/* 
 *	Copyright (C) 2004-2005 Vadim Berezniker
 *	http://www.kryptolus.com
 *
 *  This Program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2, or (at your option)
 *  any later version.
 *   
 *  This Program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 *  GNU General Public License for more details.
 *   
 *  You should have received a copy of the GNU General Public License
 *  along with GNU Make; see the file COPYING.  If not, write to
 *  the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. 
 *  http://www.gnu.org/copyleft/gpl.html
 *
 */

#include "stdafx.h"

#include "common.h"

#include "sabbu.h"

#include "kryArray.h"
#include "kryString.h"
#include "krySSACommandParser.h"
#include "krySSACommandHighlighter.h"

#include "gui_status_bar.h"
#include "gui_text_editor.h"
#include "gui_time_entry.h"
#include "gui_waveforms.h"
#include "sound.h"
#include "sound_out.h"

#include "gui_peakfile.h"

extern struct sabbu app;

/*
 * Destroys any waveforms currently displayed and any data associated with them.
 */
void gui_waveforms_destroy()
{
  soundserver_stop();
  soundserver_close();

  if(app.ui.sound_info && app.ui.pane_other_pos)
  {
    char *key = kry_strdup_printf(KRY_LOC "PanePositionAudioB%d", app.ui.sound_info->channels);
    app.prefs->SetInt(key, app.ui.pane_other_pos);
    kry_free(key);
  }

  GList *list = gtk_container_get_children(GTK_CONTAINER(app.ui.hbox_hide_channels));
  for(GList *ptr = list; ptr; ptr = ptr->next)
  {
    if(ptr == list)
      continue;

    gtk_container_remove(GTK_CONTAINER(app.ui.hbox_hide_channels), GTK_WIDGET(ptr->data));
  }
  g_list_free(list);

  kry_waveform_group_waveform_remove_all(app.ui.waveform_group);
  kry_waveform_group_reset(app.ui.waveform_group);

  struct sound_info *sound_info = app.ui.sound_info;
  if(sound_info)
  {
    for(int i = 0; i < sound_info->channels; i++)
      kry_free(sound_info->waveform_data[i]);
    kry_free(sound_info->waveform_data);
    sf_close(sound_info->snd);
  }
}

void gui_waveforms_waveform_set_name(GtkWidget *widget, struct waveform_info *info)
{
  GtkDialog *dialog = GTK_DIALOG(gtk_dialog_new_with_buttons(_("Set Name"), app.ui.window, GTK_DIALOG_MODAL, GTK_STOCK_OK, 1, NULL));
  GtkEntry *entry = GTK_ENTRY(gtk_entry_new());
  char *text;

  gtk_entry_set_text(entry, info->name);

  gtk_box_pack_start(GTK_BOX(dialog->vbox), GTK_WIDGET(entry), FALSE, TRUE, 0);
  gtk_widget_show_all(GTK_WIDGET(dialog));

  gui_main_disable();
  gtk_dialog_run(dialog);

  text = kry_strdup((char *) gtk_entry_get_text(entry)); 
  gtk_label_set_text(info->label_name, text);
  kry_free(info->name);
  info->name = text; 

  gtk_window_present(app.ui.window);
  gtk_widget_destroy(GTK_WIDGET(dialog));
  gui_main_enable();

  gui_main_focus_on_wave();
}

void gui_waveforms_waveform_hide_simple_cb(GtkToggleButton *button, KryWaveformGroupItem *item)
{
  if(gtk_toggle_button_get_active(button))
    kry_waveform_group_item_show(item);
  else
    kry_waveform_group_item_hide(item);
}

void gui_waveforms_waveform_hide_cb(GtkWidget *widget, struct waveform_info *info)
{
  GList *children = gtk_container_get_children(GTK_CONTAINER(widget));
  GList *ptr = children;
  while(ptr)
  {
    gtk_container_remove(GTK_CONTAINER(widget), GTK_WIDGET(ptr->data));
    ptr = ptr->next;
  }

  if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget)))
  {
    gtk_container_add(GTK_CONTAINER(widget), gtk_image_new_from_pixbuf(app.ui.pixbufs.show));
    kry_waveform_group_item_show(info->item);
  }
  else
  {
    gtk_container_add(GTK_CONTAINER(widget), gtk_image_new_from_pixbuf(app.ui.pixbufs.hide));
    kry_waveform_group_item_hide(info->item);
  }

  g_list_free(children);
  gtk_widget_show_all(widget);
}

void gui_waveforms_waveform_spin_zoom_cb(GtkWidget *widget, struct waveform_info *info)
{
  double val = gtk_spin_button_get_value_as_float(GTK_SPIN_BUTTON(widget));

  if(info)
    kry_waveform_set_zoom(info->waveform, val);
  else
    kry_waveform_group_set_zoom(app.ui.waveform_group, val);

  gui_main_focus_on_wave();

  while(gtk_events_pending())
    gtk_main_iteration();
}

void gui_waveforms_waveform_spin_scale_cb(GtkWidget *widget, struct waveform_info *info)
{
  int val = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(widget));

  if(info)
    kry_waveform_set_scale(info->waveform, val);
  else
    kry_waveform_group_set_scale(app.ui.waveform_group, val);

  gui_main_focus_on_wave();

  while(gtk_events_pending())
    gtk_main_iteration();
}

void gui_waveforms_waveform_sync_zoom_cb(GtkWidget *widget, struct waveform_info *info)
{
  gboolean val = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget));
  kry_waveform_group_item_set_zoom_sync(info->item, val);
}

void gui_waveforms_waveform_sync_scale_cb(GtkWidget *widget, struct waveform_info *info)
{
  gboolean val = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget));
  kry_waveform_group_item_set_scale_sync(info->item, val);
}

void gui_waveforms_waveform_sync_scroll_cb(GtkWidget *widget, struct waveform_info *info)
{
  gboolean val = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget));
  kry_waveform_group_item_set_scroll_sync(info->item, val);
}


void gui_waveforms_waveform_show_time_cb(GtkWidget *widget, struct waveform_info *info)
{
  gboolean val = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget));

  if(info)
  {
    kry_waveform_set_show_time_bar(info->waveform, val);
    kry_waveform_set_show_time_markers(info->waveform, val);
  }
  else
  {
    kry_waveform_group_set_show_time_bar(app.ui.waveform_group, val);
    kry_waveform_group_set_show_time_markers(app.ui.waveform_group, val);
  }
  gui_main_focus_on_wave();
}

void gui_waveforms_waveform_show_keyframes_cb(GtkWidget *widget, struct waveform_info *info)
{
  gboolean val = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget));
  if(info)
    kry_waveform_set_show_keyframes(info->waveform, val);
  else
    kry_waveform_group_set_show_keyframes(app.ui.waveform_group, val);

  gui_main_focus_on_wave();
}


void gui_waveforms_waveform_mute_cb(GtkWidget *widget, struct waveform_info *info)
{
  gboolean val = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget));
  sound_mute(info->channel, val);
  kryListIterator<struct waveform_info *> iter;
  /*app.ui.waves.GetIterator(&iter);
  while(struct waveform_info *info_cur = iter.GetNext())
  {
    if(info_cur->channel == info->channel)
      gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(info_cur->button_mute), val);
  }*/

  gui_main_focus_on_wave();
}

void gui_waveforms_waveform_focus_selected_cb(GtkWidget *widget, struct waveform_info *info)
{
  if(info)
    kry_waveform_focus_selected(info->waveform);
  else
    kry_waveform_group_focus_selected(app.ui.waveform_group);
}

void gui_waveforms_waveform_close(GtkWidget *widget, struct waveform_info *info)
{
  GList *list_buttons = gtk_container_get_children(GTK_CONTAINER(app.ui.hbox_hide_channels));
  GList *list_items = kry_waveform_group_waveform_get_list(app.ui.waveform_group);
  int i = 1;
  for(GList *ptr = list_items; ptr; ptr = ptr->next, i++)
  {
    if(ptr->data == info->item)
    {
      GtkWidget *widget = GTK_WIDGET(g_list_nth_data(list_buttons, i));
      gtk_container_remove(GTK_CONTAINER(app.ui.hbox_hide_channels), widget);
      break;
    }
  }
  kry_waveform_group_waveform_remove(app.ui.waveform_group, info->item);

  kry_free(info->name);
  kry_free(info);
}

GtkWidget *gui_waveforms_create_sep()
{
  GtkWidget *box = gtk_event_box_new();
  GtkWidget *label_left = gtk_label_new(NULL);
  GtkWidget *label_right = gtk_label_new(NULL);
  GtkWidget *sep = gtk_vseparator_new();

  gtk_widget_set_size_request(GTK_WIDGET(label_left), 2, 0);
  gtk_widget_set_size_request(GTK_WIDGET(label_right), 2, 0);

  gtk_container_add(GTK_CONTAINER(box), sep);
  gtk_container_set_border_width(GTK_CONTAINER(box), 4);

  return box;
}

void gui_waveforms_group_zoom_cb(KryWaveformGroup *group, double zoom, GtkSpinButton *spin)
{
  gtk_spin_button_set_value(spin, zoom);
}

void gui_waveforms_group_scale_cb(KryWaveformGroup *group, int scale, GtkSpinButton *spin)
{
  gtk_spin_button_set_value(spin, scale);
}

GtkToolbar *gui_waveforms_create_simple_toolbar()
{
  GtkToolbar *toolbar = GTK_TOOLBAR(gtk_toolbar_new());
  GtkButton *button_opt_time;
  GtkButton *button_opt_keyframes;
  GtkLabel *label_scale = GTK_LABEL(gtk_label_new(_("Scale:")));
  GtkSpinButton *spin_scale = GTK_SPIN_BUTTON(gtk_spin_button_new_with_range(0, 200, 5));
  GtkLabel *label_zoom = GTK_LABEL(gtk_label_new(_("Zoom:")));
  GtkSpinButton *spin_zoom = GTK_SPIN_BUTTON(gtk_spin_button_new_with_range(1, 2000, 1));

  gtk_misc_set_padding(GTK_MISC(label_zoom), 3, 0);

  gtk_spin_button_set_digits(spin_zoom, 2);
  
  gtk_spin_button_set_value(spin_scale, 100);

  g_signal_connect(G_OBJECT(spin_scale), "value-changed", G_CALLBACK(gui_waveforms_waveform_spin_scale_cb), NULL);
  g_signal_connect(G_OBJECT(spin_zoom), "value-changed", G_CALLBACK(gui_waveforms_waveform_spin_zoom_cb), NULL);

  g_signal_connect(G_OBJECT(app.ui.waveform_group), "zoom-changed", G_CALLBACK(gui_waveforms_group_zoom_cb), spin_zoom);
  g_signal_connect(G_OBJECT(app.ui.waveform_group), "scale-changed", G_CALLBACK(gui_waveforms_group_scale_cb), spin_scale);

  // options
  button_opt_time = GTK_BUTTON(gtk_toggle_button_new());
  gtk_container_add(GTK_CONTAINER(button_opt_time), gtk_image_new_from_pixbuf(app.ui.pixbufs.show_time));
  gtk_button_set_relief(button_opt_time, GTK_RELIEF_NONE);
  gtk_tooltips_set_tip(app.ui.tooltips, GTK_WIDGET(button_opt_time), __("ToggleTimeMarkersTooltip|Toggle Time Markers"), NULL);
  g_signal_connect(button_opt_time, "toggled", G_CALLBACK(gui_waveforms_waveform_show_time_cb), NULL);
  gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button_opt_time), TRUE);

  button_opt_keyframes = GTK_BUTTON(gtk_toggle_button_new());
  gtk_container_add(GTK_CONTAINER(button_opt_keyframes), gtk_image_new_from_pixbuf(app.ui.pixbufs.show_keyframes));
  gtk_button_set_relief(button_opt_keyframes, GTK_RELIEF_NONE);
  gtk_tooltips_set_tip(app.ui.tooltips, GTK_WIDGET(button_opt_keyframes), __("ToggleKeyframesTooltip|Toggle Key Frames"), NULL);
  gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button_opt_keyframes), TRUE);
  g_signal_connect(button_opt_keyframes, "toggled", G_CALLBACK(gui_waveforms_waveform_show_keyframes_cb), NULL);
  gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button_opt_keyframes), TRUE);

  GtkHBox *hbox_play_toolbar = GTK_HBOX(gtk_hbox_new(FALSE, 0));
  app.ui.hbox_play_toolbar = hbox_play_toolbar;

  gtk_toolbar_append_widget(toolbar, GTK_WIDGET(label_zoom), __("ZoomTooltip|Zoom (number of seconds displayed on each page)"), NULL);
  gtk_toolbar_append_widget(toolbar, GTK_WIDGET(spin_zoom), __("ZoomTooltip|Zoom (number of seconds displayed on each page)"), NULL);
  GtkWidget *label_s = gtk_label_new(__("Seconds|s"));
  gtk_toolbar_append_widget(toolbar, label_s, __("DefaultZoomSuffix|seconds"), NULL);
  gtk_toolbar_append_widget(toolbar, gui_waveforms_create_sep(), NULL, NULL);
  gtk_toolbar_append_widget(toolbar, GTK_WIDGET(label_scale), __("ScaleLabelTooltip|Scale"), NULL);
  gtk_toolbar_append_widget(toolbar, GTK_WIDGET(spin_scale), __("ScaleSpinnerTooltip|Scale"), NULL);
  gtk_toolbar_append_widget(toolbar, gui_waveforms_create_sep(), NULL, NULL);
  gtk_toolbar_append_item(toolbar, NULL, _("Jump To Selection"), NULL, gtk_image_new_from_stock("sabbu-wave-jump", GTK_ICON_SIZE_SMALL_TOOLBAR), GTK_SIGNAL_FUNC(gui_waveforms_waveform_focus_selected_cb), NULL);
  gtk_toolbar_append_widget(toolbar, gui_waveforms_create_sep(), NULL, NULL);
  gtk_toolbar_append_widget(toolbar, GTK_WIDGET(button_opt_time), _("Show Time Markers"), NULL);
  gtk_toolbar_append_widget(toolbar, GTK_WIDGET(button_opt_keyframes), _("Show Key Frames"), NULL);

  GtkHBox *hbox = GTK_HBOX(gtk_hbox_new(FALSE, 0));
  gtk_box_pack_start(GTK_BOX(hbox), gui_waveforms_create_sep(), FALSE, TRUE, 0);
  gtk_toolbar_append_widget(toolbar, GTK_WIDGET(hbox), NULL, NULL);
  app.ui.hbox_hide_channels = hbox;

  gtk_toolbar_set_icon_size(toolbar, GTK_ICON_SIZE_SMALL_TOOLBAR);
  gtk_widget_show_all(GTK_WIDGET(toolbar));
  gtk_widget_hide(GTK_WIDGET(hbox));

  return toolbar;
}


