void wxControlContainer::HandleOnNavigationKey( wxNavigationKeyEvent& event ) { wxWindow *parent = m_winParent->GetParent(); // the event is propagated downwards if the event emitter was our parent bool goingDown = event.GetEventObject() == parent; const wxWindowList& children = m_winParent->GetChildren(); // if we have exactly one notebook-like child window (actually it could be // any window that returns true from its HasMultiplePages()), then // [Shift-]Ctrl-Tab and Ctrl-PageUp/Down keys should iterate over its pages // even if the focus is outside of the control because this is how the // standard MSW properties dialogs behave and we do it under other platforms // as well because it seems like a good idea -- but we can always put this // block inside "#ifdef __WXMSW__" if it's not suitable there if ( event.IsWindowChange() && !goingDown ) { // check if we have a unique notebook-like child wxWindow *bookctrl = NULL; for ( wxWindowList::const_iterator i = children.begin(), end = children.end(); i != end; ++i ) { wxWindow * const window = *i; if ( window->HasMultiplePages() ) { if ( bookctrl ) { // this is the second book-like control already so don't do // anything as we don't know which one should have its page // changed bookctrl = NULL; break; } bookctrl = window; } } if ( bookctrl ) { // make sure that we don't bubble up the event again from the book // control resulting in infinite recursion wxNavigationKeyEvent eventCopy(event); eventCopy.SetEventObject(m_winParent); if ( bookctrl->GetEventHandler()->ProcessEvent(eventCopy) ) return; } } // there is not much to do if we don't have children and we're not // interested in "notebook page change" events here if ( !children.GetCount() || event.IsWindowChange() ) { // let the parent process it unless it already comes from our parent // of we don't have any if ( goingDown || !parent || !parent->GetEventHandler()->ProcessEvent(event) ) { event.Skip(); } return; } // where are we going? const bool forward = event.GetDirection(); // the node of the children list from which we should start looking for the // next acceptable child wxWindowList::compatibility_iterator node, start_node; // we should start from the first/last control and not from the one which // had focus the last time if we're propagating the event downwards because // for our parent we look like a single control if ( goingDown ) { // just to be sure it's not used (normally this is not necessary, but // doesn't hurt neither) m_winLastFocused = (wxWindow *)NULL; // start from first or last depending on where we're going node = forward ? children.GetFirst() : children.GetLast(); } else // going up { // try to find the child which has the focus currently // the event emitter might have done this for us wxWindow *winFocus = event.GetCurrentFocus(); // but if not, we might know where the focus was ourselves if (!winFocus) winFocus = m_winLastFocused; // if still no luck, do it the hard way if (!winFocus) winFocus = wxWindow::FindFocus(); if ( winFocus ) { #ifdef __WXMSW__ // If we are in a radio button group, start from the first item in the // group if ( event.IsFromTab() && wxIsKindOf(winFocus, wxRadioButton ) ) winFocus = wxGetFirstButtonInGroup((wxRadioButton*)winFocus); #endif // ok, we found the focus - now is it our child? start_node = children.Find( winFocus ); } if ( !start_node && m_winLastFocused ) { // window which has focus isn't our child, fall back to the one // which had the focus the last time start_node = children.Find( m_winLastFocused ); } // if we still didn't find anything, we should start with the first one if ( !start_node ) { start_node = children.GetFirst(); } // and the first child which we can try setting focus to is the next or // the previous one node = forward ? start_node->GetNext() : start_node->GetPrevious(); } // we want to cycle over all elements passing by NULL for ( ;; ) { // don't go into infinite loop if ( start_node && node && node == start_node ) break; // Have we come to the last or first item on the panel? if ( !node ) { if ( !start_node ) { // exit now as otherwise we'd loop forever break; } if ( !goingDown ) { // Check if our (maybe grand) parent is another panel: if this // is the case, they will know what to do with this navigation // key and so give them the chance to process it instead of // looping inside this panel (normally, the focus will go to // the next/previous item after this panel in the parent // panel). wxWindow *focussed_child_of_parent = m_winParent; while ( parent ) { // we don't want to tab into a different dialog or frame if ( focussed_child_of_parent->IsTopLevel() ) break; event.SetCurrentFocus( focussed_child_of_parent ); if ( parent->GetEventHandler()->ProcessEvent( event ) ) return; focussed_child_of_parent = parent; parent = parent->GetParent(); } } //else: as the focus came from our parent, we definitely don't want // to send it back to it! // no, we are not inside another panel so process this ourself node = forward ? children.GetFirst() : children.GetLast(); continue; } wxWindow *child = node->GetData(); #ifdef __WXMSW__ if ( event.IsFromTab() ) { if ( wxIsKindOf(child, wxRadioButton) ) { // only radio buttons with either wxRB_GROUP or wxRB_SINGLE // can be tabbed to if ( child->HasFlag(wxRB_GROUP) ) { // need to tab into the active button within a group wxRadioButton *rb = wxGetSelectedButtonInGroup((wxRadioButton*)child); if ( rb ) child = rb; } else if ( !child->HasFlag(wxRB_SINGLE) ) { node = forward ? node->GetNext() : node->GetPrevious(); continue; } } } else if ( m_winLastFocused && wxIsKindOf(m_winLastFocused, wxRadioButton) && !m_winLastFocused->HasFlag(wxRB_SINGLE) ) { // cursor keys don't navigate out of a radio button group so // find the correct radio button to focus if ( forward ) { child = wxGetNextButtonInGroup((wxRadioButton*)m_winLastFocused); if ( !child ) { // no next button in group, set it to the first button child = wxGetFirstButtonInGroup((wxRadioButton*)m_winLastFocused); } } else { child = wxGetPreviousButtonInGroup((wxRadioButton*)m_winLastFocused); if ( !child ) { // no previous button in group, set it to the last button child = wxGetLastButtonInGroup((wxRadioButton*)m_winLastFocused); } } if ( child == m_winLastFocused ) { // must be a group consisting of only one button therefore // no need to send a navigation event event.Skip(false); return; } } #endif // __WXMSW__ if ( child->AcceptsFocusFromKeyboard() ) { // if we're setting the focus to a child panel we should prevent it // from giving it to the child which had the focus the last time // and instead give it to the first/last child depending from which // direction we're coming event.SetEventObject(m_winParent); // disable propagation for this call as otherwise the event might // bounce back to us. wxPropagationDisabler disableProp(event); if ( !child->GetEventHandler()->ProcessEvent(event) ) { // set it first in case SetFocusFromKbd() results in focus // change too m_winLastFocused = child; // everything is simple: just give focus to it child->SetFocusFromKbd(); } //else: the child manages its focus itself event.Skip( false ); return; } node = forward ? node->GetNext() : node->GetPrevious(); } // we cycled through all of our children and none of them wanted to accept // focus event.Skip(); }
void SCXMLIOProcessor::eventFromSCXML(const std::string& target, const Event& event) { // see http://www.w3.org/TR/scxml/#SendTargets Event eventCopy(event); // test 253 / 198 / 336 eventCopy.origintype = "http://www.w3.org/TR/scxml/#SCXMLEventProcessor"; // test 336 eventCopy.origin = "#_scxml_" + _interpreter->getSessionId(); if (false) { } else if(target.length() == 0) { /** * If neither the 'target' nor the 'targetexpr' attribute is specified, the * SCXML Processor must add the event will be added to the external event * queue of the sending session. */ // test333 vs test351 // reqCopy.sendid = ""; // test 198 _interpreter->enqueueExternal(eventCopy); } else if (iequals(target, "#_internal")) { /** * #_internal: If the target is the special term '#_internal', the Processor * must add the event to the internal event queue of the sending session. */ _interpreter->enqueueInternal(eventCopy); } else if (iequals(target, "#_parent")) { /** * #_parent: If the target is the special term '#_parent', the Processor must * add the event to the external event queue of the SCXML session that invoked * the sending session, if there is one. */ if (_interpreter->_parentQueue) { _interpreter->_parentQueue.enqueue(eventCopy); } else { ERROR_COMMUNICATION_THROW("Sending to parent invoker, but none is set"); } } else if (target.length() > 8 && iequals(target.substr(0, 8), "#_scxml_")) { /** * #_scxml_sessionid: If the target is the special term '#_scxml_sessionid', * where sessionid is the id of an SCXML session that is accessible to the * Processor, the Processor must add the event to the external queue of that * session. The set of SCXML sessions that are accessible to a given SCXML * Processor is platform-dependent. */ std::string sessionId = target.substr(8); std::lock_guard<std::recursive_mutex> lock(_interpreter->_instanceMutex); std::map<std::string, std::weak_ptr<InterpreterImpl> > instances = InterpreterImpl::getInstances(); if (instances.find(sessionId) != instances.end()) { std::shared_ptr<InterpreterImpl> otherSession = instances[sessionId].lock(); if (otherSession) { otherSession->enqueueExternal(eventCopy); } else { ERROR_COMMUNICATION_THROW("Can not send to scxml session " + sessionId + " - not known"); } } else { ERROR_COMMUNICATION_THROW("Invalid target scxml session for send"); } } else if (target.length() > 2 && iequals(target.substr(0, 2), "#_")) { /** * #_invokeid: If the target is the special term '#_invokeid', where invokeid * is the invokeid of an SCXML session that the sending session has created * by <invoke>, the Processor must add the event to the external queue of that * session. */ std::string invokeId = target.substr(2); if (_interpreter->_invokers.find(invokeId) != _interpreter->_invokers.end()) { std::lock_guard<std::recursive_mutex> lock(_interpreter->_instanceMutex); try { _interpreter->_invokers[invokeId].eventFromSCXML(eventCopy); } catch(Event e) { // Is this the right thing to do? // _interpreter->enqueueExternal(eventCopy); } catch (const std::exception &e) { ERROR_COMMUNICATION_THROW("Exception caught while sending event to invoker '" + invokeId + "': " + e.what()); } catch(...) { ERROR_COMMUNICATION_THROW("Exception caught while sending event to invoker '" + invokeId + "'"); } } else { ERROR_COMMUNICATION_THROW("Can not send to invoked component '" + invokeId + "', no such invokeId"); } } else { ERROR_COMMUNICATION_THROW("Not sure what to make of the target '" + target + "' - raising error"); } }