lqt_gtk.c

这个库实现了录象功能

#include "lqt_private.h"
#include "lqt_gtk.h"
#include <stdlib.h>
#include <string.h>

#include <libintl.h>
#define _(str) dgettext(PACKAGE, str)
 

#define GTK_OPTION_MENU(x) x

enum 
{
LQGTK_LIST_CODEC_NAME_COLUMN_ID  = 0,
LQGTK_LIST_CODEC_INDEX_COLUMN_ID,
LQGTK_LIST_CODEC_NUM_COLS
};

static void parameter_combobox_callback(GtkWidget * w, gpointer data)
  {
  LqtGtkParameterWidget * p = (LqtGtkParameterWidget*)data;
  p->selected = gtk_combo_box_get_active(GTK_COMBO_BOX(w));
  }

/*
 *   Transfer parameters from the widgets to the default
 *   values in the parameter info.
 */

static void parameter_set_string(lqt_parameter_info_t * info,
                                 const char * str)
  {
  if(info->val_default.val_string)
    free(info->val_default.val_string);
  info->val_default.val_string = malloc(strlen(str)+1);
  strcpy(info->val_default.val_string, str);
  }

static void parameter_widget_apply(LqtGtkParameterWidget * w)
  {
  const char * ptr;
  switch(w->parameter_info->type)
    {
    case LQT_PARAMETER_STRINGLIST:
      ptr = w->parameter_info->stringlist_options[w->selected];
      parameter_set_string(w->parameter_info, ptr);
      break;
    case LQT_PARAMETER_STRING:
      ptr = gtk_entry_get_text(GTK_ENTRY(w->widget));
      parameter_set_string(w->parameter_info, ptr);
      break;
    case LQT_PARAMETER_INT:
      if((w->parameter_info->val_min.val_int == 0) &&
         (w->parameter_info->val_max.val_int == 1))
        {
        w->parameter_info->val_default.val_int =
          gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(w->widget));
        }
      else if((w->parameter_info->val_min.val_int <
               w->parameter_info->val_max.val_int))
        {
        w->parameter_info->val_default.val_int =
          (int)(GTK_ADJUSTMENT(w->adjustment)->value);
        }
      else
        {
        w->parameter_info->val_default.val_int =
          gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(w->widget));
        }
      break;
    case LQT_PARAMETER_FLOAT:
      if((w->parameter_info->val_min.val_float <
          w->parameter_info->val_max.val_float))
        {
        w->parameter_info->val_default.val_float =
          GTK_ADJUSTMENT(w->adjustment)->value;
        }
      else
        {
        w->parameter_info->val_default.val_float =
          gtk_spin_button_get_value(GTK_SPIN_BUTTON(w->widget));
        }
    case LQT_PARAMETER_SECTION:
      break;
    }
  
  }


static void parameter_widget_update(LqtGtkParameterWidget * pw)
  {
  int i;
  switch(pw->parameter_info->type)
    {
    case LQT_PARAMETER_INT:
#ifndef NDEBUG
      fprintf(stderr, "Parameter: %s: %d\n", pw->parameter_info->name,
              pw->parameter_info->val_default.val_int);
#endif
      /* Boolean */
      if((pw->parameter_info->val_min.val_int == 0) && (pw->parameter_info->val_max.val_int == 1))
        gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(pw->widget),
                                     pw->parameter_info->val_default.val_int);
      /* Integer with limits -> slider */
      else if(pw->parameter_info->val_min.val_int < pw->parameter_info->val_max.val_int)
        gtk_adjustment_set_value(GTK_ADJUSTMENT(pw->adjustment),
                                 pw->parameter_info->val_default.val_int);
      /* Spinbutton */
      else
        gtk_spin_button_set_value(GTK_SPIN_BUTTON(pw->widget),
                                  pw->parameter_info->val_default.val_int);
      break;
    case LQT_PARAMETER_FLOAT:
#ifndef NDEBUG
      fprintf(stderr, "Parameter: %s: %f\n", pw->parameter_info->name,
              pw->parameter_info->val_default.val_float);
#endif
      /* Float with limits -> slider */
      if(pw->parameter_info->val_min.val_float < pw->parameter_info->val_max.val_float)
        gtk_adjustment_set_value(GTK_ADJUSTMENT(pw->adjustment),
                                 pw->parameter_info->val_default.val_float);
      /* Spinbutton */
      else
        gtk_spin_button_set_value(GTK_SPIN_BUTTON(pw->widget),
                                  pw->parameter_info->val_default.val_float);
      break;
    case LQT_PARAMETER_STRING:
#ifndef NDEBUG
      fprintf(stderr, "Parameter: %s: %s\n", pw->parameter_info->name,
              pw->parameter_info->val_default.val_string);
#endif
      gtk_entry_set_text(GTK_ENTRY(pw->widget),
                         pw->parameter_info->val_default.val_string);
      break;
    case LQT_PARAMETER_STRINGLIST:    /* String with options */
#ifndef NDEBUG
      fprintf(stderr, "Parameter: %s: %s\n", pw->parameter_info->name,
              pw->parameter_info->val_default.val_string);
#endif
      for(i = 0; i < pw->parameter_info->num_stringlist_options; i++)
        {
        if(!strcmp(pw->parameter_info->stringlist_options[i],
                   pw->parameter_info->val_default.val_string))
          {
	  gtk_combo_box_set_active(GTK_COMBO_BOX(pw->widget), i);
          break;
          }
        }
    case LQT_PARAMETER_SECTION:
      break;
    }
  }

