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

#ifdef HAVE_CONFIG_H
#  include <config.h>
#endif

#include <gtk/gtk.h>
#include <gmodule.h>

#include "callbacks.h"
#include "interface.h"
#include "support.h"
#include <lttv/mainWindow.h>
#include <lttv/menu.h>
#include <lttv/toolbar.h>
#include <lttv/gtkTraceSet.h>
#include <lttv/module.h>

#define PATH_LENGTH     256

extern systemView * gSysView;
extern LttvTracesetContext * gTracesetContext;

/** Array containing instanced objects. */
extern GSList * Main_Window_List;

mainWindow * get_window_data_struct(GtkWidget * widget);

/* test part */
void insertView(GtkWidget* widget, view_constructor constructor);

void
on_textview1_grab_focus                     (GtkTextView     *text_view,
					  gpointer         user_data)
{
  GtkWidget * widget;
  GtkCustom * custom = (GtkCustom*)user_data;
  widget = gtk_widget_get_parent((GtkWidget*)text_view);
  widget = gtk_widget_get_parent(widget);
  gtk_custom_set_focus((GtkWidget*)custom, (gpointer)widget);
}

void
insertViewTest(GtkMenuItem *menuitem, gpointer user_data)
{
  guint val = 20;
  insertView((GtkWidget*)menuitem, (view_constructor)user_data);
  //  selected_hook(&val);
}

void
on_insert_viewer_test_activate         (GtkMenuItem     *menuitem,
                                        gpointer         user_data)
{
  GtkWidget *scrolledwindow1, *textview1, *label;
  static int count = 0;
  char str[64];
  GtkCustom * custom;
  GtkTextBuffer* buf;
  
  mainWindow * mwData;  
  mwData = get_window_data_struct((GtkWidget*)menuitem);
  if(!mwData->CurrentTab) return;
  custom = mwData->CurrentTab->custom;

  sprintf(str,"label : %d",++count);
  scrolledwindow1 = gtk_scrolled_window_new (NULL, NULL);
  gtk_widget_show (scrolledwindow1);
  label = gtk_label_new(str);
  gtk_widget_show(label);

  gtk_custom_widget_add(custom, scrolledwindow1);
  gtk_widget_set_size_request ((GtkWidget*)scrolledwindow1, 800, 100);
  
  textview1 = gtk_text_view_new ();
  gtk_widget_show (textview1);
  gtk_container_add (GTK_CONTAINER (scrolledwindow1), textview1);
  buf =  gtk_text_view_get_buffer((GtkTextView*)textview1);
  sprintf(str,"text view : %d",count);
  gtk_text_buffer_set_text(buf,str, -1);
  
  g_signal_connect ((gpointer) textview1, "grab_focus",
		    G_CALLBACK (on_textview1_grab_focus), custom);
}

/* end of test part */


/* internal functions */
void insertView(GtkWidget* widget, view_constructor constructor)
{
  GtkCustom * custom;
  mainWindow * mwData;  
  GtkWidget * viewer;

  mwData = get_window_data_struct(widget);
  if(!mwData->CurrentTab) return;
  custom = mwData->CurrentTab->custom;

  viewer = (GtkWidget*)constructor(mwData);
  if(viewer)
  {
    gtk_custom_widget_add(custom, viewer); 
    // Added by MD
    //    g_object_unref(G_OBJECT(viewer));
  }
}

void get_label_string (GtkWidget * text, gchar * label) 
{
  GtkEntry * entry = (GtkEntry*)text;
  if(strlen(gtk_entry_get_text(entry))!=0)
    strcpy(label,gtk_entry_get_text(entry)); 
}

void get_label(GtkWindow * mw, gchar * str, gchar* dialogue_title, gchar * label_str)
{
  GtkWidget * dialogue;
  GtkWidget * text;
  GtkWidget * label;
  gint id;

  dialogue = gtk_dialog_new_with_buttons(dialogue_title,mw,
					 GTK_DIALOG_MODAL,
					 GTK_STOCK_OK,GTK_RESPONSE_ACCEPT,
					 GTK_STOCK_CANCEL,GTK_RESPONSE_REJECT,
					 NULL); 

  label = gtk_label_new(label_str);
  gtk_widget_show(label);

  text = gtk_entry_new();
  gtk_widget_show(text);

  gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialogue)->vbox), label,TRUE, TRUE,0);
  gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialogue)->vbox), text,FALSE, FALSE,0);

  id = gtk_dialog_run(GTK_DIALOG(dialogue));
  switch(id){
    case GTK_RESPONSE_ACCEPT:
      get_label_string(text,str);
      gtk_widget_destroy(dialogue);
      break;
    case GTK_RESPONSE_REJECT:
    default:
      gtk_widget_destroy(dialogue);
      break;
  }
}

mainWindow * get_window_data_struct(GtkWidget * widget)
{
  GtkWidget * mw;
  mainWindow * mwData;

  mw = lookup_widget(widget, "MWindow");
  if(mw == NULL){
    g_printf("Main window does not exist\n");
    return;
  }
  
  mwData = (mainWindow *) g_object_get_data(G_OBJECT(mw),"mainWindow");
  if(mwData == NULL){
    g_printf("Main window data does not exist\n");
    return;
  }
  return mwData;
}

