/* make file  */
CC = cc

CFLAGS = -Wall -g `pkg-config --cflags --libs gtk+-2.0`



all: 
	$(MAKE) main



main: mynotebook.c  main.c mynotebook.h
	$(CC) $(CFLAGS) $@.c mynotebook.c -o $@


clean:

	rm -f main


/* main file */
#include "mynotebook.h"
#include <gtk/gtk.h>

void destroy(GtkWidget * window, gpointer data)
{
	g_print ("\nIn destroy\n");
	gtk_main_quit();
}

gboolean delete_event(GtkWidget *widget ,GdkEvent *event, gpointer data)
{
	g_print ("\ndelete event occured\n");
	return FALSE;
}
 
int main(int argc,char* argv[] )
{
	GtkWidget *window;
	GtkWidget *my_notebook;
	GtkWidget *vbox;
	GtkWidget *label, *tab;

   	gtk_init(&argc,&argv);
  	
	window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
	gtk_window_set_title(GTK_WINDOW(window),"Media Player");
	gtk_window_set_position(GTK_WINDOW(window),GTK_WIN_POS_CENTER);
	gtk_window_set_default_size(GTK_WINDOW(window),900,500);
	
	 
	my_notebook = my_notebook_new ();
	gtk_notebook_set_tab_pos (GTK_NOTEBOOK (my_notebook), GTK_POS_TOP);
	gtk_widget_show_all(my_notebook);

	vbox = gtk_vbox_new (FALSE, 0); 
	gtk_box_pack_start (GTK_BOX (vbox), my_notebook, TRUE, TRUE, 0);

	gtk_container_add (GTK_CONTAINER (window), vbox);
	gtk_widget_show_all(vbox);
 	g_signal_connect(GTK_OBJECT(window),"delete_event",G_CALLBACK(delete_event),NULL);
	g_signal_connect(GTK_OBJECT(window),"destroy",G_CALLBACK(destroy),NULL);
	gtk_widget_show_all(window);
 
	gtk_main();
	return 0;
}

/* mynotebook.h*/
#ifndef  _MYNOTEBOOK_H_
#define _MYNOTEBOOK_H_

#include <glib.h>
#include <glib-object.h>
#include <gtk/gtknotebook.h>

G_BEGIN_DECLS
#define MY_NOTEBOOK_TYPE            (my_notebook_get_type ())
#define MY_NOTEBOOK(obj)              (G_TYPE_CHECK_INSTANCE_CAST ((obj), MY_NOTEBOOK_TYPE, MyNotebook))
#define MY_NOTEBOOK_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), MY_NOTEBOOK_TYPE, MyNotebookClass))
#define IS_MY_NOTEBOOK(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MY_NOTEBOOK_TYPE))
#define IS_MY_NOTEBOOK_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MY_NOTEBOOK_TYPE))

typedef struct _MyNotebook        MyNotebook;
typedef struct _MyNotebookClass   MyNotebookClass;
 
struct _MyNotebook 
{
  GtkNotebook  notebook;
};

struct _MyNotebookClass
{
  GtkNotebookClass parent_class;
};

GType      my_notebook_get_type (void) G_GNUC_CONST;
GtkWidget* my_notebook_new     (void);

void   my_notebook_set_tabs (MyNotebook *notebook,  const gchar *tab_label);
//gchar* my_notebook_get_tabs (MyNotebook *notebook);

G_END_DECLS

#endif /*__MYNOTEBOOK_H__*/
/* mynotebook.c*/
#include "mynotebook.h"
#include <glib.h>
#include <gdk/gdk.h>
#include <gtk/gtk.h>

#define MY_NOTEBOOK_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj),  MY_NOTEBOOK_TYPE, MyNotebookPrivate)) 

static void my_notebook_class_init (MyNotebookClass*);
static void my_notebook_init (MyNotebook *notebook);
static void my_notebook_get_property (GObject*, guint, GValue*, GParamSpec*);
static void my_notebook_set_property (GObject*, guint, 
                         				    const GValue*, GParamSpec*);

static void my_notebook_render (MyNotebook*);
typedef struct _MyNotebookPrivate  MyNotebookPrivate;

struct _MyNotebookPrivate 
{
  gchar* tabs[1];
};

enum
{
  PROP_TAB1 =1,
  PROP_TAB2
};

enum
{
  PROP_PLAYLIST = 1,
  PROP_PLAYER
};


/* Get a GType that corresponds to MyNotebook. The first time this function is
 * called (on object instantiation), the type is registered. */
GType
my_notebook_get_type (void)
{
  static GType   notebook_type = 0;

  if (!notebook_type)
  {
    static const GTypeInfo notebook_info =
    {
      sizeof (MyNotebookClass),
      NULL, 
      NULL,
      (GClassInitFunc) my_notebook_class_init,
      NULL, 
      NULL,
      sizeof (MyNotebook),
      0,
      (GInstanceInitFunc) my_notebook_init,
    };

     notebook_type = g_type_register_static (GTK_TYPE_NOTEBOOK, "MyNotebook", 
                                         & notebook_info, 0);
  }

  return notebook_type;
}

