Manejo de Colores de Consola desde ANSI C

En esta entrada voy a tratar de explicar como funciona el cambio de colores de la consola, usando secuencias de escape, siendo válidos para la consola de GNU/Linux, ya sea desde bash, como desde el ANSI C.

Recordemos que las secuencias de escape se ejecutan en la consola por medio directo en una consola GNU/Linux, y desde una sentencia de salida como el printf(), desde el ANSI C.
La secuencia de escape se indica con \033. Este número está expresado en octal y es el número 27 en decimal (Esc).

Luego se escribe el corchete abierto [ para indicar que se inicia la secuencia de caracteres no imprimibles.
A continuación se indican los valores para el
Separado por un ; se agregan dos dígitos para el color de Fondo o de Texto de manera indistinta
Y se repite un número de dos dígitos para el color de Fondo o Texto.

Esto es posible hacerlo, dado que los valores de los colores para el fondo, se obtienen sumando diez al los colores del texto.

La secuencia de escape para cambiar el color quedaría de la siguiente manera:

          "\033[#;## ;##m"

(debo reconocer que no se para que está la "m")

Los estilos que podemos seleccionar son los siguientes:
0   -  Normal
1 - Claro (el color se diluye, permite hacer dos tonos de cada color: azul/azulclaro, rojo/rojoclaro...)
4  -  Subrayado
5  -  Parpadeante (solo funciona para bash)
7  -  Inverso
8  -  Oculto (Pensado para pedir contraseñas al usuario)

Los colores para texto son los siguientes:

Negro 0;30 Gris Obscuro 1;30

Azul 0;34 Azul Claro 1;34
Verde 0;32 Verde Claro 1;32
Cyan 0;36 Cyan Claro 1;36
Rojo 0;31 Rojo Claro 1;31
Purpura 0;35 Magenta 1;35
Café 0;33 Amarillo 1;33 
Gris Claro 0;37 Blanco 1;37 

Debiendo sumarle 10 a los colores para obtener los colores para fondo.

También podemos realizar desplazamientos del cursor en filas y columnas:

"\033[10;20H"

donde 10 es la fila y 20 la columna, la "H" indica que esa secuencia responde a posicionamiento del cursor.

Como usar GDB

En éste link, encontré una explicación muy cómoda a cerca del funcionamiento del GDB, herramienta que permite realizar el seguimiento de nuestros programas, desde una terminal.


karmic (1) - gdb.1.gz

• 
  
• 
  
• 
  
• 
  
• 
  
• 
  

Provided by: manpages-es-extra_0.8a-16_all 

NOMBRE

gdb - El depurador GNU

SINOPSIS

gdb    [-help] [-nx] [-q] [-batch] [-cd=dir] [-f] [-b bps] [-tty=dev]
              [-s symfile] [-e prog] [-se prog] [-c core] [-x cmds] [-d dir]
              [prog[core|procID]]

DESCRIPCIÓN

El proposito de un depurador como GDB es permitir al usuario ver lo que
       está ocurriendo ‘‘dentro’’  de  otro  programa  mientras  que  se  está
       ejecutando — o lo que estaba haciendo en el momento que falló.

       GDB  puede hacer cuatro tipo de cosas (más otras cosas para dar soporte
       a éstas) para ayudarte a capturar errores en el acto:

          ·   Comenzar tu programa, especificando  cualquier  cosa  que  pueda
              afectar a su comportamiento.

          ·   Hacer  que  tu  programa  se  pare  al cumplirse las condiciones
              especificadas.

          ·   Examinar que ha pasado, cuando tu programa se ha parado.

          ·   Cambiar  cosas  de  tu  programa,  de  tal  manera  que   puedas
              experimentar  corrigiendo  los  efectos  de un fallo y continuar
              para descubrir otros.

       Puedes usar GDB para depurar programas escritos en C, C++, y  Modula-2.
       El  soporte para Fortran se añadirá cuando esté listo un compilador GNU
       Fortran.

       GDB se invoca con la orden  de  shell  gdb.   Una  vez  comenzado,  lee
       órdenes  del  terminal  hasta  que  le dices que salga con la orden GDB
       quit. Usando la orden help puedes obtener una ayuda directa del gdb.

       Se puede ejecutar gdb sin argumentos ni opciones; pero  la  manera  más
       común  de  comenzar  GDB  es con uno o dos argumentos, especificando un
       programa ejecutable con el argumento:

       gdb programa

       También puedes comenzar con un programa ejecutable y  un  fichero  core
       específico:

       gdb programa core

       Puedes,  en  su  lugar,  especificar  un  ID  de  proceso  como segundo
       argumento, si quieres depurar un proceso en ejecución:

       gdb programa 1234

       ligaría GDB al proceso 1234 (al menos que  también  tengas  un  fichero
       denominado ‘1234’; GDB busca un fichero core en primer lugar).

       Aquí están las ordenes más frecuentemente necesitadas en GDB:

       break [fichero:]función
               Pone un punto de ruptura en función (en fichero).

       run [arglist]
              Comienza tu programa (con arglist, si se especifica).

       bt     Backtrace: muestra la pila del programa.

       print expr
              Muestra el valor de una expresión.

       c      Continua  ejecutando  tu  programa (después de parar, p.e. en un
              punto de ruptura).

       next   Ejecuta la siguiente línea del programa (después de parar); pasa
              sobre cualquier llamada a función que apareciera en la línea.

       step   Ejecuta  la  siguiente  línea  del  programa  (despué de parar);
              entrando en cualquier llamada a función  que  apareciera  en  la
              línea.

       help [nombre]
              Muestra  información  sobre  la  orden GDB nombre, o información
              general sobre como utilizar GDB.

       quit   Salir de GDB.

       Para todos los detaller sobre GDB, véase Using GDB: A Guide to the  GNU
       Source-Level  Debugger, by Richard M. Stallman and Roland H. Pesch.  El
       mismo texto está disponible en línea como la entrada gdb en el programa
       info.

OPCIONES

Cualquier   argumento  distinto  de  las  opciones  indica  un  fichero
       ejecutable y un fichero core (o un ID de proceso); es decir, el  primer
       argumento  encontrado si la bandera de opción asociada es equivalente a
       la opción ‘-se’, y el segundo, si existe, es equivalente  a  la  opción
       ‘-c’  si  es  el  nombre  de  un fichero.  Muchas opciones tienen tanto
       formato largo como corto; ambos se muestra aquí.  Los  formatos  largos
       también se reconocen si los truncas, siempre que sea lo suficientemente
       largo para que la opción que representa no sea ambigüa.  (Si lo deseas,
       puedes  indicar  los  argumentos  de  opción con ‘+’ en  lugar de  ‘-’,
       aunque nosotros mostramos la convención más usual.)

       Todas las opciones y argumentos en la  línea  de  ordenes  que  des  se
       procesann  en orden secuencial. El orden es importante cuando se usa la
       opción ‘-x’.

       -help

       -h     Lista todas las opciones, con explicaciones breves.

       -symbols=fichero

       -s fichero
               Lee la tabla de símbolos del fichero fichero.

       -exec=fichero

       -e fichero
               Usa el fichero fichero como el fichero  ejecutable  a  ejecutar
              cuando  sea  adecuado,  y para examinar los datos puros en unión
              con un volcado core.

       -se=fichero
               Lee la tabla de símbolos del fichero fichero y la usa  como  el
              fichero ejecutable.

       -core=fichero

       -c fichero
               Usa el fichero fichero como un volcado core para examinar.

       -command=fichero

       -x fichero
               Ejecuta las ordenes GDB del fichero fichero.

       -directory=directorio

       -d directorio
                Añade directorio al camino de búsqueda de los ficheros fuente.

       -nx

       -n     No ejecuta las  ordenes  de  ningún  fichero  de  inicialización
              ‘.gdbinit’.   Normalmente,  las  ordenes  de  estos  ficheros se
              ejecutan después de que todas las  opciones  de  comando  y  los
              argumentos hayan sido procesados.

       -quiet

       -q     ‘‘Quiet’’.    No   imprime  los  mensajes  introductorios  y  de
              copyright.   Estos mensajes también se suprimen en  el  modo  de
              trabajo por lotes.

       -batch Se  ejecuta  en  modo  trabajo por lotes.  Finaliza con estado 0
              después de procesar todos los ficheros de ordenes  especificados
              con  ‘-x’  (y ‘.gdbinit’, si no está inhibido).  Finaliza con un
              estado distinto del cero si ocurre un error durante la ejecución
              de las ordenes GDB en los ficheros de ordenes.

              El  modo  de  trabajo por lotes puede ser util cuando se ejecuta
              GDB como un filtro, pot  ejemplo  para  bajarse  y  ejecutar  un
              programa  en  otro  ordenador;  para  hacer que sea más útil, el
              mensaje

              Program exited normally.

              (que se muestra normalmente siempre que un programa ejecutándose
              bajo  el control de GDB termina) no se muestra cuando se ejecuta
              en modo de trabajo por lotes.

       -cd=directorio
               Ejecuta GDB usando directorio como directorio  de  trabajo,  en
              lugar del directorio actual.

       -fullname

       -f     Emacs  activa esta opción cuando ejecuta GDB como un subproceso.
              Indica al GDB que saque el nombre  completo  del  fichero  y  el
              número de línea de manera estándar y reconocible cada vez que se
              muestra una porción de pila (lo que  incluye  cada  vez  que  el
              programa  se  para).   Este  formato  reconocible se parece a do
              caracteres ‘ 32’, seguidos del nombre del fichero, el número  de
              línea  y  la  posición  del  caracter separados por comas, y una
              nueva línea.  El programa de interface Emacs-a-GDB usa  los  dos
              caracteres program uses the two ‘ 32’ como una señal para mostra
              el código fuente para la porción.

       -b bps  Fija la velocidad de la línea (ratio  de  baudios  o  bits  por
              segundo)  de  cualquier  interface  serie  usado por GDB para la
              depuración remota.

       -tty=dispositivo
               Se ejecuta usando dispositivo como la entrada y salida estándar
              de tu programa.

VÉASE TAMBIÉN

Entrada  ‘gdb’  en  info;  Using  GDB:  A Guide to the GNU Source-Level
       Debugger, Richard M. Stallman and Roland H. Pesch, July 1991.

COPYING

Copyright (c) 1991 Free Software Foundation, Inc.

       Permission is granted to make and distribute verbatim  copies  of  this
       manual  provided  the  copyright  notice and this permission notice are
       preserved on all copies.

       Permission is granted to copy and distribute modified versions of  this
       manual  under  the  conditions  for verbatim copying, provided that the
       entire resulting derived work is  distributed  under  the  terms  of  a
       permission notice identical to this one.

       Permission  is  granted  to  copy  and  distribute translations of this
       manual into another language, under the above conditions  for  modified
       versions,  except  that  this  permission  notice  may  be  included in
       translations approved by the Free Software Foundation instead of in the
       original English.

---

Resolución de la Evaluación de Laboratorio II y Programación II de Diciembre

En el enunciado se destacaban las condiciones a cumplir, dando los casos base para la formación de una lista simplemente encadenada que representa un nivel de la triángulo de Tartaglia (o Pascal, o Binomio de Newton) para obtener algo como lo representado en la figura siguiente:

Para poder resolver el problema, primero definí la estructura que iba a soportar los datos en la lista:

Luego separé el problema en cuatro partes (se puede mejorar...):

- agregarNodo() será la función encargada de ir sumando un nodo por cada nivel, desde el primer hasta el nivel ingresado por el usuario.

- borrarLista() se encargará de eliminar la lista completa, para cuando queramos ver un triángulo de otro nivel.

- muestraLista() nos permitirá ver en pantalla toda la lista.

- calculaNivel() es la función que realizará las sumas sobre cada nodo.

En el programa principal, armé un menú con dos opciones:

1) Crear Triángulo.