void createNewWindow(GtkWidget* widget, gpointer user_data, gboolean clone)
{
  GtkWidget  * mw = NULL; /* Main window */
  systemView * sv = NULL; /* System view */
  systemView * newSv;     /* New system view displayed in the new window */
  GtkWidget  * newWindow; /* New generated main window */
  mainWindow * newMWindow;/* New main window structure */

  //test
  int i;
  GtkWidget * ToolMenuTitle_menu, *insert_view, *pixmap;
  LttvMenus * menu;
  LttvToolbars * toolbar;
  lttv_menu_closure *menuItem;
  lttv_toolbar_closure *toolbarItem;
  LttvAttributeValue value;
  LttvIAttribute *attributes = LTTV_IATTRIBUTE(lttv_global_attributes());
  view_constructor constructor;
  GdkPixbuf *pixbuf;
  //end

  mw = lookup_widget (widget, "MWindow");
  if(mw == NULL){
    g_printf("Can not find main window\n");
    return;
  }
  
  sv = (systemView *)g_object_get_data(G_OBJECT(mw),"systemView");
  if(sv == NULL){
    g_printf("Can not find system view\n");
    return;
  }  
    
  newMWindow = g_new(mainWindow, 1);

  /* Add the object's information to the module's array */
  Main_Window_List = g_slist_append(Main_Window_List, mw);

  newWindow  = create_MWindow();
  gtk_widget_show (newWindow);
  
  
  newSv = g_new(systemView, 1);
  while(sv->Next) sv = sv->Next;
  sv->Next = newSv;

  newSv->EventDB = NULL;
  newSv->SystemInfo = NULL;
  newSv->Options  = NULL;
  newSv->Next = NULL;
  newSv->Window = newMWindow;

  newMWindow->MWindow = newWindow;
  newMWindow->Tab = NULL;
  newMWindow->CurrentTab = NULL;
  newMWindow->SystemView = newSv;
  newMWindow->Attributes = LTTV_IATTRIBUTE(g_object_new(LTTV_ATTRIBUTE_TYPE, NULL));
  newMWindow->traceset_context = LTTV_TRACESET_CONTEXT(gTracesetContext);
  newMWindow->traceset = (LTTV_TRACESET_CONTEXT(gTracesetContext))->ts;
  g_object_ref(gTracesetContext);

  //test yxx
  g_assert(lttv_iattribute_find_by_path(attributes,
	   "viewers/menu", LTTV_POINTER, &value));
  menu = (LttvMenus*)*(value.v_pointer);

  if(menu){
    for(i=0;i<menu->len;i++){
      menuItem = &g_array_index(menu, lttv_menu_closure, i);
      constructor = menuItem->con;
      ToolMenuTitle_menu = lookup_widget(newMWindow->MWindow,"ToolMenuTitle_menu");
      insert_view = gtk_menu_item_new_with_mnemonic (menuItem->menuText);
      gtk_widget_show (insert_view);
      gtk_container_add (GTK_CONTAINER (ToolMenuTitle_menu), insert_view);
      g_signal_connect ((gpointer) insert_view, "activate",
			G_CALLBACK (insertViewTest),
			constructor);  
    }
  }
  g_assert(lttv_iattribute_find_by_path(attributes,
	   "viewers/toolbar", LTTV_POINTER, &value));
  toolbar = (LttvToolbars*)*(value.v_pointer);

  if(toolbar){
    for(i=0;i<toolbar->len;i++){
      toolbarItem = &g_array_index(toolbar, lttv_toolbar_closure, i);
      constructor = toolbarItem->con;
      ToolMenuTitle_menu = lookup_widget(newMWindow->MWindow,"MToolbar2");
      pixbuf = gdk_pixbuf_new_from_xpm_data ((const char**)toolbarItem->pixmap);
      pixmap = gtk_image_new_from_pixbuf(pixbuf);
      insert_view = gtk_toolbar_append_element (GTK_TOOLBAR (ToolMenuTitle_menu),
						GTK_TOOLBAR_CHILD_BUTTON,
						NULL,
						"",
						toolbarItem->tooltip, NULL,
						pixmap, NULL, NULL);
      gtk_label_set_use_underline (GTK_LABEL (((GtkToolbarChild*) (g_list_last (GTK_TOOLBAR (ToolMenuTitle_menu)->children)->data))->label), TRUE);
      gtk_widget_show (insert_view);
      gtk_container_set_border_width (GTK_CONTAINER (insert_view), 1);
      g_signal_connect ((gpointer) insert_view, "clicked",G_CALLBACK (insertViewTest),constructor);       
    }
  }
  //end
  
  g_object_set_data(G_OBJECT(newWindow), "systemView", (gpointer)newSv);    
  g_object_set_data(G_OBJECT(newWindow), "mainWindow", (gpointer)newMWindow);    

  if(clone){
    g_printf("Clone : use the same traceset\n");
  }else{
    g_printf("Empty : traceset is set to NULL\n");
  }
}

void move_up_viewer(GtkWidget * widget, gpointer user_data)
{
  mainWindow * mw = get_window_data_struct(widget);
  if(!mw->CurrentTab) return;
  gtk_custom_widget_move_up(mw->CurrentTab->custom);
}

void move_down_viewer(GtkWidget * widget, gpointer user_data)
{
  mainWindow * mw = get_window_data_struct(widget);
  if(!mw->CurrentTab) return;
  gtk_custom_widget_move_down(mw->CurrentTab->custom);
}

void delete_viewer(GtkWidget * widget, gpointer user_data)
{
  mainWindow * mw = get_window_data_struct(widget);
  if(!mw->CurrentTab) return;
  gtk_custom_widget_delete(mw->CurrentTab->custom);
}

void open_traceset(GtkWidget * widget, gpointer user_data)
{
  g_printf("Open a trace set\n");
}

void add_trace(GtkWidget * widget, gpointer user_data)
{
  g_printf("add a trace to a trace set\n");
}

void remove_trace(GtkWidget * widget, gpointer user_data)
{
  g_printf("remove a trace from a trace set\n");
}

void save(GtkWidget * widget, gpointer user_data)
{
  g_printf("Save\n");
}

void save_as(GtkWidget * widget, gpointer user_data)
{
  g_printf("Save as\n");
}

void zoom_in(GtkWidget * widget, gpointer user_data)
{
  g_printf("Zoom in\n");
}

void zoom_out(GtkWidget * widget, gpointer user_data)
{
  g_printf("Zoom out\n");
}

void zoom_extended(GtkWidget * widget, gpointer user_data)
{
  g_printf("Zoom extended\n");
}

void go_to_time(GtkWidget * widget, gpointer user_data)
{
  g_printf("Go to time\n");
}

void show_time_frame(GtkWidget * widget, gpointer user_data)
{
  g_printf("Show time frame\n");  
}


/* callback function */

void
on_empty_traceset_activate             (GtkMenuItem     *menuitem,
                                        gpointer         user_data)
{
  createNewWindow((GtkWidget*)menuitem, user_data, FALSE);
}


void
on_clone_traceset_activate             (GtkMenuItem     *menuitem,
                                        gpointer         user_data)
{
  createNewWindow((GtkWidget*)menuitem, user_data, TRUE);
}


void
on_tab_activate                        (GtkMenuItem     *menuitem,
                                        gpointer         user_data)
{
  GList * list;
  gchar label[PATH_LENGTH];

  tab * tmpTab;
  GtkWidget * pane;
  mainWindow * mwData;
  GtkNotebook * notebook = (GtkNotebook *)lookup_widget((GtkWidget*)menuitem, "MNotebook");
  if(notebook == NULL){
    g_printf("Notebook does not exist\n");
    return;
  }

  mwData = get_window_data_struct((GtkWidget*)menuitem);

  tmpTab = mwData->Tab;
  while(tmpTab && tmpTab->Next) tmpTab = tmpTab->Next;
  if(!tmpTab){
    mwData->CurrentTab = NULL;
    tmpTab = g_new(tab,1);
    mwData->Tab = tmpTab;    
  }else{
    tmpTab->Next = g_new(tab,1);
    tmpTab = tmpTab->Next;
  }
  if(mwData->CurrentTab){
    tmpTab->traceStartTime = mwData->CurrentTab->traceStartTime;
    tmpTab->traceEndTime   = mwData->CurrentTab->traceEndTime;
    tmpTab->startTime      = mwData->CurrentTab->startTime;
    tmpTab->endTime        = mwData->CurrentTab->endTime;
    tmpTab->currentTime    = mwData->CurrentTab->currentTime;
  }else{
    getTracesetTimeSpan(mwData,&tmpTab->traceStartTime, &tmpTab->traceEndTime);
    tmpTab->startTime   = tmpTab->traceStartTime;
    tmpTab->endTime     = tmpTab->traceEndTime;
    tmpTab->currentTime = tmpTab->traceStartTime;
  }
  tmpTab->Attributes = LTTV_IATTRIBUTE(g_object_new(LTTV_ATTRIBUTE_TYPE, NULL));
  //  mwData->CurrentTab = tmpTab;
  tmpTab->custom = (GtkCustom*)gtk_custom_new();
  tmpTab->custom->mw = mwData;
  gtk_widget_show((GtkWidget*)tmpTab->custom);
  tmpTab->Next = NULL;    

  strcpy(label,"Page");
  get_label((GtkWindow*)mwData->MWindow, label,"Get the name of the tab","Please input tab's name");
  tmpTab->label = gtk_label_new (label);
  gtk_widget_show (tmpTab->label);

  gtk_notebook_append_page(notebook, (GtkWidget*)tmpTab->custom, tmpTab->label); 
  
  list = gtk_container_get_children(GTK_CONTAINER(notebook));
  gtk_notebook_set_current_page(notebook,g_list_length(list)-1);
}


void
on_open_activate                       (GtkMenuItem     *menuitem,
                                        gpointer         user_data)
{
  open_traceset((GtkWidget*)menuitem, user_data);
}


void
on_close_activate                      (GtkMenuItem     *menuitem,
                                        gpointer         user_data)
{
  g_printf("Close\n");
}


void
on_close_tab_activate                  (GtkMenuItem     *menuitem,
                                        gpointer         user_data)
{
  g_printf("Close tab\n");
}


void
on_add_trace_activate                  (GtkMenuItem     *menuitem,
                                        gpointer         user_data)
{
  add_trace((GtkWidget*)menuitem, user_data);
}


void
on_remove_trace_activate               (GtkMenuItem     *menuitem,
                                        gpointer         user_data)
{
  remove_trace((GtkWidget*)menuitem, user_data);
}


void
on_save_activate                       (GtkMenuItem     *menuitem,
                                        gpointer         user_data)
{
  save((GtkWidget*)menuitem, user_data);
}


void
on_save_as_activate                    (GtkMenuItem     *menuitem,
                                        gpointer         user_data)
{
  save_as((GtkWidget*)menuitem, user_data);
}


void
on_quit_activate                       (GtkMenuItem     *menuitem,
                                        gpointer         user_data)
{
  on_MWindow_destroy(GTK_OBJECT(menuitem), user_data);
}


void
on_cut_activate                        (GtkMenuItem     *menuitem,
                                        gpointer         user_data)
{
  g_printf("Cut\n");
}


void
on_copy_activate                       (GtkMenuItem     *menuitem,
                                        gpointer         user_data)
{
  g_printf("Copye\n");
}


void
on_paste_activate                      (GtkMenuItem     *menuitem,
                                        gpointer         user_data)
{
  g_printf("Paste\n");
}


void
on_delete_activate                     (GtkMenuItem     *menuitem,
                                        gpointer         user_data)
{
  g_printf("Delete\n");
}


void
on_zoom_in_activate                    (GtkMenuItem     *menuitem,
                                        gpointer         user_data)
{
   zoom_in((GtkWidget*)menuitem, user_data); 
}


void
on_zoom_out_activate                   (GtkMenuItem     *menuitem,
                                        gpointer         user_data)
{
   zoom_out((GtkWidget*)menuitem, user_data); 
}


void
on_zoom_extended_activate              (GtkMenuItem     *menuitem,
                                        gpointer         user_data)
{
   zoom_extended((GtkWidget*)menuitem, user_data); 
}


void
on_go_to_time_activate                 (GtkMenuItem     *menuitem,
                                        gpointer         user_data)
{
   go_to_time((GtkWidget*)menuitem, user_data); 
}


void
on_show_time_frame_activate            (GtkMenuItem     *menuitem,
                                        gpointer         user_data)
{
   show_time_frame((GtkWidget*)menuitem, user_data); 
}


void
on_move_viewer_up_activate             (GtkMenuItem     *menuitem,
                                        gpointer         user_data)
{
  move_up_viewer((GtkWidget*)menuitem, user_data);
}


void
on_move_viewer_down_activate           (GtkMenuItem     *menuitem,
                                        gpointer         user_data)
{
  move_down_viewer((GtkWidget*)menuitem, user_data);
}


void
on_remove_viewer_activate              (GtkMenuItem     *menuitem,
                                        gpointer         user_data)
{
  delete_viewer((GtkWidget*)menuitem, user_data);
}


void
on_load_module_activate                (GtkMenuItem     *menuitem,
                                        gpointer         user_data)
{
  g_printf("Load module\n");
}


void
on_unload_module_activate              (GtkMenuItem     *menuitem,
                                        gpointer         user_data)
{
  g_printf("Unload module\n");
}


