import java.awt.*;
import java.awt.event.*;
import java.lang.Math;
import java.util.*;
import javax.swing.*;
import com.genlogic.*;

//////////////////////////////////////////////////////////////////////////
// A diagramming editor: example of using Extended API.
//
// This demo uses Glg as a bean and may be used in a browser or
// stand-alone.
//
// The CustomHandler class provides callbacks for interfacing with
// application-specific functionality.
//////////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////
public class GlgDiagram extends GlgJBean
{
   static final long serialVersionUID = 0;

   // Constants

   // Selection sensitivity in pixels
   static final int SELECTION_RESOLUTION = 5;
   static final int POINT_SELECTION_RESOLUTION = 2;

   // Number of palette buttons to skip: the first button with the 
     // "select" icon is already in the palette.
   static final int PALETTE_START_INDEX = 1;

   // Default scale factor for icon buttons.
   static final double DEFAULT_ICON_SCALE = 10.;

   // Scale factor when placed in the drawing
   static final double IconScale = 1.;

   // Editing Modes
   static final int SELECT_OBJECT = 0;
   static final int ADD_NODE = 4;
   static final int ADD_LINK1 = 5;
   static final int ADD_LINK2 = 6;
   static final int DRAGGING = 7;

   // Object types
   static final int NO_OBJ = 0;
   static final int NODE = 1;
   static final int LINK = 2;

   boolean StandAlone;
   GlgObject Viewport;
   GlgObject MainArea;
   GlgObject SelectedObject = null;
   GlgObject SelectedMarker = null;
   boolean StickyCreateMode = false;
   boolean AllowUnconnectedLinks = true;
   boolean PointFeedbackShown = false;
   int SelectedObjectType;
   int NodeType;
   int LinkType;
   GlgObject DragLink;
   int EdgeType;
   GlgObject Point1;
   GlgObject StoredColor;
   GlgObject CutBuffer;
   int CutBufferType;
   int Mode;
   int NumLinkPoints;
   boolean MiddlePointAdded = false;
   String LastButton;
   GlgObject Handler;
   GlgDiagramData CurrentDiagram = new GlgDiagramData();
   GlgDiagramData SavedDiagram;
   GlgObject NodeIconArray;
   GlgObject NodeObjectArray;
   GlgObject LinkIconArray;
   GlgObject LinkObjectArray;
   GlgObject PaletteTemplate;
   GlgObject ButtonTemplate;
   int NumRows;
   int NumColumns;

   GlgPoint cursor_pos = new GlgPoint();
   GlgPoint world_coord = new GlgPoint();
   GlgPoint screen_coord = new GlgPoint();
   GlgPoint start_point = new GlgPoint();
   GlgPoint end_point = new GlgPoint();
   GlgCube select_rect = new GlgCube();

   GlgObject last_color; // Stores color during selection.

   //////////////////////////////////////////////////////////////////////////
   // Utility class used to return several values.
   //////////////////////////////////////////////////////////////////////////
   class ObjectInfo
   {
      GlgObject object;
      int type;

      // Constructors
      ObjectInfo()
      {}

      ObjectInfo( GlgObject object_p, int type_p )
      {
         object = object_p;
         type = type_p;
      }
   }

   //////////////////////////////////////////////////////////////////////////
   public GlgDiagram()
   {
      super();
      SetDResource( "$config/GlgSwingUsage", 1. );

      SelectedObjectType = NO_OBJ;
      CutBufferType = NO_OBJ;
      Mode = SELECT_OBJECT;
      LastButton = null;

      // The bean is a default listener for bean events except the trace
      // events (which are disabled by default), but add all listeners
        // explicitely as an example.
      AddListener( GlgObject.H_CB, this );
      AddListener( GlgObject.V_CB, this );
      AddListener( GlgObject.READY_CB, this );
      AddListener( GlgObject.INPUT_CB, this );
      AddListener( GlgObject.TRACE_CB, this );
   }

   //////////////////////////////////////////////////////////////////////////
   // For use as a stand-alone java demo
   //////////////////////////////////////////////////////////////////////////
   public static void main( final String arg[] )
   {
      SwingUtilities.
        invokeLater( new Runnable(){ public void run() { Main( arg ); } } );
   }

   //////////////////////////////////////////////////////////////////////////
   public static void Main( final String arg[] )
   {
      class DemoQuit extends WindowAdapter
      {
         public void windowClosing( WindowEvent e ) { System.exit( 0 ); }
      }

      JFrame frame = new JFrame();

      frame.setResizable( true );
      frame.setSize( 900, 700 );
      frame.setLocation( 20, 20 );

      GlgDiagram diagram = new GlgDiagram();
      diagram.StandAlone = true;

      // Loading the drawing triggers the H, V and Ready callbacks.
      // When used as an applet, the DrawingName parameter is set in HTML.
        //
      diagram.SetDrawingName( "diagram.g" );

      frame.getContentPane().add( diagram );

      frame.addWindowListener( new DemoQuit() );
      frame.setVisible( true );
   }

   //////////////////////////////////////////////////////////////////////////
   // Invoked after the drawing has been loaded but before it's set up. 
   //////////////////////////////////////////////////////////////////////////
   public void HCallback( GlgObject viewport )
   {
      // Fill out the palette and change the dialog type before the 
        // hierarchy setup

      Viewport = GetViewport();

      MainArea = Viewport.GetResourceObject( "MainArea" );
      if( MainArea == null )
      {
         PrintToJavaConsole( "Can't find MainArea viewport.\n" );
         return;
      }

      PaletteTemplate = Viewport.GetResourceObject( "PaletteTemplate" );
      if( PaletteTemplate == null )
      {
         PrintToJavaConsole( "Can't find PaletteTemplate viewport.\n" );
         return;
      }
      Viewport.DeleteObject( PaletteTemplate );

      // Create groups to hold nodes and links.
      NodeIconArray = new GlgDynArray( GlgObject.GLG_OBJECT, 0, 0 );
      NodeObjectArray = new GlgDynArray( GlgObject.GLG_OBJECT, 0, 0 );
      LinkIconArray = new GlgDynArray( GlgObject.GLG_OBJECT, 0, 0 );
      LinkObjectArray = new GlgDynArray( GlgObject.GLG_OBJECT, 0, 0 );

      // Scan palette template and extract icon and link objects, adding them
        // to the buttons in the object palette.
      GetPaletteIcons( PaletteTemplate, "Node",
                      NodeIconArray, NodeObjectArray );
      GetPaletteIcons( PaletteTemplate, "Link",
                      LinkIconArray, LinkObjectArray );

      FillObjectPalette( "ObjectPalette", "IconButton", PALETTE_START_INDEX );
   }

   //////////////////////////////////////////////////////////////////////////
   // Invoked after the drawing has been loaded and set up, but before it's 
   // displayed.
   //////////////////////////////////////////////////////////////////////////
   public void VCallback( GlgObject viewport )
   {
      // Do some initialization here before displaying the drawing.
      SetPrompt( "" );

      // Create a color object to store original node color during node 
      // selection.
      StoredColor = Viewport.GetResourceObject( "FillColor" ).CopyObject();

      // Make exit button visible for stand-alone.
      if( StandAlone )
        Viewport.SetDResource( "Exit/Visibility", 1. );
      else
        Viewport.SetDResource( "Exit/Visibility", 0. );

      // Set grid color (configuration parameter) to grey.
      Viewport.SetGResource( "$config/GlgGridPolygon/EdgeColor",
                             0.632441, 0.632441, 0.632441 );

      // Change the shell type of the Properties dialog to make it a separate
      // top-level window, and make it invisible on start-up.
        // You can replace the dialog with any custom Java-based dialog.
      Viewport.SetDResource( "Dialog/ShellType",
                            (double) GlgObject.DIALOG_SHELL );
      Viewport.SetDResource( "Dialog/Visibility", 0. );

      // Set the Properties dialog's title.
      Viewport.SetSResource( "Dialog/ScreenName", "Object Properties" );

      // Create a separate group to hold objects.
      GlgObject group = new GlgDynArray( GlgObject.GLG_OBJECT, 0, 0 );
      group.SetSResource( "Name", "ObjectGroup" );
      MainArea.AddObjectToBottom( group );

      Mode = SELECT_OBJECT;
      SetRadioBox( "IconButton0" ); // Highlight Select button

      SetCreateMode(); // Query initial create mode from the drawing.

      CurrentDiagram = new GlgDiagramData();

      // Position node icons inside the palette buttons.
      SetupObjectPalette( "IconButton", PALETTE_START_INDEX );
   }

   //////////////////////////////////////////////////////////////////////////
   // Invoked after the drawing has been drawn for the first time.
   //////////////////////////////////////////////////////////////////////////
   public void ReadyCallback( GlgObject viewport )
   {
      // May be used to start data updates, not used here.
   }

   //////////////////////////////////////////////////////////////////////////
   // Sets create mode based on the state of the CreateMode button.
   //////////////////////////////////////////////////////////////////////////
   void SetCreateMode()
   {
      int create_mode = (int) GetDResource( "CreateMode/OnState" );
      StickyCreateMode = ( create_mode != 0 );
   }