2) Salir.

La opción 1) nos va a pedir el nivel del triángulo a formar, verifica que no exista una lista anterior, y en caso contrario, la elimina, para luego en una estructura de repetición que va desde el valor ingresado por el usuario hasta 0, realizando los sucesivos llamados a agregarNodo() y muestraLista().

Básicamente la función agregarNodo() inserta un nodo delante del primero existente, donde el dato almacenado es un uno (1), de esa manera cumple con la condición que habla de que empieza la lista siempre con un uno. Luego verifica que si no es el primer nodo o el segundo, entonces llama a la función encargada de realizar las sumas necesarias:

La función calculaNivel(), es la función recursiva que solicita el enunciado, y actúa de la siguiente manera:

- para cada ejecución de la función, crea una variable auxiliar que almacenará la dirección del siguiente a la dirección del parámetro. Haciendo esto siempre y cuando esa dirección sea distinta de NULL, y luego sumando los valores almacenados en el campo de dato. Y finalmente hace el llamado recursivo, pasando ahora como parámetro de la función, la dirección almacenada en el campo sig del parámetro recibido.

En el video se puede ver un seguimiento para nivel 4:

Para completar el código nos quendan las funciones borrarLista() y muestraLista().

Espero que les pueda ser de ayuda, para entender la forma de resolver el ejercicio.

