MainDialog.cpp

Go to the documentation of this file.

//
// File: MainDialog.cpp
// Created by: cc <cc@cmn42.Stanford.EDU>
// Created on: Sun Mar  2 10:20:41 2003
//

#include "MainDialog.h"
#include "qapplication.h"
#include "qradiobutton.h"
#include "qpushbutton.h"
#include "qprogressbar.h"
#include "qslider.h"
#include "qaccel.h"
#include "Jukebox.h"
#include "Logger.h"
using namespace std;
#include <iostream>
#include <vector>
#include <algorithm>
#include <time.h>
#include <stdlib.h>

extern Snd *theSnd;

MainDialog::MainDialog (QWidget * parent, const char *name):
  MainForm (parent, name)               // generated by designer
{
  juke = new Jukebox ();        // read in files, count 'em
  nTalk = juke->getNumTalkFiles() / CH;
  nMask = juke->getNumMaskFiles() / CH;
  independent_talk_conditions = nTalk-1;        
  nTrials = independent_talk_conditions * nMask;
  juke->setNumTrials(nTrials);
  cout << "nTrials = " << nTrials << endl;
  
  //=========================================================
  /*
    DEFINE HERE OUTPUT PATH and TEST NAME
    -------------------------------------
    TEST NAME Should have the Following Name Convension:
    exp#_subjID
    for example: experiment01_Subject01
    Don't Forget to define the names of the output files
    Use a different file name for each subject, and the same
    name for the experiment tipe.
    A Complete example will be:
    QString logRoot ("/zap/"); // output directory
    log = new Logger ("experiment01_Subject01", // ID
                      logRoot + "experiment01_Subject01.dat", // single subject file
                      logRoot + "experiment01.dat"      // all subjects file
    );
  */

  QString logRoot ("/zap/"); // output directory
  log = new Logger ("experiment01_Subject01",   // ID
                    logRoot + "experiment01_Subject01.dat", // single subject file
                    logRoot + "experiment01.dat"        // all subjects file
                    );
  //===========================================================
  
  mythreads.setAutoDelete (true);
  
  /* link threads to start / stop */
  addThread (theSnd, false);    // not a thread now that we're using jack
  
  /* add to orch */
  theSnd->addInstrument (juke);
  
  /* wire up the signals and slots */
  // GUI next pair
  connect ((QObject *) nextB, SIGNAL (clicked ()), this,
           SLOT (trialTick ()));
  // GUI stop playing
  connect ((QObject *) stopB, SIGNAL (clicked ()), juke,
           SLOT (stopPlay ()));
  // GUI play file A
  connect ((QObject *) AplayB, SIGNAL (clicked ()), juke,
           SLOT (playA ()));
  // GUI play file B
  connect ((QObject *) BplayB, SIGNAL (clicked ()), juke,
           SLOT (playB ()));
  // GUI show progress
  connect ((QObject *) juke, SIGNAL (updateProgress (int)), progressBar,
           SLOT (setProgress (int)));
  // quit from inside program
  connect ((QObject *) juke, SIGNAL (quitAll ()),
           qApp, SLOT (closeAllWindows ()));
  // GUI <ctrl>q 
  QAccel *a = new QAccel (this);
  a->connectItem (a->insertItem (Key_Q + CTRL),
                  qApp, SLOT (closeAllWindows ()));
  
  goThreads (true); // run
  
  
  /*JPa**************************************************************************** 
    Create vectores and shuffle them to use in the experiment
    This vectors will be shuffled once (here) and then is just reading them 
    The mothod is crating a vector of all the pair that will be tested, and then 
    shuffle that vector. For example:
    TalkMask_matrix[0] = [0,0]
    TalkMask_matrix[1] = [1,0]
    TalkMask_matrix[2] = [2,0]
    TalkMask_matrix[3] = [3,0]    
    TalkMask_matrix[4] = [0,1]
    TalkMask_matrix[5] = [1,1]
    TalkMask_matrix[6] = [2,1]
    TalkMask_matrix[7] = [3,1]
    and then we shuffle this TalkMask_matrix, so we are sure that each combination
    is represented.
  ******************************************************************************/
  vector<int> TalkMask(2,0); //creates a vector of 2 ints of value 0
  for (int i = 0; i < independent_talk_conditions*nMask; i++) {
    //TalkMask[0] = 1 + (i % independent_talk_conditions); //Talks counts [1,2,3,4,1,2,3,4,...]
    TalkMask[0] = (i % independent_talk_conditions); //Talks counts [0,1,2,3,0,1,2,3,...]
    TalkMask[1] = i/independent_talk_conditions; //Masks // counts [0,0,0,0,1,1,1,1,2,...]
    TalkMask_matrix.push_back(TalkMask);
  }
  srand (time(0)); // need to call srand to get a different arrangement each time the program is called
  random_shuffle(TalkMask_matrix.begin(), TalkMask_matrix.end()); //Shuffle matrix vector
  //*******************************************************************************
  
  curTrial = 0;
  setTrial (curTrial);
  
  juke->setTrial (curTrial, curTalk, curMask, silenceIsA); // set jukebox for trial
  //JPa**************************************************************************** 
  stopB->setChecked(true);
  //**********************************************************************8
  
}