   ////////////////////////////////////////////////////////////////////////
   // The trace callback receives all low-level events and is used for
   // handling mouse interaction, such as creating and dragging nodes
   // and links. 
   //
   // The TraceCB requires handling native events as the price of the extended
   // functionality it provides. However, the native code is limited to just
   // a few code lines to extract the platform-specific event information.
   ////////////////////////////////////////////////////////////////////////
   public void TraceCallback( GlgObject viewport, GlgTraceData trace_info )
   {
      int event_type;

      // Use the MainArea's events only.
      if( !IsReady() || trace_info.viewport != MainArea )
        return;

      event_type = trace_info.event.getID();
      switch( event_type )
      {
       case MouseEvent.MOUSE_PRESSED:
       case MouseEvent.MOUSE_MOVED:
       case MouseEvent.MOUSE_DRAGGED:
       case MouseEvent.MOUSE_RELEASED:
         if( GetButton( trace_info.event ) != 1 )
           return; // Use the left button clicks only.

         cursor_pos.x = (double) ((MouseEvent)trace_info.event).getX();
         cursor_pos.y = (double) ((MouseEvent)trace_info.event).getY();
         cursor_pos.z = 0.;
         break;

       default: return;
      }

      if( MainArea.GetDResource( "ZoomToMode" ).intValue() != 0 )
        return; // Don't handle mouse selection in ZoomTo mode.

      switch( Mode )
      {
       default:
         Bell();
         ResetModes();
         Update();
         return;

       case ADD_NODE: AddNodeHandler( event_type, cursor_pos ); return;

       case ADD_LINK1:
       case ADD_LINK2:
         AddLinkHandler( event_type, cursor_pos, viewport, trace_info );
         return;

       case DRAGGING:
         DraggingHandler( event_type, cursor_pos ); return;

       case SELECT_OBJECT:
         ObjectHandler( event_type, cursor_pos, viewport, trace_info ); return;
      }
   }

   ////////////////////////////////////////////////////////////////////////
   public void AddNodeHandler( int event_type, GlgPoint cursor_pos )
   {
      if( event_type != MouseEvent.MOUSE_PRESSED )
        return;

      // Use screen coords of the cursor to add graphics
      GlgObject new_node =
        AddNodeAt( NodeType, null, cursor_pos, GlgObject.SCREEN_COORD );

      CustomHandler.AddObjectCB( this, new_node, GetData( new_node ), true );

      SelectGlgObject( new_node, NODE );

      if( !StickyCreateMode )
        ResetModes();

      Update();
   }

   ////////////////////////////////////////////////////////////////////////
   public void AddLinkHandler( int event_type, GlgPoint cursor_pos,
                              GlgObject viewport, GlgTraceData trace_info )
   {
      GlgObject point, sel_object = null;
      GlgLinkData link_data;
      int num_selected;

      if( event_type != MouseEvent.MOUSE_PRESSED &&
         event_type != MouseEvent.MOUSE_MOVED )
        return;

      // Drag the link
      if( event_type == MouseEvent.MOUSE_MOVED && Mode == ADD_LINK2 )
      {
         link_data = (GlgLinkData) GetData( DragLink );

         // First time: set link direction depending of the 
           // direction of the first mouse move, then make the link visible.
         if( link_data.first_move )
         {
            SetEdgeDirection( DragLink, start_point, cursor_pos );
            DragLink.SetDResource( "Visibility", 1. );
            link_data.first_move = false;
         }

         SetLastPoint( DragLink, cursor_pos, false );

         if( !MiddlePointAdded )
           SetArcMiddlePoint( DragLink );
         Update();
      }

      GlgObject selection =
        GetObjectsAtCursor( /** top viewport **/ viewport,
                           /** event viewport **/ trace_info.viewport,
                           cursor_pos );

      if( selection != null && ( num_selected = selection.GetSize() ) != 0 )
      {
         // Some objects were selected, process the selection to find the 
           // point to connect to.
         point = null;
         for( int i=0; i < num_selected; ++i )
         {
            sel_object = (GlgObject) selection.GetElement( i );

            // Find if the object itself is a link or a node,
            // of if it's a part of a node. If it's a part of a node,
            // get the node object ID.
            //
            ObjectInfo selection_info = GetSelectedObject( sel_object );
            sel_object = selection_info.object;
            int selection_type = selection_info.type;

            if( selection_type == NODE )
            {
               int type = sel_object.GetDResource( "Type" ).intValue();
               if( type == GlgObject.REFERENCE )
               {
                  // Use ref's point as a connector.
                  point = sel_object.GetResourceObject( "Point" );
               }
               else
               {
                  // Node has multiple connectors. Get connection point 
                  point = GetSelectedPoint( sel_object, cursor_pos, "CP" );
               }

               if( point != null )
                 break; // Found a point to connect to: stop search and use it.
            }

            // No point to connect to: continue searching all selected objects.
         }

         if( point != null ) // Use point if found.
         {
            switch( event_type )
            {
               // Show feedback at the connector's position.
             case MouseEvent.MOUSE_MOVED:
               // Get screen coords of the connector point, not the cursor
               // position: may be a few pixels off.
               GlgPoint screen_point = point.GetGResource( "XfValue" );

               MainArea.ScreenToWorld( true, screen_point, world_coord );

               // Position the feedback marker over the connector
               SelectedMarker.SetGResource( "Point", world_coord );

               if( !PointFeedbackShown )
               {
                  MainArea.AddObjectToBottom( SelectedMarker );
                  PointFeedbackShown = true;
               }
               Update();
               break;

             case MouseEvent.MOUSE_PRESSED: // Connect
               switch( Mode )
               {
                case ADD_LINK1:
                  Point1 = point;

                  DragLink = AddLink( LinkType, null );
                  NumLinkPoints = 1;

                  // First point
                  ConstrainLinkPoint( DragLink, Point1, false );
                  AttachFramePoints( DragLink );

                  // Wire up the start node
                  link_data = (GlgLinkData) GetData( DragLink );
                  link_data.setStartNode( (GlgNodeData)GetData( sel_object ) );

                  // Store cursor position for setting direction based on the
                    // first mouse move.
                  start_point.CopyFrom( cursor_pos );
                  link_data.first_move = true;
                  DragLink.SetDResource( "Visibility", 0. );

                  Mode = ADD_LINK2;
                  SetPrompt( "Select the second node." );

                  Update();
                  break;

                case ADD_LINK2:
                  if( point == Point1 )
                  {
                     SetError( "The two nodes are the same, " +
                              "chose a different second node." );
                     break;
                  }

                  ++NumLinkPoints;

                  // Last point
                  ConstrainLinkPoint( DragLink, point, true );
                  AttachFramePoints( DragLink );
                  if( !MiddlePointAdded )
                    SetArcMiddlePoint( DragLink );

                  // Wire up the end node
                  link_data = (GlgLinkData) GetData( DragLink );
                  link_data.setEndNode( (GlgNodeData) GetData( sel_object ) );

                  FinalizeLink( DragLink );
                  DragLink = null;

                  if( StickyCreateMode )
                  {
                     // Start over to create more links
                     Mode = ADD_LINK1;
                     SetPrompt( "Select the first node." );
                     MiddlePointAdded = false;
                  }
                  else
                    ResetModes();

                  Update();
                  break;
               }
            } /* switch( event_type ) */

            return; // We are done with the point.

         } /* if( point != null )   */
      }

      // No point or no selection: handle point feedback and link middle 
        // points.

      if( PointFeedbackShown )
      {
         MainArea.DeleteObject( SelectedMarker );
         PointFeedbackShown = false;
         Update();
      }

      if( event_type == MouseEvent.MOUSE_PRESSED ) // Add midlle link point
      {
         if( Mode == ADD_LINK1 )
         {
            SetError( "Invalid connection point!" );
            return; // No first point yet
         }

         ++NumLinkPoints;

         // Add middle link point.
         AddLinkPoints( DragLink, 1 );
         MiddlePointAdded = true;

         SetLastPoint( DragLink, cursor_pos, EdgeType == GlgObject.ARC );
         AttachFramePoints( DragLink );

         if( EdgeType == GlgObject.ARC )
         {
            // Offset the last point after setting the middle one.
            cursor_pos.x += 10;
            cursor_pos.y += 10;
            SetLastPoint( DragLink, cursor_pos, false );
         }
         Update();
      }
   }

   ////////////////////////////////////////////////////////////////////////
   void FinalizeLink( GlgObject link )
   {
      GlgObject arrow_type = link.GetResourceObject( "ArrowType" );
      if( arrow_type != null )
        arrow_type.SetDResource( null, (double) GlgObject.MIDDLE_FILL_ARROW );

      GlgLinkData link_data = (GlgLinkData) GetData( link );

      // Store points
      StorePointData( link_data, link );

      // Add link data to the link list
      Vector link_list = CurrentDiagram.getLinkList();
      link_list.addElement( link_data );

      // After storing color: changes color to select.
      SelectGlgObject( link, LINK );

      CustomHandler.AddObjectCB( this, link, GetData( link ), false );
   }

