xref: /dports/x11-fm/catseye-fm/catseye-fm-4.2.0.0/myfm.c

/*
    Copyright 2007, 2008, 2009, 2010 Geyer Klaus

    This file is part of Cat'sEyE.

    Cat'sEyE is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    Cat'sEyE is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with Cat'sEyE.  If not, see <http://www.gnu.org/licenses/>.
*/



#include <glib.h>   //g_thread_init
#include <glib/gstdio.h> //g_rename
#include <gtk/gtk.h>
#ifndef NO_GIO
#include <gio/gio.h> //gfile, monitor, ...
#endif
#include <gdk/gdkkeysyms.h>
#include <stdlib.h>
#include <string.h>
#include <dirent.h>	//Verzeichnis Zeiger und DIR - Struktur
#include <unistd.h> 	//e.g. chdir, usleep
#include <errno.h>

#include "globalDefinitions.h"
#include "listitems.h"
#include "helpers.h"
#include "confighandling.h"
#include "confighandlingDefinitions.h"
#include "Lists.h"
#include "threads.h"
#include "userdata.h"
#include "myfm.h"
#include "fileshelf.h"
#include "mytrace.h"
#include "internals.h"
#include "userdata.h"
#include "CommandParser.h"
#include "DragnDrop.h"
#include "automaticUpdate.h"
#include "SearchFor.h"

#include "CreateUsercommandDialog.h"
#include "propertyPage.h"

#include "allInclude.h"

static gint delete_Event(GtkWidget *widget, GdkEvent event, gpointer daten);
static void end (GtkWidget *widget, GdkEvent event, gpointer daten);
int predefine_Main_Objects();
int makeLists(struct SideObjectList *Object, struct updateList **itemlist);
void connectListToView(struct SideObjectList *Object);
void doActionsForNewView (struct SideObjectList *Object);
void disconnectListAndView (struct SideObjectList *Object);
void bringAllToTheRightOrder();
void onePathChanged(GtkEntry *entry, gpointer g);
gboolean oneKeyPressed_PathEntry(GtkWidget *widget, GdkEventKey *event, gpointer data);
int checkDirectory(struct SideObjectList *Object, GString *NewPath);
void oneColumnWasClicked(GtkTreeViewColumn *Column, gpointer data);
void formatPathString(GString *NewPath);
void oneOnePathUpButtonClicked(GtkButton *button, gpointer data);
void oneSelectionChanged(GtkTreeSelection *treeselection, gpointer data);
gboolean oneKeyPressedInView(GtkWidget *widget, GdkEventKey *event, gpointer data);
static void deleteSelectedRowsHelper(GtkTreeModel *model,GtkTreePath *path,GtkTreeIter *iter,gpointer data);
static void sizeOfSelected_Helper (GtkTreeModel *model,GtkTreePath *path,GtkTreeIter *iter,gpointer data);
gboolean oneContextMenuReplied(GtkWidget *treeview, gpointer data);
gboolean oneNoteBookContextMenuReplied(GtkWidget *treeview, gpointer data);
void openContextMenu(GtkWidget *treeview, GdkEventButton *event, gpointer data);
void mayDeleteSelectedRows(GtkWidget *menuitem, gpointer data);
void editItems(GtkWidget *menuitem, gpointer data);
gboolean onePageSwitched(GtkNotebook *notebook, GtkNotebookPage *page, guint page_num, gpointer user_data);
void openTabContextMenu(GtkWidget *notebook, GdkEventButton *event, gpointer data);
void onePageAddedToNotebook(GtkNotebook *notebook, GtkWidget *child, guint page_num, gpointer data);
struct SideObjectList *getOtherSideObject(struct SideObjectList *ThisSideObject);
void updatePathEntryBox(GtkNotebook *notebook, guint num);
void loadThings();
void loadStartPathes();
void savePathes();
void saveThings();
void loadSize();
void saveSize();
void getStandardStartDirectory(GString *gstrCommand);//, GString *gstrCommandName);
void addNewPage(GtkWidget *menuitem, gpointer data);
void closeActivePage(GtkWidget *menuitem, gpointer data);
void dublicateActivePage(GtkWidget *menuitem, gpointer data);
void moveActivePage(GtkWidget *menuitem, gpointer data);
void copyActivePage(GtkWidget *menuitem, gpointer data);
void AlwaysShowHiddenfilesInAllTabs();
void ChangePreviewState(GtkWidget *menuitem, gpointer data);
void ChangeReadOnlyState (GtkWidget *menuitem, gpointer data);
void showHiddenFilesInActivePage(GtkWidget *menuitem, gpointer data);
void addNewPageFromBookmarks(GtkWidget *menuitem, struct UserDataList *UserDataListItem);
void goToFromBookmarks(GtkWidget *menuitem, struct UserDataList *UserDataListItem);
int AddPathesToNotebook( GtkNotebook *Notebook, GString *gstrPathes, int AllreadyStarted);
static void getSizeOfSelectedItemsRecursive_getItems (GtkTreeModel *model,GtkTreePath *path,GtkTreeIter *iter,gpointer data);
void CopyPasteCreateList_SideObject(struct SideObjectList *Object, int CopyOrMove);
void CopyPasteProcessList_SideObject(struct SideObjectList *Object);
void defineGlobals();
void clearUpGobals();
void loadGlobals();
int mysortfunctionforNamesLeft(GtkTreeModel *model, GtkTreeIter *a, GtkTreeIter *b, gpointer userdata);
void ShowSplashScreen();
void DestroySplashScreen();
void MenuAddToNewFileshelf(GtkWidget *menuitem, gpointer data);
void searchStringInAndHighlightItems_WraperforSideObject(GtkWidget *menuitem, gpointer data);
void copyToOtherPannel(GtkWidget *menuitem, gpointer data);
void moveToOtherPannel(GtkWidget *menuitem, gpointer data);
void renameItems(GtkWidget *menuitem, gpointer data);
void startItemsWithUserCommand_WraperforSideObject(GtkWidget *menuitem, gpointer data);
void oneRowActivated_SideObjectWrap(GtkTreeView *treeview, GtkTreePath *TreePath, GtkTreeViewColumn *col, gpointer data);
void internalSavePatheAsBookmark_wrap(GtkWidget *menuitem, gpointer data);
void mayNewDirectory(GtkWidget *menuitem, gpointer data);
int addPointsToSideView(char *cpPath, GtkListStore *listStore, const char *cpColorDir);
void internal_startPropPage (GtkWidget *menuitem, gpointer data);
gboolean IntervallTimer_SaveSession (gpointer data);

gint glistComparePointer (gconstpointer a, gconstpointer b);


const char *Names[] = {   "preview",
                    "filename",
                    "size",
                    "owner",
                    "group",
                    "perm.",
                    "accessed",
                    "changed",
                    "target",
                    "type",
                    "TimeStamp_1",
                    "TimeStamp_2",
                    "type_d",
                    "Color"
                    };
#define COLTYPES   	G_TYPE_OBJECT,\
                    G_TYPE_STRING,\
					G_TYPE_UINT64,\
					G_TYPE_INT,\
					G_TYPE_INT,\
					G_TYPE_STRING,\
					G_TYPE_STRING,\
					G_TYPE_STRING,\
					G_TYPE_STRING,\
					G_TYPE_STRING,\
					G_TYPE_INT,\
					G_TYPE_INT,\
					G_TYPE_INT,\
					G_TYPE_STRING

GtkWindow 		*win;
GtkWindow 		*Splashwin;
GtkWidget 		*HPanedLeftRight;
GtkWidget		*VPanedForFileShelf;
GtkWidget 		*Notebooks[SIDE_BOTH];
GtkWidget       *PathEntryBox[SIDE_BOTH];
GtkVBox         *VBox[SIDE_BOTH];
GtkHBox         *HBoxForButtonsAndPathEntry[SIDE_BOTH];
GtkButton       *OnePathUpButton[SIDE_BOTH];


struct CopyReMoveList *g_CopyPasteShortcutStruct;

extern int          g_iFileshelfIsInitialized;
extern GtkNotebook  *g_FileShelfNotebook;
extern struct FileShelfObjectList *FirstFileShelfObject;

//extern struct _UserCommandList *g_UserCommandsForMarkedItems;   //save a list of usercommands which have the target of the marked items ending
extern struct UserDataList *g_UserDataList;                     //used wthin the contextmenu
extern struct _OptionsList *g_OptionsList;
extern struct _UserCommandList *g_UserCommandList;

#ifndef NO_GIO
extern struct autoUpdateList *g_listAutoUpdateList;
#endif

int gint_Starting; //is 1 while startprocess. when program is in mainloop, its 0

int g_int_AlwaysShowHidden;

GtkTextBuffer *g_TextBuffer_CommandHistory;

struct SearchParams *gpSearchParamStru;



int main(int argc, char *argv[]){
	TRACEIT(10,"main		start");
    gint_Starting = 1;

	g_thread_init(NULL);
	gdk_threads_init();


	gtk_init(&argc, &argv);

	//ShowSplashScreen();

	win = g_object_new(GTK_TYPE_WINDOW,
		"title",MYNAME,
		"default-width", 800,
		"default-height", 640,
		"resizable",TRUE,
		"border-width",5,
		NULL);
	//gtk_window_maximize(win);

	// Add Icon to Window
	AddMyIconsToWindow(win);

	//Set some global variables
	defineGlobals();

	//Predefine Objects
	predefine_Main_Objects();

	//some Signals
	g_signal_connect (win, "delete-event",G_CALLBACK(delete_Event),NULL);
	g_signal_connect (win, "destroy", G_CALLBACK(end),NULL);

	g_signal_connect (PathEntryBox[SIDE_LEFT], "activate",G_CALLBACK(onePathChanged),GINT_TO_POINTER(SIDE_LEFT));
	g_signal_connect (PathEntryBox[SIDE_RIGHT], "activate",G_CALLBACK(onePathChanged),GINT_TO_POINTER(SIDE_RIGHT));
	g_signal_connect (PathEntryBox[SIDE_LEFT], "key-press-event",G_CALLBACK(oneKeyPressed_PathEntry),GINT_TO_POINTER(SIDE_LEFT));
	g_signal_connect (PathEntryBox[SIDE_RIGHT], "key-press-event",G_CALLBACK(oneKeyPressed_PathEntry),GINT_TO_POINTER(SIDE_RIGHT));

	g_signal_connect (OnePathUpButton[SIDE_LEFT],"clicked",G_CALLBACK(oneOnePathUpButtonClicked),GINT_TO_POINTER(SIDE_LEFT));
	g_signal_connect (OnePathUpButton[SIDE_RIGHT],"clicked",G_CALLBACK(oneOnePathUpButtonClicked),GINT_TO_POINTER(SIDE_RIGHT));

	g_signal_connect (Notebooks[SIDE_LEFT],"page-added",G_CALLBACK(onePageAddedToNotebook),GINT_TO_POINTER(SIDE_LEFT));
	g_signal_connect (Notebooks[SIDE_RIGHT],"page-added",G_CALLBACK(onePageAddedToNotebook),GINT_TO_POINTER(SIDE_RIGHT));
	g_signal_connect (Notebooks[SIDE_LEFT],"button-press-event",G_CALLBACK(oneMouseButtonPressedOnNotebook),GINT_TO_POINTER(SIDE_LEFT));
	g_signal_connect (Notebooks[SIDE_RIGHT],"button-press-event",G_CALLBACK(oneMouseButtonPressedOnNotebook),GINT_TO_POINTER(SIDE_RIGHT));
	g_signal_connect (Notebooks[SIDE_LEFT],"popup-menu",G_CALLBACK(oneNoteBookContextMenuReplied),GINT_TO_POINTER(SIDE_LEFT));
	g_signal_connect (Notebooks[SIDE_RIGHT],"popup-menu",G_CALLBACK(oneNoteBookContextMenuReplied),GINT_TO_POINTER(SIDE_RIGHT));
	g_signal_connect (Notebooks[SIDE_LEFT],"key-press-event",G_CALLBACK(oneKeyPressedOnNotebook),GINT_TO_POINTER(SIDE_LEFT));
	g_signal_connect (Notebooks[SIDE_RIGHT],"key-press-event",G_CALLBACK(oneKeyPressedOnNotebook),GINT_TO_POINTER(SIDE_RIGHT));
	g_signal_connect (Notebooks[SIDE_LEFT],"switch-page",G_CALLBACK(onePageSwitched),GINT_TO_POINTER(SIDE_LEFT));
	g_signal_connect (Notebooks[SIDE_RIGHT],"switch-page",G_CALLBACK(onePageSwitched),GINT_TO_POINTER(SIDE_RIGHT));

	//We want to see the things we have created
	bringAllToTheRightOrder();

	loadThings();

	//gtk_window_set_opacity (win, 0.8);
    //DestroySplashScreen();


	gtk_widget_show_all (GTK_WIDGET (win));

    //set the position of the devider. This should make sure that the divider will not change its position when some view changes, e.g. if th user changes the directory
    //its important that this is done after we have shown all widgets, otherwise they will not know their size
    int iNewPosition;
    g_object_get ( (gpointer) HPanedLeftRight,"max-position", &iNewPosition, NULL);
	gtk_paned_set_position ((GtkPaned *)HPanedLeftRight, iNewPosition/2);


	//prepare the timer for saving the session after a specific intervall
	int iSaveSessionMinutes;
	iSaveSessionMinutes = OptionsList_GetIntValueByID (g_OptionsList, SAVESESSIONMINUTESTYPES, DEFAULT_SAVESESSIONMINUTES);
	if (iSaveSessionMinutes > 0){
		g_timeout_add_seconds (iSaveSessionMinutes*60, (GSourceFunc)( IntervallTimer_SaveSession), NULL);
	}

    //MainLOOP
	TRACEIT(10,"main-mainloop		start");
	gint_Starting=0;
	myWrap_gdk_threads_enter("main");
	gtk_main();
	//printf("after big MAIN\n");
	myWrap_gdk_threads_leave("main");

	//Let us forget this things!
	clearUpGobals();

    #ifdef MYGSTRINGWATCH
	my_g_gstring_exit();
	#endif

	TRACEIT(10,"main		ends");
    return 0;
}


static gint delete_Event (GtkWidget *widget, GdkEvent event, gpointer daten){
	TRACEIT(10,"main		delete_Event (noerror) (event: delete-event)");
	saveThings();
	return FALSE;
}


static void end (GtkWidget *widget, GdkEvent event, gpointer daten){
//	g_printf("end\n");
    TRACEIT(10,"main		end (noerror) (event: destroy)");
    gtk_main_quit();

}


void ShowSplashScreen(){
    //funktioniert nicht, weiss aber nicht warum!
    GString *home = g_string_sized_new(20);
    struct myFiles_struct *filestru;

    getHomeDirectory(home);
    checkPathForLastChar(home);
    g_string_append(home, SPASHIMAGENAME);
    filestru = myFiles_openFile(home->str, "r");
    printf("filename: %s\n",home->str);
    if (filestru){
        //gtk_window_set_auto_startup_notification(FALSE);

        myFiles_closeFile(filestru);
        GtkWidget *image = gtk_image_new_from_file (home->str);
        Splashwin = g_object_new(GTK_TYPE_WINDOW,
        /*"allow-grow",FALSE,*/
        /*"allow-shrink",FALSE,*/
        /*"decorated",FALSE,*/
        /*"default-width", 800,*/
		/*"default-height", 640,*/
		"deletable", FALSE,
		/*"opacity",0.4,*/
		"resizable",FALSE,
		/*"skip-pager-hint",TRUE,*/
		/*"skip-taskbar-hint",TRUE,*/
		/*"title",MYNAME,*/
		/*"border-width",5,*/
		"type_hint",GDK_WINDOW_TYPE_HINT_SPLASHSCREEN,
		NULL);
		//gtk_window_set_type_hint(Splashwin,GDK_WINDOW_TYPE_HINT_SPLASHSCREEN);
        printf("File found\n");
        gtk_container_add (GTK_CONTAINER(Splashwin),image);

		gtk_widget_show_all (GTK_WIDGET (Splashwin));

    }
    if (home)
        g_string_free(home, TRUE);
}


void DestroySplashScreen(){
    gtk_widget_destroy(GTK_WIDGET(Splashwin));
    //gtk_window_set_auto_startup_notification(TRUE);
}


void defineGlobals(){
	g_CopyPasteShortcutStruct = NULL;

	g_int_AlwaysShowHidden=0;

	g_iFileshelfIsInitialized = 0;
	g_FileShelfNotebook = NULL;
	FirstFileShelfObject = NULL;

    //create a TextBuffer which holds the commands send to the shell by catseye
    //and add an tag, wich will be refered to when an error occured while processing a command
    //the text in the error string will be displayed in the color specified here ( "myWrapOf__g_spawn_command_line_sync" )
    g_TextBuffer_CommandHistory = gtk_text_buffer_new(NULL);
    gtk_text_buffer_create_tag (g_TextBuffer_CommandHistory, "error", "foreground", "red", NULL);


    //used in the SearchForDialog, we want it to now the last searched text
	gpSearchParamStru = NULL;

#ifndef NO_GIO
    g_listAutoUpdateList=NULL;
#endif
}


void clearUpGobals(){
	//please free all memory in here (global used varaibles)
    TRACEIT(10,"clearUpGobals		start");


    //MIND!! autoUpdateList_deleteList has to be before SideObjectList_ClearAllForShutdown, because SideObjectList_ClearAllForShutdown
    //will call a threaded function to delete the monitors but nobody waits for them to finish, leading to memory leaks
    //while autoUpdateList_deleteList is synchrone
    #ifndef NO_GIO
	//free autoUpdateList
	autoUpdateList_deleteList ();
    #endif

    SideObjectList_ClearAllForShutdown();

	//freeTypesAndUserProgrammArrays();
	//free memory used in contextmenu for usercommands
	if (NULL != g_UserDataList){
        UserDataList_DeleteList(&g_UserDataList);
        //g_UserDataList = NULL;	//this is allready done from deleteList function
	}
	//free the things the xml parser may have stored in his lists
	configFileHandling_clearForShutdown();

    if (g_CopyPasteShortcutStruct != NULL){
        CopyReMoveList_DeleteList(g_CopyPasteShortcutStruct);
        g_CopyPasteShortcutStruct = NULL;
    }

    //used in the SearchForDialog, we want it to now the last searched text
    if (gpSearchParamStru)
		searchParams_delete(gpSearchParamStru);

    //Free the fileshelfthings
	DeleteFileshelfThings();



	TRACEIT(10,"clearUpGobals		end");
}


gboolean IntervallTimer_SaveSession (gpointer data){
	TRACEIT(10,"IntervallTimer_SaveSession		start");

	//both, this timer and the close event are signals called within the mainloop and are therefor threadsave, live's easy
	saveThings ();

	TRACEIT(10,"IntervallTimer_SaveSession		end");
	return TRUE;
}


void saveThings(){
	TRACEIT(10,"saveThings		start");
	GString *gstrBuf = g_string_sized_new(20);
	if (0 == myFiles_SaveFileSimpleSave("Cat'sEyE save file, please do not touch unless you really know what to do.\n", "w+")){
        saveSize();
        savePathes();
        saveFileShelfs();
		if (1==g_int_AlwaysShowHidden){
			g_string_printf(gstrBuf, "%s%strue\n",ALWAYS_SHOW_HIDDEN,TYPESEPARATOR);
			myFiles_SaveFileSimpleSave(gstrBuf->str, "a+");
		}
	}
	g_string_free(gstrBuf, TRUE);
	TRACEIT(10,"saveThings		ends");
}


void saveSize(){
	TRACEIT(10,"saveSize		start");
	GString *gstrBuf = g_string_sized_new (20);
	gint width;
	gint height;

	gtk_window_get_size (win, &width, &height);

	g_string_printf(gstrBuf, "%s%s%d\n", LASTSIZE_X, TYPESEPARATOR, width);
	myFiles_SaveFileSimpleSave(gstrBuf->str, "a+");

	g_string_printf(gstrBuf, "%s%s%d\n", LASTSIZE_Y, TYPESEPARATOR, height);
	myFiles_SaveFileSimpleSave(gstrBuf->str, "a+");

	g_string_free (gstrBuf, TRUE);
	TRACEIT(10,"saveSize		end");
	return;
}


void loadThings(){
	TRACEIT(10,"loadThings		start");

	configFileHandling_Init();

	loadGlobals();
	loadStartPathes();
	loadFileShelfs(NULL);
	loadSize ();
	TRACEIT(10,"loadThings		ends");
}

void loadSize(){
	TRACEIT(10,"loadSize		start");
	GString *gstrBuf=NULL;

	int iLastSize_X=0;
	int iLastSize_Y=0;

	gstrBuf = g_string_sized_new(10);
	if (1 == myFiles_SaveFileSimpleGetValue(LASTSIZE_X, gstrBuf)){
		sscanf (gstrBuf->str, "%d", &iLastSize_X);
	}
	if (1 == myFiles_SaveFileSimpleGetValue(LASTSIZE_Y, gstrBuf)){
		sscanf (gstrBuf->str, "%d", &iLastSize_Y);
	}

	if (iLastSize_X!=0 && iLastSize_Y!=0){
		gtk_window_resize (win, iLastSize_X, iLastSize_Y);
	}

	g_string_free(gstrBuf, TRUE);
	TRACEIT(10,"loadSize		end");
}

void loadGlobals(){
	TRACEIT(10,"loadGlobals		start");
    GString *gstrBuf=NULL;

	//load from savefile:
	gstrBuf = g_string_sized_new(10);
	if (1 == myFiles_SaveFileSimpleGetValue(ALWAYS_SHOW_HIDDEN, gstrBuf)){
		if (0==strcmp(gstrBuf->str, "true")){
			g_int_AlwaysShowHidden=1;
		}
		else{
			g_int_AlwaysShowHidden=0;
		}
	}
	g_string_free(gstrBuf, TRUE);

	//used in the SearchForDialog, we want it to now the last searched text
    gpSearchParamStru = searchParams_new();

   	TRACEIT(10,"loadGlobals		end");
}


void savePathes(){
	TRACEIT(10,"savePathes		start");
	GString *PathesLeft = g_string_sized_new(10);
	GString *StartPath = g_string_sized_new(10);

    configFileHandling_loadConfigFile( FALSE, FALSE );
    const char *ccpSavePathesOnExit = OptionsList_getValueByID (g_OptionsList, SAVEPATHESONEXIT);

	if (ccpSavePathesOnExit != NULL){
	    g_string_assign(StartPath, ccpSavePathesOnExit);
        cutSpacesFromGString(StartPath);
        if (strcmp (StartPath->str,"true") == 0 || strcmp (StartPath->str,"True") == 0 || strcmp (StartPath->str,"TRUE") == 0){
            struct  SideObjectList *Object = NULL;
            guint i;
            int i_NoteBookTabs;
            guint guint_NoteBookTabs=0;


            //save left pathes and attributes
            i_NoteBookTabs = gtk_notebook_get_n_pages ((GtkNotebook *)Notebooks[SIDE_LEFT]);
            if (i_NoteBookTabs > 0){
                guint_NoteBookTabs = i_NoteBookTabs;
            }
            for (i=0; i<guint_NoteBookTabs; i++){
                if ( 0== SideObjectList_GetObjectByPageNumber((GtkNotebook *)Notebooks[SIDE_LEFT], &Object, i)){
                    //PATH
                    g_string_printf(PathesLeft, LASTPATHLEFTID, i);
                    g_string_append(PathesLeft,TYPESEPARATOR);
                    g_string_append(PathesLeft,Object->gstrPath->str);
                    myFiles_SaveFileSimpleSave(PathesLeft->str, "a+");
                    //HIDDEN FLAG
                    if (Object->showHiddenFiles){
                        g_string_printf(PathesLeft, LASTPATHLEFTHIDDENID, i);
                        g_string_append(PathesLeft,TYPESEPARATOR);
                        g_string_append(PathesLeft,"true");
                        myFiles_SaveFileSimpleSave(PathesLeft->str, "a+");
                    }
                    //PREVIEW
                    if (Object->iPreview > 0){
                        g_string_printf(PathesLeft, LASTPATHLEFTPREVIEWID, i);
                        g_string_append(PathesLeft,TYPESEPARATOR);
                        g_string_append(PathesLeft,"true");
                        myFiles_SaveFileSimpleSave(PathesLeft->str, "a+");
                    }
                    //READONLY
                    if (Object->bReadOnly == TRUE){
						g_string_printf(PathesLeft, LASTPATHLEFTREADONLYID, i);
						g_string_append(PathesLeft, TYPESEPARATOR);
						g_string_append(PathesLeft, "true");
						myFiles_SaveFileSimpleSave(PathesLeft->str, "a+");
                    }
                }
            }
            //save right pathes and attributes
            guint_NoteBookTabs=0;
            i_NoteBookTabs = gtk_notebook_get_n_pages ((GtkNotebook *)Notebooks[SIDE_RIGHT]);
            if (i_NoteBookTabs > 0){
                guint_NoteBookTabs = i_NoteBookTabs;
            }
            for (i=0; i<guint_NoteBookTabs; i++){
                if ( 0== SideObjectList_GetObjectByPageNumber((GtkNotebook *)Notebooks[SIDE_RIGHT], &Object, i)){
                    //PATH
                    g_string_printf(PathesLeft, LASTPATHRIGHTID, i);
                    g_string_append(PathesLeft,TYPESEPARATOR);
                    g_string_append(PathesLeft,Object->gstrPath->str);
                    myFiles_SaveFileSimpleSave(PathesLeft->str, "a+");
                    //HIDDEN FLAG
                    if (Object->showHiddenFiles){
                        g_string_printf(PathesLeft, LASTPATHRIGHTHIDDENID, i);
                        g_string_append(PathesLeft,TYPESEPARATOR);
                        g_string_append(PathesLeft,"true");
                        myFiles_SaveFileSimpleSave(PathesLeft->str, "a+");
                    }
                    //PREVIEW
                    if (Object->iPreview > 0){
                        g_string_printf(PathesLeft, LASTPATHRIGHTPREVIEWID, i);
                        g_string_append(PathesLeft,TYPESEPARATOR);
                        g_string_append(PathesLeft,"true");
                        myFiles_SaveFileSimpleSave(PathesLeft->str, "a+");
                    }
                    //READONLY
                    if (Object->bReadOnly == TRUE){
						g_string_printf(PathesLeft, LASTPATHRIGHTREADONLYID, i);
						g_string_append(PathesLeft, TYPESEPARATOR);
						g_string_append(PathesLeft, "true");
						myFiles_SaveFileSimpleSave(PathesLeft->str, "a+");
                    }
                }
            }
        }

	}

	g_string_free(PathesLeft,TRUE);
	g_string_free(StartPath,TRUE);
	TRACEIT(10,"savePathes		ends");
}


