/* 
 *	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 "kry_marker.h"
#include "kry_region.h"
#include "kry_waveform.h"
#include "kry_waveform_group_item.h"
#include "kry_waveform_group.h"
#include "sound.h"

extern struct sabbu app;

static void kry_waveform_group_class_init(KryWaveformGroupClass *klass);
static void kry_waveform_group_init(KryWaveformGroup *group);
static void kry_waveform_group_destroy(GtkObject *object);
static void kry_waveform_group_waveform_zoom_changed_cb(KryWaveform *waveform, double zoom, KryWaveformGroupItem *item);
static void kry_waveform_group_waveform_scale_changed_cb(KryWaveform *waveform, int scale, KryWaveformGroupItem *item);
static void kry_waveform_group_enable_simple_interface_item(KryWaveformGroup *group, KryWaveformGroupItem *item);

GType kry_waveform_group_get_type()
{
  static GType kry_waveform_group_type = 0;

  if(!kry_waveform_group_type)
  {
    static const GTypeInfo kry_waveform_group_info =
    {
      sizeof (KryWaveformGroupClass),
      NULL, /* base init */
      NULL, /* base finalize */
      (GClassInitFunc) kry_waveform_group_class_init,
      NULL, /* class finalize */
      NULL, /* class data */
      sizeof(KryWaveformGroup),
      0, /* n_preallocs */
      (GInstanceInitFunc) kry_waveform_group_init,
    };

    kry_waveform_group_type = g_type_register_static(GTK_TYPE_VBOX,
      "KryWaveformGroup",
      &kry_waveform_group_info,
      (GTypeFlags) 0);
  }

  return kry_waveform_group_type;
}

enum
{
  ZOOM_CHANGED_SIGNAL,
  SCALE_CHANGED_SIGNAL,
  LAST_SIGNAL
};

static guint kry_waveform_group_signals[LAST_SIGNAL] = { 0 };


static void kry_waveform_group_class_init(KryWaveformGroupClass *klass)
{
  GtkObjectClass *object_klass = (GtkObjectClass *) klass;
  object_klass->destroy = kry_waveform_group_destroy;
  
  kry_waveform_group_signals[ZOOM_CHANGED_SIGNAL] =
    g_signal_new ("zoom-changed",
		  G_OBJECT_CLASS_TYPE (klass),
		  (GSignalFlags) (G_SIGNAL_RUN_FIRST),
      G_STRUCT_OFFSET (KryWaveformGroupClass, zoom_changed),
		  NULL, NULL,
      g_cclosure_marshal_VOID__DOUBLE,
		  G_TYPE_NONE, 1, G_TYPE_DOUBLE);

  kry_waveform_group_signals[SCALE_CHANGED_SIGNAL] =
    g_signal_new ("scale-changed",
		  G_OBJECT_CLASS_TYPE (klass),
		  (GSignalFlags) (G_SIGNAL_RUN_FIRST),
      G_STRUCT_OFFSET (KryWaveformGroupClass, scale_changed),
		  NULL, NULL,
      g_cclosure_marshal_VOID__INT,
		  G_TYPE_NONE, 1, G_TYPE_INT);}

static void kry_waveform_group_init(KryWaveformGroup *group)
{
  group->common_adjustment = GTK_ADJUSTMENT(gtk_adjustment_new(0, 0, 0, 0, 0, 0));
  g_object_ref(group->common_adjustment);

  kry_waveform_group_reset(group);

  group->drag_selection = TRUE;
  group->marker_dragging = TRUE;
}

static void kry_waveform_group_destroy(GtkObject *object)
{
  g_return_if_fail(KRY_IS_WAVEFORM_GROUP(object));

  KryWaveformGroup *group = KRY_WAVEFORM_GROUP(object);

  g_object_unref(group->common_adjustment);

  kry_waveform_group_marker_remove_all(group);
  kry_waveform_group_region_remove_all(group);
}

