/**
 * [15821] Team CODA
 * File Manager
 * By Sang Kil Cha, Jaeyoon Chong, Anoop Jaishankar
 */

#include <hildon/hildon-program.h>
#include <hildon/hildon-file-selection.h>
#include <hildon/hildon-banner.h>
#include <hildon/hildon-file-details-dialog.h>
#include <hildon/hildon-file-chooser-dialog.h>
#include <hildon/hildon-file-system-model.h>

#include "fine_fm.h"
#include <gtk/gtk.h>
#include <glib/gstdio.h>
#include <glib/gprintf.h>

#include <libogs/ogs.h>

#include <stdlib.h>
#include <limits.h>
#include <errno.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/wait.h>
#include <fcntl.h>
#include <unistd.h>

#define RM_PROGRAM "/bin/rm"

struct _HildonFileChooserDialogPrivate {
    GtkWidget *action_button;
    GtkWidget *folder_button;
    GtkWidget *cancel_button;
    HildonFileSelection *filetree;
    HildonFileSystemModel *model;
    GtkSizeGroup *caption_size_group;
    GtkWidget *caption_control_name;
    GtkWidget *caption_control_location;
    GtkWidget *entry_name;
    GtkWidget *eventbox_location;
    GtkWidget *hbox_location, *image_location, *title_location;
    GtkWidget *extensions_combo;
    GtkFileChooserAction action;
    GtkWidget *popup;
    GtkWidget *multiple_label, *hbox_items;
    gulong changed_handler;
    gint max_full_path_length;
    gint max_filename_length;
    gboolean popup_protect;
    GtkFileSystemHandle *create_folder_handle;

    /* Popup menu contents */
    GtkWidget *sort_type, *sort_name, *sort_date, *sort_size;

    GtkWidget *mode_list, *mode_thumbnails;
    GSList *filters;
    GtkWidget *filters_separator;
    GSList *filter_menu_items;
    GSList * filter_item_menu_toggle_handlers;

    gchar *stub_name;   /* Set by call to set_current_name */
    gchar *ext_name;
    gboolean autonaming_enabled;
    gboolean edited;
    gboolean should_show_folder_button;
    gboolean should_show_location;
    gboolean show_upnp;
};

/* Application UI data struct */
typedef struct _AppData AppData;
struct _AppData {
	HildonProgram *program;
	HildonWindow *window;
	
	GtkWidget * main_vbox;
	GtkWidget * main_file_selection;
	GtkWidget * top_entry;
	
	GtkWidget * bottom_toolbar;
	GtkToolItem * bottom_btn_find;
	GtkToolItem * bottom_btn_newfolder;
	GtkToolItem * bottom_btn_movefile;
	GtkToolItem * bottom_btn_info;
	GtkToolItem * bottom_btn_delete;
	GtkToolItem * bottom_btn_refresh;
	GtkToolItem * bottom_separator;
	GtkToolItem * bottom_btn_about;
	GtkToolItem * bottom_btn_listview;
	GtkToolItem * bottom_btn_thumbview;

	GtkTooltips * tooltips;
	
	HildonFileSystemModel *hildon_model;
	
	/* Menu stuff */
	GtkMenu   * main_menu;
	GtkMenu   * context_menu;
	/* Menu Items */
	GtkWidget * menu_item_file;
	GtkWidget * menu_item_edit;
	GtkWidget * menu_item_view;
	GtkWidget * menu_item_configure;
	GtkWidget * menu_item_rename;
	GtkWidget * menu_item_del;
	GtkWidget * menu_item_info;
	GtkWidget * menu_item_quit;

	/* full screen */
	gboolean fullscreen;
};

void cb_configure (GtkWidget * w, AppData * data) 
{
}