void
on_add_module_search_path_activate     (GtkMenuItem     *menuitem,
                                        gpointer         user_data)
{
  gchar  str[PATH_LENGTH];
  mainWindow * mwData = get_window_data_struct((GtkWidget*)menuitem);
  g_printf("Add module search path\n");
  str[0] = '\0';
  get_label((GtkWindow*)mwData->MWindow, str, "Add module search path", "Please input a search path:");
  if(strlen(str)){
    lttv_module_path_add(str);
  }
}


void
on_color_activate                      (GtkMenuItem     *menuitem,
                                        gpointer         user_data)
{
  g_printf("Color\n");
}


void
on_filter_activate                     (GtkMenuItem     *menuitem,
                                        gpointer         user_data)
{
  g_printf("Filter\n");
}


void
on_save_configuration_activate         (GtkMenuItem     *menuitem,
                                        gpointer         user_data)
{
  g_printf("Save configuration\n");
}


void
on_content_activate                    (GtkMenuItem     *menuitem,
                                        gpointer         user_data)
{
  g_printf("Content\n");
}


void
on_about_activate                      (GtkMenuItem     *menuitem,
                                        gpointer         user_data)
{
  g_printf("About...\n");
}


void
on_button_new_clicked                  (GtkButton       *button,
                                        gpointer         user_data)
{
  createNewWindow((GtkWidget*)button, user_data, FALSE);
}


void
on_button_open_clicked                 (GtkButton       *button,
                                        gpointer         user_data)
{
  open_traceset((GtkWidget*)button, user_data);
}


void
on_button_add_trace_clicked            (GtkButton       *button,
                                        gpointer         user_data)
{
  add_trace((GtkWidget*)button, user_data);
}


void
on_button_remove_trace_clicked         (GtkButton       *button,
                                        gpointer         user_data)
{
  remove_trace((GtkWidget*)button, user_data);
}


void
on_button_save_clicked                 (GtkButton       *button,
                                        gpointer         user_data)
{
  save((GtkWidget*)button, user_data);
}


void
on_button_save_as_clicked              (GtkButton       *button,
                                        gpointer         user_data)
{
  save_as((GtkWidget*)button, user_data);
}


void
on_button_zoom_in_clicked              (GtkButton       *button,
                                        gpointer         user_data)
{
   zoom_in((GtkWidget*)button, user_data); 
}


void
on_button_zoom_out_clicked             (GtkButton       *button,
                                        gpointer         user_data)
{
   zoom_out((GtkWidget*)button, user_data); 
}


void
on_button_zoom_extended_clicked        (GtkButton       *button,
                                        gpointer         user_data)
{
   zoom_extended((GtkWidget*)button, user_data); 
}


void
on_button_go_to_time_clicked           (GtkButton       *button,
                                        gpointer         user_data)
{
   go_to_time((GtkWidget*)button, user_data); 
}


void
on_button_show_time_frame_clicked      (GtkButton       *button,
                                        gpointer         user_data)
{
   show_time_frame((GtkWidget*)button, user_data); 
}


void
on_button_move_up_clicked              (GtkButton       *button,
                                        gpointer         user_data)
{
  move_up_viewer((GtkWidget*)button, user_data);
}


void
on_button_move_down_clicked            (GtkButton       *button,
                                        gpointer         user_data)
{
  move_down_viewer((GtkWidget*)button, user_data);
}


void
on_button_delete_viewer_clicked        (GtkButton       *button,
                                        gpointer         user_data)
{
  delete_viewer((GtkWidget*)button, user_data);
}

void
on_MWindow_destroy                     (GtkObject       *object,
                                        gpointer         user_data)
{
  systemView * sv = gSysView;
  gint count = 0;
  while(sv->Next){
    g_printf("There are : %d windows\n",++count);
    sv = sv->Next;
  }
  g_printf("There are : %d windows\n",++count);
  
  gtk_main_quit ();

}


void
on_MNotebook_switch_page               (GtkNotebook     *notebook,
                                        GtkNotebookPage *page,
                                        guint            page_num,
                                        gpointer         user_data)
{
  mainWindow * mw = get_window_data_struct((GtkWidget*)notebook);
  tab * Tab = mw->Tab;
 
  while(page_num){
    Tab = Tab->Next;
    page_num--;
  }
  mw->CurrentTab = Tab;
}
Commit	Line	Data
561eba2a	1	#ifdef HAVE_CONFIG_H
	2	# include <config.h>
	3	#endif
	4
	5	#include <gtk/gtk.h>
	6	#include <gmodule.h>
	7
	8	#include "callbacks.h"
	9	#include "interface.h"
	10	#include "support.h"
95cd67ef	11	#include <lttv/mainWindow.h>
37d0eca6	12	#include <lttv/menu.h>
37d0eca6	13	#include <lttv/toolbar.h>
58960b51	14	#include <lttv/gtkTraceSet.h>
6b1d3120	15	#include <lttv/module.h>
	16
	17	#define PATH_LENGTH 256
561eba2a	18
561eba2a	19	extern systemView * gSysView;
ec25ff5e	20	extern LttvTracesetContext * gTracesetContext;
	21
	22	/** Array containing instanced objects. */
	23	extern GSList * Main_Window_List;
