lqt_gtk.c

这个库实现了录象功能

                           parameters_in_section);
#endif      
      /* Append table */

      tab_label = gtk_label_new(parameter_info[parameter_index-1].real_name);
      gtk_widget_show(tab_label);
      gtk_notebook_append_page(GTK_NOTEBOOK(notebook), table, tab_label);
      
      /* Increment */

      parameter_index += parameters_in_section + 1;
      }
    gtk_widget_show(notebook);
    ret->widget = notebook;
    }
  else
#if GTK_MINOR_VERSION < 12
    ret->widget = create_table(parameter_info,
                               ret->parameter_widgets,
                               num_parameters, ret->tooltips);
#else
    ret->widget = create_table(parameter_info,
                               ret->parameter_widgets,
                               num_parameters);
#endif
  return ret;
  }

/* 
 * 
 */

void codec_config_widget_apply(LqtGtkCodecConfigWidget * ccw)
  {
  int i;
  for(i = 0; i < ccw->num_parameters; i++)
    parameter_widget_apply(ccw->parameter_widgets[i]);
  }

void codec_config_widget_update(LqtGtkCodecConfigWidget * ccw)
  {
  int i;
  for(i = 0; i < ccw->num_parameters; i++)
    parameter_widget_update(ccw->parameter_widgets[i]);
  }

void lqtgtk_destroy_codec_config_widget(LqtGtkCodecConfigWidget * w)
  {
  int i;

  for(i = 0; i < w->num_parameters; i++)
    lqtgtk_destroy_parameter_widget(w->parameter_widgets[i]);
  
  free(w->parameter_widgets);
  free(w);
  }


/*
 *  Codec Browser
 */

static void browser_select_row_callback(GtkTreeSelection *selection,
					gpointer user_data)
  {
    LqtGtkCodecBrowser * cb = (LqtGtkCodecBrowser *)user_data;
    GtkTreeModel * model;
    GtkTreeIter iter;
    gint row;

    if (gtk_tree_selection_get_selected(selection, &model, &iter) == TRUE)
      {

      if(cb->selected == -1)	/* ??? */
	gtk_widget_set_sensitive(cb->info_button, 1);

      gtk_tree_model_get(model, &iter, LQGTK_LIST_CODEC_INDEX_COLUMN_ID, &row, -1);
      cb->selected = row;
      cb->codec_info = cb->codecs[row];

      if((cb->encode && cb->codec_info->num_encoding_parameters) ||
	 (cb->decode && cb->codec_info->num_decoding_parameters))
	gtk_widget_set_sensitive(cb->parameters_button, 1);
      else
	gtk_widget_set_sensitive(cb->parameters_button, 0);
	
      if(cb->selected == 0)
	gtk_widget_set_sensitive(cb->up_button, 0);
      else
	gtk_widget_set_sensitive(cb->up_button, 1);
	
      if(cb->selected == cb->num_codecs - 1)
	gtk_widget_set_sensitive(cb->down_button, 0);
      else
	gtk_widget_set_sensitive(cb->down_button, 1);
      }
  }

static
void lqtgtk_codec_browser_model_update(GtkTreeModel * model,
				       int            num_codecs,
				       lqt_codec_info_t ** codecs)
  {
  int i;
  GtkListStore * store = GTK_LIST_STORE(model);
  GtkTreeIter iter;
  
  gtk_list_store_clear(store);
  for(i = 0; i < num_codecs; i++)
    {
    gtk_list_store_append(store, &iter);
    gtk_list_store_set(store, &iter, 
		       LQGTK_LIST_CODEC_NAME_COLUMN_ID, 
		       _(codecs[i]->long_name),
		       LQGTK_LIST_CODEC_INDEX_COLUMN_ID, 
		       i,
		       -1);
    }

  }

