/****************************************************************

                      Uebungen zur Vorlesung
		  "Graphische Datenverarbeitung"
                       Sommersemester  1996

       Programm: planung.c
       Autor:    Xiaowei Xu

       Programm für Planungssystem.

****************************************************************/

# include <stdio.h>
# include <stdlib.h>
# include <Xm/Xm.h>
# include <Xm/XmAll.h>
# include "Landkarte.h"

#define MAX_WIDTH	5069
#define MAX_HIGTH	5069
#define MIN_WIDTH	6
#define MIN_HIGTH	6
#define MAX_INDEX	1000
#define POINT_SIZE	3
#define SEARCH_SIZE	5
#define IN_LINE_LENGTH	100
#define STR_LENGTH	81
#define ABS(a)          ((a)<0?-(a):(a))

struct netnode {
double x, y;
char  name [STR_LENGTH];
};

Widget		DrawAr;			/* Drawing Area */
XtAppContext	kontext;		/* Applikations-Umgebung */
GC		fensterGC, pixmapGC;	/* Graphik-Kontext fuer XDrawLine...*/
GC		eraseDrawArGC;		/* G-Kontext für Abwischen */
GC		eraseGraphGC;		/* G-Kontext für Abwischen */
Display*	display;
Pixmap		GraphikPixmap = 0;	/* Pixmap fuer Graphik */
struct netnode	netnodes[MAX_INDEX];	/* Netzknoten */
int		index = -1;		/* aktuell selektierter  Netzknoten */
int             maxindex = 0;           /* Anzahl von Netzknoten */
int		markindex = -1;
Widget		text_w;			/* text Widget fuer Namen von netnode */
char*		nname = NULL;

static char * fallbackRessourcen [] = {
	"Planung.geometry: 750x500",
        "*drawingarea.background: white",
        "*drawingarea.foreground: black",
	"*operationsMenue.labelString: Punkte:",
	"*datei.labelString: Datei",
	"*datei.mnemonic: D",
	"*hilfe.labelString: Hilfe",
	"*hilfe.mnemonic: H",
        NULL
} ;

void DrawLandkarte (int n, struct linesegment *segs,
			double s, Drawable w, GC g)
{
    int i ;

    for (i=0 ; i<n ; i++)
        XDrawLine (display, w, g,
        segs[i].x1*s, s-segs[i].y1*s, segs[i].x2*s, s-segs[i].y2*s) ;
}

void DrawKnoten(Display *dplay, Drawable drawable, GC gc, int x, int y)
{
    XDrawArc(dplay, drawable, gc, x - POINT_SIZE/2, y - POINT_SIZE/2,
	     POINT_SIZE, POINT_SIZE, 0, 360 * 64);
    XFillArc(dplay, drawable, gc, x - POINT_SIZE/2 + 1, y - POINT_SIZE/2 + 1,
	     POINT_SIZE - 1, POINT_SIZE - 1, 0, 360 * 64);
}

void DrawNetzknoten (double s, Drawable w, GC g)
{
    int i ;

    for (i=0 ; i<maxindex ; i++)
	DrawKnoten(display, w, g, netnodes[i].x*s, netnodes[i].y*s);
}