561eba2a	24
561eba2a	25	mainWindow * get_window_data_struct(GtkWidget * widget);
	26
	27	/* test part */
	28	void insertView(GtkWidget* widget, view_constructor constructor);
	29
	30	void
	31	on_textview1_grab_focus (GtkTextView *text_view,
	32	gpointer user_data)
	33	{
	34	GtkWidget * widget;
	35	GtkCustom * custom = (GtkCustom*)user_data;
	36	widget = gtk_widget_get_parent((GtkWidget*)text_view);
	37	widget = gtk_widget_get_parent(widget);
	38	gtk_custom_set_focus((GtkWidget*)custom, (gpointer)widget);
	39	}
	40
	41	void
	42	insertViewTest(GtkMenuItem *menuitem, gpointer user_data)
	43	{
	44	guint val = 20;
37d0eca6	45	insertView((GtkWidget*)menuitem, (view_constructor)user_data);
37d0eca6	46	// selected_hook(&val);
561eba2a	47	}
	48
	49	void
	50	on_insert_viewer_test_activate (GtkMenuItem *menuitem,
	51	gpointer user_data)
	52	{
	53	GtkWidget scrolledwindow1, textview1, *label;
	54	static int count = 0;
	55	char str[64];
	56	GtkCustom * custom;
	57	GtkTextBuffer* buf;
	58
	59	mainWindow * mwData;
	60	mwData = get_window_data_struct((GtkWidget*)menuitem);
	61	if(!mwData->CurrentTab) return;
	62	custom = mwData->CurrentTab->custom;
	63
	64	sprintf(str,"label : %d",++count);
	65	scrolledwindow1 = gtk_scrolled_window_new (NULL, NULL);
	66	gtk_widget_show (scrolledwindow1);
	67	label = gtk_label_new(str);
	68	gtk_widget_show(label);
	69
	70	gtk_custom_widget_add(custom, scrolledwindow1);
	71	gtk_widget_set_size_request ((GtkWidget*)scrolledwindow1, 800, 100);
	72
	73	textview1 = gtk_text_view_new ();
	74	gtk_widget_show (textview1);
	75	gtk_container_add (GTK_CONTAINER (scrolledwindow1), textview1);
	76	buf = gtk_text_view_get_buffer((GtkTextView*)textview1);
	77	sprintf(str,"text view : %d",count);
	78	gtk_text_buffer_set_text(buf,str, -1);
	79
	80	g_signal_connect ((gpointer) textview1, "grab_focus",
	81	G_CALLBACK (on_textview1_grab_focus), custom);
	82	}
	83
	84	/* end of test part */
	85
	86
	87	/* internal functions */
	88	void insertView(GtkWidget* widget, view_constructor constructor)
	89	{
	90	GtkCustom * custom;
	91	mainWindow * mwData;
f9334f6f	92	GtkWidget * viewer;
561eba2a	93
	94	mwData = get_window_data_struct(widget);
	95	if(!mwData->CurrentTab) return;
	96	custom = mwData->CurrentTab->custom;
	97
f9334f6f	98	viewer = (GtkWidget*)constructor(mwData);
f9334f6f	99	if(viewer)
f0d936c0	100	{
	101	gtk_custom_widget_add(custom, viewer);
	102	// Added by MD
8af8e4c5	103	// g_object_unref(G_OBJECT(viewer));
f0d936c0	104	}
561eba2a	105	}
	106
	107	void get_label_string (GtkWidget * text, gchar * label)
	108	{
	109	GtkEntry * entry = (GtkEntry*)text;
	110	if(strlen(gtk_entry_get_text(entry))!=0)
	111	strcpy(label,gtk_entry_get_text(entry));
	112	}
	113