void loadStartPathes(){
	TRACEIT(10,"loadStartPathes		start");
	int done_pathloaded=0;
	int LoadLastPathes = 0;
	int i=0;
	int firstItem=0;
	struct SideObjectList *Object=NULL;
	int iReUpdate=0;

	GString *StartPath = g_string_sized_new(30);
	GString *gstrIdentifier = g_string_sized_new(20);
	GString *gstrLastPathesLeft = g_string_sized_new(50);
	GString *gstrLastPathesRight = g_string_sized_new(50);
	GString *gstrStandardDirCommand = g_string_sized_new(10);
	GString *gstrStandardDirCommandName = g_string_sized_new(10);

    struct myFiles_struct *Savefilestru=NULL;
    configFileHandling_loadConfigFile( FALSE, FALSE );
    const char *ccpSavePathesOnExit = OptionsList_getValueByID (g_OptionsList, SAVEPATHESONEXIT);

	//fall back, no configfile found, load homedir and exit
	if (g_OptionsList == NULL){
		TRACEIT(8,"loadStartPathes		configFile NOT found");

		getStandardStartDirectory(gstrStandardDirCommand);//, gstrStandartDirCommandName);
		SideObjectList_StartWithObjectList((GtkNotebook *)Notebooks[SIDE_LEFT], gstrStandardDirCommand->str);
		SideObjectList_CreateNewViewWithPath((GtkNotebook *)Notebooks[SIDE_RIGHT], gstrStandardDirCommand->str,NULL);

		g_string_free(StartPath,TRUE);
		g_string_free(gstrLastPathesLeft,TRUE);
		g_string_free(gstrLastPathesRight,TRUE);
		g_string_free(gstrStandardDirCommand,TRUE);
		g_string_free(gstrStandardDirCommandName,TRUE);
		g_string_free(gstrIdentifier, TRUE);
		TRACEIT(10,"loadStartPathes		ends");
		return;
	}

	//check for 'save pathes on exit' property in configfile
	if (ccpSavePathesOnExit != NULL){
		g_string_assign (StartPath, ccpSavePathesOnExit);
        cutSpacesFromGString(StartPath);
        if (strcmp (StartPath->str,"true") == 0 || strcmp (StartPath->str,"True") == 0 || strcmp (StartPath->str,"TRUE") == 0){
            LoadLastPathes=1;
        }
	}

	Savefilestru = myFiles_openSaveFile("r");

	firstItem=0;
	if (LoadLastPathes==1 && Savefilestru!= NULL){// && 1==myFiles_getValueFromIdentifier(Savefilestru, LASTPATHESLEFTKEY, 0)){
		//lets get it on and load the saved pathes from savefile
		i=0;
		while (1){
			//PATH
			g_string_printf(gstrIdentifier, LASTPATHLEFTID, i);
			if ( 1 == myFiles_getValueFromIdentifier(Savefilestru, gstrIdentifier->str, 0) ){
				done_pathloaded = 1;
				if (0 == firstItem){
					SideObjectList_StartWithObjectList((GtkNotebook *)Notebooks[SIDE_LEFT], Savefilestru->gstrValue->str);
					firstItem=1;
				}
				else
					SideObjectList_CreateNewViewWithPath((GtkNotebook *)Notebooks[SIDE_LEFT], Savefilestru->gstrValue->str, NULL);
			}
			else{
				break;
			}
			SideObjectList_GetActiveObject((GtkNotebook *)Notebooks[SIDE_LEFT], &Object);
			//HIDDENFLAG
			g_string_printf(gstrIdentifier, LASTPATHLEFTHIDDENID, i);
			if ( 1 == myFiles_getValueFromIdentifier(Savefilestru, gstrIdentifier->str, 0) ){
				if (strcmp(Savefilestru->gstrValue->str, "true")==0){
					Object->showHiddenFiles=TRUE;
					iReUpdate = 1;
				}
			}
			//PREVIEW
			g_string_printf(gstrIdentifier, LASTPATHLEFTPREVIEWID, i);
			if ( 1 == myFiles_getValueFromIdentifier(Savefilestru, gstrIdentifier->str, 0) ){
				if (strcmp(Savefilestru->gstrValue->str, "true")==0){
					Object->iPreview=1;
					iReUpdate=1;
					gtk_tree_view_column_set_visible(Object->PreviewCol,TRUE);
				}
			}
			//READONLY
			g_string_printf(gstrIdentifier, LASTPATHLEFTREADONLYID, i);
			if ( 1 == myFiles_getValueFromIdentifier(Savefilestru, gstrIdentifier->str, 0) ){
				if (strcmp(Savefilestru->gstrValue->str, "true")==0){
					Object->bReadOnly=TRUE;
					iReUpdate=1;
				}
			}

			if (iReUpdate==1){
                SideObjectList_UpdateObject(Object);
                updateViewWithNewFolder(Object,NULL);
			}

			i++;
		}
	}
	//fallback, load standard start dirs from startdirectory property from configfile
	struct _OptionsList *NextItem = NULL;
	const char *ccpStandardStartDirs = NULL;
	if (done_pathloaded==0){
	    NextItem = OptionsList_getFirstItem(g_OptionsList);
        do{
            ccpStandardStartDirs = OptionsList_getValueAndNextItemByID (NextItem, &NextItem, STARTDIRECTORIESLEFTKEY);
            if (ccpStandardStartDirs){
                g_string_assign(StartPath, ccpStandardStartDirs);
                if (done_pathloaded == 0){
                    SideObjectList_StartWithObjectList((GtkNotebook *)Notebooks[SIDE_LEFT], StartPath->str);
                    done_pathloaded=1;
                }
                else{
                    SideObjectList_CreateNewViewWithPath((GtkNotebook *)Notebooks[SIDE_LEFT], StartPath->str,NULL);
                }
            }
        }while (NextItem);
	}
	// fall back, just load standard start directory (one) or at least the homedir
	if(done_pathloaded == 0){
		TRACEIT(11,"loadStartPathes		left side NOT Found");
		getStandardStartDirectory(gstrStandardDirCommand);//, gstrStandartDirCommandName);
		SideObjectList_StartWithObjectList((GtkNotebook *)Notebooks[SIDE_LEFT], gstrStandardDirCommand->str);
	}

	//RIGHT
	iReUpdate=0;
	done_pathloaded=0;
	if (LoadLastPathes==1 && Savefilestru!= NULL){// && 1==myFiles_getValueFromIdentifier(Savefilestru, LASTPATHESLEFTKEY, 0)){
		//lets get it on and load the saved pathes from savefile
		i=0;
		while (1){
			//PATH
			g_string_printf(gstrIdentifier, LASTPATHRIGHTID, i);
			if ( 1 == myFiles_getValueFromIdentifier(Savefilestru, gstrIdentifier->str, 0) ){
				done_pathloaded = 1;
				SideObjectList_CreateNewViewWithPath((GtkNotebook *)Notebooks[SIDE_RIGHT], Savefilestru->gstrValue->str, NULL);
			}
			else{
				break;
			}
			SideObjectList_GetActiveObject((GtkNotebook *)Notebooks[SIDE_RIGHT], &Object);
			//HIDDENFLAG
			g_string_printf(gstrIdentifier, LASTPATHRIGHTHIDDENID, i);
			if ( 1 == myFiles_getValueFromIdentifier(Savefilestru, gstrIdentifier->str, 0) ){
				if (strcmp(Savefilestru->gstrValue->str, "true")==0){
					Object->showHiddenFiles=TRUE;
					iReUpdate=1;
				}
			}
			//PREVIEW
			g_string_printf(gstrIdentifier, LASTPATHRIGHTPREVIEWID, i);
			if ( 1 == myFiles_getValueFromIdentifier(Savefilestru, gstrIdentifier->str, 0) ){
				if (strcmp(Savefilestru->gstrValue->str, "true")==0){
					Object->iPreview=1;
					iReUpdate=1;
					gtk_tree_view_column_set_visible(Object->PreviewCol,TRUE);
				}
			}
			//READONLY
			g_string_printf(gstrIdentifier, LASTPATHRIGHTREADONLYID, i);
			if ( 1 == myFiles_getValueFromIdentifier(Savefilestru, gstrIdentifier->str, 0) ){
				if (strcmp(Savefilestru->gstrValue->str, "true")==0){
					Object->bReadOnly=TRUE;
					iReUpdate=1;
				}
			}

			if (iReUpdate==1){
                SideObjectList_UpdateObject(Object);
					updateViewWithNewFolder(Object,NULL);
			}

			i++;
		}
	}
	//fallback, load standard start dirs from startdirectory property from configfile
	if (done_pathloaded==0){
	    NextItem = OptionsList_getFirstItem(g_OptionsList);
        do{
            ccpStandardStartDirs = OptionsList_getValueAndNextItemByID (NextItem, &NextItem, STARTDIRECTORIESRIGHTKEY);
            if (ccpStandardStartDirs){
                g_string_assign(StartPath, ccpStandardStartDirs);
                //if (done_pathloaded == 0){
                //    SideObjectList_StartWithObjectList((GtkNotebook *)Notebooks[SIDE_RIGHT], StartPath->str);
                //    done_pathloaded=1;
                //}
                //else{
                SideObjectList_CreateNewViewWithPath((GtkNotebook *)Notebooks[SIDE_RIGHT], StartPath->str,NULL);
                done_pathloaded=1;
                //}
            }
        }while (NextItem);
	}
	// fall back, just load standard start directory (one) or at least the homedir
	if(done_pathloaded == 0){
		getStandardStartDirectory(gstrStandardDirCommand);//, gstrStandartDirCommandName);
		SideObjectList_CreateNewViewWithPath((GtkNotebook *)Notebooks[SIDE_RIGHT], gstrStandardDirCommand->str,NULL);
    }

	//clean up
    myFiles_closeFile(Savefilestru);
	g_string_free(StartPath,TRUE);
	g_string_free(gstrLastPathesLeft,TRUE);
	g_string_free(gstrLastPathesRight,TRUE);
	g_string_free(gstrStandardDirCommand,TRUE);
	g_string_free(gstrStandardDirCommandName,TRUE);
	g_string_free(gstrIdentifier, TRUE);
	TRACEIT(10,"loadStartPathes		ends");
}


void bringAllToTheRightOrder(){
	TRACEIT(10,"bringAllToTheRightOrder		start");

	//PathEntry, 1UP Button
	gtk_box_pack_start(GTK_BOX(HBoxForButtonsAndPathEntry[SIDE_LEFT]),GTK_WIDGET(PathEntryBox[SIDE_LEFT]),TRUE,TRUE,1);
	gtk_box_pack_start(GTK_BOX(HBoxForButtonsAndPathEntry[SIDE_LEFT]),GTK_WIDGET(OnePathUpButton[SIDE_LEFT]),FALSE,FALSE,1);
	gtk_box_pack_end(GTK_BOX(HBoxForButtonsAndPathEntry[SIDE_RIGHT]),GTK_WIDGET(PathEntryBox[SIDE_RIGHT]),TRUE,TRUE,1);
	gtk_box_pack_end(GTK_BOX(HBoxForButtonsAndPathEntry[SIDE_RIGHT]),GTK_WIDGET(OnePathUpButton[SIDE_RIGHT]),FALSE,FALSE,1);

	//Bring components of each side toghether
	gtk_box_pack_start(GTK_BOX(VBox[SIDE_LEFT]),GTK_WIDGET(HBoxForButtonsAndPathEntry[SIDE_LEFT]),FALSE,FALSE,1);
	gtk_box_pack_start(GTK_BOX(VBox[SIDE_LEFT]),GTK_WIDGET(Notebooks[SIDE_LEFT]),TRUE,TRUE,1);

	gtk_box_pack_start(GTK_BOX(VBox[SIDE_RIGHT]),GTK_WIDGET(HBoxForButtonsAndPathEntry[SIDE_RIGHT]),FALSE,FALSE,1);
	gtk_box_pack_start(GTK_BOX(VBox[SIDE_RIGHT]),GTK_WIDGET(Notebooks[SIDE_RIGHT]),TRUE,TRUE,1);

	//Bring the two sides together
	gtk_paned_pack1(GTK_PANED(HPanedLeftRight),GTK_WIDGET(VBox[SIDE_LEFT]),TRUE,TRUE);
	gtk_paned_pack2(GTK_PANED(HPanedLeftRight),GTK_WIDGET(VBox[SIDE_RIGHT]),TRUE,TRUE);

	//There is one more pane
	gtk_paned_pack1(GTK_PANED(VPanedForFileShelf),GTK_WIDGET(HPanedLeftRight),TRUE,TRUE);

	//Connect it with mainwindow
	gtk_container_add (GTK_CONTAINER(win),VPanedForFileShelf);

	TRACEIT(10,"bringAllToTheRightOrder		ends");
}


int AddPathesToNotebook(GtkNotebook *Notebook, GString *gstrPathes, int AllreadyStarted){
	// gets one path and add this path to the note
	TRACEIT(10,"AddPathesToNotebook		start");
	int WeStarted=0;
	const char sep[] = PROGRAMSEPERATOR;
	char *cOnePath=NULL;
	GString *gstrOnePath=g_string_sized_new(10);

	cOnePath = strtok(gstrPathes->str,sep);
	if (cOnePath == NULL){
		TRACEIT(7,"AddPathesToNotebook		ends, NOT A PATH");
		return -1;
	}
	while(cOnePath != NULL){
	    g_string_assign(gstrOnePath, cOnePath);
	    cutLeadingSpacesFromGString(gstrOnePath);
		if (AllreadyStarted == 0 && WeStarted == 0){
			SideObjectList_StartWithObjectList(Notebook, gstrOnePath->str);
			WeStarted = 1;
		}
		else{
			SideObjectList_CreateNewViewWithPath(Notebook, gstrOnePath->str, NULL);
		}
		cOnePath = strtok(NULL,sep);
	}
	TRACEIT(10,"AddPathesToNotebook		ends");
	return 1;
}


void updatePathEntryBox(GtkNotebook *notebook, guint num){
	TRACEIT(10,"updatePathEntryBox		start");
	struct SideObjectList *Object=NULL;
	SideObjectList_GetObjectByPageNumber(notebook,&Object,(int)num);
	if (Object == NULL){
		TRACEIT(2,"updatePathEntryBox		ends, No Object??");
		return;
	}

	int leftORright = (Object->notebook == (GtkNotebook *)Notebooks[SIDE_LEFT])?SIDE_LEFT:SIDE_RIGHT;
	g_object_set(PathEntryBox[leftORright],"text",Object->gstrPath->str,NULL);
	TRACEIT(10,"updatePathEntryBox		ends");
}


gboolean onePageSwitched(GtkNotebook *notebook, GtkNotebookPage *page, guint page_num, gpointer user_data){
	TRACEIT(10,"onePageSwitched		start");
	updatePathEntryBox(notebook,page_num);

	struct SideObjectList *Object=NULL;
	if (gint_Starting == 0){
	    SideObjectList_GetObjectByPageNumber(notebook, &Object, page_num);
	    if (Object->bUpdateFlag_UpdateOnTabSwitch){
	        //Object->bUpdateFlag_F6=FALSE;
            updateView(Object);
            Object->bUpdateFlag_UpdateOnTabSwitch=FALSE;
	    }
	}
	TRACEIT(10,"onePageSwitched		ends");
	return FALSE;
}


gboolean oneMouseButtonPressedOnNotebook(GtkWidget *notebook, GdkEventButton *event, gpointer data){
	TRACEIT(10,"oneMouseButtonPressedOnNotebook		start");

	int leftORrightOrFileshelf = GPOINTER_TO_INT(data);

	//event->button = 2 is the middle mousebutton, I've tried many things but the problem, that the
	//tab, the mouse is over, will be deleted only once still was there. All further klicks on the
	//middle mouse button delete just the tab which is currently active, without activating the one
	//the mouse is over. So I decided to forget this feature. However, now it is possible to close a
	//tab via double click with the left mouse button
	//IT SEEMS THIS WAS A BUG in a earlier release in compination with FreeBSD or something like
	//that, however, now it works just great and from now on, we close the tabs via the middle mouse button.
	if (event->type == GDK_BUTTON_PRESS  &&  (event->button == 3 /*|| event->button==2*/)){
	    //contextMenu
		//If the user makes a right click on an unselected Tab we want the notbook to select the Tab the mouse is over.
		//So we sent an left click event to the notebook and it will make the work for us
		GdkEventButton newEvent;
		newEvent.type = event->type;
		newEvent.window = event->window;
		newEvent.send_event = event->send_event;
		newEvent.time = event->time+1;
		newEvent.x = event->x;
		newEvent.y = event->y;
		newEvent.axes = event->axes;
		newEvent.state = event->state;
		newEvent.button = 1;
		newEvent.device = event->device;
		newEvent.x_root = event->x_root;
		newEvent.y_root = event->y_root;

		gboolean ret;

		g_signal_emit_by_name (notebook,"button-press-event",&newEvent,&ret);
		newEvent.type= GDK_BUTTON_RELEASE;
		g_signal_emit_by_name (notebook,"button-press-event",&newEvent,&ret);

        if (leftORrightOrFileshelf <= SIDE_BOTH){
            openTabContextMenu(notebook,event,data);	//Look near the end of the file
        }
        else if(leftORrightOrFileshelf == SIDE_FILESHELF){
            openFileShelfTabContextMenu(notebook,event,data);
        }

		TRACEIT(10,"oneMouseButtonPressedOnNotebook		ends");
		return TRUE;
	}
	else if(event->type == GDK_2BUTTON_PRESS &&  event->button == 1){
	    //New Tab
		if (leftORrightOrFileshelf <= SIDE_BOTH){
            addNewPage(NULL, notebook);
		}
		else if(leftORrightOrFileshelf == SIDE_FILESHELF){
            NewFileShelf(NULL);
		}
		return TRUE;
	}
	else if (event->type == GDK_BUTTON_PRESS  &&  (event->button==2)){
	    //close tab
		//If the user makes a right click on an unselected Tab we want the notbook to select the Tab the mouse is over.
		//So we sent an left click event to the notebook and it will make the work for us
		GdkEventButton newEvent;
		newEvent.type = event->type;
		newEvent.window = event->window;
		newEvent.send_event = event->send_event;
		newEvent.time = event->time+1;
		newEvent.x = event->x;
		newEvent.y = event->y;
		newEvent.axes = event->axes;
		newEvent.state = event->state;
		newEvent.button = 1;
		newEvent.device = event->device;
		newEvent.x_root = event->x_root;
		newEvent.y_root = event->y_root;

		gboolean ret;

		g_signal_emit_by_name (notebook,"button-press-event",&newEvent,&ret);
		newEvent.type= GDK_BUTTON_RELEASE;
		g_signal_emit_by_name (notebook,"button-press-event",&newEvent,&ret);

        if (leftORrightOrFileshelf <= SIDE_BOTH){
			SideObjectList_DeleteActiveObject((GtkNotebook *)notebook);
		}
		else if(leftORrightOrFileshelf == SIDE_FILESHELF){
			FileShelf_DeleteActiveTab();
		}

		return TRUE;
	}

	TRACEIT(10,"oneMouseButtonPressedOnNotebook		ends");
	return FALSE;
}


void onePageAddedToNotebook(GtkNotebook *notebook, GtkWidget *child, guint page_num, gpointer data){
	TRACEIT(10,"onePageAddedToNotebook		start");
	struct SideObjectList *Object=NULL;
	SideObjectList_GetObjectByPageNumber(notebook,&Object,page_num);
	if (Object == NULL){
		TRACEIT(10,"onePageAddedToNotebook		ends");
		return;
	}

	gtk_notebook_set_current_page(notebook,page_num);

	updateViewWithNewFolder(Object,Object->gstrPath);   //dont change this, we need the the newPath here for moitoring, look updateViewWithNewFolder
	TRACEIT(10,"onePageAddedToNotebook		ends");
}


gboolean oneMouseButtonPressed(GtkWidget *treeview, GdkEventButton *event, gpointer data){
	TRACEIT(10,"oneMouseButtonPressed		start");
    GdkEventButton newEvent;
	struct SideObjectList *Object=(struct SideObjectList *)data;

    //dragndrop - related
    //I want to explain the following lines till //END-EXPLAINLINES:
    // This lines are here for the dragndrop thing. When marking more than one item and we want them to drag and drop we have to
    // catch this mousebutton event (this is the first if statement).
    // But we also have to unselect all the others when a simple mousebutten event on one item occurs. This is the second if statement.
    // We define an area in which we onyl select the item the mousepointer is over.
	GtkTreeSelection *selection=NULL;
    selection  = gtk_tree_view_get_selection((GtkTreeView *)treeview);
    guint modifiers;
	modifiers = gtk_accelerator_get_default_mod_mask ();
    static double x=0;
    static double y=0;
    GtkTreePath *path=NULL;
	if (gtk_tree_selection_count_selected_rows(selection)  > 1 ){   //onyl catch this if more than one item is selected
        if (event->type == GDK_BUTTON_PRESS  &&  event->button == 1){   //and it is the 1st mouse button
            if ((event->state & modifiers) == 0){                       //and no modifiers (such as ctrl or alt) are pressed.
                //when we have an event not over an selected Path we ignore the event
                gtk_tree_view_get_path_at_pos ( (GtkTreeView *)treeview, (gint) event->x, (gint) event->y, &path, NULL, NULL, NULL);
                if (path != NULL){  //may be NULL if the area which is clicked has no item
                    if (TRUE == gtk_tree_selection_path_is_selected (selection, path)){
                        gtk_tree_path_free (path);
                        x=event->x;
                        y=event->y;
                        return TRUE;
                    }
                    gtk_tree_path_free (path);
                }
                else{
                    gtk_tree_selection_unselect_all(selection); //dont waste time and unmark the items
                }
            }
		}
	}
    if (gtk_tree_selection_count_selected_rows(selection)  > 1 ){
        if (event->type == GDK_BUTTON_RELEASE  &&  event->button == 1){
            if ((event->state & modifiers) == 0){
                if (x-event->x < 6.0 && y-event->y < 6.0){
                    gtk_tree_selection_unselect_all(selection);
                    x=0;
                    y=0;
                    if (event->window == gtk_tree_view_get_bin_window ((GtkTreeView *)treeview)){
                        gtk_tree_view_get_path_at_pos ( (GtkTreeView *)treeview, (gint) event->x, (gint) event->y, &path, NULL, NULL, NULL);
                        if (path != NULL){  //may be NULL if the area which is clicked has no item
                            gtk_tree_selection_select_path (selection,  path);
                            gtk_tree_path_free (path);
                        }
                    }
                    return TRUE;
                }
            }
		}
	}
    //END-EXPLAINLINES (dragndrop - related)

	if (event->type == GDK_BUTTON_PRESS  &&  event->button == 3){
		openContextMenu(treeview,event,data);	//Look near the end of the file
		TRACEIT(10,"oneMouseButtonPressed		ends");
		return TRUE;
	}
	if (event->type == GDK_BUTTON_PRESS  &&  event->button == 2){ //we mark all items of the view which have the same endings as the one allready marked
	    //we fire an mousebutton 1 event to the same position to get the item selected the mouse is over
        newEvent.type = event->type;
		newEvent.window = event->window;
		newEvent.send_event = event->send_event;
		newEvent.time = event->time+1;
		newEvent.x = event->x;
		newEvent.y = event->y;
		newEvent.axes = event->axes;
		newEvent.state = event->state;
		newEvent.button = 1;
		newEvent.device = event->device;
		newEvent.x_root = event->x_root;
		newEvent.y_root = event->y_root;

		gboolean ret;

		g_signal_emit_by_name (treeview,"button-press-event",&newEvent,&ret);
		newEvent.type= GDK_BUTTON_RELEASE;
		g_signal_emit_by_name (treeview,"button-press-event",&newEvent,&ret);

		markItemsWithSameType((GtkTreeView *)Object->listView, COL_FILETYPE);
		TRACEIT(10,"oneMouseButtonPressed		ends");
		return TRUE;
	}
	TRACEIT(10,"oneMouseButtonPressed		ends");
	return FALSE;
}


gboolean oneContextMenuReplied(GtkWidget *treeview, gpointer data){
	TRACEIT(10,"oneContextMenuReplied		start");
	openContextMenu(treeview,NULL, data);	//Look near the end of the file
	TRACEIT(10,"oneContextMenuReplied		ends");
	return TRUE;
}


gboolean oneNoteBookContextMenuReplied(GtkWidget *treeview, gpointer data){
    TRACEIT(10,"oneNoteBookContextMenuReplied		start");
	openTabContextMenu(treeview,NULL, NULL);	//Look near the end of the file
	TRACEIT(10,"oneNoteBookContextMenuReplied		ends");
	return TRUE;
}


gboolean oneKeyPressedOnNotebook(GtkWidget *widget, GdkEventKey *event, gpointer data){
    //data = SIDE_LEFT || SIDE_RIGHT
    //We pass key events to the view (SideObjects AND Fileshelf)
	TRACEIT(10,"oneKeyPressedOnNotebook		start");
	struct SideObjectList *SideObject=NULL;
	struct FileShelfObjectList *ShelfObject=NULL;
	int leftORrightOrFileshelf = GPOINTER_TO_INT(data);
    gboolean bRet = FALSE;

    if (leftORrightOrFileshelf <= SIDE_BOTH){
        SideObjectList_GetActiveObject((GtkNotebook *)Notebooks[leftORrightOrFileshelf], &SideObject);
        if (SideObject == NULL){
            TRACEIT(3,"oneKeyPressedOnNotebook		end, No Object found");
            return FALSE;
        }
        bRet = oneKeyPressedInView(NULL, event, (void *)SideObject);
	}
	else if(leftORrightOrFileshelf == SIDE_FILESHELF){
        FileShelfObjectList_GetActiveObject(&ShelfObject);
        if (ShelfObject == NULL){
            TRACEIT(3,"oneKeyPressedOnNotebook		end, No Object found");
            return FALSE;
        }
        bRet = oneFileShelfKeyPressedInView(NULL, event, (void *)ShelfObject);
    }

	TRACEIT(10,"oneKeyPressedOnNotebook		end");
	return bRet; //if we do not handle it return FALSE
}


