Truco:
Como Guardar (y Abrir) comprimidos
los archivos de datos de nuestros programas
En este artículo, os comento como guardar datos de nuestros programas y luego abrirlos, comprimiendo los archivos. Aunque lo explico usando código de Gambas, es aplicable a otros lenguajes Python, Java, etc... Básicamente se trata de usar el comando del sistema tar, y para que se entienda mejor, os haré la explicación de como lo hace el programa pintascreen.
El programa pintascreen, maneja los siguientes datos:
- Una imagen de fondo
- Un array de objetos del tipo "dibujo", que es el que contiene las diversas primitivas de dibujo, osea los objetos del tipo "marcador", "texto", "linea", "flecha", "chincheta", etc... que es lo que va dibujando el usuario.
- Una imagen miniatura de todo lo que ha dibujado, que la usa para mostrarla en el formulario de "abrir":
Os describo los pasos a seguir para Guardar los datos:
Los archivos que tenemos que guardar por cada captura son:
fondo.jpg: es la imagen del fondo
mini.jpg: es una imagen en miniatura de lo dibujado (incluyendo el fondo)
figuras.txt: es un archivo de texto plano, donde se guardan los datos de las figuras dibujadas (ancho, color, coordenada de inicio y fin, etc..)
Pasos a seguir:
0) Pedir la ruta y el nombre del archivo donde guardaremos los datos. Lo guardaremos en la variable "rutafichero"
1) Generar los archivos, tanto la imagen de miniatura como el archivo .txt de las figuras dibujadas.
No entro en detalles, porque para cada programa será distinto, pero podeis ver como se hace en el pintascreen en el módulo: ModuleAbrirGuardar, en el método guardar().
2) Copiarlos en una ruta.
En nuestro caso, los vamos a copiarlo en el directorio /tmp/pintascreenGuarda/
3) Crear el tar.gz
Mediante el siguiente comando, vamos a crear el archivo comprimido que contenga los 3 archivos:
comando
=
"cd
/tmp/pintascreenGuarda/;tar czvf \"" &
File.Name(rutafichero) & ".tar.gz\"
*"
Nota:Es muy importante que usemos "cd" para desplazarnos al directorio donde tenemos los archivos, y luego usar ";" para unir la siguiente orden (tar).
y lo ejecutamos con la orden Shell:
Shell
comando
Wait
4) Cambiamos la extensión .tar.gz por .pintascreen y lo movemos a la ruta seleccionada:
comando
=
"mv
/tmp/pintascreenGuarda/" &
File.Name(rutafichero)
&
".tar.gz "
&
Rutafichero
&
".pintascreen"
Shell comando Wait
5) Borrar archivos temporales.
Borraríamos los archivos que tendríamos en la carpeta "/tmp/pintascreenGuarda/":
For
Each
nombrearchivo
In
Dir("/tmp/pintascreenGuarda/",
"*.*",
GB.File).Sort()
Kill
"/tmp/pintascreenGuarda/"
&
nombrearchivo
Next
Así obtenemos un archivo con extensión .pintascreen, que realmente es un tar.gz, con los archivos de los datos comprimidos y empaquetado.
Pasos para Abrir los archivos .pintascreen
0) Elegir el archivo que queremos abrir, lo llamaremos "rutafichero"
1) Creamos el directorio de trabajo, en nuestro caso lo llamamos "/tmp/pintascreenAbrir", y si no existe lo creamos:
If
Not
Exist("/tmp/pintascreenAbrir")
Then
Mkdir
"/tmp/pintascreenAbrir"
Endif
2) Borramos el contenido del directorio de trabajo, por si hubiésemos abierto otro archivo anteriormente.
'borrar
archivos existentes
For
Each
nombrearchivo
In
Dir("/tmp/pintascreenAbrir",
"*.*",
GB.File).Sort()
Kill
"/tmp/pintascreenAbrir/"
&
nombrearchivo
Next
3) Copiamos el archivo y lo descomprimirmos.
'copia
el archivo y lo descomprime el archivo
Copy
Rutafichero
To
"/tmp/pintascreenAbrir/"
&
File.Name(Rutafichero)
Shell
"cd
/tmp/pintascreenAbrir/;tar -zxvf \"/tmp/pintascreenAbrir/"
& File.Name(Rutafichero) & "\""
Wait
Nota:
Es muy importante que usemos "cd" para desplazarnos al directorio donde tenemos los archivos, y luego usar ";" para unir la siguiente orden (tar).
4) Ya con los archivos descomprimidos, lo usaríamos en el programa, por ejemplo en el pintascreen, se cargaría el fondo, se leería el fichero de figuras.txt, para crear los objetos de dibujo.
Extracción de un archivo concreto:
Os dejo por ultimo, la forma de extraer un archivo en concreto, que es lo que uso para cuando estamos en el formulario de abrir, y nos muestra la miniatura. Se trata de usar el comando tag -zxvf indicándole la ruta donde queramos que se descomprima y el nombre del fichero que queramos extraer. Esto lo hago con el método "cargaImagen()", que esta en el módulo "ModuleAbrirGuardar"
Public
Sub
cargaImagen(Rutafichero
As
String)
As
Picture
'leer
el archivo, lo descomprime, y carga la vista minuatura...Try
Kill
"/tmp/mini.jpg"
Shell
"cd
/tmp;tar -zxvf \"" & Rutafichero & "\"
mini.jpg"
Wait
If
Exist("/tmp/mini.jpg")
ThenReturn
Picture.Load("/tmp/mini.jpg")ElseReturn
NullEndif
End
Como veis, la función recibe el nombre (ruta incluida), del fichero que queremos ver si miniatura, y devuelve un objeto Picture.
Extrae el fichero mini.jpg (en la ruta /tmp) ,
Shell "cd /tmp;tar -zxvf \"" & Rutafichero & "\" mini.jpg" Wait
y lo carga y devuelve
Return Picture.Load("/tmp/mini.jpg")
Si hay no lo encuentra, devuelve Null
Return Null
Por último os comento que seguramente existen otros métodos más óptimos y con mejor rendimiento para hacer esto, yo os lo comento para que veais la forma en que lo hago yo, y como lo he usado en varios de mis programas con éxito.
Nota:
El código fuente del programa pintascreen lo podéis descargar en:
