/* Copyright (C) 1999 Southern Gold Development <bruces@mail.petech.ac.za>
 *
 * This program 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 2 of the License, or
 * (at your option) any later version.
 *
 * This program 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 this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 */

#define USE_DND
#include "gview.h"
#include "xpm.h"
#include <gdk/gdkx.h>

/* No changes to code, only to format to look like mine does 
 * The readXVThumb function source may be re-used under
 * the XFree86-style license. <adam@gimp.org>
 */
   
guchar* readXVThumb(const gchar *fnam, gint* w, gint* h, gchar** imginfo) {
	FILE *fp;
	const gchar *P7_332 = "P7 332";
	gchar P7_buf[7];
	gchar linebuf[200];
	guchar *buf;
	gint twofivefive;
	void *ptr;

	*w = *h = 0;
	*imginfo = NULL;
	fp = fopen (fnam, "rb");
	if (!fp)
		return (NULL);
	fread (P7_buf, 6, 1, fp);
	if (strncmp(P7_buf, P7_332, 6)!=0) {
		g_warning("Thumbnail doesn't have the 'P7 332' header.");
		fclose(fp);
		return(NULL);
	}
	fread (P7_buf, 1, 1, fp);
	do {
		ptr = fgets(linebuf, 199, fp);
		if ((strncmp(linebuf, "#IMGINFO:", 9) == 0) && (linebuf[9] != '\0') && (linebuf[9] != '\n')) {
			if (linebuf[strlen(linebuf)-1] == '\n')
				linebuf[strlen(linebuf)-1] = '\0';

			if (linebuf[9] != '\0') {
				if (*imginfo)
					g_free(*imginfo);
					*imginfo = g_strdup (&linebuf[9]);
			}
		}
	} while (ptr && linebuf[0]=='#'); /* keep throwing away comment lines */
	if (!ptr) {
		fclose(fp);
		return(NULL);
	}
	sscanf(linebuf, "%d %d %d\n", w, h, &twofivefive);
	if (twofivefive!=255) {
		g_warning("Thumbnail is of funky depth.");
		fclose(fp);
		return(NULL);
	}
	if ((*w)<1 || (*h)<1 || (*w)>80 || (*h)>60) {
		g_warning ("Thumbnail size bad.  Corrupted?");
		fclose(fp);
		return (NULL);
	}
	buf = g_malloc((*w)*(*h));
	fread(buf, (*w)*(*h), 1, fp);
	fclose(fp);
	return(buf);
}

#ifdef USE_GEN_PREVIEW
void genThumb(sgview *view, gchar *fName) {
	GdkImlibImage *img;
	gint newX, newY;
	gfloat divX, divY, workX, workY;

	img = gdk_imlib_load_image(fName);
	if (!(img)) 
		return;
	
	workX=img->rgb_width;
	workY=img->rgb_height;
	divY = workY / 60.0;
	newX = (gint) (workX / divY);
	if (newX > 80) {
		divX = workX / 80.0;
		newY = (gint) (workY / divX);
		newX = 80;
	}
	else {
		newY = 60;
	}
	gdk_imlib_render(img, newX, newY);
	gtk_widget_hide(GTK_WIDGET (view->preview));
	gtk_widget_show(GTK_WIDGET (view->imgPrev));
	gtk_drawing_area_size(GTK_DRAWING_AREA (view->imgPrev), newX, newY);
	gtk_widget_set_usize(GTK_WIDGET (view->imgPrev), newX, newY);
	gtk_fixed_move(GTK_FIXED (view->browFix), view->imgPrev, 225 + ((160 - newX) / 2), 15 + ((60 - newY) / 2));
	gdk_window_shape_combine_mask(view->imgPrev->window, NULL, 0, 0);
	while (gtk_events_pending()) {
		gtk_main_iteration();
	}
	gdk_imlib_apply_image(img, view->imgPrev->window);
	gdk_imlib_kill_image(img);
}
#endif /* USE_GEN_PREVIEW */

