archivo

Archivo de la etiqueta: imágenes

graphiql_demo

Pantalla demo creada con GraphiQL

Siguiendo con la fórmula de la semana pasada de recuperar artículos de QForum, hoy hablaremos de mostrar imágenes en la pantalla del QL. No entraré a explicar cómo es esta pantalla, pues existe documentación específica para ello en este mismo blog, pero sí indicaré cómo hacer para, por ejemplo, poner una pantalla de inicio a un juego o mostrar una imagen de un tamaño determinado en píxeles en una posición determinada de la pantalla.

Read More

Anuncios

Estamos acostumbrados a ver fotos de aquellos viejos ordenadores de los 80 y alguna que otra máquina de los 60-70 con sesudos científicos de bata blanca pululando alrededor o señores trajeados haciendo negocios con sus calculadoras como habitaciones de grande.

Pues bien, en esta ocasión son las chicas las que pueden verse en la colección de fotografías del blog retro-space en Flckr titulada «Chicks ‘n’ Computers» (chicas y ordenadores).

Aunque es una buena ocasión para ver estas máquinas operadas por sus usuarios/as, a nadie se le escapa que los ordenadores aquí son menos relevantes que las señoritas fotografiadas. No obstante, no hay que esperar mucho de estas fotos. Algunas de estas mujeres tienen el típico aspecto de tu hermana mayor cuando vuelve de descubrir una nueva peluquería y no se ha puesto las lentillas por la mañana. Vamos, que la cosa no es como las portadas de esas revistas en plan “Cars & Girls“.

Sea como fuere, no deja de ser un tributo a las mujeres científicos y las operarias que tanto han aportado a la informática tal como la conocemos hoy, porque ¿quién dijo que a las chicas no les gusta la informática?

Enlace: Chicas y ordenadores
Vía Microsiervos

En varias ocasiones hemos tratado el tema del manejo de la pantalla del QL en Qforum (el foro del QL de sinclairql.es). En ellos hay variedad de información, pero al menos a mí, siempre me han quedado algunas lagunas debido al desconocimiento de cómo trata el QL la pantalla. En muchas ocasiones no he entendido exactamente las aportaciones de los otros usuarios cuando hablan en profundidad de este tema, siempre ha habido conceptos que se me han escapado y que no he llegado a comprender del todo bien. Por ejemplo, el porqué de las distintas resoluciones del QL, como se gestionan los colores, las peculiaridades del “flashing”, etc.

Para cubrir estas lagunas presento este artículo en el cual sólo me he dedicado a rescatar material “enterrado” en varias fuentes que hablan sobre esto. He dividido el artículo en dos partes. Una primera parte con “la teoría” extraída de un buen artículo de la vieja revista Qlave escrito por Javier Boira (¡fantástico el artículo!), y una segunda parte donde se ejemplifica el tratamiento directo de la memoria de pantalla del QL mediante un pequeño programa escrito en SuperBASIC. Este programa no es más que una adaptación de otro pequeño programa de Timothy Swenson publicado en el ezine “QL Hacer’s Journal”. Como veis, el contenido no es de elaboración propia, yo sólo me he limitado a rescatar, traducir, mezclar, decorar y organizar la información que he encontrado.

Bueno, empecemos.

La teoría

La pantalla constituye el medio directo de comunicación del ordenador con el usuario, es lógico pues que dediquemos algún tiempo a conocer más de cerca este elemento tan cercano al programador.

Nuestro QL nos ofrece, ya nada encenderlo, dos posibilidades gráficas; una de ellas con mayor colorido pero menor resolución (256×256), mientras la otra nos ofrece la ventaja de una mayor resolución con 512 puntos horizontales (512×256) a la par que se pierden cuatro colores y la posibilidad de parpadeo.

