src/apps/codycam/CodyCam.h

   1 #ifndef CODYCAM_H
   2 #define CODYCAM_H
   3
   4
   5 #include "Settings.h"
   6 #include "VideoConsumer.h"
   7
   8 #include <string.h>
   9
  10 #include <Application.h>
  11 #include <Box.h>
  12 #include <Catalog.h>
  13 #include <CheckBox.h>
  14 #include <Locale.h>
  15 #include <Menu.h>
  16 #include <MenuField.h>
  17 #include <StringView.h>
  18 #include <TextControl.h>
  19 #include <Window.h>
  20
  21
  22 class BMediaRoster;
  23
  24
  25 enum {
  26         msg_filename    = 'file',
  27
  28         msg_rate_changed = 'rate',
  29
  30         msg_translate   = 'tran',
  31
  32         msg_upl_client  = 'ucli',
  33         msg_server              = 'srvr',
  34         msg_login               = 'lgin',
  35         msg_password    = 'pswd',
  36         msg_directory   = 'drct',
  37         msg_passiveftp  = 'pasv',
  38         msg_pswrd_text  = 'pstx',
  39
  40         msg_start               = 'strt',
  41         msg_stop                = 'stop',
  42
  43         msg_setup               = 'setp',
  44         msg_video               = 'vdeo',
  45
  46         msg_control_win = 'ctlw'
  47 };
  48
  49
  50 struct capture_rate {
  51         const char* name;
  52         time_t          seconds;
  53 };
  54
  55
  56 // NOTE: These are translated once the app catalog is loaded.
  57 capture_rate kCaptureRates[] = {
  58         {"Every 15 seconds", 15 },
  59         {"Every 30 seconds", 30 },
  60         {"Every minute", 60 },
  61         {"Every 5 minutes", 5 * 60 },
  62         {"Every 10 minutes", 10 * 60 },
  63         {"Every 15 minutes", 15 * 60 },
  64         {"Every 30 minutes", 30 * 60 },
  65         {"Every hour", 60 * 60 },
  66         {"Every 2 hours", 2 * 60 * 60 },
  67         {"Every 4 hours", 4 * 60 * 60 },
  68         {"Every 8 hours", 8 * 60 * 60 },
  69         {"Every 24 hours", 24 * 60 * 60 },
  70         {"Never", 0 }
  71 };
  72
  73
  74 const int32 kCaptureRatesCount = sizeof(kCaptureRates) / sizeof(capture_rate);
  75
  76
  77 const char* kUploadClients[] = {
  78         // NOTE: These are translated once the app catalog is loaded.
  79         "FTP",
  80         "SFTP",
  81         "Local"
  82 };
  83
  84
  85 const int32 kUploadClientsCount = sizeof(kUploadClients) / sizeof(char*);
  86
  87 class VideoWindow;
  88 class ControlWindow;
  89
  90 class CodyCam : public BApplication {
  91 public:
  92                                                         CodyCam();
  93         virtual                                 ~CodyCam();
  94
  95                         void                    ReadyToRun();
  96         virtual bool                    QuitRequested();
  97         virtual void                    MessageReceived(BMessage* message);
  98
  99 private:
 100                         status_t                _SetUpNodes();
 101                         void                    _TearDownNodes();
 102
 103                         BMediaRoster*   fMediaRoster;
 104                         media_node              fTimeSourceNode;
 105                         media_node              fProducerNode;
 106                         VideoConsumer*  fVideoConsumer;
 107                         media_output    fProducerOut;
 108                         media_input             fConsumerIn;
 109                         VideoWindow*    fWindow;
 110                         port_id                 fPort;
 111                         ControlWindow*  fVideoControlWindow;
 112 };
 113
 114
 115 class VideoWindow : public BWindow {
 116 public:
 117                                                         VideoWindow(const char* title,
 118                                                                 window_type type, uint32 flags,
 119                                                                 port_id* consumerport);
 120                                                         ~VideoWindow();
 121
 122         virtual bool                    QuitRequested();
 123         virtual void                    MessageReceived(BMessage* message);
 124
 125                         void                    ApplyControls();
 126
 127                         BView*                  VideoView();
 128                         BStringView*    StatusLine();
 129                         void                    ToggleMenuOnOff();
 130
 131                         void                    ErrorAlert(const char*, status_t);
 132
 133 private:
 134                         void                    _BuildCaptureControls();
 135
 136                         void                    _SetUpSettings(const char* filename,
 137                                                                 const char* dirname);
 138                         void                    _UploadClientChanged();
 139                         void                    _QuitSettings();
 140
 141 private:
 142                         media_node*             fProducer;
 143                         port_id*                fPortPtr;
 144
 145                         BView*                  fVideoView;
 146                         BTextView*      fErrorView;
 147
 148                         BTextControl*   fFileName;
 149                         BBox*                   fCaptureSetupBox;
 150                         BMenu*                  fCaptureRateMenu;
 151                         BMenuField*             fCaptureRateSelector;
 152                         BMenu*                  fImageFormatMenu;
 153                         BMenuField*             fImageFormatSelector;
 154                         BMenu*                  fUploadClientMenu;
 155                         BMenuField*             fUploadClientSelector;
 156                         BBox*                   fFtpSetupBox;
 157                         BTextControl*   fServerName;
 158                         BTextControl*   fLoginId;
 159                         BTextControl*   fPassword;
 160                         BTextControl*   fDirectory;
 161                         BCheckBox*              fPassiveFtp;
 162                         BBox*                   fStatusBox;
 163                         BStringView*    fStatusLine;
 164
 165                         ftp_msg_info    fFtpInfo;
 166
 167                         Settings*               fSettings;
 168
 169                         BMenu*                  fMenu;
 170
 171                         StringValueSetting*             fServerSetting;
 172                         StringValueSetting*             fLoginSetting;
 173                         StringValueSetting*             fPasswordSetting;
 174                         StringValueSetting*             fDirectorySetting;
 175                         BooleanValueSetting*    fPassiveFtpSetting;
 176                         StringValueSetting*             fFilenameSetting;
 177                         StringValueSetting*             fImageFormatSettings;
 178
 179                         EnumeratedStringValueSetting*   fUploadClientSetting;
 180                         EnumeratedStringValueSetting*   fCaptureRateSetting;
 181 };
 182
 183
 184 class ControlWindow : public BWindow {
 185 public:
 186                                                         ControlWindow(BView* controls,
 187                                                                 media_node node);
 188                         void                    MessageReceived(BMessage* message);
 189                         bool                    QuitRequested();
 190
 191 private:
 192                         BView*                  fView;
 193                         media_node              fNode;
 194 };
 195
 196 #endif  // CODYCAM_H
 197