using GMW_data;
using SteamWare;
using System;
using System.Web.UI;
using System.Web.UI.WebControls;

namespace GMW.WebUserControls
{
  public partial class mod_SterrTagOUT : System.Web.UI.UserControl
  {
    /// <summary>
    /// flusso associato (hard coded) a FUSI
    /// </summary>
    protected string flusso = "ST";
    /// <summary>
    /// stato associato (hard coded) a  FUSI
    /// </summary>
    protected string statoUDC = "Sterr";
    /// <summary>
    /// tipo di evento associato alla creazione dell'UDC
    /// </summary>
    protected string eventoUDC = "UDC_STTA";
    /// <summary>
    /// stringa degli UDC selezionati per consumo COMPLETO (nel formato #UDC1##UDC2#)
    /// </summary>
    protected string udcSelC
    {
      get
      {
        return memLayer.ML.StringSessionObj(string.Format("UdcSelC_{0}", uid));
      }
      set
      {
        memLayer.ML.setSessionVal(string.Format("UdcSelC_{0}", uid), value);
      }
    }
    /// <summary>
    /// stringa degli UDC selezionati per consumo PARZIALE (nel formato #UDC1##UDC2#)
    /// </summary>
    protected string udcSelP
    {
      get
      {
        return memLayer.ML.StringSessionObj(string.Format("UdcSelP_{0}", uid));
      }
      set
      {
        memLayer.ML.setSessionVal(string.Format("UdcSelP_{0}", uid), value);
      }
    }
    public event EventHandler eh_nuovaRicerca;
    public event EventHandler eh_reqUpdate;
    /// <summary>
    /// stringa UID univoca
    /// </summary>
    public string uid
    {
      get
      {
        return this.UniqueID.Replace("$", "_").Replace("-", "_");
      }
    }
    /// <summary>
    /// caricamento pagina
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    protected void Page_Load(object sender, EventArgs e)
    {
      if (!Page.IsPostBack)
      {
        fixRicercaUdc();
        traduciObj();
        idxCella = Postazione.currIdxCella;
      }
      doChecks();
    }
    /// <summary>
    /// IDX cella associata alla linea corrente
    /// </summary>
    protected int idxCella
    {
      get
      {
        int answ = 0;
        if (memLayer.ML.isInSessionObject("IdxCellaLineaST_OUT"))
        {
          answ = memLayer.ML.IntSessionObj("IdxCellaLineaST_OUT");
        }
        return answ;
      }
      set
      {
        memLayer.ML.setSessionVal("IdxCellaLineaST_OUT", value);
      }
    }
    /// <summary>
    /// verifica se si debba mostrare un campo ricerca attivo...
    /// </summary>
    private void fixRicercaUdc()
    {
      if (memLayer.ML.isInSessionObject("valoreCercatoSTO"))
      {
        testoRicerca = memLayer.ML.StringSessionObj("valoreCercatoSTO");
      }
    }
    /// <summary>
    /// richiesta (ri)stampa UDC
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    public void ristampa()
    {
      bool fatto = false;
      // registro ri-stampa UDC
      DateTime adesso = DateTime.Now;
      // calcolo particolare...
      DS_magazzino.ElencoCartelliniRow rigaUDC;
      string particolare = "";
      try
      {
        rigaUDC = MagClass.magazzino.taCartellini.getByUdc(udcReq)[0];
        particolare = rigaUDC.Particolare;
        fatto = MagClass.magazzino.ristampaUdc(udcReq, Postazione.printer, Request.UserHostName);
      }
      catch
      {
        logger.lg.scriviLog(string.Format("Errore recupero particolare UDC Sterratura OUT {0}", udcReq), tipoLog.EXCEPTION);
      }
      if (fatto) MagClass.magazzino.taSAO.insertQuery(adesso, MagClass.magazzino.CodSoggCurrUser, Postazione.name, Postazione.IP, udcReq, particolare, "stampaUDC", "Ri-Stampato UDC Sterratura OUT");
      // raise dell'evento
      if (eh_reqUpdate != null)
      {
        eh_reqUpdate(this, new EventArgs());
      }
    }
    /// <summary>
    /// udc da stampare
    /// </summary>
    protected string udcReq
    {
      get
      {
        return memLayer.ML.StringSessionObj("udcSelSAO");
      }
    }
    /// <summary>
    /// controlla particolare selezionato
    /// </summary>
    private void checkParticolare()
    {
      if (currParticolare != "")
      {
        lblParticolareAttivo.Text = string.Format("Particolare selezionato <b>{0}</b>", currParticolare);
        // aggiungo descrizione del particolare
        string descr = "";
        string disegno = "";
        try
        {
          DS_magazzino.AnagParticolariRow riga = MagClass.magazzino.taAnagPart.likeSearch(currParticolare, memLayer.ML.StringSessionObj("CodCS"))[0];
          descr = riga.DescParticolare;
          disegno = string.Format("( {0} )", riga.DisegnoGrezzo);
        }
        catch
        { }
        lblDescrAttivo.Text = descr;
        lblDisegno.Text = disegno;
      }
      else
      {
        lblParticolareAttivo.Text = "...";
        lblDescrAttivo.Text = "";
        lblDisegno.Text = "";
      }
    }
    /// <summary>
    /// effettua controlli visibilità
    /// </summary>
    private void doChecks()
    {
      checkBarcode();
      checkStampa();
      checkParticolare();
    }
    /// <summary>
    /// sistemo labels oggetti
    /// </summary>
    private void traduciObj()
    {
      // labels
      btnCerca.Text = traduci("btnSearch");
      //txtBox
      txtQta.Text = memLayer.ML.cdv("QtaImballoSterr");
      // buttons
      btnEmptyNote.Text = traduci("btnEmptyNote");
    }
    /// <summary>
    /// restituisce il nome della pagina corrente
    /// </summary>
    protected string PagCorrente
    {
      get
      {
        string answ = "";
        Uri MyUrl = Request.Url;
        string delimStr = "/";
        char[] delimiter = delimStr.ToCharArray();
        string[] finalUrl = MyUrl.LocalPath.ToString().Split(delimiter);
        int n = finalUrl.Length;
        answ = finalUrl[n - 1].ToString();
        DataLayer_AnagGen.PermessiRow riga = (DataLayer_AnagGen.PermessiRow)user_std.UtSn.permessi.Select(string.Format("URL = '{0}'", answ))[0];
        answ = riga.NOME;
        return answ;
      }
    }
    /// <summary>
    /// wrapper traduzione
    /// </summary>
    /// <param name="lemma"></param>
    /// <returns></returns>
    public string traduci(object lemma)
    {
      return user_std.UtSn.Traduci(lemma.ToString());
    }
    /// <summary>
    /// indica il codice articolo correntemente selezionato
    /// </summary>
    protected string currParticolare
    {
      get
      {
        return memLayer.ML.StringSessionObj(string.Format("currParticolare_{0}", uid));
      }
      set
      {
        memLayer.ML.setSessionVal(string.Format("currParticolare_{0}", uid), value, memLayer.ML.confReadBool("keepParticolareSel"));
      }
    }
    /// <summary>
    /// indica se i caratteri vadano forzati a maiuscoli
    /// </summary>
    public bool forceUppercase
    {
      get
      {
        return memLayer.ML.confReadBool("forceUppercase");
      }
    }
    /// <summary>
    ///  num pezzi dell'ultimo UDC del particolare generato
    /// </summary>
    public int pezziUdc
    {
      get
      {
        int answ = 0;
        try
        {
          answ = (int)MagClass.magazzino.taCartellini.getLastByParticolareStato(memLayer.ML.StringSessionObj("CodCS"), currParticolare, statoUDC, false)[0].Qta;
        }
        catch
        { }
        return answ;
      }
    }
    /// <summary>
    /// decodifica il tipo barcode acquisito
    /// </summary>
    public tipoCodiceBarcode tipoBCode
    {
      get
      {
        tipoCodiceBarcode answ = tipoCodiceBarcode.ND;
        int trovati = 0;
        // controllo non si tratti di un comando...
        string preCmd = memLayer.ML.AppConf["prefComandi"];
        if (barcodeIn.StartsWith(preCmd))
        {
          answ = tipoCodiceBarcode.Comando;
        }
        else if ((TermClass.Ter.riconosciBarcode(barcodeIn) == tipoCodiceBarcode.Particolare)) // è un particolare...
        {
          answ = tipoCodiceBarcode.Particolare;
        }
        else
        {
          try
          {
            // cerco tra gitterbox (UDC)...
            trovati = MagClass.magazzino.taCartellini.getByUdc(barcodeIn).Rows.Count;
            if (trovati > 0)
            {
              answ = tipoCodiceBarcode.UDC;
            }
          }
          catch
          {
          }
        }
        return answ;
      }
    }
    /// <summary>
    /// valore barcode
    /// </summary>
    public string barcodeIn
    {
      get
      {
        return txtBarcode.Text.Trim();
      }
      set
      {
        txtBarcode.Text = value;
      }
    }
    /// <summary>
    /// qta pezzi TOTALE
    /// </summary>
    public int qta
    {
      get
      {
        int qta = 0;
        try
        {
          qta = Convert.ToInt32(txtQta.Text.Trim());
        }
        catch
        { }
        return qta;
      }
      set
      {
        txtQta.Text = value.ToString();
      }
    }
    /// <summary>
    /// controlla se ci sia un barcode
    /// </summary>
    private void checkBarcode()
    {
      if (barcodeIn != "")
      {
        Postazione.messaggiText = string.Format("Barcode digitato: {0}", barcodeIn);
        switch (tipoBCode)
        {
          case tipoCodiceBarcode.Particolare:
            // 2014.02.13: tolto perché NON si vuole particolare OUT diverso da IN
#if false
                        // imposto il particolare corrente
                        currParticolare = barcodeIn;
                        impostaParticolare(); 
#endif
            break;
          case tipoCodiceBarcode.UDC:
            // procedo solo se UDC esistente
            if (MagClass.magazzino.checkUDC(barcodeIn))
            {
              // calcolo nuovo particolare
              string newPart = DataProxy.obj.taCartellini.stp_getByUdc(barcodeIn)[0].Particolare;
              if (testoRicerca != newPart)
              {
                // resetto precedente ricerca e deseleziono TUTTI gli UDC elencati SE è cambiato il particolare
                udcSelC = string.Format("#{0}#", barcodeIn);
              }
              else
              {
                udcSelC = string.Format("{0}#{1}#", udcSelC, barcodeIn);
                // se era presente in elenco "P" lo elimino
                udcSelP = udcSelP.Replace(string.Format("#{0}#", barcodeIn), "");
              }
              updFiltroPart(newPart);
              // imposto particolare!
              currParticolare = newPart;
              impostaParticolare();
            }

            break;
          default:
            Postazione.messaggiText += " - codice <b>non riconosciuto</b>!";
            Postazione.CssClass = "stileComandoND";
            break;
        }
        barcodeIn = "";
      }
      else
      {
        Postazione.messaggiText = traduci("AttesaBCode");
        Postazione.CssClass = "stileAttesa";
      }
      //grView.DataBind();
      txtBarcode.Focus();
    }
    /// <summary>
    /// imposto i dati dal particolare corrente
    /// </summary>
    private void impostaParticolare()
    {
      // controllo esista il particolare scansionato
      if (DataProxy.obj.taAnagParticolari.getByParticolare(currParticolare).Rows.Count == 0)
      {
        currParticolare = "";
        Postazione.messaggiText += " - codice particolare non valido / non trovato in RILPRO.";
        Postazione.CssClass = "stileComandoKo";
      }
      else
      {
        Postazione.messaggiText += " - impostato particolare!";
        Postazione.CssClass = "stileComandoOk";
      }
      // leggo la qta dell'ultimo UDC del particolare, SE C'E', e la imposto...
      if (pezziUdc > 0)
      {
        txtQta.Text = pezziUdc.ToString();
      }
      else // rimette default
      {
        txtQta.Text = memLayer.ML.cdv("QtaImballoSterr");
      }
    }
    /// <summary>
    /// update del filtro su particolare x grview UDC caricati in linea
    /// </summary>
    /// <param name="newPart"></param>
    private void updFiltroPart(string newPart)
    {
      if (testoRicerca != newPart)
      {
        // imposto filtraggio x particoalre nell'elenco degli UDC della linea...
        testoRicerca = newPart;
        // salvo UDC da selezionare come consumo COMPLETO
        salvaCerca();
      }
      else
      {
        doUpdate();
      }
    }
    /// <summary>
    /// aggiorna tabella + focus a barcode
    /// </summary>
    public void doUpdate()
    {
      idxCella = Postazione.currIdxCella;
      checkStampa();
      grView.DataBind();
      txtBarcode.Focus();
      // raise dell'evento
      if (eh_reqUpdate != null)
      {
        eh_reqUpdate(this, new EventArgs());
      }
    }
    /// <summary>
    /// controllo l'abilitazione alla stampa UDC:
    /// - particolare ok
    /// - qta > 0
    /// - udc da consumo totale/parziale
    /// altrimenti disabilito btn stampa
    /// </summary>
    private void checkStampa()
    {
      bool stampaOk = false;
      //controllo siano inseriti valori qta
      if (qta > 0)
      {
        // controllo ci siano particolare e ci sia selezionato almeno un UDC
        if (currParticolare != "" && ((udcSelC.Replace("#", "").Length > 1) || (udcSelP.Replace("#", "").Length > 1)))
        {
          stampaOk = true;
        }
      }
      divNote.Visible = stampaOk;
    }
    /// <summary>
    /// genera i barcode di
    /// - trattamenti
    /// - nuovo x pezzi liquidi
    /// e lancia la relativa stampa
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    protected void btnStampa_Click(object sender, EventArgs e)
    {
      string[] stringSeparators = new string[] { "#" };
      // verifico postazione x procedere...
      if (Postazione.printer != "n.d.")
      {
        // controllo UDC in ingresso, che siano tutti con uguale particolare e DIVERSO da ""
        string partUdcIn = "";
        try
        {
          string fullUdc = string.Format("{0}#{1}", udcSelC, udcSelP);
          // ciclo tutti gli UDC consumati P e C e verifico loro particolare
          if (fullUdc.Replace("#", "").Length > 1)
          {
            string[] elencoUDC;
            elencoUDC = fullUdc.Split(stringSeparators, StringSplitOptions.RemoveEmptyEntries);
            partUdcIn = checkPartUDC(elencoUDC);
          }
        }
        catch
        { }
        if (partUdcIn != "")
        {
          // controllo da distinta base coerenza particolare IN/OUT
          bool partDistintaOk = false;
          try
          {
            if (MagClass.magazzino.taPartIO.GetData(currParticolare, partUdcIn, true)[0].Trovati > 0) partDistintaOk = true;
          }
          catch
          { }
          if (partDistintaOk)
          {
            string newUdcChild = "";
            int qta = memLayer.ML.cdvi("QtaImballoSterr");
            string noteTrim = txtNote.Text.Trim();
            noteTrim = string.Format("{0}{1}{2}", Postazione.currNomeLinea, Environment.NewLine, noteTrim);
            try
            {
              qta = Convert.ToInt32(txtQta.Text);
            }
            catch
            { }
            // effettuo controlli che cod_soggetto e cod particolare siano disponibili...
            string codSogg = "";
            string particolare = "";
            try
            {
              codSogg = MagClass.magazzino.CodSoggCurrUser;
              particolare = currParticolare;
            }
            catch
            {
            }
            if (codSogg != "" && particolare != "")
            {
              // genero cartellino
              DateTime adesso = DateTime.Now;
              try
              {
                // creo nuovo UDC sterrato OUT multiple
                newUdcChild = MagClass.magazzino.creaUdc(flusso, "", currParticolare, "", "", "", "", "", 0, memLayer.ML.cdv("CodImballoSterr"), "U", MagClass.magazzino.CodSoggCurrUser, qta, 0, 0, adesso, 0, statoUDC, memLayer.ML.cdvi("IdxPosizioneSterrati"), "IdxPosizioneSterrati", eventoUDC, noteTrim, "", adesso.Year, Request.UserHostName);
                // registro creazione nuovo UDC
                MagClass.magazzino.taSAO.insertQuery(adesso, codSogg, Postazione.name, Postazione.IP, newUdcChild, particolare, "creaUDC", string.Format("Creato nuovo UDC Sterrato, qta: {0} {1}", qta, noteTrim));
              }
              catch (Exception exc)
              {
                httpLog(string.Format("Errore creazione UDC Sterrato: {0}", exc), tipoLog.EXCEPTION);
              }
              // devo gestire associazione e consumo cartellini FUSI
              if (newUdcChild != "")
              {
                string[] UDC_P;
                // ASSOCIO tutti gli UDC consumati sia Parziali che Completi al nuovo UDC
                if (udcSelP.Replace("#", "").Length > 1)
                {
                  // associo
                  UDC_P = udcSelP.Split(stringSeparators, StringSplitOptions.RemoveEmptyEntries);
                  //UDC_P = SteamWare.StringSplitter.CSplitter.Split(udcSelP, "#", false, 0, SteamWare.StringSplitter.ComparisonMethod.Text);
                  associaUdc(newUdcChild, UDC_P);
                }
                if (udcSelC.Replace("#", "").Length > 1)
                {
                  // associo
                  UDC_P = udcSelC.Split(stringSeparators, StringSplitOptions.RemoveEmptyEntries);
                  //UDC_P = SteamWare.StringSplitter.CSplitter.Split(udcSelC, "#", false, 0, SteamWare.StringSplitter.ComparisonMethod.Text);
                  associaUdc(newUdcChild, UDC_P);
                  // consumo gli UDC indicati come "C"
                  consumaUdc(UDC_P);
                }

                // ora stampo il nuovo cartellino!!!
                MagClass.magazzino.stampaUdc(newUdcChild, Postazione.printer, tipoCartellino.cartSterr, Request.UserHostName);
                // incremento timing...
                adesso = DateTime.Now;
                adesso = adesso.AddSeconds(2);
                // registro stampa nuovo UDC
                MagClass.magazzino.taSAO.insertQuery(adesso, codSogg, Postazione.name, Postazione.IP, newUdcChild, particolare, "stampaUDC", "Stampato UDC Sterrato");
              }
              // resetto
              doResetData();
            }
            else
            {
              httpLog(string.Format("STERRATI OUT, Errore persi utente/particolare, ricarico!"), tipoLog.ERROR);
              Response.Redirect("~/login.aspx");
            }
          }
          else
          {
            httpLog(string.Format("STERRATI OUT, Errore controllo coerenza particolari da distinta base!"), tipoLog.ERROR);
            Postazione.messaggiText += "Errore particolari UDC da controllo distinta base";
            Postazione.CssClass = "stileComandoND";
          }
        }
        else
        {
          httpLog(string.Format("STERRATI OUT, Errore controllo coerenza elenco aprticolari IN!"), tipoLog.ERROR);
          Postazione.messaggiText += "Errore particolari UDC da consumare non coerenti";
          Postazione.CssClass = "stileComandoND";
        }
      }
      else
      {
        Response.Redirect("~/menu.aspx");
      }
      doUpdate();
      // raise dell'evento
      if (eh_reqUpdate != null)
      {
        eh_reqUpdate(this, new EventArgs());
      }
    }
    /// <summary>
    /// effettua il consumo di tutti gli UDC inviati come array di stringhe
    /// </summary>
    /// <param name="UDC_P"></param>
    private void consumaUdc(string[] UDC_P)
    {
      if (UDC_P.Length > 0)
      {
        // ciclo
        foreach (string udc_p in UDC_P)
        {
          // se UDC è NON vuoto ed esiste
          if (udc_p != "" && MagClass.magazzino.checkUDC(udc_p))
          {
            // se è consumabile (IdxPosizione > 0)...
            if (MagClass.magazzino.udcMpIsConsumabile(udc_p))
            {
              // consumo UDC
              MagClass.magazzino.scaricaUdcMpWip(udc_p, Request.UserHostName);
              // sposta UDC da posizione corrente a nessuna...
            }
          }
        }
      }
    }
    /// <summary>
    ///associa nuovo UDC ad elenco UDC
    /// </summary>
    /// <param name="newUdcChild">UDC da associare come child</param>
    /// <param name="UDC_P">vettore di UDC da associare come parent</param>
    private void associaUdc(string newUdcChild, string[] UDC_P)
    {
      if (UDC_P.Length > 0)
      {
        // ciclo
        foreach (string udc_p in UDC_P)
        {
          // se UDC è NON vuoto ed esiste
          if (udc_p != "" && MagClass.magazzino.checkUDC(udc_p))
          {
            MagClass.magazzino.associaUdcParent(newUdcChild, udc_p);
          }
        }
      }
    }
    /// <summary>
    /// verifica che il vettore di UDC abbia tutto lo stesso particolare e lo restituisce, altrimenti restituisce ""
    /// </summary>
    /// <param name="UDC_P">vettore di UDC da verificare</param>
    private string checkPartUDC(string[] UDC_P)
    {
      string answ = "";
      if (UDC_P.Length > 0)
      {
        // imposto il primo particolare...
        answ = MagClass.magazzino.getParticolareByUDC(UDC_P[0]);
        // ciclo
        foreach (string udc_p in UDC_P)
        {
          if (MagClass.magazzino.getParticolareByUDC(udc_p) != answ) answ = ""; // se uno è diverso "azzero"
        }
      }
      return answ;
    }
    /// <summary>
    /// wrapper per log con salvataggio dell'IP del chiamante
    /// </summary>
    /// <param name="_testoPre"></param>
    /// <returns></returns>
    public bool httpLog(string _testoPre)
    {
      bool answ = false;
      logger.lg.scriviLog(Postazione.IP + _testoPre);
      return answ;
    }
    /// <summary>
    /// wrapper per log con salvataggio dell'IP del chiamante
    /// </summary>
    /// <param name="_testoPre"></param>
    /// <returns></returns>
    public bool httpLog(string testoLog, tipoLog tipo)
    {
      bool answ = false;
      logger.lg.scriviLog(Postazione.IP + testoLog, tipo);
      return answ;
    }
    /// <summary>
    /// effettua reset dati
    /// </summary>
    public void doResetData()
    {
      // resetto i dati QtaTot e particolare...
      qta = 0;
      currParticolare = "";
      txtQta.Text = "";
      testoRicerca = "";
      salvaCerca();
      doChecks();
    }
    /// <summary>
    /// svuoto le note
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    protected void btnEmptyNote_Click(object sender, EventArgs e)
    {
      txtNote.Text = "";
    }
    /// <summary>
    /// passo alla modalità IN
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    protected void btnIn_Click(object sender, EventArgs e)
    {
      Response.Redirect("SterrTaglioIN.aspx");
    }

