< Home

< Table of Contents

REFERENCE MANUAL

sprk.h
1 // Copyright (c) 1998-2014 by Tech Soft 3D, Inc.
2 //
3 // The information contained herein is confidential and proprietary to Tech Soft 3D, Inc.,
4 // and considered a trade secret as defined under civil and criminal statutes.
5 // Tech Soft 3D, Inc. shall pursue its civil and criminal remedies in the event of
6 // unauthorized use or misappropriation of its trade secrets. Use of this information
7 // by anyone other than authorized employees of Tech Soft 3D, Inc. is granted only under
8 // a written non-disclosure agreement, expressly prescribing the scope and manner of such use.
9 
10 #ifndef SPRK_H
11 #define SPRK_H
12 
13 #include "hps.h"
14 
15 #include <list>
16 #include <stack>
17 #include <memory>
18 #include <map>
19 
20 #ifdef _MSC_VER
21 # pragma warning(disable: 4251) //Not an issue as long as debug and release libraries aren't mixed
22 #ifndef STATIC_APP
23 # ifdef SPROCKETS
24 # define SPRK_API __declspec (dllexport)
25 # else
26 # define SPRK_API __declspec (dllimport)
27 # endif
28 #endif
29 #else
30 # include <stddef.h>
31 # if defined(LINUX_SYSTEM) && defined(SPROCKETS)
32 # ifndef STATIC_APP
33 # define SPRK_API __attribute__ ((visibility ("default")))
34 # endif
35 # endif
36 #endif
37 
38 #ifndef SPRK_API
39 # define SPRK_API
40 #endif
41 namespace SPRKI
42 {
43  class X;
44 };
45 
46 namespace HPS
47 {
48 
49 class Factory;
50 class Canvas;
51 class Layout;
52 class View;
53 class Model;
54 class Operator;
55 class OperatorControl;
56 class NavigationCubeControl;
57 class AxisTriadControl;
58 class Component;
59 class ComponentPath;
60 class ComponentHighlightEvent;
61 class Filter;
62 class Capture;
63 class CADModel;
64 class Metadata;
65 
66 
67 
68 
69 class SPRK_API Sprocket : public Object
70 {
71 public:
72  Sprocket() {}
73  Sprocket(Sprocket && in_that) : Object(std::move(in_that)) {}
74 
75  virtual ~Sprocket() {}
76 
77  enum class UpdateType
78  {
79  Synchronous,
80  Asynchronous
81  };
82 };
83 
84 typedef std::shared_ptr<Operator> OperatorPtr;
85 
86 typedef std::vector<OperatorPtr, Allocator<OperatorPtr> > OperatorPtrArray;
87 
88 typedef std::vector<Canvas, Allocator<Canvas> > CanvasArray;
89 typedef std::vector<Layout, Allocator<Layout> > LayoutArray;
90 typedef std::vector<View, Allocator<View> > ViewArray;
91 typedef std::vector<Model, Allocator<Model> > ModelArray;
92 
93 typedef std::vector<Component, Allocator<Component> > ComponentArray;
94 typedef std::vector<Metadata, Allocator<Metadata> > MetadataArray;
95 typedef std::vector<Filter, Allocator<Filter> > FilterArray;
96 typedef std::vector<Capture, Allocator<Capture> > CaptureArray;
97 typedef std::vector<CADModel, Allocator<CADModel> > CADModelArray;
98 typedef std::vector<ReferenceKeyArray, Allocator<ReferenceKeyArray>> ReferenceKeyArrayArray;
99 typedef std::vector<ComponentPath, Allocator<ComponentPath>> ComponentPathArray;
100 
101 
105 class SPRK_API Canvas : public Sprocket
106 {
107 public:
108  Canvas();
109  Canvas(Canvas const & that);
110  ~Canvas();
111 
112  Type ObjectType() const { return Type::Canvas; }
113 
115  void Delete();
116 
117  Canvas & operator=(Canvas const & in_that);
118  void Assign(Canvas const & in_that);
119 
120  bool Equals(Canvas const & in_that) const;
121  bool operator!= (Canvas const & in_that) const;
122  bool operator== (Canvas const & in_that) const;
123 
125  UTF8 GetName() const;
126 
130  void AttachLayout(Layout const & in_layout);
131 
135  void AttachViewAsLayout(View const & in_view);
136 
138  void DetachLayout();
139 
141  Layout GetAttachedLayout() const;
142 
144  IncludeKey GetAttachedLayoutIncludeLink() const;
145 
147  View GetFrontView() const;
148 
149  WindowKey const GetWindowKey() const;
150 
153  WindowKey GetWindowKey();
154 
155  PortfolioKey const GetPortfolioKey() const;
156 
158  PortfolioKey GetPortfolioKey();
159 
161  void Update(Sprocket::UpdateType in_update_type = Sprocket::UpdateType::Asynchronous) const;
162 
165  UpdateNotifier UpdateWithNotifier() const;
166 
170  void Update(Window::UpdateControl const in_control, Time const time_limit = -1.) const;
171 
176  UpdateNotifier UpdateWithNotifier(Window::UpdateControl const in_control, Time const time_limit = -1.) const;
177 
181  void SetFrameRate(float in_frame_rate=20);
182 
186  float GetFrameRate() const;
187 };
188 
189 class SPRK_API Rendering
190 {
191 public:
194  enum class Mode
195  {
196  Gouraud,
197  GouraudWithLines,
198  Flat,
199  FlatWithLines,
200  Phong,
201  PhongWithLines,
202  HiddenLine,
203  FastHiddenLine,
204  Wireframe,
205  Default = Phong
206  };
207 
208 private:
209  Rendering() {}
210 };
211 
212 class SPRK_API SprocketControl : public Sprocket
213 {
214 public:
215  Type ObjectType() const {return Type::SprocketControl;}
216 
217 protected:
218  SprocketControl() {}
219 
223  SprocketControl(SprocketControl && in_that) : Sprocket(std::move(in_that)) {}
224 
229  {
230  this->Object::operator=(std::move(in_that));
231  return *this;
232  }
233 };
234 
238 class SPRK_API View : public Sprocket
239 {
240 public:
241  View();
242  View(View const & that);
243  explicit View(SprocketControl const & in_ctrl);
244  ~View();
245 
246  Type ObjectType() const { return Type::View; }
247 
249  void Delete();
250 
251  View & operator=(View const & in_that);
252  void Assign(View const & in_that);
253 
254  bool Equals(View const & in_that) const;
255  bool operator!= (View const & in_that) const;
256  bool operator== (View const & in_that) const;
257 
259  UTF8 GetName() const;
260 
261 
263  View & ComputeFitWorldCamera(CameraKit & out_camera);
264 
267  View & ComputeFitWorldCamera(SegmentKey const & in_segment, CameraKit & out_camera);
268 
269 
272  View & ComputeFitWorldCamera(BoundingKit const & in_bounding, CameraKit & out_camera);
273 
278  View & ComputeFitWorldCamera(SegmentKey const & in_segment, MatrixKit const & in_transform, CameraKit & out_camera);
279 
280 
285  View & ComputeFitWorldCamera(BoundingKit const & in_bounding, MatrixKit const & in_transform, CameraKit & out_camera);
286 
287 
289  View & FitWorld();
290 
293  View & FitWorld(SegmentKey const & in_segment);
294 
295 
298  View & FitWorld(BoundingKit const & in_bounding);
299 
304  View & FitWorld(SegmentKey const & in_segment, MatrixKit const & in_transform);
305 
306 
311  View & FitWorld(BoundingKit const & in_bounding, MatrixKit const & in_transform);
312 
317  void AttachModel(Model const & in_model);
318 
320  void DetachModel();
321 
323  Model GetAttachedModel() const;
324 
326  IncludeKey GetAttachedModelIncludeLink() const;
327 
331  void SetRenderingMode(Rendering::Mode in_mode);
332 
335  Rendering::Mode GetRenderingMode() const;
336 
338  OperatorPtrArray GetOperators() const;
339 
342  void SetOperators(OperatorPtrArray & in_operators);
343 
347  void SetOperators(size_t in_count, OperatorPtr in_operators []);
348 
351  void SetOperator(OperatorPtr const & in_operator);
352 
355  void SetOperator(Operator * in_operator);
356 
358  OperatorControl GetOperatorControl();
359  OperatorControl const GetOperatorControl() const;
360 
362  NavigationCubeControl GetNavigationCubeControl();
363  NavigationCubeControl const GetNavigationCubeControl() const;
364 
366  AxisTriadControl GetAxisTriadControl();
367  AxisTriadControl const GetAxisTriadControl() const;
368 
371  SegmentKey GetSegmentKey();
372  SegmentKey const GetSegmentKey() const;
373 
376  SegmentKey GetModelOverrideSegmentKey();
377  SegmentKey const GetModelOverrideSegmentKey() const;
378 
379 
380  PortfolioKey const GetPortfolioKey() const;
381 
383  PortfolioKey GetPortfolioKey();
384 
389  void SetSimpleShadow(bool in_state, float in_percent_offset = 5.0f);
390 
391  /* Returns the status of the simple shadows */
392  bool GetSimpleShadow();
393 
398  void SetSimpleReflection(bool in_state, float in_percent_offset = 5.0f);
399 
400  /* Returns the status of the simple reflection */
401  bool GetSimpleReflection();
402 
404  void Update(Sprocket::UpdateType in_update_type = Sprocket::UpdateType::Asynchronous) const;
405 
409  void Update(Window::UpdateControl const in_control, Time const time_limit=-1.) const;
410 
411  /* Smoothly moves the camera from the current position to the one specified by the user.
412  \param in_camera_kit a camera kit describing the destination camera
413  \param in_duration the duration of the animation, specified in seconds. Defaults to 0.5 seconds. */
414  void SmoothTransition(CameraKit const & in_camera_kit, Time in_duration = 0.5);
415 
416  static UTF8 GetHideStyleName();
417  static UTF8 GetShowStyleName();
418 
420  KeyArray const GetNavigationKeys();
421 
423  LayoutArray GetOwningLayouts();
424  LayoutArray const GetOwningLayouts() const;
425 };
426 
430 class SPRK_API Model : public Sprocket
431 {
432 public:
433  Model();
434  Model(Model const & that);
435  ~Model();
436 
437  Type ObjectType() const { return Type::Model; }
438 
440  void Delete();
441 
442  Model & operator=(Model const & in_that);
443  void Assign(Model const & in_that);
444 
445  bool Equals(Model const & in_that) const;
446  bool operator!= (Model const & in_that) const;
447  bool operator== (Model const & in_that) const;
448 
450  UTF8 GetName() const;
451 
454  SegmentKey GetSegmentKey();
455  SegmentKey const GetSegmentKey() const;
456 
458  SegmentKey GetLibraryKey();
459  SegmentKey const GetLibraryKey() const;
460 
462  PortfolioKey GetPortfolioKey();
463  PortfolioKey const GetPortfolioKey() const;
464 
466  Vector GetUpVector();
467  Vector const GetUpVector() const;
468 
470  Vector GetFrontVector();
471  Vector const GetFrontVector() const;
472 
474  ViewArray GetOwningViews();
475  ViewArray const GetOwningViews() const;
476 
480  void SetOrientation(Vector & in_up_vector, Vector & in_front_vector);
481 
483  bool ShowOrientation(Vector & out_up_vector, Vector & out_front_vector);
484 
486  void Update(Sprocket::UpdateType in_update_type = Sprocket::UpdateType::Asynchronous) const;
487 
491  void Update(Window::UpdateControl const in_control, Time const time_limit=-1.) const;
492 };
493 
497 class SPRK_API Layout : public Sprocket
498 {
499 public:
500  Layout();
501  Layout(Layout const & that);
502  ~Layout();
503 
504  Type ObjectType() const { return Type::Layout; }
505 
507  void Delete();
508 
509  Layout & operator=(Layout const & in_that);
510  void Assign(Layout const & in_that);
511 
512  bool Equals(Layout const & in_that) const;
513  bool operator!= (Layout const & in_that) const;
514  bool operator== (Layout const & in_that) const;
515 
517  UTF8 GetName() const;
518 
519  /* Returns the number of Layers currently associated with this Layout */
520  size_t GetLayerCount() const;
521 
525  void AttachViewFront(View const & in_view, Rectangle const & in_position = Rectangle(-1.0f, 1.0f, -1.0f, 1.0f));
529  void AttachViewBack(View const & in_view, Rectangle const & in_position = Rectangle(-1.0f, 1.0f, -1.0f, 1.0f));
530 
533  void DetachLayer(size_t in_layer);
534 
537  void DetachView(View const & in_view); // everywhere it occurs
538 
541  void BringToFront(size_t in_layer);
542 
546  void ReassignLayer(size_t in_layer, View in_view);
547 
551  void RepositionLayer(size_t in_layer, Rectangle const & in_position);
552 
554  View GetFrontView() const;
555 
559  View GetAttachedView(size_t in_layer = 0) const;
560 
564  Rectangle GetPosition(size_t in_layer) const;
565 
567  IncludeKey GetAttachedViewIncludeLink(size_t in_layer) const;
568 
569  /* Returns the position within the layer list of the top layer at a specified position
570  * \param in_point A point in Window coordinates.
571  * \return The position within the layer list of the top layer at position in_point. */
572  size_t GetLayerAt(WindowPoint const & in_point) const;
573 
574  /* Returns whether a layer is present at the specified position.
575  * \param in_point A point in Window coordinates.
576  * \return <span class='code'>true</span> if a layer is present at in_point, <span class='code'>false</span> otherwise. */
577  bool ShowLayerAt(WindowPoint const & in_point) const;
578 
581  SegmentKey GetSegmentKey();
582  SegmentKey const GetSegmentKey() const;
583 
585  CanvasArray GetOwningCanvases();
586  CanvasArray const GetOwningCanvases() const;
587 
589  void Update(Sprocket::UpdateType in_update_type = Sprocket::UpdateType::Asynchronous) const;
590 
594  void Update(Window::UpdateControl const in_control, Time const time_limit=-1.) const;
595 };
596 
597 class SPRK_API CanvasDeletedEvent : public Event
598 {
599 public:
602  {
603  channel = GetClassID();
604  consumable = false;
605  }
606 
607  CanvasDeletedEvent(Canvas const & in_canvas)
608  : Event(), canvas(in_canvas)
609  {
610  channel = GetClassID();
611  consumable = false;
612  }
613 
616  CanvasDeletedEvent(Event const & in_event) : Event(in_event)
617  {
618  if (in_event.GetChannel() == Object::ClassID<CanvasDeletedEvent>())
619  {
620  auto that = static_cast<CanvasDeletedEvent const &>(in_event);
621  canvas = that.canvas;
622  }
623  else
624  throw InvalidSpecificationException("Invalid Event Type to Cast From.");
625  }
626 
628 
631  Event * Clone() const
632  {
633  CanvasDeletedEvent * new_event = new CanvasDeletedEvent(*this);
634  return new_event;
635  }
636 
637  Canvas canvas;
638 };
639 
640 class SPRK_API LayoutDetachedEvent : public Event
641 {
642 public:
645  {
646  channel = GetClassID();
647  consumable = false;
648  }
649 
650  LayoutDetachedEvent(Canvas const & in_canvas, Layout const & in_layout)
651  : Event(), canvas(in_canvas), layout(in_layout)
652  {
653  channel = GetClassID();
654  consumable = false;
655  }
656 
659  LayoutDetachedEvent(Event const & in_event) : Event(in_event)
660  {
661  if (in_event.GetChannel() == Object::ClassID<LayoutDetachedEvent>())
662  {
663  auto that = static_cast<LayoutDetachedEvent const &>(in_event);
664  canvas = that.canvas;
665  layout = that.layout;
666  }
667  else
668  throw InvalidSpecificationException("Invalid Event Type to Cast From.");
669  }
670 
672 
675  Event * Clone() const
676  {
677  LayoutDetachedEvent * new_event = new LayoutDetachedEvent(*this);
678  return new_event;
679  }
680 
681  Canvas canvas;
682  Layout layout;
683 };
684 
685 class SPRK_API LayoutDeletedEvent : public Event
686 {
687 public:
690  {
691  channel = GetClassID();
692  consumable = false;
693  }
694 
695  LayoutDeletedEvent(Layout const & in_layout)
696  : Event(), layout(in_layout)
697  {
698  channel = GetClassID();
699  consumable = false;
700  }
701 
704  LayoutDeletedEvent(Event const & in_event) : Event(in_event)
705  {
706  if (in_event.GetChannel() == Object::ClassID<LayoutDeletedEvent>())
707  {
708  auto that = static_cast<LayoutDeletedEvent const &>(in_event);
709  layout = that.layout;
710  }
711  else
712  throw InvalidSpecificationException("Invalid Event Type to Cast From.");
713  }
714 
716 
719  Event * Clone() const
720  {
721  LayoutDeletedEvent * new_event = new LayoutDeletedEvent(*this);
722  return new_event;
723  }
724 
725  Layout layout;
726 };
727 
728 class SPRK_API ViewDetachedEvent : public Event
729 {
730 public:
731  enum class Action
732  {
733  None = 0,
734  SpecificLayer,
735  AllLayers,
736  };
737 
739  ViewDetachedEvent() : Event(), action(Action::None), layer(0)
740  {
741  channel = GetClassID();
742  consumable = false;
743  }
744 
745  ViewDetachedEvent(Layout const & in_layout, size_t in_layer, View const & in_view)
746  : Event(), layout(in_layout), action(Action::SpecificLayer), layer(in_layer), view(in_view)
747  {
748  channel = GetClassID();
749  consumable = false;
750  }
751 
752  ViewDetachedEvent(Layout const & in_layout, View const & in_view)
753  : Event(), layout(in_layout), action(Action::AllLayers), layer(std::numeric_limits<size_t>::max()), view(in_view)
754  {
755  channel = GetClassID();
756  consumable = false;
757  }
758 
761  ViewDetachedEvent(Event const & in_event) : Event(in_event)
762  {
763  if (in_event.GetChannel() == Object::ClassID<ViewDetachedEvent>())
764  {
765  auto that = static_cast<ViewDetachedEvent const &>(in_event);
766  layout = that.layout;
767  action = that.action;
768  layer = that.layer;
769  view = that.view;
770  }
771  else
772  throw InvalidSpecificationException("Invalid Event Type to Cast From.");
773  }
774 
776 
779  Event * Clone() const
780  {
781  ViewDetachedEvent * new_event = new ViewDetachedEvent(*this);
782  return new_event;
783  }
784 
785  Layout layout;
786  Action action;
787  size_t layer;
788  View view;
789 };
790 
791 class SPRK_API ViewDeletedEvent : public Event
792 {
793 public:
796  {
797  channel = GetClassID();
798  consumable = false;
799  }
800 
801  ViewDeletedEvent(View const & in_view)
802  : Event(), view(in_view)
803  {
804  channel = GetClassID();
805  consumable = false;
806  }
807 
810  ViewDeletedEvent(Event const & in_event) : Event(in_event)
811  {
812  if (in_event.GetChannel() == Object::ClassID<ViewDeletedEvent>())
813  {
814  auto that = static_cast<ViewDeletedEvent const &>(in_event);
815  view = that.view;
816  }
817  else
818  throw InvalidSpecificationException("Invalid Event Type to Cast From.");
819  }
820 
821  ~ViewDeletedEvent();
822 
825  Event * Clone() const
826  {
827  ViewDeletedEvent * new_event = new ViewDeletedEvent(*this);
828  return new_event;
829  }
830 
831  View view;
832 };
833 
834 class SPRK_API ModelDetachedEvent : public Event
835 {
836 public:
839  {
840  channel = GetClassID();
841  consumable = false;
842  }
843 
844  ModelDetachedEvent(View const & in_view, Model const & in_model)
845  : Event(), view(in_view), model(in_model)
846  {
847  channel = GetClassID();
848  consumable = false;
849  }
850 
853  ModelDetachedEvent(Event const & in_event) : Event(in_event)
854  {
855  if (in_event.GetChannel() == Object::ClassID<ModelDetachedEvent>())
856  {
857  auto that = static_cast<ModelDetachedEvent const &>(in_event);
858  view = that.view;
859  model = that.model;
860  }
861  else
862  throw InvalidSpecificationException("Invalid Event Type to Cast From.");
863  }
864 
866 
869  Event * Clone() const
870  {
871  ModelDetachedEvent * new_event = new ModelDetachedEvent(*this);
872  return new_event;
873  }
874 
875  View view;
876  Model model;
877 };
878 
879 class SPRK_API ModelDeletedEvent : public Event
880 {
881 public:
884  {
885  channel = GetClassID();
886  consumable = false;
887  }
888 
889  ModelDeletedEvent(Model const & in_model)
890  : Event(), model(in_model)
891  {
892  channel = GetClassID();
893  consumable = false;
894  }
895 
898  ModelDeletedEvent(Event const & in_event) : Event(in_event)
899  {
900  if (in_event.GetChannel() == Object::ClassID<ModelDeletedEvent>())
901  {
902  auto that = static_cast<ModelDeletedEvent const &>(in_event);
903  model = that.model;
904  }
905  else
906  throw InvalidSpecificationException("Invalid Event Type to Cast From.");
907  }
908 
910 
913  Event * Clone() const
914  {
915  ModelDeletedEvent * new_event = new ModelDeletedEvent(*this);
916  return new_event;
917  }
918 
919  Model model;
920 };
921 
922 /* The SprocketPath class is a utility class which can be used to automatically obtain a KeyPath
923  * from the Model to the Canvas. */
924 class SPRK_API SprocketPath : public Sprocket
925 {
926 public:
927  SprocketPath();
928  SprocketPath(Model const & in_model, View const & in_view, Layout const & in_layout, Canvas const & in_canvas);
929  SprocketPath(Canvas const & in_canvas, Layout const & in_layout, View const & in_view, Model const & in_model);
930  SprocketPath(Canvas const & in_canvas, size_t in_layer = 0);
931  SprocketPath(SprocketPath const & that);
932  ~SprocketPath();
933 
934  Type ObjectType() const { return Type::SprocketPath; }
935 
936  SprocketPath & operator=(SprocketPath const & in_that);
937  void Set(SprocketPath const & in_that);
938 
939  bool Equals(SprocketPath const & in_that) const;
940  bool operator!= (SprocketPath const & in_that) const;
941  bool operator== (SprocketPath const & in_that) const;
942 
944  Canvas GetCanvas() const;
945 
947  Layout GetLayout() const;
948 
950  View GetView() const;
951 
953  Model GetModel() const;
954 
959  KeyPath GetKeyPath() const;
960 };
961 
962 
965 class SPRK_API Operator : public Sprocket
966 {
967 public:
968  Operator(MouseButtons in_mouse_trigger = MouseButtons::ButtonLeft(), ModifierKeys in_modifier_trigger = ModifierKeys());
969  Operator(Operator const & in_that);
970 
971  virtual ~Operator();
972 
973  Type ObjectType() const { return Type::Operator; }
974 
975  virtual Operator & operator= (Operator const & in_that);
976 
977  /* Assigns the parameter in_that to this operator, resulting in a clone. */
978  virtual void Assign(Operator const & in_that);
979 
980  /* Tests this operator for equality against the parameter <span class=code>in_that</span>. Same as Operator::operator== */
981  virtual bool Equals(Operator const & in_that) const;
982 
983  /* Tests this operator for non-equality against the parameter <span class=code>in_that</span>. */
984  virtual bool operator!= (Operator const & in_that) const;
985 
986  /* Tests this operator for equality against the parameter <span class=code>in_that</span>. Same as Operator::Equals. */
987  virtual bool operator== (Operator const & in_that) const;
988 
990  void DetachView();
991 
993  View GetAttachedView() const;
994 
996  virtual UTF8 GetName() const { return "Operator"; }
997 
1001  virtual bool OnMouseDown(MouseState const & in_state) { HPS_UNREFERENCED(in_state); return false; }
1002 
1006  virtual bool OnMouseUp(MouseState const & in_state) { HPS_UNREFERENCED(in_state); return false; }
1007 
1011  virtual bool OnMouseMove(MouseState const & in_state) { HPS_UNREFERENCED(in_state); return false; }
1012 
1016  virtual bool OnMouseWheel(MouseState const & in_state) { HPS_UNREFERENCED(in_state); return false; }
1017 
1021  virtual bool OnMouseEnter(MouseState const & in_state) { HPS_UNREFERENCED(in_state); return false; }
1022 
1026  virtual bool OnMouseLeave(MouseState const & in_state) { HPS_UNREFERENCED(in_state); return false; }
1027 
1031  virtual bool OnTouchDown(TouchState const & in_state) { HPS_UNREFERENCED(in_state); return false; }
1032 
1036  virtual bool OnTouchUp(TouchState const & in_state) { HPS_UNREFERENCED(in_state); return false; }
1037 
1041  virtual bool OnTouchMove(TouchState const & in_state) { HPS_UNREFERENCED(in_state); return false; }
1042 
1046  virtual bool OnKeyDown(KeyboardState const & in_state) { HPS_UNREFERENCED(in_state); return false; }
1047 
1051  virtual bool OnKeyUp(KeyboardState const & in_state) { HPS_UNREFERENCED(in_state); return false; }
1052 
1056  virtual bool OnTimerTick(TimerTickEvent const & in_event) { HPS_UNREFERENCED(in_event); return false; }
1057 
1059  virtual void OnViewAttached() { return; }
1060 
1062  virtual void OnViewDetached() { return; }
1063 
1066  virtual void OnModelAttached() { return; }
1067 
1070  virtual void OnModelDetached() { return; }
1071 
1073  void SetMouseTrigger(MouseButtons in_buttons) { mouse_trigger = in_buttons; }
1074 
1077  MouseButtons GetMouseTrigger() const { return mouse_trigger; }
1078 
1082  void SetModifierTrigger(ModifierKeys in_modifiers) { modifier_trigger = in_modifiers; }
1083 
1085  ModifierKeys GetModifierTrigger() const { return modifier_trigger; }
1086 
1088  virtual bool IsMouseTriggered(MouseState const & in_state) { return (in_state.GetButtons().HasAll(mouse_trigger) && in_state.GetModifierKeys().HasAll(modifier_trigger)); }
1089 
1090  enum class Priority
1091  {
1092  Low,
1093  Normal,
1094  High
1095  };
1096 
1097 protected:
1098 
1099  MouseButtons mouse_trigger;
1100  ModifierKeys modifier_trigger;
1101 };
1102 
1105 class SPRK_API OperatorControl : public SprocketControl
1106 {
1107 public:
1109  explicit OperatorControl(View const & in_view);
1110 
1112  OperatorControl(OperatorControl const & in_that);
1113 
1117  OperatorControl(OperatorControl && in_that);
1118 
1122  OperatorControl & operator=(OperatorControl && in_that);
1123 
1125  ~OperatorControl();
1126 
1127  Type ObjectType() const {return Type::OperatorControl;};
1128 
1130  OperatorControl & operator=(OperatorControl const & in_that);
1131 
1132 
1134  size_t GetCount();
1135 
1138  size_t GetCount(Operator::Priority in_priority);
1139 
1140 
1146  OperatorControl & Push(OperatorPtr const & in_operator, Operator::Priority in_priority = Operator::Priority::Normal);
1147 
1153  OperatorControl & Push(Operator * in_operator, Operator::Priority in_priority = Operator::Priority::Normal);
1154 
1158  bool Pop(Operator::Priority in_priority = Operator::Priority::Normal);
1159 
1164  bool Pop(OperatorPtr & out_operator);
1165 
1171  bool Pop(Operator::Priority in_priority, OperatorPtr & out_operator);
1172 
1173 
1179  OperatorControl & Set(OperatorPtr const & in_operator, Operator::Priority in_priority = Operator::Priority::Normal);
1180 
1186  OperatorControl & Set(Operator * in_operator, Operator::Priority in_priority = Operator::Priority::Normal);
1187 
1193  OperatorControl & Set(OperatorPtrArray & in_operators, Operator::Priority in_priority = Operator::Priority::Normal);
1194 
1201  OperatorControl & Set(size_t in_count, OperatorPtr in_operators [], Operator::Priority in_priority = Operator::Priority::Normal);
1202 
1203 
1207  OperatorControl & UnsetTop(Operator::Priority in_priority = Operator::Priority::Normal);
1208 
1212  OperatorControl & UnsetEverything(Operator::Priority in_priority);
1213 
1216  OperatorControl & UnsetEverything();
1217 
1218 
1222  bool ShowTop(OperatorPtr & out_operator) const;
1223 
1228  bool ShowTop(Operator::Priority in_priority, OperatorPtr & out_operator) const;
1229 
1233  bool Show(OperatorPtrArray & out_operators) const;
1234 
1239  bool Show(Operator::Priority in_priority, OperatorPtrArray & out_operators) const;
1240 
1241 private:
1243  OperatorControl() {}
1244 };
1245 
1249 {
1250 public:
1251 
1252  enum class Location
1253  {
1254  TopRight,
1255  TopLeft,
1256  BottomRight,
1257  BottomLeft
1258  };
1259 
1261  explicit NavigationCubeControl(View const & in_view);
1262 
1265 
1270 
1274  NavigationCubeControl & operator=(NavigationCubeControl && in_that);
1275 
1278 
1279  Type ObjectType() const {return Type::NavigationCubeControl;};
1280 
1282  NavigationCubeControl & operator=(NavigationCubeControl const & in_that);
1283 
1288  NavigationCubeControl & SetLocation(Location in_location);
1289 
1292  Location GetLocation() const;
1293 
1298  NavigationCubeControl & SetVisibility(bool in_visibility);
1299 
1302  bool GetVisibility();
1303 
1307  NavigationCubeControl & SetTextVisibility(bool in_text_visibility);
1308 
1311  bool GetTextVisibility();
1312 
1327  NavigationCubeControl & SetMaterialPalette(const char * in_material_palette);
1328 
1331  UTF8 GetMaterialPalette();
1332 
1340  NavigationCubeControl & SetInteractivity(bool in_interactivity);
1341 
1344  bool GetInteractivity();
1345 
1348  SegmentKey GetSegmentKey();
1349 
1350 private:
1353 
1355  SegmentKey GetNavigationCubeSegment() const;
1356 };
1357 
1360 class SPRK_API AxisTriadControl : public SprocketControl
1361 {
1362 public:
1363 
1364  enum class Location
1365  {
1366  TopRight,
1367  TopLeft,
1368  BottomRight,
1369  BottomLeft
1370  };
1371 
1373  explicit AxisTriadControl(View const & in_view);
1374 
1376  AxisTriadControl(AxisTriadControl const & in_that);
1377 
1381  AxisTriadControl(AxisTriadControl && in_that);
1382 
1386  AxisTriadControl & operator=(AxisTriadControl && in_that);
1387 
1389  ~AxisTriadControl();
1390 
1391  Type ObjectType() const {return Type::AxisTriadControl;};
1392 
1394  AxisTriadControl & operator=(AxisTriadControl const & in_that);
1395 
1400  AxisTriadControl & SetLocation(Location in_location);
1401 
1404  Location GetLocation() const;
1405 
1410  AxisTriadControl & SetVisibility(bool in_visibility);
1411 
1414  bool GetVisibility();
1415 
1419  AxisTriadControl & SetTextVisibility(bool in_text_visibility);
1420 
1423  bool GetTextVisibility();
1424 
1433  AxisTriadControl & SetMaterialPalette(const char * in_material_palette);
1434 
1437  UTF8 GetMaterialPalette();
1438 
1445  AxisTriadControl & SetInteractivity(bool in_interactivity);
1446 
1449  bool GetInteractivity();
1450 
1453  SegmentKey GetSegmentKey();
1454 
1455 private:
1457  AxisTriadControl(){};
1458 
1460  SegmentKey GetAxisTriadSegment() const;
1461 };
1462 
1464 class SPRK_API Component : public Sprocket
1465 {
1466 public:
1469  enum class ComponentType : uint32_t
1470  {
1471  None = 0x00000000,
1472  GenericMask = 0xfffff000,
1473 
1474  ExchangeComponentMask = 0x00001000,
1475  ExchangeModelFile = 0x00001001,
1476  ExchangeProductOccurrence = 0x00001002,
1477  ExchangePartDefinition = 0x00001003,
1478 
1479  ExchangeView = 0x00001004,
1480  ExchangeFilter = 0x00001005,
1481 
1482  ExchangeRepresentationItemMask = 0x00003000,
1483  ExchangeRIBRepModel = 0x00003001,
1484  ExchangeRICurve = 0x00003002,
1485  ExchangeRIDirection = 0x00003003,
1486  ExchangeRIPlane = 0x00003004,
1487  ExchangeRIPointSet = 0x00003005,
1488  ExchangeRIPolyBRepModel = 0x00003006,
1489  ExchangeRIPolyWire = 0x00003007,
1490  ExchangeRISet = 0x00003008,
1491  ExchangeRICoordinateSystem = 0x00003009,
1492 
1493  ExchangeTopologyMask = 0x00005000,
1494  ExchangeTopoBody = 0x00005001,
1495  ExchangeTopoConnex = 0x00005002,
1496  ExchangeTopoShell = 0x00005003,
1497  ExchangeTopoFace = 0x00005004,
1498  ExchangeTopoLoop = 0x00005005,
1499  ExchangeTopoCoEdge = 0x00005006,
1500  ExchangeTopoEdge = 0x00005007,
1501  ExchangeTopoVertex = 0x00005008,
1502  ExchangeTopoSingleWireBody = 0x00005009,
1503  ExchangeTopoWireEdge = 0x0000500a,
1504 
1505  ExchangeDrawingMask = 0x00006000,
1506  ExchangeDrawingModel = 0x00006001,
1507  ExchangeDrawingView = 0x00006002,
1508  ExchangeDrawingSheet = 0x00006003,
1509  ExchangeBasicDrawingBlock = 0x00006004,
1510  ExchangeOperatorDrawingBlock = 0x00006005,
1511 
1512  ExchangePMIMask = 0x00009000,
1513  ExchangePMI = ExchangePMIMask,
1514  ExchangePMIText = 0x00009100,
1515  ExchangePMIRichText = 0x00009200,
1516  ExchangePMIRoughness = 0x00009300,
1517  ExchangePMIGDT = 0x00009400,
1518  ExchangePMIDatum = 0x00009500,
1519  ExchangePMILineWelding = 0x00009600,
1520  ExchangePMISpotWelding = 0x00009700,
1521  ExchangePMIDimension = 0x00009800,
1522  ExchangePMIBalloon = 0x00009900,
1523  ExchangePMICoordinate = 0x00009a00,
1524  ExchangePMIFastener = 0x00009b00,
1525  ExchangePMILocator = 0x00009c00,
1526  ExchangePMIMeasurementPoint = 0x00009d00,
1527 
1528 
1529  ParasolidComponentMask = 0x00010000,
1530 
1531  ParasolidModelFile = 0x00010001,
1532  ParasolidAssembly = 0x00010002,
1533 
1534  ParasolidTopologyMask = 0x00050000,
1535  ParasolidTopoBody = 0x00050001,
1536  ParasolidTopoRegion = 0x00050002,
1537  ParasolidTopoShell = 0x00050003,
1538  ParasolidTopoFace = 0x00050004,
1539  ParasolidTopoLoop = 0x00050005,
1540  ParasolidTopoFin = 0x00050006,
1541  ParasolidTopoEdge = 0x00050007,
1542  ParasolidTopoVertex = 0x00050008,
1543  };
1544 
1545 
1547  Component();
1548 
1551  Component(Component const & in_that);
1552 
1555  Component(Component && in_that);
1556 
1558  virtual ~Component();
1559 
1560  Type ObjectType() const { return Type::Component; }
1561 
1562 
1566  Component & operator=(Component const & in_that);
1567 
1571  Component & operator=(Component && in_that);
1572 
1576  virtual void Assign(Component const & in_that);
1577 
1581  bool Equals(Component const & in_that) const;
1582 
1586  bool operator!=(Component const & in_that) const;
1587 
1591  bool operator==(Component const & in_that) const;
1592 
1593 
1596  ComponentType GetComponentType() const;
1597 
1601  bool HasComponentType(ComponentType in_mask) const;
1602 
1603 
1604 
1610  void AddKey(Key const & in_key);
1611 
1614  KeyArray GetKeys() const;
1615 
1616 
1617 
1622  void AddOwner(Component & in_owner, IncludeKey const & in_include = IncludeKey());
1623 
1627  ComponentArray GetOwners() const;
1628 
1631  ComponentArray GetSubcomponents() const;
1632 
1637  ComponentArray GetAllSubcomponents(ComponentType in_type) const;
1638 
1639 
1640 
1643  void AddReference(Component & in_reference);
1644 
1647  ComponentArray GetReferrers() const;
1648 
1652  ComponentArray GetReferences() const;
1653 
1654 
1655 
1658  MetadataArray GetAllMetadata() const;
1659 
1663  Metadata GetMetadata(char const * in_name) const;
1664 
1665 
1666 
1669  void Delete();
1670 
1671 
1679  static KeyPathArray GetKeyPath(Component const & in_component);
1680 
1690  static KeyPathArray GetKeyPath(size_t in_count, Component const in_components[]);
1691 
1700  static KeyPathArray GetKeyPath(ComponentArray const & in_components);
1701 };
1702 
1705 class SPRK_API ComponentPath : public Sprocket
1706 {
1707 public:
1709  ComponentPath();
1710 
1713  ComponentPath(ComponentArray const & in_components);
1714 
1718  ComponentPath(size_t in_count, Component const in_components[]);
1719 
1721  ComponentPath(ComponentPath const & in_that);
1722 
1726  ComponentPath(ComponentPath && in_that);
1727 
1731  ComponentPath & operator=(ComponentPath && in_that);
1732 
1734  virtual ~ComponentPath();
1735 
1736  Type ObjectType() const { return Type::ComponentPath; }
1737 
1741  ComponentPath & operator+=(Component const & in_component);
1742 
1746  ComponentPath & operator+=(ComponentPath const & in_path);
1747 
1751  ComponentPath & operator+=(ComponentArray const & in_components);
1752 
1756  ComponentPath & Append(Component const & in_component);
1757 
1761  ComponentPath & Append(ComponentPath const & in_path);
1762 
1766  ComponentPath & Append(ComponentArray const & in_components);
1767 
1771  ComponentPath & operator=(ComponentPath const & in_that);
1772 
1776  ComponentPath & operator=(ComponentArray const & in_path);
1777 
1780  void Set(ComponentPath const & in_that);
1781 
1785  bool Equals(ComponentPath const & in_that) const;
1786 
1790  bool operator!= (ComponentPath const & in_that) const;
1791 
1795  bool operator== (ComponentPath const & in_that) const;
1796 
1797 
1801  ComponentPath & SetComponents(ComponentArray const & in_components);
1802 
1807  ComponentPath & SetComponents(size_t in_count, Component const in_components[]);
1808 
1811  ComponentArray GetComponents() const;
1812 
1816  KeyPathArray GetKeyPaths() const;
1817 
1822  KeyPathArray GetKeyPaths(Canvas const & in_canvas, size_t in_layer = 0) const;
1823 
1824 
1828  void Highlight(Canvas const & in_canvas, HighlightOptionsKit const & in_options) const;
1829 
1834  void Highlight(Canvas const & in_canvas, size_t in_layer, HighlightOptionsKit const & in_options) const;
1835 
1839  void Unhighlight(Canvas const & in_canvas, HighlightOptionsKit const & in_options) const;
1840 
1845  void Unhighlight(Canvas const & in_canvas, size_t in_layer, HighlightOptionsKit const & in_options) const;
1846 
1847 
1851  void Hide(Canvas const & in_canvas, size_t in_layer = 0);
1852 
1856  void Show(Canvas const & in_canvas, size_t in_layer = 0);
1857 
1861  void Isolate(Canvas const & in_canvas, size_t in_layer = 0);
1862 
1863  static void Isolate(ComponentPathArray & in_components_to_be_isolated, Canvas const & in_canvas, size_t in_layer = 0);
1864 };
1865 
1866 
1871 inline ComponentPath operator+(Component const & in_lhs, Component const & in_rhs)
1872 {
1873  return ComponentPath().Append(in_lhs).Append(in_rhs);
1874 }
1875 
1880 inline ComponentPath operator+(Component const & in_lhs, ComponentArray const & in_rhs)
1881 {
1882  return ComponentPath().Append(in_lhs).Append(in_rhs);
1883 }
1884 
1889 inline ComponentPath operator+(Component const & in_lhs, ComponentPath const & in_rhs)
1890 {
1891  return ComponentPath().Append(in_lhs).Append(in_rhs);
1892 }
1893 
1898 inline ComponentPath operator+(ComponentArray const & in_lhs, Component const & in_rhs)
1899 {
1900  return ComponentPath().Append(in_lhs).Append(in_rhs);
1901 }
1902 
1907 inline ComponentPath operator+(ComponentArray const & in_lhs, ComponentArray const & in_rhs)
1908 {
1909  return ComponentPath().Append(in_lhs).Append(in_rhs);
1910 }
1911 
1916 inline ComponentPath operator+(ComponentArray const & in_lhs, ComponentPath const & in_rhs)
1917 {
1918  return ComponentPath().Append(in_lhs).Append(in_rhs);
1919 }
1920 
1925 inline ComponentPath operator+(ComponentPath const & in_lhs, Component const & in_rhs)
1926 {
1927  return ComponentPath().Append(in_lhs).Append(in_rhs);
1928 }
1929 
1934 inline ComponentPath operator+(ComponentPath const & in_lhs, ComponentArray const & in_rhs)
1935 {
1936  return ComponentPath().Append(in_lhs).Append(in_rhs);
1937 }
1938 
1943 inline ComponentPath operator+(ComponentPath const & in_lhs, ComponentPath const & in_rhs)
1944 {
1945  return ComponentPath().Append(in_lhs).Append(in_rhs);
1946 }
1947 
1948 
1950 class SPRK_API ComponentHighlightEvent : public Event
1951 {
1952 public:
1953  enum class Action
1954  {
1955  None = 0,
1956  Highlight,
1957  Unhighlight,
1958  };
1959 
1962  {
1963  channel = GetClassID();
1964  consumable = false;
1965  action = Action::None;
1966  }
1967 
1968  ComponentHighlightEvent(Action in_action,
1969  ComponentPath const & in_path = ComponentPath(),
1970  HighlightOptionsKit const & in_options = HighlightOptionsKit())
1971  : Event(), action(in_action), path(in_path), options(in_options)
1972  {
1973  channel = GetClassID();
1974  consumable = false;
1975  }
1976 
1979  ComponentHighlightEvent(Event const & in_event) : Event(in_event)
1980  {
1981  if (in_event.GetChannel() == Object::ClassID<ComponentHighlightEvent>())
1982  {
1983  auto that = static_cast<ComponentHighlightEvent const &>(in_event);
1984  action = that.action;
1985  path = that.path;
1986  options = that.options;
1987  }
1988  else
1989  throw InvalidSpecificationException("Invalid Event Type to Cast From.");
1990  }
1991 
1993 
1996  Event * Clone() const
1997  {
1998  ComponentHighlightEvent * new_event = new ComponentHighlightEvent(*this);
1999  return new_event;
2000  }
2001 
2002  Action action;
2003  ComponentPath path;
2004  HighlightOptionsKit options;
2005 };
2006 
2007 
2009 class SPRK_API Filter : public Component
2010 {
2011 public:
2013  Filter();
2014 
2018  Filter(Component const & in_that);
2019 
2022  Filter(Filter const & in_that);
2023 
2026  Filter(Filter && in_that);
2027 
2028  virtual ~Filter();
2029 
2030  Type ObjectType() const { return Type::Filter; }
2031 
2032 #ifndef _MSC_VER
2033  Filter & operator=(Filter const & in_that) = default;
2034 #endif
2035 
2039  Filter & operator=(Filter && in_that);
2040 
2041 
2044  void Activate(View const & in_view);
2045 
2048  void Deactivate(View const & in_view);
2049 };
2050 
2051 
2052 class SPRK_API FilterActivationEvent : public Event
2053 {
2054 public:
2055  enum class Action
2056  {
2057  None = 0,
2058  Activate,
2059  Deactivate,
2060  };
2061 
2064  {
2065  channel = GetClassID();
2066  consumable = false;
2067  }
2068 
2069  FilterActivationEvent(Filter in_filter, Action in_action, View in_view) : Event(), filter(in_filter), action(in_action), view(in_view)
2070  {
2071  channel = GetClassID();
2072  consumable = false;
2073  }
2074 
2077  FilterActivationEvent(Event const & in_event) : Event(in_event)
2078  {
2079  if (in_event.GetChannel() == Object::ClassID<FilterActivationEvent>())
2080  {
2081  auto that = static_cast<FilterActivationEvent const &>(in_event);
2082  filter = that.filter;
2083  action = that.action;
2084  view = that.view;
2085  }
2086  else
2087  throw InvalidSpecificationException("Invalid Event Type to Cast From.");
2088  }
2089 
2091 
2094  Event * Clone() const
2095  {
2096  FilterActivationEvent * new_event = new FilterActivationEvent(*this);
2097  return new_event;
2098  }
2099 
2100  Filter filter;
2101  Action action;
2102  View view;
2103 };
2104 
2105 
2107 class SPRK_API Capture : public Component
2108 {
2109 public:
2111  Capture();
2112 
2116  Capture(Component const & in_that);
2117 
2120  Capture(Capture const & in_that);
2121 
2124  Capture(Capture && in_that);
2125 
2126  virtual ~Capture();
2127 
2128  Type ObjectType() const { return Type::Capture; }
2129 
2130 #ifndef _MSC_VER
2131  Capture & operator=(Capture const & in_that) = default;
2132 #endif
2133 
2137  Capture & operator=(Capture && in_that);
2138 
2139 
2143  View Activate();
2144 };
2145 
2146 
2147 class SPRK_API CaptureActivationEvent : public Event
2148 {
2149 public:
2152  {
2153  channel = GetClassID();
2154  consumable = false;
2155  }
2156 
2157  CaptureActivationEvent(Capture in_capture, View in_view) : Event(), capture(in_capture), view(in_view)
2158  {
2159  channel = GetClassID();
2160  consumable = false;
2161  }
2162 
2165  CaptureActivationEvent(Event const & in_event) : Event(in_event)
2166  {
2167  if (in_event.GetChannel() == Object::ClassID<CaptureActivationEvent>())
2168  {
2169  auto that = static_cast<CaptureActivationEvent const &>(in_event);
2170  capture = that.capture;
2171  view = that.view;
2172  }
2173  else
2174  throw InvalidSpecificationException("Invalid Event Type to Cast From.");
2175  }
2176 
2178 
2181  Event * Clone() const
2182  {
2183  CaptureActivationEvent * new_event = new CaptureActivationEvent(*this);
2184  return new_event;
2185  }
2186 
2187  Capture capture;
2188  View view;
2189 };
2190 
2191 
2193 class SPRK_API CADModel : public Component
2194 {
2195 public:
2197  CADModel();
2198 
2202  CADModel(Component const & in_that);
2203 
2206  CADModel(CADModel const & in_that);
2207 
2210  CADModel(CADModel && in_that);
2211 
2214  CADModel(Model const & in_that);
2215 
2216  virtual ~CADModel();
2217 
2218  Type ObjectType() const { return Type::CADModel; }
2219 
2220 #ifndef _MSC_VER
2221  CADModel & operator=(CADModel const & in_that) = default;
2222 #endif
2223 
2227  CADModel & operator=(CADModel && in_that);
2228 
2229 
2233  Component GetComponentFromKey(Key const & in_key) const;
2234 
2239  ComponentPath GetComponentPath(KeyPath const & in_key_path) const;
2240 
2246  ComponentPath GetComponentPath(SelectionItem const & in_item) const;
2247 
2248 
2251  Model GetModel() const;
2252 
2255  FilterArray GetAllFilters() const;
2256 
2259  CaptureArray GetAllCaptures() const;
2260 
2264  FilterArray GetActiveFilters(View const & in_view) const;
2265 
2266 
2270  View ActivateDefaultCapture();
2271 
2272 
2280  void ResetVisibility(Canvas & in_canvas, size_t in_layer = 0);
2281 };
2282 
2283 
2284 
2287 class SPRK_API Metadata : public Sprocket
2288 {
2289 public:
2291  Metadata();
2292 
2295  Metadata(Metadata const & in_that);
2296 
2299  Metadata(Metadata && in_that);
2300 
2303  Metadata(char const * in_name);
2304 
2305  virtual ~Metadata();
2306 
2307  Type ObjectType() const { return Type::Metadata; }
2308 
2309 
2313  Metadata & operator=(Metadata const & in_that);
2314 
2318  Metadata & operator=(Metadata && in_that);
2319 
2323  virtual void Assign(Metadata const & in_that);
2324 
2328  bool Equals(Metadata const & in_that) const;
2329 
2333  bool operator!=(Metadata const & in_that) const;
2334 
2338  bool operator==(Metadata const & in_that) const;
2339 
2340 
2343  UTF8 GetName() const;
2344 
2347  void SetName(char const * in_name);
2348 };
2349 
2351 class SPRK_API IntegerMetadata : public Metadata
2352 {
2353 public:
2355  IntegerMetadata();
2356 
2360  IntegerMetadata(Metadata const & in_that);
2361 
2364  IntegerMetadata(IntegerMetadata const & in_that);
2365 
2368  IntegerMetadata(IntegerMetadata && in_that);
2369 
2373  IntegerMetadata(char const * in_name, int in_value);
2374 
2375  virtual ~IntegerMetadata();
2376 
2377  Type ObjectType() const { return Type::IntegerMetadata; }
2378 
2379 #ifndef _MSC_VER
2380  IntegerMetadata & operator=(IntegerMetadata const & in_that) = default;
2381 #endif
2382 
2386  IntegerMetadata & operator=(IntegerMetadata && in_that);
2387 
2388 
2391  int GetValue() const;
2392 
2395  void SetValue(int in_value);
2396 };
2397 
2399 class SPRK_API UnsignedIntegerMetadata : public Metadata
2400 {
2401 public:
2404 
2408  UnsignedIntegerMetadata(Metadata const & in_that);
2409 
2413 
2417 
2421  UnsignedIntegerMetadata(char const * in_name, unsigned int in_value);
2422 
2423  virtual ~UnsignedIntegerMetadata();
2424 
2425  Type ObjectType() const { return Type::UnsignedIntegerMetadata; }
2426 
2427 #ifndef _MSC_VER
2428  UnsignedIntegerMetadata & operator=(UnsignedIntegerMetadata const & in_that) = default;
2429 #endif
2430 
2434  UnsignedIntegerMetadata & operator=(UnsignedIntegerMetadata && in_that);
2435 
2436 
2439  unsigned int GetValue() const;
2440 
2443  void SetValue(unsigned int in_value);
2444 };
2445 
2447 class SPRK_API DoubleMetadata : public Metadata
2448 {
2449 public:
2451  DoubleMetadata();
2452 
2456  DoubleMetadata(Metadata const & in_that);
2457 
2460  DoubleMetadata(DoubleMetadata const & in_that);
2461 
2464  DoubleMetadata(DoubleMetadata && in_that);
2465 
2469  DoubleMetadata(char const * in_name, double in_value);
2470 
2471  virtual ~DoubleMetadata();
2472 
2473  Type ObjectType() const { return Type::DoubleMetadata; }
2474 
2475 #ifndef _MSC_VER
2476  DoubleMetadata & operator=(DoubleMetadata const & in_that) = default;
2477 #endif
2478 
2482  DoubleMetadata & operator=(DoubleMetadata && in_that);
2483 
2484 
2487  double GetValue() const;
2488 
2491  void SetValue(double in_value);
2492 };
2493 
2495 class SPRK_API StringMetadata : public Metadata
2496 {
2497 public:
2499  StringMetadata();
2500 
2504  StringMetadata(Metadata const & in_that);
2505 
2508  StringMetadata(StringMetadata const & in_that);
2509 
2512  StringMetadata(StringMetadata && in_that);
2513 
2517  StringMetadata(char const * in_name, char const * in_value);
2518 
2519  virtual ~StringMetadata();
2520 
2521  Type ObjectType() const { return Type::StringMetadata; }
2522 
2523 #ifndef _MSC_VER
2524  StringMetadata & operator=(StringMetadata const & in_that) = default;
2525 #endif
2526 
2530  StringMetadata & operator=(StringMetadata && in_that);
2531 
2532 
2535  UTF8 GetValue() const;
2536 
2539  void SetValue(char const * in_value);
2540 };
2541 
2543 class SPRK_API TimeMetadata : public Metadata
2544 {
2545 public:
2547  TimeMetadata();
2548 
2552  TimeMetadata(Metadata const & in_that);
2553 
2556  TimeMetadata(TimeMetadata const & in_that);
2557 
2560  TimeMetadata(TimeMetadata && in_that);
2561 
2565  TimeMetadata(char const * in_name, unsigned int in_value);
2566 
2567  virtual ~TimeMetadata();
2568 
2569  Type ObjectType() const { return Type::TimeMetadata; }
2570 
2571 #ifndef _MSC_VER
2572  TimeMetadata & operator=(TimeMetadata const & in_that) = default;
2573 #endif
2574 
2578  TimeMetadata & operator=(TimeMetadata && in_that);
2579 
2580 
2583  unsigned int GetValue() const;
2584 
2587  UTF8 GetValueAsString() const;
2588 
2591  void SetValue(unsigned int in_value);
2592 };
2593 
2594 
2596 class SPRK_API BooleanMetadata : public Metadata
2597 {
2598 public:
2600  BooleanMetadata();
2601 
2605  BooleanMetadata(Metadata const & in_that);
2606 
2609  BooleanMetadata(BooleanMetadata const & in_that);
2610 
2613  BooleanMetadata(BooleanMetadata && in_that);
2614 
2618  BooleanMetadata(char const * in_name, bool in_value);
2619 
2620  virtual ~BooleanMetadata();
2621 
2622  Type ObjectType() const { return Type::BooleanMetadata; }
2623 
2624 #ifndef _MSC_VER
2625  BooleanMetadata & operator=(BooleanMetadata const & in_that) = default;
2626 #endif
2627 
2631  BooleanMetadata & operator=(BooleanMetadata && in_that);
2632 
2633 
2636  bool GetValue() const;
2637 
2640  void SetValue(bool in_value);
2641 };
2642 
2643 
2644 
2646 class SPRK_API Factory : public Sprocket
2647 {
2648 public:
2649 
2652  static CanvasArray GetCanvases();
2653 
2656  static LayoutArray GetLayouts();
2657 
2660  static ViewArray GetViews();
2661 
2664  static ModelArray GetModels();
2665 
2668  static CADModelArray GetCADModels();
2669 
2675  static Canvas CreateCanvas(WindowHandle in_window_handle, char const * in_name = "", ApplicationWindowOptionsKit const & in_options = ApplicationWindowOptionsKit());
2676 
2681  static Canvas CreateCanvas(char const * in_name = "", StandAloneWindowOptionsKit const & in_options = StandAloneWindowOptionsKit());
2682 
2688  static Canvas CreateCanvas(WindowKey const & in_window_key, PortfolioKey const & in_portfolio_key = PortfolioKey(), char const * in_name = "");
2689 
2693  static Layout CreateLayout(char const * in_name = "");
2694 
2698  static View CreateView(char const * in_name = "");
2699 
2703  static Model CreateModel(char const * in_name = "");
2704 
2705 private:
2706  Factory() {}
2707 };
2708 
2718 class SPRK_API AxisTriadOperator : public Operator
2719 {
2720 public:
2721  AxisTriadOperator(MouseButtons in_mouse_trigger = MouseButtons::ButtonLeft(), ModifierKeys in_modifier_trigger = ModifierKeys());
2723  virtual UTF8 GetName() const { return "HPS_AxisTriadOperator"; }
2724 
2730  virtual bool OnMouseDown(MouseState const & in_state);
2735  virtual bool OnMouseUp(MouseState const & in_state);
2740  virtual bool OnMouseMove(MouseState const & in_state);
2741 
2746  virtual bool OnTouchDown(TouchState const & in_state);
2751  virtual bool OnTouchUp(TouchState const & in_state);
2756  virtual bool OnTouchMove(TouchState const & in_state);
2757 
2758  virtual void OnViewAttached();
2759  virtual void OnViewDetached();
2760 
2761 private:
2762 
2763  bool AxisOrbit(WindowPoint const & in_loc);
2764  void Transition(SelectionResults selection_results);
2765  void TranslatePoint(WindowPoint * point);
2766  bool IsEventRelevant(WindowPoint const & event_location);
2767 
2768  bool operator_active;
2769  WindowPoint start_point;
2770  Vector start_sphere_point;
2771  float axis_subwindow_width;
2772  float axis_subwindow_height;
2773  TouchID tracked_touch_ID;
2774  Rectangle axis_subwindow;
2775  SegmentKey axis_triad_segment;
2776 
2777 };
2778 
2780 class SPRK_API SmoothTransitionCompleteEvent: public Event
2781 {
2782 public:
2785  virtual ~SmoothTransitionCompleteEvent();
2786 
2789  SmoothTransitionCompleteEvent(View const & in_view) : view(in_view)
2790  { channel = Object::ClassID<SmoothTransitionCompleteEvent>(); }
2791 
2794  Event * Clone() const
2795  {
2797  return new_event;
2798  }
2799 
2803  virtual bool Drop(Event const * in_that_event) const
2804  {
2805  HPS_UNREFERENCED(in_that_event);
2806  return false;
2807  }
2808 
2809  View view;
2810 };
2811 
2821 class SPRK_API NavigationCubeOperator : public Operator
2822 {
2823 public:
2824  NavigationCubeOperator(MouseButtons in_mouse_trigger = MouseButtons::ButtonLeft(), ModifierKeys in_modifier_trigger = ModifierKeys());
2825  ~NavigationCubeOperator() { OnViewDetached(); }
2826 
2828  virtual UTF8 GetName() const { return "HPS_NavigationCubeOperator"; }
2829 
2834  virtual bool OnMouseDown(MouseState const & in_state);
2839  virtual bool OnMouseUp(MouseState const & in_state);
2844  virtual bool OnMouseMove(MouseState const & in_state);
2845 
2849  virtual bool OnTouchDown(TouchState const & in_state);
2854  virtual bool OnTouchUp(TouchState const & in_state);
2859  virtual bool OnTouchMove(TouchState const & in_state);
2860 
2861  virtual void OnViewAttached();
2862  virtual void OnViewDetached();
2863 
2864  virtual void OnModelAttached();
2865 
2866  void UpdateHighlightColor();
2867 
2868  /* Sets a segment as the reference segment. All rotations happen around the reference segment.
2869  By default the reference segment is the View segment.
2870  /param in_segment the segment to rotate around. */
2871  void SetReferenceSegment(SegmentKey const & in_segment);
2872 
2873  /* Sets a group of segments as the reference segments.
2874  * All rotations happen around the combined bounding box of the reference segments.
2875  By default the reference segment is the View segment.
2876  /param in_segments the segments to rotate around. */
2877  void SetReferenceSegment(SegmentKeyArray const & in_segments);
2878 
2879  /* Returns the segments used as a reference for rotations
2880  By default the reference segment is the View segment.
2881  /return the segments to rotate around. */
2882  SegmentKeyArray ShowReferenceSegment();
2883 
2884 private:
2885  void Transition(SelectionResults selection_results);
2886  bool Orbit(WindowPoint const & in_loc);
2887  void TranslatePoint(WindowPoint * point);
2888  bool IsEventRelevant(WindowPoint const & event_location);
2889  bool AreCamerasEqual(CameraKit const & this_camera, CameraKit const & that_camera);
2890 
2891  bool operator_active;
2892  TouchID tracked_touch_ID;
2893  WindowPoint start_point;
2894  WindowPoint down_position;
2895  Vector start_sphere_point;
2896  SegmentKeyArray reference_segments; //rotation and zooming happen around these segments
2897 
2898  SegmentKey nav_cube_segment;
2899  SegmentKey style_segment;
2900  PortfolioKey portfolio;
2901  ReferenceKeyArrayArray groups;
2902  HighlightOptionsKit highlight_options_kit;
2903  CameraKit previous_camera;
2904  int previous_face;
2905 
2906  Rectangle nav_cube_subwindow;
2907  float nav_cube_subwindow_width;
2908  float nav_cube_subwindow_height;
2909 
2910  int highlighted_group;
2911 
2912  bool moving;
2913 
2914  class SmoothTransitionCompleteEventHandler : public EventHandler
2915  {
2916  public:
2917  SmoothTransitionCompleteEventHandler(View const & in_view, bool & in_moving)
2918  : handler_view(in_view), handler_moving(&in_moving) {}
2919 
2920  ~SmoothTransitionCompleteEventHandler() { Shutdown(); }
2921 
2922  virtual HandleResult Handle(Event const * in_event);
2923 
2924  private:
2925  View handler_view;
2926  bool * handler_moving;
2927  };
2928 
2929  SmoothTransitionCompleteEventHandler * handler;
2930 };
2931 
2932 
2933 
2934 
2935 class SceneTreeItem;
2936 typedef std::shared_ptr<SceneTreeItem> SceneTreeItemPtr;
2937 class SceneTree;
2938 typedef std::shared_ptr<SceneTree> SceneTreePtr;
2939 
2942 class SPRK_API SceneTree : public Sprocket
2943 {
2944 public:
2947  enum class ItemType : uint32_t
2948  {
2949  None = 0x00000000,
2950  GenericMask = 0xffff0000,
2951 
2952  Segment = 0x00000001,
2953  Include = 0x00000002,
2954  ConditionalExpression = 0x00000003,
2955  StaticModelSegment = 0x00000004,
2956  AttributeFilter = 0x00000005,
2957 
2958  Geometry = 0x00010000,
2959  CuttingSection = 0x00010001,
2960  Shell = 0x00010002,
2961  Mesh = 0x00010003,
2962  Grid = 0x00010004,
2963  NURBSSurface = 0x00010005,
2964  Cylinder = 0x00010006,
2965  Sphere = 0x00010007,
2966  Polygon = 0x00010008,
2967  Circle = 0x00010009,
2968  CircularWedge = 0x0001000a,
2969  Ellipse = 0x0001000b,
2970  Line = 0x0001000c,
2971  NURBSCurve = 0x0001000d,
2972  CircularArc = 0x0001000e,
2973  EllipticalArc = 0x0001000f,
2974  InfiniteLine = 0x00010010,
2975  InfiniteRay = 0x00010011,
2976  Marker = 0x00010012,
2977  Text = 0x00010013,
2978  Reference = 0x00010014,
2979  DistantLight = 0x00010015,
2980  Spotlight = 0x00010016,
2981 
2982  Attribute = 0x00020000,
2983  Portfolio = 0x00020001,
2984  SegmentStyle = 0x00020002,
2985  NamedStyle = 0x00020003,
2986  MaterialPalette = 0x00020004,
2987  Priority = 0x00020005,
2988  Material = 0x00020006,
2989  Camera = 0x00020007,
2990  ModellingMatrix = 0x00020008,
2991  UserData = 0x00020009,
2992  TextureMatrix = 0x0002000a,
2993  Culling = 0x0002000b,
2994  CurveAttribute = 0x0002000c,
2995  CylinderAttribute = 0x0002000d,
2996  EdgeAttribute = 0x0002000e,
2997  LightingAttribute = 0x0002000f,
2998  LineAttribute = 0x00020010,
2999  MarkerAttribute = 0x00020011,
3000  SurfaceAttribute = 0x00020012,
3001  Selectability = 0x00020013,
3002  SphereAttribute = 0x00020014,
3003  Subwindow = 0x00020015,
3004  TextAttribute = 0x00020016,
3005  Transparency = 0x00020017,
3006  Visibility = 0x00020018,
3007  VisualEffects = 0x00020019,
3008  Performance = 0x00020020,
3009  DrawingAttribute = 0x00020021,
3010  HiddenLineAttribute = 0x00020022,
3011  ContourLine = 0x00020023,
3012  Condition = 0x00020024,
3013  Bounding = 0x00020025,
3014  AttributeLock = 0x00020026,
3015  TransformMask = 0x00020027,
3016  ColorInterpolation = 0x00020028,
3017  CuttingSectionAttribute = 0x00020029,
3018 
3019  // window only attributes
3020  Debugging = 0x00020030,
3021  PostProcessEffects = 0x00020031,
3022  SelectionOptions = 0x00020032,
3023  UpdateOptions = 0x00020033,
3024 
3025  Definition = 0x00040000,
3026  NamedStyleDefinition = 0x00040001,
3027  TextureDefinition = 0x00040002,
3028  LinePatternDefinition = 0x00040003,
3029  GlyphDefinition = 0x00040004,
3030  CubeMapDefinition = 0x00040005,
3031  ImageDefinition = 0x00040006,
3032  MaterialPaletteDefinition = 0x00040007,
3033  ShaderDefinition = 0x00040008,
3034 
3035  Group = 0x00080000,
3036  SegmentGroup = 0x00080100,
3037  GeometryGroup = 0x00080200,
3038  AttributeGroup = 0x00080300,
3039  PortfolioGroup = 0x00080400,
3040  StyleGroup = 0x00080500,
3041  IncludeGroup = 0x00080600,
3042  DefinitionGroup = 0x00180000,
3043  NamedStyleDefinitionGroup = 0x00180700,
3044  TextureDefinitionGroup = 0x00180800,
3045  LinePatternDefinitionGroup = 0x00180900,
3046  GlyphDefinitionGroup = 0x00180a00,
3047  CubeMapDefinitionGroup = 0x00180b00,
3048  ImageDefinitionGroup = 0x00180c00,
3049  MaterialPaletteDefinitionGroup = 0x00180d00,
3050  ShaderDefinitionGroup = 0x00180e00,
3051  CuttingSectionGroup = 0x00080001,
3052  ShellGroup = 0x00080002,
3053  MeshGroup = 0x00080003,
3054  GridGroup = 0x00080004,
3055  NURBSSurfaceGroup = 0x00080005,
3056  CylinderGroup = 0x00080006,
3057  SphereGroup = 0x00080007,
3058  PolygonGroup = 0x00080008,
3059  CircleGroup = 0x00080009,
3060  CircularWedgeGroup = 0x0008000a,
3061  EllipseGroup = 0x0008000b,
3062  LineGroup = 0x0008000c,
3063  NURBSCurveGroup = 0x0008000d,
3064  CircularArcGroup = 0x0008000e,
3065  EllipticalArcGroup = 0x0008000f,
3066  InfiniteLineGroup = 0x00080010,
3067  InfiniteRayGroup = 0x00080011,
3068  MarkerGroup = 0x00080012,
3069  TextGroup = 0x00080013,
3070  ReferenceGroup = 0x00080014,
3071  DistantLightGroup = 0x00080015,
3072  SpotlightGroup = 0x00080016,
3073  };
3074 
3076  SceneTree();
3077 
3080  SceneTree(Canvas const & in_canvas);
3081 
3084  SceneTree(SceneTree const & in_that);
3085 
3088  SceneTree(SceneTree && in_that);
3089 
3090  virtual ~SceneTree();
3091 
3092  virtual Type ObjectType() const { return Type::SceneTree; }
3093 
3097  SceneTree & operator=(SceneTree const & in_that);
3098 
3102  SceneTree & operator=(SceneTree && in_that);
3103 
3107  virtual void Assign(SceneTree const & in_that);
3108 
3112  bool Equals(SceneTree const & in_that) const;
3113 
3117  bool operator!=(SceneTree const & in_that) const;
3118 
3122  bool operator==(SceneTree const & in_that) const;
3123 
3124 
3132  void SetHighlightOptions(HighlightOptionsKit const & in_options);
3133 
3136  HighlightOptionsKit GetHighlightOptions() const;
3137 
3138 
3143  void SetGroupingLimit(size_t in_limit);
3144 
3147  size_t GetGroupingLimit() const;
3148 
3149 
3156  void SetRoot(SceneTreeItemPtr const & in_root);
3157 
3160  SceneTreeItemPtr GetRoot() const;
3161 
3162 
3165  virtual void Flush();
3166 };
3167 
3168 
3171 class SPRK_API SceneTreeItem : public Sprocket
3172 {
3173 public:
3175  SceneTreeItem();
3176 
3179  SceneTreeItem(SceneTreeItem const & in_that);
3180 
3183  SceneTreeItem(SceneTreeItem && in_that);
3184 
3190  SceneTreeItem(SceneTreePtr const & in_tree, Model const & in_model);
3191 
3197  SceneTreeItem(SceneTreePtr const & in_tree, View const & in_view);
3198 
3204  SceneTreeItem(SceneTreePtr const & in_tree, Layout const & in_layout);
3205 
3211  SceneTreeItem(SceneTreePtr const & in_tree, Canvas const & in_canvas);
3212 
3220  SceneTreeItem(SceneTreePtr const & in_tree, Key const & in_key, SceneTree::ItemType in_type, char const * in_title = nullptr);
3221 
3222  virtual ~SceneTreeItem();
3223 
3224  Type ObjectType() const { return Type::SceneTreeItem; }
3225 
3229  SceneTreeItem & operator=(SceneTreeItem const & in_that);
3230 
3234  SceneTreeItem & operator=(SceneTreeItem && in_that);
3235 
3239  virtual void Assign(SceneTreeItem const & in_that);
3240 
3244  bool Equals(SceneTreeItem const & in_that) const;
3245 
3249  bool operator!=(SceneTreeItem const & in_that) const;
3250 
3254  bool operator==(SceneTreeItem const & in_that) const;
3255 
3256 
3259  SceneTreePtr GetTree() const;
3260 
3263  UTF8 GetTitle() const;
3264 
3267  SceneTree::ItemType GetItemType() const;
3268 
3272  bool HasItemType(SceneTree::ItemType in_mask) const;
3273 
3276  Key GetKey() const;
3277 
3280  bool HasChildren() const;
3281 
3282 
3291  virtual SceneTreeItemPtr AddChild(Key const & in_key, SceneTree::ItemType in_type, char const * in_title = nullptr) = 0;
3292 
3293 
3296  virtual void Expand();
3297 
3300  virtual void Collapse();
3301 
3302 
3307  bool IsSelected() const;
3308 
3314  virtual void Select();
3315 
3321  virtual void Unselect();
3322 
3327  bool IsHighlightable() const;
3328 
3334  bool IsHighlighted() const;
3335 
3339  void Highlight();
3340 
3345  void Unhighlight();
3346 };
3347 
3348 
3349 
3350 class ComponentTreeItem;
3351 typedef std::shared_ptr<ComponentTreeItem> ComponentTreeItemPtr;
3352 class ComponentTree;
3353 typedef std::shared_ptr<ComponentTree> ComponentTreePtr;
3354 
3357 class SPRK_API ComponentTree : public Sprocket
3358 {
3359 public:
3362  enum class ItemType
3363  {
3364  None,
3365  ExchangeComponent,
3366  ExchangeModelFile,
3367 
3368  ExchangeViewGroup,
3369  ExchangeAnnotationViewGroup,
3370  ExchangePMIGroup,
3371  ExchangeModelGroup,
3372 
3373  ParasolidComponent,
3374  ParasolidModelFile,
3375  };
3376 
3378  ComponentTree();
3379 
3383  ComponentTree(Canvas const & in_canvas, size_t in_layer = 0);
3384 
3387  ComponentTree(ComponentTree const & in_that);
3388 
3391  ComponentTree(ComponentTree && in_that);
3392 
3393  virtual ~ComponentTree();
3394 
3395  virtual Type ObjectType() const { return Type::ComponentTree; }
3396 
3400  ComponentTree & operator=(ComponentTree const & in_that);
3401 
3405  ComponentTree & operator=(ComponentTree && in_that);
3406 
3410  virtual void Assign(ComponentTree const & in_that);
3411 
3415  bool Equals(ComponentTree const & in_that) const;
3416 
3420  bool operator!=(ComponentTree const & in_that) const;
3421 
3425  bool operator==(ComponentTree const & in_that) const;
3426 
3427 
3435  void SetHighlightOptions(HighlightOptionsKit const & in_options);
3436 
3439  HighlightOptionsKit GetHighlightOptions() const;
3440 
3441 
3448  void SetRoot(ComponentTreeItemPtr const & in_root);
3449 
3452  ComponentTreeItemPtr GetRoot() const;
3453 
3454 
3457  virtual void Flush();
3458 };
3459 
3460 
3463 class SPRK_API ComponentTreeItem : public Sprocket
3464 {
3465 public:
3468 
3471  ComponentTreeItem(ComponentTreeItem const & in_that);
3472 
3476 
3482  ComponentTreeItem(ComponentTreePtr const & in_tree, CADModel const & in_cad_model);
3483 
3490  ComponentTreeItem(ComponentTreePtr const & in_tree, Component const & in_component, ComponentTree::ItemType in_type);
3491 
3492  virtual ~ComponentTreeItem();
3493 
3494  Type ObjectType() const { return Type::ComponentTreeItem; }
3495 
3499  ComponentTreeItem & operator=(ComponentTreeItem const & in_that);
3500 
3504  ComponentTreeItem & operator=(ComponentTreeItem && in_that);
3505 
3509  virtual void Assign(ComponentTreeItem const & in_that);
3510 
3514  bool Equals(ComponentTreeItem const & in_that) const;
3515 
3519  bool operator!=(ComponentTreeItem const & in_that) const;
3520 
3524  bool operator==(ComponentTreeItem const & in_that) const;
3525 
3526 
3527 
3530  ComponentTreePtr GetTree() const;
3531 
3534  UTF8 GetTitle() const;
3535 
3538  ComponentTree::ItemType GetItemType() const;
3539 
3542  Component GetComponent() const;
3543 
3546  bool HasChildren() const;
3547 
3550  ComponentPath GetPath() const;
3551 
3552 
3560  virtual ComponentTreeItemPtr AddChild(Component const & in_component, ComponentTree::ItemType in_type) = 0;
3561 
3562 
3565  virtual void Expand();
3566 
3569  virtual void Collapse();
3570 
3571 
3577  bool IsHighlighted() const;
3578 
3583  virtual void OnHighlight(HighlightOptionsKit const & in_options);
3584 
3589  virtual void OnUnhighlight(HighlightOptionsKit const & in_options);
3590 
3591 
3595  void Highlight();
3596 
3600  void Unhighlight();
3601 
3602 
3612  bool IsHidden() const;
3613 
3617  virtual void OnHide();
3618 
3622  virtual void OnShow();
3623 
3627  void Hide();
3628 
3632  void Show();
3633 
3638  void Isolate();
3639 };
3640 
3641 
3642 
3643 
3644 }
3645 #endif
3646 
3647 
3648 
Definition: sprk.h:2543
Type ObjectType() const
Definition: sprk.h:2377
Definition: hps.h:5899
bool HasAll(MouseButtons const &in_buttons) const
Definition: hps.h:40518
Type ObjectType() const
Definition: sprk.h:437
Event * Clone() const
Definition: sprk.h:675
Definition: sprk.h:2718
Definition: sprk.h:238
ComponentHighlightEvent(Event const &in_event)
Definition: sprk.h:1979
Type ObjectType() const
Definition: sprk.h:246
virtual bool OnTimerTick(TimerTickEvent const &in_event)
Definition: sprk.h:1056
Definition: hps.h:37001
Definition: hps.h:1479
ComponentHighlightEvent()
Definition: sprk.h:1961
void SetModifierTrigger(ModifierKeys in_modifiers)
Definition: sprk.h:1082
Definition: hps.h:452
Type ObjectType() const
Definition: sprk.h:215
Type ObjectType() const
Definition: sprk.h:973
virtual bool OnKeyDown(KeyboardState const &in_state)
Definition: sprk.h:1046
Type ObjectType() const
Definition: sprk.h:2030
An InvalidSpecificationException is thrown when a method is called with non-sensical or contradictory...
Definition: hps.h:5417
Location
Definition: sprk.h:1252
ModifierKeys GetModifierTrigger() const
Definition: sprk.h:1085
virtual bool OnKeyUp(KeyboardState const &in_state)
Definition: sprk.h:1051
ItemType
Definition: sprk.h:3362
Definition: hps.h:5457
CaptureActivationEvent()
Definition: sprk.h:2151
Definition: sprk.h:69
Definition: sprk.h:212
Definition: sprk.h:597
Definition: sprk.h:105
virtual bool OnMouseMove(MouseState const &in_state)
Definition: sprk.h:1011
MouseButtons GetButtons() const
Definition: sprk.h:3463
virtual bool OnMouseEnter(MouseState const &in_state)
Definition: sprk.h:1021
Definition: sprk.h:2596
Type ObjectType() const
Definition: sprk.h:2218
Definition: hps.h:36788
Definition: hps.h:1310
Definition: hps.h:1033
Type ObjectType() const
Definition: sprk.h:1736
Definition: hps.h:1651
ModelDeletedEvent()
Definition: sprk.h:883
SmoothTransitionCompleteEvent(View const &in_view)
Definition: sprk.h:2789
Definition: sprk.h:3357
Definition: hps.h:41012
Definition: sprk.h:924
virtual bool OnTouchUp(TouchState const &in_state)
Definition: sprk.h:1036
Definition: hps.h:7136
MouseButtons GetMouseTrigger() const
Definition: sprk.h:1077
virtual Type ObjectType() const
Definition: sprk.h:3092
Definition: hps.h:3348
Definition: hps.h:1978
Definition: sprk.h:834
Event * Clone() const
Definition: sprk.h:719
Definition: sprk.h:685
Definition: hps.h:1369
Definition: hps.h:864
Type ObjectType() const
Definition: sprk.h:1391
UpdateControl
Definition: hps.h:168
bool HasAll(ModifierKeys const &in_keys) const
Definition: hps.h:40163
Definition: hps.h:36906
virtual void OnModelDetached()
Definition: sprk.h:1070
Definition: hps.h:1697
Definition: hps.h:1508
Definition: hps.h:8173
Definition: hps.h:221
void SetMouseTrigger(MouseButtons in_buttons)
Definition: sprk.h:1073
ComponentPath & Append(Component const &in_component)
Definition: hps.h:1749
Event * Clone() const
Definition: sprk.h:825
Definition: hps.h:40934
Definition: hps.h:35917
Definition: sprk.h:1248
Definition: sprk.h:879
Definition: sprk.h:497
Type ObjectType() const
Definition: sprk.h:112
ViewDetachedEvent(Event const &in_event)
Definition: sprk.h:761
virtual void OnViewDetached()
Definition: sprk.h:1062
Definition: hps.h:35963
Type ObjectType() const
Definition: sprk.h:3224
LayoutDeletedEvent()
Definition: sprk.h:689
Event * Clone() const
Definition: sprk.h:869
virtual void OnViewAttached()
Definition: sprk.h:1059
Definition: hps.h:35433
Definition: hps.h:38147
Definition: hps.h:1072
Definition: sprk.h:2287
LayoutDetachedEvent()
Definition: sprk.h:644
Definition: sprk.h:2399
virtual bool OnMouseLeave(MouseState const &in_state)
Definition: sprk.h:1026
Definition: hps.h:8774
Definition: hps.h:36949
Definition: hps.h:1456
ModifierKeys GetModifierKeys() const
SmoothTransitionCompleteEvent()
Definition: sprk.h:2784
Definition: hps.h:1395
Type ObjectType() const
Definition: sprk.h:504
virtual bool OnMouseUp(MouseState const &in_state)
Definition: sprk.h:1006
FilterActivationEvent()
Definition: sprk.h:2063
Definition: hps.h:1414
virtual void OnModelAttached()
Definition: sprk.h:1066
Definition: hps.h:33903
FilterActivationEvent(Event const &in_event)
Definition: sprk.h:2077
ModelDetachedEvent(Event const &in_event)
Definition: sprk.h:853
Type ObjectType() const
Definition: sprk.h:1279
Type ObjectType() const
Definition: sprk.h:1560
Definition: hps.h:6647
Location
Definition: sprk.h:1364
Definition: hps.h:40460
Definition: sprk.h:2351
Definition: sprk.h:1360
Definition: hps.h:38319
Type ObjectType() const
Definition: sprk.h:1127
SprocketControl & operator=(SprocketControl &&in_that)
Definition: sprk.h:228
Definition: hps.h:39649
virtual UTF8 GetName() const
Definition: sprk.h:996
Definition: hps.h:40856
Definition: sprk.h:640
Event * Clone() const
Definition: sprk.h:2094
CaptureActivationEvent(Event const &in_event)
Definition: sprk.h:2165
virtual bool OnTouchDown(TouchState const &in_state)
Definition: sprk.h:1031
Type ObjectType() const
Definition: sprk.h:2473
CanvasDeletedEvent()
Definition: sprk.h:601
virtual bool OnMouseWheel(MouseState const &in_state)
Definition: sprk.h:1016
Type ObjectType() const
Definition: sprk.h:2307
Type ObjectType() const
Definition: sprk.h:2425
SprocketControl(SprocketControl &&in_that)
Definition: sprk.h:223
Event * Clone() const
Definition: sprk.h:2181
Definition: hps.h:13841
ViewDeletedEvent()
Definition: sprk.h:795
intptr_t GetChannel() const
Definition: hps.h:6032
Definition: sprk.h:728
virtual bool Drop(Event const *in_that_event) const
Definition: sprk.h:2803
virtual UTF8 GetName() const
Definition: sprk.h:2723
Definition: sprk.h:1464
Definition: hps.h:38596
Definition: hps.h:40109
ViewDeletedEvent(Event const &in_event)
Definition: sprk.h:810
Definition: hps.h:37337
Definition: hps.h:33520
Definition: sprk.h:2495
ViewDetachedEvent()
Definition: sprk.h:739
Definition: hps.h:5999
Definition: sprk.h:1105
Definition: hps.h:388
Type ObjectType() const
Definition: sprk.h:2521
Event * Clone() const
Definition: sprk.h:1996
Definition: sprk.h:430
CanvasDeletedEvent(Event const &in_event)
Definition: sprk.h:616
Definition: sprk.h:2821
Definition: sprk.h:1705
ComponentType
Definition: sprk.h:1469
Definition: hps.h:39575
Definition: hps.h:6902
Definition: sprk.h:1950
Event * Clone() const
Definition: sprk.h:631
LayoutDetachedEvent(Event const &in_event)
Definition: sprk.h:659
Type ObjectType() const
Definition: sprk.h:3494
virtual bool OnMouseDown(MouseState const &in_state)
Definition: sprk.h:1001
ItemType
Definition: sprk.h:2947
Definition: sprk.h:2009
Definition: sprk.h:2646
virtual UTF8 GetName() const
Definition: sprk.h:2828
Definition: sprk.h:189
Definition: sprk.h:2780
Definition: hps.h:408
Event * Clone() const
Definition: sprk.h:913
Definition: sprk.h:2107
Definition: hps.h:1996
ModelDetachedEvent()
Definition: sprk.h:838
static MouseButtons ButtonLeft()
Definition: hps.h:40578
virtual Type ObjectType() const
Definition: sprk.h:3395
Definition: sprk.h:2942
Definition: sprk.h:2447
Definition: hps.h:8211
Type ObjectType() const
Definition: sprk.h:934
virtual bool IsMouseTriggered(MouseState const &in_state)
Definition: sprk.h:1088
Definition: hps.h:7058
Definition: sprk.h:2052
Definition: hps.h:33136
Definition: hps.h:331
Event * Clone() const
Definition: sprk.h:2794
ModelDeletedEvent(Event const &in_event)
Definition: sprk.h:898
Event * Clone() const
Definition: sprk.h:779
LayoutDeletedEvent(Event const &in_event)
Definition: sprk.h:704
Definition: hps.h:8413
Definition: hps.h:9805
virtual bool OnTouchMove(TouchState const &in_state)
Definition: sprk.h:1041
Definition: sprk.h:3171
Definition: sprk.h:2193
Mode
Definition: sprk.h:194
Definition: hps.h:498
Definition: sprk.h:965
Definition: hps.h:1114
Definition: hps.h:36833
Definition: sprk.h:791
Definition: sprk.h:2147
Definition: hps.h:35496
Type ObjectType() const
Definition: sprk.h:2569
Type ObjectType() const
Definition: sprk.h:2128
Type ObjectType() const
Definition: sprk.h:2622