/* rename callback */
void cb_rename (GtkWidget * w, AppData * data) 
{
	GtkWidget *dialog;
	GtkWidget *entry;
	GSList *list;
	gchar *uri;
	gint result, length;
	GtkFileSystem *backend;
	GtkFilePath *file_path;
	gchar *filename, *dirname;
	const gchar *tmp;
	gchar *final;

	list = hildon_file_selection_get_selected_uris( HILDON_FILE_SELECTION(data->main_file_selection) );
	uri = g_slist_nth_data(list, 0);
	if(uri == NULL)
		return;
	backend = _hildon_file_system_model_get_file_system(data->hildon_model);
	file_path = gtk_file_system_uri_to_path(backend, uri);
	filename = gtk_file_system_path_to_filename(backend, file_path);

	/* delete direcoty from the filename path */
	char *slash;
	slash = strrchr( filename, '/');
	slash ++; /* removing '/' */

	length = slash - filename;
	dirname = g_malloc(length+1);
	if(dirname == 0){
		g_print("Rename memory alloc, error\n");
		return;
	}	
	strncpy( dirname, filename, length);
	dirname[length] = 0;
	
	entry = gtk_entry_new();
	gtk_entry_set_max_length( GTK_ENTRY(entry), 256);
	gtk_entry_set_text( GTK_ENTRY(entry), slash );

	final = g_malloc( gtk_entry_get_max_length( GTK_ENTRY(entry) ));
	if(final == 0){
		g_print("Rename memory alloc, error\n");
		return;
	}
	
	/* user dialog */
	dialog = gtk_dialog_new_with_buttons("Rename", GTK_WINDOW( data->window ), GTK_DIALOG_MODAL|GTK_DIALOG_DESTROY_WITH_PARENT, GTK_STOCK_OK, GTK_RESPONSE_ACCEPT, GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT, NULL);
	gtk_container_add( GTK_CONTAINER( GTK_DIALOG(dialog)->vbox ), entry );
	gtk_widget_show_all(dialog);

	result = gtk_dialog_run( GTK_DIALOG(dialog) );
	switch(result){
		case GTK_RESPONSE_ACCEPT:
			/* check user input */
			tmp = gtk_entry_get_text( GTK_ENTRY(entry) );
			g_strlcpy(final, dirname, gtk_entry_get_max_length( GTK_ENTRY(entry)) );
			g_strlcat(final, tmp, gtk_entry_get_max_length( GTK_ENTRY(entry)) );
//	g_print("\n\nuri: %s\nfilename: %s\ndirname: %s\nfinal: %s\n", uri, filename, dirname, final);
			/* rename */
			g_rename(filename, final);
			break;
		default:
			break;
	}
	gtk_widget_destroy(dialog);
	g_free(uri);
	g_free(dirname);
	g_free(final);
}

/* information */
void cb_information(AppData *data){
	HildonFileDetailsDialog   *dialog = NULL;
	gchar                     *filepath = NULL;
	GSList                    *list = NULL;
	HildonFileSystemModel     *model = NULL;
	GtkTreeIter               iter;
	GtkWidget                 *label = NULL;
	gint                      result;
	
	model = data -> hildon_model;

	if( model == NULL ){
		g_print("could not get model...\n");
		return;
	}
	
	list = hildon_file_selection_get_selected_uris( HILDON_FILE_SELECTION(data->main_file_selection) );
	filepath = g_slist_nth_data(list, 0); /* full path */
	//g_print("debug fp: %s\n", filepath);
	if( ! hildon_file_system_model_load_uri(model, filepath, &iter) ){
		g_print("could not load uri...\nfp:%s\n", filepath);
		return;
	}

	dialog = HILDON_FILE_DETAILS_DIALOG( hildon_file_details_dialog_new_with_model(GTK_WINDOW (data->window), model) );

	hildon_file_details_dialog_set_file_iter(dialog, &iter);

	/* show tabs */
	g_object_set(dialog, "show-tabs", TRUE, NULL);
	
	/* make additional tabs */
	label = gtk_label_new(g_strdup_printf("Name of this file is:\n%s", filepath));
	g_object_set(dialog, "additional-tab", label, NULL);

	g_object_set(dialog, "additional-tab-label", "More Info", NULL);

	gtk_widget_show_all( GTK_WIDGET(dialog) );
	result = gtk_dialog_run( GTK_DIALOG(dialog) );

	/* destroy */
	gtk_widget_destroy( GTK_WIDGET(dialog) );
	g_free(filepath);
}

/*
 * Callback Functions
 * */

/* create folder callback */
static void create_folder_callback(GtkFileSystemHandle *handle,
		const GtkFilePath *path, const GError *error, gpointer data)
{
	HildonFileChooserDialog *self;
	GtkDialog *dialog;
	const gchar *message;

	g_assert(HILDON_IS_FILE_CHOOSER_DIALOG(data));
	self = HILDON_FILE_CHOOSER_DIALOG(data);

	/* ignoring previous operations */
	if (self->priv->create_folder_handle != handle)
		return;

	self->priv->create_folder_handle = NULL;
	dialog = GTK_DIALOG(self);

	if(error){
		if (g_error_matches(error, GTK_FILE_SYSTEM_ERROR,
				GTK_FILE_SYSTEM_ERROR_ALREADY_EXISTS))
			message = "Folder is already exists!";
		else
			message = "Operation failed..";

		hildon_banner_show_information( GTK_WIDGET(self), NULL, message );
//		hildon_file_chooser_dialog_select_text(self->priv);
		gtk_dialog_set_response_sensitive(dialog, GTK_RESPONSE_OK, TRUE);
	}
	else{
		gtk_dialog_response(dialog, HILDON_RESPONSE_FOLDER_CREATED);
	}
	/* This reference was added while setting up the callback */
	g_object_unref(self);
}

/* folder synchronization */
void sync_current_folders_with_file_selection
	(HildonFileSelection *fs, HildonFileChooserDialog *target){
	gchar *uri;
	
	uri = hildon_file_selection_get_current_folder_uri(fs);
//	g_print("\n\nSync: %s\n\n", uri);
	/* sync here */
	gtk_file_chooser_set_current_folder_uri(GTK_FILE_CHOOSER(target), uri);
	g_free(uri);
}

