[lttv.git] / ltt / branches / poly / lttv / modules / gui / mainWin / src / gtkcustom.c

#include <gtk/gtk.h>

#include <lttv/gtkcustom.h>
//#include "gtkintl.h"
#include <lttv/mainWindow.h>
#include <lttv/gtkTraceSet.h>

static void gtk_custom_class_init (GtkCustomClass    *klass);
static void gtk_custom_init       (GtkCustom         *custom);


static void     gtk_custom_size_request   (GtkWidget      *widget,
					   GtkRequisition *requisition);
static void     gtk_custom_size_allocate  (GtkWidget      *widget,
					   GtkAllocation  *allocation);

void gtk_custom_scroll_value_changed (GtkRange *range, gpointer custom);

GType
gtk_custom_get_type (void)
{
  static GType custom_type = 0;

  if (!custom_type)
    {
      static const GTypeInfo custom_info =
      {
	sizeof (GtkCustomClass),
	NULL,		/* base_init */
	NULL,		/* base_finalize */
	(GClassInitFunc) gtk_custom_class_init,
	NULL,		/* class_finalize */
	NULL,		/* class_data */
	sizeof (GtkCustom),
	0,		/* n_preallocs */
	(GInstanceInitFunc) gtk_custom_init,
	NULL,		/* value_table */
      };

      custom_type = g_type_register_static (GTK_TYPE_PANED, "GtkCustom", 
					 &custom_info, 0);
    }

  return custom_type;
}

static void
gtk_custom_class_init (GtkCustomClass *class)
{
  GtkWidgetClass *widget_class;
  
  widget_class = (GtkWidgetClass *) class;

  widget_class->size_request = gtk_custom_size_request;
  widget_class->size_allocate = gtk_custom_size_allocate;
}

static void
gtk_custom_init (GtkCustom *custom)
{
  GtkWidget * button;

  GTK_WIDGET_SET_FLAGS (custom, GTK_NO_WINDOW);
  gtk_widget_set_redraw_on_allocate (GTK_WIDGET (custom), FALSE);
  
  custom->first_pane    = NULL;
  custom->last_pane     = NULL;
  custom->focused_pane  = NULL;
  custom->num_children  = 0;

  custom->vbox         = NULL;
  //  custom->scrollWindow = NULL;
  //  custom->viewport     = NULL;
  custom->hscrollbar   = NULL;
}


GtkWidget* gtk_custom_new ()
{
  return GTK_WIDGET (g_object_new (gtk_custom_get_type (), NULL));
}


void gtk_custom_set_focus (GtkWidget * widget, gpointer user_data)
{
  GtkCustom * custom = (GtkCustom*) widget;
  GtkPaned * pane;
  if(!custom->first_pane) return;
  

  pane = custom->first_pane;
  while(1){
    if((GtkWidget*)pane == (GtkWidget*)user_data){
      custom->focused_pane = pane;
      break;
    }
    if(pane == custom->last_pane){
      custom->focused_pane = NULL;
      break;
    }
    pane = (GtkPaned*)pane->child1;
  }
}

void gtk_custom_set_adjust(GtkCustom * custom, gboolean first_time)
{
  TimeWindow time_window;
  TimeInterval *time_span;
  double tmp, start;
  double range = 0;

  get_time_window(custom->mw,&time_window);
  if(first_time){
    time_span = LTTV_TRACESET_CONTEXT(custom->mw->traceset_info->traceset_context)->Time_Span ;
  
    custom->hadjust->lower = ltt_time_to_double(time_span->startTime) * 
                             NANOSECONDS_PER_SECOND;
    custom->hadjust->value = custom->hadjust->lower;
    custom->hadjust->upper = ltt_time_to_double(time_span->endTime) *
                             NANOSECONDS_PER_SECOND;
  }

  /* Page increment of whole visible area */
  if(custom->hadjust == NULL){
    g_warning("Insert a viewer first");
    return;
  }

  start = ltt_time_to_double(time_window.start_time) * NANOSECONDS_PER_SECOND;
  tmp = custom->hadjust->upper - custom->hadjust->lower;

  custom->hadjust->page_increment = ltt_time_to_double(
		        time_window.time_width) * NANOSECONDS_PER_SECOND;

  if(custom->hadjust->page_increment >= tmp - range)
    custom->hadjust->value = custom->hadjust->lower;
  if(start + custom->hadjust->page_increment >= custom->hadjust->upper - range)
    custom->hadjust->value = start;

  /* page_size to the whole visible area will take care that the
     * scroll value + the shown area will never be more than what is
     * in the trace. */
  custom->hadjust->page_size = custom->hadjust->page_increment;
  custom->hadjust->step_increment = custom->hadjust->page_increment / 10;

  gtk_adjustment_changed (custom->hadjust);
}

void gtk_custom_widget_add(GtkCustom * custom, GtkWidget * widget1)
{
  GtkPaned * tmpPane; 
  GtkWidget * w;
  
  g_return_if_fail(GTK_IS_CUSTOM(custom));
  g_object_ref(G_OBJECT(widget1));
 

  if(!custom->first_pane){
    custom->first_pane = (GtkPaned *)gtk_vpaned_new();
    custom->last_pane = custom->first_pane;

    custom->hscrollbar = gtk_hscrollbar_new (NULL);
    gtk_widget_show(custom->hscrollbar);

    custom->hadjust = gtk_range_get_adjustment(GTK_RANGE(custom->hscrollbar));
    gtk_custom_set_adjust(custom, TRUE);

    gtk_range_set_update_policy (GTK_RANGE(custom->hscrollbar),
                                  GTK_UPDATE_DISCONTINUOUS);
    g_signal_connect(G_OBJECT(custom->hscrollbar), "value-changed",
		     G_CALLBACK(gtk_custom_scroll_value_changed), custom);

    custom->vbox = gtk_vbox_new(FALSE,0);
    gtk_widget_show(custom->vbox);
    
    //    custom->viewport = gtk_viewport_new (NULL,NULL);
    //    gtk_widget_show(custom->viewport);
    
    //    gtk_container_add(GTK_CONTAINER(custom->viewport), (GtkWidget*)custom->vbox);
    gtk_box_pack_end(GTK_BOX(custom->vbox),(GtkWidget*)custom->hscrollbar,FALSE,FALSE,0);
    gtk_box_pack_end(GTK_BOX(custom->vbox),(GtkWidget*)custom->first_pane,TRUE,TRUE,0);
    
    //    custom->scrollWindow = gtk_scrolled_window_new (NULL, NULL);
    //    gtk_widget_show(custom->scrollWindow);
    //    gtk_container_add (GTK_CONTAINER (custom->scrollWindow), (GtkWidget*)custom->viewport);    
    //    gtk_paned_pack1(GTK_PANED(custom), (GtkWidget*)custom->scrollWindow,FALSE, TRUE);

    gtk_paned_pack1(GTK_PANED(custom), (GtkWidget*)custom->vbox,FALSE, TRUE);
  }else{
    tmpPane = custom->last_pane;
    custom->last_pane = (GtkPaned *)gtk_vpaned_new();
    gtk_paned_pack1 (tmpPane,(GtkWidget*)custom->last_pane, FALSE,TRUE);
  }
  gtk_widget_show((GtkWidget *)custom->last_pane);  

  gtk_paned_pack2 (custom->last_pane,widget1, TRUE, TRUE);      
  custom->focused_pane = custom->last_pane;
  custom->num_children++;
  
}

void gtk_custom_widget_delete(GtkCustom * custom)
{
  GtkPaned * tmp, *prev, *next;

  if(!custom->focused_pane) return;
 
  tmp = (GtkPaned*)custom->focused_pane->child2; //widget in vpaned
  g_object_unref(G_OBJECT(tmp));

  if(custom->focused_pane == custom->first_pane &&
     custom->focused_pane == custom->last_pane){
    //    gtk_container_remove(GTK_CONTAINER(custom),(GtkWidget*)custom->scrollWindow);
    gtk_container_remove(GTK_CONTAINER(custom),(GtkWidget*)custom->vbox);
    custom->first_pane = NULL;
    custom->last_pane = NULL;
    custom->focused_pane = NULL;
  }else if(custom->focused_pane == custom->first_pane &&
	   custom->focused_pane != custom->last_pane){
    next = (GtkPaned*)custom->first_pane->child1;
    g_object_ref(G_OBJECT(next));
    gtk_container_remove(GTK_CONTAINER(custom->first_pane),(GtkWidget*)next);
    gtk_container_remove(GTK_CONTAINER(custom->vbox),(GtkWidget*)custom->first_pane);
    custom->first_pane = next;
    gtk_box_pack_end(GTK_BOX(custom->vbox),(GtkWidget*)custom->first_pane,TRUE,TRUE,0);
    custom->focused_pane = custom->first_pane;
    g_object_unref(G_OBJECT(next));
  }else if(custom->focused_pane != custom->first_pane &&
	   custom->focused_pane == custom->last_pane){
    tmp = custom->last_pane;
    custom->last_pane = (GtkPaned*)gtk_widget_get_parent((GtkWidget*)custom->last_pane);
    custom->focused_pane = custom->last_pane;
    gtk_container_remove(GTK_CONTAINER(custom->last_pane),(GtkWidget*)tmp);
  }else{
    tmp = custom->focused_pane;
    prev = (GtkPaned*)gtk_widget_get_parent((GtkWidget*)tmp);
    next = (GtkPaned*)tmp->child1;
    g_object_ref(G_OBJECT(next));
    gtk_container_remove(GTK_CONTAINER(custom->focused_pane),(GtkWidget*)next);
    gtk_container_remove(GTK_CONTAINER(prev),(GtkWidget*)custom->focused_pane);
    gtk_paned_pack1(prev, (GtkWidget*)next, FALSE, TRUE);
    custom->focused_pane = next;
    g_object_unref(G_OBJECT(next));
  }

  custom->num_children--;
}


void gtk_custom_widget_move_up(GtkCustom * custom)
{
  GtkWidget* upWidget, *downWidget;
  GtkPaned * prev,*next, *prevPrev;

  if(custom->last_pane == custom->focused_pane) return;

  // move VPane
  prev = (GtkPaned*)custom->focused_pane->child1;
  g_object_ref(G_OBJECT(prev));
  gtk_container_remove(GTK_CONTAINER(custom->focused_pane),(GtkWidget*)prev);

  if(prev == custom->last_pane){
    prevPrev = NULL;
    custom->last_pane = custom->focused_pane;
  }else{    
    prevPrev = (GtkPaned*)prev->child1;
    g_object_ref(G_OBJECT(prevPrev));
    gtk_container_remove(GTK_CONTAINER(prev),(GtkWidget*)prevPrev);   
  }

  g_object_ref(G_OBJECT(custom->focused_pane));
  if(custom->first_pane == custom->focused_pane){
    gtk_container_remove(GTK_CONTAINER(custom->vbox),(GtkWidget*)custom->focused_pane);
    gtk_box_pack_end(GTK_BOX(custom->vbox),(GtkWidget*)prev,TRUE,TRUE,0);
    custom->first_pane = prev;
  }else{
    next = (GtkPaned*)gtk_widget_get_parent((GtkWidget*)custom->focused_pane);
    gtk_container_remove(GTK_CONTAINER(next),(GtkWidget*)custom->focused_pane);
    gtk_paned_pack1(GTK_PANED(next), (GtkWidget*)prev, FALSE,TRUE);
  }
  gtk_paned_pack1(GTK_PANED(prev),(GtkWidget*)custom->focused_pane, FALSE,TRUE);
  if(prevPrev)
    gtk_paned_pack1(GTK_PANED(custom->focused_pane),(GtkWidget*)prevPrev, FALSE,TRUE);

  g_object_unref(G_OBJECT(prev));
  if(prevPrev) g_object_unref(G_OBJECT(prevPrev));
  g_object_unref(G_OBJECT(custom->focused_pane));
}


void gtk_custom_widget_move_down(GtkCustom * custom)
{
  GtkWidget* upWidget, *downWidget;
  GtkPaned * prev,*next, *nextNext;

  if(custom->first_pane == custom->focused_pane) return;

  //move VPane
  next = (GtkPaned*)gtk_widget_get_parent((GtkWidget*)custom->focused_pane);
  g_object_ref(G_OBJECT(next));

  if(custom->last_pane == custom->focused_pane){
    prev = NULL;
    custom->last_pane = next;
  }else{
    prev = (GtkPaned*)custom->focused_pane->child1;
    g_object_ref(G_OBJECT(prev));
    gtk_container_remove(GTK_CONTAINER(custom->focused_pane),(GtkWidget*)prev);    
  }

  g_object_ref(G_OBJECT(custom->focused_pane));
  gtk_container_remove(GTK_CONTAINER(next),(GtkWidget*)custom->focused_pane);
  
  if(next == custom->first_pane){
    custom->first_pane = custom->focused_pane;
    gtk_container_remove(GTK_CONTAINER(custom->vbox),(GtkWidget*)next);       
    gtk_box_pack_end(GTK_BOX(custom->vbox),(GtkWidget*)custom->focused_pane,TRUE,TRUE,0);
  }else{    
    nextNext = (GtkPaned*)gtk_widget_get_parent((GtkWidget*)next);
    gtk_container_remove(GTK_CONTAINER(nextNext),(GtkWidget*)next);       
    gtk_paned_pack1(nextNext, (GtkWidget*)custom->focused_pane, FALSE, TRUE);
  }
  gtk_paned_pack1(custom->focused_pane,(GtkWidget*)next, FALSE,TRUE);
  if(prev)
    gtk_paned_pack1(next,(GtkWidget*)prev, FALSE,TRUE);

  if(prev)g_object_unref(G_OBJECT(prev));
  g_object_unref(G_OBJECT(next));
  g_object_unref(G_OBJECT(custom->focused_pane));
}

void gtk_custom_scroll_value_changed(GtkRange *range, gpointer custom_arg)
{
  LttTime time;
  GtkCustom * custom = (GtkCustom*)custom_arg;
  gdouble value = gtk_range_get_value(range);
  time = ltt_time_from_double(value / NANOSECONDS_PER_SECOND);
  set_current_time(custom->mw, &time);
  g_warning("The current time is second :%d, nanosecond : %d\n", time.tv_sec, time.tv_nsec);
}


static void
gtk_custom_size_request (GtkWidget      *widget,
			 GtkRequisition *requisition)
{
  GtkPaned *paned = GTK_PANED (widget);
  GtkRequisition child_requisition;

  requisition->width = 0;
  requisition->height = 0;

  if (paned->child1 && GTK_WIDGET_VISIBLE (paned->child1))
    {
      gtk_widget_size_request (paned->child1, &child_requisition);

      requisition->height = child_requisition.height;
      requisition->width = child_requisition.width;
    }

  if (paned->child2 && GTK_WIDGET_VISIBLE (paned->child2))
    {
      gtk_widget_size_request (paned->child2, &child_requisition);

      requisition->width = MAX (requisition->width, child_requisition.width);
      requisition->height += child_requisition.height;
    }

  requisition->height += GTK_CONTAINER (paned)->border_width * 2;
  requisition->width += GTK_CONTAINER (paned)->border_width * 2;
  
  if (paned->child1 && GTK_WIDGET_VISIBLE (paned->child1) &&
      paned->child2 && GTK_WIDGET_VISIBLE (paned->child2))
    {
      gint handle_size;

      gtk_widget_style_get (widget, "handle_size", &handle_size, NULL);
      requisition->height += handle_size;
    }

}

