popup.cc

一个共享源码的音频库4

// This file contains no license whatsoever. It is provided in the public domain as an example
// of how to use the audio library
//
// Bruce Forsberg
// [e-mail]
// 
//


#include <stdio.h>
#include <stdlib.h>
#include <sys/ioctl.h>
#include <unistd.h>
#include <iostream.h>

#include <X11/X.h>

extern "C"
{
#include <Xm/Xm.h>
#include <Xm/Form.h>
#include <Xm/DrawingA.h>
#include <Xm/LabelG.h>
#include <Xm/PushBG.h>
#include <Xm/RowColumn.h>
#include <Xm/SeparatoG.h>
#include <Xm/FileSB.h>
#include <Xm/SelectioB.h>
#include <Xm/DialogS.h>
#include <Xm/PanedW.h>
#include <Xm/List.h>
#include <Xm/Text.h>
#include <Xm/Label.h>
#include <Xm/ToggleB.h>
}

#include "audio.h"
#include "popup.h"
#include "gui.h"
#include "string.h"
#include "aflibFile.h"
#include "aflibConfig.h"
#include "aflibDateTime.h"
#include "aflibEnvFile.h"
#include "aflibAudioRecorder.h"

extern void
popup_configure_dialog(
   Widget  w,
   caddr_t client_data,
   XmAnyCallbackStruct *cbs);

extern void
popup_play_dialog(
   Widget  w,
   caddr_t client_data,
   XmAnyCallbackStruct *cbs);

extern void
popup_record_callback(
   Widget  w,
   caddr_t client_data,
   XmAnyCallbackStruct *cbs);

extern void
popup_format_cb(
   Widget  w,
   caddr_t client_data,
   XmAnyCallbackStruct *cbs);

extern void
popup_program_dialog(
   Widget  w,
   caddr_t client_data,
   XmAnyCallbackStruct *cbs);

extern void
popup_exit_dialog(
   Widget  w,
   caddr_t client_data,
   XmAnyCallbackStruct *cbs);

extern void
popup_play_file(
   Widget w,
   caddr_t client_data,
   XmFileSelectionBoxCallbackStruct  *cbs);

extern void
popup_record_file(
   Widget w,
   caddr_t client_data,
   XmFileSelectionBoxCallbackStruct  *cbs);

extern void
popup_cancel_file(
   Widget w,
   caddr_t client_data,
   XmFileSelectionBoxCallbackStruct  *cbs);

extern void
promptCallback(
   Widget w,
   caddr_t client_data,
   XmSelectionBoxCallbackStruct  *cbs);

extern void
popup_record_dialog(
   Widget w);

extern void
popup_record_close(
   Widget  w,
   caddr_t client_data,
   XmAnyCallbackStruct *cbs);

extern void
popup_record_edit(
   Widget  w,
   caddr_t client_data,
   XmAnyCallbackStruct *cbs);

extern void
popup_record_add(
   Widget  w,
   caddr_t client_data,
   XmAnyCallbackStruct *cbs);

extern void
popup_record_delete(
   Widget  w,
   caddr_t client_data,
   XmAnyCallbackStruct *cbs);

extern void
popup_config_dialog(
   Widget w);

extern void
popup_record_update_list();


typedef struct _menu_item
{
   char         * label;
   WidgetClass  * _class;
   char           mnemonic;
   char         * accelerator;
   char         * accel_text;
   void          (*callback)(Widget, void *, void *);
   caddr_t        callback_data;
   struct _menu_item  *subitem;
} MenuItem;

MenuItem items[] = {
   { "Audio Player", &xmLabelGadgetClass, (char) 0, NULL, 
     NULL, NULL, NULL, NULL},
   { "sep", &xmSeparatorGadgetClass, (char) 0, NULL,
     NULL, NULL, NULL, NULL},
   { "Configure...", &xmPushButtonGadgetClass, 'C', "Ctrl<Key>C",
     "Ctrl+C", popup_configure_dialog, NULL, NULL},
   { "Play...", &xmPushButtonGadgetClass, 'P', "Ctrl<Key>P",
     "Ctrl+P", popup_play_dialog, NULL, NULL},
   { "Record...", &xmPushButtonGadgetClass, 'R', "Ctrl<Key>R",
     "Ctrl+R", popup_record_callback, NULL, NULL},
   { "Program Record...", &xmPushButtonGadgetClass, 'V', "Ctrl<Key>V",
     "Ctrl+V", popup_program_dialog, NULL, NULL},
   { "sep1", &xmSeparatorGadgetClass, (char) 0, NULL,
     NULL, NULL, NULL, NULL},
   { "Exit", &xmPushButtonGadgetClass, 'E', "Ctrl<Key>E",
     "Ctrl+E", popup_exit_dialog, NULL, NULL},
   { NULL, NULL, (char) 0, NULL, NULL, NULL, NULL, NULL}
};

#define DEFAULT_DEVICE "/dev/audio"