GtkToolbar *gui_waveforms_waveform_toolbar_create(struct waveform_info *info, gboolean show_sync_toggles, KryWaveformGroupItem *parent)
{
  GtkToolbar *toolbar = GTK_TOOLBAR(gtk_toolbar_new());
  GtkLabel *label_name = GTK_LABEL(gtk_label_new(info->name));
  GtkButton *button_opt_time;
  GtkButton *button_opt_keyframes;
  GtkFrame *frame_name = GTK_FRAME(gtk_frame_new(NULL));
  GtkLabel *label_scale = GTK_LABEL(gtk_label_new(_("Scale:")));
  GtkSpinButton *scale_spin = GTK_SPIN_BUTTON(gtk_spin_button_new_with_range(0, 200, 5));
  GtkLabel *label_zoom = GTK_LABEL(gtk_label_new(_("Zoom:")));
  GtkSpinButton *zoom_spin = GTK_SPIN_BUTTON(gtk_spin_button_new_with_range(1, 2000, 1));

  info->label_name = label_name;
  info->toolbar = toolbar;
  info->spin_scale = scale_spin;
  info->spin_zoom = zoom_spin;
  info->frame_name = frame_name;

  gtk_misc_set_padding(GTK_MISC(label_zoom), 3, 0);

  gtk_spin_button_set_digits(info->spin_zoom, 2);
  
  gtk_spin_button_set_value(info->spin_scale, 100);

  gtk_widget_set_usize(GTK_WIDGET(label_name), 150, -1);

  gtk_container_add(GTK_CONTAINER(frame_name), GTK_WIDGET(label_name));
  gtk_container_set_border_width(GTK_CONTAINER(frame_name), 3);

  info->button_hide = GTK_BUTTON(gtk_toggle_button_new());
  gtk_container_add(GTK_CONTAINER(info->button_hide), gtk_image_new_from_pixbuf(app.ui.pixbufs.show));
  gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(info->button_hide), TRUE);
  gtk_button_set_relief(info->button_hide, GTK_RELIEF_NONE);
  gtk_tooltips_set_tip(app.ui.tooltips, GTK_WIDGET(info->button_hide), "Hide", NULL);
  g_signal_connect(info->button_hide, "toggled", G_CALLBACK(gui_waveforms_waveform_hide_cb), info);


  info->button_mute = GTK_TOGGLE_BUTTON(gtk_toggle_button_new_with_label(__("Mute|M")));
  gtk_button_set_relief(GTK_BUTTON(info->button_mute), GTK_RELIEF_NONE);
  g_signal_connect(G_OBJECT(info->button_mute), "clicked", G_CALLBACK(gui_waveforms_waveform_mute_cb), info);
  g_signal_connect(G_OBJECT(scale_spin), "value-changed", G_CALLBACK(gui_waveforms_waveform_spin_scale_cb), info);
  g_signal_connect(G_OBJECT(zoom_spin), "value-changed", G_CALLBACK(gui_waveforms_waveform_spin_zoom_cb), info);

  // options
  button_opt_time = GTK_BUTTON(gtk_toggle_button_new());
  gtk_container_add(GTK_CONTAINER(button_opt_time), gtk_image_new_from_pixbuf(app.ui.pixbufs.show_time));
  gtk_button_set_relief(button_opt_time, GTK_RELIEF_NONE);
  gtk_tooltips_set_tip(app.ui.tooltips, GTK_WIDGET(button_opt_time), __("ToggleTimeMarkersTooltip|Toggle Time Markers"), NULL);
  g_signal_connect(button_opt_time, "toggled", G_CALLBACK(gui_waveforms_waveform_show_time_cb), info);
  if(parent)
  {
    gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button_opt_time), kry_waveform_get_show_time_bar(parent->waveform));
    gtk_toggle_button_toggled(GTK_TOGGLE_BUTTON(button_opt_time));
  }
  else
  {
    gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button_opt_time), TRUE);
  }

  button_opt_keyframes = GTK_BUTTON(gtk_toggle_button_new());
  gtk_container_add(GTK_CONTAINER(button_opt_keyframes), gtk_image_new_from_pixbuf(app.ui.pixbufs.show_keyframes));
  gtk_button_set_relief(button_opt_keyframes, GTK_RELIEF_NONE);
  gtk_tooltips_set_tip(app.ui.tooltips, GTK_WIDGET(button_opt_keyframes), __("ToggleKeyframesTooltip|Toggle Key Frames"), NULL);
  gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button_opt_keyframes), TRUE);
  g_signal_connect(button_opt_keyframes, "toggled", G_CALLBACK(gui_waveforms_waveform_show_keyframes_cb), info);
  if(parent)
  {
    gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button_opt_keyframes), kry_waveform_get_show_keyframes(parent->waveform));
    gtk_toggle_button_toggled(GTK_TOGGLE_BUTTON(button_opt_keyframes));
  }
  else
  {
    gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button_opt_keyframes), TRUE);
  }

  if(show_sync_toggles)
  {
    info->button_sync_scroll = GTK_TOGGLE_BUTTON(gtk_toggle_button_new());
    gtk_container_add(GTK_CONTAINER(info->button_sync_scroll), gtk_image_new_from_pixbuf(app.ui.pixbufs.sync_scroll));
    gtk_button_set_relief(GTK_BUTTON(info->button_sync_scroll), GTK_RELIEF_NONE);
    gtk_tooltips_set_tip(app.ui.tooltips, GTK_WIDGET(info->button_sync_scroll), __("SyncScrollTooltip|Sync Scroll"), NULL);
    gtk_toggle_button_set_active(info->button_sync_scroll, TRUE);
    g_signal_connect(info->button_sync_scroll, "toggled", G_CALLBACK(gui_waveforms_waveform_sync_scroll_cb), info);

    info->button_sync_zoom = GTK_TOGGLE_BUTTON(gtk_toggle_button_new());
    gtk_container_add(GTK_CONTAINER(info->button_sync_zoom), gtk_image_new_from_pixbuf(app.ui.pixbufs.sync_zoom));
    gtk_button_set_relief(GTK_BUTTON(info->button_sync_zoom), GTK_RELIEF_NONE);
    gtk_tooltips_set_tip(app.ui.tooltips, GTK_WIDGET(info->button_sync_zoom), __("SyncZoomTooltip|Sync Zoom"), NULL);
    gtk_toggle_button_set_active(info->button_sync_zoom, TRUE);
    g_signal_connect(info->button_sync_zoom, "toggled", G_CALLBACK(gui_waveforms_waveform_sync_zoom_cb), info);

    info->button_sync_scale = GTK_TOGGLE_BUTTON(gtk_toggle_button_new());
    gtk_container_add(GTK_CONTAINER(info->button_sync_scale), gtk_image_new_from_pixbuf(app.ui.pixbufs.sync_scale));
    gtk_button_set_relief(GTK_BUTTON(info->button_sync_scale), GTK_RELIEF_NONE);
    gtk_tooltips_set_tip(app.ui.tooltips, GTK_WIDGET(info->button_sync_scale), __("SyncScaleTooltip|Sync Scale"), NULL);
    gtk_toggle_button_set_active(info->button_sync_scale, TRUE);
    g_signal_connect(info->button_sync_scale, "toggled", G_CALLBACK(gui_waveforms_waveform_sync_scale_cb), info);
  }

  GtkHBox *hbox_play_toolbar = GTK_HBOX(gtk_hbox_new(FALSE, 0));
  app.ui.hbox_play_toolbar = hbox_play_toolbar;

  gtk_toolbar_append_widget(toolbar, GTK_WIDGET(hbox_play_toolbar), NULL, NULL);
  gtk_toolbar_append_widget(toolbar, GTK_WIDGET(info->button_hide), __("HideWaveformTooltip|Hide"), NULL);
  gtk_toolbar_append_widget(toolbar, GTK_WIDGET(frame_name), __("WaveformNameTooltip|Waveform Name"), NULL);
  info->button_set_name =
    gtk_toolbar_append_item(toolbar, NULL, _("Set Name"), _("Set Waveform Name"), gtk_image_new_from_stock("sabbu-wave-name", GTK_ICON_SIZE_SMALL_TOOLBAR), GTK_SIGNAL_FUNC(gui_waveforms_waveform_set_name), info);
  info->sep1 = gui_waveforms_create_sep();
  gtk_toolbar_append_widget(toolbar, info->sep1, NULL, NULL);
  gtk_toolbar_append_widget(toolbar, GTK_WIDGET(info->button_mute), _("Mute"), NULL);
  info->sep2 = gui_waveforms_create_sep();
  gtk_toolbar_append_widget(toolbar, info->sep2, NULL, NULL);
  gtk_toolbar_append_widget(toolbar, GTK_WIDGET(label_zoom), __("ZoomTooltip|Zoom (number of seconds displayed on each page)"), NULL);
  gtk_toolbar_append_widget(toolbar, GTK_WIDGET(zoom_spin), __("ZoomTooltip|Zoom (number of seconds displayed on each page)"), NULL);
  
  GtkWidget *label_s = gtk_label_new(__("Seconds|s"));
  gtk_toolbar_append_widget(toolbar, label_s, __("DefaultZoomSuffix|seconds"), NULL);
  gtk_toolbar_append_widget(toolbar, gui_waveforms_create_sep(), NULL, NULL);
  gtk_toolbar_append_widget(toolbar, GTK_WIDGET(label_scale), __("ScaleLabelTooltip|Scale"), NULL);
  gtk_toolbar_append_widget(toolbar, GTK_WIDGET(scale_spin), __("ScaleSpinnerTooltip|Scale"), NULL);
  gtk_toolbar_append_widget(toolbar, gui_waveforms_create_sep(), NULL, NULL);
  gtk_toolbar_append_item(toolbar, NULL, _("Jump To Selection"), NULL, 
    gtk_image_new_from_stock("sabbu-wave-jump", GTK_ICON_SIZE_SMALL_TOOLBAR), 
    GTK_SIGNAL_FUNC(gui_waveforms_waveform_focus_selected_cb), info);
  gtk_toolbar_append_widget(toolbar, gui_waveforms_create_sep(), NULL, NULL);
  info->button_clone = 
    gtk_toolbar_append_item(toolbar, NULL, _("Clone View"), NULL, 
    gtk_image_new_from_stock("sabbu-wave-clone", GTK_ICON_SIZE_SMALL_TOOLBAR), 
    GTK_SIGNAL_FUNC(gui_waveforms_waveform_clone_cb), info->item);
  info->sep3 = GTK_WIDGET(gtk_vseparator_new());
  gtk_toolbar_append_widget(toolbar, info->sep3, NULL, NULL);
  gtk_toolbar_append_widget(toolbar, GTK_WIDGET(button_opt_time), _("Show Time Markers"), NULL);
  gtk_toolbar_append_widget(toolbar, GTK_WIDGET(button_opt_keyframes), _("Show Key Frames"), NULL);

  if(show_sync_toggles)
  {
    gtk_toolbar_append_widget(toolbar, gui_waveforms_create_sep(), NULL, NULL);
    gtk_toolbar_append_widget(toolbar, GTK_WIDGET(info->button_sync_scroll), _("Synchronize Scroll"), NULL);
    gtk_toolbar_append_widget(toolbar, GTK_WIDGET(info->button_sync_zoom), _("Synchronize Zoom"), NULL);
    gtk_toolbar_append_widget(toolbar, GTK_WIDGET(info->button_sync_scale), _("Synchronize Scale"), NULL);
    gtk_toolbar_append_widget(toolbar, gui_waveforms_create_sep(), NULL, NULL);

    if(parent)
      gtk_toolbar_append_item(toolbar, NULL, _("Close View"), NULL, 
      gtk_image_new_from_stock("sabbu-wave-close", GTK_ICON_SIZE_SMALL_TOOLBAR), 
      GTK_SIGNAL_FUNC(gui_waveforms_waveform_close), info);
  }

  gtk_toolbar_set_icon_size(toolbar, GTK_ICON_SIZE_SMALL_TOOLBAR);

  if(!info->data_info)
  {
    GList *children = gtk_container_get_children(GTK_CONTAINER(toolbar));
    GList *ptr = children;
    while(ptr)
    {
      gtk_widget_set_sensitive(GTK_WIDGET(ptr->data), FALSE);
      ptr = ptr->next;
    }

    gtk_widget_set_sensitive(GTK_WIDGET(info->button_hide), TRUE);
    gtk_widget_set_sensitive(GTK_WIDGET(frame_name), TRUE);
  }

  gtk_widget_show_all(GTK_WIDGET(toolbar));

  return toolbar;
}

