// 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); } }