#ifndef FD_xtuner_h_
  #include "xtuner.h"
#endif

extern xtuner_data_t xtuner_data;
extern mixer_data_t mixer_data;
extern flags_t flags;
extern FD_xtuner *mainui;
extern FD_misc   *miscui;
extern Display   *dpy;
extern GC canvasGC; 
extern Window window; 

/* ======================================================================= */
/* Callback for mute button						   */
/* ======================================================================= */
void mute(FL_OBJECT *ob, long flag)
{   
  if (flags.mute_f)
  {
    flags.mute_f = OFF;
    if (flags.radio_f)
      radioon(FCODE(xtuner_data.freq),0xa0);
  }
  else
  {
    flags.mute_f = ON;
    radiooff();
  }
}

/* ======================================================================= */
/* Callback for power button						   */
/* ======================================================================= */
void power(FL_OBJECT *ob, long flag)
{
  if (flags.radio_f)
  {
    fl_show_form(miscui->quitform,FL_PLACE_MOUSE,FL_TRANSIENT,"");
    while (fl_do_forms() != miscui->no)
    {
      if (miscui->yes)
        do_exit();
    }
   
    fl_hide_form(miscui->quitform);
    
    radiooff();
    flags.radio_f = OFF;
    update();
    
    fl_set_button(mainui->power_but,0);
    fl_set_form_title(mainui->xtuner, "Xtuner - OFF");
  }
  else
  {
    if (!flags.mute_f) 
      radioon(FCODE(xtuner_data.freq),0xa0);
    
    is_tuned();
     
    flags.radio_f = ON;
    update();
  }
}

/* ======================================================================== */
/* Callback for the 8 preset buttons; saves presets if set button is active */
/* ======================================================================== */
void preset(FL_OBJECT *ob, long channel)
{
  char str[100];
    
    
  if (!flags.radio_f)
  {
    return;
  }
  
  if (flags.set_f)
  {
    xtuner_data.MemCh[(int)channel-1] = xtuner_data.freq;
    write_file();
    flags.set_f = OFF;
    update();
    fl_set_button(mainui->setmem,0);
    return;
  }
  
  xtuner_data.freq = xtuner_data.MemCh[(int)channel-1];
 
  flags.preset_f = ON;
 
  is_tuned();
  
  update();
    
  if (flags.mute_f)
    return;
  else  
    radioon(FCODE(xtuner_data.MemCh[(int)channel-1]),0xa0);        
}
/* ======================================================================== */
/* Callback for the volume buttons					    */
/* ======================================================================== */
void adjust_volume(FL_OBJECT *ob, long vol)
{

  if (!flags.radio_f || flags.mute_f)
  {
    return;
  }
 
  if (vol == 0)
  {
    volumeup();    
  }
  else if (vol == 1) 
  {
    volumedn();
  }

}

/* ======================================================================== */
/* Callback for fine and course tuning					    */
/* ======================================================================== */
void tuner(FL_OBJECT *ob, long button)
{
  if (!flags.radio_f)
    return;

  switch(button)
  {
    case 0:
      xtuner_data.freq -= .025;
      break;
    case 1:
      xtuner_data.freq -= 1;
      break;
    case 2:
      xtuner_data.freq += .025;
      break;
    case 3:
      xtuner_data.freq += 1;
      break;
  }
  if (xtuner_data.freq > 107.9)
  {
    xtuner_data.freq = 107.9;
  }
  if (xtuner_data.freq < 87.9)
  {
    xtuner_data.freq = 87.9;
  }
  
  flags.preset_f = OFF;
  
  is_tuned();
  
  update();   
      
  if (flags.mute_f)
    return;
     
  radioon(FCODE(xtuner_data.freq),0xa0);
} 

/* ======================================================================= */
/* Callback for the set (mem) button		                           */
/* ======================================================================= */
void set_presets(FL_OBJECT *ob, long but)
{
  if (!flags.radio_f)
  {
    fl_set_button(mainui->setmem,0);
    return;
  }
  if (flags.set_f)
  {
    flags.set_f = OFF;
    update();
    fl_set_button(mainui->setmem,0);
    return;
  }
 
  flags.set_f = ON;
}

/* ======================================================================== */
/* Callback activated when either the sleep, alarm, or clock timers elapse  */
/* ======================================================================== */
void do_timer(FL_OBJECT *ob, long status)
{  
  char buf[5];
  time_t now;
  struct tm *now_tm;
  
  
  /* Set the auto on timer (alarm)*/
  if (status == ON)
  {
    if (!flags.mute_f)
      radioon(FCODE(xtuner_data.freq),0xa0);
    
    flags.radio_f = ON;  
    update();
    fl_set_button(mainui->auto_but,0);
    fl_set_button(mainui->power_but,1);
    is_tuned();
  }
  /* Set the auto off timer (sleep)*/
  else if (status == OFF)
  {
    radiooff();
    flags.radio_f = OFF;
    update();
    fl_set_button(mainui->on_timer_but,0);
    fl_set_button(mainui->power_but,0);
  }
  /* It's time to update the clock */
  else if ((status == UPDATE) && (!flags.disp_type_f))
  {
    now = time(NULL);
    now_tm = localtime(&now);
    if(!flags.miltime_f)
    {
      if (now_tm->tm_hour > 12)
        now_tm->tm_hour -= 12;
      if (now_tm->tm_hour == 0)
        now_tm->tm_hour = 12;
    }
    sprintf(buf,"%2i:%02i",now_tm->tm_hour,now_tm->tm_min);
    XClearArea(dpy, window, 10, 10, 45, 10, 0); 
    XDrawString(dpy, window, canvasGC, 10, 20, buf, 5);                
    fl_set_timer(mainui->update_timer,61);    
  }   
}