/*
 * Creates waveforms based on the data in the sound_info parameters.
 * One waveform will be created for each channel.
 * If sound_info is NULL, an empty waveform is created.
 */
void gui_waveforms_setup(struct sound_info *sound_info)
{
  if(sound_info)
  {
    for(int i = sound_info->channels; i >= 1; i --)
    {
      char *key = kry_strdup_printf(KRY_LOC "PanePositionAudioB%d", i);
      int pos = app.prefs->GetInt(key, 0);
      if(pos)
      {
        gtk_paned_set_position(app.ui.wave_pane, pos);
        break;
      }
    }

    kry_waveform_group_set_zoom(app.ui.waveform_group, app.prefs->GetInt("DefaultZoomMili", 3000) / 1000.0);
    for(int i = 0; i < sound_info->channels; i++)
    {
      KryWaveformDataInfo *info = kry_new0(KryWaveformDataInfo);
      info->length_seconds = sound_info->length_seconds;
      info->max_neg = sound_info->max_neg;
      info->max_pos = sound_info->max_pos;
      info->vals_per_sec = sound_info->vals_per_sec;
      info->waveform_data = sound_info->waveform_data[i];

      char *title = "";
      if(sound_info->channels == 1)
      {
        title = kry_strdup(_("Center Channel"));
      }
      else if(sound_info->channels == 2)
      {
        if(i == 0)
          title = kry_strdup(_("Left Channel"));
        else if(i == 1)
          title = kry_strdup(_("Right Channel"));
      }
      else
      {
        title = kry_strdup_printf(KRY_LOC  _("Channel %d"), i + 1);
      }

      gui_waveforms_waveform_add(info, title, i != 0, NULL);
      kry_free(title);

    }
  }
  else
  {
    gui_waveforms_waveform_add_empty();
    gtk_widget_hide(GTK_WIDGET(app.ui.hbox_hide_channels));
    gtk_widget_hide(kry_waveform_group_get_scrollbar(app.ui.waveform_group));
    gtk_widget_hide(kry_waveform_group_get_toolbar(app.ui.waveform_group));
  }

  gui_main_focus_on_wave();

  app.ui.sound_info = sound_info;
}