    /// <summary>
    /// effettua refresh (su db) del blocco postazione
    /// </summary>
    /// <param name="codLinea"></param>
    private void refreshBloccoPost(string codLinea)
    {
      // resetto usi linee precedenti..
      MagClass.magazzino.taAL.resetPost(Postazione.name);
      // se la linea non è "base" = "Sel linea", finisce x "0"
      if (codLinea.Substring(codLinea.Length - 1) != "0")
      {
        // salvo su DB che sto occupando linea...
        MagClass.magazzino.taAL.updatePost(codLinea, Postazione.name);
      }
    }
    /// <summary>
    /// cambiato valore in ricerca
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    protected void txtCerca_TextChanged(object sender, EventArgs e)
    {
      // se è nuovo il testo resetto
      if (testoRicerca != SteamWare.memLayer.ML.StringSessionObj("valoreCercatoSTO"))
      {
        udcSelC = "";
        udcSelP = "";
      }
      salvaCerca();
    }
    /// <summary>
    /// effettuato reset
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    protected void lnkReset_Click(object sender, EventArgs e)
    {
      testoRicerca = "";
      salvaCerca();
    }
    /// <summary>
    /// pressione del button di ricerca
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    protected void btnCerca_Click(object sender, EventArgs e)
    {
      salvaCerca();
    }