static void
gtk_custom_size_allocate (GtkWidget     *widget,
			  GtkAllocation *allocation)
{
  GtkPaned *paned = GTK_PANED (widget);
  gint border_width = GTK_CONTAINER (paned)->border_width;

  widget->allocation = *allocation;

  if (paned->child1 && GTK_WIDGET_VISIBLE (paned->child1) &&
      paned->child2 && GTK_WIDGET_VISIBLE (paned->child2))
    {
      GtkRequisition child1_requisition;
      GtkRequisition child2_requisition;
      GtkAllocation child1_allocation;
      GtkAllocation child2_allocation;
      gint handle_size;
      
      gtk_widget_style_get (widget, "handle_size", &handle_size, NULL);

      gtk_widget_get_child_requisition (paned->child1, &child1_requisition);
      gtk_widget_get_child_requisition (paned->child2, &child2_requisition);
    
      gtk_paned_compute_position (paned,
				  MAX (1, widget->allocation.height
				       - handle_size
				       - 2 * border_width),
				  child1_requisition.height,
				  child2_requisition.height);

      paned->handle_pos.x = widget->allocation.x + border_width;
      paned->handle_pos.y = widget->allocation.y + paned->child1_size + border_width;
      paned->handle_pos.width = MAX (1, (gint) widget->allocation.width - 2 * border_width);
      paned->handle_pos.height = handle_size;
      
      if (GTK_WIDGET_REALIZED (widget))
	{
	  if (GTK_WIDGET_MAPPED (widget))
	    gdk_window_show (paned->handle);
	  gdk_window_move_resize (paned->handle,
				  paned->handle_pos.x,
				  paned->handle_pos.y,
				  paned->handle_pos.width,
				  handle_size);
	}

      child1_allocation.width = child2_allocation.width = MAX (1, (gint) allocation->width - border_width * 2);
      child1_allocation.height = MAX (1, paned->child1_size);
      child1_allocation.x = child2_allocation.x = widget->allocation.x + border_width;
      child1_allocation.y = widget->allocation.y + border_width;
      
      child2_allocation.y = child1_allocation.y + paned->child1_size + paned->handle_pos.height;
      child2_allocation.height = MAX (1, widget->allocation.y + widget->allocation.height - child2_allocation.y - border_width);
      
      if (GTK_WIDGET_MAPPED (widget) &&
	  paned->child1->allocation.height < child1_allocation.height)
	{
	  gtk_widget_size_allocate (paned->child2, &child2_allocation);
	  gtk_widget_size_allocate (paned->child1, &child1_allocation);
	}
      else
	{
	  gtk_widget_size_allocate (paned->child1, &child1_allocation);
	  gtk_widget_size_allocate (paned->child2, &child2_allocation);
	}
    }
  else
    {
      GtkAllocation child_allocation;

      if (GTK_WIDGET_REALIZED (widget))      
	gdk_window_hide (paned->handle);

      if (paned->child1)
	gtk_widget_set_child_visible (paned->child1, TRUE);
      if (paned->child2)
	gtk_widget_set_child_visible (paned->child2, TRUE);

      child_allocation.x = widget->allocation.x + border_width;
      child_allocation.y = widget->allocation.y + border_width;
      child_allocation.width = MAX (1, allocation->width - 2 * border_width);
      child_allocation.height = MAX (1, allocation->height - 2 * border_width);
      
      if (paned->child1 && GTK_WIDGET_VISIBLE (paned->child1))
	gtk_widget_size_allocate (paned->child1, &child_allocation);
      else if (paned->child2 && GTK_WIDGET_VISIBLE (paned->child2))
	gtk_widget_size_allocate (paned->child2, &child_allocation);
    }
}
Commit	Line	Data
561eba2a	1	#include <gtk/gtk.h>
561eba2a	2
95cd67ef	3	#include <lttv/gtkcustom.h>
561eba2a	4	//#include "gtkintl.h"
68b48a45	5	#include <lttv/mainWindow.h>
58960b51	6	#include <lttv/gtkTraceSet.h>
561eba2a	7
	8	static void gtk_custom_class_init (GtkCustomClass *klass);
	9	static void gtk_custom_init (GtkCustom *custom);
	10
	11
	12	static void gtk_custom_size_request (GtkWidget *widget,
	13	GtkRequisition *requisition);
	14	static void gtk_custom_size_allocate (GtkWidget *widget,
	15	GtkAllocation *allocation);
	16
