boolean needRepaint = false;
    protected boolean handleGesture(int descriptor, MouseEvent e) {        Debug.message("link", "LinkLayer: handleGesture:");        // Set if we need to repaint        boolean needRepaint = false;        try {            LinkOMGraphicList graphics = getGraphicList(); // Get old            // list            if (graphics == null) {                // Nothing to search on - this condition occurs when                // the layer is already busy getting new graphics as a                // result of a changed projection.                Debug.message("link", "LinkLayer: null graphics list.");                return false;            }            if (e == null) {                graphics.deselectAll();                return false;            }            // Find out if a graphic is closeby...            int gesGraphicIndex = graphics.findIndexOfClosest(e.getX(),                    e.getY(),                    distanceLimit);            // We need to do this to deselect everything else too.            OMGraphic gesGraphic = graphics.selectClosest(e.getX(),                    e.getY(),                    distanceLimit);            String id = null;            // If there was a graphic, set the mask to indicate that,            // and keep track of the graphic and the list index of the            // graphic for the response. If a graphic modify command            // comes back without an ID, then we'll assume the server            // was refering to this graphic.            if (gesGraphic != null) {                boolean tellServer = graphicGestureReaction(gesGraphic,                        descriptor,                        e);                if (!tellServer) {                    repaint();                    return true;                }                //              needRepaint = true; // Why? At this point, we                // should wait to see what the server wants us to do,                // we should only repaint if a graphic update comes                // back.                descriptor = LinkUtil.setMask(descriptor, GRAPHIC_ID_MASK);                id = ((LinkProperties) gesGraphic.getAppObject()).getProperty(LPC_GRAPHICID);            } else {                // clear out info line                fireRequestInfoLine("");            }            // server inform            if (!LinkUtil.isMask(getGestureDescriptor(),                    SERVER_NOTIFICATION_MASK)) {                return false;            }            // Get the lat/lon point of the event            LatLonPoint llpoint = getProjection().inverse(e.getX(), e.getY());            // Don't need these anymore, look below for explaination            // for asynchronous operation.            //      LinkActionList lal;            //      LinkActionRequest lar;            ClientLink l = linkManager.getLink(false);            // We'll check this here because we don't want to wait if            // it is not available - it could be used for another            // graphics or gui fetch.            if (l == null) {                Debug.message("link",                        "LinkLayer: unable to get link in handleGesture().");                return false;            }            // Using the link - carefully prevent others from using it            // too!            synchronized (l) {                if (id != null) {                    args.setProperty(LPC_GRAPHICID, id);                }                // Send the query                LinkActionRequest.write(descriptor,                        e,                        llpoint.getLatitude(),                        llpoint.getLongitude(),                        args,                        l);                /////////////////////////////////////////////////////                // With asynchronous behavior, we don't listen to the                // reply                // now. The LinkListener will handle it.                //              // Read the response                //              l.readAndParse(getProjection(), currentGenerator,                // this);                //              lal = l.getActionList();                //              lar = l.getActionRequest();                //              if (id != null) {                //                  args.remove(LPC_GRAPHICID);                //              }                /////////////////////////////////////////////////////            }            linkManager.finLink();            /////////////////////////////////////////////////////            // With asynchronous behavior, we don't listen to the            // reply            // now. The LinkListener will handle it.            //      handleLinkActionRequest(lar);            //      // If nothing else was returned concerning the gesture            // query            //      if (lal == null) {            //          return false;            //      }            //      handleLinkActionList(lal);            //      return lal.consumedGesture();            /////////////////////////////////////////////////////            // I don't know what to answer here, we really don't know            // at this point. There may be something we can do to set            // up some lag circle to start returning true if we need            // to, but if we're not listening in this thread, we just            // don't know if the gesture is consumed here and we can't            // hold up the event thread to find out.            return false;        } catch (IOException ioe) {            System.err.println("LinkLayer: IOException contacting server during gesture handling!");            System.err.println(ioe);            linkManager.resetLink();            return false;        }    }