    /// <summary>
    /// testo ricerca trimmato da spazi
    /// </summary>
    protected string testoRicerca
    {
      get
      {
        return txtCerca.Text.Trim();
      }
      set
      {
        txtCerca.Text = value;
      }
    }
    /// <summary>
    /// salvo ricerca particolare
    /// </summary>
    protected void salvaCerca()
    {
      if (string.IsNullOrEmpty(testoRicerca))
      {
        SteamWare.memLayer.ML.emptySessionVal("valoreCercatoSTO");
        udcSelC = "";
        udcSelP = "";
      }
      else
      {
        SteamWare.memLayer.ML.setSessionVal("valoreCercatoSTO", testoRicerca);
      }
      // raise dell'evento
      if (eh_nuovaRicerca != null)
      {
        eh_nuovaRicerca(this, new EventArgs());
      }
      doUpdate();
    }
    protected void grView_PageIndexChanged(object sender, EventArgs e)
    {
      // fix dell'ODS
      checkFixOds();
    }
    protected void grView_Sorted(object sender, EventArgs e)
    {
      // fix dell'ODS
      checkFixOds();
    }
    /// <summary>
    /// aggiorno ods al binding..
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    protected void ods_DataBinding(object sender, EventArgs e)
    {
      // fix dell'ODS
      checkFixOds();
    }
    /// <summary>
    /// verifica se attivo filtro company e imposta ods di conseguenza...
    /// </summary>
    private void checkFixOds()
    {
    }
    /// <summary>
    /// traduce gli header delle colonne
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    protected void grView_DataBound(object sender, EventArgs e)
    {
      if (grView.Rows.Count > 0)
      {
        LinkButton lb;
        // aggiorno gli headers        
        foreach (TableCell cella in grView.HeaderRow.Cells)
        {
          try
          {
            lb = (LinkButton)cella.Controls[0];
            lb.Text = traduci(lb.Text);
          }
          catch
          { }
        }
        int totRecord = grView.Rows.Count + grView.PageSize * (grView.PageCount - 1);
        lblNumRec.Text = string.Format("{0} records of ~ {1}", grView.Rows.Count, totRecord);
      }
      else
      {
        lblNumRec.Text = "";
      }
    }