void gui_waveforms_waveform_zoom_cb(KryWaveform *waveform, double zoom, struct waveform_info *info)
{
  //g_signal_handlers_block_by_func(info->spin_zoom, gui_waveforms_waveform_spin_zoom_cb, info);
  gtk_spin_button_set_value(info->spin_zoom, zoom);
  //g_signal_handlers_unblock_by_func(info->spin_zoom, gui_waveforms_waveform_spin_zoom_cb, info);
}

void gui_waveforms_waveform_scale_cb(KryWaveform *waveform, int scale, struct waveform_info *info)
{
  //g_signal_handlers_block_by_func(info->spin_zoom, gui_waveforms_waveform_spin_scale_cb, info);
  gtk_spin_button_set_value(info->spin_scale, scale);
  //g_signal_handlers_unblock_by_func(info->spin_zoom, gui_waveforms_waveform_spin_scale_cb, info);
}

void gui_waveforms_waveform_min_zoom_cb(KryWaveform *waveform, double min_zoom, struct waveform_info *info)
{
  gtk_spin_button_set_range(info->spin_zoom, min_zoom, info->data_info->length_seconds);
}

void gui_waveforms_waveform_zoom_sync_cb(KryWaveformGroupItem *item, gboolean val, struct waveform_info *info)
{
  gtk_toggle_button_set_active(info->button_sync_zoom, val);
}

