// Handle events from AFU
static void _handle_afu(struct psl *psl)
{
struct client *client;
uint64_t error;
uint8_t *buffer;
int reset_done;
size_t size;
reset_done = handle_aux2(psl->job, &(psl->parity_enabled),
&(psl->latency), &error);
if (error && !directed_mode_support(psl->mmio)) {
client = psl->client[0];
size = 1 + sizeof(uint64_t);
buffer = (uint8_t *) malloc(size);
buffer[0] = PSLSE_AFU_ERROR;
error = htonll(error);
memcpy((char *)&(buffer[1]), (char *)&error, sizeof(error));
if (put_bytes
(client->fd, size, buffer, psl->dbg_fp, psl->dbg_id,
0) < 0) {
client_drop(client, PSL_IDLE_CYCLES, CLIENT_NONE);
}
}
handle_mmio_ack(psl->mmio, psl->parity_enabled);
if (psl->cmd != NULL) {
if (reset_done)
psl->cmd->credits = psl->cmd->parms->credits;
handle_response(psl->cmd);
handle_buffer_write(psl->cmd);
handle_buffer_read(psl->cmd);
handle_buffer_data(psl->cmd, psl->parity_enabled);
handle_mem_write(psl->cmd);
handle_touch(psl->cmd);
handle_cmd(psl->cmd, psl->parity_enabled, psl->latency);
handle_interrupt(psl->cmd);
}
}
static void MCEventQueueDispatchEvent(MCEvent *p_event)
{
MCEvent *t_event;
t_event = p_event;
MCObject *t_menu;
t_menu = MCdispatcher -> getmenu();
switch(t_event -> type)
{
case kMCEventTypeNotify:
t_event -> notify . callback(t_event -> notify . state, true);
break;
case kMCEventTypeWindowReshape:
// IM-2014-02-14: [[ HiDPI ]] update view backing scale
t_event -> window . stack -> view_setbackingscale(t_event->window.scale);
t_event -> window . stack -> view_configure(true);
break;
case kMCEventTypeMouseFocus:
if (t_event -> mouse . focus . inside)
{
if (MCmousestackptr != t_event -> mouse . stack)
{
MCmousestackptr = t_event -> mouse . stack;
MCmousestackptr -> enter();
}
if (t_menu == nil)
MCmousestackptr -> mfocus(MCmousex, MCmousey);
else
t_menu -> mfocus(MCmousex, MCmousey);
}
else if (MCmousestackptr == t_event -> mouse . stack)
{
MCmousestackptr -> munfocus();
MCmousestackptr = nil;
}
break;
case kMCEventTypeMousePress:
if (MCmousestackptr == t_event -> mouse . stack || t_menu != nil)
{
if (t_event -> mouse . press . state == kMCMousePressStateDown)
MCbuttonstate |= (1 << t_event -> mouse . press . button);
else
MCbuttonstate &= ~(1 << t_event -> mouse . press . button);
if (t_event -> mouse . press . state == kMCMousePressStateDown)
{
if (t_event -> mouse . time - s_click_time < MCdoubletime &&
MCU_abs(MCclicklocx - MCmousex) < MCdoubledelta &&
MCU_abs(MCclicklocy - MCmousey) < MCdoubledelta)
s_click_count += 1;
else
s_click_count = 0;
}
else
s_click_time = t_event -> mouse . time;
MCeventtime = t_event -> mouse . time;
MCmodifierstate = t_event -> mouse . press . modifiers;
MCclicklocx = MCmousex;
MCclicklocy = MCmousey;
MCclickstackptr = MCmousestackptr;
MCObject *t_target;
t_target = t_menu != nil ? t_menu : MCclickstackptr;
if (t_event -> mouse . press . state == kMCMousePressStateDown)
{
tripleclick = s_click_count == 2;
if (s_click_count != 1)
t_target -> mdown(t_event -> mouse . press . button + 1);
else
t_target -> doubledown(t_event -> mouse . press . button + 1);
}
else if (t_event -> mouse . press . state == kMCMousePressStateUp)
{
if (s_click_count != 1)
t_target -> mup(t_event -> mouse . press . button + 1);
else
t_target -> doubleup(t_event -> mouse . press . button + 1);
}
else
{
s_click_count = 0;
tripleclick = False;
// If the press was 'released' i.e. cancelled then we stop messages, mup then
// dispatch a mouseRelease message ourselves.
// FG-2013-10-09 [[ Bugfix 11208 ]]
// CS_NO_MESSAGES only applies to the target and not the controls it contains
// so the mouse up message (on mouseUp) sets sent when it isn't desired
// Hopefully nobody depends on the old behaviour...
//t_target -> setstate(True, CS_NO_MESSAGES);
//t_target -> mup(t_event -> mouse . press . button + 1);
//t_target -> setstate(False, CS_NO_MESSAGES);
bool old_lock = MClockmessages;
MClockmessages = true;
t_target -> mup(t_event -> mouse . press . button + 1);
MClockmessages = old_lock;
t_target -> message_with_args(MCM_mouse_release, t_event -> mouse . press . button + 1);
}
}
break;
case kMCEventTypeMouseWheel:
// Notice that we recompute mfocused twice - this is because calling the key handler
// could invalidate mfocused in between.
if (MCmousestackptr == t_event -> mouse . stack)
{
MCObject *mfocused;
mfocused = MCmousestackptr->getcard()->getmfocused();
if (mfocused == NULL)
mfocused = MCmousestackptr -> getcard();
if (mfocused == NULL)
mfocused = MCmousestackptr;
MCeventtime = t_event -> mouse . time;
MCmodifierstate = t_event -> mouse . wheel . modifiers;
if (t_event -> mouse . wheel . dv != 0)
mfocused -> kdown("", t_event -> mouse . wheel . dv < 0 ? XK_WheelUp : XK_WheelDown);
mfocused = MCmousestackptr->getcard()->getmfocused();
if (mfocused == NULL)
mfocused = MCmousestackptr -> getcard();
if (mfocused == NULL)
mfocused = MCmousestackptr;
if (t_event -> mouse . wheel . dh != 0)
mfocused -> kdown("", t_event -> mouse . wheel . dh < 0 ? XK_WheelLeft : XK_WheelRight);
}
break;
case kMCEventTypeMousePosition:
if (MCmousestackptr == t_event -> mouse . stack || t_menu != nil)
{
MCeventtime = t_event -> mouse . time;
MCmodifierstate = t_event -> mouse . position . modifiers;
MCObject *t_target;
t_target = t_menu != nil ? t_menu : MCmousestackptr;
// IM-2013-09-30: [[ FullscreenMode ]] Translate mouse location to stack coords
MCPoint t_mouseloc;
t_mouseloc = MCPointMake(t_event->mouse.position.x, t_event->mouse.position.y);
// IM-2013-10-03: [[ FullscreenMode ]] Transform mouseloc based on the mousestack
t_mouseloc = MCmousestackptr->view_viewtostackloc(t_mouseloc);
MCmousex = t_mouseloc.x;
MCmousey = t_mouseloc.y;
t_target -> mfocus(t_mouseloc . x, t_mouseloc . y);
}
break;
case kMCEventTypeKeyFocus:
if (t_event -> key . focus . owner)
t_event -> key . stack -> kfocus();
else
t_event -> key . stack -> kunfocus();
break;
case kMCEventTypeKeyPress:
{
MCObject *t_target;
t_target = t_menu != nil ? t_menu : t_event -> key . stack;
MCmodifierstate = t_event -> key . press . modifiers;
// If 'char_code' is 0, then this key press has not generated a
// character.
if (t_event -> key . press . char_code == 0)
{
t_target -> kdown(MCnullstring, t_event -> key . press . key_code);
t_target -> kup(MCnullstring, t_event -> key . press . key_code);
break;
}
// Otherwise 'char_code' is the unicode codepoint, so first map to
// UTF-16 (not done properly yet...)
uint2 t_unichar;
t_unichar = (uint2)t_event -> key . press . char_code;
// If we successfully map to native, then we can dispatch as a normal kdown
uint1 t_char;
if (MCUnicodeMapToNative(&t_unichar, 1, t_char))
{
char t_buffer[2];
t_buffer[0] = t_char;
t_buffer[1] = '\0';
t_target -> kdown(t_buffer, t_event -> key . press . key_code);
t_target -> kup(t_buffer, t_event -> key . press . key_code);
break;
}
// Otherwise we dispatch in a unicode way...
if (!t_target -> kdown(MCnullstring, t_event -> key . press . key_code))
if (MCactivefield != nil)
{
MCString t_unibuffer;
t_unibuffer . set((char *)&t_unichar, 2);
// MW-2012-02-13: [[ Block Unicode ]] Use the new 'finsert' method in
// unicode mode.
MCactivefield -> finsertnew(FT_IMEINSERT, t_unibuffer, LCH_UNICODE, true);
}
t_target -> kup(MCnullstring, t_event -> key . press . key_code);
}
break;
case kMCEventTypeImeCompose:
{
if (!MCactivefield)
break;
if (t_event -> ime . compose . enabled)
MCactivefield -> startcomposition();
else
MCactivefield -> stopcomposition(True, False);
MCactivefield -> setcompositioncursoroffset(t_event -> ime . compose . offset * 2);
MCString t_unichars;
t_unichars . set((const char *)t_event -> ime . compose . chars, t_event -> ime . compose . char_count * sizeof(uint16_t));
// MW-2012-02-13: [[ Block Unicode ]] Use the new 'finsert' method in
// unicode mode.
MCactivefield -> finsertnew(FT_IMEINSERT, t_unichars, LCH_UNICODE, true);
if (t_event -> ime . compose . enabled)
{
MCRectangle r;
MCactivefield -> getcompositionrect(r, -1);
MCModeConfigureIme(MCactivefield -> getstack(), true, r . x, r . y + r . height);
}
}
break;
#ifdef _MOBILE
case kMCEventTypeTouch:
handle_touch(t_event -> touch . stack, t_event -> touch . phase, t_event -> touch . id, t_event -> touch . taps, t_event -> touch . x, t_event -> touch . y);
break;
case kMCEventTypeMotion:
{
MCNameRef t_message;
const char *t_motion;
switch(t_event -> motion . type)
{
case kMCEventMotionShakeBegan:
t_motion = "shake";
t_message = MCM_motion_start;
break;
case kMCEventMotionShakeEnded:
t_motion = "shake";
t_message = MCM_motion_end;
break;
case kMCEventMotionShakeCancelled:
t_motion = "shake";
t_message = MCM_motion_release;
break;
}
MCdefaultstackptr -> getcurcard() -> message_with_args(t_message, t_motion);
}
break;
case kMCEventTypeAcceleration:
{
char t_value[64 * 4 + 4];
sprintf(t_value, "%.6f,%.6f,%.6f,%f", t_event -> acceleration . x, t_event -> acceleration . y, t_event -> acceleration . z, t_event -> acceleration . t);
MCdefaultstackptr -> getcurcard() -> message_with_args(MCM_acceleration_changed, t_value);
}
break;
case kMCEventTypeOrientation:
MCdefaultstackptr -> getcurcard() -> message(MCM_orientation_changed);
break;
case kMCEventTypeLocation:
MCdefaultstackptr -> getcurcard() -> message(t_event -> location . error == nil ? MCM_location_changed : MCM_location_error);
break;
case kMCEventTypeHeading:
MCdefaultstackptr -> getcurcard() -> message(t_event -> location . error == nil ? MCM_heading_changed : MCM_heading_error);
break;
case kMCEventTypeCustom:
t_event -> custom . event -> Dispatch();
break;
#endif
}
}
int wikilib_run(void)
{
int sleep;
long time_now;
struct wl_input_event ev;
int more_events = 0;
unsigned long last_event_time = 0;
int rc;
/*
* test searching code...
*/
article_buf_pointer = NULL;
search_init();
history_list_init();
malloc_status_simple();
print_intro();
#ifndef INCLUDED_FROM_KERNEL
if (!load_init_article(idx_init_article))
{
display_mode = DISPLAY_MODE_ARTICLE;
last_display_mode = DISPLAY_MODE_INDEX;
}
#endif
render_string(SUBTITLE_FONT_IDX, -1, 55, MESSAGE_TYPE_A_WORD, strlen(MESSAGE_TYPE_A_WORD), 0);
for (;;) {
if (more_events)
sleep = 0;
else
sleep = 1;
if (!more_events && display_mode == DISPLAY_MODE_ARTICLE && render_article_with_pcf())
sleep = 0;
else if (!more_events && display_mode == DISPLAY_MODE_INDEX && render_search_result_with_pcf())
sleep = 0;
else if (!more_events && display_mode == DISPLAY_MODE_HISTORY && render_history_with_pcf())
sleep = 0;
if (finger_move_speed != 0)
{
scroll_article();
sleep = 0;
}
#ifdef INCLUDED_FROM_KERNEL
time_now = get_time_ticks();
if(display_mode == DISPLAY_MODE_INDEX)
{
if (press_delete_button && get_search_string_len()>0)
{
sleep = 0;
if(time_diff(time_now, start_search_time) > seconds_to_ticks(3.5))
{
if (!clear_search_string())
{
search_string_changed_remove = true;
search_reload_ex(SEARCH_RELOAD_NORMAL);
}
press_delete_button = false;
}
else if (time_diff(time_now, start_search_time) > seconds_to_ticks(0.5) &&
time_diff(time_now, last_delete_time) > seconds_to_ticks(0.25))
{
if (!search_remove_char(0))
{
search_string_changed_remove = true;
search_reload_ex(SEARCH_RELOAD_NO_POPULATE);
}
last_delete_time = time_now;
}
}
}
else if (display_mode == DISPLAY_MODE_RESTRICTED)
{
if (press_delete_button && get_password_string_len()>0)
{
sleep = 0;
time_now = get_time_ticks();
if(time_diff(time_now, start_search_time) > seconds_to_ticks(3.5))
{
clear_password_string();
press_delete_button = false;
}
else if (time_diff(time_now, start_search_time) > seconds_to_ticks(0.5) &&
time_diff(time_now, last_delete_time) > seconds_to_ticks(0.25))
{
password_remove_char();
last_delete_time = time_now;
}
}
}
#endif
if (!more_events && display_mode == DISPLAY_MODE_INDEX && fetch_search_result(0, 0, 0))
{
sleep = 0;
}
if (keyboard_key_reset_invert(KEYBOARD_RESET_INVERT_CHECK)) // check if need to reset invert
sleep = 0;
if (check_invert_link()) // check if need to invert link
sleep = 0;
if (sleep)
{
if (time_diff(get_time_ticks(), last_event_time) > seconds_to_ticks(15))
rc = history_list_save(HISTORY_SAVE_POWER_OFF);
else
rc = history_list_save(HISTORY_SAVE_NORMAL);
if (rc > 0)
{
#ifdef INCLUDED_FROM_KERNEL
delay_us(200000); // for some reason, save may not work if no delay
#endif
}
else if (rc < 0)
sleep = 0; // waiting for last_event_time timeout to save the history
}
wl_input_wait(&ev, sleep);
more_events = 1;
switch (ev.type) {
case WL_INPUT_EV_TYPE_CURSOR:
handle_cursor(&ev);
last_event_time = get_time_ticks();
break;
case WL_INPUT_EV_TYPE_KEYBOARD:
if (ev.key_event.value != 0)
{
b_show_scroll_bar = 0;
handle_key_release(ev.key_event.keycode);
}
last_event_time = get_time_ticks();
break;
case WL_INPUT_EV_TYPE_TOUCH:
handle_touch(&ev);
last_event_time = ev.touch_event.ticks;
break;
default:
more_events = 0;
break;
}
}
/* never reached */
return 0;
}
// Handle events from AFU
static void _handle_afu(struct psl *psl)
{
struct client *client;
uint64_t error;
uint8_t *buffer;
int reset_done;
int i;
size_t size;
reset_done = _handle_aux2(psl, &(psl->parity_enabled),
&(psl->latency), &error);
//printf("after reset_done in handle_afu \n");
if (error) {
if (dedicated_mode_support(psl->mmio)) {
client = psl->client[0];
size = 1 + sizeof(uint64_t);
buffer = (uint8_t *) malloc(size);
buffer[0] = PSLSE_AFU_ERROR;
error = htonll(error);
memcpy((char *)&(buffer[1]), (char *)&error, sizeof(error));
warn_msg("%s: Received JERROR: 0x%016"PRIx64" in afu-dedicated mode", psl->name, error);
if (put_bytes
(client->fd, size, buffer, psl->dbg_fp, psl->dbg_id,
0) < 0) {
client_drop(client, PSL_IDLE_CYCLES, CLIENT_NONE);
}
}
if (directed_mode_support(psl->mmio)) {
// afu error gets logged by OS. - print warning message
// no interrupt/event is sent up to the application - don't "put_bytes" back to client(s)
// all clients lose connection to afu but how is this observered by the client?
warn_msg("%s: Received JERROR: 0x%016"PRIx64" in afu-directed mode", psl->name, error);
for (i = 0; i < psl->max_clients; i++) {
if (psl->client[i] == NULL)
continue;
client_drop(psl->client[i], PSL_IDLE_CYCLES, CLIENT_NONE);
}
}
}
handle_mmio_ack(psl->mmio, psl->parity_enabled);
if (psl->cmd != NULL) {
if (reset_done)
psl->cmd->credits = psl->cmd->parms->credits;
#if defined PSL9lite || defined PSL9
handle_caia2_cmds(psl->cmd);
#endif /* ifdef PSL9 or PSL9lite */
#ifdef PSL9
handle_dma0_port(psl->cmd);
handle_dma0_write(psl->cmd);
handle_dma0_sent_sts(psl->cmd);
handle_dma0_read(psl->cmd);
#endif /* ifdef PSL9 */
handle_response(psl->cmd);
handle_buffer_write(psl->cmd);
handle_buffer_read(psl->cmd);
handle_buffer_data(psl->cmd, psl->parity_enabled);
handle_mem_write(psl->cmd);
handle_touch(psl->cmd);
handle_cmd(psl->cmd, psl->parity_enabled, psl->latency);
handle_interrupt(psl->cmd);
}
}
