view.h

Go to the documentation of this file.

// This file is part of Hermes2D.
// Hermes2D 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.
//
// Hermes2D 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 Hermes2D.  If not, see <http://www.gnu.org/licenses/>.
#ifndef __H2D_VIEW_H
#define __H2D_VIEW_H

#include "../global.h"
#include "orderizer.h"

namespace Hermes
{
  namespace Hermes2D
  {
    namespace Views
    {
      // Constants
#define H2D_DEFAULT_X_POS -1
#define H2D_DEFAULT_Y_POS -1
#define H2D_DEFAULT_WIDTH 600
#define H2D_DEFAULT_HEIGHT 400
#define H2DV_SCALE_LOG_BASE 1.005 

#define transform_x(x) ((x * scale + trans_x) + center_x)
#define transform_y(y) (center_y - (y * scale + trans_y))

      enum ViewWaitEvent {
        HERMES_WAIT_CLOSE, 
        HERMES_WAIT_KEYPRESS, 
      };

      struct WinGeom {
        int x;
        int y;
        int width;
        int height;

        WinGeom(int x, int y, int width, int height) {
          this->x = x;
          this->y = y;
          this->width = width;
          this->height = height;
        };
      };

      enum ViewPaletteType {
        H2DV_PT_HUESCALE = 0, 
        H2DV_PT_GRAYSCALE = 1, 
        H2DV_PT_INVGRAYSCALE = 2, 
        H2DV_PT_MAX_ID = 3 
      };

      // you can define NOGLUT to turn off all OpenGL stuff in Hermes2D
#ifndef NOGLUT

      class HERMES_API View : public Hermes::Mixins::TimeMeasurable, public Hermes::Mixins::Loggable
      {
      public:

        void init();
        View(const char* title, WinGeom* wg = nullptr);
        View(char* title, WinGeom* wg = nullptr);
        ~View();

        int  create();
        void close();
        void refresh();

        const char* get_title() const;
        void set_title(const char* msg, ...);

        void set_min_max_range(double min, double max);
        void auto_min_max_range();
        void get_min_max_range(double& min, double& max);

        void show_scale(bool show = true);
        void set_scale_position(int horz, int vert);
        void set_scale_size(int width, int height, int numticks);
        void set_scale_format(const char* fmt);
        void fix_scale_width(int width = 80);

        void save_screenshot(const char* bmpname, bool high_quality = false);
        void save_numbered_screenshot(const char* format, int number, bool high_quality = false);

        void set_palette(ViewPaletteType type);
        void set_num_palette_steps(int num);
        void set_palette_filter(bool linear);

        static void wait_for_keypress(const char* text = nullptr);
        void wait_for_close();
        void wait_for_draw();

        static void wait(const char* text);
        static void wait(ViewWaitEvent wait_event = HERMES_WAIT_CLOSE, const char* text = nullptr);
        void draw_help();
        virtual void reset_view(bool force_reset);

      protected: //FPS measurement
#define FPS_FRAME_SIZE 5
        double rendering_frames[FPS_FRAME_SIZE];
        int rendering_frames_top;
        void draw_fps();
        static double get_tick_count();

      protected: //view
        bool view_not_reset;
        double vertices_min_x, vertices_max_x, vertices_min_y, vertices_max_y;
        double scale, log_scale, trans_x, trans_y;
        double center_x, center_y;
        int margin, lspace, rspace;
        int mouse_x, mouse_y;
        int scx, scy;
        double objx, objy;
        bool dragging, scaling;

        virtual void on_create(int output_id);
        virtual void on_display() {};
        virtual void on_reshape(int width, int height);
        virtual void on_mouse_move(int x, int y);
        virtual void on_left_mouse_down(int x, int y);
        virtual void on_left_mouse_up(int x, int y);
        virtual void on_left_mouse_double_click(int x, int y) {}
        virtual void on_right_mouse_down(int x, int y);
        virtual void on_right_mouse_up(int x, int y);
        virtual void on_right_mouse_double_click(int x, int y) {}
        virtual void on_middle_mouse_down(int x, int y) {}
        virtual void on_middle_mouse_up(int x, int y) {}
        virtual void on_middle_mouse_double_click(int x, int y) {}
        virtual void on_key_down(unsigned char key, int x, int y);
        virtual void on_special_key(int key, int x, int y);
        virtual void on_entry(int state) {}
        virtual void on_close();

        virtual void update_layout();

      protected:
        std::string title;
        int output_id;
        int output_x, output_y, output_width, output_height;
        float jitter_x, jitter_y;
        bool hq_frame, frame_ready;

        ViewPaletteType pal_type;
        int pal_steps, pal_filter;
        double tex_scale, tex_shift;
        bool range_auto;
        double range_min, range_max;