void cb_newfolder(GtkButton *button, AppData *data){
	gchar *foldername = NULL;
	gchar *uri = NULL;
	GtkWidget *dialog;
	GtkFilePath *file_path = NULL;
	GtkFileSystem *backend;
	HildonFileChooserDialogPrivate *sub_priv = NULL;
	
	backend = _hildon_file_system_model_get_file_system(data->hildon_model);
	
	dialog = hildon_file_chooser_dialog_new_with_properties(
			GTK_WINDOW(data->window),
			"action", GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER,
			"file-system-model", data->hildon_model,
			"local-only", TRUE,
			"show-hidden", FALSE,
			"show-upnp", FALSE,
			NULL
			);
	gtk_window_set_destroy_with_parent (GTK_WINDOW(dialog), TRUE);
	sync_current_folders_with_file_selection( HILDON_FILE_SELECTION(data->main_file_selection), HILDON_FILE_CHOOSER_DIALOG(dialog));
	
	/* create folder */
	while(gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_OK){
		uri = gtk_file_chooser_get_uri(GTK_FILE_CHOOSER(dialog));
		// DEBUG
		g_print("FM: About to create folder: %s\n", uri);
		if(file_path)
			gtk_file_path_free(file_path);
		file_path = gtk_file_system_uri_to_path(backend, uri);
		
		sub_priv = HILDON_FILE_CHOOSER_DIALOG (dialog)->priv;
		
		// Handling duplicated operation
		if( sub_priv->create_folder_handle )
		{
			gtk_file_system_cancel_operation ( sub_priv->create_folder_handle );
			sub_priv->create_folder_handle = NULL;
		}

		// Callback is guaranteed to be called
		sub_priv->create_folder_handle =
			gtk_file_system_create_folder (backend, file_path, create_folder_callback, g_object_ref(dialog));

		// Make OK button insensitive while folder operation is going
		gtk_dialog_set_response_sensitive (GTK_DIALOG(dialog), GTK_RESPONSE_OK, FALSE);
		foldername = gtk_file_chooser_get_current_folder( GTK_FILE_CHOOSER(dialog) );
	}
	gtk_widget_destroy(dialog);
}

void cb_select_all(GtkWidget * w, AppData * data){
	hildon_file_selection_select_all(HILDON_FILE_SELECTION(data->main_file_selection));
}

void cb_fullscreen(GtkWidget * w, AppData * data){
	if(data->fullscreen == TRUE){
		data->fullscreen = FALSE;
		gtk_window_unfullscreen(GTK_WINDOW(data->window));
	}
	else{
		data->fullscreen = TRUE;
		gtk_window_fullscreen(GTK_WINDOW(data->window));
	}
}

void cb_showtoolbars(GtkWidget * w, AppData * data){
	gboolean visible;
	
	g_object_get(data->bottom_toolbar, "visible", &visible, NULL);

	if(visible == TRUE){
		g_object_set(data->bottom_toolbar, "visible", FALSE, NULL);
	}
	else{
		g_object_set(data->bottom_toolbar, "visible", TRUE, NULL);
	}
}

/* long click (right click)
 * Tap & hold
 * */
void evt_longclick_content(HildonFileSelection *self, AppData *data){
	GtkMenu *menu;
	guint32 time;
	gchar *filepath = NULL;
	GSList *list = NULL;
	
	/* check if there is a selected one */
	list = hildon_file_selection_get_selected_uris( HILDON_FILE_SELECTION(data->main_file_selection) );
	filepath = g_slist_nth_data(list, 0); /* full path */
	if (filepath == NULL){
		/* there is no selected file */
		return;
	}
	
	menu = data->context_menu;
	time = gtk_get_current_event_time();
	gtk_menu_popup(menu, NULL, NULL, NULL, NULL, 0, time);
}

void evt_longclick_navigation(HildonFileSelection *self, AppData *data){
}

/* File is activated */
void evt_activated(HildonFileSelection *self, AppData * data){
	GSList *list;
	gchar *uri;
	DBusConnection *dbus;
	osso_context_t *osso;
	gint ret;

	/* initialize osso */
	osso = osso_initialize("osso-mime-summon", "0.1", TRUE, NULL);
	if(osso == NULL){
		g_print("Failed to launch osso\n");
		return;
	}

	dbus = (DBusConnection *) osso_get_dbus_connection(osso);
	if(dbus == NULL){
		g_print("Failed to get dbus connection.\n");
		return;
	}

	/* get uri */
	list = hildon_file_selection_get_selected_uris( HILDON_FILE_SELECTION(data->main_file_selection) );
	uri = g_slist_nth_data(list, 0);
	//g_print("about to open %s. \n", uri);
	
	ret = hildon_mime_open_file(dbus, uri);
	//ret = hildon_mime_open_file_with_mime_type(dbus, uri, mime);
	if(ret != 1){
		g_print("Faield to execute file, hildon_mime_open_file: %d\n", ret);
		return;
	}
}
/* Drag & Drop Event */
void evt_dragndrop(HildonFileSelection *self, gchar *dest, GSList *list, AppData *data){
	g_print("\n\nhere..\n");
}