static void browser_move_codec(LqtGtkCodecBrowser * cb, int pos, int new_pos)
  {
  lqt_codec_info_t * tmp_info;
  GtkTreePath * path;
  GtkTreeSelection * selection;

  tmp_info = cb->codecs[pos];
  cb->codecs[pos] = cb->codecs[new_pos];
  cb->codecs[new_pos] = tmp_info;

  /* We immediately apply this in the registry */

  if(cb->type == LQT_CODEC_AUDIO)
    lqt_reorder_audio_codecs(cb->codecs);
  else if(cb->type == LQT_CODEC_VIDEO)
    lqt_reorder_video_codecs(cb->codecs);
    
  /* Enable up button */ 
  
  if(!cb->selected && new_pos)
    gtk_widget_set_sensitive(cb->up_button, 1);

  /* Enable down button */

  if((cb->selected == cb->num_codecs - 1) && (new_pos < cb->num_codecs - 1))
    gtk_widget_set_sensitive(cb->down_button, 1);

  /* Disable up button */
 
  if(!new_pos)
    gtk_widget_set_sensitive(cb->up_button, 0);

  /* Disable down button */

  if(new_pos == cb->num_codecs - 1)
    gtk_widget_set_sensitive(cb->down_button, 0);
  
  cb->selected = new_pos;

  lqtgtk_codec_browser_model_update(cb->model, cb->num_codecs, cb->codecs);
  
  /* The selected codec should still be visible */
  selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(cb->list));
  path = gtk_tree_path_new_from_indices(cb->selected, -1);
  gtk_tree_selection_select_path(selection, path);
  gtk_tree_view_scroll_to_cell(GTK_TREE_VIEW(cb->list), path, NULL, FALSE, 0.0, 0.0);
  gtk_tree_path_free(path);
  }

static void browser_button_callback(GtkWidget * w, gpointer data)
  {
  LqtGtkCodecBrowser * cb = (LqtGtkCodecBrowser *)data;

  LqtGtkCodecConfigWindow * codec_config_window;
  LqtGtkCodecInfoWindow * codec_info_window;
  
  if(w == cb->up_button)
    browser_move_codec(cb, cb->selected, cb->selected-1);
  else if(w == cb->down_button)
    browser_move_codec(cb, cb->selected, cb->selected+1);
  else if(w == cb->parameters_button)
    {
    codec_config_window =
      lqtgtk_create_codec_config_window(cb->codec_info,
                                        cb->encode,
                                        cb->decode);
    lqtgtk_codec_config_window_run(codec_config_window);
    lqtgtk_destroy_codec_config_window(codec_config_window);
    }
  else if(w == cb->info_button)
    {
    codec_info_window =
      lqtgtk_create_codec_info_window(cb->codec_info);
    lqtgtk_codec_info_window_run(codec_info_window);
    }
  }

LqtGtkCodecBrowser * lqtgtk_create_codec_browser(lqt_codec_type type,
                                                 int encode, int decode)
  {
  LqtGtkCodecBrowser * ret = calloc(1, sizeof(LqtGtkCodecBrowser));
  GtkCellRenderer    * renderer;
  GtkTreeSelection   * selection;
  
  ret->encode = encode;
  ret->decode = decode;
  ret->type   = type;
  
  ret->widget = gtk_table_new(4, 2, 0); 
  gtk_table_set_row_spacings(GTK_TABLE(ret->widget), 10);
  gtk_table_set_col_spacings(GTK_TABLE(ret->widget), 10);
  gtk_container_set_border_width(GTK_CONTAINER(ret->widget), 10);


  ret->model = (GtkTreeModel *)gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_INT);
  ret->list  = gtk_tree_view_new_with_model(ret->model);
  renderer   = gtk_cell_renderer_text_new();
  gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(ret->list),
					      -1,
					      _("Installed codecs"),
					      renderer,
					      "text", LQGTK_LIST_CODEC_NAME_COLUMN_ID,
					      NULL);

  selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(ret->list));
  gtk_tree_selection_set_mode(selection, GTK_SELECTION_BROWSE);
  g_signal_connect(G_OBJECT(selection), "changed",
		   G_CALLBACK(browser_select_row_callback),
		   (gpointer)ret);
  
  gtk_widget_show(ret->list);
 
  ret->scrolledwindow =
    gtk_scrolled_window_new(NULL, NULL);

  gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(ret->scrolledwindow),
                                 GTK_POLICY_NEVER,
                                 GTK_POLICY_AUTOMATIC);

  gtk_container_add(GTK_CONTAINER(ret->scrolledwindow), ret->list);
  gtk_widget_show(ret->scrolledwindow);

  gtk_table_attach_defaults(GTK_TABLE(ret->widget), ret->scrolledwindow,
                            0, 1, 0, 4);
  
  ret->up_button =         gtk_button_new_with_label(_("Up"));
  ret->down_button =       gtk_button_new_with_label(_("Down"));

  ret->parameters_button = gtk_button_new_with_label(_("Parameters..."));
  ret->info_button =       gtk_button_new_with_label(_("Info..."));

  g_signal_connect(G_OBJECT(ret->up_button), "clicked",
		   G_CALLBACK(browser_button_callback),
		   (gpointer)ret);
  g_signal_connect(G_OBJECT(ret->down_button), "clicked",
		   G_CALLBACK(browser_button_callback),
		   (gpointer)ret);
  g_signal_connect(G_OBJECT(ret->parameters_button), "clicked",
		   G_CALLBACK(browser_button_callback),
		   (gpointer)ret);
  g_signal_connect(G_OBJECT(ret->info_button), "clicked",
		   G_CALLBACK(browser_button_callback),
		   (gpointer)ret);

  gtk_widget_show(ret->up_button);
  gtk_widget_show(ret->down_button);
  gtk_widget_show(ret->parameters_button);
  gtk_widget_show(ret->info_button);
  
  gtk_table_attach(GTK_TABLE(ret->widget),
                   ret->up_button, 1, 2, 0, 1,
                   GTK_FILL, GTK_FILL, 0, 0);
  gtk_table_attach(GTK_TABLE(ret->widget),
                   ret->down_button, 1, 2, 1, 2,
                   GTK_FILL, GTK_FILL, 0, 0);
  gtk_table_attach(GTK_TABLE(ret->widget),
                   ret->parameters_button, 1, 2, 2, 3,
                   GTK_FILL, GTK_FILL, 0, 0);
  gtk_table_attach(GTK_TABLE(ret->widget),
                   ret->info_button, 1, 2, 3, 4,
                   GTK_FILL, GTK_FILL, 0, 0);
  
  gtk_widget_show(ret->widget);
  return ret;
  }