/* ======================================================================== */
/* Callback for the sleep and alarm buttons                                 */
/* ======================================================================== */
void set_timer(FL_OBJECT *ob, long status)  
{
  char minute[10];
  char hour[10];
  
  if (status == OFF)
  {
    fl_set_timer(mainui->off_timer,0);
    fl_set_button(mainui->on_timer_but,0);
    return;
  }
  
  if (status == AUTOOFF)
  {
    fl_set_timer(mainui->on_timer,0);
    fl_set_button(mainui->auto_but,0);
    return;
  }
  
  if (status == ON)
    flags.set_type_f = 0;
  else
    flags.set_type_f = 4;
    
  fl_show_form(miscui->set_time,FL_PLACE_MOUSE,FL_NOBORDER,"");
  
  if (flags.set_type_f > 3)
  {      
    sprintf(hour, "%d", xtuner_data.on_hours);
    if (xtuner_data.on_mins < 10)
      sprintf(minute, "0%d", xtuner_data.on_mins);
    else
      sprintf(minute, "%d", xtuner_data.on_mins);
  }
  else 
  {    
    sprintf(hour, "%d", xtuner_data.off_hours);
    if (xtuner_data.off_mins < 10)
      sprintf(minute, "0%d", xtuner_data.off_mins);
    else
      sprintf(minute, "%d", xtuner_data.off_mins);
  }
  
  fl_set_object_label(miscui->hours,hour);
  fl_set_object_label(miscui->mins,minute);
  
  while(fl_do_forms() != miscui->done)
    ;
    
  fl_hide_form(miscui->set_time);
 
  if ((status == ON) && ((xtuner_data.off_hours + xtuner_data.off_mins) > 0))
  {
    fl_set_timer(mainui->off_timer,(xtuner_data.off_hours*60*60) + 
                 xtuner_data.off_mins*60);
  }     
  if (status == AUTOON && ((xtuner_data.on_hours + xtuner_data.on_mins) > 0))
  {
    fl_set_timer(mainui->on_timer,(xtuner_data.on_hours*60*60) +
                 xtuner_data.on_mins*60);
  }
  
  if ((xtuner_data.off_hours + xtuner_data.off_mins) == 0)
    fl_set_button(mainui->on_timer_but,0);
  if ((xtuner_data.on_hours + xtuner_data.on_mins) == 0)    
    fl_set_button(mainui->auto_but,0);
   
}

/* ========================================================================= */
/* Callback for the time adjustment buttons on the set time forms            */
/* ========================================================================= */
void do_set_time(FL_OBJECT *ob, long type)
{
  char minute[10];
  char hour[10];
  
  type += flags.set_type_f;
  
  switch (type)
  {
    case 0: xtuner_data.off_hours++;
            if (xtuner_data.off_hours > 23)
              xtuner_data.off_hours = 23;
            break;
    case 1: xtuner_data.off_hours--;
            if (xtuner_data.off_hours < 0)
              xtuner_data.off_hours = 0;
            break;
    case 2: xtuner_data.off_mins++;
            if (xtuner_data.off_mins > 59)
              xtuner_data.off_mins = 59;
            break;
    case 3: xtuner_data.off_mins--;
            if (xtuner_data.off_mins < 0)
              xtuner_data.off_mins = 0;
            break;
    case 4: xtuner_data.on_hours++;
            if (xtuner_data.on_hours > 23)
              xtuner_data.on_hours = 23;
            break;
    case 5: xtuner_data.on_hours--;
            if (xtuner_data.on_hours < 0)
              xtuner_data.on_hours = 0;
            break;
    case 6: xtuner_data.on_mins++;
            if (xtuner_data.on_mins > 59)
              xtuner_data.on_mins = 59;
            break;
    case 7: xtuner_data.on_mins--;
            if (xtuner_data.on_mins < 0)
              xtuner_data.on_mins = 0;
            break;
    default: break;
  }
  
  if (flags.set_type_f > 3)
  {      
    sprintf(hour, "%d", xtuner_data.on_hours);
    if (xtuner_data.on_mins < 10)
      sprintf(minute, "0%d", xtuner_data.on_mins);
    else
      sprintf(minute, "%d", xtuner_data.on_mins);
  }
  else 
  {    
    sprintf(hour, "%d", xtuner_data.off_hours);
    if (xtuner_data.off_mins < 10)
      sprintf(minute, "0%d", xtuner_data.off_mins);
    else
      sprintf(minute, "%d", xtuner_data.off_mins);
  }
  
  fl_set_object_label(miscui->hours,hour);
  fl_set_object_label(miscui->mins,minute);
}

/* ======================================================================= */
/* Callback mixer adjustments			                           */
/* ======================================================================= */
void mixer(FL_OBJECT *ob, long but)
{
  if (mixer_data.mixer_supp != TRUE)
    return;
    
  switch(but)
  {
     case BASS_DOWN:
       if (mixer_data.bass_level < 0)
         break;
       mixer_data.bass_level--;
       adjust_mixer(SOUND_MIXER_BASS);
       break;
     case BASS_UP:
       if (mixer_data.bass_level > 100)
         break;
       mixer_data.bass_level++;
       adjust_mixer(SOUND_MIXER_BASS);
       break;
     case TREBLE_DOWN:
       if (mixer_data.treble_level < 0)
         break;
       mixer_data.treble_level--;
       adjust_mixer(SOUND_MIXER_TREBLE);
       break;
     case TREBLE_UP:
       if (mixer_data.treble_level > 100)
         break;
       mixer_data.treble_level++;
       adjust_mixer(SOUND_MIXER_TREBLE);
       break;
     default:
       break;
  }
  
  update();
}