void kry_waveform_group_reset(KryWaveformGroup *group)
{
  g_return_if_fail(KRY_IS_WAVEFORM_GROUP(group));

  group->common_zoom = 3.0;
  group->common_scale = 100;

  g_signal_emit(group, kry_waveform_group_signals[ZOOM_CHANGED_SIGNAL], 0, 3.0);
  g_signal_emit(group, kry_waveform_group_signals[SCALE_CHANGED_SIGNAL], 0, 100);

  gtk_adjustment_set_value(group->common_adjustment, 0);
}

GtkWidget* kry_waveform_group_new(void)
{
  return GTK_WIDGET (g_object_new (KRY_TYPE_WAVEFORM_GROUP, NULL));
}

GtkAdjustment *kry_waveform_group_get_adjustment(KryWaveformGroup *group)
{
  g_return_val_if_fail(KRY_IS_WAVEFORM_GROUP(group), NULL);

  return group->common_adjustment;
}

void kry_waveform_group_set_drag_selection(KryWaveformGroup *group, gboolean val)
{
  g_return_if_fail(KRY_IS_WAVEFORM_GROUP(group));

  group->drag_selection = val;

  for(GList *ptr = group->waveform_list; ptr; ptr = ptr->next)
  {
    KryWaveformGroupItem *item =  KRY_WAVEFORM_GROUP_ITEM(ptr->data);
    kry_waveform_set_drag_selection(kry_waveform_group_item_get_waveform(item), val);
  }
}

void kry_waveform_group_set_marker_dragging(KryWaveformGroup *group, gboolean val)
{
  g_return_if_fail(KRY_IS_WAVEFORM_GROUP(group));

  group->marker_dragging = val;

  for(GList *ptr = group->waveform_list; ptr; ptr = ptr->next)
  {
    KryWaveformGroupItem *item =  KRY_WAVEFORM_GROUP_ITEM(ptr->data);
    kry_waveform_set_marker_dragging(kry_waveform_group_item_get_waveform(item), val);
  }
}

void kry_waveform_group_waveform_remove_all(KryWaveformGroup *group)
{
  g_return_if_fail(KRY_IS_WAVEFORM_GROUP(group));

  GList *ptr_next;
  for(GList *ptr = group->waveform_list; ptr; ptr = ptr_next)
  {
    ptr_next = ptr->next;
    KryWaveformGroupItem *item =  KRY_WAVEFORM_GROUP_ITEM(ptr->data);
    kry_waveform_group_waveform_remove(group, item);
  }
}

void kry_waveform_group_disable_draw(KryWaveformGroup *group)
{
  g_return_if_fail(KRY_IS_WAVEFORM_GROUP(group));

  group->disable_draw = TRUE;

  for(GList *ptr = group->waveform_list; ptr; ptr = ptr->next)
  {
    KryWaveformGroupItem *item =  KRY_WAVEFORM_GROUP_ITEM(ptr->data);
    kry_waveform_disable_draw(kry_waveform_group_item_get_waveform(item));
  }
}

void kry_waveform_group_enable_draw(KryWaveformGroup *group)
{
  g_return_if_fail(KRY_IS_WAVEFORM_GROUP(group));

  group->disable_draw = FALSE;

  for(GList *ptr = group->waveform_list; ptr; ptr = ptr->next)
  {
    KryWaveformGroupItem *item =  KRY_WAVEFORM_GROUP_ITEM(ptr->data);
    kry_waveform_enable_draw(kry_waveform_group_item_get_waveform(item));
  }
}

void kry_waveform_group_focus_selected(KryWaveformGroup *group)
{
  g_return_if_fail(KRY_IS_WAVEFORM_GROUP(group));

  for(GList *ptr = group->waveform_list; ptr; ptr = ptr->next)
  {
    KryWaveformGroupItem *item =  KRY_WAVEFORM_GROUP_ITEM(ptr->data);
    kry_waveform_focus_selected(kry_waveform_group_item_get_waveform(item));
  }
}