/* Selection change event */
void evt_selection(HildonFileSelection *self, AppData * data){
	gchar * label_text = hildon_file_selection_get_current_folder_uri(self);
	
	gtk_entry_set_text(GTK_ENTRY(data->top_entry), label_text);
	g_free(label_text);
}

gboolean evt_top_keypress(GtkWidget *widget, GdkEventKey *event, AppData *data){
	const gchar * label_text = NULL;
	gboolean result = TRUE;
	HildonFileSelection *self = HILDON_FILE_SELECTION(data->main_file_selection);
	
	/* keyboard event from top entry */
	switch(event->keyval){
		case GDK_Return:
		case GDK_KP_Enter:
			label_text = gtk_entry_get_text(GTK_ENTRY(data->top_entry));
			result = hildon_file_selection_set_current_folder_uri(self, label_text, NULL);
			if(result == FALSE){
				
			}else{}
			return TRUE;
		default:
			return FALSE;
	}
}

/* find button */
void evt_btn_find(HildonFileSelection *self, AppData *data){
	/* Call osso search */
	osso_context_t *osso = osso_initialize("ogs", "0.1", FALSE, NULL);
	osso_rpc_t t;

	osso_rpc_run_with_defaults(osso, OGS_DBUS_SERVICE, OGS_DBUS_METHOD_SEARCH_FILE, &t, DBUS_TYPE_INVALID);
	osso_rpc_free_val(&t);
}

/* new folder button */
void evt_btn_newfolder(GtkButton *button, AppData *data){
	cb_newfolder(button, data);
}


/* Move file button */
void evt_btn_movefile(GtkButton *button, AppData *data){
	
}

/* information button */
void evt_btn_info(GtkButton *button, AppData *data){
	cb_information(data);
}

/* About Us */
void evt_btn_about(GtkButton *button, AppData *data){
	/* show my information */
	GtkWidget *about_dialog;
	GtkWidget *label;
	GtkWidget *image;
	
	gchar message[256] = "\nProject Team CODA (Fine FM)\n\nSang Kil Cha\nJaeyoon Chong\nAnoop Jaishankar\n";
	gint result;
	
	about_dialog = gtk_dialog_new_with_buttons("About us...", GTK_WINDOW( data->window ), GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT, GTK_STOCK_OK, GTK_RESPONSE_ACCEPT, NULL );

	// attach widgets
	label = gtk_label_new( message );
	image = gtk_image_new_from_file("/usr/share/icons/hicolor/26x26/hildon/qgn_toolb_im_smiley.png");
			
	gtk_container_add( GTK_CONTAINER( GTK_DIALOG(about_dialog)->vbox ), image );
	gtk_container_add( GTK_CONTAINER( GTK_DIALOG(about_dialog)->vbox ), label );
	gtk_widget_show_all(about_dialog);
	
	result = gtk_dialog_run (GTK_DIALOG(about_dialog));
	gtk_widget_destroy(about_dialog);
}

//ANOOP

int remove_recursive(char* filename)
{
    char *argv[10];
    int pipefds[2], devnull;
    int rc, status, n = 0;
    // anoop
    int pipe2[2];
    char errMsg[100];
    int i;
    for(i=0;i<100;i++)
	    errMsg[i] = '\0';

	/* set up pipe to communicate with ctokens */
    	rc = pipe(pipefds);
	if (rc) return -1;

	rc = pipe(pipe2);
	if (rc) return -1;
	
	/* fork and execute ctokens */
        rc = fork();
	if (rc < 0) return -1;

	if (rc == 0) /* child */
	{
		devnull = open("/dev/null", O_WRONLY);

		/* set the pipe's output to stdin redirect stdout and
		 *  stderr to /dev/null */
		dup2(pipefds[0], 0);
		// comment next 2
		//dup2(devnull, 1);
		//dup2(devnull, 2);
		
		// anoop
		dup2(pipe2[1], 1);
		dup2(pipe2[1], 2);
		close(pipe2[0]);
		close(pipe2[1]);
		
		/* cleanup open file descriptors */
		close(pipefds[0]);
		close(pipefds[1]);
		close(devnull);
		
		/* set up arguments */
		argv[n++] = "rm";
		argv[n++] = (char*) "-rf";
		argv[n++] = (char*) filename;
		argv[n++] = NULL;
		
		execv(RM_PROGRAM, argv);
	        
		/* exec failed? nothing to do but die, maybe log a failure */
	        exit(-1);
	}

	/* cleanup */
	
	close(pipefds[0]);
	close(pipefds[1]);

	/* and wait for rm to exit (wait not strictly necessary),
	 * but this way we will know if the execution failed */
	
	rc = wait(&status);

	if (rc > 0 && WIFEXITED(status) && WEXITSTATUS(status) == 0)
	{
		printf("RM succeeded\n");
		return 0;
	}

	read(pipe2[0], errMsg, 100);
	close(pipe2[0]);
	close(pipe2[1]);
	
	printf("%s\n", errMsg);
	return -1;
}

