kc/src/kc/kcApp.h

#ifndef kcApp_h
#define kcApp_h

extern "C" struct cmApBufState_str; 

class Fl_Menu_Bar;
class Fl_HSplitter;
class Fl_Text_Buffer;
class Fl_Text_Display;
class Fl_Box;
class Fl_Tabs;
class Fl_Check_Button;
class Fl_Value_Slider;
class Fl_Menu_Button;
class Fl_File_Btn;
class Fl_Select_Browser;
class Fl_Valuator;
class Fl_Value_Input;
class Fl_Progress;
class tlCtl;

class kcApp : public Fl_Double_Window
{
public:
  typedef unsigned kcKmRC_t;


  enum
  {
    kOkKmRC,
    kEngFailKmRC,
    kMemFailKmRC,
    kPrefsNotFoundKmRC,
    kPrefWriteFailKmRC,
    kPrefLoadFailKmRC,
    kPrefFailKmRC,
    kPrefSetFailKmRC,
    kMlistLoadFailKmRC,
    kJsonFailKmRC,
    kDeserialFailKmRC,
    kPrintQueFailKmRC,
  
  };


  kcApp(int w, int h, const char *l, int argc, char *argv[]);
  virtual ~kcApp();

  kcKmRC_t audioDspInitialize( cmCtx_t* ctx, cmRptPrintFunc_t printFunc, void* printFuncArg );
  kcKmRC_t audioDspFinalize();
  bool     audioDspIsValid();

  void print( const char* fmt, ... );
  void vprint( const char* fmt, va_list vl );


private:
  enum
  {
    kMenuH = 30,
    kStatusH = 30,
    kIndH = 25,
    kIndW = 25,
    
    kSsPhaseMax = 20
  };

  //Fl_Menu_Bar*     menu;
  Fl_HSplitter*    splt;
  Fl_Box*          ind[4];
  Fl_Text_Buffer*  buf;
  Fl_Text_Display* con;
  Fl_Tabs*         tabs;
  Fl_Check_Button* ena_chk;
  //Fl_Group*        ctl_grp;

  Fl_Menu_Button*  as_btn;
  Fl_Menu_Button*  ai_btn;
  Fl_Menu_Button*  ao_btn;
  Fl_Menu_Button*  pgm_btn;
  Fl_Menu_Button*  ss_btn;
  Fl_Menu_Button*  sr_btn;

  Fl_Group*        mstr_grp;


  enum
  {
    kSldrTypeId,
    kNumbTypeId,
    kTextTypeId,
    kButnTypeId,
    kChckTypeId,
    kLablTypeId,
    kFnamTypeId,
    kMlstTypeId,
    kMetrTypeId,
    kTmlnTypeId,


    kSldrMinArgIdx = 0,
    kSldrMaxArgIdx = 1,
    kSldrStpArgIdx = 2,
    kSldrValArgIdx = 3,
    kSldrLblArgIdx = 4,
    kSldrVarCnt    = 5,

    kTextValArgIdx = 0,
    kTextLblArgIdx = 1,
    kTextVarCnt    = 2,

    kButnValArgIdx = 0,
    kButnLblArgIdx = 1,
    kButnVarCnt    = 2,

    kLablValArgIdx  = 0,
    kLablAlignArgIdx= 1,
    kLablVarCnt     = 2,

    kChckValArgIdx  = 0,
    kChckLblArgIdx  = 1,
    kChckVarCnt     = 2,

    kFnamValArgIdx = 0,
    kFnamPatArgIdx = 1,
    kFnamDirArgIdx = 2,
    kFnamVarCnt    = 3,

    kMlstHgtArgIdx = 0,
    kMlstSelArgIdx = 1,
    kMlstLstArgIdx = 2,
    kMlstVarCnt    = 3,

    kMetrMinArgIdx = 0,
    kMetrMaxArgIdx = 1,
    kMetrValArgIdx = 2,
    kMetrLblArgIdx = 3,
    kMetrVarCnt    = 4,

    kTmlnValArgIdx = 0,
    kTmlnLblArgIdx = 1,
    kTmlnFileArgIdx= 2,
    kTmlnPathArgIdx= 3,
    kTmlnVarCnt    = 4

  }; 

  enum
  {
    kEnableBtnId = 1,
    kAudDevRptBtnId,
    kAudioSysCfgBtnId,
    kInAudDevBtnId,
    kOutAudDevBtnId,
    kPgmBtnId,
    kSubSystemIdxBtnId,
    kSrateBtnId,
    kTestBtnId
  };

  enum
  {
    k44100SrateIdx,
    k48000SrateIdx,
    k96000SrateIdx
  };

  typedef struct sldr_str
  {
    union
    {
      Fl_Value_Slider*  sldr;
      Fl_Value_Input*   numb;
    } u;
    Fl_Valuator*      val;
    double            defaultVal;
    unsigned          varIdArray[ kSldrVarCnt ];
  } sldr_t;

  typedef struct text_str
  {
    Fl_Input* text;
    char*      val;
    unsigned   varIdArray[ kTextVarCnt ];
  } text_t;