        bool b_scale, b_help;
        bool scale_focused, scale_dragging;
        int pos_horz, pos_vert;
        int scale_x, scale_y;
        int scale_width, scale_height, labels_width;
        int scale_numticks, scale_box_height, scale_box_skip;
        char scale_fmt[20];
        int scale_fixed_width;

        bool want_screenshot;
        static int screenshot_no;
        std::string screenshot_filename;

      protected: //palette
        unsigned int gl_pallete_tex_id;

        void create_gl_palette();
        virtual void get_palette_color(double x, float* gl_color);

      protected: //internal functions
        inline double untransform_x(double x) { return (x - center_x - trans_x) / scale; }
        inline double untransform_y(double y) { return (center_y - y - trans_y) / scale; }

        virtual void clear_background();
        void pre_display();
        void display_antialiased();

        void set_ortho_projection(bool no_jitter = false);
        void set_3d_projection(int fov, double znear, double zfar);

        void draw_text(double x, double y, const char* text, int align = -1);
        int  get_text_width(const char* text);

        char *get_screenshot_file_name();
        void save_screenshot_internal(const char* filename);

        virtual void scale_dispatch();
        virtual int measure_scale_labels();
        void draw_continuous_scale(char* title, bool righttext);
        void draw_discrete_scale(int numboxes, const char* boxnames[], const float boxcolors[][3]);

        void update_tex_adjust();

        virtual const char* get_help_text() const = 0;

        friend void on_display_stub(void);
        friend void on_reshape_stub(int, int);
        friend void on_mouse_move_stub(int, int);
        friend void on_mouse_click_stub(int, int, int, int);
        friend void on_key_down_stub(unsigned char, int, int);
        friend void on_special_key_stub(int, int, int);
        friend void on_entry_stub(int);
        friend void on_idle_stub();
        friend void on_close_stub();
        friend int add_view_in_thread(void*);
        friend int remove_view_in_thread(void*);
        friend void on_create(int);
      };
#else
      class HERMES_API View
      {
      public:

        void init() { throw Hermes::Exceptions::Exception("GLUT disabled."); }
        View() {}
        View(const char* title, WinGeom* wg = nullptr) {}
        View(char* title, WinGeom* wg = nullptr) {}

        int  create() { throw Hermes::Exceptions::Exception("GLUT disabled."); return -1; }
        void close() { throw Hermes::Exceptions::Exception("GLUT disabled."); }
        void refresh() { throw Hermes::Exceptions::Exception("GLUT disabled."); }

        void set_title(const char* msg, ...) { throw Hermes::Exceptions::Exception("GLUT disabled."); }

        void set_min_max_range(double min, double max) { throw Hermes::Exceptions::Exception("GLUT disabled."); }
        void auto_min_max_range() { throw Hermes::Exceptions::Exception("GLUT disabled."); }
        void get_min_max_range(double& min, double& max) { throw Hermes::Exceptions::Exception("GLUT disabled."); }

        void show_scale(bool show = true) { throw Hermes::Exceptions::Exception("GLUT disabled."); }
        void set_scale_position(int horz, int vert) { throw Hermes::Exceptions::Exception("GLUT disabled."); }
        void set_scale_size(int width, int height, int numticks) { throw Hermes::Exceptions::Exception("GLUT disabled."); }
        void set_scale_format(const char* fmt) { throw Hermes::Exceptions::Exception("GLUT disabled."); }
        void fix_scale_width(int width = 80) { throw Hermes::Exceptions::Exception("GLUT disabled."); }

        void save_screenshot(const char* bmpname, bool high_quality = false) { throw Hermes::Exceptions::Exception("GLUT disabled."); }
        void save_numbered_screenshot(const char* format, int number, bool high_quality = false) { throw Hermes::Exceptions::Exception("GLUT disabled."); }

        void set_palette(ViewPaletteType type) { throw Hermes::Exceptions::Exception("GLUT disabled."); }
        void set_num_palette_steps(int num) { throw Hermes::Exceptions::Exception("GLUT disabled."); }
        void set_palette_filter(bool linear) { throw Hermes::Exceptions::Exception("GLUT disabled."); }

        static void wait_for_keypress(const char* text = nullptr) { throw Hermes::Exceptions::Exception("GLUT disabled."); }
        void wait_for_close() { throw Hermes::Exceptions::Exception("GLUT disabled."); }
        void wait_for_draw() { throw Hermes::Exceptions::Exception("GLUT disabled."); }

        static void wait(const char* text) { throw Hermes::Exceptions::Exception("GLUT disabled."); }
        static void wait(ViewWaitEvent wait_event = HERMES_WAIT_CLOSE, const char* text = nullptr) { throw Hermes::Exceptions::Exception("GLUT disabled."); }
      };
#endif
    }
  }
}
#endif