gboolean oneKeyPressedInView(GtkWidget *widget, GdkEventKey *event, gpointer data){
    //Be aware of using widget, as this function is called when a key is pressed on a notebook (tab) too
    //data = struct SideObjectList
	TRACEIT(10,"oneKeyPressedInView		start");
	guint modifiers;

	modifiers = gtk_accelerator_get_default_mod_mask ();
	struct SideObjectList *Object = (struct SideObjectList *)data;
    int leftORright = (Object->notebook == (GtkNotebook *)Notebooks[SIDE_LEFT])?SIDE_LEFT:SIDE_RIGHT;

	if ( (event->keyval == GDK_Delete)){
	    //Delete selected files with 'del-key'
		mayDeleteSelectedRows(NULL, data);
		TRACEIT(10,"oneKeyPressedInView		ends");
		return TRUE;
	}
	else if ( (event->keyval == GDK_Return)){
        //go to directory or start userprogram with marked items
        oneRowActivated_SideObjectWrap(NULL, NULL, NULL, data);
        return TRUE;
	}
	else if (event->keyval == GDK_BackSpace){
	    //One path up with backspace
        oneOnePathUpButtonClicked(NULL, GINT_TO_POINTER (leftORright));
        return TRUE;
	}
	else if (event->keyval == GDK_F2){
        //rename selected
        renameItems(NULL, data);
        return TRUE;
	}
    else if (event->keyval == GDK_F3){
	    //create New Directory
        mayNewDirectory(NULL, data);
        return TRUE;
	}
    else if (event->keyval == GDK_F4){
	    //open Terminal
        UserOption_callTerminal(Object, SOURCE_SIDEOBJECT);
        return TRUE;
	}
	else if (event->keyval == GDK_F5){
	    //Update view with
        updateViewWithNewFolder_UserAdvice(Object, NULL);
        return TRUE;
	}
	else if (event->keyval == GDK_F6){
	    //Update view with

	    //We do not need this here because calcDirectorySizeInView_wrap will wait for thread and abort if another thread allready is running
	    //calcDirectorySizeInView_closeProcess (&(Object->iRecursiveSizeCalculation), &(Object->gthreadF6Updage));
	    //#ifdef NO_GIO
	    //updateView(Object); //we do not need this any longer, because of our automatic update
	    //#endif
        //Object->bUpdateFlag_F6=TRUE;
	    struct AllInformationAllUseStruct *stru = malloc (sizeof(struct AllInformationAllUseStruct));
	    if (stru == NULL){
            TRACEIT(1,"oneKeyPressedInView		error allocating memory");
            return TRUE;
	    }
        stru->source=SOURCE_SIDEOBJECT;
        stru->Info_1 = data;
        stru->Info_2 = &(Object->gthreadF6Updage);
        stru->Info_3 = &(Object->iRecursiveSizeCalculation);
        stru->Info_4 = &(Object->bUpdateFlag_F6);
        stru->Info_5 = NULL;

        calcDirectorySizeInView_wrap(stru);

        return TRUE;
	}

	else if ((event->keyval == 'c' || event->keyval == 'C') && (event->state & modifiers) == GDK_CONTROL_MASK){
        //Copy Paste // here is copy
        CopyPasteCreateList_SideObject(data, 1);
        return TRUE;
	}
	else if ((event->keyval == 'x' || event->keyval == 'X') && (event->state & modifiers) == GDK_CONTROL_MASK){
        //Copy Paste // here is cut
        CopyPasteCreateList_SideObject(data, 2);
        return TRUE;
	}
	else if ((event->keyval == 'v' || event->keyval == 'V') && (event->state & modifiers) == GDK_CONTROL_MASK){
        //Copy Paste // here is paste
        CopyPasteProcessList_SideObject(data);
        return TRUE;
	}
	else if ((event->keyval == 'n' || event->keyval == 'N') && (event->state & modifiers) == GDK_CONTROL_MASK){
        //new page
        addNewPage(NULL, Object->notebook);
        return TRUE;
	}
	else if ((event->keyval == 'i' || event->keyval == 'I') && (event->state & modifiers) == GDK_CONTROL_MASK){
        //size of selected
        sizeOfSelectedItemsRecursive (NULL, data);
        return TRUE;
	}
	else if ((event->keyval == 'h' || event->keyval == 'H') && (event->state & modifiers) == GDK_CONTROL_MASK){
        //show hidden files
        showHiddenFilesInActivePage(NULL, Object->notebook);
        return TRUE;
	}
	else if((event->keyval == 'a' || event->keyval == 'A') && (event->state & modifiers) == GDK_CONTROL_MASK){
	    //select all
        mySelectAllFunction((GtkTreeView *)Object->listView, (void *)Object);
        return TRUE;
	}
	else if ((event->keyval == 's' || event->keyval == 'S') && (event->state & modifiers) == GDK_CONTROL_MASK){
	    //Add selected items to active fileshelf
		MenuAddItemToFileshelf(NULL, data);
		return TRUE;
	}
	else if ((event->keyval == 'd' || event->keyval == 'D') && (event->state & modifiers) == GDK_CONTROL_MASK){
	    //Add selected items to new fileshelf
		MenuAddToNewFileshelf(NULL, data);
		return TRUE;
	}
	else if ((event->keyval == 'f' || event->keyval == 'F') && (event->state & modifiers) == GDK_MOD1_MASK){
        //my search function
        searchStringInAndHighlightItems_WraperforSideObject(NULL, Object->listView);
        return TRUE;
	}
	else if ((event->keyval == 'c' || event->keyval == 'C') && (event->state & modifiers) == GDK_MOD1_MASK){
        //copy selected to other side
        copyToOtherPannel(NULL, data);
        return TRUE;
	}
	else if ((event->keyval == 'x' || event->keyval == 'X') && (event->state & modifiers) == GDK_MOD1_MASK){
        //move selected to other side
        moveToOtherPannel(NULL, data);
        return TRUE;
	}
	else if ((event->keyval == 'y' || event->keyval == 'Y') && (event->state & modifiers) == GDK_CONTROL_MASK){
		//copies the marked names withOUT path to the real clipboard
		markedNamesToClipboard((GtkTreeView *)Object->listView, FALSE, COL_NAME, -1, NULL);
		//markedNamesToClipboard(GtkTreeView *TreeView, gboolean bWithPath, int iColumnName, int iColumnPath, char *cpPath)
		return TRUE;
	}
	else if ((event->keyval == 'y' || event->keyval == 'Y') && (event->state & modifiers) == GDK_MOD1_MASK){
		//copies the marked names WITH path to the real clipboard
		markedNamesToClipboard((GtkTreeView *)Object->listView, TRUE, COL_NAME, -1, Object->gstrPath->str);
		return TRUE;
	}
	else if ((event->keyval == 'p' || event->keyval == 'P') && (event->state & modifiers) == GDK_CONTROL_MASK){
        // Enable/Disable Preview for current Tab
        ChangePreviewState(NULL, Object);
        return TRUE;
	}
	else if ((event->keyval == 'r' || event->keyval == 'R') && (event->state & modifiers) == GDK_CONTROL_MASK){
		//enable/disable read only
		ChangeReadOnlyState(NULL, Object);
		return TRUE;
	}


	TRACEIT(10,"oneKeyPressedInView		ends");
	return FALSE;
}


void oneOnePathUpButtonClicked(GtkButton *button, gpointer data){
	TRACEIT(10,"oneOnePathUpButtonClicked		start");
	int leftORright = GPOINTER_TO_INT(data);

	struct SideObjectList *Object=NULL;

	SideObjectList_GetActiveObject(GTK_NOTEBOOK(Notebooks[leftORright]), &Object);
	if (Object == NULL){
		TRACEIT(10,"oneOnePathUpButtonClicked		ends");
		return;
	}
    GString *gstrPath = g_string_new(Object->gstrPath->str);

	checkPathForLastChar(gstrPath);
	g_string_append(gstrPath,"..");
	g_object_set(PathEntryBox[leftORright],"text",gstrPath->str,NULL);
	gtk_widget_activate(GTK_WIDGET(PathEntryBox[leftORright]));
    g_string_free(gstrPath, TRUE);
	TRACEIT(10,"oneOnePathUpButtonClicked		ends");
}


void oneColumnWasClicked(GtkTreeViewColumn *Column, gpointer data){
	TRACEIT(10,"oneColumnWasClicked		start");
	struct SideObjectList *Object=(struct SideObjectList *)data;
	Object->actualSortCol = Column;
	TRACEIT(10,"oneColumnWasClicked		ends");
}


void oneRowActivated_SideObjectWrap(GtkTreeView *treeview, GtkTreePath *TreePath, GtkTreeViewColumn *col, gpointer data){
    struct AllInformationAllUseStruct stru;

    stru.source = SOURCE_SIDEOBJECT;
    stru.Info_1 = data; //SideObject
    stru.Info_2 = NULL;
    stru.Info_3 = NULL;
    stru.Info_4 = NULL;
    stru.Info_5 = NULL;

    //oneRowActivated (treeview, TreePath, col, (void *)&stru);
    oneRowActivated (&stru);

}


void oneRowActivated(struct AllInformationAllUseStruct *stru){
    GtkTreeSelection *selection=NULL;
    int i_rowsSelected=0;
    int i_oneIsDirectory=0;
    int i_oneIsPoints=0;
    GtkWidget *ListView=NULL;
    struct SideObjectList *SideObject=NULL;
    struct FileShelfObjectList *FlShlfObject=NULL;
    GList *list=NULL;
    GtkTreeModel *model;
    GtkTreeIter iter;
	gchar *name=NULL;
	gchar *path=NULL;
	gint type_d;
	GString *NewPath=g_string_sized_new(20);
	int side=stru->source;
	struct AllInformationAllUseStruct info;

    info.source = side;
    if (stru->source == SOURCE_SIDEOBJECT){
        SideObject=(struct SideObjectList *)stru->Info_1;
    }
    else{
        FlShlfObject = (struct FileShelfObjectList *)stru->Info_1;
        //FileShelfObjectList_GetActiveObject(&Object);
	}
	if ( (side==SOURCE_SIDEOBJECT && SideObject==NULL) || (side==SOURCE_FILESHELF && FlShlfObject== NULL) ){
	    TRACEIT(2,"oneRowActivated		end, found exception");
		return;
	}
	if (side==SOURCE_SIDEOBJECT){
	    info.Info_1 = (void *)SideObject->listView;
        ListView = SideObject->listView;
        i_oneIsDirectory = checkIfOneSelectionIsPath(ListView, COL_TYPE_D);
        i_oneIsPoints = checkIfOneSelectionIsPoints(ListView, COL_NAME);
	}
    else{
        info.Info_1 = (void *)FlShlfObject->listView;
	    ListView = FlShlfObject->listView;
	    i_oneIsDirectory = checkIfOneSelectionIsPath(ListView, COL_FLSHLF_TYPE_D);
	    i_oneIsPoints = checkIfOneSelectionIsPoints(ListView, COL_FLSHLF_NAME);
    }

	selection  = gtk_tree_view_get_selection((GtkTreeView *)ListView);
    i_rowsSelected = gtk_tree_selection_count_selected_rows(selection);

    if (i_rowsSelected > 1 && (i_oneIsDirectory!=0 || i_oneIsPoints!=0)){   //We do not handle this!!, e.g. more than one directory selected, or normal items and directories are selected
        //TODO!!!!!!! error message in stutusbar
        if (side==SOURCE_SIDEOBJECT){
            gtk_statusbar_pop(SideObject->StatusBar,0);
            gtk_statusbar_push(SideObject->StatusBar,0,"There is more than one directory selected... can't do anything.");
        }
        return;
    }
    else if (i_rowsSelected != 0 && i_oneIsDirectory!=0){   //Its ONE directory we want to go to
        list = gtk_tree_selection_get_selected_rows (selection, &model);
        gtk_tree_model_get_iter (model, &iter, (GtkTreePath *)list->data);

        if (side == SOURCE_SIDEOBJECT){
            gtk_tree_model_get(model, &iter,COL_NAME,&name,COL_TYPE_D,&type_d, -1);
        }
        else{
            gtk_tree_model_get(model, &iter,COL_FLSHLF_NAME,&name,COL_FLSHLF_TYPE_D,&type_d,COL_FLSHLF_PATH,&path, -1);
        }
        if ((type_d==4 || type_d==10) && strcmp(name,".")!=0){	//Folder!
            if (side==SOURCE_SIDEOBJECT){
                g_string_assign(NewPath, SideObject->gstrPath->str);
                checkPathForLastChar(NewPath);
                g_string_append(NewPath,name);
                formatPathString(NewPath);
                updateViewWithNewFolder_UserAdvice(SideObject,NewPath);
            }
            else{
                g_string_assign(NewPath,path);
                checkPathForLastChar(NewPath);
                g_string_append(NewPath,name);
                SideObjectList_CreateNewViewWithPath(NULL,NewPath->str,NULL);
            }
        }
        g_list_foreach (list, (GFunc)gtk_tree_path_free, NULL);
        g_list_free (list);
    }
    else if (i_oneIsDirectory==0 && i_oneIsPoints==0){  //one or more items to call
        if (NULL != g_UserDataList){
            UserDataList_DeleteList(&g_UserDataList);
            //g_UserDataList = NULL;	//this is allready done by the deleteList function
        }
        GList *glistMarkedTypes=NULL;

        glistMarkedTypes = getTypesOfSelectedItems(&info);
        getUserProgramsForSelectedItems(glistMarkedTypes, &g_UserDataList);   //u will get the commands which 'countForAllItems' too
        if (NULL != glistMarkedTypes){
            g_string_assign (NewPath, ((GString *)(glistMarkedTypes->data))->str);
            g_list_foreach(glistMarkedTypes, (GFunc) GListFreeGStrings, NULL);
            g_list_free(glistMarkedTypes);
            glistMarkedTypes = NULL;
        }
        struct UserDataList *UserDataListBuf = UserDataList_getStandardItem(g_UserDataList);
        if (UserDataListBuf != NULL){
            if (stru->source == SOURCE_SIDEOBJECT){
                UserDataListBuf->iSourceType = SOURCE_SIDEOBJECT;
                UserDataListBuf->Object = (void *)SideObject;
            }
            else{
                UserDataListBuf->iSourceType = SOURCE_FILESHELF;
                UserDataListBuf->Object = (void *)FlShlfObject;
            }

            startItemsWithUserCommand(NULL, (void *)UserDataListBuf);
        }
        else{
            g_string_prepend (NewPath, "Sorry, there is no default command\ndefined for this type of file: \"");
            g_string_append (NewPath, "\"\n\nPlease mind that in the case that\nthere are more items marked,\nonly the first item type is used.");
            MyMessageWidget (win, "Error",NewPath->str);
        }
    }
    if (name)
        g_free(name);
    if (path)
        g_free(path);
    g_string_free(NewPath,TRUE);

}


gboolean oneKeyPressed_PathEntry(GtkWidget *widget, GdkEventKey *event, gpointer data){
    TRACEIT(10,"oneKeyPressed_PathEntry		start");
    char *completed=NULL;
    char *cpPath=NULL;
    int iCurrentPosition=0;
    int ret=0;

    if ( (event->keyval == GDK_Tab)){   //PATH COMPLETION
        g_object_get(widget,"text",&cpPath,NULL);
        if (cpPath != NULL){
            ret = completePath(cpPath, &completed);
            if (completed){
                g_object_set(widget,"text",completed,NULL);
                gtk_editable_set_position ( (GtkEditable *)widget, -1); //sets the cursor to the end
                iCurrentPosition = gtk_editable_get_position ((GtkEditable *)widget);
                if (ret == 2){  //directory is valid
                    gtk_editable_insert_text ( (GtkEditable *)widget, "/", -1, &iCurrentPosition );
                    gtk_editable_set_position ( (GtkEditable *)widget, -1); //sets the cursor to the end
                }
                free(completed);
            }
            free(cpPath);
        }
        TRACEIT(10,"oneKeyPressed_PathEntry		end");
        return TRUE;
    }
    TRACEIT(10,"oneKeyPressed_PathEntry		end");
    return FALSE;
}


void onePathChanged(GtkEntry *entry, gpointer g){
	TRACEIT(10,"onePathChanged		start");
	gchar *NewPath=NULL;

	int leftORright = GPOINTER_TO_INT(g);
	if (leftORright == SIDE_LEFT)
		g_object_get(PathEntryBox[SIDE_LEFT], "text", &NewPath, NULL);
	else
		g_object_get(PathEntryBox[SIDE_RIGHT], "text", &NewPath, NULL);

	//Test if NewPath exists
	struct SideObjectList *Object=NULL;
	SideObjectList_GetActiveObject(GTK_NOTEBOOK(Notebooks[leftORright]), &Object);
	if (Object==NULL){
	    if (NewPath)
            g_free(NewPath);
		return;
	}
	GString *gstrbuf = g_string_new(NewPath);
	formatPathString(gstrbuf);
	if (-1 == checkDirectory(Object,gstrbuf)){
		g_string_free(gstrbuf,TRUE);
		if (NewPath)
            g_free(NewPath);
		TRACEIT(10,"onePathChanged		ends");
		return;
	}
	updateViewWithNewFolder_UserAdvice(Object, gstrbuf);

	g_string_free(gstrbuf,TRUE);
	if (NewPath)
        g_free(NewPath);
	TRACEIT(10,"onePathChanged		ends");
}


static void sizeOfSelected_Helper (GtkTreeModel *model,GtkTreePath *path,GtkTreeIter *iter,gpointer data){
	TRACEIT(10,"sizeOfSelected_Helper		start");
	struct SideObjectList *Object = (struct SideObjectList *)data;

	guint64 isize;
	gint type_d;
	gchar *name=NULL;

	GString *Path= g_string_new(Object->gstrPath->str);

	if (gtk_tree_model_get_iter(model, iter, path)){
		gtk_tree_model_get(model, iter, COL_SIZE, &isize, COL_NAME, &name, COL_TYPE_D, &type_d, -1);
		if ( strcmp(name,".")!=0 && strcmp(name,"..")!=0){
			Object->guint64sizeOfSelectedItems+=isize;
		}
	}

	g_string_free(Path,TRUE);
	if (name)
		g_free(name);

	TRACEIT(10,"sizeOfSelected_Helper		ends");
}


void updateStatusBar(struct SideObjectList *Object){
    GtkTreeSelection	*treeselection;
	char buf[266];  //266 should do the job, as it just represents a number (size in bytes)
	int len;
	GString *gstrBuf = g_string_sized_new(10);
	GString *gstrBuf2 = g_string_sized_new(10);
	void *data = (void *)Object;

	treeselection  = gtk_tree_view_get_selection((GtkTreeView *)Object->listView);
	Object->guint64sizeOfSelectedItems=0;
	gtk_tree_selection_selected_foreach(treeselection, sizeOfSelected_Helper, data);

	snprintf(buf,265,"%lld",Object->guint64sizeOfSelectedItems);
	g_string_assign(gstrBuf2, buf);
	len = strlen(gstrBuf2->str)-3;
	while (len>0){
		g_string_insert_c(gstrBuf2,len,'.');
		len -=3;
	}
	strcpy(buf,gstrBuf2->str);

	BytesToHumanityString (Object->guint64sizeOfSelectedItems, gstrBuf2, 0);
	g_string_printf(gstrBuf,"%d Items selected: %s ( %s bytes )", gtk_tree_selection_count_selected_rows(treeselection), gstrBuf2->str, buf);

	gtk_statusbar_pop(Object->StatusBar,0);
	gtk_statusbar_push(Object->StatusBar,0,gstrBuf->str);

	g_string_free(gstrBuf,TRUE);
	g_string_free(gstrBuf2,TRUE);
}


void oneSelectionChanged(GtkTreeSelection *treeselection, gpointer data){
	TRACEIT(10,"oneSelectionChanged		start");
	struct SideObjectList *Object = (struct SideObjectList *)data;

    updateStatusBar(Object);
	TRACEIT(10,"oneSelectionChanged		ends");
}


void formatPathString(GString *NewPath){
	TRACEIT(10,"formatPathString		start");
	char *path = NewPath->str;
	int len = strlen(path);

	char *EndString;
	char *buf;
	int Anzahl1=0;
	int Anzahl2=0;
	int i;

	EndString = malloc(sizeof(char) * len + 20);
	if (EndString == NULL){
		TRACEIT(10,"formatPathString		ends");
		return;
	}

	//Wieviele "/.."
	buf = path;
	while(buf != NULL){
		buf = strstr(buf,"/..");
		if (buf != NULL){
			Anzahl1++;
			buf++;
		}
	}
	//Wieviele "/."
	buf = path;
	while(buf != NULL){
		buf = strstr(buf,"/.");
		if (buf != NULL){
			Anzahl2++;
			buf++;
		}
	}
	Anzahl2 = Anzahl2-Anzahl1;
	if (Anzahl2 == 0 && Anzahl1 == 0){
		free(EndString);
		TRACEIT(10,"formatPathString		ends");
		return;
	}
	int Anzahl3=0;
	EndString[0] = '\0';
	const char sep[] = "/";
	for (buf = strtok(path,sep); buf; buf=strtok(NULL,sep)){
		if (strcmp(buf,".") != 0 && strcmp(buf,"..") != 0){
			strcat(EndString,"/");
			strcat(EndString,buf);
			Anzahl3++;
		}
	}
	if (Anzahl1 >= Anzahl3){
		sprintf(EndString,"/");
		g_string_assign(NewPath,EndString);
		free(EndString);
		TRACEIT(10,"formatPathString		ends");
		return;
	}
	path = malloc(sizeof(char) * strlen(EndString) + 20);
	if (path == NULL){
		free(EndString);
		TRACEIT(10,"formatPathString		ends");
		return;
	}

	strcpy(path,EndString);
	EndString[0] = '\0';
	i=0;
	for (buf = strtok(path,sep); buf && (Anzahl3-Anzahl1) > i; buf=strtok(NULL,sep) ){
		i++;
		strcat(EndString,sep);
		strcat(EndString,buf);
	}

	g_string_assign(NewPath,EndString);

	free(path);
	free(EndString);

	TRACEIT(10,"formatPathString		ends");
}


gboolean updateViewsFolder_Helper (GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter, struct AllInformationAllUseStruct *infostru){
	//WARNING, not only used from udateFolder, but also from within the fileshelf (interseption...)
	TRACEIT(11,"updateViewsFolder_Helper		start");
	gchar *Name=NULL;
	gchar *Path=NULL;
	struct updateList **itemlist= (struct updateList **)infostru->Info_1;

	int *columnToSearch=(int *)infostru->Info_2;
	int *columnToUseToo=(int *)infostru->Info_3;

	if (columnToUseToo){
		gtk_tree_model_get(model, iter, *columnToSearch, &Name, *columnToUseToo, &Path, -1);
	}
	else{
		gtk_tree_model_get(model, iter, *columnToSearch, &Name, -1);
	}
	if (!(strcmp(Name, "..")==0 || strcmp(Name,".")==0)){
        updateList_addItem(itemlist, Name, Path, gtk_tree_row_reference_new(model, path), 0);
	}

	if (Name)
		g_free(Name);
	if (Path)
		g_free(Path);
	TRACEIT(11,"updateViewsFolder_Helper		ends");
	return FALSE;
}


void updateViewWithNewFolder(struct SideObjectList *Object, GString *NewPath){
	//NewPath may be NULL
	TRACEIT(10,"updateViewWithNewFolder		start");
	if (Object == NULL){
		TRACEIT(2,"updateViewWithNewFolder		ends. ERROR, Object=NULL");
		return;
	}

    //SET UPDATEING FLAG
    if (Object->bUpdateFlag_CurrentlyUpdating==TRUE){
        TRACEIT(10,"updateViewWithNewFolder		ends, No Update 2");
        return;
    }
    Object->bUpdateFlag_CurrentlyUpdating=TRUE;

    if ( Object->iPreventFromUpdating != 0 && NewPath == NULL){
	    TRACEIT(10,"updateViewWithNewFolder		ends, No Update");
	    Object->bUpdateFlag_CurrentlyUpdating=FALSE;
	    SideObjectList_UpdateObject(Object);
        return;
	}

    if (NewPath != NULL){
        calcDirectorySizeInView_closeProcess (&(Object->iRecursiveSizeCalculation), &(Object->gthreadF6Updage), &(Object->bUpdateFlag_F6), &(Object->iPreventFromUpdating), TRUE);
    }

	struct updateList *updateItemlist=NULL;
	struct updateList *firstUpdateItemList=NULL;
    GtkTreeIter iter;
    GtkTreePath *path;
    int BrandNewStore=0;
    GString *OldName=NULL;
    GString *Ending=NULL;
    GString *Starting=NULL;

	struct AllInformationAllUseStruct infostru;
	int columnToSearch=COL_NAME;

	infostru.Info_1=(void *)&updateItemlist;
	infostru.Info_2=(void *)&columnToSearch;
	infostru.Info_3=NULL;
	infostru.Info_4=NULL;
	infostru.Info_5=NULL;

    //CursorToWait(win);
	TRACEIT(10,"updateViewWithNewFolder		check point 1");
	int leftORright = (Object->notebook == (GtkNotebook *)Notebooks[SIDE_LEFT])?SIDE_LEFT:SIDE_RIGHT;
	if (NewPath == NULL && Object->listStore != NULL){
        TRACEIT(10,"updateViewWithNewFolder		just update view");
        gtk_tree_model_foreach(GTK_TREE_MODEL(Object->listStore),(GtkTreeModelForeachFunc) updateViewsFolder_Helper,&infostru);
        //When we try to update the view, while the folder was not available the function foreach did not do anything
        firstUpdateItemList = updateItemlist;

        makeLists(Object, &updateItemlist);

        updateItemlist = firstUpdateItemList;
        TRACEIT(10,"updateViewWithNewFolder		check point 1.1");
        while (updateItemlist){
            if (updateItemlist->found == 0){
                path = gtk_tree_row_reference_get_path(updateItemlist->rowref);
                if (path){
                    if (gtk_tree_model_get_iter(GTK_TREE_MODEL(Object->listStore), &iter, path)){
                        //gtk_list_store_set (Object->listStore, &iter, COL_INTERNAL, 1,-1);    //what the **CK!! why setting a value, when all the information for deleting this row is already there?
                        gtk_list_store_remove(Object->listStore, &iter);
                    }
                }
            }
            updateItemlist = updateItemlist->NextItem;
        }
        TRACEIT(10,"updateViewWithNewFolder		check point 1.2");
        if (firstUpdateItemList != NULL){
            updateList_deleteList(&firstUpdateItemList);
        }
        //RemoveInternalMarkedItems(Object);    //what the **CK!! why calling another function, when all the information for deleting this row is already there?
        updateStatusBar(Object);
        // SideObjectList_UpdateObject(Object);    //TODO: check if we need thi, This has come ot here because we change the tenotebooktab text as long as we do not change the mouse curosr
        SideObjectList_UpdateObject(Object);	//sets the tabs label
        checkDirectory(Object,NewPath);	//sets the status bar
	}
	else{
		TRACEIT(10,"updateViewWithNewFolder		new view");
	    if (NewPath != NULL){	//we expect a completly new path, no update
            g_object_set(PathEntryBox[leftORright],"text",NewPath->str,NULL);
            OldName = g_string_new(Object->gstrPath->str);
            g_string_assign(Object->gstrPath,NewPath->str);

            //printf("OldName=%s\nNewPath=%s\n",OldName->str,NewPath->str);

            //stop old monitor and start new one
            if (strcmp (OldName->str, NewPath->str) != 0){  //on creating, both are the same and we dont do anything
//                #ifndef NO_GIO
                autoUpdateList_RemoveMonitor(OldName->str);
                autoUpdateList_AddMonitor(NewPath->str);
//                #endif
            }
	    }
        if (NULL == Object->listStore){
            //firstly I thought we can use this on startup and create a new monitor, but this fails when copying, moving, dublicating a tab
            //in this cases NewPath is NULL but never the less we have to catch it.
            //such events are now catched where they should be, in the sideObjectList_* functions
            //autoUpdateList_AddMonitor(NewPath->str);
            BrandNewStore=1;
        }
        Object->guint64sizeOfSelectedItems=0;

        //start reading the directory and fill items in list

		makeLists(Object, NULL);
        //if (0==makeLists(Object, NULL) && BrandNewStore==1){
        	//then we have to connect the new list to the obejct
        	// NO, not anymore! the makeLists function will do this for us now

            //connectListToView(Object);
			//doActionsForNewView ();
        //}

		TRACEIT(10,"updateViewWithNewFolder		check point 2.1");
        if (BrandNewStore != 1  && NewPath != NULL){  //its a new folder to load, but maybe we come from a lower one... lets look for this
            Ending = g_string_sized_new(10);
            Starting = g_string_sized_new(10);

            //g_string_assign(Ending, OldName->str);
            g_string_assign(Starting, OldName->str);
            checkPathForLastCharOtherwise(Starting);
            checkPathForLastCharOtherwise(NewPath);
            if (NULL != strstr (Starting->str, NewPath->str)){  //then we can mark and scroll to the folder we just came from
                while(strlen(NewPath->str) <= strlen(Starting->str)){
                    g_string_assign(Ending, Starting->str);

                    getLastStringInPath(Ending);
                    GetPathFromPathWithName(Starting, 1);
                    checkPathForLastCharOtherwise(Starting);

                    if (strcmp(NewPath->str, Starting->str)==0){
                        scrollListStoreToName((GtkTreeView *)Object->listView, Object->listStore, Ending, COL_NAME);
                        break;
                    }
                }
            }
            else {  //We do not come from a lower path, the scrollpoint is sewt to root position
                //we have to realkize the tree view before we can use scroll to point
                gtk_widget_realize(Object->listView);   //Beacuse the BrandnewStore cant be 1 in here, we are sure to realize an item already shown.
                gtk_tree_view_scroll_to_point ((GtkTreeView *)Object->listView, -1, 0);
            }
			TRACEIT(10,"updateViewWithNewFolder		check point 2.2");
            g_string_free(Ending, TRUE);
            g_string_free(Starting, TRUE);
        }
        if (OldName)
            g_string_free(OldName, TRUE);
		TRACEIT(10,"updateViewWithNewFolder		check point 3.1");
        SideObjectList_UpdateObject(Object); //sets the tabs label
        checkDirectory(Object,NewPath);	//sets the status bar
		TRACEIT(10,"updateViewWithNewFolder		check point 3.2");
	}

    //set Some updateflags:
    Object->bUpdateFlag_UpdateOnTabSwitch=FALSE;
    Object->bUpdateFlag_CurrentlyUpdating=FALSE;
    //CursorToNormal(win);
	TRACEIT(10,"updateViewWithNewFolder		ends");
}


void updateViewWithNewFolder_UserAdvice(struct SideObjectList *Object, GString *NewPath){
    Object->bUpdateFlag_UserWantsToUpdate=TRUE;
    while (Object->bUpdateFlag_CurrentlyUpdating){
        usleep(100000);
    }
    calcDirectorySizeInView_closeProcess (&(Object->iRecursiveSizeCalculation), &(Object->gthreadF6Updage), &(Object->bUpdateFlag_F6), &(Object->iPreventFromUpdating), TRUE);

    updateViewWithNewFolder(Object, NewPath);

    Object->bUpdateFlag_UserWantsToUpdate=FALSE;
}


void updateObjectsViewingFolder(char *Folder, gboolean automaticTriggered){
    //automaticTriggered:   TRUE: comming from a monitor event, FALSE: userevent
    TRACEIT(10,"updateObjectsViewingFolder		start");
    GString *gstrFolder=g_string_sized_new(10);
    GString *gstrObjectFolder=g_string_sized_new(10);

    if (Folder == NULL){
        TRACEIT(10,"updateObjectsViewingFolder		ends");
        g_string_free(gstrFolder, TRUE);
        g_string_free(gstrObjectFolder, TRUE);
        return;
    }

    struct SideObjectList *Objects = SideObjectList_getFirstObject();
    g_string_assign(gstrFolder, Folder);
    checkPathForLastCharOtherwise(gstrFolder);

    //Set bUpdateFlag_UserWantsToUpdate
    while (Objects){
        g_string_assign(gstrObjectFolder, Objects->gstrPath->str);
        checkPathForLastCharOtherwise(gstrObjectFolder);
        if ( 0==strcmp(gstrFolder->str, gstrObjectFolder->str)){
            Objects->bUpdateFlag_UpdateOnTabSwitch=TRUE;
        }
        Objects = Objects->NextItem;
    }

    SideObjectList_GetActiveObject((GtkNotebook *)Notebooks[SIDE_LEFT], &Objects);
    if (Objects != NULL){
        g_string_assign(gstrObjectFolder, Objects->gstrPath->str);
        checkPathForLastCharOtherwise(gstrObjectFolder);
        if ( 0==strcmp(gstrFolder->str, gstrObjectFolder->str)){
            //#ifdef NO_GIO
            //updateViewWithNewFolder(Objects, NULL);
            //#endif
            if (automaticTriggered==TRUE && Objects->bUpdateFlag_UserWantsToUpdate==FALSE){  //prefent automatic update when user want an update, think of big directories changing often
                updateView(Objects);
            }
        }
    }

    SideObjectList_GetActiveObject((GtkNotebook *)Notebooks[SIDE_RIGHT], &Objects);
    if (Objects != NULL){
        g_string_assign(gstrObjectFolder, Objects->gstrPath->str);
        checkPathForLastCharOtherwise(gstrObjectFolder);
        if ( 0==strcmp(gstrFolder->str, gstrObjectFolder->str)){
           //#ifdef NO_GIO
           // updateViewWithNewFolder(Objects, NULL);
           //#endif
           if (automaticTriggered==TRUE && Objects->bUpdateFlag_UserWantsToUpdate==FALSE){  //prefent automatic update when user want an update, think of big directories changing often
                updateView(Objects);
           }
        }
    }

    g_string_free(gstrFolder, TRUE);
    g_string_free(gstrObjectFolder, TRUE);
    TRACEIT(10,"updateObjectsViewingFolder		ends");
}


void updateActiveViews(){
    struct SideObjectList *Objects = SideObjectList_getFirstObject();

	SideObjectList_GetActiveObject((GtkNotebook *)Notebooks[SIDE_LEFT], &Objects);
	updateView(Objects);

    SideObjectList_GetActiveObject((GtkNotebook *)Notebooks[SIDE_RIGHT], &Objects);
    updateView(Objects);
}


void updateView(struct SideObjectList *Object){
    //if (1==checkIfFolderNeedsUpdate(Object)){
        updateViewWithNewFolder(Object, NULL);
    //}
}

/*
The idea: I thought that the timestamp from a directory changed when a file within this directory changed. And therefore
we could check this before we update the whole list. But after I wrote this, I saw that this does not work like this.
This means this code is useless. F*SADIOSASASA'*'*�SP�DO
int checkIfFolderNeedsUpdate(struct SideObjectList *Object){
    //returnvalues: 1:update needed.    0:no update needed
    struct FileAttributs attribs;
    GtkTreeIter iter;
    int viewsTimeStamp=-2;
    int filesTimeStamp=-1;
    gchar *name=NULL;
    GString *gstrNames = g_string_sized_new(20);
    DIR *Directory;
    struct dirent *dirzeiger;
	int DirectoryOpened=0;

    GtkTreeModel *tree_model = gtk_tree_view_get_model ((GtkTreeView *)Object->listView);

    if (TRUE == gtk_tree_model_get_iter_first (tree_model, &iter)){
        do{
            gtk_tree_model_get(tree_model, &iter, COL_NAME, &name, -1);
            if (name){
                if (strcmp(name,".") == 0){
                    gtk_tree_model_get(tree_model, &iter, COL_TIMESTAMPCHANGED, &viewsTimeStamp, -1);
                    g_free(name);
                    break;
                }
                g_free(name);
            }
        }while(TRUE == gtk_tree_model_iter_next(tree_model, &iter) );
    }
    if (viewsTimeStamp == -2){
        g_string_free(gstrNames,TRUE);
        return 1;
    }

    openDirectory(&Directory, &DirectoryOpened, Object->gstrPath);
    if (DirectoryOpened != 0){
        do{
            getNextListItem(Directory, &dirzeiger, DirectoryOpened, gstrNames);
            if ( 0 == strstr(gstrNames->str, ".") ){
                if (0==fileAttributesGet(dirzeiger, DirectoryOpened, &attribs, Object->gstrPath->str, gstrNames->str)){
                    filesTimeStamp = attribs.utchanged;
                }
                break;
            }
        }while(strlen(gstrNames->str));
    }
    closeDirectory(&Directory);
	g_string_free(gstrNames,TRUE);

	if (filesTimeStamp > viewsTimeStamp)
        return 1;
    else
        return 0;

}
*/

void doActionsForNewView (struct SideObjectList *Object){
	TRACEIT(10,"doActionsForNewView		start");
	gtk_tree_view_column_clicked(Object->actualSortCol);
	TRACEIT(10,"doActionsForNewView		end");
}


void connectListToView(struct SideObjectList *Object){
	TRACEIT(10,"connectListToView		start");

	gtk_tree_view_set_model (GTK_TREE_VIEW(Object->listView), GTK_TREE_MODEL(Object->listStore));

	TRACEIT(10,"connectListToView		ends");
}


void disconnectListAndView (struct SideObjectList *Object){
	TRACEIT(10,"disconnectListAndView		start");

	if (NULL != gtk_tree_view_get_model (GTK_TREE_VIEW(Object->listView)) ){
		gtk_tree_view_set_model (GTK_TREE_VIEW(Object->listView), NULL);
	}

	TRACEIT(10,"disconnectListAndView		end");
}


int addPointsToSideView(char *cpPath, GtkListStore *listStore, const char *cpColorDir){
    //as we changed the getNextItemInLocation function to gtk functions we losed the '.' and '..'
    //this function simply adds them (inclusive their attribs)
    TRACEIT(10,"addPointsToSideView		start");
    struct FileAttributs attribs;
    GtkTreeIter iter;
    GString *gstrNames = g_string_new(".");


    fileAttributesGet(&attribs, cpPath, gstrNames->str);
    gtk_list_store_append(listStore,&iter);
    gtk_list_store_set (listStore, &iter, COL_NAME, gstrNames->str, COL_FILETYPE, attribs.type,
        COL_SIZE, attribs.size,
        COL_OWNER, attribs.owner, COL_GROUP, attribs.group, COL_PERMISSION, attribs.permission,
        COL_ACCESSED, attribs.accessed, COL_CHANGED, attribs.changed,
        COL_TYPE_D, attribs.type_d, COL_TIMESTAMPACCESSED, attribs.utaccessed,
        COL_TIMESTAMPCHANGED, attribs.utchanged, COL_COLOR,cpColorDir,
        -1);

    g_string_assign (gstrNames, "..");
    fileAttributesGet(&attribs, cpPath, gstrNames->str);
    gtk_list_store_append(listStore,&iter);
    gtk_list_store_set (listStore, &iter, COL_NAME, gstrNames->str, COL_FILETYPE, attribs.type,
        COL_SIZE, attribs.size,
        COL_OWNER, attribs.owner, COL_GROUP, attribs.group, COL_PERMISSION, attribs.permission,
        COL_ACCESSED, attribs.accessed, COL_CHANGED, attribs.changed,
        COL_TYPE_D, attribs.type_d, COL_TIMESTAMPACCESSED, attribs.utaccessed,
        COL_TIMESTAMPCHANGED, attribs.utchanged, COL_COLOR,cpColorDir,
        -1);

    g_string_free(gstrNames, TRUE);
    TRACEIT(10,"addPointsToSideView		end");
    return 0;
}


int makeLists(struct SideObjectList *Object, struct updateList **itemlist){
	TRACEIT(10,"makeLists		start");
	GtkTreeIter iter;
    GtkTreeRowReference *rowref=NULL;
    int done=0;
    GtkTreePath *path;
	struct FileAttributs attribs;
	GString *gstrNames = g_string_sized_new(20);
    int iLocationOpened=-1;
	struct myLocationStruct locationStru;
	int BrandNewStore=0;
	GdkPixbuf *gdkpixBuf=NULL;

	const char *cpColorDir=NULL;
	const char *cpColorItm=NULL;
	const char *cpColorLnk=NULL;
	const char cpColorFallBackItms[] = DEFAULT_COLOR_ITEMS_DEFAULT;
	const char cpColorFallBackDirs[] = DEFAULT_COLOR_DIRECTORIES;
	const char cpColorFallBackLnks[] = DEFAULT_COLOR_LINKS;
	const char *cpPreviewEndings=NULL;

	cpColorDir = OptionsList_getValueByID (g_OptionsList, COLOR_DIRECTORIES);
	cpColorItm = OptionsList_getValueByID (g_OptionsList, COLOR_ITEMS_DEFAULT);
	cpColorLnk = OptionsList_getValueByID (g_OptionsList, COLOR_LINKS);
    cpPreviewEndings = OptionsList_getValueByID (g_OptionsList, PREVIEWTYPES);

    if (cpColorDir == NULL)
        cpColorDir = cpColorFallBackDirs;
    if (cpColorItm == NULL)
        cpColorItm = cpColorFallBackItms;
    if (cpColorLnk == NULL)
        cpColorLnk = cpColorFallBackLnks;

    iLocationOpened = openLocation(Object->gstrPath->str, &locationStru, TRUE, FALSE);

	//disconnectListAndView (Object);	// I tried to disconnect the model and the treeview before updating the view.
	// but then, we lose the marking by every update

	if (itemlist == NULL ){
	    if (NULL == Object->listStore){
            Object->listStore = gtk_list_store_new(NUM_COLS,COLTYPES);
            BrandNewStore=1;
	    }
        else{
            SideObjectList_UnrefPreviewPixbufs (Object->listStore, COL_PREVIEW);
            gtk_list_store_clear (Object->listStore);
        }
        if (0==iLocationOpened){
            addPointsToSideView(Object->gstrPath->str, Object->listStore, cpColorDir);
            Object->bPointsAddedToView = TRUE;
        }
	}else if (NULL != Object->listStore){
	    SideObjectList_UnrefPreviewPixbufs (Object->listStore, COL_PREVIEW);
	}

    if (-1==iLocationOpened){
        gtk_list_store_clear (Object->listStore);
        Object->bPointsAddedToView = FALSE;
    }
    else if (Object->bPointsAddedToView == FALSE){
        addPointsToSideView(Object->gstrPath->str, Object->listStore, cpColorDir);
        Object->bPointsAddedToView = TRUE;
    }

	while (0==iLocationOpened && 1==getNextItemInLocation(&locationStru, gstrNames, TRUE, FALSE) ){
		fileAttributesGet(&attribs, Object->gstrPath->str, gstrNames->str);
		if (!(!Object->showHiddenFiles && attribs.hiddenfile) || Object->alwaysShowHiddenFiles){
            if (itemlist != NULL && *itemlist != NULL){
                rowref = updateList_checkForItem(itemlist, gstrNames->str);
                if (rowref){
                    path = gtk_tree_row_reference_get_path(rowref);
                    if (path){
                        if (gtk_tree_model_get_iter(GTK_TREE_MODEL(Object->listStore), &iter, path)){
                            done=1;
                        }
                    }
                }
            }
            if (done == 0){
                gtk_list_store_append(Object->listStore,&iter);
            }
			gtk_list_store_set (Object->listStore, &iter,
                COL_PREVIEW, NULL,
				COL_NAME, gstrNames->str,
				COL_FILETYPE, attribs.type,
				/*COL_SIZE, attribs.size,*/
				COL_OWNER, attribs.owner,
				COL_GROUP, attribs.group,
				COL_PERMISSION, attribs.permission,
				COL_ACCESSED, attribs.accessed,
				COL_CHANGED, attribs.changed,
				COL_TYPE_D, attribs.type_d,
				COL_TIMESTAMPACCESSED, attribs.utaccessed,
				COL_TIMESTAMPCHANGED, attribs.utchanged,
				COL_COLOR,(attribs.type_d==4)?cpColorDir:(attribs.type_d==10)?cpColorLnk:cpColorItm,
				-1);
            if (attribs.type_d!=4 || (attribs.type_d==4 && (Object->bUpdateFlag_F6==FALSE || done==0))){  //size of newly added items have to be set.
                gtk_list_store_set (Object->listStore, &iter,COL_SIZE, attribs.size, -1);
            }
            if (attribs.gstrLinkTarget){
                gtk_list_store_set (Object->listStore, &iter, COL_TARGET, attribs.gstrLinkTarget->str, COL_COLOR, cpColorLnk,-1);
            }

            if (Object->iPreview > 0 && cpPreviewEndings!=NULL){
                if (1 == CheckForEndingInEndingList (cpPreviewEndings, attribs.type)){
                    gdkpixBuf = getPreviewPixBufForFile (Object->gstrPath->str, gstrNames->str);
                    if (NULL != gdkpixBuf){
                        gtk_list_store_set (Object->listStore, &iter,COL_PREVIEW, gdkpixBuf, -1);
                    }
                }
            }
            done = 0;
		}
		if (attribs.gstrLinkTarget){
		    g_string_free(attribs.gstrLinkTarget, TRUE);
		}
	}



    if (BrandNewStore==1){ //Connect SortFunctions
    	connectListToView(Object);
        gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(Object->listStore),COL_NAME,mysortfunctionforNamesLeft,Object->listStore,NULL);
        gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(Object->listStore),COL_FILETYPE,mysortfunctionforText,GINT_TO_POINTER(COL_FILETYPE),NULL);
        gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(Object->listStore),COL_PERMISSION,mysortfunctionforText,GINT_TO_POINTER(COL_PERMISSION),NULL);
        gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(Object->listStore),COL_ACCESSED,mysortfunctionforNumbers,GINT_TO_POINTER(COL_TIMESTAMPACCESSED),NULL);
        gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(Object->listStore),COL_CHANGED,mysortfunctionforNumbers,GINT_TO_POINTER(COL_TIMESTAMPCHANGED),NULL);
        gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(Object->listStore),COL_SIZE,mysortfunctionforBigNumbers,GINT_TO_POINTER(COL_SIZE),NULL);
        gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(Object->listStore),COL_OWNER,mysortfunctionforNumbers,GINT_TO_POINTER(COL_OWNER),NULL);
        gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(Object->listStore),COL_GROUP,mysortfunctionforNumbers,GINT_TO_POINTER(COL_GROUP),NULL);
		doActionsForNewView (Object);
    }




    //S�ubern:
	closeLocation(&locationStru);
	g_string_free(gstrNames,TRUE);

	TRACEIT(10,"makeLists		ends");
	//gtk_widget_queue_draw((GtkWidget *)win);
	return 0;
}


GdkPixbuf *getPreviewPixBufForFile (const char *ccpPath, const char *ccpFilename){
    //this functions creates a GdkPixBuf for the given file. The calling function has to check if the file is a Picture and should be previewed.
    TRACEIT(10,"getPreviewPixBufForFile		start");

    if (NULL == ccpFilename || ccpPath == NULL){
        TRACEIT (2, "getPreviewPixBufForFile    error: Parameter NULL");
        return NULL;
    }

    const char *ccpPreviewSizeRaw=NULL;
    char *cpPreviewSizeRaw=NULL;
    char cpDefaultPreviewSize[] = DEFAULT_PREVIEWSIZE;
    int iX, iY;
    char *cpBuf = NULL;
    GError *error=NULL;
    GdkPixbuf *gdkpixBuf = NULL;
    GString *gstrBuf = g_string_new (ccpPath);

    ccpPreviewSizeRaw = OptionsList_getValueByID (g_OptionsList, PREVIEWSIZE);
    if (ccpPreviewSizeRaw == NULL){
        cpPreviewSizeRaw=cpDefaultPreviewSize;
    }
    else{
        cpPreviewSizeRaw = malloc (sizeof(char) * (strlen(ccpPreviewSizeRaw) +1 ));
        if (cpPreviewSizeRaw == NULL){
            cpPreviewSizeRaw=cpDefaultPreviewSize;
        }
        else{
            strcpy (cpPreviewSizeRaw, ccpPreviewSizeRaw);
        }
    }

    cpBuf = strtok (cpPreviewSizeRaw, "xX");
    if (NULL == cpBuf){
        iX = 24;
    }
    else{
        sscanf (cpBuf, "%d", &iX);
    }
    cpBuf = strtok (NULL, "xX");
    if (NULL == cpBuf){
        iY = 24;
    }
    else{
        sscanf (cpBuf, "%d", &iY);
    }


    checkPathForLastChar (gstrBuf);
    g_string_append (gstrBuf, ccpFilename);

    gdkpixBuf = gdk_pixbuf_new_from_file_at_size (gstrBuf->str, iX, iY, &error);
    if (NULL != error){
        TRACEIT (3, "getPreviewPixBufForFile unable to create preview for:");
        TRACEIT (3, ccpFilename);
        TRACEIT (3, error->message);
        g_error_free (error);
    }
    if (NULL == gdkpixBuf){
        TRACEIT (3, "Error creating preview");
    }

    free (cpPreviewSizeRaw);
    g_string_free (gstrBuf, TRUE);

    TRACEIT(10,"getPreviewPixBufForFile		ends");
    return gdkpixBuf;
}


int predefine_Main_Objects(){
	TRACEIT(10,"predefine_Main_Objects		start");
//Defining EntrieyBoxes
	myWrap_gdk_threads_enter("predefine_Main_Objects");
	PathEntryBox[SIDE_LEFT] = gtk_entry_new();
	PathEntryBox[SIDE_RIGHT] = gtk_entry_new();
	gtk_entry_set_max_length(GTK_ENTRY(PathEntryBox[SIDE_LEFT]),MAXENTRYBOX);
	gtk_entry_set_max_length(GTK_ENTRY(PathEntryBox[SIDE_RIGHT]),MAXENTRYBOX);
	gtk_editable_set_editable(GTK_EDITABLE(PathEntryBox[SIDE_LEFT]),TRUE);
	gtk_editable_set_editable(GTK_EDITABLE(PathEntryBox[SIDE_RIGHT]),TRUE);

//Defining VBoxes
	VBox[SIDE_LEFT] = g_object_new(GTK_TYPE_VBOX, "spacing", 5, "homogeneous", FALSE, NULL);
	VBox[SIDE_RIGHT] = g_object_new(GTK_TYPE_VBOX, "spacing", 5, "homogeneous", FALSE, NULL);

//Defining SideObject Pane
	HPanedLeftRight = gtk_hpaned_new();

//Defining Pane for SideObject(Pane) and Fileshelf
	VPanedForFileShelf = gtk_vpaned_new();

//Defining HBoxes
	HBoxForButtonsAndPathEntry[SIDE_LEFT] = g_object_new(GTK_TYPE_HBOX, "spacing", 5, "homogeneous", FALSE, NULL);
	HBoxForButtonsAndPathEntry[SIDE_RIGHT] = g_object_new(GTK_TYPE_HBOX, "spacing", 5, "homogeneous", FALSE, NULL);

//Defining Buttons
	OnePathUpButton[SIDE_LEFT] = (GtkButton *)gtk_button_new_with_label("1up");
	OnePathUpButton[SIDE_RIGHT] = (GtkButton *)gtk_button_new_with_label("1up");

//Defining NoteBooks
	Notebooks[SIDE_LEFT]=g_object_new(GTK_TYPE_NOTEBOOK, "show-border",TRUE,"scrollable",TRUE,NULL);	//Different show-border properties, but no effect seen
	Notebooks[SIDE_RIGHT]=g_object_new(GTK_TYPE_NOTEBOOK, "show-border",FALSE,"scrollable",TRUE,NULL);

	//gtk_notebook_set_group ((GtkNotebook *)Notebooks[SIDE_LEFT], GROUP_VIEWNOTEBOOK); //enable dragndrop between notebooks
	//gtk_notebook_set_group ((GtkNotebook *)Notebooks[SIDE_RIGHT], GROUP_VIEWNOTEBOOK); //enable dragndrop between notebooks
	//gtk_drag_dest_unset ((GtkWidget *)Notebooks[SIDE_LEFT]);
	//gtk_drag_dest_unset ((GtkWidget *)Notebooks[SIDE_RIGHT]);
    prepareWidgetForDrop ((GtkWidget *)Notebooks[SIDE_LEFT], 1, DNDSignal_dragdatereceive_forSideObjectAndFileShelf, NULL);    //mind the 1, to enable notbook tab acceptance from other notebooks
    prepareWidgetForDrop ((GtkWidget *)Notebooks[SIDE_RIGHT], 1, DNDSignal_dragdatereceive_forSideObjectAndFileShelf, NULL);

    //gtk_drag_source_unset ((GtkWidget *)Notebooks[SIDE_LEFT]);
	//gtk_drag_source_unset ((GtkWidget *)Notebooks[SIDE_RIGHT]);
    //prepareWidgetForDrag ((GtkWidget *)Notebooks[SIDE_LEFT]);
    //prepareWidgetForDrag ((GtkWidget *)Notebooks[SIDE_RIGHT]);
	myWrap_gdk_threads_leave("predefine_Main_Objects");
	TRACEIT(10,"predefine_Main_Objects		ends");
	return 0;
}


void reorderAllTabsColumns (){
	TRACEIT (10, "reorderAllTabsColumns		start");

	struct SideObjectList *Object = NULL;

	Object = SideObjectList_getFirstObject();
	while (Object){
		predefine_NotebookTabs_reorderColumns ((GtkTreeView *) Object->listView);

		Object = SideObjectList_getNextObejct (Object);
	}

	TRACEIT (10, "reorderAllTabsColumns		end");
}


