void new_message_common_window(char *message)
{
GR_SIZE width, height, base;
int i, maxwidth;
if (msg_wid) {
msg_destroy_msg();
}
msg_gc = pz_get_gc(1);
GrSetGCUseBackground(msg_gc, GR_FALSE);
GrSetGCForeground(msg_gc, appearance_get_color( CS_MESSAGEFG ));
msg_build_msg(message);
maxwidth = 0;
for(i=linenum; i; i--) {
GrGetGCTextSize(msg_gc, msglines[i-1], -1, GR_TFASCII, &width,
&height, &base);
if(width > maxwidth)
maxwidth = width;
}
msg_wid = pz_new_window((screen_info.cols - (maxwidth + 10)) >> 1,
(screen_info.rows - (((height + 3) * linenum) + 10)) >> 1,
maxwidth + 10, ((height + 3) * linenum) + 10,
msg_do_draw, msg_do_keystroke);
GrSelectEvents(msg_wid, GR_EVENT_MASK_EXPOSURE| GR_EVENT_MASK_KEY_UP|
GR_EVENT_MASK_KEY_DOWN| GR_EVENT_MASK_TIMER);
GrMapWindow(msg_wid);
/* window will auto-close after 6 seconds */
msg_timer = GrCreateTimer(msg_wid, 6000);
}
void new_invaders_window()
{
invaders_gc = pz_get_gc(1);
GrSetGCUseBackground(invaders_gc, GR_TRUE);
GrSetGCBackground(invaders_gc, GR_RGB(255,255,255));
GrSetGCForeground(invaders_gc, GR_RGB(0,0,0));
invaders_score_pix = GrNewPixmap(screen_info.cols, 13, 0);
invaders_wid = pz_new_window(0,
HEADER_TOPLINE + 1,
screen_info.cols,
screen_info.rows - HEADER_TOPLINE - 1,
invaders_do_draw,
invaders_handle_event);
GrSelectEvents(invaders_wid, GR_EVENT_MASK_TIMER |
GR_EVENT_MASK_EXPOSURE | GR_EVENT_MASK_KEY_UP |
GR_EVENT_MASK_KEY_DOWN);
score = 0;
level = 0;
aliens_rows = (screen_info.rows - 40) / 20;
game_status = GAME_STATUS_PLAY;
invaders_create_board(level);
invaders_timer_id = GrCreateTimer(invaders_wid, 50);
GrMapWindow(invaders_wid);
draw_first();
}
void new_video_window(char *filename)
{
#ifndef IPOD
pz_error("No video support on the desktop.");
#else /* IPOD */
if (full_hw_version==0)
{
full_hw_version = ipod_get_hw_version();
}
outl(1, VAR_VIDEO_ON);
outl(0, VAR_VIDEO_MODE);
cop_wakeup();
init_variables();
video_status = VIDEO_CONTROL_MODE_STARTING;
video_curPosition = 0;
video_gc = pz_get_gc(1);
GrSetGCUseBackground(video_gc, GR_FALSE);
GrSetGCForeground(video_gc, GR_RGB(0,0,0));
//nes_window("Create win");
video_wid = pz_new_window(0, 0, screen_info.cols, screen_info.rows, video_do_draw, video_do_keystroke);
GrSelectEvents(video_wid,
GR_EVENT_MASK_KEY_DOWN| GR_EVENT_MASK_KEY_UP);
GrMapWindow(video_wid);
GrClearWindow(video_wid, GR_FALSE);
//nes_window("Load");
video_status_message("Loading video...");
//nes_window("Play");
playVideo(filename);
outl(0, VAR_VIDEO_ON);
#endif
}
void new_ipobble_window()
{
ipobble_gc = pz_get_gc(1);
GrSetGCUseBackground(ipobble_gc, GR_TRUE);
GrSetGCForeground(ipobble_gc, BLACK);
GrSetGCBackground(ipobble_gc, WHITE);
ipobble_wid = pz_new_window(0, HEADER_TOPLINE + 1,
screen_info.cols,
screen_info.rows - HEADER_TOPLINE - 1,
ipobble_do_draw, ipobble_handle_event);
GrSelectEvents(ipobble_wid, GR_EVENT_MASK_TIMER |
GR_EVENT_MASK_EXPOSURE | GR_EVENT_MASK_KEY_UP |
GR_EVENT_MASK_KEY_DOWN);
if( screen_info.bpp > 2) {
ipodc=1;
}
score = 0;
level = 0;
game_status = GAME_STATUS_PLAY;
ipobble_create_board(level);
ipobble_timer_id = GrCreateTimer(ipobble_wid, DELTA_TIME);
GrMapWindow(ipobble_wid);
draw_first();
}
//Create the blackjack window
void new_blackjack_window(void)
{
srand((unsigned int)time(NULL) / 2); //Make a seed for our random # generator
blackjack_gc = pz_get_gc(1); /* Get the graphics context */
/* Open the window: */
blackjack_wid = pz_new_window (0,
21,
screen_info.cols,
screen_info.rows - (HEADER_TOPLINE+1),
draw_header,
handle_event);
GrGetWindowInfo(blackjack_wid, &wi); /* Get screen info */
/* Select the types of events you need for your window: */
GrSelectEvents (blackjack_wid, GR_EVENT_MASK_EXPOSURE|GR_EVENT_MASK_KEY_DOWN|GR_EVENT_MASK_KEY_UP);
/* Display the window: */
GrMapWindow (blackjack_wid);
readPot();
reset();
}
// Creates a new tunnel "app" window
void new_tunnel_window(void)
{
tunnel_gc = pz_get_gc(1); /* Get the graphics context */
/* Open the window: */
tunnel_wid = pz_new_window (0,
21,
screen_info.cols,
screen_info.rows - (HEADER_TOPLINE+1),
draw_header,
handle_event);
GrGetWindowInfo(tunnel_wid, &wi); /* Get screen info */
/* Select the types of events you need for your window: */
GrSelectEvents (tunnel_wid, GR_EVENT_MASK_TIMER|GR_EVENT_MASK_EXPOSURE|GR_EVENT_MASK_KEY_DOWN|GR_EVENT_MASK_KEY_UP);
// set up pixmap
temp_pixmap = GrNewPixmap(screen_info.cols,
(screen_info.rows - (HEADER_TOPLINE + 1)),
NULL);
/* Display the window: */
GrMapWindow (tunnel_wid);
draw_header();
readHighScore();
reset();
}
int
main(int argc, char **argv)
{
int COLS, ROWS;
if (GrOpen() < 0) {
fprintf(stderr, "Cannot open graphics\n");
exit(1);
}
COLS = 350;
ROWS = 300;
g_main = GrNewWindowEx(GR_WM_PROPS_APPWINDOW, "dashdemo",
GR_ROOT_WINDOW_ID, 100, 50, COLS - 120, ROWS - 60, BLUE);
GrSelectEvents(g_main, GR_EVENT_MASK_EXPOSURE|GR_EVENT_MASK_CLOSE_REQ);
GrMapWindow(g_main);
while (1) {
GR_EVENT event;
GrGetNextEvent(&event);
switch (event.type) {
case GR_EVENT_TYPE_EXPOSURE:
draw_screen();
break;
case GR_EVENT_TYPE_CLOSE_REQ:
GrClose();
exit(0);
}
}
}
int main (void)
{
if (GrOpen() < 0)
{
GrError("GrOpen failed");
return 1;
}
gc = GrNewGC();
GrSetGCUseBackground (gc, GR_FALSE);
GrSetGCForeground (gc, RED);
wid = GrNewWindowEx (GR_WM_PROPS_APPFRAME |
GR_WM_PROPS_CAPTION |
GR_WM_PROPS_CLOSEBOX,
"Hello Window",
GR_ROOT_WINDOW_ID,
50, 50, 200, 100, WHITE);
GrSelectEvents (wid, GR_EVENT_MASK_EXPOSURE |
GR_EVENT_MASK_CLOSE_REQ);
GrMapWindow (wid);
GrMainLoop (event_handler);
}
/* initialize the window */
void new_lights_window(void)
{
/* Init randomizer */
srand(time(NULL));
lights_gc = pz_get_gc (1);
GrSetGCUseBackground(lights_gc, GR_FALSE);
GrSetGCForeground(lights_gc, GR_RGB(0,0,0));
lights_height = (lights_screen_info.rows - (HEADER_TOPLINE + 1));
lights_wid = pz_new_window( 0, HEADER_TOPLINE + 1,
screen_info.cols, lights_height,
lights_do_draw, lights_handle_event );
lights_bufwid = GrNewPixmap( lights_screen_info.cols,
lights_height, NULL );
GrSelectEvents( lights_wid, GR_EVENT_MASK_TIMER
| GR_EVENT_MASK_EXPOSURE
| GR_EVENT_MASK_KEY_UP
| GR_EVENT_MASK_KEY_DOWN );
lights_timer = GrCreateTimer( lights_wid, 300 );
GrMapWindow( lights_wid );
/* intialize game state */
lights_new_game();
}
void new_browser_window(char *initial_path)
{
if (initial_path) {
chdir(initial_path);
}
getcwd(current_dir, sizeof(current_dir));
browser_gc = pz_get_gc(1);
GrSetGCUseBackground(browser_gc, GR_FALSE);
GrSetGCBackground(browser_gc, WHITE);
GrSetGCForeground(browser_gc, BLACK);
browser_wid = pz_new_window(0, HEADER_TOPLINE + 2, screen_info.cols,
screen_info.rows - (HEADER_TOPLINE + 2),
browser_do_draw, browser_do_keystroke);
GrSelectEvents(browser_wid, GR_EVENT_MASK_EXPOSURE |
GR_EVENT_MASK_KEY_UP | GR_EVENT_MASK_KEY_DOWN |
GR_EVENT_MASK_TIMER);
browser_menu = NULL;
browser_menu_overlay = NULL;
browser_mscandir("./");
GrMapWindow(browser_wid);
}
void new_cube_window( void )
{
if (screen_info.cols==220) {
photo = 1;
if (!z_off) z_off = 400;
} else if (screen_info.cols==138) {
if (!z_off) z_off = 800;
} else {
if (!z_off) z_off = 600;
}
cube_gc = pz_get_gc(1);
GrSetGCUseBackground(cube_gc, GR_FALSE);
GrSetGCForeground(cube_gc, BLACK);
cube_wid = pz_new_window(0, HEADER_TOPLINE + 1,
screen_info.cols, screen_info.rows - (HEADER_TOPLINE + 1),
cube_do_draw, cube_handle_event);
GrSelectEvents( cube_wid, GR_EVENT_MASK_TIMER|
GR_EVENT_MASK_EXPOSURE|GR_EVENT_MASK_KEY_UP|GR_EVENT_MASK_KEY_DOWN);
cube_timer = GrCreateTimer( cube_wid, 100 );
GrMapWindow( cube_wid );
x_off = screen_info.cols/2;
y_off = (screen_info.rows - (HEADER_TOPLINE + 1))/2;
temp_pixmap = GrNewPixmap(screen_info.cols,
(screen_info.rows - (HEADER_TOPLINE + 1)),
NULL);
cube_init();
}
struct menulist *new_ml()
{
struct menulist *ret =
(struct menulist *) malloc(sizeof(struct menulist));
GrGetScreenInfo(&ret->screen_info);
ret->gc = pz_get_gc(1);
GrSetGCUseBackground(ret->gc, GR_FALSE);
GrSetGCForeground(ret->gc, BLACK);
GrSetGCBackground(ret->gc, BLACK);
ret->wid = pz_new_window(0, HEADER_TOPLINE + 1, ret->screen_info.cols,
ret->screen_info.rows - (HEADER_TOPLINE + 1),
itunes_do_draw, itunes_do_keystroke);
GrSelectEvents(ret->wid, GR_EVENT_MASK_EXPOSURE|GR_EVENT_MASK_KEY_DOWN|GR_EVENT_MASK_KEY_UP|GR_EVENT_MASK_TIMER);
GrGetGCTextSize(ret->gc, "M", -1, GR_TFASCII, &ret->gr_width,
&ret->gr_height, &ret->gr_base);
ret->gr_height += 4;
GrMapWindow(ret->wid);
ret->itunes_menu = menu_init(ret->wid, "Music", 0, 0,
screen_info.cols, screen_info.rows -
(HEADER_TOPLINE + 1), NULL, NULL, UTF8);
ret->init = 0;
ret->prevml = NULL;
return ret;
}
/*
* Initialize graphics and open a window for the viewer
*/
Bool
CreateXWindow(void)
{
int fd;
GR_SIZE w, h;
GR_SCREEN_INFO si;
if ((fd = GrOpen()) < 0)
return(False);
nx_dpy.fd = fd;
dpy = &nx_dpy;
GrGetScreenInfo(&si);
/* pass screen details to RFB handler */
myFormat.bitsPerPixel = si.bpp;
myFormat.depth = si.bpp; /* is this right? */
myFormat.bigEndian = 0; /* how do I find this out? */
myFormat.trueColour = (myFormat.depth == 8 && !useBGR233) ? 0 : 1;
if (myFormat.trueColour) {
myFormat.redMax = myFormat.greenMax = 7;
myFormat.blueMax = 3;
myFormat.redShift = 0;
myFormat.greenShift = 3;
myFormat.blueShift = 6;
}
pixtype = si.pixtype;
/* get the initial server palette */
GrGetSystemPalette(&srv_pal);
#if 0
/* DEBUG */
for (i = 0; i < srv_pal.count; i++) {
printf("0x%02x %03d %03d %03d\n", i, \
srv_pal.palette[i].r, srv_pal.palette[i].g, \
srv_pal.palette[i].b );
}
#endif
/* create the top-level window */
w = (VW_WIDTH > (si.cols - VW_X)) ? (si.cols - VW_X) : VW_WIDTH;
h = (VW_HEIGHT > (si.rows - VW_Y)) ? (si.rows - VW_Y) : VW_HEIGHT;
if ((wid = GrNewWindow(GR_ROOT_WINDOW_ID, VW_X, VW_Y, w, h,
2, LTGRAY, BLACK)) == 0) {
fprintf(stderr, "Unable to create top-level window\n");
GrClose();
return False;
}
/* select events to receive */
GrSelectEvents(wid, GR_EVENT_MASK_BUTTON_DOWN |
GR_EVENT_MASK_BUTTON_UP | GR_EVENT_MASK_KEY_DOWN |
GR_EVENT_MASK_KEY_UP | GR_EVENT_MASK_MOUSE_POSITION);
/* make thw window visible */
GrMapWindow(wid);
canvas = wid;
/* create the graphics contexts */
gc = GrNewGC();
srcGC = GrNewGC();
dstGC = GrNewGC();
return True;
}
static void
do_update(GR_EVENT_UPDATE *ep)
{
mwin * mwp;
mwin * tmwp;
GR_WINDOW_INFO winfo;
if (IsDecoration(ep->wid)) return;
if ((mwp = FindWindow(ep->wid)) == NULL) {
/* We have a new window */
if (ep->utype != GR_UPDATE_MAP) return;
if ((mwp = NewWindow(ep->wid)) == NULL) {
GrError("malloc failed\n");
return;
}
GrGetWindowInfo(ep->wid, &winfo);
mwp->x = ep->x - winfo.bordersize;
mwp->y = ep->y - winfo.bordersize;
mwp->width = ep->width + 2 * winfo.bordersize;
GrMoveWindow(mwp->wid, mwp->x + winfo.bordersize,
mwp->y + DEC_HEIGHT +
2 * winfo.bordersize);
mwp->fid = GrNewWindow(GR_ROOT_WINDOW_ID, mwp->x + 1,
mwp->y + 1, mwp->width - 2,
DEC_HEIGHT - 2, 1, BLUE, BLACK);
GrSelectEvents(mwp->fid, GR_EVENT_MASK_BUTTON_DOWN |
GR_EVENT_MASK_BUTTON_UP | GR_EVENT_MASK_MOUSE_POSITION);
GrMapWindow(mwp->fid);
} else {
switch (ep->utype) {
case GR_UPDATE_UNMAP:
GrUnmapWindow(mwp->fid);
GrDestroyWindow(mwp->fid);
if (mwins == mwp) {
mwins = mwp->next;
} else for(tmwp = mwins; tmwp; tmwp = tmwp->next) {
if (tmwp->next == mwp) {
tmwp->next = mwp->next;
}
}
free(mwp);
break;
case GR_UPDATE_MOVE:
GrGetWindowInfo(ep->wid, &winfo);
if ((ep->x == (mwp->x + winfo.bordersize)) &&
(ep->y == (mwp->y + winfo.bordersize
+ DEC_HEIGHT))) {
return;
}
mwp->x = ep->x - winfo.bordersize;
mwp->y = ep->y - winfo.bordersize - DEC_HEIGHT;
GrMoveWindow(mwp->fid, mwp->x + 1, mwp->y + 1);
default:
break;
}
}
}
void
mvpw_show(mvp_widget_t *widget)
{
mvp_widget_t *top;
if (widget) {
if ((widget->type == MVPW_DIALOG) &&
widget->data.dialog.modal) {
top = mvpw_get_focus();
GrMapWindow(widget->wid);
raise_widget(widget, top);
if (!mvpw_visible((mvp_widget_t*)screensaver_widget))
GrRaiseWindow(widget->wid);
mvpw_focus(widget);
} else {
GrMapWindow(widget->wid);
if(widget->show) (*widget->show)(widget, 1);
}
}
}
static int incall_handler(struct lgsm_handle *lh, int evt, struct gsmd_evt_auxdata *aux)
{
printf("EVENT: Incoming call type = %u\n", aux->u.call.type);
GrMapWindow(dialer_window);
GrSetFocus(dialer_window);
GrText(dialer_window, gc, 10, 10, "Incoming call", 0, 0);
return 0;
}
/*
Cover root window to erase roaches.
*/
void
CoverRoot(void)
{
GR_WINDOW_ID roachWin;
roachWin = GrNewWindow(GR_ROOT_WINDOW_ID, 0, 0, display_width, display_height,
0, CYAN, BLACK);
GrLowerWindow(roachWin);
GrMapWindow(roachWin);
GrFlush();
}
void new_mp3_window(char *filename, char *album, char *artist, char *title, int len)
{
if (album) {
strncpy(current_album, album, sizeof(current_album)-1);
current_album[sizeof(current_album)-1] = 0;
}
else
current_album[0]=0;
if (artist) {
strncpy(current_artist, artist, sizeof(current_artist)-1);
current_artist[sizeof(current_artist)-1] = 0;
} else {
current_artist[0]=0;
}
if (title) {
strncpy(current_title, title, sizeof(current_title)-1);
current_title[sizeof(current_title)-1] = 0;
} else {
current_title[0]=0;
}
sprintf(current_pos, _("Song %d of %d"), playlistpos, playlistlength);
next_song_time = len;
/* play another song when one isn't complete */
if (window_open)
{
strcpy(next_song, filename);
next_song_queued = 1;
return;
}
window_open = 1;
mp3_gc = pz_get_gc(1);
GrSetGCUseBackground(mp3_gc, GR_TRUE);
GrSetGCBackground(mp3_gc, GR_RGB(255,255,255));
GrSetGCForeground(mp3_gc, GR_RGB(0,0,0));
mp3_wid = pz_new_window(0, HEADER_TOPLINE + 1, screen_info.cols, screen_info.rows - (HEADER_TOPLINE + 1), mp3_do_draw, mp3_do_keystroke);
GrSelectEvents(mp3_wid, GR_EVENT_MASK_EXPOSURE|GR_EVENT_MASK_KEY_UP|GR_EVENT_MASK_KEY_DOWN|GR_EVENT_MASK_TIMER);
GrMapWindow(mp3_wid);
total_time = remaining_time = len;
mp3_do_draw(0);
start_mp3_playback(filename);
window_open = 0;
}
int NX_LeaveFullScreen (_THIS)
{
if (currently_fullscreen) {
GrUnmapWindow (FSwindow) ;
GrMapWindow (SDL_Window) ;
GrRaiseWindow (SDL_Window) ;
GrSetFocus (SDL_Window) ;
currently_fullscreen = 0 ;
}
return 0 ;
}
void draw_pause_continue_button(nstate *state)
{
if((state->running_buttons_mapped) && (state->state == STATE_STOPPED)) {
GrUnmapWindow(state->pause_continue_button);
GrUnmapWindow(state->anticlockwise_button);
GrUnmapWindow(state->clockwise_button);
GrUnmapWindow(state->left_button);
GrUnmapWindow(state->right_button);
GrUnmapWindow(state->drop_button);
state->running_buttons_mapped = 0;
return;
}
if((!state->running_buttons_mapped) && (state->state == STATE_RUNNING)){
GrMapWindow(state->pause_continue_button);
GrMapWindow(state->anticlockwise_button);
GrMapWindow(state->clockwise_button);
GrMapWindow(state->left_button);
GrMapWindow(state->right_button);
GrMapWindow(state->drop_button);
state->running_buttons_mapped = 1;
return;
}
if(!state->running_buttons_mapped) return;
GrFillRect(state->pause_continue_button, state->buttongcb, 0, 0,
PAUSE_CONTINUE_BUTTON_WIDTH, PAUSE_CONTINUE_BUTTON_HEIGHT);
if(state->state == STATE_PAUSED) {
GrText(state->pause_continue_button, state->buttongcf,
TEXT_X_POSITION, TEXT_Y_POSITION, " Continue", 9, 0);
} else {
GrText(state->pause_continue_button, state->buttongcf,
TEXT_X_POSITION, TEXT_Y_POSITION, " Pause", 8, 0);
}
}
nxeyes_state *init(void)
{
nxeyes_state *state;
GR_REGION_ID rid1, rid2;
GR_SCREEN_INFO si;
GR_WM_PROPERTIES props;
if(!(state = malloc(sizeof(nxeyes_state)))) return NULL;
state->oldx = state->oldy = state->x = state->y = 0;
state->button_down = state->eyes_closed = state->quit = 0;
state->olx = state->orx = EYEMASK_WIDTH / 2;
state->oly = state->ory = EYEMASK_HEIGHT / 2;
GrGetScreenInfo(&si);
state->mousex = si.xpos;
state->mousey = si.ypos;
state->mouse_moved = 1;
state->gc = GrNewGC();
GrSetGCForeground(state->gc, GR_COLOR_WHITE);
GrSetGCBackground(state->gc, GR_COLOR_BLACK);
state->wid = GrNewWindow(GR_ROOT_WINDOW_ID, 0, 0, (EYEFG_HEIGHT * 2) +
EYE_SPACING, EYEFG_HEIGHT, 0, GR_COLOR_WHITE, 0);
rid1 = GrNewBitmapRegion(eyemask_bits, EYEMASK_WIDTH, EYEMASK_HEIGHT);
rid2 = GrNewBitmapRegion(eyemask_bits, EYEMASK_WIDTH, EYEMASK_HEIGHT);
GrOffsetRegion(rid2, EYEMASK_WIDTH + EYE_SPACING, 0);
GrUnionRegion(rid1, rid1, rid2);
GrSetWindowRegion(state->wid, rid1, GR_WINDOW_BOUNDING_MASK);
GrDestroyRegion(rid1);
GrDestroyRegion(rid2);
props.flags = GR_WM_FLAGS_PROPS;
props.props = GR_WM_PROPS_NODECORATE;
GrSetWMProperties(state->wid, &props);
GrSelectEvents(state->wid, GR_EVENT_MASK_CLOSE_REQ |
GR_EVENT_MASK_MOUSE_POSITION |
GR_EVENT_MASK_BUTTON_UP |
GR_EVENT_MASK_BUTTON_DOWN |
GR_EVENT_MASK_EXPOSURE |
GR_EVENT_MASK_TIMER);
GrSelectEvents(GR_ROOT_WINDOW_ID, GR_EVENT_MASK_MOUSE_POSITION);
GrMapWindow(state->wid);
srand(123);
#if MW_FEATURE_TIMERS
start_blink_timer(state);
#endif
return state;
}
/* End of the game */
void draw_end(char col)
{
int offset, off_x, off_y;
if (end == 0) {
end = 1;
end_type = col;
}
else {
end = 2;
if (is_mini) {
offset = 0;
off_x = 11;
off_y = 9;
}
else {
offset = HEADER_TOPLINE+1;
off_x = 0;
off_y = 0;
}
end_wid = pz_new_window (0, offset, screen_info.cols,
screen_info.rows - offset,
tuxchess_do_draw, tuxchess_handle_event);
GrSelectEvents(end_wid, GR_EVENT_MASK_KEY_DOWN |
GR_EVENT_MASK_KEY_UP);
GrMapWindow(end_wid);
/* Put the foreground and background in good shapes */
GrSetGCForeground(tuxchess_gc, GR_RGB(0,0,0));
GrSetGCBackground(tuxchess_gc, GR_RGB(255,255,255));
/* Clear the window */
GrClearWindow(end_wid, GR_FALSE);
if (col=='b') {
GrText(end_wid, tuxchess_gc, 57-off_x,40-off_y, "You Lost", -1, GR_TFASCII);
}
else if (col=='w') {
GrText(end_wid, tuxchess_gc, 54-off_x,40-off_y, "Well Done", -1, GR_TFASCII);
}
else if (col=='d') {
GrText(end_wid, tuxchess_gc, 67-off_x,40-off_y, "Draw", -1, GR_TFASCII);
}
GrText(end_wid, tuxchess_gc, 52-off_x,65-off_y,
"Menu : Quit", -1, GR_TFASCII);
GrText(end_wid, tuxchess_gc, 33-off_x,80-off_y,
"Action : New Game", -1, GR_TFASCII);
}
}
int
main(int ac, char **av)
{
GR_EVENT event;
GR_GC_ID gc;
GR_WINDOW_ID pmap;
GR_WINDOW_ID window;
GR_WINDOW_INFO info;
if (GrOpen() < 0) {
fprintf(stderr, "cannot open graphics\n");
exit(1);
}
window = nxCreateAppWindow(&ac, &av, args);
gc = GrNewGC();
GrSetGCForeground(gc, GrGetSysColor(GR_COLOR_WINDOW));
GrSetGCBackground(gc, GrGetSysColor(GR_COLOR_WINDOWTEXT));
GrSelectEvents(window, GR_EVENT_MASK_EXPOSURE |
GR_EVENT_MASK_UPDATE | GR_EVENT_MASK_CLOSE_REQ);
GrGetWindowInfo(window, &info);
pmap = resize(info.width, info.height, 0);
GrMapWindow(window);
while (1) {
GrGetNextEventTimeout(&event, 500L);
switch (event.type) {
case GR_EVENT_TYPE_EXPOSURE:
case GR_EVENT_TYPE_TIMEOUT:
draw_clock(0, 0, width, height, pmap, gc, window);
break;
case GR_EVENT_TYPE_CLOSE_REQ:
GrClose();
exit(0);
case GR_EVENT_TYPE_UPDATE:
switch (event.update.utype) {
case GR_UPDATE_SIZE:
pmap = resize(event.update.width, event.update.height, pmap);
break;
}
}
}
return 0;
}
void new_idw_window()
{
idw_gc = GrNewGC();
GrGetScreenInfo(&screen_info);
init_defaults();
init_drugs();
init_screens();
init_sheets();
idw_wid = pz_new_window(0, HEADER_TOPLINE + 1, screen_info.cols, screen_info.rows - (HEADER_TOPLINE + 1), idw_do_draw, idw_do_keystroke);
GrSelectEvents(idw_wid, GR_EVENT_MASK_EXPOSURE|GR_EVENT_MASK_KEY_DOWN);
GrMapWindow(idw_wid);
}
int NX_EnterFullScreen (_THIS)
{
if (! currently_fullscreen) {
GR_SCREEN_INFO si ;
GrGetScreenInfo (& si) ;
GrResizeWindow (FSwindow, si.cols, si.rows) ;
GrUnmapWindow (SDL_Window) ;
GrMapWindow (FSwindow) ;
GrRaiseWindow (FSwindow) ;
GrSetFocus (FSwindow) ;
currently_fullscreen = 1 ;
}
return 1 ;
}
int
XMapSubwindows(Display *dpy, Window w)
{
GR_WINDOW_ID parent;
GR_WINDOW_ID *child, *cp;
int i, nchild;
GrQueryTree(w, &parent, &child, &nchild);
cp = child;
for (i=0; i<nchild; ++i)
GrMapWindow(*cp++);
free(child);
return 1;
}
void CContextWeather::Proc(UINT nContextNum)
{
char szWaveFile[7][14] = { "serenity\0", "party_cloudy\0", "cloudy\0", "shower\0", "rainny\0", "thunderstorm\0", "snow\0" };
char szWaveFilePath[128] = {0,};
DBGMSGC(DBG_WEATHER, "++ [%d]\r\n", nContextNum);
switch (nContextNum) {
case 0: //하단 배너 준비
if ((!g_setup_data.m_SetupData.light_stat) &&
(g_gpio_mtm.CheckWatchdogReset()==FALSE) &&
(g_gpio_mtm.GetGpioInputPin(GPIO_DOOR_DETECT)==HIGH)) { //와치독 리셋상태가 아니고 출입문이 닫힌 상태이면
sprintf(szWaveFilePath, "/app/sound/%s.wav\0",
szWaveFile[g_setup_data.m_SetupData.weather_right]);
PlayWavFile(szWaveFilePath);
}
//문자열의 길이
m_len_ment = strlen(g_szWeatherMent[g_setup_data.m_SetupData.weather_right]);
//폰트크기를 감안한 문자열이 표시되는 폭
m_width_ment = m_len_ment*12;
//멘트 텍스트를 픽셀맵에 그리기
GrMapWindow(m_wid_ment);
RedrawImage(m_wid_ment, g_gc, 0, 0, MENT_AREA_WIDTH, MENT_AREA_HEIGHT,
MENT_AREA_X, MENT_AREA_Y, MENT_AREA_WIDTH, MENT_AREA_HEIGHT, WEATHER_OBJ_BG);
RedrawImage(m_pixmap_ment, g_gc, 0, 0, MENT_AREA_WIDTH, MENT_AREA_HEIGHT,
MENT_AREA_X, MENT_AREA_Y, MENT_AREA_WIDTH, MENT_AREA_HEIGHT, WEATHER_OBJ_BG);
RedrawImage(m_pixmap_ment, g_gc, MENT_AREA_WIDTH, 0, MENT_PIXEL_MAP_WIDTH-MENT_AREA_WIDTH, MENT_AREA_HEIGHT,
MENT_AREA_X, MENT_AREA_Y, MENT_PIXEL_MAP_WIDTH-MENT_AREA_WIDTH, MENT_AREA_HEIGHT, WEATHER_OBJ_BG);
DrawText(g_szWeatherMent[g_setup_data.m_SetupData.weather_right],
m_pixmap_ment, g_gc, 0, 0, m_width_ment, MENT_AREA_HEIGHT, g_font, 24, WHITE, TXT_HALIGN_LEFT|TXT_VALIGN_MIDDLE);
GrRaiseWindow(m_wid_ment);
m_nThreadStep = 0;
break;
case 1:
break;
}
DBGMSGC(DBG_WEATHER, "--\r\n");
}
//------------------------------------------------------------------------------
// Function Name : init_ui_manager()
// Description :
//------------------------------------------------------------------------------
BOOL init_ui_manager(void)
{
CObject* pObject;
UINT id;
PRINT_FUNC_CO();
// start nano-x service
if (GrOpen() < 0) {
// DBGMSG(DBG_MAIN, "[Failure]\r\n--> %s: GrOpen Failed!!\r\n", __func__);
return FALSE;
}
GrSetErrorHandler(error_handler);
GrGetScreenInfo(&g_scr_info);
// prepare g_font
g_font = GrCreateFontEx((GR_CHAR *)FONT_PATH, 18, 18, NULL);
GrSetFontAttr(g_font, (GR_TFKERNING | GR_TFANTIALIAS), 0);
g_wid = GrNewWindow(GR_ROOT_WINDOW_ID, 0, 0, g_scr_info.cols, g_scr_info.rows, 0, BLACK, 0);
if (g_wid == 0) {
// DBGMSG(DBG_MAIN, "[Failure]\r\n--> %s: GrNewWindow failure\r\n", __func__);
GrClose();
return FALSE;
}
g_gc = GrNewGC();
GrRaiseWindow(g_wid);
GrMapWindow(g_wid);
GrSelectEvents(g_wid, GR_EVENT_MASK_BUTTON_DOWN | GR_EVENT_MASK_EXPOSURE);
GrSetGCUseBackground(g_gc, FALSE);
// GrSetGCUseBackground(g_gc, TRUE);
GrSetGCFont(g_gc, g_font);
// GrSetGCBackground(g_gc, BLACK);
GrSetGCForeground(g_gc, WHITE);
// BuildObject();
return TRUE;
}
int main()
{
GR_WINDOW_ID window;
GR_EVENT event;
if (GrOpen() < 0) {
fprintf(stderr, "cannot open graphics\n");
exit(1);
}
window = GrNewWindow(GR_ROOT_WINDOW_ID, 20, 20, 100, 60, 4, WHITE, BLUE);
GrMapWindow(window);
while(1)
GrCheckNextEvent(&event);
GrClose();
}
CRJinkeScreen( int width, int height )
: CRGUIScreenBase( width, height, true )
{
if( GrOpen() < 0 )
{
fprintf(stderr, "Couldn't connect to Nano-X server\n");
return;
}
GR_WM_PROPERTIES props;
//GR_SCREEN_INFO si;
//GrGetScreenInfo(&si);
_wid = GrNewWindow(GR_ROOT_WINDOW_ID,VIEWER_WINDOW_X,VIEWER_WINDOW_Y,
VIEWER_WINDOW_WIDTH,VIEWER_WINDOW_HEIGHT, 0, GR_COLOR_WHITE, 0);
_gc = GrNewGC();
GrSetGCForeground(_gc, GR_COLOR_BLACK);
GrSetGCBackground(_gc, GR_COLOR_WHITE);
GrSelectEvents(_wid, GR_EVENT_MASK_BUTTON_DOWN | \
GR_EVENT_MASK_BUTTON_UP | GR_EVENT_MASK_MOUSE_POSITION |\
GR_EVENT_MASK_EXPOSURE |GR_EVENT_MASK_KEY_UP|\
GR_EVENT_MASK_KEY_DOWN | GR_EVENT_MASK_CLOSE_REQ);
//Set Windows style
props.flags = GR_WM_FLAGS_PROPS;
props.props = GR_WM_PROPS_NODECORATE;
GrSetWMProperties(_wid, &props);
//#ifndef USE_OLD_NANOX
GrMapWindow(_wid);
GrSetFocus(_wid);
//#endif
_canvas = LVRef<LVDrawBuf>( new LVGrayDrawBuf( _width, _height, GRAY_BACKBUFFER_BITS ) );
_front = LVRef<LVDrawBuf>( new LVGrayDrawBuf( _width, _height, GRAY_BACKBUFFER_BITS ) );
_canvas->Clear(0xFFFFFF);
//_front->Clear(0xFFFFFF);
_front->Clear(0x000000);
instance = this;
}
