callbacks.c

Coriander is a GUI for controlling a Digital Camera (in the sense of the IIDC specs issued by the 1

    if (dc1394_set_white_balance(camera->camera_info.handle, camera->camera_info.id, camera->feature_set.feature[FEATURE_WHITE_BALANCE-FEATURE_MIN].BU_value, adj->value)!=DC1394_SUCCESS)
      MainError("Could not set R/V white balance");
    else {
      camera->feature_set.feature[FEATURE_WHITE_BALANCE-FEATURE_MIN].RV_value=adj->value;
      if (camera->feature_set.feature[FEATURE_WHITE_BALANCE-FEATURE_MIN].absolute_capable!=0) {
	GetAbsValue(FEATURE_WHITE_BALANCE);
      }
    }
    break;
  case FEATURE_WHITE_SHADING:
    fprintf(stderr,"Not yet implemented\n");
    break;
    
  default: // includes trigger_count
    if (dc1394_set_feature_value(camera->camera_info.handle, camera->camera_info.id,(int)user_data,adj->value)!=DC1394_SUCCESS)
      MainError("Could not set feature");
    else {
      camera->feature_set.feature[(int)user_data-FEATURE_MIN].value=adj->value;
      if ((int)user_data!=FEATURE_TRIGGER) {
	if (camera->feature_set.feature[(int)user_data-FEATURE_MIN].absolute_capable!=0) {
	  GetAbsValue((int)user_data);
	}
      }
    }
    // optical filter sometimes changes white balance (sony cameras) so we update the WB.
    if ((int)user_data==FEATURE_OPTICAL_FILTER) {
      UpdateRange(FEATURE_WHITE_BALANCE);
    }
    break;
  }
}

void
on_format7_value_changed             ( GtkAdjustment    *adj,
				       gpointer         user_data)
{
  int sx, sy, px, py;
  Format7ModeInfo_t* info;

  if (camera->format7_info.edit_mode>=0) { // check if F7 is supported
    info=&camera->format7_info.mode[camera->format7_info.edit_mode-MODE_FORMAT7_MIN];
    sx=info->size_x;
    sy=info->size_y;
    px=info->pos_x;
    py=info->pos_y;
    /*
    fprintf(stderr,"%d %d %d %d %d %d\n",info->max_size_x, info->max_size_y,
	    info->step_x, info->step_y, 
	    info->step_pos_x, info->step_pos_y);
    */
    switch((int)user_data) {
    case FORMAT7_SIZE_X:
      sx=adj->value;
      sx=NearestValue(sx,info->unit_size_x, info->unit_size_x, info->max_size_x - px);
      break;
    case FORMAT7_SIZE_Y:
      sy=adj->value;
      sy=NearestValue(sy,info->unit_size_y, info->unit_size_y, info->max_size_y - py);
      break;
    case FORMAT7_POS_X:
      px=adj->value;
      px=NearestValue(px,info->unit_pos_x, 0, info->max_size_x - info->unit_pos_x);
      break;
    case FORMAT7_POS_Y:
      py=adj->value;
      py=NearestValue(py,info->unit_pos_y, 0, info->max_size_y - info->unit_pos_y);
      break;
    }
    SetFormat7Crop(sx,sy,px,py, camera->format7_info.edit_mode);
    
    //fprintf(stderr,"Size: %d %d  Position: %d %d\n",info->size_x, info->size_y, info->pos_x, info->pos_y);
    // update bpp range here.
    GetFormat7ModeInfo(camera, camera->format7_info.edit_mode);
    UpdateFormat7BppRange();
    UpdateFormat7InfoFrame();
  }
}


void
on_preferences_window_activate         (GtkMenuItem     *menuitem,
                                        gpointer         user_data)
{
  gtk_signal_connect(GTK_OBJECT(preferences_window), "realize",
		     GTK_SIGNAL_FUNC(window_set_icon), preferences_window);
  gtk_widget_show(preferences_window);
}


void
on_service_iso_toggled                 (GtkToggleButton *togglebutton,
                                        gpointer         user_data)
{
  if (!silent_ui_update) {
    if (togglebutton->active) {
      if (IsoStartThread(camera)==-1)
	gtk_toggle_button_set_active(togglebutton,0);
    }
    else
      IsoStopThread(camera);
  }
  UpdatePrefsReceiveFrame();
}


void
on_service_display_toggled             (GtkToggleButton *togglebutton,
                                        gpointer         user_data)
{
  if (!silent_ui_update) {
    if (togglebutton->active) {
      pthread_mutex_lock(&camera->uimutex);
      camera->want_to_display=1;
      pthread_mutex_unlock(&camera->uimutex);
      if (DisplayStartThread(camera)==-1) {
	gtk_toggle_button_set_active(togglebutton,0);
	camera->want_to_display=0;
      }
    } 
    else {
      DisplayStopThread(camera);
      pthread_mutex_lock(&camera->uimutex);
      camera->want_to_display=0;
      pthread_mutex_unlock(&camera->uimutex);
    } 
  }
  UpdatePrefsDisplayFrame();
}