void chDirUp(sgview *view) {
	gchar *wdir;
	int cnt;

	wdir = view->currPath;
	if (strlen(wdir) == 1) 
		return;
	cnt = strlen(wdir);
	wdir[cnt - 1] = '\0';
	cnt--;
	while ((cnt > 0) && (wdir[cnt] != '/')) {
		wdir[cnt] = '\0';
		cnt--;
	}
	view->currPath = g_strdup(wdir);
	g_free(wdir);
	gloaddir(view);
}

void cdUp(GtkWidget *widget, gpointer data) {
	chDirUp((sgview *) data);
}

void handleFile(sgview *view, gchar *file) {
	gchar *wdir;

	if (!(file)) 
		return;
	if (strcmp(file, _(".. (parent)")) == 0) {
		chDirUp(view);
		return;
	}
	if (file[strlen(file) - 1] == '/') {
		wdir = g_strconcat(view->currPath, file, NULL);
		g_free(view->currPath);
		view->currPath = wdir;
		gloaddir(view);
		return;
	}
	if (file[0] == '/') {
		loadPic(view, file);
		return;
	}
	wdir = g_strconcat(view->currPath, file, NULL);
	loadPic(view, wdir);
	g_free(wdir);
}

void navEnter(sgview *view) {
	gchar *inName, *wdir;
	struct stat buff;
	gint err;

	inName = gtk_entry_get_text(GTK_ENTRY (view->dirlabel));
	wdir = g_strdup(inName);

#ifdef HAVE_NET
	if ((strncmp(inName, "http://", 7) == 0) || (strncmp(inName, "ftp://", 6) == 0)) {
		netload(view, wdir);
		g_free(wdir);
		return;
	}
#endif /* HAVE_NET */
	
	err = stat(wdir, &buff);
	if (err == -1) 
		return;
	if (buff.st_mode & S_IFREG) {
		view->statCh = (view->statCh & 0xfd);
		loadPic(view, wdir);
		view->statCh = (view->statCh | 0x02);
	}
	if (buff.st_mode & S_IFDIR) {
		g_free(view->currPath);
		view->currPath = g_strdup(wdir);
		gloaddir(view);
	}
	g_free(wdir);
}

#ifdef HAVE_WORKING_MSG
gint ipcIncoming(gpointer data) {
	nmsg ipc_msg;
	gint res, errIn, cnt, row;
	gchar *spath, *iName, *work, *tmpN, *tmpF;
	sgview *view;
	struct stat buff;
	
	view = (sgview *) data;
	gtk_timeout_remove(view->msgTimer); 
	if (view->dqueue != -1) {
		res = msgrcv(view->dqueue, (struct msgbuf *) &ipc_msg, MAX_BUFF, 4351, IPC_NOWAIT);
		if (res != -1) {
			work = g_strdup(ipc_msg.mtext);
			errIn = stat(work, &buff);
			if (errIn != -1) {
				if (buff.st_mode & S_IFDIR) {
					if (view->main) {
						if (work[strlen(work) - 1] == '/')
							spath = g_strdup(work);
						else 
							spath = g_strconcat(work, "/", NULL);
						g_free(view->currPath);
						view->currPath = spath;
						gloaddir(view);
					}
				}
				else {
					tmpN = g_strdup(work);
					tmpF = rindex(tmpN, '/');
					tmpF[0] = '\0';
					tmpF++;
					iName = g_strdup(tmpF);
					spath = g_strconcat(tmpN, "/", NULL);
					g_free (tmpN);
					g_free(view->currPath);
					view->currPath = spath;
					if (view->main) {
						gloaddir(view);
						row = 0;
						for (cnt = 0; cnt < GTK_CLIST (view->clist)->rows; cnt++) {
							gtk_clist_get_text(GTK_CLIST (view->clist), cnt, 0, &tmpN);
							if (strcmp(tmpN, iName) == 0)
								row = cnt;
						}
						gtk_clist_unselect_row(GTK_CLIST (view->clist), 0, 0);
						GTK_CLIST (view->clist)->focus_row = row;
						gtk_clist_select_row(GTK_CLIST (view->clist), row, 0);
						gtk_clist_moveto(GTK_CLIST (view->clist), row, 0, 0.5, 0.5);
					}
					handleFile(view, iName);
					g_free(iName);
				}
			}
			g_free(work);
		}
	}
	view->msgTimer = gtk_timeout_add(500, (GtkFunction) ipcIncoming, (gpointer) view);
	return 0;
}
#endif /* HAVE_WORKING_MSG */

