gui_main.cpp

完整的RTP RTSP代码库

  GTK_WIDGET_SET_FLAGS(cancel_button1, GTK_CAN_DEFAULT);
 
  gtk_window_set_modal(GTK_WINDOW(fs), true);
  gtk_window_set_transient_for(GTK_WINDOW(fs), 
			       GTK_WINDOW(MainWindow));
  g_signal_connect((gpointer) fs, "response",
		   G_CALLBACK (onConfigFileOpenResponse),
		   GINT_TO_POINTER(new_one));
  gtk_widget_show(fs);

}

static void
on_new1_activate                       (GtkMenuItem     *menuitem,
                                        gpointer         user_data)
{
  start_config_file_selection(true);
}

static void
on_open1_activate                      (GtkMenuItem     *menuitem,
                                        gpointer         user_data)
{
  start_config_file_selection(false);
}


static void
on_save1_activate                      (GtkMenuItem     *menuitem,
                                        gpointer         user_data)
{
  if (started == false) {
    // read that info
    ReadConfigFromWindow();
  }

  // need to read the information
  GtkWidget *statusbar = lookup_widget(MainWindow, "statusbar1");
  gtk_statusbar_pop(GTK_STATUSBAR(statusbar), 0);
  gtk_statusbar_push(GTK_STATUSBAR(statusbar), 
		     0,
		     "Writing Configuration and Stream Files");
  MyConfig->WriteToFile();
  CMediaStream *ms = AVFlow->m_stream_list->GetHead();
  while (ms != NULL) {
    ms->WriteToFile();
    ms = ms->GetNext();
  }
    
  gtk_statusbar_pop(GTK_STATUSBAR(statusbar), 0);
  gtk_statusbar_push(GTK_STATUSBAR(statusbar), 
		     0,
		     "Configuration and stream files written");
}


static void on_generate_addresses_yes (void)
{
  CMediaStream *ms = AVFlow->m_stream_list->GetHead();

  while (ms != NULL) {
    struct in_addr in;
    if (ms->GetBoolValue(STREAM_TRANSMIT)) {
      if (ms->GetBoolValue(STREAM_VIDEO_ENABLED) &&
	  ms->GetBoolValue(STREAM_VIDEO_ADDR_FIXED) == false) {
	in.s_addr = CRtpTransmitter::GetRandomMcastAddress();
	ms->SetStringValue(STREAM_VIDEO_DEST_ADDR, inet_ntoa(in));
	ms->SetIntegerValue(STREAM_VIDEO_DEST_PORT,
			    CRtpTransmitter::GetRandomPortBlock());
      }
      if (ms->GetBoolValue(STREAM_AUDIO_ENABLED) &&
	  ms->GetBoolValue(STREAM_AUDIO_ADDR_FIXED) == false) {
	in.s_addr = CRtpTransmitter::GetRandomMcastAddress();
	ms->SetStringValue(STREAM_AUDIO_DEST_ADDR, inet_ntoa(in));
	ms->SetIntegerValue(STREAM_AUDIO_DEST_PORT,
			    CRtpTransmitter::GetRandomPortBlock());
      }
      if (ms->GetBoolValue(STREAM_TEXT_ENABLED) &&
	  ms->GetBoolValue(STREAM_TEXT_ADDR_FIXED) == false) {
	in.s_addr = CRtpTransmitter::GetRandomMcastAddress();
	ms->SetStringValue(STREAM_TEXT_DEST_ADDR, inet_ntoa(in));
	ms->SetIntegerValue(STREAM_TEXT_DEST_PORT,
			    CRtpTransmitter::GetRandomPortBlock());
      }
    }
    ms = ms->GetNext();
  }
  AVFlow->ValidateAndUpdateStreams();
  DisplayStreamData(SelectedStream);
}

static void
on_generate_addresses_activate         (GtkMenuItem     *menuitem,
                                        gpointer         user_data)
{
  printf("generate_addresses_activate\n");
  YesOrNo("Generate Random Multicast Addresses",
	  "This will generate new addresses and ports\n"
	  "for all Streams\n"
	  "\nDo you want to continue ?",
	  true,
	  GTK_SIGNAL_FUNC(on_generate_addresses_yes),
	  NULL);
}

static void on_restart_record_yes (void)
{
  AVFlow->RestartFileRecording();
}
static const char *restart1 = 
"This will restart recording for all streams\n"
"\nDo you want to continue ?";
static const char *restart2 = 
"This will restart recording for all streams\n"
"\nIt is configured to wipe out the existing file\n"
"\nDo you want to continue ?";

