/*
* Called when the properties on the root window change, e.g. when the screen
* resolution changes. If so we update the window to cover the whole screen
* and also redraw the image, if any.
*
*/
void handle_screen_resize(void) {
xcb_get_geometry_cookie_t geomc;
xcb_get_geometry_reply_t *geom;
geomc = xcb_get_geometry(conn, screen->root);
if ((geom = xcb_get_geometry_reply(conn, geomc, 0)) == NULL)
return;
if (last_resolution[0] == geom->width &&
last_resolution[1] == geom->height) {
free(geom);
return;
}
last_resolution[0] = geom->width;
last_resolution[1] = geom->height;
free(geom);
redraw_screen();
uint32_t mask = XCB_CONFIG_WINDOW_WIDTH | XCB_CONFIG_WINDOW_HEIGHT;
xcb_configure_window(conn, win, mask, last_resolution);
xcb_flush(conn);
xinerama_query_screens();
redraw_screen();
}
void event_loop(void)
{
GP_Event ev;
for (;;) {
GP_BackendWaitEvent(win, &ev);
switch (ev.type) {
case GP_EV_KEY:
if (ev.code != GP_EV_KEY_DOWN)
continue;
switch (ev.val.key.key) {
case GP_KEY_SPACE:
if (font)
font_flag = (font_flag + 1) % 5;
else
font_flag = (font_flag + 1) % 4;
redraw_screen();
GP_BackendFlip(win);
break;
case GP_KEY_UP:
tracking++;
redraw_screen();
GP_BackendFlip(win);
break;
case GP_KEY_DOWN:
tracking--;
redraw_screen();
GP_BackendFlip(win);
break;
case GP_KEY_B:
font_h++;
if (font_path) {
GP_FontFaceFree(font);
font = GP_FontFaceLoad(font_path, 0, font_h);
redraw_screen();
GP_BackendFlip(win);
}
break;
case GP_KEY_S:
font_h--;
if (font_path) {
GP_FontFaceFree(font);
font = GP_FontFaceLoad(font_path, 0, font_h);
redraw_screen();
GP_BackendFlip(win);
}
break;
case GP_KEY_ESC:
GP_BackendExit(win);
exit(0);
break;
}
}
}
}
static void input_done(void) {
if (clear_pam_wrong_timeout) {
ev_timer_stop(main_loop, clear_pam_wrong_timeout);
free(clear_pam_wrong_timeout);
clear_pam_wrong_timeout = NULL;
}
pam_state = STATE_PAM_VERIFY;
redraw_screen();
if (pam_authenticate(pam_handle, 0) == PAM_SUCCESS) {
DEBUG("successfully authenticated\n");
clear_password_memory();
if (shell_auth_done_command) {
system(shell_auth_done_command);
}
exit(0);
}
else
{
if (shell_auth_fail_command) {
system(shell_auth_fail_command);
}
}
if (debug_mode)
fprintf(stderr, "Authentication failure\n");
pam_state = STATE_PAM_WRONG;
clear_input();
redraw_screen();
/* Clear this state after 2 seconds (unless the user enters another
* password during that time). */
ev_now_update(main_loop);
if ((clear_pam_wrong_timeout = calloc(sizeof(struct ev_timer), 1))) {
ev_timer_init(clear_pam_wrong_timeout, clear_pam_wrong, 2.0, 0.);
ev_timer_start(main_loop, clear_pam_wrong_timeout);
}
/* Cancel the clear_indicator_timeout, it would hide the unlock indicator
* too early. */
stop_clear_indicator_timeout();
/* beep on authentication failure, if enabled */
if (beep) {
xcb_bell(conn, 100);
xcb_flush(conn);
}
}
int main(int argc, char *argv[])
{
const char *backend_opts = "X11";
print_instructions();
if (argc > 1) {
font_path = argv[1];
fprintf(stderr, "\nLoading font '%s'\n", argv[1]);
font = gp_font_face_load(argv[1], 0, font_h);
}
win = gp_backend_init(backend_opts, "Font Test");
if (win == NULL) {
fprintf(stderr, "Failed to initalize backend '%s'\n",
backend_opts);
return 1;
}
white_pixel = gp_rgb_to_pixmap_pixel(0xff, 0xff, 0xff, win->pixmap);
gray_pixel = gp_rgb_to_pixmap_pixel(0xbe, 0xbe, 0xbe, win->pixmap);
dark_gray_pixel = gp_rgb_to_pixmap_pixel(0x7f, 0x7f, 0x7f, win->pixmap);
black_pixel = gp_rgb_to_pixmap_pixel(0x00, 0x00, 0x00, win->pixmap);
red_pixel = gp_rgb_to_pixmap_pixel(0xff, 0x00, 0x00, win->pixmap);
blue_pixel = gp_rgb_to_pixmap_pixel(0x00, 0x00, 0xff, win->pixmap);
redraw_screen();
gp_backend_flip(win);
event_loop();
return 0;
}
/* 游戏主循环。
* 在初始化工作结束后，main函数就跳转到主循环执行。
* 在主循环执行期间随时会插入异步的中断。时钟中断最终调用timer_event，
* 键盘中断最终调用keyboard_event。中断处理完成后将返回主循环原位置继续执行。
*
* tick是时钟中断中维护的信号，数值含义是“系统到当前时刻已经发生过的时钟中断数”
* HZ是时钟控制器硬件每秒产生的中断数，在include/device/timer.h中定义
* now是主循环已经正确处理的时钟中断数，即游戏已经处理到的物理时间点
* */
void
main_loop(void) {
int now = 0, target;
int num_draw = 0;
bool redraw;
while (true) {
wait_intr();
cli();
if (now == tick) {
sti();
continue;
}
assert(now < tick);
target = tick; /* now总是小于tick，因此我们需要“追赶”当前的时间 */
sti();
redraw = false;
while (update_keypress())
;
/* 依次模拟已经错过的时钟中断。一次主循环如果执行时间长，期间可能到来多次时钟中断，
* 从而主循环中维护的时钟可能与实际时钟相差较多。为了维持游戏的正常运行，必须补上
* 期间错过的每一帧游戏逻辑。 */
while (now < target) {
/* 每隔一定时间产生一个新的字符 */
if (now % (HZ / CHARACTER_PER_SECOND) == 0) {
create_new_letter();
}
/* 每隔一定时间更新屏幕上字符的位置 */
if (now % (HZ / UPDATE_PER_SECOND) == 0) {
update_letter_pos();
}
/* 每隔一定时间需要刷新屏幕。注意到这里实现了“跳帧”的机制：假设
* HZ = 1000, FPS = 100, now = 10, target = 1000
* 即我们要模拟990个时钟中断之间发生的事件，其中包含了9次屏幕更新，
* 但redraw flag只被置一次。 */
/* 以上是余大神的解释，但我觉得怎么应该是: */
/* 即我们要模拟990个时钟中断，其中redraw flag被重置了99次（应该更新99次）， */
/* 但实际上屏幕只更新了一次 */
if (now % (HZ / FPS) == 0) {
redraw = true;
}
/* 更新fps统计信息 */
if (now % (HZ / 2) == 0) {
int now_fps = num_draw * 2 + 1;
if (now_fps > FPS) now_fps = FPS;
set_fps(now_fps);
num_draw = 0;
}
now ++;
}
if (redraw) { /* 当需要重新绘图时重绘 */
num_draw ++;
redraw_screen();
}
}
}
int main(int argc, char **args)
{
RAND = ((int)time(NULL))%10;
init_console();
init_buffer();
init_clipboard();
if (argc > 1)
{
FILENAME = (unsigned char *)malloc(256*sizeof(char));
strcpy((char *)FILENAME, args[1]);
file_to_buffer();
}
else
{
MAX_VPOS = 1;
}
while (RUN)
{
redraw_screen();
#ifdef DEBUG_MODE
printf("%d", INPUT_KEY);
#endif
INPUT_KEY = _getch();
process_key();
}
DestroyAndExit("Exiting...");
return 0;
}
int main(void)
{
const char *backend_opts = "X11";
win = GP_BackendInit(backend_opts, "Random Shape Test", stderr);
if (win == NULL) {
fprintf(stderr, "Failed to initalize backend '%s'\n",
backend_opts);
return 1;
}
white = GP_ColorToContextPixel(GP_COL_WHITE, win->context);
black = GP_ColorToContextPixel(GP_COL_BLACK, win->context);
for (;;) {
GP_BackendPoll(win);
event_loop();
usleep(20000);
if (pause_flag)
continue;
redraw_screen();
GP_BackendFlip(win);
}
}
static void handleUpdateWhileScrolling(volatile bool& doneScrolling, int refresh) {
while(!doneScrolling) {
sf::sleep(sf::milliseconds(10));
redraw_screen(refresh);
}
mainPtr.setActive(false);
}
/*
* Hides the unlock indicator completely when there is no content in the
* password buffer.
*
*/
void clear_indicator(void) {
if (input_position == 0) {
unlock_state = STATE_STARTED;
} else
unlock_state = STATE_KEY_PRESSED;
redraw_screen();
}
int main(int argc, char *argv[])
{
const char *backend_opts = "X11";
if (argc > 1)
font = GP_FontFaceLoad(argv[1], 0, 20);
print_instructions();
win = GP_BackendInit(backend_opts, "Font Align Test");
if (win == NULL) {
fprintf(stderr, "Failed to initalize backend '%s'\n",
backend_opts);
return 1;
}
black_pixel = GP_RGBToContextPixel(0x00, 0x00, 0x00, win->context);
red_pixel = GP_RGBToContextPixel(0xff, 0x00, 0x00, win->context);
blue_pixel = GP_RGBToContextPixel(0x00, 0x00, 0xff, win->context);
green_pixel = GP_RGBToContextPixel(0x00, 0xff, 0x00, win->context);
yellow_pixel = GP_RGBToContextPixel(0xff, 0xff, 0x00, win->context);
white_pixel = GP_RGBToContextPixel(0xff, 0xff, 0xff, win->context);
darkgray_pixel = GP_RGBToContextPixel(0x7f, 0x7f, 0x7f, win->context);
redraw_screen();
GP_BackendFlip(win);
event_loop();
return 0;
}
void Handle_Update() {
redraw_screen(REFRESH_NONE);
if(map_visible) draw_map(false);
else mini_map.setVisible(false);
}
int main(int argc, char *argv[])
{
const char *backend_opts = "X11";
print_instructions();
if (argc > 1) {
font_path = argv[1];
fprintf(stderr, "\nLoading font '%s'\n", argv[1]);
font = GP_FontFaceLoad(argv[1], 0, font_h);
}
win = GP_BackendInit(backend_opts, "Font Test");
if (win == NULL) {
fprintf(stderr, "Failed to initalize backend '%s'\n",
backend_opts);
return 1;
}
white_pixel = GP_RGBToContextPixel(0xff, 0xff, 0xff, win->context);
gray_pixel = GP_RGBToContextPixel(0xbe, 0xbe, 0xbe, win->context);
dark_gray_pixel = GP_RGBToContextPixel(0x7f, 0x7f, 0x7f, win->context);
black_pixel = GP_RGBToContextPixel(0x00, 0x00, 0x00, win->context);
red_pixel = GP_RGBToContextPixel(0xff, 0x00, 0x00, win->context);
blue_pixel = GP_RGBToContextPixel(0x00, 0x00, 0xff, win->context);
redraw_screen();
GP_BackendFlip(win);
event_loop();
return 0;
}
int main(void)
{
if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_TIMER) != 0) {
fprintf(stderr, "Could not initialize SDL: %s\n", SDL_GetError());
return 1;
}
display = SDL_SetVideoMode(W, H, 0, SDL_SWSURFACE);
if (display == NULL) {
fprintf(stderr, "Could not open display: %s\n", SDL_GetError());
SDL_Quit();
return 1;
}
GP_ContextFromSDLSurface(&context, display);
black_pixel = GP_RGBToContextPixel(0x00, 0x00, 0x00, &context);
darkgray_pixel = GP_RGBToContextPixel(0x7f, 0x7f, 0x7f, &context);
redraw_screen();
SDL_Flip(display);
event_loop();
SDL_Quit();
return 0;
}
void end_talk_mode()
{
DeleteObject(talk_gworld);
talk_gworld = NULL;
if((PSD [SDF_ASK_ABOUT_TEXT_BOX] == 1) && (talk_edit_box != NULL)){
DestroyWindow(talk_edit_box);
talk_edit_box = NULL;
}
overall_mode = store_pre_talk_mode;
create_clip_region();
if (overall_mode == MODE_TALK_TOWN)
overall_mode = MODE_TOWN;
if (overall_mode == MODE_TOWN) {
center = c_town.p_loc;
update_explored(center);
}
stat_screen_mode = 0;
put_item_screen(stat_window,0);
put_pc_screen();
redraw_screen(0);
}
void event_loop(void)
{
SDL_Event event;
while (SDL_WaitEvent(&event) > 0) {
switch (event.type) {
case SDL_VIDEOEXPOSE:
redraw_screen();
SDL_Flip(display);
break;
case SDL_KEYDOWN:
switch (event.key.keysym.sym) {
case SDLK_ESCAPE:
return;
default:
break;
}
break;
case SDL_QUIT:
return;
}
}
}
/*
* Name: zoom_window
* Purpose: To blow-up current window.
* Date: September 1, 1991
* Passed: window: pointer to current window
* Notes: Make all windows, visible and hidden, full size.
*/
int zoom_window( WINDOW *window )
{
register WINDOW *wp;
if (window != NULL) {
entab_linebuff( );
un_copy_line( window->ll, window, TRUE );
for (wp=g_status.window_list; wp != NULL; wp=wp->next) {
if (wp != window && wp->visible)
wp->visible = FALSE;
/*
* can't diff one window, reset the diff
*/
diff.defined = FALSE;
if (wp->top_line != 1)
wp->cline = wp->cline - (wp->top_line+wp->ruler) + 1;
wp->top_line = 1;
wp->bottom_line = g_display.nlines;
wp->end_col = g_display.ncols - 1;
wp->start_col = 0;
wp->vertical = FALSE;
check_virtual_col( wp, wp->rcol, wp->ccol );
make_ruler( wp );
}
redraw_screen( window );
show_ruler( window );
}
return( OK );
}
int main(void)
{
if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_TIMER) != 0) {
fprintf(stderr, "Could not initialize SDL: %s\n", SDL_GetError());
return 1;
}
display = SDL_SetVideoMode(W, H, 0, SDL_SWSURFACE);
if (display == NULL) {
fprintf(stderr, "Could not open display: %s\n", SDL_GetError());
SDL_Quit();
return 1;
}
gp_pixmap_from_sdl_surface(&pixmap, display);
black_pixel = gp_rgb_to_pixmap_pixel(0x00, 0x00, 0x00, &pixmap);
darkgray_pixel = gp_rgb_to_pixmap_pixel(0x7f, 0x7f, 0x7f, &pixmap);
redraw_screen();
SDL_Flip(display);
event_loop();
SDL_Quit();
return 0;
}
static void input_done(void) {
STOP_TIMER(clear_pam_wrong_timeout);
pam_state = STATE_PAM_VERIFY;
redraw_screen();
if (pam_authenticate(pam_handle, 0) == PAM_SUCCESS) {
DEBUG("successfully authenticated\n");
clear_password_memory();
/* Turn the screen on, as it may have been turned off
* on release of the 'enter' key. */
turn_monitors_on();
/* PAM credentials should be refreshed, this will for example update any kerberos tickets.
* Related to credentials pam_end() needs to be called to cleanup any temporary
* credentials like kerberos /tmp/krb5cc_pam_* files which may of been left behind if the
* refresh of the credentials failed. */
pam_setcred(pam_handle, PAM_REFRESH_CRED);
pam_end(pam_handle, PAM_SUCCESS);
exit(0);
}
if (debug_mode)
fprintf(stderr, "Authentication failure\n");
pam_state = STATE_PAM_WRONG;
failed_attempts += 1;
clear_input();
if (unlock_indicator)
redraw_screen();
/* Clear this state after 2 seconds (unless the user enters another
* password during that time). */
ev_now_update(main_loop);
START_TIMER(clear_pam_wrong_timeout, TSTAMP_N_SECS(2), clear_pam_wrong);
/* Cancel the clear_indicator_timeout, it would hide the unlock indicator
* too early. */
STOP_TIMER(clear_indicator_timeout);
/* beep on authentication failure, if enabled */
if (beep) {
xcb_bell(conn, 100);
xcb_flush(conn);
}
}
static void warp_down(int lines)
{
while (lines-- > 0)
if (first_line->next != NULL)
first_line = first_line->next;
redraw_screen();
GP_BackendFlip(backend);
}
static void warp_up(int lines)
{
while (lines-- > 0)
if (first_line->prev != NULL)
first_line = first_line->prev;
redraw_screen();
GP_BackendFlip(backend);
}
bool handle_action(sf::Event event) {
short i;
location the_point;
bool to_return = false;
the_point = {event.mouseButton.x, event.mouseButton.y};
if(file_in_mem.empty())
return false;
for(i = 0; i < 6; i++)
if((the_point.in(pc_area_buttons[i][0])) &&
(univ.party[i].main_status != eMainStatus::ABSENT)) {
do_button_action(0,i);
current_active_pc = i;
redraw_screen();
}
for(i = 0; i < 5; i++)
if((the_point.in(edit_rect[i])) &&
(univ.party[current_active_pc].main_status != eMainStatus::ABSENT)) {
do_button_action(0,i + 10);
switch(i) {
case 0:
display_pc(current_active_pc,10,nullptr);
break;
case 1:
display_pc(current_active_pc,11,nullptr);
break;
case 2:
pick_race_abil(&univ.party[current_active_pc],0);
break;
case 3:
spend_xp(current_active_pc,2,nullptr);
break;
case 4:
edit_xp(&univ.party[current_active_pc]);
break;
}
}
for(i = 0; i < 24; i++)
if((the_point.in(item_string_rects[i][1])) && // drop item
univ.party[current_active_pc].items[i].variety != eItemType::NO_ITEM) {
flash_rect(item_string_rects[i][1]);
univ.party[current_active_pc].take_item(i);
}
for(i = 0; i < 24; i++)
if((the_point.in(item_string_rects[i][2])) && // identify item
univ.party[current_active_pc].items[i].variety != eItemType::NO_ITEM) {
flash_rect(item_string_rects[i][2]);
univ.party[current_active_pc].items[i].ident = true;
}
return to_return;
}
/*
* Resets pam_state to STATE_PAM_IDLE 2 seconds after an unsuccessful
* authentication event.
*
*/
static void clear_pam_wrong(EV_P_ ev_timer *w, int revents) {
DEBUG("clearing pam wrong\n");
pam_state = STATE_PAM_IDLE;
unlock_state = STATE_STARTED;
redraw_screen();
/* Now free this timeout. */
STOP_TIMER(clear_pam_wrong_timeout);
}
static void drawscreen (void) {
/* This is the screen redrawing routine that event_loop assumes exists. *
* It erases whatever is on screen, then calls redraw_screen to redraw *
* it. */
clearscreen();
redraw_screen ();
}
/* 游戏主循环。
* 在初始化工作结束后，main函数就跳转到主循环执行。
* 在主循环执行期间随时会插入异步的中断。时钟中断最终调用timer_event，
* 键盘中断最终调用keyboard_event。中断处理完成后将返回主循环原位置继续执行。
*
* tick是时钟中断中维护的信号，数值含义是“系统到当前时刻已经发生过的时钟中断数”
* HZ是时钟控制器硬件每秒产生的中断数，在include/device/timer.h中定义
* now是主循环已经正确处理的时钟中断数，即游戏已经处理到的物理时间点
*
* 由于qemu-kvm在访问内存映射IO区域时每次都会产生陷入，在30FPS时，
* 对显存区域每秒会产生30*320*200/4次陷入，从而消耗过多时间导致跳帧的产生(实际FPS<30)。
* 在CFLAGS中增加-DSLOW可以在此情况下提升FPS。如果FPS仍太小，可以尝试
* -DTOOSLOW，此时将会采用隔行扫描的方式更新屏幕(可能会降低显示效果)。
* 这些机制的实现在device/video.c中。
* */
void
main_loop(void) {
int now = 0, target;
int num_draw = 0;
bool redraw;
while (TRUE) {
wait_for_interrupt();
/*disable_interrupt();*/
if (now == tick) {
/*enable_interrupt();*/
continue;
}
assert(now < tick);
target = tick; /* now总是小于tick，因此我们需要“追赶”当前的时间 */
/*enable_interrupt();*/
redraw = FALSE;
while (update_keypress())
;
/* 依次模拟已经错过的时钟中断。一次主循环如果执行时间长，期间可能到来多次时钟中断，
* 从而主循环中维护的时钟可能与实际时钟相差较多。为了维持游戏的正常运行，必须补上
* 期间错过的每一帧游戏逻辑。 */
while (now < target) {
/* 每隔一定时间产生一个新的字符 */
if (now % (HZ / CHARACTER_PER_SECOND) == 0) {
create_new_letter();
}
/* 每隔一定时间更新屏幕上字符的位置 */
if (now % (HZ / UPDATE_PER_SECOND) == 0) {
update_letter_pos();
}
/* 每隔一定时间需要刷新屏幕。注意到这里实现了“跳帧”的机制：假设
* HZ = 1000, FPS = 100, now = 10, target = 1000
* 即我们要模拟990个时钟中断之间发生的事件，其中包含了9次屏幕更新，
* 但redraw flag只被置一次。 */
if (now % (HZ / FPS) == 0) {
redraw = TRUE;
}
/* 更新fps统计信息 */
if (now % (HZ / 2) == 0) {
int now_fps = num_draw * 2 + 1;
if (now_fps > FPS) now_fps = FPS;
set_fps(now_fps);
num_draw = 0;
}
now ++;
}
if (redraw) { /* 当需要重新绘图时重绘 */
num_draw ++;
redraw_screen();
}
}
}
/*
* Hides the unlock indicator completely when there is no content in the
* password buffer.
*
*/
static void clear_indicator(EV_P_ ev_timer *w, int revents) {
if (input_position == 0) {
unlock_state = STATE_STARTED;
} else unlock_state = STATE_KEY_PRESSED;
redraw_screen();
ev_timer_stop(main_loop, clear_indicator_timeout);
free(clear_indicator_timeout);
clear_indicator_timeout = NULL;
}
/*
* Resets pam_state to STATE_PAM_IDLE 2 seconds after an unsuccesful
* authentication event.
*
*/
static void clear_pam_wrong(EV_P_ ev_timer *w, int revents) {
DEBUG("clearing pam wrong\n");
pam_state = STATE_PAM_IDLE;
unlock_state = STATE_STARTED;
redraw_screen();
/* Now free this timeout. */
ev_timer_stop(main_loop, clear_pam_wrong_timeout);
free(clear_pam_wrong_timeout);
clear_pam_wrong_timeout = NULL;
}
void pause(short length) {
long len;
len = (long) length;
// Before pausing, make sure the screen is updated.
redraw_screen(REFRESH_NONE);
if(get_bool_pref("DrawTerrainFrills", true))
sf::sleep(time_in_ticks(len));
}
static void clear_input(void) {
input_position = 0;
clear_password_memory();
password[input_position] = '\0';
/* Hide the unlock indicator after a bit if the password buffer is
* empty. */
start_clear_indicator_timeout();
unlock_state = STATE_BACKSPACE_ACTIVE;
redraw_screen();
unlock_state = STATE_KEY_PRESSED;
}
/*
* Resets pam_state to STATE_PAM_IDLE 2 seconds after an unsuccessful
* authentication event.
*
*/
static void clear_pam_wrong(EV_P_ ev_timer *w, int revents) {
DEBUG("clearing pam wrong\n");
pam_state = STATE_PAM_IDLE;
redraw_screen();
/* Clear modifier string. */
if (modifier_string != NULL) {
free(modifier_string);
modifier_string = NULL;
}
/* Now free this timeout. */
STOP_TIMER(clear_pam_wrong_timeout);
}
// TODO: Pass the event object around instead of keeping a global one
void Mouse_Pressed() {
if(had_text_freeze > 0) {
had_text_freeze--;
return;
}
if(overall_mode != MODE_STARTUP) {
location mousePos(event.mouseButton.x, event.mouseButton.y);
volatile bool doneScrolling = false;
if(mousePos.in(text_sbar->getBounds())) {
mainPtr.setActive(false);
boost::thread updater(std::bind(handleUpdateWhileScrolling, std::ref(doneScrolling), REFRESH_TRANS));
text_sbar->handleClick(mousePos);
doneScrolling = true;
updater.join();
redraw_screen(REFRESH_TRANS);
} else if(mousePos.in(item_sbar->getBounds())) {
mainPtr.setActive(false);
boost::thread updater(std::bind(handleUpdateWhileScrolling, std::ref(doneScrolling), REFRESH_INVEN));
item_sbar->handleClick(mousePos);
doneScrolling = true;
updater.join();
redraw_screen(REFRESH_INVEN);
} else if(overall_mode == MODE_SHOPPING && mousePos.in(shop_sbar->getBounds())) {
mainPtr.setActive(false);
boost::thread updater(std::bind(handleUpdateWhileScrolling, std::ref(doneScrolling), REFRESH_DLOG));
shop_sbar->handleClick(mousePos);
doneScrolling = true;
updater.join();
redraw_screen(REFRESH_DLOG);
} else All_Done = handle_action(event);
} else All_Done = handle_startup_press({event.mouseButton.x, event.mouseButton.y});
menu_activate();
}