void viewPic(GtkWidget *widget, gpointer data) {
	sgview *view;
	gchar *file;

	view = (sgview *) data;
	if (GTK_CLIST (view->clist)->focus_row == -1) 
		return;
	gtk_clist_get_text(GTK_CLIST (view->clist), GTK_CLIST(view->clist)->focus_row, 0, &file);
	handleFile(view, file);	
}

void quit(GtkWidget *widget, gpointer data) {
	sgview *view;

	view = (sgview *) data;
	gtk_widget_destroy(view->main);
}

void killwin(GtkWidget *widget, gpointer data) {
	sgview *view;

	view = (sgview *) data;
#ifdef HAVE_WORKING_MSG
	if (view->dqueue != -1) 
		msgctl(view->dqueue, IPC_RMID, NULL);
#endif /* HAVE_WORKING_MSG */
	g_free(view);
	gtk_main_quit();
}

void menuOpen(GtkWidget *widget, gpointer data) {
	sgview *view;
	gchar *file;

	view = (sgview *) data;
	if (GTK_CLIST (view->clist)->focus_row == -1)
		return;
	gtk_clist_get_text(GTK_CLIST (view->clist), GTK_CLIST(view->clist)->focus_row, 0, &file);

	handleFile(view, file);	
}

void menuInfo(GtkWidget *widget, gpointer data) {
	sgview *view;
	gchar *file, *fName;

	view = (sgview *) data;
	if (GTK_CLIST (view->clist)->focus_row == -1)
		return;
	gtk_clist_get_text(GTK_CLIST (view->clist), GTK_CLIST(view->clist)->focus_row, 0, &file);
	if ((strcmp(file, _(".. (parent)")) == 0) || (file[strlen(file) - 1] == '/')) {
		return;
	}
	fName = g_strconcat(view->currPath, file, NULL);
	loadInfo(view, fName);
	g_free(fName);
}

void menuSet(GtkWidget *widget, gpointer data) {
	sgview *view;
	gchar *file, *lfile;
	GdkImlibImage *newImage;

	view = (sgview *) data;
	if (GTK_CLIST (view->clist)->focus_row == -1)
		return;
	gtk_clist_get_text(GTK_CLIST (view->clist), GTK_CLIST(view->clist)->focus_row, 0, &file);
	if (index(file, '/') != NULL)
		return;
	if (strcmp(file, _(".. (parent)")) == 0) 
		return;
	lfile = g_strconcat(view->currPath, file, NULL);
	newImage = gdk_imlib_load_image(lfile);
	g_free(lfile);
	view->backPic = newImage;
	setBack(widget, (gpointer) data);
}

void menuRefresh(GtkWidget *widget, gpointer data) {
	gloaddir((sgview *) data);
}

void menuHome(GtkWidget *widget, gpointer data) {
	sgview *view;
	
	view = (sgview *) data;
	g_free(view->currPath);
	view->currPath = g_strconcat(getenv("HOME"), "/", NULL);
	gloaddir(view);
}

void menuComment(GtkWidget *widget, gpointer data) {
	sgview *view;
	gchar *file;

	view = (sgview *) data;
	if (GTK_CLIST (view->clist)->focus_row == -1)
		return;
	gtk_clist_get_text(GTK_CLIST (view->clist), GTK_CLIST(view->clist)->focus_row, 0, &file);
	if (index(file, '/') != NULL)
		return;
	if (strcmp(file, _(".. (parent)")) == 0) 
		return;
	setGVComment(view, file);
}

/* Here i've made changes to fit with the rest of gView's structs and so on
 * Apologies to all those who wrote this code
 */