static Widget  _form = NULL;
static Widget  list1;
static Widget  _text1, _text2, _text3, _text4, _text5, _text6;
static string  _record_file;
static int     _channels = 1;
static int     _samples_per_second = 22050;
static int     _bytes_per_sample = 1;
static string  _format_type;
static int     _timer_record_mode = FALSE;
static aflibConfig  _config;


aflibAudioRecorder *  _recorder = NULL;

void
popup_configure_dialog(
   Widget  w,
   caddr_t client_data,
   XmAnyCallbackStruct *cbs)
{
   popup_device_dialog(_form);
}

void
popup_play_dialog(
   Widget  w,
   caddr_t client_data,
   XmAnyCallbackStruct *cbs)
{
   Arg  args[10];
   int  n;
   static Widget dialog = 0;
   XmString  str;

   if (!dialog)
   {
      str = XmStringCreateSimple("Select File to Play");

      n = 0;
      XtSetArg(args[n], XmNdialogStyle, XmDIALOG_FULL_APPLICATION_MODAL); n++;
      XtSetArg(args[n], XmNdialogTitle, str); n++;
      dialog = XmCreateFileSelectionDialog(_form, "FileBox", args, n);
      XtUnmanageChild(XmSelectionBoxGetChild(dialog, XmDIALOG_HELP_BUTTON));
      XtAddCallback(dialog, XmNokCallback, popup_play_file, NULL);
      XtAddCallback(dialog, XmNcancelCallback, popup_cancel_file, NULL);

      XmStringFree(str);
   }

   XtManageChild(dialog);
   XtPopup(XtParent(dialog), XtGrabNone);

}

void
popup_record_callback(
   Widget  w,
   caddr_t client_data,
   XmAnyCallbackStruct *cbs)
{
   Arg  args[10];
   int  n;
   static Widget dialog = 0;
   XmString  str;

   if (!dialog)
   {
      str = XmStringCreateSimple("Select File to Record");

      n = 0;
      XtSetArg(args[n], XmNdialogStyle, XmDIALOG_FULL_APPLICATION_MODAL); n++;
      XtSetArg(args[n], XmNdialogTitle, str); n++;
      dialog = XmCreateFileSelectionDialog(_form, "FileBox", args, n);
      XtUnmanageChild(XmSelectionBoxGetChild(dialog, XmDIALOG_HELP_BUTTON));
      XtAddCallback(dialog, XmNokCallback, popup_record_file, NULL);
      XtAddCallback(dialog, XmNcancelCallback, popup_cancel_file, NULL);

      XmStringFree(str);
   }
   XtManageChild(dialog);
   XtPopup(XtParent(dialog), XtGrabNone);
}

void
popup_program_dialog(
   Widget  w,
   caddr_t client_data,
   XmAnyCallbackStruct *cbs)
{
   popup_record_dialog(_form);
}

void
popup_exit_dialog(
   Widget  w,
   caddr_t client_data,
   XmAnyCallbackStruct *cbs)
{
   audio_stop();
   exit(1);
}

void
popup_play_file(
   Widget w,
   caddr_t client_data,
   XmFileSelectionBoxCallbackStruct  *cbs)
{
   char * file = NULL;

   if (cbs)
   {
      if (!XmStringGetLtoR(cbs->value, XmSTRING_DEFAULT_CHARSET, &file))
         return;

      audio_play(file);
      XtFree(file);
   }
   XtUnmanageChild(w);
}

void
popup_record_file(
   Widget w,
   caddr_t client_data,
   XmFileSelectionBoxCallbackStruct  *cbs)
{
   char * file = NULL;

   if (cbs)
   {
      if (!XmStringGetLtoR(cbs->value, XmSTRING_DEFAULT_CHARSET, &file))
         return;

      _record_file = file;
      XtFree(file);
   }
   XtUnmanageChild(w);

   popup_config_dialog(_form);
}


void
popup_cancel_file(
   Widget w,
   caddr_t client_data,
   XmFileSelectionBoxCallbackStruct  *cbs)
{
   XtUnmanageChild(w);
}


Widget
popup_build(
   Widget  parent,
   int     menu_type)
{
   Widget  menu, widget;
   int i;
   XmString str;

   _form = parent;

   menu = XmCreatePopupMenu(parent, "_popup", NULL, 0);

   for (i = 0; items[i].label != NULL; i++)
   {
      widget = XtVaCreateManagedWidget(items[i].label,
         *items[i]._class, menu, 
         NULL);

      if (items[i].mnemonic)
      {
         XtVaSetValues(widget, XmNmnemonic, items[i].mnemonic, NULL);
      }

      if (items[i].accelerator)
      {
         str = XmStringCreateSimple(items[i].accel_text);
         XtVaSetValues(widget,
            XmNaccelerator, items[i].accelerator,
            XmNacceleratorText, str,
            NULL);
         XmStringFree(str);
      }

      if (items[i].callback)
      {
         XtAddCallback(widget, XmNactivateCallback,
            items[i].callback, items[i].callback_data);
      }
   }
   return (menu);
}


