Alphabetical Class Index  Class Hierarchy   File Members   Compound Members   File List  

HBaseView.h
Go to the documentation of this file.
00001 //
00002 // Copyright (c) 2000 by Tech Soft 3D, LLC.
00003 // The information contained herein is confidential and proprietary to
00004 // Tech Soft 3D, LLC., and considered a trade secret as defined under
00005 // civil and criminal statutes.  Tech Soft 3D shall pursue its civil
00006 // and criminal remedies in the event of unauthorized use or misappropriation
00007 // of its trade secrets.  Use of this information by anyone other than
00008 // authorized employees of Tech Soft 3D, LLC. is granted only under a
00009 // written non-disclosure agreement, expressly prescribing the scope and
00010 // manner of such use.
00011 //
00012 // $Id: 0ce2699859509a6ff6585723d926b70e1c2aa2a1 $
00013 //
00014 
00018 #ifndef _HBASEVIEW_H
00019 #define _HBASEVIEW_H
00020 
00021 #ifdef H_PACK_8
00022 #pragma pack(push)
00023 #pragma pack(8)
00024 #endif
00025 
00026 #include "HTools.h"
00027 #include "HTManager.h"
00028 #include "HEventListener.h"
00029 
00030 class HDB;
00031 class HBaseModel;
00032 class HCamera;
00033 class HEventInfo;
00034 class HSelectionSet;
00035 class HBaseOperator;
00036 class HConstantFrameRate;
00037 class HSharedKey;
00038 class HImCuttingGeometry;
00039 class HOutputHandler;
00040 class HOutputHandlerOptions;
00041 class HInputHandler;
00042 class HInputHandlerOptions;
00043 class HUtilityAntialiasing;
00044 class HMarkupManager;
00045 class HShadow;
00046 class HUndoManager;
00047 class HEventManager;
00048 class HObjectManager;
00049 class HOpCameraManipulate;
00050 class HDebugZBuffer;
00051 class HConstFRSimpType;
00052 
00053 
00059 typedef bool(*HSignalNotifyFunction)(int signal, void *signal_data, void *user_data);
00060 
00061 
00062 
00066 enum HRenderMode 
00067 {
00068     HRenderWireframe = 1,       
00069     HRenderTriangulation = 2,   
00070     HRenderSilhouette = 3,      
00071     HRenderHiddenLine = 4,      
00072     HRenderHiddenLineHOOPS = 5, 
00073     HRenderHiddenLineFast = 6,  
00074     HRenderFlat = 7,            
00075     HRenderGouraud = 8,         
00076     HRenderGouraudWithEdges = 9,
00077     HRenderPhong = 10,          
00078     HRenderShaded = 11,         
00079     HRenderShadedWithLines = 12,
00080     HRenderWireframeWithSilhouette = 13, 
00081     HRenderShadedWireframe = 14,
00082     HRenderVertices = 15,       
00083     HRenderShadedVertices = 16, 
00084     HRenderGouraudWithLines = 17,
00085     HRenderLOD1 = 18,
00086     HRenderLOD2 = 19,
00087     HRenderBRepHiddenLine = 20, 
00088     HRenderBRepHiddenLineFast = 21, 
00089     HRenderBRepWireframe = 22,  
00090     HRenderGoochShaded  = 23,   
00091     HRenderFakeHiddenLine = 24, 
00092     HRenderUnknown = 0
00093 };
00094 
00098 enum ViewMode 
00099 {
00100     HViewNone,     
00101     HViewXY,  
00102     HViewYX,  
00103     HViewXZ,  
00104     HViewZX,  
00105     HViewYZ,  
00106     HViewZY,  
00107     HViewIso,  
00108     HViewIsoFrontRightTop,  
00109     HViewIsoBackRightTop,  
00110     HViewIsoBackLeftTop,  
00111     HViewIsoBackLeftBottom,  
00112     HViewIsoBackRightBottom,  
00113     HViewIsoFrontLeftTop,  
00114     HViewIsoFrontLeftBottom,  
00115     HViewIsoFrontRightBottom,  
00116 
00117     HViewSEIso, 
00118     HViewSWIso, 
00119     HViewNEIso, 
00120     HViewNWIso, 
00121 
00122     HViewFront,
00123     HViewBack,
00124     HViewRight,
00125     HViewLeft,
00126     HViewTop,
00127     HViewBottom,
00128 
00129     HViewUnknown  
00130 };
00131 
00132 
00136 enum LightingIntMode 
00137 {
00138     LightingIntUnknown,  
00139     LightingIntGouraud,  
00140     LightingIntPhong     
00141 };
00142 
00143 
00152 enum FramerateMode 
00153 {
00154     FramerateOff,  
00155     FramerateFixed,  
00156     FramerateTarget     
00157 };
00164 enum ProjMode 
00165 {
00166     ProjUnknown,       
00167     ProjPerspective,   
00168     ProjOrthographic,  
00169     ProjStretched      
00170 };
00171 
00172  
00173 
00177 enum HandednessMode 
00178 {
00179     HandednessLeft,   
00180     HandednessRight,  
00181     HandednessNone    
00182 };
00183 
00184 
00188 enum DisplayListType
00189 {
00190     DisplayListOff,         
00191     DisplayListGeometry,    
00192     DisplayListSegment      
00193 };
00194 
00198 enum MultiThreadingType
00199 {
00200     MultiThreadingOff,
00201     MultiThreadingBasic,
00202     MultiThreadingFull
00203 };
00204 
00208 enum HLRMode
00209 {
00210     AnalyticHiddenLine,     
00211     FastHiddenLine,         
00212     FakeHiddenLine          
00213 };
00214 
00215 
00217 enum AxisMode 
00218 {
00219     AxisOff,    
00220     AxisSimple, 
00221     AxisCenter, 
00222     AxisOn      
00223 };
00224 
00226 enum UpDirection
00227 {
00228     UpDirectionX = 0xFADE,
00229     UpDirectionY,
00230     UpDirectionZ
00231 };
00232 
00233 
00237 enum ViewUpdateMode
00238 {
00239     OnDemand,    
00240     Continuous,   
00241     Deferred    
00242 };
00243 
00244 
00246 enum HShadowRenderingMode 
00247 {
00248     SoftwareShadow,             
00249     HardwareShadow,         
00250     SoftwareOpenglShadow        
00251 };
00252 
00254 enum HBloomShape
00255 {
00256     RadialBloom,            
00257     StarBloom               
00258 };
00259 
00261 enum HQuickMovesMethod
00262 {
00263     HQuickMoves_None,       
00264     HQuickMoves_XOR,        
00265     HQuickMoves_Overlay,    
00266     HQuickMoves_Spriting    
00267 };
00268 
00269 
00276 enum HViewSelectionLevel
00277 {
00278     HSelectionLevelEntity,      
00279     HSelectionLevelSegment,     
00280     HSelectionLevelSegmentTree  
00281 };
00287 enum SplatSymbol
00288 {
00289     SplatRound,         
00290     SplatSquare         
00291 };
00292 
00293 
00294 
00301 typedef void(*HBaseViewEmitMessageFunction)(const char* message, unsigned int length, void * user_data);
00302 
00303 
00305 
00337 class MVO_API HBaseView : public HUpdateListener , public HMouseListener, public HObjectManipulationListener
00338 {
00339 
00340 public:
00341 
00342     
00372     HBaseView(HBaseModel *model,
00373         const char * alias = 0, 
00374         const char * driver_type = 0,
00375         const char * instance_name = 0,
00376         void * window_handle = 0,
00377         void * colormap = 0,
00378         void * clip_override = 0,
00379         void * window_handle_2 = 0,
00380         const char * driver_path = 0);
00381 
00409     void RebindView(
00410         const char * alias = 0, 
00411         const char * driver_type = 0,
00412         const char * instance_name = 0,
00413         void * window_handle = 0,
00414         void * colormap = 0,
00415         void * clip_override = 0,
00416         void * window_handle_2 = 0, 
00417         int debug_flags = 0
00418         );
00419 
00424     virtual ~HBaseView();
00425 
00430     virtual void Init();
00431 
00437     virtual void FitWorld(HPoint * center_out = 0);
00438 
00446     virtual void FitWorldExact(HPoint * center_out = 0);
00447     
00452     virtual void ZoomToExtents();
00453 
00457     virtual void ZoomToInitialCamera();
00458 
00459 
00464     void FitSegment(HC_KEY seg_key);
00465 
00470     void FitSelection(HC_KEY key = INVALID_KEY, bool adjustToShellNormal = false);
00471 
00475     void FitItemByPath(HC_KEY key, int incl_count, HC_KEY * incl_path); 
00476     
00478     void RenderAntialiasing(); 
00479 
00481     void InitAntialiasing();   
00482     
00484     HUtilityAntialiasing * GetAntialiasing() { return m_pAntialiasing; }
00485 
00487     HMarkupManager * GetMarkupManager();
00488 
00490     bool HaveMarkupManager() {return (m_pMarkupManager != 0);}
00491 
00495     void    SetMarkupManager( HMarkupManager* markup ) { m_pMarkupManager = markup; }
00496 
00498     void RenderWireframe(); 
00499 
00502     void RenderSilhouette();    
00503 
00505     void RenderHiddenLine(); 
00506 
00508     void RenderHiddenLineFast();  
00509 
00511     void RenderFlat();  
00512 
00514     void RenderGooch();
00515 
00517     void RenderGouraud();    
00518 
00520     void RenderPhong();     
00521 
00523     void RenderWireframeWithSilhouette();
00524 
00526     void RenderShadedWireframe(); 
00527 
00529     void RenderVertices();        
00530 
00532     void RenderShadedVertices();  
00533 
00537     void RenderFakeHiddenLine();
00538 
00541     void RenderBRepHiddenLine();  
00542 
00545     void RenderBRepHiddenLineFast();  
00546     
00548     void RenderBRepWireframe();   
00549  
00554     void RenderShaded();
00555 
00557     void RenderShadedWithLines();          
00558 
00560     void RenderGouraudWithLines();          
00561 
00563     void RenderLOD1();          
00565     void RenderLOD2();          
00566 
00567     
00569     void RemoveTransforms(); 
00570 
00577     virtual void Update();
00578 
00584     virtual void ForceUpdate();
00585 
00597     virtual HFileInputResult FileInput(const __wchar_t * FileName, HInputHandler * handler, HInputHandlerOptions * options = 0);
00598     
00610     virtual HFileInputResult FileInput(const char * FileName, HInputHandler * handler, HInputHandlerOptions * options = 0){
00611         return FileInput((__wchar_t*)H_WCS(FileName).encodedText(), handler, options);
00612     }
00613 
00625 #ifdef H_USHORT_OVERLOAD
00626     virtual HFileInputResult FileInput(const unsigned short * FileName, HInputHandler * handler, HInputHandlerOptions * options = 0){
00627         H_UTF16 utf16;
00628         utf16.encodedText((utf16_char*)FileName);
00629         return FileInput((__wchar_t*)H_WCS(utf16).encodedText(), handler, options);
00630     }
00631 #endif
00632 
00658     virtual HFileOutputResult FileOutput(const __wchar_t * FileName, HOutputHandler * handler, HOutputHandlerOptions * options = 0);
00659     
00685     virtual HFileOutputResult FileOutput(const char * FileName, HOutputHandler * handler, HOutputHandlerOptions * options = 0){
00686         return FileOutput((__wchar_t*)H_WCS(FileName).encodedText(), handler, options);
00687     }
00688 
00689     // accessors
00690 
00692     const char*     GetDriverPath() { return m_sDriverPath; }
00693 
00695     const char*     GetDriverType() { return m_sDriverType; }
00696 
00698     virtual void UpdateHighlighting();
00699 
00701     HSelectionSet*  GetSelection() { return m_pSelection; }
00702     
00706     void            SetSelection(HSelectionSet* selection) { m_pSelection = selection; }
00707 
00709     virtual HBaseModel * GetModel() { return m_pModel; }
00710 
00713     HC_KEY          GetModelKey();
00714 
00716     HRenderMode     GetRenderMode () { return m_RenderMode; }
00717 
00719     ViewMode        GetViewMode () { return m_ViewMode; }
00720 
00727     virtual void    SetViewMode (ViewMode mode, bool invert = false, bool fitWorld = true);
00728 
00730     bool            GetCPLineVisibility() {return m_bCPLineVisibility; }
00731 
00733     bool            GetCPFaceVisibility() {return m_bCPFaceVisibility; }
00734 
00742     void            SetCPGeomVisibility(bool lines, bool faces=false);
00743 
00744 
00750     bool            GetCuttingPlanesExist(const char *plane = 0);
00751  
00755     void            SetCuttingPlanesExist(bool state);
00756 
00758     bool            GetCuttingPlanesVisibility() {return m_bCuttingPlanesVisibility; }
00759 
00763     void            SetCuttingPlanesVisibility(bool visible);
00764 
00766     HConstantFrameRate* GetConstantFrameRateObject() { return m_pConstantFrameRate; }
00767 
00771     void            SetConstantFrameRateObject(HConstantFrameRate* cf) { m_pConstantFrameRate = cf; }
00772 
00774     void            SetEventCheckerCallback(void (* EventChecker)(HIC_Rendition const *nr));
00775  
00777     void SetKeyStateCallback(bool (* KeyState)(unsigned int, int &)) { m_pfKeyState = KeyState; }   
00778 
00780     bool  (*GetKeyStateCallback())(unsigned int, int &) { return m_pfKeyState; }
00781 
00783     void  (*GetEventCheckerCallback())(HIC_Rendition const *nr) { return m_pfEventChecker; }
00784 
00785 
00793     void            SetOcclusionCullingMode(bool mode,  bool UseOctree = true, int threshold = 50);
00794 
00795  
00798     HandednessMode  GetHandedness();
00799 
00811     virtual void SetHandedness(HandednessMode mode, bool emit_message=false);
00812 
00817     virtual void SetHandednessFromMessage(const char *in_data, unsigned int data_length);
00818 
00825     virtual void SetFontSize(const char *font_size, bool emit_message=false);
00826 
00831     virtual void SetFontSizeFromMessage(const char *in_data, unsigned int data_length);
00832     
00834     bool            GetBackplaneCulling(); 
00835     
00842     void            SetBackplaneCulling(bool cull); 
00843 
00847     ProjMode        GetProjMode(); 
00848     
00852     void            SetProjMode(ProjMode mode); 
00853 
00855     DisplayListType GetDisplayListType(); 
00856 
00860     void            SetDisplayListType(DisplayListType type); 
00861 
00863     bool            GetDisplayListMode(); 
00864 
00868     void            SetDisplayListMode(bool mode); 
00869 
00871     HandednessMode  GetPolygonHandednessMode(); 
00872 
00884     void            SetPolygonHandednessMode(HandednessMode); 
00885     
00888     bool            GetLodMode(); 
00889 
00896     void            SetLodMode(bool onoff);
00897     
00899     bool            GetSpritingMode() { return m_bSpritingAllowed; } 
00900 
00906     void            SetSpritingMode(bool onoff) { m_bSpritingAllowed = onoff; } 
00907 
00911     int             GetLodThreshold(); 
00912 
00917     void            SetLodThreshold(int val);
00918 
00920     HC_KEY          GetViewKey() { return m_ViewKey; }  
00922     void            SetViewKey( HC_KEY view_key ) { m_ViewKey = view_key; }    
00923 
00925     HC_KEY          GetIncludeLinkKey() { return m_lIncludeLinkKey; }   
00927     void            SetIncludeLinkKey( HC_KEY link ) { m_lIncludeLinkKey = link; }    
00928 
00930     HC_KEY          GetSceneKey() { return m_SceneKey; }    
00931     
00935     void            SetSceneKey( HC_KEY scene_key ) { m_SceneKey = scene_key; } 
00936 
00938     HC_KEY          GetOverwriteKey() { return m_OverwriteKey; }    
00939  
00941     HC_KEY          GetShadowMapSegmentKey() { return HC_KShow_Owner_By_Key (m_lIncludeLinkKey); }
00942                     
00944     HC_KEY          GetLightsKey() { return m_LightsKey; }   
00945 
00949     void            SetLightsKey( HC_KEY lights_key ) { m_LightsKey = lights_key; }   
00950 
00952     float           GetZoomLimit() { return m_fZoomLimit; }   
00953 
00957     void            SetZoomLimit( float zoomLimit ) { m_fZoomLimit = zoomLimit; }   
00958     
00960     void            SetZoomLimit();   
00961 
00963     HC_KEY          GetWindowspaceKey() { return m_WindowspaceKey; }   
00964 
00968     void            SetWindowspaceKey( HC_KEY winspace_key ) { m_WindowspaceKey = winspace_key; }   
00969 
00971     HC_KEY          GetConstructionKey() { return m_ConstructionKey; }   
00972 
00976     void            SetConstructionKey( HC_KEY construct_key ) { m_ConstructionKey = construct_key; }   
00977 
00979     HC_KEY          GetBBoxGeometryKey() { return m_BBoxGeometryKey; }   
00981     void            SetBBoxGeometryKey( HC_KEY bbox_key ) { m_BBoxGeometryKey = bbox_key; }   
00982 
00984     HC_KEY          GetCuttingPlanesKey() { return m_CuttingPlanesKey; }   
00985 
00989     void            SetCuttingPlanesKey( HC_KEY cuttingplanes_key ) { m_CuttingPlanesKey = cuttingplanes_key; }   
00990     
00992     HC_KEY          GetCuttingPlaneGeomKey() { return m_CuttingPlaneGeomKey; }   
00993 
00997     void            SetCuttingPlaneGeomKey( HC_KEY cuttingplanegeom_key ) { m_CuttingPlaneGeomKey = cuttingplanegeom_key; }   
00999     HC_KEY          GetIntersectPolylinesKey() { return m_IntersectPolylinesKey; }   
01000 
01004     void            SetIntersectPolylinesKey( HC_KEY intersectpolylines_key ) { m_IntersectPolylinesKey = intersectpolylines_key; }   
01005     
01007     HC_KEY          GetProgressBarKey() { return m_ProgressBarKey; }    
01012     void            SetProgressBarKey( HC_KEY key ) { m_ProgressBarKey = key; } 
01013 
01014     
01016     int             GetUpdateInterrupted() { return m_UpdateInterrupted; }  
01017 
01021     void            SetUpdateInterrupted( int val ) { m_UpdateInterrupted = val; } 
01022 
01024     float           GetIdleTime(); 
01025 
01027     void            ResetIdleTime(); 
01028     
01031     HQuickMovesMethod GetQuickMovesMethod () const;  
01032 
01034     class HDebugZBuffer *GetDebugZBuffer() { return m_pDebugZBuffer; } 
01035 
01038     void SetDebugZBuffer(HDebugZBuffer *dzb) { m_pDebugZBuffer = dzb; }; 
01039     
01041     AxisMode        GetAxisMode() {return m_bAxisMode; }   
01042     
01047     virtual void            SetAxisMode(AxisMode mode);
01048 
01052     virtual void            OnSetAxisMode( AxisMode mode );
01053     
01055     void            UpdateAxisTriad() { SetAxisMode(GetAxisMode()); }
01056     
01062     virtual void            AdjustAxisWindow( int axis_window_pixels_in = -1, HIntRectangle *rect_in=0 );
01063     
01065     static  void            AdjustAxisWindowCallback(int signal, void * signal_data, void * user_data);
01066 
01068     static  void            AdjustWindowCallback(int signal, void * signal_data, void * user_data);
01069 
01071     HShadowMode GetShadowMode() {return m_ShadowMode; }   
01072 
01077     virtual void SetShadowMode (HShadowMode sm, bool saveMode = true);  
01078 
01090     virtual void SetReflectionPlane(bool state, float opacity=0.5f, bool fading=true, bool attenuate=false,
01091             float hither=0.0f, float yon=1.0f, bool blur=false, int blur_level=1);
01092 
01094     HC_KEY          GetDefaultLightKey(int which = 0) { return m_SceneLight[which]; }   
01095 
01096  
01098     bool            GetTransparentSelectionBoxMode() {return m_bTransparentSelectionBox; }   
01099     
01103     void            SetTransparentSelectionBoxMode(bool mode) { m_bTransparentSelectionBox = mode; }
01104 
01110     virtual void    DeleteSelectionList(bool emit_message=false);
01111 
01118     void            RotateOnUpdate(const char *sname);
01119 
01127     virtual void SetWindowColor(HPoint rgb, bool emit_message=false);
01128     
01139     virtual void SetWindowColor(HPoint rgbtop, HPoint rgbbottom, bool emit_message=false); 
01140 
01152     virtual void SetWindowColorRange(HPoint rgbtop, HPoint rgbbottom, int percentage, bool emit_message=false); 
01153 
01154 
01162     virtual void SetWindowMaterial(const char * name, bool emit_message=false);
01163 
01169     virtual void SetWindowColorFromMessage(const char *in_data, unsigned int data_length);
01170 
01174     void GetWindowColor(HPoint &color_out);
01175     
01180     void GetWindowColor(HPoint &color_top, HPoint &color_bottom);
01181     
01187     void GetWindowColor(HPoint &color_top, HPoint &color_bottom, int &percentage);
01188 
01193     void GetWindowMaterial(char * out_material, char * out_pattern);
01194 
01198     void            SetOperator(HBaseOperator *NewOperator);
01199 
01200 
01202     void            SetCurrentOperator(HBaseOperator *NewOperator) { SetOperator(NewOperator); }
01203 
01207     HBaseOperator*  GetOperator() { return m_pOperator; }
01208 
01213     HBaseOperator*  GetCurrentOperator() { return m_pOperator; }    
01214 
01215 
01217     HC_KEY  GetAxisTriadKey() {return m_AxisTriadKey;}  
01218 
01220     bool    GetHideOverlappedText(){ return m_bHideOverlappedText;}  
01221 
01225     void    SetHideOverlappedText(bool hide);  
01226 
01230     void    SetNavCube(bool onoff) { m_bNavCube = onoff;}   
01231 
01233     bool    GetSmoothTransition() { return m_bSmoothTransition;}    
01234 
01238     void    SetSmoothTransition(bool onoff) { m_bSmoothTransition = onoff;} 
01239 
01243     void    SetSmoothTransitionDuration(float duration) { m_SmoothTransitionDuration = duration;} 
01244     
01246     float   GetSmoothTransitionDuration() { return m_SmoothTransitionDuration;} 
01247 
01249     bool    IsLightFollowCamera(){return m_bLightFollowsCamera;}  
01250 
01254     void    SetLightFollowsCamera(bool onoroff);    
01255 
01256     static const int MaxLights = 6;
01257 
01261     void    SetLightCount(int count);
01262 
01266     int GetLightCount() { return m_LightCount; }
01267     
01276     virtual void CameraPositionChanged(bool emit_message=false, bool smooth_camera_transition=false);
01277 
01278 
01282     virtual void PrepareForCameraChange();
01283 
01284 
01294     virtual void SetCamera(HPoint pos, HPoint tar, HPoint up, float fieldx, float fieldy, const char *proj);
01295 
01305     virtual void SetInitialCamera(HPoint pos, HPoint tar, HPoint up, float fieldx, float fieldy, char const * proj);
01306 
01307 
01317     virtual void GetCamera(HPoint *pos, HPoint *tar, HPoint *up, float &fieldx, float &fieldy, char *proj);
01318 
01323     virtual void SetCamera(HCamera camera);
01324 
01329     virtual void GetCamera(HCamera *camera);
01330 
01336     virtual void SetCameraFromMessage(const char *data, unsigned int data_length);
01337 
01345     virtual void InsertHSFData(const char *segment, const char *in_data, unsigned int data_length, bool emit_message=false);
01346 
01352     virtual void InsertHSFDataFromMessage(const char *in_data, unsigned int data_length);
01353 
01360     virtual void EmitHSFData(const char *segment, const char *in_data, unsigned int data_length);
01361 
01367     virtual void SetRenderMode (HRenderMode NewRenderMode, bool emit_message=false);
01368 
01374     virtual void SetRenderModeFromMessage(const char *in_data, unsigned int data_length);
01375 
01379     virtual void EmitFlushMessage();
01380 
01388     virtual void FlushFromMessage(const char *in_data, unsigned int data_length);
01389 
01390 
01396     virtual void Flush(bool emit_message=false);
01397 
01404     void SetEmitMessageFunction(
01405         HBaseViewEmitMessageFunction new_emit_message_function,
01406         void * user_data=0) {
01407         emit_message_function=new_emit_message_function;
01408         emit_message_function_user_data=user_data;};
01409 
01414     bool EmittingMessages() {return emit_message_function != 0;};
01415     
01419     HBaseViewEmitMessageFunction GetEmitMessageFunction() {return emit_message_function;};
01420 
01424     void * GetEmitMessageFunctionUserData() {return emit_message_function_user_data;};
01425 
01431     virtual void EmitSelectMessage(HC_KEY key, bool isSelect);
01432 
01438     virtual void SelectFromMessage(const char *in_data, unsigned int data_length);
01439 
01443     virtual void EmitDeSelectAllMessage();
01444 
01445 
01449     virtual void EmitDeleteSelectionListMessage();
01450 
01451 
01455     virtual void DeleteSelectionListFromMessage();
01456 
01457 
01461     virtual void DeSelectAllFromMessage();
01462 
01463 
01468     virtual void EmitSetModellingMatrixMessage(HC_KEY key);
01469 
01470 
01475     virtual void EmitSetModellingMatrixMessage();
01476 
01484     virtual void EmitSegment(HC_KEY key, bool emit_contents_only = false);
01485 
01490     virtual void EmitDeleteByKeyMessage(HC_KEY key);
01491 
01497     virtual void DeleteByKeyFromMessage(const char *in_data, unsigned int data_length);
01498 
01504     virtual void SetModellingMatrixFromMessage(const char *in_data, unsigned int data_length);
01505  
01509     HSharedKey * GetSharedKey() {return m_pSharedKey;};
01510 
01511 
01515     virtual void StartSharedKey();
01516 
01517 
01519     enum HAnimateMode {
01520         HAnimateScene    =          0x00000001 
01521     };
01522 
01523 
01531     virtual void Animate (int animation_steps = 30, HAnimateMode animate_flags = HAnimateScene, int MaxRotation = 360);
01532     
01535     virtual void SetGeometryChanged();
01536 
01540     bool GetSceneBoundingSet() { return m_bSceneBoundingSet; }
01541     
01546     void SetSceneBounding(HPoint &min, HPoint &max);
01547 
01549     void InvalidateSceneBounding() { m_bSceneBoundingSet = false; }
01550 
01554     void SetFastMarkerDrawing(bool b_fast);
01555 
01559     bool GetFastMarkerDrawing();
01560     
01566     void SetDoubleBuffering(bool double_buffer);
01567     
01569     virtual void ClearGeometryChanged() {m_bGeometryChanged = false; };
01570 
01572     virtual bool GeometryChanged() {return m_bGeometryChanged;};
01573     
01579     unsigned long SetSignalNotify( int signal, HSignalNotifyFunction callback, void *user_data ); 
01580     
01583     void UnSetSignalNotify( unsigned long cookie );                                         
01584 
01589     void SetColorInterpolation(bool onoff);
01590 
01596     void SetColorIndexInterpolation(bool onoff, bool isolines = false);
01597 
01603     bool GetColorIndexInterpolation(char * option = 0);
01604 
01613     bool GetFrameBufferEffectsOptions(char * options = 0, int *border = 0);
01614 
01620     void Notify(int signal, void * signal_data = 0);
01621 
01628     int UpdateEvent(bool antialias = false, bool forceUpdate = false);  
01632     bool    GetUpdateRequested() { return m_bUpdateRequested; }
01636     void    RequestUpdate() { m_bUpdateRequested = true; }
01640     void    ClearUpdateRequest() { m_bUpdateRequested = false; }
01641 
01647     void    SetSuppressUpdate(bool suppress) {
01648         suppress?m_SuppressUpdate++:m_SuppressUpdate--;
01649         if (m_SuppressUpdate<0)
01650             m_SuppressUpdate = 0;
01651     }
01652 
01657     bool    GetSuppressUpdate() { return m_SuppressUpdate > 0; }
01658 
01664     void    SetSuppressUpdateTick(bool suppress) { 
01665         suppress?m_SuppressUpdateTick++:m_SuppressUpdateTick--;
01666         if (m_SuppressUpdateTick<0)
01667             m_SuppressUpdateTick = 0;
01668     }
01669 
01674     bool    GetSuppressUpdateTick() { return m_SuppressUpdateTick > 0; }
01675 
01691     void    SetViewUpdateMode(ViewUpdateMode mode, float rate = 0.01f);
01692 
01696     ViewUpdateMode  GetViewUpdateMode() { return m_ViewUpdateMode; }
01697 
01705     static bool UpdateTick(float request_time, float actual_time, void * user_data);
01706 
01714     static bool StreamProgressCallback(unsigned long so_far, unsigned long expected, void * user_data);
01715 
01717     void FlushProgressBar();
01718 
01720     HUndoManager *GetUndoManager();
01721 
01723     HEventManager *GetEventManager();
01724 
01726     HObjectManager *GetHObjectManager();
01727 
01729     bool    GetDynamicHighlighting() { return m_bDynamicHighlighting; }
01730 
01734     void    SetDynamicHighlighting(bool state);
01735 
01741     virtual int OnNoButtonDownAndMove(HEventInfo &hevent);
01742 
01747     virtual int OnLButtonDownAndMove(HEventInfo &hevent);
01748 
01754     virtual int OnLButtonDblClk(HEventInfo &hevent);
01755 
01760     virtual int OnRButtonDownAndMove(HEventInfo &hevent);
01765     virtual int OnMButtonDownAndMove(HEventInfo &hevent);
01770     virtual int OnLRButtonDownAndMove(HEventInfo &hevent);
01771 
01776     virtual int OnLButtonDown(HEventInfo &hevent);  
01777 
01782     virtual int OnMouseMove(HEventInfo &hevent);
01783 
01789     virtual int OnLButtonUp(HEventInfo &hevent);
01790 
01791 #if 0
01792 
01796     virtual int OnMouseWheel(HEventInfo &hevent);
01797 #else
01798 
01802     virtual int OnMouseWheel(HEventInfo &hevent);
01803     
01806     virtual bool ComputeReasonableTarget(HPoint & new_tar, HPoint const & mouse_win, HPoint const & tar_orig);
01807 
01808     /* This method adjusts the old field to the new target so the picture on the screen won't change. */
01809     void ComputeNewField(float & width, float & height, HPoint const & new_tar,
01810                                  HCamera const & old_camera);
01811 #endif
01812 
01814     virtual int OnKeyDown(HEventInfo &hevent);
01815 
01817     virtual int OnKeyUp(HEventInfo &hevent);
01818 
01821     virtual void SetShadowColor(HPoint color);
01822 
01827     virtual void SetShadowLightDirection(bool explicit_light, HPoint const * direction = 0);
01828 
01833     virtual bool GetShadowLightDirection(HPoint * direction = 0);
01834 
01838     virtual void SetShadowIgnoresTransparency(bool ignore);
01839 
01843     virtual bool GetShadowIgnoresTransparency();
01844 
01847     virtual void DoDynamicHighlighting(HPoint mouse_pos);
01848 
01851     virtual void SetShadowResolution(int res);
01852 
01855     virtual void SetShadowBlurring(int blur);
01856 
01858     virtual void InternalUpdate();
01859 
01863     virtual void SetShadowRegenerationMode(bool onoff) { m_bShadowRegeneration = onoff; }
01864 
01867     virtual void SetShadowRegenerationToggle() { m_bShadowRegenerationToggle  = true; m_bShadowRegeneration = false; }
01868 
01871     bool GetCuttingPlaneRegenerationMode() { return m_bCuttingPlaneRegeneration; }
01872  
01877     virtual void SetCuttingPlaneRegenerationMode(bool onoff) { m_bCuttingPlaneRegeneration = onoff; }
01878 
01882     bool GetShadowRegenerationMode() { return m_bShadowRegeneration; }
01883 
01887     virtual void SetCameraChanged( bool val=true ) { m_bCameraChanged = val; if(val) ResetIdleTime(); }
01888     
01890     virtual bool GetCameraChanged() { return m_bCameraChanged; }
01891 
01895     virtual void SetInvertMouseWheelZoom( bool val=true ) { m_bInvertMouseWheelZoom = val;}
01896 
01898     virtual bool GetInvertMouseWheelZoom() { return m_bInvertMouseWheelZoom; }
01899 
01900 
01904     virtual void SetAxisManipulateOperator(HOpCameraManipulate *op);
01905 
01910     virtual void SetVisibilitySelectionMode(bool onoff);
01911  
01913     virtual bool GetVisibilitySelectionMode();
01914 
01917     virtual void SetRelatedSelectionLimit(int limit);
01918  
01920     virtual int GetRelatedSelectionLimit();
01921 
01926     virtual void SetDetailSelection(bool onoff);
01927 
01929     virtual bool GetDetailSelectionMode();
01930 
01938     virtual void SmartFilterCircumcuboid(const char *segment, const char *defaults, HPoint *bottomfrontleft, HPoint *topbackright);
01939     
01946     int SetupHandlesEvent(HBaseView *view, HC_KEY key, bool complex);
01947 
01949     virtual bool GetHasObjects() { return m_bHasObjects; }
01950     
01954     virtual void SetHasObjects(bool hasobjects);
01955     
01956     
01960     virtual void SetHandleOperator(HBaseOperator *op) { m_pHandleOperator = op; }
01961 
01965     virtual HBaseOperator *GetHandleOperator() { return m_pHandleOperator; }    
01966 
01970     virtual float GetDefaultSelectionProximity() { return m_DefaultSelectionProximity; }
01974     virtual void SetDefaultSelectionProximity(float selectionproximity);
01975     
01978     bool GetAllowInteractiveShadows(){
01979         return m_bAllowInteractiveShadows;
01980     }
01981 
01987     void SetAllowInteractiveShadows(bool onoff) {
01988         m_bAllowInteractiveShadows = onoff;
01989     }
01990 
01993     HShadowRenderingMode GetShadowRenderingMode();
01994 
01999     void SetShadowRenderingMode(HShadowRenderingMode mode);
02000 
02003     bool GetAllowInteractiveCutGeometry() { return m_bAllowInteractiveCutGeometry; }
02004 
02009     void SetAllowInteractiveCutGeometry(bool onoff){
02010         m_bAllowInteractiveCutGeometry = onoff;
02011     }
02012 
02015     HCutGeometryVisibility GetCutGeometryVisibility();
02016 
02020     void SetCutGeometryVisibility(HCutGeometryVisibility visibility);
02021     
02022 
02025     void *          GetWindowHandle() { return m_pWindowHandle; }
02026 
02030     bool            GetInitialCameraSet() { return m_bInitialCameraSet; }
02031     
02032 
02033 
02040     int ObjectMovedEvent(HBaseView *view, HC_KEY key, HPoint *pos);
02041 
02045     void SetRecordCamera(bool rc);
02046 
02048     bool GetRecordMode() { return m_bRecordCamera; }
02049     
02053     void InjectEvent(HEventInfo const & hevent);
02054 
02055 
02060     void SetForceFastHiddenLine(bool force) { m_bForceFastHiddenLine = force; }
02061 
02063     bool    GetForceFastHiddenLine() { return m_bForceFastHiddenLine; }
02064 
02070     void SetTransparency(char const * text, bool fast_z_sort=false);
02071 
02076     void SetLineAntialiasing( bool onoff );
02077 
02079     bool GetLineAntialiasing() { return m_bLineAntialiasing; }
02080 
02084     void SetTextAntialiasing( bool onoff );
02085 
02090     void SetDepthOfField(bool onoff, float strength = 1.0f);
02091 
02096     void SetDepthOfFieldRange(float near=0.0f, float far=0.0f);
02097 
02099     bool GetTextAntialiasing() { return m_bTextAntialiasing; }
02100 
02104     void SetIsoDefault(ViewMode vm) { m_IsoDefault = vm; }\
02105     
02107     ViewMode GetIsoDefault() { return m_IsoDefault; }
02108 
02115     void SetCullingThreshold(int cullingthreshold);
02116 
02120     int GetCullingThreshold();
02121 
02128     void SetHardExtent(int cutoff);
02129 
02133     int GetHardExtent();
02134 
02139     void BeginShellSelection();
02140     
02143     void EndShellSelection();
02144 
02146     HSelectionSet * GetHighlightSelection() { return m_pHighlight; }
02147 
02154     void SetViewAxis(HVector *front_axis, HVector *top_axis) { m_FrontAxis = front_axis; m_TopAxis = top_axis; }
02159     void GetViewAxis(HVector *front_axis, HVector *top_axis) { *front_axis = m_FrontAxis; *top_axis = m_TopAxis; }
02160     
02164     void SetDefaultHSRA();
02165 
02166 
02170     void SetMaximumUpdateTime(float mut) { m_MaximumUpdateTime = mut; }
02171     
02175     float GetMaximumUpdateTime() { return m_MaximumUpdateTime; }
02176 
02180     virtual const HSelectionHighlightMode GetHighlightMode() { return m_HighlightMode; }
02181 
02186     virtual void SetHighlightMode(HSelectionHighlightMode m);
02187 
02191     virtual void SetReferenceSelection(bool use_ref);
02192     
02199     bool GetKeyState(unsigned int key, int &flags);
02200 
02202     void ResetKeyState();
02203 
02207     void SetFastFitWorld(bool fw) { m_bFastFitWorld = fw;    }
02208 
02214     void GetSceneExtents(HPoint &min, HPoint &max); 
02215 
02219     void SetLightScaling(float sv);
02220 
02221     void SetXYSizeOverride(int x,int y) { m_XSize_override = x, m_YSize_override = y; }
02222 
02223 
02225     int GetXSize() {return m_XSize;}
02226 
02228     int GetYSize() {return m_YSize;}
02229 
02231     HViewSelectionLevel GetViewSelectionLevel();
02232 
02241     void  SetViewSelectionLevel(HViewSelectionLevel level);
02242 
02251     void EnableTargetFrameRate(bool enable=true, int target=100, int threshold=10, int steps=5);
02252 
02257     float GetFramerate();
02258 
02260     FramerateMode GetFramerateMode();
02261 
02263     int GetFramerateCullingThreshold();
02264 
02269     int GetFramerateSteps();
02270 
02272     bool IsFramerateLodEnabled();
02273 
02287     void SetFramerateMode(FramerateMode mode, float framerate = 0.1f, int cullingthreshold = 150, 
02288         bool enableLods = false, int steps = 20, int cutoff = 1);
02289  
02291     bool IsFrameRateEnabled();
02292     
02294     bool GetViewActive();
02295 
02297     void cleanupSimpList();
02298 
02302     void SetAnnotationResize(bool value);
02303 
02305     bool GetAnnotationResize() { return m_AnnotationCookie==0?false:true; }
02306 
02308     bool GetFirstUpdate() { return m_bFirstUpdate; }
02309 
02311     void SetDisplayHandlesOnDblClk(bool dh) { m_bDisplayHandlesOnDblClk = dh; } 
02312 
02314     bool HasInitialView()   { return m_has_initial_view; }
02315 
02317     void HasInitialView(bool does_it)   { m_has_initial_view=does_it; }
02318 
02320     void ExhaustiveUpdate();
02321 
02323     bool GetUpdateNotFinished() { return m_bUpdateNotFinished; }
02324 
02326     void SetUpdateNotFinished(bool NotFinished) { m_bUpdateNotFinished  = NotFinished; }
02327 
02328     /* This method sets the mousewheel sensitivity which is used to control the apparent sensitivity of the mousewheel for MVO operators.
02329        \param sensitivity value is strictly positive float. */
02330     void SetMouseWheelSensitivity(float sensitivity) {
02331         if (sensitivity > 0)
02332             m_MouseWheelSensitivity = sensitivity;
02333     }
02334     /* Use this in an operator to modify the return value of HEventInfo::GetMouseWheelDelta()
02335        \return value of the operator mousewheel sensitivity, a strictly positive value. */
02336     float GetMouseWheelSensitivity() { return m_MouseWheelSensitivity; }
02337 
02339     void SetSplatRendering(bool onoff);
02340 
02342     bool GetSplatRendering() { return m_bSplatRendering; };
02343 
02345     void SetSplatSize(int splat_size);
02346 
02348     int GetSplatSize() { return m_SplatSize; };
02349 
02351     void SetSplatSymbol(SplatSymbol symbol);
02352 
02354     SplatSymbol GetSplatSymbol() {return m_SplatSymbol;};
02355     
02356     
02360     void UpdateFakeHLRColor(HPoint paper_color);
02361 
02363     void SetHardwareAntialiasing(int antialiasinglevel) { m_HardwareAntialiasing = antialiasinglevel; }
02364 
02366     int GetHardwareAntialiasing() { return m_HardwareAntialiasing; }
02367 
02371     static void StaticForceUpdateRequest(void * view_pointer);
02372 
02373     /*
02374         This method can be used to visualize the internal bounding stored on segments 
02375         and some types of geometry.   The bounding is drawn outside of the model so it does not
02376         interfere with static trees.  It is semi-transparent with a color that indicates the 
02377         bounding density: blue is very dense, red is sparse, green is somewhere in between.
02378         \param draw_something If this value is false, any existing bounding geometry will simply 
02379             be discarded.  If it is true, a new bounding geometry will also be generated.
02380         \param key The key of the segment or geometry whose bounding should be visualized.
02381         \param incl_count The number of keys in the incl_path array.
02382         \param incl_path This array of keys should be structured for a PShow.  That is, the leaf 
02383             as the first entry followed by a series of include keys mapping a path to the view.
02384     */
02385     void VisualizeBounding(bool draw_something, HC_KEY key=INVALID_KEY, int incl_count=0, HC_KEY * incl_path=0);
02386 
02387     
02388     /*
02389         Retrieves the color set by an earlier call to SetFakeHLRColor.
02390         \return the color as an rgb triplet with values from 0.0 to 1.0.
02391     */
02392     HPoint GetFakeHLRColor();
02393     
02394     /*
02395         Sets the color to be used in fake hidden-line render mode.
02396         \param color An rgb triplet with values from 0.0 to 1.0.
02397     */
02398     void SetFakeHLRColor(HPoint color);
02399 
02400     /*
02401         Orients the camera to point at selected geometry and sets depth-of-field to keep it in focus.
02402         \param onoff passing true will focus on the selected geometry, passing false will remove an earlier depth-of-field setting.
02403     */
02404     void FocusOnSelection(bool onoff = true);
02405 
02406     /*
02407         \return true if the view is currently focused on a selection via a previous call to FocusOnSelection(), false otherwise.
02408     */
02409     bool GetFocusOnSelection() { return m_FocusedOnSelection; }
02410     
02412     HTouchManager *GetTouchManager() { return m_TouchManager; }
02413 
02414 protected:
02415     HC_KEY          m_FakeHLRStyle;             
02416     HC_KEY          m_FakeHLRSource;            
02417     bool            m_bCPLineVisibility;        
02418     bool            m_bCPFaceVisibility;        
02419     int             m_CPMode;                   
02420     bool            m_bCuttingPlanesExist;      
02421     bool            m_bCuttingPlanesVisibility; 
02422     bool            m_bSpritingAllowed;         
02423     bool            m_bAxisTriadTransparencyAllowed; 
02424     int             m_AxisWindowSize;           
02426     bool            m_bForceFastHiddenLine;     
02427     bool            m_bLineAntialiasing;        
02428     bool            m_bTextAntialiasing;        
02429     bool            m_bBeginShellSelection;     
02430     bool            m_bDisplayHandlesOnDblClk;
02431     bool            m_has_initial_view;
02432     
02433     HTouchManager   *m_TouchManager;            
02435     int             m_HardwareAntialiasing;
02436     ViewMode        m_IsoDefault;               
02437     HSelectionHighlightMode m_HighlightMode;        
02438     DisplayListType m_DisplayListType;          
02442     bool            m_bGeometryChanged;
02443     HPoint          m_SceneBoundingMin;
02444     HPoint          m_SceneBoundingMax;
02445     bool            m_bSceneBoundingSet;
02446     bool            m_bFastFitWorld;
02447     HImCuttingGeometry * m_pHImCuttingGeometry; 
02448     HUtilityAntialiasing * m_pAntialiasing;     
02449     HMarkupManager * m_pMarkupManager;          
02450     AxisMode        m_bAxisMode;                
02451     bool            m_bHideOverlappedText;      
02452     bool            m_bNavCube;                 
02453     bool            m_bSmoothTransition;        
02454     float           m_SmoothTransitionDuration; 
02455     bool            m_bLightFollowsCamera;      
02456     int             m_WindowColorPercentage;    
02457     HVector         m_FrontAxis;                
02458     HVector         m_TopAxis;                  
02460     HBaseModel*     m_pModel;                   
02461     HC_KEY          m_ViewKey;                  
02463     HC_KEY          m_SceneKey;             
02465     HC_KEY          m_OverwriteKey;             
02467     HC_KEY          m_BBoxGeometryKey;      
02469     HC_KEY          m_WindowspaceKey;       
02471     HC_KEY          m_ConstructionKey;      
02473     HC_KEY          m_CuttingPlanesKey;     
02475     HC_KEY          m_CuttingPlaneGeomKey;  
02477     HC_KEY          m_IntersectPolylinesKey;    
02479     HC_KEY          m_AxisTriadKey; 
02481     HC_KEY          m_ProgressBarKey;   
02482 
02483  
02484     HC_KEY          m_InfoTextKey;  
02485 
02487     HC_KEY          m_lIncludeLinkKey;
02488     HC_KEY          m_LightsKey;            
02489     HC_KEY          m_SceneLight[MaxLights];        
02490     HRenderMode     m_RenderMode;           
02491     ViewMode        m_ViewMode;             
02492     HBaseOperator*  m_pOperator;            
02493     HEventInfo*     m_pEvent;               
02494     HSelectionSet*  m_pSelection;           
02495     HSelectionSet*  m_pHighlight;           
02496     HConstantFrameRate *m_pConstantFrameRate;
02497     HShadowMode     m_ShadowMode;           
02498     HSharedKey *    m_pSharedKey;           
02499     int             m_UpdateInterrupted;   
02500     int             m_InUpdateInternal;   
02501     void            (* m_pfEventChecker)(HIC_Rendition const *nr); 
02502     bool            (* m_pfKeyState)(unsigned int, int &); 
02503     ViewUpdateMode  m_ViewUpdateMode;       
02504     bool            m_bUpdateRequested;     
02505     HEventManager * m_pEventManager;        
02506     HUndoManager *  m_pUndoManager;         
02507     HObjectManager *m_pObjectManager;       
02508     class HDebugZBuffer *m_pDebugZBuffer;   
02509     bool            m_bLButtonDown;         
02510     bool            m_bMouseMove;           
02511     HOpCameraManipulate *m_pManipulateOperator; 
02512     bool            m_bShadowRegeneration;  
02513     bool            m_bShadowRegenerationToggle;    
02514     bool            m_bCuttingPlaneRegeneration; 
02515     bool            m_bCameraChanged;       
02516     float           m_IdleTime;             
02517     bool            m_bFirstUpdate;         
02518     HBaseOperator * m_pHandleOperator;      
02519     bool            m_bAllowInteractiveShadows; 
02520     bool            m_bAllowInteractiveCutGeometry; 
02521     float           m_DefaultSelectionProximity; 
02522     float           m_MaximumUpdateTime;    
02523     HCamera         m_InitialCamera;        
02524     bool            m_bInitialCameraSet;    
02525     bool            m_bRecordCamera;        
02526     bool            m_bTransparentSelectionBox; 
02527     bool            m_bInvertMouseWheelZoom;  
02528     unsigned long   m_AnnotationCookie;
02529     unsigned long   m_AxisResizeCookie;
02530     FramerateMode   m_FramerateMode;
02531     bool            m_bSplatRendering;
02532     int             m_SplatSize;
02533     SplatSymbol     m_SplatSymbol;
02534     bool            m_FocusedOnSelection;
02535     
02542     void ComputeShadowParams(HPlane& shadow_plane, HPoint& light_pos);
02543 
02549     void AdjustShadowPlane(HPlane& shadow_plane, HPoint const & light_pos);
02550 
02556     void SetShadowParams(const HPlane& shadow_plane, const HPoint& light_pos, 
02557                          const HPoint* color = 0, const char * filter = 0);
02558 
02565     virtual void SetShadowParams(HShadow* shadowObj);
02566 
02569     void RefreshViewSize();
02570 
02576     void QueryDeviceCapabilities();
02577 
02586     virtual void UpdateInternal(bool antialias = false, bool force_update = false);
02587 
02588 
02593     virtual void SetupLights();
02594     
02595 private:
02596     float   m_LastRecordTime;   
02598     char * m_sDriverPath;       // fully rooted pathname of driver instance
02599     char * m_sDriverType;       // driver type; e.g. msw, opengl, x11
02600     char * m_sAlias;    
02601     void * m_pWindowHandle;
02602     void * m_pColormap;
02603     void * m_pClipOverride;
02604     void * m_pWindowHandle2;
02605     struct vlist_s *m_SignalRequestsList;   
02606     HBaseViewEmitMessageFunction emit_message_function;
02607     void * emit_message_function_user_data;
02608     HTClient *  m_pUpdateTimerClient;
02609     bool    m_bPrevBackplaneCullMode;   // this caches backplane cull mode (which is switched off when capping planes are turned off with cutting planes on )
02610     bool    m_bHasObjects;
02611     float   m_fZoomLimit;
02612     int     m_SuppressUpdate;
02613     int     m_SuppressUpdateTick;
02614     bool    m_bDynamicHighlighting;
02615     int     m_XSize;
02616     int     m_YSize;
02617     int     m_XSize_override;
02618     int     m_YSize_override;
02619     float   m_LastMouseWheelTime;
02620     float   m_MouseWheelSensitivity;
02621     bool    m_KeyMap[256];
02622     int     m_KeyFlags;
02623     bool    m_bOwnDriver;
02624     bool    m_bUpdateNotFinished;
02625     int     m_NotFinishedCounter;
02626     HPoint  m_FakeHLRColor;
02627     HConstFRSimpType            **SimpList;
02628     int                         simpListLength;
02629     int     m_OldCullingThreshold;
02630     float *m_pTempClipArray;
02631     ViewUpdateMode      m_OldViewUpdateMode;
02632     bool m_UseExplicitShadowLight;
02633     HPoint m_ExplicitShadowLightDirection;
02634     int m_LightCount;
02635 
02636     //no default constructor
02637     HBaseView() {;};
02638 
02639     //obsolete
02640     HBaseView(HBaseModel *model, char const * alias, char const * driver_type,char const * instance_name, long window_handle, long colormap) {
02641         UNREFERENCED(model);
02642         UNREFERENCED(alias);
02643         UNREFERENCED(driver_type);
02644         UNREFERENCED(instance_name);
02645         UNREFERENCED(window_handle);
02646         UNREFERENCED(colormap);
02647     }
02648 
02649     //obsolete
02650     void RebindView(HBaseModel *model, char const * alias, char const * driver_type,char const * instance_name, long window_handle, long colormap) {
02651         UNREFERENCED(model);
02652         UNREFERENCED(alias);
02653         UNREFERENCED(driver_type);
02654         UNREFERENCED(instance_name);
02655         UNREFERENCED(window_handle);
02656         UNREFERENCED(colormap);
02657     }
02658 
02659 };
02660 
02661 
02662 #ifdef H_PACK_8
02663 #pragma pack(pop)
02664 #endif
02665 
02666 #endif