58960b51	17	void gtk_custom_scroll_value_changed (GtkRange *range, gpointer custom);
58960b51	18
561eba2a	19	GType
	20	gtk_custom_get_type (void)
	21	{
	22	static GType custom_type = 0;
	23
	24	if (!custom_type)
	25	{
	26	static const GTypeInfo custom_info =
	27	{
	28	sizeof (GtkCustomClass),
	29	NULL, /* base_init */
	30	NULL, /* base_finalize */
	31	(GClassInitFunc) gtk_custom_class_init,
	32	NULL, /* class_finalize */
	33	NULL, /* class_data */
	34	sizeof (GtkCustom),
	35	0, /* n_preallocs */
	36	(GInstanceInitFunc) gtk_custom_init,
	37	NULL, /* value_table */
	38	};
	39
	40	custom_type = g_type_register_static (GTK_TYPE_PANED, "GtkCustom",
	41	&custom_info, 0);
	42	}
	43
	44	return custom_type;
	45	}
	46
	47	static void
	48	gtk_custom_class_init (GtkCustomClass *class)
	49	{
	50	GtkWidgetClass *widget_class;
	51
	52	widget_class = (GtkWidgetClass *) class;
	53
	54	widget_class->size_request = gtk_custom_size_request;
	55	widget_class->size_allocate = gtk_custom_size_allocate;
	56	}
	57
	58	static void
	59	gtk_custom_init (GtkCustom *custom)
	60	{
	61	GtkWidget * button;
	62
	63	GTK_WIDGET_SET_FLAGS (custom, GTK_NO_WINDOW);
	64	gtk_widget_set_redraw_on_allocate (GTK_WIDGET (custom), FALSE);
	65
bca3b81f	66	custom->first_pane = NULL;
	67	custom->last_pane = NULL;
	68	custom->focused_pane = NULL;
	69	custom->num_children = 0;
561eba2a	70
	71	custom->vbox = NULL;
	72	// custom->scrollWindow = NULL;
	73	// custom->viewport = NULL;
bca3b81f	74	custom->hscrollbar = NULL;
561eba2a	75	}
	76
	77
	78	GtkWidget* gtk_custom_new ()
	79	{
	80	return GTK_WIDGET (g_object_new (gtk_custom_get_type (), NULL));
	81	}
	82
	83
	84	void gtk_custom_set_focus (GtkWidget * widget, gpointer user_data)
	85	{
	86	GtkCustom * custom = (GtkCustom*) widget;
	87	GtkPaned * pane;
bca3b81f	88	if(!custom->first_pane) return;
561eba2a	89
561eba2a	90
bca3b81f	91	pane = custom->first_pane;
561eba2a	92	while(1){
561eba2a	93	if((GtkWidget)pane == (GtkWidget)user_data){
bca3b81f	94	custom->focused_pane = pane;
561eba2a	95	break;
561eba2a	96	}
bca3b81f	97	if(pane == custom->last_pane){
bca3b81f	98	custom->focused_pane = NULL;
561eba2a	99	break;
	100	}
	101	pane = (GtkPaned*)pane->child1;
	102	}
	103	}
	104