static void 
on_restart_recording_activate           (GtkMenuItem  *menuitem,
					 gpointer      user_data)
{
  YesOrNo("Restart Recording",
	  MyConfig->GetIntegerValue(CONFIG_RECORD_MP4_FILE_STATUS)
	  == FILE_MP4_CREATE_NEW ? restart1 : restart2,
	  false,
	  GTK_SIGNAL_FUNC(on_restart_record_yes),
	  NULL);
}

static void
on_generate_sdp_activate         (GtkMenuItem     *menuitem,
				  gpointer         user_data)
{
  AVFlow->ValidateAndUpdateStreams();
  GtkWidget *statusbar = lookup_widget(MainWindow, "statusbar1");
  gtk_statusbar_pop(GTK_STATUSBAR(statusbar), 0);
  gtk_statusbar_push(GTK_STATUSBAR(statusbar), 
		     0,
		     "SDP files have been generated");
}
static void
on_preferences1_activate               (GtkMenuItem     *menuitem,
                                        gpointer         user_data)
{
  create_PreferencesDialog();
}


static void
on_about1_activate                     (GtkMenuItem     *menuitem,
                                        gpointer         user_data)
{
  char buffer[1024];
  snprintf(buffer, sizeof(buffer), 
	   "mp4live %s %s\n"
	   "\nAn open source live broadcaster\n"
	   "\nDeveloped by Cisco Systems\n"
	   "\nUsing open source packages:\n"
	   "lame encoder\n"
	   "faac encoder\n"
#if defined(HAVE_XVID10) || defined(HAVE_XVID_H)
	   "Xvid mpeg-4 encoder\n"
#endif
#ifdef HAVE_FFMPEG
	   "Ffmpeg encoder\n"
#endif
#ifdef HAVE_X264
	   "H.264 encoder from x264\n"
#endif
	   "H.261 encoder from UC\n"
	   "Glade interface designer\n"
	   "\n2000 to present\n"
	   ,
	   get_linux_video_type(),
	   MPEG4IP_VERSION);
  ShowMessage("About", buffer);
}

// Source Menu handlers
static void RestoreSourceMenu (void)
{
  GtkWidget *wid = lookup_widget(MainWindow, "SourceOptionMenu");
  gtk_option_menu_set_history(GTK_OPTION_MENU(wid), 0);
}

static void
on_VideoSourceMenu_activate            (GtkMenuItem     *menuitem,
                                        gpointer         user_data)
{
  RestoreSourceMenu();
  create_VideoSourceDialog();
}


static void
on_AudioSourceMenu_activate           (GtkMenuItem     *menuitem,
                                        gpointer         user_data)
{
  RestoreSourceMenu();
  create_AudioSourceDialog();
}
static void
on_picture_settings_activate           (GtkMenuItem     *menuitem,
                                        gpointer         user_data)
{
  RestoreSourceMenu();
  CreatePictureDialog();
}

#ifdef HAVE_TEXT
static void
on_TextSourceMenu_activate             (GtkMenuItem     *menuitem,
                                        gpointer         user_data)
{
  RestoreSourceMenu();
  create_TextSourceDialog();
}
#endif

// Add Stream Dialog
static void
on_AddStreamDialog_response            (GtkDialog       *dialog,
                                        gint             response_id,
                                        gpointer         user_data)
{
  if (GTK_RESPONSE_OK == response_id) {
    GtkWidget *temp = lookup_widget(GTK_WIDGET(dialog), "AddStreamText");
    
    const char *stream_name = gtk_entry_get_text(GTK_ENTRY(temp));
    if ((stream_name == NULL) || (*stream_name == '\0')) {
      ShowMessage("Add Stream Error", "Must enter stream name", GTK_WIDGET(dialog));
      return;
    }

    if (AVFlow->AddStream(stream_name) == false) {
      ShowMessage("Not Added", "An Error as occurred\nStream has not been added");
    } else {
      DisplayStreamsInView(NULL, stream_name);
      DisplayStreamData(stream_name);
    }
  }
  gtk_widget_destroy(GTK_WIDGET(dialog));
}

// This is if they hit return from the AddStream text window
static void on_AddStreamText_activate (GtkEntry *ent,
				       gpointer user_data)
{
  on_AddStreamDialog_response(GTK_DIALOG(user_data),
			      GTK_RESPONSE_OK,
			      NULL);
}


