Anatomist.h

Go to the documentation of this file.

/* This software and supporting documentation are distributed by
 *     Institut Federatif de Recherche 49
 *     CEA/NeuroSpin, Batiment 145,
 *     91191 Gif-sur-Yvette cedex
 *     France
 *
 * This software is governed by the CeCILL-B license under
 * French law and abiding by the rules of distribution of free software.
 * You can  use, modify and/or redistribute the software under the
 * terms of the CeCILL-B license as circulated by CEA, CNRS
 * and INRIA at the following URL "http://www.cecill.info".
 *
 * As a counterpart to the access to the source code and  rights to copy,
 * modify and redistribute granted by the license, users are provided only
 * with a limited warranty  and the software's author,  the holder of the
 * economic rights,  and the successive licensors  have only  limited
 * liability.
 *
 * In this respect, the user's attention is drawn to the risks associated
 * with loading,  using,  modifying and/or developing or reproducing the
 * software by the user in light of its specific status of free software,
 * that may mean  that it is complicated to manipulate,  and  that  also
 * therefore means  that it is reserved for developers  and  experienced
 * professionals having in-depth computer knowledge. Users are therefore
 * encouraged to load and test the software's suitability as regards their
 * requirements in conditions enabling the security of their systems and/or
 * data to be ensured and,  more generally, to use and operate it in the
 * same conditions as regards security.
 *
 * The fact that you are presently reading this means that you have had
 * knowledge of the CeCILL-B license and that you accept its terms.
 */
 
 
#ifndef ANATOMIST_APPLICATION_ANATOMIST
#define ANATOMIST_APPLICATION_ANATOMIST
 
#include <anatomist/config/anatomist_config.h>
#include <aims/getopt/getopt2.h>
#include <qwidget.h>
#include <set>
#include <map>
 
class ReferentialWindow;
class ControlWindow;
 
 
namespace anatomist
{
 
  class AObject;
  class MObject;
  class PaletteList;
  class Transformation;
  class AWindow;
  class Referential;
  class GlobalConfiguration;
  class CommandWriter;
 
  namespace internal
  {
    class AnatomistPrivate;
  }
 
  class ANATOMIST_API Anatomist : public aims::AimsApplication
  {
 
  public:
    enum Cursor
    {
      Normal, 
      Working
    };
 
    Anatomist( int argc, const char **argv, 
               const std::string &documentation );
    virtual ~Anatomist();
 
    virtual void initialize();
    static std::string versionString();
    static std::string libraryVersionString();
 
    PaletteList & palettes();
    const PaletteList & palettes() const;
 
    virtual void Refresh();
 
    void NotifyMapWindow( AWindow* );
    void NotifyUnmapWindow( AWindow* );
 
    virtual void createControlWindow();
    ControlWindow* getControlWindow() const;
    QWidget* getQWidgetAncestor() const;
 
    virtual void createReferentialWindow();
    ReferentialWindow* getReferentialWindow() const;
 
    bool hasWindow( const AWindow* win ) const;
    int groupWindows( std::set<AWindow*> & winL, int groupnum = -1 );
    void ungroupWindows( int group );
    std::set<AWindow*> getWindowsInGroup( int group );
    void NotifyWindowChange( AWindow* win );
 
    int destroyObject( AObject*, bool verbose = true );
    std::set<AObject *> destroyObjects( const std::set<AObject* > &,
                                        bool verbose = true );
    bool hasObject( const AObject* obj ) const;
    void mapObject( AObject* obj );
    void unmapObject( AObject* obj );
 
    virtual void UpdateInterface();
 
    std::string makeObjectName( const std::string & name );
    std::set<AObject* > getObjects() const;
    std::set<AWindow*> getWindows() const;
    const std::set<Referential*> & getReferentials() const;
    bool hasReferential( const Referential * );
    Transformation* getTransformation( const Referential*, 
                                       const Referential* );
    const Transformation* getTransformation( const Referential*, 
                                             const Referential* ) const;
 
    std::list<AObject *> loadObject( const std::string & filename,
                                     const std::string & objname = "",
                                     carto::Object options = carto::none() );
 
    void registerObject( AObject* obj, int inctrl=1 );
    void unregisterObject( AObject* obj );
    void releaseObject( AObject* obj );
    void takeObjectRef( AObject* obj );
    void NotifyObjectChange( AObject* obj );
    void registerSubObject( MObject* parent, AObject* obj );
    void registerReferential( Referential* ref );
    void unregisterReferential( Referential* ref );
    void registerWindow( AWindow* win );
    void unregisterWindow( AWindow* win );
    void releaseWindow( AWindow* win );
    void takeWindowRef( AWindow* obj );
    void registerObjectName( const std::string& name, AObject* obj );
    void unregisterObjectName( const std::string& name );
 
    bool initialized() const;
 
    const CommandWriter & historyWriter() const;
    CommandWriter & historyWriter();
    GlobalConfiguration* config();
 
    void setCursor( Cursor c );
 
    const std::string & objectsFileFilter() const;
    void addObjectsFileFilter( const std::string & filter );
 
    virtual bool glMakeCurrent();
    Referential* centralReferential() const;
    std::string language() const;
    int userLevel() const;
    void setUserLevel( int );
    void setLastPosition( const Point3df & pos, Referential * fromref = 0 );
    void setLastPosition( const std::vector<float> & pos,
                          Referential * fromref = 0 );
    Point3df lastPosition( const Referential* toref = 0 ) const;
    std::vector<float> lastFullPosition( const Referential* toref = 0 ) const;
    bool destroying() const;
    void updateFileDialogObjectsFilter();
    void lockObjects( bool locked=true );
 
  private:
    // friend ~ReferentialWindow would be enough but needs to include its .h
    friend class ::ReferentialWindow;
    friend class anatomist::internal::AnatomistPrivate;
    struct Anatomist_privateData;
 
    void unregisterReferentialWindow();
 
    Anatomist_privateData               *_privData;
  };
 
}
 
 
extern anatomist::Anatomist* ANATOMIST_API theAnatomist;
 
 
#endif