emftgl.h

Go to the documentation of this file.

/*
 * Author: David Woolford, 7/16/2008 (woolford@bcm.edu)
 * Copyright (c) 2000-2006 Baylor College of Medicine
 *
 * This software is issued under a joint BSD/GNU license. You may use the
 * source code in this file under either license. However, note that the
 * complete EMAN2 and SPARX software packages have some GPL dependencies,
 * so you are responsible for compliance with the licenses of these packages
 * if you opt to use BSD licensing. The warranty disclaimer below holds
 * in either instance.
 *
 * This complete copyright notice must be included in any revised version of the
 * source code. Additional authorship citations may be added, but existing
 * author citations must be preserved.
 *
 * 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 *
 * */
#ifndef emftgl_h__
#define emftgl_h__
 
#include <string>
using std::string;
 
#include <vector>
using std::vector;
 
#include <map>
using std::map;
 
#include <FTGL/ftgl.h>
#include <FTGL/FTFont.h>
namespace EMAN {
 
 
class EMFTGL
{
        public:
#ifdef __APPLE__
                EMFTGL() : font_file_name("/Library/Fonts/Arial.ttf" ), face_size(32), depth(32), use_display_lists(true), mode(TEXTURE) {};
#else
#ifdef WIN32
                EMFTGL() : font_file_name("" ), face_size(32), depth(32), use_display_lists(true), mode(TEXTURE) {};
#else
                EMFTGL() : font_file_name("/usr/share/fonts/dejavu/DejaVuSerif.ttf"), face_size(32), depth(32), use_display_lists(true), mode(TEXTURE) {};
#endif
 
 
#endif
                ~EMFTGL() {};
 
 
                enum FontMode {
                        EXTRUDE,
                        PIXMAP,
                        TEXTURE,
                        BITMAP,
                        OUTLINE,
                        POLYGON
                };
 
                void render_string(const string& message);
 
                vector<float> bounding_box(const string& message);
 
                void set_font_file_name(const string& file_name) { font_file_name = file_name; }
 
                void set_face_size(const unsigned int size) { face_size = size; }
 
                void set_depth(const unsigned int d ) { depth = d; }
 
                void set_using_display_lists(const bool b) { use_display_lists = b; }
 
                void set_font_mode(const FontMode m ) { mode = m; }
                string get_font_file_name() { return font_file_name; }
                unsigned int get_face_size() {return face_size; }
                unsigned int get_depth() { return depth; }
                bool get_using_display_lists() { return use_display_lists; }
                FontMode get_font_mode() { return mode; }
 
 
 
        private:
//              EMFTGL(const EMFTGL& );  FIXME solve this issue
//              EMFTGL& operator=(const EMFTGL& );
 
                string font_file_name;
                unsigned int face_size;
                unsigned int depth;
                bool use_display_lists;
 
                FontMode mode;
 
                class EMFTGLFontInstance
                {
                        public:
                                EMFTGLFontInstance(EMFTGL::FontMode mode, const string& file_name, const unsigned int face_size, const unsigned int d, const bool use_dl);
                                ~EMFTGLFontInstance();
 
                                bool params_match(EMFTGL::FontMode mode, const string& file_name, const unsigned int face_size, const unsigned int depth, const bool use_dl);
 
                                FTFont* get_font() { return font; }
                        private:
//                              EMFTGLFontInstance(const EMFTGLFontInstance& );
//                              EMFTGLFontInstance& operator=(const EMFTGLFontInstance& );
 
                                EMFTGL::FontMode font_mode;
                                string font_file_name;
                                unsigned int face_size;
                                unsigned int depth;
                                bool use_display_lists;
                                FTFont* font;
                };
 
                class EMFTGLManager
                {
                        public:
                                EMFTGLManager();
//              static EMFTGLManager& instance();
 
                                ~EMFTGLManager();
 
                                FTFont* get_font(EMFTGL::FontMode mode, const string& file_name, const unsigned int face_size, const unsigned int d, const bool use_dl);
                        private:
//                              EMFTGLManager(const EMFTGLManager& );
//                              EMFTGLManager& operator=(const EMFTGLManager& );
 
                                vector<EMFTGLFontInstance*> font_instances;
                };
 
                EMFTGLManager fm;
};
 
 
 
 
} // namespace EMAN
 
#endif //emftgl_h__