elhacker.net cabecera Bienvenido(a), Visitante. Por favor Ingresar o Registrarse
¿Perdiste tu email de activación?.


 


Tema destacado: Security Series.XSS. [Cross Site Scripting]


  Mostrar Mensajes
Páginas: 1 2 3 4 5 6 7 8 9 10 11 12 13 [14] 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 ... 229
131  Programación / .NET (C#, VB.NET, ASP) / Introducir y seleccionar lengua en modo consola en: 25 Febrero 2019, 05:51
Hola:

Teniendo un menú hecho por defecto en español en este caso. (Cuando todo esté acabado tiene que estar en Inglés por defecto).

Quiero crear menús que sea capaz de elegir el idioma, en al cual hoy en día no hay problema porque está este traductor para escapar.

Mi idea para tener un orden de cada idioma a introducir, por ejemplo, español, inglés, alemán, francés, italiano y portugués.

En este ejemplo hay 6 lenguas. No se si la mejor opción es crear una carpeta de idiomas y ahí meto cada lengua en el cual es llamado.



Código de ejemplo para.
Código
  1. using System;
  2.  
  3. namespace Idiomas_consola_01_cs
  4. {
  5.    class Program
  6.    {
  7.        static void Main(string[] args)
  8.        {
  9.            // Título de la ventana.
  10.            Console.Title = "Menú - C# 2017";
  11.  
  12.            // Tamaño ventana consola.
  13.            // X anchura.
  14.            Console.WindowWidth = 80;
  15.  
  16.            // Y altura.
  17.            Console.WindowHeight = 40;
  18.  
  19.            // Oculto el cursor.
  20.            Console.CursorVisible = false;
  21.  
  22.            // Almacena la tecla pulsada en la variable.
  23.            ConsoleKey teclaInicial;
  24.  
  25.            // Fondo verde.
  26.            Console.BackgroundColor = ConsoleColor.Green;
  27.  
  28.            // Letras negras.
  29.            Console.ForegroundColor = ConsoleColor.Black;
  30.  
  31.            do
  32.            {
  33.                // Limpiar pantalla.
  34.                Console.Clear();
  35.  
  36.                // Formato numérico dd/MM/yyyy.
  37.                Console.WriteLine(DateTime.Now.ToString("ddd dd MMM"));
  38.  
  39.                // Almacena en la variable una tecla pulsada.
  40.                teclaInicial = Console.ReadKey(true).Key;
  41.  
  42.                // ¿Haz pulsado la tecla Enter?
  43.                if (teclaInicial == ConsoleKey.Enter)
  44.                {
  45.                    // Sí. Se ejecuta esta función.
  46.                    menuPrincipal();
  47.                }
  48.            } while (teclaInicial != ConsoleKey.Escape);
  49.        }
  50.  
  51.        #region Menú Principal.
  52.        public static void menuPrincipal()
  53.        {
  54.  
  55.            // Contador de teclas y navegador.
  56.            int opcion = 0;
  57.            bool salir = false;
  58.            // Capturar tecla para luego validar.
  59.            ConsoleKey tecla;
  60.  
  61.            do
  62.            {
  63.                // Limpiar pantalla.
  64.                Console.Clear();
  65.  
  66.                switch (opcion)
  67.                {
  68.                    case 0:
  69.                        Console.SetCursorPosition(0, 0);
  70.                        Console.Write("Language");
  71.                        break;
  72.                    case 1:
  73.                        Console.SetCursorPosition(0, 0);
  74.                        Console.WriteLine("Opción 1.");
  75.                        break;
  76.                    case 2:
  77.                        Console.SetCursorPosition(0, 0);
  78.                        Console.WriteLine("Opción 2.");
  79.                        break;
  80.                    case 3:
  81.                        Console.SetCursorPosition(0, 0);
  82.                        Console.WriteLine("Opción 3.");
  83.                        break;
  84.                    case 4:
  85.                        Console.SetCursorPosition(0, 0);
  86.                        Console.WriteLine("Opción 4.");
  87.                        break;
  88.                    case 5:
  89.                        Console.SetCursorPosition(0, 0);
  90.                        Console.WriteLine("Opción 5.");
  91.                        break;
  92.                    case 6:
  93.                        Console.SetCursorPosition(0, 0);
  94.                        Console.WriteLine("Opción 6.");
  95.                        break;
  96.                    case 7:
  97.                        Console.SetCursorPosition(0, 0);
  98.                        Console.WriteLine("Salir menú");
  99.                        break;
  100.                    default:
  101.                        break;
  102.                }
  103.  
  104.                // Fin de pintar el menú.
  105.                //******************************************************************
  106.  
  107.                // Leer tecla ingresada por el usuario.
  108.                tecla = Console.ReadKey(true).Key;
  109.  
  110.                // Validar el tipo de tecla.
  111.                if (tecla == ConsoleKey.Enter)
  112.                {
  113.                    switch (opcion)
  114.                    {
  115.                        case 1:
  116.                            // Instrucciones.
  117.                            break;
  118.                        case 2:
  119.                            // Instrucciones.
  120.                            break;
  121.                        case 3:
  122.                            // Instrucciones.
  123.                            break;
  124.                        case 4:
  125.                            // Instrucciones.
  126.                            break;
  127.                        case 6:
  128.                            // Instrucciones.
  129.                            break;
  130.                        case 7:
  131.                            salir = true;
  132.                            break;
  133.                        default:
  134.                            break;
  135.                    }
  136.                }
  137.  
  138.                if (tecla == ConsoleKey.DownArrow)
  139.                {
  140.                    opcion += 1; // Equivalente ++.
  141.                }
  142.  
  143.                if (tecla == ConsoleKey.UpArrow)
  144.                {
  145.                    opcion -= 1; // --.
  146.                }
  147.  
  148.                // Si está en la última opción, salta a la primera.
  149.                if (opcion > 7)
  150.                {
  151.                    opcion = 0;
  152.                }
  153.  
  154.                // Si está en la primera posición, salta a la última.
  155.                if (opcion < 0)
  156.                {
  157.                    opcion = 7;
  158.                }
  159.  
  160.                // Uso la tecla escape como salida.
  161.            } while (salir == false);
  162.        }
  163.        #endregion
  164.    }
  165. }

En el menú Languaje, si pulsas Enter, tiene que verse en Inglés, todos los idiomas que vayamos incorporando. El usuario elige el idioma y se queda seleccionado.

¿Alguna idea?

Saludos.
132  Programación / .NET (C#, VB.NET, ASP) / Re: Timer en vez de Sleep. en: 23 Febrero 2019, 12:00
Buena explicación. ;)

Gracias.
133  Programación / .NET (C#, VB.NET, ASP) / Re: Timer en vez de Sleep. en: 20 Febrero 2019, 21:22
Buenas:

No esperaba que usaras el kernel32.dll.

Voy a examinar.

Muchas gracias. ;)
134  Programación / .NET (C#, VB.NET, ASP) / Re: Timer en vez de Sleep. en: 20 Febrero 2019, 00:15
Muchas gracias.
135  Programación / .NET (C#, VB.NET, ASP) / Re: Crear una DLL y llamarla en otro lenguaje en: 16 Febrero 2019, 13:02
Hola:



Les dejo un mini tutorial rápido en PDF por si alguien lo necesita.

Ver tutorial.

Saludos.

PD: Gracias a los compañeros del foro.
136  Programación / .NET (C#, VB.NET, ASP) / Re: Timer en vez de Sleep. en: 9 Febrero 2019, 17:12
Muchas gracias mi muy distinguido amigo. ;)

Código
  1. using System;
  2.  
  3. namespace Parpadeo_texto_consola_01_cs
  4. {
  5.    class Program
  6.    {
  7.        static void Main(string[] args)
  8.        {
  9.            // Título de la ventana.
  10.            Console.Title = "Blink";
  11.  
  12.            // Tamaño ventana consola.
  13.            // X anchura.
  14.            Console.WindowWidth = 16;
  15.  
  16.            // Y altura.
  17.            Console.WindowHeight = 2;
  18.  
  19.            // Oculto el cursor.
  20.            Console.CursorVisible = false;
  21.  
  22.            // Como estamos en un ejemplo, da igual en este caso
  23.            // poner un bucle infinito. Quiero que se muestre el
  24.            // resultado.
  25.  
  26.            int t = 0;
  27.            System.Timers.Timer blink = new System.Timers.Timer(100);
  28.            blink.Enabled = true;
  29.            bool mostrar = true;
  30.            blink.Elapsed += (a, b) =>
  31.            {
  32.                switch (t++)
  33.                {
  34.                    case 0:
  35.                        mostrar = true;
  36.                        break;
  37.                    case 5:
  38.                        mostrar = false;
  39.                        break;
  40.                    case 6:
  41.                        t = -1;
  42.                        break;
  43.                }
  44.  
  45.                // Posición de la pantalla.
  46.                Console.SetCursorPosition(0, 0);
  47.  
  48.                // Mostrar texto en pantalla.
  49.                Console.Write(mostrar ? "Hola mundo" : "          ");
  50.            };
  51.            Console.ReadKey();
  52.        }
  53.    }
  54. }
  55.  

No me gusta el código de arriba, mejor el que dices. Sigo con ello y me alegro el ejemplo del gif que pusiste. ;)
137  Programación / .NET (C#, VB.NET, ASP) / Timer en vez de Sleep. en: 9 Febrero 2019, 11:10
Hola:

Quiero hacer un parpadeo de un texto en modo consola. Por ahora solo me sale con Sleep, pero no me gusta este. Aún así dejo un ejemplo de lo que quiero pero está hecho en Sleep.



Código
  1. using System;
  2. using System.Threading; // No olvidar.
  3.  
  4. namespace Parpadeo_texto_consola_01_cs
  5. {
  6.    class Program
  7.    {
  8.        static void Main(string[] args)
  9.        {
  10.            // Título de la ventana.
  11.            Console.Title = "Blink";
  12.  
  13.            // Tamaño ventana consola.
  14.            // X anchura.
  15.            Console.WindowWidth = 16;
  16.  
  17.            // Y altura.
  18.            Console.WindowHeight = 2;
  19.  
  20.            // Oculto el cursor.
  21.            Console.CursorVisible = false;
  22.  
  23.            // Como estamos en un ejemplo, da igual en este caso
  24.            // poner un bucle infinito. Quiero que se muestre el
  25.            // resultado.
  26.            while (true)
  27.            {
  28.                // Posición de la pantalla.
  29.                Console.SetCursorPosition(0, 0);
  30.  
  31.                // Mostrar texto en pantalla.
  32.                Console.Write("Hola mundo");
  33.  
  34.                // Retardo de 0.5 segundos. 1000 ml (mili segundos)
  35.                // es igual a 1 segundo.
  36.                Thread.Sleep(500);
  37.  
  38.                // Posición de la pantalla.
  39.                Console.SetCursorPosition(0, 0);
  40.  
  41.                // Mostrar espaciones en blanco para borrar texto anterior.
  42.                Console.Write("          ");
  43.  
  44.                // Retardo 0.3 seg.
  45.                Thread.Sleep(300);
  46.            }
  47.        }
  48.    }
  49. }

Quiero hacer lo mismo, pero con el Timer en modo consola, lo que me cuesta hacerlo. Ya qu el timer pude interrumpir el programa cuando está dentro del temporizador pero con el Sleep, hasta que no acabe el tiempo, el programa se queda como en esclavo, sobre todo en tiempos muy largos.

¿Hay alguna forma de hacerlo en modo consola?

Si se puede hacer el parpadeo en una función y lo llamo cuando quiera, mejor que mejor.

Saludos.
138  Programación / .NET (C#, VB.NET, ASP) / Re: Menús en modo consola en: 8 Febrero 2019, 20:47
Hola:

Sí, haz entedido bien, tamién es mejor la opción booleana. Lo saqué así al final.

Código
  1.        public static void radiazo()
  2.        {
  3.            ConsoleKey teclaRadio;
  4.            Console.Clear();
  5.            do
  6.            {
  7.                Console.SetCursorPosition(0, 0);
  8.                Console.Write("Ver radio: ");          
  9.  
  10.                Console.SetCursorPosition(11, 0);
  11.                Console.Write(radio ? "On " : "Off");
  12.  
  13.  
  14.                teclaRadio = Console.ReadKey(true).Key;
  15.  
  16.                if ((teclaRadio == ConsoleKey.UpArrow) || (teclaRadio == ConsoleKey.DownArrow))
  17.                {
  18.                    radio = !radio;
  19.                }
  20.  
  21.            } while (teclaRadio != ConsoleKey.Enter);
  22.        }

Si vez que ahora dice el On y Off si pulso todo el rato arriba o abajo ya puedo cambiar, tal como lo haz entendido.

Si te fijas bien, el On y Off está fijo. Quiero que parpadee en cada 0.5 segundos, o lo que es lo mismo, 500 ms (mili segundos).

Iba a usar Sleep, pero prefiero usar timer para que no se quede esclavo el programa aunque sea corto de tiempo.

¿Por qué quiero hacer esto así?

Porque estoy practicando en modo consola usando el 16x2, aunque ahora mismo el 16x1. Cuando lo domine partes por partes lo que deseo, como el booleano, el XXXXXX-- del brillo, y me falta el volumen del 0 que es mute hasta aumentar el sonido hasta el 7. Poco a poco lo estoy haciendo.

Cuando acabe con C#, adaptaré este código a un LCD real de 16x2 como puedes ver aquí.

Quiero aprender hacer menús para LCD pero primero que acabo antes, en PC. ;)


Saludos.
139  Programación / .NET (C#, VB.NET, ASP) / Re: Menús en modo consola en: 7 Febrero 2019, 21:39
Buenas:

Hoy me volví loco de la cabeza. Entrego código incompleto, lo entrego como curiosidad. Lo intentaré acabarlo al 100 %.

Código
  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Text;
  5. using System.Threading.Tasks;
  6.  
  7. namespace Menu_consola_09_cs
  8. {
  9.    class Program
  10.    {
  11.        // Variables globales.
  12.        public static int luz = 6;
  13.        public const int BRILLO_MAX = 8;
  14.        public static bool radio = false;
  15.  
  16.        static void Main(string[] args)
  17.        {
  18.            // Título de la ventana.
  19.            Console.Title = "Menú de opciones";
  20.  
  21.            // Tamaño ventana consola.
  22.            // X anchura.
  23.            Console.WindowWidth = 16;
  24.  
  25.            // Y altura.
  26.            Console.WindowHeight = 2;
  27.  
  28.            // Oculto el cursor.
  29.            Console.CursorVisible = false;
  30.            ConsoleKey teclaInicial;
  31.            Console.BackgroundColor = ConsoleColor.Green;
  32.  
  33.            // Letras negras.
  34.            Console.ForegroundColor = ConsoleColor.Black;
  35.  
  36.            // Limpiar pantalla.
  37.            do
  38.            {
  39.                Console.Clear();
  40.                Console.WriteLine(DateTime.Now.ToString("dd/MM/yyyy"));
  41.                teclaInicial = Console.ReadKey(true).Key;
  42.                if(teclaInicial == ConsoleKey.Enter)
  43.                {
  44.                    menuPrincipal();
  45.                }
  46.            } while (teclaInicial != ConsoleKey.Escape); // SANTIAGOOOOO.
  47.  
  48.        }
  49.        public static void menuPrincipal()
  50.        {
  51.  
  52.            // Contador de teclas y navegador.
  53.            int opcion = 0;
  54.            bool salir = false;
  55.            // Capturar tecla para luego validar.
  56.            ConsoleKey tecla;
  57.  
  58.            do
  59.            {
  60.  
  61.                //******************************************************************
  62.                // Dibujo el menú.
  63.  
  64.                // Rellenar fondo verde.
  65.                Console.BackgroundColor = ConsoleColor.Green;
  66.  
  67.                // Letras negras.
  68.                Console.ForegroundColor = ConsoleColor.Black;
  69.  
  70.                // Limpiar pantalla.
  71.                Console.Clear();
  72.  
  73.                switch (opcion)
  74.                {
  75.                    case 0:
  76.                        Console.SetCursorPosition(0, 0);
  77.                        Console.Write("Language");
  78.                        break;
  79.                    case 1:
  80.                        Console.SetCursorPosition(0, 0);
  81.                        Console.WriteLine("Ajustar hora ->");
  82.                        break;
  83.                    case 2:
  84.                        Console.SetCursorPosition(0, 0);
  85.                        Console.WriteLine("Ajustar fecha ->");
  86.                        break;
  87.                    case 3:
  88.                        Console.SetCursorPosition(0, 0);
  89.                        Console.WriteLine("Brillo");
  90.                        break;
  91.                    case 4:
  92.                        Console.SetCursorPosition(0, 0);
  93.                        Console.WriteLine("Ver radio");
  94.                        break;
  95.                    case 5:
  96.                        Console.SetCursorPosition(0, 0);
  97.                        Console.WriteLine("Vol. avisos");
  98.                        break;
  99.                    case 6:
  100.                        Console.SetCursorPosition(0, 0);
  101.                        Console.WriteLine("Vol. teclas");
  102.                        break;
  103.                    case 7:
  104.                        Console.SetCursorPosition(0, 0);
  105.                        Console.WriteLine("Salir menú");
  106.                        break;
  107.                    default:
  108.                        Console.WriteLine("Fuera de rango.");
  109.                        break;
  110.                }
  111.  
  112.                // Fin de pintar el menú.
  113.                //******************************************************************
  114.  
  115.                // Leer tecla ingresada por el usuario.
  116.                tecla = Console.ReadKey(true).Key;
  117.  
  118.                // Validar el tipo de tecla.
  119.                if (tecla == ConsoleKey.Enter)
  120.                {
  121.                    switch (opcion)
  122.                    {
  123.                        case 3:
  124.                            brillo();
  125.                            break;
  126.                        case 4:
  127.                            radiazo();
  128.                            break;
  129.                        case 7:
  130.                            salir = true;
  131.                            break;
  132.                        default:
  133.                            break;
  134.                    }
  135.                }
  136.  
  137.                if (tecla == ConsoleKey.DownArrow)
  138.                {
  139.                    opcion += 1;
  140.                }
  141.  
  142.                if (tecla == ConsoleKey.UpArrow)
  143.                {
  144.                    opcion -= 1;
  145.                }
  146.  
  147.                // Si está en la última opción, salta a la primera.
  148.                if (opcion > 7)
  149.                {
  150.                    opcion = 0;
  151.                }
  152.  
  153.                // Si está en la primera posición, salta a la última.
  154.                if (opcion < 0)
  155.                {
  156.                    opcion = 7;
  157.                }
  158.  
  159.                // Uso la tecla escape como salida.
  160.            } while (salir==false);
  161.        }
  162.  
  163.        #region Brillo (3).
  164.        public static void brillo()
  165.        {
  166.            ConsoleKey teclaBrillo;
  167.            Console.Clear();
  168.            do
  169.            {
  170.  
  171.                Console.SetCursorPosition(0, 0);
  172.                Console.Write("Luz: ");
  173.  
  174.                for (int i = 0; i < luz; i++)
  175.                {
  176.                    Console.Write("X");
  177.                }
  178.  
  179.                for (int j = 0; j < (BRILLO_MAX - luz); j++)
  180.                {
  181.                    Console.Write("-");
  182.                }
  183.  
  184.                teclaBrillo = Console.ReadKey(true).Key;
  185.  
  186.                // ¿Se pulsó el cursor arriba?
  187.                if (teclaBrillo == ConsoleKey.UpArrow)
  188.                {
  189.                    //¿no llega al limite?
  190.                    if (luz < BRILLO_MAX)
  191.                    {
  192.                        // Incrementa 1.
  193.                        luz++;
  194.                    }
  195.                }
  196.  
  197.                if (teclaBrillo == ConsoleKey.DownArrow)
  198.                {
  199.                    if (luz > 0)
  200.                    {
  201.                        // Decremmenta 1.
  202.                        luz--;
  203.                    }
  204.                }
  205.  
  206.            } while (teclaBrillo != ConsoleKey.Enter);
  207.        }
  208.        #endregion
  209.  
  210.        #region Radio (4).
  211.        public static void radiazo()
  212.        {
  213.            ConsoleKey teclaRadio;
  214.            Console.Clear();
  215.            do
  216.            {
  217.                Console.SetCursorPosition(0, 0);
  218.                Console.Write("Radio: ");
  219.  
  220.  
  221.  
  222.                if (radio == true)
  223.                {
  224.                    Console.SetCursorPosition(7, 0);
  225.                    Console.Write("On ");
  226.                }
  227.  
  228.                else
  229.                {
  230.                    Console.SetCursorPosition(7, 0);
  231.                    Console.Write("Off");
  232.                }
  233.  
  234.                teclaRadio = Console.ReadKey(true).Key;
  235.  
  236.                if (teclaRadio == ConsoleKey.UpArrow)
  237.                {
  238.                    Console.SetCursorPosition(7, 0);
  239.                    Console.Write("On ");
  240.                    radio = true;
  241.                }
  242.  
  243.                if (teclaRadio == ConsoleKey.DownArrow)
  244.                {
  245.                    Console.SetCursorPosition(7, 0);
  246.                    Console.Write("Off");
  247.                    radio = false;
  248.                }
  249.  
  250.            } while (teclaRadio != ConsoleKey.Enter);
  251.        }
  252.        #endregion
  253.  
  254.    }
  255. }
  256.  
  257.  

Hay una parte en Ver Radio que no me sale. Si pulso la fecla del teclado arriba, me sale "Radio: On". Si sigo pulsado la fecla arriba otra vez, se queda en On, lo mismo hacia abajo, que se queda en Off.

¿Hay alguna manera de que si pulso la tecla flecha arriba todo el rato o abajo se cambie en On y Off?

El código es esta función.
Código
  1. public static void radiazo()
  2.        {
  3.            ConsoleKey teclaRadio;
  4.            Console.Clear();
  5.            do
  6.            {
  7.                Console.SetCursorPosition(0, 0);
  8.                Console.Write("Radio: ");
  9.  
  10.  
  11.  
  12.                if (radio == true)
  13.                {
  14.                    Console.SetCursorPosition(7, 0);
  15.                    Console.Write("On ");
  16.                }
  17.  
  18.                else
  19.                {
  20.                    Console.SetCursorPosition(7, 0);
  21.                    Console.Write("Off");
  22.                }
  23.  
  24.                teclaRadio = Console.ReadKey(true).Key;
  25.  
  26.                if (teclaRadio == ConsoleKey.UpArrow)
  27.                {
  28.                    Console.SetCursorPosition(7, 0);
  29.                    Console.Write("On ");
  30.                    radio = true;
  31.                }
  32.  
  33.                if (teclaRadio == ConsoleKey.DownArrow)
  34.                {
  35.                    Console.SetCursorPosition(7, 0);
  36.                    Console.Write("Off");
  37.                    radio = false;
  38.                }
  39.  
  40.            } while (teclaRadio != ConsoleKey.Enter);
  41.        }

Saludos
;)
140  Programación / .NET (C#, VB.NET, ASP) / Re: Menús en modo consola en: 7 Febrero 2019, 06:16
Gracias, estoy en ello. ;)

Lo dejo más claro, luego hago esquema de cada submenú.



Antes usé solo if. Ahora hice lo mismo pero con Switch. No se cual es el más indicado para hacer el submenú.

Código
  1.                switch (contador)
  2.                {
  3.                    case 0:
  4.                        Console.SetCursorPosition(0, 0);
  5.                        Console.Write("FECHA");
  6.  
  7.  
  8.                        break;
  9.                    case 1:
  10.                        Console.SetCursorPosition(0, 0);
  11.                        Console.Write("MENú &#9650;&#9660;");
  12.                        break;
  13.                    case 2:
  14.                        Console.SetCursorPosition(0, 0);
  15.                        Console.WriteLine("1.   UNO");
  16.                        break;
  17.                    case 3:
  18.                        Console.SetCursorPosition(0, 0);
  19.                        Console.WriteLine("2.   DOS");
  20.                        break;
  21.                    case 4:
  22.                        Console.SetCursorPosition(0, 0);
  23.                        Console.WriteLine("3.   TRES");
  24.                        break;
  25.                    case 5:
  26.                        Console.SetCursorPosition(0, 0);
  27.                        Console.WriteLine("4.  CUATRO");
  28.                        break;
  29.                    case 6:
  30.                        Console.SetCursorPosition(0, 0);
  31.                        Console.WriteLine("5. ESC = SALIR");
  32.                        break;
  33.                    default:
  34.                        Console.WriteLine("Fuera de rango.");
  35.                        break;
  36.                }

Salu2.
Páginas: 1 2 3 4 5 6 7 8 9 10 11 12 13 [14] 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 ... 229
Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines