¿Cómo reproducir videos .rm y .rmvb en K/Ubuntu Linux?

En primer lugar necesitaras tener:

sudo apt-get install libstdc++5

sudo apt-get install ffmpeg mencoder

Lo siguiente es bajar el real player

http://spain.real.com/download/player/linux/es/

Una vez bajado, dale permisos de ejecución:

chmod +x RealPlayer11GOLD.bin

Y ahora lanzamos el instalador:

./RealPlayer11GOLD

Se instalará solito...

Es probable que necesites reiniciar el modo X. Cierra todo y luego pulsa Ctrl+Alt+BackSpace

Listo!!

Problema con NVidia y K/Ubuntu Hardy al actualizar en el paquete nvidia-glx

El error que se obtiene es como este:

¿Desea continuar [S/n]? S
(Leyendo la base de datos ...
246928 ficheros y directorios instalados actualmente.)
Desinstalando nvidia-glx ...
dpkg-divert: renombrar obliga a sobreescribir `/usr/lib/xorg/modules/libwfb.so' con
un fichero distinto `/usr/lib/nvidia/libwfb.so.xserver-xorg-core', no está permitido.
dpkg: error al procesar nvidia-glx (--remove):
el subproceso post-removal script devolvió el código de salida de error 2
Se encontraron errores al procesar:
nvidia-glx
E: Sub-process /usr/bin/dpkg returned an error code (1)


La solución es eliminar:

sudo rm /usr/lib/xorg/modules/libwfb.so

¿Cómo instalar Latex en Linux?

sudo apt-get install texlive-latex-base
sudo apt-get install texlive-latex-recommended
sudo apt-get intall ttf-marvosym
sudo texhash

Para hacer un Curriculum Vitae instalar:

sudo apt-get install texlive-latex-extra texlive-fonts-recommended lmodern

Un editor para latex:

sudo apt-get install texmaker

(Se situa en Menú K -> Utilidades)


Página que explica como instalar LG3D

Enlace

Enlaces a información sobre Estructuras de ficheros.

Interesante información sobre estructuras de ficheros ( índices primarios, árboles...)

Universidad de Jaén

¿Cómo instalar free pascal en Kubuntu Linux?

Para instalar free pascal:

sudo apt-get install fp-compiler fp-docs fp-ide fp-units-base fp-units-db fp-units-fcl fp-units-gfx fp-units-gnome1 fp-units-gtk fp-units-gtk2 fp-units-misc fp-units-net fp-units-rtl fp-utils

¿Cómo instalar y configurar bochs?

Para instalar bochs:

sudo apt-get install bochs bochs-x

Para configurarlo, en el fichero .bochsrc cambiamos las líneas:

romimage: file=$BXSHARE/BIOS-bochs-lastest, adress=0xf0000
vgaromimage: $BXSHARE/VGABIOS-lgpl-lastest

por estas:

romimage: file=/usr/share/bochs/BIOS-bochs-legacy, address=0xf0000
vgaromimage: file=/usr/share/vgabios/vgabios.bin

Direcciones de java 2 sdk y j2me para bajarlo directo en linux

Aquí pongo dos direcciones de donde poder bajar de forma rápida:

java 2 sdk:

Java 2 SDK

y j2me:

Java 2 Micro Edition

¿Para qué sirve el comando time?

Con el comando time podemos conocer el tiempo que tarda en realizarse la ejecución de un comando. Por ejemplo:

airam@airam-laptop:/etc$ time ls

real 0m0.014s
user 0m0.004s
sys 0m0.004s

Esto puede ser útil para conocer cuánto tiempo tarda en ejecutarse nuestros programas.

¿Cómo mostrar la fecha y la hora en Linux?

Para mostrar la fecha y la hora utilizamos el comando date.

airam@airam-laptop:~$ date
mar mar 25 10:59:49 WET 2008

Los parámetros de formato son los siguientes:
%a -> abrevia el día de la semana.
Ejemplo:
airam@airam-laptop:~$ date +%a
mar
%A -> muestra el nombre completo del día de la semana.
Ejemplo:
airam@airam-laptop:~$ date +%A
martes
%b -> abrevia el mes.
Ejemplo:
airam@airam-laptop:~$ date +%b
mar
%B -> nombre completo del mes.
Ejemplo:
airam@airam-laptop:~$ date +%B
marzo
%c -> muestra el nombre del día y del mes abreviados.
Ejemplo:
airam@airam-laptop:~$ date +%c
mar 25 mar 2008 11:05:27 WET
%d -> muestra el mes en formato numérico.
Ejemplo:
airam@airam-laptop:~$ date +%d
25
%D -> muestra la fecha en formado mmddaa
Ejemplo:
airam@airam-laptop:~$ date +%D
03/25/08
%y -> muestra sólo los dos últimos dígitos del año.
Ejemplo:
airam@airam-laptop:~$ date +%y
08
%Y -> muestra los cuatro dígitos del año.
Ejemplo:
airam@airam-laptop:~$ date +%Y
2008

Sólo el root la puede cambiar. Para cambiarla tendrá que poner:
date mesdiaminutossegundosaño
Por ejemplo:
date 052312342009
Significa que es dia 23-05-2009 y son las 12:34

¿Para qué sirve el comando id?

El comando id muestra la identificación del usuario. También se le llama "user id" o "uid". Muestra a su vez, el grupo de identificación en el que está inscrito (group id o gid).

airam@airam-laptop:~$ id
uid=1000(airam) gid=1000(airam) grupos=4(adm),20(dialout),24(cdrom),25(floppy),29(audio),30(dip),44(video),46(plugdev),106(fuse),108(lpadmin),113(admin),1000(airam)

Comprobar la versión del kernel

Para conocer la versión del kernel podemos utilizar dos métodos. El primero:

airam@airam-laptop:~$ cat /proc/version
Linux version 2.6.24-12-386 (buildd@palmer) (gcc version 4.2.3 (Ubuntu 4.2.3-2ubuntu4)) #1 Wed Mar 12 22:30:29 UTC 2008

y el segundo:

airam@airam-laptop:~$ uname -a
Linux airam-laptop 2.6.24-12-386 #1 Wed Mar 12 22:30:29 UTC 2008 i686 GNU/Linux

y si sólo queremos la versión, entonces:

airam@airam-laptop:~$ uname -r
2.6.24-12-386

Conocer la distribución de Linux

Para conocer la distribución de Linux que tenemos instalado podemos hacer lo siguiente:

airam@airam-laptop:~$ cat /etc/issue
Ubuntu hardy (development branch) \n \l

que en mi caso es Kubuntu Hardy Heron.

¿Para qué sirve el comando whoami?

El comando whoami te permite ver el nombre del usuario que está conectado.
Por ejemplo:

airam@airam-laptop:~$ whoami
airam

¿Para qué sirve el comando hostname?

El comando hostname te permite asignar un nombre a la máquina o al servidor local. Si simplemente ponemos hostname nos saldrá:

airam@airam-laptop:~$ hostname
airam-laptop

¿Para qué sirve pwd?

El comando pwd sirve para mostrar el directorio actual.
Ejemplo:
airam@airam-laptop:~$ pwd
/home/airam

¿Cómo instalar un archivo .bin en linux?

Los archivos .bin son de lo más facilito que instalar. Solo tenemos que dar dos pasos (no conflictivos).
La explicación la realizaré mediante un ejemplo. Supongamos que queremos intalar el fichero "install.bin"

chmod +x install.bin

Con esto le damos permiso de ejecución al fichero. Ahora por último lo mandamos a ejecutar:

./install

¿Cómo saber si nuestra tarjeta gráfica está acelerada en linux?

Independientemente de el modelo de tarjeta gráfica, podremos saber si está acelerada de la siguiente manera:

~$ glxinfo | grep direct
direct rendering: Yes

Además si también podemos probar con:

~$ glxgears

En este caso deberíamos ver los engranajes moviéndose.

¿Cómo ver Kubuntu Linux en la tele?

Bueno, después de haber acelerado la tarjeta gráfica NVIDIA, de haber instalado compiz fusion, de descomprimir rar, de visualizar wmv sin necesidad de utilizar vlc,... ahora vamos a poner linux en nuestra tele ( todo ésta explicado en el blog ).
Nota: Es impresimdible tener acelerada la tarjeta gráfica. Acelerar NVIDIA.
Nota2: Para que funcione arranca el modo gr´africo con la tele enchufada a la tarjeta NVIDIA.
Una vez conectado el ordenador a la tele, con el cable adecuado, nos dirigimos a: Kde > Sistema > NVIDIA X Server Settings.
Maximizamos la ventana que aparece. Pinchamos en el apartado de X Server Display Configuration.

Seleccionamos en la imagen donde salen dos pantallas la segunda (OEM (Disbled)). Verificamos la casilla de Enable Xinerama. Pinchamos en el bot´on Configure... y en el cuadro de di´alogo que aparece seleccionamos Separate X Screen. En la lista desplegable Resolution: Seleccionamos la m´as apropiada para nuestro televisor, en mi caso es de 800x600. Ahora en la lista desplegable que se ve a continuaci´on, seleccionamos la frecuencia de nuestro televisor, en mi caso es de 60 Hz, porque estoy en Europa. En tu caso aplica la adecuada, esta la puedes ver en el manual que viene con la televisi´on. Ahora pulsamos el bot´on Apply y este es el resultado:

Otro método:

Siempre que nuestra tarjeta gráfica esté acelerada podremos escribir en la consola los siguientes comandos para ver de manera rápida la salida de video en la televisión.
~$ xrandr -q
Screen 0: minimum 320 x 200, current 1280 x 800, maximum 1280 x 1280
VGA disconnected (normal left inverted right x axis y axis)
LVDS connected 1280x800+0+0 (normal left inverted right x axis y axis) 331mm x 207mm
1280x800 59.9*+ 60.0
1280x768 60.0
1024x768 60.0
800x600 60.3
640x480 59.9
TV disconnected (normal left inverted right x axis y axis)

Si sale esto todo correcto, ahora:
~$ xrandr --output VGA --auto

En este momento deberíamos de estar viendo la salida de video por la televisión. Cuando queramos volver al modo normal tecleamos:

~$ xrandr --output VGA --off

¿Cómo instalar Compiz Fusion en kubuntu?

En primer lugar Compiz Fusion es la unión de beryl y Compiz. Es un conjunto
de plugins que permiten añadir efectos visuales a tu escritorio. En primer
lugar debes de tener acelerada tu tarjeta gráfica. En caso contrario, ya
publiqué un post donde puedes consultar como hacerlo en caso de tener una
NVIDIA. Este es el línk:
Acelerar NVIDIA
Y también si no la habías acelerado, consulta como configurarla en:
Configurar NVIDIA

Bueno y si ya has conseguido acelerar tu tarjeta gráfica ( mis felicitaciones ). Primero vamos a instalar emerald. Para ello editamos el sources.list para incluir los temas de emerald.
sudo vim /etc/apt/sources.list
A continuación nos movemos hasta el final del fichero, pulsamos la tecla i y pegamos estas líneas:

#Temas de emerald
deb http://es.archive.ubuntu.com/ubuntu/ feisty universe
deb-src http://es.archive.ubuntu.com/ubuntu/ feisty universe
deb http://es.archive.ubuntu.com/ubuntu/ feisty-updates universe
deb-src http://es.archive.ubuntu.com/ubuntu/ feisty-updates universe
#######################################

Nota: Para pegar en vim utiliza Shift + Ins.

Ahora pulsamos Esc y tecleamos ":x" para que guarde y salga.
Actualizamos el sistema:

sudo apt-get update

Y ya solo queda instalar emerald:

sudo apt-get install emerald-themes emerald

Ahora es el turno de instalar compiz fusion:

sudo apt-get install compiz-kde compizconfig-settings-manager compiz-fusion-plugins-main compiz-fusion-plugins-extra


Fíjate que he puesto plugins extra. Ahora ya sólo falta que juegues con la configuración. Para ello, en el menú de KDE > Preferencias > Advanced Desktop Effects Settings, abrirá un cuadro de diálogo en
el que puedes ir probando cada plug-in.
Para ver los efectos, tienes que abrir una consola y poner:
compiz
De esta forma, ejecutara compiz fusion.

Para poder aplicar los temas de emerald, tienes que escribir en la consola:
emerald --replace

Ahora si accedes a Kde > Pereferencias > Gestor de temas de emerald, podrás cambiar la apariencia de las ventanas.

Nota: Cuando inicies kde deberías ver algo así:

Modificar el xorg.conf para utilizar beryl en linux

Para que el beryl funcione bien en kubuntu linux es necesario realizar las siguientes modificaciones al fichero xorg.conf que realizaremos desde consola con el programa nvidia-xconfig. Antes que nada realizamos una copia al xorg.conf por si acaso:

cp /etc/X11/xorg.conf /etc/X11/xorg.conf.backup

y ahora las siguientes instrucciones:

sudo nvidia-xconfig -allow-glx-with-composite

Using X configuration file: "/etc/X11/xorg.conf".
Option "AllowGLXWithComposite" "True" added to Screen "Screen0".
Backed up file '/etc/X11/xorg.conf' as '/etc/X11/xorg.conf.backup'
New X configuration file written to '/etc/X11/xorg.conf'

sudo nvidia-xconfig -allow-glx-with-composite

Using X configuration file: "/etc/X11/xorg.conf".
Option "AllowGLXWithComposite" "True" added to Screen "Screen0".
Backed up file '/etc/X11/xorg.conf' as '/etc/X11/xorg.conf.backup'
New X configuration file written to '/etc/X11/xorg.conf'


sudo nvidia-xconfig -render-accel

Using X configuration file: "/etc/X11/xorg.conf".
Option "RenderAccel" "True" added to Screen "Screen0".
Backed up file '/etc/X11/xorg.conf' as '/etc/X11/xorg.conf.backup'
New X configuration file written to '/etc/X11/xorg.conf'

sudo nvidia-xconfig -add-argb-glx-visuals

Using X configuration file: "/etc/X11/xorg.conf".
Option "AddARGBGLXVisuals" "True" added to Screen "Screen0".
Backed up file '/etc/X11/xorg.conf' as '/etc/X11/xorg.conf.backup'
New X configuration file written to '/etc/X11/xorg.conf'

Ahora si todo sale bien, pulsamos Alt+Crtl+BackSpace para reiniciar
el sistema gráfico. Si te arranca en modo texto porque te da un error,
consulta la siguiente página:
Acelerar NVIDIA
y mira el apartado donde dice: "qué pasa si no me entra en kde porque me ha dado un error, sigue estos pasos:"

¿Cómo instalar el compilador de c++ en kubuntu linux?

Para instalar el compilador de c++ en kubuntu linux es tan fácil como:

sudo apt-get install g++

¿Cómo acelerar la tarjeta gráfica nvidia geforce go 7300 en kubuntu linux?

Buenas!! Seguro que si tienes la tarjeta gráfica nvidia geforce go 7300 y quieres acelerarla en linux, no habrás encontrado los drivers en la página de nvidia. Esto es porque según explican en la web, los da Asus en su página. Sin embargo, en la página de Asus sólo están disponibles los drivers para Windoze. (que raro... lol). Pero los puedes descargar poniendo en tu consola:

wget -Nc ftp://download.nvidia.com/XFree86/Linux-x86/169.09/NVIDIA-Linux-x86-169.09-pkg1.run

Recuerda que antes de instalar tienes que tener instalado el make, gcc y kernel-source.
Nota: En kubuntu el make y el gcc viene instalados por defecto, pero el kernel-source no. Tendrás que hacer un apt-cache search kernel-source. Te mostrará todos los paquetes que tengan que ver con kernel-source. Acto seguido, instala todos los kernel-source que tengan que ver con nvidia. Una vez que los hayas instalado, reinicia el equipo para que los cambios surtan efecto.
El siguiente paso es instalar lo que nos hemos descargado, para ello haz lo siguiente: (lápiz y papel para anotar)

1) Pulsa Ctrl+Alt+Backspace o cierra la sesión de linux.
2) Pulsa Ctrl+Alt+F1 y logeate con tu nombre de usuario y contraseña (o como root si lo tienes configurado. )
3) escribe: sudo /etc/init.d/kdm stop
4) escribe sudo sh NVIDIA-Linux-x86-169.09-pkg1.run -q
5) Te entrará en un asistente de instalación, pulsa aceptar aceptar ok ok... hasta que termine. En este paso a mi me dijo que me faltaba el paquete libc. Lo solucioné de forma bruta poniendo: sudo apt-get install lib*-dev
6) Escribe: sax2 -r -m 0=nvidia
7) Reinicia el ordenador con: sudo shutdown -r now
8) Si te sale antes de entrar en kde una imagen de NVIDIA lo habrás logrado.

En este punto, qué pasa si no me entra en kde porque me ha dado un error, sigue estos pasos:

1) Pulsa Ctrl+Alt+Backspace o cierra la sesión de linux.
2) Pulsa Ctrl+Alt+F1 y logeate con tu nombre de usuario y contraseña (o como root si lo tienes configurado. )
3) escribe: sudo /etc/init.d/kdm stop
4) y ahora: sudo vim /etc/default/linux-restricted-modules-common
5)Pulsa la tecla "i" para entrar en el modo de edición y cambia la siguiente línea:
DISABLED_MODULES="nv".
Esto desabilitará la nvidia.
6) reinicia con : sudo shutdown -r now
7) Entra en kde.

Ahora si tienes la nvidia acelerada lo comprobamos utilizando glxinfo, para ello antes debes de intalar:
sudo apt-get install mesa-utils
y ahora podemos comprobar si efectivamente se aceleró la tarjeta gráfica, poniendo:
glxinfo | grep direct
direct rendering: Yes



El yes significa -> ÉXITOO y el no significa, léete de nuevo todo esto y vuelvelo a intentar, y si no te funciona comentalo por aquí. BUENA SUERTE!!!!

PD:Si escribes en la consola: glxgears
tendrás que ver unos engranajes moviendose.

¿Cómo reproducir videos .wmv en kaffeine?

Para reproducir videos .wmv en Kaffeine tenemos que instalar el siguiente paquete:

sudo apt-get install libxine1-ffmpeg

y listo!!

¿Cuál es la diferencia en C++ entre usar "\n" y endl?

La diferencia está en que al usar endl se invoca automáticamente a flush y "\n" no.

Cómo implementar la funcion getch(), readkey, getchar() para C++

El siguiente post explica como implementar una función getch() al estilo getchar() de Pascal o getche() de conio.h.

Creamos un fichero al que yo llamé Stflib.h ( debido a que incluyo otras funciones como ToString, Gotoxy, que puedes ver en este blog en el menú).

#include <iostream>
#include <string>
#include <sstream>
#include <fstream>
#include <cstdlib>
 
using namespace std;

static bool isGenerated = false;

const string readCharScript[7] = {"#!/bin/sh" ,
"tput smso",
"tput rmso",
"oldstty=`stty -g`",
"stty -icanon min 1 time 0",
"dd bs=1 count=1 of=output >/dev/null 2>&1",
"stty \"$oldstty\"" };

void GenereFile() {
ofstream outputFile( ".readone", fstream::out );
for ( int i = 0; i < 7; i++ ) outputFile << readCharScript[i] << endl; system("chmod +x .readone"); isGenerated = true; } char getch() { if (!isGenerated) GenereFile(); system("./.readone"); char ch; ifstream file("output", fstream::in); file >> ch;
file.close();
return ch;
}



En otro fichero, al que llamé getch.C, ponemos:


#include "Stflib.h"

using namespace std;

int main() {
char ch = getch();
cout << endl << "El caracter es: " << ch << endl; return 0; }

¿Por qué se usa m_ como prefijo en los atributos privados de la clase en C++ y otros lenguajes?

En los atributos privados muchos programadores anteponen el prefijo m_ al atributo. Esto se hace para saber distinguir las variables de la clase de las que no lo son. La m viene de member variable.
En los atributos protegidos se utiliza m_p.

How to convert float to int in c++

Let's use static_cast.


float foo = 3.4; // Here the float variable
int myint = static_cast<int>(foo); // Now we have the int part of foo in myint


I hope I had helped you. If you want, you can post your comments and I'll answer you as soon as possible. Thanks!

Cómo convertir un float a un int en c++

Para convertir un int a float utilizamos static_cast de la siguiente manera:

float foo = 3.4;
int myint = static_cast<int>(foo);

Y ahora ya tenemos en la variable myint el valor 3.
Espero que les haya servido de ayuda. Pueden postear comentarios si lo desean o proponer una alternativa.

Crear una barra de progreso para la consola de Linux en C++.

Un ejemplo de cómo programar una barra de progreso para utilizarla en la consola de Linux.

Primero creamos el fichero Stflib.h

#include <iostream>
#include <string>
#include <sstream>

using namespace std;

/**
 * Función para convertir cualquier tipo de datos a string.
 */
template <class T>
inline string ToString(const T& t) {
  stringstream ss;
  ss << t;
  return ss.str();
}

/**
 * Función para emular al gotoxy en la consola de Linux.
 */
inline string Gotoxy(const int& x, const int& y) {
  return "\33[" + ToString(x) + ";" + ToString(y) + "H";
}

Segundo creamos el fichero Colors.h