static void
my_notebook_class_init (MyNotebookClass *klass)
{
   GObjectClass *gobject_class;
   GtkWidgetClass *widget_class;

   gobject_class = (GObjectClass*) klass;
   widget_class = (GtkWidgetClass*) klass;

   /* Override the standard functions for setting and retrieving properties. */
   gobject_class->set_property = my_notebook_set_property;
   gobject_class->get_property = my_notebook_get_property;

    /* Add MyMarqueePrivate as a private data class of MyNotebookClass. */
  g_type_class_add_private (klass, sizeof (MyNotebookPrivate));
  
  /* Register four GObject properties, the message and the speed. */
  g_object_class_install_property (gobject_class, PROP_PLAYLIST,

              g_param_spec_string ("library",

                                   "playlist_library",

                                   "It is playlist library frame",
                                   " ",

                                   G_PARAM_READWRITE));
  
  g_object_class_install_property (gobject_class, PROP_PLAYER,

                 g_param_spec_string ("player",

                                   "player_frame",

                                   "It is player frame",
                                   " ",

                                   G_PARAM_READWRITE));

}

static void 
my_notebook_init (MyNotebook* notebook)
{
	MyNotebookPrivate *priv = MY_NOTEBOOK_GET_PRIVATE (notebook);
 	PangoFontDescription *fd;

	 priv->tabs[0] = "Library";
         priv->tabs[1]= "Player";

	fd = pango_font_description_from_string ("Monospace");
        gtk_widget_modify_font (GTK_WIDGET (notebook), fd);
     	pango_font_description_free (fd);
}

static void
my_notebook_set_property (GObject *object,
                         guint prop_id,
                         const GValue *value,
                         GParamSpec *pspec)
{
	 MyNotebook  *notebook  =  MY_NOTEBOOK (object);
	 

	  switch (prop_id)
	  {
	    case PROP_PLAYLIST:
		my_notebook_set_tabs (notebook, g_value_get_string (value));
		break;	
	    case PROP_PLAYER:
		my_notebook_set_tabs (notebook, g_value_get_string (value));
	      break;
	    default:
	      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
	      break;
	  }
}

/* This function is called when the programmer requests the value of a widget
 * property with g_object_get(). */
static void
my_notebook_get_property (GObject *object,
                         guint prop_id,
                         GValue *value,
                         GParamSpec *pspec)
{

   MyNotebook  *notebook  =  MY_NOTEBOOK (object);
   MyNotebookPrivate *priv = MY_NOTEBOOK_GET_PRIVATE (notebook);

  switch (prop_id)
  {
    case PROP_PLAYLIST:
	my_notebook_set_tabs (notebook, g_value_get_string (value));
	break;	
    case PROP_PLAYER:
	my_notebook_set_tabs (notebook, g_value_get_string (value));
      break;
    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
      break;
  }
}

void   
my_notebook_set_tabs (MyNotebook *notebook,  const gchar *tab_label)
{
	MyNotebookPrivate *priv = MY_NOTEBOOK_GET_PRIVATE (notebook);
	static gint i = 0;
	GtkWidget *frame = NULL;
	frame = gtk_frame_new("Frame"); 
  	GtkWidget *label  = gtk_label_new ("tab2");
 	gtk_notebook_append_page (GTK_NOTEBOOK((g_object_new (my_notebook_get_type (), NULL))),frame,label);
	/*  priv->tabs[i] = g_strdup (tab_label);*/
	if(i == 1)
	{
  	 my_notebook_render (notebook);
	}
	i++;
}

/*gchar* 
my_notebook_get_tabs (MyNotebook *notebook)
{
	
}
*/

static void my_notebook_render (MyNotebook* notebook)
{
		/*GtkWidget *fixed = NULL;
		GtkWidget *hbox = NULL;
		GtkWidget *label = NULL;
		GtkWidget *entry = NULL;

		label = gtk_label_new ("Search");
		entry = gtk_entry_new_with_max_length (20);
		hbox = gtk_hbox_new (FALSE, 0);
		
		fixed= gtk_fixed_new();
 		gtk_fixed_put (GTK_FIXED(fixed),GTK_WIDGET(notebook),0,0);
 		gtk_fixed_put (GTK_FIXED(fixed),hbox,100,0);
		gtk_widget_show_all(fixed);*/
}

/* Create and return a new instance of the MyNotebook widget. */
GtkWidget*
my_notebook_new ()
{
		/*GtkWidget *fixed = NULL;
		GtkWidget *hbox = NULL;
		GtkWidget *label = NULL;
		GtkWidget *entry = NULL;

		label = gtk_label_new ("Search");
		entry = gtk_entry_new_with_max_length (20);
		hbox = gtk_hbox_new (FALSE, 0);
		
		fixed= gtk_fixed_new();
 		gtk_fixed_put (GTK_FIXED(fixed),hbox,100,0);
		gtk_widget_show_all(hbox);*/

	return GTK_WIDGET (g_object_new (my_notebook_get_type (), NULL));
}