void initGraphikGC (Widget widget)
{
        Dimension	w, h ;
	XGCValues	werte;       /* Struktur zum Setzen von GC-Attributen */

	XtVaGetValues (widget, XmNheight, &h, XmNwidth, &w, NULL) ;

	if (GraphikPixmap) {
                XFreeGC (display, pixmapGC) ;
                XFreeGC (display, eraseGraphGC) ;
                XFreePixmap (display, GraphikPixmap) ;
        }
        GraphikPixmap = XCreatePixmap (display, XtWindow (widget), w, h, 
				       XDefaultDepthOfScreen (XtScreen(widget))) ;

	/* Graphik-Fenster und Graphik-Pixmap durch Bemalen mit
	   Hintergrundfarbe loeschen
	 */
        werte.foreground = XWhitePixelOfScreen(XtScreen (widget)) ;
        werte.background = XWhitePixelOfScreen(XtScreen (widget)) ;
        pixmapGC = XCreateGC (display, GraphikPixmap,
                              GCForeground | GCBackground, &werte) ;
        XFillRectangle (display, GraphikPixmap, pixmapGC, 0, 0, w, h) ;

	/* Fuer "XDrawLine" GC anpassen
	 */
        werte.foreground = XBlackPixelOfScreen(XtScreen (widget)) ;
        werte.background = XWhitePixelOfScreen(XtScreen (widget)) ;
        XChangeGC (display, pixmapGC, GCForeground | GCBackground, &werte) ;

	/* Fuer Abwischen GC anpassen
	 */
	werte.foreground = XWhitePixelOfScreen(XtScreen (widget)) ;
	eraseGraphGC = XCreateGC (display, GraphikPixmap,
				  GCForeground, &werte) ;
}

void resizeCB (Widget widget, XtPointer dum2, XtPointer dum3)
{
	Dimension	w, h;
	double		scale ;

	XtVaGetValues (widget, XmNheight, &h, XmNwidth, &w, NULL) ;
	
	initGraphikGC (widget);
	scale = (double) ( w < h )? w : h ;
	DrawLandkarte (AnzahlLinien, lines, scale, GraphikPixmap, pixmapGC) ;
	DrawNetzknoten(scale, GraphikPixmap, pixmapGC) ;
	XClearArea (display, XtWindow (widget), 0, 0, w, h, True) ;
}

void exposeCB (Widget widget, XtPointer clientDaten, XtPointer aufrufDaten)
{
        XmDrawingAreaCallbackStruct* DAinfos;

	/* Callback-Informationen mit Event-Struktur */
	DAinfos = (XmDrawingAreaCallbackStruct*)aufrufDaten;

	/* Im Expose-Event angegebenen Fenster-Ausschnitt 
	 * von Graphik-Bitmap ins Graphik-Fenster kopieren
	 */
	XCopyArea (display, GraphikPixmap, XtWindow(widget), fensterGC,
		    DAinfos->event->xexpose.x, DAinfos->event->xexpose.y,
		    DAinfos->event->xexpose.width,
		    DAinfos->event->xexpose.height,
		    DAinfos->event->xexpose.x, DAinfos->event->xexpose.y);
}

void update_name ( Widget widget, XtPointer client_data,
                                XtPointer call_data )
{
   if (index == -1) {
      printf ("Erst selektieren !\n") ;
      return ;
   }
   if (nname) XtFree (nname) ;
   nname = XmTextGetString (widget);
   strncpy (netnodes[index].name, nname, STR_LENGTH - 1);
}

void get_real_xy (double *x, double *y, double * scale, 
		  Widget widget, XmDrawingAreaCallbackStruct* DAinfos)
{
    Dimension w, h;
    XtVaGetValues (widget, XmNheight, &h, XmNwidth, &w, NULL) ;
    *scale = (double) ( w < h ) ? h : w;
    *x = (double) (DAinfos->event->xbutton.x) / *scale ;
    *y = (double) (DAinfos->event->xbutton.y) / *scale ;
}

void erase (Widget widget, int x, int y)
{
   DrawKnoten(display, XtWindow(widget), eraseDrawArGC, x, y);
   DrawKnoten(display, GraphikPixmap, eraseGraphGC, x, y);
}

void markieren (Widget widget, int x, int y)
{
  String color = "Red";
  Colormap cmap = DefaultColormapOfScreen (XtScreen (widget));
  XColor col, unused;

  XAllocNamedColor (display, cmap, color, &col, &unused);
  XSetForeground (display, fensterGC, col.pixel);
  XSetForeground (display, pixmapGC, col.pixel);

  DrawKnoten(display, XtWindow(widget), fensterGC, x, y);
  DrawKnoten(display, GraphikPixmap, pixmapGC, x, y);

  XSetForeground (display, fensterGC, 0);
  XSetForeground (display, pixmapGC, 0);
}

