cursor.h

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2005-2019 by the FIFE team                              *
 *   http://www.fifengine.net                                              *
 *   This file is part of FIFE.                                            *
 *                                                                         *
 *   FIFE is free software; you can redistribute it and/or                 *
 *   modify it under the terms of the GNU Lesser General Public            *
 *   License as published by the Free Software Foundation; either          *
 *   version 2.1 of the License, or (at your option) any later version.    *
 *                                                                         *
 *   This library 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     *
 *   Lesser General Public License for more details.                       *
 *                                                                         *
 *   You should have received a copy of the GNU Lesser General Public      *
 *   License along with this library; if not, write to the                 *
 *   Free Software Foundation, Inc.,                                       *
 *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA          *
 ***************************************************************************/

#ifndef FIFE_CURSOR_H
#define FIFE_CURSOR_H

// Standard C++ library includes

// 3rd party library includes

// FIFE includes
// These includes are split up in two parts, separated by one empty line
// First block: files included from the FIFE root src directory
// Second block: files included from the same folder

#include "animation.h"

struct SDL_Cursor;

namespace FIFE {

    class RenderBackend;
    class TimeManager;

    enum MouseCursorType {
        CURSOR_NONE,
        CURSOR_NATIVE,
        CURSOR_IMAGE,
        CURSOR_ANIMATION
    };

    enum NativeCursor {
        // Start on 1000000 to avoid id-clashes with SDL
        NC_ARROW = 1000000, // Standard arrow
        NC_IBEAM,           // I-beam for text selection
        NC_WAIT,            // Hourglass
        NC_CROSS,           // Crosshair
        NC_WAITARROW,       // Small wait cursor (or Wait if not available)
        NC_RESIZENWSE,      // Double arrow pointing northwest and southeast
        NC_RESIZENESW,      // Double arrow pointing northeast and southwest
        NC_RESIZEWE,        // Double arrow pointing west and east
        NC_RESIZENS,        // Double arrow pointing north and south
        NC_RESIZEALL,       // Four-pointed arrow pointing north, south, east, and west
        NC_NO,              // Slashed circle
        NC_HAND             // Hand. Common for links, etc.
    };

    class Cursor {
    public:
        Cursor(RenderBackend* renderbackend);

        virtual ~Cursor() { invalidate(); }

        void invalidate();

        virtual void draw();

        void set(uint32_t cursor_id=0);

        void set(ImagePtr image);

        void set(AnimationPtr anim);

        void setDrag(ImagePtr image, int32_t drag_offset_x=0, int32_t drag_offset_y=0);

        void setDrag(AnimationPtr anim, int32_t drag_offset_x=0, int32_t drag_offset_y=0);

        void resetDrag();

        MouseCursorType getType() const { return m_cursor_type; }

        uint32_t getId() const { return m_cursor_id; }

        ImagePtr getImage() { return m_cursor_image; }

        AnimationPtr getAnimation() { return m_cursor_animation; }

        MouseCursorType getDragType() const { return m_drag_type; }

        ImagePtr getDragImage() { return m_cursor_drag_image; }

        AnimationPtr getDragAnimation() { return m_cursor_drag_animation; }

        uint32_t getX() const { return m_mx; }

        uint32_t getY() const { return m_my; }

        void setPosition(uint32_t x, uint32_t y);

        void getPosition(int32_t* x, int32_t* y);

        void setNativeImageCursorEnabled(bool native_image_cursor_enabled);

        bool isNativeImageCursorEnabled() const;

    protected:
        void setNativeCursor(uint32_t cursor_id);

        bool setNativeImageCursor(ImagePtr image);

        uint32_t getNativeId(uint32_t cursor_id);

    private:
        uint32_t m_cursor_id;
        MouseCursorType m_cursor_type;
        MouseCursorType m_drag_type;

        SDL_Cursor* m_native_cursor;

        ImagePtr m_cursor_image;
        ImagePtr m_cursor_drag_image;

        AnimationPtr m_cursor_animation;
        AnimationPtr m_cursor_drag_animation;

        RenderBackend* m_renderbackend;

        uint32_t m_animtime;
        uint32_t m_drag_animtime;

        int32_t m_drag_offset_x;
        int32_t m_drag_offset_y;
        int32_t m_mx;
        int32_t m_my;
        TimeManager* m_timemanager;

        bool m_invalidated;
        bool m_native_image_cursor_enabled;
        ImagePtr m_native_cursor_image;
    };

} //FIFE

#endif