← Back to branch summary

~ubuntu-branches/ubuntu/wily/ginkgocadx/wily-proposed

« back to all changes in this revision

Viewing changes to src/cadxcore/vtk/widgets/widgetsactor.h

  • Committer: Bazaar Package Importer
  • Author(s): Andreas Tille
  • Date: 2011-05-02 08:09:26 UTC
  • Revision ID: james.westby@ubuntu.com-20110502080926-bql5wep49c7hg91t
Tags: upstream-2.4.1.1
Import upstream version 2.4.1.1

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/cadxcore/vtk/widgets/widgetsactor.h
 
1
/*
 
2
 *  
 
3
 *  $Id: widgetsactor.h 3535 2011-03-18 17:57:05Z carlos $
 
4
 *  Ginkgo CADx Project
 
5
 *
 
6
 *  Copyright 2008-10 MetaEmotion S.L. All rights reserved.
 
7
 *  http://ginkgo-cadx.com
 
8
 *
 
9
 *  This file is licensed under LGPL v3 license.
 
10
 *  See License.txt for details
 
11
 *
 
12
 *  Code based in VTK
 
13
 */
 
14
#pragma once
 
15
#ifdef __DEPRECATED
 
16
#undef __DEPRECATED
 
17
#endif 
 
18
#include <api/api.h>
 
19
#include <vtkProp.h>
 
20
#include <vtkOpenGLActor.h>
 
21
#include <vtkOpenGLPolyDataMapper.h>
 
22
#include <vtkOpenGLTexture.h>
 
23
 
 
24
class vtkRenderer;
 
25
class vtkBox;
 
26
class WidgetsActor;
 
27
class WidgetsMapper;
 
28
 
 
29
namespace GNC {
 
30
        namespace GCS {
 
31
                class IWidgetsManager;
 
32
                class IWidgetsRenderer;
 
33
        }
 
34
}
 
35
 
 
36
class EXTAPI WidgetRepresentation : public vtkProp
 
37
        {
 
38
        public:
 
39
                // Description:
 
40
                // Standard methods for instances of this class.
 
41
                void PrintSelf(ostream& os, vtkIndent indent);
 
42
                
 
43
                static WidgetRepresentation *New();
 
44
                
 
45
                vtkTypeMacro(WidgetRepresentation,vtkProp);
 
46
                
 
47
                virtual void SetRenderer(vtkRenderer *ren);
 
48
                vtkGetObjectMacro(Renderer,vtkRenderer);
 
49
                virtual int GetInteractionState()
 
50
                {return this->InteractionState;}
 
51
                
 
52
                vtkSetClampMacro(HandleSize,double,0.001,1000);
 
53
                vtkGetMacro(HandleSize,double);
 
54
                
 
55
                vtkGetMacro( NeedToRender, int );
 
56
                vtkSetClampMacro( NeedToRender, int, 0, 1 );
 
57
                vtkBooleanMacro( NeedToRender, int );
 
58
                
 
59
                virtual double *GetBounds();
 
60
                virtual void GetActors(vtkPropCollection *);
 
61
                virtual void GetActors2D(vtkPropCollection *);
 
62
                virtual void GetVolumes(vtkPropCollection *);
 
63
                virtual void ReleaseGraphicsResources(vtkWindow *);
 
64
                virtual int RenderOverlay(vtkViewport *vtkNotUsed(viewport));
 
65
                virtual int RenderOpaqueGeometry(vtkViewport *vtkNotUsed(viewport));
 
66
                virtual int RenderTranslucentPolygonalGeometry(vtkViewport *vtkNotUsed(viewport));
 
67
                virtual int RenderVolumetricGeometry(vtkViewport *vtkNotUsed(viewport));
 
68
                virtual int HasTranslucentPolygonalGeometry();
 
69
                
 
70
                void SetWidgetsManager(GNC::GCS::IWidgetsManager* pWidgetsManager);
 
71
                void SetWidgetsRenderer(GNC::GCS::IWidgetsRenderer* pWidgetRenderer);
 
72
                
 
73
        protected:
 
74
                WidgetRepresentation();
 
75
                ~WidgetRepresentation();
 
76
                
 
77
                vtkRenderer *Renderer;
 
78
                
 
79
                int InteractionState;
 
80
                
 
81
                // These are used to track the beginning of interaction with the representation
 
82
                // It's dimensioned [3] because some events re processed in 3D.
 
83
                double StartEventPosition[3];
 
84
                
 
85
                // Instance variable and members supporting suclasses
 
86
                double PlaceFactor; // Used to control how widget is placed around bounding box
 
87
                int    Placed; // Indicate whether widget has been placed
 
88
                void   AdjustBounds(double bounds[6], double newBounds[6], double center[3]);
 
89
                double InitialBounds[6]; //initial bounds on place widget (valid after PlaceWidget)
 
90
                double InitialLength; //initial length on place widget
 
91
                bool   Enabled;
 
92
                
 
93
                int    ValidPick; //indicate when valid picks are made
 
94
                
 
95
                double HandleSize; //controlling relative size of widget handles
 
96
                double SizeHandlesRelativeToViewport(double factor, double pos[3]);
 
97
                double SizeHandlesInPixels(double factor,double pos[3]);
 
98
                
 
99
                int NeedToRender;
 
100
                
 
101
                vtkTimeStamp  BuildTime;
 
102
                
 
103
                WidgetsActor*  CustomActor;
 
104
                WidgetsMapper* CustomMapper;
 
105
                
 
106
        private:
 
107
                WidgetRepresentation(const WidgetRepresentation&);  //Not implemented
 
108
                void operator=(const WidgetRepresentation&);  //Not implemented
 
109
        };
 