void kry_waveform_group_region_add(KryWaveformGroup *group, KryRegion *region)
{
  g_return_if_fail(KRY_IS_WAVEFORM_GROUP(group));

  g_object_ref(region);

  group->region_list = g_list_append(group->region_list, region);

  for(GList *ptr = group->waveform_list; ptr; ptr = ptr->next)
  {
    KryWaveformGroupItem *item =  KRY_WAVEFORM_GROUP_ITEM(ptr->data);
    kry_waveform_region_add(kry_waveform_group_item_get_waveform(item), region);
  }
}

void kry_waveform_group_region_add_new(KryWaveformGroup *group, KryMarker *marker_left, KryMarker *marker_right, int colorid)
{
  g_return_if_fail(KRY_IS_WAVEFORM_GROUP(group));

  KryRegion *region = KRY_REGION(kry_region_new(marker_left, marker_right, colorid));
  kry_waveform_group_region_add(group, region);
  g_object_unref(G_OBJECT(region));
}

void kry_waveform_group_region_fixed_list_set(KryWaveformGroup *group, KryRegionFixedList *list)
{
  g_return_if_fail(KRY_IS_WAVEFORM_GROUP(group));

  group->region_fixed_list = list;

  for(GList *ptr = group->waveform_list; ptr; ptr = ptr->next)
  {
    KryWaveformGroupItem *item =  KRY_WAVEFORM_GROUP_ITEM(ptr->data);
    kry_waveform_region_fixed_list_set(kry_waveform_group_item_get_waveform(item), list);
  }

}

void kry_waveform_group_region_remove_by_type(KryWaveformGroup *group, int colorid)
{
  g_return_if_fail(KRY_IS_WAVEFORM_GROUP(group));

  GList *ptr_next;
  for(GList *ptr = group->region_list; ptr; ptr = ptr_next)
  {
    ptr_next = ptr->next;
    KryRegion *region = (KryRegion *) ptr->data;
    if(region->color_id == colorid)
    {
      g_object_unref(G_OBJECT(region));
      group->region_list = g_list_remove(group->region_list, region);
    }
  }

  for(GList *ptr = group->waveform_list; ptr; ptr = ptr->next)
  {
    KryWaveformGroupItem *item =  KRY_WAVEFORM_GROUP_ITEM(ptr->data);
    kry_waveform_region_remove_by_type(kry_waveform_group_item_get_waveform(item), colorid);
  }
}

void kry_waveform_group_region_remove_all(KryWaveformGroup *group)
{
  g_return_if_fail(KRY_IS_WAVEFORM_GROUP(group));

  for(GList *ptr = group->region_list; ptr; ptr = ptr->next)
    g_object_unref(G_OBJECT(ptr->data));

  g_list_free(group->region_list);
  group->region_list = NULL;

  for(GList *ptr = group->waveform_list; ptr; ptr = ptr->next)
  {
    KryWaveformGroupItem *item =  KRY_WAVEFORM_GROUP_ITEM(ptr->data);
    kry_waveform_region_remove_all(kry_waveform_group_item_get_waveform(item));
  }
}

void kry_waveform_group_marker_add(KryWaveformGroup *group, KryMarker *marker)
{
  g_return_if_fail(KRY_IS_WAVEFORM_GROUP(group));

  g_object_ref(marker);

  group->marker_list = g_list_append(group->marker_list, marker);

  for(GList *ptr = group->waveform_list; ptr; ptr = ptr->next)
  {
    KryWaveformGroupItem *item =  KRY_WAVEFORM_GROUP_ITEM(ptr->data);
    kry_waveform_marker_add(kry_waveform_group_item_get_waveform(item), marker);
  }
}

void kry_waveform_group_marker_show(KryWaveformGroup *group, KryMarker *marker)
{
  g_return_if_fail(KRY_IS_WAVEFORM_GROUP(group));

  for(GList *ptr = group->waveform_list; ptr; ptr = ptr->next)
  {
    KryWaveformGroupItem *item =  KRY_WAVEFORM_GROUP_ITEM(ptr->data);
    kry_waveform_marker_show(kry_waveform_group_item_get_waveform(item), marker);
  }
}

void kry_waveform_group_marker_hide(KryWaveformGroup *group, KryMarker *marker)
{
  g_return_if_fail(KRY_IS_WAVEFORM_GROUP(group));

  for(GList *ptr = group->waveform_list; ptr; ptr = ptr->next)
  {
    KryWaveformGroupItem *item =  KRY_WAVEFORM_GROUP_ITEM(ptr->data);
    kry_waveform_marker_hide(kry_waveform_group_item_get_waveform(item), marker);
  }
}

void kry_waveform_group_marker_set_active_start(KryWaveformGroup *group, KryMarker *marker)
{
  g_return_if_fail(KRY_IS_WAVEFORM_GROUP(group));

  group->marker_active_start = marker;

  for(GList *ptr = group->waveform_list; ptr; ptr = ptr->next)
  {
    KryWaveformGroupItem *item =  KRY_WAVEFORM_GROUP_ITEM(ptr->data);
    kry_waveform_marker_set_active_start(kry_waveform_group_item_get_waveform(item), marker);
  }
}

void kry_waveform_group_marker_set_active_end(KryWaveformGroup *group, KryMarker *marker)
{
  g_return_if_fail(KRY_IS_WAVEFORM_GROUP(group));

  group->marker_active_end = marker;

  for(GList *ptr = group->waveform_list; ptr; ptr = ptr->next)
  {
    KryWaveformGroupItem *item =  KRY_WAVEFORM_GROUP_ITEM(ptr->data);
    kry_waveform_marker_set_active_end(kry_waveform_group_item_get_waveform(item), marker);
  }
}

void kry_waveform_group_marker_set_autoscroll(KryWaveformGroup *group, KryMarker *marker)
{
  g_return_if_fail(KRY_IS_WAVEFORM_GROUP(group));

  group->marker_autoscroll = marker;

  for(GList *ptr = group->waveform_list; ptr; ptr = ptr->next)
  {
    KryWaveformGroupItem *item =  KRY_WAVEFORM_GROUP_ITEM(ptr->data);
    kry_waveform_marker_set_autoscroll(kry_waveform_group_item_get_waveform(item), marker);
  }
}

void kry_waveform_group_marker_remove_all(KryWaveformGroup *group)
{
  g_return_if_fail(KRY_IS_WAVEFORM_GROUP(group));

  for(GList *ptr = group->marker_list; ptr; ptr = ptr->next)
    g_object_unref(G_OBJECT(ptr->data));

  g_list_free(group->marker_list);
  group->marker_list = NULL;

  for(GList *ptr = group->waveform_list; ptr; ptr = ptr->next)
  {
    KryWaveformGroupItem *item =  KRY_WAVEFORM_GROUP_ITEM(ptr->data);
    kry_waveform_marker_remove_all(kry_waveform_group_item_get_waveform(item));
  }
}

void kry_waveform_group_marker_remove(KryWaveformGroup *group, KryMarker *marker_match)
{
  g_return_if_fail(KRY_IS_WAVEFORM_GROUP(group));

  GList *next;
  for(GList *marker_ptr = group->marker_list; marker_ptr; marker_ptr = next)
  {
    next = marker_ptr->next;

    KryMarker *marker = KRY_MARKER(marker_ptr->data);
    if(marker == marker_match)
    {
      for(GList *ptr = group->waveform_list; ptr; ptr = ptr->next)
      {
        KryWaveformGroupItem *item =  KRY_WAVEFORM_GROUP_ITEM(ptr->data);
        kry_waveform_marker_remove(kry_waveform_group_item_get_waveform(item), marker_match);
      }
      group->marker_list = g_list_remove(group->marker_list, marker);
      g_object_unref(marker);
    }
  }
}

KryWaveformKeyframeList *kry_waveform_group_get_keyframe_list(KryWaveformGroup *group)
{
  g_return_val_if_fail(KRY_IS_WAVEFORM_GROUP(group), NULL);

  return group->keyframe_list;
}

void kry_waveform_group_set_keyframe_list(KryWaveformGroup *group, KryWaveformKeyframeList *list)
{
  g_return_if_fail(KRY_IS_WAVEFORM_GROUP(group));

  group->keyframe_list = list;

  for(GList *ptr = group->waveform_list; ptr; ptr = ptr->next)
  {
    KryWaveformGroupItem *item =  KRY_WAVEFORM_GROUP_ITEM(ptr->data);
    kry_waveform_set_keyframe_list(kry_waveform_group_item_get_waveform(item), list);
  }
}

void kry_waveform_group_waveform_remove(KryWaveformGroup *group, KryWaveformGroupItem *item)
{
  group->waveform_list = g_list_remove(group->waveform_list, item);

  if(item->toolbar)
    gtk_container_remove(GTK_CONTAINER(group), item->toolbar);

  if(item->scrollbar)
    gtk_container_remove(GTK_CONTAINER(group), item->scrollbar);

  gtk_container_remove(GTK_CONTAINER(group), GTK_WIDGET(kry_waveform_group_item_get_waveform(item)));

  kry_free(item);
}

static KryWaveformGroupItem *kry_waveform_group_waveform_add_internal(KryWaveformGroup *group, KryWaveformGroupItem *parent_item, KryWaveformGroupItem *item)
{
  g_return_val_if_fail(KRY_IS_WAVEFORM_GROUP(group), NULL);

  KryWaveform *waveform = kry_waveform_group_item_get_waveform(item);

  kry_waveform_group_item_set_group(item, GTK_WIDGET(group));

  if(group->disable_draw)
    kry_waveform_disable_draw(waveform);

  if(parent_item)
  {
    if(parent_item->parent_item)
      item->parent_item = parent_item->parent_item;
    else
      item->parent_item = parent_item;
  }

  if(parent_item && !parent_item->zoom_sync)
  {
    item->zoom = parent_item->zoom;
    kry_waveform_group_item_set_zoom_sync(item, FALSE);
    kry_waveform_set_zoom(waveform, parent_item->zoom);
  }
  else
  {
    item->zoom = group->common_zoom;
    kry_waveform_set_zoom(waveform, group->common_zoom);
  }

  if(parent_item && !parent_item->scale_sync)
  {
    item->scale = parent_item->scale;
    kry_waveform_group_item_set_scale_sync(item, FALSE);
    kry_waveform_set_scale(waveform, parent_item->scale);
  }
  else
  {
    item->scale = group->common_scale;
    kry_waveform_set_scale(waveform, group->common_scale);
  }

  if(parent_item && !parent_item->scroll_sync)
    kry_waveform_group_item_set_scroll_sync(item, FALSE);

  for(GList *ptr = group->marker_list; ptr; ptr = ptr->next)
    kry_waveform_marker_add(waveform, (KryMarker *) ptr->data);

  for(GList *ptr = group->region_list; ptr; ptr = ptr->next)
    kry_waveform_region_add(waveform, (KryRegion *) ptr->data);

  if(group->keyframe_list)
    kry_waveform_set_keyframe_list(waveform, group->keyframe_list);

  if(group->marker_active_start)
    kry_waveform_marker_set_active_start(waveform, group->marker_active_start);

  if(group->marker_active_end)
    kry_waveform_marker_set_active_end(waveform, group->marker_active_end);

  if(group->marker_autoscroll)
    kry_waveform_marker_set_autoscroll(waveform, group->marker_autoscroll);

  if(group->region_fixed_list)
    kry_waveform_region_fixed_list_set(waveform, group->region_fixed_list);

  kry_waveform_set_drag_selection(waveform, group->drag_selection);
  kry_waveform_set_marker_dragging(waveform, group->marker_dragging);

  group->waveform_list = g_list_append(group->waveform_list, item);

  if(GtkWidget *toolbar = kry_waveform_group_item_get_toolbar(item))
  {
    gtk_box_pack_start(GTK_BOX(group), toolbar, FALSE, TRUE, 0);
    if(group->simple_interface && g_list_length(group->waveform_list) > 1)
      gtk_widget_hide(toolbar);
    else
      gtk_widget_show(toolbar);
  }

  gtk_box_pack_start(GTK_BOX(group), GTK_WIDGET(waveform), TRUE, TRUE, 0);
  gtk_widget_show(GTK_WIDGET(waveform));

  if(GtkWidget *scrollbar = kry_waveform_group_item_get_scrollbar(item))
  {
    gtk_box_pack_start(GTK_BOX(group), GTK_WIDGET(scrollbar), FALSE, TRUE, 0);
    if(group->simple_interface)
    {
      kry_waveform_group_enable_simple_interface_item(group, item);
      gtk_widget_hide(scrollbar);
    }
    else
    {
      gtk_widget_show(scrollbar);
      gtk_widget_hide(group->scrollbar);
    }
  }

  if(group->simple_interface)
  {
    if(group->toolbar)
      gtk_widget_show(group->toolbar);

    if(group->scrollbar)
      gtk_widget_show(group->scrollbar);

    if(item != group->waveform_list->data)
    {
      kry_waveform_set_show_time_bar(waveform, FALSE);
      kry_waveform_set_show_time_markers(waveform, TRUE);
    }
  }

  g_signal_connect(G_OBJECT(waveform), "zoom-changed", G_CALLBACK(kry_waveform_group_waveform_zoom_changed_cb), item);
  g_signal_connect(G_OBJECT(waveform), "scale-changed", G_CALLBACK(kry_waveform_group_waveform_scale_changed_cb), item);

  return item;
}

KryWaveformGroupItem *
  kry_waveform_group_waveform_add(KryWaveformGroup *group, 
                                  KryWaveformGroupItem *item)
{
  return kry_waveform_group_waveform_add_internal(group, NULL, item);
}

KryWaveformGroupItem *
  kry_waveform_group_waveform_add_with_toolbar(KryWaveformGroup *group, 
                                               KryWaveformGroupItem *item)
{
  return kry_waveform_group_waveform_add_internal(group, NULL, item);
}

KryWaveformGroupItem *
  kry_waveform_group_waveform_view_add(KryWaveformGroup *group, KryWaveformGroupItem *parent, 
                                       KryWaveformGroupItem *item)
{
  return kry_waveform_group_waveform_add_internal(group, parent, item);
}

KryWaveformGroupItem *
  kry_waveform_group_waveform_view_add_with_toolbar(KryWaveformGroup *group, KryWaveformGroupItem *parent, 
                                                    KryWaveformGroupItem *item)
{
  return kry_waveform_group_waveform_add_internal(group, parent, item);
}

static void kry_waveform_group_set_zoom_internal(KryWaveformGroup *group, KryWaveformGroupItem *item, double zoom)
{
  if(!item || item->zoom_sync)
  {
    if(group->common_zoom == zoom)
      return;

    group->common_zoom = zoom;

    for(GList *ptr = group->waveform_list; ptr; ptr = ptr->next)
    {
      KryWaveformGroupItem *item_cur =  KRY_WAVEFORM_GROUP_ITEM(ptr->data);
      if(item_cur != item && item_cur->zoom_sync)
        kry_waveform_set_zoom(kry_waveform_group_item_get_waveform(item_cur), zoom);
    }

    g_signal_emit(group, kry_waveform_group_signals[ZOOM_CHANGED_SIGNAL], 0, zoom);
  }
  else
  {
    kry_waveform_set_zoom(kry_waveform_group_item_get_waveform(item), zoom);
  }
}