/*
 *  Really dirty trick to get tooltips for a GtkComboBox working:
 *  loop through all container children and set the tooltip for
 *  the child, which is a button
 */

static void
set_combo_tooltip(GtkWidget *widget, gpointer   data)
  {
  LqtGtkParameterWidget * w = (LqtGtkParameterWidget *)data;
  //  GtkTooltips *tooltips = (GtkTooltips *)data;

  if(GTK_IS_BUTTON (widget))
#if GTK_MINOR_VERSION < 12
    gtk_tooltips_set_tip(w->tooltips, widget,
                         w->parameter_info->help_string,
                         NULL);
#else
  gtk_widget_set_tooltip_text(widget, w->parameter_info->help_string);
#endif
  }

static void
realize_combo(GtkWidget *combo, gpointer   data)
  {
  LqtGtkParameterWidget * w = (LqtGtkParameterWidget *)data;

  gtk_container_forall (GTK_CONTAINER (combo),
                        set_combo_tooltip,
                        w);
  }

static void set_tooltip(LqtGtkParameterWidget * widget,
                        GtkWidget * w)
  {
#if GTK_MINOR_VERSION < 12
  gtk_tooltips_set_tip(widget->tooltips, w,
                       widget->parameter_info->help_string,
                       widget->parameter_info->help_string);
#else
  gtk_widget_set_tooltip_text(w, widget->parameter_info->help_string);
#endif
  }

