@esfaenza/es-table 12.2.17 → 12.2.21

package/esm2015/lib/components/es-table/es_table.component.js

@@ -0,0 +1,1316 @@
+import { __awaiter } from "tslib";
+// Angular
+import { Component, forwardRef, ContentChildren, ChangeDetectorRef, ChangeDetectionStrategy, Input, EventEmitter, Output, ContentChild, ViewChild, ViewEncapsulation, Optional, Self, Inject } from '@angular/core';
+import { NgControl } from '@angular/forms';
+// Configurazioni
+import { UtilityService, ExportService, MessageService, DateService } from '@esfaenza/extensions';
+import { LocalizationService } from '@esfaenza/localizations';
+import { PreferencesService } from '@esfaenza/preferences';
+// Modelli
+import { AppSearch, ReportDefinition } from '../../domain';
+// Componenti e Localizzazione
+import { EsTd } from '../es-td/es_td.component';
+import { EsTh } from '../es-th/es_th.component';
+import { EsTdDirective } from '../../directives/es_td.directive';
+import { EsThDirective } from '../../directives/es_th.directive';
+import { EsTableLoc } from './es_table.component.loc';
+import { ItemsSelection } from '../../domain/externals/classes/appsearch/ItemsSelection';
+import { GroupFilter } from "../../domain/externals/classes/appsearch/GroupFilter";
+import { EsTableDefaultable } from '../../domain/configuration/EsTableDefaultable';
+import { EST_DEFAULTS, EST_LOCALE } from '../../tokens';
+import { ExportHandler, ColumnMetadataHandler, DynamicModeHandler, HierarchyModeHandler, ItemsHandler, ReportModeHandler, RowGroupingHandler, SelectionHandler, UtilitiesHandler } from '../../core/handlers';
+/** Componente che permette di rappresentare una griglia di valori */
+export class EsTableComponent {
+    /** @ignore */
+    constructor(ngControl, prefService, deafults, locale, lc, cdr, utilities_H, utiExts, expExts, dateExts, msgExts) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r;
+        this.ngControl = ngControl;
+        this.prefService = prefService;
+        this.deafults = deafults;
+        this.locale = locale;
+        this.lc = lc;
+        this.cdr = cdr;
+        this.utilities_H = utilities_H;
+        this.utiExts = utiExts;
+        this.expExts = expExts;
+        this.dateExts = dateExts;
+        this.msgExts = msgExts;
+        /** View finale su cui bindarsi lato Frontend, il tipo può essere IAppSearch<any> (per la **viewMode**), any[] (per l'**arrayMode**) e ReportDefinition per la **reportMode** */
+        this.View = null;
+        /** Indica se l'es-table deve mostrare il check globale nell'header per fare il "seleziona tutto" */
+        this.globalCheck = false;
+        /** Tiene da conto l'ultimo elemento selezionato in modo da poter effettuare il SHIFT+CLICK */
+        this.lastSelected = null;
+        /** Conteggio interno per il numero di elementi selezionati */
+        this.selectedObjects = 0;
+        /** Indica se è possibile effettuare una selezione massiva */
+        this.canSelectAll = false;
+        /** Indica se il componente sta gestendo un IAppSearch<any> */
+        this.viewMode = false;
+        /** Indica se il componente sta gestendo un any[] */
+        this.arrayMode = false;
+        /** Indica se il componente sta gestendo un ReportDefinition */
+        this.reportMode = false;
+        /**
+         * Contenitore degli elementi da listare lato interfaccia dopo tutte le elaborazioni del caso,
+         * generalmente non sono altro che tutti gli oggetti da presentare con in più l'hash calcolato per identificare 1 oggetto con la propria riga
+         */
+        this.boundSource = [];
+        /** Stessa cosa della **boundSource**, utilizzata come appoggio temporaneo interno */
+        this.TMPBoundSource = [];
+        /** "Fetta" di oggetti utilizzata nell'endless scroll, ogni elemento di questo array è un blocchetto di 100 elementi */
+        this.boundSubSources = [];
+        /** Questa funge da indicatore per gli slice inseriti, la lunghezza dovrebbe essere corrispondente a **boundSubSources** */
+        this.addedSlices = [];
+        /** Variabile che identifica il valore del "seleziona Tutto" nella paginazione */
+        this.defaultAllPageOverride = 999999;
+        /** Indica se utilizzare il sistema di autoupdate, cioè un trigger time-izzato in alto a destra della tabella che ripete le ricerche ogni X **seconds** */
+        this.autoUpdate = false;
+        /** Numero di secondi da fare trascorrere fra una ricerca e l'altra */
+        this.seconds = '10';
+        /** Impostata a true ogni volta che viene avviata una ricerca, e a false ogni volta che un nuovo valore viene ricevuto */
+        this.researchInProgress = false;
+        /** Modello rappresentante un singolo td della tabella, generato in base alle configurazioni e agli oggetti ricevuti */
+        this.RowTDs = null;
+        /** Modello di appoggio temporaneo per i **RowTDs** */
+        this.TMPRowTDs = null;
+        /** Modello rappresentante un singolo th della tabella, generato in base alle configurazioni e agli oggetti ricevuti */
+        this.RowTHs = null;
+        /** Modello di appoggio temporaneo per i **RowTHs** */
+        this.TMPRowTHs = null;
+        /** Modello di appoggio temporaneo per i **RowThGroups** */
+        this.TMPRowThGroups = null;
+        /** Modello rappresentante un singolo header group della tabella. Questa lista è già ordinata e pronta per essere utilizzata in ngFor */
+        this.RowThGroups = null;
+        /** Cache per i routerLink generati nelle tabelle dinamiche */
+        this.DynamicTableRouterLinkCache = {};
+        /**
+         * Lista dei contesti. Un contesto non è altro che un hash particolare calcolato su un oggetto che identifica univocamente tale oggetto.
+         *
+         * Ognuno di questi contesti rappresenterà a sua volta, univocamente, una riga all'interno della tabella
+         */
+        this.RowContexts = [];
+        /** Direttive di ordinamento delle colonne (non ordinamento dei dati ma delle colonne in se) */
+        this.OrderDirectives = [];
+        /** Codice dell'ultimo oggetto solezionato */
+        this.lastSelectedItemID = null;
+        /**
+         * Indica se oltre alle colonne dinamiche specifiche di un tipo di oggetto ci sono anche colonne dinamiche aggiunte dall'utente
+         *
+         * Es. una colonna in cui mostrare sempre un iconcina
+         */
+        this.UserDefinedDynamicCols = false;
+        /** Indica che questo è il primo Bind della tabella, viene settato a false non appena il primo bind viene terminato con successo */
+        this.FirstBind = true;
+        /** Lista di colonne che si possono visualizzare/ordinare fra di loro */
+        this.ColumnsList = [];
+        /** Variabile d'appoggio usata dalla dialog di selezione/nascondimento, per evitare di danneggiare **ColumnsList** in caso di modifiche poi annullate */
+        this.TMPColumnsList = [];
+        /** Valore del check globale di visibilità valido per tutte le colonne in **ColumnsList** */
+        this.globalColVisCheck = false;
+        /** Opzioni extra che devono apparire nel Menù contestuale in alto a destra, richiamato dai 3 pallini verticali */
+        this.CornerMenuOptions = null;
+        /** Indica se dev'essere possibile effettuare il resize delle colonne */
+        this.ColumnsResizable = null;
+        /** Indica se dev'essere disponibile il sistema di aggiornamento automatico */
+        this.AutoUpdate = null;
+        /** Indica se la tabella (configurata con **UseCustomCells**) deve mettersi in ascolto per i click sulle celle desiderate
+         *
+         * @deprecated Utilizzare l'Input **Template** delle es-td e assegnare un template con tutti i binding che si vuole ai click
+         */
+        this.UseCustomCellActions = null;
+        /**
+         * Indica le celle desiderate su cui intercettare i click. Attiva solo quando **UseCustomCellActions** è true.
+         * Ogni cella dev'essere separata dalla successiva dal carattere del Simoleon:
+         *
+         * Es, "MiaCella1§MiaCella2"
+         *
+         * @deprecated Utilizzare l'Input **Template** delle es-td e assegnare un template con tutti i binding che si vuole ai click
+         */
+        this.CustomCellActionsOn = '';
+        /**
+         * Serve per decidere di lanciare o meno il **event.stopPropagation()** al termine della gestione dell'evento
+         *
+         * @deprecated Utilizzare l'Input **Template** delle es-td e assegnare un template con tutti i binding che si vuole ai click
+         */
+        this.CellActionPropagates = true;
+        /**
+         * Decide se utilizzare o meno le CustomCells. Impostandolo a **true** l'es-table diventa in grado di gestire nativamente:
+         *
+         * 1) Ordinamento e visibilità delle colonne
+         *
+         * 2) Ordinamento dei dati
+         *
+         * 3) Modalità Gerarchica
+         *
+         * ecc...
+         */
+        this.UseCustomCells = null;
+        /** Permette di impostare l'altezza massima della tabella. Se null la dimensione si adatta al numero di elementi attualmente in visualizzazione */
+        this.MaxHeight = null;
+        /** Classi da applicare al contenitore della tabella */
+        this.ContainerClass = null;
+        /** Permette o meno l'export in formato XLSX */
+        this.XLSXExport = null;
+        /** Permette o meno l'export in formato CSV */
+        this.CSVExport = true;
+        /** Permette di visualizzare o meno l'opzione di paginazione "Tutti" */
+        this.AllSearch = null;
+        /** Diminuisce gli spazi fra una cella e l'altra, e internamente il padding del font in modo da presentare molti più dati in un'unica pagina */
+        this.HighCellDensity = null;
+        /** Abilita o meno la possibilità di selezionare oggetti */
+        this.Selection = null;
+        /** Mostra o meno un messaggio di Loading al primo caricamento della tabella */
+        this.ShowLoadingOnBootstrap = null;
+        /** Se impostato a **true** aggiunge una colonna con pulsante di eliminazione per effettuare l'elimina dell'oggetto relativo */
+        this.Removal = null;
+        /**
+         * Condizione che nasconde l'icona di eliminazione inserita impostando **Removal** a true qualora la condizione non venisse rispettata
+         *
+         * Come condizione si considera un semplice campo su cui effettuare un controllo booleano, come ad esempio "canremove"
+         */
+        this.RemovalCondition = '';
+        /** Indica se abilitare la possibilità di esportare la vista dati attuale */
+        this.Export = null;
+        /** Indica se permettere la selezione multipla Windows-like cliccando un oggetto e facendo poi Shift + click su un oggetto successivo */
+        this.ShiftClick = null;
+        /** Indica il testo che va a sostituire "Oggetti Visualizzati" in caso si stia facendo qualcosa di custom */
+        this.CountLabel = null;
+        /** Indica se nascondere o mostrare il componente di paginazione */
+        this.HidePaging = null;
+        /** Indica se nascondere o mostrare il conteggio degli elementi trovati */
+        this.HidePagingCount = null;
+        /** Indica se nascondere o mostrare i pulsanti di paginazione */
+        this.HidePagingButtons = null;
+        /** Riferimento al ContextMenu (ngx-contextmenu) associato al click destro di uno o più elementi selezionati nella tabella */
+        this.ContextMenu = null;
+        /** Nome dell'esportazione generata da questa tabella */
+        this.ExportFileName = 'Export.csv';
+        /** Classe (HTML) di default della tabella */
+        this.TableClass = null;
+        /** Indica la presenza di raggruppamenti a livello di header */
+        this.HasHeaderGroup = null;
+        /** Indica la presenza di raggruppamenti a livello del raggruppamento precedentemente esistente, chiaramente è insensata senza **HasHeaderGroup** */
+        this.HasSecondaryHeaderGroup = null;
+        /** Utilizzato per dividere la sorgente in modalità EndlessScroll */
+        this.SliceSize = 100;
+        /** Decide se utilizzare la modalità di EndlessScroll */
+        this.EndlessScroll = null;
+        /** Qualora **EndlessScroll** fosse true, indica se utilizzare questa modalità solo quando si cerca per "Tutti" o in generale */
+        this.EndlessScrollOnlyForAll = true;
+        /** Indica se nascondere gli Header della tabella */
+        this.HeaderHidden = null;
+        /** Indica se nascondere il Body della tabella */
+        this.BodyHidden = null;
+        /**
+         * Indica se la selezione è temporaneamente disabilitata. Rispetto all'Input **Selection** che visivamente gestisce se ci sono o no gli input di selezione,
+         * questo Input gestisce se questi input sono abilitati o meno
+         */
+        this.SelectionDisabled = null;
+        /**
+         * Indica se forzare il sistema di selezione a gestire un elemento per volta.
+         * Selezionare un'altra riga con una già selezionata applicherà la selezione alla nuova riga, rimuovendola dall'attuale
+         */
+        this.SingleSelection = null;
+        /** Callback che dato un oggetto resituisce l'eventuale classe da applicare alla riga collegata all'oggetto */
+        this.RowClassAssigner = null;
+        /** Permette di ordinare i dati in maniera discendente o ascendente */
+        this.OrderByColumn = null;
+        /** Permette di avere più direttive di ordinamento dei dati */
+        this.MultipleOrderingDirectives = true;
+        /** Permette di nascondere le colonne in base alle selezioni effettuate dal Menù contestuale in alto a destra */
+        this.HiddenColumns = null;
+        /** Permette di riordinare le colonne in base alle impostazioni effettuate dal Menù contestuale in alto a destra */
+        this.ColumnsOrdering = null;
+        /** Eventuale supporto alle ricerche applicate alla modalità Array */
+        this.SearchView = null;
+        /** Abilita o disabilita il sistema che permette di selezionare tutti gli elementi nella vista */
+        this.SelectAll = null;
+        /** Simula la paginazione anche per le tabelle che funzionano in modalità Array */
+        this.UseArrayModePaging = true;
+        /** Definizione di colonne dinamche per la modalità, appunto, dinamica */
+        this.DynamicRowColumnsDefinition = null;
+        /** Indica operazioni dinamiche generiche che possono essere effettuate per riga. Appaiono come colonne extra sul lato sinistro della tabella */
+        this.DynamicOperations = [];
+        /** Indica se visualizzare i dati in maniera gerarchica */
+        this.Hierarchy = null;
+        /** Nome della proprietà che contiene l'ID del padre. Da utilizzare se **Hierarchy** è impostato */
+        this.ParentKey = '';
+        /** Nome della proprietà che contiene l'ID dell'oggetto attuale. Da utilizzare se **Hierarchy** è impostato */
+        this.OwnKey = '';
+        /** Indica se partire con un albero espanso. Da utilizzare se **Hierarchy** è impostato */
+        this.StartsExpanded = true;
+        /** Indica se effettuare il salvataggio delle preferenze di ricerca */
+        this.SavePreferences = null;
+        /** Indica dove visualizzare le informazioni di paginazione, se sopra, sotto o in entrambi */
+        this.PagingStyle = null;
+        /** Indica dove visualizzare le informazioni di paginazione, se sopra, sotto o in entrambi */
+        this.RowGroupingPagingStyle = null;
+        /**
+         * Sorgente dati secondaria
+         *
+         * @deprecated Utilizzato solo per un caso particolare del Metering
+         */
+        this.SecondarySource = null;
+        /**
+         * Sorgente dati secondaria
+         *
+         * @deprecated Utilizzato solo per un caso particolare del Metering
+         */
+        this.TertiarySource = null;
+        /** Indica se utilizzare la cache di selezione che permette di mantenere gli stati di selezione dei vari oggetti navigando da una pagina all'altra */
+        this.UseSelectionCache = null;
+        /** Permette di decidere se, in modalità raggruppamento, mostrare o meno il valore delle colonne di gruppo negli oggetti finali. Di default sono nascosti */
+        this.ShowItemGroupsColumns = null;
+        /** Evento che viene richiamato al cambio di oridnamento di una colonna */
+        this.onOrderChanged = new EventEmitter();
+        /**
+         * Evento che viene richiamato quando l'es-table ritiene sia necessario ri-effettuare la ricerca.
+         * Il booleano dell'evento indica se viene suggerito di resettare la pagina o meno.
+         *
+         * Solo in caso venga utilizzata la modalità a raggruppamenti di righe può succedere che l'es-table passi un intero AppSearch come parametro di ricerca,
+         * in quel caso l'applicazione ricevente dovrà onorare la richiesta spedendo al backand l'oggetto di ricerca AS-IS
+         *
+         * il tipo dell'Emitter invece di essere [boolean | AppSearch<any>] è stato impostato a "any" per evitare problemi di retrocompatibilità
+         */
+        this.onSearchRequest = new EventEmitter();
+        /** Evento che parte ad ogni modifica di "checkaggio" in forma di comodo array. Espone l'oggetto con lo stato di check attuale */
+        this.onSelectionChanged = new EventEmitter();
+        /** Evento richiamato all'eliminazione di un oggetto */
+        this.onRemoval = new EventEmitter();
+        /** Evento richiamato all'annullamento di un'eliminazione */
+        this.onAbortRemoval = new EventEmitter();
+        /** Evento richiamato al click su una cella quando **UseCustomCellActions** è attivo
+         *
+         * @deprecated Utilizzare l'Input **Template** delle es-td e assegnare un template con tutti i binding che si vuole ai click
+         */
+        this.onCellClick = new EventEmitter();
+        /** Evento richiamato quando si clicca su un opzione definita nelle **CornerMenuOptions** */
+        this.onCornerAction = new EventEmitter();
+        /** Evento richiamato quando si clicca su un opzione definita nelle **DynamicOperations** */
+        this.onDynamicOperation = new EventEmitter();
+        /** Pagina in visualizzazione (durante la paginazione in modalità Array) */
+        this.arraymodePage = 1;
+        /** Numero di pagine (durante la paginazione in modalità Array) */
+        this.arraymodePages = 1;
+        /** Oggetti per ogni pagina (durante la paginazione in modalità Array) */
+        this.ArraymodeItemsPerPage = null;
+        /** Colonne da visualizzare in modalità array */
+        this.arrayColumns = [];
+        /** Ordine delle colonne da visualizzare in modalità array */
+        this.arrayColumnOrdering = [];
+        /** Ordinamenti ASC-DESC sulle colonne in modalità array */
+        this.arrayOrders = [];
+        /**
+         * Variabile che serve a gestire il momento in cui l'es-table aggiorna la paginazione (pulsanti ecc).
+         * Essendo operazioni comunque costose le effettuo solo su binding esterni, non su rewrite generati internamente
+         */
+        this.internalWriteCall = false;
+        /**
+         * Cache che conterrà tutte le ricerche effettuate su gruppi diversi dal primo e su elementi contenuti nei gruppi.
+         * In caso di cambi di ordinamento delle colonne diverse dalla prima tutte le chiamate fatte dal secondo livello in poi devono essere rieseguite secondo la seguente logica:
+         *
+         *
+         * **Cambio ordinamento sul primo gruppo**: reload completo, non mi occupo di ripulire gli elementi bindati in alcun modo
+         *
+         * **Cambio ordinamento sulla colonna relativa all'N-esimo gruppo**: reload completo del contenuto dei gruppi precedenti, ripulendo precedentemente
+         * tutti gli elementi con **_grouplevel** = N
+         *
+         * **Cambio ordinamento su una colonna non raggruppata**: reload completo per tutti i gruppi finali aperti, devo precedentemente ripulire tutti gli elementi con **_item** = true
+         *
+         * Altri eventi non dovrebbero rappresentare problemi:
+         * - Selezione: non cambia nulla
+         * - Paginazione: cambia a livello root quindi viene ricaricato tutto comunque, stesso vale per le paginazioni interne
+         */
+        this.groupSearchRequestsCache = [];
+        /** Variabile d'appoggio per capire se c'è bisogno di ri-effettuare una ricerca o meno */
+        this.ResearchNeeded = false;
+        /** Colonne visibili della vista attuale. Valorizzato di default al numero massimo di colonne supportate dalla tabella per le casistiche in assenza di custom cells */
+        this.Columns = { Visibile: 100, VisibleUnpinned: 100, Global: 100 };
+        /** In caso di Row Grouping qui viene salvata la vista principale dei gruppi base */
+        this.MainGroupView = null;
+        /** Conteggio base degli oggetti. In modalità normale viene resettato ad ogni nuova View inserita, in modalità RowGrouping viene resettato solo ad una nuova View di livello "0" */
+        this.BaseItemsCount = null;
+        /** Indica se nonostante siamo in modalità array sono stati individuati dei gruppi. In tal caso es-table si comporta da pseudo backend ed effettua le aggregazioni e raggruppamenti completamente lato client */
+        this.ArrayGrouping = false;
+        /** Indica che l'es-table è basata sulle direttive (nuova modalità) */
+        this.DirectivesBased = false;
+        /** Opzioni di paginazione */
+        this.PagerOptions = { PagerCount: null, ShowCount: true, ShowPaging: true, ShowButtons: true, ShowPagingOptions: true, UsesView: true, View: null, Ready: false, Searches: 'items' };
+        /** @ignore */
+        this.propagateChange = (_) => { };
+        /** Funzione di trackby per il body che dovrebbe evitare il 90% delle change detection */
+        this.bodyTrackBy = (index, item) => item._hash;
+        this.export_H = new ExportHandler(this, this.expExts, this.msgExts);
+        this.rowGrouping_H = new RowGroupingHandler(this, this.utilities_H, this.dateExts);
+        this.columnMetadata_H = new ColumnMetadataHandler(this, this.utilities_H, this.utiExts, this.prefService, this.rowGrouping_H);
+        this.dynamicMode_H = new DynamicModeHandler(this);
+        this.hierarchyMode_H = new HierarchyModeHandler(this);
+        this.items_H = new ItemsHandler(this, this.utilities_H);
+        this.reportMode_H = new ReportModeHandler(this, this.utilities_H);
+        this.selection_H = new SelectionHandler(this, this.rowGrouping_H);
+        if (ngControl)
+            ngControl.valueAccessor = this;
+        // Assegnazione per tutti gli Input di default
+        this.ColumnsResizable = this.utilities_H.InputOrDefault(this.ColumnsResizable, (_a = this.deafults) === null || _a === void 0 ? void 0 : _a.ColumnsResizable);
+        this.AutoUpdate = this.utilities_H.InputOrDefault(this.AutoUpdate, (_b = this.deafults) === null || _b === void 0 ? void 0 : _b.AutoUpdate);
+        this.AllSearch = this.utilities_H.InputOrDefault(this.AllSearch, (_c = this.deafults) === null || _c === void 0 ? void 0 : _c.AllSearch, true);
+        this.Export = this.utilities_H.InputOrDefault(this.Export, (_d = this.deafults) === null || _d === void 0 ? void 0 : _d.Export);
+        this.HidePaging = this.utilities_H.InputOrDefault(this.HidePaging, (_e = this.deafults) === null || _e === void 0 ? void 0 : _e.HidePaging, false);
+        this.HidePagingCount = this.utilities_H.InputOrDefault(this.HidePagingCount, (_f = this.deafults) === null || _f === void 0 ? void 0 : _f.HidePagingCount);
+        this.HidePagingButtons = this.utilities_H.InputOrDefault(this.HidePagingButtons, (_g = this.deafults) === null || _g === void 0 ? void 0 : _g.HidePagingButtons);
+        this.ContainerClass = this.utilities_H.InputOrDefault(this.ContainerClass, (_h = this.deafults) === null || _h === void 0 ? void 0 : _h.ContainerClass, '');
+        this.TableClass = this.utilities_H.InputOrDefault(this.TableClass, (_j = this.deafults) === null || _j === void 0 ? void 0 : _j.TableClass, 'table table-striped table-hover table-sm');
+        this.Selection = this.utilities_H.InputOrDefault(this.Selection, (_k = this.deafults) === null || _k === void 0 ? void 0 : _k.Selection);
+        this.SavePreferences = this.utilities_H.InputOrDefault(this.SavePreferences, (_l = this.deafults) === null || _l === void 0 ? void 0 : _l.SavePreferences);
+        this.PagingStyle = this.utilities_H.InputOrDefault(this.PagingStyle, (_m = this.deafults) === null || _m === void 0 ? void 0 : _m.PagingStyle, 'bottom');
+        this.RowGroupingPagingStyle = this.utilities_H.InputOrDefault(this.RowGroupingPagingStyle, (_o = this.deafults) === null || _o === void 0 ? void 0 : _o.RowGroupingPagingStyle, 'left');
+        this.UseSelectionCache = this.utilities_H.InputOrDefault(this.UseSelectionCache, (_p = this.deafults) === null || _p === void 0 ? void 0 : _p.UseSelectionCache, true);
+        this.ShowItemGroupsColumns = this.utilities_H.InputOrDefault(this.ShowItemGroupsColumns, (_q = this.deafults) === null || _q === void 0 ? void 0 : _q.ShowItemGroupsColumns, false);
+        this.ArraymodeItemsPerPage = this.utilities_H.InputOrDefault(this.ArraymodeItemsPerPage, (_r = this.deafults) === null || _r === void 0 ? void 0 : _r.ArraymodeItemsPerPage, 15);
+    }
+    /** @ignore */
+    ngOnInit() {
+        //Per poter cambiare il layout in base al livello gerarchico il componente deva avere il pieno controllo di ogni cella,
+        //che con solo la proiezione (senza celle cusotm) non è disponibile
+        if (this.Hierarchy && !this.UseCustomCells)
+            throw "Es-table error: Per poter utilizzare l'es-table con [Hierarchy]=\"true\" è richiesto anche [UseCustomCells]=\"true\"";
+        // click destro su una riga con selezione attiva: Tiro fuori il context menu e selezione l'elemento corrente
+        this.ctxMenuSubscription = (this.ContextMenu || this.tableEmptyMenu).open.subscribe(t => {
+            // Gruppi va bene, oggetti pure, ma separatori fra gruppi proprio no...
+            if (t.item._sep)
+                return;
+            let shouldEmit = !t.item._selected;
+            t.item._selected = true;
+            var itemSelection = this.selection_H.handleItemsSelection([t.item]);
+            this.changed();
+            if (shouldEmit)
+                this.onSelectionChanged.emit(itemSelection);
+        });
+    }
+    /** @ignore */
+    ngAfterViewInit() {
+        // Se utilizzo la new spicy mode deduco tutti i parametri di lavoro possibili al caricamento della tabella
+        // Vengono sovrascritte solo le proprietà non impostate dall'utente
+        if (this.EsTdsDirective && this.EsTdsDirective.length > 0 && this.EsThsDirective && this.EsThsDirective.length > 0) {
+            if (this.UseCustomCells == null)
+                this.UseCustomCells = true;
+            if (this.HiddenColumns == null && this.UseCustomCells)
+                this.HiddenColumns = true;
+            if (this.ColumnsOrdering == null && this.UseCustomCells)
+                this.ColumnsOrdering = true;
+            if (this.OrderByColumn == null && this.UseCustomCells)
+                this.OrderByColumn = true;
+            if (this.SelectAll == null && this.Selection)
+                this.SelectAll = true;
+            if (this.ShiftClick == null && this.Selection)
+                this.ShiftClick = true;
+            this.DirectivesBased = true;
+        }
+    }
+    /** @ignore */
+    ngOnDestroy() {
+        if (this.ctxMenuSubscription)
+            this.ctxMenuSubscription.unsubscribe();
+    }
+    /** @ignore */
+    ngOnChanges(changes) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let newSearchView = changes['SearchView'];
+            if (newSearchView && this.SearchView)
+                this.arrayPulsanti = this.utilities_H.getPagesArray(6, this.SearchView.page, this.SearchView.pages || 1, this.SearchView.items.length, this.SearchView.itemsperpageoverride);
+        });
+    }
+    /** @ignore */
+    registerOnChange(fn) { this.propagateChange = fn; }
+    /** @ignore */
+    registerOnTouched(fn) { }
+    /** @ignore */
+    changed() { this.propagateChange(this.View); }
+    /** @ignore */
+    writeValue(obj) {
+        var _a;
+        this.View = obj ? obj : null;
+        // Mi è arrivata l'AppSearch quindi di sicuro non ho una ricerca in progress
+        this.researchInProgress = false;
+        if (!this.View && !this.SearchView) {
+            // Su view nulla evito di fare pressoché qualsiasi cosa. Se arriva un null devo anche assicurarmi di non mostrare nulla
+            this.boundSource = this.TMPBoundSource || [];
+            // Per essere sicuro che dopo un bind di oggetti la es-table aggiorni la grafica
+            this.cdr.markForCheck();
+            return;
+        }
+        // Se per sbaglio l'oggetto che mi arriva non è tipizzato (instanceof AppSearch restituisce false anche se è del tipo giusto)
+        // lo correggo--------------------------------------------------------------------------------------------------------------
+        if (this.View && typeof this.View.result != 'undefined' && !(this.View instanceof ReportDefinition))
+            this.View.__proto__ = new ReportDefinition();
+        else if (this.View && typeof this.View.itemsperpageoverride != 'undefined' && !(this.View instanceof AppSearch))
+            this.View.__proto__ = new AppSearch();
+        else if (this.SearchView && typeof this.SearchView.itemsperpageoverride != 'undefined' && !(this.SearchView instanceof AppSearch))
+            this.SearchView.__proto__ = new AppSearch();
+        // -------------------------------------------------------------------------------------------------------------------------
+        if (this.View && this.View instanceof ReportDefinition) {
+            // Se mi arriva una report definition vuol dire che potrei avere dei risultati da visualizzare
+            this.setMode('report');
+            this.ReportValues = this.View.result;
+            if (this.ReportValues)
+                this.reportMode_H.reviewReportBindings();
+        }
+        else if (this.View && this.View instanceof AppSearch) {
+            // Se cambia l'oggetto intero significa che ho rimandato la ricerca
+            this.setMode('view');
+            let firstItemGroupOrNoGrouping = (((_a = this.View.requestedgroups) === null || _a === void 0 ? void 0 : _a.length) || 0) == 0;
+            // Se vengo da una ricerca interna mantengo lo stato di selezione precedente (quindi su cambio pagina, cambio ipp, ecc...)
+            // se invece l'utente ha fatto una ricerca lui (quindi cambiando filtri), secco le info di selezione
+            if (!this.View.selection || (!this.View.internalsearchrequest && firstItemGroupOrNoGrouping) || !this.UseSelectionCache) {
+                this.selection_H.clearSelectionCaches();
+                this.View.selection = new ItemsSelection([]);
+                this.onSelectionChanged.emit(this.View.selection);
+            }
+            this.View.internalsearchrequest = false;
+            // Recupero Preference
+            if (this.SavePreferences) {
+                if (!this.ngControl.name)
+                    console.error("Non posso utilizzare le preference senza avere un 'name' per questa tabella");
+                else if (!this.prefService)
+                    console.error("Non posso utilizzare le preference senza che il pacchetto @esfaenza/preferences sia installato");
+                else {
+                    this.prefService.retrieve(this.ngControl.name).subscribe(prefs => {
+                        if (prefs) {
+                            this.View.columns = prefs.columns;
+                            this.View.column_ordering = prefs.column_ordering;
+                        }
+                    });
+                }
+            }
+            // La paginazione devo farla solamente quando richiedo o un gruppo principale (se sono in row grouping) o se non richiedo gruppi (in tutti lgi altri casi)
+            if (firstItemGroupOrNoGrouping)
+                this.arrayPulsanti = this.utilities_H.getPagesArray(6, this.View.page, this.View.pages || 1, this.View.items.length, this.View.itemsperpageoverride);
+        }
+        else if (this.View && (this.View.length != null && this.View.length != undefined)) {
+            this.setMode('array');
+            if (!this.UseSelectionCache || !this.arraymodeSelection) {
+                this.selection_H.clearSelectionCaches();
+                this.arraymodeSelection = new ItemsSelection([]);
+                this.onSelectionChanged.emit(this.arraymodeSelection);
+            }
+            // Recupero Preference
+            if (this.SavePreferences) {
+                if (!this.ngControl.name)
+                    console.error("Non posso utilizzare le preference senza avere un 'name' per questa tabella");
+                else if (!this.prefService)
+                    console.error("Non posso utilizzare le preference senza che il pacchetto @esfaenza/preferences sia installato");
+                else {
+                    this.prefService.retrieve(this.ngControl.name).subscribe(prefs => {
+                        if (prefs) {
+                            this.arrayColumns = prefs.columns;
+                            this.arrayColumnOrdering = prefs.column_ordering;
+                        }
+                    });
+                }
+            }
+            if (this.SearchView)
+                this.arrayPulsanti = this.utilities_H.getPagesArray(6, this.SearchView.page, this.SearchView.pages || 1, this.SearchView.items.length, this.SearchView.itemsperpageoverride);
+        }
+        if (this.View && !(this.View instanceof ReportDefinition))
+            this.finalizeContext();
+        this.postBoundSourceCalculation();
+    }
+    /**
+     * Successivamente al bind del nuovo input questa funzione si occupa di finalizzare tutti i parametri di funzionamento dell'es-table
+     * in base a Input - Modello, e qualsiasi altra cosa possa servire
+     */
+    finalizeContext() {
+        let viewCasted = this.View;
+        /*
+         *Uso la tecnica di EndlessScroll se la variabile relativa è attiva e se
+         * 1) Ho un Array, oppure
+         * 2) Ho un AppSearch che sta cercando con paginazione "Tutto", oppure
+         * 3) Ho un AppSearch che sta cercando con paginazione diversa da "Tutto" ma con la variabile EndlessScrollOnlyForAll a false
+         */
+        let isAppSearchWithIppMax = this.viewMode && viewCasted.itemsperpageoverride == this.defaultAllPageOverride;
+        let isAppSearchNoMaxIpp = this.viewMode && viewCasted.itemsperpageoverride != this.defaultAllPageOverride;
+        this.UseEndlessscroll = this.EndlessScroll && (this.arrayMode || isAppSearchWithIppMax || (isAppSearchNoMaxIpp && !this.EndlessScrollOnlyForAll));
+        let hasRowGroups = (viewCasted.groupings && viewCasted.groupings.filter(t => !t.aggregation).length > 0) || (this.arrayMode && this.EsThsDirective.some(t => t.thGroup));
+        // Se ho dei gruppi in modalità array devo sistemare un po' di variabili che diventano insensate
+        if (this.arrayMode && hasRowGroups)
+            this.UseArrayModePaging = false;
+        // Riempimento della TMPBoundSource con gli oggetti che verranno poi mostrati ad interfaccia
+        if (this.UseEndlessscroll && !hasRowGroups) {
+            this.addedSlices = [];
+            this.boundSubSources = this.items_H.getItemSlices();
+            let firstSub = this.boundSubSources[0];
+            this.TMPBoundSource = firstSub ? firstSub : [];
+            if (firstSub)
+                this.addedSlices.push(0);
+        }
+        else
+            this.TMPBoundSource = this.items_H.getItemsByMode(false, !this.internalWriteCall);
+        // Se ho una gerarchia, assegno i livelli gerarchici alla TMPBoundSource
+        if (this.Hierarchy && !hasRowGroups)
+            this.hierarchyMode_H.assignHierarchyLevels(this.TMPBoundSource);
+        // L'hashing degli oggetti lo faccio a prescindere
+        this.utilities_H.calculateHash(this.TMPBoundSource);
+        // Assegno a una variabile mia l'eventuale override per la classe della riga
+        // Se poi sono in modalità gerarchica inietto anche la classe per la configurazione del livello della riga
+        if ((this.TMPBoundSource && this.RowClassAssigner) || this.Hierarchy) {
+            for (let i = 0; i < this.TMPBoundSource.length; i++) {
+                let item = this.TMPBoundSource[i];
+                item._rowClass = this.RowClassAssigner ? this.RowClassAssigner(item) : "";
+                item._rowClass += this.Hierarchy ? " est-row-lvl-" + item._level : "";
+            }
+        }
+    }
+    /** Genera le informzioni di paginazione per la vista globale dell'es-table */
+    setupPagingInformations() {
+        var _a;
+        // Default che valgono di base, poi eventualmente moddati dalle funzioni sotto
+        this.PagerOptions.ShowCount = !this.HidePagingCount;
+        this.PagerOptions.ShowButtons = !this.HidePagingButtons;
+        this.PagerOptions.ShowPaging = !this.HidePaging;
+        this.PagerOptions.UsesView = true;
+        if (this.arrayMode && this.UseArrayModePaging && !this.SearchView) {
+            this.PagerOptions.PagerCount = this.View.length || 0;
+            this.PagerOptions.ShowButtons = this.PagerOptions.ShowButtons && this.View.length > 10;
+            this.PagerOptions.View = this.View;
+            this.PagerOptions.UsesView = false;
+            this.PagerOptions.ShowPagingOptions = this.PagerOptions.ShowButtons;
+        }
+        else if (this.arrayMode && (!this.UseArrayModePaging || this.SearchView)) {
+            if (this.SearchView) {
+                this.PagerOptions.View = this.SearchView;
+                this.PagerOptions.PagerCount = this.SearchView.objectcount || 0;
+            }
+            else
+                this.PagerOptions.PagerCount = this.View.length || 0;
+            this.PagerOptions.ShowButtons = this.PagerOptions.ShowButtons && (this.View.length > 10 || (((_a = this.SearchView) === null || _a === void 0 ? void 0 : _a.objectcount) || 0) > 10);
+            this.PagerOptions.ShowCount = this.PagerOptions.ShowCount || (this.View && this.View.length) || (this.SearchView && this.SearchView.objectcount && this.SearchView.objectcount != -1);
+            this.PagerOptions.ShowPaging = this.PagerOptions.ShowButtons || this.PagerOptions.ShowCount;
+            this.PagerOptions.ShowPagingOptions = this.PagerOptions.ShowButtons;
+        }
+        else if (this.viewMode) {
+            let tmpView = this.MainGroupView || this.View;
+            let count = (tmpView === null || tmpView === void 0 ? void 0 : tmpView.groupcount) || (tmpView === null || tmpView === void 0 ? void 0 : tmpView.objectcount);
+            this.PagerOptions.Searches = (tmpView === null || tmpView === void 0 ? void 0 : tmpView.groupcount) != null && (tmpView === null || tmpView === void 0 ? void 0 : tmpView.groupcount) != undefined ? 'groups' : 'items';
+            this.PagerOptions.PagerCount = count || 0;
+            this.PagerOptions.View = tmpView;
+            this.PagerOptions.ShowCount = this.PagerOptions.ShowCount || (tmpView && count && count != -1);
+        }
+        else if (this.reportMode) {
+            let rvc = this.ReportValues.count;
+            this.PagerOptions.View = this.View;
+            this.PagerOptions.PagerCount = rvc && rvc == -1 ? this.ReportValues.rows.length : rvc && rvc > 0 ? this.ReportValues.count : 0;
+            this.PagerOptions.ShowCount = this.PagerOptions.ShowCount || (this.View && this.View.result.count != -1);
+            this.PagerOptions.ShowButtons = this.PagerOptions.ShowButtons && (this.View.pagingavailable || this.PagerOptions.ShowCount);
+            this.PagerOptions.ShowPagingOptions = this.PagerOptions.ShowButtons;
+        }
+    }
+    /**
+     * Metodo che gestisce l'endless scroll e in base a quanto la tabella è stata scrollata aggiunge degli elementi extra a **TMPBoundSource**
+     *
+     * @param {any} e Evento di scroll del browser
+     */
+    onScroll(e) {
+        let tableViewHeight = e.target.offsetHeight;
+        let tableScrollHeight = e.target.scrollHeight;
+        let scrollLocation = e.target.scrollTop;
+        let buffer = 200;
+        let limit = tableScrollHeight - tableViewHeight - buffer;
+        if (scrollLocation > limit) {
+            let indexToAdd = Math.floor(this.TMPBoundSource.length / 100);
+            if (this.boundSubSources[indexToAdd] && this.addedSlices.indexOf(indexToAdd) == -1) {
+                // Devo ricordarmi di fare l'hash del nuovo pezzo
+                this.utilities_H.calculateHash(this.boundSubSources[indexToAdd]);
+                this.TMPBoundSource = this.TMPBoundSource.concat(this.boundSubSources[indexToAdd]);
+                this.addedSlices.push(indexToAdd);
+                setTimeout(() => { this.postBoundSourceCalculation(); });
+            }
+        }
+    }
+    /**
+     * Metodo lanciato dopo che la sorgente dati è stata correttamente bindata, si occupa di ricalcolare tutto ciò che serve
+     * all'es-table per renderizzare i valori da mostrare
+     */
+    postBoundSourceCalculation() {
+        // Resetto tutto tranne RowTDs e RowTHs per evitare flickering. RowTDs e RowTHs saranno modificate all'interno del prossimo ciclo di CD
+        this.RowContexts = [];
+        this.OrderDirectives = [];
+        this.lastSelectedItemID = null;
+        if (this.EsThsDirective && this.EsThsDirective.length > 0 && this.EsTdsDirective && this.EsTdsDirective.length > 0)
+            this.internalPostBoundSource();
+        else {
+            this.cdr.detectChanges();
+            setTimeout(() => { this.internalPostBoundSource(); });
+        }
+    }
+    /** Per poter distinguere le chiamate a questo metodo: Dopo il setTimeout se uso gli EsTd/EsTh vecchi, senza il setTimeout se uso le nuove direttive */
+    internalPostBoundSource() {
+        let View = this.View;
+        let ths = this.EsThs && this.EsThs.length > 0 ? this.EsThs.toArray() : this.EsThsDirective && this.EsThsDirective.length > 0 ? this.EsThsDirective.toArray() : [];
+        let tds = this.EsTds && this.EsTds.length > 0 ? this.EsTds.toArray() : this.EsTdsDirective && this.EsTdsDirective.length > 0 ? this.EsTdsDirective.toArray() : [];
+        // Se non ho colonne dinamiche ma sono in modalità dinamica (lo capisco perché c'è una view piena di genericitem) metto il default delle colonne
+        this.dynamicMode_H.eventuallyReviewDynamicColumns();
+        this.bindDisplayToLoadedItemsOrGroups(View);
+        // Questo dev'essere per forza lanciato dopo **bindDisplayToLoadedItemsOrGroups** dato che è lì che alcune cose vengono valorizzate
+        this.setupPagingInformations();
+        // Molte cose sono ovviamente disponibili solo in modalità View
+        if ((this.viewMode || this.arrayMode) && this.UseCustomCells) {
+            let view = this.viewMode ? View : null;
+            let itemsAndGroups = this.viewMode ? [...(view.items || []), ...(view.groups || [])] : View;
+            let si = this.viewMode ? view.selection : this.arraymodeSelection;
+            // N.B: Rispettare l'ordine di queste 3 macrocategorie è VITALE
+            // *************************************        Sistemazioni di TH, TD, e visibilità varie      *************************************
+            // Prepassaggio per tirare fuori tutte le info utili sugli headers in modo da non ricacolarseli sempre dopo
+            let hI = this.columnMetadata_H.evaluateHeadersGroupingInfos(ths);
+            if (this.arrayMode) { // In modalità array non ho un backend...
+                this.items_H.arrayModeReviewOrderings(); // ... quindi gli ordinamenti li devo fare lato client, e ...
+                this.rowGrouping_H.arrayModeReviewGroupings(hI.leafs); // ... i raggruppamenti li devo fare lato client
+            }
+            this.columnMetadata_H.reviewColumnsList(hI.leafs); // Aggiorna la lista delle colonne da mostrare nella dialog per ordinamento ecc
+            this.columnMetadata_H.alignColumnsIfLoadedView(view); // Se sto caricando una View da hotpotato (quindi con savedstate = true) riallineo la visibilità delle colonne e il loro ordine.
+            this.columnMetadata_H.moveFixedColumnsAtTheBeginning(hI.leafs, tds); // Sposto tutte le cose fixed all'inizio in modo che la creazione di th e td sia più snella (Utilizza le ColumnsList, quindi dev'essere richiamata PIRMA di reviewColumnsList)
+            this.columnMetadata_H.alignHeadersOrdering(hI.leafs, view); // Allineo gli ordinamenti agli header
+            this.columnMetadata_H.refreshColumnsVisibility(hI.leafs, tds, view); // Lavoro sui TH ed eventualmente modifico la visibilità anche dei TD.
+            this.columnMetadata_H.evaluatePinnedColumnsWidth(); // Se sono presenti colonne pinnate valuta la dimensione del contenitore
+            this.columnMetadata_H.generateDefaultOrder(hI.leafs, view); // Genero le direttive di ordinamento, che siano default o derivanti dalla AppSearch
+            this.columnMetadata_H.evaluateHeaderGroups(hI); // Valuto i raggruppamenti degli header se presenti
+            // *************************************        Generazione binding per righe e colonne         *************************************
+            this.evaluateRowThs(hI.leafs); // Raccolgo i TH
+            this.evaluateRowTds(hI.leafs, tds); // Raccolgo i TD in contesti separati, un contesto per ogni item o gruppo
+            // *************************************        Ultimi aggiustmaenti dei binding                *************************************
+            this.columnMetadata_H.applyOrdering(view, true); // Applico l'ordinamento sulle colonne (non ASC DESC, ma "prima questa o quella colonna")
+            this.MoveTemporaryVariablesToRealOnes(); // Collego TH e TD aggiustati fino ad ora alle variabili di Binding HTML
+            this.selection_H.evaluateSelection(itemsAndGroups, si); // Riallineo le info di selezione degli elementi della View
+            if (this.ResearchNeeded) {
+                this.changed();
+                this.emitSearchRequest(false);
+                this.ResearchNeeded = false;
+            }
+        }
+        else if ((this.viewMode || this.arrayMode) && !this.UseCustomCells) {
+            // Riallineo le info di selezione degli elementi della View
+            let items = this.viewMode ? View.items : View;
+            let si = this.viewMode ? View.selection : this.arraymodeSelection;
+            this.selection_H.evaluateSelection(items, si);
+        }
+        // Per essere sicuro che dopo un bind di oggetti la es-table aggiorni la grafica
+        this.cdr.markForCheck();
+        this.FirstBind = false;
+    }
+    /**
+     * Effettua il binding degli oggetti pervenuti da questa chiamata con gli oggetti effettivamente da graficare
+     *
+     * @param {any} view View da cui sono arrivati gli oggetti. Può essere o un array se sono in **arrayMode** o una AppSearch<T> se sono in **viewMode**
+     */
+    bindDisplayToLoadedItemsOrGroups(view) {
+        var _a, _b;
+        if (this.TMPBoundSource.length == 0) {
+            this.BaseItemsCount = 0;
+            this.boundSource = this.TMPBoundSource;
+            return;
+        }
+        if (this.arrayMode || !this.UseCustomCells) {
+            this.boundSource = this.TMPBoundSource;
+            this.BaseItemsCount = (view === null || view === void 0 ? void 0 : view.objectcount) || view.length;
+            return;
+        }
+        let groupingKeys = ((_b = (_a = view.groupings) === null || _a === void 0 ? void 0 : _a.filter(t => !t.aggregation)) === null || _b === void 0 ? void 0 : _b.length) || 0;
+        if (groupingKeys == 0) {
+            this.boundSource = this.TMPBoundSource;
+            this.BaseItemsCount = view.objectcount;
+            return;
+        }
+        this.rowGrouping_H.handleNewDataOnRowGrouping(view, groupingKeys);
+    }
+    /** Metodo richiamato solo quando **TMPRowTDs** e **TMPRowTHs** sono completamente generati ed aggiustati. Serve per collegarli alle variabili usate lato binding HTML */
+    MoveTemporaryVariablesToRealOnes() {
+        this.RowTDs = this.TMPRowTDs;
+        this.RowTHs = this.TMPRowTHs;
+        this.RowThGroups = this.TMPRowThGroups ? this.TMPRowThGroups.reverse() : null;
+        this.Columns.Visibile = this.RowTHs.filter(t => t.Visible).length;
+        this.Columns.VisibleUnpinned = this.RowTHs.filter(t => t.Visible && !t.Pinned).length;
+        this.Columns.Global = this.Columns.VisibleUnpinned + (this.HasPinnedColumns ? 1 : 0) + (this.Selection ? 1 : 0) + (this.Removal ? 1 : 0) + (this.Export || this.HiddenColumns || this.ColumnsOrdering || this.CornerMenuOptions ? 1 : 0);
+    }
+    /**
+     * Permette di selezionare o deselezionare in maniera arbitraria degli oggetti
+     *
+     * @param {any[]} items Oggetti da selezionare o deselezionare
+     * @param {boolean} select **true** per selezionarli, **false** per non toccarli
+     */
+    setSelectionStatus(items, select) {
+        this.selection_H.handleItemsSelection(items, select);
+        this.cdr.markForCheck();
+    }
+    /**
+     * Metodo che gestisce il cambio di Ordinamento di una colonna
+     *
+     * @param {string} id ID della colonna il cui oridnamento è cambiato
+     * @param {'DESC' | 'ASC'} order Nuovo ordine selezionato per la colonna
+     */
+    thOrderChanged(id, order) {
+        if (!this.viewMode && !this.arrayMode) {
+            console.warn('Order changed on a table not in viewMode or Array mode. Operation not supported');
+            return;
+        }
+        if (!this.OrderByColumn)
+            return;
+        this.columnMetadata_H.handleTHOrderChange(id, order);
+    }
+    /**
+     * Metodo da chiamare ogni volta che si vuole dare evidenza all'esterno del bisogno di rieffettuare la ricerca
+     *
+     * @param {boolean} resetsPage Indica al listener che deve resettare il numero di pagina
+     * @param {AppSearch<any>} viewOverride Override della view da emettere per questa ricerca
+     */
+    emitSearchRequest(resetsPage, viewOverride) {
+        if (this.viewMode && !viewOverride) {
+            this.View.internalsearchrequest = true;
+            this.changed();
+        }
+        if (viewOverride) {
+            if (resetsPage)
+                viewOverride.page = 1;
+            viewOverride.internalsearchrequest = true;
+        }
+        this.researchInProgress = true;
+        this.onSearchRequest.emit(viewOverride ? viewOverride : resetsPage);
+    }
+    /**
+     * Partendo dagli **EsTds** bindati genera, all'interno del dizionario **TMPRowTDs** tutti i contesti dei vari oggetti.
+     *
+     * Vengono esclusi i TD "Interni" in quanto vengono generati dagli originali quindi includerli vorrebbe dire rieffettuare le operazioni due volte
+     *
+     * Costo: 2 scan EsThs, 1 scan EsTds
+     *
+     * @param {EsTh[] | EsThDirective[]} ths Colonne della tabella
+     * @param {EsTd[] | EsTdDirective[]} tds Celle della tabella
+     */
+    evaluateRowTds(ths, tds) {
+        if (tds.length == 0)
+            return;
+        let thsCache = {};
+        let columnsCache = {};
+        for (let coli = 0; coli < this.ColumnsList.length; coli++) {
+            let col = this.ColumnsList[coli];
+            columnsCache[col.id] = col;
+        }
+        for (let i = 0; i < ths.length; i++) {
+            let th = ths[i];
+            thsCache[this.utilities_H.isEsTh(th) ? th.ID : th.th] = th;
+        }
+        this.TMPRowTDs = {};
+        // Variabile d'appoggio per permettermi di inserire tutte le colonne "Fixed" davanti
+        let contextFixeds = {};
+        for (let i = 0; i < tds.length; i++) {
+            let td = tds[i];
+            if (this.utilities_H.isEsTd(td)) {
+                let th = thsCache[td.ID];
+                if (!!th)
+                    th._referenced = true;
+                else
+                    throw "ID dell'oggeto EsTd non compatibile con gli ID dicharati negli EsTh: " + td.ID;
+                let isFixed = (this.utilities_H.isEsTh(th) && th.Fixed) || (!this.utilities_H.isEsTh(th) && (th.thFixed || th.thGroup));
+                let itemToAdd = { GroupAggregation: false, GroupHeader: false, Wraps: true, ID: td.ID, Visible: td.Visible, Class: td.Class, Content: td.Content, RouterLink: td.RouterLink, Template: td.Template };
+                let ctx = td.Context;
+                if (this.TMPRowTDs[ctx]) {
+                    if (isFixed)
+                        this.TMPRowTDs[ctx].splice(0 + (contextFixeds[ctx]++), 0, itemToAdd);
+                    else
+                        this.TMPRowTDs[ctx].push(itemToAdd);
+                }
+                else {
+                    this.RowContexts.push(ctx);
+                    this.TMPRowTDs[ctx] = [itemToAdd];
+                    contextFixeds[ctx] = isFixed ? 1 : 0;
+                }
+            }
+            else {
+                for (let i = 0; i < this.boundSource.length; i++) {
+                    let item = this.boundSource[i];
+                    let ctx = item._hash;
+                    let key = td.td;
+                    let th = thsCache[td.td];
+                    if (!!th)
+                        th._referenced = true;
+                    else
+                        throw "ID dell'oggeto EsTd non compatibile con gli ID dicharati negli EsTh: " + td.td;
+                    if (td.tdIf || (!this.utilities_H.isEsTh(th) && th.thGroup)) {
+                        let thCasted = th;
+                        let isFixed = (this.utilities_H.isEsTh(th) && th.Fixed) || (!this.utilities_H.isEsTh(th) && (th.thFixed || th.thGroup || th.thPinned));
+                        let itemToAdd = item._item ?
+                            { LeftBorder: thCasted._lbord, RightBorder: thCasted._rbord, ID: key, Pinned: columnsCache[td.td].pinned, PinnedWidth: thCasted.thPinnedWidth, GroupHeader: false, GroupAggregation: false, Visible: columnsCache[td.td].visible, Wraps: false, Class: td.tdClass, Template: thCasted.thGroup && !this.ShowItemGroupsColumns ? null : td.Template } :
+                            { LeftBorder: thCasted._lbord, RightBorder: thCasted._rbord, ID: key, Pinned: columnsCache[td.td].pinned, PinnedWidth: thCasted.thPinnedWidth, GroupHeader: thCasted.thGroup, GroupAggregation: !!thCasted.thAggregation, Visible: columnsCache[td.td].visible, Wraps: false, Class: thCasted.thGroupClass || '', Content: this.rowGrouping_H.getGroupCellDisplay(item, key, th) };
+                        if (this.TMPRowTDs[ctx]) {
+                            this.TMPRowTDs[ctx].push(itemToAdd);
+                        }
+                        else {
+                            this.RowContexts.push(ctx);
+                            this.TMPRowTDs[ctx] = [itemToAdd];
+                            contextFixeds[ctx] = isFixed ? 1 : 0;
+                        }
+                    }
+                }
+            }
+        }
+        // Se non ho oggetti è inutile che controllo gli errori, dato che gli es-td non esisteranno di certo e di conseguenza gli es-th non saranno referenziati
+        if (this.TMPBoundSource.length == 0)
+            return;
+        var errs = [];
+        for (let i = 0; i < ths.length; i++) {
+            let th = ths[i];
+            if (!th._referenced)
+                errs.push(this.utilities_H.isEsTh(th) ? th.ID : th.th);
+        }
+        if (errs.length > 0) {
+            var errIds = errs.join(', ');
+            throw "L'ID di uno o più EsTh non hanno alcun EsTd associato: " + errIds;
+        }
+    }
+    /**
+     * Partendo dagli **EsThs** bindati genera, all'interno del dizionario **TMPRowTHs** tutti i contesti dei vari oggetti.
+     *
+     * Vengono esclusi i TH "Interni" in quanto vengono generati dagli originali quindi includerli vorrebbe dire rieffettuare le operazioni due volte
+     *
+     * Costo: 1 scan EsThs
+     *
+     * @param {EsTh[] | EsThDirective[]} ths Colonne della tabella
+     */
+    evaluateRowThs(ths) {
+        if (ths.length == 0)
+            return;
+        let columnsListCache = {};
+        let castedView = this.View;
+        let groupingsUndefined = this.viewMode && (castedView && !castedView.groupings || castedView.groupings.length == 0);
+        for (let i = 0; i < this.ColumnsList.length; i++) {
+            let itm = this.ColumnsList[i];
+            columnsListCache[itm.id] = itm;
+        }
+        this.TMPRowTHs = [];
+        let fixed = 0;
+        for (let i = 0; i < ths.length; i++) {
+            let th = ths[i];
+            let toAdd;
+            if (this.utilities_H.isEsTh(th)) {
+                toAdd = { Pinned: false, ID: th.ID, Visible: th.Visible, Class: th.Class, Order: th.Order, Orderable: th.Orderable, Template: null, Content: th.Description, Wrap: th.Wrap };
+                if (th.Fixed)
+                    this.TMPRowTHs.splice(0 + (fixed++), 0, toAdd);
+                else
+                    this.TMPRowTHs.push(toAdd);
+            }
+            else if (th.thIf || th.thGroup) {
+                let thClass = (th.thClass || '') + (th.thGroup ? " est-col-min" : "");
+                toAdd = { Pinned: columnsListCache[th.th].pinned, PinnedWidth: th.thPinnedWidth, ID: th.th, Visible: th.thVisible, Class: thClass, Order: th.thOrder, Orderable: th.thOrderable, Template: th.Template, Content: null, Wrap: th.thWrap, LeftBorder: th._lbord, RightBorder: th._rbord };
+                this.TMPRowTHs.push(toAdd);
+                // Se ho un modello che deve funzionare a rowgrouping ma non è ancora stata effettuata nessuna ricerca sui gruppi principali (groupingsUndefined)
+                // li genero e mando la prima ricerca che dev'essere spedita al backend per il primo caricamento dei gruppi
+                if (groupingsUndefined && (th.thAggregation || th.thGroup)) {
+                    let groupAggregations = this.rowGrouping_H.getGroupAggregations(th);
+                    if (!castedView.groupings)
+                        castedView.groupings = groupAggregations;
+                    else
+                        castedView.groupings.push(...groupAggregations);
+                    this.ResearchNeeded = true;
+                }
+            }
+        }
+    }
+    /**
+     * Sposta la ricerca di una pagina in avanti (o indietro)
+     *
+     * @param {number} page Numero di pagine da aggiungere (o sottrarre, se negativo) alla pagina attuale
+     * @param {any} pager Elemento di separazione su cui è effettuata la ricerca
+     */
+    addToPageGroup(page, pager) {
+        this.goToPageGroup(pager.view.page + page, pager);
+    }
+    /**
+     * Sposta la ricerca alla pagina specificata
+     *
+     * @param {number} page Pagina a cui navigare
+     * @param {any} pager Elemento di separazione su cui è effettuata la ricerca
+     */
+    goToPageGroup(page, pager) {
+        let appSearchElement = pager.view;
+        if (page === 0 || (page > appSearchElement.pages && appSearchElement.pages > 0))
+            return;
+        appSearchElement.page = page;
+        pager.buttons = this.utilities_H.getPagesArray(6, appSearchElement.page, appSearchElement.pages);
+        this.emitSearchRequest(false, appSearchElement);
+    }
+    /**
+     * Gestisce i click sulla tabella solo per le righe a gruppo.
+     * O rimuove gli elementi attualmente presenti o carica il contenuto del gruppo
+     *
+     * @param {any} group Gruppo bindato su cui si è effettuato il click
+     *
+     * @returns {boolean} **true** se l'operaizone è andata a buon fine, **false** altrimenti
+     */
+    handleGroupClick(group) {
+        let casted = this.View;
+        let anyG = group;
+        anyG._expanded = !anyG._expanded;
+        // Sono in modalità raggruppamento virtuale da array: Espandere significa rendere visibili tutti gli oggetti relativi a questo gruppo, viceversa il contrarre
+        if (this.ArrayGrouping) {
+            let allRelatives = this.boundSource.filter(t => (t._group && ((anyG._expanded && t._parent == anyG._thisKey) || (!anyG._expanded && t._parent && t._parent.startsWith(anyG._thisKey)))) ||
+                (t._item && ((anyG._expanded && t._thisKey == anyG._thisKey) || (!anyG._expanded && t._thisKey.startsWith(anyG._thisKey)))));
+            allRelatives.forEach(t => { t._visible = anyG._expanded; if (t._group)
+                t._expanded = false; });
+            return;
+        }
+        if (anyG._expanded) {
+            // Resetto ipp
+            casted.itemsperpageoverride = 15;
+            if (!casted.requestedgroups)
+                casted.requestedgroups = [new GroupFilter(group.column, group.value)];
+            else {
+                let level = anyG._grouplevel;
+                // se il gruppo cliccato non ha un livello è il primo gruppo, quindi ordinamento unico
+                // altrimenti devo rimuovere tutti i filtri su livelli superiori al level cliccato e aggiungere il level cliccato
+                if (!level)
+                    casted.requestedgroups = [new GroupFilter(group.column, group.value)];
+                else {
+                    casted.requestedgroups = [];
+                    anyG._parentRoute.forEach((step) => {
+                        casted.requestedgroups.push(new GroupFilter(step.column, step.value));
+                    });
+                    casted.requestedgroups.push(new GroupFilter(group.column, group.value));
+                }
+            }
+            this.changed();
+            this.emitSearchRequest(true);
+        }
+        else {
+            let path = (anyG._parent || '') + group.value;
+            // Se ho chiuso un gruppo non mi serve rieffettuare ricerce, mi basta eliminare dagli oggetti bindati tutti gli elementi sottostanti a quel gruppo
+            this.boundSource = this.boundSource.filter(t => !t._parent || !t._parent.startsWith(path));
+            // devo però anche rimuovere eventuali cache relative
+            this.groupSearchRequestsCache = this.groupSearchRequestsCache.filter(t => t.path != path);
+        }
+        return true;
+    }
+    /**
+     * Gestisce la selezione globale degli oggetti, sia per pagina che a livello di **SelectAll**
+     *
+     * @param {boolean} forcedVal Valore forzato di check da assegnare agli oggetti
+     */
+    globalCheckChanged(forcedVal = null) {
+        // Prendo tutti gli elementi presenti in questa vista. Se ho gruppi prendo solo i gruppi a livello 0, altrimenti prendo tutti gli oggetti per selezionarli
+        let items = this.boundSource.find(t => t._group) ? this.boundSource.filter(t => t._group && !t._parent) : this.boundSource;
+        var itemSelection = this.selection_H.handleItemsSelection(items, forcedVal, this.globalCheck);
+        this.changed();
+        this.onSelectionChanged.emit(itemSelection);
+    }
+    /**
+     * Gestisce i click sulla tabella, gestendo eventualmente anche gli Shift + Click per selezionare un range di oggetti
+     *
+     * @param {any} event Evento nativo HTML del click
+     * @param {any} item Oggetto bindato su cui si è effettuato il click
+     *
+     * @returns {boolean} **true** se l'operaizone è andata a buon fine, **false** altrimenti
+     */
+    handleClick(event, item) {
+        // Seleziono del testo ma non ho shift premuto -> ignoro la selezione
+        if ((event.view.getSelection().type == 'Range' || event.view.getSelection().toString().length > 0) && !event.shiftKey)
+            return false;
+        // Seleziono del testo e ho shift premuto -> annullo la selezione del testo
+        if ((event.view.getSelection().type == 'Range' || event.view.getSelection().toString().length > 0) && event.shiftKey)
+            this.utiExts.clearTextSelection();
+        let selecteditems = [];
+        if (event.shiftKey && this.ShiftClick && !this.SingleSelection) {
+            let startSelecting = false;
+            let items = this.boundSource.filter(t => !t._group && !t._sep);
+            for (let i = 0; i < items.length; i++) {
+                let t = items[i];
+                if (startSelecting) {
+                    t._selected = true;
+                    selecteditems.push(t);
+                }
+                if ((t == item || t == this.lastSelected) && !startSelecting) {
+                    startSelecting = true;
+                    t._selected = true;
+                    selecteditems.push(t);
+                }
+                else if ((t == item || t == this.lastSelected) && startSelecting)
+                    startSelecting = false;
+            }
+        }
+        else {
+            item._selected = !item._selected;
+            this.lastSelected = item;
+            selecteditems.push(item);
+        }
+        var itemSelection = this.selection_H.handleItemsSelection(selecteditems);
+        this.changed();
+        this.onSelectionChanged.emit(itemSelection);
+        return true;
+    }
+    /**
+     * Sposta la ricerca di una pagina in avanti (o indeitro)
+     *
+     * @param {number} page Numero di pagine da aggiungere (o sottrarre, se negativo) alla pagina attuale
+     */
+    addToPage(page) {
+        var _a;
+        let view = this.MainGroupView ? this.MainGroupView : this.View;
+        this.goToPage((((_a = (this.SearchView || view)) === null || _a === void 0 ? void 0 : _a.page) || 0) + page);
+    }
+    /**
+     * Sposta la ricerca alla pagina specificata
+     *
+     * @param {number} page Pagina a cui navigare
+     */
+    goToPage(page) {
+        var _a, _b;
+        let view = this.MainGroupView ? this.MainGroupView : (this.arrayMode ? this.SearchView : this.View);
+        if (!view.page || !view.pages)
+            return;
+        let appSearchElement = this.SearchView || view;
+        if (page === 0 || (page > appSearchElement.pages && appSearchElement.pages > 0))
+            return;
+        appSearchElement.page = page;
+        let count = this.reportMode ? (((_a = view.result) === null || _a === void 0 ? void 0 : _a.count) || 0) : (view.items.length || ((_b = view.groups) === null || _b === void 0 ? void 0 : _b.length) || 0);
+        let ipp = this.reportMode ? (view.itemsperpageoverride || 15) : view.itemsperpageoverride || 15;
+        this.arrayPulsanti = this.utilities_H.getPagesArray(6, appSearchElement.page, appSearchElement.pages, count, ipp);
+        let hasGroupings = !!this.MainGroupView;
+        this.emitSearchRequest(false, hasGroupings ? view : this.SearchView ? this.SearchView : null);
+    }
+    /**
+     * Evento richiamato sul cambio della paginazione. Verrà richiamato l'evento **emitSearchRequest**
+     * per comunicare al componente che utilizza questa tabella che i dati sono da aggiornare
+     */
+    onItemsPerPageChanged(newIpp) {
+        this.PagerOptions.View.itemsperpageoverride = newIpp;
+        this.changed();
+        if (this.MainGroupView)
+            this.emitSearchRequest(true, this.MainGroupView);
+        else if (this.SearchView) {
+            // Questo secondo me si può portare a livello un po' più alto
+            this.SearchView.page = 1;
+            this.emitSearchRequest(true, this.SearchView);
+        }
+        else
+            this.emitSearchRequest(true);
+    }
+    /** Evento richiamato sul cambio della paginazione. Verrà richiamato l'evento **emitSearchRequest** con la vista del separatore */
+    onGroupItemsPerPageChanged(pager, newIpp) {
+        pager.view.itemsperpageoverride = newIpp;
+        this.emitSearchRequest(true, pager.view);
+    }
+    /** Metodo che gestisce la modifica del tempo specificato per l'aggiornamento automatico */
+    autoUpdateChanged() {
+        if (!/^[1-9]\d*$/.test(this.seconds))
+            this.seconds = '10';
+        let secondsInMs = parseInt(this.seconds, null) * 1000;
+        if (this.autoUpdate)
+            this.updateTimer = setInterval(() => { this.emitSearchRequest(false); }, secondsInMs);
+        else
+            clearInterval(this.updateTimer);
+    }
+    /**
+     * Metodo chiamato dal click su una delle colonne generate dall'Input **DynamicOperations**
+     *
+     * @param {any} item L'oggetto su cui va effettuata l'operazione
+     * @param {string} opid Codice identificativo dell'operazione da effettuarsi
+     */
+    dynamicOperation(item, opid) {
+        this.onDynamicOperation.emit({ id: opid, item: item });
+    }
+    /**
+     * Ottiene il contenuto dell'EsTd da utilizzare per la colonna specificata
+     *
+     * @param {string} column Colonna per cui cercare la cella
+     *
+     * @returns {TemplateRef<any>} Template da usare per la colonna
+     */
+    findEsTd(column) {
+        var EsTd = this.EsTdsDirective.find((item) => item.td === column);
+        return EsTd ? EsTd.Template : null;
+    }
+    /**
+     * Equivalente del metodo **addToPage** riadattato per la modalità array
+     *
+     * @param {number} page Numero di pagine da aggiungere (o sottrarre, se negativo) alla pagina attuale
+     */
+    arrayAddToPage(page) {
+        this.arrayGoToPage(this.arraymodePage + page);
+    }
+    /**
+     * Equivalente del metodo **goToPage** riadattato per la modalità array
+     *
+     * @param {number} page Pagina a cui navigare
+     */
+    arrayGoToPage(page) {
+        if (page === 0 || page > this.arraymodePages)
+            return;
+        this.arraymodePage = page;
+        // Riforzo il writevalue in modo che il codice passi dalla gestione come se fosse fatta ripartire una ricerca
+        this.internalWriteValue();
+    }
+    /**
+     * Gestore dei click sulle celle per le quali era impostata una azione custom da **CustomCellActionsOn**
+     *
+     * @param {string} name Nome della cella su cui si è fatto click
+     * @param {any} model Modello relativo alla cella cliccata
+     *
+     * @returns {boolean} **true** se il click è stato fatto su una cella cliccabile, **false** altrimenti
+     */
+    cellClicked(name, model) {
+        if (this.UseCustomCellActions && this.CustomCellActionsOn.split('$').indexOf(name) != -1) {
+            this.onCellClick.emit({ column: name, model: model });
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Gestione dei click sulle opzioni del menù contestuale in alto a destra generato dall'Input **CornerMenuOptions**
+     *
+     * @param {string} cornerid Codice dell'operazione selezionata
+     */
+    cornerActionClicked(cornerid) {
+        this.onCornerAction.emit({ id: cornerid, estable: this });
+    }
+    /**
+     * Impostazione modalità dell'EsTable
+     *
+     * @param {'array' | 'view' | 'report'} mode Modalità da impostare
+     **/
+    setMode(mode) {
+        this.viewMode = mode == 'view';
+        this.arrayMode = mode == 'array';
+        this.reportMode = mode == 'report';
+        if (this.reportMode) {
+            // In modalità report ho di sicuro queste due
+            this.XLSXExport = true;
+            this.CSVExport = false;
+        }
+    }
+    /**
+     * Helper per effettuare chiamate interne di allineamento alla funzione **writeValue**,
+     * impostando prima **internalWriteCall** in modo da non effettuare operazioni inutili
+     */
+    internalWriteValue() {
+        this.internalWriteCall = true;
+        this.writeValue(this.View);
+        this.internalWriteCall = false;
+    }
+    /**
+     * Metodo eventualmente richiamabile anche dal componente esterno che permette di forzare un refresh della tabella
+     */
+    forceRefresh() {
+        // Se sono in modalità View viene mantenuto in automatico il numero di pagina, ma per la modalità array devo prendere le info di paginazione prima e riapplicarle dopo
+        let arrayPage;
+        let arrayIpp;
+        if (this.arrayMode) {
+            arrayPage = this.arraymodePage;
+            arrayIpp = this.ArraymodeItemsPerPage;
+        }
+        this.writeValue(this.View);
+        this.cdr.detectChanges();
+        if (this.arrayMode) {
+            this.ArraymodeItemsPerPage = arrayIpp;
+            this.arrayGoToPage(arrayPage);
+        }
+    }
+}
+EsTableComponent.decorators = [
+    { type: Component, args: [{
+                selector: 'es-table',
+                viewProviders: [{ provide: LocalizationService, useClass: EsTableLoc }],
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                encapsulation: ViewEncapsulation.None,
+                template: "<!-- Patacchino di autoaggiornamento -->\r\n<div class=\"w-100\" *ngIf=\"AutoUpdate\">\r\n    <div class=\"pull-right\">\r\n        {{'Update every' | localize : lc}}&nbsp;<input [readonly]=\"autoUpdate\" maxlength=\"3\" class=\"form-control est-custom-input\" type=\"text\" [(ngModel)]=\"seconds\" />&nbsp;{{'second/s' | localize : lc}}\r\n    </div>\r\n    <div class=\"pull-right m-t-2\">\r\n        <label class=\"est-switch\">\r\n            <input type=\"checkbox\" [(ngModel)]=\"autoUpdate\" (ngModelChange)=\"autoUpdateChanged();\" />\r\n            <div class=\"est-slider round\"></div>\r\n        </label>\r\n    </div>\r\n    <div class=\"clearfix\"></div>\r\n</div>\r\n\r\n<!--\r\nI TH sono contenuto statico, questo significa che senza condizione per RowTHs arriverebbero sia qui sia nell ng-container dell'header in fase non inizializzata, duplicando fisicamente le colonne.\r\nPer ovviare al problema, questo pezzo lo faccio apparire solo se ci sono gi\u00E0 dei RowTHs, quindi su valorizzazione della View succeder\u00E0:\r\n1) appaiono i th nell' ng-container dell'header, e NON qui\r\n2) i TH vengono presi, elaborati e trasformati in RowTHs\r\n3) l'ng-container dell'header sparisce (per la condizione !UseCustomCells || !RowTHs) e qui appaiono i nuovi TH (che poi sono gli stessi di prima che girano)\r\n4) Vengono presi i nuovi TH da qui e trasformati a loro volta in RowTHs\r\n-->\r\n<div hidden *ngIf=\"UseCustomCells && RowTHs\">\r\n    <ng-container *ngIf=\"View\">\r\n        <!--Qui invece ci sono tutti i TH-->\r\n        <ng-container *ngTemplateOutlet=\"headerRef\"></ng-container>\r\n    </ng-container>\r\n</div>\r\n\r\n<!--\r\nQuesta parte \u00E8 un po' pi\u00F9 semplice del sopra. Infatti i TD vengono s\u00EC bindati in entrambi i punti (qui e nell'ng-container del body), ma avr\u00F2 le TD statiche prima di generare la TMPBoundSource.\r\nQuesto significa che il workflow di binding sar\u00E0:\r\n1) Appaiono i TD statici nel body e NON qui, perch\u00E9 i TMPBoundSource non sono ancora stati emessi\r\n2) Contemporaneamente all'emissione dei TMPBoundSource vengono anche emessi i RowTds\r\n3) Considerando il punto 2, al giro dopo appariranno i TD qui, perch\u00E9 \u00E8 stata generata la TMPBoundSource, e spariranno contemporaneamente dall'ng-container del body (per la condizione !UseCustomCells || !RowTDs)\r\n-->\r\n<div hidden *ngIf=\"UseCustomCells && bodyRef\">\r\n    <ng-container *ngIf=\"View\">\r\n        <!--Tutti i TD che dopo verranno presi ed elaborati internamente-->\r\n        <ng-container *ngFor=\"let item of TMPBoundSource\">\r\n            <ng-container *ngTemplateOutlet=\"bodyRef; context : {$implicit: item}\"></ng-container>\r\n        </ng-container>\r\n    </ng-container>\r\n</div>\r\n\r\n<div *ngIf=\"View\" class=\"est-relative\">\r\n    <div *ngIf=\"FirstBind && ShowLoadingOnBootstrap\" class=\"est-loading-box\">\r\n        <div class=\"est-loading-content\">\r\n            <span class=\"fa fa-spinner fa-spin\"></span>&nbsp;{{'Performing Table bootstrap' | localize: lc}}...\r\n        </div>\r\n    </div>\r\n\r\n    <div class=\"est-top-pager\" *ngIf=\"PagingStyle == 'both' || PagingStyle == 'top'\">\r\n        <ng-container *ngTemplateOutlet=\"pagingElement\"></ng-container>\r\n    </div>\r\n\r\n    <div class=\"est-top-allselect\" *ngIf=\"canSelectAll || (!reportMode && (View?.selection || arraymodeSelection).all)\">\r\n        <span>{{ (selectedObjects == -1 ? ('All the' | localize : lc) : ((selectedObjects || 0) | number : '0.0-0' : locale)) + ' ' + ((selectedObjects == 1 ? 'Object Selected' : 'Objects Selected') | localize : lc) }}</span>&nbsp;\r\n        <span class=\"est-link est-inline\" (click)=\"selection_H.selectAllOrResetSelection()\">{{ (View?.selection || arraymodeSelection).all ? ('Reset Selection' | localize : lc) : ('Select Everything' | localize : lc)}}</span>\r\n    </div>\r\n\r\n    <div class=\"table-responsive datatable {{ContainerClass}}\" [class.est-scrollable]=\"UseEndlessscroll\" (scroll)=\"UseEndlessscroll && onScroll($event)\" [style.max-height.px]=\"MaxHeight\">\r\n        <table class=\"{{ TableClass }} est-margin-bottom-10\"  [class.est-high-density]=\"HighCellDensity\">\r\n            <thead [hidden]=\"HeaderHidden || FirstBind\">\r\n                <!-- Aggiungo il pezzo che gestisce la selezione di tutto se attivo da config -->\r\n                <tr *ngIf=\"SelectAll || PagingStyle != 'bottom'\">\r\n                    <th class=\"est-no-selection\" [attr.colspan]=\"Columns.Global\" [class.est-hidden-view]=\"!canSelectAll && (reportMode || !(View?.selection || arraymodeSelection).all) && PagingStyle == 'bottom'\">\r\n                        <p class=\"est-hidden-view app-margin-bottom-0\">\u00A7</p>\r\n                    </th>\r\n                </tr>\r\n\r\n                <!-- Blocco header group -->\r\n                <ng-container *ngIf=\"RowThGroups\">\r\n                    <tr *ngFor=\"let level of RowThGroups\">\r\n                        <th *ngFor=\"let cell of level\" [attr.colspan]=\"cell.Span\" \r\n                            [class.est-pinned-header]=\"cell.Pinned\" [class.est-col-min]=\"cell.Pinned\"\r\n                            [class.est-ltab-border]=\"cell.Borders\" [class.est-rtab-border]=\"cell.Borders\"\r\n                            class=\"est-text-center\">\r\n                            <ng-container *ngIf=\"cell.Pinned; Else: cell.Template\">\r\n                                <div class=\"est-pinned-border est-cell-group-padding\"></div>\r\n                            </ng-container>\r\n                        </th>\r\n                    </tr>\r\n                </ng-container>\r\n\r\n                <ng-container *ngIf=\"!RowThGroups\">\r\n                    <tr *ngIf=\"HasHeaderGroup\">\r\n                        <ng-container *ngTemplateOutlet=\"headerGroupRef\"></ng-container>\r\n                        <th *ngIf=\"Export\"></th>\r\n                    </tr>\r\n    \r\n                    <!-- Blocco header group secondario -->\r\n                    <tr *ngIf=\"HasSecondaryHeaderGroup\">\r\n                        <ng-container *ngTemplateOutlet=\"secondaryHeaderGroupRef\"></ng-container>\r\n                        <th *ngIf=\"Export\"></th>\r\n                    </tr>\r\n                </ng-container>\r\n\r\n                <!-- Blocco effettivo degli header -->\r\n                <tr>\r\n                    <!-- Aggiungo una checkbox se la selezione \u00E8 attiva -->\r\n                    <th class=\"est-col-min\" *ngIf=\"Selection && !HasPinnedColumns\">\r\n                        <input *ngIf=\"!SingleSelection\" class=\"est-pointer\" type=\"checkbox\" [disabled]=\"SelectionDisabled\" [(ngModel)]=\"globalCheck\" [ngModelOptions]=\"{'standalone': true}\" (ngModelChange)=\"globalCheckChanged();\">\r\n                    </th>\r\n\r\n                    <!-- Header che valgono per view mode e array mode -->\r\n                    <ng-container *ngIf=\"(viewMode || arrayMode)\">\r\n\r\n                        <!-- In una tabella base prendo semplicemente i th scritti dall'utente nell'HTML -->\r\n                        <ng-container *ngIf=\"(!UseCustomCells || !RowTHs) && !DynamicRowColumnsDefinition\">\r\n                            <ng-container *ngTemplateOutlet=\"headerRef\"></ng-container>\r\n                        </ng-container>\r\n\r\n                        <!-- Se ho un modello dinamico dell'oggetto creo le colonne in base alle propriet\u00E0 -->\r\n                        <ng-container *ngIf=\"(!UseCustomCells || !RowTHs) && DynamicRowColumnsDefinition\">\r\n                            <th *ngFor=\"let operation of DynamicOperations\" class=\"est-col-min est-no-side-padding\"></th>\r\n                            \r\n                            <ng-container *ngFor=\"let rowHeader of DynamicRowColumnsDefinition\">\r\n                                <ng-container *ngIf=\"rowHeader.visible\">\r\n                                    <th *ngIf=\"OrderByColumn\" es-th=\"{{rowHeader.propertyName}}\" class=\"{{UserDefinedDynamicCols ? ((rowHeader.clss || '') + (rowHeader.headerWraps ? '' : ' est-nowrap')) : ' est-nowrap'}}\" [Order]=\"rowHeader.dataOrder\" [Resizable]=\"ColumnsResizable\" [Orderable]=\"rowHeader.orderable\" [OrderBy]=\"OrderByColumn\" [SearchInProgress]=\"!!researchInProgress\" (onOrderChange)=\"thOrderChanged(rowHeader.propertyName, $event)\">{{rowHeader.description}}</th>\r\n                                    <th *ngIf=\"!OrderByColumn\" es-th=\"{{rowHeader.propertyName}}\" class=\"{{UserDefinedDynamicCols ? ((rowHeader.clss || '') + (rowHeader.headerWraps ? '' : ' est-nowrap')) : ' est-nowrap'}}\" [Order]=\"rowHeader.dataOrder\" [Resizable]=\"ColumnsResizable\" [Orderable]=\"rowHeader.orderable\" [OrderBy]=\"OrderByColumn\">{{rowHeader.description}}</th>\r\n                                </ng-container>\r\n                            </ng-container>\r\n                        </ng-container>\r\n\r\n                        <!-- Se non ho un modello dinamico ma invece delle celle custom, genero gli header in base ai row th -->\r\n                        <ng-container *ngIf=\"UseCustomCells && RowTHs\">\r\n                            <th *ngIf=\"HasPinnedColumns\" class=\"est-pinned-header est-col-min\">\r\n                                <div [style.width.px]=\"PinnedContainerWidth\" class=\"est-pinned-border est-simple-border-bottom\">\r\n                                    <th class=\"est-col-min est-no-border\" *ngIf=\"Selection\">\r\n                                        <input *ngIf=\"!SingleSelection\" class=\"est-pointer\" type=\"checkbox\" [disabled]=\"SelectionDisabled\" [(ngModel)]=\"globalCheck\" [ngModelOptions]=\"{'standalone': true}\" (ngModelChange)=\"globalCheckChanged();\">\r\n                                    </th>\r\n                                    <ng-container *ngFor=\"let rowHeader of RowTHs\">\r\n                                        <th *ngIf=\"rowHeader && rowHeader.Visible && rowHeader.Pinned\" [style.width.px]=\"rowHeader.PinnedWidth\" es-th=\"{{rowHeader.ID}}\" \r\n                                            class=\"{{rowHeader.Class || ''}}\" \r\n                                            [class.est-pinned-internal-header]=\"true\" \r\n                                            [class.est-no-border]=\"true\" \r\n                                            [class.est-nowrap]=\"!rowHeader.Wrap\" \r\n                                            [Pinned]=\"true\" [Order]=\"rowHeader.Order\" [Resizable]=\"ColumnsResizable\" [Orderable]=\"rowHeader.Orderable\" [OrderBy]=\"OrderByColumn\" [SearchInProgress]=\"!!researchInProgress\" (onUnpinning)=\"columnMetadata_H.unpinColumn($event)\" (onOrderChange)=\"OrderByColumn && thOrderChanged(rowHeader.ID, $event)\">\r\n                                            <ng-container *ngIf=\"rowHeader.Template\"><ng-container *ngTemplateOutlet=\"rowHeader.Template;\"></ng-container></ng-container>\r\n                                            <span *ngIf=\"!rowHeader.Template\">{{rowHeader.Content}}</span>\r\n                                        </th>\r\n                                    </ng-container>\r\n                                </div>\r\n                            </th>\r\n                            <ng-container *ngFor=\"let rowHeader of RowTHs\">\r\n                                <th *ngIf=\"rowHeader && rowHeader.Visible && !rowHeader.Pinned\" es-th=\"{{rowHeader.ID}}\" class=\"{{rowHeader.Class || ''}}\" [class.est-ltab-border]=\"rowHeader.LeftBorder\" [class.est-rtab-border]=\"rowHeader.RightBorder\" [class.est-nowrap]=\"!rowHeader.Wrap\" [Order]=\"rowHeader.Order\" [Resizable]=\"ColumnsResizable\" [Orderable]=\"rowHeader.Orderable\" [OrderBy]=\"OrderByColumn\" [SearchInProgress]=\"!!researchInProgress\" (onOrderChange)=\"OrderByColumn && thOrderChanged(rowHeader.ID, $event)\">\r\n                                    <ng-container *ngIf=\"rowHeader.Template\"><ng-container *ngTemplateOutlet=\"rowHeader.Template;\"></ng-container></ng-container>\r\n                                    <span *ngIf=\"!rowHeader.Template\">{{rowHeader.Content}}</span>\r\n                                </th>\r\n                            </ng-container>\r\n                        </ng-container>\r\n                    </ng-container>\r\n\r\n                    <!--Casistica in cui ho il setup proveniente da un report. Gli header sono definiti da come \u00E8 fatto il report-->\r\n                    <ng-container *ngIf=\"reportMode\">\r\n                        <th [style.color]=\"clm.color\" *ngFor=\"let clm of ReportValues.columns\" class=\"est-no-selection est-pointer est-nowrap\" (click)=\"reportMode_H.setupNextOrderAndSearch(clm)\">\r\n                            {{clm.description}}<span class=\"fa\" [class.fa-chevron-down]=\"clm.order == 'DESC'\" [class.fa-chevron-up]=\"clm.order == 'ASC'\"></span>\r\n                        </th>\r\n                    </ng-container>\r\n\r\n                    <!--Per l'eliminazione mi serve un header aggiuntivo-->\r\n                    <th *ngIf=\"Removal\" [class.est-right-9]=\"Export || HiddenColumns\" class=\"est-col-min est-sticky-last-column\"><span class=\"fa fa-trash\"></span></th>\r\n\r\n                    <!--Per l'esportazione mi serve l'header extra da cui faccio uscire i 3 pallocchi-->\r\n                    <th *ngIf=\"Export || HiddenColumns || ColumnsOrdering || CornerMenuOptions\" class=\"est-table-dotted-menu est-sticky-last-column est-col-min text-sm-center\">\r\n                        \r\n                        <!-- Link nascosto che serve a scaricare il file -->\r\n                        <a *ngIf=\"headers\" hidden #exportDownloader csvLink [data]=\"data\" [headers]=\"headers\" [delimiter]=\"';'\" [filename]=\"ExportFileName\"></a>\r\n\r\n                        <!-- Blocco con i 3 pallocchi che tira fuori il context menu delle operazioni -->\r\n                        <div class=\"btn-group\" container=\"body\" placement=\"bottom right\" dropdown #dropdown=\"bs-dropdown\" [autoClose]=\"true\">\r\n                            <span dropdownToggle class=\"fa fa-ellipsis-v est-fs-18 est-pointer est-padding-3\"></span>\r\n\r\n                            <div *dropdownMenu class=\"dropdown-menu dropdown-menu-right est-bring-to-front-strong\">\r\n                                <div class=\"est-pointer\">\r\n                                    <a class=\"dropdown-item\" *ngIf=\"HiddenColumns || ColumnsOrdering\" (click)=\"columnMetadata_H.resetColumnVisSelection(); changeColumnVisibilityModal.show();\">\r\n                                        <ng-container *ngIf=\"!HiddenColumns && ColumnsOrdering\">\r\n                                            {{'Columns Order' | localize : lc}}\r\n                                        </ng-container>\r\n                                        <ng-container *ngIf=\"HiddenColumns && !ColumnsOrdering\">\r\n                                            {{'Columns Visibility' | localize : lc}}\r\n                                        </ng-container>\r\n                                        <ng-container *ngIf=\"HiddenColumns && ColumnsOrdering\">\r\n                                            {{'Columns Visibility and Order' | localize : lc}}\r\n                                        </ng-container>\r\n                                    </a>\r\n                                    <a class=\"dropdown-item\" *ngIf=\"Export && CSVExport\" (click)=\"export_H.tryExport('CSV')\">{{'Export View' | localize : lc}} (CSV)</a>\r\n                                    <a class=\"dropdown-item\" *ngIf=\"Export && XLSXExport\" (click)=\"export_H.tryExport('XLSX')\">{{'Export View' | localize : lc}} (XLSX)</a>\r\n                                    <a class=\"dropdown-item\" *ngFor=\"let option of CornerMenuOptions\" (click)=\"cornerActionClicked(option.id)\">{{option.description}}</a>\r\n                                </div>\r\n                            </div>\r\n                        </div>\r\n                    </th>\r\n                </tr>\r\n            </thead>\r\n            \r\n            <!-- Valido per modalit\u00E0 View o Array. Se sono in report mode il body \u00E8 creato in altro modo -->\r\n            <tbody [hidden]=\"BodyHidden || FirstBind\" *ngIf=\"(arrayMode || viewMode)\">\r\n                <!--Con selection attiva richiamo il template che gestisce il context menu-->\r\n                <ng-container *ngIf=\"Selection\">\r\n                    <ng-container *ngTemplateOutlet=\"TBodySelection; context: { $implicit: { selDisabled: arrayMode ? false : SelectionDisabled, sel: Selection }}\"></ng-container>\r\n                </ng-container>\r\n\r\n                <!--Senza selection richiamo il template che NON gestisce il context menu-->\r\n                <ng-container *ngIf=\"!Selection\">\r\n                    <ng-container *ngTemplateOutlet=\"TBody\"></ng-container>\r\n                </ng-container>\r\n            </tbody>\r\n\r\n            <!-- Per la modalit\u00E0 a report c'\u00E8 un body particolare semi-dinamico -->\r\n            <tbody [hidden]=\"BodyHidden\" *ngIf=\"reportMode\">\r\n                <tr *ngFor=\"let row of ReportValues.rows; let even = even;\">\r\n                    <td class=\"est-nowrap\" *ngFor=\"let val of row.values\">{{val}}</td>\r\n                    <td class=\"est-sticky-last-column{{even && !Hierarchy ? '-alt' : ''}}\"></td>\r\n                </tr>\r\n            </tbody>\r\n        </table>\r\n    </div>\r\n\r\n    <div *ngIf=\"PagingStyle == 'both' || PagingStyle == 'bottom'\">\r\n        <ng-container *ngTemplateOutlet=\"pagingElement\"></ng-container>\r\n    </div>\r\n</div>\r\n\r\n<!-- Template che contiene tutte le info di paginazione in modo da poterlo replicare anche sopra -->\r\n<ng-template #pagingElement>\r\n    <ng-container *ngIf=\"!FirstBind\">\r\n        <!-- Pulsanti avanti-indietro di paginazione -->\r\n        <div *ngIf=\"PagerOptions.ShowPaging && PagerOptions.ShowButtons && (PagerOptions.PagerCount > 10 || PagerOptions.PagerCount == -1)\" class=\"pull-right btn-toolbar\">\r\n            <ng-container *ngIf=\"(!reportMode || View?.pagingavailable) && (!arrayMode || SearchView)\">\r\n                <ng-container *ngTemplateOutlet=\"pagingButtons; context: { $implicit: { Margin: true, ATP: addToPage.bind(this), GTP: goToPage.bind(this), Array: arrayPulsanti }}\"></ng-container>\r\n            </ng-container>\r\n            <ng-container *ngIf=\"arrayMode && UseArrayModePaging && !SearchView\">\r\n                <ng-container *ngTemplateOutlet=\"pagingButtons; context: { $implicit: { Margin: true, ATP: arrayAddToPage.bind(this), GTP: arrayGoToPage.bind(this), Array: arrayPulsanti }}\"></ng-container>\r\n            </ng-container>\r\n        </div>\r\n        <!-- Paginatore dove appare la count e le opzioni di paginazione -->\r\n        <div class=\"pull-right\" *ngIf=\"PagerOptions.ShowCount || PagerOptions.ShowPagingOptions\">\r\n            <div class=\"est-mt-min-5\" *ngIf=\"PagerOptions.ShowPaging\">\r\n                <app-paging *ngIf=\"!PagerOptions.UsesView\" [CountLabel]=\"CountLabel\" [ShowPaging]=\"PagerOptions.ShowPagingOptions\" [ShowCount]=\"PagerOptions.ShowCount\" [PagerCount]=\"PagerOptions.PagerCount\" [WarnOnAll]=\"false\" [CurrentPageSize]=\"ArraymodeItemsPerPage\" (pagingSelected)=\"items_H.refreshPaging($event)\"></app-paging>\r\n                <app-paging *ngIf=\"PagerOptions.UsesView\" [CountLabel]=\"CountLabel\" [ShowPaging]=\"PagerOptions.ShowPagingOptions\" [ShowCount]=\"PagerOptions.ShowCount\" [PagerCount]=\"PagerOptions.PagerCount\" [GroupMode]=\"PagerOptions.Searches == 'groups'\" [AllSearch]=\"AllSearch\" [View]=\"PagerOptions.View\" (pagingSelected)=\"onItemsPerPageChanged($event);\"></app-paging>\r\n            </div>\r\n            <div *ngIf=\"reportMode && !PagerOptions.ShowPaging\"><em>{{'Paging options are not available for this report' | localize: lc}}</em></div>\r\n        </div>\r\n        <div class=\"clearfix\"></div>\r\n    </ng-container>\r\n</ng-template>\r\n\r\n<!-- Template che contiene i pulsanti per cambiare pagina -->\r\n<ng-template #pagingButtons let-options>\r\n    <div class=\"est-flex\" [class.est-margin-left-50]=\"options.Margin\">\r\n        <a class=\"btn\" class=\"est-page-prev app-pointer\" (click)=\"options.ATP(-1, options.separator)\"><span class=\"fa fa-chevron-left\"></span></a>\r\n        <div *ngIf=\"options.Array\" class=\"est-inline\"><a *ngFor=\"let p of options.Array\" class=\"btn est-page-sel {{p.cssClass}}\" (click)=\"options.GTP(p.val, options.separator)\">{{p.val}}</a></div>\r\n        <a class=\"btn\" class=\"est-page-next app-pointer\" (click)=\"options.ATP(1, options.separator)\"><span class=\"fa fa-chevron-right\"></span></a>\r\n    </div>\r\n</ng-template>\r\n\r\n<!-- Questi due template rappresentano effettivamente il body della tabella. essendo il tr l'unica cosa che davvero cambia, il resto \u00E8 templatizzato -->\r\n<ng-template #TBodySelection let-templateOptions>\r\n    <ng-container *ngFor=\"let item of boundSource; let even = even; let i=index; trackBy: bodyTrackBy\">\r\n        <tr *ngIf=\"item._visible || (!Hierarchy && !ArrayGrouping)\" \r\n            [class]=\"item._rowClass ? item._rowClass : ''\" \r\n            [class.est-line-through]=\"item.removed || item.deleted\" \r\n            [class.est-pointer]=\"!item.locked\" \r\n            [class.est-white-selected]=\"item._selected && !item.locked\"\r\n            [class.est-rg]=\"item._group\"\r\n            [class.est-rg-sep]=\"item._sep\"\r\n            [contextMenu]=\"!item.locked ? (ContextMenu || emptyMenu) : emptyMenu\" [contextMenuSubject]=\"item\"\r\n            (click)=\"(!item.locked && !item._sep && !item._group && handleClick($event, item)) || item._group && handleGroupClick(item)\">\r\n\r\n            <td *ngIf=\"!item.locked && !item._sep && !HasPinnedColumns\">\r\n                <input  type=\"checkbox\" \r\n                        [disabled]=\"templateOptions.selDisabled\" \r\n                        [class.est-pointer]=\"!item.locked\"\r\n                        [(ngModel)]=\"item._selected\" name=\"check{{i}}\" \r\n                        (click)=\"$event.stopPropagation(); handleClick($event, item);\">\r\n            </td>\r\n            <td *ngIf=\"(item.locked || item._sep) && !HasPinnedColumns\"></td>\r\n\r\n            <ng-container *ngIf=\"item._sep\"><ng-container *ngTemplateOutlet=\"groupPager; context: { $implicit: item }\"></ng-container> </ng-container>\r\n\r\n            <ng-container *ngIf=\"!item._sep\">\r\n                <ng-container *ngTemplateOutlet=\"basicColumns; context: { $implicit: item }\"></ng-container>\r\n                <ng-container *ngTemplateOutlet=\"dynamicColumns; context: { $implicit: item }\"></ng-container>\r\n                <ng-container *ngTemplateOutlet=\"customCells; context: { $implicit: item, templateOptions: templateOptions }\"></ng-container>\r\n            </ng-container>\r\n            <ng-container *ngTemplateOutlet=\"bodyDeleteAndExport; context: { $implicit: { even: even, item: item }}\"></ng-container>\r\n        </tr>\r\n    </ng-container>\r\n</ng-template>\r\n\r\n<ng-template #TBody>\r\n    <ng-container *ngFor=\"let item of boundSource; let even = even;\">\r\n        <tr *ngIf=\"item._visible || !Hierarchy\" \r\n            [class]=\"item._rowClass ? item._rowClass : ''\" \r\n            [class.est-line-through]=\"item.removed || item.deleted\"\r\n            [class.est-rg]=\"item._group\"\r\n            [class.est-rg-sep]=\"item._sep\"\r\n            (click)=\"item._group && handleGroupClick(item)\">\r\n\r\n            <ng-container *ngIf=\"item._sep\"><ng-container *ngTemplateOutlet=\"groupPager; context: { $implicit: item }\"></ng-container></ng-container>\r\n\r\n            <ng-container *ngIf=\"!item._sep\">\r\n                <ng-container *ngTemplateOutlet=\"basicColumns; context: { $implicit: item }\"></ng-container>\r\n                <ng-container *ngTemplateOutlet=\"dynamicColumns; context: { $implicit: item }\"></ng-container>\r\n                <ng-container *ngTemplateOutlet=\"customCells; context: { $implicit: item }\"></ng-container>\r\n            </ng-container>\r\n            <ng-container *ngTemplateOutlet=\"bodyDeleteAndExport; context: { $implicit: { even: even, item: item }}\"></ng-container>\r\n        </tr>\r\n    </ng-container>\r\n</ng-template>\r\n\r\n<ng-template #groupPager let-item>\r\n    <td class=\"est-pinned-body \" *ngIf=\"HasPinnedColumns\"><div class=\"est-pinned-border est-cell-group-padding\"></div></td>\r\n    <td *ngIf=\"item._grouplevel > 1\" [attr.colspan]=\"item._grouplevel-1\"></td>\r\n    <td [attr.colspan]=\"Columns.VisibleUnpinned - (item._grouplevel > 0 ? item._grouplevel - 1 : 0)\">\r\n        <div class=\"est-rg-sep-flex-right\" *ngIf=\"RowGroupingPagingStyle == 'right'\">\r\n            <div class=\"est-rg-page\"><ng-container *ngTemplateOutlet=\"pagingButtons; context: { $implicit: { separator: item, ATP: addToPageGroup.bind(this), GTP: goToPageGroup.bind(this), Array: item.buttons }}\"></ng-container></div>\r\n            <div class=\"est-rg-ipp\" *ngIf=\"(item.searches == 'groups' ? item.view.groupcount : item.view.objectcount) > 10\"><app-paging [CountLabel]=\"CountLabel\" [AllSearch]=\"AllSearch\" [GroupMode]=\"item.searches == 'groups'\" [PagerCount]=\"item.searches == 'groups' ? item.view.groupcount : item.view.objectcount\" [View]=\"item.view\" (pagingSelected)=\"onGroupItemsPerPageChanged(item, $event);\"></app-paging></div>\r\n        </div>\r\n\r\n        <div class=\"est-rg-sep-flex-left\" *ngIf=\"RowGroupingPagingStyle == 'left'\">\r\n            <div class=\"est-rg-ipp\"><app-paging [AllSearch]=\"AllSearch\" [CountLabel]=\"CountLabel\" [GroupMode]=\"item.searches == 'groups'\" [PagerCount]=\"item.searches == 'groups' ? item.view.groupcount : item.view.objectcount\" [View]=\"item.view\" (pagingSelected)=\"onGroupItemsPerPageChanged(item, $event);\"></app-paging></div>\r\n            <div class=\"est-rg-page\" *ngIf=\"(item.searches == 'groups' ? item.view.groupcount : item.view.objectcount) > 10\"><ng-container *ngTemplateOutlet=\"pagingButtons; context: { $implicit: { separator: item, ATP: addToPageGroup.bind(this), GTP: goToPageGroup.bind(this), Array: item.buttons }}\"></ng-container></div>\r\n        </div>\r\n    </td>\r\n</ng-template>\r\n\r\n<!-- Questo template contiene la print condizionale su tabelle semplici, con header e body scritti a manazza -->\r\n<ng-template #basicColumns let-item>\r\n    <ng-container *ngIf=\"(!UseCustomCells || !RowTDs) && !DynamicRowColumnsDefinition\">\r\n        <ng-container *ngTemplateOutlet=\"bodyRef; context : {$implicit: item}\"></ng-container>\r\n    </ng-container>\r\n</ng-template>\r\n\r\n<!-- Questo template contiene la print condizionale su tabelle definite in maniera dinamica dal modello -->\r\n<ng-template #dynamicColumns let-item>\r\n    <ng-container *ngIf=\"(!UseCustomCells || !RowTDs) && DynamicRowColumnsDefinition\">\r\n        <ng-container *ngFor=\"let operation of DynamicOperations; let first = first; let last = last;\">\r\n            <ng-container *ngIf=\"!operation.conditionField || (item.properties[operation.conditionField] == operation.conditionValue)\">\r\n                <td [class.est-no-right-padding]=\"last\" [class.est-no-left-padding]=\"!first\" class=\"est-col-min\"><span title=\"{{operation.title}}\" class=\"{{operation.iconClass}} est-pointer\" (click)=\"dynamicOperation(item, operation.id)\">{{operation.text}}</span></td>\r\n            </ng-container>\r\n            <ng-container *ngIf=\"operation.conditionField && (item.properties[operation.conditionField] != operation.conditionValue)\">\r\n                <td class=\"est-col-min est-no-side-padding\"></td>\r\n            </ng-container>\r\n        </ng-container>\r\n        <ng-container *ngFor=\"let rowItem of DynamicRowColumnsDefinition\">\r\n            <ng-container *ngIf=\"rowItem.routePath && rowItem.visible\">\r\n                <td es-td=\"{{rowItem.propertyName}}\" class=\"{{UserDefinedDynamicCols ? rowItem.clss : 'est-nowrap'}}\" [Internal]=\"false\" [Context]=\"item._hash\">\r\n                    <a [routerLink]=\"dynamicMode_H.generateRouterLink(rowItem.routePath, rowItem.routeParameterProperties, item)\" class=\"est-link\" [innerHTML]=\"item.properties[rowItem.propertyName]\"></a>\r\n                </td>\r\n            </ng-container>\r\n            <ng-container *ngIf=\"!rowItem.routePath && rowItem.visible\">\r\n                <ng-container *ngTemplateOutlet=\"findEsTd(rowItem.propertyName) || defaultEsTd; context: { $implicit: item.properties[rowItem.propertyName], rowItem : rowItem, item : item }\"> </ng-container>\r\n            </ng-container>\r\n        </ng-container>\r\n    </ng-container>\r\n</ng-template>\r\n\r\n<ng-template #defaultEsTd let-value let-rowItem='rowItem' let-item='item'>\r\n    <td es-td=\"{{rowItem.propertyName}}\" class=\"{{UserDefinedDynamicCols ? rowItem.clss : 'est-nowrap'}}\"\r\n        [class.est-pointer]=\"UseCustomCellActions && CustomCellActionsOn.indexOf('$' + rowItem.propertyName + '$') != -1\"\r\n        (click)=\"cellClicked(rowItem.propertyName, item) && !CellActionPropagates && $event.stopPropagation()\"\r\n        [Internal]=\"false\" [Context]=\"item._hash\">\r\n        {{value}}\r\n    </td>\r\n</ng-template>\r\n\r\n<!-- Questo template contiene la print condizionale delle celle custom se configurate -->\r\n<ng-template #customCells let-item let-opt=\"templateOptions\">\r\n    <ng-container *ngIf=\"UseCustomCells && RowTDs\">\r\n\r\n        <td *ngIf=\"HasPinnedColumns\" class=\"est-pinned-body est-col-min\" [class.est-white-selected]=\"item._selected\">\r\n            <div [style.width.px]=\"PinnedContainerWidth\" class=\"est-pinned-border\">\r\n                <td *ngIf=\"!item.locked && !item._sep && Selection\" class=\"est-no-border est-col-min\">\r\n                    <input type=\"checkbox\" [disabled]=\"opt.selDisabled\" [class.est-pointer]=\"!item.locked\" [(ngModel)]=\"item._selected\" name=\"check{{item._hash}}\" (click)=\"$event.stopPropagation(); handleClick($event, item);\">\r\n                </td>\r\n                <td class=\"est-no-border est-col-min\" *ngIf=\"(item.locked || item._sep) && Selection\"></td>\r\n\r\n                <ng-container *ngFor=\"let rowItem of RowTDs[item._hash]; let i = index\">\r\n                    <td *ngIf=\"rowItem && rowItem.Pinned\" [style.width.px]=\"rowItem.PinnedWidth\" es-td=\"{{rowItem.ID}}\" class=\"{{rowItem.Class}}\" [class.est-no-border]=\"true\" [class.est-rg-hdr]=\"rowItem.GroupHeader\" [class.est-rg-agg]=\"rowItem.GroupAggregation\" \r\n                        [class.est-nowrap]=\"Hierarchy || !rowItem.Wraps\" [Internal]=\"true\">\r\n                        <ng-container *ngIf=\"Hierarchy && i == 0\"><ng-container *ngTemplateOutlet=\"HierarchyNavigator; context: { $implicit: item }\"></ng-container></ng-container>\r\n                        <ng-container *ngIf=\"rowItem.Template\"><ng-container *ngTemplateOutlet=\"rowItem.Template; context: { $implicit: item }\"></ng-container></ng-container>\r\n                        <span *ngIf=\"!rowItem.Template\">{{rowItem.Content}}</span>\r\n                    </td>\r\n                </ng-container>\r\n            </div>\r\n        </td>\r\n\r\n        <ng-container *ngFor=\"let rowItem of RowTDs[item._hash]; let i = index\">\r\n            <ng-container *ngIf=\"rowItem && !rowItem.Pinned\">\r\n\r\n                <!-- Casistica senza bodyRef, quindi con direttive per i td -->\r\n                <ng-container *ngIf=\"!bodyRef && rowItem.Visible\">\r\n                    <td es-td=\"{{rowItem.ID}}\" class=\"{{rowItem.Class}}\" [class.est-ltab-border]=\"rowItem.LeftBorder\" [class.est-rtab-border]=\"rowItem.RightBorder\" [class.est-rg-hdr]=\"rowItem.GroupHeader\" [class.est-rg-agg]=\"rowItem.GroupAggregation\" \r\n                        [class.est-nowrap]=\"Hierarchy || !rowItem.Wraps\" [Internal]=\"true\">\r\n                        <ng-container *ngIf=\"Hierarchy && i == 0\"><ng-container *ngTemplateOutlet=\"HierarchyNavigator; context: { $implicit: item }\"></ng-container></ng-container>\r\n                        <ng-container *ngIf=\"rowItem.Template\"><ng-container *ngTemplateOutlet=\"rowItem.Template; context: { $implicit: item }\"></ng-container></ng-container>\r\n                        <span *ngIf=\"!rowItem.Template\">{{rowItem.Content}}</span>\r\n                    </td>\r\n                </ng-container>\r\n\r\n                <!-- Casistica bodyRef, quindi con componenti per i td (RouterLink) DEPRECATO -->\r\n                <ng-container *ngIf=\"rowItem.RouterLink && rowItem.Visible && bodyRef\">\r\n                    <td es-td=\"{{rowItem.ID}}\" class=\"{{rowItem.Class}}\" [class.est-nowrap]=\"Hierarchy || !rowItem.Wraps\" [Internal]=\"true\">\r\n                        <ng-container *ngIf=\"Hierarchy && i == 0\">\r\n                            <ng-container *ngTemplateOutlet=\"HierarchyNavigator; context: { $implicit: item }\"></ng-container>\r\n                        </ng-container>\r\n                        <a [routerLink]='rowItem.RouterLink' class=\"est-link\" [innerHTML]=\"rowItem.Content\"></a>\r\n                    </td>\r\n                </ng-container>\r\n\r\n                <!-- Casistica bodyRef, quindi con componenti per i td (NON RouterLink) DEPRECATO -->\r\n                <ng-container *ngIf=\"!rowItem.RouterLink && rowItem.Visible && bodyRef\">\r\n                    <td es-td=\"{{rowItem.ID}}\" class=\"{{rowItem.Class}}\" [class.est-nowrap]=\"Hierarchy || !rowItem.Wraps\" [class.est-pointer]=\"UseCustomCellActions && CustomCellActionsOn.indexOf('$' + $any(rowItem).ID + '$') != -1\" (click)=\"cellClicked(rowItem.ID, item) && !CellActionPropagates && $event.stopPropagation()\" [Internal]=\"true\">\r\n                        <ng-container *ngIf=\"Hierarchy && i == 0\">\r\n                            <ng-container *ngTemplateOutlet=\"HierarchyNavigator; context: { $implicit: item }\"></ng-container>\r\n                        </ng-container>\r\n                        <ng-container *ngIf=\"rowItem.Template\">\r\n                            <ng-container *ngTemplateOutlet=\"rowItem.Template; context: { $implicit: item }\"></ng-container>\r\n                        </ng-container>\r\n                        <span *ngIf=\"!rowItem.Template\" [innerHTML]=\"rowItem.Content\"></span>\r\n                    </td>\r\n                </ng-container>\r\n            </ng-container>\r\n        </ng-container>\r\n    </ng-container>\r\n</ng-template>\r\n\r\n<ng-template #HierarchyNavigator let-item>\r\n    <span *ngIf=\"!item.parent\" class=\"fa fa-chevron-down\" style=\"visibility:hidden\"></span>\r\n    <span *ngIf=\"item.parent && item._expanded\" class=\"fa fa-chevron-down est-pointer est-no-selection\" (click)=\"hierarchyMode_H.collapseParent(item[this.OwnKey])\"></span>\r\n    <span *ngIf=\"item.parent && !item._expanded\" class=\"fa fa-chevron-up est-pointer est-no-selection\" (click)=\"hierarchyMode_H.expandParent(item[this.OwnKey])\"></span>\r\n    &nbsp;\r\n</ng-template>\r\n\r\n<!-- Questo template contiene i pulsanti di eliminazione/undo eliminazione ed esportazione che vanno in fondo ad un record edlla tabella -->\r\n<ng-template #bodyDeleteAndExport let-options>\r\n    <ng-container *ngIf=\"Removal && !RemovalCondition\">\r\n        <td class=\"est-sticky-last-column{{options.even? '-alt' : ''}} {{Export || HiddenColumns || CornerMenuOptions ? 'est-right-9' : ''}}\" *ngIf=\"!(options.item.removed || options.item.deleted)\"><span class=\"fa fa-remove est-pointer text-danger\" [hidden]=\"options.item.removable != undefined && !options.item.removable\" (click)=\"onRemoval.emit(options.item)\"></span></td>\r\n        <td class=\"est-sticky-last-column{{options.even? '-alt' : ''}} {{Export || HiddenColumns || CornerMenuOptions ? 'est-right-9' : ''}}\" *ngIf=\"(options.item.removed || options.item.deleted)\"><span class=\"fa fa-undo  text-warning est-pointer\" (click)=\"onAbortRemoval.emit(options.item)\"></span></td>\r\n    </ng-container>\r\n    <ng-container *ngIf=\"Removal && RemovalCondition\">\r\n        <td class=\"est-sticky-last-column{{options.even? '-alt' : ''}} {{Export || HiddenColumns || CornerMenuOptions ? 'est-right-9' : ''}}\" *ngIf=\"!(options.item.removed || options.item.deleted) && options.item[RemovalCondition]\"><span class=\"fa fa-remove est-pointer text-danger\" [hidden]=\"options.item.removable != undefined && !options.item.removable\" (click)=\"onRemoval.emit(options.item)\"></span></td>\r\n        <td class=\"est-sticky-last-column{{options.even? '-alt' : ''}} {{Export || HiddenColumns || CornerMenuOptions ? 'est-right-9' : ''}}\" *ngIf=\"(options.item.removed || options.item.deleted) && options.item[RemovalCondition]\"><span class=\"fa fa-undo  text-warning est-pointer\" (click)=\"onAbortRemoval.emit(options.item)\"></span></td>\r\n        <td class=\"est-sticky-last-column{{options.even? '-alt' : ''}} {{Export || HiddenColumns || CornerMenuOptions ? 'est-right-9' : ''}}\" *ngIf=\"!options.item[RemovalCondition]\"><span class=\"fa fa-remove est-hidden-view\"></span></td>\r\n    </ng-container>\r\n    <td *ngIf=\"Export || HiddenColumns || CornerMenuOptions\" class=\"est-sticky-last-column{{options.even && !Hierarchy ? '-alt' : ''}}\"></td>\r\n</ng-template>\r\n\r\n<!-- Context menu vuoto default per tutte le tabella che non ce l'hanno, in modo che al click destro appaia \"nessuna op disponibile\" -->\r\n<context-menu #emptyMenu>\r\n    <ng-template contextMenuItem>\r\n        <span>\r\n            <em>{{'No operations available' | localize : lc}}...</em>\r\n        </span>\r\n    </ng-template>\r\n</context-menu>\r\n\r\n<!-- Modal per cambiare posizione e visibilit\u00E0 delle colonne dell'es-table -->\r\n<div bsModal #changeColumnVisibilityModal=\"bs-modal\" class=\"modal fade\" role=\"dialog\" aria-hidden=\"true\">\r\n    <div class=\"modal-dialog modal-lg\">\r\n        <div class=\"modal-content\">\r\n            <div class=\"modal-header\">\r\n                <h5 class=\"modal-title pull-left\">\r\n                    <ng-container *ngIf=\"!HiddenColumns && ColumnsOrdering\">\r\n                        {{'Columns Order' | localize : lc}}\r\n                    </ng-container>\r\n                    <ng-container *ngIf=\"HiddenColumns && !ColumnsOrdering\">\r\n                        {{'Columns Visibility' | localize : lc}}\r\n                    </ng-container>\r\n                    <ng-container *ngIf=\"HiddenColumns && ColumnsOrdering\">\r\n                        {{'Columns Visibility and Order' | localize : lc}}\r\n                    </ng-container>\r\n                </h5>\r\n                <button type=\"button\" class=\"close pull-right\" (click)=\"changeColumnVisibilityModal.hide();\" aria-label=\"Close\">\r\n                    <span aria-hidden=\"true\">&times;</span>\r\n                </button>\r\n            </div>\r\n            <div class=\"modal-body\">\r\n                <div *ngIf=\"!TMPColumnsList || TMPColumnsList.length == 0\" class=\"card card-info est-padding-10 est-margin-bottom-0\">\r\n                    {{'There are no columns configured to be hidden/shown in this view' | localize : lc}}\r\n                </div>\r\n                <div *ngIf=\"TMPColumnsList && TMPColumnsList.length > 0\" style=\"max-height:500px; overflow-y:auto\">\r\n                    <!--Aaaaaaah la tristezza... qui mi servirebbe l'es-table per facilitare la selezione multipla ecc... peccato che se la linko qui entro in un loop impressionante-->\r\n                    <table class=\"table table-striped table-sm est-margin-bottom-0\">\r\n                        <thead>\r\n                            <tr>\r\n                                <th class=\"est-col-min\" *ngIf=\"HiddenColumns\">\r\n                                    <input class=\"est-pointer\" type=\"checkbox\" [(ngModel)]=\"globalColVisCheck\" [ngModelOptions]=\"{'standalone': true}\" (ngModelChange)=\"columnMetadata_H.globalColVisCheckChanged();\">\r\n                                </th>\r\n                                <th class=\"est-col-min\" *ngIf=\"ColumnsOrdering\"></th>\r\n                                <th class=\"est-col-min est-nowrap\">{{'Column Name' | localize : lc}}</th>\r\n                                <!--Filler-->\r\n                                <th></th>\r\n                                <!-- Pinner -->\r\n                                <th *ngIf=\"DirectivesBased\" class=\"est-col-min\"></th>\r\n                            </tr>\r\n                        </thead>\r\n                        <tbody>\r\n                            <tr *ngFor=\"let item of TMPColumnsList; let i = index; let last = last\" class=\"est-pointer\" [class.est-white-selected]=\"lastSelectedItemID == item.id\" [class.est-no-selection]=\"!item.visible\">\r\n                                <td *ngIf=\"HiddenColumns\">\r\n                                    <input type=\"checkbox\" [class.est-hidden-view]=\"item.fixed\" class=\"est-pointer\" [(ngModel)]=\"item.visible\" name=\"visible{{i}}\" (ngModelChange)=\"columnMetadata_H.updateGlobalColVisCheck();\" />\r\n                                </td>\r\n                                <td class=\"est-nowrap\" *ngIf=\"ColumnsOrdering\">\r\n                                    <span class=\"fa fa-arrow-up\" [class.est-hidden-view]=\"item.fixed || item.pinned\" (click)=\"lastSelectedItemID = item.id; i != 0 && !item.fixed && columnMetadata_H.sendUp(item); $event.stopPropagation();\"></span>\r\n                                    <span class=\"fa fa-arrow-down\" [class.est-hidden-view]=\"item.fixed || item.pinned\" (click)=\"lastSelectedItemID = item.id; !last && !item.fixed && columnMetadata_H.sendDown(item); $event.stopPropagation();\"></span>\r\n                                </td>\r\n                                <td class=\"est-nowrap\" (click)=\"columnMetadata_H.columnClicked(item);\">\r\n                                    <ng-container *ngIf=\"item.template\">\r\n                                        <ng-container *ngTemplateOutlet=\"item.template\"></ng-container>\r\n                                    </ng-container>\r\n                                    <ng-container *ngIf=\"!item.template\">{{item.description}}</ng-container>\r\n                                </td>\r\n                                <!--Filler-->\r\n                                <td (click)=\"columnMetadata_H.columnClicked(item);\"></td>\r\n                                <!-- Pinner -->\r\n                                <td *ngIf=\"DirectivesBased\"><span *ngIf=\"!item.fixed\" class=\"fa fa-thumb-tack\" [class.text-success]=\"item.pinned\" (click)=\"columnMetadata_H.pinOrUnpinColumn(item)\"></span></td>\r\n                            </tr>\r\n                        </tbody>\r\n                    </table>\r\n                </div>\r\n            </div>\r\n            <div class=\"modal-footer\">\r\n                <button type=\"button\" class=\"btn btn-secondary est-margin-right-10\" (click)=\"lastSelectedItemID = null; changeColumnVisibilityModal.hide();\">{{'Close' | localize : lc}}</button>\r\n                <button type=\"button\" [disabled]=\"!TMPColumnsList || TMPColumnsList.length == 0\" class=\"btn btn-primary\" (click)=\"columnMetadata_H.confirmColumnVisibilitySelection() && changeColumnVisibilityModal.hide()\">{{'Confirm' | localize : lc}}</button>\r\n            </div>\r\n        </div>\r\n    </div>\r\n</div>",
+                styles: [".est-loading-box{height:200px;text-align:center;position:relative;background:#ccc}.est-loading-content{margin:0;position:absolute;top:50%;left:50%;transform:translate(-50%,-50%);font-size:35px}.est-scrollable{max-height:600px;overflow:auto}.est-pointer{cursor:pointer}.est-high-density th,.est-high-density td{padding:0 .2rem}.est-no-selection{-webkit-user-select:none;-moz-user-select:none;-khtml-user-select:none;-ms-user-select:none}.est-hidden-view{visibility:hidden}.est-no-border{border:none!important}.est-nowrap{white-space:nowrap}.est-mt-min-5{margin-top:-5px}.est-white-selected{background-color:#ddd!important}.est-line-through{text-decoration:line-through}.est-no-side-padding{padding-left:0;padding-right:0}.est-no-left-padding{padding-left:0}.est-no-right-padding{padding-left:0}.est-col-min{width:1px}.est-margin-bottom-0{margin-bottom:0!important}.est-margin-right-10{margin-right:10px!important}.est-right-9{right:9px!important}.est-table-dotted-menu{padding:0 0 2px!important;color:#999}.est-fs-18{font-size:18px}.est-fs-14{font-size:14px}.est-padding-3{padding:3px!important}.est-page-container{position:relative}.est-bring-to-front-strong{z-index:99999999!important}.est-switch{position:relative;display:inline-block;width:30px;height:17px;margin-bottom:0;margin-right:5px;margin-left:5px}.est-switch input{display:none}.est-slider{position:absolute;cursor:pointer;top:0;left:0;right:0;bottom:0;background-color:#ccc;transition:.4s}.est-slider:before{position:absolute;content:\"\";height:13px;width:13px;left:3px;bottom:2px;background-color:#fff;transition:.4s}input:checked+.est-slider{background-color:#2196f3}input:focus+.est-slider{box-shadow:0 0 1px #2196f3}input:checked+.est-slider:before{transform:translate(11px)}.est-slider.round{border-radius:10px}.est-slider.round:before{border-radius:50%}.est-custom-input{width:30px;display:inline;padding:1px;height:20px}.est-row-lvl-1 td:first-child{padding-left:5px}.est-row-lvl-2 td:first-child{padding-left:20px}.est-row-lvl-3 td:first-child{padding-left:35px}.est-row-lvl-4 td:first-child{padding-left:50px}.est-row-lvl-5 td:first-child{padding-left:65px}.est-row-lvl-6 td:first-child{padding-left:80px}.est-row-lvl-7 td:first-child{padding-left:95px}.est-row-lvl-8 td:first-child{padding-left:110px}.est-row-lvl-9 td:first-child{padding-left:125px}.est-row-lvl-10 td:first-child{padding-left:140px}.est-row-lvl-11 td:first-child{padding-left:155px}.est-row-lvl-12 td:first-child{padding-left:170px}.est-row-lvl-13 td:first-child{padding-left:185px}.est-row-lvl-14 td:first-child{padding-left:200px}.est-row-lvl-15 td:first-child{padding-left:215px}.est-row-lvl-16 td:first-child{padding-left:230px}.est-row-lvl-17 td:first-child{padding-left:245px}.est-row-lvl-18 td:first-child{padding-left:260px}.est-row-lvl-19 td:first-child{padding-left:275px}.est-row-lvl-20 td:first-child{padding-left:290px}.est-row-lvl-21 td:first-child{padding-left:305px}.est-row-lvl-22 td:first-child{padding-left:320px}.est-row-lvl-23 td:first-child{padding-left:335px}.est-row-lvl-24 td:first-child{padding-left:350px}.est-row-lvl-25 td:first-child{padding-left:365px}.est-row-lvl-26 td:first-child{padding-left:380px}.est-row-lvl-27 td:first-child{padding-left:395px}.est-row-lvl-28 td:first-child{padding-left:410px}.est-row-lvl-29 td:first-child{padding-left:425px}.est-row-lvl-30 td:first-child{padding-left:440px}.est-row-lvl-31 td:first-child{padding-left:455px}.est-row-lvl-32 td:first-child{padding-left:470px}.est-row-lvl-33 td:first-child{padding-left:485px}.est-row-lvl-34 td:first-child{padding-left:500px}.est-row-lvl-35 td:first-child{padding-left:515px}.est-row-lvl-36 td:first-child{padding-left:530px}.est-row-lvl-37 td:first-child{padding-left:545px}.est-row-lvl-38 td:first-child{padding-left:560px}.est-row-lvl-39 td:first-child{padding-left:575px}.est-row-lvl-40 td:first-child{padding-left:590px}.est-row-lvl-41 td:first-child{padding-left:605px}.est-row-lvl-42 td:first-child{padding-left:620px}.est-row-lvl-43 td:first-child{padding-left:635px}.est-row-lvl-44 td:first-child{padding-left:650px}.est-row-lvl-45 td:first-child{padding-left:665px}.est-row-lvl-46 td:first-child{padding-left:680px}.est-row-lvl-47 td:first-child{padding-left:695px}.est-row-lvl-48 td:first-child{padding-left:710px}.est-row-lvl-49 td:first-child{padding-left:725px}.est-row-lvl-50 td:first-child{padding-left:740px}.est-row-lvl-51 td:first-child{padding-left:755px}.est-row-lvl-52 td:first-child{padding-left:770px}.est-row-lvl-53 td:first-child{padding-left:785px}.est-row-lvl-54 td:first-child{padding-left:800px}.est-row-lvl-55 td:first-child{padding-left:815px}.est-row-lvl-56 td:first-child{padding-left:830px}.est-row-lvl-57 td:first-child{padding-left:845px}.est-row-lvl-58 td:first-child{padding-left:860px}.est-row-lvl-59 td:first-child{padding-left:875px}.est-row-lvl-60 td:first-child{padding-left:890px}.est-row-lvl-61 td:first-child{padding-left:905px}.est-row-lvl-62 td:first-child{padding-left:920px}.est-row-lvl-63 td:first-child{padding-left:935px}.est-row-lvl-64 td:first-child{padding-left:950px}.est-row-lvl-65 td:first-child{padding-left:965px}.est-row-lvl-66 td:first-child{padding-left:980px}.est-row-lvl-67 td:first-child{padding-left:995px}.est-row-lvl-68 td:first-child{padding-left:1010px}.est-row-lvl-69 td:first-child{padding-left:1025px}.est-row-lvl-70 td:first-child{padding-left:1040px}.est-row-lvl-71 td:first-child{padding-left:1055px}.est-row-lvl-72 td:first-child{padding-left:1070px}.est-row-lvl-73 td:first-child{padding-left:1085px}.est-row-lvl-74 td:first-child{padding-left:1100px}.est-row-lvl-75 td:first-child{padding-left:1115px}.est-row-lvl-76 td:first-child{padding-left:1130px}.est-row-lvl-77 td:first-child{padding-left:1145px}.est-row-lvl-78 td:first-child{padding-left:1160px}.est-row-lvl-79 td:first-child{padding-left:1175px}.est-row-lvl-80 td:first-child{padding-left:1190px}.est-row-lvl-81 td:first-child{padding-left:1205px}.est-row-lvl-82 td:first-child{padding-left:1220px}.est-row-lvl-83 td:first-child{padding-left:1235px}.est-row-lvl-84 td:first-child{padding-left:1250px}.est-row-lvl-85 td:first-child{padding-left:1265px}.est-row-lvl-86 td:first-child{padding-left:1280px}.est-row-lvl-87 td:first-child{padding-left:1295px}.est-row-lvl-88 td:first-child{padding-left:1310px}.est-row-lvl-89 td:first-child{padding-left:1325px}.est-row-lvl-90 td:first-child{padding-left:1340px}.est-row-lvl-91 td:first-child{padding-left:1355px}.est-row-lvl-92 td:first-child{padding-left:1370px}.est-row-lvl-93 td:first-child{padding-left:1385px}.est-row-lvl-94 td:first-child{padding-left:1400px}.est-row-lvl-95 td:first-child{padding-left:1415px}.est-row-lvl-96 td:first-child{padding-left:1430px}.est-row-lvl-97 td:first-child{padding-left:1445px}.est-row-lvl-98 td:first-child{padding-left:1460px}.est-row-lvl-99 td:first-child{padding-left:1475px}.est-relative{position:relative}.est-top-pager{position:absolute;right:0;top:5px}.est-top-allselect{position:absolute;left:0;top:5px;font-weight:bold}.est-padding-10{padding:10px!important}.est-margin-right-50{margin-right:50px}.est-margin-left-50{margin-left:50px}.est-quick-unpin{color:#000;margin-left:8px;font-size:14px;transform:rotate(45deg)}.est-page-sel{color:#000;margin-left:3px;margin-right:3px;padding:0 5px;font-size:inherit;border:none;border-radius:15px}.est-page-prev{color:#000;padding:2px 0 0;font-size:inherit}.est-page-next{color:#000;padding:2px 0 0;font-size:inherit}.est-pinned-header{background-color:#fff;left:0;top:0;position:sticky;z-index:1;border-bottom:1px solid #dee2e6!important;padding:0!important}.est-simple-border-bottom{border-bottom:1px solid #dee2e6}.est-pinned-internal-header{border-top:0;border-bottom:0px solid #dee2e6}.est-pinned-border{border-right:2px solid #dee2e6!important}.est-cell-padding{padding:.3rem}.est-pinned-body{background-color:#fff;left:0;position:sticky;z-index:1;border-top:1px solid #dee2e6!important;padding:0!important}.est-inline{display:inline!important}.est-inline-block{display:inline-block!important}.est-link{color:#0275d8!important;cursor:pointer;text-decoration:none;display:block}.est-link:hover{color:#23527c!important;cursor:pointer;text-decoration:underline!important}.est-sticky-last-column{right:-1px;position:sticky;z-index:0;background-color:#fff}.est-sticky-last-column-alt{right:-1px;position:sticky;z-index:0;background-color:#f2f2f2}.est-ltab-border{border-left:2px solid #bbb}.est-rtab-border{border-right:2px solid #bbb}.est-cell-group-padding{padding:calc(.3rem + 1px);position:absolute;top:0;left:0;height:100%;width:100%}.est-margin-bottom-10{margin-bottom:10px}.est-text-center{text-align:center}.est-flex{display:flex}.est-rg-sep-flex-right{display:flex;flex-direction:row-reverse;width:100%;margin:-5px}.est-rg-sep-flex-left{display:flex;flex-direction:row;width:100%;margin:-5px}.est-rg-hdr{font-weight:bold}.est-rg-agg{font-style:italic}.est-rg{background-color:#7777!important}.est-rg-sep{font-size:12px;padding-right:20px!important;background-color:#bbbb!important}.est-rg-ipp{text-align:left;display:inline-flex;margin-right:25px}.est-rg-page{text-align:right;display:inline-flex;font-size:inherit;padding-top:5px}\n"]
+            },] }
+];
+EsTableComponent.ctorParameters = () => [
+    { type: NgControl, decorators: [{ type: Self }, { type: Optional }] },
+    { type: PreferencesService, decorators: [{ type: Optional }] },
+    { type: EsTableDefaultable, decorators: [{ type: Optional }, { type: Inject, args: [EST_DEFAULTS,] }] },
+    { type: String, decorators: [{ type: Optional }, { type: Inject, args: [EST_LOCALE,] }] },
+    { type: LocalizationService },
+    { type: ChangeDetectorRef },
+    { type: UtilitiesHandler },
+    { type: UtilityService },
+    { type: ExportService },
+    { type: DateService },
+    { type: MessageService }
+];
+EsTableComponent.propDecorators = {
+    EsTdsDirective: [{ type: ContentChildren, args: [EsTdDirective,] }],
+    EsThsDirective: [{ type: ContentChildren, args: [EsThDirective,] }],
+    EsThs: [{ type: ContentChildren, args: [forwardRef(() => EsTh),] }],
+    EsTds: [{ type: ContentChildren, args: [forwardRef(() => EsTd),] }],
+    bodyRef: [{ type: ContentChild, args: ['body', { static: false },] }],
+    headerRef: [{ type: ContentChild, args: ['header', { static: false },] }],
+    headerGroupRef: [{ type: ContentChild, args: ['headerGroup', { static: false },] }],
+    secondaryHeaderGroupRef: [{ type: ContentChild, args: ['secondaryHeaderGroup', { static: false },] }],
+    CornerMenuOptions: [{ type: Input }],
+    ColumnsResizable: [{ type: Input }],
+    AutoUpdate: [{ type: Input }],
+    UseCustomCellActions: [{ type: Input }],
+    CustomCellActionsOn: [{ type: Input }],
+    CellActionPropagates: [{ type: Input }],
+    UseCustomCells: [{ type: Input }],
+    MaxHeight: [{ type: Input }],
+    ContainerClass: [{ type: Input }],
+    XLSXExport: [{ type: Input }],
+    CSVExport: [{ type: Input }],
+    AllSearch: [{ type: Input }],
+    HighCellDensity: [{ type: Input }],
+    Selection: [{ type: Input }],
+    ShowLoadingOnBootstrap: [{ type: Input }],
+    Removal: [{ type: Input }],
+    RemovalCondition: [{ type: Input }],
+    Export: [{ type: Input }],
+    ShiftClick: [{ type: Input }],
+    CountLabel: [{ type: Input }],
+    HidePaging: [{ type: Input }],
+    HidePagingCount: [{ type: Input }],
+    HidePagingButtons: [{ type: Input }],
+    ContextMenu: [{ type: Input }],
+    ExportFileName: [{ type: Input }],
+    TableClass: [{ type: Input }],
+    ExportFunction: [{ type: Input }],
+    HasHeaderGroup: [{ type: Input }],
+    HasSecondaryHeaderGroup: [{ type: Input }],
+    SliceSize: [{ type: Input }],
+    EndlessScroll: [{ type: Input }],
+    EndlessScrollOnlyForAll: [{ type: Input }],
+    HeaderHidden: [{ type: Input }],
+    BodyHidden: [{ type: Input }],
+    SelectionDisabled: [{ type: Input }],
+    SingleSelection: [{ type: Input }],
+    RowClassAssigner: [{ type: Input }],
+    OrderByColumn: [{ type: Input }],
+    MultipleOrderingDirectives: [{ type: Input }],
+    HiddenColumns: [{ type: Input }],
+    ColumnsOrdering: [{ type: Input }],
+    SearchView: [{ type: Input }],
+    SelectAll: [{ type: Input }],
+    UseArrayModePaging: [{ type: Input }],
+    DynamicRowColumnsDefinition: [{ type: Input }],
+    DynamicOperations: [{ type: Input }],
+    Hierarchy: [{ type: Input }],
+    ParentKey: [{ type: Input }],
+    OwnKey: [{ type: Input }],
+    StartsExpanded: [{ type: Input }],
+    SavePreferences: [{ type: Input }],
+    PagingStyle: [{ type: Input }],
+    RowGroupingPagingStyle: [{ type: Input }],
+    SecondarySource: [{ type: Input }],
+    TertiarySource: [{ type: Input }],
+    UseSelectionCache: [{ type: Input }],
+    ShowItemGroupsColumns: [{ type: Input }],
+    onOrderChanged: [{ type: Output }],
+    onSearchRequest: [{ type: Output }],
+    onSelectionChanged: [{ type: Output }],
+    onRemoval: [{ type: Output }],
+    onAbortRemoval: [{ type: Output }],
+    onCellClick: [{ type: Output }],
+    onCornerAction: [{ type: Output }],
+    onDynamicOperation: [{ type: Output }],
+    exportDownloader: [{ type: ViewChild, args: ['exportDownloader', { static: false },] }],
+    tableEmptyMenu: [{ type: ViewChild, args: ['emptyMenu', { static: true },] }],
+    ArraymodeItemsPerPage: [{ type: Input }]
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"es_table.component.js","sourceRoot":"","sources":["../../../../../../projects/es-table/src/lib/components/es-table/es_table.component.ts"],"names":[],"mappings":"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","sourcesContent":["// Angular\r\nimport {\r\n    Component, forwardRef, ContentChildren, QueryList, ChangeDetectorRef, ChangeDetectionStrategy, Input,\r\n    EventEmitter, Output, ContentChild, OnChanges, SimpleChanges, ViewChild, ElementRef, ViewEncapsulation, Optional, Self, TemplateRef, Inject\r\n} from '@angular/core';\r\nimport { ControlValueAccessor, NgControl } from '@angular/forms';\r\n\r\n// Configurazioni\r\nimport { UtilityService, ExportService, MessageService, DateService } from '@esfaenza/extensions';\r\nimport { LocalizationService } from '@esfaenza/localizations';\r\nimport { PreferencesService } from '@esfaenza/preferences';\r\n\r\n// Plugins\r\nimport { ContextMenuComponent } from '@esfaenza/ngx-contextmenu';\r\n\r\n// Modelli\r\nimport {\r\n    AppSearch, AppOrdering, EsTableColumnsDefinition, CornerMenuOption, ReportDefinition, ReportResult,\r\n    EsTableOperationDefinition, EsTableColumn, GroupPager, GroupRouteFragment, ThElement\r\n} from '../../domain';\r\n\r\n// Componenti e Localizzazione\r\nimport { EsTd } from '../es-td/es_td.component';\r\nimport { EsTh } from '../es-th/es_th.component';\r\nimport { EsTdDirective } from '../../directives/es_td.directive';\r\nimport { EsThDirective } from '../../directives/es_th.directive';\r\nimport { EsTableLoc } from './es_table.component.loc';\r\nimport { ItemsSelection } from '../../domain/externals/classes/appsearch/ItemsSelection';\r\nimport { GroupOrAggregation } from \"../../domain/externals/classes/appsearch/GroupOrAggregation\";\r\nimport { GroupFilter } from \"../../domain/externals/classes/appsearch/GroupFilter\";\r\nimport { Group } from \"../../domain/externals/classes/appsearch/Group\";\r\nimport { EsTableDefaultable } from '../../domain/configuration/EsTableDefaultable';\r\n\r\nimport { EST_DEFAULTS, EST_LOCALE } from '../../tokens';\r\n\r\nimport { ExportHandler, ColumnMetadataHandler, DynamicModeHandler, HierarchyModeHandler, ItemsHandler, ReportModeHandler, RowGroupingHandler, SelectionHandler, UtilitiesHandler } from '../../core/handlers';\r\n\r\n/** Componente che permette di rappresentare una griglia di valori */\r\n@Component({\r\n    selector: 'es-table',\r\n    viewProviders: [{ provide: LocalizationService, useClass: EsTableLoc }],\r\n    changeDetection: ChangeDetectionStrategy.OnPush,\r\n    encapsulation: ViewEncapsulation.None,\r\n    styleUrls: ['./es_table.component.scss'],\r\n    templateUrl: './es_table.component.html'\r\n})\r\nexport class EsTableComponent implements ControlValueAccessor, OnChanges {\r\n\r\n    export_H: ExportHandler;\r\n    columnMetadata_H: ColumnMetadataHandler;\r\n    dynamicMode_H: DynamicModeHandler;\r\n    hierarchyMode_H: HierarchyModeHandler;\r\n    items_H: ItemsHandler;\r\n    reportMode_H: ReportModeHandler;\r\n    rowGrouping_H: RowGroupingHandler\r\n    selection_H: SelectionHandler;\r\n\r\n    /** @ignore */\r\n    constructor(\r\n        @Self() @Optional() public ngControl: NgControl, \r\n        @Optional() private prefService: PreferencesService, \r\n        @Optional() @Inject(EST_DEFAULTS) private deafults: EsTableDefaultable, \r\n        @Optional() @Inject(EST_LOCALE) public locale: string, \r\n        public lc: LocalizationService,\r\n        public cdr: ChangeDetectorRef, \r\n        private utilities_H: UtilitiesHandler, \r\n        private utiExts: UtilityService, \r\n        private expExts: ExportService, \r\n        private dateExts: DateService, \r\n        private msgExts: MessageService) {\r\n\r\n        this.export_H = new ExportHandler(this, this.expExts, this.msgExts);\r\n        this.rowGrouping_H = new RowGroupingHandler(this, this.utilities_H, this.dateExts);\r\n        this.columnMetadata_H = new ColumnMetadataHandler(this, this.utilities_H, this.utiExts, this.prefService, this.rowGrouping_H);\r\n        this.dynamicMode_H = new DynamicModeHandler(this);\r\n        this.hierarchyMode_H = new HierarchyModeHandler(this);\r\n        this.items_H = new ItemsHandler(this, this.utilities_H);\r\n        this.reportMode_H = new ReportModeHandler(this, this.utilities_H);\r\n        this.selection_H = new SelectionHandler(this, this.rowGrouping_H);\r\n\r\n        if (ngControl)\r\n            ngControl.valueAccessor = this;\r\n\r\n        // Assegnazione per tutti gli Input di default\r\n        this.ColumnsResizable = this.utilities_H.InputOrDefault(this.ColumnsResizable, this.deafults?.ColumnsResizable);\r\n        this.AutoUpdate = this.utilities_H.InputOrDefault(this.AutoUpdate, this.deafults?.AutoUpdate);\r\n        this.AllSearch = this.utilities_H.InputOrDefault(this.AllSearch, this.deafults?.AllSearch, true);\r\n        this.Export = this.utilities_H.InputOrDefault(this.Export, this.deafults?.Export);\r\n        this.HidePaging = this.utilities_H.InputOrDefault(this.HidePaging, this.deafults?.HidePaging, false);\r\n        this.HidePagingCount = this.utilities_H.InputOrDefault(this.HidePagingCount, this.deafults?.HidePagingCount);\r\n        this.HidePagingButtons = this.utilities_H.InputOrDefault(this.HidePagingButtons, this.deafults?.HidePagingButtons);\r\n        this.ContainerClass = this.utilities_H.InputOrDefault(this.ContainerClass, this.deafults?.ContainerClass, '');\r\n        this.TableClass = this.utilities_H.InputOrDefault(this.TableClass, this.deafults?.TableClass, 'table table-striped table-hover table-sm');\r\n        this.Selection = this.utilities_H.InputOrDefault(this.Selection, this.deafults?.Selection);\r\n        this.SavePreferences = this.utilities_H.InputOrDefault(this.SavePreferences, this.deafults?.SavePreferences);\r\n        this.PagingStyle = this.utilities_H.InputOrDefault(this.PagingStyle, this.deafults?.PagingStyle, 'bottom');\r\n        this.RowGroupingPagingStyle = this.utilities_H.InputOrDefault(this.RowGroupingPagingStyle, this.deafults?.RowGroupingPagingStyle, 'left');\r\n        this.UseSelectionCache = this.utilities_H.InputOrDefault(this.UseSelectionCache, this.deafults?.UseSelectionCache, true);\r\n        this.ShowItemGroupsColumns = this.utilities_H.InputOrDefault(this.ShowItemGroupsColumns, this.deafults?.ShowItemGroupsColumns, false);\r\n        this.ArraymodeItemsPerPage = this.utilities_H.InputOrDefault(this.ArraymodeItemsPerPage, this.deafults?.ArraymodeItemsPerPage, 15);\r\n    }\r\n\r\n    /** View finale su cui bindarsi lato Frontend, il tipo può essere IAppSearch<any> (per la **viewMode**), any[] (per l'**arrayMode**) e ReportDefinition per la **reportMode** */\r\n    public View: any = null;\r\n    /** Modello da cui l'es-table mostra i pulsanti di paginazione in basso a destra */\r\n    public arrayPulsanti: any;\r\n    /** Indica se l'es-table deve mostrare il check globale nell'header per fare il \"seleziona tutto\" */\r\n    public globalCheck = false;\r\n    /** Tiene da conto l'ultimo elemento selezionato in modo da poter effettuare il SHIFT+CLICK */\r\n    private lastSelected: any = null;\r\n    /** Conteggio interno per il numero di elementi selezionati */\r\n    public selectedObjects = 0;\r\n    /** Indica se è possibile effettuare una selezione massiva */\r\n    public canSelectAll = false;\r\n    /** Indica se il componente sta gestendo un IAppSearch<any> */\r\n    public viewMode = false;\r\n    /** Indica se il componente sta gestendo un any[] */\r\n    public arrayMode = false;\r\n    /** Indica se il componente sta gestendo un ReportDefinition */\r\n    public reportMode = false;\r\n\r\n    /**\r\n     * Contenitore degli elementi da listare lato interfaccia dopo tutte le elaborazioni del caso,\r\n     * generalmente non sono altro che tutti gli oggetti da presentare con in più l'hash calcolato per identificare 1 oggetto con la propria riga\r\n     */\r\n    public boundSource: any[] = [];\r\n    /** Stessa cosa della **boundSource**, utilizzata come appoggio temporaneo interno */\r\n    public TMPBoundSource: any[] = [];\r\n    /** \"Fetta\" di oggetti utilizzata nell'endless scroll, ogni elemento di questo array è un blocchetto di 100 elementi */\r\n    public boundSubSources: any[] = [];\r\n    /** Questa funge da indicatore per gli slice inseriti, la lunghezza dovrebbe essere corrispondente a **boundSubSources** */\r\n    public addedSlices: number[] = [];\r\n    /** Variabile che identifica il valore del \"seleziona Tutto\" nella paginazione */\r\n    public defaultAllPageOverride = 999999;\r\n    /** Indica se utilizzare il sistema di Endless Scroll */\r\n    public UseEndlessscroll: boolean;\r\n    /** Valori dell'eventuale report in visualizzazione */\r\n    public ReportValues: ReportResult;\r\n    /** Serve per tenere in memoria il conteggio precedente e recuperarlo in caso diventi -2 (verificare con Ale perché la logica del -2) */\r\n    public previousCount: number;\r\n    /** Indica se utilizzare il sistema di autoupdate, cioè un trigger time-izzato in alto a destra della tabella che ripete le ricerche ogni X **seconds** */\r\n    public autoUpdate = false;\r\n    /** Numero di secondi da fare trascorrere fra una ricerca e l'altra */\r\n    public seconds = '10';\r\n    /** Riferimento all'Interval che viene generato se **autoUpdate** è impostata a true in modo da poterlo ripulire */\r\n    public updateTimer: any;\r\n    /** Impostata a true ogni volta che viene avviata una ricerca, e a false ogni volta che un nuovo valore viene ricevuto */\r\n    public researchInProgress: boolean = false;\r\n    /** Modello rappresentante un singolo td della tabella, generato in base alle configurazioni e agli oggetti ricevuti */\r\n    public RowTDs: { [context: string]: EsTd[] } = null;\r\n    /** Modello di appoggio temporaneo per i **RowTDs** */\r\n    public TMPRowTDs: { [context: string]: EsTd[] } = null;\r\n    /** Modello rappresentante un singolo th della tabella, generato in base alle configurazioni e agli oggetti ricevuti */\r\n    public RowTHs: ThElement[] = null;\r\n    /** Modello di appoggio temporaneo per i **RowTHs** */\r\n    public TMPRowTHs: ThElement[] = null;\r\n    /** Modello di appoggio temporaneo per i **RowThGroups** */\r\n    public TMPRowThGroups: { Span: number, Template: TemplateRef<any> }[][] = null;\r\n    /** Modello rappresentante un singolo header group della tabella. Questa lista è già ordinata e pronta per essere utilizzata in ngFor */\r\n    public RowThGroups: { Span: number, Template: TemplateRef<any> }[][] = null;\r\n    /** Cache per i routerLink generati nelle tabelle dinamiche */\r\n    public DynamicTableRouterLinkCache: {} = {};\r\n\r\n    /**\r\n     * Lista dei contesti. Un contesto non è altro che un hash particolare calcolato su un oggetto che identifica univocamente tale oggetto.\r\n     *\r\n     * Ognuno di questi contesti rappresenterà a sua volta, univocamente, una riga all'interno della tabella\r\n     */\r\n    public RowContexts: any[] = [];\r\n    /** Direttive di ordinamento delle colonne (non ordinamento dei dati ma delle colonne in se) */\r\n    public OrderDirectives: string[] = [];\r\n    /** Codice dell'ultimo oggetto solezionato */\r\n    public lastSelectedItemID = null;\r\n\r\n    /**\r\n     * Indica se oltre alle colonne dinamiche specifiche di un tipo di oggetto ci sono anche colonne dinamiche aggiunte dall'utente\r\n     *\r\n     * Es. una colonna in cui mostrare sempre un iconcina\r\n     */\r\n    public UserDefinedDynamicCols: boolean = false;\r\n    /** Indica che questo è il primo Bind della tabella, viene settato a false non appena il primo bind viene terminato con successo */\r\n    public FirstBind: boolean = true;\r\n    /** Lista di colonne che si possono visualizzare/ordinare fra di loro */\r\n    public ColumnsList: EsTableColumn[] = [];\r\n    /** Variabile d'appoggio usata dalla dialog di selezione/nascondimento, per evitare di danneggiare **ColumnsList** in caso di modifiche poi annullate */\r\n    public TMPColumnsList: EsTableColumn[] = [];\r\n    /** Valore del check globale di visibilità valido per tutte le colonne in **ColumnsList** */\r\n    public globalColVisCheck = false;\r\n\r\n    /** Query per recuperare tutte le nuove direttive  assegnati a direttiva (Per la modalità dinamica dell'es-table) */\r\n    @ContentChildren(EsTdDirective) EsTdsDirective: QueryList<EsTdDirective>;\r\n    /** Query per recuperare tutti gli es-td assegnati a direttiva (Per la modalità dinamica dell'es-table) */\r\n    @ContentChildren(EsThDirective) EsThsDirective: QueryList<EsThDirective>;\r\n    /** @deprecated Query per recuperare tutti gli es-th */\r\n    @ContentChildren(forwardRef(() => EsTh)) private EsThs: QueryList<EsTh>;\r\n    /** @deprecated Query per recuperare tutti gli es-td */\r\n    @ContentChildren(forwardRef(() => EsTd)) private EsTds: QueryList<EsTd>;\r\n    /** @deprecated Query per recuperare le informazioni del body (punto della tabella dove vengono mostrate le righe) */\r\n    @ContentChild('body', { static: false }) public bodyRef: any;\r\n    /** @deprecated Query per recuperare le informazioni dell'header (punto della tabella dove vengono mostrate le intestazioni delle righe) */\r\n    @ContentChild('header', { static: false }) public headerRef: any;\r\n    /** Query per recuperare le informazioni sul raggruppamento degli header */\r\n    @ContentChild('headerGroup', { static: false }) public headerGroupRef: any;\r\n    /** Query per recuperare le informazioni sul raggruppamento di secondo livello degli header */\r\n    @ContentChild('secondaryHeaderGroup', { static: false }) public secondaryHeaderGroupRef: any;\r\n    /** Opzioni extra che devono apparire nel Menù contestuale in alto a destra, richiamato dai 3 pallini verticali */\r\n    @Input() CornerMenuOptions: CornerMenuOption[] = null;\r\n    /** Indica se dev'essere possibile effettuare il resize delle colonne */\r\n    @Input() ColumnsResizable: boolean = null;\r\n    /** Indica se dev'essere disponibile il sistema di aggiornamento automatico */\r\n    @Input() AutoUpdate: boolean = null;\r\n\r\n    /** Indica se la tabella (configurata con **UseCustomCells**) deve mettersi in ascolto per i click sulle celle desiderate\r\n     * \r\n     * @deprecated Utilizzare l'Input **Template** delle es-td e assegnare un template con tutti i binding che si vuole ai click\r\n     */\r\n    @Input() UseCustomCellActions: boolean = null;\r\n\r\n    /**\r\n     * Indica le celle desiderate su cui intercettare i click. Attiva solo quando **UseCustomCellActions** è true.\r\n     * Ogni cella dev'essere separata dalla successiva dal carattere del Simoleon:\r\n     *\r\n     * Es, \"MiaCella1§MiaCella2\"\r\n     * \r\n     * @deprecated Utilizzare l'Input **Template** delle es-td e assegnare un template con tutti i binding che si vuole ai click\r\n     */\r\n    @Input() CustomCellActionsOn = '';\r\n\r\n    /** \r\n     * Serve per decidere di lanciare o meno il **event.stopPropagation()** al termine della gestione dell'evento \r\n     * \r\n     * @deprecated Utilizzare l'Input **Template** delle es-td e assegnare un template con tutti i binding che si vuole ai click\r\n     */\r\n    @Input() CellActionPropagates = true;\r\n\r\n    /**\r\n     * Decide se utilizzare o meno le CustomCells. Impostandolo a **true** l'es-table diventa in grado di gestire nativamente:\r\n     *\r\n     * 1) Ordinamento e visibilità delle colonne\r\n     *\r\n     * 2) Ordinamento dei dati\r\n     *\r\n     * 3) Modalità Gerarchica\r\n     *\r\n     * ecc...\r\n     */\r\n    @Input() UseCustomCells: boolean = null;\r\n    /** Permette di impostare l'altezza massima della tabella. Se null la dimensione si adatta al numero di elementi attualmente in visualizzazione */\r\n    @Input() MaxHeight: number = null;\r\n    /** Classi da applicare al contenitore della tabella */\r\n    @Input() ContainerClass = null;\r\n    /** Permette o meno l'export in formato XLSX */\r\n    @Input() XLSXExport: boolean = null;\r\n    /** Permette o meno l'export in formato CSV */\r\n    @Input() CSVExport = true;\r\n    /** Permette di visualizzare o meno l'opzione di paginazione \"Tutti\" */\r\n    @Input() AllSearch = null;\r\n    /** Diminuisce gli spazi fra una cella e l'altra, e internamente il padding del font in modo da presentare molti più dati in un'unica pagina */\r\n    @Input() HighCellDensity: boolean = null;\r\n    /** Abilita o meno la possibilità di selezionare oggetti */\r\n    @Input() Selection: boolean = null;\r\n    /** Mostra o meno un messaggio di Loading al primo caricamento della tabella */\r\n    @Input() ShowLoadingOnBootstrap: boolean = null;\r\n    /** Se impostato a **true** aggiunge una colonna con pulsante di eliminazione per effettuare l'elimina dell'oggetto relativo */\r\n    @Input() Removal: boolean = null;\r\n\r\n    /**\r\n     * Condizione che nasconde l'icona di eliminazione inserita impostando **Removal** a true qualora la condizione non venisse rispettata\r\n     *\r\n     * Come condizione si considera un semplice campo su cui effettuare un controllo booleano, come ad esempio \"canremove\"\r\n     */\r\n    @Input() RemovalCondition = '';\r\n    /** Indica se abilitare la possibilità di esportare la vista dati attuale */\r\n    @Input() Export: boolean = null;\r\n    /** Indica se permettere la selezione multipla Windows-like cliccando un oggetto e facendo poi Shift + click su un oggetto successivo */\r\n    @Input() ShiftClick: boolean = null;\r\n    /** Indica il testo che va a sostituire \"Oggetti Visualizzati\" in caso si stia facendo qualcosa di custom */\r\n    @Input() CountLabel: string = null;\r\n    /** Indica se nascondere o mostrare il componente di paginazione */\r\n    @Input() HidePaging: boolean = null;\r\n    /** Indica se nascondere o mostrare il conteggio degli elementi trovati */\r\n    @Input() HidePagingCount: boolean = null;\r\n    /** Indica se nascondere o mostrare i pulsanti di paginazione */\r\n    @Input() HidePagingButtons: boolean = null;\r\n    /** Riferimento al ContextMenu (ngx-contextmenu) associato al click destro di uno o più elementi selezionati nella tabella */\r\n    @Input() ContextMenu: ContextMenuComponent = null;\r\n    /** Nome dell'esportazione generata da questa tabella */\r\n    @Input() ExportFileName = 'Export.csv';\r\n    /** Classe (HTML) di default della tabella */\r\n    @Input() TableClass = null;\r\n\r\n    /**\r\n     * Funzione da utilizzare in esportazione. Nel formato \"Report\" avrà un unico parametro \"Formato\" e nessun valore di ritorno.\r\n     *\r\n     * Nel formato \"View\" ha come parametro una callback con i dati completi da esportare (dato che di default la ricerca è paginata)\r\n     */\r\n    @Input() ExportFunction: any;\r\n    /** Indica la presenza di raggruppamenti a livello di header */\r\n    @Input() HasHeaderGroup: boolean = null;\r\n    /** Indica la presenza di raggruppamenti a livello del raggruppamento precedentemente esistente, chiaramente è insensata senza **HasHeaderGroup** */\r\n    @Input() HasSecondaryHeaderGroup: boolean = null;\r\n    /** Utilizzato per dividere la sorgente in modalità EndlessScroll */\r\n    @Input() SliceSize = 100;\r\n    /** Decide se utilizzare la modalità di EndlessScroll */\r\n    @Input() EndlessScroll: boolean = null;\r\n    /** Qualora **EndlessScroll** fosse true, indica se utilizzare questa modalità solo quando si cerca per \"Tutti\" o in generale */\r\n    @Input() EndlessScrollOnlyForAll = true;\r\n    /** Indica se nascondere gli Header della tabella */\r\n    @Input() HeaderHidden: boolean = null;\r\n    /** Indica se nascondere il Body della tabella */\r\n    @Input() BodyHidden: boolean = null;\r\n\r\n    /**\r\n     * Indica se la selezione è temporaneamente disabilitata. Rispetto all'Input **Selection** che visivamente gestisce se ci sono o no gli input di selezione,\r\n     * questo Input gestisce se questi input sono abilitati o meno\r\n     */\r\n    @Input() SelectionDisabled: boolean = null;\r\n\r\n    /**\r\n     * Indica se forzare il sistema di selezione a gestire un elemento per volta.\r\n     * Selezionare un'altra riga con una già selezionata applicherà la selezione alla nuova riga, rimuovendola dall'attuale\r\n     */\r\n    @Input() SingleSelection: boolean = null;\r\n    /** Callback che dato un oggetto resituisce l'eventuale classe da applicare alla riga collegata all'oggetto */\r\n    @Input() RowClassAssigner: any = null;\r\n    /** Permette di ordinare i dati in maniera discendente o ascendente */\r\n    @Input() OrderByColumn: boolean = null;\r\n    /** Permette di avere più direttive di ordinamento dei dati */\r\n    @Input() MultipleOrderingDirectives = true;\r\n    /** Permette di nascondere le colonne in base alle selezioni effettuate dal Menù contestuale in alto a destra */\r\n    @Input() HiddenColumns: boolean = null;\r\n    /** Permette di riordinare le colonne in base alle impostazioni effettuate dal Menù contestuale in alto a destra */\r\n    @Input() ColumnsOrdering: boolean = null;\r\n    /** Eventuale supporto alle ricerche applicate alla modalità Array */\r\n    @Input() SearchView = null as AppSearch<any>;\r\n    /** Abilita o disabilita il sistema che permette di selezionare tutti gli elementi nella vista */\r\n    @Input() SelectAll: boolean = null;\r\n    /** Simula la paginazione anche per le tabelle che funzionano in modalità Array */\r\n    @Input() UseArrayModePaging = true;\r\n    /** Definizione di colonne dinamche per la modalità, appunto, dinamica */\r\n    @Input() DynamicRowColumnsDefinition: EsTableColumnsDefinition[] = null;\r\n    /** Indica operazioni dinamiche generiche che possono essere effettuate per riga. Appaiono come colonne extra sul lato sinistro della tabella */\r\n    @Input() DynamicOperations: EsTableOperationDefinition[] = [];\r\n    /** Indica se visualizzare i dati in maniera gerarchica */\r\n    @Input() Hierarchy: boolean = null;\r\n    /** Nome della proprietà che contiene l'ID del padre. Da utilizzare se **Hierarchy** è impostato */\r\n    @Input() ParentKey = '';\r\n    /** Nome della proprietà che contiene l'ID dell'oggetto attuale. Da utilizzare se **Hierarchy** è impostato */\r\n    @Input() OwnKey = '';\r\n    /** Indica se partire con un albero espanso. Da utilizzare se **Hierarchy** è impostato */\r\n    @Input() StartsExpanded = true;\r\n    /** Indica se effettuare il salvataggio delle preferenze di ricerca */\r\n    @Input() SavePreferences: boolean = null;\r\n\r\n    /** Indica dove visualizzare le informazioni di paginazione, se sopra, sotto o in entrambi */\r\n    @Input() PagingStyle: 'both' | 'top' | 'bottom' = null;\r\n    /** Indica dove visualizzare le informazioni di paginazione, se sopra, sotto o in entrambi */\r\n    @Input() RowGroupingPagingStyle: 'left' | 'right' = null;\r\n\r\n    /**\r\n     * Sorgente dati secondaria\r\n     *\r\n     * @deprecated Utilizzato solo per un caso particolare del Metering\r\n     */\r\n    @Input() SecondarySource: boolean = null;\r\n\r\n    /**\r\n     * Sorgente dati secondaria\r\n     *\r\n     * @deprecated Utilizzato solo per un caso particolare del Metering\r\n     */\r\n    @Input() TertiarySource: boolean = null;\r\n    /** Indica se utilizzare la cache di selezione che permette di mantenere gli stati di selezione dei vari oggetti navigando da una pagina all'altra */\r\n    @Input() UseSelectionCache = null;\r\n    /** Permette di decidere se, in modalità raggruppamento, mostrare o meno il valore delle colonne di gruppo negli oggetti finali. Di default sono nascosti */\r\n    @Input() ShowItemGroupsColumns = null;\r\n    /** Evento che viene richiamato al cambio di oridnamento di una colonna */\r\n    @Output() onOrderChanged: EventEmitter<AppOrdering> = new EventEmitter<AppOrdering>();\r\n\r\n    /**\r\n     * Evento che viene richiamato quando l'es-table ritiene sia necessario ri-effettuare la ricerca.\r\n     * Il booleano dell'evento indica se viene suggerito di resettare la pagina o meno.\r\n     * \r\n     * Solo in caso venga utilizzata la modalità a raggruppamenti di righe può succedere che l'es-table passi un intero AppSearch come parametro di ricerca,\r\n     * in quel caso l'applicazione ricevente dovrà onorare la richiesta spedendo al backand l'oggetto di ricerca AS-IS\r\n     * \r\n     * il tipo dell'Emitter invece di essere [boolean | AppSearch<any>] è stato impostato a \"any\" per evitare problemi di retrocompatibilità\r\n     */\r\n    @Output() onSearchRequest: EventEmitter<any> = new EventEmitter<any>();\r\n    /** Evento che parte ad ogni modifica di \"checkaggio\" in forma di comodo array. Espone l'oggetto con lo stato di check attuale */\r\n    @Output() onSelectionChanged: EventEmitter<ItemsSelection<any>> = new EventEmitter<ItemsSelection<any>>();\r\n    /** Evento richiamato all'eliminazione di un oggetto */\r\n    @Output() onRemoval: EventEmitter<any> = new EventEmitter<any>();\r\n    /** Evento richiamato all'annullamento di un'eliminazione */\r\n    @Output() onAbortRemoval: EventEmitter<any> = new EventEmitter<any>();\r\n\r\n    /** Evento richiamato al click su una cella quando **UseCustomCellActions** è attivo \r\n     * \r\n     * @deprecated Utilizzare l'Input **Template** delle es-td e assegnare un template con tutti i binding che si vuole ai click\r\n     */\r\n    @Output() onCellClick: EventEmitter<{ column: string, model: any }> = new EventEmitter<{ column: string, model: any }>();\r\n    /** Evento richiamato quando si clicca su un opzione definita nelle **CornerMenuOptions** */\r\n    @Output() onCornerAction: EventEmitter<{ id: string, estable: any }> = new EventEmitter<{ id: string, estable: any }>();\r\n    /** Evento richiamato quando si clicca su un opzione definita nelle **DynamicOperations** */\r\n    @Output() onDynamicOperation: EventEmitter<{ id: string, item: any }> = new EventEmitter<{ id: string, item: any }>();\r\n\r\n    /** Dati esportati da ngx-csv */\r\n    public data: any[];\r\n    /** Header dei dati esportati da ngx-csv */\r\n    public headers: any[];\r\n    /** Elemento HTML da cliccare per l'esportazione */\r\n    @ViewChild('exportDownloader', { static: false }) public exportDownloader: ElementRef;\r\n    /** Placeholder di menù contestuale per quando non ci sono opzioni nel placeholder \"Vero\"  */\r\n    @ViewChild('emptyMenu', { static: true }) public tableEmptyMenu: ContextMenuComponent;\r\n\r\n    /** Subscription sull'apertura del context menu da ripulire al destroy della classe */\r\n    private ctxMenuSubscription: any;\r\n\r\n    /** Pagina in visualizzazione (durante la paginazione in modalità Array) */\r\n    public arraymodePage = 1;\r\n    /** Numero di pagine (durante la paginazione in modalità Array) */\r\n    public arraymodePages = 1;\r\n    /** Oggetti per ogni pagina (durante la paginazione in modalità Array) */\r\n    @Input() ArraymodeItemsPerPage = null;\r\n    /** Oggetto di selezione per la modalità Array, che deve comportarsi come la controparte in modalità View */\r\n    public arraymodeSelection: ItemsSelection<any>;\r\n    /** Colonne da visualizzare in modalità array */\r\n    public arrayColumns: string[] = [];\r\n    /** Ordine delle colonne da visualizzare in modalità array */\r\n    public arrayColumnOrdering: string[] = [];\r\n    /** Ordinamenti ASC-DESC sulle colonne in modalità array */\r\n    public arrayOrders: AppOrdering[] = [];\r\n\r\n    /**\r\n     * Variabile che serve a gestire il momento in cui l'es-table aggiorna la paginazione (pulsanti ecc).\r\n     * Essendo operazioni comunque costose le effettuo solo su binding esterni, non su rewrite generati internamente\r\n     */\r\n    private internalWriteCall = false;\r\n\r\n    /**\r\n     * Cache che conterrà tutte le ricerche effettuate su gruppi diversi dal primo e su elementi contenuti nei gruppi.\r\n     * In caso di cambi di ordinamento delle colonne diverse dalla prima tutte le chiamate fatte dal secondo livello in poi devono essere rieseguite secondo la seguente logica:\r\n     * \r\n     * \r\n     * **Cambio ordinamento sul primo gruppo**: reload completo, non mi occupo di ripulire gli elementi bindati in alcun modo\r\n     * \r\n     * **Cambio ordinamento sulla colonna relativa all'N-esimo gruppo**: reload completo del contenuto dei gruppi precedenti, ripulendo precedentemente \r\n     * tutti gli elementi con **_grouplevel** = N\r\n     * \r\n     * **Cambio ordinamento su una colonna non raggruppata**: reload completo per tutti i gruppi finali aperti, devo precedentemente ripulire tutti gli elementi con **_item** = true\r\n     * \r\n     * Altri eventi non dovrebbero rappresentare problemi:\r\n     * - Selezione: non cambia nulla\r\n     * - Paginazione: cambia a livello root quindi viene ricaricato tutto comunque, stesso vale per le paginazioni interne\r\n     */\r\n    public groupSearchRequestsCache: { path: string, route: GroupRouteFragment[], view: AppSearch<any>, group_column: string }[] = [];\r\n\r\n    /** Variabile d'appoggio per capire se c'è bisogno di ri-effettuare una ricerca o meno */\r\n    private ResearchNeeded: boolean = false;\r\n    /** Colonne visibili della vista attuale. Valorizzato di default al numero massimo di colonne supportate dalla tabella per le casistiche in assenza di custom cells */\r\n    public Columns: { Visibile: number, VisibleUnpinned: number, Global: number } = { Visibile: 100, VisibleUnpinned: 100, Global: 100 };\r\n    /** In caso di Row Grouping qui viene salvata la vista principale dei gruppi base */\r\n    public MainGroupView: AppSearch<any> = null;\r\n   \r\n    /** Conteggio base degli oggetti. In modalità normale viene resettato ad ogni nuova View inserita, in modalità RowGrouping viene resettato solo ad una nuova View di livello \"0\" */\r\n    public BaseItemsCount = null;\r\n\r\n    /** Indica se ci sono delle colonne pinnate e visibili. Serve per poter settare tutte le colonne prima che arrivino dati a pinned*/\r\n    public HasPinnedColumns: boolean\r\n    /** Larghezza calcolata del container delle colonne pinnate */\r\n    public PinnedContainerWidth: number;\r\n    /** Indica se nonostante siamo in modalità array sono stati individuati dei gruppi. In tal caso es-table si comporta da pseudo backend ed effettua le aggregazioni e raggruppamenti completamente lato client */\r\n    public ArrayGrouping: boolean = false;\r\n    /** Indica che l'es-table è basata sulle direttive (nuova modalità) */\r\n    public DirectivesBased: boolean = false;\r\n\r\n    /** Opzioni di paginazione */\r\n    public PagerOptions: { PagerCount: number, ShowCount: boolean, ShowPaging: boolean, UsesView: boolean, ShowButtons: boolean, ShowPagingOptions: boolean, View: any, Ready: boolean, Searches: 'items' | 'groups' } =\r\n        { PagerCount: null, ShowCount: true, ShowPaging: true, ShowButtons: true, ShowPagingOptions: true, UsesView: true, View: null, Ready: false, Searches: 'items' };\r\n\r\n    /** @ignore */\r\n    public ngOnInit() {\r\n        //Per poter cambiare il layout in base al livello gerarchico il componente deva avere il pieno controllo di ogni cella,\r\n        //che con solo la proiezione (senza celle cusotm) non è disponibile\r\n        if (this.Hierarchy && !this.UseCustomCells)\r\n            throw \"Es-table error: Per poter utilizzare l'es-table con [Hierarchy]=\\\"true\\\" è richiesto anche [UseCustomCells]=\\\"true\\\"\";\r\n\r\n        // click destro su una riga con selezione attiva: Tiro fuori il context menu e selezione l'elemento corrente\r\n        this.ctxMenuSubscription = (this.ContextMenu || this.tableEmptyMenu).open.subscribe(t => {\r\n            // Gruppi va bene, oggetti pure, ma separatori fra gruppi proprio no...\r\n            if (t.item._sep) return;\r\n\r\n            let shouldEmit = !t.item._selected;\r\n\r\n            t.item._selected = true;\r\n            var itemSelection = this.selection_H.handleItemsSelection([t.item]);\r\n            this.changed();\r\n\r\n            if (shouldEmit)\r\n                this.onSelectionChanged.emit(itemSelection);\r\n        });\r\n    }\r\n\r\n    /** @ignore */\r\n    public ngAfterViewInit() {\r\n        // Se utilizzo la new spicy mode deduco tutti i parametri di lavoro possibili al caricamento della tabella\r\n        // Vengono sovrascritte solo le proprietà non impostate dall'utente\r\n        if (this.EsTdsDirective && this.EsTdsDirective.length > 0 && this.EsThsDirective && this.EsThsDirective.length > 0) {\r\n            if (this.UseCustomCells == null) this.UseCustomCells = true;\r\n            if (this.HiddenColumns == null && this.UseCustomCells) this.HiddenColumns = true;\r\n            if (this.ColumnsOrdering == null && this.UseCustomCells) this.ColumnsOrdering = true;\r\n            if (this.OrderByColumn == null && this.UseCustomCells) this.OrderByColumn = true;\r\n            if (this.SelectAll == null && this.Selection) this.SelectAll = true;\r\n            if (this.ShiftClick == null && this.Selection) this.ShiftClick = true;\r\n            this.DirectivesBased = true;\r\n        }\r\n    }\r\n\r\n    /** @ignore */\r\n    public ngOnDestroy() {\r\n        if (this.ctxMenuSubscription)\r\n            this.ctxMenuSubscription.unsubscribe();\r\n    }\r\n\r\n     /** @ignore */\r\n     public async ngOnChanges(changes: SimpleChanges) {\r\n        let newSearchView = changes['SearchView'];\r\n        if (newSearchView && this.SearchView)\r\n            this.arrayPulsanti = this.utilities_H.getPagesArray(6, this.SearchView.page, this.SearchView.pages || 1, this.SearchView.items.length, this.SearchView.itemsperpageoverride);\r\n    }\r\n\r\n    /** @ignore */\r\n    public registerOnChange(fn): void { this.propagateChange = fn; }\r\n    /** @ignore */\r\n    public registerOnTouched(fn): void { }\r\n    /** @ignore */\r\n    changed() { this.propagateChange(this.View); }\r\n    /** @ignore */\r\n    propagateChange = (_: any) => { };\r\n\r\n    /** @ignore */\r\n    public writeValue(obj): void {\r\n        this.View = obj ? obj : null;\r\n\r\n        // Mi è arrivata l'AppSearch quindi di sicuro non ho una ricerca in progress\r\n        this.researchInProgress = false;\r\n\r\n        if (!this.View && !this.SearchView) {\r\n            // Su view nulla evito di fare pressoché qualsiasi cosa. Se arriva un null devo anche assicurarmi di non mostrare nulla\r\n            this.boundSource = this.TMPBoundSource || [];\r\n\r\n            // Per essere sicuro che dopo un bind di oggetti la es-table aggiorni la grafica\r\n            this.cdr.markForCheck();\r\n            return;\r\n        }\r\n\r\n        // Se per sbaglio l'oggetto che mi arriva non è tipizzato (instanceof AppSearch restituisce false anche se è del tipo giusto)\r\n        // lo correggo--------------------------------------------------------------------------------------------------------------\r\n        if (this.View && typeof (this.View as any).result != 'undefined' && !(this.View instanceof ReportDefinition)) \r\n            (this.View as any).__proto__ = new ReportDefinition();\r\n        else if (this.View && typeof (this.View as any).itemsperpageoverride != 'undefined' && !(this.View instanceof AppSearch)) \r\n            (this.View as any).__proto__ = new AppSearch();\r\n        else if (this.SearchView && typeof (this.SearchView as any).itemsperpageoverride != 'undefined' && !(this.SearchView instanceof AppSearch)) \r\n            (this.SearchView as any).__proto__ = new AppSearch();\r\n        // -------------------------------------------------------------------------------------------------------------------------\r\n\r\n        if (this.View && this.View instanceof ReportDefinition) {\r\n            // Se mi arriva una report definition vuol dire che potrei avere dei risultati da visualizzare\r\n            this.setMode('report');\r\n\r\n            this.ReportValues = this.View.result;\r\n            if (this.ReportValues)\r\n                this.reportMode_H.reviewReportBindings();\r\n        }\r\n        else if (this.View && this.View instanceof AppSearch) {\r\n            // Se cambia l'oggetto intero significa che ho rimandato la ricerca\r\n            this.setMode('view');\r\n\r\n            let firstItemGroupOrNoGrouping = (this.View.requestedgroups?.length || 0) == 0;\r\n\r\n            // Se vengo da una ricerca interna mantengo lo stato di selezione precedente (quindi su cambio pagina, cambio ipp, ecc...)\r\n            // se invece l'utente ha fatto una ricerca lui (quindi cambiando filtri), secco le info di selezione\r\n            if (!this.View.selection || (!this.View.internalsearchrequest && firstItemGroupOrNoGrouping) || !this.UseSelectionCache) {\r\n                this.selection_H.clearSelectionCaches();\r\n                this.View.selection = new ItemsSelection([]);\r\n                this.onSelectionChanged.emit(this.View.selection);\r\n            }\r\n\r\n            this.View.internalsearchrequest = false;\r\n\r\n            // Recupero Preference\r\n            if (this.SavePreferences) {\r\n                if (!this.ngControl.name)\r\n                    console.error(\"Non posso utilizzare le preference senza avere un 'name' per questa tabella\");\r\n                else if (!this.prefService)\r\n                    console.error(\"Non posso utilizzare le preference senza che il pacchetto @esfaenza/preferences sia installato\");\r\n                else {\r\n                    this.prefService.retrieve<{ columns: string[], column_ordering: string[] }>(<string>this.ngControl.name).subscribe(prefs => {\r\n                        if (prefs) {\r\n                            this.View.columns = prefs.columns;\r\n                            this.View.column_ordering = prefs.column_ordering;\r\n                        }\r\n                    });\r\n                }\r\n            }\r\n\r\n            // La paginazione devo farla solamente quando richiedo o un gruppo principale (se sono in row grouping) o se non richiedo gruppi (in tutti lgi altri casi)\r\n            if (firstItemGroupOrNoGrouping)\r\n                this.arrayPulsanti = this.utilities_H.getPagesArray(6, this.View.page, this.View.pages || 1, this.View.items.length, this.View.itemsperpageoverride);\r\n        }\r\n        else if (this.View && (this.View.length != null && this.View.length != undefined)) {\r\n            this.setMode('array');\r\n\r\n            if (!this.UseSelectionCache || !this.arraymodeSelection) {\r\n                this.selection_H.clearSelectionCaches();\r\n                this.arraymodeSelection = new ItemsSelection([]);\r\n                this.onSelectionChanged.emit(this.arraymodeSelection);\r\n            }\r\n\r\n            // Recupero Preference\r\n            if (this.SavePreferences) {\r\n                if (!this.ngControl.name)\r\n                    console.error(\"Non posso utilizzare le preference senza avere un 'name' per questa tabella\");\r\n                else if (!this.prefService)\r\n                    console.error(\"Non posso utilizzare le preference senza che il pacchetto @esfaenza/preferences sia installato\");\r\n                else {\r\n                    this.prefService.retrieve<{ columns: string[], column_ordering: string[] }>(<string>this.ngControl.name).subscribe(prefs => {\r\n                        if (prefs) {\r\n                            this.arrayColumns = prefs.columns;\r\n                            this.arrayColumnOrdering = prefs.column_ordering;\r\n                        }\r\n                    });\r\n                }\r\n            }\r\n\r\n            if (this.SearchView)\r\n                this.arrayPulsanti = this.utilities_H.getPagesArray(6, this.SearchView.page, this.SearchView.pages || 1, this.SearchView.items.length, this.SearchView.itemsperpageoverride);\r\n        }\r\n\r\n        if (this.View && !(this.View instanceof ReportDefinition))\r\n            this.finalizeContext();\r\n\r\n        this.postBoundSourceCalculation();\r\n    }\r\n\r\n    /** Funzione di trackby per il body che dovrebbe evitare il 90% delle change detection */\r\n    public bodyTrackBy = (index: number, item: any) => item._hash;\r\n\r\n    /**\r\n     * Successivamente al bind del nuovo input questa funzione si occupa di finalizzare tutti i parametri di funzionamento dell'es-table \r\n     * in base a Input - Modello, e qualsiasi altra cosa possa servire\r\n     */\r\n    private finalizeContext() {\r\n        let viewCasted = this.View as AppSearch<any>;\r\n\r\n        /*\r\n         *Uso la tecnica di EndlessScroll se la variabile relativa è attiva e se\r\n         * 1) Ho un Array, oppure\r\n         * 2) Ho un AppSearch che sta cercando con paginazione \"Tutto\", oppure\r\n         * 3) Ho un AppSearch che sta cercando con paginazione diversa da \"Tutto\" ma con la variabile EndlessScrollOnlyForAll a false\r\n         */\r\n        let isAppSearchWithIppMax = this.viewMode && viewCasted.itemsperpageoverride == this.defaultAllPageOverride;\r\n        let isAppSearchNoMaxIpp = this.viewMode && viewCasted.itemsperpageoverride != this.defaultAllPageOverride;\r\n        this.UseEndlessscroll = this.EndlessScroll && (this.arrayMode || isAppSearchWithIppMax || (isAppSearchNoMaxIpp && !this.EndlessScrollOnlyForAll));\r\n\r\n        let hasRowGroups = (viewCasted.groupings && viewCasted.groupings.filter(t => !t.aggregation).length > 0) || (this.arrayMode && this.EsThsDirective.some(t => t.thGroup));\r\n\r\n        // Se ho dei gruppi in modalità array devo sistemare un po' di variabili che diventano insensate\r\n        if (this.arrayMode && hasRowGroups)\r\n            this.UseArrayModePaging = false;\r\n\r\n        // Riempimento della TMPBoundSource con gli oggetti che verranno poi mostrati ad interfaccia\r\n        if (this.UseEndlessscroll && !hasRowGroups) {\r\n            this.addedSlices = [];\r\n            this.boundSubSources = this.items_H.getItemSlices();\r\n            let firstSub = this.boundSubSources[0];\r\n\r\n            this.TMPBoundSource = firstSub ? firstSub : [];\r\n            if (firstSub)\r\n                this.addedSlices.push(0);\r\n        }\r\n        else\r\n            this.TMPBoundSource = this.items_H.getItemsByMode(false, !this.internalWriteCall);\r\n\r\n        // Se ho una gerarchia, assegno i livelli gerarchici alla TMPBoundSource\r\n        if (this.Hierarchy && !hasRowGroups)\r\n            this.hierarchyMode_H.assignHierarchyLevels(this.TMPBoundSource);\r\n\r\n        // L'hashing degli oggetti lo faccio a prescindere\r\n        this.utilities_H.calculateHash(this.TMPBoundSource);\r\n\r\n        // Assegno a una variabile mia l'eventuale override per la classe della riga\r\n        // Se poi sono in modalità gerarchica inietto anche la classe per la configurazione del livello della riga\r\n        if ((this.TMPBoundSource && this.RowClassAssigner) || this.Hierarchy) {\r\n            for (let i = 0; i < this.TMPBoundSource.length; i++) {\r\n                let item = this.TMPBoundSource[i];\r\n                item._rowClass = this.RowClassAssigner ? this.RowClassAssigner(item) : \"\";\r\n                item._rowClass += this.Hierarchy ? \" est-row-lvl-\" + item._level : \"\";\r\n            }\r\n        }\r\n    }\r\n\r\n    /** Genera le informzioni di paginazione per la vista globale dell'es-table */\r\n    private setupPagingInformations() {\r\n\r\n        // Default che valgono di base, poi eventualmente moddati dalle funzioni sotto\r\n        this.PagerOptions.ShowCount = !this.HidePagingCount;\r\n        this.PagerOptions.ShowButtons = !this.HidePagingButtons;\r\n        this.PagerOptions.ShowPaging = !this.HidePaging\r\n        this.PagerOptions.UsesView = true;\r\n\r\n        if (this.arrayMode && this.UseArrayModePaging && !this.SearchView) {\r\n            this.PagerOptions.PagerCount = (<any[]>this.View).length || 0;\r\n            this.PagerOptions.ShowButtons = this.PagerOptions.ShowButtons && this.View.length > 10;\r\n            this.PagerOptions.View = this.View;\r\n            this.PagerOptions.UsesView = false;\r\n            this.PagerOptions.ShowPagingOptions = this.PagerOptions.ShowButtons;\r\n        }\r\n        else if (this.arrayMode && (!this.UseArrayModePaging || this.SearchView)) {\r\n            if (this.SearchView) {\r\n                this.PagerOptions.View = this.SearchView\r\n                this.PagerOptions.PagerCount = this.SearchView.objectcount || 0;\r\n            }\r\n            else\r\n                this.PagerOptions.PagerCount = (<any[]>this.View).length || 0\r\n\r\n            this.PagerOptions.ShowButtons = this.PagerOptions.ShowButtons && (this.View.length > 10 || (this.SearchView?.objectcount || 0) > 10);\r\n            this.PagerOptions.ShowCount = this.PagerOptions.ShowCount || (this.View && this.View.length) || (this.SearchView && this.SearchView.objectcount && this.SearchView.objectcount != -1);\r\n            this.PagerOptions.ShowPaging = this.PagerOptions.ShowButtons || this.PagerOptions.ShowCount;\r\n            this.PagerOptions.ShowPagingOptions = this.PagerOptions.ShowButtons;\r\n        }\r\n        else if (this.viewMode) {\r\n            let tmpView = this.MainGroupView || this.View;\r\n            let count = tmpView?.groupcount || tmpView?.objectcount;\r\n            this.PagerOptions.Searches = tmpView?.groupcount != null && tmpView?.groupcount != undefined ? 'groups' : 'items';\r\n            this.PagerOptions.PagerCount = count || 0;\r\n            this.PagerOptions.View = tmpView;\r\n            this.PagerOptions.ShowCount = this.PagerOptions.ShowCount || (tmpView && count && count != -1);\r\n        }\r\n        else if (this.reportMode) {\r\n            let rvc = this.ReportValues.count;\r\n            this.PagerOptions.View = this.View;\r\n            this.PagerOptions.PagerCount = rvc && rvc == -1 ? this.ReportValues.rows.length : rvc && rvc > 0 ? this.ReportValues.count : 0;\r\n            this.PagerOptions.ShowCount = this.PagerOptions.ShowCount || (this.View && (<ReportDefinition>this.View).result.count != -1);\r\n            this.PagerOptions.ShowButtons = this.PagerOptions.ShowButtons && (this.View.pagingavailable || this.PagerOptions.ShowCount);\r\n            this.PagerOptions.ShowPagingOptions = this.PagerOptions.ShowButtons;\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Metodo che gestisce l'endless scroll e in base a quanto la tabella è stata scrollata aggiunge degli elementi extra a **TMPBoundSource**\r\n     *\r\n     * @param {any} e Evento di scroll del browser\r\n     */\r\n    public onScroll(e: any) {\r\n        let tableViewHeight = e.target.offsetHeight;\r\n        let tableScrollHeight = e.target.scrollHeight;\r\n        let scrollLocation = e.target.scrollTop;\r\n        let buffer = 200;\r\n\r\n        let limit = tableScrollHeight - tableViewHeight - buffer;\r\n        if (scrollLocation > limit) {\r\n            let indexToAdd = Math.floor(this.TMPBoundSource.length / 100);\r\n            if (this.boundSubSources[indexToAdd] && this.addedSlices.indexOf(indexToAdd) == -1) {\r\n                // Devo ricordarmi di fare l'hash del nuovo pezzo\r\n                this.utilities_H.calculateHash(this.boundSubSources[indexToAdd]);\r\n                this.TMPBoundSource = this.TMPBoundSource.concat(this.boundSubSources[indexToAdd]);\r\n                this.addedSlices.push(indexToAdd);\r\n\r\n                setTimeout(() => { this.postBoundSourceCalculation(); });\r\n            }\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Metodo lanciato dopo che la sorgente dati è stata correttamente bindata, si occupa di ricalcolare tutto ciò che serve\r\n     * all'es-table per renderizzare i valori da mostrare\r\n     */\r\n    private postBoundSourceCalculation() {\r\n        // Resetto tutto tranne RowTDs e RowTHs per evitare flickering. RowTDs e RowTHs saranno modificate all'interno del prossimo ciclo di CD\r\n        this.RowContexts = [];\r\n        this.OrderDirectives = [];\r\n        this.lastSelectedItemID = null;\r\n\r\n        if (this.EsThsDirective && this.EsThsDirective.length > 0 && this.EsTdsDirective && this.EsTdsDirective.length > 0)\r\n            this.internalPostBoundSource();\r\n        else {\r\n            this.cdr.detectChanges();\r\n            setTimeout(() => { this.internalPostBoundSource(); });\r\n        }\r\n    }\r\n\r\n    /** Per poter distinguere le chiamate a questo metodo: Dopo il setTimeout se uso gli EsTd/EsTh vecchi, senza il setTimeout se uso le nuove direttive */\r\n    private internalPostBoundSource() {\r\n        let View = this.View;\r\n        let ths = this.EsThs && this.EsThs.length > 0 ? this.EsThs.toArray() : this.EsThsDirective && this.EsThsDirective.length > 0 ? this.EsThsDirective.toArray() : [];\r\n        let tds = this.EsTds && this.EsTds.length > 0 ? this.EsTds.toArray() : this.EsTdsDirective && this.EsTdsDirective.length > 0 ? this.EsTdsDirective.toArray() : [];\r\n\r\n        // Se non ho colonne dinamiche ma sono in modalità dinamica (lo capisco perché c'è una view piena di genericitem) metto il default delle colonne\r\n        this.dynamicMode_H.eventuallyReviewDynamicColumns();\r\n        this.bindDisplayToLoadedItemsOrGroups(View);\r\n\r\n        // Questo dev'essere per forza lanciato dopo **bindDisplayToLoadedItemsOrGroups** dato che è lì che alcune cose vengono valorizzate\r\n        this.setupPagingInformations();\r\n\r\n        // Molte cose sono ovviamente disponibili solo in modalità View\r\n        if ((this.viewMode || this.arrayMode) && this.UseCustomCells) {\r\n            let view = this.viewMode ? View as AppSearch<any> : null;\r\n            let itemsAndGroups = this.viewMode ? [...(view.items || []), ...(view.groups || [])] : View as any[];\r\n            let si = this.viewMode ? view.selection : this.arraymodeSelection;\r\n            // N.B: Rispettare l'ordine di queste 3 macrocategorie è VITALE\r\n\r\n            // *************************************        Sistemazioni di TH, TD, e visibilità varie      *************************************\r\n\r\n            // Prepassaggio per tirare fuori tutte le info utili sugli headers in modo da non ricacolarseli sempre dopo\r\n            let hI = this.columnMetadata_H.evaluateHeadersGroupingInfos(ths);        \r\n\r\n            if (this.arrayMode) {                                       // In modalità array non ho un backend...\r\n                this.items_H.arrayModeReviewOrderings()                 // ... quindi gli ordinamenti li devo fare lato client, e ...\r\n                this.rowGrouping_H.arrayModeReviewGroupings(hI.leafs);  // ... i raggruppamenti li devo fare lato client\r\n            }\r\n\r\n            this.columnMetadata_H.reviewColumnsList(hI.leafs);                       // Aggiorna la lista delle colonne da mostrare nella dialog per ordinamento ecc\r\n            this.columnMetadata_H.alignColumnsIfLoadedView(view);                    // Se sto caricando una View da hotpotato (quindi con savedstate = true) riallineo la visibilità delle colonne e il loro ordine.\r\n            this.columnMetadata_H.moveFixedColumnsAtTheBeginning(hI.leafs, tds);     // Sposto tutte le cose fixed all'inizio in modo che la creazione di th e td sia più snella (Utilizza le ColumnsList, quindi dev'essere richiamata PIRMA di reviewColumnsList)\r\n            this.columnMetadata_H.alignHeadersOrdering(hI.leafs, view);              // Allineo gli ordinamenti agli header\r\n            this.columnMetadata_H.refreshColumnsVisibility(hI.leafs, tds, view);     // Lavoro sui TH ed eventualmente modifico la visibilità anche dei TD.\r\n            this.columnMetadata_H.evaluatePinnedColumnsWidth();                      // Se sono presenti colonne pinnate valuta la dimensione del contenitore\r\n            this.columnMetadata_H.generateDefaultOrder(hI.leafs, view);              // Genero le direttive di ordinamento, che siano default o derivanti dalla AppSearch\r\n            this.columnMetadata_H.evaluateHeaderGroups(hI);                          // Valuto i raggruppamenti degli header se presenti\r\n\r\n            // *************************************        Generazione binding per righe e colonne         *************************************\r\n\r\n            this.evaluateRowThs(hI.leafs);                              // Raccolgo i TH\r\n            this.evaluateRowTds(hI.leafs, tds);                         // Raccolgo i TD in contesti separati, un contesto per ogni item o gruppo\r\n\r\n            // *************************************        Ultimi aggiustmaenti dei binding                *************************************\r\n\r\n            this.columnMetadata_H.applyOrdering(view, true);            // Applico l'ordinamento sulle colonne (non ASC DESC, ma \"prima questa o quella colonna\")\r\n            this.MoveTemporaryVariablesToRealOnes();                    // Collego TH e TD aggiustati fino ad ora alle variabili di Binding HTML\r\n            this.selection_H.evaluateSelection(itemsAndGroups, si);     // Riallineo le info di selezione degli elementi della View\r\n\r\n            if (this.ResearchNeeded) {\r\n                this.changed();\r\n                this.emitSearchRequest(false);\r\n                this.ResearchNeeded = false;\r\n            }\r\n        }\r\n        else if ((this.viewMode || this.arrayMode) && !this.UseCustomCells) {\r\n            // Riallineo le info di selezione degli elementi della View\r\n            let items = this.viewMode ? (View as AppSearch<any>).items : View as any[];\r\n            let si = this.viewMode ? (View as AppSearch<any>).selection : this.arraymodeSelection;\r\n            this.selection_H.evaluateSelection(items, si);\r\n        }\r\n\r\n        // Per essere sicuro che dopo un bind di oggetti la es-table aggiorni la grafica\r\n        this.cdr.markForCheck();\r\n        this.FirstBind = false;\r\n    }\r\n\r\n    /**\r\n     * Effettua il binding degli oggetti pervenuti da questa chiamata con gli oggetti effettivamente da graficare\r\n     * \r\n     * @param {any} view View da cui sono arrivati gli oggetti. Può essere o un array se sono in **arrayMode** o una AppSearch<T> se sono in **viewMode**\r\n     */\r\n    private bindDisplayToLoadedItemsOrGroups(view: any) {\r\n        if (this.TMPBoundSource.length == 0) {\r\n            this.BaseItemsCount = 0;\r\n            this.boundSource = this.TMPBoundSource;\r\n            return;\r\n        }\r\n\r\n        if (this.arrayMode || !this.UseCustomCells) {\r\n            this.boundSource = this.TMPBoundSource;\r\n            this.BaseItemsCount = view?.objectcount || view.length;\r\n            return;\r\n        }\r\n\r\n        let groupingKeys = view.groupings?.filter(t => !t.aggregation)?.length || 0;\r\n        if (groupingKeys == 0) {\r\n            this.boundSource = this.TMPBoundSource;\r\n            this.BaseItemsCount = view.objectcount;\r\n            return;\r\n        }\r\n\r\n        this.rowGrouping_H.handleNewDataOnRowGrouping(view, groupingKeys);\r\n    }\r\n\r\n    /** Metodo richiamato solo quando **TMPRowTDs** e **TMPRowTHs** sono completamente generati ed aggiustati. Serve per collegarli alle variabili usate lato binding HTML */\r\n    private MoveTemporaryVariablesToRealOnes() {\r\n        this.RowTDs = this.TMPRowTDs;\r\n        this.RowTHs = this.TMPRowTHs;\r\n        this.RowThGroups = this.TMPRowThGroups ? this.TMPRowThGroups.reverse() : null;\r\n\r\n        this.Columns.Visibile = this.RowTHs.filter(t => t.Visible).length;\r\n        this.Columns.VisibleUnpinned = this.RowTHs.filter(t => t.Visible && !t.Pinned).length;\r\n        this.Columns.Global = this.Columns.VisibleUnpinned + (this.HasPinnedColumns ? 1 : 0) + (this.Selection ? 1 : 0) + (this.Removal ? 1 : 0) + (this.Export || this.HiddenColumns || this.ColumnsOrdering || this.CornerMenuOptions ? 1 : 0)\r\n    }\r\n\r\n    /**\r\n     * Permette di selezionare o deselezionare in maniera arbitraria degli oggetti\r\n     * \r\n     * @param {any[]} items Oggetti da selezionare o deselezionare\r\n     * @param {boolean} select **true** per selezionarli, **false** per non toccarli\r\n     */\r\n    public setSelectionStatus(items: any[], select: boolean) {\r\n        this.selection_H.handleItemsSelection(items, select);\r\n        this.cdr.markForCheck();\r\n    }\r\n\r\n    /**\r\n     * Metodo che gestisce il cambio di Ordinamento di una colonna\r\n     *\r\n     * @param {string} id ID della colonna il cui oridnamento è cambiato\r\n     * @param {'DESC' | 'ASC'} order Nuovo ordine selezionato per la colonna\r\n     */\r\n    public thOrderChanged(id: string, order?: 'DESC' | 'ASC') {\r\n        if (!this.viewMode && !this.arrayMode) {\r\n            console.warn('Order changed on a table not in viewMode or Array mode. Operation not supported');\r\n            return;\r\n        }\r\n\r\n        if (!this.OrderByColumn)\r\n            return;\r\n\r\n        this.columnMetadata_H.handleTHOrderChange(id, order);\r\n    }\r\n\r\n    /**\r\n     * Metodo da chiamare ogni volta che si vuole dare evidenza all'esterno del bisogno di rieffettuare la ricerca\r\n     * \r\n     * @param {boolean} resetsPage Indica al listener che deve resettare il numero di pagina\r\n     * @param {AppSearch<any>} viewOverride Override della view da emettere per questa ricerca\r\n     */\r\n    public emitSearchRequest(resetsPage: boolean, viewOverride?: AppSearch<any>) {\r\n        if (this.viewMode && !viewOverride) {\r\n            (this.View as AppSearch<any>).internalsearchrequest = true;\r\n            this.changed();\r\n        }\r\n\r\n        if (viewOverride) {\r\n            if (resetsPage)\r\n                viewOverride.page = 1;\r\n            viewOverride.internalsearchrequest = true\r\n        }\r\n\r\n        this.researchInProgress = true;\r\n        this.onSearchRequest.emit(viewOverride ? viewOverride : resetsPage);\r\n    }\r\n\r\n    /**\r\n     * Partendo dagli **EsTds** bindati genera, all'interno del dizionario **TMPRowTDs** tutti i contesti dei vari oggetti.\r\n     *\r\n     * Vengono esclusi i TD \"Interni\" in quanto vengono generati dagli originali quindi includerli vorrebbe dire rieffettuare le operazioni due volte\r\n     *\r\n     * Costo: 2 scan EsThs, 1 scan EsTds\r\n     *\r\n     * @param {EsTh[] | EsThDirective[]} ths Colonne della tabella\r\n     * @param {EsTd[] | EsTdDirective[]} tds Celle della tabella\r\n     */\r\n    private evaluateRowTds(ths: EsTh[] | EsThDirective[], tds: EsTd[] | EsTdDirective[]) {\r\n        if (tds.length == 0)\r\n            return;\r\n\r\n        let thsCache: { [index: string]: EsTh | EsThDirective } = {};\r\n        let columnsCache: { [index: string]: EsTableColumn } = {};\r\n\r\n        for (let coli = 0; coli < this.ColumnsList.length; coli++) {\r\n            let col = this.ColumnsList[coli];\r\n            columnsCache[col.id] = col;\r\n        }\r\n\r\n        for (let i = 0; i < ths.length; i++) {\r\n            let th = ths[i];\r\n            thsCache[this.utilities_H.isEsTh(th) ? th.ID : th.th] = th;\r\n        }\r\n\r\n        this.TMPRowTDs = {};\r\n        // Variabile d'appoggio per permettermi di inserire tutte le colonne \"Fixed\" davanti\r\n        let contextFixeds: { [context: string]: number } = {};\r\n        for (let i = 0; i < tds.length; i++) {\r\n            let td = tds[i];\r\n\r\n            if (this.utilities_H.isEsTd(td)) {\r\n                let th = thsCache[td.ID];\r\n                if (!!th)\r\n                    th._referenced = true;\r\n                else\r\n                    throw \"ID dell'oggeto EsTd non compatibile con gli ID dicharati negli EsTh: \" + td.ID;\r\n\r\n                let isFixed = (this.utilities_H.isEsTh(th) && th.Fixed) || (!this.utilities_H.isEsTh(th) && (th.thFixed || th.thGroup));\r\n                let itemToAdd = <any>{ GroupAggregation: false, GroupHeader: false, Wraps: true, ID: td.ID, Visible: td.Visible, Class: td.Class, Content: td.Content, RouterLink: td.RouterLink, Template: td.Template };\r\n                let ctx = td.Context;\r\n                if (this.TMPRowTDs[ctx]) {\r\n                    if (isFixed)\r\n                        this.TMPRowTDs[ctx].splice(0 + (contextFixeds[ctx]++), 0, itemToAdd);\r\n                    else\r\n                        this.TMPRowTDs[ctx].push(itemToAdd);\r\n                }\r\n                else {\r\n                    this.RowContexts.push(ctx);\r\n                    this.TMPRowTDs[ctx] = [itemToAdd];\r\n                    contextFixeds[ctx] = isFixed ? 1 : 0\r\n                }\r\n            }\r\n            else {\r\n                for (let i = 0; i < this.boundSource.length; i++) {\r\n                    let item = this.boundSource[i];\r\n                    let ctx = item._hash;\r\n                    let key = td.td;\r\n                    let th = thsCache[td.td];\r\n                    if (!!th)\r\n                        th._referenced = true;\r\n                    else\r\n                        throw \"ID dell'oggeto EsTd non compatibile con gli ID dicharati negli EsTh: \" + td.td;\r\n\r\n                    if (td.tdIf || (!this.utilities_H.isEsTh(th) && th.thGroup)) {\r\n                        let thCasted = <EsThDirective>th;\r\n                        let isFixed = (this.utilities_H.isEsTh(th) && th.Fixed) || (!this.utilities_H.isEsTh(th) && (th.thFixed || th.thGroup || th.thPinned));\r\n                        let itemToAdd = item._item ?\r\n                            <any>{ LeftBorder: (<any>thCasted)._lbord, RightBorder: (<any>thCasted)._rbord, ID: key, Pinned: columnsCache[td.td].pinned, PinnedWidth: thCasted.thPinnedWidth, GroupHeader: false, GroupAggregation: false, Visible: columnsCache[td.td].visible, Wraps: false, Class: td.tdClass, Template: thCasted.thGroup && !this.ShowItemGroupsColumns ? null : td.Template } :\r\n                            <any>{ LeftBorder: (<any>thCasted)._lbord, RightBorder: (<any>thCasted)._rbord, ID: key, Pinned: columnsCache[td.td].pinned, PinnedWidth: thCasted.thPinnedWidth, GroupHeader: thCasted.thGroup, GroupAggregation: !!thCasted.thAggregation, Visible: columnsCache[td.td].visible, Wraps: false, Class: thCasted.thGroupClass || '', Content: this.rowGrouping_H.getGroupCellDisplay(<Group>item, key, <EsThDirective>th) };\r\n\r\n                        if (this.TMPRowTDs[ctx]) {\r\n                            this.TMPRowTDs[ctx].push(itemToAdd);\r\n                        }\r\n                        else {\r\n                            this.RowContexts.push(ctx);\r\n                            this.TMPRowTDs[ctx] = [itemToAdd];\r\n                            contextFixeds[ctx] = isFixed ? 1 : 0;\r\n                        }\r\n                    }\r\n                }\r\n            }\r\n        }\r\n\r\n        // Se non ho oggetti è inutile che controllo gli errori, dato che gli es-td non esisteranno di certo e di conseguenza gli es-th non saranno referenziati\r\n        if (this.TMPBoundSource.length == 0)\r\n            return;\r\n\r\n        var errs: string[] = [];\r\n        for (let i = 0; i < ths.length; i++) {\r\n            let th = ths[i];\r\n            if (!th._referenced)\r\n                errs.push(this.utilities_H.isEsTh(th) ? th.ID : th.th);\r\n        }\r\n\r\n        if (errs.length > 0) {\r\n            var errIds = errs.join(', ');\r\n            throw \"L'ID di uno o più EsTh non hanno alcun EsTd associato: \" + errIds;\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Partendo dagli **EsThs** bindati genera, all'interno del dizionario **TMPRowTHs** tutti i contesti dei vari oggetti.\r\n     *\r\n     * Vengono esclusi i TH \"Interni\" in quanto vengono generati dagli originali quindi includerli vorrebbe dire rieffettuare le operazioni due volte\r\n     *\r\n     * Costo: 1 scan EsThs\r\n     *\r\n     * @param {EsTh[] | EsThDirective[]} ths Colonne della tabella\r\n     */\r\n    private evaluateRowThs(ths: EsTh[] | EsThDirective[]) {\r\n        if (ths.length == 0)\r\n            return;\r\n\r\n        let columnsListCache: { [index: string]: EsTableColumn } = {};\r\n        let castedView = <AppSearch<any>>this.View;\r\n        let groupingsUndefined = this.viewMode && (castedView && !castedView.groupings || castedView.groupings.length == 0);\r\n\r\n        for (let i = 0; i < this.ColumnsList.length; i++) {\r\n            let itm = this.ColumnsList[i];\r\n            columnsListCache[itm.id] = itm\r\n        }\r\n\r\n        this.TMPRowTHs = [];\r\n        let fixed = 0;\r\n        for (let i = 0; i < ths.length; i++) {\r\n            let th = ths[i];\r\n            let toAdd;\r\n\r\n            if (this.utilities_H.isEsTh(th)) {\r\n                toAdd = { Pinned: false, ID: th.ID, Visible: th.Visible, Class: th.Class, Order: th.Order, Orderable: th.Orderable, Template: null, Content: th.Description, Wrap: th.Wrap };\r\n                if (th.Fixed)\r\n                    this.TMPRowTHs.splice(0 + (fixed++), 0, toAdd);\r\n                else\r\n                    this.TMPRowTHs.push(toAdd);\r\n            }\r\n            else if (th.thIf || th.thGroup) {\r\n\r\n                let thClass = (th.thClass || '') + (th.thGroup ? \" est-col-min\" : \"\");\r\n                toAdd = { Pinned: columnsListCache[th.th].pinned, PinnedWidth: th.thPinnedWidth, ID: th.th, Visible: th.thVisible, Class: thClass, Order: th.thOrder, Orderable: th.thOrderable, Template: th.Template, Content: null, Wrap: th.thWrap, LeftBorder: (<any>th)._lbord, RightBorder: (<any>th)._rbord };\r\n                this.TMPRowTHs.push(toAdd);\r\n\r\n                // Se ho un modello che deve funzionare a rowgrouping ma non è ancora stata effettuata nessuna ricerca sui gruppi principali (groupingsUndefined)\r\n                // li genero e mando la prima ricerca che dev'essere spedita al backend per il primo caricamento dei gruppi\r\n                if (groupingsUndefined && (th.thAggregation || th.thGroup)) {\r\n                    let groupAggregations: GroupOrAggregation[] = this.rowGrouping_H.getGroupAggregations(th);\r\n                    if (!castedView.groupings)\r\n                        castedView.groupings = groupAggregations;\r\n                    else\r\n                        castedView.groupings.push(...groupAggregations);\r\n\r\n                    this.ResearchNeeded = true;\r\n                }\r\n            }\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Sposta la ricerca di una pagina in avanti (o indietro)\r\n     *\r\n     * @param {number} page Numero di pagine da aggiungere (o sottrarre, se negativo) alla pagina attuale\r\n     * @param {any} pager Elemento di separazione su cui è effettuata la ricerca\r\n     */\r\n    public addToPageGroup(page: number, pager: GroupPager) {\r\n        this.goToPageGroup(pager.view.page + page, pager);\r\n    }\r\n\r\n    /**\r\n     * Sposta la ricerca alla pagina specificata\r\n     *\r\n     * @param {number} page Pagina a cui navigare\r\n     * @param {any} pager Elemento di separazione su cui è effettuata la ricerca\r\n     */\r\n    public goToPageGroup(page: number, pager: GroupPager) {\r\n\r\n        let appSearchElement = pager.view;\r\n        if (page === 0 || (page > appSearchElement.pages && appSearchElement.pages > 0))\r\n            return;\r\n\r\n        appSearchElement.page = page;\r\n        pager.buttons = this.utilities_H.getPagesArray(6, appSearchElement.page, appSearchElement.pages);\r\n\r\n        this.emitSearchRequest(false, appSearchElement);\r\n    }\r\n\r\n\r\n    /**\r\n     * Gestisce i click sulla tabella solo per le righe a gruppo. \r\n     * O rimuove gli elementi attualmente presenti o carica il contenuto del gruppo\r\n     *\r\n     * @param {any} group Gruppo bindato su cui si è effettuato il click\r\n     *\r\n     * @returns {boolean} **true** se l'operaizone è andata a buon fine, **false** altrimenti\r\n     */\r\n    public handleGroupClick(group: Group): boolean {\r\n        let casted = this.View as AppSearch<any>;\r\n        let anyG = (<any>group);\r\n        anyG._expanded = !anyG._expanded;\r\n\r\n        // Sono in modalità raggruppamento virtuale da array: Espandere significa rendere visibili tutti gli oggetti relativi a questo gruppo, viceversa il contrarre\r\n        if (this.ArrayGrouping) {\r\n            let allRelatives = this.boundSource.filter(t =>\r\n                (t._group && ((anyG._expanded && t._parent == anyG._thisKey) || (!anyG._expanded && t._parent && t._parent.startsWith(anyG._thisKey)))) ||\r\n                (t._item && ((anyG._expanded && t._thisKey == anyG._thisKey) || (!anyG._expanded && t._thisKey.startsWith(anyG._thisKey)))))\r\n            allRelatives.forEach(t => { t._visible = anyG._expanded; if (t._group) t._expanded = false });\r\n            return;\r\n        }\r\n\r\n        if (anyG._expanded) {\r\n            // Resetto ipp\r\n            casted.itemsperpageoverride = 15;\r\n            if (!casted.requestedgroups)\r\n                casted.requestedgroups = [new GroupFilter(group.column, group.value)];\r\n            else {\r\n                let level = anyG._grouplevel;\r\n                // se il gruppo cliccato non ha un livello è il primo gruppo, quindi ordinamento unico\r\n                // altrimenti devo rimuovere tutti i filtri su livelli superiori al level cliccato e aggiungere il level cliccato\r\n                if (!level)\r\n                    casted.requestedgroups = [new GroupFilter(group.column, group.value)];\r\n                else {\r\n                    casted.requestedgroups = [];\r\n                    anyG._parentRoute.forEach((step: GroupRouteFragment) => {\r\n                        casted.requestedgroups.push(new GroupFilter(step.column, step.value));\r\n                    });\r\n                    casted.requestedgroups.push(new GroupFilter(group.column, group.value));\r\n                }\r\n            }\r\n\r\n            this.changed();\r\n            this.emitSearchRequest(true);\r\n        }\r\n        else {\r\n            let path = (anyG._parent || '') + group.value;\r\n\r\n            // Se ho chiuso un gruppo non mi serve rieffettuare ricerce, mi basta eliminare dagli oggetti bindati tutti gli elementi sottostanti a quel gruppo\r\n            this.boundSource = this.boundSource.filter(t => !t._parent || !t._parent.startsWith(path));\r\n\r\n            // devo però anche rimuovere eventuali cache relative\r\n            this.groupSearchRequestsCache = this.groupSearchRequestsCache.filter(t => t.path != path);\r\n        }\r\n\r\n        return true;\r\n    }\r\n\r\n\r\n    /**\r\n     * Gestisce la selezione globale degli oggetti, sia per pagina che a livello di **SelectAll**\r\n     *\r\n     * @param {boolean} forcedVal Valore forzato di check da assegnare agli oggetti\r\n     */\r\n    public globalCheckChanged(forcedVal: boolean = null) {\r\n\r\n        // Prendo tutti gli elementi presenti in questa vista. Se ho gruppi prendo solo i gruppi a livello 0, altrimenti prendo tutti gli oggetti per selezionarli\r\n        let items = this.boundSource.find(t => t._group) ? this.boundSource.filter(t => t._group && !t._parent) : this.boundSource;\r\n        var itemSelection = this.selection_H.handleItemsSelection(items, forcedVal, this.globalCheck);\r\n        this.changed();\r\n\r\n        this.onSelectionChanged.emit(itemSelection);\r\n    }\r\n\r\n    /**\r\n     * Gestisce i click sulla tabella, gestendo eventualmente anche gli Shift + Click per selezionare un range di oggetti\r\n     *\r\n     * @param {any} event Evento nativo HTML del click\r\n     * @param {any} item Oggetto bindato su cui si è effettuato il click\r\n     *\r\n     * @returns {boolean} **true** se l'operaizone è andata a buon fine, **false** altrimenti\r\n     */\r\n    public handleClick(event: any, item: any): boolean {\r\n        // Seleziono del testo ma non ho shift premuto -> ignoro la selezione\r\n        if ((event.view.getSelection().type == 'Range' || event.view.getSelection().toString().length > 0) && !event.shiftKey)\r\n            return false;\r\n\r\n        // Seleziono del testo e ho shift premuto -> annullo la selezione del testo\r\n        if ((event.view.getSelection().type == 'Range' || event.view.getSelection().toString().length > 0) && event.shiftKey)\r\n            this.utiExts.clearTextSelection();\r\n\r\n        let selecteditems: any[] = [];\r\n        if (event.shiftKey && this.ShiftClick && !this.SingleSelection) {\r\n            let startSelecting = false;\r\n\r\n            let items = this.boundSource.filter(t => !t._group && !t._sep);\r\n            for (let i = 0; i < items.length; i++) {\r\n                let t = items[i];\r\n                if (startSelecting) {\r\n                    t._selected = true;\r\n                    selecteditems.push(t);\r\n                }\r\n                if ((t == item || t == this.lastSelected) && !startSelecting) {\r\n                    startSelecting = true;\r\n                    t._selected = true;\r\n                    selecteditems.push(t);\r\n                } else if ((t == item || t == this.lastSelected) && startSelecting)\r\n                    startSelecting = false;\r\n            }\r\n        } else {\r\n            item._selected = !item._selected;\r\n            this.lastSelected = item;\r\n            selecteditems.push(item);\r\n        }\r\n\r\n        var itemSelection = this.selection_H.handleItemsSelection(selecteditems);\r\n        this.changed();\r\n\r\n        this.onSelectionChanged.emit(itemSelection);\r\n        return true;\r\n    }\r\n\r\n\r\n    /**\r\n     * Sposta la ricerca di una pagina in avanti (o indeitro)\r\n     *\r\n     * @param {number} page Numero di pagine da aggiungere (o sottrarre, se negativo) alla pagina attuale\r\n     */\r\n    public addToPage(page: number) {\r\n        let view = this.MainGroupView ? this.MainGroupView : this.View;\r\n\r\n        this.goToPage(((this.SearchView || view)?.page || 0) + page);\r\n    }\r\n\r\n    /**\r\n     * Sposta la ricerca alla pagina specificata\r\n     *\r\n     * @param {number} page Pagina a cui navigare\r\n     */\r\n    public goToPage(page: number) {\r\n        let view = this.MainGroupView ? this.MainGroupView : (this.arrayMode ? this.SearchView : this.View);\r\n        if (!view.page || !view.pages)\r\n            return;\r\n\r\n        let appSearchElement = this.SearchView || view;\r\n        if (page === 0 || (page > appSearchElement.pages && appSearchElement.pages > 0))\r\n            return;\r\n\r\n        appSearchElement.page = page;\r\n        let count = this.reportMode ? ((<ReportDefinition>view).result?.count || 0) : (view.items.length || view.groups?.length || 0);\r\n        let ipp = this.reportMode ? ((<ReportDefinition>view).itemsperpageoverride || 15) : view.itemsperpageoverride || 15;\r\n        this.arrayPulsanti = this.utilities_H.getPagesArray(6, appSearchElement.page, appSearchElement.pages, count, ipp);\r\n\r\n        let hasGroupings = !!this.MainGroupView;\r\n        this.emitSearchRequest(false, hasGroupings ? view : this.SearchView ? this.SearchView : null);\r\n    }\r\n\r\n    /**\r\n     * Evento richiamato sul cambio della paginazione. Verrà richiamato l'evento **emitSearchRequest**\r\n     * per comunicare al componente che utilizza questa tabella che i dati sono da aggiornare\r\n     */\r\n    public onItemsPerPageChanged(newIpp) {\r\n        this.PagerOptions.View.itemsperpageoverride = newIpp;\r\n        this.changed();\r\n        if (this.MainGroupView)\r\n            this.emitSearchRequest(true, this.MainGroupView);\r\n        else if (this.SearchView) {\r\n            // Questo secondo me si può portare a livello un po' più alto\r\n            this.SearchView.page = 1;\r\n            this.emitSearchRequest(true, this.SearchView);\r\n        }\r\n        else\r\n            this.emitSearchRequest(true);\r\n    }\r\n\r\n    /** Evento richiamato sul cambio della paginazione. Verrà richiamato l'evento **emitSearchRequest** con la vista del separatore */\r\n    public onGroupItemsPerPageChanged(pager: GroupPager, newIpp: number) {\r\n        pager.view.itemsperpageoverride = newIpp;\r\n        this.emitSearchRequest(true, pager.view);\r\n    }\r\n\r\n\r\n    /** Metodo che gestisce la modifica del tempo specificato per l'aggiornamento automatico */\r\n    public autoUpdateChanged() {\r\n        if (!/^[1-9]\\d*$/.test(this.seconds))\r\n            this.seconds = '10';\r\n\r\n        let secondsInMs = parseInt(this.seconds, null) * 1000;\r\n\r\n        if (this.autoUpdate)\r\n            this.updateTimer = setInterval(() => { this.emitSearchRequest(false); }, secondsInMs);\r\n        else\r\n            clearInterval(this.updateTimer);\r\n    }\r\n\r\n    /**\r\n     * Metodo chiamato dal click su una delle colonne generate dall'Input **DynamicOperations**\r\n     *\r\n     * @param {any} item L'oggetto su cui va effettuata l'operazione\r\n     * @param {string} opid Codice identificativo dell'operazione da effettuarsi\r\n     */\r\n    public dynamicOperation(item: any, opid: string) {\r\n        this.onDynamicOperation.emit({ id: opid, item: item });\r\n    }\r\n\r\n    /**\r\n     * Ottiene il contenuto dell'EsTd da utilizzare per la colonna specificata\r\n     * \r\n     * @param {string} column Colonna per cui cercare la cella\r\n     * \r\n     * @returns {TemplateRef<any>} Template da usare per la colonna\r\n     */\r\n    public findEsTd(column: string): TemplateRef<any> {\r\n        var EsTd = this.EsTdsDirective.find((item) => item.td === column);\r\n        return EsTd ? EsTd.Template : null;\r\n    }\r\n\r\n\r\n    /**\r\n     * Equivalente del metodo **addToPage** riadattato per la modalità array\r\n     *\r\n     * @param {number} page Numero di pagine da aggiungere (o sottrarre, se negativo) alla pagina attuale\r\n     */\r\n    public arrayAddToPage(page: number) {\r\n        this.arrayGoToPage(this.arraymodePage + page)\r\n    }\r\n\r\n    /**\r\n     * Equivalente del metodo **goToPage** riadattato per la modalità array\r\n     *\r\n     * @param {number} page Pagina a cui navigare\r\n     */\r\n    public arrayGoToPage(page: number) {\r\n        if (page === 0 || page > this.arraymodePages)\r\n            return;\r\n        this.arraymodePage = page;\r\n\r\n        // Riforzo il writevalue in modo che il codice passi dalla gestione come se fosse fatta ripartire una ricerca\r\n        this.internalWriteValue();\r\n    }\r\n\r\n    /**\r\n     * Gestore dei click sulle celle per le quali era impostata una azione custom da **CustomCellActionsOn**\r\n     *\r\n     * @param {string} name Nome della cella su cui si è fatto click\r\n     * @param {any} model Modello relativo alla cella cliccata\r\n     *\r\n     * @returns {boolean} **true** se il click è stato fatto su una cella cliccabile, **false** altrimenti\r\n     */\r\n    public cellClicked(name: string, model: any): boolean {\r\n        if (this.UseCustomCellActions && this.CustomCellActionsOn.split('$').indexOf(name) != -1) {\r\n            this.onCellClick.emit({ column: name, model: model });\r\n            return true;\r\n        }\r\n\r\n        return false;\r\n    }\r\n\r\n    /**\r\n     * Gestione dei click sulle opzioni del menù contestuale in alto a destra generato dall'Input **CornerMenuOptions**\r\n     *\r\n     * @param {string} cornerid Codice dell'operazione selezionata\r\n     */\r\n    public cornerActionClicked(cornerid: string) {\r\n        this.onCornerAction.emit({ id: cornerid, estable: this });\r\n    }\r\n\r\n    /** \r\n     * Impostazione modalità dell'EsTable \r\n     * \r\n     * @param {'array' | 'view' | 'report'} mode Modalità da impostare\r\n     **/\r\n    private setMode(mode: 'array' | 'view' | 'report') {\r\n        this.viewMode = mode == 'view';\r\n        this.arrayMode = mode == 'array';\r\n        this.reportMode = mode == 'report';\r\n\r\n        if (this.reportMode) {\r\n            // In modalità report ho di sicuro queste due\r\n            this.XLSXExport = true;\r\n            this.CSVExport = false;\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Helper per effettuare chiamate interne di allineamento alla funzione **writeValue**, \r\n     * impostando prima **internalWriteCall** in modo da non effettuare operazioni inutili\r\n     */\r\n    public internalWriteValue() {\r\n        this.internalWriteCall = true;\r\n        this.writeValue(this.View);\r\n        this.internalWriteCall = false;\r\n    }\r\n\r\n    /**\r\n     * Metodo eventualmente richiamabile anche dal componente esterno che permette di forzare un refresh della tabella\r\n     */\r\n    public forceRefresh() {\r\n\r\n        // Se sono in modalità View viene mantenuto in automatico il numero di pagina, ma per la modalità array devo prendere le info di paginazione prima e riapplicarle dopo\r\n        let arrayPage: number;\r\n        let arrayIpp: number;\r\n        if (this.arrayMode) {\r\n            arrayPage = this.arraymodePage;\r\n            arrayIpp = this.ArraymodeItemsPerPage;\r\n        }\r\n\r\n        this.writeValue(this.View);\r\n        this.cdr.detectChanges();\r\n\r\n        if (this.arrayMode) {\r\n            this.ArraymodeItemsPerPage = arrayIpp;\r\n            this.arrayGoToPage(arrayPage);\r\n        }\r\n    }\r\n}"]}