// create the add stream dialog
static void
on_AddStreamButton_clicked             (GtkButton       *button,
                                        gpointer         user_data)
{
  GtkWidget *AddStreamDialog;
  GtkWidget *dialog_vbox1;
  GtkWidget *vbox20;
  GtkWidget *AddStreamText;
  GtkWidget *dialog_action_area1;
  GtkWidget *cancelbutton1;
  GtkWidget *okbutton1;
  GtkTooltips *tooltips;

  tooltips = gtk_tooltips_new();

  AddStreamDialog = gtk_dialog_new();
  gtk_window_set_title(GTK_WINDOW(AddStreamDialog), _("Add Stream"));
  gtk_window_set_modal(GTK_WINDOW(AddStreamDialog), TRUE);
  gtk_window_set_transient_for(GTK_WINDOW(AddStreamDialog), 
			       GTK_WINDOW(MainWindow));
  gtk_window_set_resizable(GTK_WINDOW(AddStreamDialog), FALSE);
  gtk_dialog_set_has_separator(GTK_DIALOG(AddStreamDialog), FALSE);

  dialog_vbox1 = GTK_DIALOG(AddStreamDialog)->vbox;
  gtk_widget_show(dialog_vbox1);

  vbox20 = gtk_vbox_new(FALSE, 0);
  gtk_widget_show(vbox20);
  gtk_box_pack_start(GTK_BOX(dialog_vbox1), vbox20, TRUE, TRUE, 0);

  AddStreamText = gtk_entry_new();
  gtk_widget_show(AddStreamText);
  gtk_box_pack_start(GTK_BOX(vbox20), AddStreamText, FALSE, FALSE, 16);
  gtk_tooltips_set_tip(tooltips, AddStreamText, _("Enter Stream Name"), NULL);
  gtk_entry_set_width_chars(GTK_ENTRY(AddStreamText), 40);

  dialog_action_area1 = GTK_DIALOG(AddStreamDialog)->action_area;
  gtk_widget_show(dialog_action_area1);
  gtk_button_box_set_layout(GTK_BUTTON_BOX(dialog_action_area1), GTK_BUTTONBOX_END);

  cancelbutton1 = gtk_button_new_from_stock("gtk-cancel");
  gtk_widget_show(cancelbutton1);
  gtk_dialog_add_action_widget(GTK_DIALOG(AddStreamDialog), cancelbutton1, GTK_RESPONSE_CANCEL);
  GTK_WIDGET_SET_FLAGS(cancelbutton1, GTK_CAN_DEFAULT);

  okbutton1 = gtk_button_new_from_stock("gtk-ok");
  gtk_widget_show(okbutton1);
  gtk_dialog_add_action_widget(GTK_DIALOG(AddStreamDialog), okbutton1, GTK_RESPONSE_OK);
  GTK_WIDGET_SET_FLAGS(okbutton1, GTK_CAN_DEFAULT);
  
  g_signal_connect((gpointer) AddStreamText, "activate",
		   G_CALLBACK(on_AddStreamText_activate),
		   AddStreamDialog);
  g_signal_connect((gpointer) AddStreamDialog, "response",
                    G_CALLBACK(on_AddStreamDialog_response),
                    NULL);

  /* Store pointers to all widgets, for use by lookup_widget(). */
  GLADE_HOOKUP_OBJECT_NO_REF(AddStreamDialog, AddStreamDialog, "AddStreamDialog");
  GLADE_HOOKUP_OBJECT_NO_REF(AddStreamDialog, dialog_vbox1, "dialog_vbox1");
  GLADE_HOOKUP_OBJECT(AddStreamDialog, vbox20, "vbox20");
  GLADE_HOOKUP_OBJECT(AddStreamDialog, AddStreamText, "AddStreamText");
  GLADE_HOOKUP_OBJECT_NO_REF(AddStreamDialog, dialog_action_area1, "dialog_action_area1");
  GLADE_HOOKUP_OBJECT(AddStreamDialog, cancelbutton1, "cancelbutton1");
  GLADE_HOOKUP_OBJECT(AddStreamDialog, okbutton1, "okbutton1");
  GLADE_HOOKUP_OBJECT_NO_REF(AddStreamDialog, tooltips, "tooltips");

  gtk_widget_grab_focus(AddStreamText);
  gtk_widget_show(AddStreamDialog);

}

/*
 * Delete Stream handlers and dialog
 */
static void
on_DeleteStreamDialog_response         (GtkDialog       *dialog,
                                        gint             response_id,
                                        gpointer         user_data)
{
  if (GTK_RESPONSE_YES == response_id) {
    if (MyConfig->GetBoolValue(CONFIG_VIDEO_PREVIEW)) {
      const char *stream = 
	MyConfig->GetStringValue(CONFIG_VIDEO_PREVIEW_STREAM);
      if (strcmp(stream, SelectedStream) == 0) {
	AVFlow->StopVideoPreview();
	MyConfig->SetBoolValue(CONFIG_VIDEO_PREVIEW, false);
	MyConfig->SetStringValue(CONFIG_VIDEO_PREVIEW_STREAM, NULL);
      }
    }
    if (AVFlow->DeleteStream(SelectedStream) == false) {
      ShowMessage("Not Deleted", "An Error as occurred\nStream not deleted");
    } else {
      DisplayStreamsInView();
      DisplayStreamData(NULL);
    }
  }
  gtk_widget_destroy(GTK_WIDGET(dialog));
}