/* delete button */ 
void evt_btn_delete(GtkButton *button, AppData *data){
	GSList *list;
	gchar * uri;
	GtkWidget *dialog, *label;
	gint result;
	gchar *message, *filename;
	GtkFileSystem *backend;
	GtkFilePath *file_path;
	
	list = hildon_file_selection_get_selected_uris( HILDON_FILE_SELECTION(data->main_file_selection) );
	uri = g_slist_nth_data(list, 0);
	if(uri == NULL)
		return;

	backend = _hildon_file_system_model_get_file_system(data->hildon_model);
	file_path = gtk_file_system_uri_to_path(backend, uri);
	filename = gtk_file_system_path_to_filename(backend, file_path);
	/*
	 * uri: file:///home/mobileuser/MyDocs/.sounds/clip1.wav
	 * filepath: class structure
	 * filename: /home/mobileuser/MyDocs/.sounds/clip1.wav
	 * */
	
	/* dialog */
	dialog = gtk_dialog_new_with_buttons("Delete", GTK_WINDOW( data->window ), GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT, GTK_STOCK_OK, GTK_RESPONSE_ACCEPT, GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT, NULL );
	
	message = g_malloc(256);
	g_sprintf(message, "Delete this file: %s ?\n", filename);
	label = gtk_label_new( message );
	gtk_container_add( GTK_CONTAINER( GTK_DIALOG(dialog)->vbox ), label );
	gtk_widget_show_all(dialog);
	
	result = gtk_dialog_run( GTK_DIALOG(dialog) );
	switch(result)
	{
		case GTK_RESPONSE_ACCEPT:
//			g_print("About to delete: %s\n", filename);
			/* recursive delete */
			if(remove_recursive(filename) < 0)
				g_print("Error occured during removing file.\n");
			break;
		default:
			break;
	}
	gtk_widget_destroy (dialog);
	
	g_free(uri);
	g_free(message);
}

/* refresh button */
void evt_btn_refresh(GtkButton *button, AppData *data){
	hildon_file_system_model_refresh(data->hildon_model);
}

/* list view button */ 
void evt_btn_listview(GtkButton *button, AppData *data){
	hildon_file_selection_set_mode( HILDON_FILE_SELECTION(data->main_file_selection), HILDON_FILE_SELECTION_MODE_LIST);
}

/* list thumbnail button */ 
void evt_btn_thumbview(GtkButton *button, AppData *data){
	hildon_file_selection_set_mode( HILDON_FILE_SELECTION(data->main_file_selection), HILDON_FILE_SELECTION_MODE_THUMBNAILS);
}

void fm_quit (GtkWidget *w, AppData * data)
{
	gtk_main_quit ();
}