void
popup_device_dialog(
   Widget w)
{
   Arg   args[10];
   int   n;
   Widget  widget, dead_widget, text_widget;
   XmString  str, str1;
   string value;
   string key(PORT_KEY);
   aflibEnvFile env(ENV_FILE);


   str = XmStringCreateLtoR("Please enter the audio device now.\n\
For linux you should use /dev/audio for most cases.",
      XmSTRING_DEFAULT_CHARSET);
   env.readValueFromFile(key, value);

   str1 = XmStringCreateSimple("Configure");
   
   /* Create dialog */
   n = 0;
   XtSetArg(args[n], XmNselectionLabelString, str); n++;
   XtSetArg(args[n], XmNdialogStyle, XmDIALOG_PRIMARY_APPLICATION_MODAL); n++;
   XtSetArg(args[n], XmNdialogTitle, str1); n++;
   widget = XmCreatePromptDialog(w, "Configure", args, n);
   XtAddCallback(widget, XmNokCallback, promptCallback, NULL);

   /* Get the text widget and insert a default value */
   text_widget = XmSelectionBoxGetChild(widget, XmDIALOG_TEXT);
   n = 0;
   XtSetArg(args[n], XmNvalue, value.c_str()); n++;
   XtSetValues(text_widget, args, n);

   /* get rid of two buttons. We only want OK button */
   dead_widget = XmSelectionBoxGetChild(widget, XmDIALOG_HELP_BUTTON);
   XtUnmanageChild(dead_widget);
   dead_widget = XmSelectionBoxGetChild(widget, XmDIALOG_CANCEL_BUTTON);
   XtUnmanageChild(dead_widget);

   XtManageChild(widget);

   XmStringFree(str);
   XmStringFree(str1);
}

void
promptCallback(
   Widget w,
   caddr_t client_data,
   XmSelectionBoxCallbackStruct  *cbs)
{
   char * str;
   string key, device_str;

   /* get the device value entered in the prompt dialog */
   if (!XmStringGetLtoR(cbs->value, XmSTRING_DEFAULT_CHARSET, &str))
   {
      return;
   }

   audio_device(str);

   key = PORT_KEY;
   device_str = str;
   aflibEnvFile env(ENV_FILE);
   env.writeValueToFile(key, device_str);

   XtFree(str);
}

void
popup_record_dialog(
   Widget w)
{
   Widget shell, pane, form1, row;
   Widget form2, close, edit, delete1, add;
   Widget label1, label2, label3, label4, label5, label6;
   Widget label11, label12, label13, label14, label15, label16;
   Widget file;
   Widget place1, place2, place3, place4, place5;
   Arg   args[10];
   int   n;


   n = 0;
   XtSetArg(args[n], XmNdeleteResponse, XmDESTROY); n++;
   shell = XmCreateDialogShell(w, "Programmed Record", args, n);

   n = 0;
   pane = XmCreatePanedWindow(shell, "Record Pane", args, n);

   n = 0;
   form1 = XmCreateForm(pane, "Form1", args, n);

   n = 0;
   XtSetArg(args[n], XmNorientation, XmHORIZONTAL); n++;
   XtSetArg(args[n], XmNpacking, XmPACK_COLUMN); n++;
   XtSetArg(args[n], XmNnumColumns, 4); n++;
   row = XmCreateRowColumn(form1, "RowCol1", args, n);

   n = 0;
   label1 = XmCreateLabel(row, "Start Date", args, n);
   XtManageChild(label1);

   n = 0;
   label2 = XmCreateLabel(row, "Start Time", args, n);
   XtManageChild(label2);

   n = 0;
   label3 = XmCreateLabel(row, "Stop Date", args, n);
   XtManageChild(label3);

   n = 0;
   label4 = XmCreateLabel(row, "Stop Time", args, n);
   XtManageChild(label4);

   n = 0;
   label5 = XmCreateLabel(row, "Each Limit", args, n);
   XtManageChild(label5);

   n = 0;
   label6 = XmCreateLabel(row, "Max Limit", args, n);
   XtManageChild(label6);

   n = 0;
   label11 = XmCreateLabel(row, "(MM/DD/YYYY)", args, n);
   XtManageChild(label11);

   n = 0;
   label12 = XmCreateLabel(row, "(HH:MM:SS)", args, n);
   XtManageChild(label12);

   n = 0;
   label13 = XmCreateLabel(row, "(MM/DD/YYYY)", args, n);
   XtManageChild(label13);

   n = 0;
   label14 = XmCreateLabel(row, "(HH:MM:SS)", args, n);
   XtManageChild(label14);

   n = 0;
   label15 = XmCreateLabel(row, "(Bytes)", args, n);
   XtManageChild(label15);

   n = 0;
   label16 = XmCreateLabel(row, "(Bytes)", args, n);
   XtManageChild(label16);

   n = 0;
   XtSetArg(args[n], XmNcolumns, 10); n++;
   XtSetArg(args[n], XmNmarginWidth, 2); n++;
   _text1 = XmCreateText(row, "Start Date", args, n);
   XtManageChild(_text1);

   n = 0;
   XtSetArg(args[n], XmNcolumns, 10); n++;
   XtSetArg(args[n], XmNmarginWidth, 2); n++;