#if GTK_MINOR_VERSION < 12
LqtGtkParameterWidget *
lqtgtk_create_parameter_widget(lqt_parameter_info_t * info, GtkTooltips * tooltips)
#else
LqtGtkParameterWidget *
lqtgtk_create_parameter_widget(lqt_parameter_info_t * info)
#endif
  {
  int i;
  LqtGtkParameterWidget * ret = calloc(1, sizeof(LqtGtkParameterWidget));
#if GTK_MINOR_VERSION < 12
  ret->tooltips = tooltips;
#endif
  ret->parameter_info = info;
  
  switch(info->type)
    {
    case LQT_PARAMETER_INT:

      /* Boolean */
      if((info->val_min.val_int == 0) && (info->val_max.val_int == 1))
        {
        ret->widget = gtk_check_button_new_with_label(info->real_name);
        if(info->help_string)
          set_tooltip(ret, ret->widget);
        }
      /* Integer with limits -> slider */
      else if(info->val_min.val_int < info->val_max.val_int)
        {
        ret->label = gtk_label_new(info->real_name);
        gtk_misc_set_alignment(GTK_MISC(ret->label), 0.0, 0.5);
        ret->adjustment = gtk_adjustment_new((gfloat) info->val_min.val_int,
                                             (gfloat) info->val_min.val_int,
                                             (gfloat) info->val_max.val_int,
                                             0.0,
                                             0.0,
                                             0.0);
        ret->widget = gtk_hscale_new(GTK_ADJUSTMENT(ret->adjustment));
        gtk_scale_set_value_pos(GTK_SCALE(ret->widget),
                                GTK_POS_LEFT);
        
        gtk_scale_set_digits(GTK_SCALE(ret->widget), 0);
        if(info->help_string)
          set_tooltip(ret, ret->widget);
        }
      /* Spinbutton */
      else
        {
        ret->label = gtk_label_new(info->real_name);
        gtk_misc_set_alignment(GTK_MISC(ret->label), 0.0, 0.5);
        ret->adjustment = gtk_adjustment_new(0.0,
                                             -1.0e8,
                                             1.0e8,
                                             1.0,
                                             1.0,
                                             1.0);
        ret->widget = gtk_spin_button_new(GTK_ADJUSTMENT(ret->adjustment),
                                          0.0,
                                          0);
        if(info->help_string)
          set_tooltip(ret, ret->widget);
        }
      break;
    case LQT_PARAMETER_FLOAT:

      /* Float with limits -> slider */
      if(info->val_min.val_float < info->val_max.val_float)
        {
        ret->label = gtk_label_new(info->real_name);
        gtk_misc_set_alignment(GTK_MISC(ret->label), 0.0, 0.5);
        ret->adjustment = gtk_adjustment_new(info->val_min.val_float,
                                             info->val_min.val_float,
                                             info->val_max.val_float,
                                             0.0,
                                             0.0,
                                             0.0);
        
        ret->widget = gtk_hscale_new(GTK_ADJUSTMENT(ret->adjustment));

        gtk_scale_set_digits(GTK_SCALE(ret->widget),
                             info->num_digits);
        // fprintf(stderr, "** NUM DIGITS: %d\n", info->num_digits);
        
        gtk_scale_set_value_pos(GTK_SCALE(ret->widget),
                                GTK_POS_LEFT);
        
        if(info->help_string)
          set_tooltip(ret, ret->widget);
        }
      /* Spinbutton */
      else
        {
        ret->label = gtk_label_new(info->real_name);
        gtk_misc_set_alignment(GTK_MISC(ret->label), 0.0, 0.5);
        ret->adjustment = gtk_adjustment_new(0.0,
                                             -1.0e8,
                                             1.0e8,
                                             1.0,
                                             1.0,
                                             1.0);
        ret->widget = gtk_spin_button_new(GTK_ADJUSTMENT(ret->adjustment),
                                          0.0,
                                          0);

        gtk_spin_button_set_digits(GTK_SPIN_BUTTON(ret->widget),
                                   info->num_digits);

        if(info->help_string)
          set_tooltip(ret, ret->widget);
        }
      break;
    case LQT_PARAMETER_STRING:
      ret->label = gtk_label_new(info->real_name);
      gtk_misc_set_alignment(GTK_MISC(ret->label), 0.0, 0.5);
      ret->widget = gtk_entry_new();
      if(info->help_string)
        set_tooltip(ret, ret->widget);
      break;
    case LQT_PARAMETER_STRINGLIST:    /* String with options */
      ret->selected = 0;
      ret->label = gtk_label_new(info->real_name);
      gtk_misc_set_alignment(GTK_MISC(ret->label), 0.0, 0.5);

      ret->widget = gtk_combo_box_new_text();
      for(i = 0; i < info->num_stringlist_options; i++)
        {
	gtk_combo_box_append_text (GTK_COMBO_BOX (ret->widget), 
				   info->stringlist_options[i]);
        }
      g_signal_connect(GTK_COMBO_BOX (ret->widget),
		       "changed",
		       G_CALLBACK(parameter_combobox_callback),
		       ret);

      if(info->help_string)
        g_signal_connect (ret->widget, "realize",
                          G_CALLBACK (realize_combo), ret);

      
      break;
    case LQT_PARAMETER_SECTION:
      break;
    }

  gtk_widget_set_size_request(ret->widget, 100, -1);
  
  parameter_widget_update(ret);

  gtk_widget_show(ret->widget);
  if(ret->label)
    gtk_widget_show(ret->label);
  return ret;
  }

/*
 *  Maybe empty function if we trust gtk's widget destroying mechanisms
 */ 