   ////////////////////////////////////////////////////////////////////////
   // Stores point coordinates in the link data structure as a vector.
   ////////////////////////////////////////////////////////////////////////
   void StorePointData( GlgLinkData link_data, GlgObject link )
   {
      ObjectInfo link_info = GetCPContainer( link );
      GlgObject point_container = link_info.object;

      int num_points = point_container.GetSize();

      // Always create a new vector and discard the old one for simplicity
        // (not much to gain any way).
      link_data.point_array = new Vector( num_points );
      for( int i=0; i<num_points; ++i )
      {
         GlgObject point = (GlgObject) point_container.GetElement( i );
         GlgPoint xyz = point.GetGResource( null );
         link_data.point_array.addElement( new GlgDiagramPoint( xyz ) );
      }
   }

   ////////////////////////////////////////////////////////////////////////
   // Restores link's middle points from the link data's stored vector.
   // The first and last point's values are not used: they are constrained 
   // to nodes and positioned/controlled by them.
   ////////////////////////////////////////////////////////////////////////
   void RestorePointData( GlgLinkData link_data, GlgObject link )
   {
      // Set middle point values
      if( link_data.point_array != null )
      {
         int num_points = link_data.point_array.size();

         ObjectInfo link_info = GetCPContainer( link );
         GlgObject point_container = link_info.object;

         // Skip the first and last point if they are constrained to nodes.
           // Set only the unconnected ends and middle points.
         int start = ( link_data.getStartNode() != null ? 1 : 0 );
         int end =
           ( link_data.getEndNode() != null ? num_points - 1 : num_points );

         // Skip the first and last point: constrained to nodes.
           // Set only the middle points.
         for( int i=start; i<end; ++i )
         {
            GlgObject point = (GlgObject) point_container.GetElement( i );
            GlgDiagramPoint xyz =
              (GlgDiagramPoint) link_data.point_array.elementAt( i );
            point.SetGResource( null, xyz );
         }
      }
   }

   ////////////////////////////////////////////////////////////////////////
   // Handles object selection and dragging start.
   ////////////////////////////////////////////////////////////////////////
   public void ObjectHandler( int event_type, GlgPoint cursor_pos,
                             GlgObject viewport, GlgTraceData trace_info )
   {
      int num_selected;

      if( event_type != MouseEvent.MOUSE_PRESSED )
        return;

      GlgObject selection =
        GetObjectsAtCursor( /** top viewport **/ viewport,
                           /** event viewport **/ trace_info.viewport,
                           cursor_pos );

      if( selection != null && ( num_selected = selection.GetSize() ) != 0 )
      {
         // Some objects were selected, process the selection.
         for( int i=0; i < num_selected; ++i )
         {
            GlgObject sel_object = (GlgObject) selection.GetElement( i );

            // Find if the object itself is a link or a node,
            // of if it's a part of a node. If it's a part of a node,
            // get the node object ID.
            //
            ObjectInfo selection_info = GetSelectedObject( sel_object );
            sel_object = selection_info.object;
            int selection_type = selection_info.type;

            if( selection_type != 0 )
            {
               SelectGlgObject( sel_object, selection_type );

               Update();

               CustomHandler.SelectObjectCB( this, sel_object,
                                            GetData( sel_object ),
                                            selection_type == NODE );

               // Prepare for dragging
               Mode = DRAGGING;

               // Store the start point
               start_point.CopyFrom( cursor_pos );
               return;
            }
         }
      }

      // No link or node was selected.
      SelectGlgObject( null, 0 ); // Unselect.
      Update();
   }

   ////////////////////////////////////////////////////////////////////////
   public void DraggingHandler( int event_type, GlgPoint cursor_pos )
   {
      switch( event_type )
      {
       case MouseEvent.MOUSE_RELEASED:
         ResetModes();
         return;

       case MouseEvent.MOUSE_DRAGGED:
         if( SelectedObjectType == NODE )
           SelectedObject.MoveObject( GlgObject.SCREEN_COORD,
                                     start_point, cursor_pos );
         else
           MoveLink( SelectedObject, start_point, cursor_pos );

         Update();

         Object data = GetData( SelectedObject );
         if( data != null )
            if( data instanceof GlgNodeData )
            {
               // Update the X and Y in the product's data struct.
               UpdateNodePosition( SelectedObject, (GlgNodeData) data );

               // Don't need to update the attached links' points, since 
               // the stored positions of the first and last points are
               // not used: they are constrained to nodes and positioned 
                 // by them.
            }
            else // LinkData
            {
               GlgLinkData link_data = (GlgLinkData) data;

               GlgNodeData start_node = link_data.getStartNode();
               if( start_node != null )
                 UpdateNodePosition( start_node.graphics, null );

               GlgNodeData end_node = link_data.getEndNode();
               if( end_node != null )
                 UpdateNodePosition( end_node.graphics, null );

               // Update stored point values
               StorePointData( link_data, SelectedObject );
            }

         // Update the start point for the next move
         start_point.CopyFrom( cursor_pos );
         break;
      }
   }

   ////////////////////////////////////////////////////////////////////////
   // If the link is attached to nodes that use reference objects, moving the
   // link moves the nodes, with no extra actions required. However, the link
   // can be connected to a node with multiple attachment points which doesn't
   // use reference object. Moving such a link would move just the attachment
   // points, but not the nodes. To avoid this, unsconstrain the end points
   // of the link not to spoil the attachment points' geometry, move the link,
   // move the nodes, then constrain the link points back.
   ////////////////////////////////////////////////////////////////////////
   void MoveLink( GlgObject link, GlgPoint start_point, GlgPoint end_point )
   {
      GlgObject
        start_node = null,
        end_node = null;
      int type1 = GlgObject.REFERENCE, type2 = GlgObject.REFERENCE;

      GlgLinkData link_data = (GlgLinkData) GetData( link );

      if( link_data.getStartNode() != null )
      {
         start_node = link_data.getStartNode().graphics;
         type1 = start_node.GetDResource( "Type" ).intValue();
      }

      if( link_data.getEndNode() != null )
      {
         end_node = link_data.getEndNode().graphics;
         type2 = end_node.GetDResource( "Type" ).intValue();
      }

      if( type1 == GlgObject.REFERENCE && type2 == GlgObject.REFERENCE )
      {
         // Nodes are reference objects (or null), moving the link moves nodes.
         link.MoveObject( GlgObject.SCREEN_COORD, start_point, end_point );
      }
      else // Nodes with multiple attachment points.
      {
         // Unconstrain link points
         GlgObject point1 = null, point2 = null;

         if( start_node != null )
           point1 = UnConstrainLinkPoint( link, false );
         if( end_node != null )
           point2 = UnConstrainLinkPoint( link, true );

         DetachFramePoints( link );

         // Move the link
         link.MoveObject( GlgObject.SCREEN_COORD, start_point, end_point );

         // Move start node, then reattach the link.
         if( start_node != null )
         {
            start_node.MoveObject( GlgObject.SCREEN_COORD,
                                  start_point, end_point );
            ConstrainLinkPoint( link, point1, false );
         }

         // Move end node, then reattach the link.
         if( end_node != null )
         {
            end_node.MoveObject( GlgObject.SCREEN_COORD,
                                start_point, end_point );
            ConstrainLinkPoint( link, point2, true );
         }

         AttachFramePoints( link );
      }
   }

   ////////////////////////////////////////////////////////////////////////
   void UpdateNodePosition( GlgObject node, GlgNodeData node_data )
   {
      if( node_data == null )
        node_data = (GlgNodeData) GetData( node );

      GetPosition( node, world_coord );
      node_data.position.x = world_coord.x;
      node_data.position.y = world_coord.y;
   }

   ////////////////////////////////////////////////////////////////////////
   public GlgObject GetObjectsAtCursor( GlgObject viewport, GlgObject event_vp,
                                       GlgPoint cursor_pos )
   {
      // Select all objects in the vicinity of the +-SELECTION_RESOLUTION 
      // pixels from the actual mouse click position.
      select_rect.p1.x = cursor_pos.x - SELECTION_RESOLUTION;
      select_rect.p1.y = cursor_pos.y - SELECTION_RESOLUTION;
      select_rect.p2.x = cursor_pos.x + SELECTION_RESOLUTION;
      select_rect.p2.y = cursor_pos.y + SELECTION_RESOLUTION;

      return
        GlgObject.CreateSelection( /** top viewport **/ viewport, select_rect,
                                  /** event viewport **/ event_vp );
   }