void fm_create_menu (AppData * data)
{
	GtkWidget *menu_file;
	GtkWidget *menu_edit;
	GtkWidget *menu_view;
	
	GtkWidget *menu_file_newfolder;
	GtkWidget *menu_file_rename;
	GtkWidget *menu_file_delete;
	GtkWidget *menu_file_detail;
	
	GtkWidget *menu_edit_cut;
	GtkWidget *menu_edit_copy;
	GtkWidget *menu_edit_paste;
	GtkWidget *menu_edit_select;
	GtkWidget *menu_edit_move;
	
	GtkWidget *menu_view_list;
	GtkWidget *menu_view_thumb;
	GtkWidget *menu_view_sort;
	GtkWidget *menu_view_full;
	GtkWidget *menu_view_show;
	
	data->main_menu = GTK_MENU(gtk_menu_new());
	data->context_menu = GTK_MENU(gtk_menu_new());

	menu_file = gtk_menu_new();
	menu_edit = gtk_menu_new();
	menu_view = gtk_menu_new();

	/* Create Menu items */
	data->menu_item_file = gtk_menu_item_new_with_label ("File");
	data->menu_item_edit = gtk_menu_item_new_with_label ("Edit");
	data->menu_item_view = gtk_menu_item_new_with_label ("View");
	
	/* Create Menu items and connect signals */
	data->menu_item_configure = gtk_menu_item_new_with_label ("Configure");
	g_signal_connect (G_OBJECT (data->menu_item_configure), "activate", G_CALLBACK (cb_configure), data);

	data->menu_item_rename = gtk_menu_item_new_with_label ("Rename");
	g_signal_connect (G_OBJECT (data->menu_item_rename), "activate", G_CALLBACK (cb_rename), data);
		
	data->menu_item_del = gtk_menu_item_new_with_label ("Delete");
	g_signal_connect (G_OBJECT (data->menu_item_del), "activate", G_CALLBACK (evt_btn_delete), data);
		
	data->menu_item_info = gtk_menu_item_new_with_label ("Details");
	g_signal_connect (G_OBJECT (data->menu_item_info), "activate", G_CALLBACK (evt_btn_info), data);
		
	data->menu_item_quit = gtk_menu_item_new_with_label ("Quit");
	g_signal_connect (G_OBJECT (data->menu_item_quit), "activate", G_CALLBACK (fm_quit), NULL);

	/* Append items to menu 
	 * main menu +
	 *           - File
	 *           - Edit
	 *           - View
	 *           - configure
	 *           - ---
	 *           - quit
	 * */
	gtk_menu_item_set_submenu (GTK_MENU_ITEM(data->menu_item_file), menu_file);
	gtk_menu_append (data->main_menu, data->menu_item_file);
	gtk_menu_item_set_submenu (GTK_MENU_ITEM(data->menu_item_edit), menu_edit);
	gtk_menu_append (data->main_menu, data->menu_item_edit);
	gtk_menu_item_set_submenu (GTK_MENU_ITEM(data->menu_item_view), menu_view);
	gtk_menu_append (data->main_menu, data->menu_item_view);
	
//	gtk_menu_append (data->main_menu, data->menu_item_configure);
	
	/*gtk_menu_append (data->main_menu, data->menu_item_file_save);*/
	gtk_menu_append (data->main_menu, gtk_separator_menu_item_new());
	gtk_menu_append (data->main_menu, data->menu_item_quit);

	/* Append items to menu 
	 * File menu +
	 *           - New folder
	 *           - Rename
	 *           - Delete
	 *           - ---
	 *           - Details
	 * */
	menu_file_newfolder = gtk_menu_item_new_with_label ("New Folder");
	menu_file_rename = gtk_menu_item_new_with_label ("Rename");
	menu_file_delete = gtk_menu_item_new_with_label ("Delete");
	menu_file_detail = gtk_menu_item_new_with_label ("Details");
	
	gtk_menu_append (menu_file, menu_file_newfolder);
	gtk_menu_append (menu_file, menu_file_rename);
	gtk_menu_append (menu_file, menu_file_delete);
	gtk_menu_append (menu_file, gtk_separator_menu_item_new());
	gtk_menu_append (menu_file, menu_file_detail);

	g_signal_connect (G_OBJECT (menu_file_newfolder), "activate", G_CALLBACK (cb_newfolder), data);
	g_signal_connect (G_OBJECT (menu_file_rename), "activate", G_CALLBACK (cb_rename), data);
	g_signal_connect (G_OBJECT (menu_file_delete), "activate", G_CALLBACK (evt_btn_delete), data);
	g_signal_connect (G_OBJECT (menu_file_detail), "activate", G_CALLBACK (cb_information), data);
	
	/* Append items to menu 
	 * Edit menu +
	 *           - Cut
	 *           - Copy
	 *           - Paste
	 *           - Select all
	 *           - ---
	 *           - Move to
	 * */
	menu_edit_cut = gtk_menu_item_new_with_label ("Cut");
	menu_edit_copy = gtk_menu_item_new_with_label ("Copy");
	menu_edit_paste = gtk_menu_item_new_with_label ("Paste");
	menu_edit_select = gtk_menu_item_new_with_label ("Select All");
	menu_edit_move = gtk_menu_item_new_with_label ("Move to");

	gtk_menu_append (menu_edit, menu_edit_cut);
	gtk_menu_append (menu_edit, menu_edit_copy);
	gtk_menu_append (menu_edit, menu_edit_paste);
	gtk_menu_append (menu_edit, menu_edit_select);
	gtk_menu_append (menu_edit, gtk_separator_menu_item_new());
	gtk_menu_append (menu_edit, menu_edit_move);

	g_signal_connect (G_OBJECT (menu_edit_select), "activate", G_CALLBACK (cb_select_all), data);
	
	/* Append items to menu 
	 * View menu +
	 *           - List
	 *           - Thumbnails
	 *           - ---
	 *           - Sort
	 *           - ---
	 *           - Full screen
	 *           - ---
	 *           - show toolbar
	 * */
	menu_view_list = gtk_menu_item_new_with_label ("List");
	menu_view_thumb = gtk_menu_item_new_with_label ("Thumbnails");
	menu_view_sort = gtk_menu_item_new_with_label ("Sort");
	menu_view_full = gtk_menu_item_new_with_label ("Full Screen");
	menu_view_show = gtk_menu_item_new_with_label ("Show toolbars");
	
	gtk_menu_append (menu_view, menu_view_list);
	gtk_menu_append (menu_view, menu_view_thumb);
	gtk_menu_append (menu_view, gtk_separator_menu_item_new());
	gtk_menu_append (menu_view, menu_view_sort);
	gtk_menu_append (menu_view, gtk_separator_menu_item_new());
	gtk_menu_append (menu_view, menu_view_full);
	gtk_menu_append (menu_view, gtk_separator_menu_item_new());
	gtk_menu_append (menu_view, menu_view_show);
	
	g_signal_connect (G_OBJECT (menu_view_list), "activate", G_CALLBACK (evt_btn_listview), data);
	g_signal_connect (G_OBJECT (menu_view_thumb), "activate", G_CALLBACK (evt_btn_thumbview), data);
	g_signal_connect (G_OBJECT (menu_view_full), "activate", G_CALLBACK (cb_fullscreen), data);
	g_signal_connect (G_OBJECT (menu_view_show), "activate", G_CALLBACK (cb_showtoolbars), data);
	
	/* display menu */
	hildon_window_set_menu(HILDON_WINDOW(data->window), GTK_MENU(data->main_menu));
	gtk_widget_show_all (GTK_WIDGET (data->main_menu));

	/* Append items to menu 
	 * Context menu +
	 *           - rename
	 *           - delete
	 *           - information
	 * */
	gtk_menu_append (data->context_menu, data->menu_item_rename);
	gtk_menu_append (data->context_menu, data->menu_item_del);
	gtk_menu_append (data->context_menu, data->menu_item_info);
//	gtk_menu_append (data->context_menu, gtk_separator_menu_item_new());

	gtk_widget_show_all (GTK_WIDGET (data->context_menu));
}