/** \file   Colors.h
*  \brief  Declaraciones de la clase \c Colors.
*  \author Airam Rodríguez Rivero.
*  \date   11-11-07
*  El propósito de esta clase es la de permitir la utilización de colores
*  utilizando la consola de linux que será donde se envíe el flujo de datos
*  generado por nuestro programa.
*/

#ifndef _COLORS_H_
#define _COLORS_H_


#include <string>
#include <iostream>

using namespace std;

typedef string     TColor;

const TColor Reset     = "\033[0m";    // Reset
const TColor Bold      = "\033[1m";    // Brillo o negrita.
const TColor Underline = "\033[4m";    // Subrayado

// ******************* Foreground Non-lighted Colors *******************

const TColor Black     = "\033[30m";   // Negro
const TColor Red       = "\033[31m";   // Rojo
const TColor Green     = "\033[32m";   // Verde
const TColor Brown     = "\033[33m";   // Marron
const TColor Blue      = "\033[34m";   // Azul
const TColor Magenta   = "\033[35m";   // Magenta
const TColor Cyan      = "\033[36m";   // Cyan
const TColor White     = "\033[37m";   // Blanco

// ******************* Foreground Lighted Colors *******************

const TColor HBlack    = "\033[1m\033[30m"; /// bright/bold black
const TColor HRed      = "\033[1m\033[31m"; /// b red
const TColor HGreen    = "\033[1m\033[32m"; /// b green
const TColor HYellow   = "\033[1m\033[33m"; /// b yellow
const TColor HBlue     = "\033[1m\033[34m"; /// b blue
const TColor HMagenta  = "\033[1m\033[35m"; /// b pink
const TColor HCyan     = "\033[1m\033[36m"; /// b cyan
const TColor HWhite    = "\033[1m\033[37m"; /// b white

// ******************* Background Non-lighted Colors *******************

const TColor BBlack    = "\033[40m";   // Negro
const TColor BRed      = "\033[41m";   // Rojo
const TColor BGreen    = "\033[42m";   // Verde
const TColor BBrown    = "\033[43m";   // Marron
const TColor BBlue     = "\033[44m";   // Azul
const TColor BMagenta  = "\033[45m";   // Magenta
const TColor BCyan     = "\033[46m";   // Cyan
const TColor BWhite    = "\033[47m";   // Blanco

// ******************* Background Lighted Colors *******************

const TColor HBBlack   =  "\033[40;1m";   // Negro
const TColor HBRed     =  "\033[41;1m";   // Rojo
const TColor HBGreen   =  "\033[42;1m";   // Verde
const TColor HBBrown   =  "\033[43;1m";   // Marron
const TColor HBBlue    =  "\033[44;1m";   // Azul
const TColor HBMagenta =  "\033[45;1m";   // Magenta
const TColor HBCyan    =  "\033[46;1m";   // Cyan
const TColor HBWhite   =  "\033[47;1m";   // Blanco

#endif

Tercero creamos el fichero ProgressBar.h

/** \file   ProgressBar.h
*  \brief  Declaraciones de la clase \c ProgressBar.
*  \author Airam Rodríguez Rivero.
*  \date   21-02-08
*  La clase ProgressBar permite generar barras de progreso para la
*  consola de Linux. Se puede determinar el color de fondo de la barra
*  de progreso ( el parámetro _background ), el color de progreso cargado
*  ( el parámetro _loadedColor ), el caracter de relleno de la barra de 
*  progreso que por defecto es un espacio en blanco. Se especifica la
*  posición en la pantalla donde se va a colocar la barra de progreso mediante
*  el atributo _coordinate.
*/

#ifndef _PROGRESSBAR_H_
#define _PROGRESSBAR_H_

#include <iostream>
#include <string>
#include "Stflib.h"

using namespace std;

typedef short int            TProgress;
typedef short int                TSize;
typedef string                  TColor;
typedef pair TCoordinate;
typedef char                 TFillChar;

