diff --git a/libs/ui/input/kis_input_manager.cpp b/libs/ui/input/kis_input_manager.cpp
index 34e482f9a7..b287628c31 100644
--- a/libs/ui/input/kis_input_manager.cpp
+++ b/libs/ui/input/kis_input_manager.cpp
@@ -1,608 +1,613 @@
 /* This file is part of the KDE project
  *
  *  Copyright (C) 2012 Arjen Hiemstra <ahiemstra@heimr.nl>
  *  Copyright (C) 2015 Michael Abrahams <miabraha@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_input_manager.h"
 
 #include <kis_debug.h>
 #include <QQueue>
 #include <klocalizedstring.h>
 #include <QApplication>
 
 #include <KoToolManager.h>
 
 #include "kis_tool_proxy.h"
 
 #include <kis_config.h>
 #include <kis_canvas2.h>
 #include <KisViewManager.h>
 #include <kis_image.h>
 #include <kis_canvas_resource_provider.h>
 #include <kis_favorite_resource_manager.h>
 
 #include "kis_abstract_input_action.h"
 #include "kis_tool_invocation_action.h"
 #include "kis_pan_action.h"
 #include "kis_alternate_invocation_action.h"
 #include "kis_rotate_canvas_action.h"
 #include "kis_zoom_action.h"
 #include "kis_show_palette_action.h"
 #include "kis_change_primary_setting_action.h"
 
 #include "kis_shortcut_matcher.h"
 #include "kis_stroke_shortcut.h"
 #include "kis_single_action_shortcut.h"
 #include "kis_touch_shortcut.h"
 
 #include "kis_input_profile.h"
 #include "kis_input_profile_manager.h"
 #include "kis_shortcut_configuration.h"
 
 #include <input/kis_tablet_debugger.h>
 #include <kis_signal_compressor.h>
 
 #include "kis_extended_modifiers_mapper.h"
 #include "kis_input_manager_p.h"
 
 template <typename T>
 uint qHash(QPointer<T> value) {
     return reinterpret_cast<quintptr>(value.data());
 }
 
 
 #define start_ignore_cursor_events() d->blockMouseEvents()
 #define stop_ignore_cursor_events() d->allowMouseEvents()
 #define break_if_should_ignore_cursor_events() if (d->ignoringQtCursorEvents()) break;
+#define break_if_tablet_active() if (d->tabletActive) break;
 
 // Touch rejection: if touch is disabled on canvas, no need to block mouse press events
 #define touch_start_block_press_events()  d->touchHasBlockedPressEvents = d->disableTouchOnCanvas;
 #define touch_stop_block_press_events()  d->touchHasBlockedPressEvents = false;
 #define break_if_touch_blocked_press_events() if (d->touchHasBlockedPressEvents) break;
 #define touch_eat_one_mouse_press() if (d->disableTouchOnCanvas) d->eatOneMousePress();
 
 KisInputManager::KisInputManager(QObject *parent)
     : QObject(parent), d(new Private(this))
 {
     d->setupActions();
 
     connect(KoToolManager::instance(), SIGNAL(changedTool(KoCanvasController*,int)),
             SLOT(slotToolChanged()));
     connect(&d->moveEventCompressor, SIGNAL(timeout()), SLOT(slotCompressedMoveEvent()));
 
 
-#ifndef Q_OS_MAC
     QApplication::instance()->
         installEventFilter(new Private::ProximityNotifier(d, this));
-#endif
 }
 
 KisInputManager::~KisInputManager()
 {
     delete d;
 }
 
 void KisInputManager::addTrackedCanvas(KisCanvas2 *canvas)
 {
     d->canvasSwitcher.addCanvas(canvas);
 }
 
 void KisInputManager::removeTrackedCanvas(KisCanvas2 *canvas)
 {
     d->canvasSwitcher.removeCanvas(canvas);
 }
 
 void KisInputManager::toggleTabletLogger()
 {
     KisTabletDebugger::instance()->toggleDebugging();
 }
 
 void KisInputManager::attachPriorityEventFilter(QObject *filter, int priority)
 {
     Private::PriorityList::iterator begin = d->priorityEventFilter.begin();
     Private::PriorityList::iterator it = begin;
     Private::PriorityList::iterator end = d->priorityEventFilter.end();
 
     it = std::find_if(begin, end,
                       [filter] (const Private::PriorityPair &a) { return a.second == filter; });
 
     if (it != end) return;
 
     it = std::find_if(begin, end,
                       [priority] (const Private::PriorityPair &a) { return a.first > priority; });
 
     d->priorityEventFilter.insert(it, qMakePair(priority, filter));
     d->priorityEventFilterSeqNo++;
 }
 
 void KisInputManager::detachPriorityEventFilter(QObject *filter)
 {
     Private::PriorityList::iterator it = d->priorityEventFilter.begin();
     Private::PriorityList::iterator end = d->priorityEventFilter.end();
 
     it = std::find_if(it, end,
                       [filter] (const Private::PriorityPair &a) { return a.second == filter; });
 
     if (it != end) {
         d->priorityEventFilter.erase(it);
     }
 }
 
 void KisInputManager::setupAsEventFilter(QObject *receiver)
 {
     if (d->eventsReceiver) {
         d->eventsReceiver->removeEventFilter(this);
     }
 
     d->eventsReceiver = receiver;
 
     if (d->eventsReceiver) {
         d->eventsReceiver->installEventFilter(this);
     }
 }
 
 void KisInputManager::stopIgnoringEvents()
 {
     stop_ignore_cursor_events();
 }
 
 void KisInputManager::slotFocusOnEnter(bool value)
 {
     Q_UNUSED(value);
     // not used anymore
 }
 
 #if defined (__clang__)
 #pragma GCC diagnostic ignored "-Wswitch"
 #endif
 
 bool KisInputManager::eventFilter(QObject* object, QEvent* event)
 {
     if (object != d->eventsReceiver) return false;
 
     if (d->eventEater.eventFilter(object, event)) return false;
 
     if (!d->matcher.hasRunningShortcut()) {
 
         int savedPriorityEventFilterSeqNo = d->priorityEventFilterSeqNo;
 
         for (auto it = d->priorityEventFilter.begin(); it != d->priorityEventFilter.end(); /*noop*/) {
             const QPointer<QObject> &filter = it->second;
 
             if (filter.isNull()) {
                 it = d->priorityEventFilter.erase(it);
 
                 d->priorityEventFilterSeqNo++;
                 savedPriorityEventFilterSeqNo++;
                 continue;
             }
 
             if (filter->eventFilter(object, event)) return true;
 
             /**
              * If the filter removed itself from the filters list or
              * added something there, just exit the loop
              */
             if (d->priorityEventFilterSeqNo != savedPriorityEventFilterSeqNo) {
                 return true;
             }
 
             ++it;
         }
 
         // KoToolProxy needs to pre-process some events to ensure the
         // global shortcuts (not the input manager's ones) are not
         // executed, in particular, this line will accept events when the
         // tool is in text editing, preventing shortcut triggering
         d->toolProxy->processEvent(event);
     }
 
     // Continue with the actual switch statement...
     return eventFilterImpl(event);
 }
 
 template <class Event>
 bool KisInputManager::compressMoveEventCommon(Event *event)
 {
     /**
      * We construct a copy of this event object, so we must ensure it
      * has a correct type.
      */
     static_assert(std::is_same<Event, QMouseEvent>::value ||
                   std::is_same<Event, QTabletEvent>::value,
                   "event should a mouse or a tablet event");
 
     bool retval = false;
 
     /**
      * Compress the events if the tool doesn't need high resolution input
      */
     if ((event->type() == QEvent::MouseMove ||
          event->type() == QEvent::TabletMove) &&
         (!d->matcher.supportsHiResInputEvents() ||
          d->testingCompressBrushEvents)) {
 
         d->compressedMoveEvent.reset(new Event(*event));
         d->moveEventCompressor.start();
 
         /**
          * On Linux Qt eats the rest of unneeded events if we
          * ignore the first of the chunk of tablet events. So
          * generally we should never activate this feature. Only
          * for testing purposes!
          */
         if (d->testingAcceptCompressedTabletEvents) {
             event->setAccepted(true);
         }
 
         retval = true;
     } else {
         slotCompressedMoveEvent();
         retval = d->handleCompressedTabletEvent(event);
     }
 
     return retval;
 }
 
 bool KisInputManager::eventFilterImpl(QEvent * event)
 {
     // TODO: Handle touch events correctly.
     bool retval = false;
 
     switch (event->type()) {
     case QEvent::MouseButtonPress:
     case QEvent::MouseButtonDblClick: {
         d->debugEvent<QMouseEvent, true>(event);
+        //Block mouse press events on Genius tablets
+        break_if_tablet_active();
         break_if_should_ignore_cursor_events();
         break_if_touch_blocked_press_events();
 
         QMouseEvent *mouseEvent = static_cast<QMouseEvent*>(event);
 
         if (d->tryHidePopupPalette()) {
             retval = true;
         } else {
             //Make sure the input actions know we are active.
             KisAbstractInputAction::setInputManager(this);
             retval = d->matcher.buttonPressed(mouseEvent->button(), mouseEvent);
         }
+        //Reset signal compressor to prevent processing events before press late
+        d->resetCompressor();
         event->setAccepted(retval);
         break;
     }
     case QEvent::MouseButtonRelease: {
         d->debugEvent<QMouseEvent, true>(event);
         break_if_should_ignore_cursor_events();
         break_if_touch_blocked_press_events();
 
         QMouseEvent *mouseEvent = static_cast<QMouseEvent*>(event);
         retval = d->matcher.buttonReleased(mouseEvent->button(), mouseEvent);
         event->setAccepted(retval);
         break;
     }
     case QEvent::ShortcutOverride: {
         d->debugEvent<QKeyEvent, false>(event);
         QKeyEvent *keyEvent = static_cast<QKeyEvent*>(event);
 
         Qt::Key key = KisExtendedModifiersMapper::workaroundShiftAltMetaHell(keyEvent);
 
         if (!keyEvent->isAutoRepeat()) {
             retval = d->matcher.keyPressed(key);
         } else {
             retval = d->matcher.autoRepeatedKeyPressed(key);
         }
 
         /**
          * Workaround for temporary switching of tools by
          * KoCanvasControllerWidget. We don't need this switch because
          * we handle it ourselves.
          */
         retval |= !d->forwardAllEventsToTool &&
                 (keyEvent->key() == Qt::Key_Space ||
                  keyEvent->key() == Qt::Key_Escape);
 
         break;
     }
     case QEvent::KeyRelease: {
         d->debugEvent<QKeyEvent, false>(event);
         QKeyEvent *keyEvent = static_cast<QKeyEvent*>(event);
 
         if (!keyEvent->isAutoRepeat()) {
             Qt::Key key = KisExtendedModifiersMapper::workaroundShiftAltMetaHell(keyEvent);
             retval = d->matcher.keyReleased(key);
         }
         break;
     }
     case QEvent::MouseMove: {
         d->debugEvent<QMouseEvent, true>(event);
         break_if_should_ignore_cursor_events();
 
         QMouseEvent *mouseEvent = static_cast<QMouseEvent*>(event);
         retval = compressMoveEventCommon(mouseEvent);
 
         break;
     }
     case QEvent::Wheel: {
         d->debugEvent<QWheelEvent, false>(event);
         QWheelEvent *wheelEvent = static_cast<QWheelEvent*>(event);
         KisSingleActionShortcut::WheelAction action;
 
         /**
          * Ignore delta 0 events on OSX, since they are triggered by tablet
          * proximity when using Wacom devices.
          */
 #ifdef Q_OS_MAC
         if(wheelEvent->delta() == 0) {
             retval = true;
             break;
         }
 #endif
 
         if(wheelEvent->orientation() == Qt::Horizontal) {
             if(wheelEvent->delta() < 0) {
                 action = KisSingleActionShortcut::WheelRight;
             }
             else {
                 action = KisSingleActionShortcut::WheelLeft;
             }
         }
         else {
             if(wheelEvent->delta() > 0) {
                 action = KisSingleActionShortcut::WheelUp;
             }
             else {
                 action = KisSingleActionShortcut::WheelDown;
             }
         }
 
         //Make sure the input actions know we are active.
         KisAbstractInputAction::setInputManager(this);
         retval = d->matcher.wheelEvent(action, wheelEvent);
         break;
     }
     case QEvent::Enter:
         d->debugEvent<QEvent, false>(event);
         d->containsPointer = true;
         //Make sure the input actions know we are active.
         KisAbstractInputAction::setInputManager(this);
 
         stop_ignore_cursor_events();
         touch_stop_block_press_events();
 
         d->matcher.enterEvent();
         break;
     case QEvent::Leave:
         d->debugEvent<QEvent, false>(event);
         d->containsPointer = false;
         /**
          * We won't get a TabletProximityLeave event when the tablet
          * is hovering above some other widget, so restore cursor
          * events processing right now.
          */
         stop_ignore_cursor_events();
         touch_stop_block_press_events();
 
         d->matcher.leaveEvent();
         break;
     case QEvent::FocusIn:
         d->debugEvent<QEvent, false>(event);
         KisAbstractInputAction::setInputManager(this);
 
         //Clear all state so we don't have half-matched shortcuts dangling around.
         d->matcher.reinitialize();
 
         { // Emulate pressing of the key that are already pressed
             KisExtendedModifiersMapper mapper;
 
             Qt::KeyboardModifiers modifiers = mapper.queryStandardModifiers();
             Q_FOREACH (Qt::Key key, mapper.queryExtendedModifiers()) {
                 QKeyEvent kevent(QEvent::ShortcutOverride, key, modifiers);
                 eventFilterImpl(&kevent);
             }
         }
 
         stop_ignore_cursor_events();
         break;
     case QEvent::TabletRelease: {
 #ifdef Q_OS_MAC
         stop_ignore_cursor_events();
 #endif
         // break_if_touch_blocked_press_events();
         d->debugEvent<QTabletEvent, false>(event);
 
         QTabletEvent *tabletEvent = static_cast<QTabletEvent*>(event);
         retval = d->matcher.buttonReleased(tabletEvent->button(), tabletEvent);
         retval = true;
         event->setAccepted(true);
         break;
     }
 
 
     case QEvent::TabletMove: {
         d->debugEvent<QTabletEvent, false>(event);
 
         QTabletEvent *tabletEvent = static_cast<QTabletEvent*>(event);
         retval = compressMoveEventCommon(tabletEvent);
 
         /**
          * The flow of tablet events means the tablet is in the
          * proximity area, so activate it even when the
          * TabletEnterProximity event was missed (may happen when
          * changing focus of the window with tablet in the proximity
          * area)
          */
         start_ignore_cursor_events();
 
         break;
     }
 
     case QEvent::TabletPress: {
         d->debugEvent<QTabletEvent, false>(event);
         QTabletEvent *tabletEvent = static_cast<QTabletEvent*>(event);
         if (d->tryHidePopupPalette()) {
             retval = true;
         } else {
             //Make sure the input actions know we are active.
             KisAbstractInputAction::setInputManager(this);
             retval = d->matcher.buttonPressed(tabletEvent->button(), tabletEvent);
         }
         event->setAccepted(true);
         retval = true;
         start_ignore_cursor_events();
+        //Reset signal compressor to prevent processing events before press late
+        d->resetCompressor();
         d->eatOneMousePress();
         break;
     }
 
     case QEvent::TouchBegin:
         touch_start_block_press_events();
         touch_eat_one_mouse_press();
         if (d->tryHidePopupPalette()) {
             retval = true;
         } else {
             KisAbstractInputAction::setInputManager(this);
             retval = d->matcher.touchBeginEvent(static_cast<QTouchEvent*>(event));
             event->accept();
         }
         // d->resetSavedTabletEvent(event->type());
         break;
     case QEvent::TouchUpdate: {
         QTouchEvent *tevent = static_cast<QTouchEvent*>(event);
 #ifdef Q_OS_MAC
         int count = 0;
         Q_FOREACH (const QTouchEvent::TouchPoint &point, tevent->touchPoints()) {
             if (point.state() != Qt::TouchPointReleased) {
                 count++;
             }
         }
 
         if (count < 2 && tevent->touchPoints().length() > count) {
             touch_stop_block_press_events();
             d->saveTouchEvent(tevent);
             retval = d->matcher.touchEndEvent(tevent);
             delete d->lastTouchEvent;
             d->lastTouchEvent = 0;
         } else {
 #endif
             touch_start_block_press_events();
             KisAbstractInputAction::setInputManager(this);
             retval = d->matcher.touchUpdateEvent(tevent);
 #ifdef Q_OS_MAC
         }
 #endif
         event->accept();
 
         // d->resetSavedTabletEvent(event->type());
         break;
     }
     case QEvent::TouchEnd:
         touch_stop_block_press_events();
         d->saveTouchEvent(static_cast<QTouchEvent*>(event));
         retval = d->matcher.touchEndEvent(static_cast<QTouchEvent*>(event));
         event->accept();
         // d->resetSavedTabletEvent(event->type());
         delete d->lastTouchEvent;
         d->lastTouchEvent = 0;
         break;
     default:
         break;
     }
 
     return !retval ? d->processUnhandledEvent(event) : true;
 }
 
 
 void KisInputManager::slotCompressedMoveEvent()
 {
     if (d->compressedMoveEvent) {
         // touch_stop_block_press_events();
 
         (void) d->handleCompressedTabletEvent(d->compressedMoveEvent.data());
         d->compressedMoveEvent.reset();
         dbgKrita << "Compressed move event received.";
     } else {
         dbgKrita << "Unexpected empty move event";
     }
 }
 
 KisCanvas2* KisInputManager::canvas() const
 {
     return d->canvas;
 }
 
 KisToolProxy* KisInputManager::toolProxy() const
 {
     return d->toolProxy;
 }
 
 QTouchEvent *KisInputManager::lastTouchEvent() const
 {
     return d->lastTouchEvent;
 }
 
 void KisInputManager::slotToolChanged()
 {
     auto toolManager = KoToolManager::instance();
     auto tool = toolManager->toolById(canvas(), toolManager->activeToolId());
     if (tool->isInTextMode()) {
         d->forwardAllEventsToTool = true;
         d->matcher.suppressAllActions(true);
     } else {
         d->forwardAllEventsToTool = false;
         d->matcher.suppressAllActions(false);
     }
 
     d->maskSyntheticEvents(tool->maskSyntheticEvents());
 }
 
 QPointF KisInputManager::widgetToDocument(const QPointF& position)
 {
     const QPointF half = QPointF(.5f, .5f);
     QPointF pixel = position + half;
     return d->canvas->coordinatesConverter()->widgetToDocument(pixel);
 }
 
 void KisInputManager::profileChanged()
 {
     d->matcher.clearShortcuts();
 
     KisInputProfile *profile = KisInputProfileManager::instance()->currentProfile();
     if (profile) {
         const QList<KisShortcutConfiguration*> shortcuts = profile->allShortcuts();
 
         for (KisShortcutConfiguration * const shortcut : shortcuts) {
             dbgUI << "Adding shortcut" << shortcut->keys() << "for action" << shortcut->action()->name();
             switch(shortcut->type()) {
             case KisShortcutConfiguration::KeyCombinationType:
                 d->addKeyShortcut(shortcut->action(), shortcut->mode(), shortcut->keys());
                 break;
             case KisShortcutConfiguration::MouseButtonType:
                 d->addStrokeShortcut(shortcut->action(), shortcut->mode(), shortcut->keys(), shortcut->buttons());
                 break;
             case KisShortcutConfiguration::MouseWheelType:
                 d->addWheelShortcut(shortcut->action(), shortcut->mode(), shortcut->keys(), shortcut->wheel());
                 break;
             case KisShortcutConfiguration::GestureType:
                 d->addTouchShortcut(shortcut->action(), shortcut->mode(), shortcut->gesture());
                 break;
             default:
                 break;
             }
         }
     }
     else {
         dbgKrita << "No Input Profile Found: canvas interaction will be impossible";
     }
 }