    protected void rbl_DataBinding(object sender, EventArgs e)
    {
      RadioButtonList rbl = (RadioButtonList)sender;
      if (udcSelC.IndexOf(rbl.ToolTip) >= 0)
      {
        rbl.SelectedValue = "C";
      }
      else if (udcSelP.IndexOf(rbl.ToolTip) >= 0)
      {
        rbl.SelectedValue = "P";
      }
    }

    protected void rbl_DataBound(object sender, EventArgs e)
    {

    }

    /// <summary>
    /// selezione UDC da elenco
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    protected void rbl_SelectedIndexChanged(object sender, EventArgs e)
    {
      RadioButtonList rbl = (RadioButtonList)sender;
      if (rbl.SelectedValue == "C")
      {
        udcSelC = string.Format("{0}#{1}#", udcSelC, rbl.ToolTip);
        // se era presente in elenco "P" lo elimino
        udcSelP = udcSelP.Replace(string.Format("#{0}#", rbl.ToolTip), "");
      }
      else
      {
        udcSelP = string.Format("{0}#{1}#", udcSelP, rbl.ToolTip);
        // se era presente in elenco "C" lo elimino
        udcSelC = udcSelC.Replace(string.Format("#{0}#", rbl.ToolTip), "");
      }
      // calcolo il particolare da selezionare...
      string newPart = DataProxy.obj.taCartellini.stp_getByUdc(rbl.ToolTip)[0].Particolare;
      updFiltroPart(newPart);
      // imposto particolare!
      currParticolare = newPart;
      checkParticolare();
      impostaParticolare();
      checkStampa();
      // raise dell'evento
      if (eh_reqUpdate != null)
      {
        eh_reqUpdate(this, new EventArgs());
      }
    }

  }
}