int predefine_NotebookTabs_reorderColumns (GtkTreeView *treeview){
	//tries to load the information from the options_list (loaded from configfile) and reoders the columns of the given TreeView
	//Ordering is done by the names of the columns
	//returns : 0 = ok
	//			-1 = error
	TRACEIT (10, "predefine_NotebookTabs_reorderColumns		start");

	if (NULL == treeview){
		TRACEIT (2, "predefine_NotebookTabs_reorderColumns		PARAMETER NULL");
		return -1;
	}

	const char *ccpUsersOrder = OptionsList_getValueByID (g_OptionsList, COLUMN_ORDER);

	if (NULL == ccpUsersOrder ){
		TRACEIT (10, "predefine_NotebookTabs_reorderColumns		end, no reodering requested");
		return 0;
	}

	int i,j;
	GString *gstrCompleteString = g_string_new (ccpUsersOrder);
	GString *gstrToken = g_string_sized_new (15);

	GtkTreeViewColumn *col = NULL;
	GtkTreeViewColumn *lastCol = NULL;

	for (i=0 ; 1 == myTokenFunction(gstrCompleteString, i, COLUMN_ORDER_SEPARATOR, gstrToken) ; i++){
		cutCharFromGString(gstrToken, '\"', 0);
		if ( 0 == strlen (gstrToken->str)){
			break;
		}

		for (j=i; j<COL_TIMESTAMPACCESSED; j++){
			col = gtk_tree_view_get_column (treeview, j);
			if (0 == strcmp (gtk_tree_view_column_get_title(col), gstrToken->str)){
				gtk_tree_view_move_column_after (treeview, col, lastCol);
				lastCol = col;
				break;
			}
		}
	}

	g_string_free (gstrCompleteString, TRUE);
	g_string_free (gstrToken, TRUE);

	TRACEIT (10, "predefine_NotebookTabs_reorderColumns		end");
	return 0;
}


int predefine_NotebookTaps_Objects(struct SideObjectList *Object){
	TRACEIT(10,"predefine_NotebookTaps_Objects		start");

// Defining Lists
	GtkTreeViewColumn   *col;
	GtkCellRenderer     *renderer;
	GtkTreeSelection	*selection;
  	int i;

	Object->listView = gtk_tree_view_new();
	prepareWidgetForDrop (Object->listView,1,DNDSignal_dragdatereceive_forSideObjectAndFileShelf, NULL);
	prepareWidgetForDrag (Object->listView);
	gtk_tree_view_set_rules_hint ((GtkTreeView *)Object->listView, TRUE);

	selection  = gtk_tree_view_get_selection((GtkTreeView *)Object->listView);
	gtk_tree_selection_set_mode(selection, GTK_SELECTION_MULTIPLE);
	//gtk_tree_selection_set_mode(selection, GTK_SELECTION_SINGLE);

	g_signal_connect(selection, "changed", G_CALLBACK(oneSelectionChanged),Object);

	for (i=0; i<NUM_COLS ;i++){
		col=gtk_tree_view_column_new();

		//gtk_tree_view_column_set_alignment(col,1.0);	//only for text in header-buttons
		gtk_tree_view_column_set_resizable(col,TRUE);
		gtk_tree_view_column_set_sort_column_id(col,i);
		gtk_tree_view_column_set_reorderable(col,TRUE);
		gtk_tree_view_column_set_title(col, Names[i]);
		gtk_tree_view_append_column(GTK_TREE_VIEW(Object->listView),col);
		if (i==COL_PREVIEW){
            renderer = gtk_cell_renderer_pixbuf_new ();
            gtk_tree_view_column_pack_start(col, renderer, TRUE);
            gtk_tree_view_column_add_attribute(col,renderer,"pixbuf",i);
            Object->PreviewCol = col;
		}
		else{
            renderer = gtk_cell_renderer_text_new();
            gtk_tree_view_column_pack_start(col, renderer, TRUE);
            gtk_tree_view_column_add_attribute(col,renderer,"text",i);
            gtk_tree_view_column_add_attribute(col,renderer,"foreground",COL_COLOR);
		}

		g_signal_connect (col, "clicked",G_CALLBACK(oneColumnWasClicked),Object);

		if (i==COL_NAME)
			Object->actualSortCol = col;
		if (i >= COL_TIMESTAMPACCESSED || (i==COL_PREVIEW && Object->iPreview==0) )
			gtk_tree_view_column_set_visible(col,FALSE);
	}

//Defining scrollWindows
	Object->ScrollWindow = gtk_scrolled_window_new(NULL,NULL);
	gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(Object->ScrollWindow),GTK_POLICY_AUTOMATIC,GTK_POLICY_AUTOMATIC);

//Defining VBoxes
	Object->VBox = g_object_new(GTK_TYPE_VBOX, "spacing", 5, "homogeneous", FALSE, NULL);

//Defining Statusbars
	Object->StatusBar = (GtkStatusbar *)gtk_statusbar_new();
	gtk_statusbar_set_has_resize_grip(Object->StatusBar, FALSE);

//Defiging Label
	Object->label = gtk_label_new(NULL);

	TRACEIT(10,"predefine_NotebookTaps_Objects		ends");
	return 0;
}


int connectSignalsToNotebookTapObject(struct SideObjectList *Object){
	TRACEIT(10,"connectSignalsToNotebookTapObject		start");
	g_signal_connect (Object->listView,"row-activated",G_CALLBACK(oneRowActivated_SideObjectWrap),Object);
	g_signal_connect (Object->listView,"key-press-event",G_CALLBACK(oneKeyPressedInView),Object);
	g_signal_connect (Object->listView,"button-press-event",G_CALLBACK(oneMouseButtonPressed),Object);
	g_signal_connect (Object->listView,"button-release-event",G_CALLBACK(oneMouseButtonPressed),Object);
	g_signal_connect (Object->listView,"popup-menu",G_CALLBACK(oneContextMenuReplied),Object);
    TRACEIT(10,"connectSignalsToNotebookTapObject		ends");
	return 0;
}


int mysortfunctionshelperForCaseInsensitiveComparission(gchar *string1, gchar *string2, GtkSortType sortOrder){
    TRACEIT(12,"mysortfunctionshelperForCaseInsensitiveComparission		start");

    int ret=0;
    gchar *str1converted=NULL;
	gchar *str2converted=NULL;
	gchar *str1converted_=NULL;
	gchar *str2converted_=NULL;
	gsize read,write;
	//GString *ReportToUser=NULL;
	GError *err=NULL;

    if (sortOrder == 0)
        sortOrder = GTK_SORT_ASCENDING;

    if (strcmp(string1, ".") == 0){
        ret = (sortOrder == GTK_SORT_ASCENDING)?-1:1;
    }
    else if (strcmp(string2, ".") == 0){
        ret = (sortOrder == GTK_SORT_ASCENDING)?1:-1;
    }
    else if ( /*strcmp(string1, ".") != 0 && */strcmp(string2, "..") == 0){
        ret = (sortOrder == GTK_SORT_ASCENDING)?1:-1;
    }
    else if ( /*strcmp(string2, ".") != 0 && */strcmp(string1, "..") == 0){
        ret = (sortOrder == GTK_SORT_ASCENDING)?-1:1;
    }
    else{
        TRACEIT(12,"mysortfunctionshelperForCaseInsensitiveComparission		g_utf8_collate");

        str1converted = g_locale_to_utf8(string1,-1,&read,&write, &err);
        if (!str1converted && err){
            TRACEIT(6,"mysortfunctionshelperForCaseInsensitiveComparission: error in g_locale_to_utf8:");
            TRACEIT(6,err->message);
            TRACEIT(6,string1);
            g_error_free (err);
            err = NULL;
            str1converted = g_filename_to_utf8 (string1,-1,&read,&write,&err);
            TRACEIT(9,"g_filename_to_utf8 returns:");
            TRACEIT(9,str1converted);
            if (err){
                TRACEIT(6,"mysortfunctionshelperForCaseInsensitiveComparission: error in g_filename_to_utf8:");
                TRACEIT(6,err->message);
                TRACEIT(6,string1);
                g_error_free (err);
                err = NULL;

                //Report problem to user.
                //I don't know this exactly but I think if this error occoures there is also a Pango-Warning
                //everytime you hit (no pressbutton) the line with the mouse.
                //ReportToUser = g_string_sized_new(20);
                //g_string_printf(ReportToUser, "displaying the name '%s' results into errors.",string1);
                //gtk_statusbar_pop(Object->StatusBar,0);
                //gtk_statusbar_push(Object->StatusBar,0,ReportToUser->str);
                //g_string_free(ReportToUser, TRUE);
            }
        }
        str2converted = g_locale_to_utf8(string2,-1,&read,&write, &err);
        if (!str2converted && err){
            TRACEIT(6,"mysortfunctionshelperForCaseInsensitiveComparission: error in g_locale_to_utf8:");
            TRACEIT(6,err->message);
            TRACEIT(6,string1);
            g_error_free (err);
            err = NULL;
            str2converted = g_filename_to_utf8 (string2,-1,&read,&write,&err);
            if (err){
                TRACEIT(6,"mysortfunctionshelperForCaseInsensitiveComparission: error in g_filename_to_utf8:");
                TRACEIT(6,err->message);
                TRACEIT(6,string2);
                g_error_free (err);
                err = NULL;

                //Report problem to user
                //READ in the section above!
                //ReportToUser = g_string_sized_new(20);
                //g_string_printf(ReportToUser, "displaying the name '%s' results into errors.",string2);
                //gtk_statusbar_pop(Object->StatusBar,0);
                //gtk_statusbar_push(Object->StatusBar,0,ReportToUser->str);
                //g_string_free(ReportToUser, TRUE);
            }
        }
        if (str1converted != NULL && str2converted != NULL){
            str1converted_ = g_utf8_casefold (str1converted,strlen(str1converted));
            g_free(str1converted);
            str1converted = g_utf8_normalize (str1converted_,strlen(str1converted_),G_NORMALIZE_DEFAULT);
            g_free(str1converted_);
            str1converted_ = NULL;

            str2converted_ = g_utf8_casefold (str2converted,strlen(str2converted));
            g_free(str2converted);
            str2converted = g_utf8_normalize (str2converted_,strlen(str2converted_),G_NORMALIZE_DEFAULT);
            g_free(str2converted_);
            str2converted_ = NULL;

            ret = g_utf8_collate(str1converted, str2converted);
        }
        else{
            TRACEIT(6,"mysortfunctionshelperForCaseInsensitiveComparission		end, there still is a problem with one string");
            ret = (sortOrder == GTK_SORT_ASCENDING)?-1:1;
        }
        if (str1converted)
            g_free (str1converted);
        if (str2converted)
            g_free (str2converted);
    }

    TRACEIT(12,"mysortfunctionshelperForCaseInsensitiveComparission		end");
    return ret;
}


int mysortfunctionforNamesLeft(GtkTreeModel *model, GtkTreeIter *a, GtkTreeIter *b, gpointer userdata){
    //usrdata is supposed to be of kind listStore
	TRACEIT(12,"mysortfunctionforNamesLeft		start");
	int ret=0;
	gchar *string1=NULL;
	gchar *string2=NULL;
	int type_d_1, type_d_2;
	gint sortedColumnId;
	GtkSortType sortOrder;

	gtk_tree_model_get(model, a, COL_NAME, &string1, COL_TYPE_D, &type_d_1, -1);
	gtk_tree_model_get(model, b, COL_NAME, &string2, COL_TYPE_D, &type_d_2, -1);

	//struct SideObjectList *Object=(struct SideObjectList *)userdata;
	GtkListStore *listStore = (GtkListStore *)userdata;
	if (string1 == NULL || string2 == NULL){
		if (string1 == NULL && string2 == NULL){
			TRACEIT(12,"mysortfunctionforNamesLeft		ends ERRORSTRING");
			return ret;
		}
		ret = (string1 == NULL)?-1:1;
	}
	else if (NULL != listStore){
		TRACEIT(12,"mysortfunctionforNamesLeft		strdown");
		gtk_tree_sortable_get_sort_column_id(GTK_TREE_SORTABLE(listStore),&sortedColumnId,&sortOrder);
		if (type_d_1 == 4 && type_d_2 != 4){
			if (sortOrder == GTK_SORT_ASCENDING)
				ret = -1;
			else
				ret = 1;
		}
		else if (type_d_1 != 4 && type_d_2 == 4){
			if (sortOrder == GTK_SORT_ASCENDING)
				ret = 1;
			else
				ret = -1;
		}
		else{
            ret = mysortfunctionshelperForCaseInsensitiveComparission(string1, string2, sortOrder);
		}
	}
	if (string1)
		g_free (string1);
	if (string2)
		g_free (string2);

	TRACEIT(12,"mysortfunctionforNamesLeft		ends");
	return ret;
}


int mysortfunctionforText(GtkTreeModel *model, GtkTreeIter *a, GtkTreeIter *b, gpointer userdata){
	TRACEIT(10,"mysortfunctionforText		start");
	int ret=0;
	gchar *string1=NULL;
	gchar *string2=NULL;

	gtk_tree_model_get(model, a, GPOINTER_TO_INT(userdata), &string1, -1);
	gtk_tree_model_get(model, b, GPOINTER_TO_INT(userdata), &string2, -1);

	if (string1 == NULL || string2 == NULL){
		if (string1 == NULL && string2 == NULL){
			TRACEIT(10,"mysortfunctionforText		ends");
			return ret;
		}
		ret = (string1 == NULL)?-1:1;
	}
	else{
	    ret = mysortfunctionshelperForCaseInsensitiveComparission(string1, string2, 0);
	}
	g_free(string1);
	g_free(string2);
	TRACEIT(10,"mysortfunctionforText		ends");
	return ret;
}


int mysortfunctionforNumbers(GtkTreeModel *model, GtkTreeIter *a, GtkTreeIter *b, gpointer userdata){
	TRACEIT(10,"mysortfunctionforNumbers		start");
	int ret=0;
	int number1, number2;

	gtk_tree_model_get(model, a, GPOINTER_TO_INT(userdata), &number1, -1);
	gtk_tree_model_get(model, b, GPOINTER_TO_INT(userdata), &number2, -1);

	if(number1 > number2)
		ret=-1;
	else if(number2 > number1)
		ret=1;
	TRACEIT(10,"mysortfunctionforNumbers		ends");
	return ret;
}


int mysortfunctionforBigNumbers(GtkTreeModel *model, GtkTreeIter *a, GtkTreeIter *b, gpointer userdata){
	TRACEIT(10,"mysortfunctionforBigNumbers		start");
	int ret=0;
	guint64 number1, number2;

	gtk_tree_model_get(model, a, GPOINTER_TO_INT(userdata), &number1, -1);
	gtk_tree_model_get(model, b, GPOINTER_TO_INT(userdata), &number2, -1);

	if(number1 > number2)
		ret=-1;
	else if(number2 > number1)
		ret=1;
	TRACEIT(10,"mysortfunctionforBigNumbers		ends");
	return ret;
}


int checkDirectory(struct SideObjectList *Object, GString *NewPath){
	//sets the status bar if the directory could be not found
	TRACEIT(10,"checkDirectory		start");
	if (Object == NULL){
        TRACEIT(2,"checkDirectory		end, Parameter NULL");
        return -1;
	}
	GString *buf = g_string_sized_new(20);
	GString *buf2 = g_string_sized_new(10);

	if (NewPath == NULL){
        g_string_assign(buf2, Object->gstrPath->str);
	}
	else{
        g_string_assign(buf2, NewPath->str);
	}

	if (FALSE == checkStringIsPath(buf2->str)){
		g_string_sprintf(buf,"unable to load directory: %s",buf2->str);
		gtk_statusbar_pop(Object->StatusBar,0);
		gtk_statusbar_push(Object->StatusBar,0,buf->str);
		TRACEIT(9,"checkDirectory		unable to load directory:");
		TRACEIT(9,buf2->str);
		g_string_free(buf,TRUE);
		g_string_free(buf2,TRUE);
		TRACEIT(10,"checkDirectory		ends -1");
		return -1;
	}

	g_string_free(buf,TRUE);
	g_string_free(buf2,TRUE);
	TRACEIT(10,"checkDirectory		ends");
	return 1;
}


struct SideObjectList *getOtherSideObject(struct SideObjectList *ThisSideObject){
	TRACEIT(12,"getOtherSideObject		start");
	struct SideObjectList *otherObject=NULL;
	int otherSide=((GtkNotebook *)Notebooks[SIDE_LEFT]==ThisSideObject->notebook)?SIDE_RIGHT:SIDE_LEFT;
	SideObjectList_GetActiveObject((GtkNotebook *)Notebooks[otherSide], &otherObject);
	TRACEIT(12,"getOtherSideObject		ends");
	return otherObject;
}



static void deleteSelectedRowsHelper(GtkTreeModel *model,GtkTreePath *path,GtkTreeIter *iter,gpointer data){
	TRACEIT(10,"deleteSelectedRowsHelper		start");
	gchar *Name=NULL;
	GString *WholeName=g_string_sized_new(300);
	struct SideObjectList *Object=(struct SideObjectList *)data;

	if (Object->data == NULL){
		g_string_free(WholeName,TRUE);
		TRACEIT(8,"deleteSelectedRowsHelper		end, data=NULL");
		return;
	}
	struct CopyReMoveList **FirstItem = (struct CopyReMoveList **)Object->data;

	if (gtk_tree_model_get_iter(model, iter, path)){
		gtk_tree_model_get(model, iter, COL_NAME, &Name, -1);
		if (!(strcmp(Name, "..")==0 || strcmp(Name,".")==0)){
			g_string_assign(WholeName,Name);
			cutSpacesFromGString(WholeName);
			if (strlen (WholeName->str) == 0){
				if (Name)
					g_free(Name);
				g_string_free(WholeName,TRUE);
				TRACEIT(10,"deleteSelectedRowsHelper		end 1");
				return;
			}
			g_string_assign(WholeName,Object->gstrPath->str);
			checkPathForLastChar(WholeName);
			g_string_append(WholeName,Name);
			CopyReMoveList_AddItem ( FirstItem, WholeName->str, NULL, Object, NULL, NULL);
		}
	}
	if (Name)
		g_free(Name);
	g_string_free(WholeName,TRUE);
	TRACEIT(10,"deleteSelectedRowsHelper		ends");
}


void mayDeleteSelectedRows(GtkWidget *menuitem, gpointer data){
	TRACEIT(10,"mayDeleteSelectedRows		start");
	GtkWidget *dialog, *label;
	GtkTreeSelection	*selection;
	struct SideObjectList *Object=(struct SideObjectList *)data;
	struct CopyReMoveList *FirstItem=NULL;

	if (Object->bReadOnly){
		TRACEIT(10,"mayDeleteSelectedRows		ends");
		MyMessageWidget(win, "Read only Tab", "The tab is marked as read only.\nPlease remove this flag to delete\nthe selected items.\n(tab context menu)");
		return;
	}

	Object->data = (void *)&FirstItem;
	dialog = CreateMyDialog("Are you absolutly sure?", win, 2, "Cancel",GTK_RESPONSE_REJECT,"Ok",GTK_RESPONSE_ACCEPT, NULL, 0, FALSE);
	label = gtk_label_new("Do you realy want to delete\nthe selected Items?");
	gtk_container_add(GTK_CONTAINER(GTK_DIALOG(dialog)->vbox),label);
	gtk_widget_show_all(dialog);
	if (gtk_dialog_run(GTK_DIALOG(dialog))== GTK_RESPONSE_ACCEPT){
		selection  = gtk_tree_view_get_selection(GTK_TREE_VIEW(Object->listView));
		gtk_tree_selection_selected_foreach(selection, deleteSelectedRowsHelper, data);
		gtk_widget_destroy(dialog);
		if (FirstItem == NULL){
			TRACEIT(10,"mayDeleteSelectedRows		ends, FirstItem = NULL");
			return;
		}
		ProcessItemsViaListWrap(FirstItem, 3);
	}
	else{
		gtk_widget_destroy(dialog);
	}

	TRACEIT(10,"mayDeleteSelectedRows		ends");
}


static void copySelectedToAnOtherPannelRowsHelper(GtkTreeModel *model,GtkTreePath *path,GtkTreeIter *iter,gpointer data){
	TRACEIT(10,"copySelectedToAnOtherPannelRowsHelper		start");
	if (data == NULL){
        TRACEIT(2,"copySelectedToAnOtherPannelRowsHelper		end, parameter NULL");
        return;
	}
	struct AllInformationAllUseStruct *stru = (struct AllInformationAllUseStruct *)data;

	struct SideObjectList *Object = (struct SideObjectList *)stru->Info_1;
	struct SideObjectList *otherObject = (struct SideObjectList *)stru->Info_2;

	if (Object == NULL){
		TRACEIT(2,"copySelectedToAnOtherPannelRowsHelper		ends, NO OBJECT (NULL)");
		return;
	}
	if (otherObject == NULL){   //this function is used for the copy-paste thing too. And therefore the otherObject can be NLL
        otherObject=getOtherSideObject(Object); //but we need an otherObject.
	}
	if (otherObject == NULL){
		TRACEIT(2,"copySelectedToAnOtherPannelRowsHelper		ends, NO OTHEROBJECT (NULL)");
		return;
	}

	gchar *Name = NULL;
	GString *source = g_string_sized_new(100);
	GString *dest = g_string_new(otherObject->gstrPath->str);

	if (Object->data == NULL){
		g_string_free(source,TRUE);
		g_string_free(dest,TRUE);
		TRACEIT(2,"copySelectedToAnOtherPannelRowsHelper		ends, data NULL ItemList for copy...");
		return;
	}
	struct CopyReMoveList **FirstItem = (struct CopyReMoveList **)Object->data;

    gtk_tree_model_get(model, iter, COL_NAME, &Name, -1);
    g_string_assign(source,Object->gstrPath->str);
    checkPathForLastChar(source);
    if (!(strcmp(Name, "..")==0 || strcmp(Name,".")==0)){
        g_string_append(source,Name);
        checkPathForLastCharOtherwise(source);
        checkPathForLastCharOtherwise(dest);
        if (!g_string_equal(source,dest)){  //this is a simple one and not a complete check, to prevent copying a underlying directory to one inherrited by that one
            CopyReMoveList_AddItem ( FirstItem, source->str, dest->str, Object, otherObject, NULL);
        }
    }

	if (Name)
		g_free(Name);
	g_string_free(source,TRUE);
	g_string_free(dest,TRUE);
	TRACEIT(10,"copySelectedToAnOtherPannelRowsHelper		ends");
}


void copyReMoveToAnOtherObject_ListCreate(struct SideObjectList *sourceObject, struct SideObjectList *destObject){
    //creates the list CopyReMoveList at sourceObject->Data to use with ProcessItemsViaListWrap
    TRACEIT(10,"copyReMoveToAnOtherObject_ListCreate		start");
    if (sourceObject == NULL || destObject == NULL){
        TRACEIT(2,"copyReMoveToAnOtherObject_ListCreate		ends, parameter NULL");
		return;
	}
    GtkTreeSelection	*selection;
    struct AllInformationAllUseStruct stru;
    stru.Info_1 = (void *)sourceObject;
    stru.Info_2 = (void *)destObject;

	struct CopyReMoveList *FirstItem=NULL;
    sourceObject->data = (void *)&FirstItem;

	selection  = gtk_tree_view_get_selection(GTK_TREE_VIEW(sourceObject->listView));

	gtk_tree_selection_selected_foreach(selection, copySelectedToAnOtherPannelRowsHelper, (void *)&stru);

    sourceObject->data = (void *)FirstItem; //FirstItem becomes invalid after this function quits, but its value must be saved, its the list
                                            //even it is NULL, its allmost better than pointing to a varibale which does not exist
	if (FirstItem == NULL){
		TRACEIT(2,"copyReMoveToAnOtherObject_ListCreate		ends, no list created");
		return;
	}

    TRACEIT(10,"copyReMoveToAnOtherObject_ListCreate		ends");
}


void copyToAnOtherPannel(struct SideObjectList *sourceObject, struct SideObjectList *destObject){
    if (sourceObject == NULL || destObject == NULL){
        TRACEIT(2,"copyToAnOtherPannel		ends, parameter NULL");
		return;
	}
	copyReMoveToAnOtherObject_ListCreate (sourceObject, destObject);

    if (sourceObject->data == NULL){
		TRACEIT(10,"copyToAnOtherPannel		ends, -1");
		return;
	}
    ProcessItemsViaListWrap((struct CopyReMoveList *)sourceObject->data, 1);
    TRACEIT(10,"copyToAnOtherPannel		ends");
}


void copyToOtherPannel(GtkWidget *menuitem, gpointer data){
    //gets an sideObject as data, searches the Object on the other side and continues with copyReMoveToAnOtherObject_ListCreate
	TRACEIT(10,"copyToOtherPannel		start");
	if (data == NULL){
        TRACEIT(2,"copyToOtherPannel		ends, parameter NULL");
		return;
	}
	struct SideObjectList *Object=(struct SideObjectList *)data;

    struct SideObjectList *otherObject=getOtherSideObject(Object);
	if (otherObject == NULL){
		TRACEIT(2,"copyToOtherPannel		ends, No other Objectfound");
		return;
	}

	if (otherObject->bReadOnly){
		TRACEIT(10,"renameItems		ends");
		MyMessageWidget(win, "Read only Tab", "The destination tab is marked as read only.\nPlease remove this flag to copy\nthe selected items.\n(tab context menu)");
		return;
	}

    copyToAnOtherPannel (Object, otherObject);

	TRACEIT(10,"copyToOtherPannel		ends");
}


void moveToOtherPannel(GtkWidget *menuitem, gpointer data){
	TRACEIT(10,"moveToOtherPannel		start");
	struct SideObjectList *Object=(struct SideObjectList *)data;
	//GtkTreeSelection	*selection;

    struct SideObjectList *otherObject=getOtherSideObject(Object);
	if (otherObject == NULL){
		TRACEIT(2,"copyToOtherPannel		ends, No other Objectfound");
		return;
	}

	if (otherObject->bReadOnly){
		TRACEIT(10,"renameItems		ends");
		MyMessageWidget(win, "Read only Tab", "The destination tab is marked as read only.\nPlease remove this flag to move\nthe selected items.\n(tab context menu)");
		return;
	}

    copyReMoveToAnOtherObject_ListCreate (Object, otherObject);

	if (Object->data == NULL){
		TRACEIT(10,"moveToOtherPannel		ends, -1");
		return;
	}
	ProcessItemsViaListWrap((struct CopyReMoveList *)Object->data, 2);

	TRACEIT(10,"moveToOtherPannel		ends");
}


