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>
#include <atomic>
 
#ifndef GEO_OS_ANDROID
#  define GEO_GLFW
#endif
 
#ifdef GEO_OS_WINDOWS
#define GEO_APPLICATION_GLOBALS \
    extern "C" { __declspec(dllexport) DWORD NvOptimusEnablement = 0x00000000; }
#else
#define GEO_APPLICATION_GLOBALS
#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_;
        }
    }
 
    bool updates_locked() const {
        return (nb_update_locks_ > 0);
    }
 
    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(bool draw_GUI = true);
 
    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);
 
    virtual void declare_args();
 
    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;
    }
 
    float get_font_size(index_t font_id) const {
        geo_assert(font_id < font_sizes_.size());
        return font_sizes_[font_id];
    }
 
    float get_font_global_scale() const {
        return font_global_scale_;
    }
 
    void set_font_global_scale(float s) {
        font_global_scale_ = s;
    }
 
    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_;               
    std::atomic<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_;                       
    vector<float> font_sizes_;     
    float font_global_scale_;      
    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