static void kry_waveform_group_waveform_zoom_changed_cb(KryWaveform *waveform, double zoom, KryWaveformGroupItem *item)
{
  if(!item->zoom_sync)
    return;

  kry_waveform_group_set_zoom_internal(KRY_WAVEFORM_GROUP(item->group), item, zoom);
}

void kry_waveform_group_set_zoom(KryWaveformGroup *group, double zoom)
{
  kry_waveform_group_set_zoom_internal(group, NULL, zoom);
}

static void kry_waveform_group_set_scale_internal(KryWaveformGroup *group, KryWaveformGroupItem *item, int scale)
{
  if(!item || item->scale_sync)
  {
    if(group->common_scale == scale)
      return;

    group->common_scale = scale;

    for(GList *ptr = group->waveform_list; ptr; ptr = ptr->next)
    {
      KryWaveformGroupItem *item_cur =  KRY_WAVEFORM_GROUP_ITEM(ptr->data);
      if(item_cur != item && item_cur->scale_sync)
        kry_waveform_set_scale(kry_waveform_group_item_get_waveform(item_cur), scale);
    }

    g_signal_emit(group, kry_waveform_group_signals[SCALE_CHANGED_SIGNAL], 0, scale);
  }
  else
  {
    kry_waveform_set_scale(kry_waveform_group_item_get_waveform(item), scale);
  }
}

static void kry_waveform_group_waveform_scale_changed_cb(KryWaveform *waveform, int scale, KryWaveformGroupItem *item)
{
  if(!item->scale_sync)
    return;

  kry_waveform_group_set_scale_internal(KRY_WAVEFORM_GROUP(item->group), item, scale);
}

void kry_waveform_group_set_scale(KryWaveformGroup *group, int scale)
{
  kry_waveform_group_set_scale_internal(group, NULL, scale);
}

GList *kry_waveform_group_waveform_get_list(KryWaveformGroup *group)
{
  g_return_val_if_fail(KRY_IS_WAVEFORM_GROUP(group), NULL);

  return group->waveform_list;
}

void kry_waveform_group_enable_simple_interface_item(KryWaveformGroup *group, KryWaveformGroupItem *item)
{
  kry_waveform_group_item_set_scroll_sync(item, TRUE);
  kry_waveform_group_item_set_zoom_sync(item, TRUE);
  kry_waveform_group_item_set_scale_sync(item, TRUE);

  GtkWidget *toolbar = kry_waveform_group_item_get_toolbar(item);
  if(toolbar)
    gtk_widget_hide(toolbar);

  if(item != group->waveform_list->data)
  {
    kry_waveform_set_show_time_bar(kry_waveform_group_item_get_waveform(item), FALSE);
    kry_waveform_set_show_scrub_bar(kry_waveform_group_item_get_waveform(item), FALSE);
  }

  GtkWidget *scrollbar = kry_waveform_group_item_get_scrollbar(item);
  if(scrollbar)
    gtk_widget_hide(scrollbar);
}

void kry_waveform_group_enable_simple_interface(KryWaveformGroup *group)
{
  g_return_if_fail(KRY_IS_WAVEFORM_GROUP(group));

  group->simple_interface = TRUE;

  for(GList *ptr = group->waveform_list; ptr; ptr = ptr->next)
    kry_waveform_group_enable_simple_interface_item(group, KRY_WAVEFORM_GROUP_ITEM(ptr->data));

  if(group->toolbar)
    gtk_widget_show(group->toolbar);

  if(group->scrollbar)
    gtk_widget_show(group->scrollbar);
}