De todas formas ambos ocupan una misma región de memoria del QL, la cantidad 32K (relativamente grandes para los ordenadores de esta generación). Son estos 32K y sólo ellos los que van a llevar toda la información que se nos ofrece en nuestros monitores. La conversión en imagen visual se realiza a través del conversor de vídeo, este elemento busca la información de cada punto en la memoria (en el momento que se necesite) para darle la tonalidad y contraste necesaria enviándola al monitor y que nosotros reconozcamos la figura claramente. A pesar de que a nosotros nos parezca al utilizar el ordenador que éste nos dedica todo su tiempo esto no es cierto. El microprocesador ha de hallarse constantemente interrumpiendo su labor hacia nosotros (BASIC) para representar la pantalla, manejar Microdrives, atender al teclado y otras muchas cosas que hace mientras nosotros inocentemente creemos estar con nuestro aparato tranquilamente ocupada en el BASIC. Nosotros no nos enteramos del tiempo ocupado en dichos menesteres porque el tiempo utilizado es mínimo para nuestra capacidad de percepción.

Pero volvamos a la memoria de pantalla, que es allí donde se van a definir todas las posibilidades gráficas del QL. Nosotros podemos acceder a toda la información contenida en la memoria de pantalla, así como podemos modificarla con solo “pokear” la zona correspondiente (o “peekear” para leer).

La zona de memoria de pantalla comienza en la dirección $20000, en decimal la 131072, y ocupa exactamente 32768 octetos de memoria RAM, es por esto por lo que de los 128K que lleva instalado nuestro QL de forma estándar, sólo son utilizables menos de 96K. Si multiplicamos estos 32768 bytes por 8 bits que contiene un byte nos dan 262144 en decimal, $40000 bits en hexadecimal. Luego en total disponemos de 262144 unidades mínimas de información, cada bit puede contener un sí o no, uno todo o nada. Luego en estas condiciones podríamos asignar dos colores, uno al si en un bit 1 y el otro al no 0, con lo que con 32K de memoria se podrían definir (si así lo hubiesen definido los diseñadores) 262144 puntos de pantalla. Los diseñadores de SINCLAIR no optaron por esta forma de estructurar la memoria de pantalla, sino por otra, en la que se utilizan cuatro colores. Con un mínimo de conocimiento binario se puede recordar que con dos bits podemos formar cuatro posiciones distintas jugando con los unos y los ceros 00, 01, 10, 11, con lo que con estas dos unidades podemos definir un punto de la pantalla en cuatro posiciones distintas o intensidades (que puede ser como en el QL en alta resolución el negro, rojo, verde y blanco).

Pues bien, si a cada punto dibujable (representable más bien) en la pantalla le asignamos dos bits, en los 262144 bits que disponíamos nos cabe la definición de 131072 puntos dibujables (dividir por dos), exactamente 512 filas por 256 columnas (512×256=131072). Pero además el QL viene dotado de otra resolución más baja, 256×256 puntos en ocho colores y posibilidad de parpadeo. En esta resolución cada punto representable debe hallarse en dieciséis posibles situaciones (negro, azul, rojo, magenta, verde, cian, amarillo, blanco, negro con parpadeo, azul con parpadeo, rojo con parpadeo, magenta con parpadeo, verde con parpadeo, cian con parpadeo, amarillo con parpadeo y blanco con parpadeo), que con bits se puede representar con cuatro (2e4=16, combinaciones de dos elementos “1” y “0” tomados de cuatro en cuatro), por lo que podemos representar 262144/4=65536 ($10000) puntos, es decir 256×256.

Por lo tanto, dependiendo de las combinaciones de unos y ceros en dos bits (alta resolución) o cuatro bits (baja resolución), aparecen en la pantalla los puntos en tonalidad e intensidades deseados. Ahora veamos cómo se colocan estos cuatro o dos bits en la memoria de pantalla.

La zona de memoria de pantalla comienza en la dirección $20000, y acaba en la $27FFF. Cada punto de la pantalla tiene situada su información en dos bytes diferentes y vecinos. Así en el modo de alta resolución cada dos bytes definirán ocho puntos (2×8/2). El primer bit de definición se hallará en el primero de los bytes, y el segundo en el segundo de los bytes. Así el primer punto de la pantalla (el de la esquina superior izquierda) vendrá definido por el primer bit el byte $20000, que seleccionará el color verde (1=verde), y por el primer bit del byte #20001, que seleccionará el color rojo. Si ninguno de ambos bits está activado el punto se hallará en negro, mientras que si se hallan ambos activados (“1”) estará en blanco.

El siguiente punto de la pantalla hacia la derecha viene definido por el segundo bit de los bytes $20000 y $20001 y así sucesivamente, cuando se completan los ocho bits del primer y segundo byte se pasa al primero del tercer y cuarto byte. De este forma los bytes pares contienen la definición del verde de un determinado punto, mitras lo impares del rojo. Cuando se completan los 512 puntos de una línea se pasa a la siguiente. Por lo tanto para localizar el byte en el que se halla de definición de un determinado punto hace falta realizar el siguiente cálculo:

– Punto definido por coordenadas “X” (horizontal) e “Y” (vertical) desde la esquina superior izquierda de la pantalla (0,0) y en puntos reales.

   byte par (verde)   = 131072 + Y * 128 + INT ( X / 8 ) * 2
   byte impar (rojo)  = 131072 + Y * 128 + INT ( X / 8 ) * 2 + 1
   posición del bit dentro del byte = 7 - (X - INT ( X / 8 ) * 8 )

Con estos cálculos podemos hallar la posición de memoria a pokear o leer. Por ejemplo, si deseamos poner en blanco el punto situado a 77 en vertical del origen (arriba) y a 405 en horizontal tendremos:

   byte par (verde)  = 141028
   byte impar (rojo) = 141029
   posicón bit = 2

Luego tenemos que poner el segundo bit de los bytes 141028 y 141029 a 1, con lo que pokeamos con una máscara de la siguiente manera:

   poke 141028, peek(141028) || 4
   poke 141029, peek(141029) || 4

Es decir, hacemos una operación lógica OR del valor 4 (en binario %00000100, el uno en el bit 2) con el contenido anterior, con lo que los bits que no son el bit 2 se quedan como estaban (0 OR 0 = 0, 0 OR 1 = 1), mientras que el bit2 se pone a 1 (0 OR 1 = 1, 1 OR 1 = 1) en los dos bytes, visualizándose dicho punto en color blanco.

Análogo razonamiento deberíamos realizar para la baja resolución, sólo que en esta modalidad cada dos bytes guardan la información de cuatro puntos (2*8/4). El razonamiento para hallar la colocación de un punto quedaría como sigue:

   byte par (verde)   = 131072 + Y * 128 + INT (X / 4) * 2
   byte impar (rojo)  = 131072 + Y * 128 + INT (X / 4) * 2 + 1
   posición del bit verde, rojo = 7 - (X - INT (X / 4) * 4)
   posición del bit azul, parpadeo = 7 - (X - INT (X / 4) * 4) + 1

Notar aquí que los bytes de verde y rojo se hallan en los puestos indicados en los bytes par (verde) e impar (rojo), seguidos inmediatamente de los bits de azul en el byte par y parpadeo en el impar.

Hay que tener cuidado con la utilización del byte de parpadeo pues es un caso muy peculiar. Se pone a uno este bit en alguno de los puntos, dicho punto, así como el resto de la línea derecha hasta el final derecho de la pantalla si no se halla otro bit de parpadeo encendido, se pondrá a parpadear. Así pues el parpadeo se activa desde el punto hasta el siguiente con dicho bit a uno.

Hay que tener mucho cuidado al trabajar con la memoria de pantalla ya que un error de cálculo nos podría llevar a la memoria situada encima de esta zona, que contiene ciertas variables del sistema que al ser alteradas pueden hacer fallar el sistema del ordenador con un consiguiente descontrol del mismo. Esto podría pasar cuando cargamos una pantalla con lbytes y por error lo que cargamos excede de los 32K.

