Esempio n. 1
0
File: psl.c Progetto: open-cpu/pslse
// 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);
	}
}
Esempio n. 2
0
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
	}
}
Esempio n. 3
0
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;
}
Esempio n. 4
0
File: psl.c Progetto: ibm-capi/pslse
// 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);

	}
}