6b1d3120	114	void get_label(GtkWindow * mw, gchar * str, gchar* dialogue_title, gchar * label_str)
561eba2a	115	{
	116	GtkWidget * dialogue;
	117	GtkWidget * text;
	118	GtkWidget * label;
	119	gint id;
	120
6b1d3120	121	dialogue = gtk_dialog_new_with_buttons(dialogue_title,mw,
561eba2a	122	GTK_DIALOG_MODAL,
	123	GTK_STOCK_OK,GTK_RESPONSE_ACCEPT,
	124	GTK_STOCK_CANCEL,GTK_RESPONSE_REJECT,
	125	NULL);
	126
6b1d3120	127	label = gtk_label_new(label_str);
561eba2a	128	gtk_widget_show(label);
	129
	130	text = gtk_entry_new();
	131	gtk_widget_show(text);
	132
	133	gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialogue)->vbox), label,TRUE, TRUE,0);
	134	gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialogue)->vbox), text,FALSE, FALSE,0);
	135
	136	id = gtk_dialog_run(GTK_DIALOG(dialogue));
	137	switch(id){
	138	case GTK_RESPONSE_ACCEPT:
	139	get_label_string(text,str);
	140	gtk_widget_destroy(dialogue);
	141	break;
	142	case GTK_RESPONSE_REJECT:
	143	default:
	144	gtk_widget_destroy(dialogue);
	145	break;
	146	}
	147	}
	148
	149	mainWindow * get_window_data_struct(GtkWidget * widget)
	150	{
	151	GtkWidget * mw;
	152	mainWindow * mwData;
	153
	154	mw = lookup_widget(widget, "MWindow");
	155	if(mw == NULL){
	156	g_printf("Main window does not exist\n");
	157	return;
	158	}
	159
	160	mwData = (mainWindow *) g_object_get_data(G_OBJECT(mw),"mainWindow");
	161	if(mwData == NULL){
	162	g_printf("Main window data does not exist\n");
	163	return;
	164	}
	165	return mwData;
	166	}
	167
	168	void createNewWindow(GtkWidget* widget, gpointer user_data, gboolean clone)
	169	{
	170	GtkWidget * mw = NULL; /* Main window */
	171	systemView * sv = NULL; /* System view */
	172	systemView * newSv; /* New system view displayed in the new window */
	173	GtkWidget * newWindow; /* New generated main window */
	174	mainWindow * newMWindow;/* New main window structure */
	175
	176	//test
37d0eca6	177	int i;
	178	GtkWidget * ToolMenuTitle_menu, insert_view, pixmap;
	179	LttvMenus * menu;
	180	LttvToolbars * toolbar;
	181	lttv_menu_closure *menuItem;
	182	lttv_toolbar_closure *toolbarItem;
	183	LttvAttributeValue value;
	184	LttvIAttribute *attributes = LTTV_IATTRIBUTE(lttv_global_attributes());
	185	view_constructor constructor;
	186	GdkPixbuf *pixbuf;
561eba2a	187	//end
	188
	189	mw = lookup_widget (widget, "MWindow");
	190	if(mw == NULL){
	191	g_printf("Can not find main window\n");
	192	return;
	193	}
	194
	195	sv = (systemView *)g_object_get_data(G_OBJECT(mw),"systemView");
	196	if(sv == NULL){
	197	g_printf("Can not find system view\n");
	198	return;
	199	}
	200
	201	newMWindow = g_new(mainWindow, 1);
ec25ff5e	202
	203	/* Add the object's information to the module's array */
	204	Main_Window_List = g_slist_append(Main_Window_List, mw);
	205
561eba2a	206	newWindow = create_MWindow();
	207	gtk_widget_show (newWindow);
	208
	209
	210	newSv = g_new(systemView, 1);
	211	while(sv->Next) sv = sv->Next;
	212	sv->Next = newSv;
	213
	214	newSv->EventDB = NULL;
	215	newSv->SystemInfo = NULL;
	216	newSv->Options = NULL;
	217	newSv->Next = NULL;
	218	newSv->Window = newMWindow;
	219
	220	newMWindow->MWindow = newWindow;
	221	newMWindow->Tab = NULL;
	222	newMWindow->CurrentTab = NULL;
	223	newMWindow->SystemView = newSv;
ec25ff5e	224	newMWindow->Attributes = LTTV_IATTRIBUTE(g_object_new(LTTV_ATTRIBUTE_TYPE, NULL));
	225	newMWindow->traceset_context = LTTV_TRACESET_CONTEXT(gTracesetContext);
	226	newMWindow->traceset = (LTTV_TRACESET_CONTEXT(gTracesetContext))->ts;
	227	g_object_ref(gTracesetContext);
561eba2a	228
561eba2a	229	//test yxx
37d0eca6	230	g_assert(lttv_iattribute_find_by_path(attributes,
	231	"viewers/menu", LTTV_POINTER, &value));
	232	menu = (LttvMenus)(value.v_pointer);
	233
	234	if(menu){
	235	for(i=0;i<menu->len;i++){
	236	menuItem = &g_array_index(menu, lttv_menu_closure, i);
	237	constructor = menuItem->con;
	238	ToolMenuTitle_menu = lookup_widget(newMWindow->MWindow,"ToolMenuTitle_menu");
	239	insert_view = gtk_menu_item_new_with_mnemonic (menuItem->menuText);
	240	gtk_widget_show (insert_view);
	241	gtk_container_add (GTK_CONTAINER (ToolMenuTitle_menu), insert_view);
	242	g_signal_connect ((gpointer) insert_view, "activate",
	243	G_CALLBACK (insertViewTest),
	244	constructor);
	245	}
	246	}
	247	g_assert(lttv_iattribute_find_by_path(attributes,
	248	"viewers/toolbar", LTTV_POINTER, &value));
	249	toolbar = (LttvToolbars)(value.v_pointer);
	250
	251	if(toolbar){
	252	for(i=0;i<toolbar->len;i++){
	253	toolbarItem = &g_array_index(toolbar, lttv_toolbar_closure, i);
	254	constructor = toolbarItem->con;
	255	ToolMenuTitle_menu = lookup_widget(newMWindow->MWindow,"MToolbar2");
	256	pixbuf = gdk_pixbuf_new_from_xpm_data ((const char**)toolbarItem->pixmap);
	257	pixmap = gtk_image_new_from_pixbuf(pixbuf);
	258	insert_view = gtk_toolbar_append_element (GTK_TOOLBAR (ToolMenuTitle_menu),
	259	GTK_TOOLBAR_CHILD_BUTTON,
	260	NULL,
	261	"",
	262	toolbarItem->tooltip, NULL,
	263	pixmap, NULL, NULL);
	264	gtk_label_set_use_underline (GTK_LABEL (((GtkToolbarChild*) (g_list_last (GTK_TOOLBAR (ToolMenuTitle_menu)->children)->data))->label), TRUE);
	265	gtk_widget_show (insert_view);
	266	gtk_container_set_border_width (GTK_CONTAINER (insert_view), 1);
	267	g_signal_connect ((gpointer) insert_view, "clicked",G_CALLBACK (insertViewTest),constructor);
	268	}
	269	}
561eba2a	270	//end
	271
	272	g_object_set_data(G_OBJECT(newWindow), "systemView", (gpointer)newSv);
	273	g_object_set_data(G_OBJECT(newWindow), "mainWindow", (gpointer)newMWindow);
	274
	275	if(clone){
	276	g_printf("Clone : use the same traceset\n");
	277	}else{
	278	g_printf("Empty : traceset is set to NULL\n");
	279	}
	280	}
	281
	282	void move_up_viewer(GtkWidget * widget, gpointer user_data)
	283	{
	284	mainWindow * mw = get_window_data_struct(widget);
	285	if(!mw->CurrentTab) return;
	286	gtk_custom_widget_move_up(mw->CurrentTab->custom);
	287	}
	288
	289	void move_down_viewer(GtkWidget * widget, gpointer user_data)
	290	{
	291	mainWindow * mw = get_window_data_struct(widget);
	292	if(!mw->CurrentTab) return;
	293	gtk_custom_widget_move_down(mw->CurrentTab->custom);
	294	}
	295
	296	void delete_viewer(GtkWidget * widget, gpointer user_data)
	297	{
	298	mainWindow * mw = get_window_data_struct(widget);
	299	if(!mw->CurrentTab) return;
	300	gtk_custom_widget_delete(mw->CurrentTab->custom);
	301	}
	302
	303	void open_traceset(GtkWidget * widget, gpointer user_data)
	304	{
	305	g_printf("Open a trace set\n");
	306	}
	307
	308	void add_trace(GtkWidget * widget, gpointer user_data)
	309	{
	310	g_printf("add a trace to a trace set\n");
	311	}
	312
	313	void remove_trace(GtkWidget * widget, gpointer user_data)
	314	{
	315	g_printf("remove a trace from a trace set\n");
	316	}
	317
	318	void save(GtkWidget * widget, gpointer user_data)
	319	{
	320	g_printf("Save\n");
	321	}
	322
	323	void save_as(GtkWidget * widget, gpointer user_data)
	324	{
	325	g_printf("Save as\n");
	326	}
	327
	328	void zoom_in(GtkWidget * widget, gpointer user_data)
	329	{
	330	g_printf("Zoom in\n");
	331	}
	332
	333	void zoom_out(GtkWidget * widget, gpointer user_data)