1f1ae829	105	void gtk_custom_set_adjust(GtkCustom * custom, gboolean first_time)
	106	{
	107	TimeWindow time_window;
	108	TimeInterval *time_span;
35d31037	109	double tmp, start;
8daac0c3	110	double range = 0;
1f1ae829	111
	112	get_time_window(custom->mw,&time_window);
	113	if(first_time){
	114	time_span = LTTV_TRACESET_CONTEXT(custom->mw->traceset_info->traceset_context)->Time_Span ;
	115
	116	custom->hadjust->lower = ltt_time_to_double(time_span->startTime) *
	117	NANOSECONDS_PER_SECOND;
	118	custom->hadjust->value = custom->hadjust->lower;
	119	custom->hadjust->upper = ltt_time_to_double(time_span->endTime) *
	120	NANOSECONDS_PER_SECOND;
	121	}
	122
	123	/* Page increment of whole visible area */
	124	if(custom->hadjust == NULL){
	125	g_warning("Insert a viewer first");
	126	return;
	127	}
35d31037	128
	129	start = ltt_time_to_double(time_window.start_time) * NANOSECONDS_PER_SECOND;
	130	tmp = custom->hadjust->upper - custom->hadjust->lower;
	131
1f1ae829	132	custom->hadjust->page_increment = ltt_time_to_double(
1f1ae829	133	time_window.time_width) * NANOSECONDS_PER_SECOND;
35d31037	134
	135	if(custom->hadjust->page_increment >= tmp - range)
	136	custom->hadjust->value = custom->hadjust->lower;
8daac0c3	137	if(start + custom->hadjust->page_increment >= custom->hadjust->upper - range)
35d31037	138	custom->hadjust->value = start;
35d31037	139
1f1ae829	140	/* page_size to the whole visible area will take care that the
	141	* scroll value + the shown area will never be more than what is
	142	* in the trace. */
	143	custom->hadjust->page_size = custom->hadjust->page_increment;
	144	custom->hadjust->step_increment = custom->hadjust->page_increment / 10;
	145
35d31037	146	gtk_adjustment_changed (custom->hadjust);
1f1ae829	147	}
1f1ae829	148
561eba2a	149	void gtk_custom_widget_add(GtkCustom * custom, GtkWidget * widget1)
	150	{
	151	GtkPaned * tmpPane;
	152	GtkWidget * w;
f7afe191	153
561eba2a	154	g_return_if_fail(GTK_IS_CUSTOM(custom));
	155	g_object_ref(G_OBJECT(widget1));
	156
	157
bca3b81f	158	if(!custom->first_pane){
	159	custom->first_pane = (GtkPaned *)gtk_vpaned_new();
	160	custom->last_pane = custom->first_pane;
561eba2a	161
bca3b81f	162	custom->hscrollbar = gtk_hscrollbar_new (NULL);
bca3b81f	163	gtk_widget_show(custom->hscrollbar);
58960b51	164
bca3b81f	165	custom->hadjust = gtk_range_get_adjustment(GTK_RANGE(custom->hscrollbar));
1f1ae829	166	gtk_custom_set_adjust(custom, TRUE);
f7afe191	167
bca3b81f	168	gtk_range_set_update_policy (GTK_RANGE(custom->hscrollbar),
f7afe191	169	GTK_UPDATE_DISCONTINUOUS);
bca3b81f	170	g_signal_connect(G_OBJECT(custom->hscrollbar), "value-changed",
58960b51	171	G_CALLBACK(gtk_custom_scroll_value_changed), custom);
58960b51	172
561eba2a	173	custom->vbox = gtk_vbox_new(FALSE,0);
	174	gtk_widget_show(custom->vbox);
	175
	176	// custom->viewport = gtk_viewport_new (NULL,NULL);
	177	// gtk_widget_show(custom->viewport);
	178
	179	// gtk_container_add(GTK_CONTAINER(custom->viewport), (GtkWidget*)custom->vbox);
bca3b81f	180	gtk_box_pack_end(GTK_BOX(custom->vbox),(GtkWidget*)custom->hscrollbar,FALSE,FALSE,0);
bca3b81f	181	gtk_box_pack_end(GTK_BOX(custom->vbox),(GtkWidget*)custom->first_pane,TRUE,TRUE,0);
561eba2a	182
	183	// custom->scrollWindow = gtk_scrolled_window_new (NULL, NULL);
	184	// gtk_widget_show(custom->scrollWindow);
	185	// gtk_container_add (GTK_CONTAINER (custom->scrollWindow), (GtkWidget*)custom->viewport);
	186	// gtk_paned_pack1(GTK_PANED(custom), (GtkWidget*)custom->scrollWindow,FALSE, TRUE);
	187
	188	gtk_paned_pack1(GTK_PANED(custom), (GtkWidget*)custom->vbox,FALSE, TRUE);
	189	}else{
bca3b81f	190	tmpPane = custom->last_pane;
	191	custom->last_pane = (GtkPaned *)gtk_vpaned_new();
	192	gtk_paned_pack1 (tmpPane,(GtkWidget*)custom->last_pane, FALSE,TRUE);
561eba2a	193	}
bca3b81f	194	gtk_widget_show((GtkWidget *)custom->last_pane);
561eba2a	195
bca3b81f	196	gtk_paned_pack2 (custom->last_pane,widget1, TRUE, TRUE);
	197	custom->focused_pane = custom->last_pane;
	198	custom->num_children++;
561eba2a	199
	200	}
	201
	202	void gtk_custom_widget_delete(GtkCustom * custom)
	203	{
	204	GtkPaned * tmp, prev, next;
	205
bca3b81f	206	if(!custom->focused_pane) return;
561eba2a	207
bca3b81f	208	tmp = (GtkPaned*)custom->focused_pane->child2; //widget in vpaned
561eba2a	209	g_object_unref(G_OBJECT(tmp));
561eba2a	210
bca3b81f	211	if(custom->focused_pane == custom->first_pane &&
bca3b81f	212	custom->focused_pane == custom->last_pane){
561eba2a	213	// gtk_container_remove(GTK_CONTAINER(custom),(GtkWidget*)custom->scrollWindow);
561eba2a	214	gtk_container_remove(GTK_CONTAINER(custom),(GtkWidget*)custom->vbox);
bca3b81f	215	custom->first_pane = NULL;
	216	custom->last_pane = NULL;
	217	custom->focused_pane = NULL;
	218	}else if(custom->focused_pane == custom->first_pane &&
	219	custom->focused_pane != custom->last_pane){
	220	next = (GtkPaned*)custom->first_pane->child1;
561eba2a	221	g_object_ref(G_OBJECT(next));
bca3b81f	222	gtk_container_remove(GTK_CONTAINER(custom->first_pane),(GtkWidget*)next);
	223	gtk_container_remove(GTK_CONTAINER(custom->vbox),(GtkWidget*)custom->first_pane);
	224	custom->first_pane = next;
	225	gtk_box_pack_end(GTK_BOX(custom->vbox),(GtkWidget*)custom->first_pane,TRUE,TRUE,0);
	226	custom->focused_pane = custom->first_pane;
561eba2a	227	g_object_unref(G_OBJECT(next));
bca3b81f	228	}else if(custom->focused_pane != custom->first_pane &&
	229	custom->focused_pane == custom->last_pane){
	230	tmp = custom->last_pane;
	231	custom->last_pane = (GtkPaned)gtk_widget_get_parent((GtkWidget)custom->last_pane);
	232	custom->focused_pane = custom->last_pane;
	233	gtk_container_remove(GTK_CONTAINER(custom->last_pane),(GtkWidget*)tmp);
561eba2a	234	}else{
bca3b81f	235	tmp = custom->focused_pane;
561eba2a	236	prev = (GtkPaned)gtk_widget_get_parent((GtkWidget)tmp);
	237	next = (GtkPaned*)tmp->child1;
	238	g_object_ref(G_OBJECT(next));
bca3b81f	239	gtk_container_remove(GTK_CONTAINER(custom->focused_pane),(GtkWidget*)next);
bca3b81f	240	gtk_container_remove(GTK_CONTAINER(prev),(GtkWidget*)custom->focused_pane);
561eba2a	241	gtk_paned_pack1(prev, (GtkWidget*)next, FALSE, TRUE);
bca3b81f	242	custom->focused_pane = next;
561eba2a	243	g_object_unref(G_OBJECT(next));
	244	}
	245
bca3b81f	246	custom->num_children--;
561eba2a	247	}
	248
	249
	250	void gtk_custom_widget_move_up(GtkCustom * custom)
	251	{
	252	GtkWidget* upWidget, *downWidget;
	253	GtkPaned * prev,next, prevPrev;
	254
bca3b81f	255	if(custom->last_pane == custom->focused_pane) return;
561eba2a	256
561eba2a	257	// move VPane
bca3b81f	258	prev = (GtkPaned*)custom->focused_pane->child1;
561eba2a	259	g_object_ref(G_OBJECT(prev));
bca3b81f	260	gtk_container_remove(GTK_CONTAINER(custom->focused_pane),(GtkWidget*)prev);
561eba2a	261
bca3b81f	262	if(prev == custom->last_pane){
561eba2a	263	prevPrev = NULL;
bca3b81f	264	custom->last_pane = custom->focused_pane;
561eba2a	265	}else{
	266	prevPrev = (GtkPaned*)prev->child1;
	267	g_object_ref(G_OBJECT(prevPrev));
	268	gtk_container_remove(GTK_CONTAINER(prev),(GtkWidget*)prevPrev);
	269	}
	270
bca3b81f	271	g_object_ref(G_OBJECT(custom->focused_pane));
	272	if(custom->first_pane == custom->focused_pane){
	273	gtk_container_remove(GTK_CONTAINER(custom->vbox),(GtkWidget*)custom->focused_pane);
561eba2a	274	gtk_box_pack_end(GTK_BOX(custom->vbox),(GtkWidget*)prev,TRUE,TRUE,0);
bca3b81f	275	custom->first_pane = prev;
561eba2a	276	}else{
bca3b81f	277	next = (GtkPaned)gtk_widget_get_parent((GtkWidget)custom->focused_pane);
bca3b81f	278	gtk_container_remove(GTK_CONTAINER(next),(GtkWidget*)custom->focused_pane);
561eba2a	279	gtk_paned_pack1(GTK_PANED(next), (GtkWidget*)prev, FALSE,TRUE);
561eba2a	280	}
bca3b81f	281	gtk_paned_pack1(GTK_PANED(prev),(GtkWidget*)custom->focused_pane, FALSE,TRUE);
561eba2a	282	if(prevPrev)
bca3b81f	283	gtk_paned_pack1(GTK_PANED(custom->focused_pane),(GtkWidget*)prevPrev, FALSE,TRUE);
561eba2a	284
	285	g_object_unref(G_OBJECT(prev));
	286	if(prevPrev) g_object_unref(G_OBJECT(prevPrev));
bca3b81f	287	g_object_unref(G_OBJECT(custom->focused_pane));
561eba2a	288	}
	289
	290
	291	void gtk_custom_widget_move_down(GtkCustom * custom)
	292	{
	293	GtkWidget* upWidget, *downWidget;
	294	GtkPaned * prev,next, nextNext;
	295
bca3b81f	296	if(custom->first_pane == custom->focused_pane) return;
561eba2a	297
561eba2a	298	//move VPane
bca3b81f	299	next = (GtkPaned)gtk_widget_get_parent((GtkWidget)custom->focused_pane);
561eba2a	300	g_object_ref(G_OBJECT(next));
561eba2a	301
bca3b81f	302	if(custom->last_pane == custom->focused_pane){
561eba2a	303	prev = NULL;
bca3b81f	304	custom->last_pane = next;
561eba2a	305	}else{
bca3b81f	306	prev = (GtkPaned*)custom->focused_pane->child1;
561eba2a	307	g_object_ref(G_OBJECT(prev));
bca3b81f	308	gtk_container_remove(GTK_CONTAINER(custom->focused_pane),(GtkWidget*)prev);
561eba2a	309	}
561eba2a	310
bca3b81f	311	g_object_ref(G_OBJECT(custom->focused_pane));
bca3b81f	312	gtk_container_remove(GTK_CONTAINER(next),(GtkWidget*)custom->focused_pane);
561eba2a	313
bca3b81f	314	if(next == custom->first_pane){
bca3b81f	315	custom->first_pane = custom->focused_pane;
561eba2a	316	gtk_container_remove(GTK_CONTAINER(custom->vbox),(GtkWidget*)next);
bca3b81f	317	gtk_box_pack_end(GTK_BOX(custom->vbox),(GtkWidget*)custom->focused_pane,TRUE,TRUE,0);
561eba2a	318	}else{
	319	nextNext = (GtkPaned)gtk_widget_get_parent((GtkWidget)next);
	320	gtk_container_remove(GTK_CONTAINER(nextNext),(GtkWidget*)next);
bca3b81f	321	gtk_paned_pack1(nextNext, (GtkWidget*)custom->focused_pane, FALSE, TRUE);
561eba2a	322	}
bca3b81f	323	gtk_paned_pack1(custom->focused_pane,(GtkWidget*)next, FALSE,TRUE);
561eba2a	324	if(prev)
	325	gtk_paned_pack1(next,(GtkWidget*)prev, FALSE,TRUE);
	326
	327	if(prev)g_object_unref(G_OBJECT(prev));
	328	g_object_unref(G_OBJECT(next));
bca3b81f	329	g_object_unref(G_OBJECT(custom->focused_pane));
561eba2a	330	}
561eba2a	331
58960b51	332	void gtk_custom_scroll_value_changed(GtkRange *range, gpointer custom_arg)
	333	{
	334	LttTime time;
	335	GtkCustom * custom = (GtkCustom*)custom_arg;
	336	gdouble value = gtk_range_get_value(range);
308711e5	337	time = ltt_time_from_double(value / NANOSECONDS_PER_SECOND);
41a76985	338	set_current_time(custom->mw, &time);
58960b51	339	g_warning("The current time is second :%d, nanosecond : %d\n", time.tv_sec, time.tv_nsec);
	340	}
	341
