/*
 * Copyright 2011, Alexandre Deckner, alex@zappotek.com
 * Distributed under the terms of the MIT License.
 */

/*!
        \class LongAndDragTrackingFilter
        \brief A simple long mouse down and drag detection filter
        *
        * A simple mouse filter that detects long clicks and pointer drags.
        * A long click message is sent when the mouse button is kept down
        * for a duration longer than a given threshold while the pointer stays
        * within the limits of a given threshold radius.
        * A drag message is triggered if the mouse goes further than the
        * threshold radius before the duration threshold elapsed.
        *
        * The messages contain the pointer position and the buttons state at
        * the moment of the click. The drag message is ready to use with the
        * be/haiku drag and drop API cf. comment in code.
        *
        * Current limitation: A long mouse down or a drag can be detected for
        * any mouse button, but any released button cancels the tracking.
        *
*/


#include <LongAndDragTrackingFilter.h>

#include <Message.h>
#include <Messenger.h>
#include <MessageRunner.h>
#include <View.h>

#include <new>


LongAndDragTrackingFilter::LongAndDragTrackingFilter(uint32 longMessageWhat,
        uint32 dragMessageWhat, float radiusThreshold,
        bigtime_t durationThreshold)
        :
        BMessageFilter(B_ANY_DELIVERY, B_ANY_SOURCE),
        fLongMessageWhat(longMessageWhat),
        fDragMessageWhat(dragMessageWhat),
        fMessageRunner(NULL),
        fClickButtons(0),
        fSquaredRadiusThreshold(radiusThreshold * radiusThreshold),
        fDurationThreshold(durationThreshold)
{
        if (durationThreshold == 0) {
                get_click_speed(&fDurationThreshold);
                        // use system's doubleClickSpeed as default threshold
        }
}


LongAndDragTrackingFilter::~LongAndDragTrackingFilter()
{
        delete fMessageRunner;
}


void
LongAndDragTrackingFilter::_StopTracking()
{
        delete fMessageRunner;
        fMessageRunner = NULL;
}


filter_result
LongAndDragTrackingFilter::Filter(BMessage* message, BHandler** target)
{
        if (*target == NULL)
                return B_DISPATCH_MESSAGE;

        switch (message->what) {
                case B_MOUSE_DOWN: {
                        int32 clicks = 0;

                        message->FindInt32("buttons", (int32*)&fClickButtons);
                        message->FindInt32("clicks", (int32*)&clicks);

                        if (fClickButtons != 0 && clicks == 1) {

                                BView* targetView = dynamic_cast<BView*>(*target);
                                if (targetView != NULL)
                                        targetView->SetMouseEventMask(B_POINTER_EVENTS);

                                message->FindPoint("where", &fClickPoint);
                                BMessage message(fLongMessageWhat);
                                message.AddPoint("where", fClickPoint);
                                message.AddInt32("buttons", fClickButtons);

                                delete fMessageRunner;
                                fMessageRunner = new (std::nothrow) BMessageRunner(
                                        BMessenger(*target), &message, fDurationThreshold, 1);
                        }
                        return B_DISPATCH_MESSAGE;
                }

                case B_MOUSE_UP:
                        _StopTracking();
                        message->AddInt32("last_buttons", (int32)fClickButtons);
                        message->FindInt32("buttons", (int32*)&fClickButtons);
                        return B_DISPATCH_MESSAGE;

                case B_MOUSE_MOVED:
                {
                        if (fMessageRunner != NULL) {
                                BPoint where;
                                message->FindPoint("be:view_where", &where);

                                BPoint delta(fClickPoint - where);
                                float squaredDelta = (delta.x * delta.x) + (delta.y * delta.y);

                                if (squaredDelta >= fSquaredRadiusThreshold) {
                                        BMessage dragMessage(fDragMessageWhat);
                                        dragMessage.AddPoint("be:view_where", fClickPoint);
                                                // name it "be:view_where" since BView::DragMessage
                                                // positions the dragging frame/bitmap by retrieving
                                                // the current message and reading that field
                                        dragMessage.AddInt32("buttons", (int32)fClickButtons);
                                        BMessenger messenger(*target);
                                        messenger.SendMessage(&dragMessage);

                                        _StopTracking();
                                }
                        }
                        return B_DISPATCH_MESSAGE;
                }

                default:
                        if (message->what == fLongMessageWhat) {
                                _StopTracking();
                                return B_DISPATCH_MESSAGE;
                        }
                        break;
        }

        return B_DISPATCH_MESSAGE;
}