void lqtgtk_codec_browser_update(LqtGtkCodecBrowser * b)
  {
  b->num_codecs = 0;
  
  if(b->codecs)
    lqt_destroy_codec_info(b->codecs);
    
  if(b->type == LQT_CODEC_AUDIO)
    b->codecs = lqt_query_registry(1, 0, b->encode, b->decode);
  else
    b->codecs = lqt_query_registry(0, 1, b->encode, b->decode);

  while(1)
    {
    if(b->codecs[b->num_codecs])
      b->num_codecs++;
    else
      break;
    }

  lqtgtk_codec_browser_model_update(b->model,
				    b->num_codecs,
				    b->codecs);

  b->selected = -1;
  b->codec_info = b->codecs[0];

  gtk_widget_set_sensitive(b->info_button, 0);
  gtk_widget_set_sensitive(b->up_button, 0);
  gtk_widget_set_sensitive(b->down_button, 0);
  gtk_widget_set_sensitive(b->parameters_button, 0);
  }

void lqtgtk_destroy_codec_browser(LqtGtkCodecBrowser * b)
  {
  if(b->codecs)
    lqt_destroy_codec_info(b->codecs);
    
  free(b);
  }

static void codec_config_window_button_callback(GtkWidget * w, gpointer data)
  {
  int encode, decode;
  
  LqtGtkCodecConfigWindow * ccw = (LqtGtkCodecConfigWindow *)data;
  if(w == ccw->apply_button)
    {
    lqtgtk_codec_config_window_apply(ccw);
    }
  else if(w == ccw->close_button)
    {
    gtk_widget_hide(ccw->window);
    gtk_main_quit();
    }
  else if(w == ccw->restore_button)
    {
    encode = (ccw->encode_widget) ? 1 : 0;
    decode = (ccw->decode_widget) ? 1 : 0;

    /*    fprintf(stderr, "Restoring parameters %d %d\n", encode, decode); */
    
    lqt_restore_default_parameters(ccw->codec_info, encode, decode);

    if(encode)
      {
      /*      fprintf(stderr, "Updating encoding parameters\n"); */
      codec_config_widget_update(ccw->encode_widget);
      }
    if(decode)
      {
      /*      fprintf(stderr, "Updating decoding parameters\n"); */
      codec_config_widget_update(ccw->decode_widget);
      }
      
    
    }
  }