El control de la memoria de pantalla es muy útil sobre todo para la programación en lenguaje máquina, ya que las rutinas que trae el sistema operativo son de carácter muy general, teniendo que contemplar muchos casos particulares con el retardo que esto conlleva. También, los métodos expuestos anteriormente son la base de los comandos del SuperBASIC para el manejo de gráficos en la pantalla.

Un ejemplo práctico
Existen diversidad de rutinas para el tratamiento de la pantalla del QL, prácticamente la totalidad de ellas están escritas en ensamblador por razones de eficiencia.

Con el fin de ilustrar el uso de la pantalla del QL veremos a continuación un programa extraído de la ezine “QL Hackers Journal” de Timothy Swenson.

La finalidad de este pequeño ejemplo es guardar en memoria una zona de una ventana de pantalla para luego recuperarla y pintarla en cualquier otro lugar. Aunque en un programa real estas funciones escritas en SuperBASIC son excesivamente lentas, nos sirven sin embargo para asentar lo que hemos estudiado en este artículo. Además podrían utilizarse como idea base si quisiéramos portar este programa al lenguaje C o al lenguaje ensamblador para un uso real. Esta versión en SuperBASIC es más instructiva a la hora de comprender y testear el algorítmo como paso previo a su versionado en leguajes más eficientes para este tipo de tareas como es el caso del lenguaje ensamblador.

El programa es muy simple de seguir, a continuación mostramos su código fuente y unas capturas de pantalla de los resultados.

100 CLEAR
110 REMark --- Vector para almacenar pantalla
120 DIM store(5000)
130 :
140 REMark --- Cargar pantalla
150 LBYTES flp1_sys_cheetah_scr, 131072
160 :
170 REMark --- Guardar ventana
180 save_bg 120, 100, 360, 20
190 :
200 REMark --- Crear nueva ventana
210 OPEN #3, con_120x100a360x20_32
220 PAPER #3,0: INK #3,7
230 CLS #3
240 PRINT #3,"This is a test"
250 PRINT #3,"of real windows"
260 PAUSE 50
270 CLS #3
280 PRINT #3,"Hit Return"
290 PRINT #3,"to make this"
300 PRINT #3,"go away"
310 INPUT #3,in$
320 CLOSE #3
330 :
340 REMark --- Restaurar ventana
350 load_bg 120, 100, 360, 20
360 :
370 REMark --- Pintar fondo ventana en
380 REMark     varios lugares para demo
390 PAUSE 250
400 CLS:CLS#0:CLS#2
410 load_bg 120, 100, 0, 0
420 load_bg 120, 100, 80, 40
430 load_bg 120, 100, 200, 80
440 PAUSE 250
450 :
460 STOP
470 :
480 :
490 REMark ------------------------------------------
500 REMark   Procedimientos para guardar
510 REMark   y recuperar fondo de ventanas
520 REMark ------------------------------------------
530 :
540 DEFine PROCedure save_bg (length, height, x, y)
550   LOCal   mem, i, j
560   mem = 1
570   FOR i = 131072+(y*128) TO 131072+((y+height)*128) STEP 128
580     FOR j = i + (x/4) TO i + ((x+length)/4) STEP 2
590          store(mem) = PEEK_W(j)
600        mem = mem + 1
610      END FOR j
620   END FOR i
630 END DEFine save_bg
640 :
650 :
660 DEFine PROCedure load_bg (length, height, x, y)
670   LOCal   mem, i, j
680   mem = 1
690   FOR i = 131072+(y*128) TO 131072+((y+height)*128) STEP 128
700     FOR j = i+(x/4) TO i+((x+length)/4) STEP 2
710       POKE_W j,store(mem)
720       mem = mem + 1
730     END FOR j
740   END FOR i
750 END DEFine load_bg
Imágen, fondo de pantalla

Imágen, fondo de pantalla

Fondo, con ventana almacenando fondo de ventana

Fondo, con ventana almacenando fondo de ventana

Réplica de fondo de ventana

Réplica de fondo de ventana

