hamolview.h

Go to the documentation of this file.

#ifndef HAMOLVIEW_H
#define HAMOLVIEW_H


#include "hastl.h"
#include "habond.h"
#include "haatgroup.h"
#include "canvas3d.h"
#include "command.h"
#include "halinalg.h"

#include "hamolset.h"

const long LOAD_AMBER_RESTART_TIMER_ID = 100301;

class HaChain;

class HaMolecule;
class Expr;
class Object3D;

class Monitor
{
public:
    Monitor();
    virtual ~Monitor();
    HaAtom  *src;
    HaAtom  *dst;

    bool operator ==( const Monitor& ref) const;
    bool operator < ( const Monitor& ref) const;

    double dist;
    short col;
};

class ShadeDesc
{
public:
    ShadeDesc();
        ~ShadeDesc();

    int def;
    unsigned char r;
    unsigned char g;
    unsigned char b;
};

class ShadeRef 
{
public:
   short col;
   short shade;
   unsigned char r;
   unsigned char g;
   unsigned char b;
};


const int ResidueAttr = 0x00;
const int ChainAttr   = 0x01;
const int TempAttr    = 0x02;
const int ChargeAttr  = 0x03;

const int RibColInside   = 0x01;
const int RibColOutside  = 0x02;
const int RibColBoth     = 0x03;

const int BackCol = 0;
const int BoxCol  = 1;
const int LabelCol = 2;
const int FirstCol = 3;


const int  VOXORDER = 21;
const int  VOXORDER2 = VOXORDER*VOXORDER;
const int  VOXSIZE   = VOXORDER2*VOXORDER;

typedef void* PSItemPtr;

class HaMolView 
{
public:

    HaMolView();
        virtual ~HaMolView();

public:
        HaMolSet* GetMolSet(); 
        
        int debug_level;

        void ResetView();

        int UseDepthCue;
        int UseStereo;
        int UseClipping;
        
        int SSBondMode,HBondMode;
        static int ZoneBoth;       

        int UseTransparent;
        int UseOutLine;
        int KinemageFlag;

        double StereoAngle;

        int DrawBoundBox,DrawAxes;
        int DrawDoubleBonds;
        int DrawUnitCell;

        double CartoonHeight;
        int SolventDots;
        double ProbeRadius;  

        int DrawDots,DrawLabels;
        int DrawMonitDistance;
        int DrawBetaArrows;
        
public:
        HaMolSet* host_mol_set;


public:
        Partition HashTable;

        static ShadeDesc Shade[LastShade] ; 

    static ShadeRef ScaleRef[LastShade]; 
    static int ScaleCount;               

        inline static int Colour2Shade(const int x) { return (int) (x-FirstCol)/ColourDepth; } 
        inline static int Shade2Colour(const int x) { return  x*ColourDepth+FirstCol ; }       
        
        int XOffset, YOffset;
        int ideltx, idelty;  

    double CenX, CenY, CenZ;          

        double CurRX; 
        double CurRY; 
        double CurRZ; 

        double CurTX; 
        double CurTY; 

        double CurZoom;      
        double CurSlabValue; 

        double LastRX,LastRY,LastRZ;  


        double LastTX, LastTY;        


        int PointX; 
        int PointY; 
        int InitX;  
        int InitY;  

        static int FakeSpecular,SpecPower;
        static int BackR,BackG,BackB; 
        static int LabR,LabG,LabB;    
        static int BoxR,BoxG,BoxB;    
        int UseLabelCol;
        static int UseBackFade;
        static double Ambient;

 // Transformation matricies connecting absolute and screen coordinate system:
        HaMat_double Rot;  
        HaVec_double Orig; 

        double Zoom;           

        double Scale;          
        double DScale;         
                               
        int UseScreenClip;
        int m_screen_transform; 

        int ReDrawFlag;
        int Hydrogens,HetaGroups;
        int DrawAtoms;
        int DrawBonds;
        int DrawRibbon;
        int DrawBestPath;
        int DrawContourSurf;
        int DrawSolidSurfaces;

protected:
        int StereoView;

        int FBufX,FBufY; 

public:

        virtual int ExecuteCommand(CmdParser& cmd_pr);
        int ExecuteSetCommand(CmdParser& cmd_pr);
        int ExecuteColourCommand(CmdParser& cmd_pr);
        void ConnectObject(Object3D* pObj);

        int BroadcastCurrAtom();
        int FillCurrAtomRef(char* buf);