void demarkieren (Widget widget, int x, int y)
{
  XSetForeground (display, fensterGC, 0);
  XSetForeground (display, pixmapGC, 0);

  DrawKnoten(display, XtWindow(widget), fensterGC, x, y);
  DrawKnoten(display, GraphikPixmap, pixmapGC, x, y);
}

void plazierenCB (Widget widget, XtPointer clientDaten, XtPointer aufrufDaten)
{
        double scale ;
	XmDrawingAreaCallbackStruct* DAinfos 
	    = (XmDrawingAreaCallbackStruct*) aufrufDaten;

	if (DAinfos->event->type == ButtonPress &&
		DAinfos->event->xbutton.button == Button1 &&
	        maxindex < MAX_INDEX-1) {
	    index = maxindex++ ;
	    get_real_xy (&(netnodes[index].x), &(netnodes[index].y), &scale,
			 widget, DAinfos) ;
	    if (markindex != -1)
		demarkieren (widget, netnodes[markindex].x *scale,
			     netnodes[markindex].y * scale);
	    markieren (widget, netnodes[index].x *scale,
		       netnodes[index].y * scale);
	    XmTextSetString (text_w, "Name eintragen!");
	    markindex = index;
	    nname = (char*) NULL ;
	}
}

void selektierenCB (Widget widget, XtPointer clientDaten, XtPointer aufrufDaten)
{
        int i ;
	double x, y, scale ;
	XmDrawingAreaCallbackStruct* DAinfos 
	    = (XmDrawingAreaCallbackStruct*) aufrufDaten;

	if (DAinfos->event->type == ButtonPress &&
		DAinfos->event->xbutton.button == Button1) {
	    get_real_xy (&x, &y, &scale, widget, DAinfos) ;
	    for (i=0 ; i<maxindex ; i++) {
		if (ABS (netnodes[i].x*scale-x*scale) < SEARCH_SIZE &&
		    ABS (netnodes[i].y*scale-y*scale) < SEARCH_SIZE) {
		    if (markindex != -1)
			demarkieren (widget, netnodes[markindex].x *scale,
			netnodes[markindex].y * scale);
		    index = i ;
		    markieren (widget, netnodes[index].x *scale,
			       netnodes[index].y *scale) ;
		    XmTextSetString (text_w, netnodes[i].name) ;
		    markindex = index ;
		    return ;
		}
	    }
	}
}

void verschiebenCB (Widget widget, XtPointer clientDaten, XtPointer aufrufDaten)
{
        int i ;
        double x, y, scale ;
        XmDrawingAreaCallbackStruct* DAinfos
            = (XmDrawingAreaCallbackStruct*) aufrufDaten;

        if (DAinfos->event->type == ButtonPress &&
                DAinfos->event->xbutton.button == Button1) {
            get_real_xy (&x, &y, &scale, widget, DAinfos) ;
	    index = -1 ;
            for (i=0 ; i<maxindex ; i++) {
                if (ABS (netnodes[i].x*scale-x*scale) < SEARCH_SIZE &&
                    ABS (netnodes[i].y*scale-y*scale) < SEARCH_SIZE) {
		    if (markindex != -1)
                        demarkieren (widget, netnodes[markindex].x *scale,
                        netnodes[markindex].y * scale);
                    index = i ;
		    XmTextSetString (text_w, netnodes[i].name) ;

		    /* netnodes[i] von DrawAr und GraphikPixmap abwischen */
		    erase (widget, netnodes[i].x*scale, netnodes[i].y*scale) ; 
                    break ;
                }
            }
        } else if (DAinfos->event->type == ButtonRelease &&
			DAinfos->event->xbutton.button == Button1 && 
		        index != -1) {
            	get_real_xy (&(netnodes[index].x), &(netnodes[index].y), &scale,
                         widget, DAinfos) ;
		markieren (widget, netnodes[index].x *scale,
                               netnodes[index].y *scale) ;
		markindex = index ;
            	XmTextSetString (text_w, netnodes[index].name);
        }
}

