Ruler.h

Go to the documentation of this file.

/*--------------------------------------------------------------------------------------------
Copyright (c) 2019, NDEVR LLC
tyler.parke@ndevr.org
  __    __   ____     _____ __     __  _______
 |  \  |  | |  __ \  |  ___|\ \   / / |   __  \
 |   \ |  | | |  \ \ | |___  \ \ / /  |  |__)  |
 |  . \|  | | |__/ / | |___   \ V /   |   _   /
 |  |\    |_|_____/__|_____|___\_/____|  | \  \
 |__| \__________________________________|  \__\
 
Subject to the terms of the Enterprise+ Agreement, NDEVR hereby grants 
Licensee a limited, non-exclusive, non-transferable, royalty-free license 
(without the right to sublicense) to use the API solely for the purpose of 
Licensee's internal development efforts to develop applications for which 
the API was provided.
 
The above copyright notice and this permission notice shall be included in all 
copies or substantial portions of the Software.
 
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
 
Library: NDEVR
File: Ruler
Included in API: True
Author(s): Tyler Parke
 *-----------------------------------------------------------------------------------------**/
#pragma once
#include "DLLInfo.h"
#include <NDEVR/Camera.h>
#if NDEVR_VIEWPORT
#include <QWidget>
class QActionGroup;
class QAction;
class QMenu;
class QWidgetAction;
namespace NDEVR
{
    class Button;
    class Ruler;
    class Toggle;
    class QTResourceListener;
    class DESIGN_WIDGETS_API Ruler : public QWidget
    {
    public:
        static const int MARGIN = 4;
        enum LabelMode
        {
              e_camera_location
            , e_selection
            , e_none
        };
    
    public:
        Ruler(bool is_horizontal, bool is_left_or_top, QWidget* parent);
        ~Ruler();
        void setCamera(const DynamicPointer<Camera>& camera);
        QSize sizeHint() const override;
        void paintEvent(QPaintEvent *event) override;
        void paintBackground(QPainter& g2D);
        void paintRuler(QPainter& g2D);
        void setLabel(const String& label, const Vector<2, fltp08>& location = Vector<2, fltp08>(0.0));
        void setLabelMode(LabelMode mode);
        String label() const;
        RGBColor labelBackground();
        void setLabelsVisible(bool visible);
    protected:
        void setAxis();
        Vector<2, fltp08> labelPixelLocation() const;
        Bounds<3, fltp08> worldBounds() const;
        Vector<2, fltp08> worldSpan() const;
        Vector<2, fltp08> scale() const;
        Vector<2, fltp08> worldOffset() const;
        Vector<2, fltp08> worldGridSpacing() const;
        fltp08 convertPixelToModel(uint04 dim, uint04 pixel);
        uint04 convertModelToPixel(uint04 dim, fltp08 model);
        TranslatedString getFormattedTickText(fltp08 value, fltp08 spacing, uint01 dim);
    protected:
        QTResourceListener* m_camera_listener;
        QTResourceListener* m_coordinate_listener;
        bool m_is_horizontal;
        String m_label_text;
        RGBColor m_label_background;
        LabelMode m_label_mode;
        ConstPointer<Camera> m_camera;
        Vector<2, uint01> m_axis;
        Vector<2, uint01> m_label_axis;
        Vector<2, fltp08> m_last_paint_scale;
        Vector<2, fltp08> m_last_label_location;
        Vector<2, fltp08> m_last_world_spacing;
        Vector<2, fltp08> m_last_world_offset;
        Vector<2, fltp08> m_label_location;
        String m_last_label_text;
        RGBColor m_last_label_background;
        bool m_is_opaque;
        bool m_is_left_or_top;
        bool m_draw_minor;
        bool m_labels_visible;
    };
 
    class DESIGN_WIDGETS_API CameraRulerMenu : public QObject
    {
        Q_OBJECT
    public:
        CameraRulerMenu(const DynamicPointer<Camera>& camera, Button* combo, const void* lock_ptr);
        CameraRulerMenu(Button* combo, const void* lock_ptr);
        void setCamera(const DynamicPointer<Camera>& camera);
        void setLockPointer(const void* lock_ptr);
        void setShowRuler(const TranslatedString& ruler_name, bool show_vertical, bool show_horizontal, bool show_lockable);
        void updateFromModel();
    protected:
        void init();
    signals:
        void requestShowRuler(bool show_vertical, bool show_horizontal);
    protected:
        bool m_show_lockable;
        bool m_is_locked;
        bool m_is_shown;
        QMenu* m_menu;
        QWidgetAction* m_lock_act;
        QWidgetAction* m_show_vert_act;
        QWidgetAction* m_show_horz_act;
        QWidgetAction* m_show_grid_act;
        Toggle* m_vert_toggle;
        Toggle* m_horz_toggle;
        Toggle* m_lock_toggle;
        Toggle* m_show_grid_toggle;
        QActionGroup* m_view_mode_group;
        Button* m_combo;
        DynamicPointer<Camera> m_camera;
        TranslatedString m_ruler_name;
        const void* m_lock_ptr;
    };
}
#endif