void
lqtgtk_destroy_parameter_widget(LqtGtkParameterWidget * w)
  {
  free(w);
  }

/*
 *  Create Codec config widget
 */

#if GTK_MINOR_VERSION < 12
static GtkWidget * create_table(lqt_parameter_info_t * parameter_info,
                                LqtGtkParameterWidget ** widgets,
                                int num_parameters, GtkTooltips * tooltips)
#else
static GtkWidget * create_table(lqt_parameter_info_t * parameter_info,
                                LqtGtkParameterWidget ** widgets,
                                int num_parameters)
#endif
  {
  int i;
  GtkWidget * ret;
  ret = gtk_table_new(num_parameters, 2, 0);
  gtk_container_set_border_width(GTK_CONTAINER(ret),
                                 10);
  gtk_table_set_row_spacings(GTK_TABLE(ret),
                             5);
  gtk_table_set_col_spacings(GTK_TABLE(ret),
                             5);
    
  for(i = 0; i < num_parameters; i++)
    {
#if GTK_MINOR_VERSION < 12
    widgets[i] =
      lqtgtk_create_parameter_widget(&parameter_info[i], tooltips);
#else
    widgets[i] =
      lqtgtk_create_parameter_widget(&parameter_info[i]);
#endif
    /* Bool parameters have no labels */

    if(widgets[i]->label)
      {    
      gtk_table_attach(GTK_TABLE(ret), widgets[i]->label,
                       0, 1, i, i+1, GTK_FILL, GTK_FILL, 0, 0);
      gtk_table_attach(GTK_TABLE(ret), widgets[i]->widget,
                       1, 2, i, i+1, GTK_EXPAND | GTK_FILL, GTK_FILL, 0, 0);
      }
    else
      {
      gtk_table_attach(GTK_TABLE(ret), widgets[i]->widget,
                       0, 2, i, i+1, GTK_EXPAND | GTK_FILL, GTK_FILL, 0, 0);
      }
    }
  gtk_widget_show(ret);
  return ret;
  }

LqtGtkCodecConfigWidget *
lqtgtk_create_codec_config_widget(lqt_parameter_info_t * parameter_info,
                                  int num_parameters)
  {
  int i, parameter_index;
  GtkWidget * table;
  GtkWidget * notebook;
  GtkWidget * tab_label;
  int num_sections = 0;
  int parameters_in_section;
  LqtGtkCodecConfigWidget * ret = calloc(1, sizeof(LqtGtkCodecConfigWidget));

#if GTK_MINOR_VERSION < 12
  ret->tooltips = gtk_tooltips_new();
  g_object_ref (G_OBJECT (ret->tooltips));

#if GTK_MINOR_VERSION < 10
  gtk_object_sink (GTK_OBJECT (ret->tooltips));
#else
  g_object_ref_sink(G_OBJECT(ret->tooltips));
#endif
#endif
  
  if(parameter_info[0].type == LQT_PARAMETER_SECTION)
    {
    for(i = 0; i < num_parameters; i++)
      {
      if(parameter_info[i].type == LQT_PARAMETER_SECTION)
        num_sections++;
      }
    }
  
  ret->parameter_info = parameter_info;
  ret->num_parameters = num_parameters - num_sections;

  /* Create the parameter widgets */

  ret->parameter_widgets = calloc(num_parameters - num_sections,
                                  sizeof(LqtGtkParameterWidget *));

  if(num_sections)
    {
    parameter_index = 1;
    notebook = gtk_notebook_new();
    for(i = 0; i < num_sections; i++)
      {
      /* Count parameters in this section */

      parameters_in_section = 0;
      while((parameters_in_section + parameter_index < num_parameters) &&
            (parameter_info[parameters_in_section + parameter_index].type != LQT_PARAMETER_SECTION))
        {
        parameters_in_section++;
        }
      
      /* Create table */
#if GTK_MINOR_VERSION < 12
      table = create_table(&(parameter_info[parameter_index]),
                           &(ret->parameter_widgets[parameter_index - i - 1]),
                           parameters_in_section, ret->tooltips);
#else
      table = create_table(&(parameter_info[parameter_index]),
                           &(ret->parameter_widgets[parameter_index - i - 1]),