void init_file_selection(AppData * data){
	/* Add file selection */
	data->hildon_model =
		HILDON_FILE_SYSTEM_MODEL(g_object_new(HILDON_TYPE_FILE_SYSTEM_MODEL, "ref-widget", data->main_vbox, NULL));
	data->main_file_selection = g_object_new( HILDON_TYPE_FILE_SELECTION, "model", data->hildon_model, "drag-enabled", TRUE, NULL );

	/* Connect signal to file widget */
	g_signal_connect(G_OBJECT(data->main_file_selection), "file-activated", G_CALLBACK(evt_activated), data);
	g_signal_connect(G_OBJECT(data->main_file_selection), "selection-changed", G_CALLBACK(evt_selection), data);
	g_signal_connect(G_OBJECT(data->main_file_selection), "content-pane-context-menu", G_CALLBACK(evt_longclick_content), data);
	g_signal_connect(G_OBJECT(data->main_file_selection), "navigation-pane-context-menu", G_CALLBACK(evt_longclick_navigation), data);
	g_signal_connect(G_OBJECT(data->main_file_selection), "uris-dropped", G_CALLBACK(evt_dragndrop), data);
}

void init_top_entry(AppData * data){
	data->top_entry = gtk_entry_new();

	/* Connect signal */
	g_signal_connect(G_OBJECT(data->top_entry), "key-press-event", G_CALLBACK(evt_top_keypress), data);
}

void init_bottom_box(AppData * data){
	GtkWidget *icon_new;

	/* button allocation / adding stock images */
	/* find / new / move /info / delete / refresh / about / listview / thumbview */
	icon_new = gtk_image_new_from_file("/usr/share/icons/hicolor/26x26/hildon/qgn_addr_icon_search_service.png");
	data->bottom_btn_find = gtk_tool_button_new(icon_new, NULL);
	
	icon_new = gtk_image_new_from_file("/usr/share/icons/hicolor/26x26/hildon/qgn_toolb_gene_newfldrbutton.png");
	data->bottom_btn_newfolder = gtk_tool_button_new(icon_new, NULL);
	
	icon_new = gtk_image_new_from_file("/usr/share/icons/hicolor/26x26/hildon/qgn_toolb_gene_movetofldr.png");
	data->bottom_btn_movefile = gtk_tool_button_new(icon_new, NULL);
	data->bottom_btn_info = gtk_tool_button_new_from_stock(GTK_STOCK_INFO);
	
	data->bottom_btn_delete = gtk_tool_button_new_from_stock(GTK_STOCK_DELETE);
	data->bottom_btn_refresh = gtk_tool_button_new_from_stock(GTK_STOCK_REFRESH);
	/* separator */
	data->bottom_separator = gtk_separator_tool_item_new();
	//gtk_separator_tool_item_set_draw( GTK_SEPARATOR_TOOL_ITEM(data->bottom_separator), TRUE);
	
	data->bottom_btn_about = gtk_tool_button_new_from_stock(GTK_STOCK_ABOUT);

	icon_new = gtk_image_new_from_file("/usr/share/icons/hicolor/26x26/hildon/qgn_toolb_filemanager_listview.png");
	data->bottom_btn_listview = gtk_tool_button_new(icon_new, NULL);
	
	icon_new = gtk_image_new_from_file("/usr/share/icons/hicolor/26x26/hildon/qgn_toolb_filemanager_thumbnailview.png");
	data->bottom_btn_thumbview = gtk_tool_button_new(icon_new, NULL);
	
	/* signals */
	g_signal_connect(G_OBJECT(data->bottom_btn_find), "clicked", G_CALLBACK(evt_btn_find), data);
	g_signal_connect(G_OBJECT(data->bottom_btn_newfolder), "clicked", G_CALLBACK(evt_btn_newfolder), data);
	g_signal_connect(G_OBJECT(data->bottom_btn_movefile), "clicked", G_CALLBACK(evt_btn_movefile), data);
	g_signal_connect(G_OBJECT(data->bottom_btn_info), "clicked", G_CALLBACK(evt_btn_info), data);
	g_signal_connect(G_OBJECT(data->bottom_btn_delete), "clicked", G_CALLBACK(evt_btn_delete), data);
	g_signal_connect(G_OBJECT(data->bottom_btn_refresh), "clicked", G_CALLBACK(evt_btn_refresh), data);
	g_signal_connect(G_OBJECT(data->bottom_btn_about), "clicked", G_CALLBACK(evt_btn_about), data);
	g_signal_connect(G_OBJECT(data->bottom_btn_listview), "clicked", G_CALLBACK(evt_btn_listview), data);
	g_signal_connect(G_OBJECT(data->bottom_btn_thumbview), "clicked", G_CALLBACK(evt_btn_thumbview), data);
	
	/* Expanding Toolbar */
	gtk_tool_item_set_expand( data->bottom_btn_find, TRUE);
	gtk_tool_item_set_expand( data->bottom_btn_newfolder, TRUE);
	gtk_tool_item_set_expand( data->bottom_btn_movefile, TRUE);
	gtk_tool_item_set_expand( data->bottom_btn_info, TRUE);
	gtk_tool_item_set_expand( data->bottom_btn_delete, TRUE);
	gtk_tool_item_set_expand( data->bottom_btn_refresh, TRUE);
	gtk_tool_item_set_expand( data->bottom_btn_about, TRUE);
	gtk_tool_item_set_expand( data->bottom_btn_listview, TRUE);
	gtk_tool_item_set_expand( data->bottom_btn_thumbview, TRUE);

	/* setting tooltip */
	//gtk_tool_item_set_tooltip( data->bottom_btn_find, data->tooltips, "Find", "Find Files!");
	
	/* Add buttons */
	gtk_toolbar_insert( GTK_TOOLBAR(data->bottom_toolbar), data->bottom_btn_find, -1);
	gtk_toolbar_insert( GTK_TOOLBAR(data->bottom_toolbar), data->bottom_btn_newfolder, -1);
	gtk_toolbar_insert( GTK_TOOLBAR(data->bottom_toolbar), data->bottom_btn_movefile, -1);
	gtk_toolbar_insert( GTK_TOOLBAR(data->bottom_toolbar), data->bottom_btn_info, -1);
	gtk_toolbar_insert( GTK_TOOLBAR(data->bottom_toolbar), data->bottom_btn_delete, -1);
	gtk_toolbar_insert( GTK_TOOLBAR(data->bottom_toolbar), data->bottom_btn_refresh, -1);
	gtk_toolbar_insert( GTK_TOOLBAR(data->bottom_toolbar), data->bottom_separator, -1);
	gtk_toolbar_insert( GTK_TOOLBAR(data->bottom_toolbar), data->bottom_btn_about, -1);
	gtk_toolbar_insert( GTK_TOOLBAR(data->bottom_toolbar), data->bottom_btn_listview, -1);
	gtk_toolbar_insert( GTK_TOOLBAR(data->bottom_toolbar), data->bottom_btn_thumbview, -1);
}