void doImagePreview (GtkWidget *widget, gint row, gint col, GdkEvent *event, gpointer data) {
	sgview *view;
	guchar *thumb_rgb, *raw_thumb;
	gint tnw,tnh;
	gchar *tname, *fname, *imginfo, *imgName;

	view = (sgview *) data;
	gtk_clist_get_text(GTK_CLIST (view->clist), row, 0, &fname);
	gtk_widget_hide(GTK_WIDGET(view->preview));
	if (!(isImage(view, fname))) {
#ifdef USE_GEN_PREVIEW
		gtk_widget_hide(GTK_WIDGET(view->imgPrev));
#endif
		return;
	}
	if (isExtern(view, fname)) {
#ifdef USE_GEN_PREVIEW
		gtk_widget_hide(GTK_WIDGET(view->imgPrev));
#endif
		return;
	}
	imgName = g_strconcat(view->currPath, G_DIR_SEPARATOR_S, fname, NULL);
	tname = g_strconcat (view->currPath, G_DIR_SEPARATOR_S, ".xvpics", G_DIR_SEPARATOR_S, fname, NULL);
	raw_thumb = readXVThumb(tname, &tnw, &tnh, &imginfo);

	if (raw_thumb) {
		int i;
		gtk_widget_hide (GTK_WIDGET (view->preview));
#ifdef USE_GEN_PREVIEW
		gtk_widget_hide (GTK_WIDGET (view->imgPrev));
#endif
		thumb_rgb = g_malloc (3 * tnw * tnh);
		for (i=0; i<tnw*tnh; i++) {
			thumb_rgb[i*3  ] = ((raw_thumb[i]>>5)*255)/7;
			thumb_rgb[i*3+1] = (((raw_thumb[i]>>2)&7)*255)/7;
			thumb_rgb[i*3+2] = (((raw_thumb[i])&3)*255)/3;
		}
		gtk_preview_size (GTK_PREVIEW (view->preview), tnw, tnh);
		for (i=0; i<tnh; i++)
			gtk_preview_draw_row(GTK_PREVIEW (view->preview), &thumb_rgb[3*i*tnw], 0, i, tnw);
		gtk_widget_show (GTK_WIDGET (view->preview));
		gtk_widget_queue_draw (GTK_WIDGET (view->preview));
		g_free (thumb_rgb);
		g_free (raw_thumb);
	}
	else {
#ifdef USE_GEN_PREVIEW
		genThumb(view, imgName);
#endif
    }
	if (imginfo) {
		g_free(imginfo);
	}
	g_free (tname);
	g_free (imgName);
}

void popupMenu(sgview *view, GdkEventButton *event) {
	GtkWidget *menu, *submenu;

	menu = gtk_menu_new();
	submenu = gtk_menu_new();

	if (!view->bMenu) {
		gAddMenu(view, GTK_MENU (submenu), _("Add To Slideshow"), (GtkSignalFunc) enqueueSlide);
		gAddMenu(view, GTK_MENU (submenu), _("Start"), (GtkSignalFunc) startSlide);
		gAddMenu(view, GTK_MENU (submenu), _("Stop"), (GtkSignalFunc) stopSlide);
		gAddMenu(view, GTK_MENU (submenu), _("Pause"), (GtkSignalFunc) pauseSlide);
		gAddMenu(view, GTK_MENU (submenu), _("Resume"), (GtkSignalFunc) resumeSlide);
		gAddMenu(view, GTK_MENU (submenu), _("View Slide List"), (GtkSignalFunc) viewSlide);
		gAddMenu(view, GTK_MENU (submenu), _("Clear Slideshow"), (GtkSignalFunc) clearSlide);
		gAddMenu(view, GTK_MENU (menu), _("Open"), (GtkSignalFunc) menuOpen);
#ifdef HAVE_NET
		gAddMenu(view, GTK_MENU (menu), _("Open URL"), (GtkSignalFunc) menuOpenURL);
#endif /* HAVE_NET */
		gAddSubMenu(view, GTK_MENU (menu), submenu, _("SlideShow"));
		gAddMenu(view, GTK_MENU (menu), _("Set As Wallpaper..."), (GtkSignalFunc) menuSet);
		gAddMenu(view, GTK_MENU (menu), _("Info"), (GtkSignalFunc) menuInfo);
		gAddMenu(view, GTK_MENU (menu), _("Edit Comment"), (GtkSignalFunc) menuComment);
		gAddMenu(view, GTK_MENU (menu), _("Refresh"), (GtkSignalFunc) menuRefresh);
		gAddMenu(view, GTK_MENU (menu), _("Delete"), (GtkSignalFunc) menuDelete);
		gAddMenu(view, GTK_MENU (menu), _("Rename"), (GtkSignalFunc) menuRename);
		gAddMenu(view, GTK_MENU (menu), _("Home"), (GtkSignalFunc) menuHome);
		gAddMenu(view, GTK_MENU (menu), _("Configure"), (GtkSignalFunc) configWin);
		view->bMenu = menu;
	}
	gtk_menu_popup(GTK_MENU (view->bMenu), NULL, NULL, NULL, NULL, event->button, event->time);
}

