diff --git a/src/include/ZMap/zmapControl.h b/src/include/ZMap/zmapControl.h
index 28730de1824b203322f8d684787dd5fe5cdf48c1..3feda675e796dce6b13167689769cc305f09ac85 100755
--- a/src/include/ZMap/zmapControl.h
+++ b/src/include/ZMap/zmapControl.h
@@ -25,9 +25,9 @@
  * Description: Interface for creating, controlling and destroying ZMaps.
  *              
  * HISTORY:
- * Last edited: Jul  2 10:50 2004 (rnc)
+ * Last edited: Jul  2 16:54 2004 (edgrif)
  * Created: Mon Nov 17 08:04:32 2003 (edgrif)
- * CVS info:   $Id: zmapControl.h,v 1.3 2004-07-02 13:27:45 rnc Exp $
+ * CVS info:   $Id: zmapControl.h,v 1.4 2004-07-02 18:22:57 edgrif Exp $
  *-------------------------------------------------------------------
  */
 #ifndef ZMAP_CONTROL_H
@@ -46,6 +46,11 @@ typedef struct _ZMapStruct *ZMap ;
 
 typedef struct zMapColumn ZMapColumn;
 
+
+
+
+typedef struct _ZMapPaneStruct *ZMapPane ;
+
 /* callback function prototypes********************************
  * These must be here as they're referred to in zMapColumn below
  */
diff --git a/src/include/ZMap/zmapWindow.h b/src/include/ZMap/zmapWindow.h
index 4f793890599034c30c34342f0ef3389e39866b6b..ed2465968ff78c0c1b623cc06a3d063a74617d1e 100755
--- a/src/include/ZMap/zmapWindow.h
+++ b/src/include/ZMap/zmapWindow.h
@@ -27,15 +27,17 @@
  *              window displaying genome data.
  *              
  * HISTORY:
- * Last edited: Jul  2 14:32 2004 (rnc)
+ * Last edited: Jul  2 18:57 2004 (edgrif)
  * Created: Thu Jul 24 15:21:56 2003 (edgrif)
- * CVS info:   $Id: zmapWindow.h,v 1.7 2004-07-02 13:33:12 rnc Exp $
+ * CVS info:   $Id: zmapWindow.h,v 1.8 2004-07-02 18:22:58 edgrif Exp $
  *-------------------------------------------------------------------
  */
 #ifndef ZMAP_WINDOW_H
 #define ZMAP_WINDOW_H
 
 #include <glib.h>
+
+/* SHOULD CANVAS BE HERE...MAYBE, MAYBE NOT...... */
 #include <libfoocanvas/libfoocanvas.h>
 
 #include <ZMap/zmapSys.h>		       /* For callback funcs... */
@@ -45,7 +47,7 @@
 
 /* Opaque type, represents an individual ZMap window. */
 typedef struct _ZMapWindowStruct *ZMapWindow ;
-typedef struct _ZMapPaneStruct *ZMapPane;
+
 
 //typedef struct {
 //  ZMapWindow window;             /* the window pane  */
@@ -72,11 +74,7 @@ ZMapWindow   zMapWindowCreateZMapWindow(void);
 
 void         zMapWindowSetHandle       (ZMapWindow window);
 void         zMapWindowCreateRegion    (ZMapWindow window);
-GNode       *zMapWindowGetPanesTree    (ZMapWindow window);
-void         zMapWindowSetPanesTree    (ZMapWindow window, GNode *node);
-void         zMapWindowSetFirstTime    (ZMapWindow window, gboolean value);
-ZMapPane     zMapWindowGetFocuspane    (ZMapWindow window);
-void         zMapWindowSetFocuspane    (ZMapWindow window, ZMapPane pane);
+
 
 /* I don't know whether we're even going to use these datatypes, so for
 ** expediency I'm commenting these out until it becomes clearer. */
@@ -99,8 +97,6 @@ void         zMapWindowSetVbox         (ZMapWindow window, GtkWidget *vbox);
 void         zMapWindowSetBorderWidth  (GtkWidget *container, int width);
 GtkWidget   *zMapWindowGetHbox         (ZMapWindow window);
 void         zMapWindowSetHbox         (ZMapWindow window, GtkWidget *hbox);
-GtkWidget   *zMapWindowGetHpane        (ZMapWindow window);
-void         zMapWindowSetHpane        (ZMapWindow window, GtkWidget *hpane);
 GtkWidget   *zMapWindowGetNavigator    (ZMapWindow window);
 void         zMapWindowSetNavigator    (ZMapWindow window, GtkWidget *navigator);
 FooCanvas   *zMapWindowGetNavCanvas    (ZMapWindow window);
@@ -121,13 +117,9 @@ void         zMapRegionFreeSegs        (ZMapRegion *region);
 GArray      *zMapRegionGetDNA          (ZMapRegion *region);
 void         zMapRegionFreeDNA         (ZMapRegion *region);
 
-int          recordFocus               (GtkWidget *widget, GdkEvent *event, gpointer data); 
-void         navUpdate                 (GtkAdjustment *adj, gpointer p);
-void         navChange                 (GtkAdjustment *adj, gpointer p);
 
-void         drawNavigatorWind         (ZMapPane pane);
 
-void         zMapWindowDrawFeatures    (ZMapWindow window, ZMapFeatureContext feature_context);
+void         zmapWindowDrawFeatures    (ZMapFeatureContext feature_context);
 
 
 /* TEST SCAFFOLDING............... */
diff --git a/src/zmapControl/zmapControl.c b/src/zmapControl/zmapControl.c
index cd1e939a7e0720bac84a177954188e89d0a83144..2bf6805654c3aef2441bbe628c5dd6b6be08d0f1 100755
--- a/src/zmapControl/zmapControl.c
+++ b/src/zmapControl/zmapControl.c
@@ -26,9 +26,9 @@
  *              the window code and the threaded server code.
  * Exported functions: See ZMap.h
  * HISTORY:
- * Last edited: Jul  2 14:06 2004 (rnc)
+ * Last edited: Jul  2 19:06 2004 (edgrif)
  * Created: Thu Jul 24 16:06:44 2003 (edgrif)
- * CVS info:   $Id: zmapControl.c,v 1.13 2004-07-02 13:37:00 rnc Exp $
+ * CVS info:   $Id: zmapControl.c,v 1.14 2004-07-02 18:23:41 edgrif Exp $
  *-------------------------------------------------------------------
  */
 
@@ -47,6 +47,8 @@ gboolean zmap_debug_G = TRUE ;
 static ZMap createZMap(void *app_data, ZMapCallbackFunc app_cb) ;
 static void destroyZMap(ZMap zmap) ;
 
+static void createZMapWindow(ZMap zmap) ;
+
 static void killZMap(ZMap zmap) ;
 static void viewKilledCB(ZMapView view, void *app_data) ;
 static void killFinal(ZMap zmap) ;
@@ -281,7 +283,6 @@ void zmapControlResetCB(ZMap zmap)
 	}
     }
 
-
 #ifdef ED_G_NEVER_INCLUDE_THIS_CODE
   /* this is not right, we may not need the resetting state at top level at all in fact..... */
   zmap->state = ZMAP_RESETTING ;
@@ -334,26 +335,50 @@ gboolean zMapDisplay(ZMap        zmap,
 		 char       *fromspec, 
 		 gboolean        isOldGraph)
 {
+
+#ifdef ED_G_NEVER_INCLUDE_THIS_CODE
   ZMapWindow window = zmap->zMapWindow;
+#endif /* ED_G_NEVER_INCLUDE_THIS_CODE */
+
 
   //  Coord x1, x2;    
   //  zMapWindowSetHandle(window);
 
-  zMapWindowSetFrame(window, zmap->view_parent);        
-  zMapWindowSetFirstTime(window, TRUE);                 /* used in addPane() */
+  zmap->frame = zmap->view_parent ;        
+
+  zmap->firstTime = TRUE ;				    /* used in addPane() */
 
   /* make the window in which to display the data */
-  createZMapWindow(window);
+  createZMapWindow(zmap);
 
-  drawNavigator(window);
+  drawNavigator(zmap);
 
-  drawWindow(zMapWindowGetFocuspane(window));
+  drawWindow(zmap->focuspane) ;
 
   return TRUE;
 
 }
 
 
+
+
+#ifdef ED_G_NEVER_INCLUDE_THIS_CODE
+
+/* Has to become redundant.......I hope......... */
+
+ZMapWindow zMapWindowCreateZMapWindow(void)
+{
+  ZMapWindow window = (ZMapWindow)malloc(sizeof(ZMapWindowStruct));
+
+  return window;
+}
+#endif /* ED_G_NEVER_INCLUDE_THIS_CODE */
+
+
+
+
+
+
 /* createZMapWindow ***************************************************************
  * Creates the root node in the panesTree (which helps keep track of all the
  * display panels).  The root node has no data, only children.
@@ -364,35 +389,36 @@ gboolean zMapDisplay(ZMap        zmap,
  * in as child2.
  */
 