void LoeschNknoten(int l)
{
   int i;

   for ( i=l; i<maxindex; i++) {
	netnodes[i].x = netnodes[i+1].x;
	netnodes[i].y = netnodes[i+1].y;
	strncpy (netnodes[i].name, netnodes[i+1].name, STR_LENGTH - 1);
    };
   maxindex--;
}

void loeschenCB (Widget widget, XtPointer clientDaten, XtPointer aufrufDaten)
{
        int i ;
        double x, y, scale ;
        XmDrawingAreaCallbackStruct* DAinfos
            = (XmDrawingAreaCallbackStruct*) aufrufDaten;

        if (DAinfos->event->type == ButtonPress &&
                DAinfos->event->xbutton.button == Button1) {
            get_real_xy (&x, &y, &scale, widget, DAinfos) ;
            for (i=0 ; i<maxindex ; i++) {
                if (ABS (netnodes[i].x*scale-x*scale) < SEARCH_SIZE &&
                    ABS (netnodes[i].y*scale-y*scale) < SEARCH_SIZE) {
                    index = i ;
		    if (markindex != -1)
                        demarkieren (widget, netnodes[markindex].x *scale,
                        netnodes[markindex].y * scale);
		    markindex = -1 ;
		    /* netnodes[i] von DrawAr und GraphikPixmap abwischen */
		    erase (widget, netnodes[i].x*scale, netnodes[i].y*scale) ;

                    /* lösch netnodes[i] von netnodes array */
		    LoeschNknoten(i) ;

            	    XmTextSetString (text_w, NULL);
		    index = -1 ;

                    return ;
                }
            }
        }
}

void ZoomPlusCB (Widget widget, XtPointer dum2, XtPointer dum3)
{
        Dimension	w, h;
        double		scale ;

        XtVaGetValues (DrawAr, XmNheight, &h, XmNwidth, &w, NULL) ;
	if ( ( w < MAX_WIDTH ) && ( h < MAX_HIGTH ) ) {
		XtVaSetValues (DrawAr, XmNx, 0, XmNy, 0, NULL) ;
		w = 2*w;
		h = 2*h;
		XtVaSetValues (DrawAr, XmNheight, h, XmNwidth, w, NULL) ;

        	initGraphikGC (DrawAr);
        	scale = (double) ( w < h )? w : h ;
        	DrawLandkarte (AnzahlLinien, lines, scale, GraphikPixmap, pixmapGC) ;
		DrawNetzknoten (scale, GraphikPixmap, pixmapGC) ;
		if (markindex != -1)
                        markieren (widget, netnodes[markindex].x *scale,
                        netnodes[markindex].y * scale);
        	XClearArea (display, XtWindow (DrawAr), 0, 0, w, h, False) ;
	}
	else
		XtAppWarning (kontext, "upper bound for zoom is reached!");
}

void ZoomMinusCB (Widget widget, XtPointer dum2, XtPointer dum3)
{
        Dimension	w, h;
        double		scale ;

        XtVaGetValues (DrawAr, XmNheight, &h, XmNwidth, &w, NULL) ;
	if ( ( w > MIN_WIDTH ) && ( h > MIN_HIGTH ) ) {
        	XtVaSetValues (DrawAr, XmNx, 0, XmNy, 0, NULL) ;
		w = (int) w/2;
		h = (int) h/2;
		XtVaSetValues (DrawAr, XmNheight, h, XmNwidth, w, NULL) ;

		initGraphikGC (DrawAr);
		scale = (double) ( w < h )? w : h ;
		DrawLandkarte (AnzahlLinien, lines, scale, GraphikPixmap, pixmapGC) ;
		DrawNetzknoten (scale, GraphikPixmap, pixmapGC) ;
		if (markindex != -1)
                        markieren (widget, netnodes[markindex].x *scale,
                        netnodes[markindex].y * scale);
		XClearArea (display, XtWindow (DrawAr), 0, 0, w, h, False) ;
	}
	else
		XtAppWarning (kontext, "lower bound for zoom is reached!");
}

void punktOperationenCB ( Widget widget, XtPointer clientDaten,
				XtPointer aufrufDaten )
{
    int op_code = (int)clientDaten;
    XtCallbackRec callbacks[] = {
	{plazierenCB, (XtPointer) NULL},
	{selektierenCB, (XtPointer) NULL},
	{verschiebenCB, (XtPointer) NULL},
	{loeschenCB, (XtPointer) NULL},
	{(XtCallbackProc) NULL, (XtPointer) NULL},
	};

    switch ( op_code )
      {
        case 1: /* Punkte Plazieren */
		XtRemoveCallbacks (DrawAr, XmNinputCallback, callbacks);
        	XtAddCallback (DrawAr, XmNinputCallback, plazierenCB,
		(XtPointer)NULL);
                break;
        case 2:	/* Punkte Selektieren */
		XtRemoveCallbacks (DrawAr, XmNinputCallback, callbacks);
        	XtAddCallback (DrawAr, XmNinputCallback, selektierenCB,
		(XtPointer)NULL);
                break;
        case 3:	/* Punkte Verschieben */
		XtRemoveCallbacks (DrawAr, XmNinputCallback, callbacks);
        	XtAddCallback (DrawAr, XmNinputCallback, verschiebenCB,
		(XtPointer)NULL);
                break;
        case 4:	/* Punkte Löschen */
		XtRemoveCallbacks (DrawAr, XmNinputCallback, callbacks);
        	XtAddCallback (DrawAr, XmNinputCallback, loeschenCB,
		(XtPointer)NULL);
                break;
        default:
                break;
      }
}

void initOperationenMenue ( Widget elternWidget )
{
	Widget   operationenW, obuttonW, operationsMenueW;
	Arg      args[10];
	Cardinal n;

	/* XmPulldownMenu mit Operationen erzeugen
	 */
	operationenW = XmCreatePulldownMenu (elternWidget, "operationen",
						(Arg*)NULL, 0);

      /* Operation "Plazieren"
       */
      obuttonW = XtCreateManagedWidget ("plazieren", xmPushButtonWidgetClass,
                                       operationenW, (Arg*)NULL, 0);
      XtAddCallback (obuttonW, XmNactivateCallback, punktOperationenCB,
			(XtPointer)1);

      /* Operation "Selektieren"
       */
      obuttonW = XtCreateManagedWidget ("selektieren", xmPushButtonWidgetClass,
                                       operationenW, (Arg*)NULL, 0);
      XtAddCallback (obuttonW, XmNactivateCallback, punktOperationenCB,
			(XtPointer)2);

      /* Operation "Verschieben"
       */
      obuttonW = XtCreateManagedWidget ("verschieben", xmPushButtonWidgetClass,
                                       operationenW, (Arg*)NULL, 0);
      XtAddCallback (obuttonW, XmNactivateCallback, punktOperationenCB,
			(XtPointer)3);

      /* Operation "Löschen"
       */
      obuttonW = XtCreateManagedWidget ("löschen", xmPushButtonWidgetClass,
                                       operationenW, (Arg*)NULL, 0);
      XtAddCallback (obuttonW, XmNactivateCallback, punktOperationenCB,
			(XtPointer)4);

    /* XmOperationMenu mit Operationen erzeugen
     */
    n = 0;
    XtSetArg (args[n], XmNsubMenuId, operationenW);  n++;
    operationsMenueW = XmCreateOptionMenu (elternWidget, "operationsMenue",
                                        args, n);
    XtManageChild (operationsMenueW);
}