/// Clase para manejar barras de progreso en la consola de linux.
class ProgressBar {
private:
TProgress         _loaded;    // Representa el porcentaje cargado en la barra de progreso.
TSize               _size;    // Tamaño de la barra de progreso.
TColor        _background;    // Color de fondo de la barra de progreso.
TColor       _loadedColor;    // Color del porcentaje cargado.
TCoordinate   _coordinate;    // Posición en la que presentar en pantalla la barra de progreso.
TFillChar       _fillChar;    // Carácter de relleno de la barra de progreso.
bool   _percentageVisible;
public:
ProgressBar( const TSize& s, const TColor& bg, const TColor& lc, const TFillChar& fc = ' ' ) : _size( s ), _background( bg ), _loadedColor( lc ), _fillChar( fc ), _percentageVisible( true ) { }
~ProgressBar() { }

inline void SetBackground( const TColor& color ) { _background  = color; }
inline void SetLoadedColor( const TColor& color ) { _loadedColor = color; }
inline void SetSize( const TSize& size ) { _size        = size; }
inline void SetCoordinate ( const TCoordinate& coordinate ) { _coordinate  = coordinate; }
inline void SetLoaded( const TProgress& progress )  { _loaded      = progress; }
inline void SetPercentageVisible( const bool& v ) { _percentageVisible = v; }

inline TSize GetX() const { return _coordinate.first;  }
inline TSize GetY() const { return _coordinate.second; }
inline TSize GetSize() const { return _size; }

inline bool IsPercentageVisible() const { return _percentageVisible; }

inline TProgress GetLoaded() const { return _loaded; }

inline TColor GetBackground() const  { return _background;  }
inline TColor GetLoadedColor() const { return _loadedColor; }
inline TFillChar GetFillChar() const { return _fillChar; }

void ShowPercentage( ostream& sout ) const;
void Paint( ostream& sout ) const;

friend ostream& operator<<( ostream& sout, const ProgressBar& pb ); };  #endif  

Cuarto: Creamos el fichero ProgressBar.C

#include "ProgressBar.h"
#include "Colors.h"

using namespace std;

void ProgressBar::ShowPercentage( ostream& sout ) const {
  if ( IsPercentageVisible() ) {
    sout << "[" << GetLoaded() << "%] ";
  }
}

void ProgressBar::Paint( ostream& sout ) const {
  sout << Gotoxy( GetX(), GetY() );
  // Calculamos el número de caracteres con los que rellenamos la barra de progreso.
  float charged = GetLoaded() * GetSize() / 100;
  TSize partialSize = static_cast(charged);
  for ( TProgress i = 0; i <= partialSize; i++ )
    sout << GetLoadedColor() << GetFillChar();
  for ( TProgress i = partialSize; i < GetSize(); i++ )
    sout << GetBackground() << ' ';
  sout << Reset;
  ShowPercentage( sout );
}

ostream& operator<<( ostream& sout, const ProgressBar& pb ) {
  pb.Paint( sout );
  return sout;
}

Quinto: Probamos nuestra barra de progreso con el fichero ProgressBarTest.C

#include <iostream>
#include <time.h>
#include <cstdlib>
#include "ProgressBar.h"
#include "Colors.h"

using namespace std;

int main() {
  //system("clear"); // Importante para no sobreescribir la pantalla.
  // Emular goto(x, y);
  TProgress completed = 10;
  ProgressBar pb( completed, HBWhite, BBlue, ' ' );
  TCoordinate c;
  c.first = 6;
  c.second = 10;
  pb.SetCoordinate(c);
  TProgress i = 0;
  time_t lastTime = time( NULL );
  while ( i <= 10 ) {
    if ((difftime(time(NULL), lastTime)) >= 0.55) {
      cout << Reset; // Importante poner este reset separado, sino tira error de segmentación. 
      system("clear");
      lastTime = time (NULL);
      pb.SetLoaded(i * 10);
      cout << pb;
      cout << flush;
      i++; 
    } else 
      lastTime = time(NULL);
  }
  cout << Reset << endl; // Importante poner este reset separado, sino tira error de segmentación. 
}  

La compilación de todo el código sería:

g++ Stflib.h
g++ Colors.h
g++ ProgressBar.h
g++ -c ProgressBar.C
g++ -o bar ProgressBar.o ProgressBarTest.C

Y ahora para ejecutar:

./bar

Espero que les sirva y que les guste. Pueden dejar comentarios por si tienen dudas o si quieren que cambie alguna cosa! Muchas gracias!!

¿Cómo implementar la función gotoxy en C++ para la consola de Linux?

Una manera de implementar la función goto(x,y) en C++ que permite escribir texto en una posición determinada en la consola de Linux.

/** \file   GotoXY.C
*  \brief  Definición de las funciones necesarias para implementar gotoxy.
*  \author Airam Rodríguez Rivero
*  \date   14-02-08
*/
#include <iostream>
#include <string>
#include <sstream>
#include <cstdlib>
using namespace std;