   ////////////////////////////////////////////////////////////////////////
   public void InputCallback( GlgObject viewport, GlgObject message_obj )
   {
      if( !IsReady() )
        return;

      String format = message_obj.GetSResource( "Format" );
      String origin = message_obj.GetSResource( "Origin" );
      String full_origin = message_obj.GetSResource( "FullOrigin" );
      String action = message_obj.GetSResource( "Action" );
      // String subaction   = message_obj.GetSResource( "SubAction" );

      // Handle Dialog window closing.
      if( format.equals( "Window" ) && action.equals( "DeleteWindow" ) &&
         origin.equals( "Dialog" ) )
      {
         // Close the dialog window.
         Viewport.SetDResource( "Dialog/Visibility", 0. );
         Update();
      }
      else if( format.equals( "Button" ) )
      {
         if( !action.equals( "Activate" ) && !action.equals( "ValueChanged" ) )
           return;

         ResetModes();

         if( origin.equals( "Save" ) )
           Save( CurrentDiagram );
         else if( origin.equals( "Insert" ) )
           Load();
         else if( origin.equals( "Print" ) )
           Print();
         else if( origin.equals( "Cut" ) )
           Cut();
         else if( origin.equals( "Paste" ) )
           Paste();
         else if( origin.equals( "Exit" ) )
           System.exit( 0 );
         else if( origin.equals( "ZoomIn" ) )
         {
            ResetModes();
            MainArea.SetZoom( null, 'i', 0. );
         }
         else if( origin.equals( "ZoomOut" ) )
         {
            ResetModes();
            MainArea.SetZoom( null, 'o', 0. );
         }
         else if( origin.equals( "ZoomTo" ) )
         {
            ResetModes();
            MainArea.SetZoom( null, 't', 0. );
         }
         else if( origin.equals( "ZoomReset" ) )
         {
            ResetModes();
            MainArea.SetZoom( null, 'n', 0. );
         }
         else if( origin.startsWith( "IconButton" ) )
         {
            GlgObject button = viewport.GetResourceObject( full_origin );
            GlgObject icon = button.GetResourceObject( "Icon" );
            if( icon == null )
            {
               SetError( "Can't find icon." );
               return;
            }

            // Object to use in the drawing. In case of connectors, uses only a
            // part of the icon (the connector object) without the end markers.
              //
            GlgObject object = icon.GetResourceObject( "Object" );
            if( object == null )
              object = icon;

            String icon_type = object.GetSResource( "IconType" );
            if( icon_type == null )
            {
               SetError( "Can't find IconType resource." );
               return;
            }

            if( icon_type.equals( "Select" ) )
              ResetModes();

            else if( icon_type.equals( "Link" ) )
              AddLink( full_origin, object );

            else if( icon_type.equals( "Node" ) )
              AddNode( full_origin, object );
         }

         else if( origin.equals( "DialogApply" ) )
           ApplyData();

         else if( origin.equals( "DialogClose" ) )
         {
            if( ApplyData() )
              // Close the dialog if successfully applied.
              Viewport.SetDResource( "Dialog/Visibility", 0. );
         }
         else if( origin.equals( "DialogCancel" ) )
         {
            // Close the dialog without applying the data.
            Viewport.SetDResource( "Dialog/Visibility", 0. );
         }
         else if( origin.equals( "Properties" ) )
         {
            // You can use a custom Java-based dialog to display properties
              // of the selected mode or link.
            FillData();
            Viewport.SetDResource( "Dialog/Visibility", 1. );
         }
         else if( origin.equals( "CreateMode" ) )
         {
            ResetModes();
            SetCreateMode();
         }

         Update();
      }
   }

   ////////////////////////////////////////////////////////////////////////
   void SelectGlgObject( GlgObject object, int selected_type )
   {
      String name;

      if( object == SelectedObject )
        return; // No change

      if( last_color != null ) // Restore the color of previously selected node
      {
         last_color.SetResourceFromObject( null, StoredColor );
         last_color = null;
      }

      SelectedObject = object;
      SelectedObjectType = selected_type;

      // Change color to highlight selected node.
      if( object != null )
      {
         if( selected_type == NODE )
         {
            last_color = object.GetResourceObject( "Template/SelectColor" );
            if( last_color == null ) // Not a reference object
              last_color = object.GetResourceObject( "SelectColor" );
         }
         else // Link
           last_color = object.GetResourceObject( "EdgeColor" );

         // Store original color
         StoredColor.SetResourceFromObject( null, last_color );

         // Set color to red to highlight selection.
         last_color.SetGResource( null, 1., 0., 0. );

         name = GetObjectLabel( SelectedObject );
      }
      else
        name = "NONE";

      // Display selected object name at the bottom.
      Viewport.SetSResource( "SelectedObject", name );

      FillData();
   }

   ////////////////////////////////////////////////////////////////////////
   void AddNode( String button_name, GlgObject node )
   {
      Mode = ADD_NODE;
      SetPrompt( "Position the node." );

      SetRadioBox( button_name );

      // Store Node type
      NodeType = node.GetDResource( "Index" ).intValue();
   }

   ////////////////////////////////////////////////////////////////////////
   void AddLink( String button_name, GlgObject link )
   {
      Mode = ADD_LINK1;
      SetPrompt( "Select the first node." );

      SetRadioBox( button_name );

      // Store Link type
      LinkType = link.GetDResource( "Index" ).intValue();

      ObjectInfo link_info = GetCPContainer( link );
      EdgeType = link_info.type;
   }

   ////////////////////////////////////////////////////////////////////////
   void Cut()
   {
      if( NoSelection() )
        return;

      // Disallow deleting a node without deleting the link first.
      if( SelectedObjectType == NODE && NodeConnected( SelectedObject ) )
      {
         SetError( "Remove links connected to the node before removing the node!" );
         return;
      }

      GlgObject group = MainArea.GetResourceObject( "ObjectGroup" );

      if( group.ContainsObject( SelectedObject ) )
      {
         // Store the node or link in the cut buffer.
         CutBuffer = SelectedObject;
         CutBufferType = SelectedObjectType;

         // Delete the node
         group.DeleteObject( SelectedObject );

         // Delete the data
         Object data = GetData( SelectedObject );
         Vector list = null;

         CustomHandler.CutObjectCB( this, SelectedObject, data,
                                   SelectedObjectType == NODE );

         if( SelectedObjectType == NODE )
           list = (Vector) CurrentDiagram.getNodeList();
         else // Link
           list = (Vector) CurrentDiagram.getLinkList();

         if( !list.removeElement( data ) )
           System.out.println( "Deleting data failed!" );

         SelectGlgObject( null, 0 );
      }
      else
        SetError( "Cut failed." );
   }

   ////////////////////////////////////////////////////////////////////////
   void Paste()
   {
      if( CutBuffer == null )
      {
         SetError( "Empty cut buffer, cut some object first." );
         return;
      }

      GlgObject group = MainArea.GetResourceObject( "ObjectGroup" );

      Object data = GetData( CutBuffer );
      Vector list = null;

      CustomHandler.PasteObjectCB( this, CutBuffer, data,
                                  CutBufferType == NODE );

      if( CutBufferType == NODE )
      {
         group.AddObjectToBottom( CutBuffer ); // In front
         list = CurrentDiagram.getNodeList();
      }
      else // LINK
      {
         group.AddObjectToTop( CutBuffer ); // Behind
         list = CurrentDiagram.getLinkList();
      }
      list.addElement( data );

      SelectGlgObject( CutBuffer, CutBufferType );

      // Allow pasting just once to avoid handling the data copy
      CutBuffer = null;
   }

   ////////////////////////////////////////////////////////////////////////
   void Save( GlgDiagramData diagram )
   {
      // Print all nodes and edges as a test
      Vector node_list = diagram.getNodeList();
      Vector link_list = diagram.getLinkList();

      int i;
      for( i=0; i<node_list.size(); ++i )
        System.out.println( "Node " + i + ", type " +
                          ((GlgNodeData) node_list.elementAt( i )).node_type );

      for( i=0; i<link_list.size(); ++i )
        System.out.println( "Link " + i );

      // Save the DiagramData class using either Java serialization,
      // writing out individual records, or any other custom save method.

      // Save the current diagram to use it as test for loading.
      SavedDiagram = diagram;

      // Empty the drawing area
      UnsetDiagram( diagram );
   }

   ////////////////////////////////////////////////////////////////////////
   void Load()
   {
      // Load the DiagramClass using Java de-serialization, reading individual
      // records or any other custom load method matching the save method
        // used above.

      // In the demo, load the saved diagram and use it as a Save/Load test.
      if( SavedDiagram == null )
        SetError( "Save the diagram first." );
      else
      {
         UnsetDiagram( CurrentDiagram );

         // Load saved diagram
         SetDiagram( SavedDiagram );
         SavedDiagram = null;
      }
   }

   ////////////////////////////////////////////////////////////////////////
   void Print()
   {
      ResetModes();

      // May be used to export postscript, generate an image to be saved, 
      // or invoke native Java printing (see Glg Java print examples).

      // In an applet printing is handled by the browser's print button.
   }

   ////////////////////////////////////////////////////////////////////////
   void ResetModes()
   {
      if( Mode != 0 )
      {
         if( DragLink != null )
         {
            if( AllowUnconnectedLinks && FinishLink( DragLink ) )
              ; // Keep the link even if its second end is not connected.
            else
            {
               GlgObject group = MainArea.GetResourceObject( "ObjectGroup" );
               group.DeleteObject( DragLink );
            }
            DragLink = null;
         }

         Mode = SELECT_OBJECT;
         SetRadioBox( "IconButton0" ); // Highlight Select button

         // Remove the link connection feedback marker, if there.
         if( SelectedMarker != null &&
            MainArea.ContainsObject( SelectedMarker ) )
           MainArea.DeleteObject( SelectedMarker );
      }

      SetPrompt( "" );
      Update();
   }