diff --git a/libs/ui/input/kis_input_manager_p.cpp b/libs/ui/input/kis_input_manager_p.cpp
index 114842104a..13a968e17d 100644
--- a/libs/ui/input/kis_input_manager_p.cpp
+++ b/libs/ui/input/kis_input_manager_p.cpp
@@ -1,518 +1,537 @@
 /*
  *  Copyright (C) 2015 Michael Abrahams <miabraha@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_input_manager_p.h"
 
 #include <QMap>
 #include <QApplication>
 #include <QScopedPointer>
 #include <QtGlobal>
 
 #include "kis_input_manager.h"
 #include "kis_config.h"
 #include "kis_abstract_input_action.h"
 #include "kis_tool_invocation_action.h"
 #include "kis_stroke_shortcut.h"
 #include "kis_touch_shortcut.h"
 #include "kis_input_profile_manager.h"
 
 /**
  * This hungry class EventEater encapsulates event masking logic.
  *
  * Its basic role is to kill synthetic mouseMove events sent by Xorg or Qt after
  * tablet events. Those events are sent in order to allow widgets that haven't
  * implemented tablet specific functionality to seamlessly behave as if one were
  * using a mouse. These synthetic events are *supposed* to be optional, or at
  * least come with a flag saying "This is a fake event!!" but neither of those
  * methods is trustworthy. (This is correct as of Qt 5.4 + Xorg.)
  *
  * Qt 5.4 provides no reliable way to see if a user's tablet is being hovered
  * over the pad, since it converts all tablethover events into mousemove, with
  * no option to turn this off. Moreover, sometimes the MouseButtonPress event
  * from the tapping their tablet happens BEFORE the TabletPress event. This
  * means we have to resort to a somewhat complicated logic. What makes this
  * truly a joke is that we are not guaranteed to observe TabletProximityEnter
  * events when we're using a tablet, either, you may only see an Enter event.
  *
  * Once we see tablet events heading our way, we can say pretty confidently that
  * every mouse event is fake. There are two painful cases to consider - a
  * mousePress event could arrive before the tabletPress event, or it could
  * arrive much later, e.g. after tabletRelease. The first was only seen on Linux
  * with Qt's XInput2 code, the solution was to hold onto mousePress events
  * temporarily and wait for tabletPress later, this is contained in git history
  * but is now removed. The second case is currently handled by the
  * eatOneMousePress function, which waits as long as necessary to detect and
  * block a single mouse press event.
  */
 
 static bool isMouseEventType(QEvent::Type t)
 {
     return (t == QEvent::MouseMove ||
             t == QEvent::MouseButtonPress ||
             t == QEvent::MouseButtonRelease ||
             t == QEvent::MouseButtonDblClick);
 }
 
 bool KisInputManager::Private::EventEater::eventFilter(QObject* target, QEvent* event )
 {
     Q_UNUSED(target)
 
     auto debugEvent = [&]() {
         if (KisTabletDebugger::instance()->debugEnabled()) {
             QString pre = QString("[BLOCKED]");
             QMouseEvent *ev = static_cast<QMouseEvent*>(event);
             dbgTablet << KisTabletDebugger::instance()->eventToString(*ev,pre);
         }
     };
 
     Qt::MouseEventSource source = static_cast<QMouseEvent*>(event)->source();
     if (peckish && event->type() == QEvent::MouseButtonPress
         // Drop one mouse press following tabletPress or touchBegin
         && (static_cast<QMouseEvent*>(event)->button() == Qt::LeftButton)) {
         peckish = false;
         debugEvent();
         return true;
     } else if (isMouseEventType(event->type()) &&
-               (hungry || (eatSyntheticEvents && source != 0))) {
-#ifdef Q_OS_MAC
-        if (eatSyntheticEvents && source != 2) {
-#endif
-            // Drop mouse events if enabled or event was synthetic & synthetic events are disabled
-            debugEvent();
-            return true;
-#ifdef Q_OS_MAC
-        }
-#endif
+               (hungry
+            // On Mac, we need mouse events when the tablet is in proximity, but not pressed down
+            // since tablet move events are not generated until after tablet press.
+            #ifndef Q_OS_MAC
+                || (eatSyntheticEvents && source != 0)
+            #endif
+                )) {
+        // Drop mouse events if enabled or event was synthetic & synthetic events are disabled
+        debugEvent();
+        return true;
     }
     return false; // All clear - let this one through!
 }
 
 
 void KisInputManager::Private::EventEater::activate()
 {
     if (!hungry && (KisTabletDebugger::instance()->debugEnabled()))
         qDebug() << "Start ignoring mouse events.";
     hungry = true;
 }
 
 void KisInputManager::Private::EventEater::deactivate()
 {
     if (hungry && (KisTabletDebugger::instance()->debugEnabled()))
         dbgTablet << "Stop ignoring mouse events.";
     hungry = false;
 }
 
 void KisInputManager::Private::EventEater::eatOneMousePress()
 {
 // #if defined(Q_OS_WIN)
     // Enable on other platforms if getting full-pressure splotches
     peckish = true;
 // #endif
 }
 
 bool KisInputManager::Private::ignoringQtCursorEvents()
 {
     return eventEater.hungry;
 }
 
 void KisInputManager::Private::maskSyntheticEvents(bool value)
 {
     eventEater.eatSyntheticEvents = value;
 }
 
 KisInputManager::Private::Private(KisInputManager *qq)
     : q(qq)
     , moveEventCompressor(10 /* ms */, KisSignalCompressor::FIRST_ACTIVE)
     , priorityEventFilterSeqNo(0)
     , canvasSwitcher(this, qq)
 {
     KisConfig cfg;
     disableTouchOnCanvas = cfg.disableTouchOnCanvas();
 
     moveEventCompressor.setDelay(cfg.tabletEventsDelay());
     testingAcceptCompressedTabletEvents = cfg.testingAcceptCompressedTabletEvents();
     testingCompressBrushEvents = cfg.testingCompressBrushEvents();
 }
 
 static const int InputWidgetsThreshold = 2000;
 static const int OtherWidgetsThreshold = 400;
 
 KisInputManager::Private::CanvasSwitcher::CanvasSwitcher(Private *_d, QObject *p)
     : QObject(p),
       d(_d),
       eatOneMouseStroke(false),
       focusSwitchThreshold(InputWidgetsThreshold)
 {
 }
 
 void KisInputManager::Private::CanvasSwitcher::setupFocusThreshold(QObject* object)
 {
     QWidget *widget = qobject_cast<QWidget*>(object);
     KIS_SAFE_ASSERT_RECOVER_RETURN(widget);
 
     thresholdConnections.clear();
     thresholdConnections.addConnection(&focusSwitchThreshold, SIGNAL(timeout()), widget, SLOT(setFocus()));
 }
 
 void KisInputManager::Private::CanvasSwitcher::addCanvas(KisCanvas2 *canvas)
 {
     QObject *canvasWidget = canvas->canvasWidget();
 
     if (!canvasResolver.contains(canvasWidget)) {
         canvasResolver.insert(canvasWidget, canvas);
         d->q->setupAsEventFilter(canvasWidget);
         canvasWidget->installEventFilter(this);
 
         setupFocusThreshold(canvasWidget);
         focusSwitchThreshold.setEnabled(false);
 
         d->canvas = canvas;
         d->toolProxy = dynamic_cast<KisToolProxy*>(canvas->toolProxy());
     } else {
         KIS_ASSERT_RECOVER_RETURN(d->canvas == canvas);
     }
 }
 
 void KisInputManager::Private::CanvasSwitcher::removeCanvas(KisCanvas2 *canvas)
 {
     QObject *widget = canvas->canvasWidget();
 
     canvasResolver.remove(widget);
 
     if (d->eventsReceiver == widget) {
         d->q->setupAsEventFilter(0);
     }
 
     widget->removeEventFilter(this);
 }
 
 bool isInputWidget(QWidget *w)
 {
     if (!w) return false;
 
 
     QList<QLatin1String> types;
     types << QLatin1String("QAbstractSlider");
     types << QLatin1String("QAbstractSpinBox");
     types << QLatin1String("QLineEdit");
     types << QLatin1String("QTextEdit");
     types << QLatin1String("QPlainTextEdit");
     types << QLatin1String("QComboBox");
     types << QLatin1String("QKeySequenceEdit");
 
     Q_FOREACH (const QLatin1String &type, types) {
         if (w->inherits(type.data())) {
             return true;
         }
     }
 
     return false;
 }
 
 bool KisInputManager::Private::CanvasSwitcher::eventFilter(QObject* object, QEvent* event )
 {
     if (canvasResolver.contains(object)) {
         switch (event->type()) {
         case QEvent::FocusIn: {
             QFocusEvent *fevent = static_cast<QFocusEvent*>(event);
             KisCanvas2 *canvas = canvasResolver.value(object);
             if (canvas != d->canvas) {
                 eatOneMouseStroke = 2 * (fevent->reason() == Qt::MouseFocusReason);
             }
 
             d->canvas = canvas;
             d->toolProxy = dynamic_cast<KisToolProxy*>(canvas->toolProxy());
 
             d->q->setupAsEventFilter(object);
 
             object->removeEventFilter(this);
             object->installEventFilter(this);
 
             setupFocusThreshold(object);
             focusSwitchThreshold.setEnabled(false);
 
             QEvent event(QEvent::Enter);
             d->q->eventFilter(object, &event);
             break;
         }
         case QEvent::FocusOut: {
             focusSwitchThreshold.setEnabled(true);
             break;
         }
         case QEvent::Enter: {
             break;
         }
         case QEvent::Leave: {
             focusSwitchThreshold.stop();
             break;
         }
         case QEvent::Wheel: {
             QWidget *widget = static_cast<QWidget*>(object);
             widget->setFocus();
             break;
         }
         case QEvent::MouseButtonPress:
         case QEvent::MouseButtonRelease:
         case QEvent::TabletPress:
         case QEvent::TabletRelease:
             focusSwitchThreshold.forceDone();
 
             if (eatOneMouseStroke) {
                 eatOneMouseStroke--;
                 return true;
             }
             break;
         case QEvent::MouseButtonDblClick:
             focusSwitchThreshold.forceDone();
             if (eatOneMouseStroke) {
                 return true;
             }
             break;
         case QEvent::MouseMove:
         case QEvent::TabletMove: {
 
             QWidget *widget = static_cast<QWidget*>(object);
 
             if (!widget->hasFocus()) {
                 const int delay =
                     isInputWidget(QApplication::focusWidget()) ?
                     InputWidgetsThreshold : OtherWidgetsThreshold;
 
                 focusSwitchThreshold.setDelayThreshold(delay);
                 focusSwitchThreshold.start();
             }
         }
             break;
         default:
             break;
         }
     }
     return QObject::eventFilter(object, event);
 }
 
 KisInputManager::Private::ProximityNotifier::ProximityNotifier(KisInputManager::Private *_d, QObject *p)
     : QObject(p), d(_d)
 {}
 
 bool KisInputManager::Private::ProximityNotifier::eventFilter(QObject* object, QEvent* event )
 {
     switch (event->type()) {
     case QEvent::TabletEnterProximity:
         d->debugEvent<QEvent, false>(event);
         // Tablet proximity events are unreliable AND fake mouse events do not
         // necessarily come after tablet events, so this is insufficient.
         // d->eventEater.eatOneMousePress();
 
         // Qt sends fake mouse events instead of hover events, so not very useful.
+        // Don't block mouse events on tablet since tablet move events are not generated until
+        // after tablet press.
+#ifndef Q_OS_MAC
         d->blockMouseEvents();
+#else
+        // Notify input manager that tablet proximity is entered for Genius tablets.
+        d->setTabletActive(true);
+#endif
         break;
     case QEvent::TabletLeaveProximity:
         d->debugEvent<QEvent, false>(event);
         d->allowMouseEvents();
+#ifdef Q_OS_MAC
+        d->setTabletActive(false);
+#endif
         break;
     default:
         break;
     }
     return QObject::eventFilter(object, event);
 }
 
 void KisInputManager::Private::addStrokeShortcut(KisAbstractInputAction* action, int index,
                                                  const QList<Qt::Key> &modifiers,
                                                  Qt::MouseButtons buttons)
 {
     KisStrokeShortcut *strokeShortcut =
         new KisStrokeShortcut(action, index);
 
     QList<Qt::MouseButton> buttonList;
     if(buttons & Qt::LeftButton) {
         buttonList << Qt::LeftButton;
     }
     if(buttons & Qt::RightButton) {
         buttonList << Qt::RightButton;
     }
     if(buttons & Qt::MidButton) {
         buttonList << Qt::MidButton;
     }
     if(buttons & Qt::XButton1) {
         buttonList << Qt::XButton1;
     }
     if(buttons & Qt::XButton2) {
         buttonList << Qt::XButton2;
     }
 
     if (buttonList.size() > 0) {
         strokeShortcut->setButtons(QSet<Qt::Key>::fromList(modifiers), QSet<Qt::MouseButton>::fromList(buttonList));
         matcher.addShortcut(strokeShortcut);
     }
     else {
         delete strokeShortcut;
     }
 }
 
 void KisInputManager::Private::addKeyShortcut(KisAbstractInputAction* action, int index,
                                               const QList<Qt::Key> &keys)
 {
     if (keys.size() == 0) return;
 
     KisSingleActionShortcut *keyShortcut =
         new KisSingleActionShortcut(action, index);
 
     //Note: Ordering is important here, Shift + V is different from V + Shift,
     //which is the reason we use the last key here since most users will enter
     //shortcuts as "Shift + V". Ideally this should not happen, but this is
     //the way the shortcut matcher is currently implemented.
     QList<Qt::Key> allKeys = keys;
     Qt::Key key = allKeys.takeLast();
     QSet<Qt::Key> modifiers = QSet<Qt::Key>::fromList(allKeys);
     keyShortcut->setKey(modifiers, key);
     matcher.addShortcut(keyShortcut);
 }
 
 void KisInputManager::Private::addWheelShortcut(KisAbstractInputAction* action, int index,
                                                 const QList<Qt::Key> &modifiers,
                                                 KisShortcutConfiguration::MouseWheelMovement wheelAction)
 {
     KisSingleActionShortcut *keyShortcut =
         new KisSingleActionShortcut(action, index);
 
     KisSingleActionShortcut::WheelAction a;
     switch(wheelAction) {
     case KisShortcutConfiguration::WheelUp:
         a = KisSingleActionShortcut::WheelUp;
         break;
     case KisShortcutConfiguration::WheelDown:
         a = KisSingleActionShortcut::WheelDown;
         break;
     case KisShortcutConfiguration::WheelLeft:
         a = KisSingleActionShortcut::WheelLeft;
         break;
     case KisShortcutConfiguration::WheelRight:
         a = KisSingleActionShortcut::WheelRight;
         break;
     default:
         return;
     }
 
     keyShortcut->setWheel(QSet<Qt::Key>::fromList(modifiers), a);
     matcher.addShortcut(keyShortcut);
 }
 
 void KisInputManager::Private::addTouchShortcut( KisAbstractInputAction* action, int index, KisShortcutConfiguration::GestureAction gesture)
 {
     KisTouchShortcut *shortcut = new KisTouchShortcut(action, index);
     switch(gesture) {
     case KisShortcutConfiguration::PinchGesture:
         shortcut->setMinimumTouchPoints(2);
         shortcut->setMaximumTouchPoints(2);
         break;
     case KisShortcutConfiguration::PanGesture:
         shortcut->setMinimumTouchPoints(3);
         shortcut->setMaximumTouchPoints(10);
         break;
     default:
         break;
     }
     matcher.addShortcut(shortcut);
 }
 
 void KisInputManager::Private::setupActions()
 {
     QList<KisAbstractInputAction*> actions = KisInputProfileManager::instance()->actions();
     Q_FOREACH (KisAbstractInputAction *action, actions) {
         KisToolInvocationAction *toolAction =
             dynamic_cast<KisToolInvocationAction*>(action);
 
         if(toolAction) {
             defaultInputAction = toolAction;
         }
     }
 
     connect(KisInputProfileManager::instance(), SIGNAL(currentProfileChanged()), q, SLOT(profileChanged()));
     if(KisInputProfileManager::instance()->currentProfile()) {
         q->profileChanged();
     }
 }
 
 bool KisInputManager::Private::processUnhandledEvent(QEvent *event)
 {
     bool retval = false;
 
     if (forwardAllEventsToTool ||
         event->type() == QEvent::KeyPress ||
         event->type() == QEvent::KeyRelease) {
 
         defaultInputAction->processUnhandledEvent(event);
         retval = true;
     }
 
     return retval && !forwardAllEventsToTool;
 }
 
 bool KisInputManager::Private::tryHidePopupPalette()
 {
     if (canvas->isPopupPaletteVisible()) {
         canvas->slotShowPopupPalette();
         return true;
     }
     return false;
 }
 
 #ifdef HAVE_X11
 inline QPointF dividePoints(const QPointF &pt1, const QPointF &pt2) {
     return QPointF(pt1.x() / pt2.x(), pt1.y() / pt2.y());
 }
 
 inline QPointF multiplyPoints(const QPointF &pt1, const QPointF &pt2) {
     return QPointF(pt1.x() * pt2.x(), pt1.y() * pt2.y());
 }
 #endif
 
 void KisInputManager::Private::saveTouchEvent( QTouchEvent* event )
 {
     delete lastTouchEvent;
     lastTouchEvent = new QTouchEvent(event->type(), event->device(), event->modifiers(), event->touchPointStates(), event->touchPoints());
 }
 
 
 void KisInputManager::Private::blockMouseEvents()
 {
     eventEater.activate();
 }
 
 void KisInputManager::Private::allowMouseEvents()
 {
     eventEater.deactivate();
 }
 
 void KisInputManager::Private::eatOneMousePress()
 {
     eventEater.eatOneMousePress();
 }
 
