static DC_ClientEvent *handle_special_msg(const char *message)
{
if (!strncmp(message, DC_MSG_CANCEL, strlen(DC_MSG_CANCEL)) &&
message[strlen(DC_MSG_CANCEL)] == ':')
{
if (strcmp(message + strlen(DC_MSG_CANCEL) + 1, wu_name))
{
DC_log(LOG_WARNING, "Received CANCEL message for "
"unknown WU %s",
message + strlen(DC_MSG_CANCEL) + 1);
return NULL;
}
DC_log(LOG_NOTICE, "Received cancel request from the master");
client_state = STATE_FINISH;
return new_event(DC_CLIENT_FINISH);
}
if (!strcmp(message, DC_MSG_SUSPEND))
{
DC_log(LOG_NOTICE, "Received suspend request from the master");
client_state = STATE_SUSPEND;
return new_event(DC_CLIENT_CHECKPOINT);
}
DC_log(LOG_WARNING, "Received unknown control message %s", message);
return NULL;
}
void
fill_ev_table(char *input) {
char *str1, *str2, *str3, *str4,
*token, *subtoken, *kommatoken, *dptoken;
char *saveptr1=NULL,
*saveptr2=NULL,
*saveptr3=NULL,
*saveptr4=NULL;
int j, i=0, k=0;
long eid=0;
handlerf *ah=0;
for (j = 1, str1 = input; ; j++, str1 = NULL) {
token = strtok_r(str1, ";", &saveptr1);
if (token == NULL)
break;
for (str2 = token; ; str2 = NULL) {
subtoken = strtok_r(str2, "=", &saveptr2);
if (subtoken == NULL)
break;
if( (str2 == token) && ((eid = get_ev_id(subtoken)) != -1))
;
else if(eid == -1)
break;
for (str3 = subtoken; ; str3 = NULL) {
kommatoken = strtok_r(str3, ",", &saveptr3);
if (kommatoken == NULL)
break;
for (str4 = kommatoken; ; str4 = NULL) {
dptoken = strtok_r(str4, ":", &saveptr4);
if (dptoken == NULL) {
break;
}
if(str4 == kommatoken && str4 != token && eid != -1) {
if((ah = get_action_handler(dptoken)) != NULL) {
new_event(eid);
add_handler(eid, i, ah);
i++;
}
}
else if(str4 != token && eid != -1 && ah) {
add_option(eid, i-1, k, dptoken);
k++;
}
else if(!ah)
break;
}
k=0;
}
new_event(eid);
add_handler(eid, i, NULL);
i=0;
}
}
}
int file_change(DIR_NODE *old_dir, DIR_NODE *new_dir)
{
FILE_NODE *old_file = old_dir->next_file;
FILE_NODE *new_file;
int change_flag = UNCHANGED;
/*get deleted or modified files*/
while (old_file != NULL)
{
new_file = new_dir->next_file;
while (new_file != NULL)
{
if (OK == is_same_file(old_file, new_file))
{
/*get modifid files*/
if (OK == is_file_changed(old_file, new_file))
{
new_event(MOD_FILE, (void *)new_file);
change_flag = CHANGED;
}
break;
}
new_file = new_file->next_file;
}
if (NULL == new_file)
{
change_flag = CHANGED;
new_event(DEL_FILE, (void *)old_file);
}
old_file = old_file->next_file;
}
new_file = new_dir->next_file;
/*get new files*/
while (new_file)
{
old_file = old_dir->next_file;
while (old_file != NULL)
{
/*don't need get modifid files*/
if (OK == is_same_file(old_file, new_file))
break;
old_file = old_file->next_file;
}
if (NULL == old_file)
{
change_flag = CHANGED;
TEST
new_event(ADD_FILE, (void *)new_file);
}
new_file = new_file->next_file;
}
return change_flag;
}
void GDNetHost::poll_events() {
ENetEvent event;
if (enet_host_service(_host, &event, _event_wait) > 0) {
_event_queue.push(new_event(event));
while (enet_host_check_events(_host, &event) > 0) {
_event_queue.push(new_event(event));
}
}
}
int chl_dir_change(DIR_NODE *old_dir, DIR_NODE *new_dir)
{
DIR_NODE *old_chl_dir = old_dir->next_chl_dir;
DIR_NODE *new_chl_dir;
int change_flag = UNCHANGED;
while (old_chl_dir != NULL)
{
new_chl_dir = new_dir->next_chl_dir;
while (new_chl_dir != NULL)
{
if (OK == is_same_dir(old_chl_dir, new_chl_dir))
{
if (CHANGED == dir_changes(old_chl_dir, new_chl_dir))
{
change_flag = CHANGED;
}
break;
}
new_chl_dir = new_chl_dir->next_bro_dir;
}
if (new_chl_dir == NULL)
{
change_flag = CHANGED;
new_event(DEL_DIR, (void*)old_chl_dir);
}
old_chl_dir = old_chl_dir->next_bro_dir;
}
new_chl_dir = new_dir->next_chl_dir;
while (new_chl_dir != NULL)
{
old_chl_dir = old_dir->next_chl_dir;
while (old_chl_dir != NULL)
{
if (OK == is_same_dir(old_chl_dir, new_chl_dir))
{
break;
}
old_chl_dir = old_chl_dir->next_bro_dir;
}
if (old_chl_dir == NULL)
{
change_flag = CHANGED;
new_event(ADD_DIR, (void *)new_chl_dir);
}
new_chl_dir = new_chl_dir->next_bro_dir;
}
return change_flag;
}
void add_dir_to_task(DIR_NODE *dir)
{
FILE_NODE *file = dir->next_file;
DIR_NODE *dir_chl = dir->next_chl_dir;
while (file)
{
new_event(ADD_FILE, (void *)file);
file = file->next_file;
}
while (dir_chl)
{
new_event (ADD_DIR, (void *)dir_chl);
dir_chl = dir_chl->next_bro_dir;
}
}
void SyncEventListener :: newEvent(EventBroadcaster* sender, EventDataPtr data)
{
if (!m_enabled) return;
m_lock.lock();
Event new_event (sender, data);
bool sender_in_queue = false;
for (int i = 0; i < m_unprocessed_ordered_events.size(); ++i)
{
if (m_unprocessed_ordered_events[i].sender == sender)
{
// A event was received some time ago and left unprocessed.
// Leave it at its place in the queue, but update the data
// since there is no buffer it does not make sense to discard
// the new data and process the old one.
m_unprocessed_ordered_events[i] = new_event;
sender_in_queue = true;
break;
}
}
if (!sender_in_queue)
{
m_unprocessed_ordered_events.push_back(new_event);
}
m_condition.wakeAll();
m_lock.unlock();
}
/**
* parse_events - parse a perf style string with events
* @el: List of events allocated earlier
* @events: Comma separated lists of events. {} style groups are legal.
*
* JSON events are supported, if the event lists are downloaded first.
*/
int parse_events(struct eventlist *el, char *events)
{
char *s, *tmp;
events = strdup(events);
if (! events) return -1;
for (s = strtok_r(events, ",", &tmp);
s;
s = strtok_r(NULL, ",", &tmp)) {
bool group_leader = false, end_group = false;
int len;
if (s[0] == '{') {
s++;
group_leader = true;
} else if (len = strlen(s), len > 0 && s[len - 1] == '}') {
s[len - 1] = 0;
end_group = true;
}
struct event *e = new_event(el, s);
e->group_leader = group_leader;
e->end_group = end_group;
if (resolve_event(s, &e->attr) < 0) {
fprintf(stderr, "Cannot resolve %s\n", e->event);
return -1;
}
}
free(events);
return 0;
}
void SessionAPIInterface::OnAPIUserNameNeeded()
{
qDebug() << "SessionAPIInterface:OnAPIUserNameNeeded: begin";
Event myevent(abbsd::sessionbadusername);
myevent.add_source(Event::ES_INTERNAL);
emit new_event(myevent);
}
void SessionAPIInterface::OnAPISessionOk()
{
qDebug() << "SessionAPIInterface:OnAPISessionOk: begin";
Event myevent(abbsd::sessionok);
myevent.add_source(Event::ES_INTERNAL);
emit new_event(myevent);
}
int main(int argc, char *argv[])
{
QApplication app(argc, argv);
SodaClient::_nb_inst = 1;
// ouverture du fichier de configuration du plugin. ce fichier contient l'IP serveur, le port, le conteneur de donnée auquel l'application doit s'inscrire
config conf;
conf.read_config();
// préparation de la connexion au serveur et au conteneur de données
//instanciation du client Soda et du conteneur de données
QHostAddress adress1(conf.IP); //adresse du serveur
SodaClient* sc = new SodaClient( adress1, conf.port.toInt() ); //connexion des client Soda avec le port
sc->reg_type( conf.data_container ); //connexion aux conteneurs de données observés
// initialisation du launcher d'application à personnaliser
Launcher *launcher = new Launcher();
launcher->sc = sc;
// connexion des signaux et slot, action répondant aux événements
QObject::connect(sc, SIGNAL(new_event(SodaClient::Event)), launcher, SLOT(launch(SodaClient::Event))); //inscription d'un événement launch lors d'un signal venant de l'objet
QObject::connect(sc, SIGNAL(quit()), &app, SLOT(quit())); //fin du programme lorsqu'un serveur s'éteint
// lancement de la boucle d'événement
return app.exec();
};
void SessionAPIInterface::OnAPILoginErr(AuthAPI::ERRCODE code)
{
qDebug() << "SessionAPIInterface:OnAPILoginErr: begin";
Event myevent;
switch(code){
case AuthAPI::BAD_USERNAME:
case AuthAPI::ALREADY_LOGGED:
break;
case AuthAPI::BAD_CREDENTIALS:
myevent = Event(abbsd::sessionbadcredentials);
myevent.add_source(Event::ES_INTERNAL);
emit new_event(myevent);
break;
case AuthAPI::SERVER_TIMEOUT:
myevent = Event(abbsd::sessionservererror);
myevent.add_source(Event::ES_INTERNAL);
emit new_event(myevent);
break;
}
}
void netlink_wrapper::link_cache_callback(nl_cache* , nl_object* obj, int)
{
nl_logfunc( "---> link_cache_callback");
struct rtnl_link* link = (struct rtnl_link*) obj;
link_nl_event new_event(g_nl_rcv_arg.msghdr, link, g_nl_rcv_arg.netlink);
notify_observers(&new_event, nlgrpLINK);
g_nl_rcv_arg.msghdr = NULL;
nl_logfunc( "<--- link_cache_callback");
}
void netlink_wrapper::neigh_cache_callback(nl_cache* , nl_object* obj, int)
{
nl_logfunc( "---> neigh_cache_callback");
struct rtnl_neigh* neigh = (struct rtnl_neigh*)obj;
neigh_nl_event new_event(g_nl_rcv_arg.msghdr, neigh, g_nl_rcv_arg.netlink);
notify_observers(&new_event, nlgrpNEIGH);
g_nl_rcv_arg.msghdr = NULL;
nl_logfunc( "<--- neigh_cache_callback");
}
static void gtk_checklist_toggled(GtkCellRendererToggle * WXUNUSED(renderer),
gchar *stringpath,
wxCheckListBox *listbox)
{
wxCHECK_RET( listbox->m_treeview != NULL, wxT("invalid listbox") );
wxGtkTreePath path(stringpath);
wxCommandEvent new_event( wxEVT_CHECKLISTBOX,
listbox->GetId() );
new_event.SetEventObject( listbox );
new_event.SetInt( gtk_tree_path_get_indices(path)[0] );
new_event.SetString( listbox->GetString( new_event.GetInt() ));
listbox->Check( new_event.GetInt(), !listbox->IsChecked(new_event.GetInt()));
listbox->HandleWindowEvent( new_event );
}
void netlink_wrapper::route_cache_callback(nl_cache* , nl_object* obj, int)
{
nl_logfunc( "---> route_cache_callback");
struct rtnl_route* route = (struct rtnl_route*) obj;
route_nl_event new_event(g_nl_rcv_arg.msghdr, route,g_nl_rcv_arg.netlink);
// notify only route events of main table
const netlink_route_info* info = new_event.get_route_info();
if (info->table == ROUTE_MAIN_TABLE_ID) {
notify_observers(&new_event, nlgrpROUTE);
}
else {
nl_logfunc("ROUTE events from non-main route table are filtered: table_id=%d", info->table);
}
g_nl_rcv_arg.msghdr = NULL;
nl_logfunc( "<--- route_cache_callback");
}
void retry_outgoing(outgoing_t *outgoing) {
outgoing->timeout += 5;
if(outgoing->timeout > maxtimeout)
outgoing->timeout = maxtimeout;
if(outgoing->event)
event_del(outgoing->event);
outgoing->event = new_event();
outgoing->event->handler = (event_handler_t) setup_outgoing_connection;
outgoing->event->time = now + outgoing->timeout;
outgoing->event->data = outgoing;
event_add(outgoing->event);
ifdebug(CONNECTIONS) logger(LOG_NOTICE,
"Trying to re-establish outgoing connection in %d seconds",
outgoing->timeout);
}
int main_loop(int error, t_servinfo *servinfo)
{
fd_set readfds;
fd_set writefds;
t_list *list;
int maxfd;
list = NULL;
while (1)
{
FD_ZERO(&readfds);
init_fd(servinfo->sock, list, &readfds);
maxfd = recup_maxfd(list, servinfo->sock);
if ((error = select(maxfd + 1, &readfds, &writefds, NULL, NULL)) != -1)
{
new_event(&list, &readfds);
if (FD_ISSET(servinfo->sock, &readfds))
recup_info_client(&list, servinfo);
}
}
return (0);
}
extern void *
evt_deserialize(int type, u_char *event, int size)
{
return new_event(type);
}
void wxListBox::OnChar(wxKeyEvent& event)
{
if ( event.GetKeyCode() == WXK_RETURN || event.GetKeyCode() == WXK_NUMPAD_ENTER)
{
wxTopLevelWindow *tlw = wxDynamicCast(wxGetTopLevelParent(this), wxTopLevelWindow);
if ( tlw && tlw->GetDefaultItem() )
{
wxButton *def = wxDynamicCast(tlw->GetDefaultItem(), wxButton);
if ( def && def->IsEnabled() )
{
wxCommandEvent event(wxEVT_COMMAND_BUTTON_CLICKED, def->GetId() );
event.SetEventObject(def);
def->Command(event);
return ;
}
}
event.Skip() ;
}
/* generate wxID_CANCEL if command-. or <esc> has been pressed (typically in dialogs) */
else if (event.GetKeyCode() == WXK_ESCAPE || (event.GetKeyCode() == '.' && event.MetaDown() ) )
{
// FIXME: look in ancestors, not just parent.
wxWindow* win = GetParent()->FindWindow( wxID_CANCEL ) ;
if (win)
{
wxCommandEvent new_event(wxEVT_COMMAND_BUTTON_CLICKED,wxID_CANCEL);
new_event.SetEventObject( win );
win->GetEventHandler()->ProcessEvent( new_event );
}
}
else if ( event.GetKeyCode() == WXK_TAB )
{
wxNavigationKeyEvent new_event;
new_event.SetEventObject( this );
new_event.SetDirection( !event.ShiftDown() );
/* CTRL-TAB changes the (parent) window, i.e. switch notebook page */
new_event.SetWindowChange( event.ControlDown() );
new_event.SetCurrentFocus( this );
if ( !GetEventHandler()->ProcessEvent( new_event ) )
event.Skip() ;
}
else if ( event.GetKeyCode() == WXK_DOWN || event.GetKeyCode() == WXK_UP )
{
// perform the default key handling first
wxControl::OnKeyDown( event ) ;
wxCommandEvent event(wxEVT_COMMAND_LISTBOX_SELECTED, m_windowId);
event.SetEventObject( this );
wxArrayInt aSelections;
int n, count = GetSelections(aSelections);
if ( count > 0 )
{
n = aSelections[0];
if ( HasClientObjectData() )
event.SetClientObject( GetClientObject(n) );
else if ( HasClientUntypedData() )
event.SetClientData( GetClientData(n) );
event.SetString(GetString(n));
}
else
{
n = -1;
}
event.SetInt(n);
GetEventHandler()->ProcessEvent(event);
}
else
{
if ( event.GetTimestamp() > m_lastTypeIn + 60 )
{
m_typeIn = wxEmptyString ;
}
m_lastTypeIn = event.GetTimestamp() ;
m_typeIn += (char) event.GetKeyCode() ;
int line = FindString(wxT("*")+m_typeIn+wxT("*")) ;
if ( line >= 0 )
{
if ( GetSelection() != line )
{
SetSelection(line) ;
wxCommandEvent event(wxEVT_COMMAND_LISTBOX_SELECTED, m_windowId);
event.SetEventObject( this );
if ( HasClientObjectData() )
event.SetClientObject( GetClientObject( line ) );
else if ( HasClientUntypedData() )
event.SetClientData( GetClientData(line) );
event.SetString(GetString(line));
event.SetInt(line);
GetEventHandler()->ProcessEvent(event);
}
}
}
}
bool wxApp::MacSendCharEvent( wxWindow* focus , long keymessage , long modifiers , long when , wxChar uniChar )
{
if ( !focus )
return false ;
wxKeyEvent event(wxEVT_CHAR) ;
MacCreateKeyEvent( event, focus , keymessage , modifiers , when , uniChar ) ;
bool handled = false ;
#if wxOSX_USE_CARBON
long keyval = event.m_keyCode ;
{
wxKeyEvent eventCharHook(wxEVT_CHAR_HOOK, event);
handled = focus->HandleWindowEvent( eventCharHook );
if ( handled && eventCharHook.IsNextEventAllowed() )
handled = false ;
}
if ( !handled )
{
handled = focus->HandleWindowEvent( event ) ;
}
if ( !handled && (keyval == WXK_TAB) )
{
wxWindow* iter = focus->GetParent() ;
while ( iter && !handled )
{
if ( iter->HasFlag( wxTAB_TRAVERSAL ) )
{
wxNavigationKeyEvent new_event;
new_event.SetEventObject( focus );
new_event.SetDirection( !event.ShiftDown() );
/* CTRL-TAB changes the (parent) window, i.e. switch notebook page */
new_event.SetWindowChange( event.ControlDown() );
new_event.SetCurrentFocus( focus );
handled = focus->GetParent()->HandleWindowEvent( new_event );
if ( handled && new_event.GetSkipped() )
handled = false ;
}
iter = iter->GetParent() ;
}
}
// backdoor handler for default return and command escape
if ( !handled && (!focus->IsKindOf(CLASSINFO(wxControl) ) || !focus->AcceptsFocus() ) )
{
// if window is not having a focus still testing for default enter or cancel
// TODO: add the UMA version for ActiveNonFloatingWindow
#ifndef __LP64__
wxWindow* focus = wxNonOwnedWindow::GetFromWXWindow( (WXWindow) FrontWindow() ) ;
if ( focus )
{
if ( keyval == WXK_RETURN || keyval == WXK_NUMPAD_ENTER )
{
wxTopLevelWindow *tlw = wxDynamicCast(wxGetTopLevelParent(focus), wxTopLevelWindow);
if ( tlw && tlw->GetDefaultItem() )
{
wxButton *def = wxDynamicCast(tlw->GetDefaultItem(), wxButton);
if ( def && def->IsEnabled() )
{
wxCommandEvent event(wxEVT_BUTTON, def->GetId() );
event.SetEventObject(def);
def->Command(event);
return true ;
}
}
}
else if (keyval == WXK_ESCAPE || (keyval == '.' && modifiers & cmdKey ) )
{
// generate wxID_CANCEL if command-. or <esc> has been pressed (typically in dialogs)
wxCommandEvent new_event(wxEVT_BUTTON,wxID_CANCEL);
new_event.SetEventObject( focus );
handled = focus->HandleWindowEvent( new_event );
}
}
#endif
}
#endif
return handled ;
}
bool wxApp::MacSendCharEvent( wxWindow* focus , long keymessage , long modifiers , long when , short wherex , short wherey , wxChar uniChar )
{
if ( !focus )
return false ;
wxKeyEvent event(wxEVT_CHAR) ;
MacCreateKeyEvent( event, focus , keymessage , modifiers , when , wherex , wherey , uniChar ) ;
long keyval = event.m_keyCode ;
bool handled = false ;
wxTopLevelWindowMac *tlw = focus->MacGetTopLevelWindow() ;
if (tlw)
{
event.SetEventType( wxEVT_CHAR_HOOK );
handled = tlw->GetEventHandler()->ProcessEvent( event );
if ( handled && event.GetSkipped() )
handled = false ;
}
if ( !handled )
{
event.SetEventType( wxEVT_CHAR );
event.Skip( false ) ;
handled = focus->GetEventHandler()->ProcessEvent( event ) ;
}
if ( !handled && (keyval == WXK_TAB) )
{
wxWindow* iter = focus->GetParent() ;
while ( iter && !handled )
{
if ( iter->HasFlag( wxTAB_TRAVERSAL ) )
{
wxNavigationKeyEvent new_event;
new_event.SetEventObject( focus );
new_event.SetDirection( !event.ShiftDown() );
/* CTRL-TAB changes the (parent) window, i.e. switch notebook page */
new_event.SetWindowChange( event.ControlDown() );
new_event.SetCurrentFocus( focus );
handled = focus->GetParent()->GetEventHandler()->ProcessEvent( new_event );
if ( handled && new_event.GetSkipped() )
handled = false ;
}
iter = iter->GetParent() ;
}
}
// backdoor handler for default return and command escape
if ( !handled && (!focus->IsKindOf(CLASSINFO(wxControl) ) || !focus->MacCanFocus() ) )
{
// if window is not having a focus still testing for default enter or cancel
// TODO: add the UMA version for ActiveNonFloatingWindow
wxWindow* focus = wxFindWinFromMacWindow( FrontWindow() ) ;
if ( focus )
{
if ( keyval == WXK_RETURN || keyval == WXK_NUMPAD_ENTER )
{
wxTopLevelWindow *tlw = wxDynamicCast(wxGetTopLevelParent(focus), wxTopLevelWindow);
if ( tlw && tlw->GetDefaultItem() )
{
wxButton *def = wxDynamicCast(tlw->GetDefaultItem(), wxButton);
if ( def && def->IsEnabled() )
{
wxCommandEvent event(wxEVT_COMMAND_BUTTON_CLICKED, def->GetId() );
event.SetEventObject(def);
def->Command(event);
return true ;
}
}
}
else if (keyval == WXK_ESCAPE || (keyval == '.' && modifiers & cmdKey ) )
{
// generate wxID_CANCEL if command-. or <esc> has been pressed (typically in dialogs)
wxCommandEvent new_event(wxEVT_COMMAND_BUTTON_CLICKED,wxID_CANCEL);
new_event.SetEventObject( focus );
handled = focus->GetEventHandler()->ProcessEvent( new_event );
}
}
}
return handled ;
}
static gint
gtk_listbox_key_press_callback( GtkWidget *widget, GdkEventKey *gdk_event, wxListBox *listbox )
{
if (g_isIdle)
wxapp_install_idle_handler();
if (g_blockEventsOnDrag)
return FALSE;
bool ret = false;
if ((gdk_event->keyval == GDK_Tab) || (gdk_event->keyval == GDK_ISO_Left_Tab))
{
wxNavigationKeyEvent new_event;
/* GDK reports GDK_ISO_Left_Tab for SHIFT-TAB */
new_event.SetDirection( (gdk_event->keyval == GDK_Tab) );
/* CTRL-TAB changes the (parent) window, i.e. switch notebook page */
new_event.SetWindowChange( (gdk_event->state & GDK_CONTROL_MASK) );
new_event.SetCurrentFocus( listbox );
ret = listbox->GetEventHandler()->ProcessEvent( new_event );
}
if ((gdk_event->keyval == GDK_Return) && (!ret))
{
// eat return in all modes
ret = true;
}
#if wxUSE_CHECKLISTBOX
if ((gdk_event->keyval == ' ') && (listbox->m_hasCheckBoxes) && (!ret))
{
int sel = listbox->GtkGetIndex( widget );
wxCheckListBox *clb = (wxCheckListBox *)listbox;
clb->Check( sel, !clb->IsChecked(sel) );
wxCommandEvent new_event( wxEVT_COMMAND_CHECKLISTBOX_TOGGLED, listbox->GetId() );
new_event.SetEventObject( listbox );
new_event.SetInt( sel );
ret = listbox->GetEventHandler()->ProcessEvent( new_event );
}
#endif // wxUSE_CHECKLISTBOX
// Check or uncheck item with SPACE
if ((gdk_event->keyval == ' ') && (!ret) &&
(((listbox->GetWindowStyleFlag() & wxLB_MULTIPLE) != 0) ||
((listbox->GetWindowStyleFlag() & wxLB_EXTENDED) != 0)) )
{
int sel = listbox->GtkGetIndex( widget );
if (sel != -1)
{
ret = true;
if (listbox->IsSelected( sel ))
gtk_list_unselect_item( listbox->m_list, sel );
else
gtk_list_select_item( listbox->m_list, sel );
wxCommandEvent new_event(wxEVT_COMMAND_LISTBOX_SELECTED, listbox->GetId() );
new_event.SetEventObject( listbox );
wxArrayInt aSelections;
int n, count = listbox->GetSelections(aSelections);
if ( count > 0 )
{
n = aSelections[0];
if ( listbox->HasClientObjectData() )
new_event.SetClientObject( listbox->GetClientObject(n) );
else if ( listbox->HasClientUntypedData() )
new_event.SetClientData( listbox->GetClientData(n) );
new_event.SetString( listbox->GetString(n) );
}
else
{
n = -1;
}
new_event.SetInt(n);
listbox->GetEventHandler()->ProcessEvent( new_event );
}
}
if (ret)
{
gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "key_press_event" );
return TRUE;
}
return FALSE;
}
bool wxApp::MacSendKeyDownEvent( wxWindow* focus , long keymessage , long modifiers , long when , short wherex , short wherey , wxChar uniChar )
{
if ( !focus )
return false ;
short keycode ;
short keychar ;
keychar = short(keymessage & charCodeMask);
keycode = short(keymessage & keyCodeMask) >> 8 ;
if ( modifiers & ( controlKey|shiftKey|optionKey ) )
{
// control interferes with some built-in keys like pgdown, return etc. therefore we remove the controlKey modifier
// and look at the character after
UInt32 state = 0;
UInt32 keyInfo = KeyTranslate((Ptr)GetScriptManagerVariable(smKCHRCache), ( modifiers & (~(controlKey|shiftKey|optionKey))) | keycode, &state);
keychar = short(keyInfo & charCodeMask);
}
long keyval = wxMacTranslateKey(keychar, keycode) ;
long realkeyval = keyval ;
if ( keyval == keychar )
{
// we are not on a special character combo -> pass the real os event-value to EVT_CHAR, but not to EVT_KEY (make upper first)
realkeyval = short(keymessage & charCodeMask) ;
keyval = wxToupper( keyval ) ;
}
// Check for NUMPAD keys
if (keyval >= '0' && keyval <= '9' && keycode >= 82 && keycode <= 92)
{
keyval = keyval - '0' + WXK_NUMPAD0;
}
else if (keycode >= 67 && keycode <= 81)
{
switch (keycode)
{
case 76 :
keyval = WXK_NUMPAD_ENTER;
break;
case 81:
keyval = WXK_NUMPAD_EQUAL;
break;
case 67:
keyval = WXK_NUMPAD_MULTIPLY;
break;
case 75:
keyval = WXK_NUMPAD_DIVIDE;
break;
case 78:
keyval = WXK_NUMPAD_SUBTRACT;
break;
case 69:
keyval = WXK_NUMPAD_ADD;
break;
case 65:
keyval = WXK_NUMPAD_DECIMAL;
break;
} // end switch
}
wxKeyEvent event(wxEVT_KEY_DOWN);
bool handled = false ;
event.m_shiftDown = modifiers & shiftKey;
event.m_controlDown = modifiers & controlKey;
event.m_altDown = modifiers & optionKey;
event.m_metaDown = modifiers & cmdKey;
event.m_keyCode = keyval ;
#if wxUSE_UNICODE
event.m_uniChar = uniChar ;
#endif
event.m_rawCode = keymessage;
event.m_rawFlags = modifiers;
event.m_x = wherex;
event.m_y = wherey;
event.SetTimestamp(when);
event.SetEventObject(focus);
handled = focus->GetEventHandler()->ProcessEvent( event ) ;
if ( handled && event.GetSkipped() )
handled = false ;
if ( !handled )
{
#if wxUSE_ACCEL
if (!handled)
{
wxWindow *ancestor = focus;
while (ancestor)
{
int command = ancestor->GetAcceleratorTable()->GetCommand( event );
if (command != -1)
{
wxCommandEvent command_event( wxEVT_COMMAND_MENU_SELECTED, command );
handled = ancestor->GetEventHandler()->ProcessEvent( command_event );
break;
}
if (ancestor->IsTopLevel())
break;
ancestor = ancestor->GetParent();
}
}
#endif // wxUSE_ACCEL
}
if (!handled)
{
wxTopLevelWindowMac *tlw = focus->MacGetTopLevelWindow() ;
if (tlw)
{
event.Skip( FALSE ) ;
event.SetEventType( wxEVT_CHAR_HOOK );
// raw value again
event.m_keyCode = realkeyval ;
handled = tlw->GetEventHandler()->ProcessEvent( event );
if ( handled && event.GetSkipped() )
handled = false ;
}
}
if ( !handled )
{
event.Skip( FALSE ) ;
event.SetEventType( wxEVT_CHAR ) ;
// raw value again
event.m_keyCode = realkeyval ;
handled = focus->GetEventHandler()->ProcessEvent( event ) ;
if ( handled && event.GetSkipped() )
handled = false ;
}
if ( !handled && (keyval == WXK_TAB) )
{
wxWindow* iter = focus->GetParent() ;
while( iter && !handled )
{
if ( iter->HasFlag( wxTAB_TRAVERSAL ) )
{
wxNavigationKeyEvent new_event;
new_event.SetEventObject( focus );
new_event.SetDirection( !event.ShiftDown() );
/* CTRL-TAB changes the (parent) window, i.e. switch notebook page */
new_event.SetWindowChange( event.ControlDown() );
new_event.SetCurrentFocus( focus );
handled = focus->GetParent()->GetEventHandler()->ProcessEvent( new_event );
if ( handled && new_event.GetSkipped() )
handled = false ;
}
iter = iter->GetParent() ;
}
}
// backdoor handler for default return and command escape
if ( !handled && (!focus->IsKindOf(CLASSINFO(wxControl) ) || !focus->MacCanFocus() ) )
{
// if window is not having a focus still testing for default enter or cancel
// TODO add the UMA version for ActiveNonFloatingWindow
wxWindow* focus = wxFindWinFromMacWindow( FrontWindow() ) ;
if ( focus )
{
if ( keyval == WXK_RETURN )
{
wxButton *def = wxDynamicCast(focus->GetDefaultItem(),
wxButton);
if ( def && def->IsEnabled() )
{
wxCommandEvent event(wxEVT_COMMAND_BUTTON_CLICKED, def->GetId() );
event.SetEventObject(def);
def->Command(event);
return true ;
}
}
/* generate wxID_CANCEL if command-. or <esc> has been pressed (typically in dialogs) */
else if (keyval == WXK_ESCAPE || (keyval == '.' && modifiers & cmdKey ) )
{
wxCommandEvent new_event(wxEVT_COMMAND_BUTTON_CLICKED,wxID_CANCEL);
new_event.SetEventObject( focus );
handled = focus->GetEventHandler()->ProcessEvent( new_event );
}
}
}
return handled ;
}
void send_mtu_probe(node_t *n) {
vpn_packet_t packet;
int len, i;
int timeout = 1;
n->mtuprobes++;
n->mtuevent = NULL;
if(!n->status.reachable || !n->status.validkey) {
ifdebug(TRAFFIC) logger(LOG_INFO, "Trying to send MTU probe to unreachable or rekeying node %s (%s)", n->name, n->hostname);
n->mtuprobes = 0;
return;
}
if(n->mtuprobes > 32) {
if(!n->minmtu) {
n->mtuprobes = 31;
timeout = pinginterval;
goto end;
}
ifdebug(TRAFFIC) logger(LOG_INFO, "%s (%s) did not respond to UDP ping, restarting PMTU discovery", n->name, n->hostname);
n->mtuprobes = 1;
n->minmtu = 0;
n->maxmtu = MTU;
}
if(n->mtuprobes >= 10 && n->mtuprobes < 32 && !n->minmtu) {
ifdebug(TRAFFIC) logger(LOG_INFO, "No response to MTU probes from %s (%s)", n->name, n->hostname);
n->mtuprobes = 31;
}
if(n->mtuprobes == 30 || (n->mtuprobes < 30 && n->minmtu >= n->maxmtu)) {
if(n->minmtu > n->maxmtu)
n->minmtu = n->maxmtu;
else
n->maxmtu = n->minmtu;
n->mtu = n->minmtu;
ifdebug(TRAFFIC) logger(LOG_INFO, "Fixing MTU of %s (%s) to %d after %d probes", n->name, n->hostname, n->mtu, n->mtuprobes);
n->mtuprobes = 31;
}
if(n->mtuprobes == 31) {
timeout = pinginterval;
goto end;
} else if(n->mtuprobes == 32) {
timeout = pingtimeout;
}
for(i = 0; i < 4 + localdiscovery; i++) {
if(i == 0) {
if(n->mtuprobes < 30 || n->maxmtu + 8 >= MTU)
continue;
len = n->maxmtu + 8;
} else if(n->maxmtu <= n->minmtu) {
len = n->maxmtu;
} else {
len = n->minmtu + 1 + rand() % (n->maxmtu - n->minmtu);
}
if(len < 64)
len = 64;
memset(packet.data, 0, 14);
RAND_pseudo_bytes(packet.data + 14, len - 14);
packet.len = len;
if(i >= 4 && n->mtuprobes <= 10)
packet.priority = -1;
else
packet.priority = 0;
ifdebug(TRAFFIC) logger(LOG_INFO, "Sending MTU probe length %d to %s (%s)", len, n->name, n->hostname);
send_udppacket(n, &packet);
}
end:
n->mtuevent = new_event();
n->mtuevent->handler = (event_handler_t)send_mtu_probe;
n->mtuevent->data = n;
n->mtuevent->time = now.tv_sec + timeout;
event_add(n->mtuevent);
}
event_ref new_timer_event(uint8_t timer, uint16_t period, uint8_t repeat, uint16_t repeat_count) {
event_ref e = 0;
action_ref check_action = 0;
node_ref period_arg = 0;
node_ref trigger_arg = 0;
time_ref time_trigger = 0;
time_ref time_period = 0;
for(;;) {
// Create a new time period
time_period = new_time();
if(!time_period) break;
// Set up the period
if(timer == CLOCK_TIME) {
time_period->clock_time = period;
} else if (timer == MILLISECONDS) {
time_period->milliseconds = period;
} else if (timer == SECONDS) {
time_period->seconds = period;
} else if (timer == MINUTES) {
time_period->minutes = period;
} else if (timer == HOURS) {
time_period->hours = period;
} else if (timer == DAYS) {
time_period->days = period;
}
// Create a new time trigger
time_trigger = new_time();
if(!time_trigger) break;
// Set up the trigger = global + period
add_time_to_time(time_trigger, global_time());
add_time_to_time(time_trigger, time_period);
// Create a new event
e = new_event();
if(!e) break;
// Create a new action
check_action = new_action();
if(!check_action) break;
// Set its function
action_set_func(check_action, &check_time_args);
// Create a trigger arg
trigger_arg = new_node(time_trigger, &time_delete);
if(!trigger_arg) break;
// Create the period arg
period_arg = new_node(time_period, &time_delete);
if(!period_arg) break;
node_append(period_arg, trigger_arg);
action_set_args(check_action, period_arg);
event_set_check(e, check_action);
event_set_repeat(e, repeat, repeat_count);
return e;
}
event_delete(&e);
node_delete(&period_arg);
node_delete(&trigger_arg);
action_delete(&check_action);
time_delete(&time_period);
time_delete(&time_trigger);
return FAILURE;
}
static bool
read_values(const char *file_path, Context *ctx)
{
FILE *f;
int line_num;
char line[LINE_SIZE];
Expectation_Block *eblock = NULL;
f = fopen(file_path, "r");
if (!f) {
fprintf(stderr, "Failed to open %s\n", file_path);
return false;
}
if (ctx->debug)
printf("=== Parsing ===\n");
line_num = 0;
// mark all events on values and expectations vectors
while (fgets(line, LINE_SIZE, f)) {
Variable *var;
Event *event;
Status_Event *status_event;
Term *term;
Expectation *expec = NULL;
int time, ret;
char sensor[STR_PARSE_LEN], state[STR_PARSE_LEN];
float value = 0;
ret = parse_value(ctx, line, &time, sensor, state);
if (ret == LINE_ERROR) {
fprintf(stderr, "Failed to read line %d: %s\n", line_num, line);
goto error;
}
line_num++;
if (ret == LINE_EMPTY)
continue;
if (time >= ctx->reads) {
fprintf(stderr, "Time %d exceeds reads %d on line %d\n",
time, ctx->reads, line_num - 1);
goto error;
}
if (!strcmp(sensor, BEGIN_EXPECTATIONS)) {
if (eblock) {
fprintf(stderr, "BEGIN_EXPECTATIONS block on line %d is inside"
" another BEGIN_EXPECTATIONS block\n", line_num - 1);
goto error;
}
eblock = add_expectation_block(&ctx->expectation_blocks, state,
time, 0);
continue;
} else if (!strcmp(sensor, END_EXPECTATIONS)) {
if (!eblock) {
fprintf(stderr, "Missing BEGIN_EXPECTATIONS block before "
"END_EXPECTATIONS block on line %d\n", line_num - 1);
goto error;
}
eblock->end = time;
eblock = NULL;
continue;
}
var = parse_sensor(ctx, sensor);
if (!var) {
expec = parse_expectation(ctx, sensor);
if (expec)
var = expec->output;
else
goto error;
}
status_event = parse_status_event(time, state);
if (status_event) {
if (expec) {
fprintf(stderr, "Error: EXP_%s is not suppose to have status "
"changes\n", var->name);
free(status_event);
goto error;
}
var->status_events = g_list_append(var->status_events,
status_event);
} else {
term = parse_state(var, state);
if (!term)
value = atof(state);
event = new_event(time, term, value);
if (expec)
expec->events = g_list_append(expec->events, event);
else
var->events = g_list_append(var->events, event);
}
}
ctx->cur_expectation_block = ctx->expectation_blocks;
if (ctx->debug)
printf("=== Parsing concluded ===\n");
fclose(f);
return true;
error:
fclose(f);
return false;
}
void CompaniesFrame::OnTryClose(wxCloseEvent& event) {
event.Veto();
wxCloseEvent new_event(wxEVT_COMMAND_BUTTON_CLICKED);
button_cancel_->ProcessWindowEvent(new_event);
Hide();
}
int main(void)
{
ALLEGRO_TIMER *timer;
ALLEGRO_EVENT_SOURCE user_src;
ALLEGRO_EVENT_QUEUE *queue;
ALLEGRO_EVENT user_event;
ALLEGRO_EVENT event;
if (!al_init()) {
abort_example("Could not init Allegro.\n");
return 1;
}
timer = al_create_timer(0.5);
if (!timer) {
abort_example("Could not install timer.\n");
return 1;
}
open_log();
al_init_user_event_source(&user_src);
queue = al_create_event_queue();
al_register_event_source(queue, &user_src);
al_register_event_source(queue, al_get_timer_event_source(timer));
al_start_timer(timer);
while (true) {
al_wait_for_event(queue, &event);
if (event.type == ALLEGRO_EVENT_TIMER) {
int n = event.timer.count;
log_printf("Got timer event %d\n", n);
user_event.user.type = MY_SIMPLE_EVENT_TYPE;
user_event.user.data1 = n;
al_emit_user_event(&user_src, &user_event, NULL);
user_event.user.type = MY_COMPLEX_EVENT_TYPE;
user_event.user.data1 = (intptr_t)new_event(n);
al_emit_user_event(&user_src, &user_event, my_event_dtor);
}
else if (event.type == MY_SIMPLE_EVENT_TYPE) {
int n = (int) event.user.data1;
ALLEGRO_ASSERT(event.user.source == &user_src);
al_unref_user_event(&event.user);
log_printf("Got simple user event %d\n", n);
if (n == 5) {
break;
}
}
else if (event.type == MY_COMPLEX_EVENT_TYPE) {
MY_EVENT *my_event = (void *)event.user.data1;
ALLEGRO_ASSERT(event.user.source == &user_src);
log_printf("Got complex user event %d\n", my_event->id);
al_unref_user_event(&event.user);
}
}
al_destroy_user_event_source(&user_src);
al_destroy_event_queue(queue);
al_destroy_timer(timer);
log_printf("Done.\n");
close_log(true);
return 0;
}
DC_ClientEvent *DC_checkClientEvent(void)
{
DC_ClientEvent *event;
char *buf, *msg;
int ret;
/* Check for checkpoint requests */
if (boinc_time_to_checkpoint())
{
DC_log(LOG_DEBUG, "Core client requested checkpoint");
return new_event(DC_CLIENT_CHECKPOINT);
}
/* Check for messages */
buf = (char *)malloc(MAX_MESSAGE_SIZE);
if (!buf)
/* Let's hope the error is transient and we can deliver the
* message when DC_checkClientEvent() is called for the next time */
return NULL;
/* Check for trickle-down messages and also handle internal
* communication */
ret = boinc_receive_trickle_down(buf, MAX_MESSAGE_SIZE);
if (ret)
{
msg = (char *)malloc(MAX_MESSAGE_SIZE);
if (!msg)
{
free(buf);
return NULL;
}
ret = parse_str(buf, "<message>", msg, MAX_MESSAGE_SIZE);
if (!ret)
{
DC_log(LOG_WARNING, "Failed to parse message %s", buf);
free(buf);
free(msg);
return NULL;
}
if (!strncmp(msg, DCAPI_MSG_PFX, strlen(DCAPI_MSG_PFX)) &&
msg[strlen(DCAPI_MSG_PFX)] == ':')
{
event = handle_special_msg(msg +
strlen(DCAPI_MSG_PFX) + 1);
free(msg);
return event;
}
DC_log(LOG_DEBUG, "Received trickle message");
event = new_event(DC_CLIENT_MESSAGE);
event->message = buf;
return event;
}
free(buf);
if (client_state == STATE_FINISH)
return new_event(DC_CLIENT_FINISH);
return NULL;
}