void toolPrev(GtkWidget *widget, gpointer data) {
	navImage((sgview *) data, FALSE);
}

void toolNext(GtkWidget *widget, gpointer data) {
	navImage((sgview *) data, TRUE);
}

gint mouseClick(GtkWidget *widget, GdkEventButton *event, gpointer data) {
	sgview *view;

	view = (sgview *) data;
	if (GTK_CLIST (view->clist)->focus_row == -1)
		return FALSE;
	switch (event->button) {
		case 1:
#ifndef ALT_UI
			if (event->type == GDK_2BUTTON_PRESS) {
				menuOpen(widget, data);
			}
#else
			if (event->type == GDK_BUTTON_PRESS) {
				if (GTK_CLIST (view->clist)->focus_row == view->currFocus) 
					menuOpen(widget, data);
				else
					view->currFocus = GTK_CLIST (view->clist)->focus_row;
			}
#endif /* ALT_UI */
			break;
		default:
			if (event->type == GDK_BUTTON_PRESS) 
				popupMenu(view, event);
			break;
	} 
	return FALSE;
}

gint keyClick(GtkWidget *widget, GdkEventKey *event, gpointer data) {
	sgview *view;

	view = (sgview *) data;
	if (GTK_CLIST (view->clist)->focus_row == -1)
		return FALSE;

	switch (event->keyval) {
		case GDK_Return:
		case GDK_KP_Enter:
			menuOpen(widget, data);	
			break;
		case GDK_Delete:
		case GDK_KP_Delete:
			menuDelete(widget, data);
			break;
		case GDK_F5:
			gloaddir(view);
			break;
		case GDK_BackSpace:
		case GDK_A ... GDK_Z:
		case GDK_a ... GDK_z:
		case GDK_0 ... GDK_9:
			if (((event->keyval == GDK_X) || (event->keyval == GDK_x)) && (event->state & GDK_CONTROL_MASK)) {
				gtk_widget_destroy(view->main);
				break;
			}
			if (((event->keyval == GDK_H) || (event->keyval == GDK_h)) && (event->state & GDK_CONTROL_MASK)) {
				menuHome(widget, data);
				break;
			}
			doMatchFile(view, event->keyval);
			break;
		default:
			break;
	}
	return FALSE;
}

gint navKeyPress(GtkWidget *widget, GdkEventKey *event, gpointer data) {
	sgview *view;

	view = (sgview *) data;
	switch(event->keyval) {
		case GDK_Return:
		case GDK_KP_Enter:
			navEnter(view);
			break;
		default:
			break;

	}
	return FALSE;
}

void gset_drag_icon(GtkWidget *win) {
	GdkColormap *map;
	GdkPixmap *pix;
	GdkBitmap *mask;
	GtkStyle *style;

	map = gtk_widget_get_default_colormap();
	style = gtk_widget_get_default_style();
	pix = gdk_pixmap_create_from_xpm_d(win->window, &mask, &style->bg[GTK_STATE_NORMAL], map_xpm);
	gtk_drag_set_default_icon(map, pix, mask, 15, 15);
}