LqtGtkCodecConfigWindow *
lqtgtk_create_codec_config_window(lqt_codec_info_t * codec_info,
                                  int encode,
                                  int decode)
  {
  LqtGtkCodecConfigWindow * ret =
    calloc(1, sizeof(LqtGtkCodecConfigWindow));

  ret->codec_info = codec_info;
  
  if(encode && codec_info->num_encoding_parameters)
    ret->encode_widget =
      lqtgtk_create_codec_config_widget(codec_info->encoding_parameters,
                                        codec_info->num_encoding_parameters);

  if(decode && codec_info->num_decoding_parameters)
    ret->decode_widget =
      lqtgtk_create_codec_config_widget(codec_info->decoding_parameters,
                                        codec_info->num_decoding_parameters);

  if(encode && decode)
    {
    ret->hbox = gtk_hbox_new(0, 5);
    if(codec_info->num_encoding_parameters)
      {
      ret->encoding_frame = gtk_frame_new(_("Encoding Options"));
      
      gtk_container_add(GTK_CONTAINER(ret->encoding_frame),
                       ret->encode_widget->widget);
      gtk_widget_show(ret->encoding_frame);
      gtk_box_pack_start_defaults(GTK_BOX(ret->hbox), ret->encoding_frame);
      }
    if(codec_info->num_decoding_parameters)
      {
      ret->decoding_frame = gtk_frame_new(_("Decoding Options"));
      gtk_container_add(GTK_CONTAINER(ret->decoding_frame),
                        ret->decode_widget->widget);
      gtk_widget_show(ret->decoding_frame);
      gtk_box_pack_start_defaults(GTK_BOX(ret->hbox), ret->decoding_frame);
      }
    gtk_widget_show(ret->hbox);
    }
  
  ret->window = gtk_window_new(GTK_WINDOW_TOPLEVEL);

  gtk_window_set_title(GTK_WINDOW(ret->window), codec_info->long_name);
  gtk_window_set_modal(GTK_WINDOW(ret->window), TRUE);
  
  ret->apply_button = gtk_button_new_from_stock(GTK_STOCK_APPLY);
  ret->close_button = gtk_button_new_from_stock(GTK_STOCK_CLOSE);
  ret->restore_button = gtk_button_new_with_label(_("Restore defaults"));

  g_signal_connect(G_OBJECT(ret->apply_button),
		   "clicked",
		   G_CALLBACK(codec_config_window_button_callback),
		   (gpointer)ret);
  
  g_signal_connect(G_OBJECT(ret->close_button),
		   "clicked",
		   G_CALLBACK(codec_config_window_button_callback),
		   (gpointer)ret);

  g_signal_connect(G_OBJECT(ret->restore_button),
		   "clicked",
		   G_CALLBACK(codec_config_window_button_callback),
		   (gpointer)ret);

  GTK_WIDGET_SET_FLAGS (ret->apply_button, GTK_CAN_DEFAULT);
  GTK_WIDGET_SET_FLAGS (ret->close_button, GTK_CAN_DEFAULT);
  GTK_WIDGET_SET_FLAGS (ret->restore_button, GTK_CAN_DEFAULT);

  gtk_widget_show(ret->apply_button);
  gtk_widget_show(ret->close_button);
  gtk_widget_show(ret->restore_button);

  ret->buttonbox = gtk_hbutton_box_new();
  gtk_box_set_spacing(GTK_BOX(ret->buttonbox), 5);

  ret->mainbox = gtk_vbox_new(0, 5);
  gtk_container_set_border_width(GTK_CONTAINER(ret->mainbox), 10);

  if(encode && decode)
    gtk_box_pack_start_defaults(GTK_BOX(ret->mainbox), ret->hbox);
  else if(encode)
    gtk_box_pack_start_defaults(GTK_BOX(ret->mainbox),
                                ret->encode_widget->widget);
  else if(decode)
    gtk_box_pack_start_defaults(GTK_BOX(ret->mainbox),
                                ret->decode_widget->widget);
    
  gtk_container_add(GTK_CONTAINER(ret->buttonbox), ret->apply_button);
  gtk_container_add(GTK_CONTAINER(ret->buttonbox), ret->close_button);
  gtk_container_add(GTK_CONTAINER(ret->buttonbox), ret->restore_button);

  gtk_widget_show(ret->buttonbox);
  gtk_box_pack_start_defaults(GTK_BOX(ret->mainbox), ret->buttonbox);
  gtk_widget_show(ret->mainbox);

  gtk_container_add(GTK_CONTAINER(ret->window), ret->mainbox);
  return ret;
  }

void lqtgtk_codec_config_window_run(LqtGtkCodecConfigWindow *w)
  {
  gtk_widget_show(w->window);
  gtk_main();
  }

/* Apply all values into the libquicktime codec registry */