Free Electron
OperatorSurfaceCommon.h
Go to the documentation of this file.
1 /* Copyright (C) 2003-2021 Free Electron Organization
2  Any use of this software requires a license. If a valid license
3  was not distributed with this file, visit freeelectron.org. */
4 
5 /** @file */
6 
7 #ifndef __operate_OperatorSurfaceCommon_h__
8 #define __operate_OperatorSurfaceCommon_h__
9 
10 namespace fe
11 {
12 namespace ext
13 {
14 
15 /**************************************************************************//**
16  @brief Partial Generic SurfaceI Implemention
17 
18  @ingroup operate
19 *//***************************************************************************/
20 class FE_DL_EXPORT OperatorSurfaceCommon:
21  public OperateCommon,
22  public CastableAs<OperatorSurfaceCommon>,
23  virtual public OperatorSurfaceI
24 {
25  public:
26  //* duplicates from SurfaceAccessibleI
27  enum Element
28  {
29  e_point=SurfaceAccessibleI::e_point,
30  e_pointGroup=SurfaceAccessibleI::e_pointGroup,
31  e_vertex=SurfaceAccessibleI::e_vertex,
32  e_primitive=SurfaceAccessibleI::e_primitive,
33  e_primitiveGroup=SurfaceAccessibleI::e_primitiveGroup,
34  e_detail=SurfaceAccessibleI::e_detail
35  };
36  enum Attribute
37  {
38  e_generic=SurfaceAccessibleI::e_generic,
39  e_position=SurfaceAccessibleI::e_position,
40  e_normal=SurfaceAccessibleI::e_normal,
41  e_uv=SurfaceAccessibleI::e_uv,
42  e_color=SurfaceAccessibleI::e_color,
43  e_vertices=SurfaceAccessibleI::e_vertices,
44  e_properties=SurfaceAccessibleI::e_properties
45  };
46  enum Properties
47  {
48  e_openCurve=SurfaceAccessibleI::e_openCurve,
49  e_countU=SurfaceAccessibleI::e_countU,
50  e_countV=SurfaceAccessibleI::e_countV,
51  e_wrappedU=SurfaceAccessibleI::e_wrappedU,
52  e_wrappedV=SurfaceAccessibleI::e_wrappedV,
53  e_depth=SurfaceAccessibleI::e_depth
54  };
55  enum Message
56  {
57  e_quiet=SurfaceAccessibleI::e_quiet,
58  e_warning=SurfaceAccessibleI::e_warning,
59  e_error=SurfaceAccessibleI::e_error
60  };
61  enum Creation
62  {
63  e_refuseMissing=SurfaceAccessibleI::e_refuseMissing,
64  e_createMissing=SurfaceAccessibleI::e_createMissing
65  };
66  enum AtomicChange
67  {
68  e_pointsOnly=
69  SurfaceAccessibleI::e_pointsOnly,
70  e_pointsOfPrimitives=
71  SurfaceAccessibleI::e_pointsOfPrimitives,
72  e_primitivesOnly=
73  SurfaceAccessibleI::e_primitivesOnly,
74  e_primitivesWithPoints=
75  SurfaceAccessibleI::e_primitivesWithPoints
76  };
77 
78  OperatorSurfaceCommon(void):
79  m_pPlugin(NULL)
80  {
81  m_spThreadingState=new
82  SurfaceAccessibleI::ThreadingState();
83  }
84 virtual ~OperatorSurfaceCommon(void) {}
85 
86  //* As HandlerI
87 virtual void handleBind(sp<SignalerI> a_spSignalerI,
88  sp<Layout> a_spLayout);
89 
90  //* As OperatorSurfaceI
91 virtual BWORD saveState(String& rBuffer) { return FALSE; }
92 virtual BWORD loadState(const String& rBuffer){ return FALSE; }
93 
94 virtual BWORD undo(String a_change,sp<Counted> a_spCounted);
95 virtual BWORD redo(String a_change,sp<Counted> a_spCounted);
96 
97 virtual void setPlugin(OperatorPlugin* a_pPlugin)
98  { m_pPlugin=a_pPlugin; }
99 
100  void dirty(BWORD a_aggressive)
101  { if(m_pPlugin) m_pPlugin->dirty(a_aggressive); }
102 
103  void setSharingName(String a_name)
104  { m_sharingName=a_name; }
105  String sharingName(void)
106  { return m_sharingName; }
107  void changeSharing(BWORD a_include);
108  void selectNode(String a_selectName);
109  void select(void)
110  { if(m_pPlugin) m_pPlugin->select(); }
111 
112  BWORD interrupted(void)
113  { return m_pPlugin?
114  m_pPlugin->interrupted(): FALSE; }
115 
116  //* As OperatorSurfaceCommon
117  Real startFrame(Record& a_rSignal)
118  {
119  Real* pFrame=m_aStartFrame.queryAttribute(
120  a_rSignal);
121  return pFrame? *pFrame: -1.0;
122  }
123  Real endFrame(Record& a_rSignal)
124  {
125  Real* pFrame=m_aEndFrame.queryAttribute(
126  a_rSignal);
127  return pFrame? *pFrame: -1.0;
128  }
129  Real currentFrame(Record& a_rSignal)
130  {
131  Real* pFrame=m_aFrame.queryAttribute(a_rSignal);
132  return pFrame? *pFrame: -1.0;
133  }
134  void setCurrentFrame(Record& a_rSignal,Real a_frame)
135  {
136  Real* pReal=m_aFrame.queryAttribute(a_rSignal);
137  if(pReal)
138  {
139  *pReal=a_frame;
140  }
141  }
142  Real currentTime(Record& a_rSignal)
143  {
144  Real* pTime=m_aTime.queryAttribute(a_rSignal);
145  return pTime? *pTime: -1.0;
146  }
147  sp<Component> surfaceOutput(Record& a_rSignal)
148  {
149  sp<Component>* pspComponent=
150  m_aSurfaceOutput.queryAttribute(
151  a_rSignal);
152  if(pspComponent)
153  {
154  return *pspComponent;
155  }
156  return sp<Component>(NULL);
157  }
158  void setSurfaceOutput(Record& a_rSignal,
159  sp<Component> a_spComponent)
160  {
161  sp<Component>* pspComponent=
162  m_aSurfaceOutput.queryAttribute(
163  a_rSignal);
164  if(pspComponent)
165  {
166  *pspComponent=a_spComponent;
167  }
168  }
169  sp<Component> outputDraw(Record& a_rSignal)
170  {
171  sp<Component>* pspComponent=
172  m_aDrawOutput.queryAttribute(a_rSignal);
173  if(pspComponent)
174  {
175  return *pspComponent;
176  }
177  return sp<Component>(NULL);
178  }
179  sp<Component> guideDraw(Record& a_rSignal)
180  {
181  sp<Component>* pspComponent=
182  m_aDrawGuide.queryAttribute(a_rSignal);
183  if(pspComponent)
184  {
185  return *pspComponent;
186  }
187  return sp<Component>(NULL);
188  }
189  sp<Component> brushDraw(Record& a_rSignal)
190  {
191  sp<Component>* pspComponent=
192  m_aDrawBrush.queryAttribute(a_rSignal);
193  if(pspComponent)
194  {
195  return *pspComponent;
196  }
197  return sp<Component>(NULL);
198  }
199  sp<Component> brushOverlayDraw(Record& a_rSignal)
200  {
201  sp<Component>* pspComponent=m_aDrawBrushOverlay
202  .queryAttribute(a_rSignal);
203  if(pspComponent)
204  {
205  return *pspComponent;
206  }
207  return sp<Component>(NULL);
208  }
209  SpatialTransform cameraTransform(Record& a_rSignal)
210  {
211  SpatialTransform* pSpatialTransform=
212  m_aCameraTransform.queryAttribute(
213  a_rSignal);
214  if(pSpatialTransform)
215  {
216  return *pSpatialTransform;
217  }
218  return SpatialTransform::identity();
219  }
220  SpatialVector rayOrigin(Record& a_rSignal)
221  {
222  SpatialVector* pSpatialVector=
223  m_aRayOrigin.queryAttribute(a_rSignal);
224  if(pSpatialVector)
225  {
226  return *pSpatialVector;
227  }
228  return SpatialVector(0.0,0.0,0.0);
229  }
230  SpatialVector rayDirection(Record& a_rSignal)
231  {
232  SpatialVector* pSpatialVector=
233  m_aRayDirection.queryAttribute(
234  a_rSignal);
235  if(pSpatialVector)
236  {
237  return *pSpatialVector;
238  }
239  return SpatialVector(0.0,0.0,0.0);
240  }
241 
242  //* boilerplate reduction methods
243  BWORD accessDraw(sp<DrawI>& a_rspDraw,Record& a_rSignal,
244  Message a_message=e_error)
245  {
246  a_rspDraw=outputDraw(a_rSignal);
247  if(a_rspDraw.isValid())
248  {
249  return TRUE;
250  }
251  reportDraw("Output",a_message);
252  return FALSE;
253  }
254  BWORD accessGuide(sp<DrawI>& a_rspDraw,Record& a_rSignal,
255  Message a_message=e_error)
256  {
257  a_rspDraw=guideDraw(a_rSignal);
258  if(a_rspDraw.isValid())
259  {
260  return TRUE;
261  }
262  reportDraw("Guide",a_message);
263  return FALSE;
264  }
265  BWORD accessBrush(sp<DrawI>& a_rspDraw,Record& a_rSignal,
266  Message a_message=e_error)
267  {
268  a_rspDraw=brushDraw(a_rSignal);
269  if(a_rspDraw.isValid())
270  {
271  return TRUE;
272  }
273  reportDraw("Brush",a_message);
274  return FALSE;
275  }
276  BWORD accessBrushOverlay(sp<DrawI>& a_rspDraw,
277  Record& a_rSignal,
278  Message a_message=e_error)
279  {
280  a_rspDraw=brushOverlayDraw(a_rSignal);
281  if(a_rspDraw.isValid())
282  {
283  return TRUE;
284  }
285  reportDraw("BrushOverlay",a_message);
286  return FALSE;
287  }
288  BWORD accessOutput(
289  sp<SurfaceAccessibleI>& a_rspAccessible,
290  Record& a_rSignal,Message a_message=e_error)
291  {
292  a_rspAccessible=surfaceOutput(a_rSignal);
293  if(a_rspAccessible.isValid() &&
294  a_rspAccessible->isBound())
295  {
296  a_rspAccessible->bind(m_spThreadingState);
297  m_spSurfaceOutput=a_rspAccessible;
298  return TRUE;
299  }
300  a_rspAccessible=NULL;
301  reportAccessible("<output>",a_message);
302  return FALSE;
303  }
304  BWORD accessOutput(sp<SurfaceAccessorI>& a_rspAccessor,
305  Record& a_rSignal,
306  Element a_element,Attribute a_attribute,
307  Message a_message=e_error,
308  Creation a_create=e_createMissing)
309  {
310  sp<SurfaceAccessibleI> spAccessible;
311  if(!accessOutput(spAccessible,
312  a_rSignal,a_message))
313  {
314  a_rspAccessor=NULL;
315  return FALSE;
316  }
317 
318  spAccessible->bind(m_spThreadingState);
319  return access(a_rspAccessor,spAccessible,
320  a_element,a_attribute,
321  a_message,a_create);
322  }
323  BWORD accessOutput(sp<SurfaceAccessorI>& a_rspAccessor,
324  Record& a_rSignal,
325  Element a_element,String a_attrName,
326  Message a_message=e_error,
327  Creation a_create=e_createMissing)
328  {
329  sp<SurfaceAccessibleI> spAccessible;
330  if(!accessOutput(spAccessible,
331  a_rSignal,a_message))
332  {
333  a_rspAccessor=NULL;
334  return FALSE;
335  }
336 
337  spAccessible->bind(m_spThreadingState);
338  return access(a_rspAccessor,spAccessible,
339  a_element,a_attrName,
340  a_message,a_create);
341  }
342  BWORD accessOutput(sp<SurfaceI>& a_rspSurface,
343  Record& a_rSignal,
344  String a_primitiveGroup,
345  Message a_message=e_error,
346  I32 a_subIndex= -1)
347  {
348  sp<SurfaceAccessibleI> spAccessible=
349  surfaceOutput(a_rSignal);
350  if(spAccessible.isNull())
351  {
352  a_rspSurface=NULL;
353  return FALSE;
354  }
355  spAccessible->bind(m_spThreadingState);
356  return access(a_rspSurface,spAccessible,
357  a_primitiveGroup,a_message,a_subIndex);
358  }
359  BWORD accessOutput(sp<SurfaceI>& a_rspSurface,
360  Record& a_rSignal,
361  Message a_message=e_error,
362  I32 a_subIndex= -1)
363  {
364  return accessOutput(a_rspSurface,a_rSignal,"",
365  a_message,a_subIndex);
366  }
367 virtual I32 discardPattern(
368  sp<SurfaceAccessibleI>& a_spAccessible,
369  Element a_element,String a_pattern)
370  {
371  return a_spAccessible->discardPattern(
372  SurfaceAccessibleI::Element(a_element),
373  a_pattern);
374  }
375 virtual BWORD discard(sp<SurfaceAccessibleI>& a_spAccessible,
376  Element a_element,String a_attrName)
377  {
378  return a_spAccessible->discard(
379  SurfaceAccessibleI::Element(a_element),
380  a_attrName);
381  }
382 virtual BWORD discard(sp<SurfaceAccessibleI>& a_spAccessible,
383  Element a_element,Attribute a_attribute)
384  {
385  return a_spAccessible->discard(
386  SurfaceAccessibleI::Element(a_element),
387  SurfaceAccessibleI::Attribute(
388  a_attribute));
389  }
390 virtual I32 deleteElements(
391  sp<SurfaceAccessibleI>& a_spAccessible,
392  Element a_element,String a_groupString,
393  BWORD a_retainGroups=FALSE)
394  {
395  return a_spAccessible->deleteElements(
396  SurfaceAccessibleI::Element(a_element),
397  a_groupString,a_retainGroups);
398  }
399 virtual I32 deleteElements(
400  sp<SurfaceAccessibleI>& a_spAccessible,
401  Element a_element,std::set<I32>& a_rIntSet,
402  BWORD a_retainGroups=FALSE)
403  {
404  return a_spAccessible->deleteElements(
405  SurfaceAccessibleI::Element(a_element),
406  a_rIntSet,a_retainGroups);
407  }
408 
409  BWORD access(sp<SurfaceI>& a_rspSurface,
410  sp<SurfaceAccessibleI>& a_rspAccessible,
411  String a_primitiveGroup,
412  Message a_message=e_error,
413  I32 a_subIndex= -1)
414  {
415  a_rspSurface=a_subIndex<0?
416  a_rspAccessible->surface(
417  a_primitiveGroup):
418  a_rspAccessible->subSurface(
419  a_subIndex,a_primitiveGroup);
420  if(a_rspSurface.isValid())
421  {
422  return TRUE;
423  }
424  reportSurface(a_rspAccessible->name(),
425  a_message);
426  return FALSE;
427  }
428  BWORD access(sp<SurfaceI>& a_rspSurface,
429  sp<SurfaceAccessibleI>& a_rspAccessible,
430  Message a_message=e_error,
431  I32 a_subIndex= -1)
432  {
433  return access(a_rspSurface,a_rspAccessible,"",
434  a_message,a_subIndex);
435  }
436  BWORD access(sp<SurfaceI>& a_rspSurface,
437  String a_key,String a_primitiveGroup,
438  Message a_message=e_error,
439  I32 a_subIndex= -1)
440  {
441  sp<SurfaceAccessibleI> spAccessible;
442  if(!access(spAccessible,a_key,a_message))
443  {
444  a_rspSurface=NULL;
445  return FALSE;
446  }
447 
448  return access(a_rspSurface,spAccessible,
449  a_primitiveGroup,a_message,a_subIndex);
450  }
451  BWORD access(sp<SurfaceI>& a_rspSurface,
452  String a_key,Message a_message=e_error,
453  I32 a_subIndex= -1)
454  {
455  return access(a_rspSurface,a_key,"",
456  a_message,a_subIndex);
457  }
458  BWORD access(sp<SurfaceAccessibleI>& a_rspAccessible,
459  String a_key,Message a_message=e_error)
460  {
461  a_rspAccessible=catalog< sp<Component> >(a_key);
462  if(a_rspAccessible.isValid() &&
463  a_rspAccessible->isBound())
464  {
465  return TRUE;
466  }
467  a_rspAccessible=NULL;
468  reportAccessible(a_key,a_message);
469  return FALSE;
470  }
471  BWORD access(sp<SurfaceAccessorI>& a_rspAccessor,
472  sp<SurfaceAccessibleI>& a_rspAccessible,
473  String a_nodeName,
474  Element a_element,Attribute a_attribute,
475  Message a_message=e_error,
476  Creation a_create=e_createMissing)
477  {
478  const BWORD writable=isOutput(a_rspAccessible);
479  a_rspAccessor=a_rspAccessible->accessor(
480  a_nodeName,
481  SurfaceAccessibleI::Element(a_element),
482  SurfaceAccessibleI::Attribute(
483  a_attribute),
484  writable?
485  SurfaceAccessibleI::Creation(a_create):
486  SurfaceAccessibleI::e_refuseMissing,
487  writable?
488  SurfaceAccessibleI::e_readWrite:
489  SurfaceAccessibleI::e_readOnly);
490  if(a_rspAccessor.isValid())
491  {
492  return TRUE;
493  }
494  const String attrName=attributeText(a_attribute);
495  reportAccessor(a_rspAccessible->name(),
496  a_element,attrName,a_message);
497  return FALSE;
498  }
499  BWORD access(sp<SurfaceAccessorI>& a_rspAccessor,
500  sp<SurfaceAccessibleI>& a_rspAccessible,
501  String a_nodeName,
502  Element a_element,String a_attrName,
503  Message a_message=e_error,
504  Creation a_create=e_createMissing)
505  {
506  const BWORD writable=isOutput(a_rspAccessible);
507  a_rspAccessor=a_rspAccessible->accessor(
508  a_nodeName,
509  SurfaceAccessibleI::Element(a_element),
510  a_attrName,
511  writable?
512  SurfaceAccessibleI::Creation(a_create):
513  SurfaceAccessibleI::e_refuseMissing,
514  writable?
515  SurfaceAccessibleI::e_readWrite:
516  SurfaceAccessibleI::e_readOnly);
517  if(a_rspAccessor.isValid())
518  {
519  return TRUE;
520  }
521  reportAccessor(a_rspAccessible->name(),
522  a_element,
523  "\""+a_attrName+"\"",a_message);
524  return FALSE;
525  }
526  BWORD access(sp<SurfaceAccessorI>& a_rspAccessor,
527  sp<SurfaceAccessibleI>& a_rspAccessible,
528  Element a_element,Attribute a_attribute,
529  Message a_message=e_error,
530  Creation a_create=e_createMissing)
531  {
532  return access(a_rspAccessor,a_rspAccessible,
533  "",a_element,a_attribute,
534  a_message,a_create);
535  }
536  BWORD access(sp<SurfaceAccessorI>& a_rspAccessor,
537  sp<SurfaceAccessibleI>& a_rspAccessible,
538  Element a_element,String a_attrName,
539  Message a_message=e_error,
540  Creation a_create=e_createMissing)
541  {
542  return access(a_rspAccessor,a_rspAccessible,
543  "",a_element,a_attrName,
544  a_message,a_create);
545  }
546  BWORD access(sp<SurfaceAccessorI>& a_rspAccessor,
547  String a_key,
548  Element a_element,Attribute a_attribute,
549  Message a_message=e_error)
550  {
551  sp<SurfaceAccessibleI> spAccessible;
552  if(!access(spAccessible,a_key,a_message))
553  {
554  a_rspAccessor=NULL;
555  return FALSE;
556  }
557 
558  return access(a_rspAccessor,spAccessible,
559  a_element,a_attribute,
560  a_message,e_refuseMissing);
561  }
562  BWORD access(sp<SurfaceAccessorI>& a_rspAccessor,
563  String a_key,
564  Element a_element,String a_attrName,
565  Message a_message=e_error)
566  {
567  sp<SurfaceAccessibleI> spAccessible;
568  if(!access(spAccessible,a_key,a_message))
569  {
570  a_rspAccessor=NULL;
571  return FALSE;
572  }
573 
574  return access(a_rspAccessor,spAccessible,
575  a_element,a_attrName,
576  a_message,e_refuseMissing);
577  }
578 
579  BWORD isOutput(
580  sp<SurfaceAccessibleI>& a_rspAccessible)
581  {
582  return (a_rspAccessible==m_spSurfaceOutput);
583  }
584  void setOutput(
585  sp<SurfaceAccessibleI>& a_rspAccessible)
586  {
587  m_spSurfaceOutput=a_rspAccessible;
588  }
589 
590  String generateSignature(
591  sp<SurfaceAccessibleI>& a_rspAccessibleI);
592 
593 static String elementText(Element a_element)
594  {
595  switch(a_element)
596  {
597  case e_point:
598  return "Point";
599  case e_pointGroup:
600  return "PointGroup";
601  case e_vertex:
602  return "Vertex";
603  case e_primitive:
604  return "Primitive";
605  case e_primitiveGroup:
606  return "PrimitiveGroup";
607  case e_detail:
608  return "Detail";
609  default:
610  return "<bad element>";
611  }
612  }
613 static String elementText(SurfaceAccessibleI::Element a_element)
614  { return elementText(Element(a_element)); }
615 
616 static String attributeText(Attribute a_attribute)
617  {
618  switch(a_attribute)
619  {
620  case e_generic:
621  return "Generic";
622  case e_position:
623  return "Position";
624  case e_normal:
625  return "Normal";
626  case e_uv:
627  return "UVW";
628  case e_color:
629  return "Color";
630  case e_vertices:
631  return "Vertices";
632  case e_properties:
633  return "Properties";
634  default:
635  return "<bad attribute>";
636  }
637  }
638 static String attributeText(
639  SurfaceAccessibleI::Attribute a_attribute)
640  { return attributeText(Attribute(a_attribute)); }
641 
642  protected:
643 
644  BWORD determineNeighborhood(
645  sp<SurfaceAccessibleI>& a_rspAccessible,
646  Array< std::set<I32> >& a_rPointFaces,
647  Array< std::set<I32> >& a_rPointNeighbors);
648 
649  sp<Catalog> duplicateCatalog(void);
650 
651 virtual BWORD anticipate(String a_change,
652  sp<Counted> a_spCounted);
653 virtual BWORD anticipate(String a_change)
654  { return anticipate(a_change,
655  sp<Counted>(NULL)); }
656 virtual BWORD resolve(String a_change,
657  sp<Counted> a_spCounted);
658 virtual BWORD resolve(String a_change)
659  { return resolve(a_change,
660  sp<Counted>(NULL)); }
661 virtual BWORD resolve(void)
662  { return resolve("",sp<Counted>(NULL)); }
663 virtual BWORD chronicle(String a_change,
664  sp<Counted> a_spOldCounted,
665  sp<Counted> a_spNewCounted)
666  { return m_pPlugin? m_pPlugin->chronicle(
667  a_change,a_spOldCounted,
668  a_spNewCounted): FALSE; }
669 virtual BWORD chronicle(String a_change)
670  { return chronicle(a_change,sp<Counted>(NULL),
671  sp<Counted>(NULL)); }
672 
673  sp<SurfaceAccessibleI::ThreadingState> m_spThreadingState;
674 
675  private:
676  void report(String a_text,Message a_message)
677  {
678 #if FE_CODEGEN<=FE_DEBUG
679  feLog("%s %s\n",name().c_str(),a_text.c_str());
680 #endif
681  catalog<String>(a_message==e_error?
682  "error": "warning")+=a_text+"; ";
683  }
684  void reportDraw(String a_drawName,Message a_message)
685  {
686  if(a_message==e_quiet)
687  {
688  return;
689  }
690  String text;
691  text.sPrintf("failed to access drawing"
692  " interface \"%s\"",a_drawName.c_str());
693  report(text,a_message);
694  }
695  void reportSurface(String a_key,Message a_message)
696  {
697  if(a_message==e_quiet)
698  {
699  return;
700  }
701  String text;
702  text.sPrintf("failed to access \"%s\""
703  " (as searchable)",a_key.c_str());
704  report(text,a_message);
705  }
706  void reportAccessible(String a_key,Message a_message)
707  {
708  if(a_message==e_quiet)
709  {
710  return;
711  }
712  String text;
713  if(a_key=="<output>")
714  {
715  text.sPrintf(
716  "failed to access general output");
717  }
718  else
719  {
720  text.sPrintf("failed to access general"
721  " input \"%s\"",a_key.c_str());
722  }
723  report(text,a_message);
724  }
725  void reportAccessor(String a_key,Element a_element,
726  String a_attrName,Message a_message)
727  {
728  if(a_message==e_quiet)
729  {
730  return;
731  }
732  String elementName=elementText(a_element);
733  String text;
734  text.sPrintf("failed to access %s %s on %s",
735  elementName.c_str(),
736  a_attrName.c_str(),
737  a_key.c_str()[0]=='<'? a_key.c_str():
738  ("\""+a_key+"\"").c_str());
739  report(text,a_message);
740 
741 // feX("inaccessible element");
742  }
743 
744  OperatorPlugin* m_pPlugin;
745 
746  hp<SurfaceAccessibleI> m_spSurfaceOutput;
747 
748  Accessor< Real > m_aStartFrame;
749  Accessor< Real > m_aEndFrame;
750  Accessor< Real > m_aFrame;
751  Accessor< Real > m_aTime;
752  Accessor< sp<Component> > m_aSurfaceOutput;
753  Accessor< sp<Component> > m_aDrawOutput;
754  Accessor< sp<Component> > m_aDrawGuide;
755  Accessor< sp<Component> > m_aDrawBrush;
756  Accessor< sp<Component> > m_aDrawBrushOverlay;
757  Accessor<SpatialTransform> m_aCameraTransform;
758  Accessor<SpatialVector> m_aRayOrigin;
759  Accessor<SpatialVector> m_aRayDirection;
760 
761  String m_sharingName;
762 
763  String m_anticipation;
764  sp<Counted> m_spOldCounted;
765 };
766 
767 } /* namespace ext */
768 } /* namespace fe */
769 
770 #endif /* __operate_OperatorSurfaceCommon_h__ */
fe::ext::OperateCommon
Common Operator/Manipulator methods.
Definition: OperateCommon.h:20
fe::String::c_str
const FESTRING_I8 * c_str(void) const
Return the contents of the 8-bit buffer cast as signed bytes.
Definition: String.h:352
fe
kernel
Definition: namespace.dox:3
fe::hp
Safe handle for shared pointer.
Definition: Handled.h:61
fe::String::sPrintf
String & sPrintf(const char *fmt,...)
Populate the string in the manner of sprintf().
Definition: String.cc:529
fe::String
Automatically reference-counted string container.
Definition: String.h:128
fe::ext::OperatorSurfaceCommon
Partial Generic SurfaceI Implemention.
Definition: OperatorSurfaceCommon.h:20
fe::Array
Wrapper for std::vector.
Definition: Array.h:21
fe::RecordSB
Reference to an instance of a Layout.
Definition: RecordSB.h:35
fe::ext::OperatorSurfaceI
General Surface Manipulation.
Definition: OperatorSurfaceI.h:20
fe::ext::OperatorPlugin
Plugin back reference for OperatorSurfaceI.
Definition: OperatorPlugin.h:20
fe::CastableAs
Per-class participation non-RTTI fallback dynamic casting mechanism.
Definition: Castable.h:192
Generated by   doxygen 1.8.13