/**
 * Función para convertir cualquier tipo de datos a string.
 */
template <class T>
inline string ToString(const T& t) {
  stringstream ss;
  ss << t;
  return ss.str(); 
} 
/** Función para emular al gotoxy en la consola de Linux. */
inline string gotoxy(const int& x,const int& y) {
  return "\33[" + ToString(x) + ";" + ToString(y) + "H"; 
}

int main() {
  system("clear"); // Importante para no sobreescribir la pantalla.
  // Emular goto(x, y);
  cout << gotoxy(2,4) << "Hola" << endl;
} 

Utilizar colores en C++ para la consola de Linux

Primero creamos un fichero cabecera como sigue:

/** \file   Colors.h
*  \brief  Declaraciones de la clase \c Colors.
*  \author Airam Rodríguez Rivero.
*  \date   11-11-07
*  El propósito de esta clase es la de permitir la utilización de colores
*  utilizando la consola de linux que será donde se envíe el flujo de datos
*  generado por nuestro programa.
*/

#ifndef _COLORS_H_
#define _COLORS_H_

#include 
#include 
#include 

#define Reset      "\033[0m"    // Reset
#define Bold       "\033[1m"    // Brillo o negrita.
#define Underline  "\033[4m"    // Subrayado

// ******************* Foreground Non-lighted Colors *******************

#define Black      "\033[30m"   // Negro
#define Red        "\033[31m"   // Rojo
#define Green      "\033[32m"   // Verde
#define Brown      "\033[33m"   // Marron
#define Blue       "\033[34m"   // Azul
#define Magenta    "\033[35m"   // Magenta
#define Cyan       "\033[36m"   // Cyan
#define White      "\033[37m"   // Blanco

// ******************* Foreground Lighted Colors *******************

#define HBlack     "\033[1m\033[30m" /// bright/bold black
#define HRed       "\033[1m\033[31m" /// b red
#define HGreen     "\033[1m\033[32m" /// b green
#define HYellow    "\033[1m\033[33m" /// b yellow
#define HBlue      "\033[1m\033[34m" /// b blue
#define HMagenta   "\033[1m\033[35m" /// b pink
#define HCyan      "\033[1m\033[36m" /// b cyan
#define HWhite     "\033[1m\033[37m" /// b white

// ******************* Background Non-lighted Colors *******************

#define BBlack      "\033[40m"   // Negro
#define BRed        "\033[41m"   // Rojo
#define BGreen      "\033[42m"   // Verde
#define BBrown      "\033[43m"   // Marron
#define BBlue       "\033[44m"   // Azul
#define BMagenta    "\033[45m"   // Magenta
#define BCyan       "\033[46m"   // Cyan
#define BWhite      "\033[47m"   // Blanco

// ******************* Background Lighted Colors *******************

#define HBBlack      "\033[40;1m"   // Negro
#define HBRed        "\033[41;1m"   // Rojo
#define HBGreen      "\033[42;1m"   // Verde
#define HBBrown      "\033[43;1m"   // Marron
#define HBBlue       "\033[44;1m"   // Azul
#define HBMagenta    "\033[45;1m"   // Magenta
#define HBCyan       "\033[46;1m"   // Cyan
#define HBWhite      "\033[47;1m"   // Blanco

#endif

Ahora podemos hacer cosas como estas:

cout << HBYellow << HRed << "Rojo sobre amarillo" << endl;

¿Cómo convertir un char* a un string con const_cast en C++?

A continuación un ejemplo de const_cast para convertir un char* a un string.

char* chain;
const string str = const_cast<char*>(chain); 

Cómo convertir int, float, char,... a string en C++

Una manera de convertir cualquier tipo de datos a un string es volcarlo a un flujo stringstream y posteriormente extraerlo.

#include <iostream>
#include <sstream>

using namespace std;
template <class T>
inline static string toString(const T& t) {
  stringstream ss;
  ss << t;
  return ss.str();
} 
int main() {
 int number = 123;
 cout << toString(number) << endl;
 return 0;
} 

Bienvenido!

El objetivo de este blog es el de aportar soluciones y configuraciones al sistema operativo Kubuntu. Utilizo un Asus F3jc. También aportaré programación en C++ y otros lenguajes de programación, así como otros artículos relacionados con la Ingeniería de informática.