GenericPluginUI.h

Go to the documentation of this file.

/*
 * Copyright 2012 Joel Baxter
 *
 * This file is part of MeshTex.
 *
 * MeshTex 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.
 *
 * MeshTex 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 MeshTex.  If not, see <http://www.gnu.org/licenses/>.
 */

#if !defined(INCLUDED_GENERICPLUGINUI_H)
#define INCLUDED_GENERICPLUGINUI_H

#include <vector>
#include <gdk/gdk.h>
#include <glib.h>

#include "GenericMainMenu.h"
#include "GenericDialog.h"

#include "qerplugin.h"
#include "generic/referencecounted.h"

class GenericPluginUI
{
protected: // protected methods


   GenericPluginUI();
   virtual ~GenericPluginUI();

private: // private methods


   GenericPluginUI(const GenericPluginUI&);
   const GenericPluginUI& operator=(const GenericPluginUI&);

public: // public types

   typedef Callback3<GtkWidget *, GdkEvent *, gpointer, gint> DialogEventCallback;

   typedef Callback2<GtkWidget *, gpointer, void> DialogSignalCallback;

   template<typename ObjectClass, gint (ObjectClass::*member)(GtkWidget *, GdkEvent*, gpointer)>
   class DialogEventCallbackMethod : public BindFirstOpaque3<Member3<ObjectClass, GtkWidget *, GdkEvent*, gpointer, gint, member> >
   {
   public:
      DialogEventCallbackMethod(ObjectClass& object) :
         BindFirstOpaque3<Member3<ObjectClass, GtkWidget *, GdkEvent *, gpointer, gint, member> >(object) {}
   };

   template<typename ObjectClass, void (ObjectClass::*member)(GtkWidget *, gpointer)>
   class DialogSignalCallbackMethod : public BindFirstOpaque2<Member2<ObjectClass, GtkWidget *, gpointer, void, member> >
   {
   public:
      DialogSignalCallbackMethod(ObjectClass& object) :
         BindFirstOpaque2<Member2<ObjectClass, GtkWidget *, gpointer, void, member> >(object) {}
   };

public: // public methods


   void RegisterMainMenu(SmartPointer<GenericMainMenu>& mainMenu);
   void RegisterDialog(SmartPointer<GenericDialog>& dialog);
   void SetWindow(GtkWidget *window);


   GenericMainMenu *MainMenu();
   GenericDialog *Dialog(const std::string& key);


   static gint DialogEventCallbackDispatch(GtkWidget *widget,
                                           GdkEvent* event,
                                           gpointer data);
   static void DialogSignalCallbackDispatch(GtkWidget *widget,
                                            gpointer data);
   gpointer RegisterDialogEventCallback(GtkWidget *widget,
                                        const gchar *name,
                                        const DialogEventCallback& callback);
   gpointer RegisterDialogSignalCallback(GtkWidget *widget,
                                         const gchar *name,
                                         const DialogSignalCallback& callback);


   void RegisterWidgetDependence(GtkWidget *controller,
                                 GtkWidget *controllee);
   void RegisterWidgetAntiDependence(GtkWidget *controller,
                                     GtkWidget *controllee);
   void WidgetControlCallback(GtkWidget *widget,
                              gpointer callbackID);


   static void ErrorReportDialog(const char *title,
                                 const char *message);
   static void WarningReportDialog(const char *title,
                                   const char *message);
   static void InfoReportDialog(const char *title,
                                const char *message);

private: // private types

   typedef std::map<std::string, SmartPointer<GenericDialog> > DialogMap;

   typedef std::map<gpointer, DialogEventCallback> DialogEventCallbackMap;

   typedef std::map<gpointer, DialogSignalCallback> DialogSignalCallbackMap;

   typedef std::map<GtkWidget *, std::vector<GtkWidget *> > WidgetDependenceMap;

private: // private member vars

   GtkWidget *_window;

   SmartPointer<GenericMainMenu> *_mainMenu;

   unsigned _callbackID;

   const DialogSignalCallbackMethod<GenericPluginUI, &GenericPluginUI::WidgetControlCallback>
      _widgetControlCallback;

   DialogMap _dialogMap;

   DialogEventCallbackMap _dialogEventCallbackMap;

   DialogSignalCallbackMap _dialogSignalCallbackMap;

   WidgetDependenceMap _widgetControlMap;

   WidgetDependenceMap _widgetControlledByMap;

   WidgetDependenceMap _widgetAntiControlledByMap;
};


GenericPluginUI& UIInstance();

#endif // #if !defined(INCLUDED_GENERICPLUGINUI_H)