void CopyPasteCreateList_SideObject(struct SideObjectList *Object, int CopyOrMove){
    TRACEIT(10,"CopyPasteCreateList_SideObject		start");
    if (Object == NULL){
        TRACEIT(10,"CopyPasteCreateList_SideObject		ends");
		return;
    }
    GtkTreeSelection	*selection;

    if (g_CopyPasteShortcutStruct != NULL){
        CopyReMoveList_DeleteList(g_CopyPasteShortcutStruct);
        g_CopyPasteShortcutStruct = NULL;
    }
    Object->data = (void *)&g_CopyPasteShortcutStruct;

    struct AllInformationAllUseStruct stru;
    stru.Info_1 = (void *)Object;
    stru.Info_2 = NULL;

    selection  = gtk_tree_view_get_selection(GTK_TREE_VIEW(Object->listView));

	gtk_tree_selection_selected_foreach(selection, copySelectedToAnOtherPannelRowsHelper, (void *)&stru);

	if (g_CopyPasteShortcutStruct != NULL){
        g_CopyPasteShortcutStruct->CopyMoveOrRemove = CopyOrMove;
	}

    TRACEIT(10,"CopyPasteCreateList_SideObject		ends");
}


void CopyPasteProcessList_SideObject(struct SideObjectList *Object){
    TRACEIT(10,"CopyPasteProcessList_SideObject		start");
    struct CopyReMoveList *buflist=NULL;

    if (g_CopyPasteShortcutStruct == NULL || Object == NULL){
        TRACEIT(10,"CopyPasteProcessList_SideObject		ends");
        return;
    }
    buflist = g_CopyPasteShortcutStruct;
    while (buflist){
        buflist->DestObject = Object;
        if (buflist->string2){
            g_string_assign(buflist->string2, Object->gstrPath->str);
        }
        else{
            buflist->string2 = g_string_new(Object->gstrPath->str);
        }
        buflist = buflist->NextItem;
    }
    //The copyPasteShortcutStruct will be freed every time a new one is created and on shutdown
    //The list given to ProcessItemsViaListWrap is deleted after completion, therefore the copy
    CopyReMoveList_CopyList (&buflist, g_CopyPasteShortcutStruct);
    ProcessItemsViaListWrap(buflist, g_CopyPasteShortcutStruct->CopyMoveOrRemove);
    if (g_CopyPasteShortcutStruct->CopyMoveOrRemove == 2){    //2 = move
        CopyReMoveList_DeleteList(g_CopyPasteShortcutStruct);
        g_CopyPasteShortcutStruct = NULL;
    }

    TRACEIT(10,"CopyPasteProcessList_SideObject		ends");
}


static void openInNewPannelHelper(GtkTreeModel *model,GtkTreePath *path,GtkTreeIter *iter,gpointer data){
	TRACEIT(10,"openInNewPannelHelper		start");
	struct SideObjectList *Object=(struct SideObjectList *)data;

	struct SideObjectList *otherObject=getOtherSideObject(Object);

	if (otherObject == NULL){
		TRACEIT(10,"openInNewPannelHelper		ends");
		return;
	}

	gchar *Name = NULL;
	int type_d=0;
	GString *NewPath = g_string_sized_new(100);

	if (gtk_tree_model_get_iter(model, iter, path)){
		gtk_tree_model_get(model, iter, COL_NAME, &Name,COL_TYPE_D, &type_d, -1);
		g_string_assign(NewPath,Object->gstrPath->str);
		checkPathForLastChar(NewPath);
		if (!(strcmp(Name, "..")==0 || strcmp(Name,".")==0) && type_d == 4){
			g_string_append(NewPath,Name);
			SideObjectList_CreateNewViewWithPath(otherObject->notebook, NewPath->str,Object);
		}
	}

	if (Name)
		g_free(Name);
	g_string_free(NewPath,TRUE);
	TRACEIT(10,"openInNewPannelHelper		ends");
}


void openInNewPannel(GtkWidget *menuitem, gpointer data){
	TRACEIT(10,"openInNewPannel		start");
	struct SideObjectList *Object=(struct SideObjectList *)data;
	GtkTreeSelection	*selection;

	selection  = gtk_tree_view_get_selection(GTK_TREE_VIEW(Object->listView));

	gtk_tree_selection_selected_foreach(selection, openInNewPannelHelper, data);

	TRACEIT(10,"openInNewPannel		ends");
}


void updatePannels(GtkWidget *menuitem, gpointer data){	//Updates just one Pannel now
	TRACEIT(10,"updatePannels		start");
	//updateViewWithNewFolder((struct SideObjectList *)data,NULL);
	updateViewWithNewFolder_UserAdvice((struct SideObjectList *)data, NULL);
	TRACEIT(10,"updatePannels		ends");
}


void sizeOfSelectedItemsRecursive (GtkWidget *menuitem, gpointer data){	//Get size if selected Items, directories are searched recursivly
	TRACEIT(10,"sizeOfSelectedItemsRecursive		start");

	struct SideObjectList *Object=(struct SideObjectList *)data;
	GtkTreeSelection	*selection;

	if( !g_thread_supported() ){
		g_thread_init(NULL);
     		//gdk_threads_init();                   // Called to initialize internal mutex "gdk_threads_mutex".
	}
	struct RecursiveSizeStructure *stru=malloc(sizeof(struct RecursiveSizeStructure));
	stru->mainWin = win;

	selection  = gtk_tree_view_get_selection(GTK_TREE_VIEW(Object->listView));

	//Get all selected items
	stru->gstrPath=g_string_new(Object->gstrPath->str);
	stru->gstrDPItems=NULL;
	stru->intPSizes = NULL;
	stru->intPTypes = NULL;
	stru->ItemStringCounter=0;
	stru->ItemCounter=0;
	stru->SideObjectOrFileshelfItem=SOURCE_SIDEOBJECT; //SideObject Identifier
	gtk_tree_selection_selected_foreach(selection, getSizeOfSelectedItemsRecursive_getItems,(void *) stru);

	g_thread_create((GThreadFunc)getSizeOfSelectedItemsRecursive_dialog, (void *)stru , FALSE, NULL);
	TRACEIT(10,"sizeOfSelectedItemsRecursive		end");
}


static void getSizeOfSelectedItemsRecursive_getItems (GtkTreeModel *model,GtkTreePath *path,GtkTreeIter *iter,gpointer data){
	TRACEIT(10,"getSizeOfSelectedItemsRecursive_getItems		start");

	struct RecursiveSizeStructure *stru = (struct RecursiveSizeStructure *)data;
	gchar *name=NULL;
	gint type_d;
	GString *gstrBuf = g_string_sized_new(20);
	int ret=0;
	guint64 isize;

    gtk_tree_model_get(model, iter, COL_SIZE, &isize, COL_NAME, &name, COL_TYPE_D, &type_d, -1);
    if (name != NULL && strcmp(name,".")!=0 && strcmp(name,"..")!=0){
        g_string_assign(gstrBuf,name);
        ret =  AddNewGStringToDPointer(&(stru->gstrDPItems),stru->ItemCounter, gstrBuf);
        if (ret == 0){
            stru->ItemStringCounter++;
            ret += AddNewGUInt64ToPointerArray(&(stru->intPSizes), stru->ItemCounter, isize);
        }
        if (ret == 0){
            ret += AddNewGUInt64ToPointerArray(&(stru->intPTypes), stru->ItemCounter, (guint64)type_d);
        }
        if (ret == 0){
            stru->ItemCounter++;
        }
    }

	g_string_free(gstrBuf,TRUE);
	if (name)
		g_free(name);

	TRACEIT(10,"getSizeOfSelectedItemsRecursive_getItems		end");
}


void mayNewDirectory(GtkWidget *menuitem, gpointer data){
	TRACEIT(10,"mayNewDirectory		start");
	GString *buf = g_string_sized_new(10);
    GString *NewDir = g_string_new("New Directory");
	struct SideObjectList *Object=(struct SideObjectList *)data;

    while ( 0 == MyEasyInputWidget (win, "create directory", "name of the directory to create", NewDir)){
		cutSpacesFromGString(buf);
		if (strcmp(NewDir->str,".")==0 || strcmp(NewDir->str,"..")==0 || strlen(NewDir->str)==0 || strstr(NewDir->str,"/..")!=NULL  ){
		    MyMessageWidget(win, "not possible", "Iam not allowed to create this Directory.\nThis means me, the programm, not the user.");
		}
		else{
			g_string_assign(buf,Object->gstrPath->str);
			checkPathForLastChar(buf);
			g_string_append(buf,NewDir->str);
			makeDirectory(buf->str,1,NULL);
			break;
		}
	}

	g_string_free(buf,TRUE);
	g_string_free(NewDir,TRUE);
	TRACEIT(10,"mayNewDirectory		ends");
}


void renameItemsHelper(GtkTreeSelection	*selection, struct AllInformationAllUseStruct *info){
	TRACEIT(10,"renameItemsHelper		start");
	if (selection==NULL || info==NULL){
		TRACEIT(2,"renameItemsHelper		end, PARAMETER NULL");
		return;
	}
    GtkTreeModel *model;
    GList *selList = gtk_tree_selection_get_selected_rows (selection,&model);// = NULL; //
	if (selList == NULL){
		TRACEIT(4,"renameItemsHelper		end, nothing selected?");
		return;
	}
	GList *buflist=selList;
	struct SideObjectList *Object=NULL;
    GtkTreeIter iter;
	int ibreakall=0;
	int ret=0;
	gchar *Name = NULL;
	gchar *Path = NULL;
	int sort_column_id;
    GtkSortType order;
    GtkListStore *listStore = NULL;

	GString *source = g_string_sized_new(20);
	GString *dest = g_string_sized_new(20);
	GString *buf = g_string_sized_new(20);
	GString *NewName = g_string_sized_new(20);

	if (info->source == SOURCE_SIDEOBJECT){
		Object= (struct SideObjectList *)info->Info_1;
        listStore=Object->listStore;
        //Object->iPreventFromUpdating++;
        manipulateCounter (&(Object->iPreventFromUpdating), TRUE, "renameItemsHelper");
	}
	else{
        listStore = (GtkListStore *)info->Info_1;
	}
    //Whenever working with Pathlists avoid reordering or updating the treeview.
    gtk_tree_sortable_get_sort_column_id (GTK_TREE_SORTABLE(listStore), &sort_column_id, &order);
    gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE(listStore),GTK_TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID, order);

    while(buflist){
        if (ibreakall==1){
            break;
        }
        if (TRUE != gtk_tree_model_get_iter (model, &iter, (GtkTreePath *)buflist->data)){
            break;
        }

        if (info->source == SOURCE_SIDEOBJECT){
            gtk_tree_model_get(model, &iter, COL_NAME, &Name, -1);
        }
        else{
            gtk_tree_model_get(model, &iter, COL_FLSHLF_PATH, &Path, COL_FLSHLF_NAME, &Name, -1);
        }
        if ((strcmp(Name, "..")==0 || strcmp(Name,".")==0)){
            if (Name){
                g_free(Name);
                Name = NULL;
            }
            if (Path){
                g_free(Path);
                Path=NULL;
            }

            buflist=buflist->next;
            continue;
        }
        if (info->source == SOURCE_SIDEOBJECT){
            g_string_assign(source,Object->gstrPath->str);
            g_string_assign(dest,Object->gstrPath->str);
        }
        else{
            g_string_assign(source,Path);
            g_string_assign(dest,Path);
        }
        checkPathForLastChar(source);
        checkPathForLastChar(dest);
        g_string_append(source,Name);

		g_string_assign(NewName,Name);
		while (1){  //Rename one item - loop
			ret = MyEasyInputWidget_Two (win, "rename", Name, NewName, NULL, NULL, "Ok", "Cancel all", "cancel", NULL);
			if (1 == ret){	//Cancel all
                ibreakall=1;
                break;
            }
            else if (ret != 0){
                //printf("break inner while, ret=%d\n",ret);
                break;	//user pressed cancel
            }

			g_string_assign(buf, NewName->str);
			cutSpacesFromGString(buf);

			if (strcmp(buf->str,".")==0 || strcmp(buf->str,"..")==0 || strlen(buf->str)==0 || strstr(buf->str,"/..")!=NULL  ){
				MyMessageWidget(win, "not possible", "Iam not allowed to rename to this!\nThis means me, the programm, not the user.");
				continue;
			}

            g_string_assign(buf, dest->str);
            checkPathForLastChar(buf);
			g_string_append(buf,NewName->str);

			if (strcmp(source->str,buf->str)==0){  //makes no sence to rename
			    //printf("source and destination are equal\n");
                continue;
			}

            if (TRUE == g_file_test(buf->str,G_FILE_TEST_EXISTS)){ //ask for permission to overwrite
                if (0 != MyEasyInputWidget_Two ((GtkWindow *)win, "overwrite", "There is allready an item with the\nsame name in the destination directory.\nDo you want to overwrite it?\n", NULL, NULL, NULL, "Overwrite", "Cancel", NULL, NULL)){
                    continue;
                }
            }

            if (0 == g_rename(source->str,buf->str)){
                g_string_printf(dest, "renamed: %s TO %s", source->str, buf->str);
                textbuffer_commandHistory_addText (dest->str, NULL);
                if (TRUE == g_file_test(buf->str,G_FILE_TEST_EXISTS)){
                    if (info->source == SOURCE_FILESHELF){	//change name on the fileshelf, or the old filename will be marked as missing
                        gtk_list_store_set (listStore, &iter, COL_FLSHLF_NAME, NewName->str, -1);
                    }
                }
                break;
            }
            else{
                g_string_printf(buf, "Renaming item %s returned error:\n%s",Name, strerror(errno));
                MyMessageWidget(win, "Error renaming", buf->str);
                textbuffer_commandHistory_addText (buf->str, "error");
            }
		}//while (1)
		if (Name){
            g_free(Name);
            Name = NULL;
        }
        if (Path){
            g_free(Path);
            Path=NULL;
        }
		buflist=buflist->next;
	}//while (buflist)

	gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE(listStore),sort_column_id, order);

    if (info->source == SOURCE_SIDEOBJECT){
        //Object->iPreventFromUpdating--;
        manipulateCounter (&(Object->iPreventFromUpdating), FALSE, "renameItemsHelper 2");
	}

	if (Name){
        g_free(Name);
        Name = NULL;
    }
    if (Path){
        g_free(Path);
        Path=NULL;
    }
	g_string_free(source,TRUE);
	g_string_free(dest,TRUE);
	g_string_free(buf,TRUE);
	g_string_free(NewName,TRUE);

	if (selList){
		g_list_foreach (selList,(GFunc) gtk_tree_path_free, NULL);
		g_list_free (selList);
	}

	TRACEIT(10,"renameItemsHelper		ends");
}


void renameItems(GtkWidget *menuitem, gpointer data){
	TRACEIT(10,"renameItems		start");
	struct SideObjectList *Object=(struct SideObjectList *)data;
	GtkTreeSelection	*selection;
	struct AllInformationAllUseStruct info;

	if (Object->bReadOnly){
		TRACEIT(10,"renameItems		ends");
		MyMessageWidget(win, "Read only Tab", "The tab is marked as read only.\nPlease remove this flag to rename\nthe selected items.\n(tab context menu)");
		return;
	}

	selection  = gtk_tree_view_get_selection(GTK_TREE_VIEW(Object->listView));
	info.source = SOURCE_SIDEOBJECT;
	info.Info_1 = (void *)data;
	info.Info_2 = NULL;
	info.Info_3 = NULL;
	renameItemsHelper(selection, &info);
	TRACEIT(10,"renameItems		ends");
}


void MenuAddItemToFileshelfHelper(GtkTreeModel *model,GtkTreePath *path,GtkTreeIter *iter,gpointer data){
	TRACEIT(10,"MenuAddItemToFileshelfHelper		start");
	struct SideObjectList *Object=(struct SideObjectList *)data;
	gchar *Name = NULL;

	if (gtk_tree_model_get_iter(model, iter, path)){
		gtk_tree_model_get(model, iter, COL_NAME, &Name, -1);
		if ((strcmp(Name, "..")==0 || strcmp(Name,".")==0)){
			g_free(Name);

			TRACEIT(10,"MenuAddItemToFileshelfHelper		ends");
			return;
		}
		AddItemToFileshelf(NULL, Name, Object->gstrPath->str, FALSE, 1);

		if (Name)
			g_free(Name);
	}
	TRACEIT(10,"MenuAddItemToFileshelfHelper		ends");
}


void MenuAddItemToFileshelf(GtkWidget *menuitem, gpointer data){
	TRACEIT(10,"MenuAddItemToFileshelf		start");
	struct SideObjectList *Object=(struct SideObjectList *)data;
	GtkTreeSelection	*selection;

	selection  = gtk_tree_view_get_selection(GTK_TREE_VIEW(Object->listView));

	gtk_tree_selection_selected_foreach(selection, MenuAddItemToFileshelfHelper, data);

	TRACEIT(10,"MenuAddItemToFileshelf		ends");
}


void MenuAddToNewFileshelf(GtkWidget *menuitem, gpointer data){
	TRACEIT(10,"MenuAddToNewFileshelf		start");
	if (0==NewFileShelf(NULL)){
        MenuAddItemToFileshelf(menuitem, data);
	}
	TRACEIT(10,"MenuAddToNewFileshelf		ends");
}


void MenuAddNewFileshelf(GtkWidget *menuitem, gpointer data){
	TRACEIT(10,"MenuAddNewFileshelf		start");
	NewFileShelf(NULL);
	TRACEIT(10,"MenuAddNewFileshelf		ends");
}


void searchStringInAndHighlightItemsHelper(GtkTreeModel *model,GtkTreePath *path,GtkTreeIter *iter,gpointer data){
	TRACEIT(10,"searchStringInAndHighlightItemsHelper		starat");
	struct AllInformationAllUseStruct *info=(struct AllInformationAllUseStruct *)data;
	struct SearchItemStruct *theStruct = (struct SearchItemStruct *)info->Info_2;
	gchar *Name=NULL;

	if (gtk_tree_model_get_iter(model, iter, path)){
		if (info->source == SOURCE_SIDEOBJECT){
			gtk_tree_model_get(model, iter, COL_NAME, &Name, -1);
		}
		else{
			gtk_tree_model_get(model, iter, COL_FLSHLF_NAME, &Name, -1);
		}
		if ((strcmp(Name, "..")==0 || strcmp(Name,".")==0)){
			gtk_tree_selection_unselect_iter(theStruct->selection, iter);
			if (Name)
				g_free(Name);
			TRACEIT(10,"searchStringInAndHighlightItemsHelper		ends");
			return;
		}
		if (strcasestr(Name,theStruct->gstrSearchString->str) == NULL){	//strcasestr returns charpointer
			gtk_tree_selection_unselect_iter(theStruct->selection, iter);
		}
	}
	if (Name)
		g_free(Name);
	TRACEIT(10,"searchStringInAndHighlightItemsHelper		ends");
	return;
}


void searchStringInAndHighlightItems(GtkWidget *menuitem, gpointer data){
	TRACEIT(10,"searchStringInAndHighlightItems		start");
	struct AllInformationAllUseStruct *info=(struct AllInformationAllUseStruct *)data;
	struct SearchItemStruct theStruct;
	GtkTreeSelection	*selection;
	selection  = gtk_tree_view_get_selection(GTK_TREE_VIEW(info->Info_1));
	GString *SearchString = g_string_sized_new(10);
	GString *buf = g_string_sized_new(10);
	theStruct.gstrSearchString = g_string_sized_new(100);

    while (0 == MyEasyInputWidget (win, "search", "\nSearches all selected Items for the string you enter.\n", SearchString)){
		g_string_assign(buf, SearchString->str);

		cutSpacesFromGString(buf);
		if (strlen(buf->str)==0 || /*strcmp(buf->str,".")==0 || strcmp(buf->str,"..")==0 || */ strstr(buf->str,"/..")!=NULL  ){
		    MyMessageWidget(win, "not possible", "Makes not much sense to search for this! Haeah!?");
		}
		else{
			theStruct.selection = selection;
			g_string_assign(theStruct.gstrSearchString, SearchString->str);
			info->Info_2=(void *)&theStruct;
			gtk_tree_selection_selected_foreach(selection, searchStringInAndHighlightItemsHelper, (void *)info);
			break;
		}
	}

	g_string_free(theStruct.gstrSearchString,TRUE);
	g_string_free(SearchString,TRUE);
	g_string_free(buf,TRUE);

	TRACEIT(10,"searchStringInAndHighlightItems		ends");
}


void searchStringInAndHighlightItems_WraperforSideObject(GtkWidget *menuitem, gpointer data){
    TRACEIT(10,"searchStringInAndHighlightItems_WraperforSideObject		start");
	struct AllInformationAllUseStruct info;
	info.source = SOURCE_SIDEOBJECT;
	info.Info_1 = (void *)data;
	searchStringInAndHighlightItems(menuitem, (void *)&info);
	TRACEIT(10,"searchStringInAndHighlightItems_WraperforSideObject		start");
}


void searchStringInDirectoryRecursive_SideObject(GtkWidget *menuitem, struct SideObjectList *Object){
	TRACEIT(10,"searchStringInDirectoryRecursive_SideObject		start");

	GList *glistDirectories = NULL;

	glistDirectories = g_list_append (glistDirectories, Object->gstrPath);

	if (glistDirectories != NULL){
		find_simple(glistDirectories);	//this call will copy the whole list, we can delete it and its data!

		//g_list_foreach(glistDirectories, (GFunc) GListFreeGStrings, NULL);	//do not delete this GString here, we do not own it
		g_list_free(glistDirectories);
	}

	TRACEIT(10,"searchStringInDirectoryRecursive_SideObject		start");
}


void callAllWith_WraperforSideObject(GtkWidget *menuitem, gpointer data){
	TRACEIT(10,"callAllWith_WraperforSideObject		start");
	CallUsersDummyCommand (data, SOURCE_SIDEOBJECT, USERCOMMAND_CALLTYPE_ALL);
	TRACEIT(10,"callAllWith_WraperforSideObject		ends");
}


void callEachWith_WraperforSideObject(GtkWidget *menuitem, gpointer data){
	TRACEIT(10,"callEachWith_WraperforSideObject		start");

	CallUsersDummyCommand (data, SOURCE_SIDEOBJECT, USERCOMMAND_CALLTYPE_EACH);

	TRACEIT(10,"callEachWith_WraperforSideObject		ends");
}


void checkIfOneSelectionIsPathHelper(GtkTreeModel *model,GtkTreePath *path,GtkTreeIter *iter,gpointer data){
	TRACEIT(10,"checkIfOneSelectionIsPathHelper		start");
	int type_d;
	struct AllInformationAllUseStruct *stru = (struct AllInformationAllUseStruct *)data;
	gint *TheInfo = (gint *)stru->Info_1;
	int *Coloumn = (int *)stru->Info_2;

    gtk_tree_model_get(model, iter, *Coloumn, &type_d, -1);
    if (type_d==4 || type_d==10){
        *TheInfo = *TheInfo + 1;
        TRACEIT(10,"checkIfOneSelectionIsPathHelper		ends");
        return;
    }

	TRACEIT(10,"checkIfOneSelectionIsPathHelper		ends");
	return;
}


int checkIfOneSelectionIsPath(gpointer data, int ColoumnToUse){
	TRACEIT(10,"checkIfOneSelectionIsPath		start");
	GtkTreeSelection	*selection;
	gint IsPath=0;
	struct AllInformationAllUseStruct stru;
	stru.Info_1 = &IsPath;
	stru.Info_2 = &ColoumnToUse;

	selection  = gtk_tree_view_get_selection(GTK_TREE_VIEW(data));
	gtk_tree_selection_selected_foreach(selection, checkIfOneSelectionIsPathHelper, &stru);

	TRACEIT(10,"checkIfOneSelectionIsPath		ends");
	return IsPath;
}


void checkIfOneSelectionIsPointsHelper(GtkTreeModel *model,GtkTreePath *path,GtkTreeIter *iter,gpointer data){
	TRACEIT(10,"checkIfOneSelectionIsPointsHelper		start");
	struct AllInformationAllUseStruct *stru = (struct AllInformationAllUseStruct *)data;
	gint *TheInfo = (gint *)stru->Info_1;
	int *Coloumn = (int *)stru->Info_2;

	gchar *name=NULL;

	if (gtk_tree_model_get_iter(model, iter, path)){
		gtk_tree_model_get(model, iter, *Coloumn, &name, -1);
		if (strcmp(name,".")==0 || strcmp(name,"..")==0){
			*TheInfo = *TheInfo + 1;

			if (name)
				g_free(name);
			TRACEIT(10,"checkIfOneSelectionIsPointsHelper		ends");
			return;
		}
	}
	if (name)
		g_free(name);
	TRACEIT(10,"checkIfOneSelectionIsPointsHelper		ends");
	return;
}


int checkIfOneSelectionIsPoints(gpointer data, int ColoumnToUse){
	TRACEIT(10,"checkIfOneSelectionIsPoints		start");
	GtkTreeSelection	*selection;
	gint IsPath=0;
    struct AllInformationAllUseStruct stru;
	stru.Info_1 = &IsPath;
	stru.Info_2 = &ColoumnToUse;

	selection  = gtk_tree_view_get_selection(GTK_TREE_VIEW(data));
	gtk_tree_selection_selected_foreach(selection, checkIfOneSelectionIsPointsHelper, &stru);

	TRACEIT(10,"checkIfOneSelectionIsPoints		ends");
	return IsPath;
}


void getTypesOfSelectedItemsHelper(GtkTreeModel *model,GtkTreePath *path,GtkTreeIter *iter,gpointer data){
	TRACEIT(10,"getTypesOfSelectedItemsHelper		start");
	gchar *type=NULL;
	struct AllInformationAllUseStruct *info = (struct AllInformationAllUseStruct *)data;
	//struct TypesOfSelectedItemsList *bufitem=NULL;
	GList **TheList = (GList **)info->Info_2;
    GList *bufItem = NULL;
    //GString *gstrBuf = g_string_sized_new(10);

    if (info->source == SOURCE_SIDEOBJECT){
        gtk_tree_model_get(model, iter, COL_FILETYPE, &type, -1);
    }
    else{
        gtk_tree_model_get(model, iter, COL_FLSHLF_FILETYPE, &type, -1);
    }
    if (strcmp(type,"--")==0){
        //g_string_free(gstrBuf, TRUE);
        TRACEIT(10,"getTypesOfSelectedItemsHelper		ends");
        return;
    }

    bufItem = g_list_first (*TheList);
	while (bufItem){
        if (strcmp(type, ((GString *)(bufItem->data))->str)==0){
            if (type)
                g_free(type);
            //g_string_free(gstrBuf, TRUE);
            TRACEIT(10,"getTypesOfSelectedItemsHelper		ends");
            return;
        }
        bufItem = bufItem->next;
    }

    *TheList = g_list_append (*TheList,(void *)g_string_new(type));

    if (type)
        g_free(type);
	TRACEIT(10,"getTypesOfSelectedItemsHelper		ends");
	return;
}


