1 /****************************************************************************
2 * MeshLab                                                           o o     *
3 * A versatile mesh processing toolbox                             o     o   *
4 *                                                                _   O  _   *
5 * Copyright(C) 2005                                                \/)\/    *
6 * Visual Computing Lab                                            /\/|      *
7 * ISTI - Italian National Research Council                           |      *
8 *                                                                    \      *
9 * All rights reserved.                                                      *
10 *                                                                           *
11 * This program is free software; you can redistribute it and/or modify      *
12 * it under the terms of the GNU General Public License as published by      *
13 * the Free Software Foundation; either version 2 of the License, or         *
14 * (at your option) any later version.                                       *
15 *                                                                           *
16 * This program is distributed in the hope that it will be useful,           *
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of            *
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the             *
19 * GNU General Public License (http://www.gnu.org/licenses/gpl.txt)          *
20 * for more details.                                                         *
21 *                                                                           *
22 ****************************************************************************/
23 
24 #ifndef ML_RENDERING_ACTIONS_H
25 #define ML_RENDERING_ACTIONS_H
26 
27 #include <QAction>
28 #include "../common/ml_shared_data_context.h"
29 
30 
31 class MLRenderingAction : public QAction
32 {
33     Q_OBJECT
34 public:
35     MLRenderingAction(QObject* parent);
36     MLRenderingAction(int meshid,QObject* parent);
37 
38 	virtual void createSisterAction(MLRenderingAction*& sisteract,QObject* par) = 0;
39     virtual void updateRenderingData(MLRenderingData& rd) = 0;
40     virtual bool isRenderingDataEnabled(const MLRenderingData& rd) const = 0;
isVisibleConditionValid(MeshModel *)41     virtual bool isVisibleConditionValid(MeshModel*) const {return true;}
switchPrimitive(MLRenderingData::PRIMITIVE_MODALITY)42 	virtual void switchPrimitive(MLRenderingData::PRIMITIVE_MODALITY /*pr*/) {}
43 
44 	int meshId() const;
45     void setMeshId(int meshid);
46 	bool isSameType(const MLRenderingAction& act) const;
47 
48 
49 protected:
50     bool isRenderingDataEnabled(MLRenderingData::PRIMITIVE_MODALITY pm,MLRenderingData::ATT_NAMES att,const MLRenderingData& rd) const;
51 };
52 
53 class MLRenderingGlobalAction : public QAction
54 {
55 	Q_OBJECT
56 public:
57 	MLRenderingGlobalAction(const QString& text,const QIcon& icon,QObject* par);
58 
59 	void addMainAction(MLRenderingAction* act);
60 	void addRelatedAction(MLRenderingAction* act);
61 
62 	QList<MLRenderingAction*>& mainActions();
63 	QList<MLRenderingAction*>& relatedActions();
64 
65 private:
66 	QList<MLRenderingAction*> _mainactions;
67 	QList<MLRenderingAction*> _relatedactions;
68 };
69 
70 class MLRenderingBBoxAction : public MLRenderingAction
71 {
72     Q_OBJECT
73 public:
74     MLRenderingBBoxAction(QObject* parent);
75     MLRenderingBBoxAction(int meshid,QObject* parent);
76 
77 	void createSisterAction(MLRenderingAction*& sisteract, QObject* par);
78     //bool isOnOffOption(MLRenderingAction* onact = 0,MLRenderingAction* offact = 0);
79     void updateRenderingData(MLRenderingData& rd);
80     bool isRenderingDataEnabled(const MLRenderingData& rd) const;
81 };
82 
83 class MLRenderingPointsAction : public MLRenderingAction
84 {
85     Q_OBJECT
86 public:
87     MLRenderingPointsAction(QObject* parent);
88     MLRenderingPointsAction(int meshid,QObject* parent);
89 
90 	void createSisterAction(MLRenderingAction*& sisteract, QObject* par);
91     void updateRenderingData(MLRenderingData& rd);
92     bool isRenderingDataEnabled(const MLRenderingData& rd) const;
93 };
94 
95 class MLRenderingWireAction : public MLRenderingAction
96 {
97     Q_OBJECT
98 public:
99     MLRenderingWireAction(QObject* parent);
100     MLRenderingWireAction(int meshid,QObject* parent);
101 
102 	void createSisterAction(MLRenderingAction*& sisteract, QObject* par);
103     void updateRenderingData(MLRenderingData& rd);
104     bool isRenderingDataEnabled(const MLRenderingData& rd) const;
105 };
106 
107 class MLRenderingSolidAction : public MLRenderingAction
108 {
109     Q_OBJECT
110 public:
111     MLRenderingSolidAction(QObject* parent);
112     MLRenderingSolidAction(int meshid,QObject* parent);
113 
114 	void createSisterAction(MLRenderingAction*& sisteract, QObject* par);
115     void updateRenderingData(MLRenderingData& rd);
116     bool isRenderingDataEnabled(const MLRenderingData& rd) const;
117 };
118 
119 class MLRenderingFauxEdgeWireAction : public MLRenderingAction
120 {
121     Q_OBJECT
122 public:
123     MLRenderingFauxEdgeWireAction(QObject* parent);
124     MLRenderingFauxEdgeWireAction(int meshid,QObject* parent);
125 
126 	void createSisterAction(MLRenderingAction*& sisteract, QObject* par);
127     void updateRenderingData(MLRenderingData& rd);
128     bool isRenderingDataEnabled(const MLRenderingData& rd) const;
129     bool isVisibleConditionValid(MeshModel*) const;
130 };
131 
132 class MLRenderingPerFaceNormalAction : public MLRenderingAction
133 {
134     Q_OBJECT
135 public:
136     MLRenderingPerFaceNormalAction(QObject* parent);
137     MLRenderingPerFaceNormalAction(int meshid,QObject* parent);
138 
139 	void createSisterAction(MLRenderingAction*& sisteract, QObject* par);
140     void updateRenderingData(MLRenderingData& rd);
141     bool isRenderingDataEnabled(const MLRenderingData& rd) const;
142 	bool isVisibleConditionValid(MeshModel*) const;
143 
144 };
145 
146 class MLRenderingPerVertexNormalAction : public MLRenderingAction
147 {
148     Q_OBJECT
149 public:
150     MLRenderingPerVertexNormalAction(MLRenderingData::PRIMITIVE_MODALITY pm,QObject* parent);
151     MLRenderingPerVertexNormalAction(MLRenderingData::PRIMITIVE_MODALITY pm,int meshid,QObject* parent);
152 
153 	void switchPrimitive(MLRenderingData::PRIMITIVE_MODALITY pr);
154 	void createSisterAction(MLRenderingAction*& sisteract, QObject* par);
155     void updateRenderingData(MLRenderingData& rd);
156     bool isRenderingDataEnabled(const MLRenderingData& rd) const;
157 	bool isVisibleConditionValid(MeshModel*) const;
158 private:
159     MLRenderingData::PRIMITIVE_MODALITY _pm;
160 };
161 
162 class MLRenderingPointsDotAction : public MLRenderingAction
163 {
164     Q_OBJECT
165 public:
166     MLRenderingPointsDotAction(QObject* parent);
167     MLRenderingPointsDotAction(int meshid,QObject* parent);
168 
169 	void createSisterAction(MLRenderingAction*& sisteract, QObject* par);
170     void updateRenderingData(MLRenderingData& rd);
171     bool isRenderingDataEnabled(const MLRenderingData& rd) const;
172 };
173 
174 
175 class MLRenderingPerVertTextCoordAction : public MLRenderingAction
176 {
177     Q_OBJECT
178 public:
179     MLRenderingPerVertTextCoordAction(MLRenderingData::PRIMITIVE_MODALITY pm,QObject* parent);
180     MLRenderingPerVertTextCoordAction(MLRenderingData::PRIMITIVE_MODALITY pm,int meshid,QObject* parent);
181 
182 	void switchPrimitive(MLRenderingData::PRIMITIVE_MODALITY pr);
183 	void createSisterAction(MLRenderingAction*& sisteract, QObject* par);
184     void updateRenderingData(MLRenderingData& rd);
185     bool isRenderingDataEnabled(const MLRenderingData& rd) const;
186     bool isVisibleConditionValid(MeshModel*) const;
187 private:
188     MLRenderingData::PRIMITIVE_MODALITY _pm;
189 };
190 
191 class MLRenderingPerWedgeTextCoordAction : public MLRenderingAction
192 {
193     Q_OBJECT
194 public:
195     MLRenderingPerWedgeTextCoordAction(QObject* parent);
196     MLRenderingPerWedgeTextCoordAction(int meshid,QObject* parent);
197 
198 	void createSisterAction(MLRenderingAction*& sisteract, QObject* par);
199     void updateRenderingData(MLRenderingData& rd);
200     bool isRenderingDataEnabled(const MLRenderingData& rd) const;
201     bool isVisibleConditionValid(MeshModel*) const;
202 };
203 
204 class MLRenderingSingleLightingAction : public MLRenderingAction
205 {
206 	Q_OBJECT
207 public:
208 	MLRenderingSingleLightingAction(QObject* parent);
209 	MLRenderingSingleLightingAction(int meshid, QObject* parent);
210 
211 	void createSisterAction(MLRenderingAction*& sisteract, QObject* par);
212 	void updateRenderingData(MLRenderingData& rd);
213 	bool isRenderingDataEnabled(const MLRenderingData& rd) const;
214 };
215 
216 class MLRenderingDoubleLightingAction : public MLRenderingAction
217 {
218     Q_OBJECT
219 public:
220     MLRenderingDoubleLightingAction(QObject* parent);
221     MLRenderingDoubleLightingAction(int meshid,QObject* parent);
222 
223 	void createSisterAction(MLRenderingAction*& sisteract, QObject* par);
224     void updateRenderingData(MLRenderingData& rd);
225     bool isRenderingDataEnabled(const MLRenderingData& rd) const;
226 };
227 
228 class MLRenderingFancyLightingAction : public MLRenderingAction
229 {
230     Q_OBJECT
231 public:
232     MLRenderingFancyLightingAction(QObject* parent);
233     MLRenderingFancyLightingAction(int meshid,QObject* parent);
234 
235 	void createSisterAction(MLRenderingAction*& sisteract, QObject* par);
236     void updateRenderingData(MLRenderingData& rd);
237     bool isRenderingDataEnabled(const MLRenderingData& rd) const;
238 };
239 
240 class MLRenderingFaceCullAction : public MLRenderingAction
241 {
242 	Q_OBJECT
243 public:
244 	MLRenderingFaceCullAction(QObject* parent);
245 	MLRenderingFaceCullAction(int meshid, QObject* parent);
246 
247 	void createSisterAction(MLRenderingAction*& sisteract, QObject* par);
248 	void updateRenderingData(MLRenderingData& rd);
249 	bool isRenderingDataEnabled(const MLRenderingData& rd) const;
250 };
251 
252 class MLRenderingNoShadingAction : public MLRenderingAction
253 {
254     Q_OBJECT
255 public:
256     MLRenderingNoShadingAction(MLRenderingData::PRIMITIVE_MODALITY pm,QObject* parent);
257     MLRenderingNoShadingAction(MLRenderingData::PRIMITIVE_MODALITY pm,int meshid,QObject* parent);
258 
259 	void switchPrimitive(MLRenderingData::PRIMITIVE_MODALITY pr);
260 	void createSisterAction(MLRenderingAction*& sisteract, QObject* par);
261     void updateRenderingData(MLRenderingData& rd);
262     bool isRenderingDataEnabled(const MLRenderingData& rd) const;
263 private:
264     MLRenderingData::PRIMITIVE_MODALITY _pm;
265 };
266 
267 
268 
269 class MLRenderingPerMeshColorAction : public MLRenderingAction
270 {
271     Q_OBJECT
272 public:
273     MLRenderingPerMeshColorAction(MLRenderingData::PRIMITIVE_MODALITY pm,QObject* parent);
274     MLRenderingPerMeshColorAction(MLRenderingData::PRIMITIVE_MODALITY pm,int meshid,QObject* parent);
275 
276 	void switchPrimitive(MLRenderingData::PRIMITIVE_MODALITY pr);
277 	void createSisterAction(MLRenderingAction*& sisteract, QObject* par);
278     void updateRenderingData(MLRenderingData& rd);
279     bool isRenderingDataEnabled(const MLRenderingData& rd) const;
280     void setColor(const QColor& col);
281     void setColor(const vcg::Color4b& col);
282 
283     vcg::Color4b& getColor();
284 private:
285     vcg::Color4b _col;
286     MLRenderingData::PRIMITIVE_MODALITY _pm;
287 };
288 
289 class MLRenderingBBoxPerMeshColorAction : public MLRenderingAction
290 {
291     Q_OBJECT
292 public:
293     MLRenderingBBoxPerMeshColorAction(QObject* parent);
294     MLRenderingBBoxPerMeshColorAction(int meshid,QObject* parent);
295 
296 	void createSisterAction(MLRenderingAction*& sisteract, QObject* par);
297     void updateRenderingData(MLRenderingData& rd);
298     bool isRenderingDataEnabled(const MLRenderingData& rd) const;
299     void setColor(const QColor& col);
300     void setColor(const vcg::Color4b& col);
301 
302     vcg::Color4b& getColor();
303 private:
304     vcg::Color4b _col;
305 };
306 
307 class MLRenderingPerVertexColorAction : public MLRenderingAction
308 {
309     Q_OBJECT
310 public:
311     MLRenderingPerVertexColorAction(MLRenderingData::PRIMITIVE_MODALITY pm,QObject* parent);
312     MLRenderingPerVertexColorAction(MLRenderingData::PRIMITIVE_MODALITY pm,int meshid,QObject* parent);
313 
314 	void switchPrimitive(MLRenderingData::PRIMITIVE_MODALITY pr);
315 	void createSisterAction(MLRenderingAction*& sisteract, QObject* par);
316     void updateRenderingData(MLRenderingData& rd);
317     bool isRenderingDataEnabled(const MLRenderingData& rd) const;
318 	bool isVisibleConditionValid(MeshModel * mm) const;
319 private:
320     MLRenderingData::PRIMITIVE_MODALITY _pm;
321 };
322 
323 class MLRenderingPerFaceColorAction : public MLRenderingAction
324 {
325     Q_OBJECT
326 public:
327     MLRenderingPerFaceColorAction(QObject* parent);
328     MLRenderingPerFaceColorAction(int meshid,QObject* parent);
329 
330 	void createSisterAction(MLRenderingAction*& sisteract, QObject* par);
331     void updateRenderingData(MLRenderingData& rd);
332     bool isRenderingDataEnabled(const MLRenderingData& rd) const;
333     bool isVisibleConditionValid(MeshModel*) const;
334 };
335 
336 class MLRenderingUserDefinedGeneralColorAction : public MLRenderingAction
337 {
338 	Q_OBJECT
339 public:
340 	MLRenderingUserDefinedGeneralColorAction(QObject* parent);
341 	MLRenderingUserDefinedGeneralColorAction(int meshid, QObject* parent);
342 	MLRenderingUserDefinedGeneralColorAction(MLRenderingUserDefinedGeneralColorAction* origin, QObject * par);
343 
344 	virtual void createSisterAction(MLRenderingAction*& sisteract, QObject* par) = 0;
345 	virtual void updateRenderingData(MLRenderingData& rd) = 0;
346 	virtual bool isRenderingDataEnabled(const MLRenderingData& rd) const = 0;
347 
348 	void setColor(const vcg::Color4b& col);
349 	void setColor(const QColor& col);
350 
351 	vcg::Color4b& getColor();
352 	virtual void readColor(const MLRenderingData& rd, vcg::Color4b& col) = 0;
353 protected:
354 	vcg::Color4b _coluser;
355 };
356 
357 class MLRenderingUserDefinedColorAction : public MLRenderingUserDefinedGeneralColorAction
358 {
359     Q_OBJECT
360 public:
361     MLRenderingUserDefinedColorAction(MLRenderingData::PRIMITIVE_MODALITY pm,QObject* parent);
362     MLRenderingUserDefinedColorAction(MLRenderingData::PRIMITIVE_MODALITY pm,int meshid,QObject* parent);
363 	MLRenderingUserDefinedColorAction(MLRenderingUserDefinedColorAction* origin, QObject * par);
364 
365 	void switchPrimitive(MLRenderingData::PRIMITIVE_MODALITY pr);
366 	void createSisterAction(MLRenderingAction*& sisteract, QObject* par);
367     void updateRenderingData(MLRenderingData& rd);
368     bool isRenderingDataEnabled(const MLRenderingData& rd) const;
369 
370 	void readColor(const MLRenderingData& rd, vcg::Color4b& col);
371 private:
372     MLRenderingData::PRIMITIVE_MODALITY _pm;
373 };
374 
375 class MLRenderingBBoxUserDefinedColorAction : public MLRenderingUserDefinedGeneralColorAction
376 {
377     Q_OBJECT
378 public:
379     MLRenderingBBoxUserDefinedColorAction(QObject* parent);
380     MLRenderingBBoxUserDefinedColorAction(int meshid,QObject* parent);
381 	MLRenderingBBoxUserDefinedColorAction(MLRenderingBBoxUserDefinedColorAction* origin, QObject * par);
382 
383 	void createSisterAction(MLRenderingAction*& sisteract, QObject* par);
384     void updateRenderingData(MLRenderingData& rd);
385     bool isRenderingDataEnabled(const MLRenderingData& rd) const;
386 
387 	void readColor(const MLRenderingData& rd, vcg::Color4b& col);
388 };
389 
390 
391 class MLRenderingFloatAction : public MLRenderingAction
392 {
393     Q_OBJECT
394 public:
395     MLRenderingFloatAction(QObject* parent);
396     MLRenderingFloatAction(int meshid,QObject* parent);
397 
setValue(float value)398     void setValue(float value) {_value = value;}
getValue()399     float getValue() {return _value;}
400 
401 	virtual void createSisterAction(MLRenderingAction*& sisteract, QObject* par) = 0;
402     virtual void updateRenderingData(MLRenderingData& rd) = 0;
403     virtual bool isRenderingDataEnabled(const MLRenderingData& rd) const = 0;
404     virtual float getValueFromRenderingData(const MLRenderingData& rd) const = 0;
405 protected:
406     float _value;
407 };
408 
409 class MLRenderingPointsSizeAction : public MLRenderingFloatAction
410 {
411     Q_OBJECT
412 public:
413     MLRenderingPointsSizeAction(QObject* parent);
414     MLRenderingPointsSizeAction(int meshid,QObject* parent);
415 	MLRenderingPointsSizeAction(MLRenderingPointsSizeAction* origin,QObject* parent);
416 
417 	void createSisterAction(MLRenderingAction*& sisteract, QObject* par);
418     void updateRenderingData(MLRenderingData& rd);
419     bool isRenderingDataEnabled(const MLRenderingData& rd) const;
420     float getValueFromRenderingData(const MLRenderingData& rd) const;
421 };
422 
423 class MLRenderingWireWidthAction : public MLRenderingFloatAction
424 {
425     Q_OBJECT
426 public:
427     MLRenderingWireWidthAction(QObject* parent);
428     MLRenderingWireWidthAction(int meshid,QObject* parent);
429 	MLRenderingWireWidthAction(MLRenderingWireWidthAction* origin, QObject* parent);
430 
431 	void createSisterAction(MLRenderingAction*& sisteract, QObject* par);
432     void updateRenderingData(MLRenderingData& rd);
433     bool isRenderingDataEnabled(const MLRenderingData& rd) const;
434     float getValueFromRenderingData(const MLRenderingData& rd) const;
435 };
436 
437 class MLRenderingSelectionAction : public MLRenderingAction
438 {
439     Q_OBJECT
440 public:
441     MLRenderingSelectionAction(QObject* parent);
442     MLRenderingSelectionAction(int meshid,QObject* parent);
443 
444 	void createSisterAction(MLRenderingAction*& sisteract, QObject* par);
445     void updateRenderingData(MLRenderingData& rd);
446     bool isRenderingDataEnabled(const MLRenderingData& rd) const;
447 };
448 
449 class MLRenderingVertSelectionAction : public MLRenderingAction
450 {
451     Q_OBJECT
452 public:
453     MLRenderingVertSelectionAction(QObject* parent);
454     MLRenderingVertSelectionAction(int meshid,QObject* parent);
455 
456 	void createSisterAction(MLRenderingAction*& sisteract, QObject* par);
457     void updateRenderingData(MLRenderingData& rd);
458     bool isRenderingDataEnabled(const MLRenderingData& rd) const;
459 };
460 
461 class MLRenderingFaceSelectionAction : public MLRenderingAction
462 {
463     Q_OBJECT
464 public:
465     MLRenderingFaceSelectionAction(QObject* parent);
466     MLRenderingFaceSelectionAction(int meshid,QObject* parent);
467 
468 	void createSisterAction(MLRenderingAction*& sisteract, QObject* par);
469     void updateRenderingData(MLRenderingData& rd);
470     bool isRenderingDataEnabled(const MLRenderingData& rd) const;
471 };
472 
473 class MLRenderingEdgeDecoratorAction : public MLRenderingAction
474 {
475     Q_OBJECT
476 public:
477     MLRenderingEdgeDecoratorAction(QObject* parent);
478     MLRenderingEdgeDecoratorAction(int meshid,QObject* parent);
479 
480 	void createSisterAction(MLRenderingAction*& sisteract, QObject* par);
481     void updateRenderingData(MLRenderingData& rd);
482     bool isRenderingDataEnabled(const MLRenderingData& rd) const;
483 };
484 
485 class MLRenderingEdgeBoundaryAction : public MLRenderingAction
486 {
487     Q_OBJECT
488 public:
489     MLRenderingEdgeBoundaryAction(QObject* parent);
490     MLRenderingEdgeBoundaryAction(int meshid,QObject* parent);
491 
492 	void createSisterAction(MLRenderingAction*& sisteract, QObject* par);
493     void updateRenderingData(MLRenderingData& rd);
494     bool isRenderingDataEnabled(const MLRenderingData& rd) const;
495 };
496 
497 class MLRenderingFaceBoundaryAction : public MLRenderingAction
498 {
499     Q_OBJECT
500 public:
501     MLRenderingFaceBoundaryAction(QObject* parent);
502     MLRenderingFaceBoundaryAction(int meshid,QObject* parent);
503 
504 	void createSisterAction(MLRenderingAction*& sisteract, QObject* par);
505     void updateRenderingData(MLRenderingData& rd);
506     bool isRenderingDataEnabled(const MLRenderingData& rd) const;
507 };
508 
509 class MLRenderingEdgeManifoldAction : public MLRenderingAction
510 {
511     Q_OBJECT
512 public:
513     MLRenderingEdgeManifoldAction(QObject* parent);
514     MLRenderingEdgeManifoldAction(int meshid,QObject* parent);
515 
516 	void createSisterAction(MLRenderingAction*& sisteract, QObject* par);
517     void updateRenderingData(MLRenderingData& rd);
518     bool isRenderingDataEnabled(const MLRenderingData& rd) const;
519 };
520 
521 class MLRenderingVertManifoldAction : public MLRenderingAction
522 {
523     Q_OBJECT
524 public:
525     MLRenderingVertManifoldAction(QObject* parent);
526     MLRenderingVertManifoldAction(int meshid,QObject* parent);
527 
528 	void createSisterAction(MLRenderingAction*& sisteract, QObject* par);
529     void updateRenderingData(MLRenderingData& rd);
530     bool isRenderingDataEnabled(const MLRenderingData& rd) const;
531 };
532 
533 
534 class MLRenderingTexBorderAction : public MLRenderingAction
535 {
536     Q_OBJECT
537 public:
538     MLRenderingTexBorderAction(QObject* parent);
539     MLRenderingTexBorderAction(int meshid,QObject* parent);
540 
541 	void createSisterAction(MLRenderingAction*& sisteract, QObject* par);
542     void updateRenderingData(MLRenderingData& rd);
543     bool isRenderingDataEnabled(const MLRenderingData& rd) const;
544 };
545 
546 //class MLRenderingLightColorAction : public MLRenderingAction
547 //{
548 //    Q_OBJECT
549 //public:
550 //    MLRenderingLightColorAction(QObject* parent);
551 //    MLRenderingLightColorAction(int meshid,QObject* parent);
552 //
553 //    void updateRenderingData(MLRenderingData& rd);
554 //    bool isRenderingDataEnabled(const MLRenderingData& rd) const;
555 //};
556 
557 class MLRenderingDotAction : public MLRenderingAction
558 {
559     Q_OBJECT
560 public:
561     MLRenderingDotAction(QObject* parent);
562     MLRenderingDotAction(int meshid,QObject* parent);
563 
564 	void createSisterAction(MLRenderingAction*& sisteract, QObject* par);
565     void updateRenderingData(MLRenderingData& rd);
566     bool isRenderingDataEnabled(const MLRenderingData& rd) const;
567 };
568 
569 class MLRenderingBBoxQuotedInfoAction : public MLRenderingAction
570 {
571     Q_OBJECT
572 public:
573     MLRenderingBBoxQuotedInfoAction(QObject* parent);
574     MLRenderingBBoxQuotedInfoAction(int meshid,QObject* parent);
575 
576 	void createSisterAction(MLRenderingAction*& sisteract, QObject* par);
577     void updateRenderingData(MLRenderingData& rd);
578     bool isRenderingDataEnabled(const MLRenderingData& rd) const;
579 };
580 
581 #endif
582