+void KisInputManager::Private::setTabletActive(bool value) {
+    tabletActive = value;
+}
+
+void KisInputManager::Private::resetCompressor() {
+    compressedMoveEvent.reset();
+    moveEventCompressor.stop();
+}
+
 bool KisInputManager::Private::handleCompressedTabletEvent(QEvent *event)
 {
     bool retval = false;
 
     if (!matcher.pointerMoved(event)) {
         toolProxy->forwardHoverEvent(event);
     }
     retval = true;
     event->setAccepted(true);
 
     return retval;
 }
diff --git a/libs/ui/input/kis_input_manager_p.h b/libs/ui/input/kis_input_manager_p.h
index a4a0c24ee8..46229392ed 100644
--- a/libs/ui/input/kis_input_manager_p.h
+++ b/libs/ui/input/kis_input_manager_p.h
@@ -1,145 +1,147 @@
 /*
  *  Copyright (C) 2015 Michael Abrahams <miabraha@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 
 #include <QList>
 #include <QPointer>
 #include <QSet>
 #include <QEvent>
 #include <QTouchEvent>
 #include <QScopedPointer>
 
 #include "kis_input_manager.h"
 #include "kis_shortcut_matcher.h"
 #include "kis_shortcut_configuration.h"
 #include "kis_canvas2.h"
 #include "kis_tool_proxy.h"
 #include "kis_signal_compressor.h"
 #include "input/kis_tablet_debugger.h"
 #include "kis_timed_signal_threshold.h"
 #include "kis_signal_auto_connection.h"
 
 
 class KisToolInvocationAction;
 
 
 class KisInputManager::Private
 {
 public:
     Private(KisInputManager *qq);
     bool tryHidePopupPalette();
     void addStrokeShortcut(KisAbstractInputAction* action, int index, const QList< Qt::Key >& modifiers, Qt::MouseButtons buttons);
     void addKeyShortcut(KisAbstractInputAction* action, int index,const QList<Qt::Key> &keys);
     void addTouchShortcut( KisAbstractInputAction* action, int index, KisShortcutConfiguration::GestureAction gesture );
     void addWheelShortcut(KisAbstractInputAction* action, int index, const QList< Qt::Key >& modifiers, KisShortcutConfiguration::MouseWheelMovement wheelAction);
     bool processUnhandledEvent(QEvent *event);
     void setupActions();
     void saveTouchEvent( QTouchEvent* event );
     bool handleCompressedTabletEvent(QEvent *event);
 
     KisInputManager *q;
 
     KisCanvas2 *canvas = 0;
     KisToolProxy *toolProxy = 0;
 
     bool forwardAllEventsToTool = false;
     bool ignoringQtCursorEvents();
 
     bool disableTouchOnCanvas = false;
     bool touchHasBlockedPressEvents = false;
 
     KisShortcutMatcher matcher;
     QTouchEvent *lastTouchEvent = 0;
 
     KisToolInvocationAction *defaultInputAction = 0;
 
     QObject *eventsReceiver = 0;
     KisSignalCompressor moveEventCompressor;
     QScopedPointer<QEvent> compressedMoveEvent;
     bool testingAcceptCompressedTabletEvents = false;
     bool testingCompressBrushEvents = false;
-
+    bool tabletActive = false; // Indicates whether or not tablet is in proximity
 
     typedef QPair<int, QPointer<QObject> > PriorityPair;
     typedef QList<PriorityPair> PriorityList;
     PriorityList priorityEventFilter;
     int priorityEventFilterSeqNo;
 
     void blockMouseEvents();
     void allowMouseEvents();
     void eatOneMousePress();
     void maskSyntheticEvents(bool value);
+    void setTabletActive(bool value);
+    void resetCompressor();
 
     template <class Event, bool useBlocking>
     void debugEvent(QEvent *event)
     {
       if (!KisTabletDebugger::instance()->debugEnabled()) return;
       QString msg1 = useBlocking && ignoringQtCursorEvents() ? "[BLOCKED] " : "[       ]";
       Event *specificEvent = static_cast<Event*>(event);
       dbgTablet << KisTabletDebugger::instance()->eventToString(*specificEvent, msg1);
     }
 
     class ProximityNotifier : public QObject
     {
     public:
         ProximityNotifier(Private *_d, QObject *p);
         bool eventFilter(QObject* object, QEvent* event );
     private:
         KisInputManager::Private *d;
     };
 
     class CanvasSwitcher : public QObject
     {
     public:
         CanvasSwitcher(Private *_d, QObject *p);
         void addCanvas(KisCanvas2 *canvas);
         void removeCanvas(KisCanvas2 *canvas);
         bool eventFilter(QObject* object, QEvent* event );
 
     private:
         void setupFocusThreshold(QObject *object);
 
     private:
         KisInputManager::Private *d;
         QMap<QObject*, KisCanvas2*> canvasResolver;
         int eatOneMouseStroke;
         KisTimedSignalThreshold focusSwitchThreshold;
         KisSignalAutoConnectionsStore thresholdConnections;
     };
     CanvasSwitcher canvasSwitcher;
 
     struct EventEater
     {
         bool eventFilter(QObject* target, QEvent* event);
 
         // This should be called after we're certain a tablet stroke has started.
         void activate();
         // This should be called after a tablet stroke has ended.
         void deactivate();
 
         // On Windows, we sometimes receive mouse events very late, so watch & wait.
         void eatOneMousePress();
 
         bool hungry{false};   // Continue eating mouse strokes
         bool peckish{false};  // Eat a single mouse press event
         bool eatSyntheticEvents{true}; // Mask all synthetic events
     };
     EventEater eventEater;
 
     bool containsPointer = true;
 };