static void
on_DeleteStreamButton_clicked          (GtkButton       *button,
                                        gpointer         user_data)
{
  GtkWidget *DeleteStreamDialog;
  GtkWidget *dialog_vbox2;
  GtkWidget *vbox21;
  GtkWidget *label72;
  GtkWidget *DeleteStreamLabel;
  GtkWidget *label74;
  GtkWidget *dialog_action_area2;
  GtkWidget *cancelbutton2;
  GtkWidget *DeleteStreamButton;

  if (started) return;

  if (AVFlow->m_stream_list->GetCount() == 1) {
    ShowMessage("Delete Error", "Can not delete last stream", MainWindow);
    return;
  }

  DeleteStreamDialog = gtk_dialog_new();
  gtk_widget_set_size_request(DeleteStreamDialog, 236, -1);
  gtk_window_set_title(GTK_WINDOW(DeleteStreamDialog), _("Delete Stream ?"));
  gtk_window_set_modal(GTK_WINDOW(DeleteStreamDialog), TRUE);
  gtk_window_set_transient_for(GTK_WINDOW(DeleteStreamDialog), 
			       GTK_WINDOW(MainWindow));
  gtk_window_set_resizable(GTK_WINDOW(DeleteStreamDialog), FALSE);
  gtk_window_set_destroy_with_parent(GTK_WINDOW(DeleteStreamDialog), TRUE);
  gtk_dialog_set_has_separator(GTK_DIALOG(DeleteStreamDialog), FALSE);

  dialog_vbox2 = GTK_DIALOG(DeleteStreamDialog)->vbox;
  gtk_widget_show(dialog_vbox2);

  vbox21 = gtk_vbox_new(FALSE, 0);
  gtk_widget_show(vbox21);
  gtk_box_pack_start(GTK_BOX(dialog_vbox2), vbox21, TRUE, TRUE, 0);

  label72 = gtk_label_new(_("You are about to delete stream:"));
  gtk_widget_show(label72);
  gtk_box_pack_start(GTK_BOX(vbox21), label72, FALSE, FALSE, 23);

  DeleteStreamLabel = gtk_label_new(SelectedStream);
  gtk_widget_show(DeleteStreamLabel);
  gtk_box_pack_start(GTK_BOX(vbox21), DeleteStreamLabel, FALSE, FALSE, 1);

  label74 = gtk_label_new(_("This operation cannot be\nreversed."));
  gtk_widget_show(label74);
  gtk_box_pack_start(GTK_BOX(vbox21), label74, FALSE, FALSE, 24);
  gtk_label_set_justify(GTK_LABEL(label74), GTK_JUSTIFY_CENTER);

  dialog_action_area2 = GTK_DIALOG(DeleteStreamDialog)->action_area;
  gtk_widget_show(dialog_action_area2);
  gtk_button_box_set_layout(GTK_BUTTON_BOX(dialog_action_area2), GTK_BUTTONBOX_END);

  cancelbutton2 = gtk_button_new_from_stock("gtk-no");
  gtk_widget_show(cancelbutton2);
  gtk_dialog_add_action_widget(GTK_DIALOG(DeleteStreamDialog), cancelbutton2, GTK_RESPONSE_NO);
  GTK_WIDGET_SET_FLAGS(cancelbutton2, GTK_CAN_DEFAULT);

  DeleteStreamButton = gtk_button_new_from_stock("gtk-yes");
  gtk_widget_show(DeleteStreamButton);
  gtk_dialog_add_action_widget(GTK_DIALOG(DeleteStreamDialog), DeleteStreamButton, GTK_RESPONSE_YES);
  GTK_WIDGET_SET_FLAGS(DeleteStreamButton, GTK_CAN_DEFAULT);

  g_signal_connect((gpointer) DeleteStreamDialog, "response",
                    G_CALLBACK(on_DeleteStreamDialog_response),
                    NULL);

  /* Store pointers to all widgets, for use by lookup_widget(). */
  GLADE_HOOKUP_OBJECT_NO_REF(DeleteStreamDialog, DeleteStreamDialog, "DeleteStreamDialog");