-void createZMapWindow(ZMapWindow window)
+static void createZMapWindow(ZMap zmap)
 {
   ZMapPane pane = NULL;
  
-  zMapWindowSetPanesTree(window, g_node_new(pane));
-  zMapWindowSetHpane(window, gtk_hpaned_new());
+  zmap->panesTree = g_node_new(pane);
+
+  zmap->hpane = gtk_hpaned_new() ;
                                                                                            
   /* After the toolbars comes an hpane, so the user can adjust the width
    * of the navigator pane */
-  gtk_container_add(GTK_CONTAINER(zMapWindowGetFrame(window)), zMapWindowGetHpane(window));
+  gtk_container_add(GTK_CONTAINER(zmap->frame), zmap->hpane) ;
                                                                                            
-  zMapWindowSetNavigator(window, gtk_scrolled_window_new(NULL, NULL));
-  gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(zMapWindowGetNavigator(window)), 
+  zmap->navigator = gtk_scrolled_window_new(NULL, NULL) ;
+  gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(zmap->navigator), 
 				 GTK_POLICY_NEVER, GTK_POLICY_NEVER);
-  gtk_widget_set_size_request(zMapWindowGetNavigator(window), 100, -1);
+  gtk_widget_set_size_request(zmap->navigator, 100, -1);
+
 
-  gtk_paned_pack1(GTK_PANED(zMapWindowGetHpane(window)), 
-		  zMapWindowGetNavigator(window),
+  gtk_paned_pack1(GTK_PANED(zmap->hpane), 
+		  zmap->navigator,
                   TRUE, TRUE);
                                                                                            
   /* create the splittable pane and pack it into the hpane as child2. */
-  zMapWindowSetDisplayVbox(window, gtk_vbox_new(FALSE,0));
+  zmap->displayvbox = gtk_vbox_new(FALSE,0) ;
 
-  addPane(window, 'v');
+  addPane(zmap, 'v');
 
-  gtk_widget_set_size_request(zMapWindowGetDisplayVbox(window), 750, -1);
-  gtk_paned_pack2(GTK_PANED(zMapWindowGetHpane(window)), 
-		  zMapWindowGetDisplayVbox(window)
-		  , TRUE, TRUE);
+  gtk_widget_set_size_request(zmap->displayvbox, 750, -1);
+  gtk_paned_pack2(GTK_PANED(zmap->hpane), 
+		  zmap->displayvbox, TRUE, TRUE);
 
   return;
 }
@@ -467,7 +493,7 @@ void drawWindow(ZMapPane pane)
  * Then in addPane we add a new frame in the child2 position, and into that we
  * load a new scrolled window and canvas. 
 */