GList *getTypesOfSelectedItems(struct AllInformationAllUseStruct *info){
    //do not forget to free the returned list, the data in the list are GString, which also have to be freed!
    //use: g_list_foreach(listDirs, (GFunc) GListFreeGStrings, NULL); g_list_free(listDirs);
	TRACEIT(10,"getTypesOfSelectedItems		start");
	//struct AllInformationAllUseStruct *info = (struct AllInformationAllUseStruct *)data;
    if (info == NULL){
        TRACEIT(2,"getTypesOfSelectedItems		parameter NULL");
        return NULL;
    }


	GtkTreeSelection	*selection;
	GList *glistTypesList=NULL;

    info->Info_2 = (void *)&glistTypesList;
	selection  = gtk_tree_view_get_selection(GTK_TREE_VIEW(info->Info_1));
	gtk_tree_selection_selected_foreach(selection, getTypesOfSelectedItemsHelper, (void *)info);
	TRACEIT(10,"getTypesOfSelectedItems		ends");
	return glistTypesList;
}


int getUserProgramsForSelectedItems(GList *glistMarkedTypes, struct UserDataList **theUserDataList){
    //DO NOT FORGET TO FREE THE RETURNED LIST!!!! in theUserDataList
    //writes a list which holds all the usercommands which are assigned to the marked items
    //
    //glistMarkedTypes can be NULL, in this case only the targets with countforall flag are written to theUserDataList
    //if glistMarkedTypes is not NULL, this items are also copied
    //return: -1=error, 0=ok
	TRACEIT(10,"getUserProgramsForSelectedItems		start");


    struct _UserCommandList *AllUserCommandList = NULL;
    GList   *glistBuf = NULL;
    int found = 0;

    if ( theUserDataList==NULL){
		TRACEIT(2,"getUserProgramsForSelectedItems		ends, Parameter NULL");
		return -1;
	}

    if (*theUserDataList != NULL){
        TRACEIT(4,"getUserProgramsForSelectedItems      theUserDataList output is not NULL, going to free this list");
        UserDataList_DeleteList (theUserDataList);
    }

    configFileHandling_loadConfigFile ( FALSE, FALSE );

    AllUserCommandList = g_UserCommandList;

    while (AllUserCommandList){
        if (glistMarkedTypes)
            glistBuf = g_list_first ( glistMarkedTypes );
        else
            glistBuf = NULL;
        found = 0;
        while (glistBuf){
            if (TRUE == UserCommandList_ItemHasTarget (AllUserCommandList, ((GString *)(glistBuf->data))->str) ){
                found = 1;
                if (*theUserDataList==NULL || NULL == UserDataList_getItemByListElement (*theUserDataList, (void *)AllUserCommandList) ){
                    UserDataList_AddItem (theUserDataList, AllUserCommandList->gstrName->str, (void *)AllUserCommandList);
                }
            }
            glistBuf = glistBuf->next;
        }
        if (found == 0 && TRUE == UserCommandList_ItemHasTarget (AllUserCommandList, COUNTSFORALLITEMSKEY) ){
            UserDataList_AddItem (theUserDataList, AllUserCommandList->gstrName->str, (void *)AllUserCommandList);
        }
        AllUserCommandList = AllUserCommandList->nextItem;
    }
    TRACEIT(10,"getUserProgramsForSelectedItems		ends");
    return 0;
}


gint glistComparePointer (gconstpointer a, gconstpointer b){
    if (a>b)
        return 1;
    else if (a<b)
        return -1;
    else
        return 0;
}


void getStandardStartDirectory(GString *gstrCommand){//, GString *gstrCommandName){
	TRACEIT(10,"getStandardStartDirectory		start");
	if (gstrCommand==NULL /*|| gstrCommandName==NULL*/){
		TRACEIT(2,"getStandardStartDirectory		ends -1  fatal: parameter are NULL");
		return;
	}

	configFileHandling_loadConfigFile( FALSE, FALSE );
    struct _OptionsList *StdStartDirItem = OptionsList_getItemByID(g_OptionsList, STANDARDSTARTDIRECTORY);
	if (StdStartDirItem == NULL /*|| StdStartDirItem->gstrName==NULL */|| StdStartDirItem->gstrValue==NULL){
		getHomeDirectory(gstrCommand);
		//g_string_assign(gstrCommandName, "home");
		TRACEIT(10,"getStandardStartDirectory		ends -1");
		return;
	}
	g_string_assign (gstrCommand, StdStartDirItem->gstrValue->str);

	TRACEIT(10,"getStandardStartDirectory		ends");
}


void MakeList_Helper (GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter, gpointer data){
	TRACEIT(10,"MakeList_Helper		start");
	struct AllInformationAllUseStruct *info = (struct AllInformationAllUseStruct *)data;
	if (info == NULL){
		return;
	}
	gchar *Name = NULL;
	gchar *Path = NULL;
	GString *gstrSource = g_string_new(((GString *)info->Info_2)->str);
	GString *gstrDest = g_string_new(((GString *)info->Info_3)->str);
	struct CopyReMoveList **FirstItem = (struct CopyReMoveList **)info->Info_1;

    if (info->source == SOURCE_SIDEOBJECT){
        gtk_tree_model_get(model, iter, COL_NAME, &Name, -1);
        checkPathForLastChar(gstrSource);
        if (!(strcmp(Name, "..")==0 || strcmp(Name,".")==0)){
            g_string_append(gstrSource,Name);
            checkPathForLastCharOtherwise(gstrSource);
            g_string_prepend_c(gstrSource,'\"');
            g_string_append_c(gstrSource,'\"');
            checkPathForLastCharOtherwise(gstrDest);
            CopyReMoveList_AddItem ( FirstItem, gstrSource->str, gstrDest->str, NULL, NULL, NULL);
        }
    }
    else{
        gtk_tree_model_get(model, iter, COL_FLSHLF_NAME, &Name, COL_FLSHLF_PATH, &Path, -1);
        g_string_assign(gstrSource,Path);
        checkPathForLastChar(gstrSource);
        if (!(strcmp(Name, "..")==0 || strcmp(Name,".")==0)){
            g_string_append(gstrSource,Name);
            checkPathForLastCharOtherwise(gstrSource);
            g_string_prepend_c(gstrSource,'\"');
            g_string_append_c(gstrSource,'\"');
            checkPathForLastCharOtherwise(gstrDest);
            CopyReMoveList_AddItem ( FirstItem, gstrSource->str, gstrDest->str, NULL, NULL, NULL);
        }
    }

	if (Name)
		g_free(Name);
	if (Path)
		g_free(Path);
	g_string_free(gstrSource,TRUE);
	g_string_free(gstrDest,TRUE);
	TRACEIT(10,"MakeList_Helper		ends");
}


int MakeList (int Source, struct CopyReMoveList **FirstItem, GtkTreeSelection *selection, GString *SourcePath, GString *gstrDestPath){
	TRACEIT(10,"MakeList		start");
	if (FirstItem == NULL || selection == NULL){
		return -1;
	}
	struct AllInformationAllUseStruct info;
	info.source = Source;
	info.Info_1 = (void *)FirstItem;
	info.Info_2 = (void *)SourcePath;
	info.Info_3 = (void *)gstrDestPath;

	gtk_tree_selection_selected_foreach(selection, MakeList_Helper, (void *)&info);

	if (*FirstItem == NULL){
		TRACEIT(3,"MakeList		end -1");
		return -1;
	}
	TRACEIT(10,"MakeList		end");
	return 0;
}

void createItemList_Helper (GtkTreeModel *model,GtkTreePath *path,GtkTreeIter *iter,gpointer data){
	TRACEIT(10,"createItemList_Helper		start");
	struct AllInformationAllUseStruct *info = (struct AllInformationAllUseStruct *)data;
	if (info == NULL){
		TRACEIT(2,"createItemList_Helper		end, Parameter NULL");
		return;
	}
	//info struct has :
	//info.Info_1 = (void *)&WithPath;
	//info.Info_2 = (void *)&glistTheList;	//do copy the list to here
	//info.Info_3 = (void *)UserDataListItem->Object;

	if (info->Info_1 == NULL || info->Info_2 == NULL || info->Info_3 == NULL){
		TRACEIT(2,"createItemList_Helper		end, Parameter NULL");
		return;
	}

	gchar *Name = NULL;
	gchar *Path = NULL;
	GList **glistBufList = (GList **)info->Info_2;
	GString *gstrPathBuf = g_string_sized_new(20);
	GString *gstrSaveString = NULL;
	int iWithPath = *(int *)(info->Info_1);

	if (info->source == SOURCE_SIDEOBJECT){
		gtk_tree_model_get(model, iter, COL_NAME, &Name, -1);
		g_string_assign (gstrPathBuf, ((struct SideObjectList *)info->Info_3)->gstrPath->str);
	}
	else if (info->source == SOURCE_FILESHELF){
		gtk_tree_model_get(model, iter, COL_FLSHLF_NAME, &Name, COL_FLSHLF_PATH, &Path, -1);
		g_string_assign (gstrPathBuf, Path);
	}
	if (!(strcmp(Name, "..")==0 || strcmp(Name,".")==0)){
		gstrSaveString = g_string_new (Name);
		if (iWithPath == 1){
			checkPathForLastChar (gstrPathBuf);
			g_string_prepend (gstrSaveString, gstrPathBuf->str);
		}
		*glistBufList = g_list_prepend (*glistBufList, gstrSaveString);
	}

	if (Name)
		g_free(Name);
	if (Path)
		g_free(Path);
	g_string_free(gstrPathBuf, TRUE);
}


GList *createItemList (struct UserDataList *UserDataListItem, GtkWidget *ListView, int WithPath){
	//creates a GList which holds all the items marked in ListView
	//we need UserDataListItem to decide if we are a SideObject or a Fileshelf
	//WithPath = 0 -> No Path added to the names, =1 -> The Path of each item is added
	TRACEIT (10, "createItemList			start");
	if (UserDataListItem == NULL || ListView == NULL){
		TRACEIT (2, "createItemList			Parameter NULL");
		return NULL;
	}
	GtkTreeSelection	*selection=NULL;
	GList *glistTheList = NULL;

	struct AllInformationAllUseStruct info;
	info.source = UserDataListItem->iSourceType;
	info.Info_1 = (void *)&WithPath;
	info.Info_2 = (void *)&glistTheList;
	info.Info_3 = (void *)UserDataListItem->Object;


	selection  = gtk_tree_view_get_selection(GTK_TREE_VIEW(ListView));
	gtk_tree_selection_selected_foreach(selection, createItemList_Helper, (void *)&info);

	glistTheList = g_list_reverse(glistTheList);


	TRACEIT (10, "createItemList			end");
	return glistTheList;
}


void startTerminal_WraperforSideObject (GtkWidget *menuitem, struct SideObjectList *Object){
    TRACEIT(10,"startTerminal_WraperforSideObject		start");
    UserOption_callTerminal(Object, SOURCE_SIDEOBJECT);
    TRACEIT(10,"startTerminal_WraperforSideObject		end");
}

void startStandardEditor_WraperforSideObject (GtkWidget *menuitem, struct SideObjectList *Object){
    TRACEIT(10,"startStandardEditor_WraperforSideObject		start");
    UserOption_callStandardEditor(Object, SOURCE_SIDEOBJECT);
    TRACEIT(10,"startStandardEditor_WraperforSideObject		end");
}


void startItemsWithUserCommand(GtkWidget *menuitem, struct UserDataList *UserDataListItem){
	//this is the main entry point for calling usercommands.
    //every time we give a command to the shell we should use this function.
    //UserDataListItem will be copied in here and not used in any following function or thread
	TRACEIT(10,"startItemsWithUserCommand		start");

    if (UserDataListItem == NULL){
        TRACEIT(2,"startItemsWithUserCommand		end, parameter NULL");
        return;
    }
    if (UserDataListItem->ListElement == NULL || UserDataListItem->Object==NULL){
        TRACEIT(2,"startItemsWithUserCommand		end, parameter 2 NULL");
        return;
    }

	//we first collect all information we may use. this means we create different lists which hold
	//the items with and without path.

	//to do that, we first need a listview:
	GtkWidget *             ListView = NULL;
	GList *                 glistItemsWithPath = NULL;
	GList *                 glistItemsWithoutPath = NULL;
	GString *               gstrHomeDir = NULL;
	GString *               gstrLeftSidePath = NULL;
	GString *               gstrRightSidePath = NULL;
	GString *               gstrThisSidePath = NULL; //only set if we come from an SideObject
	GString *               gstrOtherSidePath = NULL;//only set if we come from an SideObject
	struct SideObjectList * BufObject = NULL;
	struct UserDataList *   OurUserDataListItem = NULL;	//this will save the UserDataListItem (realcopy) for further usage within the following thread
	struct _UserCommandList *UserCommandListItem = NULL;
	int                     iRet = 0;

	if (UserDataListItem->iSourceType == SOURCE_SIDEOBJECT){
		ListView = ((struct SideObjectList *)UserDataListItem->Object)->listView;
	}
	else if(UserDataListItem->iSourceType == SOURCE_FILESHELF){
		ListView = ((struct FileShelfObjectList *)UserDataListItem->Object)->listView;
	}

	if (ListView == NULL){
		TRACEIT (2, "startItemsWithUserCommand		end, Unknown Source type!");
		return;
	}

    UserCommandListItem = (struct _UserCommandList *)UserDataListItem->ListElement;
    if (UserCommandListItem == NULL){
        TRACEIT (2, "startItemsWithUserCommand		end, UserCommandList NULL");
        return;
    }
	//now we want some additional information such as home directory
	//left side path, right side path and the item lists
	//get the home directory
	gstrHomeDir = g_string_sized_new (20);
	getHomeDirectory(gstrHomeDir);
	checkPathForLastCharOtherwise(gstrHomeDir);
	//get the left/right side pathes
	SideObjectList_GetActiveObject((GtkNotebook *)Notebooks[SIDE_LEFT], &BufObject);
	if (BufObject){
		gstrLeftSidePath = g_string_new(BufObject->gstrPath->str);
	}
	SideObjectList_GetActiveObject((GtkNotebook *)Notebooks[SIDE_RIGHT], &BufObject);
	if (BufObject){
		gstrRightSidePath = g_string_new(BufObject->gstrPath->str);
	}
	//the other side and this side gstrings only gots filled when we come from a SideObject
	if (UserDataListItem->iSourceType == SOURCE_SIDEOBJECT){
		gstrThisSidePath = g_string_new		( ((struct SideObjectList *)(UserDataListItem->Object))->gstrPath->str );
		gstrOtherSidePath = g_string_new	( (getOtherSideObject((struct SideObjectList *)(UserDataListItem->Object)))->gstrPath->str);
	}

	//all this lists are NOT QUOTED!!!
	glistItemsWithoutPath 	= 	createItemList (UserDataListItem, ListView, 0);	//0=without path
	glistItemsWithPath 		= 	createItemList (UserDataListItem, ListView, 1);	//1=with path
	//if (glistItemsWithPath == NULL || glistItemsWithoutPath == NULL){
		//iRet = -1;
	//}

	//we now will copy (this means realy copy) the UserDataListItem so we do not loose the information stored in there
	//when the list gets deleled while we are not yet finished with it.
	//because we will start a thread which to process the command and call it to the system.
	UserDataList_AddItem(&OurUserDataListItem, UserDataListItem->gstrMenuName->str, NULL);
	if (OurUserDataListItem == NULL){
		iRet = -1;
		TRACEIT (2, "startItemsWithUserCommand		Error allocating new memory");
	}
	else{
	    OurUserDataListItem->iSourceType = UserDataListItem->iSourceType;
		iRet = UserCommandList_copyItemToList ( ((struct _UserCommandList **)&(OurUserDataListItem->ListElement)), UserCommandListItem);
	}

    if (iRet != -1 && UserDataListItem->iSourceType == SOURCE_SIDEOBJECT && ((struct _UserCommandList *)(OurUserDataListItem->ListElement))->gstrWorkingDir == NULL){
        UserCommandList_editItem( ((struct _UserCommandList *)(OurUserDataListItem->ListElement)), -1, NULL, NULL, NULL, -1, NULL, NULL, NULL, NULL, NULL, NULL, ((struct SideObjectList *)UserDataListItem->Object)->gstrPath->str);
    }

	//now that we have all the information we want we can think about starting a thread to call the command to the system
	if (iRet != -1){
	    //!!! the function CallUserCommand_StartThread will free all the variables given to them!
        iRet = CallUserCommand_StartThread (OurUserDataListItem, glistItemsWithPath, glistItemsWithoutPath, gstrThisSidePath, gstrOtherSidePath, gstrLeftSidePath, gstrRightSidePath, gstrHomeDir);
	}

	//free things here
	if (iRet == -1){
		//in this case no thread was started which could free the things. so let us do this
		if (glistItemsWithPath){
			g_list_foreach(glistItemsWithPath, (GFunc) GListFreeGStrings, NULL); g_list_free(glistItemsWithPath);
		}
		if (glistItemsWithoutPath){
			g_list_foreach(glistItemsWithoutPath, (GFunc) GListFreeGStrings, NULL); g_list_free(glistItemsWithoutPath);
		}
		if (gstrHomeDir)
			g_string_free(gstrHomeDir, TRUE);
		if (gstrLeftSidePath)
			g_string_free(gstrLeftSidePath, TRUE);
		if (gstrRightSidePath)
			g_string_free(gstrRightSidePath, TRUE);
		if (gstrThisSidePath)
			g_string_free(gstrThisSidePath, TRUE);
		if (gstrOtherSidePath)
			g_string_free(gstrOtherSidePath, TRUE);

		if (OurUserDataListItem){
			UserCommandList_freeList( ((struct _UserCommandList **)&OurUserDataListItem->ListElement));
			UserDataList_DeleteList(&OurUserDataListItem);
		}
	}

	return;
}


void CallUsersDummyCommand (void *Object, int iSource, int iCallType){
	TRACEIT(10,"callAllWith		start");
	//this function will ask the user for the command
	//Object is SideObject or FileShelfObject, iSource makes this clear

	//struct AllInformationAllUseStruct *info= (struct AllInformationAllUseStruct *)data;
	if (Object == NULL){
        TRACEIT (2, "callAllWith        parameter NULL");
        return;
	}

	GString *gstrCommand = g_string_sized_new(10);
	GString *gstrBuf = g_string_sized_new(10);
	struct UserDataList *theDummyItem = malloc (sizeof (struct UserDataList));
    if (theDummyItem == NULL){
        TRACEIT (3, "CallUsersDummyCommand            unable to allocate memory");
        return ;
    }

	while (0 == MyEasyInputWidget (win, "open all with", "type in with which command you want to\nexecute the selected files.\nThey will be added to the end on one single line.", gstrCommand)){
        g_string_assign(gstrBuf, gstrCommand->str);

		cutSpacesFromGString(gstrBuf);
		if (strcmp(gstrBuf->str,".")==0 || strcmp(gstrBuf->str,"..")==0 || strlen(gstrBuf->str)==0 || strstr(gstrBuf->str,"/..")!=NULL  ){
			MyMessageWidget(win, "not possible", "Iam not allowed to call this!\nThis means me, the programm, not the user");
		}
		else{
		    g_string_append (gstrCommand, " $(MI_WP_Q)");
            UserDataList_CreateDummyCommand (theDummyItem, gstrCommand->str, Object, iSource, iCallType );
            startItemsWithUserCommand(NULL, theDummyItem);
            UserCommandList_freeList( (struct _UserCommandList **)&((theDummyItem->ListElement)) );
            UserDataList_DeleteList(&theDummyItem);
            theDummyItem = NULL;
			break;
		}
	}
    if (theDummyItem != NULL){
        free (theDummyItem);
    }

	g_string_free(gstrCommand, TRUE);
	g_string_free(gstrBuf, TRUE);

	return;
}


#ifdef WORKING

void workingMenuItem(GtkWidget *menuitem, gpointer data){
   // MyMessageWidget(NULL,"etst","terste");
   //createUserCommand_start (NULL);
    GtkTreeViewColumn *col=NULL;
    struct SideObjectList *Object = NULL;
    const char *ccpBuf = NULL;

    SideObjectList_GetActiveObject( (GtkNotebook *)Notebooks[0], &Object);
    if (Object == NULL){
        printf("OBJECT NULL\n");
        return;
    }

    col = gtk_tree_view_get_column ( (GtkTreeView *)Object->listView, 2);






    ccpBuf = gtk_tree_view_column_get_title (col);

    printf ("ccpBuf = %s\n",ccpBuf);

/*
    configFileHandling_Init();
    configFileHandling_loadConfigFile(FALSE, FALSE);
    debugOut_PrintLists();
    configFileHandling_clearForShutdown();
*/
/*
    //XML PARSER START
    GMarkupParser Parser;
    Parser.start_element = foundStart;
    Parser.end_element = foundend;
    Parser.text         = foundtext;
    Parser.passthrough = NULL;
    Parser.error = NULL;
    GError *err=NULL;

    FILE *thefile = fopen ("/wurzel/TMP/new.xml", "r");
    if (thefile == NULL){
        MyMessageWidget(NULL,"etst","error opening xml file");
    }

    GMarkupParseContext *cont = g_markup_parse_context_new (&Parser, 0, NULL, NULL); //G_MARKUP_TREAT_CDATA_AS_TEXT


    char line[401];
    while (NULL != fgets(line, 400, thefile)){
        //MyMessageWidget(NULL, "feeding line:",line);
        if (FALSE == g_markup_parse_context_parse        (cont, line, strlen(line), &err)){
            MyMessageWidget(NULL, "Parser Error",err->message);
        }
    }

    g_markup_parse_context_free         (cont);
    //XML PARSER end



  */  //GString *gstrBuf = g_string_sized_new(10);
/*
    GVfs *gfvsMine = g_vfs_get_local ();

    GFile *gfile= g_vfs_get_file_for_uri (gfvsMine, "ftp://ftp.freebsd.org/pub/FreeBSD/releases/i386/ISO-IMAGES/8.0/");

    const char * const *cppList = g_vfs_get_supported_uri_schemes (gfvsMine);
    while (*cppList){
        //g_string_append(gstrBuf, *cppList);
        //g_string_append(gstrBuf, "\n");
    //    cppList++;
        printf("string: %s\n",*cppList);
        cppList++;
    }
    //g_string_free(gstrBuf, TRUE);

    //MyMessageWidget (NULL, "test", gstrBuf->str);

    g_object_unref(gfile);
    */
/*
    //GFile - Directory read    START
    GError *err=NULL;
    GString *gstrNames = g_string_sized_new(10);
    GString *gstrBuf = g_string_sized_new(10);

    //GFile *gfilePath = g_file_new_for_path ("ftp://anonymous@ftp.freebsd.org/pub/FreeBSD/releases/i386/ISO-IMAGES/7.2/");
    GFile *gfilePath = g_file_new_for_uri ("ftp://anonymous@ftp.freebsd.org/pub/FreeBSD/releases/i386/ISO-IMAGES/7.2/");
    //GFile *gfilePath = g_file_parse_name ("ftp://anonymous@ftp.freebsd.org/pub/FreeBSD/releases/i386/ISO-IMAGES/7.2/");



    if (g_file_is_native(gfilePath) == TRUE){
        MyMessageWidget(NULL, "dfsdf","g_file_is_native returned TRUE");
    }
    else{
        MyMessageWidget(NULL, "dfsdf","g_file_is_native returned FALSE");
    }
    //"file:///wurzel/TMP"
    //g_file_get_uri_scheme
    //g_file_has_uri_scheme
    //"ftp://anonymous@ftp.freebsd.org/pub/FreeBSD/releases/i386/ISO-IMAGES/7.2/"
    //smb:///drhibbert/Lesbar/filme
    g_string_append(gstrNames, g_file_get_path (gfilePath));
    g_string_append(gstrNames, "\n");
    char *cpScheme = g_file_get_uri_scheme (gfilePath);
    g_string_append(gstrNames, cpScheme);
    g_string_append(gstrNames, "\n\n");

    //MyMessageWidget(NULL,"lits", gstrNames->str);

    GFileEnumerator *enumerator = g_file_enumerate_children (gfilePath, "standard::name", G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS, NULL, &err); //G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS

    if (err != NULL){
        g_string_printf(gstrBuf, "%d:%s",err->code, err->message);
        MyMessageWidget(NULL,"111",gstrBuf->str);
        g_error_free(err);
        err=NULL;
    }

    GFileInfo *gfinfo = NULL;
    char *cpName=NULL;
    gfinfo = g_file_enumerator_next_file (enumerator, NULL, &err);

    if (err != NULL){
        MyMessageWidget(NULL,"222",err->message);
        g_error_free(err);
        err=NULL;
    }
    do{
        cpName = g_file_info_get_attribute_as_string (gfinfo, G_FILE_ATTRIBUTE_STANDARD_NAME);
        g_string_append(gstrNames, cpName);
        g_string_append(gstrNames, "\n");
        gfinfo = g_file_enumerator_next_file (enumerator, NULL, &err);
        if (err != NULL){
            MyMessageWidget(NULL,"333",err->message);
            g_error_free(err);
            err=NULL;
        }
    }while(gfinfo!=NULL);

    MyMessageWidget(NULL,"lits", gstrNames->str);

    if (err)
        g_error_free(err);
    g_string_free(gstrNames, TRUE);
    g_string_free(gstrBuf, TRUE);

    g_file_enumerator_close (enumerator,NULL,NULL);
    g_object_unref(enumerator);
    g_object_unref(gfinfo);
//    g_object_unref(stream);

*/    //GFile - Directory read    END




//########################################################################
//########################################################################
//########################################################################
//########################################################################
//########################################################################
//########################################################################
//########################################################################
//########################################################################

}

#endif
/////////////////////////////////////////////////////////////////////////////////////
//////////////////////    CONTEXTMENU       /////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////