   ////////////////////////////////////////////////////////////////////////
   // If AllowUnconnectedLinks=true, keep the link if it has at least two 
   ////////////////////////////////////////////////////////////////////////
   boolean FinishLink( GlgObject link )
   {
      ObjectInfo link_info = GetCPContainer( link );

      GlgObject point_container = link_info.object;

      int edge_type = link_info.type;
      if( edge_type == GlgObject.ARC )
        return false; // Disconnected arc links are not allowed.

      int size = point_container.GetSize();

      // The link must have at least two points already defined, and one extra
        // point that was added to drag the next point.
      if( size < 3 )
        return false;

      // Delete the unfinished, unconnected point.
      GlgObject suspend_info = link.SuspendObject();
      point_container.DeleteBottomObject();
      link.ReleaseObject( suspend_info );

      FinalizeLink( link );
      return true;
   }

   ////////////////////////////////////////////////////////////////////////
   void SetPrompt( String string )
   {
      Viewport.SetSResource( "Prompt/String", string );
      Update();
   }

   ////////////////////////////////////////////////////////////////////////
   void SetError( String string )
   {
      Bell();
      SetPrompt( string );
   }

   ////////////////////////////////////////////////////////////////////////
   boolean NoSelection()
   {
      if( SelectedObject != null )
        return false;
      else
      {
         SetError( "Select some object first." );
         return true;
      }
   }

   ////////////////////////////////////////////////////////////////////////
   GlgObject AddNodeAt( int node_type, GlgNodeData node_data, GlgPoint pos,
                  int coord_system )
   {
      boolean store_position;

      if( node_data == null )
      {
         node_data = new GlgNodeData();
         node_data.node_type = node_type;

         // Add node data to the node list
         Vector node_list = CurrentDiagram.getNodeList();
         node_list.addElement( node_data );
      }

      // Create the node based on the node type
      GlgObject new_node = CreateNode( node_data );
      int type = new_node.GetDResource( "Type" ).intValue();

      // Make label visible
      if( type == GlgObject.REFERENCE )
      {
         if( new_node.HasResourceObject( "Template/Label" ) )
         {
            new_node.SetDResource( "Template/Label/Visibility", 1. );
            new_node.SetSResource( "Template/Label/String",
                                  node_data.object_label );
         }
      }
      else if( new_node.HasResourceObject( "Label" ) )
      {
         new_node.SetDResource( "Label/Visibility", 1. );
         new_node.SetSResource( "Label/String", node_data.object_label );
      }

      // No cursor pos: get pos from the data struct.
      if( pos == null )
      {
         pos = new GlgPoint( node_data.position.x, node_data.position.y, 0. );
         store_position = false;
      }
      else
         store_position = true;

      node_data.graphics = new_node; // Pointer from data struct to graphics

      // Add the object to the drawing first, so that it's hierarchy is setup
        // for positioning it.
      GlgObject group = MainArea.GetResourceObject( "ObjectGroup" );
      group.AddObjectToBottom( new_node );

      // Transform the object to set its size and position.
      PlaceObject( new_node, pos, coord_system, world_coord );

      if( store_position )
      {
         node_data.position.x = world_coord.x;
         node_data.position.y = world_coord.y;
      }
      return new_node;
   }

   ////////////////////////////////////////////////////////////////////////
   GlgObject CreateNode( GlgNodeData node_data )
   {
      // Get node template from the palette
      GlgObject new_node = (GlgObject)
        NodeObjectArray.GetElement( node_data.node_type );

      // Create a new node instance 
      new_node = new_node.CloneObject( GlgObject.STRONG_CLONE );

      // Name node using an "object" prefix (used to distiguish
        // nodes from links on selection).
      new_node.SetSResource( "Name", "object" );

      AddCustomData( new_node, node_data );

      return new_node;
   }

   ////////////////////////////////////////////////////////////////////////
   GlgObject CreateLink( GlgLinkData link_data )
   {
      int num_points;

      // Get link template from the palette
      GlgObject new_link = (GlgObject)
        LinkObjectArray.GetElement( link_data.link_type );

      // Create a new link instance 
      new_link = new_link.CloneObject( GlgObject.STRONG_CLONE );

      // Name link using a "link" prefix (used to distiguish
        // links from nodes on selection).
      new_link.SetSResource( "Name", "link" );

      // If point_array exists, create/add middle link points
      // If not an arc, it's created with 2 points by default, 
      // add ( num_points - 2 ) more. If it's an arc, AddLinkPoints
        // will do nothing.
      if( link_data.point_array != null &&
         ( num_points = link_data.point_array.size() ) > 2 )
        AddLinkPoints( new_link, num_points - 2 );

      AddCustomData( new_link, link_data );

      return new_link;
   }

   /////////////////////////////////////////////////////////////////////////
   // Connects the first or last point of the link.
   /////////////////////////////////////////////////////////////////////////
   void ConstrainLinkPoint( GlgObject link, GlgObject point,
                           boolean last_point )
   {
      ObjectInfo link_info = GetCPContainer( link );

      GlgObject point_container = link_info.object;

      GlgObject link_point = (GlgObject)
        point_container.GetElement(
                ( last_point ? point_container.GetSize() - 1 : 0 ) );

      GlgObject suspend_info = link.SuspendObject();
      link_point.ConstrainObject( point );
      link.ReleaseObject( suspend_info );

      // Store the point name for save/load
      String point_name = point.GetSResource( "Name" );
      if( point_name == null || point_name.length() == 0 )
        point_name = "Point";

      GlgLinkData link_data = (GlgLinkData) GetData( link );
      if( last_point )
        link_data.end_point_name = point_name;
      else
        link_data.start_point_name = point_name;
   }


   /////////////////////////////////////////////////////////////////////////
   // Positions the arc's middle point if it's not explicitly defined.
   /////////////////////////////////////////////////////////////////////////
   void SetArcMiddlePoint( GlgObject link )
   {
      ObjectInfo link_info = GetCPContainer( link );
      GlgObject point_container = link_info.object;
      int edge_type = link_info.type;

      if( edge_type != GlgObject.ARC )
        return;

      // Offset the arc's middle point if wasn't set.
      GlgObject start_point = (GlgObject) point_container.GetElement( 0 );
      GlgObject middle_point = (GlgObject) point_container.GetElement( 1 );
      GlgObject end_point = (GlgObject) point_container.GetElement( 2 );

      GlgPoint pt1 = start_point.GetGResource( null );
      GlgPoint pt2 = end_point.GetGResource( null );

      // Offset the middle point.
      middle_point.SetGResource( null,
              ( pt1.x + pt2.x ) / 2. + ( pt1.y - pt2.y != 0. ? 50. : 0. ),
              ( pt1.y + pt2.y ) / 2. + ( pt1.y - pt2.y != 0. ? 0. : 50. ),
              ( pt1.z + pt2.z ) / 2. );
   }

   /////////////////////////////////////////////////////////////////////////
   // Handles links with labels: constrains frame's points to the link's 
   // points.
   /////////////////////////////////////////////////////////////////////////
   void AttachFramePoints( GlgObject link )
   {
      GlgObject
        frame,
        link_point_container,
        frame_point_container,
        link_start_point,
        link_end_point,
        frame_start_point,
        frame_end_point,
        suspend_info;

      frame = link.GetResourceObject( "Frame" );
      if( frame == null ) // Link without label and frame
        return;

      ObjectInfo link_info = GetCPContainer( link );
      link_point_container = link_info.object;

      // Always use the first segment of the link to attach the frame.
      link_start_point = (GlgObject) link_point_container.GetElement( 0 );
      link_end_point = (GlgObject) link_point_container.GetElement( 1 );

      frame_point_container = frame.GetResourceObject( "CPArray" );
      int size = frame_point_container.GetSize();
      frame_start_point =(GlgObject) frame_point_container.GetElement( 0 );
      frame_end_point =
        (GlgObject) frame_point_container.GetElement( size - 1 );

      suspend_info = link.SuspendObject();

      frame_start_point.ConstrainObject( link_start_point );
      frame_end_point.ConstrainObject( link_end_point );

      link.ReleaseObject( suspend_info );
   }

   /////////////////////////////////////////////////////////////////////////
   // Disconnects the first or last point of the link. Returns the object 
   // the link is connected to.
   /////////////////////////////////////////////////////////////////////////
   GlgObject UnConstrainLinkPoint( GlgObject link, boolean last_point )
   {
      ObjectInfo link_info = GetCPContainer( link );

      GlgObject point_container = link_info.object;

      GlgObject link_point = (GlgObject)
        point_container.GetElement(
                ( last_point ? point_container.GetSize() - 1 : 0 ) );
      GlgObject attachment_point = link_point.GetResourceObject( "Data" );

      GlgObject suspend_info = link.SuspendObject();
      link_point.UnconstrainObject();
      link.ReleaseObject( suspend_info );

      return attachment_point;
   }

