Alphabetical Class Index  Class Hierarchy   File Members   Compound Members   File List  

HBaseView.h
Go to the documentation of this file.
00001 // Copyright (c) 1998-2014 by Tech Soft 3D, Inc.
00002 //
00003 // The information contained herein is confidential and proprietary to Tech Soft 3D, Inc.,
00004 // and considered a trade secret as defined under civil and criminal statutes.
00005 // Tech Soft 3D, Inc. shall pursue its civil and criminal remedies in the event of
00006 // unauthorized use or misappropriation of its trade secrets.  Use of this information
00007 // by anyone other than authorized employees of Tech Soft 3D, Inc. is granted only under
00008 // a written non-disclosure agreement, expressly prescribing the scope and manner of such use.
00009 
00013 #ifndef _HBASEVIEW_H
00014 #define _HBASEVIEW_H
00015 
00016 #ifdef H_PACK_8
00017 #pragma pack(push)
00018 #pragma pack(8)
00019 #endif
00020 
00021 #include "HTools.h"
00022 #include "HTManager.h"
00023 #include "HEventListener.h"
00024 
00025 class HDB;
00026 class HBaseModel;
00027 class HCamera;
00028 class HEventInfo;
00029 class HSelectionSet;
00030 class HBaseOperator;
00031 class HConstantFrameRate;
00032 class HSharedKey;
00033 class HImCuttingGeometry;
00034 class HOutputHandler;
00035 class HOutputHandlerOptions;
00036 class HInputHandler;
00037 class HInputHandlerOptions;
00038 class HUtilityAntialiasing;
00039 class HMarkupManager;
00040 class HShadow;
00041 class HUndoManager;
00042 class HEventManager;
00043 class HObjectManager;
00044 class HOpCameraManipulate;
00045 class HDebugZBuffer;
00046 class HConstFRSimpType;
00047 
00048 
00054 typedef bool(*HSignalNotifyFunction)(int signal, void *signal_data, void *user_data);
00055 
00056 
00057 
00061 enum HRenderMode 
00062 {
00063     HRenderWireframe = 1,       
00064     HRenderTriangulation = 2,   
00065     HRenderSilhouette = 3,      
00066     HRenderHiddenLine = 4,      
00067     HRenderHiddenLineHOOPS = 5, 
00068     HRenderHiddenLineFast = 6,  
00069     HRenderFlat = 7,            
00070     HRenderGouraud = 8,         
00071     HRenderGouraudWithEdges = 9,
00072     HRenderPhong = 10,          
00073     HRenderShaded = 11,         
00074     HRenderShadedWithLines = 12,
00075     HRenderWireframeWithSilhouette = 13, 
00076     HRenderShadedWireframe = 14,
00077     HRenderVertices = 15,       
00078     HRenderShadedVertices = 16, 
00079     HRenderGouraudWithLines = 17,
00080     HRenderLOD1 = 18,
00081     HRenderLOD2 = 19,
00082     HRenderBRepHiddenLine = 20, 
00083     HRenderBRepHiddenLineFast = 21, 
00084     HRenderBRepWireframe = 22,  
00085     HRenderGoochShaded  = 23,   
00086     HRenderFakeHiddenLine = 24, 
00087     HRenderUnknown = 0
00088 };
00089 
00093 enum ViewMode 
00094 {
00095     HViewNone,     
00096     HViewXY,  
00097     HViewYX,  
00098     HViewXZ,  
00099     HViewZX,  
00100     HViewYZ,  
00101     HViewZY,  
00102     HViewIso,  
00103     HViewIsoFrontRightTop,  
00104     HViewIsoBackRightTop,  
00105     HViewIsoBackLeftTop,  
00106     HViewIsoBackLeftBottom,  
00107     HViewIsoBackRightBottom,  
00108     HViewIsoFrontLeftTop,  
00109     HViewIsoFrontLeftBottom,  
00110     HViewIsoFrontRightBottom,  
00111 
00112     HViewSEIso, 
00113     HViewSWIso, 
00114     HViewNEIso, 
00115     HViewNWIso, 
00116 
00117     HViewFront,
00118     HViewBack,
00119     HViewRight,
00120     HViewLeft,
00121     HViewTop,
00122     HViewBottom,
00123 
00124     HViewUnknown  
00125 };
00126 
00127 
00131 enum LightingIntMode 
00132 {
00133     LightingIntUnknown,  
00134     LightingIntGouraud,  
00135     LightingIntPhong     
00136 };
00137 
00138 
00147 enum FramerateMode 
00148 {
00149     FramerateOff,  
00150     FramerateFixed,  
00151     FramerateTarget     
00152 };
00159 enum ProjMode 
00160 {
00161     ProjUnknown,       
00162     ProjPerspective,   
00163     ProjOrthographic,  
00164     ProjStretched      
00165 };
00166 
00167  
00168 
00172 enum HandednessMode 
00173 {
00174     HandednessLeft,   
00175     HandednessRight,  
00176     HandednessNone    
00177 };
00178 
00179 
00183 enum DisplayListType
00184 {
00185     DisplayListOff,         
00186     DisplayListGeometry,    
00187     DisplayListSegment      
00188 };
00189 
00193 enum MultiThreadingType
00194 {
00195     MultiThreadingOff,
00196     MultiThreadingBasic,
00197     MultiThreadingFull
00198 };
00199 
00203 enum HLRMode
00204 {
00205     AnalyticHiddenLine,     
00206     FastHiddenLine,         
00207     FakeHiddenLine          
00208 };
00209 
00210 
00212 enum AxisMode 
00213 {
00214     AxisOff,    
00215     AxisSimple, 
00216     AxisCenter, 
00217     AxisOn      
00218 };
00219 
00221 enum UpDirection
00222 {
00223     UpDirectionX = 0xFADE,
00224     UpDirectionY,
00225     UpDirectionZ
00226 };
00227 
00228 
00232 enum ViewUpdateMode
00233 {
00234     OnDemand,    
00235     Continuous,   
00236     Deferred    
00237 };
00238 
00239 
00241 enum HShadowRenderingMode 
00242 {
00243     SoftwareShadow,             
00244     HardwareShadow,         
00245     SoftwareOpenglShadow        
00246 };
00247 
00249 enum HBloomShape
00250 {
00251     RadialBloom,            
00252     StarBloom               
00253 };
00254 
00256 enum HQuickMovesMethod
00257 {
00258     HQuickMoves_None,       
00259     HQuickMoves_XOR,        
00260     HQuickMoves_Overlay,    
00261     HQuickMoves_Spriting    
00262 };
00263 
00264 
00271 enum HViewSelectionLevel
00272 {
00273     HSelectionLevelEntity,      
00274     HSelectionLevelSegment,     
00275     HSelectionLevelSegmentTree  
00276 };
00282 enum SplatSymbol
00283 {
00284     SplatRound,         
00285     SplatSquare         
00286 };
00287 
00288 
00289 
00296 typedef void(*HBaseViewEmitMessageFunction)(const char* message, unsigned int length, void * user_data);
00297 
00298 
00300 
00332 class MVO_API HBaseView : public HUpdateListener , public HMouseListener, public HObjectManipulationListener
00333 {
00334 
00335 public:
00336 
00337     
00367     HBaseView(HBaseModel *model,
00368         const char * alias = 0, 
00369         const char * driver_type = 0,
00370         const char * instance_name = 0,
00371         void * window_handle = 0,
00372         void * colormap = 0,
00373         void * clip_override = 0,
00374         void * window_handle_2 = 0,
00375         const char * driver_path = 0);
00376 
00404     void RebindView(
00405         const char * alias = 0, 
00406         const char * driver_type = 0,
00407         const char * instance_name = 0,
00408         void * window_handle = 0,
00409         void * colormap = 0,
00410         void * clip_override = 0,
00411         void * window_handle_2 = 0, 
00412         int debug_flags = 0
00413         );
00414 
00419     virtual ~HBaseView();
00420 
00425     virtual void Init();
00426 
00432     virtual void FitWorld(HPoint * center_out = 0);
00433 
00441     virtual void FitWorldExact(HPoint * center_out = 0);
00442     
00447     virtual void ZoomToExtents();
00448 
00452     virtual void ZoomToInitialCamera();
00453 
00454 
00459     void FitSegment(HC_KEY seg_key);
00460 
00465     void FitSelection(HC_KEY key = INVALID_KEY, bool adjustToShellNormal = false);
00466 
00470     void FitItemByPath(HC_KEY key, int incl_count, HC_KEY * incl_path); 
00471     
00473     void RenderAntialiasing(); 
00474 
00476     void InitAntialiasing();   
00477     
00479     HUtilityAntialiasing * GetAntialiasing() { return m_pAntialiasing; }
00480 
00482     HMarkupManager * GetMarkupManager();
00483 
00485     bool HaveMarkupManager() {return (m_pMarkupManager != 0);}
00486 
00490     void    SetMarkupManager( HMarkupManager* markup ) { m_pMarkupManager = markup; }
00491 
00493     void RenderWireframe(); 
00494 
00497     void RenderSilhouette();    
00498 
00500     void RenderHiddenLine(); 
00501 
00503     void RenderHiddenLineFast();  
00504 
00506     void RenderFlat();  
00507 
00509     void RenderGooch();
00510 
00512     void RenderGouraud();    
00513 
00515     void RenderPhong();     
00516 
00518     void RenderWireframeWithSilhouette();
00519 
00521     void RenderShadedWireframe(); 
00522 
00524     void RenderVertices();        
00525 
00527     void RenderShadedVertices();  
00528 
00532     void RenderFakeHiddenLine();
00533 
00536     void RenderBRepHiddenLine();  
00537 
00540     void RenderBRepHiddenLineFast();  
00541     
00543     void RenderBRepWireframe();   
00544  
00549     void RenderShaded();
00550 
00552     void RenderShadedWithLines();          
00553 
00555     void RenderGouraudWithLines();          
00556 
00558     void RenderLOD1();          
00560     void RenderLOD2();          
00561 
00562     
00564     void RemoveTransforms(); 
00565 
00572     virtual void Update();
00573 
00579     virtual void ForceUpdate();
00580 
00592     virtual HFileInputResult FileInput(const __wchar_t * FileName, HInputHandler * handler, HInputHandlerOptions * options = 0);
00593     
00605     virtual HFileInputResult FileInput(const char * FileName, HInputHandler * handler, HInputHandlerOptions * options = 0){
00606         return FileInput((__wchar_t*)H_WCS(FileName).encodedText(), handler, options);
00607     }
00608 
00620 #ifdef H_USHORT_OVERLOAD
00621     virtual HFileInputResult FileInput(const unsigned short * FileName, HInputHandler * handler, HInputHandlerOptions * options = 0){
00622         H_UTF16 utf16;
00623         utf16.encodedText((utf16_char*)FileName);
00624         return FileInput((__wchar_t*)H_WCS(utf16).encodedText(), handler, options);
00625     }
00626 #endif
00627 
00653     virtual HFileOutputResult FileOutput(const __wchar_t * FileName, HOutputHandler * handler, HOutputHandlerOptions * options = 0);
00654     
00680     virtual HFileOutputResult FileOutput(const char * FileName, HOutputHandler * handler, HOutputHandlerOptions * options = 0){
00681         return FileOutput((__wchar_t*)H_WCS(FileName).encodedText(), handler, options);
00682     }
00683 
00684     // accessors
00685 
00687     const char*     GetDriverPath() { return m_sDriverPath; }
00688 
00690     const char*     GetDriverType() { return m_sDriverType; }
00691 
00693     virtual void UpdateHighlighting();
00694 
00696     HSelectionSet*  GetSelection() { return m_pSelection; }
00697     
00701     void            SetSelection(HSelectionSet* selection) { m_pSelection = selection; }
00702 
00704     virtual HBaseModel * GetModel() { return m_pModel; }
00705 
00708     HC_KEY          GetModelKey();
00709 
00711     HRenderMode     GetRenderMode () { return m_RenderMode; }
00712 
00714     ViewMode        GetViewMode () { return m_ViewMode; }
00715 
00722     virtual void    SetViewMode (ViewMode mode, bool invert = false, bool fitWorld = true);
00723 
00725     bool            GetCPLineVisibility() {return m_bCPLineVisibility; }
00726 
00728     bool            GetCPFaceVisibility() {return m_bCPFaceVisibility; }
00729 
00737     void            SetCPGeomVisibility(bool lines, bool faces=false);
00738 
00739 
00745     bool            GetCuttingPlanesExist(const char *plane = 0);
00746  
00750     void            SetCuttingPlanesExist(bool state);
00751 
00753     bool            GetCuttingPlanesVisibility() {return m_bCuttingPlanesVisibility; }
00754 
00758     void            SetCuttingPlanesVisibility(bool visible);
00759 
00761     HConstantFrameRate* GetConstantFrameRateObject() { return m_pConstantFrameRate; }
00762 
00766     void            SetConstantFrameRateObject(HConstantFrameRate* cf) { m_pConstantFrameRate = cf; }
00767 
00769     void            SetEventCheckerCallback(void (* EventChecker)(HIC_Rendition const *nr));
00770  
00772     void SetKeyStateCallback(bool (* KeyState)(unsigned int, int &)) { m_pfKeyState = KeyState; }   
00773 
00775     bool  (*GetKeyStateCallback())(unsigned int, int &) { return m_pfKeyState; }
00776 
00778     void  (*GetEventCheckerCallback())(HIC_Rendition const *nr) { return m_pfEventChecker; }
00779 
00780 
00788     void            SetOcclusionCullingMode(bool mode,  bool UseOctree = true, int threshold = 50);
00789 
00790  
00793     HandednessMode  GetHandedness();
00794 
00806     virtual void SetHandedness(HandednessMode mode, bool emit_message=false);
00807 
00812     virtual void SetHandednessFromMessage(const char *in_data, unsigned int data_length);
00813 
00820     virtual void SetFontSize(const char *font_size, bool emit_message=false);
00821 
00826     virtual void SetFontSizeFromMessage(const char *in_data, unsigned int data_length);
00827     
00829     bool            GetBackplaneCulling(); 
00830     
00837     void            SetBackplaneCulling(bool cull); 
00838 
00842     ProjMode        GetProjMode(); 
00843     
00847     void            SetProjMode(ProjMode mode); 
00848 
00850     DisplayListType GetDisplayListType(); 
00851 
00855     void            SetDisplayListType(DisplayListType type); 
00856 
00858     bool            GetDisplayListMode(); 
00859 
00863     void            SetDisplayListMode(bool mode); 
00864 
00866     HandednessMode  GetPolygonHandednessMode(); 
00867 
00879     void            SetPolygonHandednessMode(HandednessMode); 
00880     
00883     bool            GetLodMode(); 
00884 
00891     void            SetLodMode(bool onoff);
00892     
00894     bool            GetSpritingMode() { return m_bSpritingAllowed; } 
00895 
00901     void            SetSpritingMode(bool onoff) { m_bSpritingAllowed = onoff; } 
00902 
00906     int             GetLodThreshold(); 
00907 
00912     void            SetLodThreshold(int val);
00913 
00915     HC_KEY          GetViewKey() { return m_ViewKey; }  
00917     void            SetViewKey( HC_KEY view_key ) { m_ViewKey = view_key; }    
00918 
00920     HC_KEY          GetIncludeLinkKey() { return m_lIncludeLinkKey; }   
00922     void            SetIncludeLinkKey( HC_KEY link ) { m_lIncludeLinkKey = link; }    
00923 
00925     HC_KEY          GetSceneKey() { return m_SceneKey; }    
00926     
00930     void            SetSceneKey( HC_KEY scene_key ) { m_SceneKey = scene_key; } 
00931 
00933     HC_KEY          GetOverwriteKey() { return m_OverwriteKey; }    
00934  
00936     HC_KEY          GetShadowMapSegmentKey() { return HC_KShow_Owner_By_Key (m_lIncludeLinkKey); }
00937                     
00939     HC_KEY          GetLightsKey() { return m_LightsKey; }   
00940 
00944     void            SetLightsKey( HC_KEY lights_key ) { m_LightsKey = lights_key; }   
00945 
00947     float           GetZoomLimit() { return m_fZoomLimit; }   
00948 
00952     void            SetZoomLimit( float zoomLimit ) { m_fZoomLimit = zoomLimit; }   
00953     
00955     void            SetZoomLimit();   
00956 
00958     HC_KEY          GetWindowspaceKey() { return m_WindowspaceKey; }   
00959 
00963     void            SetWindowspaceKey( HC_KEY winspace_key ) { m_WindowspaceKey = winspace_key; }   
00964 
00966     HC_KEY          GetConstructionKey() { return m_ConstructionKey; }   
00967 
00971     void            SetConstructionKey( HC_KEY construct_key ) { m_ConstructionKey = construct_key; }   
00972 
00974     HC_KEY          GetBBoxGeometryKey() { return m_BBoxGeometryKey; }   
00976     void            SetBBoxGeometryKey( HC_KEY bbox_key ) { m_BBoxGeometryKey = bbox_key; }   
00977 
00979     HC_KEY          GetCuttingPlanesKey() { return m_CuttingPlanesKey; }   
00980 
00984     void            SetCuttingPlanesKey( HC_KEY cuttingplanes_key ) { m_CuttingPlanesKey = cuttingplanes_key; }   
00985     
00987     HC_KEY          GetCuttingPlaneGeomKey() { return m_CuttingPlaneGeomKey; }   
00988 
00992     void            SetCuttingPlaneGeomKey( HC_KEY cuttingplanegeom_key ) { m_CuttingPlaneGeomKey = cuttingplanegeom_key; }   
00994     HC_KEY          GetIntersectPolylinesKey() { return m_IntersectPolylinesKey; }   
00995 
00999     void            SetIntersectPolylinesKey( HC_KEY intersectpolylines_key ) { m_IntersectPolylinesKey = intersectpolylines_key; }   
01000     
01002     HC_KEY          GetProgressBarKey() { return m_ProgressBarKey; }    
01007     void            SetProgressBarKey( HC_KEY key ) { m_ProgressBarKey = key; } 
01008 
01009     
01011     int             GetUpdateInterrupted() { return m_UpdateInterrupted; }  
01012 
01016     void            SetUpdateInterrupted( int val ) { m_UpdateInterrupted = val; } 
01017 
01019     float           GetIdleTime(); 
01020 
01022     void            ResetIdleTime(); 
01023     
01026     HQuickMovesMethod GetQuickMovesMethod () const;  
01027 
01029     class HDebugZBuffer *GetDebugZBuffer() { return m_pDebugZBuffer; } 
01030 
01033     void SetDebugZBuffer(HDebugZBuffer *dzb) { m_pDebugZBuffer = dzb; }; 
01034     
01036     AxisMode        GetAxisMode() {return m_bAxisMode; }   
01037     
01042     virtual void            SetAxisMode(AxisMode mode);
01043 
01047     virtual void            OnSetAxisMode( AxisMode mode );
01048     
01050     void            UpdateAxisTriad() { SetAxisMode(GetAxisMode()); }
01051     
01057     virtual void            AdjustAxisWindow( int axis_window_pixels_in = -1, HIntRectangle *rect_in=0 );
01058     
01060     static  void            AdjustAxisWindowCallback(int signal, void * signal_data, void * user_data);
01061 
01063     static  void            AdjustWindowCallback(int signal, void * signal_data, void * user_data);
01064 
01066     HShadowMode GetShadowMode() {return m_ShadowMode; }   
01067 
01072     virtual void SetShadowMode (HShadowMode sm, bool saveMode = true);  
01073 
01085     virtual void SetReflectionPlane(bool state, float opacity=0.5f, bool fading=true, bool attenuate=false,
01086             float hither=0.0f, float yon=1.0f, bool blur=false, int blur_level=1);
01087 
01089     HC_KEY          GetDefaultLightKey(int which = 0) { return m_SceneLight[which]; }   
01090 
01091  
01093     bool            GetTransparentSelectionBoxMode() {return m_bTransparentSelectionBox; }   
01094     
01098     void            SetTransparentSelectionBoxMode(bool mode) { m_bTransparentSelectionBox = mode; }
01099 
01105     virtual void    DeleteSelectionList(bool emit_message=false);
01106 
01113     void            RotateOnUpdate(const char *sname);
01114 
01122     virtual void SetWindowColor(HPoint rgb, bool emit_message=false);
01123     
01134     virtual void SetWindowColor(HPoint rgbtop, HPoint rgbbottom, bool emit_message=false); 
01135 
01147     virtual void SetWindowColorRange(HPoint rgbtop, HPoint rgbbottom, int percentage, bool emit_message=false); 
01148 
01149 
01157     virtual void SetWindowMaterial(const char * name, bool emit_message=false);
01158 
01164     virtual void SetWindowColorFromMessage(const char *in_data, unsigned int data_length);
01165 
01169     void GetWindowColor(HPoint &color_out);
01170     
01175     void GetWindowColor(HPoint &color_top, HPoint &color_bottom);
01176     
01182     void GetWindowColor(HPoint &color_top, HPoint &color_bottom, int &percentage);
01183 
01188     void GetWindowMaterial(char * out_material, char * out_pattern);
01189 
01193     void            SetOperator(HBaseOperator *NewOperator);
01194 
01195 
01197     void            SetCurrentOperator(HBaseOperator *NewOperator) { SetOperator(NewOperator); }
01198 
01202     HBaseOperator*  GetOperator() { return m_pOperator; }
01203 
01208     HBaseOperator*  GetCurrentOperator() { return m_pOperator; }    
01209 
01210 
01212     HC_KEY  GetAxisTriadKey() {return m_AxisTriadKey;}  
01213 
01215     bool    GetHideOverlappedText(){ return m_bHideOverlappedText;}  
01216 
01220     void    SetHideOverlappedText(bool hide);  
01221 
01225     void    SetNavCube(bool onoff) { m_bNavCube = onoff;}   
01226 
01228     bool    GetSmoothTransition() { return m_bSmoothTransition;}    
01229 
01233     void    SetSmoothTransition(bool onoff) { m_bSmoothTransition = onoff;} 
01234 
01238     void    SetSmoothTransitionDuration(float duration) { m_SmoothTransitionDuration = duration;} 
01239     
01241     float   GetSmoothTransitionDuration() { return m_SmoothTransitionDuration;} 
01242 
01244     bool    IsLightFollowCamera(){return m_bLightFollowsCamera;}  
01245 
01249     void    SetLightFollowsCamera(bool onoroff);    
01250 
01251     static const int MaxLights = 6;
01252 
01256     void    SetLightCount(int count);
01257 
01261     int GetLightCount() { return m_LightCount; }
01262     
01271     virtual void CameraPositionChanged(bool emit_message=false, bool smooth_camera_transition=false);
01272 
01273 
01277     virtual void PrepareForCameraChange();
01278 
01279 
01289     virtual void SetCamera(HPoint pos, HPoint tar, HPoint up, float fieldx, float fieldy, const char *proj);
01290 
01300     virtual void SetInitialCamera(HPoint pos, HPoint tar, HPoint up, float fieldx, float fieldy, char const * proj);
01301 
01302 
01312     virtual void GetCamera(HPoint *pos, HPoint *tar, HPoint *up, float &fieldx, float &fieldy, char *proj);
01313 
01318     virtual void SetCamera(HCamera camera);
01319 
01324     virtual void GetCamera(HCamera *camera);
01325 
01331     virtual void SetCameraFromMessage(const char *data, unsigned int data_length);
01332 
01340     virtual void InsertHSFData(const char *segment, const char *in_data, unsigned int data_length, bool emit_message=false);
01341 
01347     virtual void InsertHSFDataFromMessage(const char *in_data, unsigned int data_length);
01348 
01355     virtual void EmitHSFData(const char *segment, const char *in_data, unsigned int data_length);
01356 
01362     virtual void SetRenderMode (HRenderMode NewRenderMode, bool emit_message=false);
01363 
01369     virtual void SetRenderModeFromMessage(const char *in_data, unsigned int data_length);
01370 
01374     virtual void EmitFlushMessage();
01375 
01383     virtual void FlushFromMessage(const char *in_data, unsigned int data_length);
01384 
01385 
01391     virtual void Flush(bool emit_message=false);
01392 
01399     void SetEmitMessageFunction(
01400         HBaseViewEmitMessageFunction new_emit_message_function,
01401         void * user_data=0) {
01402         emit_message_function=new_emit_message_function;
01403         emit_message_function_user_data=user_data;};
01404 
01409     bool EmittingMessages() {return emit_message_function != 0;};
01410     
01414     HBaseViewEmitMessageFunction GetEmitMessageFunction() {return emit_message_function;};
01415 
01419     void * GetEmitMessageFunctionUserData() {return emit_message_function_user_data;};
01420 
01426     virtual void EmitSelectMessage(HC_KEY key, bool isSelect);
01427 
01433     virtual void SelectFromMessage(const char *in_data, unsigned int data_length);
01434 
01438     virtual void EmitDeSelectAllMessage();
01439 
01440 
01444     virtual void EmitDeleteSelectionListMessage();
01445 
01446 
01450     virtual void DeleteSelectionListFromMessage();
01451 
01452 
01456     virtual void DeSelectAllFromMessage();
01457 
01458 
01463     virtual void EmitSetModellingMatrixMessage(HC_KEY key);
01464 
01465 
01470     virtual void EmitSetModellingMatrixMessage();
01471 
01479     virtual void EmitSegment(HC_KEY key, bool emit_contents_only = false);
01480 
01485     virtual void EmitDeleteByKeyMessage(HC_KEY key);
01486 
01492     virtual void DeleteByKeyFromMessage(const char *in_data, unsigned int data_length);
01493 
01499     virtual void SetModellingMatrixFromMessage(const char *in_data, unsigned int data_length);
01500  
01504     HSharedKey * GetSharedKey() {return m_pSharedKey;};
01505 
01506 
01510     virtual void StartSharedKey();
01511 
01512 
01514     enum HAnimateMode {
01515         HAnimateScene    =          0x00000001 
01516     };
01517 
01518 
01526     virtual void Animate (int animation_steps = 30, HAnimateMode animate_flags = HAnimateScene, int MaxRotation = 360);
01527     
01530     virtual void SetGeometryChanged();
01531 
01535     bool GetSceneBoundingSet() { return m_bSceneBoundingSet; }
01536     
01541     void SetSceneBounding(HPoint &min, HPoint &max);
01542 
01544     void InvalidateSceneBounding() { m_bSceneBoundingSet = false; }
01545 
01549     void SetFastMarkerDrawing(bool b_fast);
01550 
01554     bool GetFastMarkerDrawing();
01555     
01561     void SetDoubleBuffering(bool double_buffer);
01562     
01564     virtual void ClearGeometryChanged() {m_bGeometryChanged = false; };
01565 
01567     virtual bool GeometryChanged() {return m_bGeometryChanged;};
01568     
01574     unsigned long SetSignalNotify( int signal, HSignalNotifyFunction callback, void *user_data ); 
01575     
01578     void UnSetSignalNotify( unsigned long cookie );                                         
01579 
01584     void SetColorInterpolation(bool onoff);
01585 
01591     void SetColorIndexInterpolation(bool onoff, bool isolines = false);
01592 
01598     bool GetColorIndexInterpolation(char * option = 0);
01599 
01608     bool GetFrameBufferEffectsOptions(char * options = 0, int *border = 0);
01609 
01615     void Notify(int signal, void * signal_data = 0);
01616 
01623     int UpdateEvent(bool antialias = false, bool forceUpdate = false);  
01627     bool    GetUpdateRequested() { return m_bUpdateRequested; }
01631     void    RequestUpdate() { m_bUpdateRequested = true; }
01635     void    ClearUpdateRequest() { m_bUpdateRequested = false; }
01636 
01642     void    SetSuppressUpdate(bool suppress) {
01643         suppress?m_SuppressUpdate++:m_SuppressUpdate--;
01644         if (m_SuppressUpdate<0)
01645             m_SuppressUpdate = 0;
01646     }
01647 
01652     bool    GetSuppressUpdate() { return m_SuppressUpdate > 0; }
01653 
01659     void    SetSuppressUpdateTick(bool suppress) { 
01660         suppress?m_SuppressUpdateTick++:m_SuppressUpdateTick--;
01661         if (m_SuppressUpdateTick<0)
01662             m_SuppressUpdateTick = 0;
01663     }
01664 
01669     bool    GetSuppressUpdateTick() { return m_SuppressUpdateTick > 0; }
01670 
01686     void    SetViewUpdateMode(ViewUpdateMode mode, float rate = 0.01f);
01687 
01691     ViewUpdateMode  GetViewUpdateMode() { return m_ViewUpdateMode; }
01692 
01700     static bool UpdateTick(float request_time, float actual_time, void * user_data);
01701 
01709     static bool StreamProgressCallback(unsigned long so_far, unsigned long expected, void * user_data);
01710 
01712     void FlushProgressBar();
01713 
01715     HUndoManager *GetUndoManager();
01716 
01718     HEventManager *GetEventManager();
01719 
01721     HObjectManager *GetHObjectManager();
01722 
01724     bool    GetDynamicHighlighting() { return m_bDynamicHighlighting; }
01725 
01729     void    SetDynamicHighlighting(bool state);
01730 
01736     virtual int OnNoButtonDownAndMove(HEventInfo &hevent);
01737 
01742     virtual int OnLButtonDownAndMove(HEventInfo &hevent);
01743 
01749     virtual int OnLButtonDblClk(HEventInfo &hevent);
01750 
01755     virtual int OnRButtonDownAndMove(HEventInfo &hevent);
01760     virtual int OnMButtonDownAndMove(HEventInfo &hevent);
01765     virtual int OnLRButtonDownAndMove(HEventInfo &hevent);
01766 
01771     virtual int OnLButtonDown(HEventInfo &hevent);  
01772 
01777     virtual int OnMouseMove(HEventInfo &hevent);
01778 
01784     virtual int OnLButtonUp(HEventInfo &hevent);
01785 
01786 #if 0
01787 
01791     virtual int OnMouseWheel(HEventInfo &hevent);
01792 #else
01793 
01797     virtual int OnMouseWheel(HEventInfo &hevent);
01798     
01801     virtual bool ComputeReasonableTarget(HPoint & new_tar, HPoint const & mouse_win, HPoint const & tar_orig);
01802 
01803     /* This method adjusts the old field to the new target so the picture on the screen won't change. */
01804     void ComputeNewField(float & width, float & height, HPoint const & new_tar,
01805                                  HCamera const & old_camera);
01806 #endif
01807 
01809     virtual int OnKeyDown(HEventInfo &hevent);
01810 
01812     virtual int OnKeyUp(HEventInfo &hevent);
01813 
01816     virtual void SetShadowColor(HPoint color);
01817 
01822     virtual void SetShadowLightDirection(bool explicit_light, HPoint const * direction = 0);
01823 
01828     virtual bool GetShadowLightDirection(HPoint * direction = 0);
01829 
01833     virtual void SetShadowIgnoresTransparency(bool ignore);
01834 
01838     virtual bool GetShadowIgnoresTransparency();
01839 
01842     virtual void DoDynamicHighlighting(HPoint mouse_pos);
01843 
01846     virtual void SetShadowResolution(int res);
01847 
01850     virtual void SetShadowBlurring(int blur);
01851 
01853     virtual void InternalUpdate();
01854 
01858     virtual void SetShadowRegenerationMode(bool onoff) { m_bShadowRegeneration = onoff; }
01859 
01862     virtual void SetShadowRegenerationToggle() { m_bShadowRegenerationToggle  = true; m_bShadowRegeneration = false; }
01863 
01866     bool GetCuttingPlaneRegenerationMode() { return m_bCuttingPlaneRegeneration; }
01867  
01872     virtual void SetCuttingPlaneRegenerationMode(bool onoff) { m_bCuttingPlaneRegeneration = onoff; }
01873 
01877     bool GetShadowRegenerationMode() { return m_bShadowRegeneration; }
01878 
01882     virtual void SetCameraChanged( bool val=true ) { m_bCameraChanged = val; if(val) ResetIdleTime(); }
01883     
01885     virtual bool GetCameraChanged() { return m_bCameraChanged; }
01886 
01890     virtual void SetInvertMouseWheelZoom( bool val=true ) { m_bInvertMouseWheelZoom = val;}
01891 
01893     virtual bool GetInvertMouseWheelZoom() { return m_bInvertMouseWheelZoom; }
01894 
01895 
01899     virtual void SetAxisManipulateOperator(HOpCameraManipulate *op);
01900 
01905     virtual void SetVisibilitySelectionMode(bool onoff);
01906  
01908     virtual bool GetVisibilitySelectionMode();
01909 
01912     virtual void SetRelatedSelectionLimit(int limit);
01913  
01915     virtual int GetRelatedSelectionLimit();
01916 
01921     virtual void SetDetailSelection(bool onoff);
01922 
01924     virtual bool GetDetailSelectionMode();
01925 
01933     virtual void SmartFilterCircumcuboid(const char *segment, const char *defaults, HPoint *bottomfrontleft, HPoint *topbackright);
01934     
01941     int SetupHandlesEvent(HBaseView *view, HC_KEY key, bool complex);
01942 
01944     virtual bool GetHasObjects() { return m_bHasObjects; }
01945     
01949     virtual void SetHasObjects(bool hasobjects);
01950     
01951     
01955     virtual void SetHandleOperator(HBaseOperator *op) { m_pHandleOperator = op; }
01956 
01960     virtual HBaseOperator *GetHandleOperator() { return m_pHandleOperator; }    
01961 
01965     virtual float GetDefaultSelectionProximity() { return m_DefaultSelectionProximity; }
01969     virtual void SetDefaultSelectionProximity(float selectionproximity);
01970     
01973     bool GetAllowInteractiveShadows(){
01974         return m_bAllowInteractiveShadows;
01975     }
01976 
01982     void SetAllowInteractiveShadows(bool onoff) {
01983         m_bAllowInteractiveShadows = onoff;
01984     }
01985 
01988     HShadowRenderingMode GetShadowRenderingMode();
01989 
01994     void SetShadowRenderingMode(HShadowRenderingMode mode);
01995 
01998     bool GetAllowInteractiveCutGeometry() { return m_bAllowInteractiveCutGeometry; }
01999 
02004     void SetAllowInteractiveCutGeometry(bool onoff){
02005         m_bAllowInteractiveCutGeometry = onoff;
02006     }
02007 
02010     HCutGeometryVisibility GetCutGeometryVisibility();
02011 
02015     void SetCutGeometryVisibility(HCutGeometryVisibility visibility);
02016     
02017 
02020     void *          GetWindowHandle() { return m_pWindowHandle; }
02021 
02025     bool            GetInitialCameraSet() { return m_bInitialCameraSet; }
02026     
02027 
02028 
02035     int ObjectMovedEvent(HBaseView *view, HC_KEY key, HPoint *pos);
02036 
02040     void SetRecordCamera(bool rc);
02041 
02043     bool GetRecordMode() { return m_bRecordCamera; }
02044     
02048     void InjectEvent(HEventInfo const & hevent);
02049 
02050 
02055     void SetForceFastHiddenLine(bool force) { m_bForceFastHiddenLine = force; }
02056 
02058     bool    GetForceFastHiddenLine() { return m_bForceFastHiddenLine; }
02059 
02065     void SetTransparency(char const * text, bool fast_z_sort=false);
02066 
02071     void SetLineAntialiasing( bool onoff );
02072 
02074     bool GetLineAntialiasing() { return m_bLineAntialiasing; }
02075 
02079     void SetTextAntialiasing( bool onoff );
02080 
02085     void SetDepthOfField(bool onoff, float strength = 1.0f);
02086 
02091     void SetDepthOfFieldRange(float near=0.0f, float far=0.0f);
02092 
02094     bool GetTextAntialiasing() { return m_bTextAntialiasing; }
02095 
02099     void SetIsoDefault(ViewMode vm) { m_IsoDefault = vm; }\
02100     
02102     ViewMode GetIsoDefault() { return m_IsoDefault; }
02103 
02110     void SetCullingThreshold(int cullingthreshold);
02111 
02115     int GetCullingThreshold();
02116 
02123     void SetHardExtent(int cutoff);
02124 
02128     int GetHardExtent();
02129 
02134     void BeginShellSelection();
02135     
02138     void EndShellSelection();
02139 
02141     HSelectionSet * GetHighlightSelection() { return m_pHighlight; }
02142 
02149     void SetViewAxis(HVector *front_axis, HVector *top_axis) { m_FrontAxis = front_axis; m_TopAxis = top_axis; }
02154     void GetViewAxis(HVector *front_axis, HVector *top_axis) { *front_axis = m_FrontAxis; *top_axis = m_TopAxis; }
02155     
02159     void SetDefaultHSRA();
02160 
02161 
02165     void SetMaximumUpdateTime(float mut) { m_MaximumUpdateTime = mut; }
02166     
02170     float GetMaximumUpdateTime() { return m_MaximumUpdateTime; }
02171 
02175     virtual const HSelectionHighlightMode GetHighlightMode() { return m_HighlightMode; }
02176 
02181     virtual void SetHighlightMode(HSelectionHighlightMode m);
02182 
02186     virtual void SetReferenceSelection(bool use_ref);
02187     
02194     bool GetKeyState(unsigned int key, int &flags);
02195 
02197     void ResetKeyState();
02198 
02202     void SetFastFitWorld(bool fw) { m_bFastFitWorld = fw;    }
02203 
02209     void GetSceneExtents(HPoint &min, HPoint &max); 
02210 
02214     void SetLightScaling(float sv);
02215 
02216     void SetXYSizeOverride(int x,int y) { m_XSize_override = x, m_YSize_override = y; }
02217 
02218 
02220     int GetXSize() {return m_XSize;}
02221 
02223     int GetYSize() {return m_YSize;}
02224 
02226     HViewSelectionLevel GetViewSelectionLevel();
02227 
02236     void  SetViewSelectionLevel(HViewSelectionLevel level);
02237 
02246     void EnableTargetFrameRate(bool enable=true, int target=100, int threshold=10, int steps=5);
02247 
02252     float GetFramerate();
02253 
02255     FramerateMode GetFramerateMode();
02256 
02258     int GetFramerateCullingThreshold();
02259 
02264     int GetFramerateSteps();
02265 
02267     bool IsFramerateLodEnabled();
02268 
02282     void SetFramerateMode(FramerateMode mode, float framerate = 0.1f, int cullingthreshold = 150, 
02283         bool enableLods = false, int steps = 20, int cutoff = 1);
02284  
02286     bool IsFrameRateEnabled();
02287     
02289     bool GetViewActive();
02290 
02292     void cleanupSimpList();
02293 
02297     void SetAnnotationResize(bool value);
02298 
02300     bool GetAnnotationResize() { return m_AnnotationCookie==0?false:true; }
02301 
02303     bool GetFirstUpdate() { return m_bFirstUpdate; }
02304 
02306     void SetDisplayHandlesOnDblClk(bool dh) { m_bDisplayHandlesOnDblClk = dh; } 
02307 
02309     bool HasInitialView()   { return m_has_initial_view; }
02310 
02312     void HasInitialView(bool does_it)   { m_has_initial_view=does_it; }
02313 
02315     void ExhaustiveUpdate();
02316 
02318     bool GetUpdateNotFinished() { return m_bUpdateNotFinished; }
02319 
02321     void SetUpdateNotFinished(bool NotFinished) { m_bUpdateNotFinished  = NotFinished; }
02322 
02323     /* This method sets the mousewheel sensitivity which is used to control the apparent sensitivity of the mousewheel for MVO operators.
02324        \param sensitivity value is strictly positive float. */
02325     void SetMouseWheelSensitivity(float sensitivity) {
02326         if (sensitivity > 0)
02327             m_MouseWheelSensitivity = sensitivity;
02328     }
02329     /* Use this in an operator to modify the return value of HEventInfo::GetMouseWheelDelta()
02330        \return value of the operator mousewheel sensitivity, a strictly positive value. */
02331     float GetMouseWheelSensitivity() { return m_MouseWheelSensitivity; }
02332 
02334     void SetSplatRendering(bool onoff);
02335 
02337     bool GetSplatRendering() { return m_bSplatRendering; };
02338 
02340     void SetSplatSize(int splat_size);
02341 
02343     int GetSplatSize() { return m_SplatSize; };
02344 
02346     void SetSplatSymbol(SplatSymbol symbol);
02347 
02349     SplatSymbol GetSplatSymbol() {return m_SplatSymbol;};
02350     
02351     
02355     void UpdateFakeHLRColor(HPoint paper_color);
02356 
02358     void SetHardwareAntialiasing(int antialiasinglevel) { m_HardwareAntialiasing = antialiasinglevel; }
02359 
02361     int GetHardwareAntialiasing() { return m_HardwareAntialiasing; }
02362 
02366     static void StaticForceUpdateRequest(void * view_pointer);
02367 
02368     /*
02369         This method can be used to visualize the internal bounding stored on segments 
02370         and some types of geometry.   The bounding is drawn outside of the model so it does not
02371         interfere with static trees.  It is semi-transparent with a color that indicates the 
02372         bounding density: blue is very dense, red is sparse, green is somewhere in between.
02373         \param draw_something If this value is false, any existing bounding geometry will simply 
02374             be discarded.  If it is true, a new bounding geometry will also be generated.
02375         \param key The key of the segment or geometry whose bounding should be visualized.
02376         \param incl_count The number of keys in the incl_path array.
02377         \param incl_path This array of keys should be structured for a PShow.  That is, the leaf 
02378             as the first entry followed by a series of include keys mapping a path to the view.
02379     */
02380     void VisualizeBounding(bool draw_something, HC_KEY key=INVALID_KEY, int incl_count=0, HC_KEY * incl_path=0);
02381 
02382     
02383     /*
02384         Retrieves the color set by an earlier call to SetFakeHLRColor.
02385         \return the color as an rgb triplet with values from 0.0 to 1.0.
02386     */
02387     HPoint GetFakeHLRColor();
02388     
02389     /*
02390         Sets the color to be used in fake hidden-line render mode.
02391         \param color An rgb triplet with values from 0.0 to 1.0.
02392     */
02393     void SetFakeHLRColor(HPoint color);
02394 
02395     /*
02396         Orients the camera to point at selected geometry and sets depth-of-field to keep it in focus.
02397         \param onoff passing true will focus on the selected geometry, passing false will remove an earlier depth-of-field setting.
02398     */
02399     void FocusOnSelection(bool onoff = true);
02400 
02401     /*
02402         \return true if the view is currently focused on a selection via a previous call to FocusOnSelection(), false otherwise.
02403     */
02404     bool GetFocusOnSelection() { return m_FocusedOnSelection; }
02405     
02407     HTouchManager *GetTouchManager() { return m_TouchManager; }
02408 
02409 protected:
02410     HC_KEY          m_FakeHLRStyle;             
02411     HC_KEY          m_FakeHLRSource;            
02412     bool            m_bCPLineVisibility;        
02413     bool            m_bCPFaceVisibility;        
02414     int             m_CPMode;                   
02415     bool            m_bCuttingPlanesExist;      
02416     bool            m_bCuttingPlanesVisibility; 
02417     bool            m_bSpritingAllowed;         
02418     bool            m_bAxisTriadTransparencyAllowed; 
02419     int             m_AxisWindowSize;           
02421     bool            m_bForceFastHiddenLine;     
02422     bool            m_bLineAntialiasing;        
02423     bool            m_bTextAntialiasing;        
02424     bool            m_bBeginShellSelection;     
02425     bool            m_bDisplayHandlesOnDblClk;
02426     bool            m_has_initial_view;
02427     
02428     HTouchManager   *m_TouchManager;            
02430     int             m_HardwareAntialiasing;
02431     ViewMode        m_IsoDefault;               
02432     HSelectionHighlightMode m_HighlightMode;        
02433     DisplayListType m_DisplayListType;          
02437     bool            m_bGeometryChanged;
02438     HPoint          m_SceneBoundingMin;
02439     HPoint          m_SceneBoundingMax;
02440     bool            m_bSceneBoundingSet;
02441     bool            m_bFastFitWorld;
02442     HImCuttingGeometry * m_pHImCuttingGeometry; 
02443     HUtilityAntialiasing * m_pAntialiasing;     
02444     HMarkupManager * m_pMarkupManager;          
02445     AxisMode        m_bAxisMode;                
02446     bool            m_bHideOverlappedText;      
02447     bool            m_bNavCube;                 
02448     bool            m_bSmoothTransition;        
02449     float           m_SmoothTransitionDuration; 
02450     bool            m_bLightFollowsCamera;      
02451     int             m_WindowColorPercentage;    
02452     HVector         m_FrontAxis;                
02453     HVector         m_TopAxis;                  
02455     HBaseModel*     m_pModel;                   
02456     HC_KEY          m_ViewKey;                  
02458     HC_KEY          m_SceneKey;             
02460     HC_KEY          m_OverwriteKey;             
02462     HC_KEY          m_BBoxGeometryKey;      
02464     HC_KEY          m_WindowspaceKey;       
02466     HC_KEY          m_ConstructionKey;      
02468     HC_KEY          m_CuttingPlanesKey;     
02470     HC_KEY          m_CuttingPlaneGeomKey;  
02472     HC_KEY          m_IntersectPolylinesKey;    
02474     HC_KEY          m_AxisTriadKey; 
02476     HC_KEY          m_ProgressBarKey;   
02477 
02478  
02479     HC_KEY          m_InfoTextKey;  
02480 
02482     HC_KEY          m_lIncludeLinkKey;
02483     HC_KEY          m_LightsKey;            
02484     HC_KEY          m_SceneLight[MaxLights];        
02485     HRenderMode     m_RenderMode;           
02486     ViewMode        m_ViewMode;             
02487     HBaseOperator*  m_pOperator;            
02488     HEventInfo*     m_pEvent;               
02489     HSelectionSet*  m_pSelection;           
02490     HSelectionSet*  m_pHighlight;           
02491     HConstantFrameRate *m_pConstantFrameRate;
02492     HShadowMode     m_ShadowMode;           
02493     HSharedKey *    m_pSharedKey;           
02494     int             m_UpdateInterrupted;   
02495     int             m_InUpdateInternal;   
02496     void            (* m_pfEventChecker)(HIC_Rendition const *nr); 
02497     bool            (* m_pfKeyState)(unsigned int, int &); 
02498     ViewUpdateMode  m_ViewUpdateMode;       
02499     bool            m_bUpdateRequested;     
02500     HEventManager * m_pEventManager;        
02501     HUndoManager *  m_pUndoManager;         
02502     HObjectManager *m_pObjectManager;       
02503     class HDebugZBuffer *m_pDebugZBuffer;   
02504     bool            m_bLButtonDown;         
02505     bool            m_bMouseMove;           
02506     HOpCameraManipulate *m_pManipulateOperator; 
02507     bool            m_bShadowRegeneration;  
02508     bool            m_bShadowRegenerationToggle;    
02509     bool            m_bCuttingPlaneRegeneration; 
02510     bool            m_bCameraChanged;       
02511     float           m_IdleTime;             
02512     bool            m_bFirstUpdate;         
02513     HBaseOperator * m_pHandleOperator;      
02514     bool            m_bAllowInteractiveShadows; 
02515     bool            m_bAllowInteractiveCutGeometry; 
02516     float           m_DefaultSelectionProximity; 
02517     float           m_MaximumUpdateTime;    
02518     HCamera         m_InitialCamera;        
02519     bool            m_bInitialCameraSet;    
02520     bool            m_bRecordCamera;        
02521     bool            m_bTransparentSelectionBox; 
02522     bool            m_bInvertMouseWheelZoom;  
02523     unsigned long   m_AnnotationCookie;
02524     unsigned long   m_AxisResizeCookie;
02525     FramerateMode   m_FramerateMode;
02526     bool            m_bSplatRendering;
02527     int             m_SplatSize;
02528     SplatSymbol     m_SplatSymbol;
02529     bool            m_FocusedOnSelection;
02530     
02537     void ComputeShadowParams(HPlane& shadow_plane, HPoint& light_pos);
02538 
02544     void AdjustShadowPlane(HPlane& shadow_plane, HPoint const & light_pos);
02545 
02551     void SetShadowParams(const HPlane& shadow_plane, const HPoint& light_pos, 
02552                          const HPoint* color = 0, const char * filter = 0);
02553 
02560     virtual void SetShadowParams(HShadow* shadowObj);
02561 
02564     void RefreshViewSize();
02565 
02571     void QueryDeviceCapabilities();
02572 
02581     virtual void UpdateInternal(bool antialias = false, bool force_update = false);
02582 
02583 
02588     virtual void SetupLights();
02589     
02590 private:
02591     float   m_LastRecordTime;   
02593     char * m_sDriverPath;       // fully rooted pathname of driver instance
02594     char * m_sDriverType;       // driver type; e.g. msw, opengl, x11
02595     char * m_sAlias;    
02596     void * m_pWindowHandle;
02597     void * m_pColormap;
02598     void * m_pClipOverride;
02599     void * m_pWindowHandle2;
02600     struct vlist_s *m_SignalRequestsList;   
02601     HBaseViewEmitMessageFunction emit_message_function;
02602     void * emit_message_function_user_data;
02603     HTClient *  m_pUpdateTimerClient;
02604     bool    m_bPrevBackplaneCullMode;   // this caches backplane cull mode (which is switched off when capping planes are turned off with cutting planes on )
02605     bool    m_bHasObjects;
02606     float   m_fZoomLimit;
02607     int     m_SuppressUpdate;
02608     int     m_SuppressUpdateTick;
02609     bool    m_bDynamicHighlighting;
02610     int     m_XSize;
02611     int     m_YSize;
02612     int     m_XSize_override;
02613     int     m_YSize_override;
02614     float   m_LastMouseWheelTime;
02615     float   m_MouseWheelSensitivity;
02616     bool    m_KeyMap[256];
02617     int     m_KeyFlags;
02618     bool    m_bOwnDriver;
02619     bool    m_bUpdateNotFinished;
02620     int     m_NotFinishedCounter;
02621     HPoint  m_FakeHLRColor;
02622     HConstFRSimpType            **SimpList;
02623     int                         simpListLength;
02624     int     m_OldCullingThreshold;
02625     float *m_pTempClipArray;
02626     ViewUpdateMode      m_OldViewUpdateMode;
02627     bool m_UseExplicitShadowLight;
02628     HPoint m_ExplicitShadowLightDirection;
02629     int m_LightCount;
02630 
02631     //no default constructor
02632     HBaseView() {;};
02633 
02634     //obsolete
02635     HBaseView(HBaseModel *model, char const * alias, char const * driver_type,char const * instance_name, long window_handle, long colormap) {
02636         UNREFERENCED(model);
02637         UNREFERENCED(alias);
02638         UNREFERENCED(driver_type);
02639         UNREFERENCED(instance_name);
02640         UNREFERENCED(window_handle);
02641         UNREFERENCED(colormap);
02642     }
02643 
02644     //obsolete
02645     void RebindView(HBaseModel *model, char const * alias, char const * driver_type,char const * instance_name, long window_handle, long colormap) {
02646         UNREFERENCED(model);
02647         UNREFERENCED(alias);
02648         UNREFERENCED(driver_type);
02649         UNREFERENCED(instance_name);
02650         UNREFERENCED(window_handle);
02651         UNREFERENCED(colormap);
02652     }
02653 
02654 };
02655 
02656 
02657 #ifdef H_PACK_8
02658 #pragma pack(pop)
02659 #endif
02660 
02661 #endif