        bool SetImageSize(int new_ImageSize);
        int GetImageSize();
        int GetImageRadius();

        void SetUseSlabPlane(int new_UseSlabPlane) { pCanv->m_UseSlabPlane= new_UseSlabPlane; }
        int UseSlabPlane() { return pCanv->m_UseSlabPlane; }
        void SetSlabMode(int new_SlabMode ) { pCanv->m_SlabMode= new_SlabMode; }
        int SlabMode() { return pCanv->m_SlabMode; }
        void SetSlabValue(int new_SlabValue ) { pCanv->m_SlabValue= new_SlabValue; }
        int SlabValue() { return pCanv->m_SlabValue; }

        void SetSlabInten( int new_SlabInten)   { pCanv->m_SlabInten= new_SlabInten; }
        void SetSliceValue( int new_SliceValue) { pCanv->m_SliceValue= new_SliceValue; }
        int SliceValue() { return pCanv->m_SliceValue; }
        

        void SetZOffset(int new_ZOffset) { pCanv->m_ZOffset = new_ZOffset; }
        int ZOffset() { return pCanv->m_ZOffset; }

#if !defined(_WIN32) & !defined(TWIN32)
        static int OpenDisplay( int, int );
#endif

protected:
        void MouseMove(int status, int dx, int dy );
        void ClampShiftVal(int  ival,double  value ); 
        void WrapShiftVal(int iaxis, double value ); 

public:

        virtual void UpdateThisView(long lHint=0);
        virtual void RefreshScreen() {}
        int CreateImage();
        virtual void ClearImage(){}
        void ClearBuffers();
        virtual void TransferImage(){}
        virtual int PrintImage(){ return True;}
        virtual int ClipboardImage(){ return True;}
        void ReSizeScreen();
        void ReAllocBuffers();

        void BuildHashTable();  
 
        void DrawFrame();        
        void ResetRenderer();
        void SetStereoMode( int );
        void SetPickMode( int );
        void PickAtom( int, int, int );

        void SetRefreshScreen();

// Transform functions
public:
        void InitialTransform(); 
        void PrepareTransform();
        void ApplyTransform();  
        void ResetTransform();  
        void CalcRotCenter(int sel_atoms = FALSE); 

        void CenterSelected(); 

        void GetTransfCoord(const double x_abs, const double y_abs, const double z_abs,
                                double& x_tr, double& y_tr, double& z_tr); 
        
public:
        void SetAtomScreenRadVal( double rad ); 
        void SetRadiusTemperature();
        void SetAtomScreenRadVdW(); 
        void DefaultRepresentation();
        void DisableSpacefill();
        void EnableWireframe( int mask, double rad );
        void DisableWireframe();
        void EnableBackbone( int mask, double rad );
        void DisableBackbone();
        void SetHBondStatus( int hbonds, int enable, double rad );
        void SetRibbonCartoons();
    void SetRibbonStatus( int enable, int flag, double width );
    void SetTraceTemperature();
        
        static void SetMouseMode( int );
        static int MouseMode;
        static int UseHourGlass;

// Color Manipulation functions:

        vector<int> min_color_map; 
        map<int,int, less<int> > rev_color_map; 

        static void DefineColourMap(); 
        
        int ComputeRevColourMap(); 



        void ScaleColourMap( int count ); 

        static int IsShadeDefined(unsigned char r, unsigned char g, unsigned char b ); 
        static int DefineShade( unsigned char r, unsigned char g, unsigned char b ); 
    static int SetShadeLutEntries(int shade_idx); 
    static int GetColorIdx(unsigned char r, unsigned char g, unsigned char b ); 

        void ColourBackNone();
        void ColourBondNone();
        void ColourHBondType();
        void ColourHBondNone( int hbonds);
        void ColourMonitNone();
        void ColourBackAttrib( int r, int g, int b);
        void ColourBondAttrib( int r, int g, int b);
        void ColourHBondAttrib( int hbonds, int r, int g, int b);
        void ColourMonitAttrib( int r, int g, int b);
        void ColourDotsAttrib( int r, int g, int b);
        void ColourDotsPotential();
    void ColourRibbonNone( int flag );
    void ColourRibbonAttrib( int flag, int r, int g, int b );