Fuentes.
————
– Revista QLave, “La Pantalla del QL”, Javier Boira.
– QL Hacer’s Journal, Timothy Swenson

Q-emuLator es capaz de emular distintas configuraciones hardware de sistemas QDOS, entre ellas un sistema Aurora+Gold Card. Aurora es una placa gráfica que sustituye a la placa base del QL estándar. Apoyada con una Gold Card o Super Gold Card podemos tener un sistema QDOS compatible, completo y autosuficiente. Entre otras cosas, Aurora aporta una mayor resolución y la posibilidad de manejar de 256 colores. Esto siempre y cuando se disponga de SMSQ/E como sistema operativo, el cual integra GD2 (el “graphics drivers” para poder sobrepasar los 4 / 8 colores del QL estándar).

Visto esto, debería ser posible manejar 256 colores con Q-emuLator. Puestos mano a la obra, al menos para mí, no fue intuitivo activar el modo “256 colores” de Aurora. La documentación de Q-emuLator y la de SMSQ/E no es muy “específica” en este apartado.

Tras perder bastante tiempo sin encontrar la manera de mostrar imágenes con esa profundidad de color, me decidí a escribir a Daniele Terdina (autor de Q-emuLator) … y … ¡¡ llegó la solución !! … Daniele me contestó amablemente con la respuesta.

Podemos activar el modo 256 colores con el comando:

DISP_COLOUR 2,512,480

el cual activa una resolución de 512×480 a pantalla completa. (DISP_COLOUR es un comando de SMSQ/E).

Por ejemplo, el siguiente programa de ejemplo nos mostrará líneas de texto con fondo en colores aleatorios.

100 DISP_COLOUR 2,512,480
110 COLOUR_24
120 REPeat x
130 PAPER RND(255)*65536+RND(255) * 256 + RND(255)
140 PRINT "hola (aurora 256 colores)"
150 END REPeat x

Aquí tenéis una muestra, la consola SuperBASIC en la parte superior mostrando colores aleatorios de la paleta de 256 colores y el Files de QPAC2 en la parte inferior (podemos mostrar las dos ventanas visibles al mismo tiempo ya que tenemos 480 pixels de alto).

QEmulator, 256 colores (1)

Q-emuLator, 256 colores (1)

Imagen completa aquí …

Aprovechando los 256 colores, os pongo algunos ejemplos más, imágenes a 256 colores cargadas con Photon en mi máquina. (No son capturas de pantalla sino fotos directa al monitor).

QEmulator, 256 colores (2)

Q-emuLator, 256 colores (2)

Imagen completa aquí …

QEmulator, 256 colores (3)

Q-emuLator, 256 colores (3)

Imagen completa aquí …

En un artículo anterior, Afx nos mostraba una utilidad llamada photon. He estado haciendo algunas pruebas y estas han dado paso al artículo que estas leyendo y que bien podría haberse llamado:

“Cómo pasar de aquel largo artículo que hice en su momento para convertir imágenes hechas en PC a imágenes visibles en QL y aún así obtener resultados”

En el mencionado artículo exponía una serie de pasos para tratar imágenes mediante un programa de retoque fotográfico y luego convertir cada imagen resultante en el formato de la pantalla del QL. Esto era muy lento y algo trabajoso.

Con la utilidad photon podemos ahorrarnos todos esos pasos. Es suficiente con cargar las imágenes en pantalla y luego volcarlas a un fichero.

Vamos por partes: en este artículo trabajaremos sólo con los modos 512 y 256 de 4 y 8 colores respectivamente. Cargaremos las imágenes con photon y luego las volcaremos a un fichero. Para hacer esto último usaremos, por ejemplo, la utilidad salvar_exe que se publicó en la revista cuq número 7. Esta utilidad previamente se carga en memoria y actua pulsando la combinación de teclas ALT+s. Seguidamente guardará una imagen numerada cada vez que pulsemos esa combinación de teclas.