void fm_init (AppData * data)
{
	/* Create the hildon program and setup the title */
	data->program = HILDON_PROGRAM(hildon_program_get_instance());
	g_set_application_name("Fine File Manager");

	/* set full screen variable */
	data->fullscreen = FALSE;

	/* Create HildonWindow and set it to HildonProgram */
	data->window = HILDON_WINDOW(hildon_window_new());
	hildon_program_add_window(data->program, data->window);

	/* Add main vbox to appview */
	data->main_vbox = gtk_vbox_new (FALSE, 0);
	gtk_container_add (GTK_CONTAINER (data->window), data->main_vbox);

	/* top entry initialization */
	init_top_entry(data);
	
	/* file selection initialization */
	init_file_selection(data);
	
	/* initializaing bottom box */
	data->bottom_toolbar = gtk_toolbar_new();
	init_bottom_box(data);
	
	/* Adding main widgets on the main window (vbox)
	 * Vbox +
	 * 	- top entry
	 * 	- file selection
	 * 	- bottom widgets (Toolbar) +
	 * 				- Buttons
	 * */
	
	gtk_box_pack_start (GTK_BOX (data->main_vbox), data->top_entry, FALSE, TRUE, 0);
	gtk_box_pack_start (GTK_BOX (data->main_vbox), data->main_file_selection, TRUE, TRUE, 0);
	gtk_box_pack_start(GTK_BOX (data->main_vbox), data->bottom_toolbar, FALSE, TRUE, 1);

        /* Connect signal to X in the upper corner */
        g_signal_connect(G_OBJECT(data->window), "delete_event",
          G_CALLBACK(fm_quit), data);

	gtk_widget_show_all (GTK_WIDGET(data->window));

	/* pane separator position in pixel */
	int pos = 75; /* 75 pixel from the left */
	HildonFileSelectionPrivate *priv = HILDON_FILE_SELECTION(data->main_file_selection)->priv;
	gtk_paned_set_position (GTK_PANED (priv->hpaned), pos);

	/* Create Menu */
	fm_create_menu (data);
}


int main(int argc, char *argv[])
{
	AppData * data = g_new0 (AppData, 1); /* structure initialization */

	gtk_init(&argc, &argv);

	fm_init (data);

	gtk_main();

	g_free (data);
    	return 0;
}