   /////////////////////////////////////////////////////////////////////////
   // Detaches the first and last points of the frame.
   /////////////////////////////////////////////////////////////////////////
   void DetachFramePoints( GlgObject link )
   {
      GlgObject
        frame,
        frame_point_container,
        frame_start_point,
        frame_end_point,
        suspend_info;

      frame = link.GetResourceObject( "Frame" );
      if( frame == null ) // Link without label and frame
        return;

      frame_point_container = frame.GetResourceObject( "CPArray" );
      int size = frame_point_container.GetSize();
      frame_start_point = (GlgObject) frame_point_container.GetElement( 0 );
      frame_end_point =
        (GlgObject) frame_point_container.GetElement( size - 1 );

      suspend_info = link.SuspendObject();

      frame_start_point.UnconstrainObject();
      frame_end_point.UnconstrainObject();

      link.ReleaseObject( suspend_info );
   }

   /////////////////////////////////////////////////////////////////////////
   // Set last point of the link (dragging).
   /////////////////////////////////////////////////////////////////////////
   void SetLastPoint( GlgObject link, GlgPoint cursor_pos,
                     boolean arc_middle_point )
   {
      GlgObject point;

      ObjectInfo link_info = GetCPContainer( link );

      GlgObject point_container = link_info.object;

      if( arc_middle_point )
        // Setting the middle point of an arc.
        point = (GlgObject) point_container.GetElement( 1 );
      else
        // Setting the last point.
        point = (GlgObject)
          point_container.GetElement( point_container.GetSize() - 1 );

      MainArea.ScreenToWorld( true, cursor_pos, world_coord );
      point.SetGResource( null, world_coord );
   }

   /////////////////////////////////////////////////////////////////////////
   void AddLinkPoints( GlgObject link, int num_points )
   {
      ObjectInfo link_info = GetCPContainer( link );
      if( link_info.type == GlgObject.ARC )
        return; // Arc connectors have fixed number of points: don't add.

      GlgObject point_container = link_info.object;

      GlgObject point = (GlgObject) point_container.GetElement( 0 );

      GlgObject suspend_info = link.SuspendObject();
      for( int i=0; i<num_points; ++i )
      {
         GlgObject add_point = point.CloneObject( GlgObject.FULL_CLONE );
         point_container.AddObjectToBottom( add_point );
      }
      link.ReleaseObject( suspend_info );
   }

   /////////////////////////////////////////////////////////////////////////
   // Set the direction of the recta-linera connector depending on the 
   // direction of the first mouse move.
   /////////////////////////////////////////////////////////////////////////
   void SetEdgeDirection( GlgObject link,
                         GlgPoint start_pos, GlgPoint end_pos )
   {
      int direction;

      ObjectInfo link_info = GetCPContainer( link );
      int edge_type = link_info.type;

      if( edge_type == GlgObject.ARC || edge_type == 0 ) // Arc or polygon
        return;

      if( Math.abs( start_pos.x - end_pos.x ) >
         Math.abs( start_pos.y - end_pos.y ) )
        direction = GlgObject.HORIZONTAL;
      else
        direction = GlgObject.VERTICAL;
      link.SetDResource( "EdgeDirection", (double) direction );

      GlgLinkData link_data = (GlgLinkData) GetData( link );
      link_data.link_direction = direction;
   }

   ////////////////////////////////////////////////////////////////////////
   GlgObject AddLink( int link_type, GlgLinkData link_data )
   {
      GlgObject link;

      if( link_data == null ) // Creating a new link interactively
      {
         link_data = new GlgLinkData();
         link_data.link_type = link_type;

         link = CreateLink( link_data );

         // Store color
         link_data.link_color =
           new GlgDiagramPoint( link.GetGResource( "EdgeColor" ) );

         // Don't add link data to the link list or store points: 
         // will be done when finished creating the link.
      }
      else // Creating a link from data on load.
      {
         link = CreateLink( link_data );

         // Set color
         link.SetGResource( "EdgeColor", link_data.link_color );

         // Enable arrow type if defined 
         GlgObject arrow_type = link.GetResourceObject( "ArrowType" );
         if( arrow_type != null )
           arrow_type.SetDResource( null,
                                   (double) GlgObject.MIDDLE_FILL_ARROW );

         // Restore connector direction if recta-linear
         GlgObject direction = link.GetResourceObject( "EdgeDirection" );
         if( direction != null )
           direction.SetDResource( null, (double) link_data.link_direction );

         // Constrain end points to start and end nodes 
         GlgNodeData start_node = link_data.getStartNode();
         if( start_node != null )
         {
            GlgObject node1 = start_node.graphics;
            GlgObject point1 =
              node1.GetResourceObject( link_data.start_point_name );
            ConstrainLinkPoint( link, point1, false ); // First point
         }

         GlgNodeData end_node = link_data.getEndNode();
         if( end_node != null )
         {
            GlgObject node2 = end_node.graphics;
            GlgObject point2 =
              node2.GetResourceObject( link_data.end_point_name );
            ConstrainLinkPoint( link, point2, true ); // Last point
         }

         AttachFramePoints( link );

         RestorePointData( link_data, link );
      }

      // Display the label if it's a link with a label.
      if( link.HasResourceObject( "Label" ) )
        link.SetSResource( "Label/String", link_data.object_label );

      link_data.graphics = link; // Pointer from data struct to graphics

      // Add to the top of the draw list to be behind other objects.
      GlgObject group = MainArea.GetResourceObject( "ObjectGroup" );
      group.AddObjectToTop( link );

      return link;
   }

   ////////////////////////////////////////////////////////////////////////
   // Set the object size and position.
   ////////////////////////////////////////////////////////////////////////
   void PlaceObject( GlgObject node, GlgPoint pos, int coord_type,
                    GlgPoint world_coord )
   {
      int type;

      // World coordinates of the node are returned to be stored in the node's
        // data structure.
      if( coord_type == GlgObject.SCREEN_COORD )
        MainArea.ScreenToWorld( true, pos, world_coord );
      else
        world_coord.CopyFrom( pos );

      type = node.GetDResource( "Type" ).intValue();
      if( type == GlgObject.REFERENCE )
      {
         // Reference: can use its point to position it.
         node.SetGResource( "Point", world_coord );

         if( IconScale != 1. ) // Change node size if required.
           // Scale object around the origin, which is now located at pos.
           node.ScaleObject( coord_type, pos, IconScale, IconScale, 1. );
      }
      else
      {
         // Arbitrary object: move its box's center to the cursor position.
         node.PositionObject( coord_type,
                             GlgObject.HCENTER | GlgObject.VCENTER,
                             pos.x, pos.y, pos.z );

         if( IconScale != 1. ) // Change node size if required.
           // Scale object around the center of it's bounding box.
           node.ScaleObject( coord_type, null, IconScale, IconScale, 1. );
      }
   }

   ////////////////////////////////////////////////////////////////////////
   // Get the link's control points container based on the link type.   
   ////////////////////////////////////////////////////////////////////////
   ObjectInfo GetCPContainer( GlgObject link )
   {
      ObjectInfo rval;
      int link_type;

      link_type = link.GetDResource( "Type" ).intValue();
      switch( link_type )
      {
       case GlgObject.POLYGON:
         rval = new ObjectInfo();
         rval.object = link;
         rval.type = 0;
         break;

       case GlgObject.GROUP: // Group containing a polygon with a label
         return GetCPContainer( link.GetResourceObject( "Link" ) );

       case GlgObject.CONNECTOR:
         rval = new ObjectInfo();
         rval.object = link;
         rval.type = link.GetDResource( "EdgeType" ).intValue();
         break;

       default: SetError( "Invalid link type." ); return null;
      }
      return rval;
   }

   ////////////////////////////////////////////////////////////////////////
   // Determines what node or link the object belongs to and returns it. 
   // Also returns type of the object: NODE or LINK.
   ////////////////////////////////////////////////////////////////////////
   ObjectInfo GetSelectedObject( GlgObject object )
   {
      while( object != null )
      {
         // Check if the object has IconType.
         if( object.HasResourceObject( "IconType" ) )
         {
            String type_string = object.GetSResource( "IconType" );
            if( type_string.equals( "Link" ) )
              return new ObjectInfo( object, LINK );
            else if( type_string.equals( "Node" ) )
              return new ObjectInfo( object, NODE );
         }

         object = object.GetParent();
      }

      // No node/link parent found - no selection.
      return new ObjectInfo( null, NO_OBJ );
   }

   ////////////////////////////////////////////////////////////////////////
   // Returns the first point at the cursor whose name starts with the 
   // name_prefix.
   ////////////////////////////////////////////////////////////////////////
   GlgObject GetSelectedPoint( GlgObject sel_object, GlgPoint cursor_pos,
                              String name_prefix )
   {
      int size;

      GlgObject pt_array = sel_object.CreatePointArray( 0 );
      if( pt_array == null || ( size = pt_array.GetSize() ) == 0 )
        return null;

      pt_array.SetStart();
      for( int i=0; i<size; ++i )
      {
         GlgObject point = (GlgObject) pt_array.Iterate();
         String name = point.GetSResource( "Name" );
         if( name == null || !name.startsWith( name_prefix ) )
           continue;

         // Get position in screen coords.
         GlgPoint screen_pos = point.GetGResource( "XfValue" );
         if( Math.abs( cursor_pos.x - screen_pos.x ) <
                                                 POINT_SELECTION_RESOLUTION &&
             Math.abs( cursor_pos.y - screen_pos.y ) <
                                                 POINT_SELECTION_RESOLUTION )
           return point;
      }
      return null;
   }

   ////////////////////////////////////////////////////////////////////////
   void SetDiagram( GlgDiagramData diagram )
   {
      int i;

      Vector node_list = diagram.getNodeList();
      Vector link_list = diagram.getLinkList();

      for( i=0; i<node_list.size(); ++i )
      {
         GlgNodeData node_data = (GlgNodeData) node_list.elementAt( i );
         AddNodeAt( 0, node_data, null, GlgObject.OBJECT_COORD );
      }

      for( i=0; i<link_list.size(); ++i )
      {
         GlgLinkData link_data = (GlgLinkData) link_list.elementAt( i );
         AddLink( 0, link_data );
      }

      CurrentDiagram = diagram;
      Update();
   }

   ////////////////////////////////////////////////////////////////////////
   void UnsetDiagram( GlgDiagramData diagram )
   {
      int i;

      SelectGlgObject( null, 0 );

      Vector node_list = diagram.getNodeList();
      Vector link_list = diagram.getLinkList();

      GlgObject group = MainArea.GetResourceObject( "ObjectGroup" );

      for( i=0; i<node_list.size(); ++i )
      {
         GlgNodeData node_data = (GlgNodeData) node_list.elementAt( i );
         if( node_data.graphics != null )
           group.DeleteObject( node_data.graphics );
      }

      for( i=0; i<link_list.size(); ++i )
      {
         GlgLinkData link_data = (GlgLinkData) link_list.elementAt( i );
         if( link_data.graphics != null )
            group.DeleteObject( link_data.graphics );
      }

      CurrentDiagram = new GlgDiagramData();
      Update();
   }

   //////////////////////////////////////////////////////////////////////////
   // Fills the object palette with buttons containing node and link icons
   // from the palette template. Palette template is a convenient place to 
   // edit all icons instead of placing them into the object palette buttons. 
   //
   // Icons named "Node0", "Node1", etc. were extracted into the NodeIconArray.
   // The LinkIconArray contains icons named "Link0", "Link1", etc.
   // Here, we place all node and link icons inside the object palette buttons 
   // named IconButton<N>, staring with the start_index to skip the first 
   // button which already contains the select button. 
   // The palette buttons are created by copying an empty template button.
   // Parameters:
   //  palette_name       Name of the object palette to add buttons to.
   //  button_name        Base name of the object palette buttons.
   //  start_index        Number of buttons to skip (the first button
   //                     with the select icon is already in the palette).
   //////////////////////////////////////////////////////////////////////////
   void FillObjectPalette( String palette_name, String button_name,
                          int start_index )
   {
      GlgObject palette = Viewport.GetResourceObject( "ObjectPalette" );

      // Find and store an empty palette button used as a template.
      // Search the button at the top viewport level, since palette's
        // HasResources=NO.
      ButtonTemplate = Viewport.GetResourceObject( button_name + start_index );

      if( ButtonTemplate == null )
      {
         SetError( "Can't find palette button to copy!" );
         return;
      }

      // Delete the template button from the palette but keep it around.
      palette.DeleteObject( ButtonTemplate );

      // Store NumRows and NumColumns info.
      NumRows = ButtonTemplate.GetDResource( "NumRows" ).intValue();
      NumColumns = ButtonTemplate.GetDResource( "NumColumns" ).intValue();

      // Add all icons from each array, increasing the start_index. */
      start_index =
        FillObjectPaletteFromArray( palette, button_name, start_index,
                                   LinkIconArray, LinkObjectArray, "Link" );
      start_index =
        FillObjectPaletteFromArray( palette, button_name, start_index,
                                   NodeIconArray, NodeObjectArray, "Node" );

      // Store the point marker template.
      SelectedMarker = PaletteTemplate.GetResourceObject( "PointMarker" );

      // Cleanup
      ButtonTemplate = null;
      PaletteTemplate = null;
      NodeIconArray = null;
      LinkIconArray = null;
   }

   //////////////////////////////////////////////////////////////////////////
   // Adds object palette buttons containing all icons from an array.
   // icon_array is an array of icon objects to use in the palette button.
   // object_array is an array of objects to use in the drawing.
   //////////////////////////////////////////////////////////////////////////
   int FillObjectPaletteFromArray( GlgObject palette, String button_name,
                                  int start_index,
                                  GlgObject icon_array, GlgObject object_array,
                                  String default_tooltip )
   {
      // Add all icons from the icon array to the palette using a copy of 
        // the template button.
      int size = icon_array.GetSize();
      int button_index = start_index;
      for( int i=0; i<size; ++i )
      {
         GlgObject icon = (GlgObject) icon_array.GetElement( i );
         GlgObject object = (GlgObject) object_array.GetElement( i );

         // Set uniform icon name to simplify selection.
         icon.SetSResource( "Name", "Icon" );

         // Set an empty initial label.
         int object_type = object.GetDResource( "Type" ).intValue();
         if( object_type == GlgObject.REFERENCE )
         {
            if( object.HasResourceObject( "Template/Label" ) )
              object.SetSResource( "Template/Label/String", "" );
         }
         else
           if( object.HasResourceObject( "Label" ) )
             object.SetSResource( "Label/String", "" );

         // Create a button to hold the icon.
         GlgObject button =
           ButtonTemplate.CloneObject( GlgObject.STRONG_CLONE );

         // Set button name by appending its index as a suffix (IconButtonN).
         button.SetSResource( "Name", button_name +button_index );

         // Set tooltip string.
         GlgObject tooltip = icon.GetResourceObject( "TooltipString" );
         if( tooltip != null )
           // Use a custom tooltip from the icon if defined.
           button.SetResourceFromObject( "TooltipString", tooltip );
         else // Use the supplied default tooltip.
           button.SetSResource( "TooltipString", "Node" );

         // Position the button by setting row and column indices.
         button.SetDResource( "RowIndex",
                             (double) ( button_index / (int) NumColumns ) );
         button.SetDResource( "ColumnIndex",
                             (double) ( button_index % (int) NumColumns ) );

         // Query icon scale factor, use default if not defined.
         double icon_scale;
         if( icon.HasResourceObject( "IconScale" ) )
           icon_scale = icon.GetDResource( "IconScale" ).doubleValue();
         else
           icon_scale = DEFAULT_ICON_SCALE;

         // Zoom palette icon button to scale icons displayed in it.
         button.SetDResource( "Zoom", icon_scale );

         button.AddObjectToBottom( icon );

         palette.AddObjectToBottom( button );
         ++button_index;
      }

      return button_index; /* Return the next start index. */
   }

   //////////////////////////////////////////////////////////////////////////
   // Positions node icons inside the palette buttons.
   // Invoked after the drawing has been setup, which is required by 
   // PositionObject().
   // Parameters:
   //  button_name        Base name of the palette buttons.
   //  start_index        Number of buttons to skip (the select and link
   //                     buttons are already in the palette).
   //////////////////////////////////////////////////////////////////////////
   void SetupObjectPalette( String button_name, int start_index )
   {
      // Find icons in the palette template and add them to the palette,
      // using a copy of the template button.
      for( int i = start_index; ; ++i )
      {
         GlgObject button = Viewport.GetResourceObject( button_name + i );

         if( button == null )
           return; // No more buttons

         GlgObject icon = button.GetResourceObject( "Icon" );
         int type = icon.GetDResource( "Type" ).intValue();

         if( type == GlgObject.REFERENCE )
           icon.SetGResource( "Point", 0., 0., 0. ); // Center position
         else
           icon.PositionObject( GlgObject.OBJECT_COORD,
                               GlgObject.HCENTER | GlgObject.VCENTER,
                               0., 0., 0. ); // Center position
      }
   }

   //////////////////////////////////////////////////////////////////////////
   // Queries items in the palette and fills array of node or link icons.
   // For each palette item, an icon is added to the icon_array, and the 
   // object to be used in the drawing is added to the object_array.
   // In case of connectors, the object uses only a part of the icon 
   // (the connector object) without the end markers.
   //////////////////////////////////////////////////////////////////////////
   void GetPaletteIcons( GlgObject palette, String icon_name,
                        GlgObject icon_array, GlgObject object_array )
   {
      for( int i=0; ; ++i )
      {
         // Get icon[i]
         GlgObject icon = palette.GetResourceObject( icon_name + i );
         if( icon == null )
           break;

         // Object to use in the drawing. In case of connectors, uses only a
         // part of the icon (the connector object) without the end markers.
           //
         GlgObject object = icon.GetResourceObject( "Object" );
         if( object == null )
           object = icon;

         if( !object.HasResourceObject( "IconType" ) )
         {
            SetError( "Can't find IconType resource." );
            continue;
         }

         String type_string = object.GetSResource( "IconType" );

         // Using icon base name as icon type since they are the same,
         // i.e. "Node" and "Node", or "Link" and "Link".
           //
         if( type_string.equals( icon_name ) )
         {
            // Found an icon of requested type, add it to the array.
            icon_array.AddObjectToBottom( icon );
            object_array.AddObjectToBottom( object );

            // Set index to match the index in the icon name, i.e. 0 for Icon0.
            object.SetDResource( "Index", (double) i );
         }
      }

      int size = icon_array.GetSize();
      if( size == 0 )
        SetError( "Can't find any icons of this type." );
      else
        System.out.println( "Scanned " + size + " " + icon_name + " icons" );
   }