Les dejo a Uds. la adaptación a Objetos de este código.

Salu2...///

Configurando wxWidgets para Code::Blocks en Windows

Luego de instalar el wxPack, en la carpeta que sugiere el instalador, comenzamos con un proyecto wxWidgets:

 

seguimos los pasos acostumbrados para la puesta en marcha de un nuevo proyecto:

 

  

  

  

  

y en esta parte hay que seleccionar la carpeta donde se encuentran las librerías de wxWidgets:

 

  

  

  

  

  

  

  

  

Bien, espero que ayude a configurar todo.

Clase de Introducción a la programación con wxWidgets

- Presentación.
- Ejemplo.
- Manual Completo (inglés).
 

Instalando Code::Blocks en ubuntu karmic

Primero nos aseguramos de instalar los paquetes básicos para programar en C / C++

     sudo apt-get install build-essential libx11-dev libc6-dev

Luego instalamos los paquetes de herramientas para hacer debug

     sudo apt-get install gdb xgdb 

También instalamos los paquetes del necesarios para encontrar la ayuda del lenguaje con el man o xman

     sudo apt-get install libc6-doc manpages-dev

Y ahora si, instalamos el codeblocks

     sudo apt-get install codeblocks

Una vez instalado el codeblocks, agragamos a la lista de repositorios los siguientes:

     sudo gedit /etc/apt/sources.list

         ## Repositorio para Code::Blocks y wxWidgets
         deb http://lgp203.free.fr/ubuntu/ karmic universe
         deb http://apt.wxwidgets.org/ karmic-wx main

     sudo apt-get update