void kry_waveform_group_disable_simple_interface(KryWaveformGroup *group)
{
  g_return_if_fail(KRY_IS_WAVEFORM_GROUP(group));

  group->simple_interface = FALSE;

  for(GList *ptr = group->waveform_list; ptr; ptr = ptr->next)
  {
    KryWaveformGroupItem *item = KRY_WAVEFORM_GROUP_ITEM(ptr->data);

    GtkWidget *toolbar = kry_waveform_group_item_get_toolbar(item);
    if(toolbar)
      gtk_widget_show(toolbar);

    kry_waveform_set_show_time_bar(kry_waveform_group_item_get_waveform(item), TRUE);
    kry_waveform_set_show_scrub_bar(kry_waveform_group_item_get_waveform(item), TRUE);

    GtkWidget *scrollbar = kry_waveform_group_item_get_scrollbar(item);
    if(scrollbar)
      gtk_widget_show(scrollbar);
  }

  if(group->toolbar)
    gtk_widget_hide(group->toolbar);

  if(group->scrollbar)
    gtk_widget_hide(group->scrollbar);
}

void kry_waveform_group_set_toolbar(KryWaveformGroup *group, GtkWidget *toolbar)
{
  g_return_if_fail(KRY_IS_WAVEFORM_GROUP(group));

  if(group->toolbar)
    gtk_container_remove(GTK_CONTAINER(group), group->toolbar);

  group->toolbar = toolbar;

  if(group->simple_interface)
    gtk_widget_show(toolbar);
  else
    gtk_widget_hide(toolbar);

  gtk_box_pack_start(GTK_BOX(group), toolbar, FALSE, TRUE, 0);
  gtk_box_reorder_child(GTK_BOX(group), toolbar, 0);
}

void kry_waveform_group_set_scrollbar(KryWaveformGroup *group, GtkWidget *scrollbar)
{
  g_return_if_fail(KRY_IS_WAVEFORM_GROUP(group));

  if(group->scrollbar)
    gtk_container_remove(GTK_CONTAINER(group), group->scrollbar);

  group->scrollbar = scrollbar;

  if(group->simple_interface)
    gtk_widget_show(scrollbar);
  else
    gtk_widget_hide(scrollbar);

  gtk_box_pack_end(GTK_BOX(group), scrollbar, FALSE, TRUE, 0);
}

GtkWidget *kry_waveform_group_get_scrollbar(KryWaveformGroup *group)
{
  g_return_val_if_fail(KRY_IS_WAVEFORM_GROUP(group), NULL);

  return group->scrollbar;
}

GtkWidget *kry_waveform_group_get_toolbar(KryWaveformGroup *group)
{
  g_return_val_if_fail(KRY_IS_WAVEFORM_GROUP(group), NULL);

  return group->toolbar;
}

void kry_waveform_group_set_show_time_bar(KryWaveformGroup *group, gboolean val)
{
  g_return_if_fail(KRY_IS_WAVEFORM_GROUP(group));

  for(GList *ptr = group->waveform_list; ptr; ptr = ptr->next)
  {
    KryWaveformGroupItem *item = (KryWaveformGroupItem *) ptr->data;
    KryWaveform *waveform = kry_waveform_group_item_get_waveform(item);
    kry_waveform_set_show_time_bar(waveform, val);

    if(group->simple_interface)
      break;
  }
}

void kry_waveform_group_set_show_time_markers(KryWaveformGroup *group, gboolean val)
{
  g_return_if_fail(KRY_IS_WAVEFORM_GROUP(group));

  for(GList *ptr = group->waveform_list; ptr; ptr = ptr->next)
  {
    KryWaveformGroupItem *item = (KryWaveformGroupItem *) ptr->data;
    KryWaveform *waveform = kry_waveform_group_item_get_waveform(item);
    kry_waveform_set_show_time_markers(waveform, val);
  }
}

void kry_waveform_group_set_show_keyframes(KryWaveformGroup *group, gboolean val)
{
  g_return_if_fail(KRY_IS_WAVEFORM_GROUP(group));

  for(GList *ptr = group->waveform_list; ptr; ptr = ptr->next)
  {
    KryWaveformGroupItem *item = (KryWaveformGroupItem *) ptr->data;
    KryWaveform *waveform = kry_waveform_group_item_get_waveform(item);
    kry_waveform_set_show_keyframes(waveform, val);
  }
}