application_base.h

/*
 *  GXML/Graphite: Geometry and Graphics Programming Library + Utilities
 *  Copyright (C) 2000 Bruno Levy
 *
 *  This program 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.
 *
 *  This program 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 this program; if not, write to the Free Software
 *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 *
 *  If you modify this software, you should include a notice giving the
 *  name of the person performing the modification, the date of modification,
 *  and the reason for such modification.
 *
 *  Contact: Bruno Levy
 *
 *     levy@loria.fr
 *
 *     ISA Project
 *     LORIA, INRIA Lorraine,
 *     Campus Scientifique, BP 239
 *     54506 VANDOEUVRE LES NANCY CEDEX
 *     FRANCE
 *
 *  Note that the GNU General Public License does not permit incorporating
 *  the Software into proprietary programs.
 */
 
 
#ifndef H_SCENE_GRAPH_SKIN_APPLICATION_BASE_H
#define H_SCENE_GRAPH_SKIN_APPLICATION_BASE_H
 
#include <OGF/scene_graph/common/common.h>
#include <OGF/gom/types/node.h>
#include <geogram/basic/progress.h>
#include <iostream>
 
namespace OGF {
 
    gom_class SCENE_GRAPH_API ApplicationBase : public Object {
 
    public:
        ApplicationBase(Interpreter* interpreter = nullptr);
 
         ~ApplicationBase() override;
 
        Interpreter* interpreter() {
            return interpreter_;
        }
 
        static ApplicationBase* instance() {
            return instance_;
        }
 
    gom_properties:
 
        void set_tooltip(const std::string& x) {
            tooltip_ = x;
            // Interpret "\\n" in string.
            for(
                size_t index = tooltip_.find("\\n");
                index != std::string::npos;
                index = tooltip_.find("\\n", index+2)
            ) {
                tooltip_.replace(index, 2, " \n");
            }
        }
 
        const std::string& get_tooltip() const {
            return tooltip_;
        }
 
    gom_slots:
        virtual void start();
 
        virtual void stop();
 
        virtual void set_style(const std::string& value);
 
        virtual void set_font_size(index_t value);
 
        void declare_preference_variable(
            const std::string& name,
            const std::string& value,
            const std::string& help=""
        );
 
        virtual void save_preferences();
 
 
        virtual void load_preferences(const std::string& filename);
 
        virtual bool preferences_loaded();
 
        virtual void cancel_current_job();
 
        virtual void draw();
 
        virtual void update();
 
        virtual void begin();
 
        virtual void progress(index_t step, index_t percent);
 
        virtual void end(bool canceled);
 
        std::string find_file(const std::string& filename) const;
 
        virtual void save_state();
 
        virtual void undo();
 
        virtual void redo();
 
 
        virtual void progress_cancel();
 
 
        virtual void post_draw();
 
    gom_properties:
 
        bool get_can_undo() const;
 
 
        bool get_can_redo() const;
 
    gom_signals:
        void started();
 
        void div(const std::string& value);
 
        void out(const std::string& value);
 
        void warn(const std::string& value);
 
        void err(const std::string& value);
 
        void status(const std::string& value);
 
        void notify_progress_begin(const std::string& value);
 
        void notify_progress(index_t value);
 
        void notify_progress_end();
 
        static bool is_stopping() {
            return stopping_;
        }
 
 
    protected:
 
        virtual void save_state_to_file(const std::string& filename);
 
        virtual void load_state_from_file(const std::string& filename);
 
 
        std::string state_buffer_filename(index_t i) const;
 
 
        static void set_stopping_flag() {
            stopping_ = true;
        }
 
        class ApplicationBaseLoggerClient : public LoggerClient {
        public:
            ApplicationBaseLoggerClient(ApplicationBase* app);
 
            void div(const std::string& value) override;
 
            void out(const std::string& value) override;
 
            void warn(const std::string& value) override;
 
            void err(const std::string& value) override;
 
            void status(const std::string& value) override;
 
        private:
            ApplicationBase* application_base_;
        };
 
        class ApplicationBaseProgressClient : public ProgressClient {
        public:
            ApplicationBaseProgressClient(ApplicationBase* app);
 
            void begin() override;
 
            void progress(index_t step, index_t percent) override;
 
            void end(bool canceled) override;
 
        private:
            ApplicationBase* application_base_;
        };
 
        Interpreter* interpreter_;
        LoggerClient_var logger_client_;
        ProgressClient_var progress_client_;
        std::string tooltip_;
 
        index_t state_buffer_begin_;
        index_t state_buffer_end_;
        index_t state_buffer_size_;
        index_t state_buffer_current_;
        bool undo_redo_called_;
 
        static ApplicationBase* instance_;
        static bool stopping_;
        bool started_callback_called_;
    };
 
}
 
#endif