Clase con funciones sencillas e imprescindibles (CUtils.cs)
Ésta es la clase con funciones genéricas que suelo utilizar en mis proyectos en C#.
Se divide en los siguientes espacios:
NSUtils <--contenedor de los restantes (Base)
NSBase <-- cuenta con operaciones sobre los tipos básicos y controles mas comunes de un formulario windows
NSDatagrid <-- cuenta con operaciones sobre controles Dtagridview y sus componentes, columnas, filas etc..
NSBusqueda <-- cuenta con operaciones especiales de busqueda y creacion de reportes
NSGestoresEventos<-- Este es un espacio que creé para experimentar con delegados y controladores de eventos.
using System;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
#region Espacios Datos
//Datos OleDB
using System.Data;
using System.Data.OleDb;
//Mysql
using MySql.Data.MySqlClient;
using MySql.Data.Types;
//Para trabajar con CURRENCY
using System.Globalization;
#endregion
//MIS LINKS:
//Tecla intro http://www.elguille.info/NET/dotnet/pulsarTeclas.htm relacionado con fIsNumeric
#region Notas
//STATIC: Compartidos. Pag114, vida de una variable. Se mantiene durante todo el programa. No se
// destruye. Permite compartir la var/proc con las clases internas.
//PUBLIC (c,v,p): Son completamente accesibles, incluso desde otros ensamblados
//INTERNAL(c,v,p): Accesibles para todas las clases pero siempre que sean del mismo ensamblado
//PRIVATE (c,v,p): Solo accesibles dentro del ambito donde se encuentran. NO son HEREDABLES en el caso de "c"
//PROTECTED(v,p): Accesible dentro de la propia clase y las derivadas de ella.
//
//*En un procedimiento y/o funcion el argumento conexion siempre se pone al final
//struct: Pag 122
//enum: Pag 117
//operadores logicos: Pag 144
//NOTA sobre Clases: Para llamar a atributos (variables) de una clase no hace falta
//crear el objeto pero si para sus metodos/funciones
//
#endregion
namespace NSUtils
{
#region NSBase
namespace NSBase
{
///
/// Clase con mis tipos predefinidos
/// enum Navega { Neutro, Inicio, Anterior, Siguiente, Final }
/// enum Menu(Neutro,Nuevo,Modificar,Borrar,Duplicar), Opcion(Neutro, Aceptar, Cancelar)
///
public static class CTipos
{
public static Label lblAviso = new Label();
//Tiene relacion con los botones del panel Navega
public enum Navega { Neutro, Inicio, Anterior, Siguiente, Final };
//Son las distintas opciones que se puede hacer con un registro
public enum Menu { Neutro, Nuevo, Modificar, Borrar, Duplicar };
//Son las opciones de confirmacion, sirven para guardar el estado
public enum Opcion { Neutro, Aceptar, Cancelar }
}//FIN CLASE clsTipos
///
/// Clase con todos los metodos generales
///
public static class CAccionBase
{
//Hay Acciones que usan funciones en CFuncion por eso necesito esta variable
//private CFuncion CFuncion;
///
///HACE: BLOQUEA todos los controles dentro de un panel siempre y cuando no
///sean Label o Button
///SE USA: por ejemplo al cargar un formulario o al agregar, editar un registro.
///
///
Si se bloqueara o no el/los controles que tiene el panel ///
El control tipo Panel donde se realizara el bloqueo o desbloqueo public static void desbloquea_controles(bool bBloquea, Panel oPanel)
{
try
{
if (!bBloquea)
{
foreach (Control pCntrl in oPanel.Controls)
{
//¬(a v b)= ¬a ^ ¬b, si es lbl o boton se bloquean
if (!((pCntrl is Label) || (pCntrl is Button)))
{
pCntrl.Enabled = false;
pCntrl.BackColor = Color.Beige;
}
}
}
else
{
foreach (Control pCntrl in oPanel.Controls)
{
if ((pCntrl is ComboBox) || (pCntrl is TextBox) || (pCntrl is DateTimePicker))
{
pCntrl.Enabled = true;
pCntrl.BackColor = Color.White;
}
}
}
}
catch (Exception e)
{
CTipos.lblAviso.Text = " Error:pBloqueaCampos() " + e.ToString();
}
}//FIN DE BLOQUEA CAMPOS
///
///HACE: ASIGNA a los textbox y el label de "ID" el caracter vacio.
///SE USA: Al crear un nuevo registro, lo mejor es sustituirlo por uno de valores por defecto.
///
///
El nombre de la etiqueta labelID q sera limpiada ///
El control tipo Panel donde se realiazara esta asigancion public static void inserta_blancos(string sNomEtiqueta, Panel oPanel)
{
foreach (Control oControl in oPanel.Controls)
{
if (oControl is TextBox)
{
oControl.Text = "";
}
if ((oControl is Label) && (oControl.Name == sNomEtiqueta))
{
oControl.Text = "";
}
}
}//Fin LimpiaText
///
///HACE: LLENA desde una sentencia SQL un array
///SE USA: Por ejemplo para pedir todos los paises en la BD y guardarlo en un array
///
///
La sentencia SELECT completa con un solo campo ///
Este parametro es solo para saber sobre que tabla se hace el SELECT ///
El Array en el que se llenarn los datos ///
La conexion a la base de datos public static void sql_a_array(string sSQL, string sNombreTabla, ref string[] sArLista, OleDbConnection oConx)
{
OleDbDataAdapter oAdaptador;
DataSet oDataset = new DataSet();
//El objeto es el contenido de una celda (FilaI,ColumnaJ)
object oAuxObjeto;
int iNumPaises;
try
{
oAdaptador = new OleDbDataAdapter(sSQL, oConx);
oAdaptador.Fill(oDataset, sNombreTabla);
iNumPaises = oDataset.Tables[sNombreTabla].Rows.Count;
sArLista = new string[iNumPaises];
for (int i = 0; i < iNumPaises; i++)
{
//La columna siempre es 0 es decir la primera
oAuxObjeto = oDataset.Tables[sNombreTabla].Rows[i][0];
sArLista[i] = CFuncionBase.valor_de_celda_sin_null(oAuxObjeto);
}
}
catch (Exception e)
{
MessageBox.Show(" Error:pSqlaArray()" + e.ToString());
}
}
///
/// HACE: LLENA desde una sentencia SQL un array
/// SE USA: Por ejemplo para pedir todos los paises en la BD y guardarlo en un array
///
///
///
///
public static void sql_a_array(string sSQL, ref string[] sArLista, OleDbConnection oConx)
{
OleDbDataAdapter oAdaptador;
DataSet oDataset = new DataSet();
//El objeto es el contenido de una celda (FilaI,ColumnaJ)
object oAuxObjeto;
int iNumPaises;
try
{
oAdaptador = new OleDbDataAdapter(sSQL, oConx);
oAdaptador.Fill(oDataset, "RESULTADOS");
iNumPaises = oDataset.Tables["RESULTADOS"].Rows.Count;
sArLista = new string[iNumPaises];
for (int i = 0; i < iNumPaises; i++)
{
//La columna siempre es 0 es decir la primera
oAuxObjeto = oDataset.Tables["RESULTADOS"].Rows[i][0];
sArLista[i] = CFuncionBase.valor_de_celda_sin_null(oAuxObjeto);
}
}
catch (Exception e)
{
MessageBox.Show(" Error:pSqlaArray()" + e.ToString());
}
}
///
///HACE: LLENA un control COMBOBOX con un array de tipo string
///SE USA: Por ejemplo para llenar los paises y sus ciudades en un combo
///
///
El Array con los valores que se pasaran al ComboBox ///
public static void array_a_combobox(string[] sArValores, ref ComboBox oCombo)
{
int iNumValores;
try
{
iNumValores = sArValores.Length;
//Se limpia el combo
oCombo.Items.Clear();
for (int i = 0; i < iNumValores; i++)
{
oCombo.Items.Add(sArValores[i]);
}
oCombo.SelectedIndex = 0;
}
catch (Exception e)
{
MessageBox.Show("Error:pArrayaCombo() " + e.ToString());
}
}
///
///HACE: ACTUALIZA el registro en que se encuentra al presionar los botones de navegacion
///SE USA: En los eventos de los botones de navegacion, solo en los FORMS q no usen tablas
///
///
Si es Inicio, Anterior, Siguiente, Final ///
Se usa para comprobar que se llego al final del recorrido ///
Variable a ser modificada cRegActual public static void navega_por_registros(CTipos.Navega tOpcion, int iNumRegs, ref int iRegActual)
{
try
{
switch (tOpcion)
{
case CTipos.Navega.Anterior:
if (iRegActual > 0)
{
iRegActual--;
}
else
{
iRegActual = 0;
}
break;
case CTipos.Navega.Siguiente:
if (iRegActual < (iNumRegs - 1))
{
iRegActual++;
}
else
{
iRegActual = iNumRegs - 1;
}
break;
case CTipos.Navega.Inicio:
if (tOpcion == CTipos.Navega.Inicio)
{
iRegActual = 0;
}
break;
case CTipos.Navega.Final:
if (tOpcion == CTipos.Navega.Final)
{
iRegActual = iNumRegs - 1;
}
break;
default:
CTipos.lblAviso.Text = "";
CTipos.lblAviso.Text = "No se asigno |< << >> >|";
break;
}
}
catch (Exception e)
{
MessageBox.Show(" Error:pNavegaRegistros()" + e.ToString());
}
}
///
///HACE: BORRA un unico registro pasandole directamente un SQL con DELETE.
///SE USA: Al presionar el boton ACEPTAR, en el procedimiento ACEPTAR_ELIMINAR
///
///
El string completo DELETE FROM cNomTabla WHERE ID.. ///
public static void sql_elimina_registro(string sSQL, OleDbConnection oConx)
{
OleDbCommand oComando;
try
{
oComando = new OleDbCommand(sSQL, oConx);
oComando.ExecuteNonQuery();
}
catch (Exception e)
{
MessageBox.Show("ERROR: oEventlimaRegistro() " + e.ToString());
}
}
///
///HACE: BORRA uno o varios registros desde un SQL con DELETE unido al Array de IDS
///ejemplo: "DELETE FROM cNomTabla WHERE IDPROV='" + ArIDS[i] +"'";
///SE USA: Normalmente para borrar en grupo desde un DATAGRIDVIEW
///
///
"DELETE FROM cNomTabla WHERE ID='" ///
El Array con todos los IDS de los registros que se borraran ///
public static void sql_elimina_registros(string sSQL, string[] sArIds, OleDbConnection oConx)
{
OleDbCommand oComando;
string sSQLCompleto;
for (int i = 0; i < sArIds.Length; i++)
{
sSQLCompleto = sSQL + sArIds[i] + "'";
try
{
oComando = new OleDbCommand(sSQLCompleto, oConx);
oComando.ExecuteNonQuery();
}
catch (Exception e)
{
MessageBox.Show(" ERROR oEventliminaRegistrosDesdeArray(): " + e.ToString());
}
}
}
///
/// HACE: ACTUALIZA un dataset cualquiera con un SQL leido
/// SE USA: Por ejemplo en el form SQL
///
///
///
///
public static void sql_llena_dataset(string sSQL, ref DataSet oDataset, OleDbConnection oConx)
{
OleDbDataAdapter oAdaptador;
oDataset = new DataSet(); //Limpio el DATASET
try
{
oAdaptador = new OleDbDataAdapter(sSQL, oConx);
oAdaptador.Fill(oDataset, "tabla");
}
catch (Exception e)
{
e.ToString();
}
}
public static void sql_llena_dataset(string sSQL, string sNombre, ref DataSet oDataset, OleDbConnection oConx)
{
OleDbDataAdapter oAdaptador;
oDataset = new DataSet();
try
{
oAdaptador = new OleDbDataAdapter(sSQL, oConx);
oAdaptador.Fill(oDataset, sNombre);
}
catch (Exception e)
{
e.ToString();
}
}
///
///HACE: ACTUALIZA un cDataset y el cNumRegs de una clase, usando un SELECT * by idn
///SE USA: Al ejecutar el constructor de una clase. usar en lugar de cBDataset()
///
///
La tabla sobre la cual se hara el SELECT ///
Variable de clase cNumRegs ///
El Dataset de clase cDataset ///
public static void llena_dataset_con_todos(string sNombreTabla, ref int iNumRegs, ref DataSet oDataset, OleDbConnection oConx)
{
OleDbDataAdapter oAdaptador;
string sSQL;
oDataset = new DataSet(); //Limpio el DATASET
sSQL = "SELECT * FROM " + sNombreTabla + " ORDER BY idn";
try
{
oAdaptador = new OleDbDataAdapter(sSQL, oConx);
oAdaptador.Fill(oDataset, sNombreTabla);
//Actualizo el numero de registros en caso de DELETE E INSERT
iNumRegs = oDataset.Tables[sNombreTabla].Rows.Count;
}
catch (Exception e)
{
MessageBox.Show("ERROR en pActualizaDataSetGeneral(): " + e.ToString());
}
}
///
///HACE: ACTUALIZA un cDataset de una clase, usando un SELECT * by idn
///SE USA: Al ACEPTAR NUEVO en lugar de cDataset=oDataset;
///
///
La tabla sobre la cual se hara el SELECT ///
El Dataset de clase cDataset ///
public static void llena_dataset_con_todos(string sNombreTabla, ref DataSet oDataset, CBaseDatos oBD)
{
MySqlDataAdapter oAdaptador;
string sSQL;
oDataset = new DataSet(); //Limpio el DATASET
sSQL = "SELECT * FROM " + sNombreTabla + " ORDER BY idn";
try
{
oAdaptador = new MySqlDataAdapter(sSQL, oBD.oConn);
oAdaptador.Fill(oDataset, sNombreTabla);
}
catch (Exception e)
{
MessageBox.Show("ERROR en llena_dataset_con_todos(): " + e.ToString());
}
}
///
///NOTA: clase Hibrida: Formulario con un panel de controles y otro con un datagridview
///HACE: ACTUALIZA un cDataset y el cNumRegs de una clase Hibrida.
///SE USA: Al ejecutar el constructor de una clase. usar en lugar de cBDataset()
///
///
SELECT completo by idn ///
cNumRegs ///
cDataset ///
public static void llena_dataset_con_todos_hibrido(string sSQL, ref int iNumRegs, ref DataSet oDataset, OleDbConnection oConx)
{
OleDbDataAdapter oAdaptador;
oDataset = new DataSet(); //Limpio el DATASET
try
{
oAdaptador = new OleDbDataAdapter(sSQL, oConx);
oAdaptador.Fill(oDataset, "tabla");
//Actualizo el numero de registros en caso de DELETE E INSERT
iNumRegs = oDataset.Tables["tabla"].Rows.Count;
}
catch (Exception e)
{
MessageBox.Show("ERROR en llena_dataset_con_todos_hibrido(): " + e.ToString());
}
}
///
///HACE: BUSCA y deja SELECCIONADO un item dentro de un COMBOBOX
///SE USA: Al editar un registro, se hace un resguardo y este se busca para dejarlo
///seleccionado
///
///
El valor que se buscara en la lista de items del ComboBox ///
El ComboBox donde se buscara y se dejara seleccionado ese valor public static void autoselecciona_item_en_combo(string sABuscar, ref ComboBox oComboBox)
{
bool isFound;
int j, iNumItems;
iNumItems = oComboBox.Items.Count;
try
{
if (iNumItems > 0)
{
j = 0; isFound = false;
while ((j < iNumItems) && (!isFound))
{
oComboBox.SelectedIndex = j;
if (sABuscar == oComboBox.SelectedItem.ToString())
{
oComboBox.SelectedIndex = j;
isFound = true;
}
else
{
j++;
}
}
if (!isFound)
{
MessageBox.Show("VALOR NO ENCONTRADO SE ASIGNARA EL PRIMERO DE LA LISTA!!");
oComboBox.SelectedIndex = 0;
}
}
else
{
MessageBox.Show(oComboBox.Name.ToString() + " esta vacio");
}
}
catch (Exception e)
{
MessageBox.Show("ERROR en pBuscaUnItemYloSelecciona(): " + e.ToString());
}
}
///
/// HACE: CONVIERTE a mayusculas el texto que se va introduciendo en un TEXTBOX
/// SE USA: En el evento TextChanged de un TEXTBOX
///
///
public static void a_mayusculas(ref KeyPressEventArgs oEvent)
{
oEvent.KeyChar = char.ToUpper(oEvent.KeyChar);
}
///
/// HACE: EVALUA los caracteres que se van introduciendo en TEXTBOX
/// SE USA: En evento KEYPRESS de un TEXTBOX
///
///
KeyPressEventArgs public static void valida_chars_telefono(ref KeyPressEventArgs oEvent)
{
//TODO puedo crear una lista de caracters validos
if (((oEvent.KeyChar >= '0') && (oEvent.KeyChar <= '9')) || (oEvent.KeyChar == '+') || (oEvent.KeyChar == ' ') || (oEvent.KeyChar == '-') || (oEvent.KeyChar == '\r') || (oEvent.KeyChar == '\b'))
{
}
else
{
oEvent.Handled = true;
}
}
///
/// HACE: OCULTA un grupo de Pestañas, excepto la seleccionada
/// SE USA: Al realizar alguna accion NUEVO, ELIMINAR, DUPLICAR.. en
/// un FORMULARIO HIBRIDO
///
///
Es el Array de Pestañas guardado al comienzo public static void oculta_pestanas(TabPage[] oArTabPages, TabControl oTabControl)
{
int iNumTabs;
int iIndex;
iIndex = oTabControl.SelectedIndex;
iNumTabs = oTabControl.TabCount;
for (int i = 0; i < iNumTabs; i++)
{
if (i != iIndex)
{
oTabControl.TabPages.Remove(oArTabPages[i]);
}
}
}
}//FIN CLASE CAccionBase
///
///Clase que tiene exclusivamente Funciones Globales
///
public static class CFuncionBase
{
///
/// Devuelve el RadioButton.text que esta marcado
///
///
///
public static string valor_radiobutton_seleccionado(GroupBox oGroupBox)
{
//RadioButton oCtrl = new RadioButton();
foreach (RadioButton oRadioButton in oGroupBox.Controls)
{
if (oRadioButton.Checked)
{
return oRadioButton.Text;
}
}
return "";
}
///
///HACE: DEVUELVE un unico valor dependiendo del SELECT exclusivo, es decir
///que se basa en un ID ejemplo: select Nombre from 26Paises where IDPAIS=valor
///SE USA: Al llenar el equivalente, por ejemplo el dato: "NOMBRE", de un ID para posteriormente
///ser mostrado.
///
///
"SELECT UnCampo FROM UnaTabla WHERE ID=Valor" ///
/// UnUnicoValor o sino existe "SIN ASIGNAR"
public static string valor_de_un_campo(string sSQL, OleDbConnection oConx)
{
OleDbDataAdapter oAdaptador;
DataSet oDataset = new DataSet();
//Es el unico valor que sera devuelto
string sResultado;
try
{
oAdaptador = new OleDbDataAdapter(sSQL, oConx);
oAdaptador.Fill(oDataset, "tabla");
if (oDataset != null)
{
//El nombre de la tabla sera igual al nombre del campo devuelto
sResultado = oDataset.Tables["tabla"].Rows[0][0].ToString();
}
else
{
sResultado = "NEX";
}
return sResultado;
}
catch (Exception e)
{
MessageBox.Show(" Error:fDevuelveUnUnicoValor() " + e.ToString());
return "Se ejecuto Exeption";
}
}
///
///HACE: DEVUELVE un valor tipo string despues de verificar una celda en un grid o dataset
///para q no sea null algo que da muchos problemas
///SE USA: Al pasar de celdas a estructuras.
///
///
Tabla.Rows.Columna /// Si es null=>"SIN ASIGNAR" sino objCelda.ToString()
public static string valor_de_celda_sin_null(object objCelda)
{
//Toda celda es de tipo object y tiene tres estados no determinado=null,
//vacia="" y llena="sdf algo"
try
{
if (objCelda == null)//Si la celda esta vacia
{
return "SIN ASIGNAR";
}
else
{
return objCelda.ToString();
}
}
catch (Exception e)
{
MessageBox.Show(" Error:valor_de_celda_sin_null()" + e.ToString());
return "Se ejecuto Exception";
}
}
///
/// Devuelve false si el estado del DgvCell es null o false
/// sino devuelve true
///
///
La celda a verificar /// true o false
public static bool isChecked(DataGridViewCell oDgvCell)
{
try
{
if (oDgvCell is DataGridViewCheckBoxCell)
{
if ((oDgvCell == null) || (oDgvCell.Value.ToString() == "false"))
{
return false;
}
else
{
return true;
}
}
return false;
}
catch
{
return false;
}
}
///
///TODO si se comienza en 000000 dar un error pq se comienza a leer desde 1
///es decir no se cuenta con esta existencia el rango es de [1-n]
///Al crear nuevo registro este p asigna la ID nueva
///
///
Ejemplo: Para pagos PAG ///
IDPAGO ///
NºPAGOS ///
///
public static string calcula_id(string sPrefijoId, string sNombreCampoId, string sNombreTabla, OleDbConnection oConx)
{
OleDbDataAdapter oAdaptador;
DataSet oDataset = new DataSet();
bool isFound;
object objAuxCelda; //Celda a comprobar si es NULL
string sSQL; //Select q dvulve tbla con una columna
string sIdObtenido; //El valor q le corresponde al ID
string sAux; //Dspues d comprobar NULL se guarda l contnido
int iNumRegs; //La cantidad de registros en la tabla
int iNumCaracteresId; //El numero de carac de los q se compone el ID
int j, iAux; //j=Indice para recorrer con While iAux:para hacer calculos
int[] iArNumerosId; //Matriz con los valores numericos de los IDS
try
{
sSQL = "SELECT " + sNombreCampoId + " FROM " + sNombreTabla + " ORDER BY " + sNombreCampoId;
oAdaptador = new OleDbDataAdapter(sSQL, oConx);
oAdaptador.Fill(oDataset, "lista_ids");
objAuxCelda = oDataset.Tables["lista_ids"];
if (objAuxCelda != null)
{
iNumRegs = oDataset.Tables["lista_ids"].Rows.Count;
iArNumerosId = new int[iNumRegs];
sAux = "";
//Pasamos a Entero quitando los 0's y lo guardamos en una matriz los IDS
for (int i = 0; i < iNumRegs; i++)
{
objAuxCelda = oDataset.Tables["lista_ids"].Rows[i][0];
sAux = objAuxCelda.ToString();
sAux = sAux.Remove(0, sPrefijoId.Length);
iArNumerosId[i] = int.Parse(sAux);
}
//numero de caracteres de los que se compone el ID
iNumCaracteresId = sAux.Length;
j = 0; sIdObtenido = ""; iAux = 0;
isFound = false;
while (!isFound)
{
if (j + 1 != iArNumerosId[j])
{
sIdObtenido = (j + 1).ToString();
isFound = true;
}
else if (j + 1 == iNumRegs)
{
iAux = j + 2;
sIdObtenido = iAux.ToString();
isFound = true;
}
j++;
}
if (sIdObtenido.Length < iNumCaracteresId)
{
iAux = (iNumCaracteresId - sIdObtenido.Length);
for (int i = 0; i < iAux; i++)
{
sIdObtenido = "0" + sIdObtenido;
}
}
sIdObtenido = sPrefijoId + sIdObtenido;
return sIdObtenido;
}
else
{
sIdObtenido = "ERROR EN LA OBTENCION DEL ID";
NSBase.CTipos.lblAviso.Text = sIdObtenido;
return sIdObtenido;
}
}
catch (ArgumentOutOfRangeException e)
{
return MessageBox.Show(e.ToString()).ToString();
}
}
///
/// HACE: CALCULA el ID que le corresponde a un nuevo registro
/// SE USA: Al crear un nuevo registro
///
///
///
///
///
///
///
public static string calcula_id(string sNomTabla, string sNomCampoId, string sPrefijoId, int iNumDigitosNumeros, OleDbConnection oConx)
{
OleDbDataAdapter oAdaptador;
DataSet oDataset = new DataSet();
bool isFound;
object objAuxCelda; //Celda a comprobar si es NULL
string sSQL; //Select q dvulve tbla con una columna
string sIdObtenido; //El valor q le corresponde al ID
string sAux; //Dspues d comprobar NULL se guarda l contnido
int iNumRegs; //La cantidad de registros en la tabla
int j, iAux; //j=Indice para recorrer con While iAux:para hacer calculos
int[] iArNumerosId; //Matriz con los valores numericos de los IDS
try
{
sSQL = "SELECT " + sNomCampoId + " FROM " + sNomTabla + " ORDER BY " + sNomCampoId;
oAdaptador = new OleDbDataAdapter(sSQL, oConx);
oAdaptador.Fill(oDataset, "lista_ids");
objAuxCelda = oDataset.Tables["lista_ids"];
iNumRegs = oDataset.Tables["lista_ids"].Rows.Count;
if (iNumRegs > 0)
{
//Array de tamaño igual a la cantidad de registros
iArNumerosId = new int[iNumRegs];
//Para guardar el IDCOMPLETO y seguidamente el IDSINPREFIJO
sAux = "";
//GUARDA LOS IDS EXISTENTES EN EL ARRAY
for (int i = 0; i < iNumRegs; i++) { objAuxCelda = oDataset.Tables["lista_ids"].Rows[i][0]; sAux = objAuxCelda.ToString(); sAux = sAux.Remove(0, sPrefijoId.Length); iArNumerosId[i] = int.Parse(sAux); } //SI TODO ESTA ORDENADO SE DEBE CUMPLIR QUE AR[j]=0..0j=>AR[j]=j
//si no hay una concidencia se ejecutara el if
//si se respeta la concidencia hasta el final se ejecutara el if
//j Indicie para recorrer el array
//iAux Guarda el Numero que le correspondera al ID
//sIdObtenido Guarda el iAux en formato string
j = 0; sIdObtenido = ""; iAux = 0;
isFound = false;
while (!isFound)
{
//Si no coinciden
if (j != iArNumerosId[j])
{
iAux = j;
isFound = true;
}
//Si coinciden y se llega al final
else if (j + 1 == iNumRegs)
{
iAux = j + 1;
isFound = true;
}
j++;
}
sIdObtenido = iAux.ToString();
//iAux Guarda la cantidad de digitos numericos faltantes
//que se llenaran con 0`s
if (sIdObtenido.Length < iNumDigitosNumeros)
{
iAux = (iNumDigitosNumeros - sIdObtenido.Length);
for (int i = 0; i < iAux; i++)
{
sIdObtenido = "0" + sIdObtenido;
}
}
}
else
{
sIdObtenido = "";
for (int i = 0; i < iNumDigitosNumeros; i++)
{
sIdObtenido = sIdObtenido + "0";
}
}
sIdObtenido = sPrefijoId + sIdObtenido;
return sIdObtenido;
}
catch (ArgumentOutOfRangeException e)
{
return MessageBox.Show(e.ToString()).ToString();
}
}
///
///HACE: DEVUELVE true o false dependiendo si una cadena completa es un numero entero o no
///SE USA: Al buscar si se presiona una tecla, para verificar que lo que se inserta es un
///numero entero bien formado.
///
///
El string a comprobar /// Si existe algun caracter no numerico devuelve false
public static bool isNumerico(string sAComprobar)
{
foreach (char cChar in sAComprobar)
{
if (!Char.IsNumber(cChar))
{
return false;
}
}
return true;
}
///
/// Segun un SQL se sabe si devuelve registros o no
///
///
///
///
public static bool isInTable(string sSQL, OleDbConnection oConx)
{
OleDbCommand oComando = new OleDbCommand(sSQL, oConx);
OleDbDataReader oLector;
oLector = oComando.ExecuteReader();
if (oLector.HasRows)
{
oLector.Close();
return true;
}
else
{
oLector.Close();
return false;
}
}
///
///HACE: DEVUELVE true o false dependiendo si existe o no un RegistroID en una tabla, el usa un
///select exclusivo concatenando los argumentos.
///SE USA: Despues de agregar un registro dentro de un while para verificar que se ha actualizado
///en la BD
///
///
La tabla donde se buscara el registro ///
El nombre del campo de ID ///
El ID ///
///
public static bool isInTable(string sNomTabla, string sNomCampo, string sId, OleDbConnection oConx)
{
string sSQL = "SELECT * FROM " + sNomTabla +
" WHERE " + sNomCampo + "='" + sId + "'";
OleDbCommand oComando = new OleDbCommand(sSQL, oConx);
OleDbDataReader oLector;
oLector = oComando.ExecuteReader();
if (oLector.HasRows)
{
oLector.Close();
return true;
}
else
{
oLector.Close();
return false;
}
}
///
/// HACE: DEVUELVE true o false dependiendo si existe o no un RegistroID en una tabla, el usa un
/// select exclusivo concatenando los argumentos.
/// SE USA: Despues de agregar un registro dentro de un while para verificar que se ha actualizado
/// en la BD
///
///
"SELECT * FROM tabla WHERE campo_id='" ///
///
///
public static bool isInTable(string sSQL, string sId, OleDbConnection oConx)
{
sSQL = sSQL + sId + "'";
OleDbCommand oComando = new OleDbCommand(sSQL, oConx);
OleDbDataReader oLector;
oLector = oComando.ExecuteReader();
if (oLector.HasRows)
{
oLector.Close();
return true;
}
else
{
oLector.Close();
return false;
}
}
///
/// HACE: CARGA UNA IMAGEN .png DESDE LA RUTA C:\csharp\TTNoBorrar\Thumbs\
/// SE USA: Al navegar o pasar un registro a los controles
///
///
ID que es al mismo tiempo el NOMBRE de la imagen almacenada en la ruta anterior ///
private static Bitmap get_imagen(string sNombreImagen)
{
//Contenedor para almacenar imagenes para poder tratarlas
//despues
Bitmap oBitmap;
string sRutaImagen = @"C:\csharp\TTNoBorrar\Thumbs\" + sNombreImagen + ".png";
try
{
oBitmap = new Bitmap(sRutaImagen);
return oBitmap;
}
catch (Exception e)
{
MessageBox.Show(" ERROR: obtener_imagen() " + e.ToString());
return null;
}
}
}//FIN CLASE CFuncionBase
public static class CInt
{
///
/// Lista de los caracteres validos para poder crear un numero int
///
private static char[] cArValidos = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '\b' };
///
/// HACE: COMPRUEBA si un caracter (keychar) esta en el array Validos
/// SE USA: Al intentar validar un caracter introducido en un TEXTBOX
///
///
El caracter a comprobar en la lista ///
private static bool isValido(char cChar)
{
foreach (char unChar in cArValidos)
{
if (cChar == unChar)
{
return true;
}
}
return false;
}
///
/// HACE: VALIDA cada tecla que se va presionando
/// SE USA: En el evento OnKeyPress de un TEXTBOX
///
///
KeyPressEventArgs public static void valida_keypress(ref KeyPressEventArgs oEvent)
{
if (isValido(oEvent.KeyChar))
{
if (oEvent.KeyChar == '.')
{
oEvent.KeyChar = ',';
}
}
else
{
//Con esto no se imprime en pantalla el caracter
oEvent.Handled = true;
}
}
public static void sintaxis_on_leave(TextBox oTextBox)
{
int iInt;
try
{
iInt = int.Parse(oTextBox.Text);
}
catch
{
oTextBox.Focus();
}
}
///
/// HACE: CONVIERTE un valor tipo string en int
/// y lo devuelve, en caso de un fallo devuelve 0
/// SE USA: Para evitar el int.parse, ya que este no controla
/// el error
///
///
un valor int en formato string /// 0 si algo falla o el Valor si todo va bien
private static int a_entero(string sValor)
{
int iResultado;
try
{
iResultado = int.Parse(sValor);
}
catch //Si hay error
{
iResultado = 0;
}
return iResultado;
}
///
/// HACE: DEVUELVE un valor int dependiendo del contenido del textbox
/// si este no es correcto devolvera 0.00
/// SE USA: Al asignar de CONTROLES a ESTRUCTURA en lugar del simple
/// int.parse(). Para evitar que se presione aceptar sin tabulacion
///
///
/// El valor o 0.00 en caso de ERROR
private static int text_a_entero(TextBox oTextBox)
{
int iInt;
try
{
iInt = int.Parse(oTextBox.Text);
}
catch
{
iInt = 0;
}
return iInt;
}
///
/// HACE: LEE el contenido de TEXTBOX y le aplica el int.Parse
/// si ocurre un ERROR devuelve FALSE sino TRUE
/// SE USA: Al validar el contenido de las cajas de texto antes de
/// AceptarNuevo o AceptarModificar
///
///
///
public static bool isNotInt(TextBox oTextBox)
{
int iInt;
try
{
iInt = int.Parse(oTextBox.Text);
return false;
}
catch
{
return true;
}
}
}//FIN CLASE CInt
///
/// Clase para trabajar con numeros Double y cajas de texto
///
public static class CDouble
{
///
/// Lista de los caracteres validos para poder crear un numero double
///
private static char[] cArValidos = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '\b', '.', ',' };
///
/// HACE: COMPRUEBA si un caracter (keychar) esta en el array Validos
/// SE USA: Al intentar validar un caracter introducido en un TEXTBOX
///
///
El caracter a comprobar en la lista ///
private static bool isValido(char cChar)
{
foreach (char unChar in cArValidos)
{
if (cChar == unChar)
{
return true;
}
}
return false;
}
///
/// HACE: VALIDA cada tecla que se va presionando
/// SE USA: En el evento OnKeyPress de un TEXTBOX
///
///
KeyPressEventArgs public static void valida_keypress(ref KeyPressEventArgs oEvent)
{
if (isValido(oEvent.KeyChar))
{
if (oEvent.KeyChar == '.')
{
oEvent.KeyChar = ',';
}
}
else
{
//Con esto no se imprime en pantalla el caracter
oEvent.Handled = true;
}
}
///
/// HACE: COMPRUEBA si se escribio bien un double
/// SE USA: En el evento OnLeave de un TEXTBOX
///
///
public static void sintaxis_on_leave(TextBox oTextBox)
{
const int iNumEnteros = 6;//4;
const int iNumDecimales = 2;
bool isComa = false;
bool isError = false;
int iContDecimal = 0;
int iContEntero = 0;
foreach (char cChar in oTextBox.Text)
{
if (cChar == ',')
{
if (isComa)
{
//"NO PUEDE TENER MAS DE UNA COMA 0,00 ";
isError = true;
break;
}
isComa = true;
}
else if (cChar >= '0' && cChar <= '9') { if (isComa) { if (iContDecimal >= iNumDecimales)
{
//"NO PUEDE TENER MAS DE DOS DECIMALES ,00 ";
isError = true;
//MessageBox.Show(oTextBox.Name.ToString());
break;
}
iContDecimal++;
}
else
{
if (iContEntero >= iNumEnteros)
{
//"NO PUEDE TENER MAS DE CUATRO ENTEROS 0000,00 ";
isError = true;
break;
}
iContEntero++;
}
}
}//Fin foreach
//Relleno con el 0 faltante en decimales
if (oTextBox.Text == "" || oTextBox.Text == ",")
{
oTextBox.Text = "0,00";
}
else if (!isError)
{
if (iContEntero == 0)
{
if (!isComa)
{
oTextBox.Text = "0," + oTextBox.Text;
}
else
{
oTextBox.Text = '0' + oTextBox.Text;
}
}
else if (iContEntero > 0 && iContEntero <= iNumEnteros)
{
if (!isComa)
{
oTextBox.Text = oTextBox.Text + ",00";
}
else
{
if (iContDecimal == 0)
{
oTextBox.Text = oTextBox.Text + "00";
}
else if (iContDecimal == 1)
{
oTextBox.Text = oTextBox.Text + "0";
}
}
}
}
else if (isError)
{
oTextBox.Focus();
oTextBox.SelectAll();
}
}
public static void sintaxis_on_leave2(TextBox oTextBox)
{
double fDouble;
try
{
fDouble = double.Parse(oTextBox.Text);
}
catch
{
oTextBox.Focus();
}
}
///
/// HACE: CONVIERTE un valor tipo string en DOUBLE
/// y lo devuelve, en caso de un fallo devuelve 0
/// SE USA: Para evitar el Double.parse, ya que este no controla
/// el error
///
///
un valor double en formato string /// 0 si algo falla o el Valor si todo va bien
public static double obtener_double(string sValor)
{
double fResultado;
try
{
fResultado = double.Parse(sValor);
}
catch //Si hay error
{
fResultado = 0.00;
}
return fResultado;
}
///
/// HACE: DEVUELVE un valor double dependiendo del contenido del textbox
/// si este no es correcto devolvera 0.00
/// SE USA: Al asignar de CONTROLES a ESTRUCTURA en lugar del simple
/// double.parse(). Para evitar que se presione aceptar sin tabulacion
///
///
/// El valor o 0.00 en caso de ERROR
public static double obtener_double(TextBox oTextBox)
{
double fDouble;
try
{
fDouble = double.Parse(oTextBox.Text);
}
catch
{
fDouble = 0.00;
}
return fDouble;
}
///
/// HACE: LEE el contenido de TEXTBOX y le aplica el double.Parse
/// si ocurre un ERROR devuelve FALSE sino TRUE
/// SE USA: Al validar el contenido de las cajas de texto antes de
/// AceptarNuevo o AceptarModificar
///
///
///
public static bool isNotDouble(TextBox oTextBox)
{
double fDouble;
try
{
fDouble = double.Parse(oTextBox.Text);
return false;
}
catch
{
return true;
}
}
///
/// HACE: PASA a un formato moneda con dos decimales un número double
/// SE USA: Al transferir datos de tipo moneda a un control
///
///
///
public static string obtener_moneda_esp(double fDouble)
{
NumberFormatInfo oNumberFormatInfo = new NumberFormatInfo();
string sResultado;
//FORMATO DE LA MONEDA
oNumberFormatInfo.CurrencyDecimalDigits = 2;
oNumberFormatInfo.CurrencyGroupSeparator = ".";
oNumberFormatInfo.CurrencyDecimalSeparator = ",";
oNumberFormatInfo.CurrencySymbol = "€ ";
sResultado = fDouble.ToString("c", oNumberFormatInfo);
//si es 0.35
if (fDouble >= 0)
{
sResultado = sResultado.Remove(0, 2);
}
//si es -0.54
else
{
sResultado = sResultado.Remove(sResultado.Length - 1, 1);
sResultado = sResultado.Remove(0, 3);
sResultado = "-" + sResultado;
}
return sResultado;
}
}//FIN CLASE CDouble
///
/// Clase para hacer calculos matematicos con TEXTBOXES
///
public static class CMatematicas
{
///
/// HACE: LEE un DOUBLE y comprueba si solo tiene parte entera,
/// si es asi lo devuelve con parte decimal a i,00
///
///
///
private static string double_sin_decimales(double fDouble)
{
string sResultado;
double fDoubleX100;
//Primero guarda DoubleX100 en entero
//Despues guarda el resto de ese Doublex100 /100
int iResto;
fDoubleX100 = fDouble * 100;
iResto = int.Parse(fDoubleX100.ToString());
iResto = iResto / 100;
//Si es 0 no hay decimales
if (iResto == 0)
{
sResultado = fDouble.ToString() + ",00";
}
else
{
sResultado = fDouble.ToString();
}
return sResultado;
}
///
/// HACE: DEVUELVE un string con digitos numericos del calculo
/// de un subtotal, este es inverso al del Total
/// SE USA: En el evento txtTOTAL_TextChanged
///
///
///
///
public static string fCalculaSubTot(TextBox fTxtTotal, double fPorcentIva)
{
double fSubtot;
double fTotal;
try
{
fTotal = double.Parse(fTxtTotal.Text);
fSubtot = (100 * fTotal) / (fPorcentIva + 100);
fSubtot = Math.Round(fSubtot, 2);
return CDouble.obtener_moneda_esp(fSubtot);
}
catch
{
fSubtot = 0.00;
return CDouble.obtener_moneda_esp(fSubtot);
}
}
///
/// HACE:A APLICA a un DOUBLE el porcentaje para obtener su "IVA"
/// SE USA: En el evento txtSUBTOT_TextChanged
///
///
///
Es el que se aplicara al subtotal ///
public static string fCalculaIva(TextBox fTxtSubtot, double fPorcentIva)
{
double fSubtot;
double fIva;
try
{
fSubtot = double.Parse(fTxtSubtot.Text);
fIva = fSubtot * (fPorcentIva / 100);
fIva = Math.Round(fIva, 2);
//return double_sin_decimales(fIva);
return CDouble.obtener_moneda_esp(fIva);
}
catch
{
fIva = 0.00;
return CDouble.obtener_moneda_esp(fIva);
}
}
///
/// HACE: SUMA dos cantidades DOUBLE y devuelve el resultado
/// SE USA: En el evento txtSUBTOT_TextChanged
///
///
///
///
public static string fCalculaTotal(TextBox fTxtSubtot, TextBox fTxtIva)
{
double fSubtot;
double fIva;
double fTotal;
try
{
fSubtot = double.Parse(fTxtSubtot.Text);
fIva = double.Parse(fTxtIva.Text);
fTotal = fSubtot + fIva;
return CDouble.obtener_moneda_esp(fTotal);
}
catch
{
fTotal = 0.00;
return CDouble.obtener_moneda_esp(fTotal);
}
}
public static string fCalculaMonto(TextBox fTxtUnidad, TextBox fTxtPreund)
{
double fUnidad;
double fPreund;
double fMonto;
try
{
fUnidad = double.Parse(fTxtUnidad.Text);
fPreund = double.Parse(fTxtPreund.Text);
fMonto = fUnidad * fPreund;
return CDouble.obtener_moneda_esp(fMonto);
}
catch
{
fMonto = 0.00;
return CDouble.obtener_moneda_esp(fMonto);
}
}
public static string fCalculaCambio(TextBox fTxtTotal, TextBox fTxtPago)
{
double fTotal;
double fPago;
double fCambio;
try
{
fTotal = double.Parse(fTxtTotal.Text);
fPago = double.Parse(fTxtPago.Text);
fCambio = fPago - fTotal;
return CDouble.obtener_moneda_esp(fCambio);
}
catch
{
fCambio = 0.00;
return CDouble.obtener_moneda_esp(fCambio);
}
}
///
/// HACE: DEVUELVE en Dolares americanos una cantidad en florines
/// ( cambio 1$=1.80 )
/// SE USA:
///
///
///
///
public static string fDolares(TextBox fTxtFlorin, double fTasCambio)
{
double fFlorines;
double fUsDolares;
try
{
fFlorines = double.Parse(fTxtFlorin.Text);
fUsDolares = fFlorines / fTasCambio;
fUsDolares = Math.Round(fUsDolares, 2);
//return double_sin_decimales(fIva);
return CDouble.obtener_moneda_esp(fUsDolares);
}
catch
{
fUsDolares = 0.00;
return CDouble.obtener_moneda_esp(fUsDolares);
}
}
//public static void cAver()
//{
// //CultureInfo nfi = new CultureInfo("es-ES", false);
// //NumberFormatInfo nfi = new CultureInfo("es-ES", false).NumberFormat;
// //NumberFormatInfo nfi = new NumberFormatInfo();
// //CREO EL OBJETO "INFORMACION DE CULTURA" para obtener los datos de cultura
// //española
// CultureInfo pCultNfo = new CultureInfo("es-ES", false);
// //CREO EL OBJETO "FORMATO DE NUMERO" para poder modificar la representacion
// //de los numeros.
// //NumberFormatInfo oNumberFormatInfo = (NumberFormatInfo)pCultNfo.Clone(); //NO SE PUEDE CASTEAR
// NumberFormatInfo oNumberFormatInfo = new NumberFormatInfo();
// //FORMATO DE LA MONEDA
// oNumberFormatInfo.CurrencyDecimalDigits = 2;
// oNumberFormatInfo.CurrencyDecimalSeparator = ",";
// oNumberFormatInfo.CurrencySymbol = "€ ";
// double IVA;
// //IVA= 3.0;
// //MessageBox.Show(IVA.ToString("C", oNumberFormatInfo));
// ////=> € 3,00
// //MessageBox.Show(IVA.ToString("C", pCultNfo));
// ////=> 3,00 €
// //if (Double.IsNaN(0 / zero))
// //{
// // Console.WriteLine("Double.IsNan() can determine whether a value is not-a-number.");
// //}
//}
}//FIN CLASE clsMatematicas
}//Fin nsBase
#endregion NSBase
#region NSDatagrid
namespace NSDatagrid
{
///
/// Estos metodos sirven para tratar con controles DataGridViews
///
public static class CDgvAccion
{
///
/// HACE: LLENA con un DATAGRIDVIEW segun el una sentencia SQL
///
///
Cualquier sentencia SELECT ///
El DATAGRIDVIEW donde se mostraran los datos ///
La conexion a la BD public static void llenar_dgv(string sSQL, ref DataGridView oDgv, OleDbConnection oConx)
{
BindingSource oBinder = new BindingSource();
OleDbDataAdapter oAdaptador = new OleDbDataAdapter(sSQL, oConx);
DataSet oDataset = new DataSet();
try
{
oAdaptador.Fill(oDataset, "tabla");
//Al binder general le digo su fuente de datos
oBinder.DataSource = oDataset;
//La fuente de datos del dg sera el binder
oDgv.DataSource = oBinder.DataSource;
oDgv.DataMember = "tabla";
}
catch
{
MessageBox.Show("SENTENCIA SQL INVALIDO", "ERROR", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
}
}
///
/// HACE: LLENA con un DATAGRIDVIEW segun el una sentencia SQL
///
///
Cualquier sentencia SELECT ///
El DATAGRIDVIEW donde se mostraran los datos ///
La conexion a la BD public static void llenar_dgv(string sSQL, ref DataGridView oDgv, CBaseDatos oBD)
{
BindingSource oBinder = new BindingSource();
MySqlDataAdapter oAdaptador = new MySqlDataAdapter(sSQL, oBD.oConn);
DataSet oDataset = new DataSet();
try
{
oAdaptador.Fill(oDataset, "tabla");
//Al binder general le digo su fuente de datos
oBinder.DataSource = oDataset;
//La fuente de datos del dg sera el binder
oDgv.DataSource = oBinder.DataSource;
oDgv.DataMember = "tabla";
}
catch
{
MessageBox.Show("SENTENCIA SQL INVALIDA", "ERROR", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
}
}
///
/// HACE: LLENA un DATAGRIDVIEW desde un dataset previamente con al menos una tabla
/// SE USA:
///
///
DATASET ya creado con datos ///
///
public static void llenar_dgv(DataSet oDataset, ref DataGridView oDgv)
{
DataTable oDataTable = new DataTable();
oDataTable = oDataset.Tables[0];
//La fuente de datos del dg sera el binder
oDgv.DataSource = oDataTable;
}
///
/// HACE: ASIGNA true a un CHECKBOXCELL si esta vacio o si esta en falso pero
/// si esta en true le asigna false.
/// SE USA:Al hacer click sobre una celda
///
///
public static void conmutar_valor_checkbox(ref DataGridView oDgv)
{
//En esta comprobacion hay un problema y es que el headercell
//es detectado como el checkboxcell[0,0]
if (oDgv.CurrentCell is DataGridViewCheckBoxCell)
{
DataGridViewCheckBoxCell oChkCell = new DataGridViewCheckBoxCell();
oChkCell.Value = oDgv.CurrentCell.Value;
if ((oChkCell.Value == null) || (bool.Parse(oChkCell.Value.ToString()) == false))
{
oChkCell.Value = true;
}
else
{
oChkCell.Value = false;
}
oDgv.CurrentCell.Value = oChkCell.Value;
}
}
///
/// HACE: LLENA un array con todos los IDS a borrar
/// SE USA: Al ejecutar ACEPTAR ELIMINAR
///
///
DGV con columna de ChecBox ///
Array para guardar los IDS public static void llenar_array_con_ids(DataGridView oDgv, ref string[] sAriIds)
{
int[] iArIndice;
int iNumRegs = 0;
iNumRegs = oDgv.Rows.Count;
//Array para guardar indices de filas con Checkbox=True
iArIndice = new int[iNumRegs];
//Tamaño del array igual al numero de filas con Checkbox=True
sAriIds = new string[CDgvFuncion.get_numero_celdas_marcadas(oDgv)];
//Asigno el indice si esta activado el checkbox
//sino asign un -1
for (int i = 0; i < iNumRegs; i++)
{
if (oDgv.Rows[i].Cells[0].Value == null)
{
iArIndice[i] = -1;
}
else if (bool.Parse(oDgv.Rows[i].Cells[0].Value.ToString()))
{
iArIndice[i] = i;
}
else
{
//En caso que este checkcell=false le agrego -1 como marca
iArIndice[i] = -1;
}
}
int j = 0; //Indice para ArIds
//Recorro todas las filas
for (int i = 0; i < iNumRegs; i++)
{
if (iArIndice[i] != -1)
{
sAriIds[j] = oDgv.Rows[i].Cells[1].Value.ToString();
j++;
}
}
}
///
/// HACE: ASIGNA un TRUE/FALSE a todas las celdas de la columna 0 de un control
/// DataGridView
/// SE USA:Al hacer Doble click sobre la cabecera de una columna CHECKBOX
///
///
///
public static void asigna_valor_columnacheckbox(bool bValor, ref DataGridView oDgv)
{
for (int i = 0; i < oDgv.RowCount; i++)
{
oDgv.Rows[i].Cells[0].Value = bValor;
}
}
///
/// HACE: MARCA Y DESMARCA las celdas de la columna 0 de un control DataGridView
/// esa columna tiene la obligacion de ser CHECKBOX
/// SE USA:Al hacer doble click en el HEADER de una columna CHECBOX
///
///
public static void marca_checkboxes_columna(ref DataGridView oDgv)
{
if (CDgvFuncion.isCheckbox(oDgv, false))
{
asigna_valor_columnacheckbox(true, ref oDgv);
}
else
{
asigna_valor_columnacheckbox(false, ref oDgv);
}
}
public static void set_estilo(ref DataGridView oDgv)
{
if (oDgv != null && oDgv.ColumnCount > 1)
{
//LE CAMBIO EL ASPECTO AL GRID
//http://pyme.net.uy/desarrolladores/herramientas/colores2.htm#16colores
//http://msdn.microsoft.com/en-us/library/74b2wakt.aspx
//Seleccion
oDgv.MultiSelect = false;
oDgv.SelectionMode = DataGridViewSelectionMode.FullRowSelect;
//Celda cabecera ezquina arriba izquierda
oDgv.TopLeftHeaderCell.Style.BackColor = Color.Black;
//ROWHEADERS
oDgv.RowHeadersWidthSizeMode = DataGridViewRowHeadersWidthSizeMode.DisableResizing;
oDgv.RowHeadersDefaultCellStyle.SelectionBackColor = Color.Crimson;
oDgv.RowHeadersDefaultCellStyle.SelectionForeColor = Color.Black;
//Bloquear edit en determinadas columnas
for (int i = 1; i < oDgv.ColumnCount - 1; i++)
{
oDgv.Columns[i].ReadOnly = true;
}
//Cabeceras
//COLUMNAS
//PARA QUE NO SE DESORDENE EL TITULO DEL HEADER
oDgv.ColumnHeadersHeightSizeMode = DataGridViewColumnHeadersHeightSizeMode.DisableResizing;
oDgv.ColumnHeadersBorderStyle = DataGridViewHeaderBorderStyle.Single;
for (int i = 0; i < oDgv.ColumnCount; i++)
{ //Alineacion texto
oDgv.Columns[i].HeaderCell.Style.Alignment = DataGridViewContentAlignment.MiddleCenter;
//Color fondo
oDgv.Columns[i].HeaderCell.Style.BackColor = Color.Black;
//Color texto
oDgv.Columns[i].HeaderCell.Style.ForeColor = Color.White;
}
//Cabeceras
//FILAS
oDgv.AllowUserToResizeRows = false;
oDgv.RowHeadersBorderStyle = DataGridViewHeaderBorderStyle.Single;
//color
oDgv.RowHeadersDefaultCellStyle.BackColor = Color.Black;
//GRILLA Lineas divisoras
oDgv.GridColor = Color.Gray;
//Filas con colores alternos
oDgv.RowsDefaultCellStyle.BackColor = Color.Pink;
oDgv.AlternatingRowsDefaultCellStyle.BackColor = Color.Linen;
//COLUMNAS
//Formato de datos
//oDgv.Columns[5].DefaultCellStyle.Format = "c";
//oDgv.Columns[6].DefaultCellStyle.Format = "c";
//Alineacion
oDgv.Columns[5].DefaultCellStyle.Alignment = DataGridViewContentAlignment.MiddleRight;
oDgv.Columns[6].DefaultCellStyle.Alignment = DataGridViewContentAlignment.MiddleRight;
//Fuentes (tipografia)
oDgv.DefaultCellStyle.Font = new Font("Tahoma", 9);
oDgv.DefaultCellStyle.ForeColor = Color.Black;
oDgv.DefaultCellStyle.BackColor = Color.LavenderBlush;
}
}
}//Fin de CDgvAccion
public static class CDgvFuncion
{
///
/// HACE: Devuelve el indice de la fila del checkbox en True
/// SE USA: Al borrar necesito almacenar los indices
///
///
///
public static int get_numero_celdas_marcadas(DataGridView oDgv)
{
int iCeldasMarcadas = 0;
for (int i = 0; i < oDgv.RowCount; i++)
{
if (oDgv.Rows[i].Cells[0].Value != null)
{
if (bool.Parse(oDgv.Rows[i].Cells[0].Value.ToString()))
{
iCeldasMarcadas++;
}
}
}
return iCeldasMarcadas;
}
///
/// HACE: Devuelve si existe o no un CheckBoxCell con valor igual a TRUE o FALSE
/// SE USA: Al maracar o desmarcar todos los CheckBoxCell tenemos que saber si existe
/// al menos uno marcado
///
///
///
///
public static bool isCheckbox(DataGridView oDgv, bool bValor)
{
try
{
for (int i = 0; i < oDgv.RowCount; i++)
{
if (oDgv.Rows[i].Cells[0].Value == null)
{
return true;
}
else if (bool.Parse(oDgv.Rows[i].Cells[0].Value.ToString()) == bValor)
{
return true;
}
}
//Si acaba el bucle es que no hay checkboxes con valor=bValor
return false;
}
catch (Exception e)
{
MessageBox.Show(" ERROR: isCheckbox() " + e.ToString());
return false;
}
}
///
/// HACE: Obtiene el valor de una celda de la columna sNomColumna y la fila
/// es la que esta seleccionada
/// SE USA: Cuando se va a pasar una determinada fila a una estructura se pide el ID
///
///
///
/// Si existe ese valor lo devuelve sino devuelve "NO EXISTE ID"
public static string get_sId(DataGridView oDgv, string sNomColumnaId)
{
DataGridViewRow oFila = new DataGridViewRow();
string sId;
try
{
oFila = oDgv.CurrentRow;
if (oFila != null)
{
sId = oFila.Cells[sNomColumnaId].Value.ToString();
}
else
{
sId = "NO EXISTE ID";
}
return sId;
}
catch (Exception e)
{
MessageBox.Show(" ERROR: id_fila_marcada() " + e.ToString());
return sId = "NO EXISTE ID";
}
}
///
/// HACE: Obtiene el valor de una celda de la columna sNomColumna y la fila
/// es la que esta seleccionada
/// SE USA: Cuando se va a pasar una determinada fila a una estructura se pide el ID
///
///
///
/// Si existe ese valor lo devuelve sino devuelve -1
public static int get_iId(DataGridView oDgv, string sNomColumnaId)
{
DataGridViewRow oFila = new DataGridViewRow();
int iId;
try
{
oFila = oDgv.CurrentRow;
if (oFila != null)
{
iId = int.Parse(oFila.Cells[sNomColumnaId].Value.ToString());
}
else
{
iId = -1;
}
return iId;
}
catch (Exception e)
{
MessageBox.Show(" ERROR: get_id() " + e.ToString());
return iId = -1;
}
}
public static double get_sumatorio(DataGridView oDgv, int iColIndex)
{
double fResultado = 0.00;
try
{
for (int i = 0; i < oDgv.RowCount; i++)
{
fResultado = fResultado + double.Parse(oDgv.Rows[i].Cells[iColIndex].Value.ToString());
}
return fResultado;
}
catch
{
return fResultado;
}
}
}//Fin de CFuncionDgv
public struct SParametrosColumna
{
internal string sHeader;
internal int iPosicion;
internal string sNombreCol;
internal string sTexto;
//El numero total de columnas que tendra este grid
//dependera del select que se meta en parametrosgrid
internal int iNumColumnas;
public SParametrosColumna(string sHeader, int iPosicion, string sNombreColumna, int iNumColumnas)
{
this.sHeader = sHeader;// " X ";
this.iPosicion = iPosicion; // 0;
this.sNombreCol = sNombreColumna; //"BORRAR";
this.iNumColumnas = iNumColumnas;// 7;
this.sTexto = "";
}
public SParametrosColumna(string sHeader, int iPosicion, string sNombreColumna, int iNumColumnas, string sTexto)
{
this.sHeader = sHeader;// " X ";
this.iPosicion = iPosicion; // 0;
this.sNombreCol = sNombreColumna; //"BORRAR";
this.iNumColumnas = iNumColumnas;// 7;
this.sTexto = sTexto;
}
}
///
/// Tiene los parametros y los metodos para crear los distintos tipos
/// de columnas en un DataGridView
///
public static class CColumnas
{
//CheckBox
public static void crear_columna_checkbox(SParametrosColumna stParametros, ref DataGridView oDgv)
{
if (oDgv.ColumnCount <= stParametros.iNumColumnas)
{
DataGridViewCheckBoxColumn oCheckboxColumn = new DataGridViewCheckBoxColumn();
//DataGridViewCheckBoxCell oCheckboxHeader = new DataGridViewCheckBoxCell();
oCheckboxColumn.HeaderText = stParametros.sHeader;
oCheckboxColumn.Name = stParametros.sNombreCol;
oCheckboxColumn.DisplayIndex = stParametros.iPosicion;
oCheckboxColumn.AutoSizeMode = DataGridViewAutoSizeColumnMode.AllCells;
oCheckboxColumn.FlatStyle = FlatStyle.Standard;
//Para que no exista el valor null
oCheckboxColumn.ThreeState = false;
//Al ser checbox es mejor readonly=true
oCheckboxColumn.ReadOnly = true;
//AGREGO LA COLUMNA
oDgv.Columns.Add(oCheckboxColumn);
}
}
//Boton
public static void crear_columna_boton(SParametrosColumna stParametros, ref DataGridView oDgv)
{
if (oDgv.ColumnCount <= stParametros.iNumColumnas)
{
//CREO LA COLUMNA
DataGridViewButtonColumn pColumnaBoton = new DataGridViewButtonColumn();
pColumnaBoton.Text = stParametros.sTexto;
pColumnaBoton.HeaderText = stParametros.sHeader;
pColumnaBoton.Name = stParametros.sNombreCol;
pColumnaBoton.DisplayIndex = stParametros.iPosicion;
pColumnaBoton.UseColumnTextForButtonValue = true;
pColumnaBoton.AutoSizeMode = DataGridViewAutoSizeColumnMode.AllCells;
pColumnaBoton.FlatStyle = FlatStyle.Standard;
pColumnaBoton.ReadOnly = true;
oDgv.Columns.Add(pColumnaBoton);
}
}
//Combo
public static void crear_columna_combobox(SParametrosColumna stParametros, ref DataGridView oDgv)
{
if (oDgv != null)
{
DataGridViewComboBoxColumn pColumnaComboBox = new DataGridViewComboBoxColumn();
pColumnaComboBox.HeaderText = stParametros.sHeader;
pColumnaComboBox.AutoSizeMode = DataGridViewAutoSizeColumnMode.AllCells;
pColumnaComboBox.FlatStyle = FlatStyle.Standard;
pColumnaComboBox.CellTemplate.Style.BackColor = Color.AliceBlue;
pColumnaComboBox.DisplayIndex = stParametros.iPosicion;
oDgv.Columns.Add(pColumnaComboBox);
}
}
//Imagen
public static void crear_columna_image(SParametrosColumna stParametros, ref DataGridView oDgv)
{
if (oDgv != null)
{
DataGridViewImageColumn pColumnaImageColum = new DataGridViewImageColumn();
pColumnaImageColum.HeaderText = stParametros.sHeader;
pColumnaImageColum.AutoSizeMode = DataGridViewAutoSizeColumnMode.AllCells;
//pColumnaImageColum.FlatStyle = FlatStyle.Standard;
pColumnaImageColum.CellTemplate.Style.BackColor = Color.AliceBlue;
pColumnaImageColum.DisplayIndex = stParametros.iPosicion;
oDgv.Columns.Add(pColumnaImageColum);
}
}
}//Fin de CColumnas
}//Fin nsDatagrid
#endregion NSDatagrid
#region NSBusqueda
namespace NSBusqueda
{
public class CAccion
{
//TODO A ELIMINAR
public static void pAgregaColumna(DataGridView oDgv, int pNumCols)
{
if (oDgv != null)
{
//refresca para evitar que repita 2 veces la col de botones
oDgv.Refresh();
if (oDgv.ColumnCount < pNumCols)
{
DataGridViewButtonColumn pColumnaBotones = new DataGridViewButtonColumn();
pColumnaBotones.HeaderText = "FORMULARIO";
pColumnaBotones.Text = "DETALLE";
pColumnaBotones.UseColumnTextForButtonValue = true;
pColumnaBotones.AutoSizeMode = DataGridViewAutoSizeColumnMode.AllCells;
pColumnaBotones.FlatStyle = FlatStyle.Standard;
pColumnaBotones.CellTemplate.Style.BackColor = Color.AliceBlue;
pColumnaBotones.DisplayIndex = 0; //Posicion boton
oDgv.Columns.Add(pColumnaBotones);
}
}
}
}//FIN CLASE CAccion
//Clase que solo tiene exclusivamente Funciones Globales
public class CFuncion
{
///
///HACE: DEVUELVE el ID completo dependiendo del IDGENERICO y un num entero.
///SE USA: Al buscar por ID sin necesidad de insertar el prefijo solo
///utilizando el numero relacionado.
///
///
Ejemplo:HOT00000 ///
Ejemplo:17 /// Ejemplo:HOT000017
public static string fDeNumAID(string fIDgenerico, int fNumAtratar)
{
int fNum_Ceros, fContDig, fContPref, fDiv;
string fPrefijo, sId;
fContDig = 0; fDiv = fNumAtratar;
//Cuento los digitos de los que consta el numero entero fNumAtratar
while (fDiv != 0)
{
fDiv = fDiv / 10;
fContDig++;
}
fPrefijo = ""; fContPref = 0;
//Obtengo el prefijo y su longitud
foreach (char cChar in fIDgenerico)
{
//Si el caracter no es numerico en HOT000000
//es decir en HOT
if (!Char.IsNumber(cChar))
{
//Guardo el caracter
fPrefijo = fPrefijo + cChar;
//Y cuento su cantidad
fContPref++;
}
}
//fNum_ceros=(HOT000000)=9-(HOT)=3
fNum_Ceros = fIDgenerico.Length - fContPref; //Cantidad de 0's del id generico
//Cantidad de 0's a faltantes para crear el HOT0..0fNumTratar
//fNum_Ceros=(000000)=6 - (cantidad de digitos en fNumTratar)=x
fNum_Ceros = fNum_Ceros - fContDig;
//fNumeroAtratar el valor numerico pasado como argumento
sId = fNumAtratar.ToString();
if (fNum_Ceros > 0)
{
for (int i = 0; i < fNum_Ceros; i++)
{
sId = "0" + sId;
}
}
sId = fPrefijo + sId;
return sId;
}
///
///HACE: DEVUELVE el equivalente del numero de fila en que se posiciona un registro
///en un dataset que se llenara con un SELECT * by idn
///SE USA:Al actualizar el valor de cRegAct por ejemplo desde boton DETALLES de un DGV
///
///
ID que se buscara ///
El SELECT * FROM cNomTabla ORDER BY idn ///
/// El numero de la fila
private static int fIDaPosicion(string fIDaBuscar, string fSQL, OleDbConnection oConx)
{
if (fIDaBuscar != null)
{
OleDbDataAdapter oAdaptador;
DataSet oDataset;
int iNumRegs;
string fContenido;
oAdaptador = new OleDbDataAdapter(fSQL, oConx);
oDataset = new DataSet();
oAdaptador.Fill(oDataset, "ListaIDS");
//Crea tabla con una sola columna, la columna 0
iNumRegs = oDataset.Tables["ListaIDS"].Rows.Count;
for (int i = 0; i < iNumRegs; i++)
{
fContenido = oDataset.Tables["ListaIDS"].Rows[i][0].ToString();
if (fIDaBuscar == fContenido)
{
return i;
}
}
//Devuelve cuando no se encuentra ese registro
return -1;
}
else
{
return -2; //Si el valor a buscar era null
}
}
///
/// HACE: PASA a un formato moneda con dos decimales un número double
/// SE USA: Al transferir datos de tipo moneda en una sentencia SQL
///
///
///
public static string fAMonedaAME(double fDouble)
{
NumberFormatInfo oNumberFormatInfo = new NumberFormatInfo();
string sResultado;
//FORMATO DE LA MONEDA
oNumberFormatInfo.CurrencySymbol = "€";
oNumberFormatInfo.CurrencyGroupSeparator = "";
oNumberFormatInfo.CurrencyDecimalSeparator = ".";
sResultado = fDouble.ToString("c", oNumberFormatInfo);
sResultado = sResultado.Remove(0, 1);
return sResultado;
}
///
/// SE USA: Al realizar un cambio en un control DATETIMEPICKER y
/// seguidamente pasar este valor a una sentencia SQL
///
///
///
public static string fFechaENG(DateTimePicker Dtp)
{
string fDia;
string fMes;
string fAno;
string fFecha;
fDia = Dtp.Value.Day.ToString();
fMes = Dtp.Value.Month.ToString();
fAno = Dtp.Value.Year.ToString();
fFecha = fMes + "/" + fDia + "/" + fAno;
return fFecha;
}
///
/// SE USA: Al pasar de una estructura a una sentencia SQL
///
///
///
public static string fFechaENG(DateTime Dt)
{
string fDia;
string fMes;
string fAno;
string fFecha;
fDia = Dt.Day.ToString();
fMes = Dt.Month.ToString();
fAno = Dt.Year.ToString();
fFecha = fMes + "/" + fDia + "/" + fAno;
return fFecha;
}
}//FIN CLASE CFuncion
}//Fin nsBusqueda
#endregion NSBusqueda
#region NSGestoresEventos
namespace NSGestoresEventos
{
//http://www.programacion.com/tutorial/csharp/13/#_Toc521045067
//Delegado: declaracion donde se asigna un nombre a ese tipo y se facilita
//la lista de prametros
//2- Creo el public delegate
public delegate void gesToCaps(TextBox evCajaTexto); //Defino el evento
//public event gesToCaps evAmayus;
}//Fin nsGestoresEventos
#endregion NSGestoresEventos
}
Autor: Eduardo A. F.
Publicado: 13-08-2010 21:48
Actualizado: 16-12-2010 23:23