void gui_waveforms_waveform_scale_sync_cb(KryWaveformGroupItem *item, gboolean val, struct waveform_info *info)
{
  gtk_toggle_button_set_active(info->button_sync_scale, val);
}

void gui_waveforms_waveform_scroll_sync_cb(KryWaveformGroupItem *item, gboolean val, struct waveform_info *info)
{
  gtk_toggle_button_set_active(info->button_sync_scroll, val);
}

void gui_waveforms_waveform_add(struct KryWaveformDataInfo *data_info, char *title, gboolean show_sync_toggles, KryWaveformGroupItem *parent)
{
  GtkHScrollbar *scrollbar = GTK_HSCROLLBAR(gtk_hscrollbar_new(kry_waveform_group_get_adjustment(app.ui.waveform_group)));
  KryWaveform *waveform = (KryWaveform *) 
    kry_waveform_new(data_info,
      kry_waveform_group_get_adjustment(app.ui.waveform_group), 
      app.ui.waveform_color_table);

  GtkToolbar *toolbar;
  struct waveform_info *info = kry_new0(struct waveform_info);

  g_signal_connect(waveform, "key-press-event", G_CALLBACK(gui_main_key_press), NULL);
  g_signal_connect(waveform, "scroll-event", G_CALLBACK(gui_main_scroll_press), NULL);
  g_signal_connect(waveform, "zoom-changed", G_CALLBACK(gui_waveforms_waveform_zoom_cb), info);
  g_signal_connect(waveform, "scale-changed", G_CALLBACK(gui_waveforms_waveform_scale_cb), info);

  info->waveform = waveform;
  info->data_info = data_info;
  info->name = title ? kry_strdup(title) : NULL;
  //info->channel = channel;

  /*if(parent)
  {
    info->name = kry_strdup_printf(KRY_LOC  "%s (Clone)", info->parent->name);
  }*/

  KryWaveformGroupItem *item = KRY_WAVEFORM_GROUP_ITEM(kry_waveform_group_item_new(waveform));

  item->parent_item = parent;
  info->item = item;

  toolbar = gui_waveforms_waveform_toolbar_create(info, show_sync_toggles, parent);

  kry_waveform_group_item_set_toolbar(item, GTK_WIDGET(toolbar));
  kry_waveform_group_item_set_scrollbar(item, GTK_WIDGET(scrollbar));

  g_signal_connect(G_OBJECT(item), "zoom-sync-changed", G_CALLBACK(gui_waveforms_waveform_zoom_sync_cb), info);
  g_signal_connect(G_OBJECT(item), "scale-sync-changed", G_CALLBACK(gui_waveforms_waveform_scale_sync_cb), info);
  g_signal_connect(G_OBJECT(item), "scroll-sync-changed", G_CALLBACK(gui_waveforms_waveform_scroll_sync_cb), info);
  g_signal_connect(G_OBJECT(waveform), "min-zoom-changed", G_CALLBACK(gui_waveforms_waveform_min_zoom_cb), info);

  GList *list = kry_waveform_group_waveform_get_list(app.ui.waveform_group);
  char *label = kry_strdup_printf(KRY_LOC "%d", g_list_length(list) + 1);
  GtkToggleButton *button_hide = GTK_TOGGLE_BUTTON(gtk_toggle_button_new_with_label(label));
  kry_free(label);
  
  char *tooltip = kry_strdup_printf(KRY_LOC _("Show Waveform %d"), g_list_length(list) + 1);
  gtk_tooltips_set_tip(app.ui.tooltips, GTK_WIDGET(button_hide), tooltip, NULL);
  kry_free(tooltip);

  gtk_toggle_button_set_active(button_hide, TRUE);
  g_signal_connect(G_OBJECT(button_hide), "clicked", G_CALLBACK(gui_waveforms_waveform_hide_simple_cb), item);
  gtk_box_pack_start(GTK_BOX(app.ui.hbox_hide_channels), GTK_WIDGET(button_hide), FALSE, TRUE, 0);
  gtk_widget_show_all(GTK_WIDGET(app.ui.hbox_hide_channels));
  
  if(parent)
    kry_waveform_group_waveform_view_add_with_toolbar(app.ui.waveform_group, parent, item);
  else
    kry_waveform_group_waveform_add_with_toolbar(app.ui.waveform_group, item);

  gtk_spin_button_set_range(info->spin_zoom, kry_waveform_get_zoom_min(info->waveform), data_info->length_seconds);
  gtk_spin_button_set_value(info->spin_zoom, kry_waveform_get_zoom(waveform));

  if(show_sync_toggles && app.opts.show_only_first_channel)
    gtk_toggle_button_set_active(button_hide, FALSE);

  g_object_set_data(G_OBJECT(waveform), "waveform_info", info);
}