void
on_service_save_toggled                (GtkToggleButton *togglebutton,
                                        gpointer         user_data)
{
  if (!silent_ui_update) {
    if (togglebutton->active) {
      if (SaveStartThread(camera)==-1)
	gtk_toggle_button_set_active(togglebutton,0);
    }
    else
      SaveStopThread(camera);
  }
  UpdatePrefsSaveFrame();
}


void
on_service_ftp_toggled                 (GtkToggleButton *togglebutton,
                                        gpointer         user_data)
{
  if (!silent_ui_update) {
    if (togglebutton->active) {
      if (FtpStartThread(camera)==-1)
	gtk_toggle_button_set_active(togglebutton,0);
    }
    else
      FtpStopThread(camera);
  }
  UpdatePrefsFtpFrame();
}


void
on_service_v4l_toggled                 (GtkToggleButton *togglebutton,
                                        gpointer         user_data)
{
  if (!silent_ui_update) {
    if (togglebutton->active) {
      if (V4lStartThread(camera)==-1) {
	gtk_toggle_button_set_active(togglebutton,0);
	gtk_widget_show(create_v4l_failure_window());
      }
    }
    else
      V4lStopThread(camera);
  }
  UpdatePrefsV4lFrame();
}


void
on_range_menu_activate             (GtkMenuItem     *menuitem,
				    gpointer         user_data)

{
  int feature;
  int action;

  // single auto variables:
  unsigned long int timeout_bin=0;
  unsigned long int step;
  dc1394bool_t value=TRUE;

  action=((int)user_data)%1000;
  feature=(((int)user_data)-action)/1000;

  switch (action) {
  case RANGE_MENU_OFF : // ============================== OFF ==============================
    if (dc1394_feature_on_off(camera->camera_info.handle, camera->camera_info.id, feature, FALSE)!=DC1394_SUCCESS)
      MainError("Could not set feature on/off");
    else {
      camera->feature_set.feature[feature-FEATURE_MIN].is_on=FALSE;
      UpdateRange(feature);
    }
    break;
  case RANGE_MENU_MAN : // ============================== MAN ==============================
      if (camera->feature_set.feature[feature-FEATURE_MIN].on_off_capable) {
	if (dc1394_feature_on_off(camera->camera_info.handle, camera->camera_info.id, feature, TRUE)!=DC1394_SUCCESS) {
	  MainError("Could not set feature on");
	  break;
	}
	else
	  camera->feature_set.feature[feature-FEATURE_MIN].is_on=TRUE;
      }
      if (dc1394_auto_on_off(camera->camera_info.handle, camera->camera_info.id, feature, FALSE)!=DC1394_SUCCESS)
	MainError("Could not set manual mode");
      else {
	camera->feature_set.feature[feature-FEATURE_MIN].auto_active=FALSE;
	if (camera->feature_set.feature[feature-FEATURE_MIN].absolute_capable)
	  SetAbsoluteControl(feature, FALSE);
	UpdateRange(feature);
      }
      break;
  case RANGE_MENU_AUTO : // ============================== AUTO ==============================
    if (camera->feature_set.feature[feature-FEATURE_MIN].on_off_capable) {
      if (dc1394_feature_on_off(camera->camera_info.handle, camera->camera_info.id, feature, TRUE)!=DC1394_SUCCESS) {
	MainError("Could not set feature on");
	break;
      }
      else
	camera->feature_set.feature[feature-FEATURE_MIN].is_on=TRUE;
    }
    if (dc1394_auto_on_off(camera->camera_info.handle, camera->camera_info.id, feature, TRUE)!=DC1394_SUCCESS)
      MainError("Could not set auto mode");
    else {
      camera->feature_set.feature[feature-FEATURE_MIN].auto_active=TRUE;
      if (camera->feature_set.feature[feature-FEATURE_MIN].absolute_capable)
	SetAbsoluteControl(feature, FALSE);
      UpdateRange(feature);
    }
    break;
    case RANGE_MENU_SINGLE : // ============================== SINGLE ==============================
      if (camera->feature_set.feature[feature-FEATURE_MIN].on_off_capable) {
	if (dc1394_feature_on_off(camera->camera_info.handle, camera->camera_info.id, feature, TRUE)!=DC1394_SUCCESS) {
	  MainError("Could not set feature on");
	  break;
	}
	else
	  camera->feature_set.feature[feature-FEATURE_MIN].is_on=TRUE;
      }
      step=(unsigned long int)(1000000.0/preferences.auto_update_frequency);
      if (dc1394_start_one_push_operation(camera->camera_info.handle, camera->camera_info.id, feature)!=DC1394_SUCCESS)
	MainError("Could not start one-push operation");
      else {
	SetScaleSensitivity(GTK_WIDGET(menuitem),feature,FALSE);
	while ((value==DC1394_TRUE) && (timeout_bin<(unsigned long int)(preferences.op_timeout*1000000.0)) ) {
	  usleep(step);
	  if (dc1394_is_one_push_in_operation(camera->camera_info.handle, camera->camera_info.id, feature, &value)!=DC1394_SUCCESS)
	    MainError("Could not query one-push operation");
	  timeout_bin+=step;
	  UpdateRange(feature);
	}
	if (timeout_bin>=(unsigned long int)(preferences.op_timeout*1000000.0))
	  MainStatus("One-Push function timed-out!");

	if (camera->feature_set.feature[feature-FEATURE_MIN].absolute_capable)
	  SetAbsoluteControl(feature, FALSE);
	UpdateRange(feature);
	// should switch back to manual mode here. Maybe a recursive call??
	// >> Not necessary because UpdateRange reloads the status which folds
	// back to 'man' in the camera
      }
      break;
  case RANGE_MENU_ABSOLUTE : // ============================== ABSOLUTE ==============================
    if (camera->feature_set.feature[feature-FEATURE_MIN].on_off_capable) {
      if (dc1394_feature_on_off(camera->camera_info.handle, camera->camera_info.id, feature, TRUE)!=DC1394_SUCCESS) {
	MainError("Could not set feature on");
	break;
      }
      else
	camera->feature_set.feature[feature-FEATURE_MIN].is_on=TRUE;
    }
    SetAbsoluteControl(feature, TRUE);
    UpdateRange(feature);
    break;
  }
}


