void Dragger::logDebug( vgd::Shp< vgd::event::Event > event )
{
using vgd::event::KeyboardButtonEvent;
using vgd::event::MouseButtonEvent;
using vgd::event::Location2Event;
using vgd::event::MouseWheelEvent;
vgd::event::KeyboardButtonEvent *keyboardButtonEvent= dynamic_cast<KeyboardButtonEvent*>(event.get());
MouseButtonEvent *mouseButtonEvent = dynamic_cast<MouseButtonEvent*>(event.get());
Location2Event *location2Event = dynamic_cast<Location2Event*>(event.get());
MouseWheelEvent *mouseWheelEvent = dynamic_cast<MouseWheelEvent*>(event.get());
if( keyboardButtonEvent != 0 )
{
vgLogDebug(
"KeyboardButtonEvent (%d,%d)",
keyboardButtonEvent->getButtonID(),
keyboardButtonEvent->getState()
);
}
else if( mouseButtonEvent != 0 )
{
vgLogDebug(
"MouseButtonEvent (%d,%d)",
mouseButtonEvent->getButtonID(),
mouseButtonEvent->getState()
);
}
else if( location2Event != 0 )
{
vgLogDebug(
"Location2Event ( previousLocation(%f,%f), location(%f,%f), size(%f,%f)",
location2Event->getPreviousLocation()[0],
location2Event->getPreviousLocation()[1],
location2Event->getLocation()[0],
location2Event->getLocation()[1],
location2Event->getSize()[0],
location2Event->getSize()[1]
);
}
else if( mouseWheelEvent != 0 )
{
vgLogDebug(
"MouseWheelEvent (%d,%d)",
mouseWheelEvent->getAxis(),
mouseWheelEvent->getDelta()
);
}
else
{
vgLogDebug("Unknown event");
}
}
const void AnimationTester::mouseWheelListener(MouseWheelEvent& event){
if (event.isCancelled()){
return;
}
if (d != NULL){
if (event.delta() > 0){
d->scale *= 1.2f;
}
else{
d->scale *= (5.0f / 6.0f);
}
if (d->scale < 1.0f){
d->scale = 1.0f;
}
logger::info("Scale: " + to_string(d->scale));
}
}
bool NativeScrollBarWin::OnMouseWheel(const MouseWheelEvent& e)
{
if(!sb_container_.get())
{
return false;
}
sb_container_->ScrollWithOffset(e.offset());
return true;
}
// Dispatch a mouse wheel event to any registered handlers
void EventDispatcher::handleMouseWheel(MouseWheelEvent& evt)
{
HANDLE dev = evt.getDeviceHandle();
{
// Set the device name if it's available
ScopedCriticalSection mMutex(&mdLock);
if(mouseDevices.count(dev) > 0)
{
evt.setDeviceInfo(mouseDevices[dev]);
}
else
{
// It's an unknown device, let's see what we can find out about it.
ScopedNonCriticalSection unlock(&mdLock);
MouseInfo *mi = unknownMouseDevice(dev);
if(mi)
{
evt.setDeviceInfo(mi);
}
}
}
{
// Run the chain, let someone make a decision about this event
ScopedCriticalSection mecMutex(&mecLock);
if(mouseEventChains.count(dev) > 0 && mouseEventChains[dev]->chainSize() > 0)
{
// You like me! You really, really like me!
mouseEventChains[dev]->runMouseWheelEventChain(evt);
}
else
{
// Zero is the REAL lonliest number. It's the lonliest number
// since the number one.
}
}
}
void SimpleMouseListener::onMouseWheel(const MouseWheelEvent& event)
{
cout<<"[MouseWheel] : direction="<<event.getDirection()<< " : ";
printXY(event);
}
const void Editor::mouseWheelListener(MouseWheelEvent event){
cout << event.delta() << endl;
}
std::string mitk::EventFactory::EventToXML(mitk::InteractionEvent *event)
{
InternalEvent* ie = dynamic_cast<InternalEvent*> (event);
if (ie != NULL)
return "";
std::string eventClass = event->GetNameOfClass();
std::string eventXML = "<" + InteractionEventConst::xmlTagEventVariant() + " " + InteractionEventConst::xmlParameterEventClass() + "=\"";
std::transform(eventClass.cbegin(), eventClass.cend(), eventClass.begin(), ::toupper);
eventXML += eventClass + "\" >\n";
// here follow event specific attributes
if (eventClass == "MOUSEPRESSEVENT" || eventClass == "MOUSERELEASEEVENT" || eventClass == "MOUSEDOUBLECLICKEVENT" || eventClass == "MOUSEMOVEEVENT" || eventClass == "MOUSEWHEELEVENT")
{
if (!(eventClass == "MOUSEMOVEEVENT") && !(eventClass == "MOUSEWHEELEVENT"))
{
// EventButton
eventXML += " <" + InteractionEventConst::xmlTagAttribute() +" " + InteractionEventConst::xmlParameterName() + "=\"" + InteractionEventConst::xmlEventPropertyEventButton() + "\" ";
eventXML += InteractionEventConst::xmlParameterValue() + "=\"";
eventXML += GetEventButton(event);
eventXML += "\"/>\n";
}
// ButtonState
if (GetButtonState(event) != "")
{
eventXML += " <" + InteractionEventConst::xmlTagAttribute() +" " + InteractionEventConst::xmlParameterName() + "=\"" + InteractionEventConst::xmlEventPropertyButtonState() + "\" ";
eventXML += InteractionEventConst::xmlParameterValue() + "=\"";
eventXML += GetButtonState(event);
eventXML += "\"/>\n";
}
// Modifiers
if (GetModifierState(event) != "")
{
eventXML += " <" + InteractionEventConst::xmlTagAttribute() +" " + InteractionEventConst::xmlParameterName() + "=\"" + InteractionEventConst::xmlEventPropertyModifier() + "\" ";
eventXML += InteractionEventConst::xmlParameterValue() + "=\"";
eventXML += GetModifierState(event);
eventXML += "\"/>\n";
}
// Position on Screen
eventXML += " <" + InteractionEventConst::xmlTagAttribute() +" " + InteractionEventConst::xmlParameterName() + "=\"" + InteractionEventConst::xmlEventPropertyPositionOnScreen() + "\" ";
eventXML += InteractionEventConst::xmlParameterValue() + "=\"";
eventXML += GetPositionOnScreen(event);
eventXML += "\"/>\n";
// Position in World
eventXML += " <" + InteractionEventConst::xmlTagAttribute() +" " + InteractionEventConst::xmlParameterName() + "=\"" + InteractionEventConst::xmlEventPropertyPositionInWorld() + "\" ";
eventXML += InteractionEventConst::xmlParameterValue() + "=\"";
eventXML += GetPositionInWorld(event);
eventXML += "\"/>\n";
}
else if (eventClass == "INTERACTIONKEYEVENT")
{
mitk::InteractionKeyEvent* ke = dynamic_cast<mitk::InteractionKeyEvent*>(event);
// key
eventXML += " <" + InteractionEventConst::xmlTagAttribute() +" " + InteractionEventConst::xmlParameterName() + "=\"" + InteractionEventConst::xmlEventPropertyKey() + "\" ";
eventXML += InteractionEventConst::xmlParameterValue() + "=\"";
eventXML += ke->GetKey();
eventXML += "\"/>\n";
}
else
{
MITK_WARN << "Event not recognized, discarding event of type " << event->GetNameOfClass();
}
if (eventClass == "MOUSEWHEELEVENT")
{
MouseWheelEvent* we = dynamic_cast<MouseWheelEvent*> (event);
int delta = we->GetWheelDelta();
std::stringstream ss;
ss << delta;
eventXML += " <" + InteractionEventConst::xmlTagAttribute() +" " + InteractionEventConst::xmlParameterName() + "=\"" + InteractionEventConst::xmlEventPropertyWheelDelta() + "\" ";
eventXML += InteractionEventConst::xmlParameterValue() + "=\"";
eventXML += ss.str();
eventXML += "\"/>\n";
eventXML += " <" + InteractionEventConst::xmlTagAttribute() +" " + InteractionEventConst::xmlParameterName() + "=\"" + InteractionEventConst::xmlEventPropertyScrollDirection() + "\" ";
eventXML += InteractionEventConst::xmlParameterValue() + "=\"";
eventXML += delta < 0 ? "DOWN" : "UP";
eventXML += "\"/>\n";
}
// Renderer name
eventXML += " <" + InteractionEventConst::xmlTagAttribute() +" " + InteractionEventConst::xmlParameterName() + "=\"" + InteractionEventConst::xmlEventPropertyRendererName() + "\" ";
eventXML += InteractionEventConst::xmlParameterValue() + "=\"";
eventXML += event->GetSender()->GetName();
eventXML += "\"/>\n";
// closing tag:
eventXML += "</" + InteractionEventConst::xmlTagEventVariant() + ">";
return eventXML;
}
void Widget::processEvent(Event* event, PassKey<Widget, WindowSystemPrivate>)
{
switch(event->type()) {
case Event::kFocusIn: {
if(isAcceptsFocus_) {
Widget* widget = first_;
Widget* next = widget;
while(next) {
widget = next;
if(widget->isAcceptsFocus_ && widget->first_ && widget->isVisible()
&& widget->isEnabled()) {
next = widget->first_;
}
else {
next = next->next_;
}
}
if(focus_)
focus_->hasFocus_ = false;
focus_ = widget;
if(focus_) {
focus_->hasFocus_ = true;
focus_->dispatchEvent(event);
}
}
return; }
case Event::kFocusOut:
if(focus_) {
focus_->hasFocus_ = false;
focus_->dispatchEvent(event);
}
return;
case Event::kMouseEnter: {
if(!hasGrab_) {
MouseEvent* e = static_cast<MouseEvent*>(event);
dispatchEvent(e);
updateHoverPoint(e->pos());
}
return; }
case Event::kMouseLeave: {
if(!hasGrab_)
sendMouseLeave();
return; }
case Event::kMouseMove: {
MouseEvent* e = static_cast<MouseEvent*>(event);
Widget* widget;
Point<int> pos;
if(hasGrab_) {
std::tie(widget, pos) = hoveredWidget();
e->setPos(e->windowPos() - pos, {});
widget->processMouseEvent(e);
}
else {
std::tie(widget, pos) = updateHoverPoint(e->pos());
e->setPos(pos, {});
widget->dispatchEvent(e);
}
return; }
case Event::kMousePress: {
MouseEvent* e = static_cast<MouseEvent*>(event);
hasGrab_ = true;
Widget* widget;
Point<int> pos;
std::tie(widget, pos) = hoveredWidget();
widget->updateFocus(this);
e->setPos(e->windowPos() - pos, {});
widget->processMouseEvent(e);
return; }
case Event::kMouseRelease: {
MouseEvent* e = static_cast<MouseEvent*>(event);
Widget* widget;
Point<int> pos;
std::tie(widget, pos) = hoveredWidget();
Point<int> eventPos = e->pos();
e->setPos(e->windowPos() - pos, {});
widget->processMouseEvent(e);
if(e->buttons() == MouseButton::kNone) {
hasGrab_ = false;
updateHoverPoint(eventPos);
}
Duration duration = widget->timeCounter_.restart();
if(duration <= 300_ms && e->button() != MouseButton::kNone
&& e->button() == widget->lastButton_) {
MouseEvent ev(Event::kMouseDoubleClick);
ev.setTimestamp(e->timestamp(), {});
ev.setModifiers(e->modifiers(), {});
ev.setPos(e->pos(), {});
ev.setWindowPos(e->windowPos(), {});
ev.setGlobalPos(e->globalPos(), {});
ev.setButton(e->button(), {});
ev.setButtons(e->buttons(), {});
widget->processEvent(&ev, {});
widget->lastButton_ = MouseButton::kNone;
}
else {
widget->lastButton_ = e->button();
}
return; }
case Event::kMouseWheel: {
MouseWheelEvent* e = static_cast<MouseWheelEvent*>(event);
Widget* widget;
Point<int> pos;
std::tie(widget, pos) = hoveredWidget();
e->setPos(e->windowPos() - pos, {});
widget->processMouseEvent(e);
return; }
case Event::kKeyPress: {
Widget* widget = focus_;
while(focus_) {
if(focus_->dispatchEvent(event)) {
if(event->isAccepted())
return;
}
widget = widget->parent_;
}
return; }
case Event::kKeyRelease: {
Widget* widget = focus_;
while(focus_) {
if(focus_->dispatchEvent(event)) {
if(event->isAccepted())
return;
}
widget = widget->parent_;
}
return; }
case Event::kShow: {
show();
break; }
case Event::kHide: {
hide();
break; }
case Event::kEnable: {
enable();
break; }
case Event::kDisable: {
disable();
break; }
case Event::kClose : {
if(dispatchEvent(event) && event->isAccepted()) {
hide();
}
return; }
case Event::kPaint: {
repaint(static_cast<PaintEvent*>(event));
// repaint() calls the dispatchEvent() by itself so we don't need to call it one
// more time
return; }
case Event::kMove: {
MoveEvent* e = static_cast<MoveEvent*>(event);
pos_ = e->pos();
break; }
case Event::kResize: {
ResizeEvent* e = static_cast<ResizeEvent*>(event);
size_ = e->size();
break; }
default:
break;
}
dispatchEvent(event);
if(event->type() == Event::kResize && layout_) {
layout_->setGeometry(rect());
}
}