-void addPane(ZMapWindow window, char orientation)
+void addPane(ZMap zmap, char orientation)
 {
   ZMapPane pane = (ZMapPane)malloc(sizeof(ZMapPaneStruct));
   GtkAdjustment *adj; 
@@ -475,7 +501,7 @@ void addPane(ZMapWindow window, char orientation)
   GNode *node = NULL;
 
   /* set up ZMapPane for this window */
-  pane->window = window;
+  pane->zmap = zmap ;
   pane->DNAwidth = 100;
   pane->step_increment = 10;
 
@@ -488,18 +514,18 @@ void addPane(ZMapWindow window, char orientation)
    * split vertically (side by side) are parents/children.  In theory
    * this enables us to get the sizing right. In practice it's not
    * perfect yet.*/
-  if (zMapWindowGetFirstTime(window)) 
+  if (zmap->firstTime) 
     { 
       pane->zoomFactor   = 1;
-      g_node_append_data(zMapWindowGetPanesTree(window), pane);
+      g_node_append_data(zmap->panesTree, pane);
     }
   else
     {
-      pane->zoomFactor   = zMapWindowGetFocuspane(window)->zoomFactor;
-      node = g_node_find (zMapWindowGetPanesTree(window),
+      pane->zoomFactor  = zmap->focuspane->zoomFactor ;
+      node = g_node_find (zmap->panesTree,
 			  G_IN_ORDER,
 			  G_TRAVERSE_ALL,
-			  zMapWindowGetFocuspane(window));
+			  zmap->focuspane);
       if (orientation == 'h')
 	  g_node_append_data(node->parent, pane);
       else
@@ -545,10 +571,10 @@ void addPane(ZMapWindow window, char orientation)
 
   /* First time through, we add the frame to the main vbox. 
    * Subsequently it goes in the lower half of the current pane. */
-  if (zMapWindowGetFirstTime(window))
-    gtk_box_pack_start(GTK_BOX(zMapWindowGetDisplayVbox(window)), pane->frame, TRUE, TRUE, 0);
+  if (zmap->firstTime)
+    gtk_box_pack_start(GTK_BOX(zmap->displayvbox), pane->frame, TRUE, TRUE, 0);
   else
-    gtk_paned_pack2(GTK_PANED(zMapWindowGetFocuspane(window)->pane), pane->frame, TRUE, TRUE);
+    gtk_paned_pack2(GTK_PANED(zmap->focuspane->pane), pane->frame, TRUE, TRUE);
 
 
   /* always show scrollbars, however big the display */
@@ -557,35 +583,79 @@ void addPane(ZMapWindow window, char orientation)
 
   adj = gtk_scrolled_window_get_vadjustment(GTK_SCROLLED_WINDOW(pane->scrolledWindow)); 
 
-  //  g_signal_connect(GTK_OBJECT(adj), "value_changed", GTK_SIGNAL_FUNC(navUpdate), (gpointer)(pane));
-  //  g_signal_connect(GTK_OBJECT(adj), "changed", GTK_SIGNAL_FUNC(navChange), (gpointer)(pane)); 
+  g_signal_connect(GTK_OBJECT(adj), "value_changed", GTK_SIGNAL_FUNC(navUpdate), (gpointer)(pane));
+  g_signal_connect(GTK_OBJECT(adj), "changed", GTK_SIGNAL_FUNC(navChange), (gpointer)(pane)); 
 
   /* focus on the new pane */
   recordFocus(NULL, NULL, pane);
   gtk_widget_grab_focus(pane->frame);
 
   /* if we do this first time, a little blank box appears before the main display */
-  if (!zMapWindowGetFirstTime(window)) 
-    gtk_widget_show_all (zMapWindowGetFrame(window));
+  if (!zmap->firstTime) 
+    gtk_widget_show_all(zmap->frame) ;
 
-  zMapWindowSetFirstTime(window, FALSE);
+  zmap->firstTime = FALSE ;
 
   zmMainScale(pane->canvas, 30, 0, 1000);
   return;
 }
 
 
-void drawNavigator(ZMapWindow window)
+
+void navChange(GtkAdjustment *adj, gpointer p)
+{
+  ZMapPane pane = (ZMapPane)p;
+  
+  drawNavigator(pane->zmap) ;
+}
+
+
+
+void navUpdate(GtkAdjustment *adj, gpointer p)
+{
+  ZMapPane pane = (ZMapPane)p ;
+  ZMap zmap = pane->zmap ;
+  int height;
+  Coord startWind, endWind;
+  ScreenCoord startWindf, startScreenf, endWindf, lenWindf;
+  float x1, y1, x2, y2;
+
+  if (GTK_WIDGET_REALIZED(zmap->frame))
+    {
+
+      //  graphActivate(zMapWindowGetNavigator(window));
+      //  graphFitBounds(NULL, &height);
+      //  graphBoxDim(pane->scrollBox, &x1, &y1, &x2, &y2);
+      
+      //  startWind =  zmCoordFromScreen(pane, 0);
+      //  endWind =  zmCoordFromScreen(pane, zMapPaneGetHeight(pane));
+      
+      //  startWindf = zMapWindowGetScreenCoord(window, startWind, height);
+      //  endWindf = zMapWindowGetScreenCoord(window, endWind, height);
+      //  lenWindf = endWindf - startWindf;
+      
+      //  startScreenf = startWindf + lenWindf * (adj->value - adj->lower)/(adj->upper - adj->lower) ;
+      
+      //  graphBoxShift(pane->scrollBox, x1, startScreenf);
+    }
+
+  return ;
+}
+
+
+
+
+void drawNavigator(ZMap zmap)
 {
   GtkWidget *w;
   GtkRequisition req;
   
   w = foo_canvas_new();
 
-  zMapWindowSetNavCanvas(window, FOO_CANVAS(w));
-  foo_canvas_set_scroll_region(zMapWindowGetNavCanvas(window), 0.0, 0.0, 200.0, 500.0);
+  zmap->navcanvas = FOO_CANVAS(w) ;
+  foo_canvas_set_scroll_region(zmap->navcanvas, 0.0, 0.0, 200.0, 500.0);
  
-  foo_canvas_item_new(foo_canvas_root(zMapWindowGetNavCanvas(window)),
+  foo_canvas_item_new(foo_canvas_root(zmap->navcanvas),
 			foo_canvas_rect_get_type(),
 			"x1",(double)0.0,
 			"y1",(double)0.0,
@@ -594,7 +664,7 @@ void drawNavigator(ZMapWindow window)
 			"fill_color", "white",
 			NULL);
 
-  gtk_container_add(GTK_CONTAINER(zMapWindowGetNavigator(window)), w);
+  gtk_container_add(GTK_CONTAINER(zmap->navigator), w);
 
 }
 
@@ -627,13 +697,35 @@ void navScale(FooCanvas *canvas, float offset, int start, int end)
 
 
 
+
+#ifdef ED_G_NEVER_INCLUDE_THIS_CODE
+/* UNUSED CURRENTLY..... */
+static void navResize(void)
+{
+  ZMapWindow window;
+  
+  //  if (graphAssFind(&navAssoc, &window))
+    drawNavigator(window);
+}
+#endif /* ED_G_NEVER_INCLUDE_THIS_CODE */
+
+
+
+#ifdef ED_G_NEVER_INCLUDE_THIS_CODE
+/* THIS PROBABLY NEEDS TO BE REWRITTEN AND PUT IN ZMAPDRAW.C, THE WHOLE CONCEPT OF GRAPHHEIGHT IS
+ * ALMOST CERTAINLY DEFUNCT NOW....... */
+
 /* Not entirely convinced this is the right place for these
 ** public functions accessing private structure members
 */
 int zMapWindowGetHeight(ZMapWindow window)
 {
-  return zMapWindowGetFocuspane(window)->graphHeight;
+  return zmap->focuspane->graphHeight;
 }
+#endif /* ED_G_NEVER_INCLUDE_THIS_CODE */
+
+
+
 
 // ZMapPane functions
 
@@ -646,6 +738,171 @@ void zMapPaneNewBox2Col(ZMapPane pane, int elements)
 
 
 
+
+/* MOVED FROM zmapWindow.c, THEY BE IN THE WRONG PLACE OR NOT EVEN NEEDED...... */
+
+#ifdef ED_G_NEVER_INCLUDE_THIS_CODE
+ZMapPane zMapWindowGetFocuspane(ZMapWindow window)
+{
+  return window->focuspane;
+}
+
+void zMapWindowSetFocuspane(ZMapWindow window, ZMapPane pane)
+{
+  window->focuspane = pane;
+  return;
+}
+#endif /* ED_G_NEVER_INCLUDE_THIS_CODE */
+
+
+
+#ifdef ED_G_NEVER_INCLUDE_THIS_CODE
+GNode *zMapWindowGetPanesTree(ZMapWindow window)
+{
+  return window->panesTree;
+}
+
+void zMapWindowSetPanesTree(ZMapWindow window, GNode *node)
+{
+  window->panesTree = node;
+  return;
+}
+#endif /* ED_G_NEVER_INCLUDE_THIS_CODE */
+
+
+
+#ifdef ED_G_NEVER_INCLUDE_THIS_CODE
+gboolean zMapWindowGetFirstTime(ZMapWindow window)
+{
+  return window->firstTime;
+}
+
+void zMapWindowSetFirstTime(ZMapWindow window, gboolean value)
+{
+  window->firstTime = value;
+  return;
+}
+#endif /* ED_G_NEVER_INCLUDE_THIS_CODE */
+
+
+
+#ifdef ED_G_NEVER_INCLUDE_THIS_CODE
+GtkWidget *zMapWindowGetHpane(ZMapWindow window)
+{
+  return window->hpane;
+}
+
+void zMapWindowSetHpane(ZMapWindow window, GtkWidget *hpane)
+{
+  window->hpane = hpane;
+  return;
+}
+#endif /* ED_G_NEVER_INCLUDE_THIS_CODE */
+
+
+
+
+#ifdef ED_G_NEVER_INCLUDE_THIS_CODE
+GtkWidget *zMapWindowGetNavigator(ZMapWindow window)
+{
+  return window->navigator;
+}
+
+
+void zMapWindowSetNavigator(ZMapWindow window, GtkWidget *navigator)
+{
+  window->navigator = navigator;
+  return;
+}
+#endif /* ED_G_NEVER_INCLUDE_THIS_CODE */
+
+
+
+#ifdef ED_G_NEVER_INCLUDE_THIS_CODE
+GtkWidget *zMapWindowGetFrame(ZMapWindow window)
+{
+  return window->frame;
+}
+
+void zMapWindowSetFrame(ZMapWindow window, GtkWidget *frame)
+{
+  window->frame = frame;
+  return;
+}
+#endif /* ED_G_NEVER_INCLUDE_THIS_CODE */
+
+
+
+#ifdef ED_G_NEVER_INCLUDE_THIS_CODE
+GtkWidget *zMapWindowGetVbox(ZMapWindow window)
+{
+  return window->vbox;
+}
+
+
+void zMapWindowSetVbox(ZMapWindow window, GtkWidget *vbox)
+{
+  window->vbox = vbox;
+  return;
+}
+#endif /* ED_G_NEVER_INCLUDE_THIS_CODE */
+
+
+
+#ifdef ED_G_NEVER_INCLUDE_THIS_CODE
+FooCanvas *zMapWindowGetNavCanvas(ZMapWindow window)
+{
+  return window->navcanvas;
+}
+
+
+void zMapWindowSetNavCanvas(ZMapWindow window, FooCanvas *navcanvas)
+{
+  window->navcanvas = navcanvas;
+  return;
+}
+#endif /* ED_G_NEVER_INCLUDE_THIS_CODE */
+
+
+
+
+#ifdef ED_G_NEVER_INCLUDE_THIS_CODE
+GtkWidget *zMapWindowGetDisplayVbox(ZMapWindow window)
+{
+  return window->displayvbox;
+}
+
+
+void zMapWindowSetDisplayVbox(ZMapWindow window, GtkWidget *vbox)
+{
+  window->displayvbox = vbox;
+  return;
+}
+#endif /* ED_G_NEVER_INCLUDE_THIS_CODE */
+
+
+
+
+#ifdef ED_G_NEVER_INCLUDE_THIS_CODE
+GtkWidget *zMapWindowGetHbox(ZMapWindow window)
+{
+  return window->hbox;
+}
+
+
+void zMapWindowSetHbox(ZMapWindow window, GtkWidget *hbox)
+{
+  window->hbox = hbox;
+  return;
+}
+#endif /* ED_G_NEVER_INCLUDE_THIS_CODE */
+
+
+
+
+
+
+
 GArray *zMapPaneSetBox2Col(ZMapPane pane, ZMapColumn *col, int index)
 {
   return g_array_insert_val(pane->box2col, index, col);
@@ -696,10 +953,14 @@ FooCanvasItem *zMapPaneGetGroup(ZMapPane pane)
 }
 
 
+
+#ifdef ED_G_NEVER_INCLUDE_THIS_CODE
 ZMapWindow zMapPaneGetZMapWindow(ZMapPane pane)
 {
   return pane->window;
 }
+#endif /* ED_G_NEVER_INCLUDE_THIS_CODE */
+
 
 FooCanvas *zMapPaneGetCanvas(ZMapPane pane)
 {
diff --git a/src/zmapControl/zmapControlSplit.c b/src/zmapControl/zmapControlSplit.c
index ef4f908e7afea3b4a6a6669e49c95a4f3c3ed1e7..55cc03d6fe833ac9ddf709d3a0444a780821e483 100755
--- a/src/zmapControl/zmapControlSplit.c
+++ b/src/zmapControl/zmapControlSplit.c
@@ -1,4 +1,4 @@
-/*  Last edited: Jul  2 14:14 2004 (rnc) */
+/*  Last edited: Jul  2 18:44 2004 (edgrif) */
 /*  file: zmapsplit.c
  *  Author: Rob Clack (rnc@sanger.ac.uk)
  *  Copyright (c) Sanger Institute, 2004
@@ -30,12 +30,12 @@
 
 /* function prototypes **************************************************/
 
-static void  shrinkPane      (ZMapWindow window);
-static void  resizePanes     (ZMapWindow window);
+static void  shrinkPane      (ZMap zmap) ;
+static void  resizePanes     (ZMap zmap) ;
 static void  resizeOnePane   (GNode     *node, gpointer user_data);
-static void  scaleCanvas     (ZMapWindow window, double zoomFactor);
-static void  shrinkHPane     (ZMapWindow window);
-static void  resizeHPanes    (ZMapWindow window);
+static void  scaleCanvas     (ZMap zmap, double zoomFactor);
+static void  shrinkHPane     (ZMap zmap);
+static void  resizeHPanes    (ZMap zmap);
 static int   unfocus         (GNode     *node, gpointer data);
 static int   resizeOneHPane  (GNode     *node, gpointer data);
 static void  exciseNode      (GNode     *node);
@@ -56,42 +56,45 @@ static void  exciseNode      (GNode     *node);
 
 void zoomIn(GtkWindow *widget, gpointer data)
 {
-  ZMapWindow window = (ZMapWindow)data;
-  ZMapPane pane = zMapWindowGetFocuspane(window);
+  ZMap zmap = (ZMap)data;
+  ZMapPane pane = zmap->focuspane ;
+
+  pane->zoomFactor *= 2 ;
 
-  pane->zoomFactor *= 2;
+  scaleCanvas(zmap, pane->zoomFactor) ;
 
-  scaleCanvas(window, pane->zoomFactor);
   return;
 }
 
 
 void zoomOut(GtkWindow *widget, gpointer data)
 {
-  ZMapWindow window = (ZMapWindow)data;
+  ZMap zmap = (ZMap)data;
+
+  zmap->focuspane->zoomFactor /= 2 ;
+
+  scaleCanvas(zmap, zmap->focuspane->zoomFactor) ;
 
-  zMapWindowGetFocuspane(window)->zoomFactor /= 2;
-  scaleCanvas(window, zMapWindowGetFocuspane(window)->zoomFactor);
   return;
 }
 
 
 int recordFocus(GtkWidget *widget, GdkEvent *event, gpointer data)
 {
-  ZMapPane pane = (ZMapPane)data;
-  ZMapWindow window = pane->window;
+  ZMapPane pane = (ZMapPane)data ;
+  ZMap zmap = pane->zmap ;
   GNode *node;
  
   /* point the parent window's focuspane pointer at this pane */
   if (pane)
-    zMapWindowSetFocuspane(window, pane);
+    zmap->focuspane = pane ;
   else /* if pane is null, arbitrarily focus on the first valid pane */
     {
-      node = g_node_first_child(zMapWindowGetPanesTree(window));
-      zMapWindowSetFocuspane(window, node->data);
+      node = g_node_first_child(zmap->panesTree) ;
+      zmap->focuspane = node->data ;
     }
   
-  g_node_traverse(zMapWindowGetPanesTree(window), 
+  g_node_traverse(zmap->panesTree, 
 		  G_IN_ORDER,
 		  G_TRAVERSE_ALL, 
 		  -1,
@@ -107,33 +110,38 @@ int recordFocus(GtkWidget *widget, GdkEvent *event, gpointer data)
 
 void splitPane(GtkWidget *widget, gpointer data)
 {
-  ZMapWindow window = (ZMapWindow)data;
+  ZMap zmap = (ZMap)data ;
 
   /* shrink the old pane */
-  shrinkPane(window);
+  shrinkPane(zmap) ;
   /* add a new pane below to the old one */
-  addPane   (window, 'h');
+  addPane(zmap, 'h') ;
   /* resize all the panes to fit the height */
-  resizePanes(window);
+  resizePanes(zmap) ;
 
   return;
 }
 
 void splitHPane(GtkWidget *widget, gpointer data)
 {
-  ZMapWindow window = (ZMapWindow)data;
+  ZMap zmap = (ZMap)data ;
 
   /* slim the old pane */
-  shrinkHPane(window);
+  shrinkHPane(zmap);
   /* add a new pane next to the old one */
-  addPane   (window, 'v');
+  addPane(zmap, 'v');
   /* resize all the panes to fit the width */
-  resizeHPanes(window);
+  resizeHPanes(zmap);
 
   return;
 }
 
 
+
+#ifdef ED_G_NEVER_INCLUDE_THIS_CODE
+
+/* THIS SEEMS NOT TO BE CALLED FROM ANYWHERE...IS THAT CORRECT ROB ? */
+
 void closePane(GtkWidget *widget, gpointer data)
 {
   ZMapWindow window = (ZMapWindow)data;
@@ -145,7 +153,7 @@ void closePane(GtkWidget *widget, gpointer data)
 
 
   /* count panes but forget the root node which isn't one */
-  guint panes = g_node_n_nodes(zMapWindowGetPanesTree(window), G_TRAVERSE_ALL) - 1;
+  guint panes = g_node_n_nodes(zmap->panesTree, G_TRAVERSE_ALL) - 1;
   int discard;  
 
   if (panes == 1)
@@ -153,10 +161,10 @@ void closePane(GtkWidget *widget, gpointer data)
   else
     {
       /* now decide where to focus after closing the pane */
-      node = g_node_find(zMapWindowGetPanesTree(window), 
+      node = g_node_find(zmap->panesTree, 
 			 G_IN_ORDER,
 			 G_TRAVERSE_ALL,
-			 zMapWindowGetFocuspane(window));
+			 zmap->focuspane) ;
       if (node->prev)
 	next = node->prev;
       else if (node->next)
@@ -168,7 +176,7 @@ void closePane(GtkWidget *widget, gpointer data)
       else
 	{
 	  printf("Don't know where to focus now!\n");
-	  parent = g_node_get_root(zMapWindowGetPanesTree(window));
+	  parent = g_node_get_root(zmap->panesTree);
 	  next = parent->children;
 	}
 
@@ -178,14 +186,14 @@ void closePane(GtkWidget *widget, gpointer data)
       * we add a pane to the current frame, then delete the corresponding node
       * from the panesTree.  When we delete panes from the display, we also need
       * to remove these extra frames as they become empty. */
-      pane_up1 = gtk_widget_get_ancestor(zMapWindowGetFocuspane(window)->frame, GTK_TYPE_PANED);
+      pane_up1 = gtk_widget_get_ancestor(zmap->focuspane->frame, GTK_TYPE_PANED);
       frame    = gtk_widget_get_ancestor(pane_up1, GTK_TYPE_FRAME);
       pane_up2 = gtk_widget_get_ancestor(frame, GTK_TYPE_PANED);
 
-      gtk_object_destroy(GTK_OBJECT(zMapWindowGetFocuspane(window)->canvas));
-      gtk_widget_destroy(zMapWindowGetFocuspane(window)->scrolledWindow);
-      gtk_widget_destroy(zMapWindowGetFocuspane(window)->frame);
-      free(zMapWindowGetFocuspane(window));
+      gtk_object_destroy(GTK_OBJECT(zmap->focuspane->canvas));
+      gtk_widget_destroy(zmap->focuspane->scrolledWindow);
+      gtk_widget_destroy(zmap->focuspane->frame);
+      free(zmap->focuspane) ;
             
       children = gtk_container_get_children(GTK_CONTAINER(pane_up1));
       if (children == NULL)
@@ -211,11 +219,15 @@ void closePane(GtkWidget *widget, gpointer data)
       discard = recordFocus(NULL, NULL, next->data);
       gtk_widget_grab_focus(((ZMapPane)next->data)->frame);
       
-      resizePanes(window);                                                                                
+      resizePanes(zmap);                                                                                
     }
   return;
 }
 
+#endif /* ED_G_NEVER_INCLUDE_THIS_CODE */
+
+
+
 /* static functions **********************************************/
 
 /* Zooming: we don't zoom as such, we scale the group, doubling the
@@ -223,9 +235,9 @@ void closePane(GtkWidget *widget, gpointer data)
  * the width the same.  I'm leaving the zoomFactor in the ZMapPane
  * structure for now in case I need it for when the user specifies
  * the bases-per-line magnification, which I've not looked at yet. */
-static void scaleCanvas(ZMapWindow window, double zoomFactor)
+static void scaleCanvas(ZMap zmap, double zoomFactor)
 {
-  foo_canvas_set_pixels_per_unit_xy(zMapWindowGetFocuspane(window)->canvas, 1.0, zoomFactor);
+  foo_canvas_set_pixels_per_unit_xy(zmap->focuspane->canvas, 1.0, zoomFactor);
   return;
 }
 
@@ -250,41 +262,41 @@ static int unfocus(GNode *node, gpointer data)
 /* shrinkPane is not quite the right name for this function.  We don't
  * actually shrink the pane, we add a new pane and frame and reposition
  * the scrolled window into that.  Later on we resize all panes. */
-static void shrinkPane(ZMapWindow window)
+static void shrinkPane(ZMap zmap)
 {
   ZMapPane pane = (ZMapPane)malloc(sizeof(ZMapPaneStruct));
   GNode *node = NULL;
 
   /* create a new vpane and hook the old scrolled window up to it */
-  pane->window = window;
+  pane->zmap = zmap ;
   pane->pane         = gtk_vpaned_new();
   pane->frame        = gtk_frame_new(NULL);;
-  pane->scrolledWindow = zMapWindowGetFocuspane(window)->scrolledWindow;
-  pane->canvas       = zMapWindowGetFocuspane(window)->canvas;
-  pane->background   = zMapWindowGetFocuspane(window)->background;
-  pane->zoomFactor   = zMapWindowGetFocuspane(window)->zoomFactor;
+  pane->scrolledWindow = zmap->focuspane->scrolledWindow;
+  pane->canvas       = zmap->focuspane->canvas;
+  pane->background   = zmap->focuspane->background;
+  pane->zoomFactor   = zmap->focuspane->zoomFactor;
   
   /* when the user clicks a button in the canvas, call recordFocus() */
   g_signal_connect (GTK_OBJECT (pane->canvas), "button_press_event",
 		    GTK_SIGNAL_FUNC (recordFocus), pane); 
   /* reparent the scrolled window into the new frame & pack1 the frame into the new vpane,
   ** then add the new vpane to the frame of the pane which currently has focus, ie that being split.  */
-  gtk_widget_reparent(GTK_WIDGET(zMapWindowGetFocuspane(window)->scrolledWindow), pane->frame);
+  gtk_widget_reparent(GTK_WIDGET(zmap->focuspane->scrolledWindow), pane->frame);
   gtk_paned_pack1(GTK_PANED(pane->pane), pane->frame, TRUE, TRUE);
-  gtk_container_add(GTK_CONTAINER(zMapWindowGetFocuspane(window)->frame), pane->pane);
+  gtk_container_add(GTK_CONTAINER(zmap->focuspane->frame), pane->pane);
 
   /* remove the old ZMapPane from panesTree, and add the new one */
-  node = g_node_find(zMapWindowGetPanesTree(window),
+  node = g_node_find(zmap->panesTree,
 		     G_IN_ORDER,
 		     G_TRAVERSE_ALL,
-		     (gpointer)zMapWindowGetFocuspane(window));
+		     (gpointer)zmap->focuspane) ;
 
   g_node_append_data(node->parent, pane);
   exciseNode(node);
 
   /* do we really need this? */
   //  gtk_widget_hide(zMapWindowGetFocuspane(window)->frame);
-  zMapWindowSetFocuspane(window, pane);
+  zmap->focuspane = pane ;
 
   return;
 }
@@ -292,7 +304,7 @@ static void shrinkPane(ZMapWindow window)
 
 /* resizing the panes doesn't really work too well, but it's not too
  * bad for a few panes and time is short. */
-static void resizePanes(ZMapWindow window)
+static void resizePanes(ZMap zmap)
 {
   GtkRequisition req;
   GNode *node = NULL;
@@ -300,10 +312,10 @@ static void resizePanes(ZMapWindow window)
   guint panes = 0;
 
   /* count how many panes there are in this column */
-  node = g_node_find(zMapWindowGetPanesTree(window),
+  node = g_node_find(zmap->panesTree,
 		     G_IN_ORDER,
 		     G_TRAVERSE_ALL,
-		     zMapWindowGetFocuspane(window));
+		     zmap->focuspane) ;
 
   last =  g_node_last_child(node->parent);
   /* first child is number 0 */
@@ -315,10 +327,10 @@ static void resizePanes(ZMapWindow window)
   /* get size of the window & divide it by the number of panes.
    * Note there's a small kludge here to adjust for a better fit.
    * Don't know why it needs the -8. */
-  gtk_widget_size_request(GTK_WIDGET(zMapWindowGetFrame(window)), &req);
+  gtk_widget_size_request(GTK_WIDGET(zmap->frame), &req);
   req.height = (req.height/panes) - 8;
 
-  g_node_children_foreach(zMapWindowGetPanesTree(window), 
+  g_node_children_foreach(zmap->panesTree, 
 		  G_TRAVERSE_LEAFS, 
 		  resizeOnePane, 
 		  &req);
@@ -341,40 +353,40 @@ static void resizeOnePane(GNode *node, gpointer data)
 /* shrinkHPane is not quite the right name for this function.  We don't
  * actually shrink the pane, we add a new, half-size one and reposition
  * the scrolled window into that */
-static void shrinkHPane(ZMapWindow window)
+static void shrinkHPane(ZMap zmap)
 {
   ZMapPane pane = (ZMapPane)malloc(sizeof(ZMapPaneStruct));
   GNode *node = NULL;
 
   /* create a new hpane and hook the old scrolled window up to it */
-  pane->window = window;
+  pane->zmap = zmap ;
   pane->pane         = gtk_hpaned_new();
   pane->frame        = gtk_frame_new(NULL);
-  pane->scrolledWindow = zMapWindowGetFocuspane(window)->scrolledWindow;
-  pane->canvas       = zMapWindowGetFocuspane(window)->canvas;
-  pane->background   = zMapWindowGetFocuspane(window)->background;
-  pane->zoomFactor   = zMapWindowGetFocuspane(window)->zoomFactor;
+  pane->scrolledWindow = zmap->focuspane->scrolledWindow;
+  pane->canvas       = zmap->focuspane->canvas;
+  pane->background   = zmap->focuspane->background;
+  pane->zoomFactor   = zmap->focuspane->zoomFactor;
 
   
   /* when the user clicks a button in the canvas, call recordFocus() */
   g_signal_connect (GTK_OBJECT (pane->canvas), "button_press_event",
 		    GTK_SIGNAL_FUNC (recordFocus), pane); 
 
-  gtk_widget_reparent(GTK_WIDGET(zMapWindowGetFocuspane(window)->scrolledWindow), pane->frame);
+  gtk_widget_reparent(GTK_WIDGET(zmap->focuspane->scrolledWindow), pane->frame);
   gtk_paned_pack1(GTK_PANED(pane->pane), pane->frame, TRUE, TRUE);
-  gtk_container_add(GTK_CONTAINER(zMapWindowGetFocuspane(window)->frame), pane->pane);
+  gtk_container_add(GTK_CONTAINER(zmap->focuspane->frame), pane->pane);
 
   /* add new pane to windowsTree. */
-  node = g_node_find(zMapWindowGetPanesTree(window),
+  node = g_node_find(zmap->panesTree,
 		     G_IN_ORDER,
 		     G_TRAVERSE_ALL,
-		     zMapWindowGetFocuspane(window));
+		     zmap->focuspane);
   g_node_append_data(node->parent, pane);
   exciseNode(node);
 
   /* do we really need this? */  
-  gtk_widget_hide(zMapWindowGetFocuspane(window)->frame);
-  zMapWindowSetFocuspane(window, pane);
+  gtk_widget_hide(zmap->focuspane->frame);
+  zmap->focuspane = pane ;
 
   return;
 }
@@ -387,17 +399,18 @@ static void shrinkHPane(ZMapWindow window)
 static int resizeOneHPane(GNode *node, gpointer data)
 {
   resizeOnePane(node, data);
+
   return 1;
 }  
 
 
-static void resizeHPanes(ZMapWindow window)
+static void resizeHPanes(ZMap zmap)
 {
   GtkRequisition req;
   guint panes = 0;
 
   /* count how many columns there are */
-  panes = g_node_n_nodes(zMapWindowGetPanesTree(window), 
+  panes = g_node_n_nodes(zmap->panesTree, 
 			G_TRAVERSE_NON_LEAFS);
   if (panes == 0)
     panes = 1;
@@ -405,10 +418,10 @@ static void resizeHPanes(ZMapWindow window)
   /* get size of the window & divide it by the number of panes.
    * Note there's a small kludge here to adjust for a better fit.
    * Don't know why it needs the -8. */
-  gtk_widget_size_request(GTK_WIDGET(zMapWindowGetDisplayVbox(window)), &req);
+  gtk_widget_size_request(GTK_WIDGET(zmap->displayvbox), &req);
   req.width = (req.width/panes) - 8;
 
-  g_node_traverse(g_node_get_root(zMapWindowGetPanesTree(window)), 
+  g_node_traverse(g_node_get_root(zmap->panesTree), 
 		  G_IN_ORDER,
 		  G_TRAVERSE_NON_LEAFS, 
 		  -1,
diff --git a/src/zmapControl/zmapControlWindow.c b/src/zmapControl/zmapControlWindow.c
index c79a793eb85e6cd1eef4ff0e1c99f7841f0e5e69..43914be97b7b20f03eb4f4659f01e2cdd647b1b7 100755
--- a/src/zmapControl/zmapControlWindow.c
+++ b/src/zmapControl/zmapControlWindow.c
@@ -26,9 +26,9 @@
  *              
  * Exported functions: See zmapTopWindow_P.h
  * HISTORY:
- * Last edited: Jul  1 09:52 2004 (edgrif)
+ * Last edited: Jul  2 19:08 2004 (edgrif)
  * Created: Fri May  7 14:43:28 2004 (edgrif)
- * CVS info:   $Id: zmapControlWindow.c,v 1.5 2004-07-01 09:25:28 edgrif Exp $
+ * CVS info:   $Id: zmapControlWindow.c,v 1.6 2004-07-02 18:23:41 edgrif Exp $
  *-------------------------------------------------------------------
  */
 
@@ -63,8 +63,6 @@ gboolean zmapControlWindowCreate(ZMap zmap, char *zmap_id)
   menubar = zmapControlWindowMakeMenuBar(zmap) ;
   gtk_box_pack_start(GTK_BOX(vbox), menubar, FALSE, TRUE, 0);
 
-  zmap->zMapWindow = zMapWindowCreateZMapWindow();
-
   button_frame = zmapControlWindowMakeButtons(zmap) ;
   gtk_box_pack_start(GTK_BOX(vbox), button_frame, FALSE, TRUE, 0);
 
diff --git a/src/zmapControl/zmapControlWindowButtons.c b/src/zmapControl/zmapControlWindowButtons.c
index 406ccaeae7da28f43dc3af9db3fad9ef4e5536eb..ce9ddb2ccfddc49ea1b7d7fe9910075ee4f9b099 100755
--- a/src/zmapControl/zmapControlWindowButtons.c
+++ b/src/zmapControl/zmapControlWindowButtons.c
@@ -26,16 +26,19 @@
  * Description: 
  * Exported functions: See XXXXXXXXXXXXX.h
  * HISTORY:
- * Last edited: Jul  2 14:40 2004 (rnc)
+ * Last edited: Jul  2 19:16 2004 (edgrif)
  * Created: Thu Jul 24 14:36:27 2003 (edgrif)
- * CVS info:   $Id: zmapControlWindowButtons.c,v 1.6 2004-07-02 13:47:49 rnc Exp $
+ * CVS info:   $Id: zmapControlWindowButtons.c,v 1.7 2004-07-02 18:23:42 edgrif Exp $
  *-------------------------------------------------------------------
  */
 
 #include <string.h>
+#include <ZMap/zmapWindow.h>
 #include <zmapControl_P.h>
 #include <zmapControlSplit.h>
 
+
+
 static void newCB(GtkWidget *widget, gpointer cb_data) ;
 static void loadCB(GtkWidget *widget, gpointer cb_data) ;
 static void stopCB(GtkWidget *widget, gpointer cb_data) ;
@@ -72,22 +75,22 @@ GtkWidget *zmapControlWindowMakeButtons(ZMap zmap)
 
   hsplit_button = gtk_button_new_with_label("H-Split");
   gtk_signal_connect(GTK_OBJECT(hsplit_button), "clicked",
-		     GTK_SIGNAL_FUNC(splitPane), (gpointer)zmap->zMapWindow);
+		     GTK_SIGNAL_FUNC(splitPane), (gpointer)zmap) ;
   gtk_box_pack_start(GTK_BOX(hbox), hsplit_button, FALSE, FALSE, 0) ;
 
   vsplit_button = gtk_button_new_with_label("V-Split");
   gtk_signal_connect(GTK_OBJECT(vsplit_button), "clicked",
-		     GTK_SIGNAL_FUNC(splitHPane), (gpointer)zmap->zMapWindow);
+		     GTK_SIGNAL_FUNC(splitHPane), (gpointer)zmap) ;
   gtk_box_pack_start(GTK_BOX(hbox), vsplit_button, FALSE, FALSE, 0) ;
                                                                                            
   zoomin_button = gtk_button_new_with_label("Zoom In");
   gtk_signal_connect(GTK_OBJECT(zoomin_button), "clicked",
-		     GTK_SIGNAL_FUNC(zoomIn), (gpointer)zmap->zMapWindow);
+		     GTK_SIGNAL_FUNC(zoomIn), (gpointer)zmap);
   gtk_box_pack_start(GTK_BOX(hbox), zoomin_button, FALSE, FALSE, 0) ;
                                                                                            
   zoomout_button = gtk_button_new_with_label("Zoom Out");
   gtk_signal_connect(GTK_OBJECT(zoomout_button), "clicked",
-		     GTK_SIGNAL_FUNC(zoomOut), (gpointer)zmap->zMapWindow);
+		     GTK_SIGNAL_FUNC(zoomOut), (gpointer)zmap);
   gtk_box_pack_start(GTK_BOX(hbox), zoomout_button, FALSE, FALSE, 0) ;
                                                                                            
   quit_button = gtk_button_new_with_label("Quit") ;
@@ -116,13 +119,21 @@ static void loadCB(GtkWidget *widget, gpointer cb_data)
 {
   ZMap zmap = (ZMap)cb_data ;
   ZMapFeatureContext feature_context ;
+  GtkWidget *topWindow;
+  char *title;
 
   zmapControlLoadCB(zmap) ;
 
   // only here temporarily until we find out why it's not working in zmapWindow.c
   feature_context = testGetGFF() ;			    /* Data read from a file... */
 
-  zmapWindowDrawFeatures(zmap->zMapWindow, feature_context);
+
+  /* ROB, THIS MAY NEED TO BE REWRITTEN, WHICH SEQUENCE NAME SHOULD GO IN THE WINDOW TITLE
+   * IF MULTIPLE SEQUENCES ARE DISPLAYED ? */
+  title = g_strdup_printf("ZMap - %s", feature_context->sequence) ;
+  gtk_window_set_title(GTK_WINDOW(zmap->toplevel), title) ;
+
+  zmapWindowDrawFeatures(feature_context) ;
 
   return ;
 }
@@ -150,10 +161,9 @@ static void newCB(GtkWidget *widget, gpointer cb_data)
 static void quitCB(GtkWidget *widget, gpointer cb_data)
 {
   ZMap zmap = (ZMap)cb_data ;
-  ZMapWindow window = zmap->zMapWindow;
 
-  if (zMapWindowGetPanesTree(window))
-    g_node_destroy(zMapWindowGetPanesTree(window));
+  if (zmap->panesTree)
+    g_node_destroy(zmap->panesTree);
 
   zmapControlTopLevelKillCB(zmap) ;
 
diff --git a/src/zmapControl/zmapControl_P.h b/src/zmapControl/zmapControl_P.h
index e62eeea648e596eded583b3302e149b248282ea2..42ad5d2396a058ad804b58e92ccd483500760d85 100755
--- a/src/zmapControl/zmapControl_P.h
+++ b/src/zmapControl/zmapControl_P.h
@@ -25,9 +25,9 @@
  * Description: Private header for interface that creates/manages/destroys
  *              instances of ZMaps.
  * HISTORY:
- * Last edited: Jul  2 14:06 2004 (rnc)
+ * Last edited: Jul  2 18:57 2004 (edgrif)
  * Created: Thu Jul 24 14:39:06 2003 (edgrif)
- * CVS info:   $Id: zmapControl_P.h,v 1.3 2004-07-02 13:47:24 rnc Exp $
+ * CVS info:   $Id: zmapControl_P.h,v 1.4 2004-07-02 18:23:42 edgrif Exp $
  *-------------------------------------------------------------------
  */
 #ifndef ZMAP_CONTROL_P_H
@@ -70,6 +70,27 @@ typedef struct _ZMapStruct
 
 
   GtkWidget *toplevel ;
+
+  /* MOVED HERE FROM zmapWindow/    */
+  ZMapPane        focuspane ;
+  GNode          *panesTree ;
+  gboolean        firstTime;
+  GtkWidget      *hpane;  /* allows the user to minimise the navigator pane */
+  GtkWidget      *navigator;
+  GtkWidget      *frame;
+  GtkWidget      *vbox;
+#ifdef ED_G_NEVER_INCLUDE_THIS_CODE
+  GtkItemFactory *itemFactory;
+#endif /* ED_G_NEVER_INCLUDE_THIS_CODE */
+  FooCanvas      *navcanvas;
+  GtkWidget      *displayvbox;
+  GtkWidget      *hbox;
+
+
+
+
+
+
   GtkWidget *view_parent ;
 
   ZMapView curr_view ;
@@ -89,7 +110,11 @@ typedef struct _ZMapStruct
 
 typedef struct _ZMapPaneStruct {
   /* Data associated with one scrolling pane. */
+
+#ifdef ED_G_NEVER_INCLUDE_THIS_CODE
   ZMapWindow   window;     /* parent */
+#endif /* ED_G_NEVER_INCLUDE_THIS_CODE */
+  ZMap zmap ;						    /* Back ptr to containing zmap. */
 
   GtkWidget   *graphWidget;
   GtkWidget   *vbox;
@@ -133,12 +158,31 @@ gboolean zMapDisplay(ZMap        zmap,
 		     char       *fromspec, 
 		     gboolean        isOldGraph);
 
-void  createZMapWindow (ZMapWindow window);
+void  addPane        (ZMap zmap, char orientation);
 
-void  addPane        (ZMapWindow  window, char orientation);
-void  drawNavigator  (ZMapWindow window);
+void  drawNavigator  (ZMap zmap) ;
 void  drawWindow     (ZMapPane pane);
 void  zMapZoomToolbar(ZMapWindow window);
 void  navScale       (FooCanvas *canvas, float offset, int start, int end);
 
+int          recordFocus               (GtkWidget *widget, GdkEvent *event, gpointer data); 
+
+void         navUpdate                 (GtkAdjustment *adj, gpointer p);
+void         navChange                 (GtkAdjustment *adj, gpointer p);
+
+
+
+
+/* Moved from ZMap/zmapWindow.h, these may be in the wrong place or not even needed. */
+ZMapPane     zMapWindowGetFocuspane    (ZMapWindow window);
+void         zMapWindowSetFocuspane    (ZMapWindow window, ZMapPane pane);
+GNode       *zMapWindowGetPanesTree    (ZMapWindow window);
+void         zMapWindowSetPanesTree    (ZMapWindow window, GNode *node);
+void         zMapWindowSetFirstTime    (ZMapWindow window, gboolean value);
+GtkWidget   *zMapWindowGetHpane        (ZMapWindow window);
+void         zMapWindowSetHpane        (ZMapWindow window, GtkWidget *hpane);
+
+
+
+
 #endif /* !ZMAP_CONTROL_P_H */
diff --git a/src/zmapWindow/zmapDraw.c b/src/zmapWindow/zmapDraw.c
index 7724987e125e8ce706587ab81fd09afd251e4e6d..11e98dbe02140d7c5a40db71ad850e0a53baf7d2 100755
--- a/src/zmapWindow/zmapDraw.c
+++ b/src/zmapWindow/zmapDraw.c
@@ -1,4 +1,4 @@
-/*  Last edited: Jul  2 14:06 2004 (rnc) */
+/*  Last edited: Jul  2 19:06 2004 (edgrif) */
 /*  file: zmapcontrol.c
  *  Author: Simon Kelley (srk@sanger.ac.uk)
  *  Copyright (c) Sanger Institute, 2003
@@ -40,7 +40,7 @@ static void *navAssoc, *winAssoc;
 
 /* function prototypes ***********************************************/
 
-static void drawGene (ZMapWindow window);
+static void drawGene (FooCanvas *canvas) ;
 static void zMapPick (int box, double x, double y);
 static void navPick  (int box, double x, double y);
 static void navDrag  (float *x, float *y, gboolean isDone);
@@ -144,46 +144,6 @@ float zmMainScale(FooCanvas *canvas, float offset, int start, int end)
 
 
 
-
-void navChange(GtkAdjustment *adj, gpointer p)
-{
-  ZMapPane pane = (ZMapPane)p;
-  
-  drawNavigator(zMapPaneGetZMapWindow(pane));
-}
-
-
-
-void navUpdate(GtkAdjustment *adj, gpointer p)
-{
-  ZMapPane pane = (ZMapPane)p;
-  ZMapWindow window = zMapPaneGetZMapWindow(pane);
-  int height;
-  Coord startWind, endWind;
-  ScreenCoord startWindf, startScreenf, endWindf, lenWindf;
-  float x1, y1, x2, y2;
-
-  if (!GTK_WIDGET_REALIZED(zMapWindowGetFrame(window)))
-    return;
-
-  //  graphActivate(zMapWindowGetNavigator(window));
-  //  graphFitBounds(NULL, &height);
-  //  graphBoxDim(pane->scrollBox, &x1, &y1, &x2, &y2);
-
-  //  startWind =  zmCoordFromScreen(pane, 0);
-  //  endWind =  zmCoordFromScreen(pane, zMapPaneGetHeight(pane));
-  
-  //  startWindf = zMapWindowGetScreenCoord(window, startWind, height);
-  //  endWindf = zMapWindowGetScreenCoord(window, endWind, height);
-  //  lenWindf = endWindf - startWindf;
-  
-  //  startScreenf = startWindf + lenWindf * (adj->value - adj->lower)/(adj->upper - adj->lower) ;
-
-  //  graphBoxShift(pane->scrollBox, x1, startScreenf);
-}
-
-
-
 /* Coordinate stuff ****************************************************/
 /* commenting out as I'm not convinced we're going to use this
 VisibleCoord zmVisibleCoord(ZMapWindow window, Coord coord)
@@ -300,17 +260,15 @@ static void zMapPick(int box, double x, double y)
 
 
 
-static void drawGene(ZMapWindow window)
+static void drawGene(FooCanvas *canvas)
 {
   FooCanvasItem *group;
-  ZMapPane pane = zMapWindowGetFocuspane(window);
-  FooCanvas *canvas = zMapPaneGetCanvas(pane);
 
   group = foo_canvas_item_new(foo_canvas_root(canvas),
-                        foo_canvas_group_get_type(),
-                        "x", (double)100,
-                        "y", (double)100 ,
-                        NULL);
+			      foo_canvas_group_get_type(),
+			      "x", (double)100,
+			      "y", (double)100 ,
+			      NULL);
 
   //group = window->focuspane->group;
 
@@ -453,12 +411,5 @@ static void navPick(int box, double x, double y)
     }
 }
 
-static void navResize(void)
-{
-  ZMapWindow window;
-  
-  //  if (graphAssFind(&navAssoc, &window))
-    drawNavigator(window);
-}
 
 /************************** end of file *********************************/
diff --git a/src/zmapWindow/zmapWindow.c b/src/zmapWindow/zmapWindow.c
index 46dbe1f659e9dd95e28918ca04fe4357d30731a7..7448d75008bd86231e1a90423149fea84efcac7f 100755
--- a/src/zmapWindow/zmapWindow.c
+++ b/src/zmapWindow/zmapWindow.c
@@ -28,9 +28,9 @@
  *              
  * Exported functions: See ZMap/zmapWindow.h
  * HISTORY:
- * Last edited: Jul  2 14:42 2004 (rnc)
+ * Last edited: Jul  2 19:06 2004 (edgrif)
  * Created: Thu Jul 24 14:36:27 2003 (edgrif)
- * CVS info:   $Id: zmapWindow.c,v 1.14 2004-07-02 13:52:14 rnc Exp $
+ * CVS info:   $Id: zmapWindow.c,v 1.15 2004-07-02 18:24:53 edgrif Exp $
  *-------------------------------------------------------------------
  */
 
@@ -191,7 +191,7 @@ static void dataEventCB(GtkWidget *widget, GdkEventClient *event, gpointer cb_da
 
       /* <<<<<<<<<<<<<  ROB, this is where calls to your drawing code need to go  >>>>>>>>>>>> */
 
-      zmapWindowDrawFeatures(window, feature_context);
+      zmapWindowDrawFeatures(feature_context) ;
 
 
       g_free(window_data) ;				    /* Free the WindowData struct. */
@@ -263,13 +263,6 @@ static void dataEventCB(GtkWidget *widget, GdkEventClient *event, gpointer cb_da
 #endif /* ED_G_NEVER_INCLUDE_THIS_CODE */
 
 
-ZMapWindow zMapWindowCreateZMapWindow(void)
-{
-  ZMapWindow window = (ZMapWindow)malloc(sizeof(ZMapWindowStruct));
-
-  return window;
-}
-
 
 
 #ifdef ED_G_NEVER_INCLUDE_THIS_CODE
@@ -289,87 +282,6 @@ void zMapWindowSetHandle(ZMapWindow window)
 
 
 
-GNode *zMapWindowGetPanesTree(ZMapWindow window)
-{
-  return window->panesTree;
-}
-
-void zMapWindowSetPanesTree(ZMapWindow window, GNode *node)
-{
-  window->panesTree = node;
-  return;
-}
-
-gboolean zMapWindowGetFirstTime(ZMapWindow window)
-{
-  return window->firstTime;
-}
-
-void zMapWindowSetFirstTime(ZMapWindow window, gboolean value)
-{
-  window->firstTime = value;
-  return;
-}
-
-ZMapPane zMapWindowGetFocuspane(ZMapWindow window)
-{
-  return window->focuspane;
-}
-
-void zMapWindowSetFocuspane(ZMapWindow window, ZMapPane pane)
-{
-  window->focuspane = pane;
-  return;
-}
-
-GtkWidget *zMapWindowGetHbox(ZMapWindow window)
-{
-  return window->hbox;
-}
-
-
-void zMapWindowSetHbox(ZMapWindow window, GtkWidget *hbox)
-{
-  window->hbox = hbox;
-  return;
-}
-
-GtkWidget *zMapWindowGetHpane(ZMapWindow window)
-{
-  return window->hpane;
-}
-
-void zMapWindowSetHpane(ZMapWindow window, GtkWidget *hpane)
-{
-  window->hpane = hpane;
-  return;
-}
-
-GtkWidget *zMapWindowGetFrame(ZMapWindow window)
-{
-  return window->frame;
-}
-
-void zMapWindowSetFrame(ZMapWindow window, GtkWidget *frame)
-{
-  window->frame = frame;
-  return;
-}
-
-
-GtkWidget *zMapWindowGetVbox(ZMapWindow window)
-{
-  return window->vbox;
-}
-
-
-void zMapWindowSetVbox(ZMapWindow window, GtkWidget *vbox)
-{
-  window->vbox = vbox;
-  return;
-}
-
-
 void zMapWindowSetBorderWidth(GtkWidget *container, int width)
 {
   gtk_container_border_width(GTK_CONTAINER(container), width);
@@ -377,43 +289,6 @@ void zMapWindowSetBorderWidth(GtkWidget *container, int width)
 }
 
 
-GtkWidget *zMapWindowGetNavigator(ZMapWindow window)
-{
-  return window->navigator;
-}
-
-
-void zMapWindowSetNavigator(ZMapWindow window, GtkWidget *navigator)
-{
-  window->navigator = navigator;
-  return;
-}
-
-FooCanvas *zMapWindowGetNavCanvas(ZMapWindow window)
-{
-  return window->navcanvas;
-}
-
-
-void zMapWindowSetNavCanvas(ZMapWindow window, FooCanvas *navcanvas)
-{
-  window->navcanvas = navcanvas;
-  return;
-}
-
-GtkWidget *zMapWindowGetDisplayVbox(ZMapWindow window)
-{
-  return window->displayvbox;
-}
-
-
-void zMapWindowSetDisplayVbox(ZMapWindow window, GtkWidget *vbox)
-{
-  window->displayvbox = vbox;
-  return;
-}
-
-
 ScreenCoord zMapWindowGetScaleOffset(ZMapWindow window)
 {
   return window->scaleOffset;
@@ -435,17 +310,19 @@ Coord zMapWindowGetCoord(ZMapWindow window, char *field)
     return window->navEnd;
 }
 
-/***************** commenting out until I know what we really need 
+
+
+#ifdef ED_G_NEVER_INCLUDE_THIS_CODE
 void zMapWindowSetCoord(ZMapWindow window, char *field, int size)
 {
   if (field == "s")
     window->navStart = window->focuspane->zMapRegion->area1 - size;
   else
     window->navEnd = window->focuspane->zMapRegion->area2 + size;
-
+  
   if (window->navStart == window->navEnd)
     window->navEnd = window->navStart + 1;
-
+  
   return;
 }
 
@@ -465,8 +342,8 @@ ScreenCoord zMapWindowGetScreenCoord(ZMapWindow window, Coord coord, int height)
 {
   return height * (coord - window->navStart) / (window->navEnd - window->navStart);
 }
+#endif /* ED_G_NEVER_INCLUDE_THIS_CODE */
 
-******************* end of commented out code */
 
 InvarCoord zMapWindowGetOrigin(ZMapWindow window)
 {
diff --git a/src/zmapWindow/zmapWindowDrawFeatures.c b/src/zmapWindow/zmapWindowDrawFeatures.c
index 7e01e282f7403e4fa59c28849de869bf590dd9d2..96d93078791703c5cc9b87fd65606d15ede1028c 100755
--- a/src/zmapWindow/zmapWindowDrawFeatures.c
+++ b/src/zmapWindow/zmapWindowDrawFeatures.c
@@ -27,9 +27,9 @@
  *              
  * Exported functions: 
  * HISTORY:
- * Last edited: Jul  1 10:27 2004 (rnc)
+ * Last edited: Jul  2 18:09 2004 (edgrif)
  * Created: Thu Jul 29 10:45:00 2004 (rnc)
- * CVS info:   $Id: zmapWindowDrawFeatures.c,v 1.1 2004-07-02 14:14:19 rnc Exp $
+ * CVS info:   $Id: zmapWindowDrawFeatures.c,v 1.2 2004-07-02 18:24:54 edgrif Exp $
  *-------------------------------------------------------------------
  */
 
@@ -40,20 +40,12 @@ static void zmapWindowProcessArray(GQuark key_id, gpointer data, gpointer user_d
 
 
 
-void zmapWindowDrawFeatures(ZMapWindow window, ZMapFeatureContext feature_context)
+void zmapWindowDrawFeatures(ZMapFeatureContext feature_context)
 {
   float column_spacing = 10.0;
-  GtkWidget *topWindow;
-  char *title;
 
-  if (!feature_context)
-    return;
-
-  title = g_strdup_printf("ZMap - %s", feature_context->sequence) ;
-  topWindow = gtk_widget_get_toplevel(window->frame);
-  gtk_window_set_title(GTK_WINDOW(topWindow), title) ;
-
-  g_datalist_foreach(&(feature_context->features), zmapWindowProcessArray, &column_spacing);
+  if (feature_context)
+    g_datalist_foreach(&(feature_context->features), zmapWindowProcessArray, &column_spacing);
 
   return;
 }
diff --git a/src/zmapWindow/zmapWindowFrame.c b/src/zmapWindow/zmapWindowFrame.c
index 36263ac84465a4fc2f12cde93cd171c7b05d82ca..1b6c64f847e1b65e55918a938406710d9791fe8e 100755
--- a/src/zmapWindow/zmapWindowFrame.c
+++ b/src/zmapWindow/zmapWindowFrame.c
@@ -25,9 +25,9 @@
  * Description: 
  * Exported functions: See XXXXXXXXXXXXX.h
  * HISTORY:
- * Last edited: Jun 23 14:29 2004 (rnc)
+ * Last edited: Jul  2 19:16 2004 (edgrif)
  * Created: Thu Apr 29 11:06:06 2004 (edgrif)
- * CVS info:   $Id: zmapWindowFrame.c,v 1.2 2004-06-28 14:29:59 rnc Exp $
+ * CVS info:   $Id: zmapWindowFrame.c,v 1.3 2004-07-02 18:24:54 edgrif Exp $
  *-------------------------------------------------------------------
  */
 
@@ -70,13 +70,23 @@ GtkWidget *zmapWindowMakeFrame(ZMapWindow window)
 
   g_free(frame_title) ;
 
-  zMapWindowSetVbox(window, gtk_vbox_new(FALSE, 0)) ;
+  vbox = gtk_vbox_new(FALSE, 0) ;
+
+
+#ifdef ED_G_NEVER_INCLUDE_THIS_CODE
+  /* ROB THIS ALL NEEDS SORTING OUT, I THINK THE FRAME HIERACHY IS ALL OUT OF WHACK...*/
+
+  zMapWindowSetVbox(window, vbox) ;
   zMapWindowSetBorderWidth(zMapWindowGetVbox(window), 5);
   gtk_container_add (GTK_CONTAINER (frame), zMapWindowGetVbox(window));
+#endif /* ED_G_NEVER_INCLUDE_THIS_CODE */
+
+
+
 
 
-    scrwin = gtk_scrolled_window_new(NULL, NULL) ;
-    gtk_container_add(GTK_CONTAINER(vbox), scrwin) ;
+  scrwin = gtk_scrolled_window_new(NULL, NULL) ;
+  gtk_container_add(GTK_CONTAINER(vbox), scrwin) ;
 
 
   /* CODE TO CREATE THE ACTUAL ZMAP SHOULD GO HERE INSTEAD OF THIS DUMMY DATA.......... */
diff --git a/src/zmapWindow/zmapWindow_P.h b/src/zmapWindow/zmapWindow_P.h
index 4c76aac8fe6b4d25a78c3ca42530ee6a8d59cd22..0cd1bd852401b8fc64f4528aee37efd3e399b7be 100755
--- a/src/zmapWindow/zmapWindow_P.h
+++ b/src/zmapWindow/zmapWindow_P.h
@@ -26,9 +26,9 @@
  * Description: 
  * Exported functions: See XXXXXXXXXXXXX.h
  * HISTORY:
- * Last edited: Jul  2 10:56 2004 (rnc)
+ * Last edited: Jul  2 17:34 2004 (edgrif)
  * Created: Fri Aug  1 16:45:58 2003 (edgrif)
- * CVS info:   $Id: zmapWindow_P.h,v 1.10 2004-07-02 13:53:33 rnc Exp $
+ * CVS info:   $Id: zmapWindow_P.h,v 1.11 2004-07-02 18:24:54 edgrif Exp $
  *-------------------------------------------------------------------
  */
 #ifndef ZMAP_WINDOW_P_H
@@ -59,20 +59,23 @@ typedef struct _ZMapWindowStruct
   STORE_HANDLE    handle;
 #endif /* ED_G_NEVER_INCLUDE_THIS_CODE */
 
-  GtkWidget      *frame;
-  GtkWidget      *vbox;
-  GtkItemFactory *itemFactory;
+
+
+
+
+#ifdef ED_G_NEVER_INCLUDE_THIS_CODE
+  /* code that references this is currently commented out..... */
   GtkWidget      *infoSpace;
-  GtkWidget      *navigator;
-  FooCanvas      *navcanvas;
+#endif /* ED_G_NEVER_INCLUDE_THIS_CODE */
+
+
+
+  /* Is this even used ??????? */
   InvarCoord      origin; /* that base which is VisibleCoord 1 */
-  GtkWidget      *displayvbox;
-  GtkWidget      *toolbar;
-  GtkWidget      *hbox;
-  GtkWidget      *hpane;  /* allows the user to minimise the navigator pane */
-  GNode          *panesTree;
-  ZMapPane        focuspane;
-  gboolean        firstTime;
+
+
+
+
   /* navigator stuff */
   Coord           navStart, navEnd; /* Start drawing the Nav bar from here */
   ScreenCoord     scaleOffset;