334	{
335	g_printf("Zoom out\n");
336	}
337
338	void zoom_extended(GtkWidget * widget, gpointer user_data)
339	{
340	g_printf("Zoom extended\n");
341	}
342
343	void go_to_time(GtkWidget * widget, gpointer user_data)
344	{
345	g_printf("Go to time\n");
346	}
347
348	void show_time_frame(GtkWidget * widget, gpointer user_data)
349	{
350	g_printf("Show time frame\n");
351	}
352
353
354	/* callback function */
355
356	void
357	on_empty_traceset_activate (GtkMenuItem *menuitem,
358	gpointer user_data)
359	{
360	createNewWindow((GtkWidget*)menuitem, user_data, FALSE);
361	}
362
363
364	void
365	on_clone_traceset_activate (GtkMenuItem *menuitem,
366	gpointer user_data)
367	{
368	createNewWindow((GtkWidget*)menuitem, user_data, TRUE);
369	}
370
371
372	void
373	on_tab_activate (GtkMenuItem *menuitem,
374	gpointer user_data)
375	{
376	GList * list;
6b1d3120	377	gchar label[PATH_LENGTH];
561eba2a	378
	379	tab * tmpTab;
	380	GtkWidget * pane;
	381	mainWindow * mwData;
	382	GtkNotebook * notebook = (GtkNotebook )lookup_widget((GtkWidget)menuitem, "MNotebook");
	383	if(notebook == NULL){
	384	g_printf("Notebook does not exist\n");
	385	return;
	386	}
	387
	388	mwData = get_window_data_struct((GtkWidget*)menuitem);
	389
	390	tmpTab = mwData->Tab;
	391	while(tmpTab && tmpTab->Next) tmpTab = tmpTab->Next;
	392	if(!tmpTab){
ec25ff5e	393	mwData->CurrentTab = NULL;
561eba2a	394	tmpTab = g_new(tab,1);
ec25ff5e	395	mwData->Tab = tmpTab;
561eba2a	396	}else{
	397	tmpTab->Next = g_new(tab,1);
	398	tmpTab = tmpTab->Next;
	399	}
ec25ff5e	400	if(mwData->CurrentTab){
	401	tmpTab->traceStartTime = mwData->CurrentTab->traceStartTime;
	402	tmpTab->traceEndTime = mwData->CurrentTab->traceEndTime;
	403	tmpTab->startTime = mwData->CurrentTab->startTime;
	404	tmpTab->endTime = mwData->CurrentTab->endTime;
	405	tmpTab->currentTime = mwData->CurrentTab->currentTime;
58960b51	406	}else{
	407	getTracesetTimeSpan(mwData,&tmpTab->traceStartTime, &tmpTab->traceEndTime);
	408	tmpTab->startTime = tmpTab->traceStartTime;
	409	tmpTab->endTime = tmpTab->traceEndTime;
	410	tmpTab->currentTime = tmpTab->traceStartTime;
ec25ff5e	411	}
ec25ff5e	412	tmpTab->Attributes = LTTV_IATTRIBUTE(g_object_new(LTTV_ATTRIBUTE_TYPE, NULL));
561eba2a	413	// mwData->CurrentTab = tmpTab;
561eba2a	414	tmpTab->custom = (GtkCustom*)gtk_custom_new();
58960b51	415	tmpTab->custom->mw = mwData;
561eba2a	416	gtk_widget_show((GtkWidget*)tmpTab->custom);
	417	tmpTab->Next = NULL;
	418
6b1d3120	419	strcpy(label,"Page");
6b1d3120	420	get_label((GtkWindow*)mwData->MWindow, label,"Get the name of the tab","Please input tab's name");
561eba2a	421	tmpTab->label = gtk_label_new (label);
	422	gtk_widget_show (tmpTab->label);
	423
	424	gtk_notebook_append_page(notebook, (GtkWidget*)tmpTab->custom, tmpTab->label);
	425
	426	list = gtk_container_get_children(GTK_CONTAINER(notebook));
	427	gtk_notebook_set_current_page(notebook,g_list_length(list)-1);
	428	}
	429
	430
	431	void
	432	on_open_activate (GtkMenuItem *menuitem,
	433	gpointer user_data)
	434	{
	435	open_traceset((GtkWidget*)menuitem, user_data);
	436	}
	437
	438
	439	void
	440	on_close_activate (GtkMenuItem *menuitem,
	441	gpointer user_data)
	442	{
	443	g_printf("Close\n");
	444	}
	445
	446
	447	void
	448	on_close_tab_activate (GtkMenuItem *menuitem,
	449	gpointer user_data)
	450	{
	451	g_printf("Close tab\n");
	452	}
	453
	454
	455	void
	456	on_add_trace_activate (GtkMenuItem *menuitem,
	457	gpointer user_data)
	458	{
	459	add_trace((GtkWidget*)menuitem, user_data);
	460	}
	461
	462
	463	void
	464	on_remove_trace_activate (GtkMenuItem *menuitem,
	465	gpointer user_data)
	466	{
	467	remove_trace((GtkWidget*)menuitem, user_data);
	468	}
	469
	470
	471	void
	472	on_save_activate (GtkMenuItem *menuitem,
	473	gpointer user_data)
	474	{
	475	save((GtkWidget*)menuitem, user_data);
	476	}
	477
	478
	479	void
	480	on_save_as_activate (GtkMenuItem *menuitem,
	481	gpointer user_data)
	482	{
	483	save_as((GtkWidget*)menuitem, user_data);
	484	}
