/* Mouse capability-change handler: */
void UIMouseHandler::sltMouseCapabilityChanged()
{
/* If mouse supports absolute pointing and mouse-integration activated: */
if (uisession()->isMouseSupportsAbsolute() && uisession()->isMouseIntegrated())
{
/* Release the mouse: */
releaseMouse();
/* Also we should switch guest mouse to the absolute mode: */
CMouse mouse = session().GetConsole().GetMouse();
mouse.PutMouseEventAbsolute(-1, -1, 0, 0, 0);
}
#if 0 /* current team's decision is NOT to capture mouse on mouse-absolute mode loosing! */
/* If mouse-integration deactivated or mouse doesn't supports absolute pointing: */
else
{
/* Search for the machine-view focused now: */
int iFocusedView = -1;
QList<ulong> screenIds = m_views.keys();
for (int i = 0; i < screenIds.size(); ++i)
{
if (m_views[screenIds[i]]->hasFocus())
{
iFocusedView = screenIds[i];
break;
}
}
/* If there is no focused view but views are present we will use the first one: */
if (iFocusedView == -1 && !screenIds.isEmpty())
iFocusedView = screenIds[0];
/* Capture mouse using that view: */
if (iFocusedView != -1)
captureMouse(iFocusedView);
}
#else /* but just to switch the guest mouse into relative mode! */
/* If mouse-integration deactivated or mouse doesn't supports absolute pointing: */
else
{
void TEWidget::mouseReleaseEvent(QMouseEvent* ev)
{
//printf("release [%d,%d] %d\n",ev->x()/font_w,ev->y()/font_h,ev->button());
if ( ev->button() == LeftButton)
{
if ( actSel > 1 ) emit endSelectionSignal(preserve_line_breaks);
preserve_line_breaks = TRUE;
actSel = 0;
//FIXME: emits a release event even if the mouse is
// outside the range. The procedure used in `mouseMoveEvent'
// applies here, too.
QPoint tL = contentsRect().topLeft();
int tLx = tL.x();
int tLy = tL.y();
if (!mouse_marks && !(ev->modifiers() & Qt::ShiftModifier))
emit mouseSignal( 3, // release
(ev->x()-tLx-blX)/font_w + 1,
(ev->y()-tLy-bY)/font_h + 1 );
releaseMouse();
}
}
LRESULT CALLBACK Window::wndProc( WindowHandle handle, UINT message, WPARAM wParam, LPARAM lParam )
{
switch ( message )
{
case WM_CLOSE:
{
// create close message and push it to the queue
InputMessage msg( InputMessage::Type::Close );
_messages.push( msg );
break;
}
case WM_ACTIVATEAPP:
{
if ( wParam && _mouseCaptured )
{
captureMouse( );
}
break;
}
case WM_KEYDOWN:
case WM_SYSKEYDOWN:
{
if ( !_oldKeyStates[wParam] )
{
InputMessage msg( InputMessage::Type::KeyDown );
msg.key.type = ( Key ) wParam;
msg.key.lCtrl = HIWORD( GetKeyState( VK_RCONTROL ) ) != 0;
msg.key.rCtrl = HIWORD( GetKeyState( VK_RCONTROL ) ) != 0;
msg.key.lAlt = HIWORD( GetKeyState( VK_LMENU ) ) != 0;
msg.key.rAlt = HIWORD( GetKeyState( VK_RMENU ) ) != 0;
msg.key.lShift = HIWORD( GetKeyState( VK_LSHIFT ) ) != 0;
msg.key.rShift = HIWORD( GetKeyState( VK_RSHIFT ) ) != 0;
_messages.push( msg );
_oldKeyStates[wParam] = true;
}
break;
}
case WM_KEYUP:
case WM_SYSKEYUP:
{
InputMessage msg( InputMessage::Type::KeyUp );
msg.key.type = ( Key ) wParam;
msg.key.lCtrl = HIWORD( GetKeyState( VK_RCONTROL ) ) != 0;
msg.key.rCtrl = HIWORD( GetKeyState( VK_RCONTROL ) ) != 0;
msg.key.lAlt = HIWORD( GetKeyState( VK_LMENU ) ) != 0;
msg.key.rAlt = HIWORD( GetKeyState( VK_RMENU ) ) != 0;
msg.key.lShift = HIWORD( GetKeyState( VK_LSHIFT ) ) != 0;
msg.key.rShift = HIWORD( GetKeyState( VK_RSHIFT ) ) != 0;
_messages.push( msg );
_oldKeyStates[wParam] = false;
break;
}
case WM_CHAR:
{
InputMessage msg( InputMessage::Type::Text );
msg.text.unicode = wParam;
_messages.push( msg );
break;
}
case WM_MOUSEMOVE:
{
InputMessage msg( InputMessage::Type::MouseMove );
msg.mouseMove.x = LOWORD( lParam );
msg.mouseMove.y = HIWORD( lParam );
msg.mouseMove.ctrl = ( wParam & MK_CONTROL ) != 0;
msg.mouseMove.lButton = ( wParam & MK_LBUTTON ) != 0;
msg.mouseMove.mButton = ( wParam & MK_MBUTTON ) != 0;
msg.mouseMove.rButton = ( wParam & MK_RBUTTON ) != 0;
msg.mouseMove.shift = ( wParam & MK_SHIFT ) != 0;
msg.mouseMove.xButton1 = ( wParam & MK_XBUTTON1 ) != 0;
msg.mouseMove.xButton2 = ( wParam & MK_XBUTTON2 ) != 0;
_messages.push( msg );
break;
}
case WM_LBUTTONDOWN:
{
InputMessage msg( InputMessage::Type::MouseButtonDown );
msg.mouseButton.type = MouseButton::LeftButton;
msg.mouseButton.ctrl = ( wParam & MK_CONTROL ) != 0;
msg.mouseButton.lButton = ( wParam & MK_LBUTTON ) != 0;
msg.mouseButton.mButton = ( wParam & MK_MBUTTON ) != 0;
msg.mouseButton.rButton = ( wParam & MK_RBUTTON ) != 0;
msg.mouseButton.shift = ( wParam & MK_SHIFT ) != 0;
msg.mouseButton.xButton1 = ( wParam & MK_XBUTTON1 ) != 0;
msg.mouseButton.xButton2 = ( wParam & MK_XBUTTON2 ) != 0;
msg.mouseButton.x = LOWORD( lParam );
msg.mouseButton.y = HIWORD( lParam );
_messages.push( msg );
captureMouse( );
break;
}
case WM_LBUTTONUP:
{
InputMessage msg( InputMessage::Type::MouseButtonUp );
msg.mouseButton.type = MouseButton::LeftButton;
msg.mouseButton.x = LOWORD( lParam );
msg.mouseButton.y = HIWORD( lParam );
_messages.push( msg );
releaseMouse( );
break;
}
case WM_RBUTTONDOWN:
{
InputMessage msg( InputMessage::Type::MouseButtonDown );
msg.mouseButton.type = MouseButton::RightButton;
msg.mouseButton.ctrl = ( wParam & MK_CONTROL ) != 0;
msg.mouseButton.lButton = ( wParam & MK_LBUTTON ) != 0;
msg.mouseButton.mButton = ( wParam & MK_MBUTTON ) != 0;
msg.mouseButton.rButton = ( wParam & MK_RBUTTON ) != 0;
msg.mouseButton.shift = ( wParam & MK_SHIFT ) != 0;
msg.mouseButton.xButton1 = ( wParam & MK_XBUTTON1 ) != 0;
msg.mouseButton.xButton2 = ( wParam & MK_XBUTTON2 ) != 0;
msg.mouseButton.x = LOWORD( lParam );
msg.mouseButton.y = HIWORD( lParam );
_messages.push( msg );
captureMouse( );
break;
}
case WM_RBUTTONUP:
{
InputMessage msg( InputMessage::Type::MouseButtonUp );
msg.mouseButton.type = MouseButton::RightButton;
msg.mouseButton.x = LOWORD( lParam );
msg.mouseButton.y = HIWORD( lParam );
_messages.push( msg );
releaseMouse( );
break;
}
case WM_MBUTTONDOWN:
{
InputMessage msg( InputMessage::Type::MouseButtonDown );
msg.mouseButton.type = MouseButton::MiddleButton;
msg.mouseButton.ctrl = ( wParam & MK_CONTROL ) != 0;
msg.mouseButton.lButton = ( wParam & MK_LBUTTON ) != 0;
msg.mouseButton.mButton = ( wParam & MK_MBUTTON ) != 0;
msg.mouseButton.rButton = ( wParam & MK_RBUTTON ) != 0;
msg.mouseButton.shift = ( wParam & MK_SHIFT ) != 0;
msg.mouseButton.xButton1 = ( wParam & MK_XBUTTON1 ) != 0;
msg.mouseButton.xButton2 = ( wParam & MK_XBUTTON2 ) != 0;
msg.mouseButton.x = LOWORD( lParam );
msg.mouseButton.y = HIWORD( lParam );
_messages.push( msg );
captureMouse( );
break;
}
case WM_MBUTTONUP:
{
InputMessage msg( InputMessage::Type::MouseButtonUp );
msg.mouseButton.type = MouseButton::MiddleButton;
msg.mouseButton.x = LOWORD( lParam );
msg.mouseButton.y = HIWORD( lParam );
_messages.push( msg );
releaseMouse( );
break;
}
case WM_MOUSEWHEEL:
{
POINT screenPos;
screenPos.x = static_cast< LONG >( LOWORD( lParam ) );
screenPos.y = static_cast< LONG >( HIWORD( lParam ) );
ScreenToClient( handle, &screenPos );
InputMessage msg( InputMessage::Type::MouseWheel );
msg.mouseWheel.ctrl = ( wParam & MK_CONTROL ) != 0;
msg.mouseWheel.lButton = ( wParam & MK_LBUTTON ) != 0;
msg.mouseWheel.mButton = ( wParam & MK_MBUTTON ) != 0;
msg.mouseWheel.rButton = ( wParam & MK_RBUTTON ) != 0;
msg.mouseWheel.shift = ( wParam & MK_SHIFT ) != 0;
msg.mouseWheel.xButton1 = ( wParam & MK_XBUTTON1 ) != 0;
msg.mouseWheel.xButton2 = ( wParam & MK_XBUTTON2 ) != 0;
msg.mouseWheel.x = static_cast< uint16_t >( screenPos.x );
msg.mouseWheel.y = static_cast< uint16_t >( screenPos.y );
msg.mouseWheel.delta = HIWORD( wParam ) / 120;
_messages.push( msg );
break;
}
case WM_XBUTTONDOWN:
{
InputMessage msg( InputMessage::Type::MouseButtonDown );
msg.mouseButton.type = HIWORD( wParam ) == XBUTTON1 ? MouseButton::XButton1 : MouseButton::XButton2;
msg.mouseButton.ctrl = ( wParam & MK_CONTROL ) != 0;
msg.mouseButton.lButton = ( wParam & MK_LBUTTON ) != 0;
msg.mouseButton.mButton = ( wParam & MK_MBUTTON ) != 0;
msg.mouseButton.rButton = ( wParam & MK_RBUTTON ) != 0;
msg.mouseButton.shift = ( wParam & MK_SHIFT ) != 0;
msg.mouseButton.xButton1 = ( wParam & MK_XBUTTON1 ) != 0;
msg.mouseButton.xButton2 = ( wParam & MK_XBUTTON2 ) != 0;
msg.mouseButton.x = LOWORD( lParam );
msg.mouseButton.y = HIWORD( lParam );
_messages.push( msg );
break;
}
case WM_XBUTTONUP:
{
InputMessage msg( InputMessage::Type::MouseButtonUp );
msg.mouseButton.type = HIWORD( wParam ) == XBUTTON1 ? MouseButton::XButton1 : MouseButton::XButton2;
msg.mouseButton.x = LOWORD( lParam );
msg.mouseButton.y = HIWORD( lParam );
_messages.push( msg );
break;
}
default:
// default window procedure
return DefWindowProc( handle, message, wParam, lParam );
}
return 0;
}
bool Window::onProcessMessage(Message* msg)
{
switch (msg->type()) {
case kOpenMessage:
m_killer = NULL;
break;
case kCloseMessage:
saveLayout();
break;
case kMouseDownMessage: {
if (!m_isMoveable)
break;
clickedMousePos = static_cast<MouseMessage*>(msg)->position();
m_hitTest = hitTest(clickedMousePos);
if (m_hitTest != HitTestNowhere &&
m_hitTest != HitTestClient) {
if (clickedWindowPos == NULL)
clickedWindowPos = new gfx::Rect(getBounds());
else
*clickedWindowPos = getBounds();
captureMouse();
return true;
}
else
break;
}
case kMouseUpMessage:
if (hasCapture()) {
releaseMouse();
jmouse_set_cursor(kArrowCursor);
if (clickedWindowPos != NULL) {
delete clickedWindowPos;
clickedWindowPos = NULL;
}
m_hitTest = HitTestNowhere;
return true;
}
break;
case kMouseMoveMessage:
if (!m_isMoveable)
break;
// Does it have the mouse captured?
if (hasCapture()) {
gfx::Point mousePos = static_cast<MouseMessage*>(msg)->position();
// Reposition/resize
if (m_hitTest == HitTestCaption) {
int x = clickedWindowPos->x + (mousePos.x - clickedMousePos.x);
int y = clickedWindowPos->y + (mousePos.y - clickedMousePos.y);
moveWindow(gfx::Rect(x, y,
getBounds().w,
getBounds().h), true);
}
else {
int x, y, w, h;
w = clickedWindowPos->w;
h = clickedWindowPos->h;
bool hitLeft = (m_hitTest == HitTestBorderNW ||
m_hitTest == HitTestBorderW ||
m_hitTest == HitTestBorderSW);
bool hitTop = (m_hitTest == HitTestBorderNW ||
m_hitTest == HitTestBorderN ||
m_hitTest == HitTestBorderNE);
bool hitRight = (m_hitTest == HitTestBorderNE ||
m_hitTest == HitTestBorderE ||
m_hitTest == HitTestBorderSE);
bool hitBottom = (m_hitTest == HitTestBorderSW ||
m_hitTest == HitTestBorderS ||
m_hitTest == HitTestBorderSE);
if (hitLeft) {
w += clickedMousePos.x - mousePos.x;
}
else if (hitRight) {
w += mousePos.x - clickedMousePos.x;
}
if (hitTop) {
h += (clickedMousePos.y - mousePos.y);
}
else if (hitBottom) {
h += (mousePos.y - clickedMousePos.y);
}
limitSize(&w, &h);
if ((getBounds().w != w) ||
(getBounds().h != h)) {
if (hitLeft)
x = clickedWindowPos->x - (w - clickedWindowPos->w);
else
x = getBounds().x;
if (hitTop)
y = clickedWindowPos->y - (h - clickedWindowPos->h);
else
y = getBounds().y;
moveWindow(gfx::Rect(x, y, w, h), false);
invalidate();
}
}
}
break;
case kSetCursorMessage:
if (m_isMoveable) {
gfx::Point mousePos = static_cast<MouseMessage*>(msg)->position();
HitTest ht = hitTest(mousePos);
CursorType cursor = kArrowCursor;
switch (ht) {
case HitTestCaption:
cursor = kArrowCursor;
break;
case HitTestBorderNW:
cursor = kSizeTLCursor;
break;
case HitTestBorderW:
cursor = kSizeLCursor;
break;
case HitTestBorderSW:
cursor = kSizeBLCursor;
break;
case HitTestBorderNE:
cursor = kSizeTRCursor;
break;
case HitTestBorderE:
cursor = kSizeRCursor;
break;
case HitTestBorderSE:
cursor = kSizeBRCursor;
break;
case HitTestBorderN:
cursor = kSizeTCursor;
break;
case HitTestBorderS:
cursor = kSizeBCursor;
break;
}
jmouse_set_cursor(cursor);
return true;
}
break;
}
return Widget::onProcessMessage(msg);
}
void PanelAppletOverlay::mouseMoveEvent(QMouseEvent *event)
{
if (!m_layout || !m_applet) {
//kDebug() << "no layout";
return;
}
const int margin = 9;
if (m_applet->inherits("PanelSpacer")) {
if (m_applet->formFactor() == Plasma::Horizontal) {
if (event->pos().x() < margin || event->pos().x() > m_applet->size().width() - margin) {
setCursor(Qt::SizeHorCursor);
} else {
setCursor(Qt::ArrowCursor);
}
} else if (m_applet->formFactor() == Plasma::Vertical) {
if (event->pos().y() < margin || event->pos().y() > m_applet->size().height() - margin) {
setCursor(Qt::SizeVerCursor);
} else {
setCursor(Qt::ArrowCursor);
}
}
}
if (!m_clickDrag && !(event->buttons() & Qt::LeftButton)) {
//kDebug() << "no left button and we aren't click dragging";
return;
}
Plasma::FormFactor f = m_applet->formFactor();
if (!m_applet->inherits("PanelSpacer") &&
(((f != Plasma::Horizontal && f != Plasma::Vertical) && rect().intersects(m_applet->rect().toRect())) ||
((f == Plasma::Horizontal || f == Plasma::Vertical) && !rect().contains(event->globalPos()))) ) {
Plasma::View *view = Plasma::View::topLevelViewAt(event->globalPos());
//kDebug() << "checking view" << view << m_applet->view();
if (!view) {
view = dynamic_cast<Plasma::View*>(parent());
}
if (!view) {
return;
}
if (view != m_applet->view() && (event->buttons() & Qt::LeftButton)) {
Plasma::Containment *c = view->containment();
if (!c) {
return;
}
syncOrientation();
syncGeometry();
if (m_spacer) {
if (m_layout) {
m_layout->removeItem(m_spacer);
}
m_spacer->deleteLater();
m_spacer = 0;
}
QPointF pos = c->view()->mapFromGlobal(event->globalPos());
QRectF g = m_applet->geometry();
pos += QPoint(m_offset, m_offset);
g.moveTo(pos);
m_applet->setGeometry(g);
m_layout = 0;
c->addApplet(m_applet, pos, true);
m_applet->flushPendingConstraintsEvents();
m_applet->setPos(pos);
releaseMouse();
emit moved(this);
return;
}
} else if (m_applet->inherits("PanelSpacer") && m_dragAction != Move) {
if (m_applet->formFactor() == Plasma::Horizontal) {
if (m_dragAction == LeftResize) {
int fixedWidth = m_applet->size().width()+(m_lastGlobalPos.x() - event->globalPos().x());
m_applet->setPos(m_applet->pos().x()-(fixedWidth-m_applet->size().width()), m_applet->pos().y());
m_applet->setMinimumWidth(fixedWidth);
m_applet->setMaximumWidth(fixedWidth);
} else if (m_dragAction == RightResize) {
int fixedWidth = m_applet->size().width()-(m_lastGlobalPos.x() - event->globalPos().x());
m_applet->setMinimumWidth(fixedWidth);
m_applet->setMaximumWidth(fixedWidth);
}
} else if (m_applet->formFactor() == Plasma::Vertical) {
if (m_dragAction == LeftResize) {
int fixedHeight = m_applet->size().height()+(m_lastGlobalPos.y() - event->globalPos().y());
m_applet->setPos(m_applet->pos().x(), m_applet->pos().y()-(fixedHeight-m_applet->size().height()));
m_applet->setMinimumHeight(fixedHeight);
m_applet->setMaximumHeight(fixedHeight);
} else if (m_dragAction == RightResize) {
int fixedHeight = m_applet->size().height()-(m_lastGlobalPos.y() - event->globalPos().y());
m_applet->setMinimumHeight(fixedHeight);
m_applet->setMaximumHeight(fixedHeight);
}
}
m_lastGlobalPos = event->globalPos();
return;
}
if (!m_spacer) {
m_spacer = new AppletMoveSpacer(m_applet);
m_spacer->setMinimumSize(m_applet->geometry().size());
m_spacer->setMaximumSize(m_applet->geometry().size());
if (m_layout) {
m_layout->removeItem(m_applet);
m_layout->insertItem(m_index, m_spacer);
}
}
QPoint p = mapToParent(event->pos());
QRectF g = m_applet->geometry();
//kDebug() << p << g << "<-- movin'?";
if (m_orientation == Qt::Horizontal) {
g.moveLeft(p.x() + m_offset);
} else {
g.moveTop(p.y() + m_offset);
}
m_applet->setGeometry(g);
//FIXME: assumption on how panel containment works, presence of a non applet spacer in last position (if they were swapped would be impossible to save and restore)
if ((m_index > 0 && m_layout->itemAt(m_index - 1)) || m_index == 0) {
const bool prevIsApplet = dynamic_cast<Plasma::Applet*>(m_layout->itemAt(m_index - 1)) != 0;
const bool nextIsApplet = dynamic_cast<Plasma::Applet*>(m_layout->itemAt(m_index + 1)) != 0;
QPointF mousePos = event->pos() + g.topLeft();
// swap items if we pass completely over the next/previous item or cross
// more than halfway across it, whichever comes first
if (m_orientation == Qt::Horizontal) {
//kDebug() << prevIsApplet << m_prevGeom << g << nextIsApplet << m_nextGeom;
if (QApplication::layoutDirection() == Qt::RightToLeft) {
if (prevIsApplet && m_prevGeom.isValid() && mousePos.x() >= m_prevGeom.right()) {
swapWithPrevious();
} else if (nextIsApplet && m_nextGeom.isValid() && mousePos.x() <= m_nextGeom.left()) {
swapWithNext();
}
} else if (prevIsApplet && m_prevGeom.isValid() && mousePos.x() <= m_prevGeom.left()) {
swapWithPrevious();
} else if (nextIsApplet && m_nextGeom.isValid() && mousePos.x() >= m_nextGeom.right()) {
swapWithNext();
}
} else if (prevIsApplet && m_prevGeom.isValid() && mousePos.y() <= m_prevGeom.top()) {
swapWithPrevious();
} else if (nextIsApplet && m_nextGeom.isValid() && mousePos.y() >= m_nextGeom.bottom()) {
swapWithNext();
}
}
m_lastGlobalPos = event->globalPos();
//kDebug() << "=================================";
}
bool TextBox::onProcessMessage(Message* msg)
{
switch (msg->type()) {
case kKeyDownMessage:
if (hasFocus()) {
View* view = View::getView(this);
if (view) {
gfx::Rect vp = view->getViewportBounds();
gfx::Point scroll = view->getViewScroll();
int textheight = getTextHeight();
switch (static_cast<KeyMessage*>(msg)->scancode()) {
case kKeyLeft:
scroll.x -= vp.w/2;
view->setViewScroll(scroll);
break;
case kKeyRight:
scroll.x += vp.w/2;
view->setViewScroll(scroll);
break;
case kKeyUp:
scroll.y -= vp.h/2;
view->setViewScroll(scroll);
break;
case kKeyDown:
scroll.y += vp.h/2;
view->setViewScroll(scroll);
break;
case kKeyPageUp:
scroll.y -= (vp.h-textheight);
view->setViewScroll(scroll);
break;
case kKeyPageDown:
scroll.y += (vp.h-textheight);
view->setViewScroll(scroll);
break;
case kKeyHome:
scroll.y = 0;
view->setViewScroll(scroll);
break;
case kKeyEnd:
scroll.y = getBounds().h - vp.h;
view->setViewScroll(scroll);
break;
default:
return Widget::onProcessMessage(msg);
}
}
return true;
}
break;
case kMouseDownMessage: {
View* view = View::getView(this);
if (view) {
captureMouse();
m_oldPos = static_cast<MouseMessage*>(msg)->position();
set_mouse_cursor(kScrollCursor);
return true;
}
break;
}
case kMouseMoveMessage: {
View* view = View::getView(this);
if (view && hasCapture()) {
gfx::Point scroll = view->getViewScroll();
gfx::Point newPos = static_cast<MouseMessage*>(msg)->position();
scroll += m_oldPos - newPos;
view->setViewScroll(scroll);
m_oldPos = newPos;
}
break;
}
case kMouseUpMessage: {
View* view = View::getView(this);
if (view && hasCapture()) {
releaseMouse();
set_mouse_cursor(kArrowCursor);
return true;
}
break;
}
case kMouseWheelMessage: {
View* view = View::getView(this);
if (view) {
gfx::Point scroll = view->getViewScroll();
scroll += static_cast<MouseMessage*>(msg)->wheelDelta() * getTextHeight()*3;
view->setViewScroll(scroll);
}
break;
}
}
return Widget::onProcessMessage(msg);
}
bool ListBox::onProcessMessage(Message* msg)
{
switch (msg->type()) {
case kOpenMessage:
centerScroll();
break;
case kMouseDownMessage:
captureMouse();
case kMouseMoveMessage:
if (hasCapture()) {
gfx::Point mousePos = static_cast<MouseMessage*>(msg)->position();
int select = getSelectedIndex();
View* view = View::getView(this);
bool pick_item = true;
if (view) {
gfx::Rect vp = view->getViewportBounds();
if (mousePos.y < vp.y) {
int num = MAX(1, (vp.y - mousePos.y) / 8);
selectIndex(select-num);
pick_item = false;
}
else if (mousePos.y >= vp.y + vp.h) {
int num = MAX(1, (mousePos.y - (vp.y+vp.h-1)) / 8);
selectIndex(select+num);
pick_item = false;
}
}
if (pick_item) {
Widget* picked;
if (view) {
picked = view->getViewport()->pick(mousePos);
}
else {
picked = pick(mousePos);
}
/* if the picked widget is a child of the list, select it */
if (picked && hasChild(picked)) {
if (ListItem* pickedItem = dynamic_cast<ListItem*>(picked))
selectChild(pickedItem);
}
}
return true;
}
break;
case kMouseUpMessage:
releaseMouse();
break;
case kMouseWheelMessage: {
View* view = View::getView(this);
if (view) {
gfx::Point scroll = view->getViewScroll();
scroll += static_cast<MouseMessage*>(msg)->wheelDelta() * getTextHeight()*3;
view->setViewScroll(scroll);
}
break;
}
case kKeyDownMessage:
if (hasFocus() && !getChildren().empty()) {
int select = getSelectedIndex();
View* view = View::getView(this);
int bottom = MAX(0, getChildren().size()-1);
KeyMessage* keymsg = static_cast<KeyMessage*>(msg);
switch (keymsg->scancode()) {
case kKeyUp:
// Select previous element.
if (select >= 0)
select--;
// Or select the bottom of the list if there is no
// selected item.
else
select = bottom;
break;
case kKeyDown:
select++;
break;
case kKeyHome:
select = 0;
break;
case kKeyEnd:
select = bottom;
break;
case kKeyPageUp:
if (view) {
gfx::Rect vp = view->getViewportBounds();
select -= vp.h / getTextHeight();
}
else
select = 0;
break;
case kKeyPageDown:
if (view) {
gfx::Rect vp = view->getViewportBounds();
select += vp.h / getTextHeight();
}
else
select = bottom;
break;
case kKeyLeft:
case kKeyRight:
if (view) {
gfx::Rect vp = view->getViewportBounds();
gfx::Point scroll = view->getViewScroll();
int sgn = (keymsg->scancode() == kKeyLeft) ? -1: 1;
scroll.x += vp.w/2*sgn;
view->setViewScroll(scroll);
}
break;
default:
return Widget::onProcessMessage(msg);
}
selectIndex(MID(0, select, bottom));
return true;
}
break;
case kDoubleClickMessage:
onDoubleClickItem();
return true;
}
return Widget::onProcessMessage(msg);
}
void Trashdialog::mouseReleaseEvent(QMouseEvent *event)
{
Q_UNUSED(event);
releaseMouse();
}
void GLView::mouseReleaseEvent(QMouseEvent*)
{
mouseDrag = false;
releaseMouse();
}
bool Entry::onProcessMessage(Message* msg)
{
switch (msg->type()) {
case kTimerMessage:
if (hasFocus() && static_cast<TimerMessage*>(msg)->timer() == &m_timer) {
// Blinking caret
m_state = m_state ? false: true;
invalidate();
}
break;
case kFocusEnterMessage:
m_timer.start();
m_state = true;
invalidate();
if (m_lock_selection) {
m_lock_selection = false;
}
else {
selectAllText();
m_recent_focused = true;
}
break;
case kFocusLeaveMessage:
invalidate();
m_timer.stop();
if (!m_lock_selection)
deselectText();
m_recent_focused = false;
break;
case kKeyDownMessage:
if (hasFocus() && !isReadOnly()) {
// Command to execute
EntryCmd cmd = EntryCmd::NoOp;
KeyMessage* keymsg = static_cast<KeyMessage*>(msg);
KeyScancode scancode = keymsg->scancode();
switch (scancode) {
case kKeyLeft:
if (msg->ctrlPressed())
cmd = EntryCmd::BackwardWord;
else
cmd = EntryCmd::BackwardChar;
break;
case kKeyRight:
if (msg->ctrlPressed())
cmd = EntryCmd::ForwardWord;
else
cmd = EntryCmd::ForwardChar;
break;
case kKeyHome:
cmd = EntryCmd::BeginningOfLine;
break;
case kKeyEnd:
cmd = EntryCmd::EndOfLine;
break;
case kKeyDel:
if (msg->shiftPressed())
cmd = EntryCmd::Cut;
else
cmd = EntryCmd::DeleteForward;
break;
case kKeyInsert:
if (msg->shiftPressed())
cmd = EntryCmd::Paste;
else if (msg->ctrlPressed())
cmd = EntryCmd::Copy;
break;
case kKeyBackspace:
cmd = EntryCmd::DeleteBackward;
break;
default:
// Map common Windows shortcuts for Cut/Copy/Paste
#if defined __APPLE__
if (msg->onlyCmdPressed())
#else
if (msg->onlyCtrlPressed())
#endif
{
switch (scancode) {
case kKeyX: cmd = EntryCmd::Cut; break;
case kKeyC: cmd = EntryCmd::Copy; break;
case kKeyV: cmd = EntryCmd::Paste; break;
}
}
else if (keymsg->unicodeChar() >= 32) {
// Ctrl and Alt must be unpressed to insert a character
// in the text-field.
if ((msg->keyModifiers() & (kKeyCtrlModifier | kKeyAltModifier)) == 0) {
cmd = EntryCmd::InsertChar;
}
}
break;
}
if (cmd == EntryCmd::NoOp)
break;
executeCmd(cmd, keymsg->unicodeChar(),
(msg->shiftPressed()) ? true: false);
return true;
}
break;
case kMouseDownMessage:
captureMouse();
case kMouseMoveMessage:
if (hasCapture()) {
gfx::Point mousePos = static_cast<MouseMessage*>(msg)->position();
base::utf8_const_iterator utf8_begin = base::utf8_const_iterator(getText().begin());
base::utf8_const_iterator utf8_end = base::utf8_const_iterator(getText().end());
int textlen = base::utf8_length(getText());
int c, x;
bool move = true;
bool is_dirty = false;
// Backward scroll
if (mousePos.x < getBounds().x) {
if (m_scroll > 0) {
m_caret = --m_scroll;
move = false;
is_dirty = true;
invalidate();
}
}
// Forward scroll
else if (mousePos.x >= getBounds().x2()) {
if (m_scroll < textlen - getAvailableTextLength()) {
m_scroll++;
x = getBounds().x + this->border_width.l;
for (c=m_scroll; utf8_begin != utf8_end; ++c) {
int ch = (c < textlen ? *(utf8_begin+c) : ' ');
x += getFont()->charWidth(ch);
if (x > getBounds().x2()-this->border_width.r) {
c--;
break;
}
}
m_caret = c;
move = false;
is_dirty = true;
invalidate();
}
}
c = getCaretFromMouse(static_cast<MouseMessage*>(msg));
if (static_cast<MouseMessage*>(msg)->left() ||
(move && !isPosInSelection(c))) {
// Move caret
if (move) {
if (m_caret != c) {
m_caret = c;
is_dirty = true;
invalidate();
}
}
// Move selection
if (m_recent_focused) {
m_recent_focused = false;
m_select = m_caret;
}
else if (msg->type() == kMouseDownMessage)
m_select = m_caret;
}
// Show the caret
if (is_dirty) {
m_timer.start();
m_state = true;
}
return true;
}
break;
case kMouseUpMessage:
if (hasCapture()) {
releaseMouse();
MouseMessage* mouseMsg = static_cast<MouseMessage*>(msg);
if (mouseMsg->right()) {
// This flag is disabled in kFocusEnterMessage message handler.
m_lock_selection = true;
showEditPopupMenu(mouseMsg->position());
requestFocus();
}
}
return true;
case kDoubleClickMessage:
forwardWord();
m_select = m_caret;
backwardWord();
invalidate();
return true;
case kMouseEnterMessage:
case kMouseLeaveMessage:
// TODO theme stuff
if (isEnabled())
invalidate();
break;
}
return Widget::onProcessMessage(msg);
}
//____________________________________________________________________
bool SplitterProxy::event( QEvent *event )
{
switch( event->type() )
{
case QEvent::MouseMove:
case QEvent::MouseButtonPress:
case QEvent::MouseButtonRelease:
{
// check splitter
if( !_splitter ) return false;
event->accept();
// grab on mouse press
if( event->type() == QEvent::MouseButtonPress) grabMouse();
parentWidget()->setUpdatesEnabled(false);
resize(1,1);
parentWidget()->setUpdatesEnabled(true);
// cast to mouse event
QMouseEvent *mouseEvent( static_cast<QMouseEvent*>( event ) );
// get relevant position to post mouse drag event to application
if( event->type() == QEvent::MouseButtonPress )
{
// use hook, to make sure splitter is properly dragged
QMouseEvent mouseEvent2(
mouseEvent->type(),
_hook,
_splitter.data()->mapToGlobal(_hook),
mouseEvent->button(),
mouseEvent->buttons(), mouseEvent->modifiers());
QCoreApplication::sendEvent( _splitter.data(), &mouseEvent2 );
} else {
// map event position to current splitter and post.
QMouseEvent mouseEvent2(
mouseEvent->type(),
_splitter.data()->mapFromGlobal( mouseEvent->globalPos() ),
mouseEvent->globalPos(),
mouseEvent->button(),
mouseEvent->buttons(), mouseEvent->modifiers());
QCoreApplication::sendEvent( _splitter.data(), &mouseEvent2 );
}
// release grab on mouse-Release
if( event->type() == QEvent::MouseButtonRelease && mouseGrabber() == this )
{ releaseMouse(); }
return true;
}
case QEvent::Timer:
if( static_cast<QTimerEvent*>( event )->timerId() != _timerId )
{ return QWidget::event( event ); }
if( mouseGrabber() == this )
{ return true; }
/*
Fall through is intended.
We somehow lost a QEvent::Leave and gonna fix that from here
*/
case QEvent::HoverLeave:
case QEvent::Leave:
{
// reset splitter
if( isVisible() && !rect().contains( mapFromGlobal( QCursor::pos() ) ) )
{ clearSplitter(); }
return true;
}
default:
return QWidget::event( event );
}
}
bool ColorShades::onProcessMessage(ui::Message* msg)
{
switch (msg->type()) {
case ui::kOpenMessage:
if (m_click == DragAndDropEntries) {
// TODO This connection should be in the ContextBar
m_conn = ColorBar::instance()->ChangeSelection.connect(
base::Bind<void>(&ColorShades::onChangeColorBarSelection, this));
}
break;
case ui::kSetCursorMessage:
if (hasCapture()) {
ui::set_mouse_cursor(ui::kMoveCursor);
return true;
}
else if (m_click == ClickEntries &&
m_hotIndex >= 0 &&
m_hotIndex < int(m_shade.size())) {
ui::set_mouse_cursor(ui::kHandCursor);
return true;
}
break;
case ui::kMouseEnterMessage:
case ui::kMouseLeaveMessage:
if (!hasCapture())
m_hotIndex = -1;
invalidate();
break;
case ui::kMouseDownMessage:
if (m_hotIndex >= 0 &&
m_hotIndex < int(m_shade.size())) {
switch (m_click) {
case ClickEntries:
Click();
m_hotIndex = -1;
invalidate();
break;
case DragAndDropEntries:
m_dragIndex = m_hotIndex;
m_dropBefore = false;
captureMouse();
break;
}
}
break;
case ui::kMouseUpMessage: {
if (m_click == ClickWholeShade) {
setSelected(true);
Click();
closeWindow();
}
if (m_dragIndex >= 0) {
ASSERT(m_dragIndex < int(m_shade.size()));
auto color = m_shade[m_dragIndex];
m_shade.erase(m_shade.begin()+m_dragIndex);
if (m_hotIndex >= 0)
m_shade.insert(m_shade.begin()+m_hotIndex, color);
m_dragIndex = -1;
invalidate();
// Relayout the context bar if we have removed an entry.
if (m_hotIndex < 0)
parent()->parent()->layout();
}
if (hasCapture())
releaseMouse();
break;
}
case ui::kMouseMoveMessage: {
ui::MouseMessage* mouseMsg = static_cast<ui::MouseMessage*>(msg);
gfx::Point mousePos = mouseMsg->position() - bounds().origin();
gfx::Rect bounds = clientBounds();
int hot = -1;
bounds.shrink(3*ui::guiscale());
if (bounds.contains(mousePos)) {
int count = size();
hot = (mousePos.x - bounds.x) / (m_boxSize*ui::guiscale());
hot = MID(0, hot, count-1);
}
if (m_hotIndex != hot) {
m_hotIndex = hot;
invalidate();
}
bool dropBefore =
(hot >= 0 && mousePos.x < (bounds.x+m_boxSize*ui::guiscale()*hot)+m_boxSize*ui::guiscale()/2);
if (m_dropBefore != dropBefore) {
m_dropBefore = dropBefore;
invalidate();
}
break;
}
}
return Widget::onProcessMessage(msg);
}
void UimToolbarDraggingHandler::mouseReleaseEvent( QMouseEvent * /* e */ )
{
isDragging = false;
releaseMouse();
}
ColorPicker::~ColorPicker()
{
releaseMouse();
releaseKeyboard();
}
void SettingsWidget::releaseAll()
{
releaseKeyboard();
releaseMouse();
_waitingForHotkey = false;
}
void ClickableLabel::mouseReleaseEvent( QMouseEvent *ev )
{
emit releaseMouse(ev->pos());
}
//____________________________________________________________________________________
bool FrameShadowBase::event(QEvent *e)
{
// paintEvents are handled separately
if (e->type() == QEvent::Paint) return QWidget::event(e);
QWidget *viewport( FrameShadowBase::viewport() );
switch (e->type())
{
case QEvent::DragEnter:
case QEvent::DragMove:
case QEvent::DragLeave:
case QEvent::Drop:
if( viewport )
{
setAcceptDrops(viewport->acceptDrops());
return viewport->QObject::event(e);
}
break;
case QEvent::Enter:
if( viewport ) {
setCursor(viewport->cursor());
setAcceptDrops(viewport->acceptDrops());
}
break;
case QEvent::ContextMenu:
if( viewport )
{
QContextMenuEvent *me = static_cast<QContextMenuEvent *>(e);
QContextMenuEvent *ne = new QContextMenuEvent(me->reason(), parentWidget()->mapFromGlobal(me->globalPos()), me->globalPos());
QApplication::sendEvent(viewport, ne);
e->accept();
return true;
}
break;
case QEvent::MouseButtonPress: releaseMouse();
case QEvent::MouseMove:
case QEvent::MouseButtonRelease:
if( viewport )
{
QMouseEvent *me = static_cast<QMouseEvent *>(e);
QMouseEvent *ne = new QMouseEvent(e->type(), parentWidget()->mapFromGlobal(me->globalPos()), me->globalPos(), me->button(), me->buttons(), me->modifiers());
QApplication::sendEvent(viewport, ne);
e->accept();
return true;
}
break;
default:
break;
}
e->ignore();
return false;
}
bool SimpleKeyGrabberButton::eventFilter(QObject *obj, QEvent *event)
{
Q_UNUSED(obj);
int controlcode = 0;
if (grabNextAction && event->type() == QEvent::MouseButtonRelease)
{
QMouseEvent *mouseEve = (QMouseEvent*) event;
if (mouseEve->button() == Qt::RightButton)
{
controlcode = 3;
}
else if (mouseEve->button() == Qt::MiddleButton)
{
controlcode = 2;
}
else {
controlcode = mouseEve->button();
}
setText(QString(tr("Mouse")).append(" ").append(QString::number(controlcode)));
buttonslot.setSlotCode(controlcode);
buttonslot.setSlotMode(JoyButtonSlot::JoyMouseButton);
releaseMouse();
releaseKeyboard();
grabNextAction = grabbingWheel = false;
emit buttonCodeChanged(controlcode);
}
else if (grabNextAction && event->type() == QEvent::KeyRelease)
{
QKeyEvent *keyEve = (QKeyEvent*) event;
int tempcode = keyEve->nativeScanCode();
int virtualactual = keyEve->nativeVirtualKey();
#ifdef Q_OS_WIN
// Find more specific virtual key (VK_SHIFT -> VK_LSHIFT)
// by checking for extended bit in scan code.
int finalvirtual = WinInfo::correctVirtualKey(tempcode, virtualactual);
int checkalias = AntKeyMapper::returnQtKey(virtualactual, tempcode);
#else
// Obtain group 1 X11 keysym. Removes effects from modifiers.
int finalvirtual = X11KeyCodeToX11KeySym(tempcode);
// Check for alias against group 1 keysym.
int checkalias = AntKeyMapper::returnQtKey(finalvirtual);
#endif
controlcode = tempcode;
if ((keyEve->modifiers() & Qt::ControlModifier) && keyEve->key() == Qt::Key_X)
{
controlcode = 0;
setText("");
}
else if (controlcode <= 0)
{
controlcode = 0;
setText("");
}
else
{
if (checkalias > 0)
{
buttonslot.setSlotCode(finalvirtual, checkalias);
buttonslot.setSlotMode(JoyButtonSlot::JoyKeyboard);
setText(keysymToKey(finalvirtual, checkalias).toUpper());
}
else
{
buttonslot.setSlotCode(virtualactual);
buttonslot.setSlotMode(JoyButtonSlot::JoyKeyboard);
setText(keysymToKey(finalvirtual).toUpper());
}
}
grabNextAction = false;
grabbingWheel = false;
releaseMouse();
releaseKeyboard();
emit buttonCodeChanged(controlcode);
}
else if (grabNextAction && event->type() == QEvent::Wheel && !grabbingWheel)
{
grabbingWheel = true;
}
else if (grabNextAction && event->type() == QEvent::Wheel)
{
QWheelEvent *wheelEve = (QWheelEvent*) event;
QString text = QString(tr("Mouse")).append(" ");
if (wheelEve->orientation() == Qt::Vertical && wheelEve->delta() >= 120)
{
controlcode = 4;
}
else if (wheelEve->orientation() == Qt::Vertical && wheelEve->delta() <= -120)
{
controlcode = 5;
}
else if (wheelEve->orientation() == Qt::Horizontal && wheelEve->delta() >= 120)
{
controlcode = 6;
}
else if (wheelEve->orientation() == Qt::Horizontal && wheelEve->delta() <= -120)
{
controlcode = 7;
}
if (controlcode > 0)
{
text = text.append(QString::number(controlcode));
setText(text);
grabNextAction = false;
grabbingWheel = false;
releaseMouse();
releaseKeyboard();
buttonslot.setSlotCode(controlcode);
buttonslot.setSlotMode(JoyButtonSlot::JoyMouseButton);
emit buttonCodeChanged(controlcode);
}
}
else if (event->type() == QEvent::MouseButtonRelease)
{
QMouseEvent *mouseEve = (QMouseEvent*) event;
if (mouseEve->button() == Qt::LeftButton)
{
grabNextAction = true;
setText("...");
setFocus();
grabKeyboard();
grabMouse();
}
}
return false;
}
void LLToolCamera::onMouseCaptureLost()
{
releaseMouse();
}
void CResizer::onReleased()
{
m_buttonDown = false;
releaseMouse();
}
void Editor::editor_click_done()
{
releaseMouse();
clear_keybuf();
}
void CResizer::leaveEvent(QEvent* e)
{
e->accept();
releaseMouse();
}
bool ButtonBase::onProcessMessage(Message* msg)
{
switch (msg->type()) {
case kFocusEnterMessage:
case kFocusLeaveMessage:
if (isEnabled()) {
if (m_behaviorType == kButtonWidget) {
// Deselect the widget (maybe the user press the key, but
// before release it, changes the focus).
if (isSelected())
setSelected(false);
}
// TODO theme specific stuff
invalidate();
}
break;
case kKeyDownMessage: {
KeyMessage* keymsg = static_cast<KeyMessage*>(msg);
KeyScancode scancode = keymsg->scancode();
// If the button is enabled.
if (isEnabled()) {
bool mnemonicPressed =
((msg->altPressed() || msg->cmdPressed()) &&
isMnemonicPressed(keymsg));
// For kButtonWidget
if (m_behaviorType == kButtonWidget) {
// Has focus and press enter/space
if (hasFocus()) {
if ((scancode == kKeyEnter) ||
(scancode == kKeyEnterPad) ||
(scancode == kKeySpace)) {
setSelected(true);
return true;
}
}
// Check if the user pressed mnemonic.
if (mnemonicPressed) {
setSelected(true);
return true;
}
// Magnetic widget catches ENTERs
else if (isFocusMagnet() &&
((scancode == kKeyEnter) ||
(scancode == kKeyEnterPad))) {
manager()->setFocus(this);
// Dispatch focus movement messages (because the buttons
// process them)
manager()->dispatchMessages();
setSelected(true);
return true;
}
}
// For kCheckWidget or kRadioWidget
else {
/* if the widget has the focus and the user press space or
if the user press Alt+the underscored letter of the button */
if ((hasFocus() && (scancode == kKeySpace)) || mnemonicPressed) {
if (m_behaviorType == kCheckWidget) {
// Swap the select status
setSelected(!isSelected());
invalidate();
}
else if (m_behaviorType == kRadioWidget) {
if (!isSelected()) {
setSelected(true);
}
}
return true;
}
}
}
break;
}
case kKeyUpMessage:
if (isEnabled()) {
if (m_behaviorType == kButtonWidget) {
if (isSelected()) {
generateButtonSelectSignal();
return true;
}
}
}
break;
case kMouseDownMessage:
switch (m_behaviorType) {
case kButtonWidget:
if (isEnabled()) {
setSelected(true);
m_pressedStatus = isSelected();
captureMouse();
}
return true;
case kCheckWidget:
if (isEnabled()) {
setSelected(!isSelected());
m_pressedStatus = isSelected();
captureMouse();
}
return true;
case kRadioWidget:
if (isEnabled()) {
if (!isSelected()) {
m_handleSelect = false;
setSelected(true);
m_handleSelect = true;
m_pressedStatus = isSelected();
captureMouse();
}
}
return true;
}
break;
case kMouseUpMessage:
if (hasCapture()) {
releaseMouse();
if (hasMouseOver()) {
switch (m_behaviorType) {
case kButtonWidget:
generateButtonSelectSignal();
break;
case kCheckWidget:
{
// Fire onClick() event
Event ev(this);
onClick(ev);
invalidate();
}
break;
case kRadioWidget:
{
setSelected(false);
setSelected(true);
// Fire onClick() event
Event ev(this);
onClick(ev);
}
break;
}
}
return true;
}
break;
case kMouseMoveMessage:
if (isEnabled() && hasCapture()) {
bool hasMouse = hasMouseOver();
m_handleSelect = false;
// Switch state when the mouse go out
if ((hasMouse && isSelected() != m_pressedStatus) ||
(!hasMouse && isSelected() == m_pressedStatus)) {
if (hasMouse)
setSelected(m_pressedStatus);
else
setSelected(!m_pressedStatus);
}
m_handleSelect = true;
}
break;
case kMouseEnterMessage:
case kMouseLeaveMessage:
// TODO theme stuff
if (isEnabled())
invalidate();
break;
}
return Widget::onProcessMessage(msg);
}
void ResizeFrame::mouseReleaseEvent( QMouseEvent* mouseEvent )
{
releaseMouse();
}
void ScrollBar::mouseReleaseEvent(QMouseEvent *)
{
mouse_grabed_ = false;
emit sliderReleased();
releaseMouse();
}
void LLToolCamera::onMouseCaptureLost()
{
releaseMouse();
handleRightMouseUp(0,0,0);
}
bool TextBox::onProcessMessage(Message* msg)
{
switch (msg->type) {
case JM_DRAW:
getTheme()->draw_textbox(this, &msg->draw.rect);
return true;
case JM_SIGNAL:
if (msg->signal.num == JI_SIGNAL_SET_TEXT) {
View* view = View::getView(this);
if (view)
view->updateView();
}
break;
case JM_KEYPRESSED:
if (hasFocus()) {
View* view = View::getView(this);
if (view) {
gfx::Rect vp = view->getViewportBounds();
gfx::Point scroll = view->getViewScroll();
int textheight = jwidget_get_text_height(this);
switch (msg->key.scancode) {
case KEY_LEFT:
scroll.x -= vp.w/2;
view->setViewScroll(scroll);
break;
case KEY_RIGHT:
scroll.x += vp.w/2;
view->setViewScroll(scroll);
break;
case KEY_UP:
scroll.y -= vp.h/2;
view->setViewScroll(scroll);
break;
case KEY_DOWN:
scroll.y += vp.h/2;
view->setViewScroll(scroll);
break;
case KEY_PGUP:
scroll.y -= (vp.h-textheight);
view->setViewScroll(scroll);
break;
case KEY_PGDN:
scroll.y += (vp.h-textheight);
view->setViewScroll(scroll);
break;
case KEY_HOME:
scroll.y = 0;
view->setViewScroll(scroll);
break;
case KEY_END:
scroll.y = jrect_h(this->rc) - vp.h;
view->setViewScroll(scroll);
break;
default:
return false;
}
}
return true;
}
break;
case JM_BUTTONPRESSED: {
View* view = View::getView(this);
if (view) {
captureMouse();
jmouse_set_cursor(JI_CURSOR_SCROLL);
return true;
}
break;
}
case JM_MOTION: {
View* view = View::getView(this);
if (view && hasCapture()) {
gfx::Rect vp = view->getViewportBounds();
gfx::Point scroll = view->getViewScroll();
scroll.x += jmouse_x(1) - jmouse_x(0);
scroll.y += jmouse_y(1) - jmouse_y(0);
view->setViewScroll(scroll);
jmouse_control_infinite_scroll(vp);
}
break;
}
case JM_BUTTONRELEASED: {
View* view = View::getView(this);
if (view && hasCapture()) {
releaseMouse();
jmouse_set_cursor(JI_CURSOR_NORMAL);
return true;
}
break;
}
case JM_WHEEL: {
View* view = View::getView(this);
if (view) {
gfx::Point scroll = view->getViewScroll();
scroll.y += (jmouse_z(1) - jmouse_z(0)) * jwidget_get_text_height(this)*3;
view->setViewScroll(scroll);
}
break;
}
}
return Widget::onProcessMessage(msg);
}
void CColorPopup::hideEvent (QHideEvent *)
{
releaseMouse ();
}
void SplitterHandle::mouseReleaseEvent(QMouseEvent* event)
{
QSplitterHandle::mouseReleaseEvent(event);
releaseMouse();
}
void Deskdev::mouseReleaseEvent(QMouseEvent *event)
{
Q_UNUSED(event);
releaseMouse();
}
