void CObjectGroup::Draw()
{
GR_IMAGE_INFO img_info;
RECT rcOptionText;
if(m_wid && m_gc && m_Image)
{
if(m_isOption)
{
GrGetImageInfo(m_Image[m_idxImage], &img_info);
GrDrawImageToFit(m_wid, m_gc, m_rect.x, m_rect.y, img_info.width, img_info.height, m_Image[m_idxImage]);
if(m_pszText)
{
memcpy(&rcOptionText, &m_rect, sizeof(RECT));
rcOptionText.x += (img_info.width + 10);
DrawTextRect(m_pszText, m_wid, m_gc, &rcOptionText, m_text_font, m_text_size, m_text_color, m_text_align);
}
}
else
{
GrDrawImageToFit(m_wid, m_gc, m_rect.x, m_rect.y, m_rect.w, m_rect.h, m_Image[m_idxImage]);
if(m_pszText)
{
DrawTextRect(m_pszText, m_wid, m_gc, &m_rect, m_text_font, m_text_size, m_text_color, m_text_align);
}
}
}
}
void CObjectCheck::Draw()
{
if(m_wid && m_gc && m_Image)
{
GrDrawImageToFit(m_wid, m_gc, m_rect.x, m_rect.y, m_rect.w, m_rect.h, m_Image[m_idxImage]);
}
}
static void
GrDrawImageToFitWrapper(void *r)
{
nxDrawImageToFitReq *req = r;
GrDrawImageToFit(req->drawid, req->gcid, req->x, req->y, req->width,
req->height, req->imageid);
}
//------------------------------------------------------------------------------
// Function Name : ui_draw_icon_image()
// Description :
//------------------------------------------------------------------------------
void ui_draw_icon_image(obj_icon_t *_obj_h, int _idx)
{
if (_obj_h == NULL)
return;
GrDrawImageToFit(_obj_h->wid, _obj_h->gc,
_obj_h->rect.x, _obj_h->rect.y, _obj_h->rect.w, _obj_h->rect.h,
_obj_h->imgs[_idx]);
}
//------------------------------------------------------------------------------
// Function Name : ui_draw_image()
// Description :
//------------------------------------------------------------------------------
void ui_draw_image(obj_img_t *_obj_h)
{
if (_obj_h == NULL)
return;
GrDrawImageToFit(_obj_h->wid, _obj_h->gc,
_obj_h->rect.x, _obj_h->rect.y, _obj_h->rect.w, _obj_h->rect.h,
_obj_h->img);
}
void CObjectButton::Draw()
{
// printf("+%s\r\n", __func__);
if(m_wid && m_gc && m_Image)
{
GrSetGCUseBackground(m_gc, FALSE);
GrDrawImageToFit(m_wid, m_gc, m_rect.x, m_rect.y, m_rect.w, m_rect.h, m_Image[m_idxImage]);
}
// printf("-%s\r\n", __func__);
}
void draw_item(lstate *state, litem *item)
{
GR_SIZE width, height, base, x, len;
GrDrawImageToFit(item->wid, state->gc, ICON_X_POSITION, ICON_Y_POSITION,
ICON_WIDTH, ICON_HEIGHT, item->iconid);
len = strlen(item->name);
GrGetGCTextSize(state->gc, item->name, len, 0, &width, &height, &base);
if(width >= ITEM_WIDTH) x = 0;
else x = (ITEM_WIDTH - width) / 2;
GrText(item->wid, state->gc, x, TEXT_Y_POSITION, item->name, len, 0);
}
void CObjectPlatButton::Draw()
{
if(m_wid && m_gc)
{
if(m_Image)
{
GrDrawImageToFit(m_wid, m_gc, m_rect.x, m_rect.y, m_rect.w, m_rect.h, m_Image);
}
if(m_pszText && m_font)
{
DrawTextRect(m_pszText, m_wid, m_gc, &m_rect, m_font, m_size, m_color, TXT_HALIGN_CENTER|TXT_VALIGN_MIDDLE);
}
}
}
static void mappaint(){
int x=0;
int i=0;
int p=0;
GrSetGCForeground(keyman_gc, BLACK);
kmimage_id=GrLoadImageFromFile(pathimage,0);
yomipict_pixmap=GrNewPixmap(384,128,NULL);
allmap_pixmap=GrNewPixmap(160,(TATEHABA*16),NULL);
GrDrawImageToFit(yomipict_pixmap,keyman_gc,0,0,384,128,kmimage_id);
for (i=0;i<=(TATEHABA-1);i++){
for (p=0;p<=9;p++){
x=pictx(wyomidata.mapd[p][i]);
GrCopyArea(allmap_pixmap,keyman_gc,(p*16),(i*16),16,16,yomipict_pixmap,x,0,0);
}
}
}
/**
* Load image from filename and return its ID
*/
GR_WINDOW_ID theme_load_image(char * filename)
{
GR_GC_ID gc;
GR_IMAGE_ID iid;
GR_WINDOW_ID pid;
GR_IMAGE_INFO iif;
gc = GrNewGC();
if(!(iid = GrLoadImageFromFile(filename, 0))) {
fprintf(stderr, "Failed to load image file \"%s\"\n", filename);
return 0;
}
GrGetImageInfo(iid, &iif);
pid = GrNewPixmap(iif.width, iif.height, NULL);
GrDrawImageToFit(pid, gc, 0, 0, iif.width, iif.height, iid);
GrDestroyGC(gc);
GrFreeImage(iid);
return pid;
}
void new_keyman_window( void )
{
keyman_gc = GrNewGC();
GrSetGCUseBackground(keyman_gc, GR_FALSE);
GrSetGCForeground(keyman_gc, WHITE);
GrGetScreenInfo(&screen_info);
yomipict_pixmap=GrNewPixmap(384,128,NULL);
mainmenu_pixmap=GrNewPixmap(160,128,NULL);
shu_pixmap=GrNewPixmap(16,16,NULL);
dialogall_pixmap=GrNewPixmap(96,80,NULL);
dialog_pixmap=GrNewPixmap(96,80,NULL);
keyman_wid = pz_new_window(0, 0,
screen_info.cols, screen_info.rows,
keyman_do_draw, keyman_handle_event);
if (!(kmimage_id=GrLoadImageFromFile(pathimage,0))){
GAMEN=NODATA;
}
else {
GAMEN=MENU;
GrDrawImageToFit(yomipict_pixmap,keyman_gc,0,0,384,128,kmimage_id);
makedialog();
}
GrSelectEvents( keyman_wid, GR_EVENT_MASK_TIMER|
GR_EVENT_MASK_EXPOSURE|GR_EVENT_MASK_KEY_UP|GR_EVENT_MASK_KEY_DOWN);
keyman_timer = GrCreateTimer( keyman_wid, 90 );
GrMapWindow( keyman_wid );
pz_draw_header( "KeyMan" );
}
/* ***********************************************************/
void print_board(void)
{
int row,column,i,x,y;
/* draw background border only*/
GrSetGCForeground(gc, WHITE);
GrLine(board, gc, 0, 0, board_w, 0); /* top*/
GrLine(board, gc, 0, board_h-1, board_w, board_h-1); /* bottom*/
GrLine(board, gc, 0, 0, 0, board_h-1); /* left*/
GrLine(board, gc, board_w, 0, board_w, board_h-1); /* right*/
GrDrawImageToFit(board, gc, 1, 0, board_w, board_h, board_image_id);
for (row=0;row<8;row++)
{
for (column=0;column<8;column++)
{
i = keyrows[row].columns[column].scancode;
switch(color[i])
{
case LIGHT:
switch(piece_char[piece[i]])
{
case 'P':
x = keyrows[row].columns[column].xoffset;
y = keyrows[row].yoffset;
GrDrawImageToFit(board, gc, x+10, y+13, w_p_w, w_p_h, w_p_image_id);
break;
case 'N':
x = keyrows[row].columns[column].xoffset;
y = keyrows[row].yoffset;
GrDrawImageToFit(board, gc, x+9, y+9, w_n_w, w_n_h, w_n_image_id);
break;
case 'B':
x = keyrows[row].columns[column].xoffset;
y = keyrows[row].yoffset;
GrDrawImageToFit(board, gc, x+9, y+9, w_b_w, w_b_h, w_b_image_id);
break;
case 'R':
x = keyrows[row].columns[column].xoffset;
y = keyrows[row].yoffset;
GrDrawImageToFit(board, gc, x+9, y+12, w_r_w, w_r_h, w_r_image_id);
break;
case 'Q':
x = keyrows[row].columns[column].xoffset;
y = keyrows[row].yoffset;
GrDrawImageToFit(board, gc, x+8, y+8, w_q_w, w_q_h, w_q_image_id);
break;
case 'K':
x = keyrows[row].columns[column].xoffset;
y = keyrows[row].yoffset;
GrDrawImageToFit(board, gc, x+8, y+5, w_k_w, w_k_h, w_k_image_id);
break;
}
break;
case DARK:
switch(piece_char[piece[i]])
{
case 'P':
x = keyrows[row].columns[column].xoffset;
y = keyrows[row].yoffset;
GrDrawImageToFit(board, gc, x+10, y+13, b_p_w, b_p_h, b_p_image_id);
break;
case 'N':
x = keyrows[row].columns[column].xoffset;
y = keyrows[row].yoffset;
GrDrawImageToFit(board, gc, x+9, y+9, b_n_w, b_n_h, b_n_image_id);
break;
case 'B':
x = keyrows[row].columns[column].xoffset;
y = keyrows[row].yoffset;
GrDrawImageToFit(board, gc, x+9, y+9, b_b_w, b_b_h, b_b_image_id);
break;
case 'R':
x = keyrows[row].columns[column].xoffset;
y = keyrows[row].yoffset;
GrDrawImageToFit(board, gc, x+9, y+12, b_r_w, b_r_h, b_r_image_id);
break;
case 'Q':
x = keyrows[row].columns[column].xoffset;
y = keyrows[row].yoffset;
GrDrawImageToFit(board, gc, x+8, y+8, b_q_w, b_q_h, b_q_image_id);
break;
case 'K':
x = keyrows[row].columns[column].xoffset;
y = keyrows[row].yoffset;
GrDrawImageToFit(board, gc, x+8, y+5, b_k_w, b_k_h, b_k_image_id);
break;
}
break;
} /* switch */
} /* for col */
} /* for row */
}
void
show_jpeg(int client, char *file, int show_time)
{
GR_EVENT event; /* current event */
GR_IMAGE_ID id = 0;
GR_SIZE w = -1;
GR_SIZE h = -1;
GR_IMAGE_INFO info;
GR_WINDOW_ID w1; /* id for large window */
GR_GC_ID gc1; /* graphics context for text */
GR_SCREEN_INFO si;
int time_left;
bool ever_exposed = false;
#if !defined(HAVE_JPEG_SUPPORT) && !defined(HAVE_BMP_SUPPORT) && !defined(HAVE_GIF_SUPPORT)
printf("Sorry, no image support compiled in\n");
exit(1);
#endif
GrGetScreenInfo(&si);
printf("Loading image: %s\n", file);
if (access(file, F_OK) < 0) {
fdprintf(client, "Can't access \"%s\": %s\n", file, strerror(errno));
return;
}
id = GrLoadImageFromFile(file, 0);
if (id) {
GrGetImageInfo(id, &info);
} else {
// File exists, so why the error?
int fd, len;
char buf[64];
fdprintf(client, "Can't load %s\n", file);
if ((fd = open(file, O_RDONLY)) >= 0) {
len = read(fd, buf, 64);
if (len != 64) {
diag_printf("Short read? len = %d\n", len);
} else {
diag_dump_buf(buf, len);
}
close(fd);
} else {
diag_printf("Can't oopen \"%s\": %s\n", file, strerror(errno));
}
return;
}
w = info.width;
h = info.height;
if ((si.rows < info.height) || (si.cols < info.width)) {
// Preserve aspect ratio
if (si.cols < info.width) {
w = si.cols;
h = (si.cols * info.height) / info.width;
}
if (si.rows < h) {
w = (si.rows * w) / h;
h = si.rows;
}
}
printf("Create window - orig %dx%d => %dx%d\n", info.width, info.height, w, h);
fdprintf(client, "<INFO> Display \"%s\" - orig %dx%d => %dx%d\n", file, info.width, info.height, w, h);
w1 = GrNewWindow(GR_ROOT_WINDOW_ID, 10, 10, w, h, 4, BLACK, WHITE);
GrSelectEvents(w1, GR_EVENT_MASK_CLOSE_REQ|GR_EVENT_MASK_EXPOSURE);
GrMapWindow(w1);
gc1 = GrNewGC();
GrSetGCForeground(gc1, WHITE);
#define TO_MS 50
time_left = show_time * 1000;
while (time_left > 0) {
GrGetNextEventTimeout(&event, TO_MS); // milliseconds
switch(event.type) {
case GR_EVENT_TYPE_CLOSE_REQ:
GrDestroyWindow(w1);
GrFreeImage(id);
return;
/* no return*/
case GR_EVENT_TYPE_EXPOSURE:
/*GrDrawImageFromFile(w1, gc1, 0, 0, w, h, argv[1],0);*/
GrDrawImageToFit(w1, gc1, 0, 0, w, h, id);
ever_exposed = true;
break;
default:
case GR_EVENT_TYPE_NONE:
case GR_EVENT_TYPE_TIMEOUT:
time_left -= TO_MS;
if ((time_left < 0) && !ever_exposed) {
// Things get real cranky if we delete the window too fast!
time_left = TO_MS;
}
break;
}
}
GrUnmapWindow(w1);
GrDestroyWindow(w1);
GrDestroyGC(gc1);
GrFreeImage(id);
}
void initialise(lstate *state)
{
GR_SCREEN_INFO si;
GR_IMAGE_ID back_image;
GR_IMAGE_INFO imageinfo;
int rows = 1, columns = 1, width, height, x = 0, y = 0;
GR_WM_PROPERTIES props;
litem *i;
if(GrOpen() < 0) {
GrError("Couldn't connect to Nano-X server\n");
exit(4);
}
state->window_background_mode = 0;
state->window_background_image = NULL;
sspid = -1;
read_config(state);
GrGetScreenInfo(&si);
if(si.rows > si.cols) {
rows = state->numlitems;
while((((rows / columns) + rows % columns) * ITEM_HEIGHT) >
si.rows) {
columns++;
}
if((columns * ITEM_WIDTH) > si.cols) goto toomany;
rows = (rows / columns) + (rows % columns);
width = columns * ITEM_WIDTH + 1 + columns;
height = rows * ITEM_HEIGHT + 1 + rows;
} else {
columns = state->numlitems;
while((((columns / rows) + (columns % rows)) * ITEM_WIDTH) >
si.cols) {
rows++;
}
if((rows * ITEM_HEIGHT) > si.rows) goto toomany;
columns = (columns / rows) + (columns % rows);
width = columns * ITEM_WIDTH + 1 + columns;
height = (rows * ITEM_HEIGHT) + 1 + rows;
y = si.rows - (rows * ITEM_HEIGHT) - 1 - rows;
}
state->gc = GrNewGC();
GrSetGCForeground(state->gc, ITEM_TEXT_COLOUR);
GrSetGCBackground(state->gc, ITEM_BACKGROUND_COLOUR);
if(state->window_background_image) {
if(!(back_image = GrLoadImageFromFile(
state->window_background_image, 0))) {
GrError("Couldn't load background image\n");
} else {
GrGetImageInfo(back_image, &imageinfo);
if(!(state->background_pixmap = GrNewPixmap(
imageinfo.width,
imageinfo.height, NULL))) {
GrError("Couldn't allocate pixmap "
"for background image\n");
} else {
GrDrawImageToFit(state->background_pixmap,
state->gc, 0, 0, imageinfo.width,
imageinfo.height, back_image);
GrFreeImage(back_image);
GrSetBackgroundPixmap(GR_ROOT_WINDOW_ID,
state->background_pixmap,
state->window_background_mode);
GrClearWindow(GR_ROOT_WINDOW_ID, GR_TRUE);
}
}
}
if(state->ssitems)
GrSelectEvents(GR_ROOT_WINDOW_ID, GR_EVENT_MASK_SCREENSAVER);
state->main_window = GrNewWindow(GR_ROOT_WINDOW_ID, 0, y, width, height,
0, ITEM_BACKGROUND_COLOUR, 0);
GrSelectEvents(state->main_window, GR_EVENT_MASK_CLOSE_REQ | GR_EVENT_MASK_TIMER);
props.flags = GR_WM_FLAGS_PROPS;
props.props = GR_WM_PROPS_NOMOVE | GR_WM_PROPS_NODECORATE | GR_WM_PROPS_NOAUTOMOVE | GR_WM_PROPS_NOAUTORESIZE;
GrSetWMProperties(state->main_window, &props);
i = state->lastlitem;
y = 0;
while(i) {
i->wid = GrNewWindow(state->main_window,
(x * ITEM_WIDTH) + x + 1,
(y * ITEM_HEIGHT) + y + 1, ITEM_WIDTH,
ITEM_HEIGHT, 1, ITEM_BACKGROUND_COLOUR, ITEM_BORDER_COLOUR);
GrSelectEvents(i->wid, GR_EVENT_MASK_EXPOSURE | GR_EVENT_MASK_BUTTON_DOWN);
GrMapWindow(i->wid);
i = i->prev;
if(++x == columns) {
x = 0;
y++;
}
}
GrMapWindow(state->main_window);
signal(SIGCHLD, &reaper);
do_startups(state);
return;
toomany:
GrError("Too many items to fit on screen\n");
exit(6);
}
int GrBitmapEx_Apollo_NEW(GR_WINDOW_ID id,GR_GC_ID gc,int x,int y,int width,int height,int src_x,int src_y, int src_width,int src_height, GR_CHAR *imagebits)
{
BMPHEADER_256 lpHeader;
GR_IMAGE_ID ImageId;
int HeaderLen;
int i;
int Lines;
int BmpBufBytsPerLine=0,BytesPerLine=0;
unsigned char char1,char2,char3,char4,BmpChar1;
unsigned char *Screen_Buf=NULL,*BmpFileBuf=NULL,*BufPtr=NULL,*HeaderBuf=NULL,*pimg = NULL;
int GrayLevel=8;//256 gray level
int BmpWidth=0,BmpHeight=0,PixesPerByte=0,BmpPanelNumbers=0,Bmpheadersize=0;
BmpWidth=min(width,src_width);
BmpHeight=min(height,src_height-src_y);
// BmpHeight=min(height,src_height);
if(BmpHeight<=0)
BmpHeight=1;
PixesPerByte=8/GrayLevel;
BmpPanelNumbers=1<<GrayLevel;
BytesPerLine=(BmpWidth*GrayLevel+31)/32*4;//
BmpBufBytsPerLine=(((src_width*GrayLevel+7)/8+3)/4)*4;
i=sizeof(BMPHEADER_256);
HeaderLen=BITMAPFILEHEADER_SIZE+sizeof(BITMAPINFOHEADER)+sizeof(MWPALENTRY)*BmpPanelNumbers;
memcpy((unsigned char *)&lpHeader.FileHeader.bfType,"BM",2);//
lpHeader.FileHeader.bfSize=(BmpHeight*BytesPerLine)/PixesPerByte+HeaderLen; //
lpHeader.FileHeader.bfReserved1=0;//
lpHeader.FileHeader.bfReserved2=0;//
lpHeader.FileHeader.bfOffBits=HeaderLen;//
lpHeader.BmpInfo.biSize=sizeof(BITMAPINFOHEADER);//BMP
lpHeader.BmpInfo.biWidth=BmpWidth;//
lpHeader.BmpInfo.biHeight=BmpHeight;//
lpHeader.BmpInfo.biPlanes=1;//
lpHeader.BmpInfo.biBitCount=GrayLevel;//
lpHeader.BmpInfo.biCompression=0;
lpHeader.BmpInfo.biSizeImage=lpHeader.FileHeader.bfSize-HeaderLen;
lpHeader.BmpInfo.biXPelsPerMeter=0x257E;
lpHeader.BmpInfo.biYPelsPerMeter=0x257E;
lpHeader.BmpInfo.biClrUsed=0;
lpHeader.BmpInfo.biClrImportant=0;
Bmpheadersize=HeaderLen;
BmpFileBuf=new unsigned char[BmpHeight*BytesPerLine+Bmpheadersize];
if(!BmpFileBuf)
{
return 1;
}
memset(BmpFileBuf,0xFF,BmpHeight*BytesPerLine+Bmpheadersize);
HeaderBuf=BmpFileBuf;
Screen_Buf=BmpFileBuf+Bmpheadersize;
BufPtr=Screen_Buf;
memcpy(HeaderBuf,(char *)&lpHeader.FileHeader.bfType,2);
memcpy(&HeaderBuf[2],(char *)&lpHeader.FileHeader.bfSize,4);
memcpy(&HeaderBuf[6],(char *)&lpHeader.FileHeader.bfReserved1,2);
memcpy(&HeaderBuf[8],(char *)&lpHeader.FileHeader.bfReserved2,2);
memcpy(&HeaderBuf[10],(char *)&lpHeader.FileHeader.bfOffBits,4);
HeaderBuf+=BITMAPFILEHEADER_SIZE;
memcpy(HeaderBuf,(unsigned char *)&lpHeader.BmpInfo,BITMAPINFOHEADER_SIZE);
HeaderBuf+=BITMAPINFOHEADER_SIZE;
memcpy(HeaderBuf,(unsigned char *)&panel256,sizeof(MWPALENTRY)*BmpPanelNumbers);
HeaderBuf=BmpFileBuf;
Lines=0;
BufPtr = (unsigned char *)(Screen_Buf+(BmpHeight-1)*BytesPerLine);
pimg = (unsigned char *)(imagebits + src_y*BmpBufBytsPerLine +src_x);
for(Lines=0;Lines<BmpHeight;Lines++)
{
//printf("%s line = %d,height =%d,byte = %d,buf =%d\n",__FUNCTION__,Lines,BmpHeight,BytesPerLine,BufPtr);
// BufPtr=(unsigned char *)&Screen_Buf[(BmpHeight-1-Lines)*BytesPerLine];
// memcpy(BufPtr,(unsigned char *)&imagebits[(Lines+src_y)*BmpBufBytsPerLine+src_x],BytesPerLine);
memcpy(BufPtr,pimg,BytesPerLine);
BufPtr -= BytesPerLine;
pimg += BmpBufBytsPerLine;
}
ImageId=GrLoadImageFromBuffer(BmpFileBuf,lpHeader.FileHeader.bfSize,GR_BACKGROUND_TOPLEFT);
GrDrawImageToFit(id,gc,x,y,BmpWidth,BmpHeight,ImageId);
printf("x=%d,y=%d,BmpWidth=%d,BmpHeight=%d\n",x,y,BmpWidth,BmpHeight);
GrFreeImage(ImageId);
delete(BmpFileBuf);
return 0;
}
int GrBitmapEx_Apollo_FOUR(GR_WINDOW_ID id,GR_GC_ID gc,int x,int y,int width,int height,int src_x,int src_y, int src_width,int src_height, GR_CHAR *imagebits)
{
// TODO: Add extra validation here
//4 bit 16 level degree color
BMPHEADER_256 lpHeader;
GR_IMAGE_ID ImageId;
int HeaderLen;
int i;
int Lines;
int BmpBufBytsPerLine=0,BytesPerLine=0;
unsigned char char1,char2,char3,char4,BmpChar1;
unsigned char *Screen_Buf=NULL,*BmpFileBuf=NULL,*BufPtr=NULL,*HeaderBuf=NULL;
int GrayLevel=8;//256 gray level
int BmpWidth=0,BmpHeight=0,PixesPerByte=0,BmpPanelNumbers=0,Bmpheadersize=0;
BmpWidth=min(width,src_width);
BmpHeight=min(height,src_height);
PixesPerByte=8/GrayLevel;
BmpPanelNumbers=1<<GrayLevel;
BytesPerLine=(BmpWidth*GrayLevel+31)/32*4;
BmpBufBytsPerLine=(src_width*2+7)/8;
i=sizeof(BMPHEADER_256);
HeaderLen=BITMAPFILEHEADER_SIZE+sizeof(BITMAPINFOHEADER)+sizeof(MWPALENTRY)*BmpPanelNumbers;
memcpy((unsigned char *)&lpHeader.FileHeader.bfType,"BM",2);
lpHeader.FileHeader.bfSize=(BmpHeight*BytesPerLine)/PixesPerByte+HeaderLen;
lpHeader.FileHeader.bfReserved1=0;
lpHeader.FileHeader.bfReserved2=0;
lpHeader.FileHeader.bfOffBits=HeaderLen;
lpHeader.BmpInfo.biSize=sizeof(BITMAPINFOHEADER);
lpHeader.BmpInfo.biWidth=BmpWidth;
lpHeader.BmpInfo.biHeight=BmpHeight;
lpHeader.BmpInfo.biPlanes=1;
lpHeader.BmpInfo.biBitCount=GrayLevel;
lpHeader.BmpInfo.biCompression=0;
lpHeader.BmpInfo.biSizeImage=lpHeader.FileHeader.bfSize-HeaderLen;
lpHeader.BmpInfo.biXPelsPerMeter=0x257E;
lpHeader.BmpInfo.biYPelsPerMeter=0x257E;
lpHeader.BmpInfo.biClrUsed=0;
lpHeader.BmpInfo.biClrImportant=0;
Bmpheadersize=HeaderLen;
BmpFileBuf=new unsigned char[BmpHeight*BytesPerLine+Bmpheadersize];
if(!BmpFileBuf)
{
return 1;
}
memset(BmpFileBuf,0x0,BmpHeight*BytesPerLine+Bmpheadersize);
HeaderBuf=BmpFileBuf;
Screen_Buf=BmpFileBuf+Bmpheadersize;
BufPtr=Screen_Buf;
memcpy(HeaderBuf,(char *)&lpHeader.FileHeader.bfType,2);
memcpy(&HeaderBuf[2],(char *)&lpHeader.FileHeader.bfSize,4);
memcpy(&HeaderBuf[6],(char *)&lpHeader.FileHeader.bfReserved1,2);
memcpy(&HeaderBuf[8],(char *)&lpHeader.FileHeader.bfReserved2,2);
memcpy(&HeaderBuf[10],(char *)&lpHeader.FileHeader.bfOffBits,4);
HeaderBuf+=BITMAPFILEHEADER_SIZE;
memcpy(HeaderBuf,(unsigned char *)&lpHeader.BmpInfo,BITMAPINFOHEADER_SIZE);
HeaderBuf+=BITMAPINFOHEADER_SIZE;
memcpy(HeaderBuf,(unsigned char *)&panel16,sizeof(MWPALENTRY)*BmpPanelNumbers);
HeaderBuf=BmpFileBuf;
Lines=0;
//4 color degress change to 16 color degress,mainframe_img_bits is 4 color degress
for(Lines=0;Lines<BmpHeight;Lines++)
{
char1=0;
char2=0;
char3=0;
char4=0;
//
BufPtr=(unsigned char *)&Screen_Buf[(BmpHeight-1-Lines)*BytesPerLine];
for(i=0;i<(BmpWidth*2+7)/8;i++)
{
BmpChar1=imagebits[i+(Lines+src_y)*BmpBufBytsPerLine+src_x/4];
//
char1=BmpChar1&0xc0;
char1>>=6;
*BufPtr=char1;
BufPtr++;
char2=BmpChar1&0x30;
char2>>=4;
*BufPtr=char2;
BufPtr++;
char3=BmpChar1&0x0c;
char3>>=2;
*BufPtr=char3;
BufPtr++;
char4=BmpChar1&0x03;
*BufPtr=char4;
BufPtr++;
}
}
ImageId=GrLoadImageFromBuffer(BmpFileBuf,lpHeader.FileHeader.bfSize,GR_BACKGROUND_TOPLEFT);
GrDrawImageToFit(id,gc,x,y,BmpWidth,BmpHeight,ImageId);
GrFreeImage(ImageId);
free(BmpFileBuf);
return 0;
}
int
main(int argc,char **argv)
{
int t;
GR_IMAGE_ID image_id;
GR_WINDOW_ID window_id;
GR_GC_ID gc_id;
GR_SIZE w = -1;
GR_SIZE h = -1;
GR_EVENT event;
GR_SCREEN_INFO sinfo;
GR_IMAGE_INFO info;
char title[256];
if (argc < 2) {
GrError("Usage: nxview [-p] [-s] <image file>\n");
return 1;
}
t = 1;
while ( t < argc ) {
if ( !strcmp("-p",argv[t])) {
pflag = 1;
++t;
continue;
}
if ( !strcmp("-s",argv[t])) {
sflag = 1;
++t;
continue;
}
break;
}
if (GrOpen() < 0) {
GrError("cannot open graphics\n");
return 1;
}
if (!(image_id = GrLoadImageFromFile(argv[t], 0))) {
GrError("Can't load image file: %s\n", argv[t]);
return 1;
}
if(sflag) {
/* stretch to half screen size*/
GrGetScreenInfo(&sinfo);
w = sinfo.cols/2;
h = sinfo.rows/2;
} else {
GrGetImageInfo(image_id, &info);
w = info.width;
h = info.height;
}
sprintf(title, "nxview %s", argv[t]);
window_id = GrNewWindowEx(GR_WM_PROPS_APPWINDOW, title, GR_ROOT_WINDOW_ID, 0, 0, w, h, GRAY);
GrSelectEvents(window_id,
GR_EVENT_MASK_CLOSE_REQ|GR_EVENT_MASK_EXPOSURE);
GrMapWindow(window_id);
gc_id = GrNewGC();
while (1) {
GrGetNextEvent(&event);
switch(event.type) {
case GR_EVENT_TYPE_CLOSE_REQ:
GrDestroyWindow(window_id);
GrDestroyGC(gc_id);
GrFreeImage(image_id);
GrClose();
return 0;
/* no return*/
case GR_EVENT_TYPE_EXPOSURE:
if (pflag) {
int x, y;
GR_WINDOW_INFO wi;
GrGetWindowInfo(window_id, &wi);
for (x=0; x<wi.width; x+=CX*2)
for (y=0; y<wi.height; y+=CY) {
if (y & CY)
GrFillRect(window_id, gc_id, x, y, CX, CY);
else GrFillRect(window_id, gc_id, x+CX, y, CX, CY);
}
}
GrDrawImageToFit(window_id, gc_id, 0,0, w,h, image_id);
break;
}
}
return 0;
}
/* ***********************************************************/
void print_board(void)
{
int row,column,i,x,y;
GrDrawImageToFit(board, gc, 1, 0, board_w, board_h, board_image_id);
for (row=0;row<8;row++)
{
for (column=0;column<8;column++)
{
i = keyrows[row].columns[column].scancode;
switch(color[i])
{
case LIGHT:
switch(piece_char[piece[i]])
{
case 'P':
x = keyrows[row].columns[column].xoffset;
y = keyrows[row].yoffset;
GrDrawImageToFit(board, gc, x+10, y+13, w_p_w, w_p_h, w_p_image_id);
break;
case 'N':
x = keyrows[row].columns[column].xoffset;
y = keyrows[row].yoffset;
GrDrawImageToFit(board, gc, x+9, y+9, w_n_w, w_n_h, w_n_image_id);
break;
case 'B':
x = keyrows[row].columns[column].xoffset;
y = keyrows[row].yoffset;
GrDrawImageToFit(board, gc, x+9, y+9, w_b_w, w_b_h, w_b_image_id);
break;
case 'R':
x = keyrows[row].columns[column].xoffset;
y = keyrows[row].yoffset;
GrDrawImageToFit(board, gc, x+9, y+12, w_r_w, w_r_h, w_r_image_id);
break;
case 'Q':
x = keyrows[row].columns[column].xoffset;
y = keyrows[row].yoffset;
GrDrawImageToFit(board, gc, x+8, y+8, w_q_w, w_q_h, w_q_image_id);
break;
case 'K':
x = keyrows[row].columns[column].xoffset;
y = keyrows[row].yoffset;
GrDrawImageToFit(board, gc, x+8, y+5, w_k_w, w_k_h, w_k_image_id);
break;
}
break;
case DARK:
switch(piece_char[piece[i]])
{
case 'P':
x = keyrows[row].columns[column].xoffset;
y = keyrows[row].yoffset;
GrDrawImageToFit(board, gc, x+10, y+13, b_p_w, b_p_h, b_p_image_id);
break;
case 'N':
x = keyrows[row].columns[column].xoffset;
y = keyrows[row].yoffset;
GrDrawImageToFit(board, gc, x+9, y+9, b_n_w, b_n_h, b_n_image_id);
break;
case 'B':
x = keyrows[row].columns[column].xoffset;
y = keyrows[row].yoffset;
GrDrawImageToFit(board, gc, x+9, y+9, b_b_w, b_b_h, b_b_image_id);
break;
case 'R':
x = keyrows[row].columns[column].xoffset;
y = keyrows[row].yoffset;
GrDrawImageToFit(board, gc, x+9, y+12, b_r_w, b_r_h, b_r_image_id);
break;
case 'Q':
x = keyrows[row].columns[column].xoffset;
y = keyrows[row].yoffset;
GrDrawImageToFit(board, gc, x+8, y+8, b_q_w, b_q_h, b_q_image_id);
break;
case 'K':
x = keyrows[row].columns[column].xoffset;
y = keyrows[row].yoffset;
GrDrawImageToFit(board, gc, x+8, y+5, b_k_w, b_k_h, b_k_image_id);
break;
}
break;
} /* switch */
} /* for col */
} /* for row */
}
void CObjectImage::Draw()
{
if(m_wid && m_gc && m_Image)
GrDrawImageToFit(m_wid, m_gc, m_rect.x, m_rect.y, m_rect.w, m_rect.h, m_Image);
}
/* Create a new sprite from the specified image file. Returns the address of
* the new sprite on success or 0 on failure. If width is -1, the real
* dimensions of the image file will be used, otherwise the image will be
* scaled up or down to the specified dimensions. */
sprite *load_sprite(nbstate *state, unsigned char *fname, int width, int height)
{
sprite *s;
GR_DRAW_ID a;
GR_DRAW_ID p;
GR_IMAGE_ID img;
GR_IMAGE_INFO ii;
/* Make sure the file name has been specified: */
if (! fname) return 0;
/* Try to find a sprite in the list with the specified filename and
* dimensions (any dimensions are OK if width is -1). If one is found,
* increment its usage count and return its address. */
for(s = state->spritelist; s; s = s->next) {
if ((width == -1 || (width == s->w && height == s->h)) &&
s->fname && !strcmp(fname, s->fname)) {
s->usage++;
return s;
}
}
#ifdef HAVE_FILEIO
{
/* Make the full path to the filename because the Nano-X server
* probably isn't running from the game data directory: */
char buf[256];
if (snprintf(buf, 256, "%s/%s", state->gamedir, fname) >= 256){
debug_printf ("Warning: image path \"%s/%s\" is too long\n",
state->gamedir, fname);
return 0;
}
/* Try to load the image file, and return 0 on failure: */
img = GrLoadImageFromFile (buf, 0);
}
#else
if (strcmp (fname, (unsigned char*) "nbb1.gif") == 0) img = GrLoadImageFromBuffer ((char*) nbb1_data, sizeof( nbb1_data), 0);
else if (strcmp (fname, (unsigned char*) "nbb2.gif") == 0) img = GrLoadImageFromBuffer ((char*) nbb2_data, sizeof( nbb2_data), 0);
else if (strcmp (fname, (unsigned char*) "nbb3.gif") == 0) img = GrLoadImageFromBuffer ((char*) nbb3_data, sizeof( nbb3_data), 0);
else if (strcmp (fname, (unsigned char*) "nbb4.gif") == 0) img = GrLoadImageFromBuffer ((char*) nbb4_data, sizeof( nbb4_data), 0);
else if (strcmp (fname, (unsigned char*) "nbb5.gif") == 0) img = GrLoadImageFromBuffer ((char*) nbb5_data, sizeof( nbb5_data), 0);
else if (strcmp (fname, (unsigned char*) "nbb6.gif") == 0) img = GrLoadImageFromBuffer ((char*) nbb6_data, sizeof( nbb6_data), 0);
else if (strcmp (fname, (unsigned char*) "nbb7.gif") == 0) img = GrLoadImageFromBuffer ((char*) nbb7_data, sizeof( nbb7_data), 0);
else if (strcmp (fname, (unsigned char*) "nbb8.gif") == 0) img = GrLoadImageFromBuffer ((char*) nbb8_data, sizeof( nbb8_data), 0);
else if (strcmp (fname, (unsigned char*) "nbb9.gif") == 0) img = GrLoadImageFromBuffer ((char*) nbb9_data, sizeof( nbb9_data), 0);
else if (strcmp (fname, (unsigned char*)"nbball1.gif") == 0) img = GrLoadImageFromBuffer ((char*)nbball1_data, sizeof(nbball1_data), 0);
else if (strcmp (fname, (unsigned char*) "nbbat1.gif") == 0) img = GrLoadImageFromBuffer ((char*) nbbat1_data, sizeof( nbbat1_data), 0);
else if (strcmp (fname, (unsigned char*) "nbbat2.gif") == 0) img = GrLoadImageFromBuffer ((char*) nbbat2_data, sizeof( nbbat2_data), 0);
else if (strcmp (fname, (unsigned char*) "nbbat3.gif") == 0) img = GrLoadImageFromBuffer ((char*) nbbat3_data, sizeof( nbbat3_data), 0);
else if (strcmp (fname, (unsigned char*) "nbbg10.gif") == 0) img = GrLoadImageFromBuffer ((char*) nbbg10_data, sizeof( nbbg10_data), 0);
else if (strcmp (fname, (unsigned char*) "nbbg1.gif") == 0) img = GrLoadImageFromBuffer ((char*) nbbg1_data, sizeof( nbbg1_data), 0);
else if (strcmp (fname, (unsigned char*) "nbbg2.gif") == 0) img = GrLoadImageFromBuffer ((char*) nbbg2_data, sizeof( nbbg2_data), 0);
else if (strcmp (fname, (unsigned char*) "nbbg3.gif") == 0) img = GrLoadImageFromBuffer ((char*) nbbg3_data, sizeof( nbbg3_data), 0);
else if (strcmp (fname, (unsigned char*) "nbbg4.gif") == 0) img = GrLoadImageFromBuffer ((char*) nbbg4_data, sizeof( nbbg4_data), 0);
else if (strcmp (fname, (unsigned char*) "nbbg5.gif") == 0) img = GrLoadImageFromBuffer ((char*) nbbg5_data, sizeof( nbbg5_data), 0);
else if (strcmp (fname, (unsigned char*) "nbbg6.gif") == 0) img = GrLoadImageFromBuffer ((char*) nbbg6_data, sizeof( nbbg6_data), 0);
else if (strcmp (fname, (unsigned char*) "nbbg7.gif") == 0) img = GrLoadImageFromBuffer ((char*) nbbg7_data, sizeof( nbbg7_data), 0);
else if (strcmp (fname, (unsigned char*) "nbbg8.gif") == 0) img = GrLoadImageFromBuffer ((char*) nbbg8_data, sizeof( nbbg8_data), 0);
else if (strcmp (fname, (unsigned char*) "nbbg9.gif") == 0) img = GrLoadImageFromBuffer ((char*) nbbg9_data, sizeof( nbbg9_data), 0);
else if (strcmp (fname, (unsigned char*) "nbpf.gif") == 0) img = GrLoadImageFromBuffer ((char*) nbpf_data, sizeof( nbpf_data), 0);
else if (strcmp (fname, (unsigned char*) "nbpn.gif") == 0) img = GrLoadImageFromBuffer ((char*) nbpn_data, sizeof( nbpn_data), 0);
else if (strcmp (fname, (unsigned char*) "nbpp.gif") == 0) img = GrLoadImageFromBuffer ((char*) nbpp_data, sizeof( nbpp_data), 0);
else if (strcmp (fname, (unsigned char*) "nbps.gif") == 0) img = GrLoadImageFromBuffer ((char*) nbps_data, sizeof( nbps_data), 0);
else if (strcmp (fname, (unsigned char*) "nbpt.gif") == 0) img = GrLoadImageFromBuffer ((char*) nbpt_data, sizeof( nbpt_data), 0);
else if (strcmp (fname, (unsigned char*) "nbpw.gif") == 0) img = GrLoadImageFromBuffer ((char*) nbpw_data, sizeof( nbpw_data), 0);
else if (strcmp (fname, (unsigned char*) "nbsp1.gif") == 0) img = GrLoadImageFromBuffer ((char*) nbsp1_data, sizeof( nbsp1_data), 0);
else if (strcmp (fname, (unsigned char*) "nbsp2.gif") == 0) img = GrLoadImageFromBuffer ((char*) nbsp2_data, sizeof( nbsp2_data), 0);
else if (strcmp (fname, (unsigned char*) "nbsp3.gif") == 0) img = GrLoadImageFromBuffer ((char*) nbsp3_data, sizeof( nbsp3_data), 0);
else {
debug_printf ("No such image: \"%s\"\n", fname);
uos_halt (0);
return 0;
}
#endif
if (! img) {
debug_printf ("Warning: failed to load image \"%s\"- make "
"sure it is where the server can find it and "
"that support for loading the relevant image "
"type has been built into the server\n", fname);
return 0;
}
/* If a size wasn't specified, get the real image size from the server
* instead: */
if(width == -1 || height == -1) {
GrGetImageInfo(img, &ii);
width = ii.width;
height = ii.height;
}
/* Make the alpha channel and pixmap to store the image in: */
if(!(a = GrNewPixmap(width, height, 0))) {
GrFreeImage(img);
return 0;
}
if(!(p = GrNewPixmap(width, height, 0))) {
GrFreeImage(img);
GrDestroyWindow(a);
return 0;
}
/* Draw the image into the specified pixmap and alpha channel, scaling
* it up or down if necessary: */
GrDrawImageToFit(p, state->gc, 0, 0, width, height, img);
GrFreeImage(img); /* Destroy the server image object. */
/* Make a new sprite and link it into the list, then return its
* address to the caller: */
s = make_sprite(state, fname, width, height, p, a);
if (! s) {
GrDestroyWindow(a);
GrDestroyWindow(p);
return 0;
}
return s;
}