Resulta además que queremos convertir una imagen que ocupe todo el ancho y el alto de la pantalla. Pues nada más fácil. Puesto que el programa photon muestra las imágenes con su correcta relación de aspecto (a no ser que le indiquemos lo contrario con el comando “r”), las imágenes que usemos deben tener la proporción 4:3. De acuerdo, pero ¿qué medidas en pixels deben tener? Haciendo pruebas he llegado a la conclusión de que las imágenes en modo 4 deben tener un tamaño de 512×384 pixels, y las imágenes en modo 8 un tamaño de 341×256 pixels.

Para mostrar como funciona todo lo explicado antes he elegido un fotograma de la escena final de la película Corazón Salvaje (1990), pues a parte de que me gusta mucho esta película y Laura Dern, la actriz protagonista, el fotograma es extremo en todo los aspectos que nos interesan para la demostración. Está muy saturado en cuanto a color (en este caso colores cálidos, aunque también hay azules), hay muchos objetos en la imagen y aparecen figuras humanas pero no en primer plano. Veamos el resultado:

corazon_salvaje_512Esta es la imagen original a tamaño 512×384.

corazon_salvaje_4Aquí tenemos su conversión a 4 colores.

corazon_salvaje_256Esta es la misma imagen a tamaño 341×256.

corazon_salvaje_8Y aquí su conversión a 8 colores.

Como veis el resultado es razonablemente aceptable, aunque no podemos pedir peras al olmo. Podéis jugar con el parámetro “dn” donde “n” tiene un valor entre 0 (cero) y 4 que corresponden a 0%, 25%, 50%, 75% y 100% de porcentaje de trama. El valor por defecto parece ser “d2” (50%), y es un porcentaje muy adecuado en cualquier ocasión. Para un valor del 75% de trama usaríamos:

ex photon;"corazon_salvaje.jpg\d3"

Observad el resultado:

corazon_salvaje_8_d3Al aumentar la trama obtenemos mayor detalle en objetos pequeños que antes ni se veían y los colores parecen más reales, pero difuminamos los objetos lisos y más cercanos. El secreto es probar y ver cual nos da mejor resultado.

Para conocer más acerca del uso de photon, no dejéis de echarle un vistazo a la ayuda en txt que viene con el programa. A partir de aquí os toca a vosotros.

Descargar el programa photon.

