From 2b35d09c7e7bb7c670013619efc251339a2f3bb5 Mon Sep 17 00:00:00 2001
From: rnc <rnc>
Date: Mon, 28 Jun 2004 14:23:55 +0000
Subject: [PATCH] merged display code with main app, functions to access
private members, g arrays instead of acedb arrays
---
src/zmapWindow/zmapWindow.c | 604 ++++++++++++++++++++++++-
src/zmapWindow/zmapWindow_P.h | 52 ++-
src/zmapWindow/zmapcalls.c | 103 +++--
src/zmapWindow/zmapcols.c | 189 +++++---
src/zmapWindow/zmapcontrol.c | 798 +++++++++++-----------------------
src/zmapWindow/zmapcontrol.h | 169 ++-----
src/zmapWindow/zmapsplit.c | 151 ++++---
src/zmapWindow/zmapsplit.h | 5 +-
8 files changed, 1222 insertions(+), 849 deletions(-)
diff --git a/src/zmapWindow/zmapWindow.c b/src/zmapWindow/zmapWindow.c
index 80c33faa5..56c63e398 100755
--- a/src/zmapWindow/zmapWindow.c
+++ b/src/zmapWindow/zmapWindow.c
@@ -28,17 +28,20 @@
*
* Exported functions: See ZMap/zmapWindow.h
* HISTORY:
- * Last edited: Jun 25 14:28 2004 (edgrif)
+ * Last edited: Jun 28 15:08 2004 (rnc)
* Created: Thu Jul 24 14:36:27 2003 (edgrif)
- * CVS info: $Id: zmapWindow.c,v 1.10 2004-06-25 13:42:26 edgrif Exp $
+ * CVS info: $Id: zmapWindow.c,v 1.11 2004-06-28 14:28:19 rnc Exp $
*-------------------------------------------------------------------
*/
#include <string.h>
+#include <../acedb/regular.h>
#include <ZMap/zmapUtils.h>
+#include <ZMap/zmapcommon.h>
#include <zmapWindow_P.h>
+
static void dataEventCB(GtkWidget *widget, GdkEventClient *event, gpointer data) ;
@@ -259,3 +262,600 @@ 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;
+}
+
+
+STORE_HANDLE zMapWindowGetHandle(ZMapWindow window)
+{
+ return window->handle;
+}
+
+
+void zMapWindowSetHandle(ZMapWindow window)
+{
+ // window->handle = handleCreate();
+ window->handle = NULL;
+ return;
+}
+
+
+void zMapWindowCreateRegion(ZMapWindow window)
+{
+ window->focuspane->zMapRegion = (ZMapRegion*)malloc(sizeof(ZMapRegion));
+ return;
+}
+
+
+GNode *zMapWindowGetPanesTree(ZMapWindow window)
+{
+ return window->panesTree;
+}
+
+void zMapWindowSetPanesTree(ZMapWindow window, GNode *node)
+{
+ window->panesTree = node;
+ return;
+}
+
+BOOL zMapWindowGetFirstTime(ZMapWindow window)
+{
+ return window->firstTime;
+}
+
+void zMapWindowSetFirstTime(ZMapWindow window, BOOL value)
+{
+ window->firstTime = value;
+ return;
+}
+
+ZMapPane zMapWindowGetFocuspane(ZMapWindow window)
+{
+ return window->focuspane;
+}
+
+void zMapWindowSetFocuspane(ZMapWindow window, ZMapPane pane)
+{
+ window->focuspane = pane;
+ return;
+}
+
+int zMapWindowGetHeight(ZMapWindow window)
+{
+ return window->focuspane->graphHeight;
+}
+
+int zMapWindowGetRegionLength(ZMapWindow window)
+{
+ return window->focuspane->zMapRegion->length;
+}
+
+Coord zMapWindowGetRegionArea(ZMapWindow window, int num)
+{
+ if (num == 1)
+ return window->focuspane->zMapRegion->area1;
+ else
+ return window->focuspane->zMapRegion->area2;
+}
+
+void zMapWindowSetRegionArea(ZMapWindow window, Coord area, int num)
+{
+ if (num == 1)
+ window->focuspane->zMapRegion->area1 = area;
+ else
+ window->focuspane->zMapRegion->area2 = area;
+
+return;
+}
+
+BOOL zMapWindowGetRegionReverse(ZMapWindow window)
+{
+ return window->focuspane->zMapRegion->rootIsReverse;
+}
+
+
+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);
+ return;
+}
+
+
+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 *zMapWindowGetZoomVbox(ZMapWindow window)
+{
+ return window->zoomvbox;
+}
+
+
+void zMapWindowSetZoomVbox(ZMapWindow window, GtkWidget *vbox)
+{
+ window->zoomvbox = vbox;
+ return;
+}
+
+
+ScreenCoord zMapWindowGetScaleOffset(ZMapWindow window)
+{
+ return window->scaleOffset;
+}
+
+
+void zMapWindowSetScaleOffset(ZMapWindow window, ScreenCoord offset)
+{
+ window->scaleOffset = offset;
+ return;
+}
+
+
+Coord zMapWindowGetCoord(ZMapWindow window, char *field)
+{
+ if (field == "s")
+ return window->navStart;
+ else
+ return window->navEnd;
+}
+
+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;
+}
+
+
+ScreenCoord zMapWindowGetScreenCoord1(ZMapWindow window, int height)
+{
+ return zMapWindowGetScreenCoord(window, window->focuspane->zMapRegion->area1, height);
+}
+
+
+ScreenCoord zMapWindowGetScreenCoord2(ZMapWindow window, int height)
+{
+ return zMapWindowGetScreenCoord(window, window->focuspane->zMapRegion->area2, height);
+}
+
+ScreenCoord zMapWindowGetScreenCoord(ZMapWindow window, Coord coord, int height)
+{
+ return height * (coord - window->navStart) / (window->navEnd - window->navStart);
+}
+
+
+int zMapWindowGetRegionSize (ZMapWindow window)
+{
+ return window->focuspane->zMapRegion->area2 - window->focuspane->zMapRegion->area1;
+}
+
+
+InvarCoord zMapWindowGetOrigin(ZMapWindow window)
+{
+ return window->origin;
+}
+
+
+// ZMapRegion functions
+
+GPtrArray *zMapRegionNewMethods(ZMapRegion *region)
+{
+ return region->methods = g_ptr_array_new();
+}
+
+GPtrArray *zMapRegionGetMethods(ZMapRegion *region)
+{
+ return region->methods;
+}
+
+GPtrArray *zMapRegionGetOldMethods(ZMapRegion *region)
+{
+ return region->oldMethods;
+}
+
+void zMapRegionFreeMethods(ZMapRegion *region)
+{
+ g_ptr_array_free(region->methods, TRUE);
+ return;
+}
+
+void zMapRegionFreeOldMethods(ZMapRegion *region)
+{
+ g_ptr_array_free(region->oldMethods, TRUE);
+ return;
+}
+
+GArray *zMapRegionNewSegs(ZMapRegion *region)
+{
+ return region->segs = g_array_new(FALSE, FALSE, sizeof(SEG));
+}
+
+GArray *zMapRegionGetSegs(ZMapRegion *region)
+{
+ return region->segs;
+}
+
+void zMapRegionFreeSegs(ZMapRegion *region)
+{
+ free(region->segs);
+ return;
+}
+
+
+GArray *zMapRegionGetDNA(ZMapRegion *region)
+{
+ return region->dna;
+}
+
+void zMapRegionFreeDNA(ZMapRegion *region)
+{
+ g_array_free(region->dna, TRUE);
+ return;
+}
+
+
+// ZMapPane functions
+
+GArray *zMapPaneNewBox2Col(ZMapPane pane, int elements)
+{
+ pane->box2col = g_array_sized_new(FALSE, TRUE, sizeof(ZMapColumn), elements);
+}
+
+
+
+GArray *zMapPaneSetBox2Col(ZMapPane pane, ZMapColumn *col, int index)
+{
+ return g_array_insert_val(pane->box2col, index, col);
+}
+
+ZMapColumn *zMapPaneGetBox2Col(ZMapPane pane, int index)
+{
+ return &g_array_index(pane->box2col, ZMapColumn, index);
+}
+
+
+void zMapPaneFreeBox2Col(ZMapPane pane)
+{
+ if (pane->box2col)
+ g_array_free(pane->box2col, TRUE);
+ return;
+}
+
+
+GArray *zMapPaneNewBox2Seg(ZMapPane pane, int elements)
+{
+ pane->box2seg = g_array_sized_new(FALSE, TRUE, sizeof(SEG), elements);
+}
+
+GArray *zMapPaneSetBox2Seg(ZMapPane pane, ZMapColumn *seg, int index)
+{
+ return g_array_insert_val(pane->box2seg, index, seg);
+}
+
+SEG *zMapPaneGetBox2Seg(ZMapPane pane, int index)
+{
+ return &g_array_index(pane->box2seg, SEG, index);
+}
+
+void zMapPaneFreeBox2Seg(ZMapPane pane)
+{
+ if (pane->box2seg)
+ g_array_free(pane->box2seg, TRUE);
+ return;
+}
+
+
+ZMapRegion *zMapPaneGetZMapRegion(ZMapPane pane)
+{
+ return pane->zMapRegion;
+}
+
+
+FooCanvasItem *zMapPaneGetGroup(ZMapPane pane)
+{
+ return pane->group;
+}
+
+
+ZMapWindow zMapPaneGetZMapWindow(ZMapPane pane)
+{
+ return pane->window;
+}
+
+FooCanvas *zMapPaneGetCanvas(ZMapPane pane)
+{
+ return pane->canvas;
+}
+
+GPtrArray *zMapPaneGetCols(ZMapPane pane)
+{
+ return &pane->cols;
+}
+
+
+int zMapPaneGetDNAwidth (ZMapPane pane)
+{
+ return pane->DNAwidth;
+}
+
+
+void zMapPaneSetDNAwidth (ZMapPane pane, int width)
+{
+ pane->DNAwidth = 100;
+ return;
+}
+
+void zMapPaneSetStepInc (ZMapPane pane, int incr)
+{
+ pane->step_increment = incr;
+ return;
+}
+
+
+int zMapPaneGetHeight(ZMapPane pane)
+{
+ return pane->graphHeight;
+}
+
+InvarCoord zMapPaneGetCentre(ZMapPane pane)
+{
+ return pane->centre;
+}
+
+
+float zMapPaneGetBPL (ZMapPane pane)
+{
+ return pane->basesPerLine;
+}
+
+
+/* addPane is called each time we add a new pane. Creates a new frame, scrolled
+ * window and canvas. First time through it sticks them in the window->zoomvbox,
+ * thereafter it packs them into the lower part of the focus pane.
+ *
+ * Splitting goes like this: we make a (h or v) pane, add a new frame to the child1
+ * position of that, then reparent the scrolled window containing the canvas into
+ * the new frame. That's the shrinkPane() function.
+ * 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)
+{
+ ZMapPane pane = (ZMapPane)malloc(sizeof(ZMapPaneStruct));
+ GtkAdjustment *adj;
+ GtkWidget *w;
+ GNode *node = NULL;
+
+ /* set up ZMapPane for this window */
+ pane->window = window;
+ pane->DNAwidth = 100;
+ pane->step_increment = 10;
+
+ /* create the bare graph & convert to a widget */
+ /* pane->graph = graphNakedCreate(TEXT_FIT, "", 20, 100, TRUE);
+ pane->graphWidget = gexGraph2Widget(pane->graph);*/
+
+ // pane->cols = arrayHandleCreate(50, ZMapColumn, zMapWindowGetHandle(window));
+ // pane->cols = arrayCreate(50, ZMapColumn);
+ pane->box2col = g_array_sized_new(FALSE, TRUE, sizeof(ZMapColumn), 50);
+ // pane->box2col = NULL;
+ // pane->box2seg = NULL;
+ // pane->drawHandle = NULL;
+ pane->frame = gtk_frame_new(NULL);
+ pane->scrolledWindow = gtk_scrolled_window_new (NULL, NULL);
+
+ /* The idea of the GNode tree is that panes split horizontally, ie
+ * one above the other, end up as siblings in the tree, while panes
+ * 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))
+ {
+ pane->zoomFactor = 1;
+ g_node_append_data(zMapWindowGetPanesTree(window), pane);
+ }
+ else
+ {
+ pane->zoomFactor = zMapWindowGetFocuspane(window)->zoomFactor;
+ node = g_node_find (zMapWindowGetPanesTree(window),
+ G_IN_ORDER,
+ G_TRAVERSE_ALL,
+ zMapWindowGetFocuspane(window));
+ if (orientation == 'h')
+ g_node_append_data(node->parent, pane);
+ else
+ g_node_append_data(node, pane);
+ }
+
+ /* draw the canvas */
+ gdk_rgb_init();
+ w = foo_canvas_new();
+
+ pane->canvas = FOO_CANVAS(w);
+ foo_canvas_set_scroll_region(pane->canvas, 0.0, 0.0, 1000, 1000);
+ pane->background = foo_canvas_item_new(foo_canvas_root(pane->canvas),
+ foo_canvas_rect_get_type(),
+ "x1",(double)0,
+ "y1",(double)0,
+ "x2",(double)1000,
+ "y2",(double)1000,
+ "fill_color", "white",
+ "outline_color", "dark gray",
+ NULL);
+
+ /* when the user clicks a button in the view, call recordFocus() */
+ g_signal_connect (GTK_OBJECT (pane->canvas), "button_press_event",
+ GTK_SIGNAL_FUNC (recordFocus), pane);
+
+ pane->group = foo_canvas_item_new(foo_canvas_root(pane->canvas),
+ foo_canvas_group_get_type(),
+ "x", (double)100,
+ "y", (double)100 ,
+ NULL);
+
+ /* add the canvas to the scrolled window */
+ gtk_container_add(GTK_CONTAINER(pane->scrolledWindow),w);
+
+ /* you have to set the step_increment manually or the scrollbar arrows don't work.*/
+ /* Using a member of ZMapPane means I can adjust it if necessary when we zoom. */
+ GTK_LAYOUT (w)->vadjustment->step_increment = pane->step_increment;
+ GTK_LAYOUT (w)->hadjustment->step_increment = pane->step_increment;
+
+ /* add the scrolled window to the frame */
+ gtk_container_add(GTK_CONTAINER(pane->frame),pane->scrolledWindow);
+
+ /* 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(zMapWindowGetZoomVbox(window)), pane->frame, TRUE, TRUE, 0);
+ else
+ gtk_paned_pack2(GTK_PANED(zMapWindowGetFocuspane(window)->pane), pane->frame, TRUE, TRUE);
+
+
+ /* always show scrollbars, however big the display */
+ gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(pane->scrolledWindow),
+ GTK_POLICY_ALWAYS, GTK_POLICY_ALWAYS);
+
+ 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));
+
+ /* 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));
+
+ zMapWindowSetFirstTime(window, FALSE);
+
+ zmMainScale(pane->canvas, 30, 0, 1000);
+ return;
+}
+
+
+void drawNavigatorWind(ZMapPane pane)
+{
+ ZMapWindow window = pane->window;
+ int height;
+ Coord startWind, endWind;
+ ScreenCoord startWindf, endWindf, lenWindf;
+ ScreenCoord startScreenf, endScreenf;
+ ScreenCoord pos;
+ GtkAdjustment *adj = gtk_scrolled_window_get_vadjustment(GTK_SCROLLED_WINDOW(pane->scrolledWindow));
+
+
+ // graphFitBounds(NULL, &height);
+
+ startWind = zmCoordFromScreen(pane, 0);
+ endWind = zmCoordFromScreen(pane, pane->graphHeight);
+
+ startWindf = zMapWindowGetScreenCoord(window, startWind, height);
+ endWindf = zMapWindowGetScreenCoord(window, endWind, height);
+ lenWindf = endWindf - startWindf;
+
+ startScreenf = startWindf + lenWindf * (adj->value - adj->lower)/(adj->upper - adj->lower) ;
+ endScreenf = startWindf + lenWindf * (adj->page_size + adj->value - adj->lower)/(adj->upper - adj->lower) ;
+
+ // graphColor(BLACK);
+
+ if (pane == window->focuspane)
+ pos = zMapWindowGetScaleOffset(window);
+ else
+ pos = zMapWindowGetScaleOffset(window);
+
+ /* for now we'll not actually draw anything */
+ // pane->dragBox = graphBoxStart();
+ // graphLine(pos, startWindf, pos, endWindf);
+ // pane->scrollBox = graphBoxStart();
+ // graphColor(GREEN);
+ // graphFillRectangle(pos - 0.3, startScreenf, pos + 0.5, endScreenf);
+ // graphBoxEnd();
+ // graphBoxSetPick(pane->scrollBox, FALSE);
+ // graphBoxEnd();
+ // graphBoxDraw(pane->dragBox, -1, LIGHTGRAY);
+
+ return;
+}
+
+/****************** end of file ************************************/
diff --git a/src/zmapWindow/zmapWindow_P.h b/src/zmapWindow/zmapWindow_P.h
index a5b7fc9e0..76695d4b3 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: Jun 25 12:11 2004 (edgrif)
+ * Last edited: Jun 28 15:09 2004 (rnc)
* Created: Fri Aug 1 16:45:58 2003 (edgrif)
- * CVS info: $Id: zmapWindow_P.h,v 1.7 2004-06-25 13:42:26 edgrif Exp $
+ * CVS info: $Id: zmapWindow_P.h,v 1.8 2004-06-28 14:28:26 rnc Exp $
*-------------------------------------------------------------------
*/
#ifndef ZMAP_WINDOW_P_H
@@ -41,7 +41,6 @@
/* Test scaffoling */
#include <ZMap/zmapFeature.h>
-
typedef struct _ZMapWindowStruct
{
gchar *sequence ;
@@ -55,9 +54,54 @@ typedef struct _ZMapWindowStruct
zmapVoidIntCallbackFunc app_routine ;
void *app_data ;
+ STORE_HANDLE handle;
+ GtkWidget *frame;
+ GtkWidget *vbox;
+ GtkItemFactory *itemFactory;
+ GtkWidget *infoSpace;
+ GtkWidget *navigator;
+ FooCanvas *navcanvas;
+ InvarCoord origin; /* that base which is VisibleCoord 1 */
+ GtkWidget *zoomvbox;
+ GtkWidget *toolbar;
+ GtkWidget *hbox;
+ GtkWidget *hpane; /* allows the user to minimise the navigator pane */
+ GNode *panesTree;
+ ZMapPane focuspane;
+ BOOL firstTime;
+ /* navigator stuff */
+ Coord navStart, navEnd; /* Start drawing the Nav bar from here */
+ ScreenCoord scaleOffset;
} ZMapWindowStruct ;
+typedef struct _ZMapPaneStruct {
+ /* Data associated with one scrolling pane. */
+ ZMapWindow window; /* parent */
+ ZMapRegion *zMapRegion; /* the region holding all the SEGS */
+ Graph graph;
+ GtkWidget *graphWidget;
+ GtkWidget *vbox;
+ GtkWidget *pane;
+ GtkWidget *frame;
+ GtkWidget *scrolledWindow;
+ FooCanvas *canvas; /* where we paint the display */
+ FooCanvasItem *background;
+ FooCanvasItem *group;
+ GtkWidget *combo;
+ int basesPerLine;
+ InvarCoord centre;
+ int graphHeight;
+ int dragBox, scrollBox;
+ GPtrArray cols;
+ GArray *box2seg, *box2col;
+ STORE_HANDLE drawHandle; /* gets freed on each redraw. */
+ int DNAwidth;
+ double zoomFactor;
+ int step_increment;
+} ZMapPaneStruct;
+
+
typedef struct
{
ZMapWindow window ;
@@ -66,8 +110,6 @@ typedef struct
-
-
/* Used in our event communication.... */
#define ZMAP_ATOM "ZMap_Atom"
diff --git a/src/zmapWindow/zmapcalls.c b/src/zmapWindow/zmapcalls.c
index e8e671e99..18417af9a 100755
--- a/src/zmapWindow/zmapcalls.c
+++ b/src/zmapWindow/zmapcalls.c
@@ -1,4 +1,4 @@
-/* Last edited: Jan 30 11:34 2004 (rnc) */
+/* Last edited: Jun 23 13:38 2004 (rnc) */
/* file: zmapcalls.c
* Author: Rob Clack (rnc@sanger.ac.uk)
* Copyright (c) Sanger Institute, 2003
@@ -25,13 +25,13 @@
* Simon Kelley (Sanger Institute, UK) srk@sanger.ac.uk
*/
-#include <wzmap/zmapcalls.h>
+#include <zmapcalls.h>
/* function prototypes ********************************************/
static methodID srMethCreate (SeqRegion *region, char *methodName);
-static srMeth *srMethFromName(Array methods , char *methodName);
+static srMeth *srMethFromName(GPtrArray *methods, char *methodName);
static methodID srMethodMake (SeqRegion *region, char *methodName);
void srActivate(void *seqRegion,
@@ -62,7 +62,8 @@ BOOL zMapDisplay(Activate_cb srActivate,
BOOL zMapCall(KEY key, KEY from, BOOL isOldGraph, void *app_data)
{
BOOL ret;
- STORE_HANDLE handle = handleCreate();
+ // STORE_HANDLE handle = handleCreate();
+ STORE_HANDLE handle = NULL;
SeqRegion *region = halloc(sizeof(SeqRegion), handle);
char *keyspec = messalloc(strlen(className(key)) + strlen(name(key)) + 2);
@@ -88,11 +89,12 @@ static methodID srMethodMake(SeqRegion *region, char *methodName)
{
srMeth *meth;
- if ((meth = srMethFromName(region->zMapRegion->methods, methodName)))
+ if ((meth = srMethFromName(zMapRegionGetMethods(region->zMapRegion), methodName)))
return meth->id;
- else if ((meth = srMethFromName(region->zMapRegion->oldMethods, methodName)))
+ else if ((meth = srMethFromName(zMapRegionGetOldMethods(region->zMapRegion), methodName)))
{
- srMeth *new = arrayp(region->zMapRegion->methods, arrayMax(region->zMapRegion->methods), srMeth);
+ srMeth *new = g_ptr_array_index(zMapRegionGetMethods(region->zMapRegion),
+ zMapRegionGetMethods(region->zMapRegion)->len);
*new = *meth;
return new->id;
}
@@ -105,14 +107,14 @@ static methodID srMethodMake(SeqRegion *region, char *methodName)
/* Retrieves the method structure from the methods array, based
* on the methodName which it recieves. */
-static srMeth *srMethFromName(Array methods, char *methodName)
+static srMeth *srMethFromName(GPtrArray *methods, char *methodName)
{
int i;
if (methods)
- for (i=0; i<arrayMax(methods); i++)
+ for (i=0; i<methods->len; i++)
{
- srMeth *meth = arrp(methods, i, srMeth);
+ srMeth *meth = g_ptr_array_index(methods, i);
if (meth->name == methodName)
return meth;
}
@@ -137,7 +139,8 @@ static methodID srMethCreate(SeqRegion *region, char *methodName)
if (!(obj = bsCreate (methodKey)))
return 0;
- meth = arrayp(region->zMapRegion->methods, arrayMax(region->zMapRegion->methods), srMeth);
+ meth = g_ptr_array_index(zMapRegionGetMethods(region->zMapRegion),
+ zMapRegionGetMethods(region->zMapRegion)->len);
meth->id = region->idc++;
meth->name = str2p(name(methodKey), region->bucket);
meth->flags &= ~METHOD_CALCULATED ;/* unset flag */
@@ -235,13 +238,16 @@ static methodID srMethCreate(SeqRegion *region, char *methodName)
void seqRegionConvert(SeqRegion *region)
{
- STORE_HANDLE localHandle = handleCreate();
+ // STORE_HANDLE localHandle = handleCreate();
+ STORE_HANDLE localHandle = NULL;
KEYSET allKeys = sMapKeys(region->smap, localHandle);
int i;
- Array units = arrayHandleCreate(256, BSunit, localHandle);
+ GArray *units = g_array_new(FALSE, TRUE, 256);
+
+ zMapRegionFreeSegs(region->zMapRegion);
+ zMapRegionNewSegs(region->zMapRegion);
+ zMapRegionNewMethods(region->zMapRegion);
- region->zMapRegion->segs = arrayReCreate(region->zMapRegion->segs, 1000, SEG);
- region->zMapRegion->methods = arrayCreate(100, srMeth);
for (i = 0 ; i < keySetMax(allKeys) ; i++)
{
@@ -259,7 +265,7 @@ void seqRegionConvert(SeqRegion *region)
srPhase phase = 1;
BOOL isStartNotFound = FALSE;
BOOL isCDS = FALSE;
- Array exons = NULL;
+ GArray *exons;
methodName = messalloc(strlen(name(methodKey))); /* need to remember to free this? */
methodName = str2p(name(methodKey), region->bucket);
@@ -270,22 +276,26 @@ void seqRegionConvert(SeqRegion *region)
bsGetData(obj, _bsRight, _Int, &phase);
}
- if (bsFindTag(obj, str2tag("Source_Exons")) &&
+ /* Commenting this block out so I don't have to retrofit
+ ** a bsFlatten-equivalent. Don't think this code will make
+ ** it into the end result anyway.
+ if (bsFindTag(obj, str2tag("Source_Exons")) &&
(bsFlatten (obj, 2, units)))
{
int j; type = SR_TRANSCRIPT;
sMapUnsplicedMap(info, 1, 0, &x1, &x2, NULL, NULL);
dnaExonsSort (units) ;
- exons = arrayHandleCreate(20, srExon, region->handle);
- for(j = 0; j < arrayMax(units); j += 2)
+ exons = g_array_new(FALSE, TRUE, sizeof(srExon), 20);
+ for(j = 0; j < units->len; j += 2)
{
- srExon *e = arrayp(exons, arrayMax(exons), srExon);
+ srExon *e = g_array_index(exons, srExon, exons->len);
sMapUnsplicedMap(info,
- arr(units, j, BSunit).i, arr(units, j+1, BSunit).i,
+ g_ptr_array_index(units, BSunit, j).i,
+ g_ptr_array_index(units, BSunit, j+1).i,
&e->x1, &e->x2, NULL, NULL);
}
- }
+ } */
else
sMapMap(info, 1, 0, &x1, &x2, NULL, NULL);
@@ -306,13 +316,14 @@ void seqRegionConvert(SeqRegion *region)
/* If no source exons, fake one up which covers the whole of the CDS. */
if (!exons)
{
- exons = arrayHandleCreate(1, srExon, region->handle);
- array(exons, 0, srExon).x1 = cdsStart;
- array(exons, 0, srExon).x2 = cdsEnd;
+ exons = g_array_new(FALSE, TRUE, 1);
+ g_array_insert_val(exons, 0, cdsStart);
+ g_array_insert_val(exons, 0, cdsEnd);
}
}
- seg = arrayp(region->zMapRegion->segs, arrayMax(region->zMapRegion->segs), SEG);
+ seg = &g_array_index(zMapRegionGetSegs(region->zMapRegion), SEG,
+ zMapRegionGetSegs(region->zMapRegion)->len);
seg->id = str2p(name(key), region->bucket);
seg->type = type;
seg->x1 = x1;
@@ -333,17 +344,20 @@ void seqRegionConvert(SeqRegion *region)
seg->u.transcript.cdsStart = cdsStart;
seg->u.transcript.cdsEnd = cdsEnd;
- seg->u.transcript.exons = exons;
+ // seg->u.transcript.exons = exons;
}
-
+
+ /* commentint this block out so I don't have to write a
+ ** bsFlatten-equivalent. Don't think this code will make
+ ** it to the final version.
if (bsFindTag(obj, str2tag("Feature")) &&
bsFlatten (obj, 5, units))
{
int j ;
- for (j = 0 ; j < arrayMax(units) ; j += 5)
+ for (j = 0 ; j < units->len ; j += 5)
{
- BSunit *u = arrayp(units, j, BSunit);
+ BSunit *u = g_ptr_array_index(units, BSunit, j);
SEG *seg;
SMapStatus status ;
@@ -351,7 +365,7 @@ void seqRegionConvert(SeqRegion *region)
if (status & SMAP_STATUS_NO_OVERLAP)
continue;
- seg = arrayp(region->zMapRegion->segs, arrayMax(region->zMapRegion->segs), SEG);
+ seg = g_ptr_array_index(region->zMapRegion->segs, SEG, region->zMapRegion->segs->len);
seg->id = str2p(name(u[0].k), region->bucket);
seg->type = SR_FEATURE;
seg->x1 = x1;
@@ -360,6 +374,7 @@ void seqRegionConvert(SeqRegion *region)
seg->method = srMethodMake(region, str2p(name(u[0].k), region->bucket));
}
}
+ */
if (bsFindTag(obj, str2tag("Homol")))
{
@@ -372,7 +387,7 @@ void seqRegionConvert(SeqRegion *region)
bsDestroy(obj);
}
- handleDestroy(localHandle);
+ // handleDestroy(localHandle);
}
@@ -393,7 +408,8 @@ void srActivate(void *seqRegion,
/* Get out own handle */
- STORE_HANDLE newHandle = handleHandleCreate(*handle);
+ // STORE_HANDLE newHandle = handleHandleCreate(*handle);
+ STORE_HANDLE newHandle = NULL;
region->handle = newHandle;
region->smap = NULL;
@@ -458,14 +474,14 @@ static void calcSeqRegion(void *seqRegion,
if (region->smap)
sMapDestroy(region->smap);
- if (region->zMapRegion->dna)
- arrayDestroy(region->zMapRegion->dna);
+ if (zMapRegionGetDNA(region->zMapRegion))
+ zMapRegionFreeDNA(region->zMapRegion);
if (region->bucket)
sbDestroy(region->bucket);
- region->zMapRegion->oldMethods = region->zMapRegion->methods;
- region->zMapRegion->methods = NULL;
+ zMapRegionSetOldMethods(region->zMapRegion, zMapRegionGetMethods(region->zMapRegion));
+ zMapRegionSetMethods(region->zMapRegion, NULL);
/* currently just put in new area - might need these to see what we have
already got. */
@@ -494,10 +510,10 @@ static void calcSeqRegion(void *seqRegion,
/* When recalculating, for whatever reason, we need to repopulate
* the dna array. On initial display, srGetDNA is called by
* srActivate, but recalculation doesn't tread that path. */
- if (!region->zMapRegion->dna)
+ if (!zMapRegionGetDNA(region->zMapRegion))
srGetDNA(region);
- arrayDestroy(region->zMapRegion->oldMethods);
+ zMapRegionFreeOldMethods(region->zMapRegion);
}
@@ -508,10 +524,9 @@ void srGetDNA(SeqRegion *region)
{
/* TODO handle callback stuff */
- /* I find Simon's comment disturbing, as I've structured it not to
- * do a callback here... RNC */
- if (!region->zMapRegion->dna)
- region->zMapRegion->dna = sMapDNA(region->smap, region->handle, 0);
+ /* Commenting out until I know what is required here. */
+ // if (!zMapRegionGetDNA(region->zMapRegion))
+ // zMapRegionSetDNA(region->zMapRegion, sMapDNA(region->smap, region->handle, 0));
return;
}
@@ -542,7 +557,7 @@ void srRevComp(SeqRegion *region)
void seqRegionDestroy(SeqRegion *region)
{
- handleDestroy(region->handle);
+ // handleDestroy(region->handle); yes, I know I have to deal with this.
}
/***************************** end of file ******************************/
diff --git a/src/zmapWindow/zmapcols.c b/src/zmapWindow/zmapcols.c
index 10cb3cd07..3e1bcbe70 100755
--- a/src/zmapWindow/zmapcols.c
+++ b/src/zmapWindow/zmapcols.c
@@ -1,4 +1,4 @@
-/* Last edited: May 14 10:34 2004 (rnc) */
+/* Last edited: Jun 22 15:59 2004 (rnc) */
/* file: zmapcols.c
* Author: Simon Kelley (srk@sanger.ac.uk)
* Copyright (c) Sanger Institute, 2003
@@ -27,33 +27,107 @@
#include <seqregion.h>
#include <zmapcontrol.h>
-#include <zmapcommon.h>
+#include <ZMap/zmapcommon.h>
+#include <ZMap/zmapWindow.h>
-static void zMapScaleColumn(ZMapPane *pane, ZMapColumn *col, float *offset, int frame)
+/*************** function prototypes *****************************************/
+
+static void zMapDNAColumn(ZMapPane pane, ZMapColumn *col,
+ float *offsetp, int frame);
+
+/*************** start function definitions **********************************/
+
+static void zMapScaleColumn(ZMapPane pane, ZMapColumn *col, float *offset, int frame)
{
- *offset = zmDrawScale( /*window->canvas,*/ *offset,
- zmVisibleCoord(pane->window, zmCoordFromScreen(pane, 0)),
- zmVisibleCoord(pane->window, zmCoordFromScreen(pane, pane->graphHeight)));
+ *offset = zmMainScale(zMapPaneGetCanvas(pane), *offset,
+ zmVisibleCoord(zMapPaneGetZMapWindow(pane), zmCoordFromScreen(pane, 0)),
+ zmVisibleCoord(zMapPaneGetZMapWindow(pane),
+ zmCoordFromScreen(pane, zMapPaneGetHeight(pane))));
}
-static void pruneCols(ZMapPane *pane)
+
+/* cut this from zmapsequence.c and pasted here for now */
+void zMapDNAColumn(ZMapPane pane, ZMapColumn *col,
+ float *offsetp, int frame)
+{
+ float offset = *offsetp;
+ float max = offset;
+ float BPL = zMapPaneGetBPL(pane);
+ ZMapRegion *zMapRegion = zMapPaneGetZMapRegion(pane);
+ Coord seqstart = srCoord(zMapRegion, zMapPaneGetCentre(pane)) -
+ (zMapPaneGetHeight(pane) * BPL) / 2;
+ Coord seqend = srCoord(zMapRegion, zMapPaneGetCentre(pane)) +
+ (zMapPaneGetHeight(pane) * BPL) / 2;
+
+ Coord i;
+
+ if (seqstart < zMapRegion->area1)
+ seqstart = zMapRegion->area1;
+
+ if (seqend > zMapRegion->area2)
+ seqend = zMapRegion->area2;
+
+ if (zMapRegion->dna->len == 0)
+ return;
+
+ for (i = seqstart; i < seqend; i += BPL)
+ {
+ char *dnap, buff[10];
+ int j;
+ ScreenCoord y = zmScreenCoord(pane, i);
+ sprintf(buff, "%7d", zmVisibleCoord(zMapPaneGetZMapWindow(pane), i));
+ // graphText(buff, offset, y);
+
+ dnap = &g_array_index(zMapRegion->dna,
+ char,
+ i - (zMapRegion->area1-1));
+
+ for (j = 0; j < BPL; j++)
+ {
+ float x = offset+8+j;
+ // buff[0] = dnaDecodeChar[(int)*(dnap+j)];
+ // buff[1] = 0;
+ // graphText(buff, x, y);
+
+ if (j+i > zMapRegion->area2)
+ break;
+
+ if (j+1 == zMapPaneGetDNAwidth(pane))
+ {
+ // graphText("...", x+1, y);
+ j = BPL;
+ x += 4;
+ }
+
+ if (x > max)
+ max = x;
+ }
+ }
+
+ *offsetp = max+1;
+}
+
+
+static void pruneCols(ZMapPane pane)
/* Remove Columns which have invalid methods */
{
int i, j;
+ // NB all this farting about with &pane->cols must be wrong but I can't see why
+ printf("length is %d\n", zMapPaneGetCols(pane)->len);
- for (i = 0; i < arrayMax(pane->cols); i++)
+ for (i = 0; i < zMapPaneGetCols(pane)->len; i++)
{
- ZMapColumn *c = arrp(pane->cols, i, ZMapColumn);
- if (c->type != SR_DEFAULT && c->meth && !srMethodFromID(pane->zMapRegion, c->meth))
+ ZMapColumn *c = g_ptr_array_index(zMapPaneGetCols(pane), i);
+
+ if (c->type != SR_DEFAULT && c->meth && !srMethodFromID(zMapPaneGetZMapRegion(pane), c->meth))
{
- for (j = i+1; j < arrayMax(pane->cols); j++)
- arr(pane->cols, j-1, ZMapColumn) = arr(pane->cols, j, ZMapColumn);
- arrayMax(pane->cols)--;
+ for (j = i+1; j < (zMapPaneGetCols(pane))->len; j++)
+ g_ptr_array_remove_index(zMapPaneGetCols(pane), j-1); // = arr(pane->cols, j, ZMapColumn);
}
}
}
-static void insertCol(ZMapPane *pane, methodID meth, srType type)
+static void insertCol(ZMapPane pane, methodID meth, srType type)
{
/* NB call this one with type == SR_DEFAULT to put in default columns. */
@@ -69,11 +143,11 @@ static void insertCol(ZMapPane *pane, methodID meth, srType type)
otherwise matches values in segs from convert routines.
*/
static struct ZMapColDefs defs[] = {
- { NULL, zMapScaleColumn , NULL, NULL , FALSE, 1.0, "Scale" , SR_DEFAULT },
- { nbcInit, zMapFeatureColumn, NULL, nbcSelect , FALSE, 2.0, "Features", SR_SEQUENCE },
- { nbcInit, zMapFeatureColumn, NULL, nbcSelect , FALSE, 2.0, "Features", SR_FEATURE },
+ { NULL, zMapScaleColumn , NULL, NULL , FALSE, 1.0, "Scale" , SR_DEFAULT },
+ { nbcInit, zMapFeatureColumn, NULL, nbcSelect , FALSE, 2.0, "Features", SR_SEQUENCE },
+ { nbcInit, zMapFeatureColumn, NULL, nbcSelect , FALSE, 2.0, "Features", SR_FEATURE },
{ nbcInit, zMapGeneDraw , NULL, geneSelect, FALSE, 2.0, "Features", SR_TRANSCRIPT },
- { NULL, zMapDNAColumn , NULL, NULL , FALSE, 11.0, "DNA" , SR_DEFAULT },
+ { NULL, zMapDNAColumn , NULL, NULL , FALSE, 11.0, "DNA" , SR_DEFAULT },
};/* init, draw, config, select, isframe, prio, name, type */
int i, j, k;
@@ -92,43 +166,55 @@ static void insertCol(ZMapPane *pane, methodID meth, srType type)
}
else if ((type == defs[i].type))
{
- if (!(methp = srMethodFromID(pane->zMapRegion, meth)))
- messcrash("Failed to find method in insertCol");
- name = strnew(methp->name, pane->window->handle);
+ if (!(methp = srMethodFromID(zMapPaneGetZMapRegion(pane), meth)))
+ {
+ // TODO: sort out error handling here
+ printf("Failed to find method in insertCol\n");
+ exit;
+ }
+ name = (char*)g_string_new(methp->name); //previously hung on pane->window->handle);
priority = methp->priority;
}
else
continue;
- for (j = 0;
- j < arrayMax(pane->cols) &&
- arr(pane->cols, j, ZMapColumn).priority < priority;
+
+ /* TODO: This bit is completely wrong. I think the pane->cols array needs to be in
+ ** priority order, but GPtrArray doesn't have an insert function, just adds at the
+ ** end. Might have to write an insert function or use GArray instead, but for now
+ ** I'm not actually doing anything, as I've been in the pub at lunchtime and a couple
+ ** of beers is a sure way to break it. */
+ /* for (j = 0;
+ j < (&pane->cols)->len &&
+ g_ptr_array_index(pane->cols, j).priority < priority;
j++);
+ */
+ // if (j < (&pane->cols)->len)
+ // {
+ // /* default columns */
+ // if (!meth &&
+ // g_ptr_array_index(pane->cols, j).name == name)
+ // continue; /* already there */
+ //
+ // /* method columns */
+ // if (meth &&
+ // g_ptr_array_index(pane->cols, j).meth == meth &&
+ // g_ptr_array_index(pane->cols, j).type == type)
+ // continue; /* already there */
+ // }
- if (j < arrayMax(pane->cols))
- {
- /* default columns */
- if (!meth &&
- arr(pane->cols, j, ZMapColumn).name == name)
- continue; /* already there */
-
- /* method columns */
- if (meth &&
- arr(pane->cols, j, ZMapColumn).meth == meth &&
- arr(pane->cols, j, ZMapColumn).type == type)
- continue; /* already there */
- }
-
- if ( j < arrayMax(pane->cols))
- /* make space */
- for (k = arrayMax(pane->cols); k >= j+1; k--)
- {
- ZMapColumn tmp = array(pane->cols, k-1, ZMapColumn);
- *arrayp(pane->cols, k, ZMapColumn) = tmp;
- }
+ // if ( j < pane->cols->len)
+ /* make space */
+ // for (k = arrayMax(pane->cols); k >= j+1; k--)
+ // {
+ // ZMapColumn tmp = array(pane->cols, k-1, ZMapColumn);
+ // *arrayp(pane->cols, k, ZMapColumn) = tmp;
+ // }
+
- c = arrayp(pane->cols, j, ZMapColumn);
+ // c = g_ptr_array_index(pane->cols, j);
+
c->drawFunc = defs[i].drawFunc;
c->configFunc = defs[i].configFunc;
c->selectFunc = defs[i].selectFunc;
@@ -141,25 +227,26 @@ static void insertCol(ZMapPane *pane, methodID meth, srType type)
if (defs[i].initFunc)
(*defs[i].initFunc)(pane, c);
}
+
}
-void buildCols(ZMapPane *pane)
+void buildCols(ZMapPane pane)
/* Add a column for each method */
{
- ZMapRegion *zMapRegion = pane->zMapRegion;
+ ZMapRegion *zMapRegion = zMapPaneGetZMapRegion(pane);
int i;
- for (i=0; i < arrayMax(zMapRegion->segs); i++)
+ for (i=0; i < zMapRegionGetSegs(zMapRegion)->len; i++)
{
- SEG *seg = arrp(zMapRegion->segs, i, SEG);
+ SEG *seg = &g_array_index(zMapRegionGetSegs(zMapRegion), SEG, i);
methodID id = seg->method;
if (id)
insertCol(pane, id, seg->type);
}
}
-void makezMapDefaultColumns(ZMapPane *pane)
+void makezMapDefaultColumns(ZMapPane pane)
{
insertCol(pane, 0, SR_DEFAULT);
}
diff --git a/src/zmapWindow/zmapcontrol.c b/src/zmapWindow/zmapcontrol.c
index 15f93fdc7..d19dfb4b0 100755
--- a/src/zmapWindow/zmapcontrol.c
+++ b/src/zmapWindow/zmapcontrol.c
@@ -1,4 +1,4 @@
-/* Last edited: May 14 10:34 2004 (rnc) */
+/* Last edited: Jun 28 13:59 2004 (rnc) */
/* file: zmapcontrol.c
* Author: Simon Kelley (srk@sanger.ac.uk)
* Copyright (c) Sanger Institute, 2003
@@ -32,30 +32,22 @@ static void *navAssoc, *winAssoc;
/* function prototypes ***********************************************/
-static void createZMap (ZMapWindow *window, ZMapCallbackData *zMapCallbackData);
-static void createZMapWindow (ZMapWindow *window, ZMapCallbackData *zMapCallbackData);
-static void zMapZoomToolbar (ZMapWindow *window, ZMapCallbackData *zMapCallbackData);
-static void drawNavigator (ZMapWindow *window);
-static void drawWindow (ZMapPane *pane);
-static void navUpdate (GtkAdjustment *adj, gpointer p);
-static void navChange (GtkAdjustment *adj, gpointer p);
-static void drawNavigatorWind(ZMapPane *pane);
-static void zMapScaleColumn (ZMapPane *pane, float *offset, int frame);
-static void drawBox (FooCanvasItem *group, double x, double y, char *line_colour, char *fill_colour);
-static void drawLine (FooCanvasGroup *group, double x1, double y1, double x2, double y2,
- char *colour, double thickness);
-static void drawGene(ZMapWindow *window);
-static void columnOfBoxes(ZMapWindow *window);
-static float zmMainScale(FooCanvas *canvas, float offset, int start, int end);
+static void createZMap (ZMapWindow window);
+static void zMapZoomToolbar (ZMapWindow window);
+static void drawNavigator (ZMapWindow window);
+static void drawWindow (ZMapPane pane);
+static void drawGene (ZMapWindow window);
+static void columnOfBoxes (ZMapWindow window);
+static void navScale (FooCanvas *canvas, float offset, int start, int end);
/* functions ********************************************************/
BOOL Quit(GtkWidget *widget, gpointer data)
{
- ZMapWindow *window = (ZMapWindow*)data;
+ ZMapWindow window = (ZMapWindow)data;
- if (window->panesTree)
- g_node_destroy(window->panesTree);
+ if (zMapWindowGetPanesTree(window))
+ g_node_destroy(zMapWindowGetPanesTree(window));
return TRUE;
}
@@ -63,59 +55,48 @@ BOOL Quit(GtkWidget *widget, gpointer data)
/* zMapDisplay
- * Main entry point for the zmap code. Called by zMapCall() zmapcalls.c.
- * The first two params are callback routines to allow zmap to
- * interrogate a data-source, the third being a void pointer to a
+ * Main entry point for the zmap code. Called by zMapWindowCreate.
+ * The first param is the display window, then two callback routines to
+ * allow zmap to interrogate a data-source. Then a void pointer to a
* structure used in the process. Although zmap doesn't need to know
* directly about this structure, it needs to pass the pointer back
* during callbacks, so AceDB can use it.
*
+ * This will all have to change, now we're acedb-independent.
+ *
* We create the display window, then call the Activate
* callback routine to get the data, passing it a ZMapRegion in
* which to create fmap-flavour segs for us to display, then
* build the columns in the display.
*/
-BOOL zMapDisplay(Activate_cb act_cb,
- Calc_cb calc_cb,
- void *region,
- char *seqspec,
- char *fromspec,
- BOOL isOldGraph)
+BOOL zMapDisplay(ZMap zmap,
+ Activate_cb act_cb,
+ Calc_cb calc_cb,
+ void *region,
+ char *seqspec,
+ char *fromspec,
+ BOOL isOldGraph)
{
+ ZMapWindow window = zmap->zMapWindow;
- ZMapWindow *window = (ZMapWindow*)messalloc(sizeof(ZMapWindow));
- Coord x1, x2;
-
- window->handle = handleCreate();
- window->firstTime = TRUE; /* used in addPane() */
- ZMapCallbackData *zMapCBData = halloc(sizeof(ZMapCallbackData), window->handle);
+ // Coord x1, x2;
+ // zMapWindowSetHandle(window);
- zMapCBData->calc_cb = calc_cb;
- zMapCBData->seqRegion = region;
+ zMapWindowSetFrame(window, zmap->view_parent);
+ zMapWindowSetFirstTime(window, TRUE); /* used in addPane() */
/* make the window in which to display the data */
- createZMap(window, zMapCBData);
+ createZMapWindow(window);
- /* Make zmapRegion - just zmap stuff, no AceDB at all. */
- window->focuspane->zMapRegion = srCreate(window->handle);
-
- /* Poke stuff in. For xace this will be srActivate(). */
- (*act_cb)(region, seqspec, window->focuspane->zMapRegion, &x1, &x2, &window->handle);
-
- /* stick the data into the display window */
- makezMapDefaultColumns(window->focuspane);
- buildCols(window->focuspane);
-
- window->origin = srInvarCoord(window->focuspane->zMapRegion, x1);
- window->focuspane->centre = srInvarCoord(window->focuspane->zMapRegion, x1);
- window->focuspane->basesPerLine = 100;
-
- gtk_widget_show_all(window->window);
+ // for now, just default the areas to 0;
+ zMapWindowCreateRegion(window);
+ zMapWindowSetRegionArea(window, 0, 1);
+ zMapWindowSetRegionArea(window, 0, 2);
drawNavigator(window);
- drawWindow(window->focuspane);
+ drawWindow(zMapWindowGetFocuspane(window));
return TRUE;
@@ -124,23 +105,24 @@ BOOL zMapDisplay(Activate_cb act_cb,
/* zmRecalculate *******************************************************/
-static BOOL zmRecalculate(ZMapWindow *window, ZMapCallbackData *zMapCBData)
+static BOOL zmRecalculate(ZMapWindow window, ZMapCallbackData *zMapCBData)
{
/* derive the region for which we need data. */
int min, max;
Calc_cb calc_cb = zMapCBData->calc_cb;
- min = zmCoordFromScreen(window->focuspane, 0);
- max = zmCoordFromScreen(window->focuspane, window->focuspane->graphHeight);
+ min = zmCoordFromScreen(zMapWindowGetFocuspane(window), 0);
+ max = zmCoordFromScreen(zMapWindowGetFocuspane(window),
+ zMapWindowGetHeight(window));
if (min < 0)
min = 0;
- if (max > window->focuspane->zMapRegion->length)
- max = window->focuspane->zMapRegion->length;
+ if (max > zMapWindowGetRegionLength(window))
+ max = zMapWindowGetRegionLength(window);
- if (min >= window->focuspane->zMapRegion->area1 &&
- max <= window->focuspane->zMapRegion->area2)
+ if (min >= zMapWindowGetRegionArea(window, 1) &&
+ max <= zMapWindowGetRegionArea(window, 2))
return FALSE; /* already covers area. */
min -= 100000;
@@ -148,21 +130,24 @@ static BOOL zmRecalculate(ZMapWindow *window, ZMapCallbackData *zMapCBData)
if (min < 0)
min = 0;
- if (max > window->focuspane->zMapRegion->length)
- max = window->focuspane->zMapRegion->length;
+ if (max > zMapWindowGetRegionLength(window))
+ max = zMapWindowGetRegionLength(window);
- (*calc_cb)(zMapCBData->seqRegion, min, max, window->focuspane->zMapRegion->rootIsReverse);
+ (*calc_cb)(zMapCBData->seqRegion, min, max,
+ zMapWindowGetRegionReverse(window));
- buildCols(window->focuspane);
+ buildCols(zMapWindowGetFocuspane(window));
return TRUE;
}
-void zmRegBox(ZMapPane *pane, int box, ZMapColumn *col, void *arg)
+void zmRegBox(ZMapPane pane, int box, ZMapColumn *col, void *arg)
{
- array(pane->box2col, box, ZMapColumn *) = col;
- array(pane->box2seg, box, void *) = arg;
+ zMapPaneSetBox2Col(pane, col, box);
+ zMapPaneSetBox2Seg(pane, arg, box);
+
+ return;
}
@@ -175,50 +160,58 @@ static void zMapPick(int box, double x, double y)
if (oldWindow && oldBox)
{
- col = arr(oldWindow->box2col, oldBox, ZMapColumn *);
- seg = arr(oldWindow->box2seg, oldBox, void *);
+ col = zMapPaneGetBox2Col(*oldWindow, oldBox);
+ seg = zMapPaneGetBox2Seg(*oldWindow, oldBox);
if (col && seg && col->selectFunc)
- (*col->selectFunc)(oldWindow, col, seg, oldBox, x, y, FALSE);
+ (*col->selectFunc)(*oldWindow, col, seg, oldBox, x, y, FALSE);
oldBox = 0;
oldWindow = NULL;
}
- if (graphAssFind(&winAssoc, &oldWindow))
+ // if (graphAssFind(&winAssoc, &oldWindow))
+ if (oldWindow)
{
oldBox = box;
- col = arr(oldWindow->box2col, oldBox, ZMapColumn *);
- seg = arr(oldWindow->box2seg, oldBox, void *);
+ col = zMapPaneGetBox2Col(*oldWindow, oldBox);
+ seg = zMapPaneGetBox2Seg(*oldWindow, oldBox);
if (col && seg && col->selectFunc)
- (*col->selectFunc)(oldWindow, col, seg, oldBox, x, y, TRUE);
+ (*col->selectFunc)(*oldWindow, col, seg, oldBox, x, y, TRUE);
}
}
-static void drawWindow(ZMapPane *pane)
+static void drawWindow(ZMapPane pane)
{
float offset = 5;
float maxOffset = 0;
int frameCol, i, frame = -1;
float oldPriority = -100000;
- graphActivate(pane->graph);
- graphClear();
- graphColor(BLACK);
- graphRegister (PICK,(GraphFunc) zMapPick);
+ // graphActivate(pane->graph);
+ // graphClear();
+ // graphColor(BLACK);
+ // graphRegister (PICK,(GraphFunc) zMapPick);
- pane->box2col = arrayReCreate(pane->box2col, 500, ZMapColumn *);
- pane->box2seg = arrayReCreate(pane->box2seg, 500, SEG *);
- if (pane->drawHandle)
- handleDestroy(pane->drawHandle);
- pane->drawHandle = handleHandleCreate(pane->window->handle);
+ // pane->box2col = arrayReCreate(pane->box2col, 500, ZMapColumn *);
+ // pane->box2seg = arrayReCreate(pane->box2seg, 500, SEG *);
+
+ zMapPaneFreeBox2Col(pane);
+ zMapPaneFreeBox2Seg(pane);
+ zMapPaneNewBox2Col(pane, 500);
+ zMapPaneNewBox2Seg(pane, 500);
+
+ // if (pane->drawHandle)
+ // handleDestroy(pane->drawHandle);
+ // pane->drawHandle = handleHandleCreate(zMapWindowGetHandle(pane->window));
+ // pane->drawHandle = NULL;
- for (i = 0; i < arrayMax(pane->cols); i++)
+ for (i = 0; i < zMapPaneGetCols(pane)->len; i++)
{
- ZMapColumn *col = arrp(pane->cols, i, ZMapColumn);
+ ZMapColumn *col = g_ptr_array_index(zMapPaneGetCols(pane), i);
float offsetSave = -1;
/* frame : -1 -> No frame column.
@@ -236,7 +229,7 @@ static void drawWindow(ZMapPane *pane)
/* in frame mode and reached end of framed columns: backtrack */
frame++;
i = frameCol;
- col = arrp(pane->cols, i, ZMapColumn);
+ col = g_ptr_array_index(zMapPaneGetCols(pane), i);
}
else if ((frame == 2) && !col->isFrame)
{
@@ -257,72 +250,13 @@ static void drawWindow(ZMapPane *pane)
}
- graphTextBounds(maxOffset, 0);
+ // graphTextBounds(maxOffset, 0);
- graphRedraw();
+ // graphRedraw();
}
-static void gtk_ifactory_cb (gpointer callback_data,
- guint callback_action,
- GtkWidget *widget)
-{
- g_message ("ItemFactory: activated \"%s\"", gtk_item_factory_path_from_widget (widget));
-}
-
-
-
-/* createZMap ***********************************************************
- * Draws the basics of the window - the trim around it, etc.
- * Creates the main menu and a text entry box, then callse createZMapWindow.
- */
-static void createZMap(ZMapWindow *window, ZMapCallbackData *zMapCallbackData)
-{
- GtkAccelGroup *accel_group = gtk_accel_group_new ();
- static GtkItemFactoryEntry menu_items[] =
- {
- { "/_File", NULL, 0, 0, "<Branch>" },
- { "/File/_Print", "<control>P", gtk_ifactory_cb, 0 },
- { "/File/Print _Whole","<control>W", gtk_ifactory_cb, 0 },
- { "/File/P_reserve", "<control>r", gtk_ifactory_cb, 0 },
- { "/File/_Recalculate",NULL, gtk_ifactory_cb, 0 },
- { "/File/sep1", NULL, gtk_ifactory_cb, 0, "<Separator>" },
- { "/File/_Quit", "<control>Q", gtk_ifactory_cb, 0 },
- { "/_Export", NULL, 0, 0, "<Branch>" },
- { "/Export/_Features", NULL, gtk_ifactory_cb, 0 },
- { "/Export/_Sequence", NULL, gtk_ifactory_cb, 0 },
- { "/Export/_Transalations", NULL, gtk_ifactory_cb, 0 },
- { "/Export/_EMBL dump", NULL, gtk_ifactory_cb, 0 },
- { "/_Help", NULL, 0, 0, "<LastBranch>" },
- { "/Help/_About", NULL, gtk_ifactory_cb, 0 },
- };
-
- static int nmenu_items = sizeof (menu_items) / sizeof (menu_items[0]);
-
-
- /* create top level window */
- window->window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
- g_signal_connect(GTK_OBJECT(window->window), "destroy",
- GTK_SIGNAL_FUNC(Quit), (gpointer) window);
-
- gtk_widget_set_size_request(window->window, 1000, 750);
- window->vbox1 = gtk_vbox_new(FALSE, 4);
- window->itemFactory = gtk_item_factory_new(GTK_TYPE_MENU_BAR, "<main>", accel_group);
- window->infoSpace = gtk_entry_new();
-
- gtk_window_add_accel_group (GTK_WINDOW(window->window), accel_group);
- gtk_item_factory_create_items (window->itemFactory, nmenu_items, menu_items, NULL);
- gtk_container_add(GTK_CONTAINER(window->window), window->vbox1);
- gtk_box_pack_start(GTK_BOX(window->vbox1),
- gtk_item_factory_get_widget(window->itemFactory, "<main>"),
- FALSE, FALSE, 0);
- gtk_box_pack_start(GTK_BOX(window->vbox1), window->infoSpace, FALSE, FALSE, 0);
-
- createZMapWindow(window, zMapCallbackData);
-}
-
-
/* createZMapWindow ***************************************************************
* Creates the root node in the panesTree (which helps keep track of all the
@@ -334,62 +268,37 @@ static void createZMap(ZMapWindow *window, ZMapCallbackData *zMapCallbackData)
* in as child2.
*/
-static void createZMapWindow(ZMapWindow *window, ZMapCallbackData *zMapCallbackData)
+void createZMapWindow(ZMapWindow window)
{
- GtkWidget *toolbar = gtk_toolbar_new();
- zMapCallbackData->window = window;
- ZMapPane *pane = NULL;
- GtkWidget *hbox = gtk_hbox_new(FALSE, 0);
+ ZMapPane pane = NULL;
- window->panesTree = g_node_new(pane);
-
- window->hbox = gtk_hbox_new(FALSE, 0);
- window->hpane = gtk_hpaned_new();
-
- /* Next into the vbox we pack an hbox to hold two toolbars. This is
- * so the Close Pane button can be far away from the rest, which I like. */
- gtk_box_pack_start(GTK_BOX(window->vbox1), hbox, FALSE, FALSE, 0);
- gtk_box_pack_start(GTK_BOX(hbox), toolbar, FALSE, FALSE, 0);
-
- gtk_toolbar_append_item(GTK_TOOLBAR(toolbar), "H-Split", "2 panes, one above the other" , NULL, NULL,
- GTK_SIGNAL_FUNC(splitPane),
- (gpointer)window);
-
- gtk_toolbar_append_item(GTK_TOOLBAR(toolbar), "Clear", NULL, NULL, NULL,
- NULL, NULL);
- gtk_toolbar_append_item(GTK_TOOLBAR(toolbar), "Rev-Comp", NULL, NULL, NULL,
- NULL, NULL);
- gtk_toolbar_append_item(GTK_TOOLBAR(toolbar), "DNA", NULL, NULL, NULL,
- NULL, NULL);
- gtk_toolbar_append_item(GTK_TOOLBAR(toolbar), "GeneFind", NULL, NULL, NULL,
- NULL, NULL);
- gtk_toolbar_append_item(GTK_TOOLBAR(toolbar), "Origin", NULL, NULL, NULL,
- NULL, NULL);
- gtk_toolbar_append_item(GTK_TOOLBAR(toolbar), "V-Split", "2 panes, side by side", NULL, NULL,
- GTK_SIGNAL_FUNC(splitHPane),
- (gpointer)window);
-
- toolbar = gtk_toolbar_new();
- gtk_box_pack_end(GTK_BOX(hbox), toolbar, FALSE, FALSE, 0);
-
- gtk_toolbar_append_item(GTK_TOOLBAR(toolbar), "Close\nPane", NULL, NULL, NULL,
- GTK_SIGNAL_FUNC(closePane),
- (gpointer)window);
+ zMapWindowSetPanesTree(window, g_node_new(pane));
+ zMapWindowSetHpane(window, gtk_hpaned_new());
/* After the toolbars comes an hpane, so the user can adjust the width
* of the navigator pane */
- gtk_box_pack_start(GTK_BOX(window->vbox1), window->hpane, TRUE, TRUE, 0);
+ gtk_container_add(GTK_CONTAINER(zMapWindowGetFrame(window)), zMapWindowGetHpane(window));
+ zMapWindowSetNavigator(window, gtk_scrolled_window_new(NULL, NULL));
+ gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(zMapWindowGetNavigator(window)),
+ GTK_POLICY_NEVER, GTK_POLICY_NEVER);
+ gtk_widget_set_size_request(zMapWindowGetNavigator(window), 100, -1);
+
/* leave window->navigator in place until navcanvas works */
- window->navigator = graphNakedCreate(TEXT_FIT, "", 20, 100, FALSE) ;
- gtk_widget_set_size_request(gexGraph2Widget(window->navigator), 50, -1);
- gtk_paned_pack1(GTK_PANED(window->hpane), gexGraph2Widget(window->navigator),
+ // zMapWindowSetNavigator(window, graphNakedCreate(TEXT_FIT, "", 20, 100, FALSE)) ;
+ // gtk_widget_set_size_request(gexGraph2Widget(zMapWindowGetNavigator(window)), 50, -1);
+
+ gtk_paned_pack1(GTK_PANED(zMapWindowGetHpane(window)),
+ zMapWindowGetNavigator(window),
TRUE, TRUE);
/* create the splittable pane and pack it into the hpane as child2. */
- zMapZoomToolbar(window, zMapCallbackData);
- gtk_widget_set_size_request(window->zoomvbox, 750, -1);
- gtk_paned_pack2(GTK_PANED(window->hpane), window->zoomvbox, TRUE, TRUE);
+ zMapZoomToolbar(window);
+
+ gtk_widget_set_size_request(zMapWindowGetZoomVbox(window), 750, -1);
+ gtk_paned_pack2(GTK_PANED(zMapWindowGetHpane(window)),
+ zMapWindowGetZoomVbox(window)
+ , TRUE, TRUE);
return;
}
@@ -400,167 +309,33 @@ static void createZMapWindow(ZMapWindow *window, ZMapCallbackData *zMapCallbackD
* sets up a bare graph. Calls addPane to add the actual data display panel.
* I suspect we'll end up putting the zoom buttons on the top menu line.
*/
-static void zMapZoomToolbar(ZMapWindow *window, ZMapCallbackData *zMapCallbackData)
+static void zMapZoomToolbar(ZMapWindow window)
{
GtkWidget *toolbar = gtk_toolbar_new();
- window->zoomvbox = gtk_vbox_new(FALSE,0);
-
- /* build the zoom toolbar */
- gtk_toolbar_append_item(GTK_TOOLBAR(toolbar), "Zoom In", NULL, NULL, NULL,
- GTK_SIGNAL_FUNC(zoomIn), (gpointer) window);
+ zMapWindowSetZoomVbox(window, gtk_vbox_new(FALSE,0));
- gtk_toolbar_append_item(GTK_TOOLBAR(toolbar), "Zoom Out", NULL, NULL, NULL,
- GTK_SIGNAL_FUNC(zoomOut), (gpointer) window);
- // GTK_SIGNAL_FUNC(zoomOut), (gpointer)zMapCallbackData);
-
- /* add zoom toolbar and scrolling window to vbox */
- gtk_box_pack_start(GTK_BOX(window->zoomvbox), toolbar, FALSE, FALSE, 0);
addPane(window, 'v');
-
- return;
-}
-
-
-/* addPane is called each time we add a new pane. Creates a new frame, scrolled
- * window and canvas. First time through it sticks them in the window->zoomvbox,
- * thereafter it packs them into the lower part of the focus pane.
- *
- * Splitting goes like this: we make a (h or v) pane, add a new frame to the child1
- * position of that, then reparent the scrolled window containing the canvas into
- * the new frame. That's the shrinkPane() function.
- * 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)
-{
- ZMapPane *pane = (ZMapPane*)malloc(sizeof(ZMapPane));
- GtkAdjustment *adj;
- GtkWidget *w;
- GNode *node = NULL;
-
- /* set up ZMapPane for this window */
- pane->window = window;
- pane->DNAwidth = 100;
- pane->step_increment = 10;
-
- /* create the bare graph & convert to a widget */
- /* pane->graph = graphNakedCreate(TEXT_FIT, "", 20, 100, TRUE);
- pane->graphWidget = gexGraph2Widget(pane->graph);*/
-
- pane->cols = arrayHandleCreate(50, ZMapColumn, window->handle);
- pane->box2col = NULL;
- pane->box2seg = NULL;
- pane->drawHandle = NULL;
- pane->frame = gtk_frame_new(NULL);
- pane->scrolledWindow = gtk_scrolled_window_new (NULL, NULL);
-
- /* The idea of the GNode tree is that panes split horizontally, ie
- * one above the other, end up as siblings in the tree, while panes
- * 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 (window->firstTime)
- {
- pane->zoomFactor = 1;
- g_node_append_data(window->panesTree, pane);
- }
- else
- {
- pane->zoomFactor = window->focuspane->zoomFactor;
- node = g_node_find (window->panesTree,
- G_IN_ORDER,
- G_TRAVERSE_ALL,
- window->focuspane);
- if (orientation == 'h')
- g_node_append_data(node->parent, pane);
- else
- g_node_append_data(node, pane);
- }
-
- /* draw the canvas */
- gdk_rgb_init();
- w = foo_canvas_new();
-
- pane->canvas = FOO_CANVAS(w);
- foo_canvas_set_scroll_region(pane->canvas, 0.0, 0.0, 1000, 1000);
- pane->background = foo_canvas_item_new(foo_canvas_root(pane->canvas),
- foo_canvas_rect_get_type(),
- "x1",(double)0,
- "y1",(double)0,
- "x2",(double)1000,
- "y2",(double)1000,
- "fill_color", "white",
- "outline_color", "dark gray",
- NULL);
-
- /* when the user clicks a button in the view, call recordFocus() */
- g_signal_connect (GTK_OBJECT (pane->canvas), "button_press_event",
- GTK_SIGNAL_FUNC (recordFocus), pane);
-
- pane->group = foo_canvas_item_new(foo_canvas_root(pane->canvas),
- foo_canvas_group_get_type(),
- "x", (double)100,
- "y", (double)100 ,
- NULL);
-
- /* add the canvas to the scrolled window */
- gtk_container_add(GTK_CONTAINER(pane->scrolledWindow),w);
-
- /* you have to set the step_increment manually or the scrollbar arrows don't work.*/
- /* Using a member of ZMapPane means I can adjust it if necessary when we zoom. */
- GTK_LAYOUT (w)->vadjustment->step_increment = pane->step_increment;
- GTK_LAYOUT (w)->hadjustment->step_increment = pane->step_increment;
-
- /* add the scrolled window to the frame */
- gtk_container_add(GTK_CONTAINER(pane->frame),pane->scrolledWindow);
-
- /* First time through, we add the frame to the main vbox.
- * Subsequently it goes in the lower half of the current pane. */
- if (window->firstTime)
- gtk_box_pack_start(GTK_BOX(window->zoomvbox), pane->frame, TRUE, TRUE, 0);
- else
- gtk_paned_pack2(GTK_PANED(window->focuspane->pane), pane->frame, TRUE, TRUE);
-
-
- /* always show scrollbars, however big the display */
- gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(pane->scrolledWindow),
- GTK_POLICY_ALWAYS, GTK_POLICY_ALWAYS);
-
- 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));
-
- /* 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 (!window->firstTime)
- gtk_widget_show_all (window->window);
-
- window->firstTime = FALSE;
-
- zmMainScale(pane->canvas, 30, 0, 1000);
drawGene(window);
- columnOfBoxes(window);
+ // columnOfBoxes(window);
return;
}
/* This is just a noddy function I used to draw a small box on the canvas */
-static void drawBox (FooCanvasItem *group, double x, double y, char *line_colour, char *fill_colour)
+void drawBox (FooCanvasItem *group, double x1, double y1,
+ double x2, double y2,
+ char *line_colour, char *fill_colour)
{
foo_canvas_item_new(FOO_CANVAS_GROUP(group),
foo_canvas_rect_get_type(),
- "x1" , (double)x ,
- "y1" , (double)y ,
- "x2" , (double)x+14.0,
- "y2" , (double)y+3.0,
+ "x1" , (double)x1 ,
+ "y1" , (double)y1 ,
+ "x2" , (double)x2,
+ "y2" , (double)y2,
"outline_color", line_colour ,
"fill_color" , fill_colour ,
"width_units" , (double)1,
@@ -571,7 +346,7 @@ static void drawBox (FooCanvasItem *group, double x, double y, char *line_colour
}
/* This is just a noddy function I used to draw a line on the canvas */
-static void drawLine(FooCanvasGroup *group, double x1, double y1, double x2, double y2,
+void drawLine(FooCanvasGroup *group, double x1, double y1, double x2, double y2,
char *colour, double thickness)
{
FooCanvasPoints *points;
@@ -599,11 +374,13 @@ static void drawLine(FooCanvasGroup *group, double x1, double y1, double x2, dou
}
-static void drawGene(ZMapWindow *window)
+static void drawGene(ZMapWindow window)
{
FooCanvasItem *group;
+ ZMapPane pane = zMapWindowGetFocuspane(window);
+ FooCanvas *canvas = zMapPaneGetCanvas(pane);
- group = foo_canvas_item_new(foo_canvas_root(window->focuspane->canvas),
+ group = foo_canvas_item_new(foo_canvas_root(canvas),
foo_canvas_group_get_type(),
"x", (double)100,
"y", (double)100 ,
@@ -611,7 +388,7 @@ static void drawGene(ZMapWindow *window)
//group = window->focuspane->group;
- drawBox(group, 0.0, 220.0 ,"light blue", "white");
+ /* drawBox(group, 0.0, 220.0 ,"light blue", "white");
drawBox(group, 0.0, 260.0 ,"light blue", "white");
drawBox(group, 0.0, 300.0 ,"light blue", "white");
drawBox(group, 0.0, 320.0 ,"light blue", "white");
@@ -655,27 +432,29 @@ static void drawGene(ZMapWindow *window)
drawLine(FOO_CANVAS_GROUP(group), 34.0, 400.0, 27.0, 420.0, "red", 1.0);
drawLine(FOO_CANVAS_GROUP(group), 27.0, 423.0, 34.0, 440.0, "red", 1.0);
drawLine(FOO_CANVAS_GROUP(group), 34.0, 440.0, 27.0, 460.0, "red", 1.0);
-
+ */
return;
}
-static void columnOfBoxes(ZMapWindow *window)
+static void columnOfBoxes(ZMapWindow window)
{
- int space[12] = {1,6,9,4,5,2,8,3,7,1,6};
+ /* int space[12] = {1,6,9,4,5,2,8,3,7,1,6};
int i, j;
double y = 0;
FooCanvasItem *group;
+ ZMapPane pane = zMapWindowGetFocuspane(window);
+ FooCanvas *canvas = zMapPaneGetCanvas(pane);
- group = foo_canvas_item_new(foo_canvas_root(window->focuspane->canvas),
+ group = foo_canvas_item_new(foo_canvas_root(canvas),
foo_canvas_group_get_type(),
"x", (double)100,
"y", (double)100 ,
NULL);
-
+ */
//group = window->focuspane->group;
-
+ /*
for (i=0; i<20; i++)
{
for (j=0; j<10; j++)
@@ -685,14 +464,14 @@ static void columnOfBoxes(ZMapWindow *window)
}
}
- group = foo_canvas_item_new(foo_canvas_root(window->focuspane->canvas),
+ group = foo_canvas_item_new(foo_canvas_root(canvas),
foo_canvas_group_get_type(),
"x", (double)100,
"y", (double)100 ,
NULL);
-
+ */
//group = window->focuspane->group;
-
+ /*
for (i=0, y=0; i<20; i++)
{
for (j=1; j<11; j++)
@@ -702,14 +481,14 @@ static void columnOfBoxes(ZMapWindow *window)
}
}
- group = foo_canvas_item_new(foo_canvas_root(window->focuspane->canvas),
+ group = foo_canvas_item_new(foo_canvas_root(canvas),
foo_canvas_group_get_type(),
"x", (double)100,
"y", (double)100 ,
NULL);
-
+ */
//group = window->focuspane->group;
-
+ /*
for (i=0, y=0; i<20; i++)
{
for (j=2; j<12; j++)
@@ -718,6 +497,7 @@ static void columnOfBoxes(ZMapWindow *window)
y += space[j];
}
}
+ */
return;
}
@@ -732,11 +512,7 @@ static void displayText(FooCanvasGroup *group, char *text, double x, double y)
}
-/* This is commented out because I started trying to draw a scalebar after
- * I first put in some of the gnomecanvas stuff, but never succeeded completely.
- * However, when I went away to work on splitting the window, I didn't want to
- * throw this away completely. */
-static float zmMainScale(FooCanvas *canvas, float offset, int start, int end)
+float zmMainScale(FooCanvas *canvas, float offset, int start, int end)
{
int x, width = 5, count;
FooCanvasItem *group;
@@ -765,93 +541,57 @@ static float zmMainScale(FooCanvas *canvas, float offset, int start, int end)
-/* This is the original zmDrawScale I inherited which draws a neat scalebar
- * in the navigator. It used to do so in the main display panel, until I
- * started using the canvas. */
-float zmDrawScale(float offset, int start, int end)
+static void navScale(FooCanvas *canvas, float offset, int start, int end)
{
- int height;
- int unit, subunit, type, unitType ;
- int x, width = 0 ;
- float mag, cutoff;
- char *cp, unitName[] = { 0, 'k', 'M', 'G', 'T', 'P' }, buf[2] ;
-
- graphFitBounds(NULL, &height);
-
- mag = (float)height/((float)(end - start));
- cutoff = 5/mag;
- unit = subunit = 1.0 ;
-
- if (cutoff < 0)
- cutoff = -cutoff ;
-
- while (unit < cutoff)
- { unit *= 2 ;
- subunit *= 5 ;
- if (unit >= cutoff)
- break ;
- unit *= 2.5000001 ;
- if (unit >= cutoff)
- break ;
- unit *= 2 ;
- subunit *= 2 ;
- }
- subunit /= 10 ;
- if (subunit < 1.0)
- subunit = 1.0 ;
-
- for (type = 1, unitType = 0 ; unit > 0 && 1000 * type < unit && unitType < 5;
- unitType++, type *= 1000) ;
-
- if (x>0)
- x = ((start/unit)+1)*unit;
- else
- x = ((start/unit)-1)*unit;
-
- for (; x < end ; x += unit)
- {
- ScreenCoord y = (float)(x-start)*mag;
- graphLine (offset, y, offset, y) ;
- buf[0] = unitName[unitType] ; buf[1] = 0 ;
- cp = messprintf ("%d%s", x/type, buf) ;
- if (width < strlen (cp))
- width = strlen (cp) ;
- graphText (cp, offset+1.5, y-0.5) ;
- }
-
+ int x, width = 5, count;
+ FooCanvasItem *group;
- for (x = ((start/unit)-1)*unit ; x < end ; x += subunit)
+ group = foo_canvas_item_new(foo_canvas_root(canvas),
+ foo_canvas_group_get_type(),
+ "x",(double)offset,
+ "y",(double)0.0,
+ NULL);
+
+ for (x = start, count = 1 ; x < end ; x += 10, count++)
{
- ScreenCoord y = (float)(x-start)*mag;
- graphLine (offset+0.5, y, offset+1, y) ;
+ drawLine(FOO_CANVAS_GROUP(group), offset-5, x, offset, x, "black", 1.0);
+ char text[25];
+ sprintf(text,"%dk", x);
+ if (count == 1)
+ displayText(FOO_CANVAS_GROUP(group), text, offset + 20, x);
+ if (count > 9) count = 0;
}
- graphLine (offset+1, 0, offset+1, height) ;
- return offset + width + 4 ;
+ drawLine(FOO_CANVAS_GROUP(group), offset+1, 0, offset+1, end, "black", 1.0);
+ return;
}
+
+
static int dragBox;
-/* I believe is only called by navPick */
+/* I believe navDrag is only called by navPick. Since I don't
+** know what navPick is doing, and don't now know what
+** navDrag is doing, I'm going to comment most of it out. */
static void navDrag(float *x, float *y, BOOL isDone)
{
static BOOL isDragging = FALSE;
static float oldY;
- ZMapWindow *window;
- ZMapPane *pane;
+ ZMapWindow window;
+ ZMapPane pane;
Coord startWind, endWind;
ScreenCoord startWindf, endWindf, lenWindf;
int height;
- graphFitBounds(NULL, &height);
- graphAssFind(&navAssoc, &window);
+ // graphFitBounds(NULL, &height);
+ // graphAssFind(&navAssoc, &window);
- if (dragBox == window->focuspane->dragBox)
+ /* if (dragBox == zMapWindowGetFocuspane(window)->dragBox)
{
- pane = window->focuspane;
- *x = window->scaleOffset - 0.3;
+ pane = zMapWindowGetFocuspane(window);
+ *x = zMapWindowGetScaleOffset(window) - 0.3;
}
else
return;
@@ -859,8 +599,15 @@ static void navDrag(float *x, float *y, BOOL isDone)
startWind = zmCoordFromScreen(pane, 0);
endWind = zmCoordFromScreen(pane, pane->graphHeight);
- startWindf = height * (startWind - window->navStart)/(window->navEnd - window->navStart);
- endWindf = height * (endWind - window->navStart)/(window->navEnd - window->navStart);
+ startWindf = zMapWindowGetScreenCoord(window, startWind, height);
+ endWindf = zMapWindowGetScreenCoord(window, endWind, height);
+ */
+ // startWindf = height * (startWind - zMapWindowGetCoord(window, "s"))
+ // / (zMapWindowGetCoord(window, "e") - zMapWindowGetCoord(window, "s"));
+
+ // endWindf = height * (endWind - zMapWindowGetCoord(window, "s"))
+ // / (zMapWindowGetCoord(window, "e") - zMapWindowGetCoord(window, "s"));
+ /*
lenWindf = endWindf - startWindf;
@@ -878,201 +625,180 @@ static void navDrag(float *x, float *y, BOOL isDone)
if (isDone)
{
isDragging = FALSE;
- pane->centre = srInvarCoord(window->focuspane->zMapRegion,
- srCoord(window->focuspane->zMapRegion, pane->centre) -
- (oldY - *y) * (float)(window->navEnd - window->navStart)/(float)height);
-
+ pane->centre = srInvarCoord(zMapWindowGetFocuspane(window)->zMapRegion,
+ srCoord(zMapWindowGetFocuspane(window)->zMapRegion, pane->centre) -
+ (oldY - *y) * (float)(zMapWindowGetCoord(window, "e") - zMapWindowGetCoord(window, "s"))/(float)height);
+ */
/* TO DO: how do I get a zMapCBData into navDrag?
ANS: when I convert the graphRegister to a g_signal_connect I can do that.
if (zmRecalculate(window, zMapCBData))
drawNavigator(window);
*/
printf("Well, I'm in navDrag\n");
-
- drawWindow(pane);
- graphActivate(window->navigator);
- }
+
+ // we don't have a pane or window, so can't do anything with them here.
+ // drawWindow(pane);
+ // graphActivate(zMapWindowGetNavigator(window));
+ // }
}
+/* not sure what navPick is supposed to do, so not
+** going to give it a signal_connect for now. Params
+** are all wrong, anyway. */
static void navPick(int box, double x, double y)
{
- ZMapWindow *window;
+ ZMapWindow window;
- graphAssFind(&navAssoc, &window);
+ // graphAssFind(&navAssoc, &window);
- if (box == window->focuspane->dragBox)
+ // if (box == zMapWindowGetFocuspane(window)->dragBox)
{
dragBox = box;
- graphBoxDrag(box, navDrag);
+ // graphBoxDrag(box, navDrag);
}
}
static void navResize(void)
{
- ZMapWindow *window;
+ ZMapWindow window;
- if (graphAssFind(&navAssoc, &window))
+ // if (graphAssFind(&navAssoc, &window))
drawNavigator(window);
}
-static void navChange(GtkAdjustment *adj, gpointer p)
+void navChange(GtkAdjustment *adj, gpointer p)
{
- ZMapPane *pane = (ZMapPane *)p;
+ ZMapPane pane = (ZMapPane)p;
- drawNavigator(pane->window);
+ drawNavigator(zMapPaneGetZMapWindow(pane));
}
-static void drawNavigator(ZMapWindow *window)
+static void drawNavigator(ZMapWindow window)
{
int height;
ScreenCoord startCalcf, endCalcf;
int areaSize;
+ GtkWidget *w;
+ GtkRequisition req;
- graphActivate(window->navigator);
- graphAssociate(&navAssoc, window);
- graphRegister (PICK,(GraphFunc) navPick) ;
- graphRegister(RESIZE, (GraphFunc) navResize);
- graphClear();
+ // graphActivate(zMapWindowGetNavigator(window));
+ // graphAssociate(&navAssoc, window);
+ // graphRegister (PICK,(GraphFunc) navPick) ;
+ // graphRegister(RESIZE, (GraphFunc) navResize);
+ // graphClear();
- graphFitBounds(NULL, &height);
+ // graphFitBounds(NULL, &height);
- areaSize = window->focuspane->zMapRegion->area2 - window->focuspane->zMapRegion->area1;
+ areaSize = zMapWindowGetRegionSize(window);
if (areaSize < 1) areaSize = 1;
- window->navStart = window->focuspane->zMapRegion->area1 - areaSize/2;
- window->navEnd = window->focuspane->zMapRegion->area2 + areaSize/2;
- if (window->navStart == window->navEnd) window->navEnd = window->navStart + 1;
+ zMapWindowSetCoord(window, "s", areaSize/2);
+ zMapWindowSetCoord(window, "e", areaSize/2);
+ startCalcf = zMapWindowGetScreenCoord1(window, height);
+ endCalcf = zMapWindowGetScreenCoord2(window, height);
- startCalcf = height * (window->focuspane->zMapRegion->area1 - window->navStart)/(window->navEnd - window->navStart);
- endCalcf = height * (window->focuspane->zMapRegion->area2 - window->navStart)/(window->navEnd - window->navStart);
-
- graphColor(LIGHTGRAY);
- graphFillRectangle(0, startCalcf, 100.0, endCalcf);
- /*
- foo_canvas_item_new(foo_canvas_window(window->navcanvas),
+ w = foo_canvas_new();
+
+ zMapWindowSetNavCanvas(window, FOO_CANVAS(w));
+ foo_canvas_set_scroll_region(zMapWindowGetNavCanvas(window), 0.0, 0.0, 200.0, 500.0);
+
+ foo_canvas_item_new(foo_canvas_root(zMapWindowGetNavCanvas(window)),
foo_canvas_rect_get_type(),
- "x1",(double)0,
- "y1",(double)startCalcf,
- "x2",(double)100,
- "y2",(double)endCalcf,
- "fill_color", "lightgray",
+ "x1",(double)0.0,
+ "y1",(double)0.0,
+ "x2",(double)200.0,
+ "y2",(double)500.0,
+ "fill_color", "white",
NULL);
- */
- graphColor(BLACK);
- window->scaleOffset = zmDrawScale(1.0, window->navStart, window->navEnd);
- drawNavigatorWind(window->focuspane);
+ // g_signal_connect(GTK_OBJECT(zMapWindowGetNavCanvas(window)), "event",
+ // GTK_SIGNAL_FUNC(navPick), (gpointer) zMapWindowGetNavCanvas(window));
+
+ // graphColor(BLACK);
+
+ zMapWindowSetScaleOffset(window,
+ zmMainScale(zMapWindowGetNavCanvas(window),
+ 1.0, zMapWindowGetCoord(window, "s"),
+ zMapWindowGetCoord(window, "e")));
+ drawNavigatorWind(zMapWindowGetFocuspane(window));
- graphRedraw();
+ gtk_container_add(GTK_CONTAINER(zMapWindowGetNavigator(window)), w);
+
+ navScale(FOO_CANVAS(w), 10, 0, 1000);
+
+ // graphRedraw();
}
-static void navUpdate(GtkAdjustment *adj, gpointer p)
+void navUpdate(GtkAdjustment *adj, gpointer p)
{
- ZMapPane *pane = (ZMapPane *)p;
- ZMapWindow *window = pane->window;
+ 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(window->window))
+ if (!GTK_WIDGET_REALIZED(zMapWindowGetFrame(window)))
return;
- graphActivate(window->navigator);
- graphFitBounds(NULL, &height);
- graphBoxDim(pane->scrollBox, &x1, &y1, &x2, &y2);
+ // graphActivate(zMapWindowGetNavigator(window));
+ // graphFitBounds(NULL, &height);
+ // graphBoxDim(pane->scrollBox, &x1, &y1, &x2, &y2);
startWind = zmCoordFromScreen(pane, 0);
- endWind = zmCoordFromScreen(pane, pane->graphHeight);
+ endWind = zmCoordFromScreen(pane, zMapPaneGetHeight(pane));
- startWindf = height * (startWind - window->navStart)/(window->navEnd - window->navStart);
- endWindf = height * (endWind - window->navStart)/(window->navEnd - window->navStart);
+ 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);
+ // graphBoxShift(pane->scrollBox, x1, startScreenf);
}
-static void drawNavigatorWind(ZMapPane *pane)
-{
- ZMapWindow *window = pane->window;
- int height;
- Coord startWind, endWind;
- ScreenCoord startWindf, endWindf, lenWindf;
- ScreenCoord startScreenf, endScreenf;
- ScreenCoord pos;
-
- GtkAdjustment *adj = gtk_scrolled_window_get_vadjustment(GTK_SCROLLED_WINDOW(pane->scrolledWindow));
- graphFitBounds(NULL, &height);
-
- startWind = zmCoordFromScreen(pane, 0);
- endWind = zmCoordFromScreen(pane, pane->graphHeight);
-
- startWindf = height * (startWind - window->navStart)/(window->navEnd - window->navStart);
- endWindf = height * (endWind - window->navStart)/(window->navEnd - window->navStart);
- lenWindf = endWindf - startWindf;
-
- startScreenf = startWindf + lenWindf * (adj->value - adj->lower)/(adj->upper - adj->lower) ;
- endScreenf = startWindf + lenWindf * (adj->page_size + adj->value - adj->lower)/(adj->upper - adj->lower) ;
-
- graphColor(BLACK);
-
- if (pane == window->focuspane)
- pos = window->scaleOffset;
- else
- pos = window->scaleOffset + 1.0;
-
- pane->dragBox = graphBoxStart();
- graphLine(pos, startWindf, pos, endWindf);
- pane->scrollBox = graphBoxStart();
- graphColor(GREEN);
- graphFillRectangle(pos - 0.3, startScreenf, pos + 0.5, endScreenf);
- graphBoxEnd();
- graphBoxSetPick(pane->scrollBox, FALSE);
- graphBoxEnd();
- graphBoxDraw(pane->dragBox, -1, LIGHTGRAY);
-
-}
-
/* Coordinate stuff ****************************************************/
-VisibleCoord zmVisibleCoord(ZMapWindow *window, Coord coord)
+VisibleCoord zmVisibleCoord(ZMapWindow window, Coord coord)
{
- return coord - srCoord(window->focuspane->zMapRegion, window->origin) + 1;
+ ZMapPane pane = zMapWindowGetFocuspane(window);
+ ZMapRegion *region = zMapPaneGetZMapRegion(pane);
+
+ return coord - srCoord(region, zMapWindowGetOrigin(window)) + 1;
}
-ScreenCoord zmScreenCoord(ZMapPane *pane, Coord coord)
+ScreenCoord zmScreenCoord(ZMapPane pane, Coord coord)
{
- Coord basesFromCent = coord - srCoord(pane->window->focuspane->zMapRegion, pane->centre);
- float linesFromCent = ((float)basesFromCent)/((float)pane->basesPerLine);
+ ZMapRegion *region = zMapPaneGetZMapRegion(pane);
+ Coord basesFromCent = coord - srCoord(region, zMapPaneGetCentre(pane));
+ float linesFromCent = ((float)basesFromCent)/zMapPaneGetBPL(pane);
- return linesFromCent + (float)(pane->graphHeight/2);
+ return linesFromCent + (float)(zMapPaneGetHeight(pane)/2);
}
-Coord zmCoordFromScreen(ZMapPane *pane, ScreenCoord coord)
+Coord zmCoordFromScreen(ZMapPane pane, ScreenCoord coord)
{
- float linesFromCent = coord - (pane->graphHeight/2);
- int basesFromCent = linesFromCent * pane->basesPerLine;
+ float linesFromCent = coord - (zMapPaneGetHeight(pane)/2);
+ int basesFromCent = linesFromCent * zMapPaneGetBPL(pane);
- return srCoord(pane->zMapRegion, pane->centre) + basesFromCent;
+ return srCoord(zMapPaneGetZMapRegion(pane), zMapPaneGetCentre(pane)) + basesFromCent;
}
-BOOL zmIsOnScreen(ZMapPane *pane, Coord coord1, Coord coord2)
+BOOL zmIsOnScreen(ZMapPane pane, Coord coord1, Coord coord2)
{
if (zmScreenCoord(pane, coord2) < 0)
return FALSE;
- if (zmScreenCoord(pane, coord1) > pane->graphHeight)
+ if (zmScreenCoord(pane, coord1) > zMapPaneGetHeight(pane))
return FALSE;
return TRUE;
diff --git a/src/zmapWindow/zmapcontrol.h b/src/zmapWindow/zmapcontrol.h
index c6274101f..913a22b2f 100755
--- a/src/zmapWindow/zmapcontrol.h
+++ b/src/zmapWindow/zmapcontrol.h
@@ -1,4 +1,4 @@
-/* Last edited: May 14 10:34 2004 (rnc) */
+/* Last edited: Jun 25 13:51 2004 (rnc) */
/* file: zmapcontrol.h
* Author: Simon Kelley (srk@sanger.ac.uk)
* Copyright (c) Sanger Institute, 2003
@@ -30,154 +30,51 @@
#include <gtk/gtk.h>
#include <libfoocanvas/libfoocanvas.h>
-#include <zmapcommon.h>
-#include <seqregion.h>
+#include <ZMap/zmapcommon.h>
+#include <../zmapWindow/seqregion.h>
+#include <../zmapControl/ZMap_P.h>
-typedef struct zMapWindow ZMapWindow;
-typedef struct zMapPane ZMapPane;
-
-typedef int VisibleCoord;
-typedef float ScreenCoord;
-typedef char *Base;
-
-
-struct zMapWindow {
- /* Data associated with whole window. */
- STORE_HANDLE handle;
- GtkWidget *window;
- GtkWidget *vbox1;
- GtkItemFactory *itemFactory;
- GtkWidget *infoSpace;
- Graph navigator;
- FooCanvas *navcanvas;
- InvarCoord origin; /* that base which is VisibleCoord 1 */
- GtkWidget *zoomvbox;
- GtkWidget *toolbar;
- GtkWidget *hbox;
- GtkWidget *hpane; /* allows the user to minimise the navigator pane */
- GNode *panesTree;
- ZMapPane *focuspane;
- BOOL firstTime;
- /* navigator stuff */
- Coord navStart, navEnd; /* Start drawing the Nav bar from here */
- ScreenCoord scaleOffset;
-};
-
-struct zMapPane {
- /* Data associated with one scrolling pane. */
- ZMapWindow *window; /* parent */
- ZMapRegion *zMapRegion; /* the region holding all the SEGS */
- Graph graph;
- GtkWidget *graphWidget;
- GtkWidget *vbox;
- GtkWidget *pane;
- GtkWidget *frame;
- GtkWidget *scrolledWindow;
- FooCanvas *canvas; /* where we paint the display */
- FooCanvasItem *background;
- FooCanvasItem *group;
- GtkWidget *combo;
- int basesPerLine;
- InvarCoord centre;
- int graphHeight;
- int dragBox, scrollBox;
- Array cols;
- Array box2seg, box2col;
- STORE_HANDLE drawHandle; /* gets freed on each redraw. */
- int DNAwidth;
- double zoomFactor;
- int step_increment;
- gulong hid1, hid2, hid3;
-};
-
-struct zMapColumn;
-typedef struct zMapColumn ZMapColumn;
-
-/* callback function prototypes********************************
- * These must be here as they're referred to in zMapColumn below
- */
-typedef void (*colDrawFunc) (ZMapPane *pane, ZMapColumn *col,
- float *offset, int frame);
-typedef void (*colConfFunc) (void);
-typedef void (*colInitFunc) (ZMapPane *pane, ZMapColumn *col);
-typedef void (*colSelectFunc)(ZMapPane *pane, ZMapColumn *col,
- void *seg, int box,
- double x, double y,
- BOOL isSelect);
-
-/**************************************************************/
-
-struct zMapColumn {
- ZMapPane *pane;
- colInitFunc initFunc;
- colDrawFunc drawFunc;
- colConfFunc configFunc;
- colSelectFunc selectFunc;
- BOOL isFrame;
- float priority;
- char *name;
- float startx, endx; /* filled in by drawing code */
- methodID meth; /* method */
- srType type;
- void *private;
-};
-
-struct ZMapColDefs {
- colInitFunc initFunc;
- colDrawFunc drawFunc;
- colConfFunc configFunc;
- colSelectFunc selectFunc;
- BOOL isFrame;
- float priority; /* only for default columns. */
- char *name;
- srType type;
-};
-
-
-typedef struct {
- ZMapWindow *window; /* the window pane */
- Calc_cb calc_cb; /* callback routine */
- void *seqRegion; /* AceDB region */
-} ZMapCallbackData;
-
/* function prototypes ************************************/
-BOOL zMapDisplay(Activate_cb act_cb,
- Calc_cb calc_cb,
- void *region,
- char *seqspec,
- char *fromspec,
- BOOL isOldGraph);
+BOOL zMapDisplay(ZMap zmap,
+ Activate_cb act_cb,
+ Calc_cb calc_cb,
+ void *region,
+ char *seqspec,
+ char *fromspec,
+ BOOL isOldGraph);
-void zmRegBox(ZMapPane *pane, int box, ZMapColumn *col, void *seg);
+void zmRegBox(ZMapPane pane, int box, ZMapColumn *col, void *seg);
/* Column drawing code ************************************/
-void zMapFeatureColumn(ZMapPane *pane, ZMapColumn *col,
- float *offset, int frame);
-void zMapDNAColumn (ZMapPane *pane, ZMapColumn *col,
- float *offsetp, int frame);
-void buildCols (ZMapPane *pane);
-void makezMapDefaultColumns(ZMapPane *pane);
+void createZMapWindow (ZMapWindow window);
+void zMapFeatureColumn(ZMapPane pane, ZMapColumn *col,
+ float *offset, int frame);
+void buildCols (ZMapPane pane);
+void makezMapDefaultColumns(ZMapPane pane);
/*float zmDrawScale (FooCanvas *canvas, float offset, int start, int end);*/
-float zmDrawScale (float offset, int start, int end);
-void nbcInit (ZMapPane *pane, ZMapColumn *col);
-void nbcSelect (ZMapPane *pane, ZMapColumn *col,
- void *seg, int box, double x, double y, BOOL isSelect);
-void zMapGeneDraw (ZMapPane *pane, ZMapColumn *col, float *offset, int frame);
-void geneSelect (ZMapPane *pane, ZMapColumn *col,
- void *arg, int box, double x, double y, BOOL isSelect);
+float zmDrawScale (float offset, int start, int end);
+void nbcInit (ZMapPane pane, ZMapColumn *col);
+void nbcSelect (ZMapPane pane, ZMapColumn *col,
+ void *seg, int box, double x, double y, BOOL isSelect);
+void zMapGeneDraw (ZMapPane pane, ZMapColumn *col, float *offset, int frame);
+void geneSelect (ZMapPane pane, ZMapColumn *col,
+ void *arg, int box, double x, double y, BOOL isSelect);
+void drawLine (FooCanvasGroup *group, double x1, double y1, double x2, double y2,
+ char *colour, double thickness);
+void drawBox (FooCanvasItem *group, double x1, double y1,
+ double x2, double y2, char *line_colour, char *fill_colour);
/* other routines *****************************************/
-BOOL zmIsOnScreen (ZMapPane *pane, Coord coord1, Coord coord2);
-VisibleCoord zmVisibleCoord (ZMapWindow *window , Coord coord);
-ScreenCoord zmScreenCoord (ZMapPane *pane, Coord coord);
-Coord zmCoordFromScreen(ZMapPane *pane, ScreenCoord coord);
-void addPane (ZMapWindow *window, char orientation);
-BOOL Quit (GtkWidget *widget, gpointer data);
+BOOL zmIsOnScreen (ZMapPane pane, Coord coord1, Coord coord2);
+VisibleCoord zmVisibleCoord (ZMapWindow window, Coord coord);
+ScreenCoord zmScreenCoord (ZMapPane pane, Coord coord);
+Coord zmCoordFromScreen(ZMapPane pane, ScreenCoord coord);
+BOOL Quit (GtkWidget *widget, gpointer data);
#endif
diff --git a/src/zmapWindow/zmapsplit.c b/src/zmapWindow/zmapsplit.c
index 8734e35ff..d33414b01 100755
--- a/src/zmapWindow/zmapsplit.c
+++ b/src/zmapWindow/zmapsplit.c
@@ -1,4 +1,4 @@
-/* Last edited: May 14 10:33 2004 (rnc) */
+/* Last edited: Jun 28 15:15 2004 (rnc) */
/* file: zmapsplit.c
* Author: Rob Clack (rnc@sanger.ac.uk)
* Copyright (c) Sanger Institute, 2004
@@ -26,18 +26,19 @@
*/
#include <zmapsplit.h>
+#include <zmapWindow_P.h>
/* function prototypes **************************************************/
-static void shrinkPane (ZMapWindow *window);
-static void resizePanes (ZMapWindow *window);
-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 int unfocus (GNode *node, gpointer data);
-static int resizeOneHPane (GNode *node, gpointer data);
-static void exciseNode (GNode *node);
+static void shrinkPane (ZMapWindow window);
+static void resizePanes (ZMapWindow window);
+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 int unfocus (GNode *node, gpointer data);
+static int resizeOneHPane (GNode *node, gpointer data);
+static void exciseNode (GNode *node);
/* end of prototypes ***************************************************/
@@ -65,29 +66,31 @@ static void exciseNode (GNode *node);
* 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(ZMapWindow window, double zoomFactor)
{
- foo_canvas_set_pixels_per_unit_xy(window->focuspane->canvas, 1.0, zoomFactor);
+ foo_canvas_set_pixels_per_unit_xy(zMapWindowGetFocuspane(window)->canvas, 1.0, zoomFactor);
return;
}
void zoomIn(GtkWindow *widget, gpointer data)
{
- ZMapWindow *window = (ZMapWindow*)data;
+ ZMapWindow window = (ZMapWindow)data;
+ ZMapPane pane = zMapWindowGetFocuspane(window);
- window->focuspane->zoomFactor *= 2;
- scaleCanvas(window, window->focuspane->zoomFactor);
+ pane->zoomFactor *= 2;
+
+ scaleCanvas(window, pane->zoomFactor);
return;
}
void zoomOut(GtkWindow *widget, gpointer data)
{
- ZMapWindow *window = (ZMapWindow*)data;
+ ZMapWindow window = (ZMapWindow)data;
- window->focuspane->zoomFactor /= 2;
- scaleCanvas(window, window->focuspane->zoomFactor);
+ zMapWindowGetFocuspane(window)->zoomFactor /= 2;
+ scaleCanvas(window, zMapWindowGetFocuspane(window)->zoomFactor);
return;
}
@@ -96,7 +99,7 @@ void zoomOut(GtkWindow *widget, gpointer data)
* of the prototype it's helpful to have unfocussed backgrounds grey */
static int unfocus(GNode *node, gpointer data)
{
- ZMapPane *pane = (ZMapPane*)node->data;
+ ZMapPane pane = (ZMapPane)node->data;
if (pane) /* skip the actual root node which is not a valid widget */
{
@@ -111,20 +114,20 @@ static int unfocus(GNode *node, gpointer data)
int recordFocus(GtkWidget *widget, GdkEvent *event, gpointer data)
{
- ZMapPane *pane = (ZMapPane*)data;
- ZMapWindow *window = pane->window;
+ ZMapPane pane = (ZMapPane)data;
+ ZMapWindow window = pane->window;
GNode *node;
/* point the parent window's focuspane pointer at this pane */
if (pane)
- window->focuspane = pane;
+ zMapWindowSetFocuspane(window, pane);
else /* if pane is null, arbitrarily focus on the first valid pane */
{
- node = g_node_first_child(window->panesTree);
- window->focuspane = node->data;
+ node = g_node_first_child(zMapWindowGetPanesTree(window));
+ zMapWindowSetFocuspane(window, node->data);
}
- g_node_traverse(window->panesTree,
+ g_node_traverse(zMapWindowGetPanesTree(window),
G_IN_ORDER,
G_TRAVERSE_ALL,
-1,
@@ -141,39 +144,41 @@ int recordFocus(GtkWidget *widget, GdkEvent *event, 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(ZMapWindow window)
{
- ZMapPane *pane = (ZMapPane*)malloc(sizeof(ZMapPane));
+ 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->pane = gtk_vpaned_new();
pane->frame = gtk_frame_new(NULL);;
- pane->scrolledWindow = window->focuspane->scrolledWindow;
- pane->canvas = window->focuspane->canvas;
- pane->background = window->focuspane->background;
+ pane->scrolledWindow = zMapWindowGetFocuspane(window)->scrolledWindow;
+ pane->canvas = zMapWindowGetFocuspane(window)->canvas;
+ pane->background = zMapWindowGetFocuspane(window)->background;
+ pane->zoomFactor = zMapWindowGetFocuspane(window)->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(window->focuspane->scrolledWindow), pane->frame);
+ /* 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_paned_pack1(GTK_PANED(pane->pane), pane->frame, TRUE, TRUE);
- gtk_container_add(GTK_CONTAINER(window->focuspane->frame), pane->pane);
+ gtk_container_add(GTK_CONTAINER(zMapWindowGetFocuspane(window)->frame), pane->pane);
- /* remove the old ZMapPane from windowsTree, and add the new one */
- node = g_node_find(window->panesTree,
+ /* remove the old ZMapPane from panesTree, and add the new one */
+ node = g_node_find(zMapWindowGetPanesTree(window),
G_IN_ORDER,
G_TRAVERSE_ALL,
- (gpointer)window->focuspane);
+ (gpointer)zMapWindowGetFocuspane(window));
g_node_append_data(node->parent, pane);
exciseNode(node);
/* do we really need this? */
- gtk_widget_hide(window->focuspane->frame);
- window->focuspane = pane;
+ // gtk_widget_hide(zMapWindowGetFocuspane(window)->frame);
+ zMapWindowSetFocuspane(window, pane);
return;
}
@@ -181,7 +186,7 @@ static void shrinkPane(ZMapWindow *window)
void splitPane(GtkWidget *widget, gpointer data)
{
- ZMapWindow *window = (ZMapWindow*)data;
+ ZMapWindow window = (ZMapWindow)data;
/* shrink the old pane */
shrinkPane(window);
@@ -195,7 +200,7 @@ void splitPane(GtkWidget *widget, gpointer data)
/* 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(ZMapWindow window)
{
GtkRequisition req;
GNode *node = NULL;
@@ -203,10 +208,10 @@ static void resizePanes(ZMapWindow *window)
guint panes = 0;
/* count how many panes there are in this column */
- node = g_node_find(window->panesTree,
+ node = g_node_find(zMapWindowGetPanesTree(window),
G_IN_ORDER,
G_TRAVERSE_ALL,
- window->focuspane);
+ zMapWindowGetFocuspane(window));
last = g_node_last_child(node->parent);
/* first child is number 0 */
@@ -218,10 +223,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(window->vbox1), &req);
+ gtk_widget_size_request(GTK_WIDGET(zMapWindowGetFrame(window)), &req);
req.height = (req.height/panes) - 8;
- g_node_children_foreach(window->panesTree,
+ g_node_children_foreach(zMapWindowGetPanesTree(window),
G_TRAVERSE_LEAFS,
resizeOnePane,
&req);
@@ -231,7 +236,7 @@ static void resizePanes(ZMapWindow *window)
static void resizeOnePane(GNode *node, gpointer data)
{
- ZMapPane *pane = (ZMapPane*)node->data;
+ ZMapPane pane = (ZMapPane)node->data;
GtkRequisition *req = (GtkRequisition*)data;
if (pane)
@@ -244,38 +249,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(ZMapWindow window)
{
- ZMapPane *pane = (ZMapPane*)malloc(sizeof(ZMapPane));
+ 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->pane = gtk_hpaned_new();
pane->frame = gtk_frame_new(NULL);
- pane->scrolledWindow = window->focuspane->scrolledWindow;
- pane->canvas = window->focuspane->canvas;
- pane->background = window->focuspane->background;
+ pane->scrolledWindow = zMapWindowGetFocuspane(window)->scrolledWindow;
+ pane->canvas = zMapWindowGetFocuspane(window)->canvas;
+ pane->background = zMapWindowGetFocuspane(window)->background;
+ pane->zoomFactor = zMapWindowGetFocuspane(window)->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(window->focuspane->scrolledWindow), pane->frame);
+ gtk_widget_reparent(GTK_WIDGET(zMapWindowGetFocuspane(window)->scrolledWindow), pane->frame);
gtk_paned_pack1(GTK_PANED(pane->pane), pane->frame, TRUE, TRUE);
- gtk_container_add(GTK_CONTAINER(window->focuspane->frame), pane->pane);
+ gtk_container_add(GTK_CONTAINER(zMapWindowGetFocuspane(window)->frame), pane->pane);
/* add new pane to windowsTree. */
- node = g_node_find(window->panesTree,
+ node = g_node_find(zMapWindowGetPanesTree(window),
G_IN_ORDER,
G_TRAVERSE_ALL,
- window->focuspane);
+ zMapWindowGetFocuspane(window));
g_node_append_data(node->parent, pane);
exciseNode(node);
/* do we really need this? */
- gtk_widget_hide(window->focuspane->frame);
- window->focuspane = pane;
+ gtk_widget_hide(zMapWindowGetFocuspane(window)->frame);
+ zMapWindowSetFocuspane(window, pane);
return;
}
@@ -283,7 +290,7 @@ static void shrinkHPane(ZMapWindow *window)
void splitHPane(GtkWidget *widget, gpointer data)
{
- ZMapWindow *window = (ZMapWindow*)data;
+ ZMapWindow window = (ZMapWindow)data;
/* slim the old pane */
shrinkHPane(window);
@@ -307,13 +314,13 @@ static int resizeOneHPane(GNode *node, gpointer data)
}
-static void resizeHPanes(ZMapWindow *window)
+static void resizeHPanes(ZMapWindow window)
{
GtkRequisition req;
guint panes = 0;
/* count how many columns there are */
- panes = g_node_n_nodes(window->panesTree,
+ panes = g_node_n_nodes(zMapWindowGetPanesTree(window),
G_TRAVERSE_NON_LEAFS);
if (panes == 0)
panes = 1;
@@ -321,10 +328,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(window->zoomvbox), &req);
+ gtk_widget_size_request(GTK_WIDGET(zMapWindowGetZoomVbox(window)), &req);
req.width = (req.width/panes) - 8;
- g_node_traverse(g_node_get_root(window->panesTree),
+ g_node_traverse(g_node_get_root(zMapWindowGetPanesTree(window)),
G_IN_ORDER,
G_TRAVERSE_NON_LEAFS,
-1,
@@ -371,7 +378,7 @@ static void exciseNode(GNode *node)
void closePane(GtkWidget *widget, gpointer data)
{
- ZMapWindow *window = (ZMapWindow*)data;
+ ZMapWindow window = (ZMapWindow)data;
GNode *node = NULL;
GNode *next = NULL;
GNode *parent = NULL;
@@ -380,7 +387,7 @@ void closePane(GtkWidget *widget, gpointer data)
/* count panes but forget the root node which isn't one */
- guint panes = g_node_n_nodes(window->panesTree, G_TRAVERSE_ALL) - 1;
+ guint panes = g_node_n_nodes(zMapWindowGetPanesTree(window), G_TRAVERSE_ALL) - 1;
int discard;
if (panes == 1)
@@ -388,10 +395,10 @@ void closePane(GtkWidget *widget, gpointer data)
else
{
/* now decide where to focus after closing the pane */
- node = g_node_find(window->panesTree,
+ node = g_node_find(zMapWindowGetPanesTree(window),
G_IN_ORDER,
G_TRAVERSE_ALL,
- window->focuspane);
+ zMapWindowGetFocuspane(window));
if (node->prev)
next = node->prev;
else if (node->next)
@@ -403,7 +410,7 @@ void closePane(GtkWidget *widget, gpointer data)
else
{
printf("Don't know where to focus now!\n");
- parent = g_node_get_root(window->panesTree);
+ parent = g_node_get_root(zMapWindowGetPanesTree(window));
next = parent->children;
}
@@ -413,14 +420,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(window->focuspane->frame, GTK_TYPE_PANED);
+ pane_up1 = gtk_widget_get_ancestor(zMapWindowGetFocuspane(window)->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(window->focuspane->canvas));
- gtk_widget_destroy(window->focuspane->scrolledWindow);
- gtk_widget_destroy(window->focuspane->frame);
- free(window->focuspane);
+ gtk_object_destroy(GTK_OBJECT(zMapWindowGetFocuspane(window)->canvas));
+ gtk_widget_destroy(zMapWindowGetFocuspane(window)->scrolledWindow);
+ gtk_widget_destroy(zMapWindowGetFocuspane(window)->frame);
+ free(zMapWindowGetFocuspane(window));
children = gtk_container_get_children(GTK_CONTAINER(pane_up1));
if (children == NULL)
@@ -444,7 +451,7 @@ void closePane(GtkWidget *widget, gpointer data)
* a canvas and scroll bars) after closing multiply-split windows, but life
* is short! */
discard = recordFocus(NULL, NULL, next->data);
- gtk_widget_grab_focus(((ZMapPane*)next->data)->frame);
+ gtk_widget_grab_focus(((ZMapPane)next->data)->frame);
resizePanes(window);
}
diff --git a/src/zmapWindow/zmapsplit.h b/src/zmapWindow/zmapsplit.h
index bc29b7bc4..947b218dd 100755
--- a/src/zmapWindow/zmapsplit.h
+++ b/src/zmapWindow/zmapsplit.h
@@ -1,4 +1,4 @@
-/* Last edited: May 14 10:33 2004 (rnc) */
+/* Last edited: Jun 25 11:19 2004 (rnc) */
/* file: zmapsplit.h
* Author: Rob Clack (rnc@sanger.ac.uk)
* Copyright (c) Sanger Institute, 2004
@@ -32,13 +32,12 @@
#include <stdlib.h>
#include <gtk/gtk.h>
#include <libfoocanvas/libfoocanvas.h>
-#include <zmapcontrol.h>
+#include <../zmapWindow/zmapcontrol.h>
/* function prototypes */
void zoomIn (GtkWindow *widget, gpointer data);
void zoomOut (GtkWindow *widget, gpointer data);
-int recordFocus (GtkWidget *widget, GdkEvent *event, gpointer data);
void splitPane (GtkWidget *widget, gpointer data);
void splitHPane (GtkWidget *widget, gpointer data);
void closePane (GtkWidget *widget, gpointer data);
--
GitLab