int GLUI_EditText::mouse_held_down_handler( int local_x, int local_y,
bool new_inside)
{
int tmp_pt;
if ( NOT new_inside )
return false;
if ( debug ) dump( stdout, "-> HELD DOWN" );
tmp_pt = find_insertion_pt( local_x, local_y );
if ( tmp_pt == -1 AND sel_end != 0 ) { /* moved mouse past left edge */
special_handler( GLUT_KEY_LEFT, GLUT_ACTIVE_SHIFT );
}
else if ( tmp_pt == substring_end+1 AND sel_end != (int) text.length()) {
/* moved mouse past right edge */
special_handler( GLUT_KEY_RIGHT, GLUT_ACTIVE_SHIFT );
}
else if ( tmp_pt != -1 AND tmp_pt != sel_end ) {
sel_end = insertion_pt = tmp_pt;
update_and_draw_text();
}
if ( debug )
dump( stdout, "<- HELD DOWN" );
return false;
}
void
Timer::remove_some_handlers()
{
// The reactor may not get around to callbacks on deletion until the test
// is over.
ACE_Reactor_Mask mask =
ACE_Event_Handler::ALL_EVENTS_MASK | ACE_Event_Handler::DONT_CALL;
for (int i = 0; i != nhandlers; ++i)
{
if (-1 == reactor()->remove_handler(&handler_[i], mask))
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("Cannot remove handler %d in %p\n"),
i,
ACE_TEXT ("timeout")));
}
}
if (-1 == reactor()->register_handler(&special_handler(),
ACE_Event_Handler::ALL_EVENTS_MASK))
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("Cannot add back special handler in %p\n"),
ACE_TEXT ("timeout")));
}
}
int
Timer::handle_timeout(ACE_Time_Value const &, void const *)
{
if (iteration_ == 0)
{
send_data_through_handlers();
}
++iteration_;
if (iteration_ < initial_iterations)
{
return 0;
}
if (iteration_ == initial_iterations)
{
remove_some_handlers();
recorded_count_ = special_handler().handle_input_count();
return 0;
}
if (iteration_ < total_iterations)
{
return 0;
}
reactor()->end_reactor_event_loop();
return 0;
}
bool Timer::check_expected_results() const
{
// We expect at least one more call after the other handlers are removed.
if(recorded_count_ + 1 < special_handler().handle_input_count() )
{
return true;
}
return false;
}
int Timer::handle_timeout(ACE_Time_Value const &, void const *)
{
if (iteration_ == 0)
{
// Sending data on the first iteration makes the handles always
// "ready" for reading because the Handler::handle_input() function
// never consumes the data.
send_data_through_handlers();
}
++iteration_;
if (iteration_ < initial_iterations)
{
// The first iterations are there just to prime things.
return 0;
}
if (iteration_ == initial_iterations)
{
// We expect the special_handler() to work normally after this
// iteration, i.e., more calls to handle_input() should be delivered
// to it.
recorded_count_ = special_handler().handle_input_count();
// Remove the handlers the next time the loop runs
remove_some_handlers();
// Run the event loop, this causes the handlers to be removed from the
// reactor, except for special_handler()
ACE_Time_Value interval(0, ACE_ONE_SECOND_IN_USECS / 50);
reactor()->handle_events(&interval);
return 0;
}
if (iteration_ < total_iterations)
{
// Run a while more to make sure the special_handler() is used.
return 0;
}
reactor()->end_reactor_event_loop();
return 0;
}
/*
* Called at splsched.
*/
void
ast_taken(
ast_t reasons,
boolean_t enable
)
{
boolean_t preempt_trap = (reasons == AST_PREEMPTION);
ast_t *myast = ast_pending();
thread_t thread = current_thread();
perfASTCallback perf_hook = perfASTHook;
/*
* CHUD hook - all threads including idle processor threads
*/
if (perf_hook) {
if (*myast & AST_CHUD_ALL) {
(*perf_hook)(reasons, myast);
if (*myast == AST_NONE)
return;
}
}
else
*myast &= ~AST_CHUD_ALL;
reasons &= *myast;
*myast &= ~reasons;
/*
* Handle ASTs for all threads
* except idle processor threads.
*/
if (!(thread->state & TH_IDLE)) {
/*
* Check for urgent preemption.
*/
if ( (reasons & AST_URGENT) &&
waitq_wait_possible(thread) ) {
if (reasons & AST_PREEMPT) {
counter(c_ast_taken_block++);
thread_block_reason(THREAD_CONTINUE_NULL, NULL,
reasons & AST_PREEMPTION);
}
reasons &= ~AST_PREEMPTION;
}
/*
* The kernel preempt traps
* skip all other ASTs.
*/
if (!preempt_trap) {
ml_set_interrupts_enabled(enable);
#ifdef MACH_BSD
/*
* Handle BSD hook.
*/
if (reasons & AST_BSD) {
thread_ast_clear(thread, AST_BSD);
bsd_ast(thread);
}
#endif
#if CONFIG_MACF
/*
* Handle MACF hook.
*/
if (reasons & AST_MACF) {
thread_ast_clear(thread, AST_MACF);
mac_thread_userret(thread);
}
#endif
/*
* Thread APC hook.
*/
if (reasons & AST_APC) {
thread_ast_clear(thread, AST_APC);
special_handler(thread);
}
if (reasons & AST_GUARD) {
thread_ast_clear(thread, AST_GUARD);
guard_ast(thread);
}
if (reasons & AST_LEDGER) {
thread_ast_clear(thread, AST_LEDGER);
ledger_ast(thread);
}
/*
* Kernel Profiling Hook
*/
if (reasons & AST_KPERF) {
thread_ast_clear(thread, AST_KPERF);
chudxnu_thread_ast(thread);
}
#if CONFIG_TELEMETRY
if (reasons & AST_TELEMETRY_ALL) {
boolean_t interrupted_userspace = FALSE;
boolean_t is_windowed = FALSE;
assert((reasons & AST_TELEMETRY_ALL) != AST_TELEMETRY_ALL); /* only one is valid at a time */
interrupted_userspace = (reasons & AST_TELEMETRY_USER) ? TRUE : FALSE;
is_windowed = ((reasons & AST_TELEMETRY_WINDOWED) ? TRUE : FALSE);
thread_ast_clear(thread, AST_TELEMETRY_ALL);
telemetry_ast(thread, interrupted_userspace, is_windowed);
}
#endif
ml_set_interrupts_enabled(FALSE);
#if CONFIG_SCHED_SFI
if (reasons & AST_SFI) {
sfi_ast(thread);
}
#endif
/*
* Check for preemption. Conditions may have changed from when the AST_PREEMPT was originally set.
*/
thread_lock(thread);
if (reasons & AST_PREEMPT)
reasons = csw_check(current_processor(), reasons & AST_QUANTUM);
thread_unlock(thread);
assert(waitq_wait_possible(thread));
if (reasons & AST_PREEMPT) {
counter(c_ast_taken_block++);
thread_block_reason((thread_continue_t)thread_exception_return, NULL, reasons & AST_PREEMPTION);
}
}
}
ml_set_interrupts_enabled(enable);
}
int GLUI_EditText::key_handler( unsigned char key,int modifiers )
{
int i, regular_key;
/* int has_selection; */
if ( NOT glui )
return false;
if ( debug )
dump( stdout, "-> KEY HANDLER" );
regular_key = false;
bool ctrl_down = (modifiers & GLUT_ACTIVE_CTRL)!=0;
/* has_selection = (sel_start != sel_end); */
if ( key == CTRL('m') ) { /* RETURN */
/* glui->deactivate_current_control(); */
deactivate(); /** Force callbacks, etc **/
activate(GLUI_ACTIVATE_TAB); /** Reselect all text **/
redraw();
return true;
}
else if ( key == CTRL('[')) { /* ESCAPE */
glui->deactivate_current_control();
return true;
}
else if ( (key == 127 AND !ctrl_down) OR /* FORWARD DELETE */
( key == CTRL('d') AND modifiers == GLUT_ACTIVE_CTRL) )
{
if ( sel_start == sel_end ) { /* no selection */
if ( insertion_pt < (int)text.length() ) {
/*** See if we're deleting a period in a float data-type box ***/
if ( ((data_type == GLUI_EDITTEXT_FLOAT) OR (data_type == GLUI_EDITTEXT_DOUBLE)) AND text[insertion_pt]=='.' )
num_periods--;
/*** Shift over string first ***/
text.erase(insertion_pt,1);
}
}
else { /* There is a selection */
clear_substring( MIN(sel_start,sel_end), MAX(sel_start,sel_end ));
insertion_pt = MIN(sel_start,sel_end);
sel_start = sel_end = insertion_pt;
}
}
else if ( ((key == 127) AND ctrl_down) OR // Delete word forward
((key == 'd') AND (modifiers == GLUT_ACTIVE_ALT)) )
{
if ( sel_start == sel_end ) { /* no selection */
sel_start = insertion_pt;
sel_end = find_word_break( insertion_pt, +1 );
}
clear_substring( MIN(sel_start,sel_end), MAX(sel_start,sel_end ));
insertion_pt = MIN(sel_start,sel_end);
sel_start = sel_end = insertion_pt;
}
else if ( key == CTRL('h') ) { /* BACKSPACE */
if ( sel_start == sel_end ) { /* no selection */
if ( insertion_pt > 0 ) {
/*** See if we're deleting a period in a float data-type box ***/
if ( ((data_type == GLUI_EDITTEXT_FLOAT) OR (data_type == GLUI_EDITTEXT_DOUBLE)) AND text[insertion_pt-1]=='.' )
num_periods--;
/*** Shift over string first ***/
insertion_pt--;
text.erase(insertion_pt,1);
}
}
else { /* There is a selection */
clear_substring( MIN(sel_start,sel_end), MAX(sel_start,sel_end ));
insertion_pt = MIN(sel_start,sel_end);
sel_start = sel_end = insertion_pt;
}
}
else if ( modifiers == GLUT_ACTIVE_CTRL ) /* CTRL ONLY */
{
/* Ctrl-key bindings */
if ( key == CTRL('a') ) {
return special_handler( GLUT_KEY_HOME, 0 );
}
else if ( key == CTRL('e') ) {
return special_handler( GLUT_KEY_END, 0 );
}
else if ( key == CTRL('b') ) {
return special_handler( GLUT_KEY_LEFT, 0 );
}
else if ( key == CTRL('f') ) {
return special_handler( GLUT_KEY_RIGHT, 0 );
}
else if ( key == CTRL('p') ) {
return special_handler( GLUT_KEY_UP, 0 );
}
else if ( key == CTRL('n') ) {
return special_handler( GLUT_KEY_DOWN, 0 );
}
else if ( key == CTRL('u') ) { /* ERASE LINE */
insertion_pt = 0;
text.erase(0,text.length());
sel_start = sel_end = 0;
}
else if ( key == CTRL('k') ) { /* KILL TO END OF LINE */
sel_start = sel_end = insertion_pt;
text.erase(insertion_pt,GLUI_String::npos);
}
}
else if ( modifiers == GLUT_ACTIVE_ALT ) /* ALT ONLY */
{
if ( key == 'b' ) { // Backward word
return special_handler ( GLUT_KEY_LEFT, GLUT_ACTIVE_CTRL );
}
if ( key == 'f' ) { // Forward word
return special_handler ( GLUT_KEY_RIGHT, GLUT_ACTIVE_CTRL );
}
}
else if ( (modifiers & GLUT_ACTIVE_CTRL) OR
(modifiers & GLUT_ACTIVE_ALT) )
{
/** ignore other keys with modifiers */
return true;
}
else { /* Regular key */
regular_key = true;
/** Check if we only accept numbers **/
if ((data_type == GLUI_EDITTEXT_FLOAT ) OR (data_type == GLUI_EDITTEXT_DOUBLE)) {
if ( (key < '0' OR key > '9') AND key != '.' AND key != '-' )
return true;
if ( key == '-' ) { /* User typed a '-' */
/* If user has first character selected, then '-' is allowed */
if ( NOT ( MIN(sel_start,sel_end) == 0 AND
MAX(sel_start,sel_end) > 0 ) ) {
/* User does not have 1st char selected */
if (insertion_pt != 0 OR text[0] == '-' ) {
return true; /* Can only place negative at beginning of text,
and only one of them */
}
}
}
if ( key == '.' ) {
/*printf( "PERIOD: %d\n", num_periods ); */
if ( num_periods > 0 ) {
/** We're trying to type a period, but the text already contains
a period. Check whether the period is contained within
is current selection (thus it will be safely replaced) **/
int period_found = false;
if ( sel_start != sel_end ) {
for( i=MIN(sel_end,sel_start); i<MAX(sel_start,sel_end); i++ ) {
/* printf( "%c ", text[i] ); */
if ( text[i] == '.' ) {
period_found = true;
break;
}
}
}
/* printf( "found: %d num: %d\n", period_found, num_periods ); */
if ( NOT period_found )
return true;
}
}
}
else if (data_type == GLUI_EDITTEXT_INT)
{
if ( (key < '0' OR key > '9') AND key != '-' )
return true;
if ( key == '-' ) { /* User typed a '-' */
/* If user has first character selected, then '-' is allowed */
if ( NOT ( MIN(sel_start,sel_end) == 0 AND
MAX(sel_start,sel_end) > 0 ) ) {
/* User does not have 1st char selected */
if (insertion_pt != 0 OR text[0] == '-' ) {
return true; /* Can only place negative at beginning of text,
and only one of them */
}
}
}
}
/** This is just to get rid of warnings - the flag regular_key is
set if the key was not a backspace, return, whatever. But I
believe if we're here, we know it was a regular key anyway */
if ( regular_key ) {
}
/**** If there's a current selection, erase it ******/
if ( sel_start != sel_end ) {
clear_substring( MIN(sel_start,sel_end), MAX(sel_start,sel_end ));
insertion_pt = MIN(sel_start,sel_end);
sel_start = sel_end = insertion_pt;
}
/******** We insert the character into the string ***/
text.insert(insertion_pt,1,key);
/******** Move the insertion point and substring_end one over ******/
insertion_pt++;
substring_end++;
sel_start = sel_end = insertion_pt;
}
/******** Now redraw text ***********/
/* Hack to prevent text box from being cleared first **/
/** int substring_change = update_substring_bounds();
draw_text_only =
(NOT substring_change AND NOT has_selection AND regular_key );
*/
draw_text_only = false; /** Well, hack is not yet working **/
update_and_draw_text();
draw_text_only = false;
if ( debug )
dump( stdout, "<- KEY HANDLER" );
/*** Now look to see if this string has a period ***/
num_periods = 0;
for( i=0; i<(int)text.length(); i++ )
if ( text[i] == '.' )
num_periods++;
return true;
}
/****************************** GLUI_TextBox::key_handler() **********/
int GLUI_TextBox::key_handler( unsigned char key,int modifiers )
{
/* int has_selection; */
if ( NOT glui )
return false;
if ( debug )
dump( stdout, "-> KEY HANDLER" );
bool ctrl_down = (modifiers & GLUT_ACTIVE_CTRL)!=0;
/* has_selection = (sel_start != sel_end); */
if ( key == CTRL('[')) { /* ESCAPE */
glui->deactivate_current_control();
return true;
}
else if ( (key == 127 AND !ctrl_down) OR /* FORWARD DELETE */
( key == CTRL('d') AND modifiers == GLUT_ACTIVE_CTRL) )
{
if ( sel_start == sel_end ) { /* no selection */
if ( insertion_pt < (int)text.length() ) {
text.erase(insertion_pt,1);
}
}
else { /* There is a selection */
clear_substring( MIN(sel_start,sel_end), MAX(sel_start,sel_end ));
insertion_pt = MIN(sel_start,sel_end);
sel_start = sel_end = insertion_pt;
}
}
else if ( ((key == 127) AND ctrl_down) OR // Delete word forward
((key == 'd') AND (modifiers == GLUT_ACTIVE_ALT)) )
{
if ( sel_start == sel_end ) { /* no selection */
sel_start = insertion_pt;
sel_end = find_word_break( insertion_pt, +1 );
}
clear_substring( MIN(sel_start,sel_end), MAX(sel_start,sel_end ));
insertion_pt = MIN(sel_start,sel_end);
sel_start = sel_end = insertion_pt;
}
else if ( key == CTRL('h') ) { /* BACKSPACE */
if ( sel_start == sel_end ) { /* no selection */
if ( insertion_pt > 0 ) {
insertion_pt--;
text.erase(insertion_pt,1);
}
}
else { /* There is a selection */
clear_substring( MIN(sel_start,sel_end), MAX(sel_start,sel_end ));
insertion_pt = MIN(sel_start,sel_end);
sel_start = sel_end = insertion_pt;
}
}
else if ( modifiers == GLUT_ACTIVE_CTRL ) /* CTRL ONLY */
{
/* Ctrl-key bindings */
if ( key == CTRL('a') ) {
return special_handler( GLUT_KEY_HOME, 0 );
}
else if ( key == CTRL('e') ) {
return special_handler( GLUT_KEY_END, 0 );
}
else if ( key == CTRL('b') ) {
return special_handler( GLUT_KEY_LEFT, 0 );
}
else if ( key == CTRL('f') ) {
return special_handler( GLUT_KEY_RIGHT, 0 );
}
else if ( key == CTRL('p') ) {
return special_handler( GLUT_KEY_UP, 0 );
}
else if ( key == CTRL('n') ) {
return special_handler( GLUT_KEY_DOWN, 0 );
}
else if ( key == CTRL('u') ) { /* ERASE LINE */
insertion_pt = 0;
text.erase(0,text.length());
sel_start = sel_end = 0;
}
else if ( key == CTRL('k') ) { /* KILL TO END OF LINE */
sel_start = sel_end = insertion_pt;
text.erase(insertion_pt,GLUI_String::npos);
}
}
else if ( modifiers == GLUT_ACTIVE_ALT ) /* ALT ONLY */
{
if ( key == 'b' ) { // Backward word
return special_handler ( GLUT_KEY_LEFT, GLUT_ACTIVE_CTRL );
}
if ( key == 'f' ) { // Forward word
return special_handler ( GLUT_KEY_RIGHT, GLUT_ACTIVE_CTRL );
}
}
else if ( (modifiers & GLUT_ACTIVE_CTRL) OR
(modifiers & GLUT_ACTIVE_ALT) )
{
/** ignore other keys with modifiers */
return true;
}
else { /* Regular key */
if ( key == 13 ) /* RETURNS are written as newlines*/
key = '\n';
/**** If there's a current selection, erase it ******/
if ( sel_start != sel_end ) {
clear_substring( MIN(sel_start,sel_end), MAX(sel_start,sel_end ));
insertion_pt = MIN(sel_start,sel_end);
sel_start = sel_end = insertion_pt;
}
/******** We insert the character into the string ***/
text.insert(insertion_pt,1,key);
/******** Move the insertion point and substring_end one over ******/
insertion_pt++;
substring_end++;
sel_start = sel_end = insertion_pt;
}
/******** Now redraw text ***********/
/* Hack to prevent text box from being cleared first **/
/** int substring_change = update_substring_bounds();
draw_text_only =
(NOT substring_change AND NOT has_selection AND regular_key );
*/
draw_text_only = false; /** Well, hack is not yet working **/
update_and_draw_text();
draw_text_only = false;
if ( debug )
dump( stdout, "<- KEY HANDLER" );
return true;
}