  typedef struct butn_str
  {
    Fl_Button* butn;
    double     val;
    unsigned   varIdArray[ kButnVarCnt ];
  } butn_t;

  typedef struct chck_str
  {
    Fl_Check_Button* chck;
    double           val;
    unsigned         varIdArray[ kChckVarCnt ];
  } chck_t;

  typedef struct labl_str
  {
    Fl_Box* box;
    unsigned varIdArray[ kLablVarCnt ];
  } labl_t;

  typedef struct fname_str
  {
    Fl_File_Btn* fnam;
    unsigned     varIdArray[ kFnamVarCnt ];
  } fnam_t;

  typedef struct mlst_str
  {
    Fl_Select_Browser* mlst;
    Fl_Menu_Button*    mbtn;
    int                sel;
    unsigned           varIdArray[ kMlstVarCnt ];
  } mlst_t;

  typedef struct metr_str
  {
    Fl_Progress* prog;
    unsigned     varIdArray[ kMetrVarCnt ];
  } metr_t;

  typedef struct tmln_str
  {
    tlCtl*     tlctl;
    char*      val;
    unsigned   varIdArray[ kTmlnVarCnt ];
  } tmln_t;


  typedef struct ctl_str
  {
    kcApp*     thisPtr;
    unsigned   asSubIdx;
    unsigned   typeId;
    unsigned   instId;
    Fl_Widget* wdgtPtr;
    bool       mstrFl;
    union
    {
      sldr_t     sldr;
      text_t     text;
      butn_t     butn;
      chck_t     chck;
      labl_t     labl;
      fnam_t     fnam;
      mlst_t     mlst;
      metr_t     metr;
      tmln_t     tmln;
    } u;
    struct ctl_str* linkPtr;
  } ctl_t;

  typedef struct page_str
  {
    Fl_Group* grp;
    struct page_str* link;
    page_str() : grp(NULL), link(NULL) {}
  } page_t;

  enum
  {
    kUpdateSsIdx,
    kWakeupSsIdx,
    kMsgSsIdx,
    kAudioCbSsIdx,
    kProgSsCnt
  };

  // each audio sub-system is represented by an ss_t record in _ssArray[_ssCnt]
  typedef struct ss_str
  {
    Fl_Progress* prog[kProgSsCnt]; // status indicator controls
    unsigned     cnt[kProgSsCnt];  // previous status count value
    
  } ss_t;


  cmCtx_t         _ctx;
  Fl_Menu_Bar*    _menu;
  cmAdlH_t        _adlH;
  cmAiH_t         _aiH;
  unsigned        _statIdx;
  page_t*         _pageList;
  ctl_t*          _ctlList;
  const cmChar_t* _prefFn;
  cmPrH_t         _prH;
  const cmChar_t* _prefsFn;
  bool            _stopTimerFl;
  cmJsonH_t       _jsH;
  bool            _newPageFl;
  unsigned        _incrColW;
  unsigned        _colW;
  bool            _horzBordFl;
  unsigned        _horzBord;
  unsigned        _closeCnt;
  unsigned        _ssCnt;   // count of audio system sub-systems (set in _handleSsInitMsg())
  ss_t*           _ssArray;
  int             _ssPhase;
  bool            _ssUpdateFl; 
  cmTsQueueH_t    _printqH; // thread-safe queue for controlling access to the output console from multiple threads

  void resize(int x, int y, int w, int h);

  void          _createSetupDlg(Fl_Group* grp);
  void          _createMenu( int w, int h );
  void          _createPage( const char* title );

  unsigned      _getCtlCount() const;
  void          _clearCtlList(bool mstrFl);
  void          _clearSsArray();
  void          _getNewCtlPosn( const cmDspUiHdr_t* m, int& x, int& y, int& w, int& h );
  ctl_t*        _findCtl( unsigned instId, unsigned asSubIdx, unsigned mstrFl=false );
  ctl_t*        _createCtl( const cmDspUiHdr_t* m, unsigned typeId, int& x, int& y, int& w, int& h, bool posnFl=true );
  void          _insertNewCtl( ctl_t* cp, const cmDspUiHdr_t* m, Fl_Widget* wdgt, unsigned* varIdArray, unsigned varIdCnt );