485
486
487	void
488	on_quit_activate (GtkMenuItem *menuitem,
489	gpointer user_data)
490	{
491	on_MWindow_destroy(GTK_OBJECT(menuitem), user_data);
492	}
493
494
495	void
496	on_cut_activate (GtkMenuItem *menuitem,
497	gpointer user_data)
498	{
499	g_printf("Cut\n");
500	}
501
502
503	void
504	on_copy_activate (GtkMenuItem *menuitem,
505	gpointer user_data)
506	{
507	g_printf("Copye\n");
508	}
509
510
511	void
512	on_paste_activate (GtkMenuItem *menuitem,
513	gpointer user_data)
514	{
515	g_printf("Paste\n");
516	}
517
518
519	void
520	on_delete_activate (GtkMenuItem *menuitem,
521	gpointer user_data)
522	{
523	g_printf("Delete\n");
524	}
525
526
527	void
528	on_zoom_in_activate (GtkMenuItem *menuitem,
529	gpointer user_data)
530	{
531	zoom_in((GtkWidget*)menuitem, user_data);
532	}
533
534
535	void
536	on_zoom_out_activate (GtkMenuItem *menuitem,
537	gpointer user_data)
538	{
539	zoom_out((GtkWidget*)menuitem, user_data);
540	}
541
542
543	void
544	on_zoom_extended_activate (GtkMenuItem *menuitem,
545	gpointer user_data)
546	{
547	zoom_extended((GtkWidget*)menuitem, user_data);
548	}
549
550
551	void
552	on_go_to_time_activate (GtkMenuItem *menuitem,
553	gpointer user_data)
554	{
555	go_to_time((GtkWidget*)menuitem, user_data);
556	}
557
558
559	void
560	on_show_time_frame_activate (GtkMenuItem *menuitem,
561	gpointer user_data)
562	{
563	show_time_frame((GtkWidget*)menuitem, user_data);
564	}
565
566
567	void
568	on_move_viewer_up_activate (GtkMenuItem *menuitem,
569	gpointer user_data)
570	{
571	move_up_viewer((GtkWidget*)menuitem, user_data);
572	}
573
574
575	void
576	on_move_viewer_down_activate (GtkMenuItem *menuitem,
577	gpointer user_data)
578	{
579	move_down_viewer((GtkWidget*)menuitem, user_data);
580	}
581
582
583	void
584	on_remove_viewer_activate (GtkMenuItem *menuitem,
585	gpointer user_data)
586	{
587	delete_viewer((GtkWidget*)menuitem, user_data);
588	}
589
590
591	void
592	on_load_module_activate (GtkMenuItem *menuitem,
593	gpointer user_data)
594	{
595	g_printf("Load module\n");
596	}
597
598
599	void
600	on_unload_module_activate (GtkMenuItem *menuitem,
601	gpointer user_data)
602	{
603	g_printf("Unload module\n");
604	}
605
606
607	void
608	on_add_module_search_path_activate (GtkMenuItem *menuitem,
609	gpointer user_data)
610	{
6b1d3120	611	gchar str[PATH_LENGTH];
6b1d3120	612	mainWindow * mwData = get_window_data_struct((GtkWidget*)menuitem);
561eba2a	613	g_printf("Add module search path\n");
6b1d3120	614	str[0] = '\0';
	615	get_label((GtkWindow*)mwData->MWindow, str, "Add module search path", "Please input a search path:");
	616	if(strlen(str)){
	617	lttv_module_path_add(str);
	618	}
561eba2a	619	}
	620
	621
	622	void
	623	on_color_activate (GtkMenuItem *menuitem,
	624	gpointer user_data)
	625	{
	626	g_printf("Color\n");
	627	}
	628
	629
	630	void
	631	on_filter_activate (GtkMenuItem *menuitem,
	632	gpointer user_data)
	633	{
	634	g_printf("Filter\n");
	635	}
	636
	637
	638	void
	639	on_save_configuration_activate (GtkMenuItem *menuitem,
	640	gpointer user_data)
	641	{
	642	g_printf("Save configuration\n");
	643	}
	644
	645
	646	void
	647	on_content_activate (GtkMenuItem *menuitem,
	648	gpointer user_data)
	649	{
	650	g_printf("Content\n");
	651	}
	652
	653
	654	void
	655	on_about_activate (GtkMenuItem *menuitem,
	656	gpointer user_data)
	657	{
	658	g_printf("About...\n");
	659	}
	660
	661
	662	void
	663	on_button_new_clicked (GtkButton *button,
	664	gpointer user_data)
	665	{
	666	createNewWindow((GtkWidget*)button, user_data, FALSE);
	667	}
	668
	669
	670	void
	671	on_button_open_clicked (GtkButton *button,
	672	gpointer user_data)
	673	{
	674	open_traceset((GtkWidget*)button, user_data);
	675	}
	676
	677
	678	void
	679	on_button_add_trace_clicked (GtkButton *button,
	680	gpointer user_data)
	681	{
	682	add_trace((GtkWidget*)button, user_data);
683	}
684
685
686	void
687	on_button_remove_trace_clicked (GtkButton *button,
688	gpointer user_data)
689	{
690	remove_trace((GtkWidget*)button, user_data);
691	}
692
693
694	void
695	on_button_save_clicked (GtkButton *button,
696	gpointer user_data)
697	{
698	save((GtkWidget*)button, user_data);
699	}
700
701
702	void
703	on_button_save_as_clicked (GtkButton *button,
704	gpointer user_data)
705	{
706	save_as((GtkWidget*)button, user_data);
707	}
708
709
710	void
711	on_button_zoom_in_clicked (GtkButton *button,
712	gpointer user_data)
713	{
714	zoom_in((GtkWidget*)button, user_data);
715	}
716
717
718	void
719	on_button_zoom_out_clicked (GtkButton *button,
720	gpointer user_data)
721	{
722	zoom_out((GtkWidget*)button, user_data);
723	}
724
725
726	void
727	on_button_zoom_extended_clicked (GtkButton *button,
728	gpointer user_data)
729	{
730	zoom_extended((GtkWidget*)button, user_data);
731	}
732
733
734	void
735	on_button_go_to_time_clicked (GtkButton *button,
736	gpointer user_data)
737	{
738	go_to_time((GtkWidget*)button, user_data);
739	}
740
741
742	void
743	on_button_show_time_frame_clicked (GtkButton *button,
744	gpointer user_data)
745	{
746	show_time_frame((GtkWidget*)button, user_data);
747	}
748
749
750	void
751	on_button_move_up_clicked (GtkButton *button,
752	gpointer user_data)
753	{
754	move_up_viewer((GtkWidget*)button, user_data);
755	}
756
757
758	void
759	on_button_move_down_clicked (GtkButton *button,
760	gpointer user_data)
761	{
762	move_down_viewer((GtkWidget*)button, user_data);
763	}
764
765
766	void
767	on_button_delete_viewer_clicked (GtkButton *button,
768	gpointer user_data)
769	{
770	delete_viewer((GtkWidget*)button, user_data);
771	}
772
773	void
774	on_MWindow_destroy (GtkObject *object,
775	gpointer user_data)
776	{
777	systemView * sv = gSysView;
778	gint count = 0;
779	while(sv->Next){
780	g_printf("There are : %d windows\n",++count);
781	sv = sv->Next;
782	}
783	g_printf("There are : %d windows\n",++count);
784
785	gtk_main_quit ();
786
787	}
788
789
790	void
791	on_MNotebook_switch_page (GtkNotebook *notebook,
792	GtkNotebookPage *page,
793	guint page_num,
794	gpointer user_data)
795	{
796	mainWindow * mw = get_window_data_struct((GtkWidget*)notebook);
797	tab * Tab = mw->Tab;
798
799	while(page_num){
800	Tab = Tab->Next;
801	page_num--;
802	}
803	mw->CurrentTab = Tab;
804	}
805