Merge commit '7c373035e82314e6e5b4390ef32f57cf891fcfcf' as 'tkblt'

1 files changed, 652 insertions, 0 deletions

diff --git a/tkblt/generic/tkbltGrElemOp.C b/tkblt/generic/tkbltGrElemOp.C
new file mode 100644
index 0000000..fdfe4f7
--- /dev/null
+++ b/tkblt/generic/tkbltGrElemOp.C
@@ -0,0 +1,652 @@
+/*
+ * Smithsonian Astrophysical Observatory, Cambridge, MA, USA
+ * This code has been modified under the terms listed below and is made
+ * available under the same terms.
+ */
+
+/*
+ *	Copyright 1993-2004 George A Howlett.
+ *
+ *	Permission is hereby granted, free of charge, to any person obtaining
+ *	a copy of this software and associated documentation files (the
+ *	"Software"), to deal in the Software without restriction, including
+ *	without limitation the rights to use, copy, modify, merge, publish,
+ *	distribute, sublicense, and/or sell copies of the Software, and to
+ *	permit persons to whom the Software is furnished to do so, subject to
+ *	the following conditions:
+ *
+ *	The above copyright notice and this permission notice shall be
+ *	included in all copies or substantial portions of the Software.
+ *
+ *	THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ *	EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ *	MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ *	NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ *	LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ *	OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ *	WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include <string.h>
+
+#include "tkbltGrBind.h"
+#include "tkbltGraph.h"
+#include "tkbltGrAxis.h"
+#include "tkbltGrElem.h"
+#include "tkbltGrElemOp.h"
+#include "tkbltGrElemBar.h"
+#include "tkbltGrElemLine.h"
+#include "tkbltGrLegd.h"
+
+using namespace Blt;
+
+static int GetIndex(Tcl_Interp* interp, Element* elemPtr, 
+		    Tcl_Obj *objPtr, int *indexPtr);
+static Tcl_Obj *DisplayListObj(Graph* graphPtr);
+
+int Blt::ElementObjConfigure(Element* elemPtr, Tcl_Interp* interp,
+			     int objc, Tcl_Obj* const objv[])
+{
+  Graph* graphPtr = elemPtr->graphPtr_;
+  Tk_SavedOptions savedOptions;
+  int mask =0;
+  int error;
+  Tcl_Obj* errorResult;
+
+  for (error=0; error<=1; error++) {
+    if (!error) {
+      if (Tk_SetOptions(interp, (char*)elemPtr->ops(), elemPtr->optionTable(), 
+			objc, objv, graphPtr->tkwin_, &savedOptions, &mask)
+	  != TCL_OK)
+	continue;
+    }
+    else {
+      errorResult = Tcl_GetObjResult(interp);
+      Tcl_IncrRefCount(errorResult);
+      Tk_RestoreSavedOptions(&savedOptions);
+    }
+
+    if (elemPtr->configure() != TCL_OK)
+      return TCL_ERROR;
+    graphPtr->flags |= mask;
+    graphPtr->eventuallyRedraw();
+
+    break; 
+  }
+
+  if (!error) {
+    Tk_FreeSavedOptions(&savedOptions);
+    return TCL_OK;
+  }
+  else {
+    Tcl_SetObjResult(interp, errorResult);
+    Tcl_DecrRefCount(errorResult);
+    return TCL_ERROR;
+  }
+}
+
+static int CgetOp(ClientData clientData, Tcl_Interp* interp, 
+		  int objc, Tcl_Obj* const objv[])
+{
+  Graph* graphPtr = (Graph*)clientData;
+  if (objc!=5) {
+    Tcl_WrongNumArgs(interp, 3, objv, "elemId option");
+    return TCL_ERROR;
+  }
+
+  Element* elemPtr;
+  if (graphPtr->getElement(objv[3], &elemPtr) != TCL_OK)
+    return TCL_ERROR;
+
+  Tcl_Obj* objPtr = Tk_GetOptionValue(interp, 
+				      (char*)elemPtr->ops(), 
+				      elemPtr->optionTable(),
+				      objv[4], graphPtr->tkwin_);
+  if (objPtr == NULL)
+    return TCL_ERROR;
+  else
+    Tcl_SetObjResult(interp, objPtr);
+  return TCL_OK;
+}
+
+static int ConfigureOp(ClientData clientData, Tcl_Interp* interp,
+		       int objc, Tcl_Obj* const objv[])
+{
+  Graph* graphPtr = (Graph*)clientData;
+  if (objc<4) {
+    Tcl_WrongNumArgs(interp, 3, objv, "elemId ?option value...?");
+    return TCL_ERROR;
+  }
+
+  Element* elemPtr;
+  if (graphPtr->getElement(objv[3], &elemPtr) != TCL_OK)
+    return TCL_ERROR;
+
+  if (objc <= 5) {
+    Tcl_Obj* objPtr = Tk_GetOptionInfo(interp, (char*)elemPtr->ops(), 
+				       elemPtr->optionTable(), 
+				       (objc == 5) ? objv[4] : NULL, 
+				       graphPtr->tkwin_);
+    if (objPtr == NULL)
+      return TCL_ERROR;
+    else
+      Tcl_SetObjResult(interp, objPtr);
+    return TCL_OK;
+  } 
+  else
+    return ElementObjConfigure(elemPtr, interp, objc-4, objv+4);
+}
+
+static int ActivateOp(ClientData clientData, Tcl_Interp* interp,
+		      int objc, Tcl_Obj* const objv[])
+{
+  Graph* graphPtr = (Graph*)clientData;
+
+  if (objc<3) {
+    Tcl_WrongNumArgs(interp, 3, objv, "?elemId? ?index...?");
+    return TCL_ERROR;
+  }
+
+  // List all the currently active elements
+  if (objc == 3) {
+    Tcl_Obj *listObjPtr = Tcl_NewListObj(0, (Tcl_Obj **)NULL);
+
+    Tcl_HashSearch iter;
+    for (Tcl_HashEntry* hPtr = Tcl_FirstHashEntry(&graphPtr->elements_.table, &iter); hPtr; hPtr = Tcl_NextHashEntry(&iter)) {
+      Element* elemPtr = (Element*)Tcl_GetHashValue(hPtr);
+      if (elemPtr->active_)
+	Tcl_ListObjAppendElement(interp, listObjPtr,
+				 Tcl_NewStringObj(elemPtr->name_, -1));
+    }
+
+    Tcl_SetObjResult(interp, listObjPtr);
+    return TCL_OK;
+  }
+
+  Element* elemPtr;
+  if (graphPtr->getElement(objv[3], &elemPtr) != TCL_OK)
+    return TCL_ERROR;
+
+  int* indices = NULL;
+  int nIndices = -1;
+  if (objc > 4) {
+    nIndices = objc - 4;
+    indices = new int[nIndices];
+
+    int* activePtr = indices;
+    for (int ii=4; ii<objc; ii++) {
+      if (GetIndex(interp, elemPtr, objv[ii], activePtr) != TCL_OK)
+	return TCL_ERROR;
+      activePtr++;
+    }
+  }
+
+  delete [] elemPtr->activeIndices_;
+  elemPtr->activeIndices_ = indices;
+  elemPtr->nActiveIndices_ = nIndices;
+
+  elemPtr->active_ = 1;
+
+  graphPtr->flags |= RESET;
+  graphPtr->eventuallyRedraw();
+
+  return TCL_OK;
+}
+
+static int BindOp(ClientData clientData, Tcl_Interp* interp,
+		  int objc, Tcl_Obj* const objv[])
+{
+  Graph* graphPtr = (Graph*)clientData;
+  if (objc == 3) {
+    Tcl_Obj *listObjPtr = Tcl_NewListObj(0, (Tcl_Obj **)NULL);
+
+    Tcl_HashSearch iter;
+    for (Tcl_HashEntry* hPtr=Tcl_FirstHashEntry(&graphPtr->elements_.tagTable, &iter); hPtr; hPtr = Tcl_NextHashEntry(&iter)) {
+      char* tagName = 
+	(char*)Tcl_GetHashKey(&graphPtr->elements_.tagTable, hPtr);
+      Tcl_ListObjAppendElement(interp, listObjPtr,Tcl_NewStringObj(tagName,-1));
+    }
+
+    Tcl_SetObjResult(interp, listObjPtr);
+    return TCL_OK;
+  }
+
+  return graphPtr->bindTable_->configure(graphPtr->elementTag(Tcl_GetString(objv[3])), objc - 4, objv + 4);
+}
+
+static int ClosestOp(ClientData clientData, Tcl_Interp* interp,
+		     int objc, Tcl_Obj* const objv[])
+{
+  Graph* graphPtr = (Graph*)clientData;
+  if (objc<5) {
+    Tcl_WrongNumArgs(interp, 3, objv, "x y ?elemName?...");
+    return TCL_ERROR;
+  }
+
+  GraphOptions* gops = (GraphOptions*)graphPtr->ops_;
+  ClosestSearch* searchPtr = &gops->search;
+
+  if (graphPtr->flags & RESET)
+    graphPtr->resetAxes();
+
+  int x;
+  if (Tcl_GetIntFromObj(interp, objv[3], &x) != TCL_OK) {
+    Tcl_AppendResult(interp, ": bad window x-coordinate", NULL);
+    return TCL_ERROR;
+  }
+  int y;
+  if (Tcl_GetIntFromObj(interp, objv[4], &y) != TCL_OK) {
+    Tcl_AppendResult(interp, ": bad window y-coordinate", NULL);
+    return TCL_ERROR;
+  }
+
+  searchPtr->x = x;
+  searchPtr->y = y;
+  searchPtr->index = -1;
+  searchPtr->dist = (double)(searchPtr->halo + 1);
+
+  if (objc>5) {
+    for (int ii=5; ii<objc; ii++) {
+      Element* elemPtr;
+      if (graphPtr->getElement(objv[ii], &elemPtr) != TCL_OK)
+	return TCL_ERROR;
+
+      ElementOptions* eops = (ElementOptions*)elemPtr->ops();
+      if (!eops->hide)
+	elemPtr->closest();
+    }
+  }
+  else {
+    // Find the closest point from the set of displayed elements,
+    // searching the display list from back to front.  That way if
+    // the points from two different elements overlay each other
+    // exactly, the last one picked will be the topmost.  
+    for (ChainLink* link = Chain_LastLink(graphPtr->elements_.displayList);
+	 link; link = Chain_PrevLink(link)) {
+      Element* elemPtr = (Element*)Chain_GetValue(link);
+      ElementOptions* eops = (ElementOptions*)elemPtr->ops();
+      if (!eops->hide)
+	elemPtr->closest();
+    }
+  }
+
+  if (searchPtr->dist < (double)searchPtr->halo) {
+    Tcl_Obj* listObjPtr = Tcl_NewListObj(0, (Tcl_Obj **)NULL);
+    Tcl_ListObjAppendElement(interp, listObjPtr, Tcl_NewStringObj("name", -1));
+    Tcl_ListObjAppendElement(interp, listObjPtr, Tcl_NewStringObj(searchPtr->elemPtr->name_, -1)); 
+    Tcl_ListObjAppendElement(interp, listObjPtr, Tcl_NewStringObj("index", -1));
+    Tcl_ListObjAppendElement(interp, listObjPtr, Tcl_NewIntObj(searchPtr->index));
+    Tcl_ListObjAppendElement(interp, listObjPtr, Tcl_NewStringObj("x", -1));
+    Tcl_ListObjAppendElement(interp, listObjPtr, Tcl_NewDoubleObj(searchPtr->point.x));
+    Tcl_ListObjAppendElement(interp, listObjPtr, Tcl_NewStringObj("y", -1));
+    Tcl_ListObjAppendElement(interp, listObjPtr, Tcl_NewDoubleObj(searchPtr->point.y));
+    Tcl_ListObjAppendElement(interp, listObjPtr, Tcl_NewStringObj("dist", -1));
+    Tcl_ListObjAppendElement(interp, listObjPtr, Tcl_NewDoubleObj(searchPtr->dist));
+    Tcl_SetObjResult(interp, listObjPtr);
+  }
+
+  return TCL_OK;
+}
+
+static int CreateOp(ClientData clientData, Tcl_Interp* interp,
+		    int objc, Tcl_Obj* const objv[])
+{
+  Graph* graphPtr = (Graph*)clientData;
+
+  // may vary in length
+  //  if (objc!=4) {
+  //    Tcl_WrongNumArgs(interp, 3, objv, "elemId");
+  //    return TCL_ERROR;
+  //  }
+  if (objc<4) {
+    Tcl_WrongNumArgs(interp, 3, objv, "elemId...");
+    return TCL_ERROR;
+  }
+  
+  if (graphPtr->createElement(objc, objv) != TCL_OK)
+    return TCL_ERROR;
+  Tcl_SetObjResult(interp, objv[3]);
+
+  graphPtr->flags |= RESET;
+  graphPtr->eventuallyRedraw();
+
+  return TCL_OK;
+}
+
+static int DeactivateOp(ClientData clientData, Tcl_Interp* interp,
+			int objc, Tcl_Obj* const objv[])
+{
+  if (objc<4) {
+    Tcl_WrongNumArgs(interp, 3, objv, "elemId...");
+    return TCL_ERROR;
+  }
+  Graph* graphPtr = (Graph*)clientData;
+  for (int ii=3; ii<objc; ii++) {
+    Element* elemPtr;
+    if (graphPtr->getElement(objv[ii], &elemPtr) != TCL_OK)
+      return TCL_ERROR;
+
+    delete [] elemPtr->activeIndices_;
+    elemPtr->activeIndices_ = NULL;
+    elemPtr->nActiveIndices_ = 0;
+    elemPtr->active_ = 0;
+  }
+
+  graphPtr->flags |= RESET;
+  graphPtr->eventuallyRedraw();
+
+  return TCL_OK;
+}
+
+static int DeleteOp(ClientData clientData, Tcl_Interp* interp,
+		    int objc, Tcl_Obj* const objv[])
+{
+  if (objc<4) {
+    Tcl_WrongNumArgs(interp, 3, objv, "elemId...");
+    return TCL_ERROR;
+  }
+  Graph* graphPtr = (Graph*)clientData;
+  for (int ii=3; ii<objc; ii++) {
+    Element* elemPtr;
+    if (graphPtr->getElement(objv[ii], &elemPtr) != TCL_OK)
+      return TCL_ERROR;
+    graphPtr->legend_->removeElement(elemPtr);
+    delete elemPtr;
+  }
+
+  graphPtr->flags |= RESET;
+  graphPtr->eventuallyRedraw();
+
+  return TCL_OK;
+}
+
+static int ExistsOp(ClientData clientData, Tcl_Interp* interp,
+		    int objc, Tcl_Obj* const objv[])
+{
+  Graph* graphPtr = (Graph*)clientData;
+
+  if (objc!=4) {
+    Tcl_WrongNumArgs(interp, 3, objv, "elemId");
+    return TCL_ERROR;
+  }
+
+  Tcl_HashEntry *hPtr = 
+    Tcl_FindHashEntry(&graphPtr->elements_.table, Tcl_GetString(objv[3]));
+  Tcl_SetBooleanObj(Tcl_GetObjResult(interp), (hPtr != NULL));
+  return TCL_OK;
+}
+
+static int LowerOp(ClientData clientData, Tcl_Interp* interp, 
+		   int objc, Tcl_Obj* const objv[])
+{
+  Graph* graphPtr = (Graph*)clientData;
+
+  if (objc<4) {
+    Tcl_WrongNumArgs(interp, 3, objv, "elemId...");
+    return TCL_ERROR;
+  }
+
+  // Move the links of lowered elements out of the display list into
+  // a temporary list
+  Chain* chain = new Chain();
+
+  for (int ii=3; ii<objc; ii++) {
+    Element* elemPtr;
+    if (graphPtr->getElement(objv[ii], &elemPtr) != TCL_OK)
+      return TCL_ERROR;
+
+    // look for duplicates
+    int ok=1;
+    for (ChainLink* link = Chain_FirstLink(chain);
+	 link; link = Chain_NextLink(link)) {
+      Element* ptr = (Element*)Chain_GetValue(link);
+      if (ptr == elemPtr) {
+	ok=0;
+	break;
+      }
+    }
+
+    if (ok && elemPtr->link) {
+      graphPtr->elements_.displayList->unlinkLink(elemPtr->link); 
+      chain->linkAfter(elemPtr->link, NULL); 
+    }
+  }
+
+  // Append the links to end of the display list
+  ChainLink *next;
+  for (ChainLink *link = Chain_FirstLink(chain); link; link = next) {
+    next = Chain_NextLink(link);
+    chain->unlinkLink(link); 
+    graphPtr->elements_.displayList->linkAfter(link, NULL); 
+  }	
+  delete chain;
+
+  graphPtr->flags |= CACHE;
+  graphPtr->eventuallyRedraw();
+
+  Tcl_SetObjResult(interp, DisplayListObj(graphPtr));
+  return TCL_OK;
+}
+
+static int NamesOp(ClientData clientData, Tcl_Interp* interp,
+		   int objc, Tcl_Obj* const objv[])
+{
+  Graph* graphPtr = (Graph*)clientData;
+
+  if (objc<3) {
+    Tcl_WrongNumArgs(interp, 3, objv, "?pattern...?");
+    return TCL_ERROR;
+  }
+
+  Tcl_Obj *listObjPtr = Tcl_NewListObj(0, (Tcl_Obj **)NULL);
+  if (objc == 3) {
+    Tcl_HashSearch iter;
+    for (Tcl_HashEntry *hPtr = Tcl_FirstHashEntry(&graphPtr->elements_.table, &iter); hPtr != NULL; hPtr = Tcl_NextHashEntry(&iter)) {
+      Element* elemPtr = (Element*)Tcl_GetHashValue(hPtr);
+      Tcl_Obj *objPtr = Tcl_NewStringObj(elemPtr->name_, -1);
+      Tcl_ListObjAppendElement(interp, listObjPtr, objPtr);
+    }
+  }
+  else {
+    Tcl_HashSearch iter;
+    for (Tcl_HashEntry *hPtr = Tcl_FirstHashEntry(&graphPtr->elements_.table, &iter); hPtr != NULL; hPtr = Tcl_NextHashEntry(&iter)) {
+      Element* elemPtr = (Element*)Tcl_GetHashValue(hPtr);
+
+      for (int ii=3; ii<objc; ii++) {
+	if (Tcl_StringMatch(elemPtr->name_,Tcl_GetString(objv[ii]))) {
+	  Tcl_Obj *objPtr = Tcl_NewStringObj(elemPtr->name_, -1);
+	  Tcl_ListObjAppendElement(interp, listObjPtr, objPtr);
+	  break;
+	}
+      }
+    }
+  }
+
+  Tcl_SetObjResult(interp, listObjPtr);
+  return TCL_OK;
+}
+
+static int RaiseOp(ClientData clientData, Tcl_Interp* interp, 
+		   int objc, Tcl_Obj* const objv[])
+{
+  Graph* graphPtr = (Graph*)clientData;
+
+  if (objc<4) {
+    Tcl_WrongNumArgs(interp, 3, objv, "elemId...");
+    return TCL_ERROR;
+  }
+
+  Chain* chain = new Chain();
+  for (int ii=3; ii<objc; ii++) {
+    Element* elemPtr;
+    if (graphPtr->getElement(objv[ii], &elemPtr) != TCL_OK)
+      return TCL_ERROR;
+
+    // look for duplicates
+    int ok=1;
+    for (ChainLink* link = Chain_FirstLink(chain);
+	 link; link = Chain_NextLink(link)) {
+      Element* ptr = (Element*)Chain_GetValue(link);
+      if (ptr == elemPtr) {
+	ok=0;
+	break;
+      }
+    }
+
+    if (ok && elemPtr->link) {
+      graphPtr->elements_.displayList->unlinkLink(elemPtr->link); 
+      chain->linkAfter(elemPtr->link, NULL); 
+    }
+  }
+
+  // Prepend the links to beginning of the display list in reverse order
+  ChainLink *prev;
+  for (ChainLink *link = Chain_LastLink(chain); link; link = prev) {
+    prev = Chain_PrevLink(link);
+    chain->unlinkLink(link); 
+    graphPtr->elements_.displayList->linkBefore(link, NULL); 
+  }	
+  delete chain;
+
+  graphPtr->flags |= CACHE;
+  graphPtr->eventuallyRedraw();
+
+  Tcl_SetObjResult(interp, DisplayListObj(graphPtr));
+  return TCL_OK;
+}
+
+static int ShowOp(ClientData clientData, Tcl_Interp* interp,
+		  int objc, Tcl_Obj* const objv[])
+{
+  Graph* graphPtr = (Graph*)clientData;
+  // may vary in length
+  if (objc<3) {
+  //  if (objc!=3 || objc!=4) {
+    Tcl_WrongNumArgs(interp, 3, objv, "?nameList?");
+    return TCL_ERROR;
+  }
+
+  if (objc == 3) {
+    Tcl_SetObjResult(interp, DisplayListObj(graphPtr));
+    return TCL_OK;
+  }
+
+  int elemObjc;
+  Tcl_Obj** elemObjv;
+  if (Tcl_ListObjGetElements(interp, objv[3], &elemObjc, &elemObjv) != TCL_OK)
+    return TCL_ERROR;
+
+  // Collect the named elements into a list
+  Chain* chain = new Chain();
+  for (int ii=0; ii<elemObjc; ii++) {
+    Element* elemPtr;
+    if (graphPtr->getElement(elemObjv[ii], &elemPtr) != TCL_OK) {
+      delete chain;
+      return TCL_ERROR;
+    }
+
+    // look for duplicates
+    int ok=1;
+    for (ChainLink* link = Chain_FirstLink(chain);
+	 link; link = Chain_NextLink(link)) {
+      Element* ptr = (Element*)Chain_GetValue(link);
+      if (ptr == elemPtr) {
+	ok=0;
+	break;
+      }
+    }
+
+    if (ok) 
+      chain->append(elemPtr);
+  }
+
+  // Clear the links from the currently displayed elements
+  for (ChainLink* link = Chain_FirstLink(graphPtr->elements_.displayList);
+       link; link = Chain_NextLink(link)) {
+    Element* elemPtr = (Element*)Chain_GetValue(link);
+    elemPtr->link = NULL;
+  }
+  delete graphPtr->elements_.displayList;
+  graphPtr->elements_.displayList = chain;
+
+  // Set links on all the displayed elements
+  for (ChainLink* link = Chain_FirstLink(chain); link; 
+       link = Chain_NextLink(link)) {
+    Element* elemPtr = (Element*)Chain_GetValue(link);
+    elemPtr->link = link;
+  }
+
+  graphPtr->flags |= RESET;
+  graphPtr->eventuallyRedraw();
+
+  Tcl_SetObjResult(interp, DisplayListObj(graphPtr));
+  return TCL_OK;
+}
+
+static int TypeOp(ClientData clientData, Tcl_Interp* interp,
+		  int objc, Tcl_Obj* const objv[])
+{
+  Graph* graphPtr = (Graph*)clientData;
+
+  if (objc!=4) {
+    Tcl_WrongNumArgs(interp, 3, objv, "elemId");
+    return TCL_ERROR;
+  }
+
+  Element* elemPtr;
+  if (graphPtr->getElement(objv[3], &elemPtr) != TCL_OK)
+    return TCL_ERROR;
+
+  Tcl_SetStringObj(Tcl_GetObjResult(interp), elemPtr->typeName(), -1);
+  return TCL_OK;
+}
+
+const Ensemble Blt::elementEnsemble[] = {
+  {"activate",   ActivateOp, 0},
+  {"bind",       BindOp, 0},
+  {"cget",       CgetOp, 0},
+  {"closest",    ClosestOp, 0},
+  {"configure",  ConfigureOp, 0},
+  {"create",     CreateOp,  0},
+  {"deactivate", DeactivateOp, 0},
+  {"delete",     DeleteOp, 0},
+  {"exists",     ExistsOp, 0},
+  {"lower",      LowerOp, 0},
+  {"names",      NamesOp, 0},
+  {"raise",      RaiseOp, 0},
+  {"show",       ShowOp, 0},
+  {"type",       TypeOp, 0},
+  { 0,0,0 }
+};
+
+// Support
+
+static Tcl_Obj *DisplayListObj(Graph* graphPtr)
+{
+  Tcl_Obj *listObjPtr = Tcl_NewListObj(0, (Tcl_Obj **)NULL);
+
+  for (ChainLink* link = Chain_FirstLink(graphPtr->elements_.displayList); 
+       link; link = Chain_NextLink(link)) {
+    Element* elemPtr = (Element*)Chain_GetValue(link);
+    Tcl_Obj *objPtr = Tcl_NewStringObj(elemPtr->name_, -1);
+    Tcl_ListObjAppendElement(graphPtr->interp_, listObjPtr, objPtr);
+  }
+
+  return listObjPtr;
+}
+
+static int GetIndex(Tcl_Interp* interp, Element* elemPtr, 
+		    Tcl_Obj *objPtr, int *indexPtr)
+{
+  ElementOptions* ops = (ElementOptions*)elemPtr->ops();
+
+  char *string = Tcl_GetString(objPtr);
+  if ((*string == 'e') && (strcmp("end", string) == 0))
+    *indexPtr = NUMBEROFPOINTS(ops);
+  else if (Tcl_GetIntFromObj(interp, objPtr, indexPtr) != TCL_OK)
+    return TCL_ERROR;
+
+  return TCL_OK;
+}
+
+