  void          _createSlider(  const cmDspUiHdr_t* m );
  void          _setSldrValue( ctl_t* cp, unsigned instVarId, const cmDspValue_t* vp );
  void          _createText(  const cmDspUiHdr_t* m );
  void          _setTextValue( ctl_t* cp, unsigned instVarId, const cmDspValue_t* vp );
  void          _createFnameCtl(   const cmDspUiHdr_t* m );
  void          _setFnamValue( ctl_t* cp, unsigned instVarId, const cmDspValue_t* vp );
  void          _createMlistCtl(   const cmDspUiHdr_t* m );
  kcKmRC_t      _loadMlist( ctl_t* cp, const cmJsonNode_t* np );
  void          _setMlistValue( ctl_t* cp, unsigned instVarId, const cmDspValue_t* vp );
  void          _createMeter( const cmDspUiHdr_t* m );
  void          _setMeterValue( ctl_t* cp, unsigned instVarId, const cmDspValue_t* vp );
  void          _createButton( const cmDspUiHdr_t* m );
  void          _setButtonValue( ctl_t* cp, unsigned instVarId, const cmDspValue_t* vp );
  void          _createCheck( const cmDspUiHdr_t* m );
  void          _setCheckValue( ctl_t* cp, unsigned instVarId, const cmDspValue_t* vp );
  void          _createLabel( const cmDspUiHdr_t* m );
  void          _setLabelValue( ctl_t* cp, unsigned instVarId, const cmDspValue_t* vp );
  void          _createTmln(  const cmDspUiHdr_t* m );
  void          _setTmlnValue( ctl_t* cp, unsigned instVarId, const cmDspValue_t* vp );
  void          _newColumn( const cmDspUiHdr_t* m );

  void          _insertAudioSysCfgLabel(unsigned long idx, const cmChar_t* label );
  void          _insertDeviceLabel( unsigned long idx, bool inputFl, const cmChar_t* label );
  void          _insertProgramLabel( unsigned long idx, const cmChar_t* label );
  void          _insertSubSysCnt( unsigned long subSysCnt );
  unsigned      _getCurAudioSubSysIdx();
  void          _setMenuButton( Fl_Menu_Button* b, unsigned value, const char* dfltLabel );
  void          _setDeviceMenuButton( unsigned asSubIdx, bool inputFl, unsigned devIdx );
  void          _setSampleRateBtn( unsigned value );

  void          _updateMeters( unsigned asSubIdx, unsigned devIdx, unsigned inFl, const double* meterArray, unsigned meterCnt );
  void          _updateSsStatusIndicator( unsigned asSubIdx, unsigned indicatorIdx, unsigned cnt );
  void          _printStatusCounts();
  void          _handleStatusMsg( const cmAudioSysStatus_t* st, const double* iMeterArray, const double* oMeterArray );
  void          _clearStatusIndicators();

  void          _sendMasterUiMsg(  unsigned asSubIdx, unsigned selId, unsigned instId, unsigned instVarId, const cmDspValue_t* v );
  void          _sendMasterUiValue(unsigned asSubIdx, unsigned instId, const double* v, unsigned vn, const cmChar_t* text );
  void          _createMasterCtl(  unsigned asSubIdx, unsigned selId, unsigned instId, unsigned varCnt, const double* dv, unsigned dn, const cmChar_t* label);
  void          _handleSsInitMsg(  const cmAudioSysSsInitMsg_t* m, const cmChar_t* inDevLabel, const cmChar_t* outDevLabel );
  void          _onRecvValue( const cmDspUiHdr_t* m );
  void          _handleUiMsg( const cmDspUiHdr_t* m );
  void          _getEngMsg();

  static cmRC_t _s_handleSsInitMsg( void* cbDataPtr, const cmAudioSysSsInitMsg_t* r, const char* iDevLabel, const char* oDevLabel );
  static cmRC_t _s_handleStatusMsg( void* cbDataPtr, const cmAudioSysStatus_t* r, const double* iMeterArray, const double* oMeterArray );
  static cmRC_t _s_handleUiMsg(     void* cbDataPtr, const cmDspUiHdr_t* r );

  static kcApp* _getApp( Fl_Widget* w );

  kcKmRC_t      _restartEngine();

  void          _testStub();

  // main app callback
  static void _s_callback(Fl_Widget* wp, void* data);
  void _callback(void* data);

  // idle callback
  static void _s_on_idle(void* data);
  void _on_idle();


  // timer callback
  static void _s_status_timeout_cb(void* userPtr);
  bool _status_timeout_cb();

  static void _s_file_new_cb(Fl_Widget *w, void *data); 
  void _file_new_cb(Fl_Widget *w); 

  static void _s_file_open_cb(Fl_Widget *w, void *data); 
  void _file_open_cb(Fl_Widget *w); 

  static void _s_edit_copy_cb(Fl_Widget *w, void *data); 
  void _edit_copy_cb(Fl_Widget *w); 

  static void _s_edit_paste_cb(Fl_Widget *w, void *data); 
  void _edit_paste_cb(Fl_Widget *w); 

  static void _s_btn_cb(Fl_Widget* w, long data);
  void _btn_cb(Fl_Widget* w,  long arg);

  static void _s_ctl_cb(Fl_Widget* w, void* data);
  void _ctl_cb(ctl_t* cp);

  static void _s_tab_cb(Fl_Widget* w, void* data);
  void _tab_cb(Fl_Widget* w);

  // 
  static void _s_print( void* userPtr, const char* text );

  // called internally by cmTsQueueDequeue() to send text to _print()
  static cmRC_t _s_print_queue_cb(void* userCbPtr, unsigned msgByteCnt, const void* msgDataPtr );

  // called periodically to check the print queue for waiting text.
  void        _checkPrintQueue();

  // send a string of text directly to the output console window
  void        _print( const char* text );


};



#endif