561eba2a	342
	343	static void
	344	gtk_custom_size_request (GtkWidget *widget,
	345	GtkRequisition *requisition)
	346	{
	347	GtkPaned *paned = GTK_PANED (widget);
	348	GtkRequisition child_requisition;
	349
	350	requisition->width = 0;
	351	requisition->height = 0;
	352
	353	if (paned->child1 && GTK_WIDGET_VISIBLE (paned->child1))
	354	{
	355	gtk_widget_size_request (paned->child1, &child_requisition);
	356
	357	requisition->height = child_requisition.height;
	358	requisition->width = child_requisition.width;
	359	}
	360
	361	if (paned->child2 && GTK_WIDGET_VISIBLE (paned->child2))
	362	{
	363	gtk_widget_size_request (paned->child2, &child_requisition);
	364
	365	requisition->width = MAX (requisition->width, child_requisition.width);
	366	requisition->height += child_requisition.height;
	367	}
	368
	369	requisition->height += GTK_CONTAINER (paned)->border_width * 2;
	370	requisition->width += GTK_CONTAINER (paned)->border_width * 2;
	371
	372	if (paned->child1 && GTK_WIDGET_VISIBLE (paned->child1) &&
	373	paned->child2 && GTK_WIDGET_VISIBLE (paned->child2))
	374	{
	375	gint handle_size;
	376
	377	gtk_widget_style_get (widget, "handle_size", &handle_size, NULL);
	378	requisition->height += handle_size;
	379	}
	380
	381	}
	382
	383	static void
	384	gtk_custom_size_allocate (GtkWidget *widget,
	385	GtkAllocation *allocation)
	386	{
	387	GtkPaned *paned = GTK_PANED (widget);
	388	gint border_width = GTK_CONTAINER (paned)->border_width;
	389
	390	widget->allocation = *allocation;
	391
	392	if (paned->child1 && GTK_WIDGET_VISIBLE (paned->child1) &&
	393	paned->child2 && GTK_WIDGET_VISIBLE (paned->child2))
	394	{
	395	GtkRequisition child1_requisition;
	396	GtkRequisition child2_requisition;
	397	GtkAllocation child1_allocation;
	398	GtkAllocation child2_allocation;
	399	gint handle_size;
	400
	401	gtk_widget_style_get (widget, "handle_size", &handle_size, NULL);
	402
	403	gtk_widget_get_child_requisition (paned->child1, &child1_requisition);
	404	gtk_widget_get_child_requisition (paned->child2, &child2_requisition);
	405
406	gtk_paned_compute_position (paned,
407	MAX (1, widget->allocation.height
408	- handle_size
409	- 2 * border_width),
410	child1_requisition.height,
411	child2_requisition.height);
412
413	paned->handle_pos.x = widget->allocation.x + border_width;
414	paned->handle_pos.y = widget->allocation.y + paned->child1_size + border_width;
415	paned->handle_pos.width = MAX (1, (gint) widget->allocation.width - 2 * border_width);
416	paned->handle_pos.height = handle_size;
417
418	if (GTK_WIDGET_REALIZED (widget))
419	{
420	if (GTK_WIDGET_MAPPED (widget))
421	gdk_window_show (paned->handle);
422	gdk_window_move_resize (paned->handle,
423	paned->handle_pos.x,
424	paned->handle_pos.y,
425	paned->handle_pos.width,
426	handle_size);
427	}
428
429	child1_allocation.width = child2_allocation.width = MAX (1, (gint) allocation->width - border_width * 2);
430	child1_allocation.height = MAX (1, paned->child1_size);
431	child1_allocation.x = child2_allocation.x = widget->allocation.x + border_width;
432	child1_allocation.y = widget->allocation.y + border_width;
433
434	child2_allocation.y = child1_allocation.y + paned->child1_size + paned->handle_pos.height;
435	child2_allocation.height = MAX (1, widget->allocation.y + widget->allocation.height - child2_allocation.y - border_width);
436
437	if (GTK_WIDGET_MAPPED (widget) &&
438	paned->child1->allocation.height < child1_allocation.height)
439	{
440	gtk_widget_size_allocate (paned->child2, &child2_allocation);
441	gtk_widget_size_allocate (paned->child1, &child1_allocation);
442	}
443	else
444	{
445	gtk_widget_size_allocate (paned->child1, &child1_allocation);
446	gtk_widget_size_allocate (paned->child2, &child2_allocation);
447	}
448	}
449	else
450	{
451	GtkAllocation child_allocation;
452
453	if (GTK_WIDGET_REALIZED (widget))
454	gdk_window_hide (paned->handle);
455
456	if (paned->child1)
457	gtk_widget_set_child_visible (paned->child1, TRUE);
458	if (paned->child2)
459	gtk_widget_set_child_visible (paned->child2, TRUE);
460
461	child_allocation.x = widget->allocation.x + border_width;
462	child_allocation.y = widget->allocation.y + border_width;
463	child_allocation.width = MAX (1, allocation->width - 2 * border_width);
464	child_allocation.height = MAX (1, allocation->height - 2 * border_width);
465
466	if (paned->child1 && GTK_WIDGET_VISIBLE (paned->child1))
467	gtk_widget_size_allocate (paned->child1, &child_allocation);
468	else if (paned->child2 && GTK_WIDGET_VISIBLE (paned->child2))
469	gtk_widget_size_allocate (paned->child2, &child_allocation);
470	}
471	}
472