void gui_waveforms_waveform_add_empty()
{
  KryWaveform *waveform = KRY_WAVEFORM(kry_waveform_new(NULL, NULL, app.ui.waveform_color_table));
  GtkToolbar *toolbar;
  struct waveform_info *info = kry_new0(struct waveform_info);

  if(!app.ui.waveform_color_table)
  {
    app.ui.waveform_color_table = kry_waveform_get_color_table(waveform);
    app.ui.waveform_color_table->Ref();
  }

  KryWaveformGroupItem *item = KRY_WAVEFORM_GROUP_ITEM(kry_waveform_group_item_new(waveform));

  info->waveform = waveform;
  info->name = kry_strdup(_("No Audio Loaded"));
  info->item = item;

  toolbar = gui_waveforms_waveform_toolbar_create(info, FALSE, FALSE);
  //toolbar = GTK_TOOLBAR(gtk_toolbar_new());

  //kry_waveform_group_item_set_toolbar(item, GTK_WIDGET(toolbar));

  kry_waveform_group_waveform_add_with_toolbar(app.ui.waveform_group, item);
}

void gui_waveforms_waveform_clone(KryWaveformGroupItem *item)
{
  gui_waveforms_waveform_add(item->waveform->data_info, "Clone", TRUE, item);
}

void gui_waveforms_waveform_clone_cb(GtkWidget *widget, KryWaveformGroupItem *item)
{
  g_signal_handlers_block_by_func(app.ui.paned_list, (void *) gui_main_text_paned_move_cb, NULL);
  g_signal_handlers_block_by_func(app.ui.paned_notebook, (void *) gui_main_text_paned_move_cb, NULL);
  gui_waveforms_waveform_clone(item);
  while(gtk_events_pending())
    gtk_main_iteration();
  g_signal_handlers_unblock_by_func(app.ui.paned_list, (void *) gui_main_text_paned_move_cb, NULL);
  g_signal_handlers_unblock_by_func(app.ui.paned_notebook, (void *) gui_main_text_paned_move_cb, NULL);
}