mainControl.h

Go to the documentation of this file.

// -*- Mode: C++; tab-width: 2; -*-
// vi: set ts=2:
//

#ifndef BALL_VIEW_KERNEL_MAINCONTROL_H
#define BALL_VIEW_KERNEL_MAINCONTROL_H

#ifndef BALL_CONCEPT_EMBEDDABLE_H
# include <BALL/CONCEPT/embeddable.h>
#endif

#ifndef BALL_DATATYPE_HASHMAP_H
# include <BALL/DATATYPE/hashMap.h>
#endif

#ifndef BALL_VIEW_KERNEL_CONNECTIONOBJECT_H
# include <BALL/VIEW/KERNEL/connectionObject.h>
#endif

#ifndef BALL_VIEW_KERNEL_REPRESENTATIONMANAGER_H
# include <BALL/VIEW/KERNEL/representationManager.h>
#endif

#ifndef BALL_VIEW_KERNEL_COMPOSITEMANAGER_H
# include <BALL/VIEW/KERNEL/compositeManager.h>
#endif

#ifndef BALL_VIEW_KERNEL_SHORTCUTREGISTRY_H
#include <BALL/VIEW/KERNEL/shortcutRegistry.h>
#endif

#ifndef BALL_FORMAT_INIFILE_H
# include <BALL/FORMAT/INIFile.h>
#endif

#ifndef BALL_SYSTEM_FILE_H
# include <BALL/SYSTEM/file.h>
#endif

#ifndef BALL_STRUCTURE_FRAGMENTDB_H
# include <BALL/STRUCTURE/fragmentDB.h>
#endif

#include <QtGui/QKeySequence>
#include <QtGui/QMainWindow>
#include <QtGui/QApplication>
#include <QtGui/QMenuBar> 
#include <QtGui/QLabel>
#include <QtCore/QTimer>

class QCloseEvent;

namespace BALL
{
  namespace VIEW
  {
    class ModelInformation;
    class ModularWidget;
    class Preferences;
    class MainControlPreferences;
    class OpenSavePreferences;
    class NetworkPreferences;
    class GeometricObjectSelectionMessage;
    class SimulationThread;

