void FxPlayerTiny::OnMouse(GFxEvent::EventType eventType, UInt button, SInt x, SInt y)
{
if (pMovie)
{
GFxMouseEvent mevent(eventType, button, (Float)x, (Float)y);
pMovie->HandleEvent(mevent);
}
if (pHUD)
{
GFxMouseEvent mevent(eventType, button, (Float)x, (Float)y);
pHUD->HandleEvent(mevent);
}
}
void messaging_adapter::on_link_remote_open(event &e) {
proton_event *pe = dynamic_cast<proton_event*>(&e);
if (pe) {
pn_link_t *link = pn_event_link(pe->pn_event());
if (is_local_open(pn_link_state(link))) {
messaging_event mevent(messaging_event::LINK_OPENED, *pe);
on_link_opened(mevent);
}
else if (is_local_unititialised(pn_link_state(link))) {
messaging_event mevent(messaging_event::LINK_OPENING, *pe);
on_link_opening(mevent);
pn_link_open(link);
}
}
}
void messaging_adapter::on_session_remote_open(event &e) {
proton_event *pe = dynamic_cast<proton_event*>(&e);
if (pe) {
pn_session_t *session = pn_event_session(pe->pn_event());
if (is_local_open(pn_session_state(session))) {
messaging_event mevent(messaging_event::SESSION_OPENED, *pe);
on_session_opened(mevent);
}
else if (is_local_unititialised(pn_session_state(session))) {
messaging_event mevent(messaging_event::SESSION_OPENING, *pe);
on_session_opening(mevent);
pn_session_open(session);
}
}
}
void messaging_adapter::on_link_remote_close(event &e) {
proton_event *pe = dynamic_cast<proton_event*>(&e);
if (pe) {
pn_event_t *cevent = pe->pn_event();
pn_link_t *lnk = pn_event_link(cevent);
if (pn_condition_is_set(pn_link_remote_condition(lnk))) {
messaging_event mevent(messaging_event::LINK_ERROR, *pe);
on_link_error(mevent);
}
else {
messaging_event mevent(messaging_event::LINK_CLOSE, *pe);
on_link_close(mevent);
}
pn_link_close(lnk);
}
}
void messaging_adapter::on_reactor_init(event &e) {
proton_event *pe = dynamic_cast<proton_event*>(&e);
if (pe) {
messaging_event mevent(messaging_event::START, *pe);
delegate_.on_start(mevent);
}
}
bool TimeSlider::event(QEvent* e)
{
// LogDialog::debug(tr("TimeSlider::event(): %1").arg(e->type()));
if( e->type() == QEvent::MouseButtonPress
|| e->type() == QEvent::MouseButtonDblClick )
{
QMouseEvent* event = static_cast<QMouseEvent*>(e);
if( event->button() == Qt::RightButton )
return false;
else
if( event->button() == Qt::LeftButton ) {
if( pointOutsideHandle(event->pos()) ) {
QMouseEvent mevent(QEvent::MouseButtonPress,
event->pos(),
Qt::MidButton, Qt::MidButton, Qt::NoModifier);
return QSlider::event(&mevent);
}
}
}
else
if( e->type() == QEvent::MouseMove ) {
if( !isSliderDown() )
return true;
}
bool b = QSlider::event(e);
// LogDialog::debug(tr("%1").arg(b));
return b;
}
void messaging_adapter::on_connection_remote_close(event &e) {
proton_event *pe = dynamic_cast<proton_event*>(&e);
if (pe) {
pn_event_t *cevent = pe->pn_event();
pn_connection_t *connection = pn_event_connection(cevent);
if (pn_condition_is_set(pn_connection_remote_condition(connection))) {
messaging_event mevent(messaging_event::CONNECTION_ERROR, *pe);
on_connection_error(mevent);
}
else {
messaging_event mevent(messaging_event::CONNECTION_CLOSE, *pe);
on_connection_close(mevent);
}
pn_connection_close(connection);
}
}
void messaging_adapter::on_connection_local_open(event &e) {
proton_event *pe = dynamic_cast<proton_event*>(&e);
if (pe) {
pn_connection_t *connection = pn_event_connection(pe->pn_event());
if (is_remote_open(pn_connection_state(connection))) {
messaging_event mevent(messaging_event::CONNECTION_OPENED, *pe);
on_connection_opened(mevent);
}
}
}
void messaging_adapter::on_transport_tail_closed(event &e) {
proton_event *pe = dynamic_cast<proton_event*>(&e);
if (pe) {
pn_connection_t *conn = pn_event_connection(pe->pn_event());
if (conn && is_local_open(pn_connection_state(conn))) {
messaging_event mevent(messaging_event::DISCONNECT, *pe);
delegate_.on_disconnect(mevent);
}
}
}
void messaging_adapter::on_session_remote_close(event &e) {
proton_event *pe = dynamic_cast<proton_event*>(&e);
if (pe) {
pn_event_t *cevent = pe->pn_event();
pn_session_t *session = pn_event_session(cevent);
pn_state_t state = pn_session_state(session);
if (pn_condition_is_set(pn_session_remote_condition(session))) {
messaging_event mevent(messaging_event::SESSION_ERROR, *pe);
on_session_error(mevent);
}
else if (is_local_closed(state)) {
messaging_event mevent(messaging_event::SESSION_CLOSED, *pe);
on_session_closed(mevent);
}
else {
messaging_event mevent(messaging_event::SESSION_CLOSING, *pe);
on_session_closing(mevent);
}
pn_session_close(session);
}
}
void messaging_adapter::on_link_flow(event &e) {
proton_event *pe = dynamic_cast<proton_event*>(&e);
if (pe) {
pn_event_t *pne = pe->pn_event();
pn_link_t *lnk = pn_event_link(pne);
if (lnk && pn_link_is_sender(lnk) && pn_link_credit(lnk) > 0) {
// create on_message extended event
messaging_event mevent(messaging_event::SENDABLE, *pe);
delegate_.on_sendable(mevent);;
}
}
}
void messaging_adapter::on_delivery(event &e) {
proton_event *pe = dynamic_cast<proton_event*>(&e);
if (pe) {
pn_event_t *cevent = pe->pn_event();
pn_link_t *lnk = pn_event_link(cevent);
delivery dlv = pe->delivery();
if (pn_link_is_receiver(lnk)) {
if (!dlv.partial() && dlv.readable()) {
// generate on_message
messaging_event mevent(messaging_event::MESSAGE, *pe);
pn_connection_t *pnc = pn_session_connection(pn_link_session(lnk));
connection_context& ctx = connection_context::get(pnc);
// Reusable per-connection message.
// Avoid expensive heap malloc/free overhead.
// See PROTON-998
class message &msg(ctx.event_message);
mevent.message_ = &msg;
mevent.message_->decode(lnk, dlv);
if (pn_link_state(lnk) & PN_LOCAL_CLOSED) {
if (auto_accept_)
dlv.release();
} else {
delegate_.on_message(mevent);
if (auto_accept_ && !dlv.settled())
dlv.accept();
}
}
else if (dlv.updated() && dlv.settled()) {
messaging_event mevent(messaging_event::DELIVERY_SETTLE, *pe);
delegate_.on_delivery_settle(mevent);
}
} else {
// sender
if (dlv.updated()) {
amqp_ulong rstate = dlv.remote_state();
if (rstate == PN_ACCEPTED) {
messaging_event mevent(messaging_event::DELIVERY_ACCEPT, *pe);
delegate_.on_delivery_accept(mevent);
}
else if (rstate == PN_REJECTED) {
messaging_event mevent(messaging_event::DELIVERY_REJECT, *pe);
delegate_.on_delivery_reject(mevent);
}
else if (rstate == PN_RELEASED || rstate == PN_MODIFIED) {
messaging_event mevent(messaging_event::DELIVERY_RELEASE, *pe);
delegate_.on_delivery_release(mevent);
}
if (dlv.settled()) {
messaging_event mevent(messaging_event::DELIVERY_SETTLE, *pe);
delegate_.on_delivery_settle(mevent);
}
if (auto_settle_)
dlv.settle();
}
}
}
}
void wxZEdit::EndPanel()
{
wxCaptionBarStyle style;
wxColour col1(193,208,233), col2(49,106,197);
style.SetFirstColour(col1);
style.SetSecondColour(col2);
style.SetCaptionStyle(wxCAPTIONBAR_FILLED_RECTANGLE);
m_pnl->ApplyCaptionStyleAll(style);
// ask for a resize
wxSizeEvent mevent( GetSize()+wxSize(1,1), GetId() );
mevent.SetEventObject( this );
ProcessEvent( mevent );
}
static gboolean
gtk_frame_configure_callback( GtkWidget* widget,
GdkEventConfigure *WXUNUSED(event),
wxTopLevelWindowGTK *win )
{
if (!win->IsShown())
return FALSE;
wxPoint point;
gtk_window_get_position((GtkWindow*)widget, &point.x, &point.y);
win->m_x = point.x;
win->m_y = point.y;
wxMoveEvent mevent(point, win->GetId());
mevent.SetEventObject( win );
win->HandleWindowEvent( mevent );
return FALSE;
}
void HexEditorCtrl::OnMouseRight( wxMouseEvent& event ){
if(event.GetEventObject() == hex_ctrl)
LastRightClickAt = hex_ctrl->PixelCoordToInternalPosition( event.GetPosition() )/2;
else if(event.GetEventObject() == text_ctrl)
LastRightClickAt = text_ctrl->PixelCoordToInternalPosition( event.GetPosition() );
else if( event.GetEventObject() == offset_ctrl)
{
//m_static_offset->SetLabel( offset_ctrl->hex_offset==true ? _("Offset: DEC") : _("Offset: HEX"));
//event.Skip(true);
offset_ctrl->OnMouseRight( event );
int x,y;
DoGetSize(&x,&y);
wxSizeEvent mevent(wxSize(x,y));
OnResize(mevent);
return;//to avoid ShowContextMenu
}
else
std::cout << "Right click captured without ctrl!\n";
ShowContextMenu( event );
}
static gint
gtk_frame_configure_callback( GtkWidget *WXUNUSED(widget), GdkEventConfigure *WXUNUSED(event), wxTopLevelWindowGTK *win )
{
if (g_isIdle)
wxapp_install_idle_handler();
if (!win->m_hasVMT || !win->IsShown())
return FALSE;
int x = 0;
int y = 0;
gdk_window_get_root_origin( win->m_widget->window, &x, &y );
win->m_x = x;
win->m_y = y;
wxMoveEvent mevent( wxPoint(win->m_x,win->m_y), win->GetId() );
mevent.SetEventObject( win );
win->HandleWindowEvent( mevent );
return FALSE;
}
static gboolean
gtk_frame_configure_callback( GtkWidget *WXUNUSED(widget),
GdkEventConfigure *WXUNUSED(event),
wxTopLevelWindowGTK *win )
{
// don't need to install idle handler, its done from "event" signal
if (!win->m_hasVMT || !win->IsShown())
return FALSE;
int x = 0;
int y = 0;
gdk_window_get_root_origin( win->m_widget->window, &x, &y );
win->m_x = x;
win->m_y = y;
wxMoveEvent mevent( wxPoint(win->m_x,win->m_y), win->GetId() );
mevent.SetEventObject( win );
win->GetEventHandler()->ProcessEvent( mevent );
return FALSE;
}
void wxMenuButton::OnButton( wxCommandEvent &event)
{
int win_id = event.GetId();
if (win_id == IDD_DROPDOWN_BUTTON)
{
wxNotifyEvent mevent(wxEVT_MENUBUTTON_OPEN, GetId());
mevent.SetEventObject(this);
if (GetEventHandler()->ProcessEvent(mevent) && !mevent.IsAllowed())
return;
if (!m_menu)
return;
PopupMenu(m_menu, wxPoint(0, GetSize().y));
m_labelButton->Refresh(FALSE);
m_dropdownButton->Refresh(FALSE);
}
else if (win_id == m_labelButton->GetId())
{
wxCommandEvent cevent(wxEVT_COMMAND_MENU_SELECTED, win_id);
cevent.SetEventObject(this);
cevent.SetId(win_id);
GetParent()->GetEventHandler()->ProcessEvent(cevent);
if (!m_menu) return;
const wxMenuItemList &items = m_menu->GetMenuItems();
int first_radio_id = -1;
int checked_id = -1;
bool check_next = FALSE;
// find the next available radio item to check
for (wxMenuItemList::Node *node = items.GetFirst(); node; node = node->GetNext())
{
wxMenuItem *mi = (wxMenuItem*)node->GetData();
if (mi && (mi->GetKind() == wxITEM_RADIO))
{
if (first_radio_id == -1)
first_radio_id = mi->GetId();
if (check_next)
{
check_next = FALSE;
checked_id = mi->GetId();
break;
}
else if (mi->IsChecked())
check_next = TRUE;
}
}
// the last item was checked, go back to the first
if (check_next && (first_radio_id != -1))
checked_id = first_radio_id;
if (checked_id != -1)
{
m_menu->Check(checked_id, TRUE);
wxCommandEvent mevent( wxEVT_COMMAND_MENU_SELECTED, checked_id);
mevent.SetEventObject( m_menu );
mevent.SetInt(1);
GetEventHandler()->ProcessEvent(mevent);
}
}
}
void OSNacl::handle_event(const pp::InputEvent& p_event) {
int type = p_event.GetType();
switch (type) {
case PP_INPUTEVENT_TYPE_MOUSEDOWN:
case PP_INPUTEVENT_TYPE_MOUSEUP:
case PP_INPUTEVENT_TYPE_WHEEL: {
InputEvent event;
event.ID=++event_id;
event.type = InputEvent::MOUSE_BUTTON;
event.device=0;
pp::MouseInputEvent mevent(p_event);
if (type == PP_INPUTEVENT_TYPE_WHEEL) {
pp::WheelInputEvent wevent(p_event);;
float ticks = wevent.GetTicks().y();
if (ticks == 0)
break; // whut?
event.mouse_button.pressed = true;
event.mouse_button.button_index = ticks > 0 ? BUTTON_WHEEL_UP : BUTTON_WHEEL_DOWN;
event.mouse_button.doubleclick = false;
} else {
event.mouse_button.pressed = (type == PP_INPUTEVENT_TYPE_MOUSEDOWN);
event.mouse_button.button_index = mouse_button(mevent.GetButton());
event.mouse_button.doubleclick = (mevent.GetClickCount() % 2) == 0;
mouse_mask &= ~(1<< (event.mouse_button.button_index - 1));
mouse_mask |= (event.mouse_button.pressed << (event.mouse_button.button_index - 1));
};
pp::Point pos = mevent.GetPosition();
event.mouse_button.button_mask = mouse_mask;
event.mouse_button.global_x = pos.x();
event.mouse_button.x = pos.x();
event.mouse_button.global_y = pos.y();
event.mouse_button.y = pos.y();
event.mouse_button.pointer_index = 0;
event.mouse_button.mod = modifier(p_event.GetModifiers());
queue_event(event);
} break;
case PP_INPUTEVENT_TYPE_MOUSEMOVE: {
pp::MouseInputEvent mevent(p_event);
pp::Point pos = mevent.GetPosition();
InputEvent event;
event.ID=++event_id;
event.type = InputEvent::MOUSE_MOTION;
event.mouse_motion.pointer_index = 0;
event.mouse_motion.global_x = pos.x();
event.mouse_motion.global_y = pos.y();
event.mouse_motion.x = pos.x();
event.mouse_motion.y = pos.y();
event.mouse_motion.button_mask = mouse_mask;
event.mouse_motion.mod = modifier(p_event.GetModifiers());
event.mouse_motion.relative_x = pos.x() - mouse_last_x;
event.mouse_motion.relative_y = pos.y() - mouse_last_y;
mouse_last_x = pos.x();
mouse_last_y = pos.y();
queue_event(event);
} break;
case PP_INPUTEVENT_TYPE_RAWKEYDOWN:
case PP_INPUTEVENT_TYPE_KEYDOWN:
case PP_INPUTEVENT_TYPE_KEYUP: {
pp::KeyboardInputEvent kevent(p_event);
bool is_char;
uint32_t key = godot_key(kevent.GetKeyCode(), is_char);
if (type != PP_INPUTEVENT_TYPE_KEYUP && is_char) {
last_scancode = key;
break;
};
InputEvent event;
event.ID=++event_id;
event.type = InputEvent::KEY;
event.key.pressed = (type != PP_INPUTEVENT_TYPE_KEYUP);
event.key.scancode = key;
event.key.unicode = key;
event.key.echo = p_event.GetModifiers() & PP_INPUTEVENT_MODIFIER_ISAUTOREPEAT;
event.key.mod = modifier(p_event.GetModifiers());
queue_event(event);
} break;
case PP_INPUTEVENT_TYPE_CHAR: {
pp::KeyboardInputEvent kevent(p_event);
InputEvent event;
event.ID = ++event_id;
event.type = InputEvent::KEY;
event.key.pressed = true;
event.key.scancode = last_scancode;
event.key.unicode = kevent.GetCharacterText().AsString().c_str()[0];
event.key.mod = modifier(p_event.GetModifiers());
event.key.echo = p_event.GetModifiers() & PP_INPUTEVENT_MODIFIER_ISAUTOREPEAT;
queue_event(event);
} break;
/*
case NPEventType_Minimize: {
minimized = p_event->u.minimize.value == 1;
} break;
case NPEventType_Focus: {
if (p_event->u.focus.value == 1) {
main_loop->notification(MainLoop::NOTIFICATION_WM_FOCUS_IN);
} else {
main_loop->notification(MainLoop::NOTIFICATION_WM_FOCUS_OUT);
};
} break;
*/
default:
;
};
};
bool KisSketchView::sceneEvent(QEvent* event)
{
if (d->canvas && d->canvasWidget) {
switch(event->type()) {
case QEvent::GraphicsSceneMousePress: {
QGraphicsSceneMouseEvent *gsmevent = static_cast<QGraphicsSceneMouseEvent*>(event);
QMouseEvent mevent(QMouseEvent::MouseButtonPress, gsmevent->pos().toPoint(), gsmevent->button(), gsmevent->buttons(), gsmevent->modifiers());
QApplication::sendEvent(d->canvasWidget, &mevent);
emit interactionStarted();
return true;
}
case QEvent::GraphicsSceneMouseMove: {
QGraphicsSceneMouseEvent *gsmevent = static_cast<QGraphicsSceneMouseEvent*>(event);
QMouseEvent mevent(QMouseEvent::MouseMove, gsmevent->pos().toPoint(), gsmevent->button(), gsmevent->buttons(), gsmevent->modifiers());
QApplication::sendEvent(d->canvasWidget, &mevent);
update();
emit interactionStarted();
return true;
}
case QEvent::GraphicsSceneMouseRelease: {
QGraphicsSceneMouseEvent *gsmevent = static_cast<QGraphicsSceneMouseEvent*>(event);
QMouseEvent mevent(QMouseEvent::MouseButtonRelease, gsmevent->pos().toPoint(), gsmevent->button(), gsmevent->buttons(), gsmevent->modifiers());
QApplication::sendEvent(d->canvasWidget, &mevent);
emit interactionStarted();
return true;
}
case QEvent::GraphicsSceneWheel: {
QGraphicsSceneWheelEvent *gswevent = static_cast<QGraphicsSceneWheelEvent*>(event);
QWheelEvent wevent(gswevent->pos().toPoint(), gswevent->delta(), gswevent->buttons(), gswevent->modifiers(), gswevent->orientation());
QApplication::sendEvent(d->canvasWidget, &wevent);
emit interactionStarted();
return true;
}
case QEvent::GraphicsSceneHoverEnter: {
QGraphicsSceneHoverEvent *hevent = static_cast<QGraphicsSceneHoverEvent*>(event);
QHoverEvent e(QEvent::Enter, hevent->screenPos(), hevent->lastScreenPos());
QApplication::sendEvent(d->canvasWidget, &e);
return true;
}
case QEvent::GraphicsSceneHoverLeave: {
QGraphicsSceneHoverEvent *hevent = static_cast<QGraphicsSceneHoverEvent*>(event);
QHoverEvent e(QEvent::Leave, hevent->screenPos(), hevent->lastScreenPos());
QApplication::sendEvent(d->canvasWidget, &e);
return true;
}
case QEvent::TouchBegin: {
QApplication::sendEvent(d->canvasWidget, event);
event->accept();
emit interactionStarted();
return true;
}
case QEvent::TabletPress:
case QEvent::TabletMove:
case QEvent::TabletRelease:
d->canvas->inputManager()->stopIgnoringEvents();
QApplication::sendEvent(d->canvasWidget, event);
return true;
default:
if (QApplication::sendEvent(d->canvasWidget, event)) {
emit interactionStarted();
return true;
}
}
}
return QDeclarativeItem::sceneEvent(event);
}