        void ScaleColourAttrib( int attr );
        void MonoColourAttrib( int r, int g, int b );
        void CPKColourAttrib();
        void GroupsColourAttrib();
        void ShapelyColourAttrib();     
        void AminoColourAttrib();
        void StructColourAttrib();
        int IsCPKColour( HaAtom* aptr );


        void FormatLabel(HaChain* chain, HaResidue* group, HaAtom* aptr, 
                             const char* label, char* ptr );
        int DeleteLabels();
        void DefineLabels( const char* label );
        void DefaultLabels( int enable );
        void DisplayLabels();

        int LabelOptFlag;
        

        list<Monitor> MonitList;

        void DeleteMonitors();
        void AddMonitors( HaAtom* src, HaAtom* dst );
        void CreateMonitor( Long src, Long dst );
        void DisplayMonitors();


        void DisplayETBestPath();


        void DisplayContourSurf();

        void RestrictSelected(); 


        int TestDot( double x, double y, double z, bool solvent_access);
        void InitElemDots();
        void AddElemDots( int elem, int density );
        void FreeElemDots();

        void DeleteDotSurfaces();
        void CalculateDotSurface( int density);
        void DisplayDotSurfaces();


        void DisplayRibbon( HaChain * ); 


protected:
        void WriteByte( int );
        void WriteLSBShort( int );
        void WriteMSBShort( int );
        void WriteLSBLong( unsigned int );
        void WriteMSBLong( unsigned int );      
        void WriteGIFCode(int code );
        void WritePPMWord(int i );      
        void FlushRastRLE();
        void WriteRastRLECode( int val );
        void WriteRastRLEPad();
        void WriteRastData( int output );
        void OutputEPSFByte( int val );
        void EncodeEPSFPixel( int val, int col );
        void FlushBMPBuffer();
        void FlushBMPPackets();
        void ProcessBMPPacket();
        void WriteBMPCode( int val);
        void WriteBMPData( int output );
    int FindDepth( PSItemPtr item, int type);
    void DepthSort( PSItemPtr* data, char* type, int count);    
        int ClipVectSphere( HaAtom * );
        int ClipVectBond( HaAtom *, HaAtom * );
        void WriteVectColour( int col );
        void WriteVectSphere( PSItemPtr *data, char *type,int index);
        void WriteVectWire( HaAtom* src, HaAtom* dst, int col, int dash );
        void WriteVectStick(HaAtom* src,HaAtom* dst, int col, int rad );

        Long CountPSItems();
        void FetchPSItems( PSItemPtr *, char * );
        void WritePSItems( PSItemPtr *, char *, int );
        void WriteVectDots();
        void WriteVectLabels();
        void WriteVectMonitors();
        void FlushPICTBuffer();
        void FlushPICTPacket();
        void WritePICTCode(int val );
        void WritePICTData();
        void FlushIRISBuffer();
        void FlushIRISPacket();
        void WriteIRISCode(int val );
        void DetermineIRISSizes(Long* rowstart,short* rowsize, int* min, int* max );
        void WriteIRISHeader(Long* rowstart, short* rowsize, int min, int max );
        void WriteIRISData();

public:
        void WriteImageFile(const char* name, int type );
        int WritePPMFile( const char* name,int raw );
        int WriteGIFFile( const char* name );
        int WriteRastFile( const char* name, int encode );
        int WriteEPSFFile( const char* name, int col, int compr );
        int WriteBMPFile( const char* name );
        int WriteVectPSFile(const char* name );
        int WritePICTFile(const char* name );
        int WriteIRISFile(const char* name );

        int WriteScriptFile(const char *name);  
        int WriteKinemageFile(const char* name);
        int WriteMolScriptFile(const char* name);
        int WritePOVRayFile(const char* name);
        int WriteVRMLFile(const char* name);



public:

        void WriteVRMLDots();
        void WriteVRMLColour( int indent, int shade ); 
        void WriteVRMLTriple( double x, double y, double z ); 
        void WriteVRMLAtoms(); 
        void WriteVRMLLine( int src, int dst, int shade, int* flag );
        void WriteVRMLWireframe();



protected:
        void WriteKinemageDots();
        void WriteKinemageData();
        int  CheckKinemageChain( HaAtom* src, HaAtom* dst, HaChain* chain );
        void WriteKinemageLabels( HaChain* chain );
        void WriteKinemageRibbons(HaChain* chain );
        void WriteKinemageSpheres( HaChain* chain );
        void OutputKinemageVector( HaAtom* src, HaAtom* dst, int col );
        void WriteKinemageBonds( HaChain* chain );

protected:
        void WriteScriptAtoms();
        void WriteScriptBonds();
        void WriteScriptBackbone();
        void WriteScriptRibbons();
        void WriteScriptLabels();
        void WriteScriptMonitors();
        void WriteScriptHBonds( char* obj );

public:

        Canvas3D* pCanv;  
        
        void DisplaySpaceFill();   
        void DisplayWireframe();   
        void DisplayCylinder(int x1,int y1,int z1,
                                                 int x2,int y2,int z2,
                                                 int c1,int c2,int rad);
        void DisplayDoubleBonds();
    void DisplayBackbone();     
        void DisplayHBonds( int mode ); 
        void DisplayBoxes();  
        void DisplayOnScreenInfo(); 
        void DisplayPickedAtoms();  
        void RenderFrame();   

        void TestAtomProximity( HaAtom* ptr, int xpos, int ypos); 
        void IdentifyAtom( int xpos, int ypos );               
        void InitializeTables();
        void InitializeRenderer();

};

//
// Macros below require definition
// MoleculesType::iterator mol_itr;
//

#define ForEachMol_VIEW     for(mol_itr=(GetMolSet()->HostMolecules).begin(); mol_itr != (GetMolSet()->HostMolecules).end(); mol_itr++)

#define ForEachChain_VIEW for(mol_itr=(GetMolSet()->HostMolecules).begin(); mol_itr != (GetMolSet()->HostMolecules).end(); mol_itr++) \
                                                        for(chain=(*mol_itr)->GetFirstChain();chain;chain=(*mol_itr)->GetNextChain())
#define ForEachResidue_VIEW  for(mol_itr=(GetMolSet()->HostMolecules).begin(); mol_itr != (GetMolSet()->HostMolecules).end(); mol_itr++)  \
                                                        for(chain=(*mol_itr)->GetFirstChain();chain;chain=(*mol_itr)->GetNextChain()) \
                                 for( group=chain->GetFirstRes(); group; group=chain->GetNextRes() )
#define ForEachBack_VIEW  for(mol_itr=(GetMolSet()->HostMolecules).begin(); mol_itr != (GetMolSet()->HostMolecules).end(); mol_itr++)  \
                                                  for(chain=(*mol_itr)->GetFirstChain();chain;chain=(*mol_itr)->GetNextChain()) \
                                  for(bptr=chain->GetFirstBackB(); bptr; bptr= chain->GetNextBackB())


const int PickNone    =     0x00;
const int PickIdent   =     0x01;
const int PickDist    =     0x02;
const int PickAngle   =     0x03;
const int PickTorsn   =     0x04;
const int PickLabel   =     0x05;
const int PickMonit   =     0x06;
const int PickCentr   =     0x07;
const int PickMolConnect =  0x08;

const int DefaultWide = 480;
const int DefaultHigh = 480;

const int RFRotateX  = 0x0001;
const int RFRotateY  = 0x0002;
const int RFRotateZ  = 0x0004;
const int RFZoom     = 0x0008;
const int RFTransX   = 0x0010;
const int RFTransY   = 0x0020;
const int RFTransZ   = 0x0040;
const int RFSlab     = 0x0080;
const int RFReSize   = 0x0100;
const int RFColour   = 0x0200;
const int RFRefresh  = 0x0400;
const int RFPoint1   = 0x1000;
const int RFPoint2   = 0x2000;

const int RFTrans    = 0x0070;
const int RFRotate   = 0x0007;
const int RFApply    = 0x017F;
const int RFDials    = 0x00FF;
const int RFMagnify  = 0x0108;
const int RFInitial  = 0x01FF;
const int RFPoint    = 0x3000;


const int MMRasMol   = 0x00;
const int MMInsight  = 0x01;
const int MMQuanta   = 0x02;


const int ViewLeft   =   0;
const int ViewRight  =   1;
 
unsigned int isqrt( unsigned int );

#define ZValid_v(z)     ((!UseSlabPlane() ) || ((z) < SlabValue()))
#define XValid_v(x)     (((x)>=0)&&((x)< pCanv->View.xmax))
#define YValid_v(y)     (((y)>=0)&&((y)< pCanv->View.ymax))

#ifdef HAMOLVIEW_CPP

HaMolView*  CurMolView;

#else

extern HaMolView* CurMolView;

#endif


#endif // !defined HAMOLVIEW_H 

---