From: Kern Sibbald Date: Thu, 19 Jun 2003 15:57:01 +0000 (+0000) Subject: Add Gnome 2.0 files X-Git-Tag: Release-1.31~61 X-Git-Url: https://git.sur5r.net/?a=commitdiff_plain;h=698742e6405e1b60b186903f33af1df8f59a4564;p=bacula%2Fbacula Add Gnome 2.0 files git-svn-id: https://bacula.svn.sourceforge.net/svnroot/bacula/trunk@595 91ce42f0-d328-0410-95d8-f526ca767f89 --- diff --git a/bacula/src/console2.glade b/bacula/src/console2.glade new file mode 100644 index 0000000000..a16540fcb9 --- /dev/null +++ b/bacula/src/console2.glade @@ -0,0 +1,3059 @@ + + + + + + + True + Bacula Console + GTK_WINDOW_TOPLEVEL + GTK_WIN_POS_NONE + False + True + False + + + + + True + False + 0 + + + + 1 + True + GTK_SHADOW_OUT + GTK_POS_LEFT + GTK_POS_TOP + + + + True + + + + True + _File + True + + + + True + + + + True + Connect to Director + _Connect + True + + + + + + + True + Disconnect from Director + _Disconnect + True + + + + + + + True + + + + + + True + gtk-quit + True + + + + + + + + + + + True + _Edit + True + + + + True + + + + True + gtk-cut + True + + + + + + + True + gtk-copy + True + + + + + + + True + gtk-paste + True + + + + + + + True + gtk-clear + True + + + + + + + True + + + + + + + + + + True + Display Messages + _View + True + + + + True + + + + True + _Display Messages + True + + + + + + + + + + + True + _Settings + True + + + + True + + + + True + gtk-preferences + True + + + + + + + + + + + True + _Help + True + + + + True + + + + True + gnome-stock-about + True + + + + + + + + + + + + 0 + False + True + + + + + + 1 + True + GTK_SHADOW_OUT + GTK_POS_LEFT + GTK_POS_TOP + + + + 1 + True + GTK_ORIENTATION_HORIZONTAL + GTK_TOOLBAR_BOTH + True + + + + True + Connect to Director + Connect + True + gtk-new + + + + + + + True + Run a Job + Run + True + gtk-execute + + + + + + + True + Display Messages + Msgs + True + gtk-find + + + + + + + True + Restore + True + gtk-revert-to-saved + + + + + + + True + Label + True + gtk-save-as + + + + + + + + 0 + False + True + + + + + + True + False + 0 + + + + True + GTK_POLICY_NEVER + GTK_POLICY_AUTOMATIC + GTK_SHADOW_IN + GTK_CORNER_TOP_LEFT + + + + True + False + GTK_JUSTIFY_LEFT + GTK_WRAP_WORD + True + 0 + 0 + 0 + 0 + 0 + 0 + + + + + + 0 + True + True + + + + + + True + False + 0 + + + + True + Command: + False + False + GTK_JUSTIFY_CENTER + False + False + 0.5 + 0.5 + 0 + 0 + + + 0 + False + True + + + + + + True + Enter Commands Here + True + True + True + True + True + True + 0 + + True + * + False + + + + + 0 + True + True + + + + + 0 + False + True + + + + + + True + False + 0 + + + + True + 0 + 0.5 + GTK_SHADOW_ETCHED_IN + + + + True + Status: + False + False + GTK_JUSTIFY_CENTER + False + False + 0.5 + 0.5 + 0 + 0 + + + + + 0 + False + True + + + + + + True + 0 + 0.5 + GTK_SHADOW_ETCHED_IN + + + + True + + False + False + GTK_JUSTIFY_LEFT + False + False + 0 + 0.5 + 0 + 0 + + + + + 0 + True + True + + + + + 0 + False + False + + + + + 0 + True + True + + + + + + + + True + About Bacula Console + GTK_WINDOW_TOPLEVEL + GTK_WIN_POS_NONE + True + True + False + True + + + + True + False + 0 + + + + True + GTK_BUTTONBOX_END + + + + True + False + 0 + + + + True + + False + False + GTK_JUSTIFY_CENTER + False + False + 0.5 + 0.5 + 0 + 0 + + + 0 + True + False + + + + + + 1 + True + True + True + gtk-ok + True + GTK_RELIEF_NORMAL + + + + 0 + False + False + + + + + + + 0 + False + True + GTK_PACK_END + + + + + + True + False + 0 + + + + True + False + 0 + + + + True + Bacula Console 1.19 (28 April 2002) + + False + False + GTK_JUSTIFY_CENTER + False + False + 0.5 + 0.5 + 0 + 0 + + + 0 + False + False + + + + + + True + + + 0 + False + False + + + + + + True + Copyright (c) 1999 - 2002, Kern Sibbald and John Walker + False + False + GTK_JUSTIFY_LEFT + False + False + 0.1 + 0.5 + 0 + 0 + + + 0 + True + False + + + + + + True + Authors: Kern Sibbald and John Walker + False + False + GTK_JUSTIFY_LEFT + False + False + 0.0400001 + 0.5 + 0 + 0 + + + 0 + True + False + + + + + + True + It comes by night and sucks the essence from your computers + False + False + GTK_JUSTIFY_LEFT + False + False + 0.15 + 0.5 + 0 + 0 + + + 0 + True + False + + + + + 0 + True + True + + + + + 0 + True + True + + + + + + + + True + Select Director + GTK_WINDOW_TOPLEVEL + GTK_WIN_POS_NONE + True + True + False + True + + + + True + False + 0 + + + + True + GTK_BUTTONBOX_END + + + + True + False + 0 + + + + True + True + gtk-ok + True + GTK_RELIEF_NORMAL + + + + 0 + False + False + + + + + + True + + False + False + GTK_JUSTIFY_CENTER + False + False + 0.5 + 0.5 + 2 + 0 + + + 0 + False + False + + + + + + True + True + gtk-cancel + True + GTK_RELIEF_NORMAL + + + + 0 + False + False + + + + + + + 0 + False + True + GTK_PACK_END + + + + + + True + False + 0 + + + + True + + False + False + GTK_JUSTIFY_CENTER + False + False + 0.48 + 0.46 + 0 + 0 + + + 0 + False + False + + + + + + True + Select Director + False + False + GTK_JUSTIFY_CENTER + False + False + 0.5 + 0.5 + 0 + 0 + + + 0 + False + False + + + + + + 6 + True + False + True + False + True + False + + + + True + True + True + True + 0 + + True + * + False + + + + + + True + GTK_SELECTION_BROWSE + + + + True + + + + True + + False + False + GTK_JUSTIFY_LEFT + False + False + 0 + 0.5 + 0 + 0 + + + + + + + + + 0 + False + False + + + + + 0 + True + True + + + + + + + + True + Run a Job + GTK_WINDOW_TOPLEVEL + GTK_WIN_POS_NONE + False + True + False + True + + + + True + False + 0 + + + + True + GTK_BUTTONBOX_END + + + + True + GTK_BUTTONBOX_END + 8 + + + + True + True + True + gtk-ok + True + GTK_RELIEF_NORMAL + + + + + + + True + True + True + gtk-cancel + True + GTK_RELIEF_NORMAL + + + + + + + + 0 + False + True + GTK_PACK_END + + + + + + True + False + 0 + + + + True + False + 0 + + + + True + Run a Job + False + False + GTK_JUSTIFY_CENTER + False + False + 0.5 + 0.5 + 0 + 9 + + + 2 + False + False + + + + + + True + False + 0 + + + + True + False + 0 + + + + True + Job: + False + False + GTK_JUSTIFY_RIGHT + False + False + 0.5 + 0.5 + 0 + 0 + + + 0 + False + False + + + + + + True + True + False + False + True + False + + + + True + True + False + True + 0 + + True + * + False + + + + + + + True + GTK_SELECTION_BROWSE + + + + True + + + + True + + False + False + GTK_JUSTIFY_LEFT + False + False + 0 + 0.5 + 0 + 0 + + + + + + + + + 1 + True + True + + + + + + True + Type: + False + False + GTK_JUSTIFY_CENTER + False + False + 0.5 + 0.5 + 0 + 0 + + + 0 + False + False + + + + + + True + True + False + False + True + False + + + + True + True + False + True + 0 + + True + * + False + + + + + + True + GTK_SELECTION_BROWSE + + + + True + + + + True + + False + False + GTK_JUSTIFY_LEFT + False + False + 0 + 0.5 + 0 + 0 + + + + + + + + + 6 + False + False + + + + + 0 + True + True + + + + + + True + + False + False + GTK_JUSTIFY_CENTER + False + False + 0.5 + 0.5 + 0 + 0 + + + 30 + False + False + + + + + 2 + False + False + + + + + + True + False + 0 + + + + True + Client: + False + False + GTK_JUSTIFY_RIGHT + False + False + 0.5 + 0.5 + 0 + 0 + + + 0 + False + False + + + + + + True + True + False + False + True + False + + + + True + True + False + True + 0 + + True + * + False + + + + + + True + GTK_SELECTION_BROWSE + + + + True + + + + True + + False + False + GTK_JUSTIFY_LEFT + False + False + 0 + 0.5 + 0 + 0 + + + + + + + + + 1 + True + True + + + + + + True + + False + False + GTK_JUSTIFY_CENTER + False + False + 0.5 + 0.5 + 0 + 0 + + + 123 + False + False + + + + + 0 + True + True + + + + + + True + False + 0 + + + + True + FileSet: + False + False + GTK_JUSTIFY_RIGHT + False + False + 0.5 + 0.5 + 0 + 0 + + + 0 + False + False + + + + + + True + True + False + False + True + False + + + + True + True + False + True + 0 + + True + * + False + + + + + + True + GTK_SELECTION_BROWSE + + + + True + + + + True + + False + False + GTK_JUSTIFY_LEFT + False + False + 0 + 0.5 + 0 + 0 + + + + + + + + + 0 + True + True + + + + + + True + True + View FileSet + True + GTK_RELIEF_NORMAL + + + + 10 + False + True + + + + + + True + + False + False + GTK_JUSTIFY_CENTER + False + False + 0.5 + 0.5 + 0 + 0 + + + 65 + False + False + + + + + 2 + True + True + + + + + + True + False + 0 + + + + True + Level: + False + False + GTK_JUSTIFY_RIGHT + False + False + 0.5 + 0.5 + 0 + 0 + + + 0 + False + False + + + + + + True + True + False + False + True + False + + + + True + True + False + True + 0 + + True + * + False + + + + + + True + GTK_SELECTION_BROWSE + + + + True + + + + True + + False + False + GTK_JUSTIFY_LEFT + False + False + 0 + 0.5 + 0 + 0 + + + + + + + + True + + + + True + + False + False + GTK_JUSTIFY_LEFT + False + False + 0 + 0.5 + 0 + 0 + + + + + + + + + 0 + True + True + + + + + + True + + False + False + GTK_JUSTIFY_CENTER + False + False + 0.5 + 0.5 + 0 + 0 + + + 100 + False + False + + + + + 2 + True + True + + + + + + True + False + 0 + + + + True + Pool: + False + False + GTK_JUSTIFY_CENTER + False + False + 0.5 + 0.5 + 0 + 0 + + + 0 + False + False + + + + + + True + True + False + False + True + False + + + + True + True + False + True + 0 + + True + * + False + + + + + + True + GTK_SELECTION_BROWSE + + + + True + + + + True + + False + False + GTK_JUSTIFY_LEFT + False + False + 0 + 0.5 + 0 + 0 + + + + + + + + True + + + + True + + False + False + GTK_JUSTIFY_LEFT + False + False + 0 + 0.5 + 0 + 0 + + + + + + + + + 0 + True + True + + + + + + True + + False + False + GTK_JUSTIFY_CENTER + False + False + 0.5 + 0.5 + 0 + 0 + + + 120 + False + False + + + + + 2 + True + True + + + + + + True + False + 0 + + + + True + Storage: + False + False + GTK_JUSTIFY_CENTER + False + False + 0.5 + 0.5 + 0 + 0 + + + 0 + False + False + + + + + + True + True + False + False + True + False + + + + True + True + False + True + 0 + + True + * + False + + + + + + True + GTK_SELECTION_BROWSE + + + + True + + + + True + + False + False + GTK_JUSTIFY_LEFT + False + False + 0 + 0.5 + 0 + 0 + + + + + + + + True + + + + True + + False + False + GTK_JUSTIFY_LEFT + False + False + 0 + 0.5 + 0 + 0 + + + + + + + + + 0 + True + True + + + + + + True + + False + False + GTK_JUSTIFY_CENTER + False + False + 0.5 + 0.5 + 0 + 0 + + + 120 + False + False + + + + + 0 + True + True + + + + + + True + False + 0 + + + + True + Messages: + False + False + GTK_JUSTIFY_CENTER + False + False + 0.5 + 0.5 + 0 + 0 + + + 0 + False + False + + + + + + True + True + False + False + True + False + + + + True + True + False + True + 0 + + True + * + False + + + + + + True + GTK_SELECTION_BROWSE + + + + True + + + + True + + False + False + GTK_JUSTIFY_LEFT + False + False + 0 + 0.5 + 0 + 0 + + + + + + + + + 0 + True + True + + + + + + True + + False + False + GTK_JUSTIFY_CENTER + False + False + 0.5 + 0.5 + 0 + 0 + + + 120 + False + False + + + + + 0 + True + True + + + + + + True + False + 0 + + + + True + Where: + False + False + GTK_JUSTIFY_CENTER + False + False + 0.5 + 0.5 + 0 + 0 + + + 0 + False + False + + + + + + True + True + True + True + 0 + + True + * + False + + + 0 + True + True + + + + + + True + + False + False + GTK_JUSTIFY_CENTER + False + False + 0.5 + 0.5 + 0 + 0 + + + 120 + False + False + + + + + 2 + True + True + + + + + 0 + True + True + + + + + + True + False + 0 + + + + True + When: + False + False + GTK_JUSTIFY_CENTER + False + False + 0.5 + 0.5 + 0 + 0 + + + 0 + False + False + + + + + + True + True + True + True + 0 + + True + * + False + + + 0 + True + True + + + + + + True + + False + False + GTK_JUSTIFY_CENTER + False + False + 0.5 + 0.5 + 0 + 0 + + + 120 + False + False + + + + + 0 + True + True + + + + + + True + + False + False + GTK_JUSTIFY_CENTER + False + False + 0.5 + 0.5 + 0 + 0 + + + 0 + False + False + + + + + 0 + True + True + + + + + + + + True + Restore File Selection + GTK_WINDOW_TOPLEVEL + GTK_WIN_POS_NONE + True + True + False + + + + True + False + 0 + + + + True + GTK_POLICY_ALWAYS + GTK_POLICY_ALWAYS + GTK_SHADOW_IN + GTK_CORNER_TOP_LEFT + + + + True + True + True + False + False + True + + + + + 0 + True + True + + + + + + True + False + 0 + + + + True + cwd: + False + False + GTK_JUSTIFY_CENTER + False + False + 0.5 + 0.5 + 0 + 0 + + + 0 + False + True + + + + + + True + Enter Commands Here + True + True + True + True + True + True + 0 + + True + * + False + + + + + 0 + True + True + + + + + 0 + False + True + + + + + + True + False + 0 + + + + True + + False + False + GTK_JUSTIFY_FILL + False + False + 0.5 + 0.5 + 59 + 0 + + + 0 + True + False + + + + + + 9 + True + True + gtk-ok + True + GTK_RELIEF_NORMAL + + + + 0 + True + False + + + + + 0 + False + True + + + + + + + + True + Restore Files + GTK_WINDOW_TOPLEVEL + GTK_WIN_POS_NONE + True + True + False + True + + + + True + False + 0 + + + + True + GTK_BUTTONBOX_END + + + + True + GTK_BUTTONBOX_END + 8 + + + + True + True + True + gtk-ok + True + GTK_RELIEF_NORMAL + + + + + + + True + True + True + gtk-cancel + True + GTK_RELIEF_NORMAL + + + + + + + + 0 + False + True + GTK_PACK_END + + + + + + True + False + 0 + + + + 8 + True + 0 + 0.5 + GTK_SHADOW_ETCHED_IN + + + + True + False + 0 + + + + True + + False + False + GTK_JUSTIFY_CENTER + False + False + 0.5 + 0.5 + 0 + 0 + + + 0 + False + False + GTK_PACK_END + + + + + + True + False + 0 + + + + True + + False + False + GTK_JUSTIFY_CENTER + False + False + 0.5 + 0.5 + 0 + 2 + + + 0 + False + False + + + + + + 3 + True + True + Select most recent backup + True + GTK_RELIEF_NORMAL + True + False + True + + + 0 + False + False + + + + + + 5 + True + True + Select list of Jobs + True + GTK_RELIEF_NORMAL + False + False + True + + + 0 + False + False + + + + + + 4 + True + True + Find a specific file + True + GTK_RELIEF_NORMAL + False + False + True + + + 0 + False + False + + + + + + True + + False + False + GTK_JUSTIFY_CENTER + False + False + 0.5 + 0.5 + 0 + 0 + + + 0 + False + False + + + + + 0 + True + True + + + + + + + + True + Select by: + False + False + GTK_JUSTIFY_LEFT + False + False + 0.5 + 0.5 + 0 + 0 + + + label_item + + + + + 0 + True + True + + + + + + True + False + 0 + + + + + + + + 50 + True + True + gtk-apply + True + GTK_RELIEF_NORMAL + + + + 0 + False + False + + + + + + + + + 0 + False + False + + + + + 0 + True + True + + + + + + + + True + Label a Volume + GTK_WINDOW_TOPLEVEL + GTK_WIN_POS_NONE + True + True + False + True + + + + True + False + 0 + + + + True + GTK_BUTTONBOX_END + + + + True + GTK_BUTTONBOX_END + 8 + + + + True + True + True + gtk-ok + True + GTK_RELIEF_NORMAL + + + + + + + True + True + True + gtk-cancel + True + GTK_RELIEF_NORMAL + + + + + + + + 0 + False + True + GTK_PACK_END + + + + + + True + False + 0 + + + + True + Label a Volume + False + False + GTK_JUSTIFY_CENTER + False + False + 0.5 + 0.5 + 0 + 9 + + + 0 + False + False + + + + + + 5 + True + False + 0 + + + + True + Storage: + False + False + GTK_JUSTIFY_CENTER + False + False + 0.15 + 0.5 + 0 + 0 + + + 0 + True + True + + + + + + True + True + False + False + True + False + + + + True + True + False + True + 0 + + True + * + False + + + + + + True + GTK_SELECTION_BROWSE + + + + True + + + + True + + False + False + GTK_JUSTIFY_LEFT + False + False + 0 + 0.5 + 0 + 0 + + + + + + + + True + + + + True + + False + False + GTK_JUSTIFY_LEFT + False + False + 0 + 0.5 + 0 + 0 + + + + + + + + + 15 + True + True + + + + + + + + + 0 + False + True + + + + + + 5 + True + False + 0 + + + + True + Pool: + False + False + GTK_JUSTIFY_LEFT + False + False + 0.12 + 0.5 + 0 + 0 + + + 0 + True + True + + + + + + True + True + False + False + True + False + + + + True + True + False + True + 0 + + True + * + False + + + + + + True + GTK_SELECTION_BROWSE + + + + True + + + + True + + False + False + GTK_JUSTIFY_LEFT + False + False + 0 + 0.5 + 0 + 0 + + + + + + + + True + + + + True + + False + False + GTK_JUSTIFY_LEFT + False + False + 0 + 0.5 + 0 + 0 + + + + + + + + + 14 + True + True + + + + + + + + + 0 + False + True + + + + + + 5 + True + False + 0 + + + + True + Volume Name: + False + False + GTK_JUSTIFY_LEFT + False + False + 0.17 + 0.5 + 0 + 0 + + + 0 + True + True + + + + + + True + True + True + True + 0 + + True + * + False + + + 0 + True + True + + + + + + + + + 0 + False + True + + + + + + 5 + True + False + 0 + + + + True + Slot: + False + False + GTK_JUSTIFY_LEFT + False + False + 0.09 + 0.5 + 0 + 0 + + + 0 + False + True + + + + + + True + True + 1 + 0 + True + GTK_UPDATE_ALWAYS + False + False + 0 0 10000 1 10 10 + + + 0 + True + True + + + + + + + + + 0 + True + True + + + + + + True + + False + False + GTK_JUSTIFY_CENTER + False + False + 0.5 + 0.5 + 0 + 0 + + + 0 + False + False + + + + + 0 + False + True + + + + + + + diff --git a/bacula/src/console2.gladep b/bacula/src/console2.gladep new file mode 100644 index 0000000000..8e701cb6f4 --- /dev/null +++ b/bacula/src/console2.gladep @@ -0,0 +1,8 @@ + + + + + console + gnome-console + gnome2-console + diff --git a/bacula/src/gnome2-console/Makefile.in b/bacula/src/gnome2-console/Makefile.in new file mode 100644 index 0000000000..74193f1719 --- /dev/null +++ b/bacula/src/gnome2-console/Makefile.in @@ -0,0 +1,120 @@ +# +# Version $Id$ +# +@MCOMMON@ + +srcdir = . +VPATH = . +.PATH: . + +# one up +basedir = .. +# top dir +topdir = ../.. +# this dir relative to top dir +thisdir = src/gnome2-console + +DEBUG=@DEBUG@ + +first_rule: all +dummy: + +GNOME_INCLUDEDIR = @GNOME_INCLUDEDIR@ +GNOMEUI_LIBS = @GNOMEUI_LIBS@ +GNOME_LIBDIR = @GNOME_LIBDIR@ +GNOME_LIBS = @GNOME_LIBS@ + + +# +CONSSRCS = console.c console_conf.c authenticate.c support.c interface.c callbacks.c +CONSOBJS = console.o console_conf.o authenticate.o support.o interface.o callbacks.o + +# these are the objects that are changed by the .configure process +EXTRAOBJS = @OBJLIST@ + +#CONS_INC=@CONS_INC@ $(GNOME_INCLUDEDIR) +#CONS_LIBS=@CONS_LIBS@ $(GNOME_LIBS) +#CONS_LDFLAGS=@CONS_LDFLAGS@ $(GNOME_LIBDIR) $(GNOMEUI_LIBS) + +CONS_INC=$(GNOME_INCLUDEDIR) +CONS_LIBS=$(GNOME_LIBS) +CONS_LDFLAGS=$(GNOME_LIBDIR) $(GNOMEUI_LIBS) + + +.SUFFIXES: .c .o +.PHONY: +.DONTCARE: + +# inference rules +.c.o: + $(CXX) $(DEFS) $(DEBUG) -c $(CPPFLAGS) $(CONS_INC) -I$(srcdir) -I$(basedir) $(DINCLUDE) $(CFLAGS) $< +#------------------------------------------------------------------------- +all: Makefile gnome-console @STATIC_CONS@ + @echo "==== Make of gnome-console is good ====" + @echo " " + + +gnome-console: $(CONSOBJS) ../lib/libbac.a ../cats/libsql.a + $(CXX) $(LDFLAGS) $(CONS_LDFLAGS) -L../lib -L../cats -o $@ $(CONSOBJS) \ + $(LIBS) $(DLIB) $(CONS_LIBS) -lbac -lsql -lm + +static-console: static-gnome-console + +static-gnome-console: $(CONSOBJS) ../lib/libbac.a ../cats/libsql.a + $(CXX) $(LDFLAGS) $(CONS_LDFLAGS) -L../lib -L../cats -o $@ $(CONSOBJS) \ + $(LIBS) $(DLIB) $(CONS_LIBS) -lbac -lsql -lm + strip $@ + +Makefile: $(srcdir)/Makefile.in $(topdir)/config.status + cd $(topdir) \ + && CONFIG_FILES=$(thisdir)/$@ CONFIG_HEADERS= $(SHELL) ./config.status + +clean: + @$(RMF) gnome-console core core.* a.out *.o *.bak *~ *.intpro *.extpro 1 2 3 + @$(RMF) static-gnome-console + +realclean: clean + @$(RMF) tags + @$(RM) -rf .deps gnome-console.conf + +distclean: realclean + if test $(srcdir) = .; then $(MAKE) realclean; fi + (cd $(srcdir); $(RMF) Makefile; $(RMF) -r CVS) + +install: all + $(INSTALL_SCRIPT) gnome-console $(DESTDIR)$(sbindir)/gnome-console + @srcconf=gnome-console.conf; \ + if test -f ${DESTDIR}${sysconfdir}/$$srcconf; then \ + destconf=$$srcconf.new; \ + echo " ==> Found existing $$srcconf, installing new conf file as $$destconf"; \ + else \ + destconf=$$srcconf; \ + fi; \ + echo "${INSTALL_CONFIG} $$srcconf ${DESTDIR}${sysconfdir}/$$destconf"; \ + ${INSTALL_CONFIG} $$srcconf ${DESTDIR}${sysconfdir}/$$destconf + +uninstall: + (cd $(DESTDIR)$(sbindir); $(RMF) gnome-console) + (cd $(DESTDIR)$(sysconfdir); $(RMF) gnome-console.conf gnome-console.conf.new) + + + +# Semi-automatic generation of dependencies: +# Use gcc -MM because X11 `makedepend' doesn't work on all systems +# and it also includes system headers. +# `semi'-automatic since dependencies are generated at distribution time. + +depend: + @$(MV) Makefile Makefile.bak + @$(SED) "/^# DO NOT DELETE:/,$$ d" Makefile.bak > Makefile + @$(ECHO) "# DO NOT DELETE: nice dependency list follows" >> Makefile + @$(CC) -S -M $(CPPFLAGS) $(XINC) -I$(srcdir) -I$(basedir) $(GNOME_INCLUDEDIR) $(SQL_INC) *.c >> Makefile + @if test -f Makefile ; then \ + $(RMF) Makefile.bak; \ + else \ + $(MV) Makefile.bak Makefile; \ + echo -e "Something went wrong\n\a"; \ + fi + +# ----------------------------------------------------------------------- +# DO NOT DELETE: nice dependency list follows diff --git a/bacula/src/gnome2-console/authenticate.c b/bacula/src/gnome2-console/authenticate.c new file mode 100644 index 0000000000..3fe7a2f1be --- /dev/null +++ b/bacula/src/gnome2-console/authenticate.c @@ -0,0 +1,82 @@ +/* + * + * Bacula UA authentication. Provides authentication with + * the Director. + * + * Kern Sibbald, June MMI + * + * Version $Id$ + * + * This routine runs as a thread and must be thread reentrant. + * + * Basic tasks done here: + * + */ +/* + Copyright (C) 2000, 2001 Kern Sibbald and John Walker + + 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. + */ + +#include "bacula.h" +#include "console.h" + + +/* Commands sent to Director */ +static char hello[] = "Hello %s calling\n"; + +/* Response from Director */ +static char OKhello[] = "1000 OK:"; + +/* Forward referenced functions */ + +/* + * Authenticate Director + */ +int authenticate_director(JCR *jcr, DIRRES *director) +{ + BSOCK *dir = jcr->dir_bsock; + int ssl_need = BNET_SSL_NONE; + + /* + * Send my name to the Director then do authentication + */ + bnet_fsend(dir, hello, "UserAgent"); + + if (!cram_md5_get_auth(dir, director->password, ssl_need) || + !cram_md5_auth(dir, director->password, ssl_need)) { + printf(_("%s: Director authorization problem.\n"), my_name); + set_text(_("Director authorization problem.\n"), -1); + return 0; + } + + Dmsg1(6, ">dird: %s", dir->msg); + if (bnet_recv(dir) <= 0) { + set_textf(_("Bad response to Hello command: ERR=%s\n"), + bnet_strerror(dir)); + printf(_("%s: Bad response to Hello command: ERR=%s\n"), + my_name, bnet_strerror(dir)); + set_text(_("The Director is probably not running.\n"), -1); + return 0; + } + Dmsg1(10, "msg); + if (strncmp(dir->msg, OKhello, sizeof(OKhello)-1) != 0) { + set_text(_("Director rejected Hello command\n"), -1); + return 0; + } else { + set_text(dir->msg, dir->msglen); + } + return 1; +} diff --git a/bacula/src/gnome2-console/callbacks.c b/bacula/src/gnome2-console/callbacks.c new file mode 100644 index 0000000000..782e35906b --- /dev/null +++ b/bacula/src/gnome2-console/callbacks.c @@ -0,0 +1,503 @@ +/* + * Version $Id$ + */ + +#ifdef HAVE_CONFIG_H +# include +#endif + +#include "bacula.h" +#include "console.h" + +#include "callbacks.h" +#include "interface.h" +#include "support.h" + +#define KEY_Enter 65293 +#define KEY_Up 65362 +#define KEY_Down 65364 +#define KEY_Left 65361 +#define KEY_Right 65363 + +gboolean +on_app1_delete_event(GtkWidget *widget, GdkEvent *event, gpointer user_data) +{ + gtk_main_quit(); + return FALSE; +} + +void +on_connect_activate(GtkMenuItem *menuitem, gpointer user_data) +{ + if (connect_to_director(user_data)) { + start_director_reader(user_data); + } +} + + +void +on_disconnect_activate(GtkMenuItem *menuitem, gpointer user_data) +{ + if (disconnect_from_director(user_data)) { + stop_director_reader(user_data); + } +} + + +void +on_exit_activate(GtkMenuItem *menuitem, gpointer user_data) +{ + gtk_main_quit(); +} + + +void +on_cut1_activate(GtkMenuItem *menuitem, gpointer user_data) +{ + +} + + +void +on_copy1_activate(GtkMenuItem *menuitem, gpointer user_data) +{ + +} + + +void +on_paste1_activate(GtkMenuItem *menuitem, gpointer user_data) +{ + +} + + +void +on_clear1_activate(GtkMenuItem *menuitem, gpointer user_data) +{ + +} + + +void +on_properties1_activate(GtkMenuItem *menuitem, gpointer user_data) +{ + +} + + +void +on_preferences1_activate(GtkMenuItem *menuitem, gpointer user_data) +{ +} + + +void +on_about_activate(GtkMenuItem *menuitem, gpointer user_data) +{ + gtk_widget_show(about1); + gtk_main(); +} + + +void +on_connect_button_clicked(GtkButton *button, gpointer user_data) +{ + if (connect_to_director(user_data)) { + start_director_reader(user_data); + } +} + +/* Define max length of history and how many to delete when it gets there. + * If you make HIST_DEL > HIST_MAX, you shoot yourself in the foot. + */ +#define HIST_MAX 2500 +#define HIST_DEL 500 + +static GList *hist = NULL; +static GList *hc = NULL; +static int hist_len = 0; + +static void add_to_history(gchar *ecmd) +{ + int len = strlen(ecmd); + + if (len > 0) { + hist = g_list_append(hist, bstrdup(ecmd)); + hist_len++; + } + if (hist_len >= HIST_MAX) { + int i; + GList *hp; + for (i=0; idata); + hist = g_list_remove(hist, hp->data); + } + hist_len -= HIST_DEL; + } + hc = NULL; +} + +/* + * Note, apparently there is a bug in GNOME where some of the + * key press events are lost -- at least it loses every other + * up arrow! + */ +gboolean +on_entry1_key_press_event(GtkWidget *widget, GdkEventKey *event, gpointer user_data) +{ + if (event->keyval == KEY_Enter) { + char *ecmd = (char *)gtk_entry_get_text((GtkEntry *)entry1); + set_text(ecmd, strlen(ecmd)); + set_text("\n", 1); + add_to_history(ecmd); + write_director(ecmd); + gtk_entry_set_text((GtkEntry *)entry1, ""); + } else if (event->keyval == KEY_Up) { + if (!hc) { + hc = g_list_last(hist); + } else { + hc = g_list_previous(hc); + } + if (!hc) { + hc = g_list_first(hist); + } + gtk_entry_set_text((GtkEntry *)entry1, (gchar *)hc->data); + } else if (event->keyval == KEY_Down) { + if (!hc) { + hc = g_list_first(hist); + } else { + hc = g_list_next(hc); + } + if (!hc) { + hc = g_list_last(hist); + } + gtk_entry_set_text((GtkEntry *)entry1, (gchar *)hc->data); + } + gtk_window_set_focus((GtkWindow *)app1, entry1); + return FALSE; +} + + +void +on_app1_show(GtkWidget *widget, gpointer user_data) +{ +} + + + +void +on_msgs_button_clicked(GtkButton *button, gpointer user_data) +{ + write_director("messages"); +} + +void +on_msgs_activate(GtkMenuItem *menuitem, gpointer user_data) +{ + write_director("messages"); +} + +void +on_about_button_clicked(GtkButton *button, gpointer user_data) +{ + gtk_widget_hide(about1); + gtk_main_quit(); + set_status_ready(); +} + +void +on_select_director_OK_clicked(GtkButton *button, gpointer user_data) +{ + reply = OK; + gtk_widget_hide(dir_dialog); + gtk_main_quit(); + set_status_ready(); +} + + +void +on_select_director_cancel_clicked(GtkButton *button, gpointer user_data) +{ + reply = CANCEL; + gtk_widget_hide(dir_dialog); + gtk_main_quit(); + set_status_ready(); +} + +/* + * Compare list string items + */ +static gint compare_func(const void *data1, const void *data2) +{ + return strcmp((const char *)data1, (const char *)data2); +} + +static GList *find_combo_list(char *name) +{ + if (strcmp(name, "job") == 0) { + return job_list; + } + if (strcmp(name, "pool") == 0) { + return pool_list; + } + if (strcmp(name, "client") == 0) { + return client_list; + } + if (strcmp(name, "storage") == 0) { + return storage_list; + } + if (strcmp(name, "fileset") == 0) { + return fileset_list; + } + if (strcmp(name, "messages") == 0) { + return messages_list; + } + if (strcmp(name, "type") == 0) { + return type_list; + } + if (strcmp(name, "level") == 0) { + return level_list; + } + return NULL; +} + +/* + * Set correct default values in the Run dialog box + */ +static void set_run_defaults() +{ + GtkWidget *combo, *entry; + char *job, *def; + GList *item, *list; + char cmd[1000]; + int pos; + + stop_director_reader(NULL); + + combo = lookup_widget(run_dialog, "combo_job"); + job = (char *)gtk_entry_get_text(GTK_ENTRY(GTK_COMBO(combo)->entry)); + bsnprintf(cmd, sizeof(cmd), ".defaults job=\"%s\"", job); + write_director(cmd); + while (bnet_recv(UA_sock) > 0) { + def = strchr(UA_sock->msg, '='); + if (!def) { + continue; + } + *def++ = 0; + if (strcmp(UA_sock->msg, "job") == 0 || + strcmp(UA_sock->msg, "when") == 0) { + continue; + } + /* Where is an entry box */ + if (strcmp(UA_sock->msg, "where") == 0) { + entry = lookup_widget(run_dialog, "entry_where"); + gtk_entry_set_text(GTK_ENTRY(entry), def); + continue; + } + + /* Now handle combo boxes */ + list = find_combo_list(UA_sock->msg); + if (!list) { + continue; + } + item = g_list_find_custom(list, def, compare_func); + bsnprintf(cmd, sizeof(cmd), "combo_%s", UA_sock->msg); + combo = lookup_widget(run_dialog, cmd); + if (!combo) { + continue; + } + pos = g_list_position(list, item); + gtk_list_select_item(GTK_LIST(GTK_COMBO(combo)->list), pos); + } + start_director_reader(NULL); +} + +void +on_entry_job_changed(GtkEditable *editable, gpointer user_data) +{ + set_run_defaults(); +} + + +void +on_run_button_clicked(GtkButton *button, gpointer user_data) +{ + char dt[50]; + GtkWidget *entry; + + bstrutime(dt, sizeof(dt), time(NULL)); + entry = lookup_widget(run_dialog, "entry_when"); + gtk_entry_set_text(GTK_ENTRY(entry), dt); + set_run_defaults(); + gtk_widget_show(run_dialog); + gtk_main(); +} + + +static char *get_combo_text(GtkWidget *dialog, char *combo_name) +{ + GtkWidget *combo; + combo = lookup_widget(dialog, combo_name); + if (!combo) { + return NULL; + } + return (char *)gtk_entry_get_text(GTK_ENTRY(GTK_COMBO(combo)->entry)); +} + +static char *get_entry_text(GtkWidget *dialog, char *entry_name) +{ + GtkWidget *entry; + entry = lookup_widget(dialog, entry_name); + if (!entry) { + return NULL; + } + return (char *)gtk_entry_get_text(GTK_ENTRY(entry)); +} + +static char *get_spin_text(GtkWidget *dialog, char *spin_name) +{ + GtkSpinButton *spin; + spin = (GtkSpinButton *)lookup_widget(dialog, spin_name); + if (!spin) { + return NULL; + } + return (char *)gtk_entry_get_text(GTK_ENTRY(&spin->entry)); +} + + + + +void +on_run_ok_clicked(GtkButton *button, gpointer user_data) +{ + char *job, *fileset, *level, *client, *pool, *when, *where, *storage; + + gtk_widget_hide(run_dialog); + gtk_main_quit(); + + job = get_combo_text(run_dialog, "combo_job"); + fileset = get_combo_text(run_dialog, "combo_fileset"); + client = get_combo_text(run_dialog, "combo_client"); + pool = get_combo_text(run_dialog, "combo_pool"); + storage = get_combo_text(run_dialog, "combo_storage"); + level = get_combo_text(run_dialog, "combo_level"); + + when = get_entry_text(run_dialog, "entry_when"); + where = get_entry_text(run_dialog, "entry_where"); + + if (!job || !fileset || !client || !pool || !storage || + !level || !when || !where) { + set_status_ready(); + return; + } + + bsnprintf(cmd, sizeof(cmd), + "run job=\"%s\" fileset=\"%s\" level=%s client=\"%s\" pool=\"%s\" " + "when=\"%s\" where=\"%s\" storage=\"%s\"", + job, fileset, level, client, pool, when, where, storage); + write_director(cmd); + write_director("yes"); + return; +} + + +void +on_run_cancel_clicked(GtkButton *button, gpointer user_data) +{ + gtk_widget_hide(run_dialog); + gtk_main_quit(); + set_status_ready(); +} + +gboolean +on_entry1_key_release_event(GtkWidget *widget, GdkEventKey *event, gpointer user_data) +{ + return FALSE; +} + +void +on_restore_button_clicked(GtkButton *button, gpointer user_data) +{ + gtk_widget_show(restore_dialog); + gtk_main(); +} + +void +on_view_fileset_clicked(GtkButton *button, gpointer user_data) +{ +} + +void +on_restore_ok_clicked(GtkButton *button, gpointer user_data) +{ + gtk_widget_hide(restore_dialog); + gtk_main_quit(); + set_status_ready(); +} + + +void +on_restore_cancel_clicked(GtkButton *button, gpointer user_data) +{ + gtk_widget_hide(restore_dialog); + gtk_main_quit(); + set_status_ready(); +} + +void +on_apply_button_clicked(GtkButton *button, gpointer user_data) +{ + gtk_widget_show(restore_files); + gtk_main(); +} + +void +on_restore_file_clicked(GtkButton *button, gpointer user_data) +{ + gtk_widget_hide(restore_files); + gtk_main_quit(); +} + +void +on_label_button_clicked(GtkButton *button, gpointer user_data) +{ + gtk_widget_show(label_dialog); + gtk_main(); +} + +void +on_label_ok_clicked(GtkButton *button, gpointer user_data) +{ + char *pool, *volume, *storage, *slot; + + gtk_widget_hide(label_dialog); + gtk_main_quit(); + + pool = get_combo_text(label_dialog, "label_combo_pool"); + storage = get_combo_text(label_dialog, "label_combo_storage"); + + volume = get_entry_text(label_dialog, "label_entry_volume"); + + slot = get_spin_text(label_dialog, "label_slot"); + + if (!pool || !storage || !volume || !(*volume)) { + set_status_ready(); + return; + } + + bsnprintf(cmd, sizeof(cmd), + "label name=\"%s\" pool=\"%s\" storage=\"%s\" slot=%s", + volume, pool, storage, slot); + write_director(cmd); +} + + +void +on_label_cancel_clicked(GtkButton *button, gpointer user_data) +{ + gtk_widget_hide(label_dialog); + gtk_main_quit(); + set_status_ready(); +} diff --git a/bacula/src/gnome2-console/callbacks.h b/bacula/src/gnome2-console/callbacks.h new file mode 100644 index 0000000000..184ba9c4ea --- /dev/null +++ b/bacula/src/gnome2-console/callbacks.h @@ -0,0 +1,240 @@ + +/* Version $Id$ */ + +gboolean +on_app1_delete_event (GtkWidget *widget, + GdkEvent *event, + gpointer user_data); + +void +on_new_file1_activate (GtkMenuItem *menuitem, + gpointer user_data); + +void +on_open1_activate (GtkMenuItem *menuitem, + gpointer user_data); + +void +on_save1_activate (GtkMenuItem *menuitem, + gpointer user_data); + +void +on_save_as1_activate (GtkMenuItem *menuitem, + gpointer user_data); + +void +on_exit1_activate (GtkMenuItem *menuitem, + gpointer user_data); + +void +on_cut1_activate (GtkMenuItem *menuitem, + gpointer user_data); + +void +on_copy1_activate (GtkMenuItem *menuitem, + gpointer user_data); + +void +on_paste1_activate (GtkMenuItem *menuitem, + gpointer user_data); + +void +on_clear1_activate (GtkMenuItem *menuitem, + gpointer user_data); + +void +on_properties1_activate (GtkMenuItem *menuitem, + gpointer user_data); + +void +on_preferences1_activate (GtkMenuItem *menuitem, + gpointer user_data); + +void +on_about1_activate (GtkMenuItem *menuitem, + gpointer user_data); + +void +on_about1_clicked (GnomeDialog *gnomedialog, + gint arg1, + gpointer user_data); + +gboolean +on_entry1_key_press_event (GtkWidget *widget, + GdkEventKey *event, + gpointer user_data); + +gboolean +on_app1_key_press_event (GtkWidget *widget, + GdkEventKey *event, + gpointer user_data); + +void +on_select_director_clicked (GtkButton *button, + gpointer user_data); + +void +on_connect_button1_clicked (GtkButton *button, + gpointer user_data); + +void +on_app1_realize (GtkWidget *widget, + gpointer user_data); + +gboolean +on_combo_entry1_key_press_event (GtkWidget *widget, + GdkEventKey *event, + gpointer user_data); + +gboolean +on_entry1_key_press_event (GtkWidget *widget, + GdkEventKey *event, + gpointer user_data); + +gboolean +on_entry1_key_press_event (GtkWidget *widget, + GdkEventKey *event, + gpointer user_data); + +void +on_app1_show (GtkWidget *widget, + gpointer user_data); + +void +on_connect_button1_clicked (GtkButton *button, + gpointer user_data); + +void +on_run_button1_clicked (GtkButton *button, + gpointer user_data); + +void +on_msgs_button_clicked (GtkButton *button, + gpointer user_data); + +void +on_msgs_activate (GtkMenuItem *menuitem, + gpointer user_data); + +void +on_run_button_clicked (GtkButton *button, + gpointer user_data); + +void +on_disconnect_activate (GtkMenuItem *menuitem, + gpointer user_data); + +void +on_about_activate (GtkMenuItem *menuitem, + gpointer user_data); + +void +on_connect_button_clicked (GtkButton *button, + gpointer user_data); + +void +on_connect_activate (GtkMenuItem *menuitem, + gpointer user_data); + +void +on_exit_activate (GtkMenuItem *menuitem, + gpointer user_data); + +void +on_about_clicked (GnomeDialog *gnomedialog, + gint arg1, + gpointer user_data); + +gboolean +on_app2_delete_event (GtkWidget *widget, + GdkEvent *event, + gpointer user_data); + +void +on_app2_show (GtkWidget *widget, + gpointer user_data); + +gboolean +on_app1_delete_event (GtkWidget *widget, + GdkEvent *event, + gpointer user_data); + +void +on_app1_show (GtkWidget *widget, + gpointer user_data); + +gboolean +on_entry1_key_press_event (GtkWidget *widget, + GdkEventKey *event, + gpointer user_data); + +void +on_about_button_clicked (GtkButton *button, + gpointer user_data); + +void +on_select_director_OK_clicked (GtkButton *button, + gpointer user_data); + +void +on_select_director_cancel_clicked (GtkButton *button, + gpointer user_data); + +void +on_run_ok_clicked (GtkButton *button, + gpointer user_data); + +void +on_run_cancel_clicked (GtkButton *button, + gpointer user_data); + +gboolean +on_entry1_key_release_event (GtkWidget *widget, + GdkEventKey *event, + gpointer user_data); + +void +on_restore_button_clicked (GtkButton *button, + gpointer user_data); + +void +on_type_combo_selection_received (GtkWidget *widget, + GtkSelectionData *data, + guint time, + gpointer user_data); + +void +on_view_fileset_clicked (GtkButton *button, + gpointer user_data); + +void +on_entry_job_changed (GtkEditable *editable, + gpointer user_data); + +void +on_restore_ok_clicked (GtkButton *button, + gpointer user_data); + +void +on_restore_cancel_clicked (GtkButton *button, + gpointer user_data); + +void +on_apply_button_clicked (GtkButton *button, + gpointer user_data); + +void +on_restore_file_clicked (GtkButton *button, + gpointer user_data); + +void +on_label_button_clicked (GtkButton *button, + gpointer user_data); + +void +on_label_ok_clicked (GtkButton *button, + gpointer user_data); + +void +on_label_cancel_clicked (GtkButton *button, + gpointer user_data); diff --git a/bacula/src/gnome2-console/console.c b/bacula/src/gnome2-console/console.c new file mode 100644 index 0000000000..63f3925ed1 --- /dev/null +++ b/bacula/src/gnome2-console/console.c @@ -0,0 +1,565 @@ +/* + * + * Bacula GNOME Console interface to the Director + * + * Kern Sibbald, March MMII + * + * Version $Id$ + */ + +/* + Copyright (C) 2002 Kern Sibbald and John Walker + + 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. + */ + +#include "bacula.h" +#include "console.h" + +#include "interface.h" +#include "support.h" + +/* Imported functions */ +int authenticate_director(JCR *jcr, DIRRES *director); + +/* Exported variables */ +GtkWidget *app1; /* application window */ +GtkWidget *text1; /* text window */ +GtkWidget *entry1; /* entry box */ +GtkWidget *status1; /* status bar */ +GtkWidget *combo1; /* director combo */ +GtkWidget *run_dialog; /* run dialog */ +GtkWidget *dir_dialog; /* director selection dialog */ +GtkWidget *restore_dialog; /* restore dialog */ +GtkWidget *restore_files; /* restore files dialog */ +GtkWidget *dir_select; +GtkWidget *about1; /* about box */ +GtkWidget *label_dialog; +GdkFont *text_font = NULL; +pthread_mutex_t cmd_mutex = PTHREAD_MUTEX_INITIALIZER; +pthread_cond_t cmd_wait; +char cmd[1000]; +int cmd_ready = FALSE; +int reply; +BSOCK *UA_sock = NULL; +GList *job_list, *client_list, *fileset_list; +GList *messages_list, *pool_list, *storage_list; +GList *type_list, *level_list; + +/* Forward referenced functions */ +static void terminate_console(int sig); +static gint message_handler(gpointer data); +static int initial_connect_to_director(gpointer data); + +/* Static variables */ +static char *configfile = NULL; +static DIRRES *dir; +static CONRES *con; +static int ndir; +static int director_reader_running = FALSE; +static int at_prompt = FALSE; +static int ready = FALSE; +static int quit = FALSE; +static guint initial; + +#define CONFIG_FILE "./gnome-console.conf" /* default configuration file */ + +static void usage() +{ + fprintf(stderr, _( +"\nVersion: " VERSION " (" BDATE ")\n\n" +"Usage: gnome-console [-s] [-c config_file] [-d debug_level] [config_file]\n" +" -c set configuration file to file\n" +" -dnn set debug level to nn\n" +" -s no signals\n" +" -t test - read configuration and exit\n" +" -? print this message.\n" +"\n")); + + exit(1); +} + + +/********************************************************************* + * + * Main Bacula GNOME Console -- User Interface Program + * + */ +int main(int argc, char *argv[]) +{ + int ch, stat; + int no_signals = TRUE; + int test_config = FALSE; + int gargc = 1; + char *gargv[2] = {"gnome-console", NULL}; + + init_stack_dump(); + my_name_is(argc, argv, "gnome-console"); + init_msg(NULL, NULL); + working_directory = "/tmp"; + + struct sigaction sigignore; + sigignore.sa_flags = 0; + sigignore.sa_handler = SIG_IGN; + sigfillset(&sigignore.sa_mask); + sigaction(SIGPIPE, &sigignore, NULL); + + if ((stat=pthread_cond_init(&cmd_wait, NULL)) != 0) { + Emsg1(M_ABORT, 0, _("Pthread cond init error = %s\n"), + strerror(stat)); + } + + gnome_init("bacula", VERSION, gargc, (char **)&gargv); + + while ((ch = getopt(argc, argv, "bc:d:r:st?")) != -1) { + switch (ch) { + case 'c': /* configuration file */ + if (configfile != NULL) + free(configfile); + configfile = bstrdup(optarg); + break; + + case 'd': + debug_level = atoi(optarg); + if (debug_level <= 0) + debug_level = 1; + break; + + case 's': /* turn off signals */ + no_signals = TRUE; + break; + + case 't': + test_config = TRUE; + break; + + case '?': + default: + usage(); + + } + } + argc -= optind; + argv += optind; + + + if (!no_signals) { + init_signals(terminate_console); + } + + if (argc) { + usage(); + } + + if (configfile == NULL) { + configfile = bstrdup(CONFIG_FILE); + } + + parse_config(configfile); + + LockRes(); + ndir = 0; + for (dir=NULL; (dir = (DIRRES *)GetNextRes(R_DIRECTOR, (RES *)dir)); ) { + ndir++; + } + UnlockRes(); + if (ndir == 0) { + Emsg1(M_ERROR_TERM, 0, _("No director resource defined in %s\n\ +Without that I don't how to speak to the Director :-(\n"), configfile); + } + + if (test_config) { + terminate_console(0); + exit(0); + } + + + app1 = create_app1(); + gtk_window_set_default_size(GTK_WINDOW(app1), 500, 700); + run_dialog = create_RunDialog(); + label_dialog = create_label_dialog(); + restore_dialog = create_restore_dialog(); + restore_files = create_restore_files(); + about1 = create_about1(); + + gtk_widget_show(app1); + + text1 = lookup_widget(app1, "text1"); + entry1 = lookup_widget(app1, "entry1"); + status1 = lookup_widget(app1, "status1"); + +/* + * Thanks to Phil Stracchino for providing the font configuration code. + * original default: + text_font = gdk_font_load("-misc-fixed-medium-r-normal-*-*-130-*-*-c-*-koi8-r"); + * this works for me: + text_font = gdk_font_load("-Bigelow & Holmes-lucida console-medium-r-semi condensed-*-12-0-100-100-m-0-iso8859-1"); + * and, new automagic:font specification! + */ + + LockRes(); + for (con = NULL; (con = (CONRES *)GetNextRes(R_CONSOLE, (RES *)con)); ) { + text_font = gdk_font_load(con->fontface); + if (text_font == NULL) { + Dmsg2(404, "Load of requested ConsoleFont \"%s\" (%s) failed!\n", + con->hdr.name, con->fontface); + } else { + Dmsg2(404, "ConsoleFont \"%s\" (%s) loaded.\n", + con->hdr.name, con->fontface); + break; + } + } + UnlockRes(); + + if (text_font == NULL) { + Dmsg1(100, "Attempting to load fallback font %s\n", + "-misc-fixed-medium-r-normal-*-*-130-*-*-c-*-iso8859-1"); + text_font = gdk_font_load("-misc-fixed-medium-r-normal-*-*-130-*-*-c-*-iso8859-1"); + } + + initial = gtk_timeout_add(100, initial_connect_to_director, (gpointer)NULL); + + gtk_main(); + quit = TRUE; + disconnect_from_director((gpointer)NULL); + return 0; +} + +/* + * Every 5 seconds, ask the Director for our + * messages. + */ +static gint message_handler(gpointer data) +{ + if (ready && UA_sock) { + bnet_fsend(UA_sock, ".messages"); + } + return TRUE; +} + +int disconnect_from_director(gpointer data) +{ + if (!quit) + set_status(_(" Not Connected")); + if (UA_sock) { + bnet_sig(UA_sock, BNET_TERMINATE); /* send EOF */ + bnet_close(UA_sock); + UA_sock = NULL; + } + return 1; +} + +/* + * Called just after the main loop is started to allow + * us to connect to the Director. + */ +static int initial_connect_to_director(gpointer data) +{ + gtk_timeout_remove(initial); + if (connect_to_director(data)) { + start_director_reader(data); + } + gtk_timeout_add(5000, message_handler, (gpointer)NULL); + return TRUE; +} + +static GList *get_list(char *cmd) +{ + GList *options; + char *msg; + + options = NULL; + write_director(cmd); + while (bnet_recv(UA_sock) > 0) { + strip_trailing_junk(UA_sock->msg); + msg = (char *)malloc(strlen(UA_sock->msg) + 1); + strcpy(msg, UA_sock->msg); + options = g_list_append(options, msg); + } + return options; + +} + +static GList *get_and_fill_combo(GtkWidget *dialog, char *combo_name, char *cmd) +{ + GtkWidget *combo; + GList *options; + + combo = lookup_widget(dialog, combo_name); + options = get_list(cmd); + if (combo && options) { + gtk_combo_set_popdown_strings(GTK_COMBO(combo), options); + } + return options; +} + +static void fill_combo(GtkWidget *dialog, char *combo_name, GList *options) +{ + GtkWidget *combo; + + combo = lookup_widget(dialog, combo_name); + if (combo) { + gtk_combo_set_popdown_strings(GTK_COMBO(combo), options); + } + return; +} + + +/* + * Connect to Director. If there are more than one, put up + * a modal dialog so that the user chooses one. + */ +int connect_to_director(gpointer data) +{ + GList *dirs = NULL; + GtkWidget *combo; + char buf[1000]; + JCR jcr; + + + if (UA_sock) { + return 0; + } + + if (ndir > 1) { + LockRes(); + for (dir = NULL; (dir = (DIRRES *)GetNextRes(R_DIRECTOR, (RES *)dir)); ) { + sprintf(buf, "%s at %s:%d", dir->hdr.name, dir->address, + dir->DIRport); + printf("%s\n", buf); + dirs = g_list_append(dirs, dir->hdr.name); + } + UnlockRes(); + dir_dialog = create_SelectDirectorDialog(); + combo = lookup_widget(dir_dialog, "combo1"); + dir_select = lookup_widget(dir_dialog, "dirselect"); + gtk_combo_set_popdown_strings(GTK_COMBO(combo), dirs); + printf("dialog run\n"); + gtk_widget_show(dir_dialog); + gtk_main(); + + if (reply == OK) { + gchar *ecmd = gtk_editable_get_chars((GtkEditable *)dir_select, 0, -1); + dir = (DIRRES *)GetResWithName(R_DIRECTOR, ecmd); + if (ecmd) { + g_free(ecmd); /* release director name string */ + } + } + if (dirs) { + g_free(dirs); + } + gtk_widget_destroy(dir_dialog); + dir_dialog = NULL; + } else { + /* Just take the first Director */ + LockRes(); + dir = (DIRRES *)GetNextRes(R_DIRECTOR, NULL); + UnlockRes(); + } + + if (!dir) { + printf("dir is NULL\n"); + return 0; + } + + memset(&jcr, 0, sizeof(jcr)); + + set_statusf(_(" Connecting to Director %s:%d\n"), dir->address,dir->DIRport); + set_textf(_("Connecting to Director %s:%d\n"), dir->address,dir->DIRport); + +// while (gtk_events_pending()) { /* fully paint screen */ +// gtk_main_iteration(); +// } + UA_sock = bnet_connect(NULL, 5, 15, "Director daemon", dir->address, + NULL, dir->DIRport, 0); + if (UA_sock == NULL) { + return 0; + } + + jcr.dir_bsock = UA_sock; + if (!authenticate_director(&jcr, dir)) { + set_text(UA_sock->msg, UA_sock->msglen); + return 0; + } + + set_status(" Initializing ..."); + + bnet_fsend(UA_sock, "autodisplay on"); + + /* Read and display all initial messages */ + while (bnet_recv(UA_sock) > 0) { + set_text(UA_sock->msg, UA_sock->msglen); + } + + /* Paint changes */ + while (gtk_events_pending()) { + gtk_main_iteration(); + } + + /* Fill the run_dialog combo boxes */ + job_list = get_and_fill_combo(run_dialog, "combo_job", ".jobs"); + client_list = get_and_fill_combo(run_dialog, "combo_client", ".clients"); + fileset_list = get_and_fill_combo(run_dialog, "combo_fileset", ".filesets"); + messages_list = get_and_fill_combo(run_dialog, "combo_messages", ".msgs"); + pool_list = get_and_fill_combo(run_dialog, "combo_pool", ".pools"); + storage_list = get_and_fill_combo(run_dialog, "combo_storage", ".storage"); + type_list = get_and_fill_combo(run_dialog, "combo_type", ".types"); + level_list = get_and_fill_combo(run_dialog, "combo_level", ".levels"); + + fill_combo(label_dialog, "label_combo_storage", storage_list); + fill_combo(label_dialog, "label_combo_pool", pool_list); + + set_status(" Connected"); + return 1; +} + +void write_director(gchar *msg) +{ + if (UA_sock) { + at_prompt = FALSE; + set_status(_(" Processing command ...")); + UA_sock->msglen = strlen(msg); + pm_strcpy(&UA_sock->msg, msg); + bnet_send(UA_sock); + } + if (strcmp(msg, ".quit") == 0 || strcmp(msg, ".exit") == 0) { + disconnect_from_director((gpointer)NULL); + gtk_main_quit(); + } +} + +void read_director(gpointer data, gint fd, GdkInputCondition condition) +{ + int stat; + + if (!UA_sock || UA_sock->fd != fd) { + return; + } + stat = bnet_recv(UA_sock); + if (stat >= 0) { + if (at_prompt) { + set_text("\n", 1); + at_prompt = FALSE; + } + set_text(UA_sock->msg, UA_sock->msglen); + return; + } + if (is_bnet_stop(UA_sock)) { /* error or term request */ + gtk_main_quit(); + return; + } + /* Must be a signal -- either do something or ignore it */ + if (UA_sock->msglen == BNET_PROMPT) { + at_prompt = TRUE; + set_status(_(" At prompt waiting for input ...")); + } + if (UA_sock->msglen == BNET_EOD) { + set_status_ready(); + } + return; +} + +static gint tag; + +void start_director_reader(gpointer data) +{ + + if (director_reader_running || !UA_sock) { + return; + } + director_reader_running = TRUE; + + tag = gdk_input_add(UA_sock->fd, GDK_INPUT_READ, read_director, NULL); +} + +void stop_director_reader(gpointer data) +{ + if (!director_reader_running) { + return; + } + gdk_input_remove(tag); + director_reader_running = FALSE; +} + + + +/* Cleanup and then exit */ +static void terminate_console(int sig) +{ + static int already_here = FALSE; + + if (already_here) /* avoid recursive temination problems */ + exit(1); + already_here = TRUE; + disconnect_from_director((gpointer)NULL); + gtk_main_quit(); + exit(0); +} + + +/* Buffer approx 2000 lines -- assume 60 chars/line */ +#define MAX_TEXT_CHARS (2000 * 60) +static int text_chars = 0; + +static void truncate_text_chars() +{ + int del_chars = MAX_TEXT_CHARS / 4; + gtk_text_set_point(GTK_TEXT(text1), del_chars); + gtk_text_backward_delete(GTK_TEXT(text1), del_chars); + text_chars -= del_chars; + gtk_text_set_point(GTK_TEXT(text1), text_chars); +} + +void set_textf(char *fmt, ...) +{ + va_list arg_ptr; + char buf[1000]; + int len; + va_start(arg_ptr, fmt); + len = bvsnprintf(buf, sizeof(buf), fmt, arg_ptr); + set_text(buf, len); +} + +void set_text(char *buf, int len) +{ + gtk_text_insert(GTK_TEXT(text1), text_font, NULL, NULL, buf, -1); + text_chars += len; + if (text_chars > MAX_TEXT_CHARS) { + truncate_text_chars(); + } +} + +void set_statusf(char *fmt, ...) +{ + va_list arg_ptr; + char buf[1000]; + int len; + va_start(arg_ptr, fmt); + len = bvsnprintf(buf, sizeof(buf), fmt, arg_ptr); + gtk_label_set_text(GTK_LABEL(status1), buf); + ready = FALSE; +} + +void set_status_ready() +{ + gtk_label_set_text(GTK_LABEL(status1), " Ready"); + ready = TRUE; +} + +void set_status(char *buf) +{ + gtk_label_set_text(GTK_LABEL(status1), buf); + ready = FALSE; +} diff --git a/bacula/src/gnome2-console/console.h b/bacula/src/gnome2-console/console.h new file mode 100644 index 0000000000..200ca32288 --- /dev/null +++ b/bacula/src/gnome2-console/console.h @@ -0,0 +1,61 @@ +/* + * Bacula GNOME User Agent specific configuration and defines + * + * Kern Sibbald, March 2002 + * + * Version $Id$ + */ + +#ifndef __CONSOLE_H_ +#define __CONSOLE_H_ + +#include "console_conf.h" +#include "jcr.h" +/* Super kludge for GNOME 2.0 */ +#undef _ +#undef N_ +#undef textdomain + +#include + +extern GtkWidget *app1; /* application window */ +extern GtkWidget *text1; /* text window */ +extern GtkWidget *entry1; /* entry box */ +extern GtkWidget *combo1; /* Directory combo */ +extern GtkWidget *dir_dialog; +extern GtkWidget *dir_select; +extern GtkWidget *run_dialog; /* run dialog */ +extern GtkWidget *label_dialog; +extern GtkWidget *restore_dialog; /* restore dialog */ +extern GtkWidget *restore_files; /* restore files dialog */ +extern GtkWidget *about1; +extern GList *job_list, *client_list, *fileset_list; +extern GList *messages_list, *pool_list, *storage_list; +extern GList *type_list, *level_list; + + +extern pthread_mutex_t cmd_mutex; +extern pthread_cond_t cmd_wait; +extern char cmd[1000]; +extern int cmd_ready; +extern int reply; +extern BSOCK *UA_sock; + + + +#define OK 1 +#define CANCEL 0 + +void set_textf(char *fmt, ...); +void set_text(char *buf, int len); +void set_status(char *buf); +void set_status_ready(); +void set_statusf(char *fmt, ...); +int connect_to_director(gpointer data); +int disconnect_from_director(gpointer data); +void start_director_reader(gpointer data); +void stop_director_reader(gpointer data); +void write_director(gchar *msg); +void read_director(gpointer data, gint fd, GdkInputCondition condition); + +#endif diff --git a/bacula/src/gnome2-console/console_conf.c b/bacula/src/gnome2-console/console_conf.c new file mode 100644 index 0000000000..572a849e89 --- /dev/null +++ b/bacula/src/gnome2-console/console_conf.c @@ -0,0 +1,263 @@ +/* + * Main configuration file parser for Bacula User Agent + * some parts may be split into separate files such as + * the schedule configuration (sch_config.c). + * + * Note, the configuration file parser consists of three parts + * + * 1. The generic lexical scanner in lib/lex.c and lib/lex.h + * + * 2. The generic config scanner in lib/parse_config.c and + * lib/parse_config.h. + * These files contain the parser code, some utility + * routines, and the common store routines (name, int, + * string). + * + * 3. The daemon specific file, which contains the Resource + * definitions as well as any specific store routines + * for the resource records. + * + * Kern Sibbald, January MM, September MM + * + * Version $Id$ + */ + +/* + Copyright (C) 2000, 2001 Kern Sibbald and John Walker + + 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. + */ + +#include "bacula.h" +#include "console_conf.h" + +/* Define the first and last resource ID record + * types. Note, these should be unique for each + * daemon though not a requirement. + */ +int r_first = R_FIRST; +int r_last = R_LAST; +pthread_mutex_t res_mutex = PTHREAD_MUTEX_INITIALIZER; + +/* Forward referenced subroutines */ + + +/* We build the current resource here as we are + * scanning the resource configuration definition, + * then move it to allocated memory when the resource + * scan is complete. + */ +URES res_all; +int res_all_size = sizeof(res_all); + +/* Definition of records permitted within each + * resource with the routine to process the record + * information. + */ +static struct res_items dir_items[] = { + {"name", store_name, ITEM(res_dir.hdr.name), 0, ITEM_REQUIRED, 0}, + {"description", store_str, ITEM(res_dir.hdr.desc), 0, 0, 0}, + {"dirport", store_int, ITEM(res_dir.DIRport), 0, ITEM_DEFAULT, 9101}, + {"address", store_str, ITEM(res_dir.address), 0, ITEM_REQUIRED, 0}, + {"password", store_password, ITEM(res_dir.password), 0, ITEM_REQUIRED, 0}, + {"enablessl", store_yesno, ITEM(res_dir.enable_ssl), 1, ITEM_DEFAULT, 0}, + {NULL, NULL, NULL, 0, 0, 0} +}; + +static struct res_items con_items[] = { + {"name", store_name, ITEM(con_dir.hdr.name), 0, ITEM_REQUIRED, 0}, + {"description", store_str, ITEM(con_dir.hdr.desc), 0, 0, 0}, + {"font", store_str, ITEM(con_dir.fontface), 0, ITEM_REQUIRED, 0}, + {"requiressl", store_yesno, ITEM(con_dir.require_ssl), 1, ITEM_DEFAULT, 0}, + {NULL, NULL, NULL, 0, 0, 0} +}; + +/* + * This is the master resource definition. + * It must have one item for each of the resources. + */ +struct s_res resources[] = { + {"director", dir_items, R_DIRECTOR, NULL}, + {"consolefont", con_items, R_CONSOLE, NULL}, + {NULL, NULL, 0, NULL} +}; + + +/* Dump contents of resource */ +void dump_resource(int type, RES *reshdr, void sendit(void *sock, char *fmt, ...), void *sock) +{ + URES *res = (URES *)reshdr; + int recurse = 1; + + if (res == NULL) { + printf("No record for %d %s\n", type, res_to_str(type)); + return; + } + if (type < 0) { /* no recursion */ + type = - type; + recurse = 0; + } + switch (type) { + case R_DIRECTOR: + printf("Director: name=%s address=%s DIRport=%d\n", reshdr->name, + res->res_dir.address, res->res_dir.DIRport); + break; + case R_CONSOLE: + printf("Console: name=%s font face=%s\n", + reshdr->name, NPRT(res->con_dir.fontface)); + break; + default: + printf("Unknown resource type %d\n", type); + } + if (recurse && res->res_dir.hdr.next) { + dump_resource(type, res->res_dir.hdr.next, sendit, sock); + } +} + +/* + * Free memory of resource. + * NB, we don't need to worry about freeing any references + * to other resources as they will be freed when that + * resource chain is traversed. Mainly we worry about freeing + * allocated strings (names). + */ +void free_resource(int type) +{ + URES *res; + RES *nres; + int rindex = type - r_first; + + res = (URES *)resources[rindex].res_head; + + if (res == NULL) + return; + + /* common stuff -- free the resource name */ + nres = (RES *)res->res_dir.hdr.next; + if (res->res_dir.hdr.name) { + free(res->res_dir.hdr.name); + } + if (res->res_dir.hdr.desc) { + free(res->res_dir.hdr.desc); + } + + switch (type) { + case R_DIRECTOR: + if (res->res_dir.address) { + free(res->res_dir.address); + } + break; + case R_CONSOLE: + if (res->con_dir.fontface) { + free(res->con_dir.fontface); + } + break; + default: + printf("Unknown resource type %d\n", type); + } + /* Common stuff again -- free the resource, recurse to next one */ + free(res); + resources[rindex].res_head = nres; + if (nres) { + free_resource(type); + } +} + +/* Save the new resource by chaining it into the head list for + * the resource. If this is pass 2, we update any resource + * pointers (currently only in the Job resource). + */ +void save_resource(int type, struct res_items *items, int pass) +{ + URES *res; + int rindex = type - r_first; + int i, size = 0; + int error = 0; + + /* + * Ensure that all required items are present + */ + for (i=0; items[i].name; i++) { + if (items[i].flags & ITEM_REQUIRED) { + if (!bit_is_set(i, res_all.res_dir.hdr.item_present)) { + Emsg2(M_ABORT, 0, "%s item is required in %s resource, but not found.\n", + items[i].name, resources[rindex]); + } + } + } + + /* During pass 2, we looked up pointers to all the resources + * referrenced in the current resource, , now we + * must copy their address from the static record to the allocated + * record. + */ + if (pass == 2) { + switch (type) { + /* Resources not containing a resource */ + case R_DIRECTOR: + break; + + case R_CONSOLE: + break; + + default: + Emsg1(M_ERROR, 0, "Unknown resource type %d\n", type); + error = 1; + break; + } + /* Note, the resoure name was already saved during pass 1, + * so here, we can just release it. + */ + if (res_all.res_dir.hdr.name) { + free(res_all.res_dir.hdr.name); + res_all.res_dir.hdr.name = NULL; + } + if (res_all.res_dir.hdr.desc) { + free(res_all.res_dir.hdr.desc); + res_all.res_dir.hdr.desc = NULL; + } + return; + } + + /* The following code is only executed during pass 1 */ + switch (type) { + case R_DIRECTOR: + size = sizeof(DIRRES); + break; + case R_CONSOLE: + size = sizeof(CONRES); + break; + default: + printf("Unknown resource type %d\n", type); + error = 1; + break; + } + /* Common */ + if (!error) { + res = (URES *)malloc(size); + memcpy(res, &res_all, size); + if (!resources[rindex].res_head) { + resources[rindex].res_head = (RES *)res; /* store first entry */ + } else { + RES *next; + /* Add new res to end of chain */ + for (next=resources[rindex].res_head; next->next; next=next->next) + { } + next->next = (RES *)res; + Dmsg2(90, "Inserting %s res: %s\n", res_to_str(type), + res->res_dir.hdr.name); + } + } +} diff --git a/bacula/src/gnome2-console/console_conf.h b/bacula/src/gnome2-console/console_conf.h new file mode 100644 index 0000000000..b63d20ccc8 --- /dev/null +++ b/bacula/src/gnome2-console/console_conf.h @@ -0,0 +1,60 @@ +/* + * Bacula GNOME User Agent specific configuration and defines + * + * Kern Sibbald, March 2002 + * + * Version $Id$ + */ + +#ifndef __CONSOLE_CONF_H_ +#define __CONSOLE_CONF_H_ + +/* + * Resource codes -- they must be sequential for indexing + */ +#define R_FIRST 1001 + +#define R_DIRECTOR 1001 +#define R_CONSOLE 1002 + +#define R_LAST R_CONSOLE + +/* + * Some resource attributes + */ +#define R_NAME 1020 +#define R_ADDRESS 1021 +#define R_PASSWORD 1022 +#define R_TYPE 1023 +#define R_BACKUP 1024 + + +/* Definition of the contents of each Resource */ +struct s_res_dir { + RES hdr; + int DIRport; /* UA server port */ + char *address; /* UA server address */ + char *password; /* UA server password */ + int enable_ssl; /* Use SSL */ +}; +typedef struct s_res_dir DIRRES; + +struct s_con_dir { + RES hdr; + char *fontface; /* Console Font specification */ + int require_ssl; /* Require SSL on all connections */ +}; +typedef struct s_con_dir CONRES; + +/* Define the Union of all the above + * resource structure definitions. + */ +union u_res { + struct s_res_dir res_dir; + struct s_con_dir con_dir; + RES hdr; +}; + +typedef union u_res URES; + +#endif diff --git a/bacula/src/gnome2-console/gnome-console.conf.in b/bacula/src/gnome2-console/gnome-console.conf.in new file mode 100644 index 0000000000..8ca3533b3d --- /dev/null +++ b/bacula/src/gnome2-console/gnome-console.conf.in @@ -0,0 +1,15 @@ +# +# Bacula User Agent (or Console) Configuration File +# + +Director { + Name = @hostname@-dir + DIRport = @dir_port@ + address = @hostname@ + Password = "@dir_password@" +} + +ConsoleFont { + Name = Default + Font = "-misc-fixed-medium-r-normal-*-*-130-*-*-c-*-iso8859-1" +} diff --git a/bacula/src/gnome2-console/interface.c b/bacula/src/gnome2-console/interface.c new file mode 100644 index 0000000000..53286b80c0 --- /dev/null +++ b/bacula/src/gnome2-console/interface.c @@ -0,0 +1,1462 @@ +/* + * DO NOT EDIT THIS FILE - it is generated by Glade. + */ + +#ifdef HAVE_CONFIG_H +# include +#endif + +#include +#include +#include +#include +#include + +#include +#include + +#include "callbacks.h" +#include "interface.h" +#include "support.h" + +#define GLADE_HOOKUP_OBJECT(component,widget,name) \ + g_object_set_data_full (G_OBJECT (component), name, \ + gtk_widget_ref (widget), (GDestroyNotify) gtk_widget_unref) + +#define GLADE_HOOKUP_OBJECT_NO_REF(component,widget,name) \ + g_object_set_data (G_OBJECT (component), name, widget) + +static GnomeUIInfo file1_menu_uiinfo[] = +{ + { + GNOME_APP_UI_ITEM, N_("_Connect"), + N_("Connect to Director"), + (gpointer) on_connect_activate, NULL, NULL, + GNOME_APP_PIXMAP_NONE, NULL, + 0, (GdkModifierType) 0, NULL + }, + { + GNOME_APP_UI_ITEM, N_("_Disconnect"), + N_("Disconnect from Director"), + (gpointer) on_disconnect_activate, NULL, NULL, + GNOME_APP_PIXMAP_NONE, NULL, + 0, (GdkModifierType) 0, NULL + }, + GNOMEUIINFO_SEPARATOR, + { + GNOME_APP_UI_ITEM, N_("gtk-quit"), + NULL, + (gpointer) on_exit_activate, NULL, NULL, + GNOME_APP_PIXMAP_NONE, NULL, + 0, (GdkModifierType) 0, NULL + }, + GNOMEUIINFO_END +}; + +static GnomeUIInfo edit1_menu_uiinfo[] = +{ + { + GNOME_APP_UI_ITEM, N_("gtk-cut"), + NULL, + (gpointer) on_cut1_activate, NULL, NULL, + GNOME_APP_PIXMAP_NONE, NULL, + 0, (GdkModifierType) 0, NULL + }, + { + GNOME_APP_UI_ITEM, N_("gtk-copy"), + NULL, + (gpointer) on_copy1_activate, NULL, NULL, + GNOME_APP_PIXMAP_NONE, NULL, + 0, (GdkModifierType) 0, NULL + }, + { + GNOME_APP_UI_ITEM, N_("gtk-paste"), + NULL, + (gpointer) on_paste1_activate, NULL, NULL, + GNOME_APP_PIXMAP_NONE, NULL, + 0, (GdkModifierType) 0, NULL + }, + { + GNOME_APP_UI_ITEM, N_("gtk-clear"), + NULL, + (gpointer) on_clear1_activate, NULL, NULL, + GNOME_APP_PIXMAP_NONE, NULL, + 0, (GdkModifierType) 0, NULL + }, + GNOMEUIINFO_SEPARATOR, + GNOMEUIINFO_END +}; + +static GnomeUIInfo item1_menu_uiinfo[] = +{ + { + GNOME_APP_UI_ITEM, N_("_Display Messages"), + NULL, + (gpointer) on_msgs_activate, NULL, NULL, + GNOME_APP_PIXMAP_NONE, NULL, + 0, (GdkModifierType) 0, NULL + }, + GNOMEUIINFO_END +}; + +static GnomeUIInfo settings1_menu_uiinfo[] = +{ + { + GNOME_APP_UI_ITEM, N_("gtk-preferences"), + NULL, + (gpointer) on_preferences1_activate, NULL, NULL, + GNOME_APP_PIXMAP_NONE, NULL, + 0, (GdkModifierType) 0, NULL + }, + GNOMEUIINFO_END +}; + +static GnomeUIInfo help1_menu_uiinfo[] = +{ + { + GNOME_APP_UI_ITEM, N_("gnome-stock-about"), + NULL, + (gpointer) on_about_activate, NULL, NULL, + GNOME_APP_PIXMAP_NONE, NULL, + 0, (GdkModifierType) 0, NULL + }, + GNOMEUIINFO_END +}; + +static GnomeUIInfo menubar1_uiinfo[] = +{ + { + GNOME_APP_UI_SUBTREE, N_("_File"), + NULL, + file1_menu_uiinfo, NULL, NULL, + GNOME_APP_PIXMAP_NONE, NULL, + 0, (GdkModifierType) 0, NULL + }, + { + GNOME_APP_UI_SUBTREE, N_("_Edit"), + NULL, + edit1_menu_uiinfo, NULL, NULL, + GNOME_APP_PIXMAP_NONE, NULL, + 0, (GdkModifierType) 0, NULL + }, + { + GNOME_APP_UI_SUBTREE, N_("_View"), + N_("Display Messages"), + item1_menu_uiinfo, NULL, NULL, + GNOME_APP_PIXMAP_NONE, NULL, + 0, (GdkModifierType) 0, NULL + }, + { + GNOME_APP_UI_SUBTREE, N_("_Settings"), + NULL, + settings1_menu_uiinfo, NULL, NULL, + GNOME_APP_PIXMAP_NONE, NULL, + 0, (GdkModifierType) 0, NULL + }, + { + GNOME_APP_UI_SUBTREE, N_("_Help"), + NULL, + help1_menu_uiinfo, NULL, NULL, + GNOME_APP_PIXMAP_NONE, NULL, + 0, (GdkModifierType) 0, NULL + }, + GNOMEUIINFO_END +}; + +GtkWidget* +create_app1 (void) +{ + GtkWidget *app1; + GtkWidget *vbox6; + GtkWidget *handlebox1; + GtkWidget *menubar1; + GtkWidget *handlebox2; + GtkWidget *toolbar2; + GtkWidget *tmp_toolbar_icon; + GtkWidget *connect_button1; + GtkWidget *run_button1; + GtkWidget *msgs_button; + GtkWidget *restore_button; + GtkWidget *label_button; + GtkWidget *vbox7; + GtkWidget *scrolledwindow3; + GtkWidget *text1; + GtkWidget *hbox18; + GtkWidget *label38; + GtkWidget *entry1; + GtkWidget *hbox19; + GtkWidget *frame1; + GtkWidget *label39; + GtkWidget *frame2; + GtkWidget *status1; + GtkTooltips *tooltips; + + tooltips = gtk_tooltips_new (); + + app1 = gtk_window_new (GTK_WINDOW_TOPLEVEL); + gtk_window_set_title (GTK_WINDOW (app1), _("Bacula Console")); + + vbox6 = gtk_vbox_new (FALSE, 0); + gtk_widget_show (vbox6); + gtk_container_add (GTK_CONTAINER (app1), vbox6); + + handlebox1 = gtk_handle_box_new (); + gtk_widget_show (handlebox1); + gtk_box_pack_start (GTK_BOX (vbox6), handlebox1, FALSE, TRUE, 0); + gtk_container_set_border_width (GTK_CONTAINER (handlebox1), 1); + + menubar1 = gtk_menu_bar_new (); + gtk_widget_show (menubar1); + gtk_container_add (GTK_CONTAINER (handlebox1), menubar1); + gnome_app_fill_menu (GTK_MENU_SHELL (menubar1), menubar1_uiinfo, + NULL, FALSE, 0); + + handlebox2 = gtk_handle_box_new (); + gtk_widget_show (handlebox2); + gtk_box_pack_start (GTK_BOX (vbox6), handlebox2, FALSE, TRUE, 0); + gtk_container_set_border_width (GTK_CONTAINER (handlebox2), 1); + + toolbar2 = gtk_toolbar_new (); + gtk_widget_show (toolbar2); + gtk_container_add (GTK_CONTAINER (handlebox2), toolbar2); + gtk_container_set_border_width (GTK_CONTAINER (toolbar2), 1); + gtk_toolbar_set_style (GTK_TOOLBAR (toolbar2), GTK_TOOLBAR_BOTH); + + tmp_toolbar_icon = gtk_image_new_from_stock ("gtk-new", gtk_toolbar_get_icon_size (GTK_TOOLBAR (toolbar2))); + connect_button1 = gtk_toolbar_append_element (GTK_TOOLBAR (toolbar2), + GTK_TOOLBAR_CHILD_BUTTON, + NULL, + _("Connect"), + _("Connect to Director"), NULL, + tmp_toolbar_icon, NULL, NULL); + gtk_label_set_use_underline (GTK_LABEL (((GtkToolbarChild*) (g_list_last (GTK_TOOLBAR (toolbar2)->children)->data))->label), TRUE); + gtk_widget_show (connect_button1); + + tmp_toolbar_icon = gtk_image_new_from_stock ("gtk-execute", gtk_toolbar_get_icon_size (GTK_TOOLBAR (toolbar2))); + run_button1 = gtk_toolbar_append_element (GTK_TOOLBAR (toolbar2), + GTK_TOOLBAR_CHILD_BUTTON, + NULL, + _("Run"), + _("Run a Job"), NULL, + tmp_toolbar_icon, NULL, NULL); + gtk_label_set_use_underline (GTK_LABEL (((GtkToolbarChild*) (g_list_last (GTK_TOOLBAR (toolbar2)->children)->data))->label), TRUE); + gtk_widget_show (run_button1); + + tmp_toolbar_icon = gtk_image_new_from_stock ("gtk-find", gtk_toolbar_get_icon_size (GTK_TOOLBAR (toolbar2))); + msgs_button = gtk_toolbar_append_element (GTK_TOOLBAR (toolbar2), + GTK_TOOLBAR_CHILD_BUTTON, + NULL, + _("Msgs"), + _("Display Messages"), NULL, + tmp_toolbar_icon, NULL, NULL); + gtk_label_set_use_underline (GTK_LABEL (((GtkToolbarChild*) (g_list_last (GTK_TOOLBAR (toolbar2)->children)->data))->label), TRUE); + gtk_widget_show (msgs_button); + + tmp_toolbar_icon = gtk_image_new_from_stock ("gtk-revert-to-saved", gtk_toolbar_get_icon_size (GTK_TOOLBAR (toolbar2))); + restore_button = gtk_toolbar_append_element (GTK_TOOLBAR (toolbar2), + GTK_TOOLBAR_CHILD_BUTTON, + NULL, + _("Restore"), + NULL, NULL, + tmp_toolbar_icon, NULL, NULL); + gtk_label_set_use_underline (GTK_LABEL (((GtkToolbarChild*) (g_list_last (GTK_TOOLBAR (toolbar2)->children)->data))->label), TRUE); + gtk_widget_show (restore_button); + + tmp_toolbar_icon = gtk_image_new_from_stock ("gtk-save-as", gtk_toolbar_get_icon_size (GTK_TOOLBAR (toolbar2))); + label_button = gtk_toolbar_append_element (GTK_TOOLBAR (toolbar2), + GTK_TOOLBAR_CHILD_BUTTON, + NULL, + _("Label"), + NULL, NULL, + tmp_toolbar_icon, NULL, NULL); + gtk_label_set_use_underline (GTK_LABEL (((GtkToolbarChild*) (g_list_last (GTK_TOOLBAR (toolbar2)->children)->data))->label), TRUE); + gtk_widget_show (label_button); + + vbox7 = gtk_vbox_new (FALSE, 0); + gtk_widget_show (vbox7); + gtk_box_pack_start (GTK_BOX (vbox6), vbox7, TRUE, TRUE, 0); + + scrolledwindow3 = gtk_scrolled_window_new (NULL, NULL); + gtk_widget_show (scrolledwindow3); + gtk_box_pack_start (GTK_BOX (vbox7), scrolledwindow3, TRUE, TRUE, 0); + GTK_WIDGET_UNSET_FLAGS (scrolledwindow3, GTK_CAN_FOCUS); + gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow3), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); + gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolledwindow3), GTK_SHADOW_IN); + + text1 = gtk_text_view_new (); + gtk_widget_show (text1); + gtk_container_add (GTK_CONTAINER (scrolledwindow3), text1); + GTK_WIDGET_UNSET_FLAGS (text1, GTK_CAN_FOCUS); + gtk_text_view_set_editable (GTK_TEXT_VIEW (text1), FALSE); + gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (text1), GTK_WRAP_WORD); + + hbox18 = gtk_hbox_new (FALSE, 0); + gtk_widget_show (hbox18); + gtk_box_pack_start (GTK_BOX (vbox7), hbox18, FALSE, TRUE, 0); + + label38 = gtk_label_new (_(" Command: ")); + gtk_widget_show (label38); + gtk_box_pack_start (GTK_BOX (hbox18), label38, FALSE, TRUE, 0); + + entry1 = gtk_entry_new (); + gtk_widget_show (entry1); + gtk_box_pack_start (GTK_BOX (hbox18), entry1, TRUE, TRUE, 0); + GTK_WIDGET_SET_FLAGS (entry1, GTK_CAN_DEFAULT); + gtk_tooltips_set_tip (tooltips, entry1, _("Enter Commands Here"), NULL); + + hbox19 = gtk_hbox_new (FALSE, 0); + gtk_widget_show (hbox19); + gtk_box_pack_start (GTK_BOX (vbox7), hbox19, FALSE, FALSE, 0); + + frame1 = gtk_frame_new (NULL); + gtk_widget_show (frame1); + gtk_box_pack_start (GTK_BOX (hbox19), frame1, FALSE, TRUE, 0); + + label39 = gtk_label_new (_(" Status: ")); + gtk_widget_show (label39); + gtk_container_add (GTK_CONTAINER (frame1), label39); + + frame2 = gtk_frame_new (NULL); + gtk_widget_show (frame2); + gtk_box_pack_start (GTK_BOX (hbox19), frame2, TRUE, TRUE, 0); + + status1 = gtk_label_new (""); + gtk_widget_show (status1); + gtk_container_add (GTK_CONTAINER (frame2), status1); + gtk_label_set_justify (GTK_LABEL (status1), GTK_JUSTIFY_LEFT); + gtk_misc_set_alignment (GTK_MISC (status1), 0, 0.5); + + g_signal_connect ((gpointer) app1, "delete_event", + G_CALLBACK (on_app1_delete_event), + NULL); + g_signal_connect ((gpointer) connect_button1, "clicked", + G_CALLBACK (on_connect_button_clicked), + NULL); + g_signal_connect ((gpointer) run_button1, "clicked", + G_CALLBACK (on_run_button_clicked), + NULL); + g_signal_connect ((gpointer) msgs_button, "clicked", + G_CALLBACK (on_msgs_button_clicked), + NULL); + g_signal_connect ((gpointer) restore_button, "clicked", + G_CALLBACK (on_restore_button_clicked), + NULL); + g_signal_connect ((gpointer) label_button, "clicked", + G_CALLBACK (on_label_button_clicked), + NULL); + g_signal_connect ((gpointer) entry1, "key_press_event", + G_CALLBACK (on_entry1_key_press_event), + NULL); + g_signal_connect ((gpointer) entry1, "key_release_event", + G_CALLBACK (on_entry1_key_release_event), + NULL); + + /* Store pointers to all widgets, for use by lookup_widget(). */ + GLADE_HOOKUP_OBJECT_NO_REF (app1, app1, "app1"); + GLADE_HOOKUP_OBJECT (app1, vbox6, "vbox6"); + GLADE_HOOKUP_OBJECT (app1, handlebox1, "handlebox1"); + GLADE_HOOKUP_OBJECT (app1, menubar1, "menubar1"); + GLADE_HOOKUP_OBJECT (app1, menubar1_uiinfo[0].widget, "file1"); + GLADE_HOOKUP_OBJECT (app1, file1_menu_uiinfo[0].widget, "connect1"); + GLADE_HOOKUP_OBJECT (app1, file1_menu_uiinfo[1].widget, "disconnect1"); + GLADE_HOOKUP_OBJECT (app1, file1_menu_uiinfo[2].widget, "menuitem4"); + GLADE_HOOKUP_OBJECT (app1, file1_menu_uiinfo[3].widget, "exit1"); + GLADE_HOOKUP_OBJECT (app1, menubar1_uiinfo[1].widget, "edit1"); + GLADE_HOOKUP_OBJECT (app1, edit1_menu_uiinfo[0].widget, "cut1"); + GLADE_HOOKUP_OBJECT (app1, edit1_menu_uiinfo[1].widget, "copy1"); + GLADE_HOOKUP_OBJECT (app1, edit1_menu_uiinfo[2].widget, "paste1"); + GLADE_HOOKUP_OBJECT (app1, edit1_menu_uiinfo[3].widget, "clear1"); + GLADE_HOOKUP_OBJECT (app1, edit1_menu_uiinfo[4].widget, "separator1"); + GLADE_HOOKUP_OBJECT (app1, menubar1_uiinfo[2].widget, "item1"); + GLADE_HOOKUP_OBJECT (app1, item1_menu_uiinfo[0].widget, "msgs"); + GLADE_HOOKUP_OBJECT (app1, menubar1_uiinfo[3].widget, "settings1"); + GLADE_HOOKUP_OBJECT (app1, settings1_menu_uiinfo[0].widget, "preferences1"); + GLADE_HOOKUP_OBJECT (app1, menubar1_uiinfo[4].widget, "help1"); + GLADE_HOOKUP_OBJECT (app1, help1_menu_uiinfo[0].widget, "about1"); + GLADE_HOOKUP_OBJECT (app1, handlebox2, "handlebox2"); + GLADE_HOOKUP_OBJECT (app1, toolbar2, "toolbar2"); + GLADE_HOOKUP_OBJECT (app1, connect_button1, "connect_button1"); + GLADE_HOOKUP_OBJECT (app1, run_button1, "run_button1"); + GLADE_HOOKUP_OBJECT (app1, msgs_button, "msgs_button"); + GLADE_HOOKUP_OBJECT (app1, restore_button, "restore_button"); + GLADE_HOOKUP_OBJECT (app1, label_button, "label_button"); + GLADE_HOOKUP_OBJECT (app1, vbox7, "vbox7"); + GLADE_HOOKUP_OBJECT (app1, scrolledwindow3, "scrolledwindow3"); + GLADE_HOOKUP_OBJECT (app1, text1, "text1"); + GLADE_HOOKUP_OBJECT (app1, hbox18, "hbox18"); + GLADE_HOOKUP_OBJECT (app1, label38, "label38"); + GLADE_HOOKUP_OBJECT (app1, entry1, "entry1"); + GLADE_HOOKUP_OBJECT (app1, hbox19, "hbox19"); + GLADE_HOOKUP_OBJECT (app1, frame1, "frame1"); + GLADE_HOOKUP_OBJECT (app1, label39, "label39"); + GLADE_HOOKUP_OBJECT (app1, frame2, "frame2"); + GLADE_HOOKUP_OBJECT (app1, status1, "status1"); + GLADE_HOOKUP_OBJECT_NO_REF (app1, tooltips, "tooltips"); + + gtk_widget_grab_focus (entry1); + gtk_widget_grab_default (entry1); + return app1; +} + +GtkWidget* +create_about1 (void) +{ + GtkWidget *about1; + GtkWidget *dialog_vbox5; + GtkWidget *vbox8; + GtkWidget *vbox9; + GtkWidget *about_head; + GtkWidget *hseparator1; + GtkWidget *copyright; + GtkWidget *authors; + GtkWidget *theme; + GtkWidget *dialog_action_area5; + GtkWidget *hbox20; + GtkWidget *label44; + GtkWidget *about_button; + + about1 = gtk_dialog_new (); + gtk_window_set_title (GTK_WINDOW (about1), _("About Bacula Console")); + gtk_window_set_modal (GTK_WINDOW (about1), TRUE); + + dialog_vbox5 = GTK_DIALOG (about1)->vbox; + gtk_widget_show (dialog_vbox5); + + vbox8 = gtk_vbox_new (FALSE, 0); + gtk_widget_show (vbox8); + gtk_box_pack_start (GTK_BOX (dialog_vbox5), vbox8, TRUE, TRUE, 0); + + vbox9 = gtk_vbox_new (FALSE, 0); + gtk_widget_show (vbox9); + gtk_box_pack_start (GTK_BOX (vbox8), vbox9, TRUE, TRUE, 0); + + about_head = gtk_label_new (_("Bacula Console 1.19 (28 April 2002)\n")); + gtk_widget_show (about_head); + gtk_box_pack_start (GTK_BOX (vbox9), about_head, FALSE, FALSE, 0); + + hseparator1 = gtk_hseparator_new (); + gtk_widget_show (hseparator1); + gtk_box_pack_start (GTK_BOX (vbox9), hseparator1, FALSE, FALSE, 0); + + copyright = gtk_label_new (_("Copyright (c) 1999 - 2002, Kern Sibbald and John Walker")); + gtk_widget_show (copyright); + gtk_box_pack_start (GTK_BOX (vbox9), copyright, TRUE, FALSE, 0); + gtk_label_set_justify (GTK_LABEL (copyright), GTK_JUSTIFY_LEFT); + gtk_misc_set_alignment (GTK_MISC (copyright), 0.1, 0.5); + + authors = gtk_label_new (_("Authors: Kern Sibbald and John Walker")); + gtk_widget_show (authors); + gtk_box_pack_start (GTK_BOX (vbox9), authors, TRUE, FALSE, 0); + gtk_label_set_justify (GTK_LABEL (authors), GTK_JUSTIFY_LEFT); + gtk_misc_set_alignment (GTK_MISC (authors), 0.0400001, 0.5); + + theme = gtk_label_new (_("It comes by night and sucks the essence from your computers")); + gtk_widget_show (theme); + gtk_box_pack_start (GTK_BOX (vbox9), theme, TRUE, FALSE, 0); + gtk_label_set_justify (GTK_LABEL (theme), GTK_JUSTIFY_LEFT); + gtk_misc_set_alignment (GTK_MISC (theme), 0.15, 0.5); + + dialog_action_area5 = GTK_DIALOG (about1)->action_area; + gtk_widget_show (dialog_action_area5); + gtk_button_box_set_layout (GTK_BUTTON_BOX (dialog_action_area5), GTK_BUTTONBOX_END); + + hbox20 = gtk_hbox_new (FALSE, 0); + gtk_widget_show (hbox20); + gtk_container_add (GTK_CONTAINER (dialog_action_area5), hbox20); + + label44 = gtk_label_new (""); + gtk_widget_show (label44); + gtk_box_pack_start (GTK_BOX (hbox20), label44, TRUE, FALSE, 0); + + about_button = gtk_button_new_from_stock ("gtk-ok"); + gtk_widget_show (about_button); + gtk_box_pack_start (GTK_BOX (hbox20), about_button, FALSE, FALSE, 0); + gtk_container_set_border_width (GTK_CONTAINER (about_button), 1); + GTK_WIDGET_SET_FLAGS (about_button, GTK_CAN_DEFAULT); + + g_signal_connect ((gpointer) about_button, "clicked", + G_CALLBACK (on_about_button_clicked), + NULL); + + /* Store pointers to all widgets, for use by lookup_widget(). */ + GLADE_HOOKUP_OBJECT_NO_REF (about1, about1, "about1"); + GLADE_HOOKUP_OBJECT_NO_REF (about1, dialog_vbox5, "dialog_vbox5"); + GLADE_HOOKUP_OBJECT (about1, vbox8, "vbox8"); + GLADE_HOOKUP_OBJECT (about1, vbox9, "vbox9"); + GLADE_HOOKUP_OBJECT (about1, about_head, "about_head"); + GLADE_HOOKUP_OBJECT (about1, hseparator1, "hseparator1"); + GLADE_HOOKUP_OBJECT (about1, copyright, "copyright"); + GLADE_HOOKUP_OBJECT (about1, authors, "authors"); + GLADE_HOOKUP_OBJECT (about1, theme, "theme"); + GLADE_HOOKUP_OBJECT_NO_REF (about1, dialog_action_area5, "dialog_action_area5"); + GLADE_HOOKUP_OBJECT (about1, hbox20, "hbox20"); + GLADE_HOOKUP_OBJECT (about1, label44, "label44"); + GLADE_HOOKUP_OBJECT (about1, about_button, "about_button"); + + return about1; +} + +GtkWidget* +create_SelectDirectorDialog (void) +{ + GtkWidget *SelectDirectorDialog; + GtkWidget *dialog_vbox6; + GtkWidget *vbox10; + GtkWidget *label48; + GtkWidget *label47; + GtkWidget *combo1; + GList *combo1_items = NULL; + GtkWidget *dirselect; + GtkWidget *dialog_action_area2; + GtkWidget *hbox21; + GtkWidget *button11; + GtkWidget *label46; + GtkWidget *button13; + + SelectDirectorDialog = gtk_dialog_new (); + gtk_window_set_title (GTK_WINDOW (SelectDirectorDialog), _("Select Director")); + gtk_window_set_modal (GTK_WINDOW (SelectDirectorDialog), TRUE); + + dialog_vbox6 = GTK_DIALOG (SelectDirectorDialog)->vbox; + gtk_widget_show (dialog_vbox6); + + vbox10 = gtk_vbox_new (FALSE, 0); + gtk_widget_show (vbox10); + gtk_box_pack_start (GTK_BOX (dialog_vbox6), vbox10, TRUE, TRUE, 0); + + label48 = gtk_label_new (""); + gtk_widget_show (label48); + gtk_box_pack_start (GTK_BOX (vbox10), label48, FALSE, FALSE, 0); + gtk_misc_set_alignment (GTK_MISC (label48), 0.48, 0.46); + + label47 = gtk_label_new (_("Select Director")); + gtk_widget_show (label47); + gtk_box_pack_start (GTK_BOX (vbox10), label47, FALSE, FALSE, 0); + + combo1 = gtk_combo_new (); + g_object_set_data (G_OBJECT (GTK_COMBO (combo1)->popwin), + "GladeParentKey", combo1); + gtk_widget_show (combo1); + gtk_box_pack_start (GTK_BOX (vbox10), combo1, FALSE, FALSE, 0); + gtk_container_set_border_width (GTK_CONTAINER (combo1), 6); + combo1_items = g_list_append (combo1_items, (gpointer) ""); + gtk_combo_set_popdown_strings (GTK_COMBO (combo1), combo1_items); + g_list_free (combo1_items); + + dirselect = GTK_COMBO (combo1)->entry; + gtk_widget_show (dirselect); + + dialog_action_area2 = GTK_DIALOG (SelectDirectorDialog)->action_area; + gtk_widget_show (dialog_action_area2); + gtk_button_box_set_layout (GTK_BUTTON_BOX (dialog_action_area2), GTK_BUTTONBOX_END); + + hbox21 = gtk_hbox_new (FALSE, 0); + gtk_widget_show (hbox21); + gtk_container_add (GTK_CONTAINER (dialog_action_area2), hbox21); + + button11 = gtk_button_new_from_stock ("gtk-ok"); + gtk_widget_show (button11); + gtk_box_pack_start (GTK_BOX (hbox21), button11, FALSE, FALSE, 0); + + label46 = gtk_label_new (_(" ")); + gtk_widget_show (label46); + gtk_box_pack_start (GTK_BOX (hbox21), label46, FALSE, FALSE, 0); + gtk_misc_set_padding (GTK_MISC (label46), 2, 0); + + button13 = gtk_button_new_from_stock ("gtk-cancel"); + gtk_widget_show (button13); + gtk_box_pack_start (GTK_BOX (hbox21), button13, FALSE, FALSE, 0); + + g_signal_connect ((gpointer) button11, "clicked", + G_CALLBACK (on_select_director_OK_clicked), + NULL); + g_signal_connect ((gpointer) button13, "clicked", + G_CALLBACK (on_select_director_cancel_clicked), + NULL); + + /* Store pointers to all widgets, for use by lookup_widget(). */ + GLADE_HOOKUP_OBJECT_NO_REF (SelectDirectorDialog, SelectDirectorDialog, "SelectDirectorDialog"); + GLADE_HOOKUP_OBJECT_NO_REF (SelectDirectorDialog, dialog_vbox6, "dialog_vbox6"); + GLADE_HOOKUP_OBJECT (SelectDirectorDialog, vbox10, "vbox10"); + GLADE_HOOKUP_OBJECT (SelectDirectorDialog, label48, "label48"); + GLADE_HOOKUP_OBJECT (SelectDirectorDialog, label47, "label47"); + GLADE_HOOKUP_OBJECT (SelectDirectorDialog, combo1, "combo1"); + GLADE_HOOKUP_OBJECT (SelectDirectorDialog, dirselect, "dirselect"); + GLADE_HOOKUP_OBJECT_NO_REF (SelectDirectorDialog, dialog_action_area2, "dialog_action_area2"); + GLADE_HOOKUP_OBJECT (SelectDirectorDialog, hbox21, "hbox21"); + GLADE_HOOKUP_OBJECT (SelectDirectorDialog, button11, "button11"); + GLADE_HOOKUP_OBJECT (SelectDirectorDialog, label46, "label46"); + GLADE_HOOKUP_OBJECT (SelectDirectorDialog, button13, "button13"); + + return SelectDirectorDialog; +} + +GtkWidget* +create_RunDialog (void) +{ + GtkWidget *RunDialog; + GtkWidget *dialog_vbox7; + GtkWidget *vbox11; + GtkWidget *vbox12; + GtkWidget *label62; + GtkWidget *hbox28; + GtkWidget *hbox29; + GtkWidget *label63; + GtkWidget *combo_job; + GList *combo_job_items = NULL; + GtkWidget *entry_job; + GtkWidget *label64; + GtkWidget *combo_type; + GList *combo_type_items = NULL; + GtkWidget *entry_type; + GtkWidget *label65; + GtkWidget *hbox30; + GtkWidget *label66; + GtkWidget *combo_client; + GList *combo_client_items = NULL; + GtkWidget *entry_client; + GtkWidget *label67; + GtkWidget *hbox31; + GtkWidget *label68; + GtkWidget *combo_fileset; + GList *combo_fileset_items = NULL; + GtkWidget *entry_fileset; + GtkWidget *view_fileset_button; + GtkWidget *label69; + GtkWidget *hbox32; + GtkWidget *label70; + GtkWidget *combo_level; + GList *combo_level_items = NULL; + GtkWidget *entry_level; + GtkWidget *label71; + GtkWidget *hbox33; + GtkWidget *label72; + GtkWidget *combo_pool; + GList *combo_pool_items = NULL; + GtkWidget *entry_pool; + GtkWidget *label73; + GtkWidget *hbox39; + GtkWidget *label96; + GtkWidget *combo_storage; + GList *combo_storage_items = NULL; + GtkWidget *entry_storage; + GtkWidget *label97; + GtkWidget *hbox40; + GtkWidget *label98; + GtkWidget *combo_messages; + GList *combo_messages_items = NULL; + GtkWidget *entry_messages; + GtkWidget *label99; + GtkWidget *hbox34; + GtkWidget *label77; + GtkWidget *entry_where; + GtkWidget *label78; + GtkWidget *hbox41; + GtkWidget *label100; + GtkWidget *entry_when; + GtkWidget *label101; + GtkWidget *label84; + GtkWidget *dialog_action_area6; + GtkWidget *hbuttonbox1; + GtkWidget *run_ok; + GtkWidget *run_cancel; + + RunDialog = gtk_dialog_new (); + gtk_window_set_title (GTK_WINDOW (RunDialog), _("Run a Job")); + + dialog_vbox7 = GTK_DIALOG (RunDialog)->vbox; + gtk_widget_show (dialog_vbox7); + + vbox11 = gtk_vbox_new (FALSE, 0); + gtk_widget_show (vbox11); + gtk_box_pack_start (GTK_BOX (dialog_vbox7), vbox11, TRUE, TRUE, 0); + + vbox12 = gtk_vbox_new (FALSE, 0); + gtk_widget_show (vbox12); + gtk_box_pack_start (GTK_BOX (vbox11), vbox12, TRUE, TRUE, 0); + + label62 = gtk_label_new (_("Run a Job")); + gtk_widget_show (label62); + gtk_box_pack_start (GTK_BOX (vbox12), label62, FALSE, FALSE, 2); + gtk_misc_set_padding (GTK_MISC (label62), 0, 9); + + hbox28 = gtk_hbox_new (FALSE, 0); + gtk_widget_show (hbox28); + gtk_box_pack_start (GTK_BOX (vbox12), hbox28, FALSE, FALSE, 2); + + hbox29 = gtk_hbox_new (FALSE, 0); + gtk_widget_show (hbox29); + gtk_box_pack_start (GTK_BOX (hbox28), hbox29, TRUE, TRUE, 0); + + label63 = gtk_label_new (_("Job:")); + gtk_widget_show (label63); + gtk_box_pack_start (GTK_BOX (hbox29), label63, FALSE, FALSE, 0); + gtk_label_set_justify (GTK_LABEL (label63), GTK_JUSTIFY_RIGHT); + + combo_job = gtk_combo_new (); + g_object_set_data (G_OBJECT (GTK_COMBO (combo_job)->popwin), + "GladeParentKey", combo_job); + gtk_widget_show (combo_job); + gtk_box_pack_start (GTK_BOX (hbox29), combo_job, TRUE, TRUE, 1); + gtk_combo_set_value_in_list (GTK_COMBO (combo_job), TRUE, FALSE); + combo_job_items = g_list_append (combo_job_items, (gpointer) ""); + gtk_combo_set_popdown_strings (GTK_COMBO (combo_job), combo_job_items); + g_list_free (combo_job_items); + + entry_job = GTK_COMBO (combo_job)->entry; + gtk_widget_show (entry_job); + gtk_editable_set_editable (GTK_EDITABLE (entry_job), FALSE); + + label64 = gtk_label_new (_(" Type:")); + gtk_widget_show (label64); + gtk_box_pack_start (GTK_BOX (hbox29), label64, FALSE, FALSE, 0); + + combo_type = gtk_combo_new (); + g_object_set_data (G_OBJECT (GTK_COMBO (combo_type)->popwin), + "GladeParentKey", combo_type); + gtk_widget_show (combo_type); + gtk_box_pack_start (GTK_BOX (hbox29), combo_type, FALSE, FALSE, 6); + gtk_combo_set_value_in_list (GTK_COMBO (combo_type), TRUE, FALSE); + combo_type_items = g_list_append (combo_type_items, (gpointer) ""); + gtk_combo_set_popdown_strings (GTK_COMBO (combo_type), combo_type_items); + g_list_free (combo_type_items); + + entry_type = GTK_COMBO (combo_type)->entry; + gtk_widget_show (entry_type); + gtk_editable_set_editable (GTK_EDITABLE (entry_type), FALSE); + + label65 = gtk_label_new (_(" ")); + gtk_widget_show (label65); + gtk_box_pack_start (GTK_BOX (hbox28), label65, FALSE, FALSE, 30); + + hbox30 = gtk_hbox_new (FALSE, 0); + gtk_widget_show (hbox30); + gtk_box_pack_start (GTK_BOX (vbox12), hbox30, TRUE, TRUE, 0); + + label66 = gtk_label_new (_("Client:")); + gtk_widget_show (label66); + gtk_box_pack_start (GTK_BOX (hbox30), label66, FALSE, FALSE, 0); + gtk_label_set_justify (GTK_LABEL (label66), GTK_JUSTIFY_RIGHT); + + combo_client = gtk_combo_new (); + g_object_set_data (G_OBJECT (GTK_COMBO (combo_client)->popwin), + "GladeParentKey", combo_client); + gtk_widget_show (combo_client); + gtk_box_pack_start (GTK_BOX (hbox30), combo_client, TRUE, TRUE, 1); + gtk_combo_set_value_in_list (GTK_COMBO (combo_client), TRUE, FALSE); + combo_client_items = g_list_append (combo_client_items, (gpointer) ""); + gtk_combo_set_popdown_strings (GTK_COMBO (combo_client), combo_client_items); + g_list_free (combo_client_items); + + entry_client = GTK_COMBO (combo_client)->entry; + gtk_widget_show (entry_client); + gtk_editable_set_editable (GTK_EDITABLE (entry_client), FALSE); + + label67 = gtk_label_new (_(" ")); + gtk_widget_show (label67); + gtk_box_pack_start (GTK_BOX (hbox30), label67, FALSE, FALSE, 123); + + hbox31 = gtk_hbox_new (FALSE, 0); + gtk_widget_show (hbox31); + gtk_box_pack_start (GTK_BOX (vbox12), hbox31, TRUE, TRUE, 2); + + label68 = gtk_label_new (_("FileSet: ")); + gtk_widget_show (label68); + gtk_box_pack_start (GTK_BOX (hbox31), label68, FALSE, FALSE, 0); + gtk_label_set_justify (GTK_LABEL (label68), GTK_JUSTIFY_RIGHT); + + combo_fileset = gtk_combo_new (); + g_object_set_data (G_OBJECT (GTK_COMBO (combo_fileset)->popwin), + "GladeParentKey", combo_fileset); + gtk_widget_show (combo_fileset); + gtk_box_pack_start (GTK_BOX (hbox31), combo_fileset, TRUE, TRUE, 0); + gtk_combo_set_value_in_list (GTK_COMBO (combo_fileset), TRUE, FALSE); + combo_fileset_items = g_list_append (combo_fileset_items, (gpointer) ""); + gtk_combo_set_popdown_strings (GTK_COMBO (combo_fileset), combo_fileset_items); + g_list_free (combo_fileset_items); + + entry_fileset = GTK_COMBO (combo_fileset)->entry; + gtk_widget_show (entry_fileset); + gtk_editable_set_editable (GTK_EDITABLE (entry_fileset), FALSE); + + view_fileset_button = gtk_button_new_with_mnemonic (_(" View FileSet ")); + gtk_widget_show (view_fileset_button); + gtk_box_pack_start (GTK_BOX (hbox31), view_fileset_button, FALSE, TRUE, 10); + + label69 = gtk_label_new (_(" ")); + gtk_widget_show (label69); + gtk_box_pack_start (GTK_BOX (hbox31), label69, FALSE, FALSE, 65); + + hbox32 = gtk_hbox_new (FALSE, 0); + gtk_widget_show (hbox32); + gtk_box_pack_start (GTK_BOX (vbox12), hbox32, TRUE, TRUE, 2); + + label70 = gtk_label_new (_("Level:")); + gtk_widget_show (label70); + gtk_box_pack_start (GTK_BOX (hbox32), label70, FALSE, FALSE, 0); + gtk_label_set_justify (GTK_LABEL (label70), GTK_JUSTIFY_RIGHT); + + combo_level = gtk_combo_new (); + g_object_set_data (G_OBJECT (GTK_COMBO (combo_level)->popwin), + "GladeParentKey", combo_level); + gtk_widget_show (combo_level); + gtk_box_pack_start (GTK_BOX (hbox32), combo_level, TRUE, TRUE, 0); + gtk_combo_set_value_in_list (GTK_COMBO (combo_level), TRUE, FALSE); + combo_level_items = g_list_append (combo_level_items, (gpointer) ""); + combo_level_items = g_list_append (combo_level_items, (gpointer) ""); + gtk_combo_set_popdown_strings (GTK_COMBO (combo_level), combo_level_items); + g_list_free (combo_level_items); + + entry_level = GTK_COMBO (combo_level)->entry; + gtk_widget_show (entry_level); + gtk_editable_set_editable (GTK_EDITABLE (entry_level), FALSE); + + label71 = gtk_label_new (_(" ")); + gtk_widget_show (label71); + gtk_box_pack_start (GTK_BOX (hbox32), label71, FALSE, FALSE, 100); + + hbox33 = gtk_hbox_new (FALSE, 0); + gtk_widget_show (hbox33); + gtk_box_pack_start (GTK_BOX (vbox12), hbox33, TRUE, TRUE, 2); + + label72 = gtk_label_new (_("Pool:")); + gtk_widget_show (label72); + gtk_box_pack_start (GTK_BOX (hbox33), label72, FALSE, FALSE, 0); + + combo_pool = gtk_combo_new (); + g_object_set_data (G_OBJECT (GTK_COMBO (combo_pool)->popwin), + "GladeParentKey", combo_pool); + gtk_widget_show (combo_pool); + gtk_box_pack_start (GTK_BOX (hbox33), combo_pool, TRUE, TRUE, 0); + gtk_combo_set_value_in_list (GTK_COMBO (combo_pool), TRUE, FALSE); + combo_pool_items = g_list_append (combo_pool_items, (gpointer) ""); + combo_pool_items = g_list_append (combo_pool_items, (gpointer) ""); + gtk_combo_set_popdown_strings (GTK_COMBO (combo_pool), combo_pool_items); + g_list_free (combo_pool_items); + + entry_pool = GTK_COMBO (combo_pool)->entry; + gtk_widget_show (entry_pool); + gtk_editable_set_editable (GTK_EDITABLE (entry_pool), FALSE); + + label73 = gtk_label_new (_(" ")); + gtk_widget_show (label73); + gtk_box_pack_start (GTK_BOX (hbox33), label73, FALSE, FALSE, 120); + + hbox39 = gtk_hbox_new (FALSE, 0); + gtk_widget_show (hbox39); + gtk_box_pack_start (GTK_BOX (vbox12), hbox39, TRUE, TRUE, 0); + + label96 = gtk_label_new (_("Storage:")); + gtk_widget_show (label96); + gtk_box_pack_start (GTK_BOX (hbox39), label96, FALSE, FALSE, 0); + + combo_storage = gtk_combo_new (); + g_object_set_data (G_OBJECT (GTK_COMBO (combo_storage)->popwin), + "GladeParentKey", combo_storage); + gtk_widget_show (combo_storage); + gtk_box_pack_start (GTK_BOX (hbox39), combo_storage, TRUE, TRUE, 0); + gtk_combo_set_value_in_list (GTK_COMBO (combo_storage), TRUE, FALSE); + combo_storage_items = g_list_append (combo_storage_items, (gpointer) ""); + combo_storage_items = g_list_append (combo_storage_items, (gpointer) ""); + gtk_combo_set_popdown_strings (GTK_COMBO (combo_storage), combo_storage_items); + g_list_free (combo_storage_items); + + entry_storage = GTK_COMBO (combo_storage)->entry; + gtk_widget_show (entry_storage); + gtk_editable_set_editable (GTK_EDITABLE (entry_storage), FALSE); + + label97 = gtk_label_new (_(" ")); + gtk_widget_show (label97); + gtk_box_pack_start (GTK_BOX (hbox39), label97, FALSE, FALSE, 120); + + hbox40 = gtk_hbox_new (FALSE, 0); + gtk_widget_show (hbox40); + gtk_box_pack_start (GTK_BOX (vbox12), hbox40, TRUE, TRUE, 0); + + label98 = gtk_label_new (_("Messages:")); + gtk_widget_show (label98); + gtk_box_pack_start (GTK_BOX (hbox40), label98, FALSE, FALSE, 0); + + combo_messages = gtk_combo_new (); + g_object_set_data (G_OBJECT (GTK_COMBO (combo_messages)->popwin), + "GladeParentKey", combo_messages); + gtk_widget_show (combo_messages); + gtk_box_pack_start (GTK_BOX (hbox40), combo_messages, TRUE, TRUE, 0); + gtk_combo_set_value_in_list (GTK_COMBO (combo_messages), TRUE, FALSE); + combo_messages_items = g_list_append (combo_messages_items, (gpointer) ""); + gtk_combo_set_popdown_strings (GTK_COMBO (combo_messages), combo_messages_items); + g_list_free (combo_messages_items); + + entry_messages = GTK_COMBO (combo_messages)->entry; + gtk_widget_show (entry_messages); + gtk_editable_set_editable (GTK_EDITABLE (entry_messages), FALSE); + + label99 = gtk_label_new (_(" ")); + gtk_widget_show (label99); + gtk_box_pack_start (GTK_BOX (hbox40), label99, FALSE, FALSE, 120); + + hbox34 = gtk_hbox_new (FALSE, 0); + gtk_widget_show (hbox34); + gtk_box_pack_start (GTK_BOX (vbox12), hbox34, TRUE, TRUE, 2); + + label77 = gtk_label_new (_("Where: ")); + gtk_widget_show (label77); + gtk_box_pack_start (GTK_BOX (hbox34), label77, FALSE, FALSE, 0); + + entry_where = gtk_entry_new (); + gtk_widget_show (entry_where); + gtk_box_pack_start (GTK_BOX (hbox34), entry_where, TRUE, TRUE, 0); + + label78 = gtk_label_new (_(" ")); + gtk_widget_show (label78); + gtk_box_pack_start (GTK_BOX (hbox34), label78, FALSE, FALSE, 120); + + hbox41 = gtk_hbox_new (FALSE, 0); + gtk_widget_show (hbox41); + gtk_box_pack_start (GTK_BOX (vbox11), hbox41, TRUE, TRUE, 0); + + label100 = gtk_label_new (_("When:")); + gtk_widget_show (label100); + gtk_box_pack_start (GTK_BOX (hbox41), label100, FALSE, FALSE, 0); + + entry_when = gtk_entry_new (); + gtk_widget_show (entry_when); + gtk_box_pack_start (GTK_BOX (hbox41), entry_when, TRUE, TRUE, 0); + + label101 = gtk_label_new (_(" ")); + gtk_widget_show (label101); + gtk_box_pack_start (GTK_BOX (hbox41), label101, FALSE, FALSE, 120); + + label84 = gtk_label_new (_(" ")); + gtk_widget_show (label84); + gtk_box_pack_start (GTK_BOX (vbox11), label84, FALSE, FALSE, 0); + + dialog_action_area6 = GTK_DIALOG (RunDialog)->action_area; + gtk_widget_show (dialog_action_area6); + gtk_button_box_set_layout (GTK_BUTTON_BOX (dialog_action_area6), GTK_BUTTONBOX_END); + + hbuttonbox1 = gtk_hbutton_box_new (); + gtk_widget_show (hbuttonbox1); + gtk_container_add (GTK_CONTAINER (dialog_action_area6), hbuttonbox1); + gtk_button_box_set_layout (GTK_BUTTON_BOX (hbuttonbox1), GTK_BUTTONBOX_END); + gtk_box_set_spacing (GTK_BOX (hbuttonbox1), 8); + + run_ok = gtk_button_new_from_stock ("gtk-ok"); + gtk_widget_show (run_ok); + gtk_container_add (GTK_CONTAINER (hbuttonbox1), run_ok); + GTK_WIDGET_SET_FLAGS (run_ok, GTK_CAN_DEFAULT); + + run_cancel = gtk_button_new_from_stock ("gtk-cancel"); + gtk_widget_show (run_cancel); + gtk_container_add (GTK_CONTAINER (hbuttonbox1), run_cancel); + GTK_WIDGET_SET_FLAGS (run_cancel, GTK_CAN_DEFAULT); + + g_signal_connect ((gpointer) entry_job, "changed", + G_CALLBACK (on_entry_job_changed), + NULL); + g_signal_connect ((gpointer) view_fileset_button, "clicked", + G_CALLBACK (on_view_fileset_clicked), + NULL); + g_signal_connect ((gpointer) run_ok, "clicked", + G_CALLBACK (on_run_ok_clicked), + NULL); + g_signal_connect ((gpointer) run_cancel, "clicked", + G_CALLBACK (on_run_cancel_clicked), + NULL); + + /* Store pointers to all widgets, for use by lookup_widget(). */ + GLADE_HOOKUP_OBJECT_NO_REF (RunDialog, RunDialog, "RunDialog"); + GLADE_HOOKUP_OBJECT_NO_REF (RunDialog, dialog_vbox7, "dialog_vbox7"); + GLADE_HOOKUP_OBJECT (RunDialog, vbox11, "vbox11"); + GLADE_HOOKUP_OBJECT (RunDialog, vbox12, "vbox12"); + GLADE_HOOKUP_OBJECT (RunDialog, label62, "label62"); + GLADE_HOOKUP_OBJECT (RunDialog, hbox28, "hbox28"); + GLADE_HOOKUP_OBJECT (RunDialog, hbox29, "hbox29"); + GLADE_HOOKUP_OBJECT (RunDialog, label63, "label63"); + GLADE_HOOKUP_OBJECT (RunDialog, combo_job, "combo_job"); + GLADE_HOOKUP_OBJECT (RunDialog, entry_job, "entry_job"); + GLADE_HOOKUP_OBJECT (RunDialog, label64, "label64"); + GLADE_HOOKUP_OBJECT (RunDialog, combo_type, "combo_type"); + GLADE_HOOKUP_OBJECT (RunDialog, entry_type, "entry_type"); + GLADE_HOOKUP_OBJECT (RunDialog, label65, "label65"); + GLADE_HOOKUP_OBJECT (RunDialog, hbox30, "hbox30"); + GLADE_HOOKUP_OBJECT (RunDialog, label66, "label66"); + GLADE_HOOKUP_OBJECT (RunDialog, combo_client, "combo_client"); + GLADE_HOOKUP_OBJECT (RunDialog, entry_client, "entry_client"); + GLADE_HOOKUP_OBJECT (RunDialog, label67, "label67"); + GLADE_HOOKUP_OBJECT (RunDialog, hbox31, "hbox31"); + GLADE_HOOKUP_OBJECT (RunDialog, label68, "label68"); + GLADE_HOOKUP_OBJECT (RunDialog, combo_fileset, "combo_fileset"); + GLADE_HOOKUP_OBJECT (RunDialog, entry_fileset, "entry_fileset"); + GLADE_HOOKUP_OBJECT (RunDialog, view_fileset_button, "view_fileset_button"); + GLADE_HOOKUP_OBJECT (RunDialog, label69, "label69"); + GLADE_HOOKUP_OBJECT (RunDialog, hbox32, "hbox32"); + GLADE_HOOKUP_OBJECT (RunDialog, label70, "label70"); + GLADE_HOOKUP_OBJECT (RunDialog, combo_level, "combo_level"); + GLADE_HOOKUP_OBJECT (RunDialog, entry_level, "entry_level"); + GLADE_HOOKUP_OBJECT (RunDialog, label71, "label71"); + GLADE_HOOKUP_OBJECT (RunDialog, hbox33, "hbox33"); + GLADE_HOOKUP_OBJECT (RunDialog, label72, "label72"); + GLADE_HOOKUP_OBJECT (RunDialog, combo_pool, "combo_pool"); + GLADE_HOOKUP_OBJECT (RunDialog, entry_pool, "entry_pool"); + GLADE_HOOKUP_OBJECT (RunDialog, label73, "label73"); + GLADE_HOOKUP_OBJECT (RunDialog, hbox39, "hbox39"); + GLADE_HOOKUP_OBJECT (RunDialog, label96, "label96"); + GLADE_HOOKUP_OBJECT (RunDialog, combo_storage, "combo_storage"); + GLADE_HOOKUP_OBJECT (RunDialog, entry_storage, "entry_storage"); + GLADE_HOOKUP_OBJECT (RunDialog, label97, "label97"); + GLADE_HOOKUP_OBJECT (RunDialog, hbox40, "hbox40"); + GLADE_HOOKUP_OBJECT (RunDialog, label98, "label98"); + GLADE_HOOKUP_OBJECT (RunDialog, combo_messages, "combo_messages"); + GLADE_HOOKUP_OBJECT (RunDialog, entry_messages, "entry_messages"); + GLADE_HOOKUP_OBJECT (RunDialog, label99, "label99"); + GLADE_HOOKUP_OBJECT (RunDialog, hbox34, "hbox34"); + GLADE_HOOKUP_OBJECT (RunDialog, label77, "label77"); + GLADE_HOOKUP_OBJECT (RunDialog, entry_where, "entry_where"); + GLADE_HOOKUP_OBJECT (RunDialog, label78, "label78"); + GLADE_HOOKUP_OBJECT (RunDialog, hbox41, "hbox41"); + GLADE_HOOKUP_OBJECT (RunDialog, label100, "label100"); + GLADE_HOOKUP_OBJECT (RunDialog, entry_when, "entry_when"); + GLADE_HOOKUP_OBJECT (RunDialog, label101, "label101"); + GLADE_HOOKUP_OBJECT (RunDialog, label84, "label84"); + GLADE_HOOKUP_OBJECT_NO_REF (RunDialog, dialog_action_area6, "dialog_action_area6"); + GLADE_HOOKUP_OBJECT (RunDialog, hbuttonbox1, "hbuttonbox1"); + GLADE_HOOKUP_OBJECT (RunDialog, run_ok, "run_ok"); + GLADE_HOOKUP_OBJECT (RunDialog, run_cancel, "run_cancel"); + + return RunDialog; +} + +GtkWidget* +create_restore_files (void) +{ + GtkWidget *restore_files; + GtkWidget *vbox13; + GtkWidget *scrolledwindow4; + GtkWidget *ctree2; + GtkWidget *hbox38; + GtkWidget *label88; + GtkWidget *entry25; + GtkWidget *hbox44; + GtkWidget *label105; + GtkWidget *restore_file; + GtkTooltips *tooltips; + + tooltips = gtk_tooltips_new (); + + restore_files = gtk_window_new (GTK_WINDOW_TOPLEVEL); + gtk_window_set_title (GTK_WINDOW (restore_files), _("Restore File Selection")); + gtk_window_set_modal (GTK_WINDOW (restore_files), TRUE); + + vbox13 = gtk_vbox_new (FALSE, 0); + gtk_widget_show (vbox13); + gtk_container_add (GTK_CONTAINER (restore_files), vbox13); + + scrolledwindow4 = gtk_scrolled_window_new (NULL, NULL); + gtk_widget_show (scrolledwindow4); + gtk_box_pack_start (GTK_BOX (vbox13), scrolledwindow4, TRUE, TRUE, 0); + GTK_WIDGET_UNSET_FLAGS (scrolledwindow4, GTK_CAN_FOCUS); + gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolledwindow4), GTK_SHADOW_IN); + + ctree2 = gtk_tree_view_new (); + gtk_widget_show (ctree2); + gtk_container_add (GTK_CONTAINER (scrolledwindow4), ctree2); + + hbox38 = gtk_hbox_new (FALSE, 0); + gtk_widget_show (hbox38); + gtk_box_pack_start (GTK_BOX (vbox13), hbox38, FALSE, TRUE, 0); + + label88 = gtk_label_new (_(" cwd:")); + gtk_widget_show (label88); + gtk_box_pack_start (GTK_BOX (hbox38), label88, FALSE, TRUE, 0); + + entry25 = gtk_entry_new (); + gtk_widget_show (entry25); + gtk_box_pack_start (GTK_BOX (hbox38), entry25, TRUE, TRUE, 0); + GTK_WIDGET_SET_FLAGS (entry25, GTK_CAN_DEFAULT); + gtk_tooltips_set_tip (tooltips, entry25, _("Enter Commands Here"), NULL); + + hbox44 = gtk_hbox_new (FALSE, 0); + gtk_widget_show (hbox44); + gtk_box_pack_start (GTK_BOX (vbox13), hbox44, FALSE, TRUE, 0); + + label105 = gtk_label_new (_(" ")); + gtk_widget_show (label105); + gtk_box_pack_start (GTK_BOX (hbox44), label105, TRUE, FALSE, 0); + gtk_label_set_justify (GTK_LABEL (label105), GTK_JUSTIFY_FILL); + gtk_misc_set_padding (GTK_MISC (label105), 59, 0); + + restore_file = gtk_button_new_from_stock ("gtk-ok"); + gtk_widget_show (restore_file); + gtk_box_pack_start (GTK_BOX (hbox44), restore_file, TRUE, FALSE, 0); + gtk_container_set_border_width (GTK_CONTAINER (restore_file), 9); + + g_signal_connect ((gpointer) entry25, "key_press_event", + G_CALLBACK (on_entry1_key_press_event), + NULL); + g_signal_connect ((gpointer) entry25, "key_release_event", + G_CALLBACK (on_entry1_key_release_event), + NULL); + g_signal_connect ((gpointer) restore_file, "clicked", + G_CALLBACK (on_restore_file_clicked), + NULL); + + /* Store pointers to all widgets, for use by lookup_widget(). */ + GLADE_HOOKUP_OBJECT_NO_REF (restore_files, restore_files, "restore_files"); + GLADE_HOOKUP_OBJECT (restore_files, vbox13, "vbox13"); + GLADE_HOOKUP_OBJECT (restore_files, scrolledwindow4, "scrolledwindow4"); + GLADE_HOOKUP_OBJECT (restore_files, ctree2, "ctree2"); + GLADE_HOOKUP_OBJECT (restore_files, hbox38, "hbox38"); + GLADE_HOOKUP_OBJECT (restore_files, label88, "label88"); + GLADE_HOOKUP_OBJECT (restore_files, entry25, "entry25"); + GLADE_HOOKUP_OBJECT (restore_files, hbox44, "hbox44"); + GLADE_HOOKUP_OBJECT (restore_files, label105, "label105"); + GLADE_HOOKUP_OBJECT (restore_files, restore_file, "restore_file"); + GLADE_HOOKUP_OBJECT_NO_REF (restore_files, tooltips, "tooltips"); + + gtk_widget_grab_focus (entry25); + gtk_widget_grab_default (entry25); + return restore_files; +} + +GtkWidget* +create_restore_dialog (void) +{ + GtkWidget *restore_dialog; + GtkWidget *dialog_vbox8; + GtkWidget *hbox42; + GtkWidget *frame3; + GtkWidget *hbox43; + GtkWidget *label102; + GtkWidget *vbox15; + GtkWidget *label103; + GtkWidget *rb_most_recent; + GSList *rb_most_recent_group = NULL; + GtkWidget *rb_jobs; + GSList *rb_jobs_group = NULL; + GtkWidget *rb_file; + GSList *rb_file_group = NULL; + GtkWidget *label104; + GtkWidget *label106; + GtkWidget *vbox14; + GtkWidget *apply_button; + GtkWidget *dialog_action_area7; + GtkWidget *hbuttonbox2; + GtkWidget *restore_ok; + GtkWidget *restore_cancel; + + restore_dialog = gtk_dialog_new (); + gtk_window_set_title (GTK_WINDOW (restore_dialog), _("Restore Files")); + gtk_window_set_modal (GTK_WINDOW (restore_dialog), TRUE); + + dialog_vbox8 = GTK_DIALOG (restore_dialog)->vbox; + gtk_widget_show (dialog_vbox8); + + hbox42 = gtk_hbox_new (FALSE, 0); + gtk_widget_show (hbox42); + gtk_box_pack_start (GTK_BOX (dialog_vbox8), hbox42, TRUE, TRUE, 0); + + frame3 = gtk_frame_new (NULL); + gtk_widget_show (frame3); + gtk_box_pack_start (GTK_BOX (hbox42), frame3, TRUE, TRUE, 0); + gtk_container_set_border_width (GTK_CONTAINER (frame3), 8); + + hbox43 = gtk_hbox_new (FALSE, 0); + gtk_widget_show (hbox43); + gtk_container_add (GTK_CONTAINER (frame3), hbox43); + + label102 = gtk_label_new (_(" ")); + gtk_widget_show (label102); + gtk_box_pack_end (GTK_BOX (hbox43), label102, FALSE, FALSE, 0); + + vbox15 = gtk_vbox_new (FALSE, 0); + gtk_widget_show (vbox15); + gtk_box_pack_start (GTK_BOX (hbox43), vbox15, TRUE, TRUE, 0); + + label103 = gtk_label_new (""); + gtk_widget_show (label103); + gtk_box_pack_start (GTK_BOX (vbox15), label103, FALSE, FALSE, 0); + gtk_misc_set_padding (GTK_MISC (label103), 0, 2); + + rb_most_recent = gtk_radio_button_new_with_mnemonic (NULL, _("Select most recent backup")); + gtk_widget_show (rb_most_recent); + gtk_box_pack_start (GTK_BOX (vbox15), rb_most_recent, FALSE, FALSE, 0); + gtk_container_set_border_width (GTK_CONTAINER (rb_most_recent), 3); + gtk_radio_button_set_group (GTK_RADIO_BUTTON (rb_most_recent), rb_most_recent_group); + rb_most_recent_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (rb_most_recent)); + gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (rb_most_recent), TRUE); + + rb_jobs = gtk_radio_button_new_with_mnemonic (NULL, _("Select list of Jobs")); + gtk_widget_show (rb_jobs); + gtk_box_pack_start (GTK_BOX (vbox15), rb_jobs, FALSE, FALSE, 0); + gtk_container_set_border_width (GTK_CONTAINER (rb_jobs), 5); + gtk_radio_button_set_group (GTK_RADIO_BUTTON (rb_jobs), rb_jobs_group); + rb_jobs_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (rb_jobs)); + + rb_file = gtk_radio_button_new_with_mnemonic (NULL, _("Find a specific file")); + gtk_widget_show (rb_file); + gtk_box_pack_start (GTK_BOX (vbox15), rb_file, FALSE, FALSE, 0); + gtk_container_set_border_width (GTK_CONTAINER (rb_file), 4); + gtk_radio_button_set_group (GTK_RADIO_BUTTON (rb_file), rb_file_group); + rb_file_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (rb_file)); + + label104 = gtk_label_new (""); + gtk_widget_show (label104); + gtk_box_pack_start (GTK_BOX (vbox15), label104, FALSE, FALSE, 0); + + label106 = gtk_label_new (_("Select by:")); + gtk_widget_show (label106); + gtk_frame_set_label_widget (GTK_FRAME (frame3), label106); + gtk_label_set_justify (GTK_LABEL (label106), GTK_JUSTIFY_LEFT); + + vbox14 = gtk_vbox_new (FALSE, 0); + gtk_widget_show (vbox14); + gtk_box_pack_start (GTK_BOX (hbox42), vbox14, FALSE, FALSE, 0); + + apply_button = gtk_button_new_from_stock ("gtk-apply"); + gtk_widget_show (apply_button); + gtk_box_pack_start (GTK_BOX (vbox14), apply_button, FALSE, FALSE, 0); + gtk_container_set_border_width (GTK_CONTAINER (apply_button), 50); + + dialog_action_area7 = GTK_DIALOG (restore_dialog)->action_area; + gtk_widget_show (dialog_action_area7); + gtk_button_box_set_layout (GTK_BUTTON_BOX (dialog_action_area7), GTK_BUTTONBOX_END); + + hbuttonbox2 = gtk_hbutton_box_new (); + gtk_widget_show (hbuttonbox2); + gtk_container_add (GTK_CONTAINER (dialog_action_area7), hbuttonbox2); + gtk_button_box_set_layout (GTK_BUTTON_BOX (hbuttonbox2), GTK_BUTTONBOX_END); + gtk_box_set_spacing (GTK_BOX (hbuttonbox2), 8); + + restore_ok = gtk_button_new_from_stock ("gtk-ok"); + gtk_widget_show (restore_ok); + gtk_container_add (GTK_CONTAINER (hbuttonbox2), restore_ok); + GTK_WIDGET_SET_FLAGS (restore_ok, GTK_CAN_DEFAULT); + + restore_cancel = gtk_button_new_from_stock ("gtk-cancel"); + gtk_widget_show (restore_cancel); + gtk_container_add (GTK_CONTAINER (hbuttonbox2), restore_cancel); + GTK_WIDGET_SET_FLAGS (restore_cancel, GTK_CAN_DEFAULT); + + g_signal_connect ((gpointer) apply_button, "clicked", + G_CALLBACK (on_apply_button_clicked), + NULL); + g_signal_connect ((gpointer) restore_ok, "clicked", + G_CALLBACK (on_restore_ok_clicked), + NULL); + g_signal_connect ((gpointer) restore_cancel, "clicked", + G_CALLBACK (on_restore_cancel_clicked), + NULL); + + /* Store pointers to all widgets, for use by lookup_widget(). */ + GLADE_HOOKUP_OBJECT_NO_REF (restore_dialog, restore_dialog, "restore_dialog"); + GLADE_HOOKUP_OBJECT_NO_REF (restore_dialog, dialog_vbox8, "dialog_vbox8"); + GLADE_HOOKUP_OBJECT (restore_dialog, hbox42, "hbox42"); + GLADE_HOOKUP_OBJECT (restore_dialog, frame3, "frame3"); + GLADE_HOOKUP_OBJECT (restore_dialog, hbox43, "hbox43"); + GLADE_HOOKUP_OBJECT (restore_dialog, label102, "label102"); + GLADE_HOOKUP_OBJECT (restore_dialog, vbox15, "vbox15"); + GLADE_HOOKUP_OBJECT (restore_dialog, label103, "label103"); + GLADE_HOOKUP_OBJECT (restore_dialog, rb_most_recent, "rb_most_recent"); + GLADE_HOOKUP_OBJECT (restore_dialog, rb_jobs, "rb_jobs"); + GLADE_HOOKUP_OBJECT (restore_dialog, rb_file, "rb_file"); + GLADE_HOOKUP_OBJECT (restore_dialog, label104, "label104"); + GLADE_HOOKUP_OBJECT (restore_dialog, label106, "label106"); + GLADE_HOOKUP_OBJECT (restore_dialog, vbox14, "vbox14"); + GLADE_HOOKUP_OBJECT (restore_dialog, apply_button, "apply_button"); + GLADE_HOOKUP_OBJECT_NO_REF (restore_dialog, dialog_action_area7, "dialog_action_area7"); + GLADE_HOOKUP_OBJECT (restore_dialog, hbuttonbox2, "hbuttonbox2"); + GLADE_HOOKUP_OBJECT (restore_dialog, restore_ok, "restore_ok"); + GLADE_HOOKUP_OBJECT (restore_dialog, restore_cancel, "restore_cancel"); + + return restore_dialog; +} + +GtkWidget* +create_label_dialog (void) +{ + GtkWidget *label_dialog; + GtkWidget *dialog_vbox9; + GtkWidget *vbox16; + GtkWidget *label106; + GtkWidget *hbox45; + GtkWidget *label107; + GtkWidget *label_combo_storage; + GList *label_combo_storage_items = NULL; + GtkWidget *entry26; + GtkWidget *hbox46; + GtkWidget *label109; + GtkWidget *label_combo_pool; + GList *label_combo_pool_items = NULL; + GtkWidget *entry27; + GtkWidget *hbox47; + GtkWidget *label111; + GtkWidget *label_entry_volume; + GtkWidget *hbox48; + GtkWidget *slot1; + GtkObject *label_slot_adj; + GtkWidget *label_slot; + GtkWidget *label113; + GtkWidget *dialog_action_area8; + GtkWidget *hbuttonbox3; + GtkWidget *label_ok; + GtkWidget *label_cancel; + + label_dialog = gtk_dialog_new (); + gtk_window_set_title (GTK_WINDOW (label_dialog), _("Label a Volume")); + gtk_window_set_modal (GTK_WINDOW (label_dialog), TRUE); + + dialog_vbox9 = GTK_DIALOG (label_dialog)->vbox; + gtk_widget_show (dialog_vbox9); + + vbox16 = gtk_vbox_new (FALSE, 0); + gtk_widget_show (vbox16); + gtk_box_pack_start (GTK_BOX (dialog_vbox9), vbox16, FALSE, TRUE, 0); + + label106 = gtk_label_new (_("Label a Volume")); + gtk_widget_show (label106); + gtk_box_pack_start (GTK_BOX (vbox16), label106, FALSE, FALSE, 0); + gtk_misc_set_padding (GTK_MISC (label106), 0, 9); + + hbox45 = gtk_hbox_new (FALSE, 0); + gtk_widget_show (hbox45); + gtk_box_pack_start (GTK_BOX (vbox16), hbox45, FALSE, TRUE, 0); + gtk_container_set_border_width (GTK_CONTAINER (hbox45), 5); + + label107 = gtk_label_new (_("Storage:")); + gtk_widget_show (label107); + gtk_box_pack_start (GTK_BOX (hbox45), label107, TRUE, TRUE, 0); + gtk_misc_set_alignment (GTK_MISC (label107), 0.15, 0.5); + + label_combo_storage = gtk_combo_new (); + g_object_set_data (G_OBJECT (GTK_COMBO (label_combo_storage)->popwin), + "GladeParentKey", label_combo_storage); + gtk_widget_show (label_combo_storage); + gtk_box_pack_start (GTK_BOX (hbox45), label_combo_storage, TRUE, TRUE, 15); + gtk_combo_set_value_in_list (GTK_COMBO (label_combo_storage), TRUE, FALSE); + label_combo_storage_items = g_list_append (label_combo_storage_items, (gpointer) ""); + label_combo_storage_items = g_list_append (label_combo_storage_items, (gpointer) ""); + gtk_combo_set_popdown_strings (GTK_COMBO (label_combo_storage), label_combo_storage_items); + g_list_free (label_combo_storage_items); + + entry26 = GTK_COMBO (label_combo_storage)->entry; + gtk_widget_show (entry26); + gtk_editable_set_editable (GTK_EDITABLE (entry26), FALSE); + + hbox46 = gtk_hbox_new (FALSE, 0); + gtk_widget_show (hbox46); + gtk_box_pack_start (GTK_BOX (vbox16), hbox46, FALSE, TRUE, 0); + gtk_container_set_border_width (GTK_CONTAINER (hbox46), 5); + + label109 = gtk_label_new (_("Pool:")); + gtk_widget_show (label109); + gtk_box_pack_start (GTK_BOX (hbox46), label109, TRUE, TRUE, 0); + gtk_label_set_justify (GTK_LABEL (label109), GTK_JUSTIFY_LEFT); + gtk_misc_set_alignment (GTK_MISC (label109), 0.12, 0.5); + + label_combo_pool = gtk_combo_new (); + g_object_set_data (G_OBJECT (GTK_COMBO (label_combo_pool)->popwin), + "GladeParentKey", label_combo_pool); + gtk_widget_show (label_combo_pool); + gtk_box_pack_start (GTK_BOX (hbox46), label_combo_pool, TRUE, TRUE, 14); + gtk_combo_set_value_in_list (GTK_COMBO (label_combo_pool), TRUE, FALSE); + label_combo_pool_items = g_list_append (label_combo_pool_items, (gpointer) ""); + label_combo_pool_items = g_list_append (label_combo_pool_items, (gpointer) ""); + gtk_combo_set_popdown_strings (GTK_COMBO (label_combo_pool), label_combo_pool_items); + g_list_free (label_combo_pool_items); + + entry27 = GTK_COMBO (label_combo_pool)->entry; + gtk_widget_show (entry27); + gtk_editable_set_editable (GTK_EDITABLE (entry27), FALSE); + + hbox47 = gtk_hbox_new (FALSE, 0); + gtk_widget_show (hbox47); + gtk_box_pack_start (GTK_BOX (vbox16), hbox47, FALSE, TRUE, 0); + gtk_container_set_border_width (GTK_CONTAINER (hbox47), 5); + + label111 = gtk_label_new (_("Volume Name:")); + gtk_widget_show (label111); + gtk_box_pack_start (GTK_BOX (hbox47), label111, TRUE, TRUE, 0); + gtk_label_set_justify (GTK_LABEL (label111), GTK_JUSTIFY_LEFT); + gtk_misc_set_alignment (GTK_MISC (label111), 0.17, 0.5); + + label_entry_volume = gtk_entry_new (); + gtk_widget_show (label_entry_volume); + gtk_box_pack_start (GTK_BOX (hbox47), label_entry_volume, TRUE, TRUE, 0); + + hbox48 = gtk_hbox_new (FALSE, 0); + gtk_widget_show (hbox48); + gtk_box_pack_start (GTK_BOX (vbox16), hbox48, TRUE, TRUE, 0); + gtk_container_set_border_width (GTK_CONTAINER (hbox48), 5); + + slot1 = gtk_label_new (_("Slot:")); + gtk_widget_show (slot1); + gtk_box_pack_start (GTK_BOX (hbox48), slot1, FALSE, TRUE, 0); + gtk_label_set_justify (GTK_LABEL (slot1), GTK_JUSTIFY_LEFT); + gtk_misc_set_alignment (GTK_MISC (slot1), 0.09, 0.5); + + label_slot_adj = gtk_adjustment_new (0, 0, 10000, 1, 10, 10); + label_slot = gtk_spin_button_new (GTK_ADJUSTMENT (label_slot_adj), 1, 0); + gtk_widget_show (label_slot); + gtk_box_pack_start (GTK_BOX (hbox48), label_slot, TRUE, TRUE, 0); + gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (label_slot), TRUE); + + label113 = gtk_label_new (_(" ")); + gtk_widget_show (label113); + gtk_box_pack_start (GTK_BOX (vbox16), label113, FALSE, FALSE, 0); + + dialog_action_area8 = GTK_DIALOG (label_dialog)->action_area; + gtk_widget_show (dialog_action_area8); + gtk_button_box_set_layout (GTK_BUTTON_BOX (dialog_action_area8), GTK_BUTTONBOX_END); + + hbuttonbox3 = gtk_hbutton_box_new (); + gtk_widget_show (hbuttonbox3); + gtk_container_add (GTK_CONTAINER (dialog_action_area8), hbuttonbox3); + gtk_button_box_set_layout (GTK_BUTTON_BOX (hbuttonbox3), GTK_BUTTONBOX_END); + gtk_box_set_spacing (GTK_BOX (hbuttonbox3), 8); + + label_ok = gtk_button_new_from_stock ("gtk-ok"); + gtk_widget_show (label_ok); + gtk_container_add (GTK_CONTAINER (hbuttonbox3), label_ok); + GTK_WIDGET_SET_FLAGS (label_ok, GTK_CAN_DEFAULT); + + label_cancel = gtk_button_new_from_stock ("gtk-cancel"); + gtk_widget_show (label_cancel); + gtk_container_add (GTK_CONTAINER (hbuttonbox3), label_cancel); + GTK_WIDGET_SET_FLAGS (label_cancel, GTK_CAN_DEFAULT); + + g_signal_connect ((gpointer) label_ok, "clicked", + G_CALLBACK (on_label_ok_clicked), + NULL); + g_signal_connect ((gpointer) label_cancel, "clicked", + G_CALLBACK (on_label_cancel_clicked), + NULL); + + /* Store pointers to all widgets, for use by lookup_widget(). */ + GLADE_HOOKUP_OBJECT_NO_REF (label_dialog, label_dialog, "label_dialog"); + GLADE_HOOKUP_OBJECT_NO_REF (label_dialog, dialog_vbox9, "dialog_vbox9"); + GLADE_HOOKUP_OBJECT (label_dialog, vbox16, "vbox16"); + GLADE_HOOKUP_OBJECT (label_dialog, label106, "label106"); + GLADE_HOOKUP_OBJECT (label_dialog, hbox45, "hbox45"); + GLADE_HOOKUP_OBJECT (label_dialog, label107, "label107"); + GLADE_HOOKUP_OBJECT (label_dialog, label_combo_storage, "label_combo_storage"); + GLADE_HOOKUP_OBJECT (label_dialog, entry26, "entry26"); + GLADE_HOOKUP_OBJECT (label_dialog, hbox46, "hbox46"); + GLADE_HOOKUP_OBJECT (label_dialog, label109, "label109"); + GLADE_HOOKUP_OBJECT (label_dialog, label_combo_pool, "label_combo_pool"); + GLADE_HOOKUP_OBJECT (label_dialog, entry27, "entry27"); + GLADE_HOOKUP_OBJECT (label_dialog, hbox47, "hbox47"); + GLADE_HOOKUP_OBJECT (label_dialog, label111, "label111"); + GLADE_HOOKUP_OBJECT (label_dialog, label_entry_volume, "label_entry_volume"); + GLADE_HOOKUP_OBJECT (label_dialog, hbox48, "hbox48"); + GLADE_HOOKUP_OBJECT (label_dialog, slot1, "slot1"); + GLADE_HOOKUP_OBJECT (label_dialog, label_slot, "label_slot"); + GLADE_HOOKUP_OBJECT (label_dialog, label113, "label113"); + GLADE_HOOKUP_OBJECT_NO_REF (label_dialog, dialog_action_area8, "dialog_action_area8"); + GLADE_HOOKUP_OBJECT (label_dialog, hbuttonbox3, "hbuttonbox3"); + GLADE_HOOKUP_OBJECT (label_dialog, label_ok, "label_ok"); + GLADE_HOOKUP_OBJECT (label_dialog, label_cancel, "label_cancel"); + + return label_dialog; +} + diff --git a/bacula/src/gnome2-console/interface.h b/bacula/src/gnome2-console/interface.h new file mode 100644 index 0000000000..f9853e1742 --- /dev/null +++ b/bacula/src/gnome2-console/interface.h @@ -0,0 +1,11 @@ +/* + * DO NOT EDIT THIS FILE - it is generated by Glade. + */ + +GtkWidget* create_app1 (void); +GtkWidget* create_about1 (void); +GtkWidget* create_SelectDirectorDialog (void); +GtkWidget* create_RunDialog (void); +GtkWidget* create_restore_files (void); +GtkWidget* create_restore_dialog (void); +GtkWidget* create_label_dialog (void); diff --git a/bacula/src/gnome2-console/support.c b/bacula/src/gnome2-console/support.c new file mode 100644 index 0000000000..b4ccd3a748 --- /dev/null +++ b/bacula/src/gnome2-console/support.c @@ -0,0 +1,114 @@ +/* + * DO NOT EDIT THIS FILE - it is generated by Glade. + */ + +#ifdef HAVE_CONFIG_H +# include +#endif + +#include +#include +#include +#include +#include + +#include + +#include "support.h" + +GtkWidget* +lookup_widget (GtkWidget *widget, + const gchar *widget_name) +{ + GtkWidget *parent, *found_widget; + + for (;;) + { + if (GTK_IS_MENU (widget)) + parent = gtk_menu_get_attach_widget (GTK_MENU (widget)); + else + parent = widget->parent; + if (!parent) + parent = (GtkWidget *)g_object_get_data (G_OBJECT (widget), "GladeParentKey"); + if (parent == NULL) + break; + widget = parent; + } + + found_widget = (GtkWidget*) g_object_get_data (G_OBJECT (widget), + widget_name); + if (!found_widget) + g_warning ("Widget not found: %s", widget_name); + return found_widget; +} + +/* This is an internally used function to create pixmaps. */ +GtkWidget* +create_pixmap (GtkWidget *widget, + const gchar *filename) +{ + GtkWidget *pixmap; + gchar *pathname; + + if (!filename || !filename[0]) + return gtk_image_new (); + + pathname = gnome_program_locate_file (NULL, GNOME_FILE_DOMAIN_APP_PIXMAP, + filename, TRUE, NULL); + if (!pathname) + { + g_warning (_("Couldn't find pixmap file: %s"), filename); + return gtk_image_new (); + } + + pixmap = gtk_image_new_from_file (pathname); + g_free (pathname); + return pixmap; +} + +/* This is an internally used function to create pixmaps. */ +GdkPixbuf* +create_pixbuf (const gchar *filename) +{ + gchar *pathname = NULL; + GdkPixbuf *pixbuf; + GError *error = NULL; + + if (!filename || !filename[0]) + return NULL; + + pathname = gnome_program_locate_file (NULL, GNOME_FILE_DOMAIN_APP_PIXMAP, + filename, TRUE, NULL); + + if (!pathname) + { + g_warning (_("Couldn't find pixmap file: %s"), filename); + return NULL; + } + + pixbuf = gdk_pixbuf_new_from_file (pathname, &error); + if (!pixbuf) + { + fprintf (stderr, "Failed to load pixbuf file: %s: %s\n", + pathname, error->message); + g_error_free (error); + } + g_free (pathname); + return pixbuf; +} + +/* This is used to set ATK action descriptions. */ +void +glade_set_atk_action_description (AtkAction *action, + const gchar *action_name, + const gchar *description) +{ + gint n_actions, i; + + n_actions = atk_action_get_n_actions (action); + for (i = 0; i < n_actions; i++) + { + if (!strcmp (atk_action_get_name (action, i), action_name)) + atk_action_set_description (action, i, description); + } +} diff --git a/bacula/src/gnome2-console/support.h b/bacula/src/gnome2-console/support.h new file mode 100644 index 0000000000..96f7654664 --- /dev/null +++ b/bacula/src/gnome2-console/support.h @@ -0,0 +1,38 @@ +/* + * DO NOT EDIT THIS FILE - it is generated by Glade. + */ + +#define GTK_ENABLE_BROKEN +#include +#include + +/* + * Public Functions. + */ + +/* + * This function returns a widget in a component created by Glade. + * Call it with the toplevel widget in the component (i.e. a window/dialog), + * or alternatively any widget in the component, and the name of the widget + * you want returned. + */ +GtkWidget* lookup_widget (GtkWidget *widget, + const gchar *widget_name); + + + +/* + * Private Functions. + */ + +/* This is used to create the pixmaps used in the interface. */ +GtkWidget* create_pixmap (GtkWidget *widget, + const gchar *filename); + +/* This is used to create the pixbufs used in the interface. */ +GdkPixbuf* create_pixbuf (const gchar *filename); + +/* This is used to set ATK action descriptions. */ +void glade_set_atk_action_description (AtkAction *action, + const gchar *action_name, + const gchar *description); diff --git a/bacula/src/gnome2-console/test-gnome-console.conf b/bacula/src/gnome2-console/test-gnome-console.conf new file mode 100644 index 0000000000..b2725a1f9f --- /dev/null +++ b/bacula/src/gnome2-console/test-gnome-console.conf @@ -0,0 +1,10 @@ +# +# Bacula User Agent (or Console) Configuration File +# + +Director { + Name = rufus-dir + DIRport = 8101 + address = rufus + Password = UA_password +}