   ////////////////////////////////////////////////////////////////////////
   // Adds custom data to the graphical object
   ////////////////////////////////////////////////////////////////////////
   void AddCustomData( GlgObject object, Object data )
   {
      // Add back-pointer from graphics to the link's data struct,
      // keeping the data already attached (if any).
        //
      GlgObject custom_data = object.GetResourceObject( "CustomData" );
      if( custom_data == null )
      {
         // No custom data attached: create an extra group and attach it 
           // to object as custom data.
         custom_data = new GlgDynArray( GlgObject.GLG_OBJECT, 0, 0 );
         object.SetResourceObject( "CustomData", custom_data );
      }

      // To allow using non-glg objects, use a group with element type
      // JAVA_OBJECT as a holder. The first element of the group will keep
        // the custom data pointer (pointer to the Link or Node structure).
      GlgObject holder_group = new GlgDynArray( GlgObject.JAVA_OBJECT, 0, 0 );
      holder_group.SetSResource( "Name", "PtrHolder" );

      holder_group.AddObjectToBottom( data );

      // Add it to custom data.
      custom_data.AddObjectToBottom( holder_group );
   }

   ////////////////////////////////////////////////////////////////////////
   // Get custom data attached to the graphical object
   ////////////////////////////////////////////////////////////////////////
   Object GetData( GlgObject object )
   {
      GlgObject holder_group = object.GetResourceObject( "PtrHolder" );
      return holder_group.GetElement( 0 );
   }

   ////////////////////////////////////////////////////////////////////////
   void SetRadioBox( String button_name )
   {
      // Always highlight the new button: the toggle would unhighlight if 
        // clicked on twice.
      GlgObject button = Viewport.GetResourceObject( button_name );
      if( button != null )
        button.SetDResource( "OnState", 1. );

      // Unhighlight the previous button.
      if( LastButton != null && !LastButton.equals( button_name ) )
      {
         button = Viewport.GetResourceObject( LastButton );
         if( button != null )
           button.SetDResource( "OnState", 0. );
      }

      LastButton = button_name; // Store the last button.
   }

   ////////////////////////////////////////////////////////////////////////
   void GetPosition( GlgObject object, GlgPoint coord )
   {
      int type = object.GetDResource( "Type" ).intValue();
      if( type == GlgObject.REFERENCE )
      {
         // Reference: can use its point to position it.
         coord.CopyFrom( object.GetGResource( "Point" ) );
      }
      else
      {
         // Arbitrary object: convert the box's center to the world coords.

         // Get object center in screen coords.
         GlgCube box = object.GetBoxPtr();

         GlgPoint center = new GlgPoint( ( box.p1.x + box.p2.x ) / 2.,
                                        ( box.p1.y + box.p2.y ) / 2.,
                                        ( box.p1.z + box.p2.z ) / 2. );

         MainArea.ScreenToWorld( true, center, coord );
      }
   }

   ////////////////////////////////////////////////////////////////////////
   // Fills Properties dialog with the selected object data 
   ////////////////////////////////////////////////////////////////////////   
   void FillData()
   {
      String
        label,
        object_data;

      switch( SelectedObjectType )
      {
       default:
         label = "NO_OBJECT";
         object_data = "";
         break;

       case NODE:
       case LINK:
         label = GetObjectLabel( SelectedObject );
         object_data = GetObjectData( SelectedObject );
         break;
      }

      Viewport.SetSResource( "Dialog/DialogName/TextString", label );
      Viewport.SetSResource( "Dialog/DialogData/TextString", object_data );
   }

   ////////////////////////////////////////////////////////////////////////
   boolean ApplyData()
   {
      String
        label,
        object_data;

      label = Viewport.GetSResource( "Dialog/DialogName/TextString" );
      object_data = Viewport.GetSResource( "Dialog/DialogData/TextString" );

      switch( SelectedObjectType )
      {
       case NODE:
       case LINK:
         break;
       default: return true;
      }

      // Store data
      SetObjectLabel( SelectedObject, label );
      SetObjectData( SelectedObject, object_data );

      Update();
      return true;
   }

   ////////////////////////////////////////////////////////////////////////
   String GetObjectLabel( GlgObject object )
   {
      Object data = GetData( object );
      if( data instanceof GlgNodeData )
        return ((GlgNodeData)data).object_label;
      else
        return ((GlgLinkData)data).object_label;
   }

   ////////////////////////////////////////////////////////////////////////
   void SetObjectLabel( GlgObject object, String label )
   {
      Object data = GetData( object );
      if( data instanceof GlgNodeData )
      {
         // Display the label in the object
         if( object.HasResourceObject( "Template/Label" ) )
           // Reference object: use template
           object.SetSResource( "Template/Label/String", label );
         else if( object.HasResourceObject( "Label" ) )
           object.SetSResource( "Label/String", label );

         ((GlgNodeData)data).object_label = label;
      }
      else if( data instanceof GlgLinkData )
      {
         // Display the label if it's a link with a label.
         if( object.HasResourceObject( "Label" ) )
           object.SetSResource( "Label/String", label );

         ((GlgLinkData)data).object_label = label;
      }
   }

   ////////////////////////////////////////////////////////////////////////
   String GetObjectData( GlgObject object )
   {
      Object data = GetData( object );
      if( data instanceof GlgNodeData )
        return ((GlgNodeData)data).object_data;
      else
        return ((GlgLinkData)data).object_data;
   }

   ////////////////////////////////////////////////////////////////////////
   void SetObjectData( GlgObject object, String object_data )
   {
      Object data = GetData( object );
      if( data instanceof GlgNodeData )
        ((GlgNodeData)data).object_data = object_data;
      else
        ((GlgLinkData)data).object_data = object_data;
   }

   ////////////////////////////////////////////////////////////////////////
   boolean NodeConnected( GlgObject node )
   {
      for( int i=0; i< CurrentDiagram.getLinkList().size(); ++ i )
      {
         GlgLinkData link_data =
           (GlgLinkData) CurrentDiagram.getLinkList().elementAt( i );

         GlgNodeData start_node = link_data.getStartNode();
         GlgNodeData end_node = link_data.getEndNode();
        if( start_node != null && start_node.graphics == node ||
           end_node != null && end_node.graphics == node )
          return true;
      }
      return false;
   }

   ////////////////////////////////////////////////////////////////////////
   int GetButton( AWTEvent event )
   {
      if( ! ( event instanceof InputEvent ) )
        return 0;

      InputEvent input_event = (InputEvent) event;
      int modifiers = input_event.getModifiers();

      if( ( modifiers & InputEvent.BUTTON3_MASK ) != 0 )
        return 3;
      else if( ( modifiers & InputEvent.BUTTON2_MASK ) != 0 )
        return 2;
      else
        return 1;
   }
}

class GlgNodeData
{
   int node_type;
   GlgDiagramPoint position;
   String object_label;
   String object_data;
   transient GlgObject graphics;

   GlgNodeData()
   {
      object_label = "";
      object_data = "";
      position = new GlgDiagramPoint();
   }
}

class GlgLinkData
{
   int link_type;
   int link_direction;
   GlgDiagramPoint link_color;
   transient GlgObject graphics;
   GlgNodeData start_node;
   GlgNodeData end_node;
   String start_point_name;
   String end_point_name;
   String object_label;
   String object_data;
   Vector point_array;
   boolean first_move;

   GlgLinkData()
   {
      object_label = "A1";
      object_data = "";
      point_array = new Vector();
   }

   GlgNodeData getStartNode()
   {
      return start_node;
   }

   GlgNodeData getEndNode()
   {
      return end_node;
   }

   void setStartNode( GlgNodeData node )
   {
      start_node = node;
   }

   void setEndNode( GlgNodeData node )
   {
      end_node = node;
   }
}

class GlgDiagramData
{
   Vector node_list;
   Vector link_list;

   GlgDiagramData()
   {
      node_list = new Vector();
      link_list = new Vector();
   }

   Vector getNodeList()
   {
      return node_list;
   }

   Vector getLinkList()
   {
      return link_list;
   }
}
class GlgDiagramPoint extends GlgPoint
{
   // Allowes for custom serialization extensions for saving and loading

   GlgDiagramPoint()
   {
   }

   GlgDiagramPoint( GlgPoint point )
   {
      if( point != null )
      {
         x = point.x;
         y = point.y;
         z = point.z;
      }
   }
}

// Custom handler, place application-specific code into these callbacks.
class CustomHandler
{
   static void AddObjectCB( GlgDiagram diagram, GlgObject icon, Object data,
                           boolean is_node )
   {
   }

   static void SelectObjectCB( GlgDiagram diagram, GlgObject icon, Object data,
                              boolean is_node )
   {
   }

   static void CutObjectCB( GlgDiagram diagram, GlgObject icon, Object data,
                           boolean is_node )
   {
   }

   static void PasteObjectCB( GlgDiagram diagram, GlgObject icon, Object data,
                             boolean is_node )
   {
   }
}