void
on_key_bindings_activate               (GtkMenuItem     *menuitem,
                                        gpointer         user_data)
{
  help_window = create_help_window();
  gtk_signal_connect(GTK_OBJECT(help_window), "realize",
		     GTK_SIGNAL_FUNC(window_set_icon), help_window);
  BuildHelpWindow();
  gtk_widget_show(help_window);
}

/******************************
 *       PREFERENCES          *
 ******************************/

void
on_camera_name_text_changed            (GtkEditable     *editable,
                                        gpointer         user_data)
{
  char *tmp, *tmp_ptr;
  const char *camera_name_str =  "coriander/camera_names/";
  //fprintf(stderr,"name changed\n");
  tmp=(char*)malloc(STRING_SIZE*sizeof(char));
  tmp_ptr=gtk_entry_get_text(GTK_ENTRY(lookup_widget(main_window, "camera_name_text")));
  sprintf(tmp,"%s%llx",camera_name_str, camera->camera_info.euid_64);
  gnome_config_set_string(tmp,tmp_ptr);
  gnome_config_sync();
  strcpy(camera->prefs.name,tmp_ptr);
  BuildCameraMenu();
  free(tmp);
}

void
on_prefs_op_timeout_scale_changed      (GtkEditable     *editable,
                                        gpointer         user_data)
{
  preferences.op_timeout=gtk_spin_button_get_value_as_float(GTK_SPIN_BUTTON(lookup_widget(preferences_window,"prefs_op_timeout_scale")));
  gnome_config_set_float("coriander/global/one_push_timeout",preferences.op_timeout);
  gnome_config_sync();
}


void
on_prefs_update_scale_changed          (GtkEditable     *editable,
                                        gpointer         user_data)
{
  preferences.auto_update_frequency=gtk_spin_button_get_value_as_float(GTK_SPIN_BUTTON(lookup_widget(preferences_window,"prefs_update_scale")));
  gnome_config_set_float("coriander/global/auto_update_frequency",preferences.auto_update_frequency);
  gnome_config_sync();
}

void
on_prefs_display_period_changed        (GtkEditable     *editable,
                                        gpointer         user_data)
{
  displaythread_info_t* info;
  chain_t* service;
  camera->prefs.display_period=gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(lookup_widget(main_window,"prefs_display_period")));
  gnome_config_set_int("coriander/display/period",camera->prefs.display_period);
  gnome_config_sync();
  service=GetService(camera,SERVICE_DISPLAY);
  if (service!=NULL) {
    info=service->data;
    info->period=camera->prefs.display_period;
  }
}
/*
void
on_prefs_display_scale_changed         (GtkEditable     *editable,
                                        gpointer         user_data)
{
  displaythread_info_t* info;
  chain_t* service;
  preferences.display_scale=gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(lookup_widget(main_window,"prefs_display_scale")));
  gnome_config_set_int("coriander/display/scale",preferences.display_scale);
  gnome_config_sync();
  service=GetService(camera,SERVICE_DISPLAY);
  if (service!=NULL) {
    info=service->data;
    info->scale_previous=info->scale;
    info->scale=preferences.display_scale;
  }
}
*/
void
on_prefs_save_period_changed           (GtkEditable     *editable,
                                        gpointer         user_data)
{
  savethread_info_t* info;
  chain_t* service;
  camera->prefs.save_period=gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(lookup_widget(main_window,"prefs_save_period")));