void createWin(sgview *view) {
	GtkWidget *win, *hbox, *vbox, *clist, *scr, *lbl, *fra, *tool, *pix;
	GtkStyle *style;
	GdkPixmap *pixm;
	GdkBitmap *mask;
	gchar *titles[] = {_("File"), _("Time Stamp"), _("Size"), _("Type")};

	win = gtk_window_new(GTK_WINDOW_TOPLEVEL);
	view->main = win;
	gtk_window_set_title(GTK_WINDOW (win), _("gView image viewer"));
	gtk_window_set_policy(GTK_WINDOW (win), TRUE, TRUE, TRUE);
	gtk_window_position(GTK_WINDOW (win), GTK_WIN_POS_NONE);
	gtk_signal_connect(GTK_OBJECT (win), "destroy", (GtkSignalFunc) killwin, (gpointer) view );	
	gtk_widget_set_usize(GTK_WIDGET (win), 400, 480);
	gtk_container_border_width(GTK_CONTAINER (win), 5);
	gtk_widget_realize(win);

	vbox = gtk_vbox_new(FALSE, 5);
	gtk_container_add(GTK_CONTAINER (win), vbox);

	tool = gtk_toolbar_new(GTK_ORIENTATION_HORIZONTAL, GTK_TOOLBAR_ICONS);
	gtk_box_pack_start(GTK_BOX (vbox), tool, FALSE, FALSE, 0);

	gAddToolbar(view, GTK_TOOLBAR (tool), open_xpm, _("Open"), _("Open Image"), (GtkSignalFunc) menuOpen);
	gAddToolbar(view, GTK_TOOLBAR (tool), prev_xpm, _("Previous"), _("Open Previous Image"), (GtkSignalFunc) toolPrev);
	gAddToolbar(view, GTK_TOOLBAR (tool), next_xpm, _("Next"), _("Open Next Image"), (GtkSignalFunc) toolNext);
	gAddToolbar(view, GTK_TOOLBAR (tool), addslide_xpm, _("Add"), _("Add To Slideshow"), (GtkSignalFunc) enqueueSlide);
	gAddToolbar(view, GTK_TOOLBAR (tool), slide_xpm, _("Slideshow"), _("Play Slideshow"), (GtkSignalFunc) startSlide);

	gtk_toolbar_append_space(GTK_TOOLBAR (tool));

	lbl = gtk_entry_new();
	view->dirlabel = lbl;
	gtk_entry_set_editable(GTK_ENTRY (lbl), TRUE);
	gtk_widget_set_usize(GTK_WIDGET (lbl), 200, 24);
	gtk_toolbar_append_widget(GTK_TOOLBAR (tool), lbl, _("Current Directory"), NULL);
	gtk_signal_connect(GTK_OBJECT (lbl), "key_press_event", (GtkSignalFunc) navKeyPress, (gpointer) view);
	gtk_widget_show(lbl);
	gtk_widget_show(tool);

	gtk_toolbar_append_space(GTK_TOOLBAR (tool));

	gAddToolbar(view, GTK_TOOLBAR (tool), up1levl_xpm, _("Parent.."), _("Change To Parent Directory"), (GtkSignalFunc) cdUp);
#ifdef HAVE_NET
	gAddToolbar(view, GTK_TOOLBAR (tool), net_xpm, _("Internet"), _("Load File Off Web Server"), (GtkSignalFunc) menuOpenURL);
#endif /* HAVE_NET */
	gAddToolbar(view, GTK_TOOLBAR (tool), exit_xpm, _("Exit"), _("Exit gView"), (GtkSignalFunc) killwin);

	scr = gtk_scrolled_window_new(NULL, NULL);
	view->mscr = scr;
	gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW (scr), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
	gtk_widget_set_usize(GTK_WIDGET (scr), 380, 360);
	gtk_box_pack_start(GTK_BOX (vbox), scr, FALSE, FALSE, 0);

	clist = gtk_clist_new_with_titles(4, titles);
	view->clist = clist;
	gtk_drag_source_set(clist, GDK_BUTTON1_MASK, target_table, 4, GDK_ACTION_COPY | GDK_ACTION_MOVE);
	gset_drag_icon(win);
	gtk_clist_set_column_width(GTK_CLIST (clist), 0, 120);
	gtk_clist_set_column_width(GTK_CLIST (clist), 1, 120);
	gtk_clist_set_column_width(GTK_CLIST (clist), 2, 60);
	gtk_clist_set_column_width(GTK_CLIST (clist), 3, 10);
	gtk_clist_set_column_justification(GTK_CLIST (clist), 0, GTK_JUSTIFY_LEFT);
	gtk_clist_set_column_justification(GTK_CLIST (clist), 1, GTK_JUSTIFY_LEFT);
	gtk_clist_set_column_justification(GTK_CLIST (clist), 2, GTK_JUSTIFY_RIGHT);
	gtk_clist_column_titles_passive(GTK_CLIST (clist));
	gtk_clist_set_column_justification(GTK_CLIST (clist), 3, GTK_JUSTIFY_LEFT);
	gtk_clist_set_auto_sort(GTK_CLIST (clist), FALSE);
	gtk_clist_set_selection_mode(GTK_CLIST (clist), GTK_SELECTION_EXTENDED);
	gtk_container_add(GTK_CONTAINER (scr), clist);
	view->sigBMouse = gtk_signal_connect_after(GTK_OBJECT (clist), "button_press_event", (GtkSignalFunc) mouseClick, (gpointer) view);
	view->sigBKey = gtk_signal_connect(GTK_OBJECT (clist), "key_press_event", (GtkSignalFunc) keyClick, (gpointer) view);
	gtk_signal_connect(GTK_OBJECT (clist), "select_row", (GtkSignalFunc) doImagePreview, (gpointer) view);
	gtk_signal_connect(GTK_OBJECT (clist), "drag_data_get", (GtkSignalFunc) startDragFile, (gpointer) view);
	gtk_widget_show(clist);
	gtk_widget_show(scr);
	GTK_WINDOW (win)->focus_widget = clist;
	
	hbox = gtk_fixed_new();
	view->browFix = hbox;
	gtk_widget_set_usize(GTK_WIDGET (hbox), 390, 80);
	gtk_box_pack_start(GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
	
	fra = gtk_frame_new(_("Controls"));
	gtk_widget_set_usize(GTK_WIDGET (fra), 210, 80);
	gtk_fixed_put(GTK_FIXED (hbox), fra, 0, 0);
	gtk_widget_show(fra);

	fra = gtk_frame_new(_("Preview"));
	gtk_widget_set_usize(GTK_WIDGET (fra), 170, 80);
	gtk_fixed_put(GTK_FIXED (hbox), fra, 220, 0);
	gtk_widget_show(fra);
	
	gAddButtonFix(view, (gpointer) view, GTK_FIXED (hbox), _("Open"), _("Open the file"), (GtkSignalFunc) viewPic, 90, 25, 10, 15);
	view->slideBtn = gAddButtonFix(view, (gpointer) view, GTK_FIXED (hbox), _("SlideShow"), _("Start the slideshow"), (GtkSignalFunc) NULL, 90, 25, 110, 15);
    view->sigSlide = gtk_signal_connect(GTK_OBJECT (view->slideBtn), "clicked", (GtkSignalFunc) startSlide, (gpointer) view);
	gAddButtonFix(view, (gpointer) view, GTK_FIXED (hbox), _("Configure"), _("Configure gView"), (GtkSignalFunc) configWin, 90, 25, 10, 45);
	gAddButtonFix(view, (gpointer) view, GTK_FIXED (hbox), _("Quit"), _("Quit gView"), (GtkSignalFunc) quit, 90, 25, 110, 45);
	
	pix = gtk_preview_new(GTK_PREVIEW_COLOR);
	view->preview = pix;
	gtk_widget_set_usize(GTK_WIDGET (pix), 160, 60);
	gtk_fixed_put(GTK_FIXED (hbox), pix, 225, 15);
	gtk_widget_show(pix);
	
	pix = gtk_drawing_area_new();
	view->imgPrev = pix;
	gtk_widget_set_usize(GTK_WIDGET (pix), 160, 60);
	gtk_fixed_put(GTK_FIXED (hbox), pix, 225, 15);
	gtk_widget_show(pix);

	gtk_widget_show(hbox);

	gtk_widget_show(vbox);

	style = gtk_widget_get_default_style();
	pixm = gdk_pixmap_create_from_xpm_d(GDK_ROOT_PARENT(), &mask, &style->bg[GTK_STATE_NORMAL], gview_xpm);
	gdk_window_set_icon(win->window, NULL, pixm, mask);
	g_free(pixm);
	g_free(mask);

	gtk_widget_show(win);
}