void initZoomButtons ( Widget elternWidget )
{
        Widget          Zoom;
        Widget          ZoomPlus;
        Widget          ZoomMinus;

        Zoom =  XtVaCreateManagedWidget   ("Zoom",
                                        xmRowColumnWidgetClass, elternWidget,
                                        XmNpacking,     XmPACK_COLUMN,
                                        XmNnumColumns,  3,
                                        XmNorientation, XmVERTICAL,
                                        NULL);
        XtVaCreateManagedWidget ("Zoom:",
                                xmLabelGadgetClass, Zoom, NULL);

        ZoomPlus = XtCreateManagedWidget ("Zoom +",xmPushButtonWidgetClass,
                                        Zoom, (Arg*)NULL, 0);
        ZoomMinus = XtCreateManagedWidget ("Zoom -",xmPushButtonWidgetClass,
                                        Zoom, (Arg*)NULL, 0);

	XtAddCallback (ZoomPlus, XmNactivateCallback, ZoomPlusCB, (XtPointer)NULL);
	XtAddCallback (ZoomMinus, XmNactivateCallback, ZoomMinusCB, (XtPointer)NULL);
}

void initTextWidget ( Widget elternWidget )
{
   Widget       knotensname;

   knotensname = XtVaCreateWidget ("knotensname",
        xmRowColumnWidgetClass, elternWidget,
        XmNorientation, XmHORIZONTAL,
        NULL);

   XtVaCreateManagedWidget ("Knotensname:",
        xmLabelGadgetClass, knotensname, NULL);

   text_w = XtVaCreateManagedWidget ("name", xmTextWidgetClass,
                           knotensname, NULL);
   XtAddCallback (text_w, XmNvalueChangedCallback, update_name,
		  (XtPointer) NULL);

   XtManageChild (knotensname);
}

void initAttributeBoxWidgets (Widget elternWidget)
{
	/* Optionen-Menue fuer die Operationen erzeugen
	 */
	initOperationenMenue (elternWidget);

	XtCreateManagedWidget ("separator", xmSeparatorWidgetClass,
				elternWidget, (Arg*)NULL, 0);

	/* Push-Button fuer Zoom erzeugen
	 */
	initZoomButtons (elternWidget);

	XtCreateManagedWidget ("separator", xmSeparatorWidgetClass,
				elternWidget, (Arg*)NULL, 0);

	/* Fester fuer die Name eines selektierten Netzknotens erzeugen
	 */
	initTextWidget (elternWidget);

	XtCreateManagedWidget ("separator", xmSeparatorWidgetClass,
				elternWidget, (Arg*)NULL, 0);
}

Widget initForm (Widget elternWidget)
{
	Widget		formW;
	Widget		dateinameW;
	Widget		attributeBoxW;
	Widget		scrollW;
	Arg		args[10];
	Cardinal	n;

	formW = XtCreateManagedWidget ("form", xmFormWidgetClass,
					elternWidget, (Arg*)NULL, 0);

	n = 0;
	XtSetArg (args[n], XmNtopAttachment,  XmATTACH_WIDGET);  n++;
	XtSetArg (args[n], XmNleftAttachment, XmATTACH_FORM);    n++;
	attributeBoxW = XtCreateManagedWidget ("attributeBox",
						xmRowColumnWidgetClass,
						formW, args, n);

	initAttributeBoxWidgets (attributeBoxW);

	n = 0;
	XtSetArg (args[n], XmNtopAttachment,    XmATTACH_WIDGET);   n++;
	XtSetArg (args[n], XmNleftAttachment,   XmATTACH_WIDGET);   n++;
	XtSetArg (args[n], XmNleftWidget,       attributeBoxW);     n++;
	XtSetArg (args[n], XmNrightAttachment,  XmATTACH_FORM);     n++;
	XtSetArg (args[n], XmNbottomAttachment, XmATTACH_FORM);     n++;
	XtSetArg (args[n], XmNwidth, 500);     n++;
	XtSetArg (args[n], XmNheight, 500);     n++;
	XtSetArg (args[n], XmNscrollingPolicy, XmAUTOMATIC);     n++;
	scrollW = XtCreateManagedWidget ("scrolledGraphik",
                                     xmScrolledWindowWidgetClass,
                                     formW, args, n);

	DrawAr = XtVaCreateManagedWidget("drawingarea",
					xmDrawingAreaWidgetClass,
					scrollW,
					XmNwidth, 500,
					XmNheight, 500,
					NULL) ;

	XtAddCallback (DrawAr, XmNexposeCallback, exposeCB, (XtPointer)NULL);
        XtAddCallback (DrawAr, XmNresizeCallback, resizeCB, (XtPointer)NULL);
        XtAddCallback (DrawAr, XmNinputCallback, plazierenCB, (XtPointer)NULL);

	return formW;
}