void openContextMenu(GtkWidget *treeview, GdkEventButton *event, gpointer data){
	TRACEIT(10,"openContextMenu		start");
	GtkWidget *menu, *menuitem;
	struct SideObjectList *Object=(struct SideObjectList *)data;
	menu = gtk_menu_new();
	struct AllInformationAllUseStruct info;
	info.source = SOURCE_SIDEOBJECT;
	info.Info_1 = (void *)Object->listView;
	GtkTreeSelection *selection;
	GtkWidget *sep1, *sep2, *sep3, *sep4, *sep5;
	int NumOfSelectedRows=0;
	GList *glistMarkedTypes=NULL;
	struct _OptionsList *OptionsListBuf = NULL;

	if (NULL != g_UserDataList){
        UserDataList_DeleteList(&g_UserDataList);
        //g_UserDataList = NULL;	//this is allready done by the deleteList function
	}

	selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(treeview));
	//NumOfSelectedRows = gtk_tree_selection_count_selected_rows(selection);
	if (gtk_tree_selection_count_selected_rows(selection)  <= 1 && event != NULL){   //Event can be NULL if the key for contextmenu is presed
		GtkTreePath *path;
        TRACEIT(11,"openContextMenu		mark the item coverd by mousepointer");
        if (gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(treeview), (gint) event->x, (gint) event->y, &path, NULL, NULL, NULL)){
			gtk_tree_selection_unselect_all(selection);
			gtk_tree_selection_select_path(selection, path);
			gtk_tree_path_free(path);
		}
	}
	NumOfSelectedRows = gtk_tree_selection_count_selected_rows(selection);

    TRACEIT(11,"openContextMenu		create seperator");
	sep1 = gtk_separator_menu_item_new ();
	sep2 = gtk_separator_menu_item_new ();
	sep3 = gtk_separator_menu_item_new ();
	sep4 = gtk_separator_menu_item_new ();
	sep5 = gtk_separator_menu_item_new ();

	menuitem = gtk_menu_item_new_with_label("update panel");
	g_signal_connect(menuitem,"activate",G_CALLBACK(updatePannels),data);
	gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);

    TRACEIT(11,"openContextMenu		check for one selection is path");
	if (checkIfOneSelectionIsPath(Object->listView, COL_TYPE_D) != 0){
		menuitem = gtk_menu_item_new_with_label("open in new panel");
		g_signal_connect(menuitem,"activate", G_CALLBACK( openInNewPannel),data);
		gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
	}

    TRACEIT(11,"openContextMenu		fill the terminal structure");

    OptionsListBuf = OptionsList_getItemByID(g_OptionsList, TERMINALKEY);
    if (OptionsListBuf!=NULL && OptionsListBuf->gstrName!= NULL && OptionsListBuf->gstrValue!=NULL){
        menuitem = gtk_menu_item_new_with_label(OptionsListBuf->gstrName->str);
        g_signal_connect(menuitem,"activate",G_CALLBACK(startTerminal_WraperforSideObject),data);
        gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
    }

    menuitem = gtk_menu_item_new_with_label("search for...");
    g_signal_connect(menuitem, "activate", G_CALLBACK(searchStringInDirectoryRecursive_SideObject), Object);
    gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);


    if (NumOfSelectedRows >= 1){
        menuitem = gtk_menu_item_new_with_label("search highlighted...");
        g_signal_connect(menuitem,"activate",G_CALLBACK(searchStringInAndHighlightItems_WraperforSideObject),Object->listView);
        gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);

        menuitem = gtk_menu_item_new_with_label("size...");
        g_signal_connect(menuitem,"activate",G_CALLBACK(sizeOfSelectedItemsRecursive),Object);
        gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
    }

	gtk_menu_shell_append(GTK_MENU_SHELL(menu), sep1);

	//UserProgams/////////////////////////////////////////
	TRACEIT(11,"openContextMenu		starting with user command section");

	if (checkIfOneSelectionIsPath(Object->listView, COL_TYPE_D)==0 && NumOfSelectedRows>0){
	    //if (NumOfSelectedRows != 0){
        OptionsListBuf = OptionsList_getItemByID(g_OptionsList, STANDARDEDITORKEY);
        if (OptionsListBuf!=NULL && OptionsListBuf->gstrName!= NULL && OptionsListBuf->gstrValue!=NULL){
            menuitem = gtk_menu_item_new_with_label(OptionsListBuf->gstrName->str);
            g_signal_connect(menuitem,"activate",G_CALLBACK(startStandardEditor_WraperforSideObject),data);
            gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
        }
        //}

		glistMarkedTypes = getTypesOfSelectedItems(&info);
		if (glistMarkedTypes != NULL)
            getUserProgramsForSelectedItems(glistMarkedTypes, &g_UserDataList);   //u will get the commands which 'countForAllItems' too
        if (NULL != glistMarkedTypes){
            g_list_foreach(glistMarkedTypes, (GFunc) GListFreeGStrings, NULL);
            g_list_free(glistMarkedTypes);
            glistMarkedTypes = NULL;
        }
	}
	else if (checkIfOneSelectionIsPoints(Object->listView, COL_NAME) == 0){
	    getUserProgramsForSelectedItems(NULL, &g_UserDataList);   //this will only get the commands which 'countForAll'
	}


	//UserCommand_CreateUserMenu(menu);
	struct MenuObjectList *MenuObjectListForMenuCreation = NULL;
	if (g_UserDataList != NULL){
        UserCommand_CreateUserMenu(menu, g_UserDataList, &MenuObjectListForMenuCreation);

        struct UserDataList *UserDataListBuf = UserDataList_getFirstItem(g_UserDataList);
        while (UserDataListBuf){
            UserDataListBuf->iSourceType = SOURCE_SIDEOBJECT;
            UserDataListBuf->Object = (void *)data;

            menuitem = gtk_menu_item_new_with_label(UserDataListBuf->gstrMenuName->str);
            g_signal_connect(menuitem,"activate",G_CALLBACK(startItemsWithUserCommand),UserDataListBuf);
            gtk_menu_shell_append(GTK_MENU_SHELL(UserDataListBuf->MenuToAddTo), menuitem);
            UserDataListBuf = UserDataListBuf->nextItem;
        }
	}
    if (MenuObjectListForMenuCreation != NULL){
        UserCommand_AttachUserMenu(MenuObjectListForMenuCreation);
        MenuObjectList_DeleteList (&MenuObjectListForMenuCreation);
    }

    TRACEIT(11,"openContextMenu		end usercommand section");
	//EndUserPrograms/////////////////////////////////////

		gtk_menu_shell_append(GTK_MENU_SHELL(menu), sep2);

    if (NumOfSelectedRows >= 1){
        menuitem = gtk_menu_item_new_with_label("open all with...");
        g_signal_connect(menuitem,"activate",G_CALLBACK(callAllWith_WraperforSideObject),data);
        gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);

        menuitem = gtk_menu_item_new_with_label("open each with...");
        g_signal_connect(menuitem,"activate",G_CALLBACK(callEachWith_WraperforSideObject),data);
        gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
    }
		gtk_menu_shell_append(GTK_MENU_SHELL(menu), sep3);

    if (NumOfSelectedRows >= 1){
        menuitem = gtk_menu_item_new_with_label("copy to other panel");
        g_signal_connect(menuitem,"activate", G_CALLBACK( copyToOtherPannel),data);
        gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);

        menuitem = gtk_menu_item_new_with_label("move to other panel");
        g_signal_connect(menuitem,"activate",G_CALLBACK(moveToOtherPannel),data);
        gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);

        menuitem = gtk_menu_item_new_with_label("rename...");
        g_signal_connect(menuitem,"activate",G_CALLBACK(renameItems),data);
        gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
    }

	menuitem = gtk_menu_item_new_with_label("new directory...");
	g_signal_connect(menuitem,"activate",G_CALLBACK(mayNewDirectory),data);
	gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);

		gtk_menu_shell_append(GTK_MENU_SHELL(menu), sep4);

    if (NumOfSelectedRows >= 1){
        menuitem = gtk_menu_item_new_with_label("add to fileshelf");
        g_signal_connect(menuitem,"activate",G_CALLBACK(MenuAddItemToFileshelf),data);
        gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);

        menuitem = gtk_menu_item_new_with_label("add to new fileshelf");
        g_signal_connect(menuitem,"activate",G_CALLBACK(MenuAddToNewFileshelf),data);
        gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
    }

		gtk_menu_shell_append(GTK_MENU_SHELL(menu), sep5);

    if (NumOfSelectedRows >= 1){
        menuitem = gtk_menu_item_new_with_label("remove");
        g_signal_connect(menuitem, "activate", G_CALLBACK( mayDeleteSelectedRows), data);
        gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
    }

	gtk_widget_show_all(menu);
	// Note: event can be NULL here when called from view_onPopupMenu;
	// gdk_event_get_time() accepts a NULL argument
	gtk_menu_popup(GTK_MENU(menu), NULL, NULL, NULL, NULL, (event != NULL) ? event->button : 0, gdk_event_get_time((GdkEvent*)event));


	TRACEIT(10,"openContextMenu		ends");
}


void openTabContextMenu(GtkWidget *notebook, GdkEventButton *event, gpointer data){
	TRACEIT(10,"openTabContextMenu		start");
	GtkWidget *menu, *menuitem, *menuNewBookmarks, *menuGoToBookmarks, *menuInternals;
	menu = gtk_menu_new();

	menuNewBookmarks = gtk_menu_new();
	menuGoToBookmarks = gtk_menu_new();
	menuInternals = gtk_menu_new();
	GtkWidget *sep1, *sep2, *sep3, *sep4, *sep5, *sep6;

	sep1 = gtk_separator_menu_item_new ();
	sep2 = gtk_separator_menu_item_new ();
	sep3 = gtk_separator_menu_item_new ();
	sep4 = gtk_separator_menu_item_new ();
	sep5 = gtk_separator_menu_item_new ();
	sep6 = gtk_separator_menu_item_new ();

    struct SideObjectList *Object=NULL;
	SideObjectList_GetActiveObject((GtkNotebook *)notebook, &Object);

    //////////////////////////////////////////////////////////////////////
    //////// BookmarkMenu start //////////////////////////////////////////////

    struct MenuObjectList *MenuObjectListForMenuCreation = NULL;
    struct UserDataList *UserDataListBuf = NULL;

    if (NULL != g_UserDataList){
        UserDataList_DeleteList(&g_UserDataList);
        //g_UserDataList = NULL;	//this is allready done by the deleteList function
	}
    UserDataListFromBookmarkList(&g_UserDataList);  //loads list from file
    if (g_UserDataList != NULL){
    	UserCommand_CreateUserMenu(menuNewBookmarks, g_UserDataList, &MenuObjectListForMenuCreation);
        UserDataListBuf = UserDataList_getFirstItem(g_UserDataList);
        while (UserDataListBuf){
            //UserDataListBuf->iSourceType = SOURCE_SIDEOBJECT;
            UserDataListBuf->Object = (void *)notebook;
            menuitem = gtk_menu_item_new_with_label(UserDataListBuf->gstrMenuName->str);
            g_signal_connect(menuitem,"activate",G_CALLBACK(addNewPageFromBookmarks),UserDataListBuf);
            gtk_menu_shell_append(GTK_MENU_SHELL(UserDataListBuf->MenuToAddTo), menuitem);
            UserDataListBuf->MenuToAddTo = NULL;    //delete the reference or the following menucreation will fail
            UserDataListBuf = UserDataListBuf->nextItem;
        }
        if (MenuObjectListForMenuCreation != NULL){ //maybe noone of the items has a menu
            UserCommand_AttachUserMenu(MenuObjectListForMenuCreation);
            MenuObjectList_DeleteList (&MenuObjectListForMenuCreation);
        }
    }
    //if (NULL != g_UserDataList){
    //    UserDataList_DeleteList(&g_UserDataList);
        //g_UserDataList = NULL;	//this is allready done by the deleteList function
	//}
    //UserDataListFromBookmarkList(&g_UserDataList);  //loads list from file
    if (g_UserDataList != NULL){
        UserCommand_CreateUserMenu(menuGoToBookmarks, g_UserDataList, &MenuObjectListForMenuCreation);
        UserDataListBuf = UserDataList_getFirstItem(g_UserDataList);
        while (UserDataListBuf){
            //UserDataListBuf->iSourceType = SOURCE_SIDEOBJECT;
            UserDataListBuf->Object = (void *)notebook;
            menuitem = gtk_menu_item_new_with_label(UserDataListBuf->gstrMenuName->str);
            g_signal_connect(menuitem,"activate",G_CALLBACK(goToFromBookmarks),UserDataListBuf);
            gtk_menu_shell_append(GTK_MENU_SHELL(UserDataListBuf->MenuToAddTo), menuitem);
            UserDataListBuf = UserDataListBuf->nextItem;
        }
        if (MenuObjectListForMenuCreation != NULL){ //maybe noone of the items has a menu
            UserCommand_AttachUserMenu(MenuObjectListForMenuCreation);
            MenuObjectList_DeleteList (&MenuObjectListForMenuCreation);
        }

        menuitem = gtk_menu_item_new_with_label("new page from Bookmark");
        gtk_menu_item_set_submenu ((GtkMenuItem *)menuitem,menuNewBookmarks);
        gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);

        menuitem = gtk_menu_item_new_with_label("go to Bookmark");
        gtk_menu_item_set_submenu ((GtkMenuItem *)menuitem,menuGoToBookmarks);
        gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
	}
    //////// BookmarkMenu end //////////////////////////////////////////////
    //////////////////////////////////////////////////////////////////////

	menuitem = gtk_menu_item_new_with_label("new page");
	g_signal_connect(menuitem,"activate",G_CALLBACK(addNewPage),notebook);
	gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);

		gtk_menu_shell_append(GTK_MENU_SHELL(menu), sep1);

	menuitem = gtk_menu_item_new_with_label("dublicate active page");
	g_signal_connect(menuitem,"activate",G_CALLBACK(dublicateActivePage),notebook);
	gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);

	if (1<gtk_notebook_get_n_pages(GTK_NOTEBOOK(notebook))){
		menuitem = gtk_menu_item_new_with_label("move active page");
		g_signal_connect(menuitem,"activate",G_CALLBACK(moveActivePage),notebook);
		gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
	}

	menuitem = gtk_menu_item_new_with_label("copy active page");
	g_signal_connect(menuitem,"activate",G_CALLBACK(copyActivePage),notebook);
	gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);

		gtk_menu_shell_append(GTK_MENU_SHELL(menu), sep2);
	//INTERNAL MENU START
        menuitem = gtk_menu_item_new_with_label("property page...");
        g_signal_connect(menuitem, "activate", G_CALLBACK(internal_startPropPage), NULL);
        gtk_menu_shell_append(GTK_MENU_SHELL(menuInternals), menuitem);

        menuitem = gtk_menu_item_new_with_label("save pathes and FileShelfs");
        g_signal_connect(menuitem,"activate",G_CALLBACK(internalSavePathesAndShelfs),NULL);
        gtk_menu_shell_append(GTK_MENU_SHELL(menuInternals), menuitem);

        gtk_menu_shell_append(GTK_MENU_SHELL(menuInternals), sep4);

        menuitem = gtk_menu_item_new_with_label("command history");
        g_signal_connect(menuitem,"activate",G_CALLBACK(internalMenuCommandHistory),NULL);
        gtk_menu_shell_append(GTK_MENU_SHELL(menuInternals), menuitem);

        gtk_menu_shell_append(GTK_MENU_SHELL(menuInternals), sep5);

        menuitem = gtk_menu_item_new_with_label("about Cat'sEyE");
        g_signal_connect(menuitem,"activate",G_CALLBACK(internalMenuAbout),NULL);
        gtk_menu_shell_append(GTK_MENU_SHELL(menuInternals), menuitem);

	menuitem = gtk_menu_item_new_with_label("internals");
	gtk_menu_item_set_submenu ((GtkMenuItem *)menuitem,menuInternals);
	gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);

	//INTERNAL MENU END

		gtk_menu_shell_append(GTK_MENU_SHELL(menu), sep3);

    if (g_int_AlwaysShowHidden==0){
        menuitem = gtk_menu_item_new_with_label("always show hidden files (all tabs)");
    }
    else{
        menuitem = gtk_menu_item_new_with_label("do not show hidden files (all tabs)");
    }
    g_signal_connect(menuitem,"activate",G_CALLBACK(AlwaysShowHiddenfilesInAllTabs),NULL);
    gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);

	if (Object != NULL){
		if (Object->showHiddenFiles){
			menuitem = gtk_menu_item_new_with_label("hide hidden files (this tab)");
		}
		else{
			menuitem = gtk_menu_item_new_with_label("show hidden files (this tab)");
		}
	}
	else{
		menuitem = gtk_menu_item_new_with_label("show hidden files");
	}
	g_signal_connect(menuitem,"activate",G_CALLBACK(showHiddenFilesInActivePage),notebook);
	gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);

	if (Object != NULL){
		if (0 != Object->iPreview){
			menuitem = gtk_menu_item_new_with_label("disable preview");
		}
		if (0 == Object->iPreview){
			menuitem = gtk_menu_item_new_with_label("enable picture preview");
		}
		g_signal_connect(menuitem,"activate",G_CALLBACK(ChangePreviewState),Object);
		gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
	}


	if (Object != NULL){
		if (FALSE == Object->bReadOnly){
			menuitem = gtk_menu_item_new_with_label("mark tab as read only");
		}
		else{
			menuitem = gtk_menu_item_new_with_label("mark tab as writable");
		}
		g_signal_connect(menuitem,"activate",G_CALLBACK(ChangeReadOnlyState),Object);
		gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
	}


    gtk_menu_shell_append(GTK_MENU_SHELL(menu), sep6);

	if (1<gtk_notebook_get_n_pages(GTK_NOTEBOOK(notebook))){
		menuitem = gtk_menu_item_new_with_label("close active page");
		g_signal_connect(menuitem,"activate",G_CALLBACK(closeActivePage),notebook);
		gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
	}

#ifdef WORKING
    menuitem = gtk_menu_item_new_with_label("Working item");
	g_signal_connect(menuitem,"activate",G_CALLBACK(workingMenuItem),NULL);
	gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);

#endif


	gtk_widget_show_all(menu);
	// Note: event can be NULL here when called from view_onPopupMenu;
	// gdk_event_get_time() accepts a NULL argument
	gtk_menu_popup(GTK_MENU(menu), NULL, NULL, NULL, NULL, (event != NULL) ? event->button : 0, gdk_event_get_time((GdkEvent*)event));

	TRACEIT(10,"openTabContextMenu		ends");
}

//////////////////////    CONTEXTMENU       /////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////

void internal_startPropPage (GtkWidget *menuitem, gpointer data){
    propPage_startPropPage ();
}


void internalSavePathesAndShelfs(GtkWidget *menuitem, gpointer data){
    GtkWidget *dialog, *label;
    GString *gstrBuf = g_string_sized_new(10);

    g_string_sprintf(gstrBuf,"This will save the currently opened directories\nand FileShelfs to the standard file in your home directory:\n%s\n",SAVE_FILE);

    dialog = CreateMyDialog("Save Session", win, 2, "Ok",GTK_RESPONSE_ACCEPT,"Cancel",GTK_RESPONSE_REJECT, NULL, 0, FALSE);
	label = gtk_label_new(gstrBuf->str);
	gtk_container_add(GTK_CONTAINER(GTK_DIALOG(dialog)->vbox),label);
	gtk_widget_show_all(dialog);
	if (gtk_dialog_run(GTK_DIALOG(dialog))== GTK_RESPONSE_ACCEPT){
            saveThings();
	}
    gtk_widget_destroy(dialog);
    g_string_free(gstrBuf, TRUE);
}


void goToFromBookmarks(GtkWidget *menuitem, struct UserDataList *UserDataListItem){
	TRACEIT(10,"goToFromBookmarks		start");
	//struct bookmarklist *Bookmark=(struct bookmarklist *)data;

	struct SideObjectList *Object=NULL;

	if (UserDataListItem == NULL){
        TRACEIT (4, "addNewPageFromBookmarks        parameter NULL");
        return;
	}
	SideObjectList_GetActiveObject((GtkNotebook *)UserDataListItem->Object, &Object);
	if (Object == NULL){
		TRACEIT(4,"goToFromBookmarks		no active object");
		return;
	}
	struct _OptionsList *optionsListItem = UserDataListItem->ListElement;
	if (optionsListItem == NULL){
        TRACEIT (4, "addNewPageFromBookmarks        parameter 2 NULL");
        return;
	}
	if (optionsListItem->gstrValue == NULL){
        TRACEIT (4, "addNewPageFromBookmarks        parameter 3 NULL");
        return;
	}
	updateViewWithNewFolder(Object, optionsListItem->gstrValue);
	TRACEIT(10,"goToFromBookmarks		ends");
}


void addNewPageFromBookmarks(GtkWidget *menuitem, struct UserDataList *UserDataListItem){
	TRACEIT(10,"addNewPageFromBookmarks		start");
	//struct bookmarklist *Bookmark=(struct bookmarklist *)data;
	if (UserDataListItem == NULL){
        TRACEIT (4, "addNewPageFromBookmarks        parameter NULL");
        return;
	}
	struct _OptionsList *optionsListItem = UserDataListItem->ListElement;
	if (optionsListItem == NULL){
        TRACEIT (4, "addNewPageFromBookmarks        parameter 2 NULL");
        return;
	}
	if (optionsListItem->gstrValue == NULL){
        TRACEIT (4, "addNewPageFromBookmarks        parameter 3 NULL");
        return;
	}

	SideObjectList_CreateNewViewWithPath((GtkNotebook *)UserDataListItem->Object, optionsListItem->gstrValue->str,NULL);
	TRACEIT(10,"addNewPageFromBookmarks		ends");
}


void AlwaysShowHiddenfilesInAllTabs(){
	TRACEIT(10,"AlwaysShowHiddenfilesInAllTabs		start");
	gboolean boolBuf=FALSE;
	if (1==g_int_AlwaysShowHidden){
		TRACEIT(11,"AlwaysShowHiddenfilesInAllTabs		hide");
		g_int_AlwaysShowHidden=0;
		boolBuf=FALSE;
	}
	else{
		TRACEIT(11,"AlwaysShowHiddenfilesInAllTabs		show");
		g_int_AlwaysShowHidden=1;
		boolBuf=TRUE;
	}

	struct SideObjectList *ObjectBuf = SideObjectList_getFirstObject();
	while (ObjectBuf != NULL){
	    calcDirectorySizeInView_closeProcess (&(ObjectBuf->iRecursiveSizeCalculation), &(ObjectBuf->gthreadF6Updage), &(ObjectBuf->bUpdateFlag_F6), &(ObjectBuf->iPreventFromUpdating), TRUE);
		ObjectBuf->alwaysShowHiddenFiles=boolBuf;
		//ObjectBuf->bUpdateFlag_F6=FALSE;
		//updating only the visible views is not enought, because we show a (h) in the tabs, when hidden flag is on
		SideObjectList_UpdateObject(ObjectBuf);
		ObjectBuf = SideObjectList_getNextObejct(ObjectBuf);
	}

	updateActiveViews();	//the tabs are updated within the while loop

	TRACEIT(10,"AlwaysShowHiddenfilesInAllTabs		end");
}


void ChangeReadOnlyState (GtkWidget *menuitem, gpointer data){
	TRACEIT(10,"ChangeReadOnlyState		start");

	struct SideObjectList *Object = (struct SideObjectList *)data;

    if (Object->PreviewCol == NULL){
        TRACEIT(10,"ChangeReadOnlyState		ends");
        return;
    }

    Object->bReadOnly = !(Object->bReadOnly);

    SideObjectList_UpdateObject(Object);

	TRACEIT(10,"ChangeReadOnlyState		end");
}


void ChangePreviewState(GtkWidget *menuitem, gpointer data){
    // data is a SideObject
    TRACEIT(10,"ChangePreviewState		start");
    struct SideObjectList *Object = (struct SideObjectList *)data;

    if (Object->PreviewCol == NULL){
        TRACEIT(10,"ChangePreviewState		ends");
        return;
    }

    if (0 == Object->iPreview){
        Object->iPreview = 1;
        gtk_tree_view_column_set_visible(Object->PreviewCol,TRUE);
    }
    else{
        Object->iPreview = 0;
        gtk_tree_view_column_set_visible(Object->PreviewCol,FALSE);
    }

    updateViewWithNewFolder(Object, NULL);

    TRACEIT(10,"ChangePreviewState		ends");
}


void showHiddenFilesInActivePage(GtkWidget *menuitem, gpointer data){
	TRACEIT(10,"showHiddenFilesInActivePage		start");
	struct SideObjectList *Object=NULL;
	SideObjectList_GetActiveObject((GtkNotebook *)data, &Object);
	if (Object == NULL){
		TRACEIT(10,"copyActivePage		ends");
		return;
	}
	calcDirectorySizeInView_closeProcess (&(Object->iRecursiveSizeCalculation), &(Object->gthreadF6Updage), &(Object->bUpdateFlag_F6), &(Object->iPreventFromUpdating), TRUE);

	Object->showHiddenFiles=!Object->showHiddenFiles;

	updateView(Object);
	TRACEIT(10,"showHiddenFilesInActivePage		ends");
}


void moveActivePage(GtkWidget *menuitem, gpointer data){
	TRACEIT(10,"moveActivePage		start");
	GtkNotebook *destNotebook = ( (GtkNotebook *)data == (GtkNotebook *)Notebooks[SIDE_LEFT])?(GtkNotebook *)Notebooks[SIDE_RIGHT]:(GtkNotebook *)Notebooks[SIDE_LEFT];
	SideObjectList_MoveActiveObject((GtkNotebook *)data, destNotebook);
	TRACEIT(10,"moveActivePage		ends");
}


void copyActivePage(GtkWidget *menuitem, gpointer data){
	TRACEIT(10,"copyActivePage		start");
	GtkNotebook *destNotebook = ( (GtkNotebook *)data == (GtkNotebook *)Notebooks[SIDE_LEFT])?(GtkNotebook *)Notebooks[SIDE_RIGHT]:(GtkNotebook *)Notebooks[SIDE_LEFT];
	struct SideObjectList *Object=NULL;
	SideObjectList_GetActiveObject((GtkNotebook *)data, &Object);
	if (Object == NULL){
		TRACEIT(10,"copyActivePage		ends");
		return;
	}
	SideObjectList_CreateNewViewWithPath(destNotebook, Object->gstrPath->str,Object);
	TRACEIT(10,"copyActivePage		ends");
}


void dublicateActivePage(GtkWidget *menuitem, gpointer data){
	TRACEIT(10,"dublicateActivePage		start");
	struct SideObjectList *Object=NULL;
	SideObjectList_GetActiveObject((GtkNotebook *)data, &Object);
	if (Object == NULL){
		TRACEIT(10,"dublicateActivePage		ends");
		return;
	}
	SideObjectList_CreateNewViewWithPath((GtkNotebook *)data, Object->gstrPath->str,Object);
	TRACEIT(10,"dublicateActivePage		ends");
}


void addNewPage(GtkWidget *menuitem, gpointer data){
	TRACEIT(10,"addNewPage		start");
	GString *gstrDirectory = g_string_sized_new(10);
	GString *gstrDirectoryName = g_string_sized_new(10);
	getStandardStartDirectory(gstrDirectory);//, gstrDirectoryName);
	SideObjectList_CreateNewViewWithPath((GtkNotebook *)data, gstrDirectory->str, NULL);
	g_string_free(gstrDirectory, TRUE);
	g_string_free(gstrDirectoryName, TRUE);
	TRACEIT(10,"addNewPage		ends");
}


void closeActivePage(GtkWidget *menuitem, gpointer data){
	TRACEIT(10,"closeActivePage		start");
	SideObjectList_DeleteActiveObject((GtkNotebook *)data);
	TRACEIT(10,"closeActivePage		ends");
}