Para obtener las claves públicas de los repositorios

     wget -q http://lgp203.free.fr/public.key -O- | sudo apt-key add -
     wget -q http://apt.wxwidgets.org/key.asc -O- | sudo apt-key add -

Y terminamos de instalar las librerías para wxWidgets y sus herramientas

     sudo apt-get update
     sudo apt-get install libcodeblocks0 codeblocks libwxsmithlib0 codeblocks-contrib
     sudo apt-get install libwxgtk2.8-0 libwxgtk2.8-dev wx2.8-headers wx-common



Ya tenemos instalado y liso para funcionar C::B ahora falta instalar las librerias
necesarias para SDL.

 SDL es un conjunto de librerias para crear videojuegos, contiene las funcione

necesarias para manejar controles, graficos, sonido, video, red etc. algo analogo

 a directx de microsoft, SDL es multiplataforma. hay muy buenos libros sobre SDL

 y se pueden crear juegos muy buenos. bueno ahora veremos como instalarlos.

Para mayor facilidad buscamos en synaptic "libsdl" y nos saldran varos paquetes,

 los que debemos instalar es:

     * libsdl1.2debian "Librerias basicas"
    * libsdl1.2-dev "Librerias basicas"
    * libsdl-gfx1.2-dev "video"
    * libsdl-image1.2-dev "Soporte para formatos de imagen"
    * libsdl-mixer1.2-dev "Aporta mejoras al sonido"
    * libsdl-net1.2-dev "Soporte para red"
    * libsdl-sound1.2-dev "Manejo de sonido"
    * libsdl-ttf2.0-dev "Soporte de fuentes ttf"

Y listo...

Poniendo a punto Debian Lenny (parte 1)

-------------------------------------------------------------------------------
 Historial de instalación de debian lenny
-------------------------------------------------------------------------------
- siempre como root
-------------------------------------------------------------------------------

-------------------------------------------------------------------------------
 Para Programar en C / C++
-------------------------------------------------------------------------------
- apt-get update
- apt-get install ssh gcc g++ make
- apt-get install build-essential

- nano /etc/apt/sources.list
    deb http://apt.jenslody.de/ any main
    deb-src http://apt.jenslody.de/ any main
    deb http://apt.wxwidgets.org/ lenny-wx main

- apt-get update
- apt-get install jens-lody-debian-keyring

- wget -q http://wxwidgets.org/key.asc -O- | sudo apt-key add -
- wget -q http://apt.wxwidgets.org/key.asc -O- | sudo apt-key add -

- apt-get install codeblocks libwxgtk2.8-0 libwxgtk2.8-dev wx2.8-headers wx-common libx11-dev

-------------------------------------------------------------------------------
 Seguridad
-------------------------------------------------------------------------------
- apt-get install nmap ssh mc