void verlassenCB (Widget widget, XtPointer clientDaten, XtPointer aufrufDaten)
{
    /* Programm mit fehlerfreiem Status beenden
     */
    exit (EXIT_SUCCESS);
}

void initVerlassenButton (Widget elternWidget)
{
    Widget buttonW;

    /* Menuepunkt 'verlassen' erzeugen
     */
    buttonW = XtCreateManagedWidget ("verlassen", xmPushButtonWidgetClass,
                                     elternWidget, (Arg*)NULL, 0);
    XtAddCallback (buttonW, XmNactivateCallback,
                   verlassenCB, (XtPointer)NULL);
}

void speichernCB (Widget widget, XtPointer clientDaten, XtPointer aufrufDaten)
/* Store the array of netnodes in a file named Netzknoten */
{
  int	i;
  FILE*	outf; 

  outf = fopen("Netzknoten", "w");

  if ( outf ) {
  	for ( i=0; i<maxindex; i++ )
		fprintf(outf, "%f %f %s\n", netnodes[i].x, netnodes[i].y,
			netnodes[i].name);
	fclose( outf );
	}
  else
	printf("Error: file Netzknoten can not be open for save.\n");
}

void initSpeichernButton (Widget elternWidget)
{
      Widget buttonW;

      /* XmPushButton zum Abspeichern einer Graphik erzeugen
       */
      buttonW = XtCreateManagedWidget ("speichern",
                                       xmPushButtonWidgetClass,
                                       elternWidget, (Arg*)NULL, 0);
      XtAddCallback (buttonW, XmNactivateCallback,
                     speichernCB, (XtPointer)NULL);
}

void ladenCB ( Widget    widget, XtPointer clientDaten, XtPointer aufrufDaten )
/* Neue Netzknoten laden */
{
  Dimension w, h;
  double scale;
  int   i = 0;
  FILE* inputf;
  char	line[IN_LINE_LENGTH];

  XtVaGetValues (DrawAr, XmNheight, &h, XmNwidth, &w, NULL) ;
  scale = (double) ( w < h ) ? h : w;

  inputf = fopen("Netzknoten", "r");

  if ( inputf ) {
	while (fgets(line, IN_LINE_LENGTH, inputf) != NULL)
	 {
	    sscanf(line,"%lf%lf%s", &netnodes[i].x, &netnodes[i].y,
                   netnodes[i].name);
	    i++;
	 };
        fclose( inputf );
	maxindex = i;
	for ( i=0; i<maxindex; i++) {
	  DrawKnoten(display, XtWindow(DrawAr), fensterGC,
			netnodes[i].x * scale, netnodes[i].y * scale);
	  DrawKnoten(display, GraphikPixmap, pixmapGC,
			netnodes[i].x * scale, netnodes[i].y * scale);
	}
   }
  else
        printf("Error: file Netzknoten can not be open for read.\n");
}

void initLadenButton ( Widget elternWidget )
{
      Widget buttonW;

      /* XmPushButton zum Laden einer Graphik erzeugen
       */
      buttonW = XtCreateManagedWidget ("laden", xmPushButtonWidgetClass,
                                      elternWidget, (Arg*)NULL, 0);
      XtAddCallback (buttonW, XmNactivateCallback,
                     ladenCB, (XtPointer)NULL);
}