110
 
 
111
class EXTAPI WidgetsActor : public vtkOpenGLActor {
 
112
public:
 
113
        static WidgetsActor *New();
 
114
        
 
115
protected:
 
116
        WidgetsActor();
 
117
        ~WidgetsActor();
 
118
        
 
119
        vtkTypeMacro(WidgetsActor,vtkOpenGLActor);
 
120
        
 
121
        void Render(vtkRenderer *ren, vtkMapper *mapper);
 
122
        virtual int GetIsOpaque();
 
123
        virtual int RenderOpaqueGeometry(vtkViewport *viewport);
 
124
        virtual int RenderOverlay(vtkViewport *viewport);
 
125
        virtual int RenderTranslucentPolygonalGeometry(vtkViewport *viewport);
 
126
        
 
127
        // Description:
 
128
        // Does this prop have some translucent polygonal geometry?
 
129
        virtual int HasTranslucentPolygonalGeometry();
 
130
        
 
131
        
 
132
public:
 
133
        
 
134
};
 
135
 
 
136
 
 
137
class EXTAPI WidgetsMapper : public vtkPolyDataMapper {
 
138
public:
 
139
        static WidgetsMapper *New();
 
140
        
 
141
        vtkTypeMacro(WidgetsMapper,vtkPolyDataMapper);
 
142
        
 
143
        // Description:
 
144
        // Implement superclass render method.
 
145
        virtual void RenderPiece(vtkRenderer *ren, vtkActor *a);
 
146
        virtual void Render(vtkRenderer *ren, vtkActor *a);
 
147
        
 
148
        // Description:
 
149
        // Release any graphics resources that are being consumed by this mapper.
 
150
        // The parameter window could be used to determine which graphic
 
151
        // resources to release.
 
152
        void ReleaseGraphicsResources(vtkWindow *);
 
153
        
 
154
        // Description:
 
155
        // Draw method for OpenGL.
 
156
        virtual int Draw(vtkRenderer *ren, vtkActor *a);
 
157
        
 
158
        void SetWidgetsManager (GNC::GCS::IWidgetsManager* pManager) {
 
159
                m_pWManager = pManager;
 
160
        }
 
161
        
 
162
        virtual void SetWidgetsRenderer(GNC::GCS::IWidgetsRenderer* pRenderer) {
 
163
                m_pWRenderer = pRenderer;
 
164
        }
 
165
        
 
166
protected:
 
167
        WidgetsMapper();
 
168
        ~WidgetsMapper();
 
169
        
 
170
        int ListId;
 
171
        GNC::GCS::IWidgetsManager*  m_pWManager;
 
172
        GNC::GCS::IWidgetsRenderer* m_pWRenderer;
 
173
        
 
174
private:
 
175
        WidgetsMapper(const WidgetsMapper&);  // Not implemented.
 
176
        void operator=(const WidgetsMapper&);  // Not implemented.
 
177
};