    class BALL_VIEW_EXPORT MainControl
      : public QMainWindow,
        public ConnectionObject,
        public Embeddable
    {
      friend class RepresentationManager;
      friend class SimulationThread;

      Q_OBJECT

      public:

      BALL_EMBEDDABLE(MainControl,Embeddable)

      
      enum PopUpID
      {
        FILE        = 10001,

        FILE_OPEN,

        FILE_OPEN_GRID,

        FILE_IMPORT,

        FILE_EXPORT,

        FILE_MONITOR,

        EDIT = 10100,

        BUILD = 10200,

        DISPLAY = 10300,

        DISPLAY_CREATE,
        
        DISPLAY_VIEWPOINT,

        DISPLAY_STEREO,
        
        DISPLAY_ANIMATION,

        MOLECULARMECHANICS = 10400,
        
        CHOOSE_FF,

        TOOLS = 10500,

        TOOLS_GRID,

        TOOLS_PYTHON,

        WINDOWS = 10600,

        USER = 10700,

        MACRO = 10750,

        HELP = 10800
      };



      MainControl(QWidget* parent = 0, const char* name = 0 , String inifile = ".BALL.preferences");

      virtual ~MainControl();
          
      // copy ctor needed for Python support only!
      MainControl(const MainControl& main_control);

      virtual void clear();

      void clearData();



      RepresentationManager& getRepresentationManager()
        { return primitive_manager_;}

      bool insert(Representation& rep);

      bool remove(Representation& rep);

      bool update(Representation& rep);

      bool updateRepresentationsOf(const Composite& composite, bool rebuild = true, bool force = false);

      void redrawAllRepresentations(bool rebuild_display_lists = false);
      

      ShortcutRegistry& getShortcutRegistry() { return shortcut_registry_;}

          
      //

      CompositeManager& getCompositeManager()
        { return composite_manager_;}
  
      bool insert(Composite& composite, String name = "");

      bool remove(Composite& composite, bool to_delete = true, bool update = true);
  
      void update(Composite& composite, bool changed_hierarchy = true);
      
      const HashSet<Composite*>& getSelection() const;

      HashSet<Composite*>& getSelection() ;

      std::list<Composite*>& getMolecularControlSelection();

      System* getSelectedSystem();

      void selectCompositeRecursive(Composite* composite, bool first_call=false);

      void deselectCompositeRecursive(Composite* composite, bool first_call=false);

      void printSelectionInfos();



      
      void saveBALLViewProjectFile(const String& filename, bool binary = true);
      
      void loadBALLViewProjectFile(const String& filename);

      virtual void fetchPreferences(INIFile &inifile);
      
      virtual void writePreferences(INIFile &inifile);
      
      virtual void restoreWindows();
  
      virtual void restoreWindows(const INIFile& inifile);
  
      INIFile& getINIFile();

      const INIFile& getINIFile() const;
      
      Preferences* getPreferences();
      
      virtual void applyPreferences();
      
    


      static MainControl* getMainControl(const QObject* object);
      
      void addModularWidget(ModularWidget* widget);

      void removeModularWidget(ModularWidget* widget);

      virtual void onNotify(Message *message);

      void sendMessage(Message& message);



    
      QAction* insertMenuEntry(Position parent_id, const String& name, const QObject* receiver = 0, 
                           const char* slot = 0, const String& description = "", QKeySequence accel = QKeySequence());

      void removeMenuEntry (Index parent_id, QAction* action);
      
      virtual QMenu* initPopupMenu(int ID);

      void insertPopupMenuSeparator(int ID);

      void setMenuHint(QAction* id, const String& hint);

      String getMenuHint(QAction* id) const;

      void setDeleteEntryEnabled(bool state);
  
      void insertDeleteEntry();

      QAction* getLastHighLightedMenuEntry() { return last_highlighted_menu_entry_;}
        


      bool compositesAreLocked() const;

      bool lockCompositesFor(ModularWidget* widget);

      bool unlockCompositesFor(ModularWidget* widget);

      ModularWidget* getLockingWidget();

      bool updateOfRepresentationRunning();
          
      bool stopedSimulation() { return stop_simulation_;}

      bool setSimulationThread(SimulationThread* thread);

      SimulationThread* getSimulationThread();

      bool useMultithreading();

      void setMultithreading(bool state)
        {multi_threading_mode_ = state;}

      bool isBusy() const;

      void wait();

      void processEvents(Size ms);

  

      
      void setStatusbarText(const String& text, bool important = false, bool beep = false);

      void setStatusbarText(const QString& text, bool important = false, bool beep = false);

      String getStatusbarText() const;
  
      const FragmentDB& getFragmentDB() const
        { return fragment_db_;}

      const ModelInformation& getModelInformation() const;

      void setModelInformation(ModelInformation* mi);

      String getWorkingDir() const
        { return working_dir_;}

      void setWorkingDir(const String& dir);

      void enableLoggingToFile();
      
      void disableLoggingToFile();

      void setLoggingFilename(const String& string);

      const String& getLoggingFilename() const;

      bool isAboutToQuit() { return about_to_quit_;}
    



      virtual void dump(std::ostream& s = std::cout, Size depth = 0) const;
          
      virtual void openFile(const String& file) ;



      
      public slots:

      virtual void show();

      virtual void checkMenus();

      void stopSimulation();
  
      void complementSelection();

      void clearSelection();

      virtual void aboutToExit();

      void menuItemHighlighted(QAction* action);
      
      virtual bool event(QEvent* e);

      virtual void quit(int return_value = 0);
    
      virtual void resize(int w, int h );

      void setContentSize(int w, int h);

      void toggleFullScreen();

      void quickSave();

      void quickLoad();
      
      void saveBALLViewProjectFile(); 

      void loadBALLViewProjectFile();

      void quickLoadConfirm();

      
      protected slots:

      /*_ This slot is called internally whenever the apply button
          of the Preferences dialog is pressed.
          It calls among other things the method applyPreferences().
      */
      virtual void applyPreferencesClicked_();
      
      /*_ This slot is called internally whenever the ok button
          of the Preferences dialog is pressed.
          It calls among other things the method applyPreferences().
      */
      virtual void okPreferencesClicked_();

      //_ Called by timer to clear the text in the statusbar
      void clearStatusBarText_();

      // Connected to the delete entry
      virtual void deleteClicked();

      void updateRepLabel_();

      protected:

      virtual void initializePreferencesTab_();

      //_  Called after receiving an SimulationThreadFinished event
      void stopedSimulation_();

      void lockComposites_();

      /*_ Remove a composite.
          Every Representation, which was created for the Composite is deleted, by sending a 
          RepresentationMessage with type RepresentationMessage::REMOVE.\par
          Redraws representations of the parent of the Composite, if wished.
          \return bool <tt>true</tt> if the CompositeManager has the Composite
      */
      bool remove_(Composite& composite, bool update_representations_of_parent = true, 
                                         bool to_delete = true);

      /*_ Select the composite parents of the geometric objects.
          The GeometricObjectSelectionMessage is sent by the Scene.
       */
      void selectComposites_(GeometricObjectSelectionMessage& message);

      void reduceSelection_(Composite* const composite);

      //_ Called by constructors
      void setup_();

      void complementSelectionHelper_(Composite& c);

      void setBusyMode_(bool state);

      //_
      void setPreferencesEnabled_(bool state);

      void init_();

      virtual void closeEvent(QCloseEvent* evt);

      bool                about_to_quit_;
      bool                multi_threading_mode_;  

      //_
      FragmentDB                  fragment_db_;

      ModelInformation*           model_information_;

      /*_ List with the selected composites
      */
      HashSet<Composite*>         selection_;

      /*_ List with the selected composites of the control.
          (Not the one with the checkboxes!)
      */
      std::list<Composite*>           control_selection_;

      /*_ Message label in the statusbar
          \see setStatusbarText
      */
      QLabel*                     message_label_;

      RepresentationManager       primitive_manager_;
      CompositeManager            composite_manager_; 
      ShortcutRegistry            shortcut_registry_;

      MainControlPreferences*     main_control_preferences_;
      OpenSavePreferences*        open_save_preferences_;
      NetworkPreferences*         network_preferences_;
      Preferences*                preferences_dialog_;
      INIFile                     preferences_file_;
      
      bool                        composites_locked_;
      ModularWidget*              locking_widget_;
      bool                        stop_simulation_;

      SimulationThread*           simulation_thread_;

      /*_ A list containing all modular widgets.
          This list is modified by addModularWidget and
          removeModularWidget.
      */
      std::list<ModularWidget*>       modular_widgets_;
    
      QLabel*             simulation_icon_;
      QLabel*             rep_label_;
      static const char  *simulation_running_xpm_[];
      static const char  *simulation_stoped_xpm_[];
      Position            rep_label_nr_;

      String              working_dir_;

      String              logging_file_name_;
      bool                logging_to_file_;
      File                logging_file_;

      bool                important_text_in_statusbar_;
      bool                was_not_busy_;
      Index               rep_label_delta_;
      QTimer              timer_;
      QTimer              render_timer_;
      Mutex               composites_locked_mutex_;

      QAction* stop_simulation_action_;
      QAction* fullscreen_action_;
      QAction* complement_selection_action_;
      QAction* clear_selection_action_;
      QAction* open_action_;
      QAction* save_project_action_;
      QAction* preferences_action_;
      QAction* delete_action_;
      QAction* qload_action_, *qsave_action_;

      QAction* last_highlighted_menu_entry_;
      HashMap<Position, QMenu*> id_to_menu_;
      QPoint        last_point_;
      QSize         last_size_;
      QByteArray    last_state_;
};

#   ifndef BALL_NO_INLINE_FUNCTIONS
#     include <BALL/VIEW/KERNEL/mainControl.iC>
#   endif 
    
    } // namespace VIEW
  } // namespace BALL

#endif // BALL_VIEW_KERNEL_MAINCONTROL_H