/*
* Copyright (c) 2001 Dan Gudmundsson
* See the file "license.terms" for information on usage and redistribution
* of this file, and for a DISCLAIMER OF ALL WARRANTIES.
*
* $Id: esdl_video.c,v 1.4 2005/06/29 14:45:39 dgud Exp $
*/
/*
* sdl_video functions
*/
#include <string.h>
#include <stdlib.h>
#include "esdl.h"
#include <SDL_syswm.h>
void es_setVideoMode(sdl_data *sd, int len, char* bp)
{
char* start;
int w, h, bpp, type;
int sendlen;
SDL_Surface *screen;
w = get16be(bp);
h = get16be(bp);
bpp = get16be(bp);
type = get32be(bp);
screen = SDL_SetVideoMode(w, h, bpp, type);
if ((type & SDL_OPENGL) == SDL_OPENGL) {
init_glexts(sd);
}
bp = start = sdl_get_temp_buff(sd, 8);
PUSHGLPTR(screen, bp);
sendlen = bp - start;
sdl_send(sd, sendlen);
}
void es_videoDriverName(sdl_data *sd, int len, char *buff)
{
char *bp;
int sendlen = 0;
bp = sdl_get_temp_buff(sd, 512);
if (SDL_VideoDriverName(bp, 512) != NULL) {
sendlen = strlen(bp);
}
sdl_send(sd, sendlen);
}
void es_getVideoSurface(sdl_data *sd, int len, char *buff)
{
char *bp, *start;
int sendlen;
SDL_Surface *ref;
bp = start = sdl_get_temp_buff(sd, 8);
ref = SDL_GetVideoSurface();
PUSHGLPTR(ref, bp);
sendlen = bp - start;
sdl_send(sd, sendlen);
}
void es_getVideoInfo(sdl_data *sd, int len, char *buff)
{
char *bp, *start;
int sendlen;
const SDL_VideoInfo *vi;
bp = start = sdl_get_temp_buff(sd, 9+2*8);
vi = SDL_GetVideoInfo();
if(vi->hw_available) put8(bp, 1);
else put8(bp, 0);
if(vi->wm_available) put8(bp, 1);
else put8(bp, 0);
if(vi->blit_hw) put8(bp, 1);
else put8(bp, 0);
if(vi->blit_hw_CC) put8(bp, 1);
else put8(bp, 0);
if(vi->blit_hw_A) put8(bp, 1);
else put8(bp, 0);
if(vi->blit_sw) put8(bp, 1);
else put8(bp, 0);
if(vi->blit_sw_CC) put8(bp, 1);
else put8(bp, 0);
if(vi->blit_sw_A) put8(bp, 1);
else put8(bp, 0);
if(vi->blit_fill) put8(bp, 1);
else put8(bp, 0);
put32be(bp, vi->video_mem);
PUSHGLPTR(vi->vfmt, bp);
sendlen = bp - start;
sdl_send(sd, sendlen);
}
void es_videoModeOK(sdl_data *sd, int len, char *buff)
{
char *bp, *start;
int w, h, bpp, type;
int sendlen;
int res;
bp = buff;
w = get16be(bp);
h = get16be(bp);
bpp = get16be(bp);
type = get32be(bp);
res = SDL_VideoModeOK(w,h,bpp,type);
bp = start = sdl_get_temp_buff(sd, 1);
put8(bp, res);
sendlen = bp - start;
sdl_send(sd, sendlen);
}
void es_listModes(sdl_data *sd, int len, char *buff)
{
char *bp, *start;
int sendlen, i;
Uint32 flags;
SDL_PixelFormat *pfp, pf;
SDL_Rect ** res;
bp = buff;
flags = get32be(bp);
switch(get8(bp)) {
case 0:
POPGLPTR(pfp, bp);
break;
case 1:
POPGLPTR(pf.palette, bp);
pf.BitsPerPixel = get8(bp);
pf.BytesPerPixel = get8(bp);
pf.Rloss = get8(bp);
pf.Gloss = get8(bp);
pf.Bloss = get8(bp);
pf.Aloss = get8(bp);
pf.Rshift = get8(bp);
pf.Gshift = get8(bp);
pf.Bshift = get8(bp);
pf.Ashift = get8(bp);
pf.Rmask = get32be(bp);
pf.Gmask = get32be(bp);
pf.Bmask = get32be(bp);
pf.Amask = get32be(bp);
pf.colorkey= get32be(bp);
pf.alpha= get8(bp);
pfp = &pf;
default:
error();
}
bp = start = sdl_get_temp_buff(sd, 128*2*4+1);
res = SDL_ListModes(pfp, flags);
switch((long)res) {
case 0: /* NULL */
put8(bp, 0);
break;
case -1:
put8(bp,-1);
break;
default:
put8(bp,0); /* Wasted byte :- )*/
for(i=0; res[i]; i++) {
put16be(bp, res[i]->x);
put16be(bp, res[i]->y);
put16be(bp, res[i]->w);
put16be(bp, res[i]->h);
}
}
sendlen = bp - start;
sdl_send(sd, sendlen);
}
void es_flip(sdl_data *sd, int len, char *buff)
{
char *bp, *start;
int sendlen, res;
SDL_Surface *ref;
bp = buff;
POPGLPTR(ref, bp);
res = SDL_Flip(ref);
start = bp = sdl_get_temp_buff(sd, 1);
put8(bp, res);
sendlen = bp - start;
sdl_send(sd, sendlen);
}
void es_setColors(sdl_data *sd, int len, char *buff)
{
char *bp, *start;
int sendlen, res = 1, first, length, i, tot =0;
SDL_Surface *ref;
SDL_Color colors[256];
bp = buff;
POPGLPTR(ref, bp);
first = get32be(bp);
length = get32be(bp);
do {
for(i = 0; i < length && i < 256; i++) {
colors[i].r = get8(bp);
colors[i].b = get8(bp);
colors[i].g = get8(bp);
};
res &= SDL_SetColors(ref, colors, first, i);
tot += i;
first += i;
} while(tot < length);
start = bp = sdl_get_temp_buff(sd, 1);
put8(bp, res);
sendlen = bp - start;
sdl_send(sd, sendlen);
}
void es_mapRGB(sdl_data *sd, int len, char *buff)
{
char *bp, *start;
int sendlen;
SDL_Surface * sptr;
Uint32 res;
Uint8 r,g,b;
bp = buff;
POPGLPTR(sptr, bp);
r = get8(bp);
g = get8(bp);
b = get8(bp);
if(sptr == NULL || sptr->format == NULL)
error();
res = SDL_MapRGB(sptr->format, r,g,b);
bp = start = sdl_get_temp_buff(sd, 4);
put32be(bp, res);
sendlen = bp - start;
sdl_send(sd, sendlen);
}
void es_getRGB(sdl_data *sd, int len, char *buff)
{
error();
}
void es_blitSurface(sdl_data *sd, int len, char * buff)
{
char *bp, *start;
int sendlen;
char type, res;
SDL_Surface *sptr, *dptr;
SDL_Rect s, d, *src, *dest;
bp = buff;
POPGLPTR(sptr, bp);
POPGLPTR(dptr, bp);
src = &s;
dest = &d;
switch get8(bp) {
case 0:
src = NULL;
dest= NULL;
type = 0;
break;
case 1:
src->x = get16be(bp);
src->y = get16be(bp);
src->w = get16be(bp);
src->h = get16be(bp);
dest = NULL;
type = 1;
break;
case 2:
dest->x = get16be(bp);
dest->y = get16be(bp);
dest->w = get16be(bp);
dest->h = get16be(bp);
src = NULL;
type = 2;
break;
case 3:
src->x = get16be(bp);
src->y = get16be(bp);
src->w = get16be(bp);
src->h = get16be(bp);
dest->x = get16be(bp);
dest->y = get16be(bp);
dest->w = get16be(bp);
dest->h = get16be(bp);
type = 3;
break;
default:
error();
};
res = SDL_BlitSurface(sptr, src, dptr, dest);
bp = start = sdl_get_temp_buff(sd, 9*2);
put8(bp, res);
put8(bp, type);
switch(type) {
case 0:
break;
case 1:
put16be(bp, src->x);
put16be(bp, src->y);
put16be(bp, src->w);
put16be(bp, src->h);
break;
case 2:
put16be(bp, dest->x);
put16be(bp, dest->y);
put16be(bp, dest->w);
put16be(bp, dest->h);
break;
case 3:
put16be(bp, src->x);
put16be(bp, src->y);
put16be(bp, src->w);
put16be(bp, src->h);
put16be(bp, dest->x);
put16be(bp, dest->y);
put16be(bp, dest->w);
put16be(bp, dest->h);
break;
default:
error();
};
sendlen = bp - start;
sdl_send(sd, sendlen);
}
void print_rect(SDL_Rect * r)
{
if(r)
fprintf(stderr, "x %d y %d w %d h %d \n\r",
r->x, r->y, r->w, r->h);
else
fprintf(stderr, "Rect is null\n\r");
}
void es_fillRect(sdl_data *sd, int len, char * buff)
{
char *bp, *start;
int sendlen;
char res;
SDL_Surface *sptr;
SDL_Rect s, *src;
Uint32 color;
src = &s;
bp = buff;
POPGLPTR(sptr, bp);
color = get32be(bp);
if(get8(bp) == 0) {
src = NULL;
} else {
src->x = get16be(bp);
src->y = get16be(bp);
src->w = get16be(bp);
src->h = get16be(bp);
}
res = SDL_FillRect(sptr, src, color);
bp = start = sdl_get_temp_buff(sd, 1);
put8(bp, res);
sendlen = bp - start;
sdl_send(sd, sendlen);
}
void es_updateRects(sdl_data *sd, int len, char * buff)
{
char *bp;
int length, i, all;
SDL_Surface *sptr;
SDL_Rect s[64], *sr;
bp = buff;
POPGLPTR(sptr, bp);
length = get16be(bp);
all = 0;
while(all < length) {
sr = s;
for(i = 0; i < 64 && all < length; i++, all++) {
sr->x = get16be(bp);
sr->y = get16be(bp);
sr->w = get16be(bp);
sr->h = get16be(bp);
sr++;
}
SDL_UpdateRects(sptr, i, s);
}
}
void es_setColorKey(sdl_data *sd, int len, char * buff)
{
char *bp, *start;
int sendlen;
SDL_Surface * sptr;
Uint32 flag, key;
int res;
bp = buff;
POPGLPTR(sptr, bp);
if(sptr == NULL)
error();
flag = get32be(bp);
key = get32be(bp);
res = SDL_SetColorKey(sptr, flag, key);
bp = start = sdl_get_temp_buff(sd, 1);
put8(bp, res);
sendlen = bp - start;
sdl_send(sd, sendlen);
}
void es_displayFormat(sdl_data *sd, int len, char * buff)
{
char *bp, *start;
int sendlen;
SDL_Surface * sptr, *new;
bp = buff;
POPGLPTR(sptr, bp);
if(sptr == NULL)
error();
new = SDL_DisplayFormat(sptr);
bp = start = sdl_get_temp_buff(sd, 8);
PUSHGLPTR(new, bp);
sendlen = bp - start;
sdl_send(sd, sendlen);
}
void es_createRGBSurface(sdl_data *sd, int len, char *buff){
char *bp, *start;
int sendlen;
SDL_Surface * sptr;
int width, height, depth, def;
Uint32 flags, rmask, gmask, bmask, amask;
bp = buff;
flags = get32be(bp);
width = get16be(bp);
height = get16be(bp);
depth = get8(bp);
def = get8(bp);
if (def==1)
{
rmask = get32be(bp);
gmask = get32be(bp);
bmask = get32be(bp);
amask = get16be(bp);
}
else
{
#if SDL_BYTEORDER == SDL_LIL_ENDIAN /* OpenGL RGBA masks */
rmask = 0x000000FF;
gmask = 0x0000FF00;
bmask = 0x00FF0000;
amask = 0xFF000000;
#else
rmask = 0xFF000000;
gmask = 0x00FF0000;
bmask = 0x0000FF00;
amask = 0x000000FF;
#endif
};
sptr = SDL_CreateRGBSurface(flags, width, height, depth,
rmask, gmask, bmask, amask);
bp = start = sdl_get_temp_buff(sd, 8);
PUSHGLPTR(sptr, bp);
sendlen = bp - start;
sdl_send(sd, sendlen);
}
void es_createRGBSurfaceFrom(sdl_data *sd, int len, char *buff){
char *bp, *start;
int sendlen;
SDL_Surface * sptr;
void * pixels;
int width, height, depth, pitch, size;
Uint32 rmask, gmask, bmask, amask;
bp = buff;
width = get16be(bp);
height = get16be(bp);
depth = get8(bp);
pitch = get16be(bp);
rmask = get32be(bp);
gmask = get32be(bp);
bmask = get32be(bp);
amask = get16be(bp);
size = get32be(bp);
if(size == -1)
{
POPGLPTR(pixels, bp);
}
else {
/* Get Pixels */
if((pixels = malloc(size)) == NULL){
bp = start = sdl_get_temp_buff(sd, 8);
sptr = NULL;
PUSHGLPTR(sptr, bp);
sendlen = bp - start;
sdl_send(sd, sendlen);
return;
}
memcpy(pixels, (void *) bp, size);
};
sptr = SDL_CreateRGBSurfaceFrom(pixels, width, height, depth, pitch,
rmask, gmask, bmask, amask);
bp = start = sdl_get_temp_buff(sd, 8);
PUSHGLPTR(sptr, bp);
sendlen = bp - start;
sdl_send(sd, sendlen);
}
void es_freeSurface(sdl_data *sd, int len, char * buff)
{
char *bp;
SDL_Surface * sptr;
bp = buff;
POPGLPTR(sptr, bp);
if(sptr == NULL)
error();
SDL_FreeSurface(sptr);
}
void es_lockSurface(sdl_data *sd, int len, char * buff)
{
char *bp, *start;
SDL_Surface * sptr;
int sendlen, res;
bp = buff;
POPGLPTR(sptr, bp);
if(sptr == NULL)
error();
res = SDL_LockSurface(sptr);
bp = start = sdl_get_temp_buff(sd, 1);
put8(bp, res);
sendlen = bp - start;
sdl_send(sd, sendlen);
}
void es_unlockSurface(sdl_data *sd, int len, char * buff)
{
char *bp;
SDL_Surface * sptr;
bp = buff;
POPGLPTR(sptr, bp);
SDL_UnlockSurface(sptr);
}
void es_loadBMP(sdl_data *sd, int len, char* bp)
{
char *start;
SDL_Surface *bmpSurface;
int sendlen;
bmpSurface = SDL_LoadBMP(bp);
bp = start = sdl_get_temp_buff(sd, 8);
PUSHGLPTR(bmpSurface, bp);
sendlen = bp - start;
sdl_send(sd, sendlen);
}
void es_saveBMP(sdl_data *sd, int len, char* bp)
{
char *start;
SDL_Surface *sptr;
int sendlen, res;
POPGLPTR(sptr, bp);
res = SDL_SaveBMP(sptr, bp);
bp = start = sdl_get_temp_buff(sd, 1);
put8(bp, res);
sendlen = bp - start;
sdl_send(sd, sendlen);
}
void es_setAlpha(sdl_data *sd, int len, char *buff)
{
char *bp, *start;
SDL_Surface *sptr;
int sendlen, res;
Uint32 flag, alpha;
bp = buff;
POPGLPTR(sptr, bp);
flag = get32be(bp);
alpha = get32be(bp);
res = SDL_SetAlpha(sptr, flag, alpha);
bp = start = sdl_get_temp_buff(sd, 4);
put32be(bp, res);
sendlen = bp - start;
sdl_send(sd, sendlen);
}
void es_setClipping(sdl_data *sd, int len, char *buff)
{
error();
}
void es_setGamma(sdl_data *sd, int len, char *bp)
{
char *start;
int sendlen, res;
float red, green, blue;
red = * (float *) bp; bp += sizeof(float);
green = * (float *) bp; bp += sizeof(float);
blue = * (float *) bp; bp += sizeof(float);
res = SDL_SetGamma(red, green, blue);
bp = start = sdl_get_temp_buff(sd, 4);
* (float *) bp = res;
sendlen = bp - start;
sdl_send(sd, sendlen);
}
void es_setGammaRamp(sdl_data *sd, int len, char * buff)
{
char *bp, *start;
int sendlen, res;
Uint16 *red,*green,*blue;
bp = buff;
red = (Uint16 *) bp; bp += 256*sizeof(Uint16);
green = (Uint16 *) bp; bp += 256*sizeof(Uint16);
blue = (Uint16 *) bp; bp += 256*sizeof(Uint16);
res = SDL_SetGammaRamp(red,green,blue);
bp = start = sdl_get_temp_buff(sd, 4);
put32be(bp, res);
sendlen = bp - start;
sdl_send(sd, sendlen);
}
void es_getGammaRamp(sdl_data *sd, int len, char * buff)
{
char *bp, *start;
int sendlen, res, i;
Uint16 red[256], green[256],blue[256];
res = SDL_GetGammaRamp(red,green,blue);
bp = start = sdl_getbuff(sd, 4 + 256*2*3);
put32be(bp, res);
for(i=0; i<256; i++) {
put16be(bp, red[i]);
}
for(i=0; i<256; i++) {
put16be(bp, green[i]);
}
for(i=0; i<256; i++) {
put16be(bp, blue[i]);
}
sendlen = bp - start;
sdl_send(sd, sendlen);
}
void es_wm_setCaption(sdl_data *sd, int len, char *bp)
{
char* title;
char* icon;
title = bp;
icon = title + strlen(title) + 1;
SDL_WM_SetCaption(title, icon);
}
void es_wm_getCaption(sdl_data *sd, int len, char *buff)
{
char * title, *icon, *bp, *start;
int i, titlelen, iconlen, sendlen;
SDL_WM_GetCaption(&title, &icon);
for(titlelen = 0; title[titlelen] != '\0'; titlelen++);
for(iconlen = 0; icon[iconlen] != '\0'; iconlen++);
bp = start = sdl_get_temp_buff(sd, 4+titlelen+iconlen);
put16be(bp, titlelen);
put16be(bp, iconlen);
for(i = 0; i < titlelen; i++)
put8(bp, title[i]);
for(i = 0; i < iconlen; i++)
put8(bp, icon[i]);
sendlen = bp - start;
sdl_send(sd, sendlen);
}
void es_wm_setIcon(sdl_data *sd, int len, char *buff)
{
char *bp;
SDL_Surface *sptr;
Uint8 mask[64*64];
Uint16 size;
int i;
bp = buff;
POPGLPTR(sptr, bp);
size = get16be(bp);
if(size > 0 && size < 64*64) {
for(i=0; i < size; i++)
mask[i] = get8(bp);
SDL_WM_SetIcon(sptr, mask);
} else {
SDL_WM_SetIcon(sptr, NULL);
}
}
void es_wm_iconifyWindow(sdl_data *sd, int len, char *buff)
{
SDL_WM_IconifyWindow();
}
void es_wm_toggleFullScreen(sdl_data *sd, int len, char *buff)
{
char *bp, *start;
SDL_Surface *sptr;
int res, sendlen;
bp = buff;
POPGLPTR(sptr, bp);
res = SDL_WM_ToggleFullScreen(sptr);
bp = start = sdl_get_temp_buff(sd, 1);
put8(bp, res);
sendlen = bp - start;
sdl_send(sd, sendlen);
}
void es_wm_grabInput(sdl_data *sd, int len, char *bp)
{
char *start;
SDL_GrabMode mode;
int sendlen;
mode = (SDL_GrabMode) *bp;
mode = SDL_WM_GrabInput(mode);
bp = start = sdl_get_temp_buff(sd, 1);
*bp++ = mode;
sendlen = bp - start;
sdl_send(sd, sendlen);
}
void es_wm_getInfo(sdl_data *sd, int len, char *buff)
{
char *bp, *start;
SDL_SysWMinfo info;
int sendlen;
bp = buff;
SDL_VERSION(&info.version);
SDL_GetWMInfo(&info);
bp = start = sdl_get_temp_buff(sd, 7);
/* fprintf(stderr, "es_wm_getInfo %d %d %d %d %d \r\n", */
/* (unsigned int *) &info, (unsigned int*) &info.version, */
/* info.version.major, */
/* info.version.minor, */
/* info.version.patch); */
put8(bp, info.version.major);
put8(bp, info.version.minor);
put8(bp, info.version.patch);
#ifdef WIN32
if(sizeof(info.window) == 4)
put32be(bp, (unsigned int) info.window);
else
put32be(bp, 0);
#else
put32be(bp, 0);
#endif
sendlen = bp - start;
sdl_send(sd, sendlen);
}
void es_wm_isMaximized(sdl_data *sd, int len, char *buff)
{
int sendlen;
char *bp, *start;
int s;
#ifdef _WIN32
{
SDL_SysWMinfo info;
SDL_VERSION(&info.version);
SDL_GetWMInfo(&info);
s = IsZoomed(info.window);
}
#else
{ /* Workaround for missing functions, window manager dep functions */
/* SDL_Surface *screen; */
/* SDL_Rect **modes; */
s = 0;
/* screen = SDL_GetVideoSurface(); */
/* Get available fullscreen modes, I think it gives the max resolution */
/* modes = SDL_ListModes(screen->format, screen->flags | SDL_FULLSCREEN); */
/* Check is there are any modes available */
/* if(modes == (SDL_Rect **)0 || modes == (SDL_Rect **)-1) { */
/* s = 0; */ /* We don't know ?? */
/* } */
/* else { */
/* if ( screen->w >= modes[0]->w && screen->h >= modes[0]->h) */
/* s = 1; */
/* else */
/* s = 0; */
/* } */
}
#endif
start = bp = sdl_get_temp_buff(sd, 1);
put8(bp, s);
sendlen = bp - start;
sdl_send(sd, sendlen);
}
void es_gl_setAttribute(sdl_data *sd, int len, char *buff)
{
char *bp;
int attr, val;
bp = buff;
attr = get16be(bp);
val = get32be(bp);
SDL_GL_SetAttribute(attr, val);
}
void es_gl_getAttribute(sdl_data *sd, int len, char *buff)
{
char *bp, *start;
int attr, val, sendlen;
bp = buff;
attr = get16be(bp);
SDL_GL_GetAttribute(attr, &val);
bp = start = sdl_get_temp_buff(sd, 4);
put32be(bp, val);
sendlen = bp - start;
sdl_send(sd, sendlen);
}
void es_gl_swapBuffers(sdl_data *sd, int len, char *buff)
{
char *bp, *start;
int sendlen;
Uint32 ts;
SDL_GL_SwapBuffers();
bp = start = sdl_get_temp_buff(sd, 4);
ts = SDL_GetTicks();
put32be(bp, ts);
sendlen = bp - start;
sdl_send(sd, sendlen);
}
void es_mapRGBA(sdl_data *sd, int len, char *buff)
{
char *bp, *start;
int sendlen;
SDL_Surface * sptr;
Uint32 res;
Uint8 r,g,b,a;
bp = buff;
POPGLPTR(sptr, bp);
r = get8(bp);
g = get8(bp);
b = get8(bp);
a = get8(bp);
if(sptr == NULL || sptr->format == NULL)
error();
res = SDL_MapRGBA(sptr->format, r,g,b,a);
bp = start = sdl_get_temp_buff(sd, 4);
put32be(bp, res);
sendlen = bp - start;
sdl_send(sd, sendlen);
}
void es_getRGBA(sdl_data *sd, int len, char *buff)
{
error();
}
void es_getClipRect(sdl_data *sd, int len, char *buff)
{
char *bp, *start;
int sendlen;
SDL_Surface * sptr;
SDL_Rect rect;
bp = buff;
POPGLPTR(sptr, bp);
if(sptr == NULL)
error();
SDL_GetClipRect(sptr, &rect);
bp = start = sdl_get_temp_buff(sd, 8);
put16be(bp, rect.x);
put16be(bp, rect.y);
put16be(bp, rect.w);
put16be(bp, rect.h);
sendlen = bp - start;
sdl_send(sd, sendlen);
}
void es_setClipRect(sdl_data *sd, int len, char *buff)
{
char *bp;
SDL_Surface * sptr;
SDL_Rect rect;
bp = buff;
POPGLPTR(sptr, bp);
rect.x = get16be(bp);
rect.y = get16be(bp);
rect.w = get16be(bp);
rect.h = get16be(bp);
if(sptr == NULL)
error();
SDL_SetClipRect(sptr, &rect);
}
void es_displayFormatAlpha(sdl_data *sd, int len, char * buff)
{
char *bp, *start;
int sendlen;
SDL_Surface * sptr, *new;
bp = buff;
POPGLPTR(sptr, bp);
if(sptr == NULL)
error();
new = SDL_DisplayFormatAlpha(sptr);
bp = start = sdl_get_temp_buff(sd, 8);
PUSHGLPTR(new, bp);
sendlen = bp - start;
sdl_send(sd, sendlen);
}
syntax highlighted by Code2HTML, v. 0.9.1