gcp/application.h

Go to the documentation of this file.

// -*- C++ -*-

/*
 * GChemPaint library
 * application.h
 *
 * Copyright (C) 2004-2012 Jean Bréfort <jean.brefort@normalesup.org>
 *
 * 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 3 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., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301
 * USA
 */

#ifndef GCHEMPAINT_APPLICATION_H
#define GCHEMPAINT_APPLICATION_H

#include <gcugtk/application.h>
#include <gcu/macros.h>
#include <libxml/parser.h>
#include <set>
#include <string>
#include <map>
#include <stdexcept>

namespace gccv {
        class Canvas;
}

namespace gcu {
        class Dialog;
        class Object;
}

namespace gcp {

typedef struct
{
        char const *name;
        unsigned char const *data_24;
        gccv::Canvas *canvas;
} IconDesc;

class Target;
class NewFileDlg;
class Tool;
class Document;
typedef void (*BuildMenuCb) (gcu::UIManager *UIManager);

typedef enum {
        CursorUnallowed,
        CursorPencil,
        CursorMax
} CursorId;

class Application: public gcugtk::Application
{
friend class ApplicationPrivate;
public:
        Application (gcugtk::CmdContextGtk *cc = NULL);
        virtual ~Application ();

        void ActivateTool (const std::string& toolname, bool activate);

        void ActivateWindowsActionWidget (const char *path, bool activate);
        virtual void ClearStatus ();
        virtual void SetStatusText (const char* text);
        virtual GtkWindow* GetWindow () = 0;
        Tool* GetActiveTool () {return m_pActiveTool;}
        gcp::Document* GetActiveDocument () {return m_pActiveDoc;}
        void SetActiveDocument (gcp::Document* pDoc) {m_pActiveDoc = pDoc;}
        Tool* GetTool (const std::string& name) {return m_Tools[name];}
        void SetTool (const std::string& toolname, Tool* tool) {m_Tools[toolname] = tool;}
        GtkWidget* GetToolItem(const std::string& name) {return ToolItems[name];}
        void SetToolItem (const std::string& name, GtkWidget* w) {ToolItems[name] = w;}
        void SetCurZ (int Z) {m_CurZ = Z;}
        int GetCurZ () {return m_CurZ;}
        void OnSaveAs ();
        bool FileProcess (const gchar* filename, const gchar* mime_type, bool bSave, GtkWindow *window, gcu::Document *pDoc = NULL);
        void SaveGcp (std::string const &filename, gcp::Document* pDoc);
        void OpenGcp (std::string const &filename, gcp::Document* pDoc);
        xmlDocPtr GetXmlDoc () {return XmlDoc;}
        void OnSaveAsImage ();
        bool HaveInChI () {return m_Have_InChI;}
        int GetDocsNumber () {return m_Docs.size ();}
        void Zoom (double zoom);
        void AddActions (GtkRadioActionEntry const *entries, int nb, char const *ui_description, IconDesc const *icons);
        void RegisterToolbar (char const *name, int index);
        void OnToolChanged (GtkAction *current);
        void AddTarget (Target *target);
        void DeleteTarget (Target *target);
        void NotifyIconification (bool iconified);
        void NotifyFocus (bool has_focus, Target *target = NULL);
        void CloseAll ();
        std::list<std::string> &GetSupportedMimeTypes () {return m_SupportedMimeTypes;}
        void OnConfigChanged (GOConfNode *node, gchar const *name);
        std::list<std::string> &GetExtensions(std::string &mime_type);

        void OnThemeNamesChanged ();

        void AddMenuCallback (BuildMenuCb cb);

        void BuildMenu (gcu::UIManager *manager);

        gcu::Document *CreateNewDocument ();

        // virtual menus actions:
        virtual void OnFileNew (char const *Theme = NULL) = 0;

        GdkCursor *GetCursor (CursorId id)  {return m_Cursors[id];}

        bool Have3DSupport () {return m_HaveGhemical | m_HaveGChem3D | m_HaveAvogadro;}
        void AddCanvas (char const *path, gccv::Canvas *canvas) {m_ToolCanvases[path] = canvas;}
        void ReceiveTargets (GtkClipboard *clipboard, GtkSelectionData *selection_data);

protected:
        void InitTools();
        void BuildTools () throw (std::runtime_error);
        void ShowTools (bool visible);

private:
        void TestSupportedType (char const *mime_type, char const* babel_type = NULL, bool writeable = false);
        void AddMimeType (std::list<std::string> &l, std::string const& mime_type);
        void UpdateAllTargets ();

protected:
        gcp::Document *m_pActiveDoc;
        Target *m_pActiveTarget;
        unsigned m_NumWindow; //used for new files (Untitled%d)

private:
        int m_CurZ;
        std::map <std::string, GtkWidget*> ToolItems;
        std::map <std::string, GtkWidget*> Toolbars;
        std::map <std::string, Tool*> m_Tools;
        Tool* m_pActiveTool;
        static bool m_bInit;
        static bool m_Have_InChI;
        xmlDocPtr XmlDoc;
        GtkIconFactory *IconFactory;
        std::list<char const*> UiDescs;
        GtkRadioActionEntry* RadioActions;
        int m_entries;
        std::map<int, std::string> ToolbarNames;
        unsigned m_NumDoc; //used to build the name of the action associated with the menu
        std::set<Target*> m_Targets;
        int visible_windows;
        std::list<std::string> m_SupportedMimeTypes;
        std::list<std::string> m_WriteableMimeTypes;
        GOConfNode *m_ConfNode;
        guint m_NotificationId;
        gcu::Object *m_Dummy;
        std::list<BuildMenuCb> m_MenuCbs;
        GdkCursor *m_Cursors[CursorMax];
        std::map < std::string, gccv::Canvas * >m_ToolCanvases;

        GCU_RO_STATIC_PROP (bool, HaveGhemical)
        GCU_RO_STATIC_PROP (bool, HaveGChem3D)
        GCU_RO_STATIC_PROP (bool, HaveAvogadro)
        GCU_RO_PROP (bool, UseAtomColors)
};

}       // namespace gcp

#endif //GCHEMPAINT_APPLICATION_H