void MainDialog::loggerTick ()
{
  // silence is playing from button A and user selected button A
  bool inResult = (silenceIsA == AselectB->isChecked ());
  log->writeData (curTalk, curMask, inResult);
}

void MainDialog::trialTick ()
{
  //JPa****************************************************************************
  if (!(AselectB->isChecked()) &&  !(BselectB->isChecked())) {
    cout << "Please Select One of the Options..." << endl;
  }
  //********************************************************************************
  else {
    loggerTick (); // log last response
    setTrial (++curTrial); // set trial params  ///HERE IS THE PROBLEM!!!!!!!!!!!!!!!!!!!

    //JPa***************************************************************************
    juke->stopPlay(); //stop playbck of noises in new trial
    //***************************************************************
    juke->setTrial (curTrial, curTalk, curMask, silenceIsA); // set jukebox for trial
    
    //JPa***************************************************************************
    //Un-check all radio buttons when user presses next
    //I couldn't find a better way to do this (it was painful...)
    stopB->setChecked(true); // check stop button, since the sounds are stoping in the new trial
    AselectB->setChecked(false);
    BselectB->setChecked(false);
    AplayB->setChecked(false);
    BplayB->setChecked(false);
    //*******************************************************************************
  }
}

void MainDialog::setTrial (int n)
{       
  //  cout << "CACACACACA" << endl;
  if (n == nTrials)
    cout << "DONE " << endl;
  else {
    //JPa ******************************************************************************
    vector<int> aux_talkmask = TalkMask_matrix[n];
    curTalk = aux_talkmask[0];
    curMask = aux_talkmask[1];
    //**********************************************************************************
    
    //curTalk = 1 + (n % independent_talk_conditions); // counts [1,2,3,4,1,2,3,4,...]
    //curMask = n/independent_talk_conditions; // counts [0,0,0,0,1,1,1,1,2,...]
    
    //silenceIsA = true;
    
    //JPa ******************************************************************************
    //Fix silenceIsA to a random true or false
    srand( (unsigned)time( NULL ) );
    silenceIsA = rand() % 2; //Random number 0 or 1    
    //**********************************************************************************
    //cout << "TRIAL " << curTrial << " (" << curTalk << ", " << curMask << ", " << silenceIsA <<")" << endl;
  }
}

MainDialog::~MainDialog ()
{
  //cout << "DESTRUCTOR" << endl;
  //delete juke;
  delete log;
}

void MainDialog::goThreads (bool go)
{
  if (go)
    {
      emit startThread ();
    }
  else
    {
      emit stopThread ();
      emit joinThread ();
    }
}

void MainDialog::addThread (QObject * t, bool isThread)
/* append thread to mythreads list */
{
  mythreads.append (t);
  connect (this, SIGNAL (startThread ()), t, SLOT (go ()));
  connect (this, SIGNAL (stopThread ()), t, SLOT (stop ()));
  if (isThread)
    connect (this, SIGNAL (joinThread ()), t, SLOT (join ()));
}

void MainDialog::closeEvent (QCloseEvent * e)
{
  if (mythreads.count ())
    goThreads (false);
  jack->stop ();
  while (qApp->hasPendingEvents ())
    qApp->processEvents ();
  e->accept ();
}

void MainDialog::customEvent (QCustomEvent * e)
{
  if (e->type () == QEvent::User + 117)
    /* received from xxx */
    {
      ThreadCommEvent *ce = (ThreadCommEvent *) e;
      //      yyy (ce->val0 (), ce->val1 (),  ce->val2 ());
    }
}

int get_fifo_priority (bool notMax)
{
  int min, max, priority;
  
  min = sched_get_priority_min (SCHED_FIFO);
  max = sched_get_priority_max (SCHED_FIFO);
  if (notMax)
    priority = min + (max - min) / 2;
  else
    priority = max;
  //      priority=min;
  return priority;
}

int set_fifo_priority (bool half)
{
  struct sched_param p;
  int priority;
  //  scheduling priority
  
  
  if (true)             // (!getuid () || !geteuid ())
    {
      priority = get_fifo_priority (half);
      p.sched_priority = priority;
      
      if (sched_setscheduler (0, SCHED_FIFO, &p) == -1)
        {
          fprintf (stderr,
                   "\ncould not activate scheduling with priority %d\n",
                   priority);
          return -1;
        }
      seteuid (getuid ());
      //                fprintf (stderr,
      //                         "\nset scheduling priority to %d (SCHED_FIFO)\n",
      //                         priority);
    }
  else
    {
      fprintf (stderr,
               "\ninsufficient privileges to set scheduling priority\n");
      priority = 0;
    }
  return priority;
}

---