Ojeando un artículo relacionado con la conexión de un QL a Internet, me encontré con la referencia a una pequeña utilidad para mostrar archivos jpg en un QL. Esta utilidad es software libre y está disponible en el sitio de Dilwyn Jones, en la sección de gráficos (http://www.dilwyn.me.uk/graphics/index.html). El programa se llama Photon y funciona a modo de línea de comandos, pasando como argumento el nombre del jpg que se quiere mostrar en pantalla y algunos parámetros más de forma opcional. Viene muy bien documentado con un fichero de ayuda donde se explican todos los parámetros y su funcionamiento. Esta utilidad es capaz de mostrarnos cualquier jpg en cualquier QL (expandido o no) sin necesidad de ningún tratamiento previo. Así podemos mostrar un jgp con los 4 colores básicos del modo 4 del QL estándar hasta un jpg con 16 bits de profundidad de color en sistemas QDOS que lo soporten (por ejemplo QPC2 o QXL con SMSQ/E). Como veréis, los resultados son excelentes.

El uso es muy simple, por ejemplo:

EXEC flp1_photon;"flp1_MiImagen.jpg"

nos mostrará MiImagen.jpg en la pantalla del QL. Si el jpg fuera de mayor tamaño que la pantalla podemos hacer scroll a través de ella con las teclas del cursor.

La utilidad nos abre muchas puertas para diseñar fondos de pantalla, intro para juegos, … Podríamos por ejemplo guardar un volcado de la pantalla para luego recuperarla simplemente con un LBYTES. Tiene un parámetro también que nos sirve para poner un jpg como fondo de escritorio si el hardware o sistema lo soporta (por ejemplo QPC2 o QEmulator con SMSQ/E).


Aquí os pongo algunas muestras:

Un jpg en un QL estándar modo 512 (4 colores).

Jpg en modo 512 (4 colores)

Jpg en modo 512 (4 colores)


Un jpg en un QL estándar modo 256 (8 colores)

Jpg en modo 256 (8 colores)

Jpg en modo 256 (8 colores)


Aquí podemos ver a QEmularor en modo pantalla completa, con un jpg como fondo de escritorio y resolución de 1024×768, 4 colores. Vemos la consola del SuperBASIC, algunos programas del QPAC1, un editor … sobre el fondo que hemos cargado.

Jpg en fondo de escritorio con Q-emulator (1024x768, 4 colores)

Jpg en fondo de escritorio con Q-emulator (1024x768, 4 colores)

Imagen completa aquí …


Para cargar el fondo de pantalla, en el boot he puesto:

EXEC flp1_photon;"flp1_microhobby.jpgw"


Otro ejemplo de lo mismo con otro fondo. Aquí podemos ver en la izquierda la versión de xchange en modo 512×512 píxels

Jpg en fondo de escritorio con Q-Emulator (1024x768, 4 colores)

Jpg en fondo de escritorio con Q-Emulator (1024x768, 4 colores)

Imagen completa aquí …


(Siempre me ha sorprendido lo que se puede lograr con ¡¡4 simples colores!!).


Por último, una ventana equivalente pero con la demo de QPC2 y con una profundidad de color de 16 bits.

Jpg en fondo de escritorio en QPC II Demo (1024x768, 16 bit color)

Jpg en fondo de escritorio en QPC II Demo (1024x768, 16 bit color)

Imagen completa aquí …


En definitiva, una utilidad que no puede faltar en tu QL (aunque sea un QL sin expansión alguna).

SMSQ/E aporta como una de sus mejoras más significativas, la posibilidad de trabajar con resoluciones mayores a la habitual 512×256 del QL original. Además de aportar mayor resolución añade también la posibilidad (teórica) de trabajar con más colores. Graphic Device Interface Version 2 (GD2) es el subsistema de SMSQ/E encargado de manejar estas nuevas características.

Todo esto lo añade el sistema operativo siempre que el hardware lo soporte. Desde luego que con un QL original no podemos obtener estas resoluciones, pero sin con placas tipo Aurora o con el Q60. Q-emuLator en modo expandido soporta la emulación de este nuevo hardware (al menos parcialmente) por lo tanto es posible trabajar en resoluciones mucho mayores a las habituales del QL (al igual que lo hace QPC2).

Empleando el comando DISP_COLOUR podemos activar diversas resoluciones y modos de pantalla. Por ejemplo, con:

DISP_COLOUR 3,1024,768

activamos la pantalla con una resolución de 1024 x 768 pixel y una paleta de 256 colores.

En el siguiente ejemplo podéis ver mi máquina con Q-emuLator trabajando en esta resolución.

QEmulator 1024x768

QEmulator 1024x768

Descarga aquí la foto con mayor resolución (1.5 MB)

El la mitad izquierda de la pantalla tengo el editor de SuperBASIC en una ventana de 512×700 pixeles y en la mitad derecha se muestran varias ventanas bajo PE (un editor de texto, el administrador de archivos de PE, varias utilidades QPAC1, …). En la parte superior está Qascade con algunos “accesos directos” a otras utilidades de PE y a otras instancias de SBASIC. (Existe también una versión de xchange adaptado para trabajar en una ventana de 512×512 pixeles).

Resulta muy cómodo trabajar con nuestros programas QL favoritos, todos visibles a la vez, y conmutar entre tarea y tarea con un simple clic de ratón.

En definitiva, Q-emuLator (modo expandido) + SMSQ/E resulta ser una gran combinación (teclado en español, funcionamiento adecuado del ratón con PE, manejo impecable de la unidad de disquete y de las unidades de almacenamiento “virtuales, … -sólo me queda investigar algo más el tema de los 256 colores-).