application.h

Go to the documentation of this file.

/*
 *  Copyright (c) 2000-2022 Inria
 *  All rights reserved.
 *
 *  Redistribution and use in source and binary forms, with or without
 *  modification, are permitted provided that the following conditions are met:
 *
 *  * Redistributions of source code must retain the above copyright notice,
 *  this list of conditions and the following disclaimer.
 *  * Redistributions in binary form must reproduce the above copyright notice,
 *  this list of conditions and the following disclaimer in the documentation
 *  and/or other materials provided with the distribution.
 *  * Neither the name of the ALICE Project-Team nor the names of its
 *  contributors may be used to endorse or promote products derived from this
 *  software without specific prior written permission.
 * 
 *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 *  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 *  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 *  ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
 *  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 *  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 *  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 *  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 *  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 *  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 *  POSSIBILITY OF SUCH DAMAGE.
 *
 *  Contact: Bruno Levy
 *
 *     https://www.inria.fr/fr/bruno-levy
 *
 *     Inria,
 *     Domaine de Voluceau,
 *     78150 Le Chesnay - Rocquencourt
 *     FRANCE
 *
 */
 
#ifndef H_GEOGRAM_GFX_GUI_APPLICATION_H
#define H_GEOGRAM_GFX_GUI_APPLICATION_H
 
#include <geogram_gfx/basic/common.h>
#include <geogram_gfx/gui/events.h>
 
#ifndef GEO_OS_ANDROID
#  define GEO_GLFW
#endif
 
namespace GEO {
 
    class Image;
    class ApplicationData;
    
    class GEOGRAM_GFX_API Application {
    public:
    
         Application(const std::string& name);
 
         virtual ~Application();
 
         static Application* instance() {
             return instance_;
         }
 
    
         const std::string& name() const {
             return name_;
         }
 
    
         virtual void start(int argc=0, char** argv=nullptr);
 
        virtual void stop();
 
        const std::string& get_style() const {
            return style_;
        }
    
        virtual void set_style(const std::string& value);
 
        static std::string get_styles();
    
        void set_font_size(index_t value);
 
        index_t get_font_size() const {
            return font_size_;
        }
 
        virtual void update();
 
        void draw_dock_space();
    
        void lock_updates() {
            ++nb_update_locks_;
        }
 
        void unlock_updates() {
            // Note: Under Windows, when the Graphite window is iconified,
            // it can happen that nb_update_locks_ is already 0 when
            // reaching this point.
            if(nb_update_locks_ > 0) {
                --nb_update_locks_;
            }
        }
 
        virtual void draw();
 
        double scaling() const;
 
        void set_full_screen_mode(
            index_t w=0, index_t h=0, index_t hz=0,
            index_t monitor=0
        );
 
        void set_windowed_mode(index_t w=0, index_t h=0);
 
        void list_video_modes();
 
        void iconify();
 
        void restore();
 
        void set_gui_state(std::string x);
 
        std::string get_gui_state() const;
        
        void set_full_screen(bool x);
 
        bool get_full_screen() const;
        
        index_t get_width() const {
            return width_;
        }
 
        index_t get_height() const {
            return height_;
        }
 
        index_t get_frame_buffer_width() const {
            return frame_buffer_width_;
        }
 
        index_t get_frame_buffer_height() const {
            return frame_buffer_height_;
        }
    
        void set_accept_drops(bool value) {
            accept_drops_ = value;
        }
 
        bool get_accept_drops() const {
            return accept_drops_;
        }
 
        void set_window_icon(Image* image);
 
        virtual void mouse_button_callback(
            int button, int action, int mods=0, int source=EVENT_SOURCE_MOUSE
        );
 
        virtual void scroll_callback(double xoffset, double yoffset);
 
        virtual void cursor_pos_callback(
            double x, double y, int source=EVENT_SOURCE_MOUSE
        );
 
        virtual void drop_callback(int nb, const char** f);
 
        virtual void char_callback(unsigned int c);
 
        virtual void key_callback(int key, int scancode, int action, int mods);
 
        void restart_gui() {
            ImGui_restart_ = true;
        }
    
        ApplicationData* impl_data() {
            return data_;
        }
 
        void* impl_window();
 
        double hidpi_scaling() const {
            return hidpi_scaling_;
        }
 
        double pixel_ratio() const {
            return pixel_ratio_;
        }
 
        void reset_soft_keyboard_flag() {
            soft_keyboard_visible_ = false;
        }
    
        //protected:
    public:
 
        const char* key_to_string(int key);
    
        virtual void draw_gui();
 
        virtual void draw_graphics();
    
        virtual void pre_draw();
 
        virtual void post_draw();
    
        virtual bool needs_to_redraw() const;
 
        virtual void create_window();
 
        virtual void delete_window();
 
         virtual void resize(index_t w, index_t h, index_t fb_w, index_t fb_h);
 
        virtual void one_frame();
 
        virtual void main_loop();
 
        virtual void GL_initialize();
 
        virtual void GL_terminate();
 
        virtual void ImGui_initialize();
 
        virtual void ImGui_load_fonts();
        
        virtual void ImGui_terminate();
 
        virtual void ImGui_new_frame();
 
        /*
         * \param[in] argc , argv command line parameters, used
         *  to initialize geogram.
         */
        virtual void geogram_initialize(int argc, char** argv);
    
        void callbacks_initialize();
 
        const std::vector<std::string>& filenames() const  {
            return filenames_;
        }
 
        bool animate() const {
            return animate_;
        }
 
        bool* animate_ptr() {
            return &animate_;
        }
    
        void start_animation() {
            animate_ = true;
        }
 
        void stop_animation() {
            animate_ = false;
        }
 
      private:
        static Application* instance_; 
        ApplicationData* data_;        
        index_t width_;                
        index_t height_;               
        index_t frame_buffer_width_;   
        index_t frame_buffer_height_;  
        bool in_main_loop_;            
        bool accept_drops_;            
        double scaling_;               
        index_t nb_update_locks_;      
        std::string style_;            
        bool ImGui_restart_;           
        bool ImGui_reload_font_;       
        bool ImGui_initialized_;       
        index_t font_size_;            
        index_t nb_frames_update_;     
        double hidpi_scaling_;         
        double pixel_ratio_;           
        std::string name_;             
        bool currently_drawing_gui_;   
        std::vector<std::string> filenames_; 
        bool animate_;                 
      protected:
        bool ImGui_firsttime_init_;  
        bool menubar_visible_;
        bool phone_screen_;          
        bool soft_keyboard_visible_;
 
#ifdef GEO_OS_EMSCRIPTEN
       friend void emscripten_one_frame();
#endif
    };
 
}
 
#endif