ASPiK SDK
plugingui.h
1  // -----------------------------------------------------------------------------
2 // ASPiK Plugin Kernel File: plugingui.h
3 //
12 // -----------------------------------------------------------------------------
13 #pragma once
14 #ifndef __PluginGUI__
15 #define __PluginGUI__
16 
17 //#define DOXYDOC 1
18 
19 #ifdef DOXYDOC
20 
21 #define AUPLUGIN 1
22 #define AAXPLUGIN 1
23 #define VSTPLUGIN 1
24 #define RAFXPLUGIN 1
25 
26 #endif
27 
28 // --- custom VSTGUI4 derived classes
29 #include "customcontrols.h"
30 
31 // --- VSTGUI
32 #include "vstgui/vstgui.h"
33 #include "vstgui/uidescription/uiviewswitchcontainer.h"
34 #include "vstgui/vstgui_uidescription.h"
35 #include "vstgui/lib/crect.h"
36 
37 #if VSTGUI_LIVE_EDITING
38 #include "vstgui/uidescription/editing/uieditcontroller.h"
39 #include "vstgui/uidescription/editing/uieditmenucontroller.h"
40 #endif
41 
42 #ifdef AUPLUGIN
43 #import <CoreFoundation/CoreFoundation.h>
44 #import <AudioUnit/AudioUnit.h>
45 #import <AudioToolbox/AudioToolbox.h>
46 #endif
47 
48 #ifdef AAXPLUGIN
49 #include "AAX_IEffectParameters.h"
50 #include "AAXtoVSTGUIButtonState.h"
51 #endif
52 
53 // --- plugin stuff
54 #include "pluginparameter.h"
55 
56 // --- std::
57 #include <sstream>
58 #include <algorithm>
59 #include <functional>
60 #include <cctype>
61 #include <locale>
62 #include <map>
63 
64 // --- const for host choice knob mode
65 const uint32_t kHostChoice = 3;
66 
67 namespace VSTGUI {
68 
84 {
85 public:
87  ControlUpdateReceiver(CControl* control, PluginParameter* pluginParameterPtr, bool _isControlListener)
88  {
89  hasRefGuiControl = pluginParameterPtr ? true : false;
90 
92  refGuiControl = *pluginParameterPtr;
93 
94  addControl(control);
95  isControlListener = _isControlListener;
96  }
97 
100  {
101  for(std::vector<CControl*>::iterator it = guiControls.begin(); it != guiControls.end(); ++it)
102  {
103  CControl* ctrl = *it;
104  ctrl->forget();
105  }
106  }
107 
112  bool hasControl(CControl* control)
113  {
114  return std::find(guiControls.begin (), guiControls.end (), control) != guiControls.end ();
115  }
116 
120  void addControl(CControl* control)
121  {
122  if(hasControl(control))
123  return;
124 
125  control->remember();
126  guiControls.push_back(control);
127 
128  // --- set default value (rather than from XML, which is a pain because it must be normalized)
129  if(hasRefGuiControl)
130  {
131  float normalizedValue = (float)refGuiControl.getDefaultValueNormalized();
132  control->setDefaultValue(normalizedValue);
133  }
134  }
135 
139  void removeControl(CControl* control)
140  {
141  for(std::vector<CControl*>::iterator it = guiControls.begin(); it != guiControls.end(); ++it)
142  {
143  CControl* ctrl = *it;
144  if(ctrl == control)
145  {
146  ctrl->forget();
147  guiControls.erase(it);
148  return;
149  }
150  }
151  }
152 
158  {
159  for(std::vector<CControl*>::iterator it = guiControls.begin(); it != guiControls.end(); ++it)
160  {
161  CControl* ctrl = *it;
162  if(ctrl && ctrl->isEditing())
163  return true;
164  }
165  return false;
166  }
167 
172  float getActualValueWithNormalizedValue(float normalizedValue)
173  {
174  return (float)refGuiControl.getControlValueWithNormalizedValue(normalizedValue);
175  }
176 
181  float getNormalizedValueWithActualValue(float actualValue)
182  {
183  return (float)refGuiControl.getNormalizedControlValueWithActualValue(actualValue);
184  }
185 
189  void updateControlsWithControl(CControl* control)
190  {
191  updateControlsWithActualValue(getActualValueWithNormalizedValue(control->getValueNormalized()), control);
192  }
193 
198  void updateControlsWithNormalizedValue(float normalizedValue, CControl* control = nullptr)
199  {
201  }
202 
206  void initControl(CControl* control)
207  {
208  float actualValue = (float)refGuiControl.getControlValue();
209  updateControlsWithActualValue(actualValue, control);
210  }
211 
216  void updateControlsWithActualValue(float actualValue, CControl* control = nullptr)
217  {
218  // --- eliminiate glitching from AAX parameter loop
219  if(!control && controlInRxGroupIsEditing())
220  return;
221 
222  // --- store on our reference control
223  refGuiControl.setControlValue(actualValue);
224 
225  // --- synchoronize all controls that share this controlID
226  for(std::vector<CControl*>::iterator it = guiControls.begin(); it != guiControls.end(); ++it)
227  {
228  CControl* guiCtrl = *it;
229  if(guiCtrl && control != guiCtrl) // nned the check for XY pads
230  {
231  // --- need to take care of multiple control types, slight differences in setup
232  CTextLabel* label = dynamic_cast<CTextLabel*>(guiCtrl);
233  COptionMenu* oMenu = dynamic_cast<COptionMenu*>(guiCtrl);
234  CXYPadEx* xyPad = dynamic_cast<CXYPadEx*>(guiCtrl);
235  CVuMeter* meter = dynamic_cast<CVuMeter*>(guiCtrl);
236 
237  if(meter)
238  {
239  continue;
240  }
241  else if(label)
242  {
243  label->setText(refGuiControl.getControlValueAsString().c_str());
244  label->invalid();
245  }
246  else if(oMenu)
247  {
248  // --- current rafx GUI Designer does not set max to anything
249  guiCtrl->setMin((float)refGuiControl.getGUIMin());
250  guiCtrl->setMax((float)refGuiControl.getGUIMin());
251 
252  // --- load for first time, NOT dynamic loading here
253  oMenu->removeAllEntry();
254 
255  for (uint32_t i = 0; i < refGuiControl.getStringCount(); i++)
256  {
257  oMenu->addEntry(refGuiControl.getStringByIndex(i).c_str());
258  }
259 
260  oMenu->setValue((float)refGuiControl.getControlValue());
261  }
262  else if(xyPad)
263  {
264  float x = 0.f;
265  float y = 0.f;
266  xyPad->calculateXY(xyPad->getValue(), x, y);
267 
268  // --- retrieve the X and Y tags on the CXYPadEx
269  int32_t tagX = xyPad->getTagX();
270  int32_t tagY = xyPad->getTagY();
271 
272  if(tagX == refGuiControl.getControlID())
274  if(tagY == refGuiControl.getControlID())
276 
277  if(tagX >= 0 && tagY >= 0 && !guiCtrl->isEditing())
278  xyPad->setValue(xyPad->calculateValue(x, y));
279  }
280  else if(!guiCtrl->isEditing())
281  guiCtrl->setValueNormalized((float)refGuiControl.getControlValueNormalized());
282 
283  guiCtrl->invalid();
284  }
285  }
286  }
287 
293 
297  int32_t getControlID(){ return refGuiControl.getControlID(); }
298 
303  inline bool controlAndContainerVisible(CControl* ctrl)
304  {
305  if(!ctrl) return false;
306 
307  bool stickyVisible = ctrl->isVisible();
308 
309  if(!stickyVisible)
310  return false;
311 
312  // --- check parents
313  CView* parent = ctrl->getParentView();
314  while(parent)
315  {
316  stickyVisible = parent->isVisible();
317  if(!stickyVisible)
318  return false;
319 
320  parent = parent->getParentView();
321  }
322  return stickyVisible;
323  }
324 
330  int getControlID_WithMouseCoords(const CPoint& where)
331  {
332  CPoint mousePoint = where;
333 
334  for(std::vector<CControl*>::iterator it = guiControls.begin(); it != guiControls.end(); ++it)
335  {
336  CControl* ctrl = *it;
337  if(ctrl && controlAndContainerVisible(ctrl))
338  {
339  CPoint point = ctrl->frameToLocal(mousePoint);
340  CRect rect = ctrl->getViewSize();
341  if(rect.pointInside(point))
342  {
343  int tag = ctrl->getTag();
344  if(isReservedTag(tag))
345  return -1;
346  else
347  return tag;
348  }
349  }
350  }
351  return -1;
352  }
353 
359  CControl* getControl_WithMouseCoords(const CPoint& where)
360  {
361  CPoint mousePoint = where;
362 
363  for(std::vector<CControl*>::iterator it = guiControls.begin(); it != guiControls.end(); ++it)
364  {
365  CControl* ctrl = *it;
366  if(ctrl && controlAndContainerVisible(ctrl))
367  {
368  CPoint point = ctrl->frameToLocal(mousePoint);
369  CRect rect = ctrl->getViewSize();
370  if(rect.pointInside(point))
371  return ctrl;
372  }
373  }
374  return nullptr;
375  }
376 
377 protected:
379  std::vector<CControl*> guiControls;
380  bool hasRefGuiControl = false;
381  bool isControlListener = false;
382 };
383 
384 
410 class PluginGUI : public IController,
411  public IViewAddedRemovedObserver,
412  public IMouseObserver,
413  public IKeyboardHook,
414  public VSTGUIEditorInterface,
415  public CBaseObject,
416  public ICommandMenuItemTarget,
417  public IGUIView
418 {
419 
420 public:
422  PluginGUI(UTF8StringPtr _xmlFile);
423 
425  virtual ~PluginGUI();
426 
428  bool open(UTF8StringPtr _viewName,
429  void* parent,
430  const std::vector<PluginParameter*>* pluginParameterPtr,
431  const PlatformType& platformType = kDefaultNative,
432  IGUIPluginConnector* _guiPluginConnector = nullptr,
433  void* data = nullptr);
434 
436  void close();
437 
439  void syncGUIControl(uint32_t controlID);
440 
442  void getSize(float& width, float& height);
443 
445  void scaleGUISize(uint32_t controlValue);
446 
448  void writeToPresetFile();
449 
450 protected:
452  virtual void idle();
453 
455  void preCreateGUI();
456 
458  bool createGUI(bool bShowGUIEditor);
459 
461  void save(bool saveAs = false);
462 
464  virtual int32_t getKnobMode() const override;
465 
468  {
469  for(std::vector<PluginParameter*>::iterator it = pluginParameters.begin(); it != pluginParameters.end(); ++it) {
470  delete *it;
471  }
472  pluginParameters.clear();
473  }
474 
483  {
484  for(std::vector<PluginParameter*>::iterator it = pluginParameters.begin(); it != pluginParameters.end(); ++it) {
485  PluginParameter* ctrl = *it;
486  if(ctrl->getControlID() == tag)
487  return ctrl;
488  }
489  return nullptr;
490  }
491 
492  // --- protected variables
494  UIDescription* description = nullptr;
495  std::string viewName;
496  std::string xmlFile;
497 
498  uint32_t numUIControls = 0;
499  double zoomFactor = 1.0;
500  CVSTGUITimer* timer;
501 
502  CPoint minSize;
503  CPoint maxSize;
504  CRect nonEditRect;
505 
506  // --- flags for showing view
507  bool showGUIEditor = false;
508  bool createNewView = true;
509 
512  float guiWidth;
513  float guiHeight;
514 
516  CFrame* guiEditorFrame = nullptr;
517  uint32_t knobAction = kLinearMode;
518 
520  std::string getGUIDesignerSize();
521 
523  int getControlID_WithMouseCoords(const CPoint& where);
524 
526  CControl* getControl_WithMouseCoords(const CPoint& where);
527 
529  CMouseEventResult sendAAXMouseDown(int controlID, const CButtonState& buttons);
530 
532  CMouseEventResult sendAAXMouseMoved(int controlID, const CButtonState& buttons, const CPoint& where);
533 
535  CMouseEventResult sendAUMouseDown(CControl* control, const CButtonState& buttons);
536 
538  CMouseEventResult sendAUMouseMoved(CControl* control, const CButtonState& buttons, const CPoint& where) { return kMouseEventNotImplemented; }
539 
551  void setPluginParameterFromGUIControl(CControl* control, int tag, float actualValue, float normalizedValue)
552  {
553 #ifdef AUPLUGIN
554  setAUEventFromGUIControl(control, tag, actualValue);
555 #endif
556 
557 #ifdef AAXPLUGIN
558  setAAXParameterFromGUIControl(control, tag, actualValue, normalizedValue);
559 #endif
560 
561 #ifdef VSTPLUGIN
562  setVSTParameterFromGUIControl(control, tag, actualValue, normalizedValue);
563 #endif
564 
565 #ifdef RAFXPLUGIN
566  setRAFXParameterFromGUIControl(control, tag, actualValue, normalizedValue);
567 #endif
568 }
569 
573 #ifdef AAXPLUGIN
574 public:
579  void setAAXViewContainer(AAX_IViewContainer* _aaxViewContainer){ aaxViewContainer = _aaxViewContainer;}
580 
582  void setAAXParameterFromGUIControl(CControl* control, int tag, float actualValue, float normalizedValue);
583 
585  void updateGUIControlAAX(int tag, float actualPluginValue, float normalizedValue = 0.f, bool useNormalized = false);
586 protected:
587 #endif
588 
589 
590 #ifdef AUPLUGIN
591  AudioUnit m_AU;
592  AUEventListenerRef AUEventListener;
593 
594 public:
596  void dispatchAUControlChange(int tag, float actualPluginValue, int message = -1, bool fromEventListener = false);
597 
601  void setAU(AudioUnit inAU){m_AU = inAU;}
602 
603 protected:
605  void setAUEventFromGUIControl(CControl* control, int tag, float normalizedValue);
606 #endif
607 
608 #ifdef VSTPLUGIN
609 
610  void setVSTParameterFromGUIControl(CControl* control, int tag, float actualValue, float normalizedValue);
611 
613  void updateGUIControlVST(int tag, float normalizedValue);
614 #endif
615 
616 #ifdef RAFXPLUGIN
617 
618  void setRAFXParameterFromGUIControl(CControl* control, int tag, float actualValue, float normalizedValue);
619 
621  void updateGUIControlRAFX(int tag, float normalizedValue);
622 #endif
623 
624 
625 public:
627  CMessageResult notify(CBaseObject* sender, IdStringPtr message) override;
628 
630  virtual void valueChanged(VSTGUI::CControl* pControl) override;
631 
633  virtual int32_t controlModifierClicked(VSTGUI::CControl* pControl, VSTGUI::CButtonState button) override { return 0; }
634 
636  virtual void controlBeginEdit(VSTGUI::CControl* pControl) override;
637 
639  virtual void controlEndEdit(VSTGUI::CControl* pControl) override;
640 
642  virtual void controlTagWillChange(VSTGUI::CControl* pControl) override;
643 
645  virtual void controlTagDidChange(VSTGUI::CControl* pControl) override;
646 #if DEBUG
647 
648  virtual char controlModifierClicked(VSTGUI::CControl* pControl, long button) { return 0; }
649 #endif
650 
652  CView* createUserCustomView(std::string viewname, const CRect rect, IControlListener* listener, int32_t tag);
653 
655  CView* createView(const UIAttributes& attributes, const IUIDescription* description) override;
656 
658  IController* createSubController(UTF8StringPtr name, const IUIDescription* description) override;
659 
661  ControlUpdateReceiver* getControlUpdateReceiver(int32_t tag) const;
662 
664  void onViewAdded(CFrame* frame, CView* view) override {}
665 
667  void onViewRemoved(CFrame* frame, CView* view) override;
668 
670  void onMouseEntered(CView* view, CFrame* frame) override {}
671 
673  void onMouseExited(CView* view, CFrame* frame) override {}
674 
676  CMouseEventResult onMouseDown(CFrame* frame, const CPoint& where, const CButtonState& buttons) override;
677 
679  CMouseEventResult onMouseMoved(CFrame* frame, const CPoint& where, const CButtonState& buttons) override;
680 
682  int32_t onKeyDown(const VstKeyCode& code, CFrame* frame) override { return -1; }
683 
685  int32_t onKeyUp(const VstKeyCode& code, CFrame* frame) override { return -1; }
686 
688  virtual bool validateCommandMenuItem(CCommandMenuItem* item);
689 
691  virtual bool onCommandMenuItemSelected(CCommandMenuItem* item);
692 
699  virtual void setGUIWindowFrame(IGUIWindowFrame* frame) override
700  {
701  // --- we keep for resiging here
702  guiWindowFrame = frame;
703  }
704 
710  inline static bool parseSize (const std::string& str, CPoint& point)
711  {
712  size_t sep = str.find (',', 0);
713  if (sep != std::string::npos)
714  {
715  point.x = strtol (str.c_str (), 0, 10);
716  point.y = strtol (str.c_str () + sep+1, 0, 10);
717  return true;
718  }
719  return false;
720  }
721 
722  // --- for Meters only right now, but could be used to mark any control as writeable
730  bool hasWriteableControl(CControl* control)
731  {
732  return std::find (writeableControls.begin (), writeableControls.end (), control) != writeableControls.end ();
733  }
734 
741  void checkAddWriteableControl(PluginParameter* piParam, CControl* control)
742  {
743  if(!piParam)
744  return;
745  if(!control)
746  return;
747  if(!piParam->getIsWritable())
748  return;
749  if(!hasWriteableControl(control))
750  {
751  writeableControls.push_back(control);
752  control->remember();
753  }
754  }
755 
761  void checkRemoveWriteableControl(CControl* control)
762  {
763  if(!hasWriteableControl(control)) return;
764 
765  for(std::vector<CControl*>::iterator it = writeableControls.begin(); it != writeableControls.end(); ++it)
766  {
767  CControl* ctrl = *it;
768  if(ctrl == control)
769  {
770  ctrl->forget();
771  writeableControls.erase(it);
772  return;
773  }
774  }
775  }
776 
777 
782  {
783  for (ControlUpdateReceiverMap::const_iterator it = controlUpdateReceivers.begin(), end = controlUpdateReceivers.end(); it != end; ++it)
784  {
785  delete it->second;
786  }
787  controlUpdateReceivers.clear();
788  }
789 
794  {
795  for (std::vector<CControl*>::iterator it = writeableControls.begin(); it != writeableControls.end(); ++it)
796  {
797  CControl* ctrl = *it;
798  ctrl->forget();
799  }
800  writeableControls.clear();
801  }
802 
810  bool hasICustomView(CView* view)
811  {
812  ICustomView* customView = dynamic_cast<ICustomView*>(view);
813  if (customView)
814  return true;
815  return false;
816  }
817 
825  bool hasICustomView(IController* subController)
826  {
827  ICustomView* customView = dynamic_cast<ICustomView*>(subController);
828  if (customView)
829  return true;
830  return false;
831  }
832 
833 private:
834  typedef std::map<int32_t, ControlUpdateReceiver*> ControlUpdateReceiverMap;
835  ControlUpdateReceiverMap controlUpdateReceivers;
836  std::vector<CControl*> writeableControls;
837  std::vector<PluginParameter*> pluginParameters;
838 
839 #ifdef AAXPLUGIN
840  AAX_IViewContainer* aaxViewContainer = nullptr;
841 #endif
842 };
843 
844 }
845 
846 #endif
IGUIWindowFrame * guiWindowFrame
interface to allow plugin shell to resize our window
Definition: plugingui.h:515
double getControlValue()
the main function to access the underlying atomic double value
Definition: pluginparameter.h:167
CView * createView(const UIAttributes &attributes, const IUIDescription *description) override
virtual void controlTagWillChange(VSTGUI::CControl *pControl) override
void checkAddWriteableControl(PluginParameter *piParam, CControl *control)
check to see if we already store this meter control and add it if we don&#39;t
Definition: plugingui.h:741
bool hasICustomView(IController *subController)
simple helper function to test sub-controller for ICustomView
Definition: plugingui.h:825
CControl * getControl_WithMouseCoords(const CPoint &where)
Definition: plugingui.h:359
virtual void setValue(float val) override
Definition: customcontrols.cpp:979
const PluginParameter getGuiControl()
Definition: plugingui.h:292
The PluginGUI object that maintains the entire GUI operation and has #defines to use with AAX...
Definition: plugingui.h:410
void save(bool saveAs=false)
void updateControlsWithControl(CControl *control)
Definition: plugingui.h:189
~ControlUpdateReceiver()
Definition: plugingui.h:99
uint32_t numUIControls
control counter
Definition: plugingui.h:498
virtual void controlBeginEdit(VSTGUI::CControl *pControl) override
void getSize(float &width, float &height)
std::string getGUIDesignerSize()
float getActualValueWithNormalizedValue(float normalizedValue)
Definition: plugingui.h:172
CMessageResult notify(CBaseObject *sender, IdStringPtr message) override
double getControlValueNormalized()
get control value as normalied value
Definition: pluginparameter.h:279
void removeControl(CControl *control)
Definition: plugingui.h:139
virtual void valueChanged(VSTGUI::CControl *pControl) override
bool getIsWritable()
query writable control (meter)
Definition: pluginparameter.h:152
IGUIPluginConnector * guiPluginConnector
the plugin shell interface that arrives with the open( ) function; OK if NULL for standalone GUIs ...
Definition: plugingui.h:493
CMouseEventResult sendAAXMouseMoved(int controlID, const CButtonState &buttons, const CPoint &where)
bool open(UTF8StringPtr _viewName, void *parent, const std::vector< PluginParameter *> *pluginParameterPtr, const PlatformType &platformType=kDefaultNative, IGUIPluginConnector *_guiPluginConnector=nullptr, void *data=nullptr)
uint32_t getControlID()
get ID value
Definition: pluginparameter.h:81
std::string getControlValueAsString()
the main function to access the underlying atomic double value as a string
Definition: pluginparameter.cpp:227
double getGUIMin()
Definition: pluginparameter.h:345
void deleteGUIControlList()
Definition: plugingui.h:467
IController * createSubController(UTF8StringPtr name, const IUIDescription *description) override
bool showGUIEditor
show the GUI designer
Definition: plugingui.h:507
double guiDesignerWidth
GUI Designer&#39;s frame size.
Definition: plugingui.h:510
std::vector< CControl * > guiControls
list of controls that share the control tag with this one
Definition: plugingui.h:379
double zoomFactor
scaling factor for built-in scaling
Definition: plugingui.h:499
CView * createUserCustomView(std::string viewname, const CRect rect, IControlListener *listener, int32_t tag)
void addControl(CControl *control)
Definition: plugingui.h:120
bool hasWriteableControl(CControl *control)
check to see if we already store this meter control
Definition: plugingui.h:730
PluginGUI(UTF8StringPtr _xmlFile)
virtual void idle()
bool controlAndContainerVisible(CControl *ctrl)
Definition: plugingui.h:303
CRect nonEditRect
non-edit area for GUI designer
Definition: plugingui.h:504
void updateControlsWithNormalizedValue(float normalizedValue, CControl *control=nullptr)
Definition: plugingui.h:198
virtual void controlTagDidChange(VSTGUI::CControl *pControl) override
virtual void controlEndEdit(VSTGUI::CControl *pControl) override
CVSTGUITimer * timer
timer object (this is platform dependent)
Definition: plugingui.h:500
bool controlInRxGroupIsEditing()
Definition: plugingui.h:157
void writeToPresetFile()
std::string getStringByIndex(uint32_t index)
get string-list string by index
Definition: pluginparameter.cpp:281
float getNormalizedValueWithActualValue(float actualValue)
Definition: plugingui.h:181
CMouseEventResult sendAUMouseMoved(CControl *control, const CButtonState &buttons, const CPoint &where)
Definition: plugingui.h:538
float guiWidth
embedded GUI size
Definition: plugingui.h:512
int32_t onKeyDown(const VstKeyCode &code, CFrame *frame) override
Definition: plugingui.h:682
CPoint minSize
the min size of the GUI window
Definition: plugingui.h:502
Custom interface so that GUI can pass information to plugin shell in a thread-safe manner...
Definition: pluginstructures.h:1473
float guiHeight
embedded GUI size
Definition: plugingui.h:513
double getControlValueWithNormalizedValue(double normalizedValue, bool applyTaper=true)
get the new control value as if it were set with a normalized value
Definition: pluginparameter.h:305
Custom View interface to allow plugin core to create safe communication channels with GUI custom view...
Definition: pluginstructures.h:1395
bool hasRefGuiControl
internal flag
Definition: plugingui.h:380
void onViewRemoved(CFrame *frame, CView *view) override
bool isReservedTag(int tag)
check to see if a tag is reserved: ASPiK defines several reserved control ID values.
Definition: guiconstants.h:49
virtual bool validateCommandMenuItem(CCommandMenuItem *item)
validates menu item selections to prevent crashing
Definition: plugingui.cpp:738
Definition: customcontrols.cpp:20
std::string viewName
name
Definition: plugingui.h:495
size_t getStringCount()
get the number of individual strings in a string-list control
Definition: pluginparameter.h:227
void setControlValue(double actualParamValue, bool ignoreSmoothing=false)
the main function to set the underlying atomic double value
Definition: pluginparameter.h:175
void syncGUIControl(uint32_t controlID)
int getControlID_WithMouseCoords(const CPoint &where)
Definition: plugingui.h:330
uint32_t knobAction
knob mode
Definition: plugingui.h:517
CMouseEventResult onMouseMoved(CFrame *frame, const CPoint &where, const CButtonState &buttons) override
double getDefaultValueNormalized()
get default value as normalied value
Definition: pluginparameter.h:253
void onMouseEntered(CView *view, CFrame *frame) override
Definition: plugingui.h:670
void onMouseExited(CView *view, CFrame *frame) override
Definition: plugingui.h:673
ControlUpdateReceiver(CControl *control, PluginParameter *pluginParameterPtr, bool _isControlListener)
Definition: plugingui.h:87
The ControlUpdateReceiver object is the connection mechanism between PluginParameter objects and thei...
Definition: plugingui.h:83
bool hasICustomView(CView *view)
simple helper function to test view for ICustomView
Definition: plugingui.h:810
int32_t onKeyUp(const VstKeyCode &code, CFrame *frame) override
Definition: plugingui.h:685
bool hasControl(CControl *control)
Definition: plugingui.h:112
ControlUpdateReceiver * getControlUpdateReceiver(int32_t tag) const
virtual bool onCommandMenuItemSelected(CCommandMenuItem *item)
message handler for GUI Designer menu
Definition: plugingui.cpp:785
void scaleGUISize(uint32_t controlValue)
The PluginParameter object stores all of the data needed for any type of plugin parameter. It is a large object, but it is not complex as it really just stores LOTS of information about plugin parameters.
Definition: pluginparameter.h:51
CMouseEventResult sendAAXMouseDown(int controlID, const CButtonState &buttons)
CMouseEventResult onMouseDown(CFrame *frame, const CPoint &where, const CButtonState &buttons) override
virtual void setGUIWindowFrame(IGUIWindowFrame *frame) override
set the interface pointer for resizing from the GUI
Definition: plugingui.h:699
Custom interface to allow resizing of GUI window; this is mainly used for the GUI designer...
Definition: pluginstructures.h:1454
void initControl(CControl *control)
Definition: plugingui.h:206
bool createNewView
show the normal GUI
Definition: plugingui.h:508
Custom interface to allow resizing of GUI window; this is mainly used for the GUI designer...
Definition: pluginstructures.h:1430
double guiDesignerHeight
GUI Designer&#39;s frame size.
Definition: plugingui.h:511
The CXYPadEx object extends the CXYPad CVuMeter object with extra functionality. It is used in the Pl...
Definition: customcontrols.h:539
CFrame * guiEditorFrame
pointer to our frame
Definition: plugingui.h:516
void onViewAdded(CFrame *frame, CView *view) override
Definition: plugingui.h:664
static bool parseSize(const std::string &str, CPoint &point)
simple helper function to get size from string
Definition: plugingui.h:710
PluginParameter * getGuiControlWithTag(int tag)
find the local PluginParameter that is connected to the same control ID
Definition: plugingui.h:482
double getNormalizedControlValueWithActualValue(double actualValue)
get the new normalized control value as if it were set with an actual value
Definition: pluginparameter.h:342
void deleteControlUpdateReceivers()
delete all reciever objects
Definition: plugingui.h:781
UIDescription * description
the description version of the XML file
Definition: plugingui.h:494
virtual int32_t getKnobMode() const override
CMouseEventResult sendAUMouseDown(CControl *control, const CButtonState &buttons)
void checkRemoveWriteableControl(CControl *control)
check to see if we already store this meter control and remove it if we do
Definition: plugingui.h:761
CControl * getControl_WithMouseCoords(const CPoint &where)
PluginParameter refGuiControl
single parameter with this control tag
Definition: plugingui.h:378
int getControlID_WithMouseCoords(const CPoint &where)
void setPluginParameterFromGUIControl(CControl *control, int tag, float actualValue, float normalizedValue)
safely set a plugin shell parameter with a GUI control
Definition: plugingui.h:551
bool isControlListener
internal flag
Definition: plugingui.h:381
void forgetWriteableControls()
forget all writeable (neter) controls
Definition: plugingui.h:793
virtual ~PluginGUI()
int32_t getControlID()
Definition: plugingui.h:297
bool createGUI(bool bShowGUIEditor)
CPoint maxSize
the max size of the GUI window
Definition: plugingui.h:503
std::string xmlFile
the XML file name
Definition: plugingui.h:496
void updateControlsWithActualValue(float actualValue, CControl *control=nullptr)
Definition: plugingui.h:216
virtual int32_t controlModifierClicked(VSTGUI::CControl *pControl, VSTGUI::CButtonState button) override
return 1 if you want the control to not handle it, otherwise 0
Definition: plugingui.h:633