void hilfeCB (Widget widget, XtPointer clientDaten, XtPointer aufrufDaten)
{
   printf("No help information.\n");
}

Widget initMenueLeiste ( Widget elternWidget )
{
    Widget   menueLeisteW;
    Widget   dateiMenueW, buttonW;
    Arg      args[10];
    Cardinal n;

    /* XmMenuBar erzeugen
     */
    menueLeisteW = XmCreateMenuBar (elternWidget, "menueLeiste",
                                    (Arg*)NULL, 0);
    XtManageChild (menueLeisteW);

    /* Datei-Menue als XmPulldownMenu dazu erzeugen
     */
    dateiMenueW = XmCreatePulldownMenu (menueLeisteW, "dateiMenue",
                                        (Arg*)NULL, 0);

    /* Menuepunkt 'laden' erzeugen
     */
    initLadenButton (dateiMenueW);

    /* Menuepunkt 'speichern' erzeugen
     */
    initSpeichernButton (dateiMenueW);

    /* Menuepunkt 'verlassen' erzeugen
     */
    initVerlassenButton (dateiMenueW);

    /* Menuepunkt 'datei' erzeugen, der das Datei-Menue aufruft
     */
    n = 0;
    XtSetArg (args[n], XmNsubMenuId, dateiMenueW);  n++;
    XtCreateManagedWidget ("datei", xmCascadeButtonWidgetClass,
                           menueLeisteW, args, n);

    /* Menuepunkt 'hilfe' erzeugen, der den Hilfetext ausgibt
     */
    buttonW = XtCreateManagedWidget ("hilfe", xmCascadeButtonWidgetClass,
                                     menueLeisteW, (Arg*)NULL, 0);
    XtAddCallback (buttonW, XmNactivateCallback,
                   hilfeCB, (XtPointer)NULL);

    /* Menuepunkt 'hilfe' ist Help-Widget in der Menueleiste
     * (wird automatisch ganz rechts plaziert)
     */
    n = 0;
    XtSetArg (args[n], XmNmenuHelpWidget, buttonW);  n++;
    XtSetValues (menueLeisteW, args, n);

    /* Menueleiste zurueckliefern
     */
    return menueLeisteW;
}

void initWidgetsBaum (Widget rtW)
{
	Widget		mainW;
	Widget		formW;
	Widget		menueW;
	XGCValues	werte;       /* Struktur zum Setzen von GC-Attributen */

	mainW = XtCreateManagedWidget ("main", xmMainWindowWidgetClass,
					rtW, (Arg*)NULL, 0);

	/* Menueleiste erzeugen
	 */
	menueW = initMenueLeiste (mainW);

	formW = initForm (mainW);

	XmMainWindowSetAreas (mainW, menueW, (Widget)NULL,
				(Widget)NULL, (Widget)NULL, formW);
}

main (int argc, char ** argv)
{
	Widget		applShell;
	XGCValues	werte;

	applShell = XtAppInitialize (&kontext, "Planung",
				     (XrmOptionDescRec*)NULL, 0,
				     &argc, argv, fallbackRessourcen,
				     (Arg*)NULL, 0);

        display = XtDisplay (applShell);

	initWidgetsBaum (applShell);

        XtRealizeWidget (applShell);

        XtVaGetValues (DrawAr, XmNforeground, &(werte.foreground),
                       XmNbackground, &(werte.background), NULL) ;
        fensterGC = XCreateGC (display, XtWindow (DrawAr),
            GCForeground | GCBackground, &werte) ;

	werte.foreground = werte.background;
	eraseDrawArGC = XCreateGC (display, XtWindow (DrawAr),
	    GCForeground, &werte) ;

	if (! GraphikPixmap)
		resizeCB (DrawAr, (XtPointer) 0, (XtPointer) 0) ;

	XtAppMainLoop (kontext);
}