Exemplo n.º 1
0
/* ARGSUSED */
static void _pgmvcp_elDropEh ( Widget w, XtPointer clnt, XEvent *event,
							Boolean *ctdr )
/************************************************************************
 * _pgmvcp_elDropEh                                                     *
 *                                                                      *
 * This function is the callback for a drop on a selected element.      *
 *                                                                      *
 * static void _pgmvcp_elDropEh (w, clnt, event, ctdr)			*
 *                                                                      *
 * Input parameters:                                                    *
 *      w               Widget          Parent widget                   *
 *      clnt		XtPointer       State information record        *
 *      *event          XEvent          Button press event record       *
 *                                                                      *
 **                                                                     *
 * Log:                                                                 *
 * E. Safford/GSC       06/97   Modified to handle Special Text         *
 * E. Wehner/EAi        07/97   Remove offsets when replacing text.     *
 * E. Safford/GSC       07/97   Fixed drag with special text problem    *
 * E. Wehner/EAi        08/97   Remove watch box slide                  *
 * C. Lin/EAI            8/97   Add offsets for 'S' coord(roam)         *
 * D.W.Plummer/NCEP      9/97   Combine into NxmDraw for new vgstruct.h *
 * E. Wehner/EAi         9/97   Remove graphics info record             *
 * C. Lin/EAi           10/97   rename from NxmDrSlDropCb, cleanup      *
 * C. Lin/EAi           10/97   add WBOX_ELEM related functions         *
 * C. Lin/EAi           11/97   further cleanup                         *
 * E. Safford/GSC       02/98   add _storedEl for undo function         *
 * S. Law/GSC           04/98   added copy function                     *
 * E. Safford/GSC       04/98   added FUNC_SELECT to FUNC_MOVE ops      *
 * S. Law/GSC           05/98   cleaned up drag, added group box        *
 * E. Safford/GSC       05/98   mod for new undo routines               *
 * E. Safford/GSC       05/98   move to nmap_pgmvcp.c                   *
 * E. Safford/GSC       06/98   split from mvcpDrop.c                   *
 * G. Krueger/EAI       06/98   Uniform status hints                    *
 * E. Safford/GSC       07/98   reset _dcN for closed figures           *
 * C. Lin/EAI       	08/98   fix ghosting problem & reset _dragCount *
 * G. Krueger/EAI	09/98	Added ghost veiling			*
 * G. Krueger/EAI	10/98	Using table for hints			*
 * E. Safford/GSC	12/98	modify refresh to limit area affected	*
 * D.W.Plummer/NCEP	 4/99	remove call to pgwlst_update		*
 * E. Safford/GSC	11/00	wipe the county list for watches     	*
 * H. Zeng/EAI          11/00   changed for the new undo design         *
 * H. Zeng/EAI          11/00   changed cvg_rdrec() parameters          *
 * A. Hardy/GSC         11/00   renamed coordinate system declaration   *
 * H. Zeng/EAI          12/00   modified for multiple undo steps        *
 * J. Wu/SAIC		12/01	add layer in crg_set() call		*
 * J. Wu/SAIC		01/02	add layer in crg_get() call		*
 * T. Lee/SAIC          11/03   added user directory to work_file       *
 * T. Lee/SAIC		11/03	used cvg_getworkfile			*
 * J. Wu/SAIC		11/03	adjust jet barb/hash position		*
 * J. Wu/SAIC		02/04	adjust gfa attribute box position	*
 * J. Wu/SAIC		07/04	add filter param. to crg_get()		*
 * J. Wu/SAIC		07/04	free GFA block memory			*
 * B. Yin/SAIC		02/05	add a call to snap for GFA		*
 * E. Safford/SAIC	06/05	allow smear to get smaller on edit	*
 * S. Danz/AWC		07/06	Added new cvg_delet placement argument	*
 * S. Danz/AWC          08/06   New flag to pgvgf_saveNewElm to place el*
 * S. Danz/AWC          08/06   Updated to use cvg_checkplace to find   *
 * 				area impacted and call crg_rebuild()    *
 * S. Danz/AWC          02/07   Add logic to update GFA centroid 	*
 * L. Hinson/AWC        07/09   Add code to update CCF centroid         *
 ***********************************************************************/
{
int         location, ier, currfunc, new_location, num, layer, el_layer;
int         found, update_crg, one = 1;
float       llx, lly, urx, ury; 
float       x_cntr, y_cntr, c_lat, c_lon, area;
float       o_llx, o_lly, o_urx, o_ury, inf_bbox[4];
char	    value[32];
VG_DBStruct el, del_el;
filter_t    filter;
/*---------------------------------------------------------------------*/

    _dragCount = 0;
    mcanvw_disarmDrag();
    mcanvw_disarmDrop();

    if ( _wboxElm )  {
	pgwpts_setSnap (TRUE);
	_pgmvcp_wboxCalc ( );
    }

    pggst_clearGhost(TRUE);
    if (!_midDrag)
	return;

    _midDrag = FALSE;

    update_crg = 0;

    currfunc = pgpalw_getCurOperId();

    pgundo_newStep();
    location = pgactv_getElmLoc();
    cvg_rdrec(cvg_getworkfile(), location, &el, &ier);

    crg_getinx (location, &num, &ier);
    crg_get (num, &el_layer, filter, &o_llx, &o_lly, &o_urx, &o_ury, &ier);
    
    pghdlb_deselectEl (location, FALSE); 

    if ((currfunc == FUNC_MOVE) || (currfunc == FUNC_SELECT)) {

/*
 * Mark elements in placement that are effected by
 * the delete, and get the area of influence back
 */
        cvg_rdrec(cvg_getworkfile(), location, &del_el, &ier);
        cvg_checkplace(&del_el, 1, location, &found, inf_bbox, &ier);
        if (found > 0) {

/*
 * Update the refresh extent if the area impacted by
 * placement was bigger than the area passed in
 */
            o_llx = G_MIN(o_llx, inf_bbox[0]);
            o_lly = G_MIN(o_lly, inf_bbox[2]);
            o_urx = G_MAX(o_urx, inf_bbox[1]);
            o_ury = G_MAX(o_ury, inf_bbox[3]);
            update_crg = 1;
        }

/*
 * Free TCA/GFA memory
 */
        if ( del_el.hdr.vg_type == TCA_ELM ) {
            cvg_freeBkpts ( &del_el );
        }
        else if ( del_el.hdr.vg_type == GFA_ELM ) {
            cvg_freeElPtr ( &del_el );
        }

/* 
 *  delete old element
 */  
	cvg_delet (cvg_getworkfile(), location, TRUE, &ier);
	crg_clear (num, &ier);
        pgundo_storeThisLoc(location, UNDO_DEL, &ier);
    }

    if ( el.hdr.vg_type == WBOX_ELM )  {

        pgwbxw_getAnchor ( 0, el.elem.wbx.info.w_a0id,
                        &el.elem.wbx.info.w_a0lt, &el.elem.wbx.info.w_a0ln,
                        &el.elem.wbx.info.w_a0dis, el.elem.wbx.info.w_a0dir,
                        &ier );

        pgwbxw_getAnchor ( 1, el.elem.wbx.info.w_a1id,
                        &el.elem.wbx.info.w_a1lt, &el.elem.wbx.info.w_a1ln,
                        &el.elem.wbx.info.w_a1dis, el.elem.wbx.info.w_a1dir,
                        &ier );

/*
 *  Wipe the county list
 */
 	el.elem.wbx.info.numcnty = 0;
    }

/*
 *  adjust jet barb/hash position accordingly
 */ 
    if ( el.hdr.vg_type == JET_ELM )  {
        _pgmvcp_jetCalc ( &el, 0, 0, False );
    }
     
    if ( el.hdr.vg_type == SIGCCF_ELM ) {
      _pgmvcp_ccfCalc ( &el, 0, 0, False );
      gtrans ( sys_D, sys_M, &_dcN, _dcX, _dcY, 
		 &(el.elem.ccf.latlon[0]), &(el.elem.ccf.latlon[_dcN]), &ier,
		 strlen(sys_D), strlen(sys_M) );
      _dcN = el.elem.ccf.info.npts;
      cvg_todev ( &el, &_dcN, _dcX, _dcY, &ier );
      
      if ( el.hdr.closed ) {
        cgr_centroid ( _dcX, _dcY, &_dcN, &x_cntr, &y_cntr, &area, &ier );
      } else {
        x_cntr = _dcX[0] ;
        y_cntr = _dcY[0] ;
      }
      gtrans( sys_D, sys_M, &one, &x_cntr, &y_cntr, &c_lat, &c_lon, &ier, 
	    strlen(sys_D), strlen(sys_M) 
	    );
      el.elem.ccf.info.arrowlat = c_lat;
      el.elem.ccf.info.arrowlon = c_lon;
    }
/*
 *  adjust GFA attribute box position accordingly
 */ 
    if ( el.hdr.vg_type == GFA_ELM ) {

        _pgmvcp_gfaCalc ( &el, 0, 0, False );

	gtrans ( sys_D, sys_M, &_dcN, _dcX, _dcY, 
		 &(el.elem.gfa.latlon[0]), &(el.elem.gfa.latlon[_dcN]), &ier,
		 strlen(sys_D), strlen(sys_M) );

	pgsmear_snapEl ( FALSE, &el, &ier );

	_dcN = el.elem.gfa.info.npts;

	cvg_todev( &el, &_dcN, _dcX, _dcY, &ier );

	if ( pggfaw_isClosed() ) {
	    cgr_centroid( _dcX, _dcY, &_dcN, &x_cntr, &y_cntr, &area, &ier );
	} else {
	    x_cntr = _dcX[ 0 ];
	    y_cntr = _dcY[ 0 ];
	}
	gtrans( sys_D, sys_M, &one, &x_cntr, &y_cntr, &c_lat, &c_lon, &ier, 
	    strlen(sys_D), strlen(sys_M) 
	    );

	sprintf ( value, "%7.2f", c_lat );
	cvg_setFld ( &el, TAG_GFA_ARROW_LAT, value, &ier );
	sprintf ( value, "%7.2f", c_lon );
	cvg_setFld ( &el, TAG_GFA_ARROW_LON, value, &ier );
    }
    
/*
 *  save new element
 */
    pgvgf_saveNewElm(NULL, sys_D, &el, _dcN, _dcX, _dcY, FALSE, 
    		&new_location, &ier);
    pgundo_storeThisLoc (new_location, UNDO_ADD, &ier);
    pgundo_endStep();
    
/*
 * Free TCA/GFA memory
 */
    if ( el.hdr.vg_type == TCA_ELM ) {
            cvg_freeBkpts ( &el );
    }
    else if ( el.hdr.vg_type == GFA_ELM ) {
        cvg_freeElPtr ( &el );
    }

    cvg_rdrec(cvg_getworkfile(), new_location, &el, &ier);
    layer = pglayer_getCurLayer( );
    crg_set (&el, new_location, layer, &ier);
    pgactv_setActvElm (&el, new_location);

    crg_getinx (new_location, &num, &ier);
    crg_get(num, &el_layer, filter, &llx, &lly, &urx, &ury, &ier);

    if (o_llx < llx)
        llx = o_llx;
    if (o_lly < lly)
        lly = o_lly;
    if (o_urx > urx)
        urx = o_urx;
    if (o_ury > ury)
        ury = o_ury;

/*
 * Mark elements in placement that are effected by
 * the new element, and get the area of influence back
 */
    cvg_checkplace(&el, 0, new_location, &found, inf_bbox, &ier);
    if (found > 0) {

/*
 * Update the refresh extent if the area impacted by
 * placement was bigger than the area passed in
 */
        llx = G_MIN(llx, inf_bbox[0]);
        lly = G_MIN(lly, inf_bbox[2]);
        urx = G_MAX(urx, inf_bbox[1]);
        ury = G_MAX(ury, inf_bbox[3]);
        update_crg = 1;
    }

    xpgpaste (llx, lly, urx, ury, &ier);
    cvg_rfrsh (NULL, llx, lly, urx, ury, &ier);

/*
 * If we may have impacted other elements with placement
 * we will need to rebuild the range records
 */
    if (update_crg) {
        crg_rebuild();
    }

    pghdlb_select (&el, new_location);

/*
 * Free TCA/GFA memory
 */
    if ( el.hdr.vg_type == TCA_ELM ) {
            cvg_freeBkpts ( &el );
    }
    else if ( el.hdr.vg_type == GFA_ELM ) {
        cvg_freeElPtr ( &el );
    }

    mbotw_mouseSet(LMHINT_DRAG, MMHINT_DONE);
}
Exemplo n.º 2
0
static void pgfilterw_updateFilter ( void )
/************************************************************************
 * pgfilterw_updateFilter						*
 *									*
 * Updates the current filter string and then refreshes the display. 	*
 *									*
 * static void pgfilterw_updateFilter ( void )				*
 *									*
 * Input parameters:							*
 * Output parameters:							*
 *	none								*
 *									*
 **									*
 * Log:									*
 * J. Wu/SAIC		07/04	initial coding				*
 * J. Wu/SAIC		08/04	link filter change with GFA window	*
 * J. Wu/SAIC		09/04	Restart GFA for any filter changes	*
 * J. Wu/SAIC		10/04	Access GFA attr with cvg_getFld()	*
 * E. Safford/SAIC	07/05	rm sequence # from cvg_scangfa() call	*
 * M. Li/SAIC		03/07	Not reset fcst hour if change from GFA	*
 * E. Safford/SAIC	05/07	fix gfa' connection			*
 * E. Safford/SAIC	06/07	fix bug in preFilterOn determination	*
 * B. Yin/SAIC		12/07	set GFA hr to last selected filter time	*
 ***********************************************************************/
{
    int 	ii, filternum, ier, cur_obj, cur_loc, newel_loc, num;
    int 	subtyp, areatyp, len;
    char	lastTime[8], value[32], tag[32], timeCmp[10];
    Boolean	gfaIsUp = False, gfaInAdd = False, preFilterOn = False;
    Boolean	gfaPrimeIsUp = False;
    VG_DBStruct	cur_el, newel;
    /*---------------------------------------------------------------------*/

    cur_el.elem.gfa.info.nblocks = 0;

    _curFilter[0] = '\0';
    filternum = 0;
    for ( ii = 0; ii < _nFilTime[TIME_FILTER]; ii++ ) {
        if ( _filterStatus[ii] ) {
            filternum++;
            strcat ( _curFilter, _filTime[TIME_FILTER][ii] );
            if ( ii < (_nFilTime[TIME_FILTER] - 1) ) {
                strcat ( _curFilter, ";" );
            }
        }
    }

    /*
     *  If no filter is provided but the filter window is up - none
     *  of the elements with time stamp will be displayed. If the
     *  filter window is down, all elements should be displayed.
     */
    if ( filternum == 0 ) {
        if ( pgfilterw_isUp() ) {
            strcpy ( _curFilter, ACTV_FILTER );
        }
        else {
            strcpy ( _curFilter, CANCEL_FILTER );
        }
    }

    /*
     *   Check if gfaw is up and its mode.
     */
    gfaIsUp = pggfaw_isUp();
    gfaPrimeIsUp = pggfawp_isUp();

    if( gfaIsUp ) {
        gfaInAdd =  pggfaw_isAddMode();
    }
    else if( gfaPrimeIsUp ) {
        gfaInAdd =  pggfawp_isAddMode();
    }
    cur_obj = pgpalw_getCurObjId ();

    /*
     *  If gfaw is up, retrieve the current GFA attributes and check
     *  if the previous forecast hour is still "ON" in filter window.
     *
     *  If it is still on, then take no action.  If it is not, and there
     *  is another time selected, set the GFA/GFA' window forecast hour to
     *  the first selected time.
     *
     *  Note that the GFA/GFA' will ignore the Airmet and Outlook filter
     *  settings.
     */
    cur_loc = -1;
    preFilterOn = False;

    if ( gfaIsUp || gfaPrimeIsUp ) {

        if ( gfaInAdd ) {
            if( gfaIsUp ) {
                pggfaw_getAttr ( &cur_el );
                ier = 0;
            }
            else {
                pggfawp_getAttr ( &cur_el );
                ier = 0;
            }
        }
        else {
            cur_loc = pgactv_getElmLoc ();
            cvg_rdrec ( cvg_getworkfile(), cur_loc, &cur_el, &ier );
        }

        cvg_getFld ( &cur_el, TAG_GFA_FCSTHR, value, &ier );

        if ( filternum > 0 && ier == 0 ) {

            for ( ii = 0; ii < _nFilTime[TIME_FILTER]; ii++ ) {

                if (  _filterStatus[ii] ) {

                    strcpy( timeCmp, _filTime[TIME_FILTER][ii] );
                    len = strlen( timeCmp );

                    if( timeCmp[ len-1 ] == '+' ) {
                        timeCmp[ len-1 ] = '\0';
                    }

                    if ( strcmp ( value, timeCmp ) == 0 )  {
                        preFilterOn = True;
                        break;
                    }
                }
            }
        }
    }

    /*
     *  Update filter setting in CVG library.
     */
    cvg_setfilter ( _curFilter, &ier );

    /*
     *  Refresh the display.
     */
    pgfilterw_refresh ();


    /*
     *  Adjust GFA window, if necessary.
     */
    if ( gfaIsUp || gfaPrimeIsUp ) {

        /*
         * If previously in "Add" mode, keep drawing.
         */
        if ( gfaInAdd ) {

            /*
             *  Set the GFA hour to the last selected filter time.
             *
             */
            pgfilterw_getLastTime ( lastTime );
            if ( strlen ( lastTime ) > (size_t)0 ) {
                if (!_fromGfa) {
                    if( gfaIsUp ) {
                        pggfaw_setHour ( lastTime );
                    }
                    else {
                        pggfawp_setHour ( lastTime );
                    }
                }
            }
        }
        else {	   /* Previously in "Edit" mode */

            /*
             *  The filter matching the active element's forecast hour
             *  is still ON, keep editing it.
             */
            if ( preFilterOn ) {
                cvg_freeElPtr( &cur_el );
                pghdlb_select ( &cur_el, cur_loc );
            }
            else {

                /*
                 *  The filter matching the active element's forecast
                 *  hour is OFF, terminate all pending actions.
                 *  However, if it is turned off by pressing hotkeys,
                 *  and a GFA element matching the same subtype,
                 *  and area type number could be found,
                 *  set to edit that element.
                 */
                if ( _offByHotkey  ) {
                    cvg_getFld ( &cur_el, TAG_GFA_SUBTYPE, value, &ier );
                    subtyp = atoi ( value );
                    cvg_getFld ( &cur_el, TAG_GFA_AREATYPE, value, &ier );
                    areatyp = atoi ( value );
                    cvg_getFld ( &cur_el, TAG_GFA_TAG, tag, &ier );

                    cvg_scangfa ( NULL, pglayer_getCurLayer(),
                                  subtyp, areatyp, tag, &newel, &newel_loc, &ier );

                    if ( ier == 0 ) {
                        crg_getinx ( cur_loc, &num, &ier);
                        pghdlb_deselectEl ( num, TRUE );

                        pgactv_setActvElm ( &newel, newel_loc );
                        pghdlb_select ( &newel, newel_loc );

                        if( gfaIsUp ) {
                            pggfaw_setAttr ( &newel );
                        }
                        else {
                            pggfawp_setAttr ( &newel );
                        }

                    }
                    else {
                        pgevt_unsetOper ( TRUE );
                    }
                }
                else {
                    pgevt_unsetOper ( TRUE );
                }

                _offByHotkey = False;
            }
        } /* End "if" in edit mode */
    }
    cvg_freeElPtr( &cur_el );
    _fromGfa = False;
}
Exemplo n.º 3
0
void crg_set ( VG_DBStruct *el, int joffset, int layer, int *iret )
/************************************************************************
 * crg_set	 							*
 *									*
 * This function sets the range record for an element.			*
 *									*
 * void crg_set ( el, joffset, layer, iret )				*
 *									*
 * Input parameters:							*
 *	*el		VG_DBStruct	Pointer to VG record structure	*
 *	joffset		int		Offset to element in file	*
 *	layer		int		Element's layer value		*
 *									*
 * Output parameters:							*
 *	*iret		int		Return code			*
 *					 -3 = Range array is full	*
 *									*
 **									*
 * Log:									*
 * E. Wehner/EAi	10/96	Created					*
 * D. Keiser/GSC	 1/97	Clean up				*
 * E. Wehner/EAi	 4/97	Added contour				*
 * D. Keiser/GSC	 4/97	Added special line			*
 * E. Safford/GSC	 4/97	Added text   				*
 * D. Keiser/GSC	 5/97	Added lines				*
 * E. Wehner/EAi	 5/97	Fixed contour, fixed lines		*
 * E. Safford/GSC        6/97	Added special text			*
 * E. Wehner/EAi	 8/97	Convert to crg_elrng and crg lib	*
 * D.W.Plummer/NCEP	 9/97	Changes for new vgstruct header file	*
 * C.Lin/EAI	 	10/97	Add WBOX_ELM				*
 * F.J.Yen/NCEP		 1/98	Renamed from crg_elrng.  Cleaned up.	*
 * C.Lin/EAI	 	04/98	Set group info				*
 * D.W.Plummer/NCEP	 4/98	Set vg_type				*
 * F.J.Yen/NCEP		 4/98	Added DARR_ELM and HASH_ELM		*
 * S. Law/GSC		05/98	Updated crg_styp call			*
 * A. Hardy/GSC         10/98   Added CMBSY_ELM                         *
 * A. Hardy/GSC         12/98   Added CIRCLE_ELM                        *
 * S. Law/GSC		05/99	Added TRKSTORM_ELM			*
 * G. Krueger/EAI	05/99	Corrected call to CRG_SETCIR		*
 * S. Law/GSC		08/99	Added SIGINTL_ELM			*
 * S. Law/GSC		08/99	Added remaining SIGMETs			*
 * D.W.Plummer/NCEP	 2/00	Added call to crg_setwbx for WBOX elem	*
 * S. Law/GSC		02/00	Added CCF				*
 * J. Wu/SAIC		12/01	set layer & call crg_mkRange		*
 * J. Wu/SAIC		07/04	set display filter			*
 * J. Wu/SAIC		07/07	set second range record			*
 ***********************************************************************/
{
    int		ier, elnum;
/*---------------------------------------------------------------------*/

    *iret = 0;

    /* 
     * Determine if element already ranged. If so, reuse the slot. 
     */

    crg_getinx(joffset, &elnum, &ier);
    if (ier < 0)
    {
	/*
	 * Get location for the element in the range array
	 */

	crg_newinx( &elnum, &ier);
	if (ier < 0)
	{
	    *iret = -3;
	    return;
	}
    }
    
    crg_mkRange( el, joffset, elnum, &ier );
   
    crg_styp(elnum, el->hdr.vg_class, el->hdr.vg_type, &ier);

    crg_setLayer( elnum, layer, &ier );

    crg_sgrp(elnum, el->hdr.grptyp, el->hdr.grpnum, &ier);

    crg_setfilter ( elnum, el, &ier );
    
    
    /* 
     * If the second range record exists, make sure it has the same
     * class/type//layer/grptyp/grpnum/filter as the primary record's. 
     */
    if ( range[ elnum ].assocRec != NO_ASSOC_REC ) {
        crg_lkattr ( elnum, &ier );  
    }
    
}
Exemplo n.º 4
0
static int pgdel_deleteElms ( void )
/************************************************************************
 * pgdel_deleteElms                                                     *
 *                                                                      *
 * This function deletes all the currently selected elements.           *
 *                                                                      *
 * static void pgdel_deleteElms ( )   	                                *
 *                                                                      *
 * Input parameters:                                                    *
 * Output parameters:                                                   *
 *      none                                                            *
 *                                                                      *
 * Return:                                                              *
 *      		int	number of deleted elements		*
 **                                                                     *
 * Log:                                                                 *
 * E. Safford/GSC	04/04	initial coding				*
 * B. Yin/SAIC          08/04   Added code to free TCA memory           *
 * B. Yin/SAIC          08/04   Changed pgtca_freeBkpts to cvg_freeBkpts*
 * J. Wu/SAIC           10/04   free GFA block pointers			*
 * S. Danz/AWC		07/06	Added new cvg_delet placement argument	*
 ***********************************************************************/
{
    int         num      = 0,  ier      = 0, found, update_crg; 
    int		grpnum   = 0,  ii       = 0, 	nelm   = 0;
    int		curIndex = -1, selIndex = 0, 	selLoc = 0;
    int		iret     = 0,  *inxarry = NULL, count  = 0;
    char        grptyp   = '0';
    float       llx = 0, lly = 0, urx = 0, ury = 0, inf_bbox[4];
    VG_DBStruct el;
/*---------------------------------------------------------------------*/

    pghdlb_getNextIndex( curIndex, &selIndex, &selLoc, &iret );

    update_crg = 0;
    while ( iret >= 0 ) {

/*
 *  If this is the first deletion, start the undo step
 */
	if( count == 0 ) {
            pgundo_newStep();	    
        }

        crg_getinx(selLoc, &num, &ier); 
        crg_ggrp (num, &grptyp, &grpnum, &ier);

/*
 *  If deleting _by_ group, process the whole group 
 */
        if (grptyp && grpnum && (grptyp == GRPTYP_COMSYM || 
	    grptyp == GRPTYP_CCF || pgpalw_getMode() == TYPE_GRP)) {

            crg_ggbnd (grptyp, grpnum, &llx, &urx, &ury, &lly, &ier);
	    llx -= EXTRA;
	    lly -= EXTRA;
	    urx += EXTRA;
	    ury += EXTRA;

            crg_ggnel(grptyp, grpnum, &nelm, &ier);

            inxarry = (int *)malloc(nelm*sizeof(int));
            crg_gginx(grptyp, grpnum, nelm, inxarry, &nelm, &ier);

            for ( ii = 0; ii < nelm; ii++ ) {

/*
 * Mark elements in placement that are effected by
 * the delete, and get the area of influence back
 */
                cvg_rdrec ( cvg_getworkfile(), selLoc, &el, &ier );
                cvg_checkplace(&el, 1, selLoc, &found, inf_bbox, &ier);
                if (found > 0) {

/*
 * Update the refresh extent if the area impacted by placement is bigger
 */
                    llx = G_MIN(llx, inf_bbox[0]);
                    lly = G_MIN(lly, inf_bbox[2]);
                    urx = G_MAX(urx, inf_bbox[1]);
                    ury = G_MAX(ury, inf_bbox[3]);

                    update_crg = 1;
                }

/*
 * Free TCA break point/GFA block memory
 */
                if ( el.hdr.vg_type == TCA_ELM ) {
                    cvg_freeBkpts ( &el );
                }
	        else if ( el.hdr.vg_type == GFA_ELM ) {
                    cvg_freeElPtr ( &el );
                }

                crg_goffset(inxarry[ii], &selLoc, &ier);
	        pgundo_storeThisLoc(selLoc, UNDO_DEL, &ier);
	        cvg_delet(cvg_getworkfile(), selLoc, TRUE, &ier);

		count++;
	        crg_clear (inxarry[ii], &ier);
            }
            free(inxarry);
            xpgpaste(llx, lly, urx, ury, &ier);

/*
 *  The deleted elements are deselected here so we won't 
 *  try to process them again in the outer while loop.
 */
	    pghdlb_deselectEl (num, TRUE);
	    cvg_rfrsh(NULL, llx, lly, urx, ury, &ier);
        }
        else {				/* non-group mode */
            pgutls_prepNew (selLoc, &el, &llx, &lly, &urx, &ury, &ier);
            pgundo_storeThisLoc(selLoc, UNDO_DEL, &ier);

/*
 * Free TCA break point/GFA block memory
 */
            if ( el.hdr.vg_type == TCA_ELM ) {
               cvg_freeBkpts ( &el );
            }
	    else if ( el.hdr.vg_type == GFA_ELM ) {
               cvg_freeElPtr ( &el );
            }

	    count++;
        }

/*
 *  Check for the next selected element
 */
	curIndex = selIndex;
        pghdlb_getNextIndex( curIndex, &selIndex, &selLoc, &iret );
    }

    if( count > 0 ) {
        pgundo_endStep();
        pglayer_setChngMade( pglayer_getCurLayer(), TRUE );
        pgactv_clearActv();
    }

/*
 * If we may have impacted other elements with placement
 * we will need to rebuild the range records
 */
    if (update_crg) {
        crg_rebuild();
    }

    return ( count );
}
Exemplo n.º 5
0
void crg_rebuild ( void )
/************************************************************************
 * crg_rebuild                                                          *
 *                                                                      *
 * This function rebuilds range records for all elem. in WORK_FILE.	*
 *                                                                      *
 * Note: the layer assignment is not affected by the rebuild - the 	*
 *       existing layer values are kept unchanged in range records. 	*
 *	 They could only be changed by crg_set() or crg_setLayer().	*
 *									*
 * void crg_rebuild ( void ) 						*
 *                                                                      *
 * Input/output parameters:                                             *
 *      none                               				*
 **                                                                     *
 * Log:                                                                 *
 * J. Wu/SAIC		12/01	initial coding				*
 * J. Wu/SAIC		12/01	replace crg_rdrec with crg_rdhdr/ele    *
 * J. Wu/SAIC		12/01	Get VG file size with cfl_inqr()  	*
 * T. Lee/SAIC		11/03	added user directory to work_file	*
 * T. Lee/SAIC		11/03	used cvg_getworkfile()			*
 * B. Yin/SAIC          07/04   Added code to free TCA memory           *
 * B. Yin/SAIC          08/04   changed pgtca_freeBkpts to cvg_freeBkpts*
 * J. Wu/SAIC		10/04	free GFA block pointers			*
 * J. Wu/SAIC		07/07	skip records for GFA text boxes		*
 ***********************************************************************/
{
    int 	ii, elnum, joffset, flag, ier;
    long	maxbytes;
    char	newfil[FILE_FULLSZ];
    VG_DBStruct	el;
    FILE	*fp;
    
/*---------------------------------------------------------------------*/

    cfl_inqr( cvg_getworkfile(), NULL, &maxbytes, newfil, &ier);

    cvg_open( cvg_getworkfile(), TRUE, &fp, &ier );

    if ( ( ier != 0 ) || ( fp == NULL ) ) {
	return;
    }
    
    
    for ( ii = 0; ii < MAX_EDITABLE_ELEMS; ii++)
    {
        joffset = range[ ii ].ioffset;
	if ( joffset >= 0 && !( crg_isauxrec( ii, &ier ) ) ) {            
	    crg_getinx( joffset, &elnum, &ier);
            
            cvg_rdhdr( cvg_getworkfile(), fp, joffset, (int)maxbytes, 
			&el, &flag, &ier );
	    cvg_rdele( &el, joffset, el.hdr.recsz, fp, &ier );
	    	    
	    if ( ier == 0 ) {
	        crg_mkRange( &el, joffset, elnum, &ier );
	    }

            /*
             * Free TCA break point/GFA blocks memory
             */
            if ( el.hdr.vg_type == TCA_ELM ) {
                cvg_freeBkpts ( &el );
            }
            else if ( el.hdr.vg_type == GFA_ELM ) {
                cvg_freeElPtr ( &el );
	    }
	}
    }

    cvg_clos( fp, &ier );

}
Exemplo n.º 6
0
void pggrpch_chngGrp ( void )
/************************************************************************
 * pggrpch_chngGrp							*
 *									*
 * Change the group type of the elements according to instructions on   *
 * VG Group Change Window.                                              *
 *									*
 * void pggrpch_chngGrp ()						*
 *									*
 * Input parameters:							*
 * Output parameters:							*
 * Return:								*
 *			NONE						*
 *									*
 **									*
 * Log:									*
 * H. Zeng/EAI          05/01	initial coding				*
 * J. Wu/SAIC		12/01	add layer in crg_set() call		*
 * J. Wu/SAIC		01/02	change only groups on current layer	*
 * H. Zeng/EAI          03/02   renamed for new nmap_pggrpch file       *
 * H. Zeng/EAI          05/02   modified to use master group type list  *
 * T. Lee/SAIC          11/03   added user directory to work_file       *
 * T. Lee/SAIC		11/03	used cvg_getworkfile			*
 * J. Wu/SAIC         	07/04   add filter param to crg_get		*
 * B. Yin/SAIC          08/04   added code to free TCA memory           *
 * B. Yin/SAIC          08/04   changed pgtca_freeBkpts to cvg_freeBkpts*
 * J. Wu/SAIC           10/04   free GFA block memory			*
 * S. Danz/AWC		07/06	Added new cvg_delet placement argument	*
 * S. Danz/AWC          08/06   New flag to pgvgf_saveNewElm to place el*
 * S. Danz/AWC          08/06   Updated to use cvg_checkplace to find   *
 * 				area impacted and call crg_rebuild()    *
 ***********************************************************************/
{
    int		el_num, new_num, el_loc, extra = 5, dest_grpnum;
    int		ori_grpnum, ier2, elN, new_location, ii, selection, iret;
    int         grpid, cur_layer, el_layer, pl_found, update_crg;
    float	llx, lly, urx, ury, m_llx, m_lly, m_urx, m_ury;
    float       *elX, *elY, inf_bbox[4];
    char	ori_grptyp, dest_grptyp, ori_grpnam[20], dest_grpnam[20];
    Boolean     found;
    VG_DBStruct	el;
    struct convertTblStrc  *convert_tbl, *ptr, *ptr_prev;
    filter_t	filter;
/*---------------------------------------------------------------------*/

    m_llx = 999999.0F;
    m_lly = 999999.0F;
    m_urx = 0.0F;
    m_ury = 0.0F;

    convert_tbl = NULL;
    ptr   = NULL;
    ptr_prev    = NULL;
    update_crg = 0;

    pgundo_newStep();
    cur_layer = pglayer_getCurLayer( );
    for (el_num = 0; el_num < MAX_EDITABLE_ELEMS; el_num++) {
	crg_goffset (el_num, &el_loc, &ier2);
	el_layer = crg_getLayer ( el_loc );

        /*
         * Skip cleared range record or those not on current layer.
         */
	if (el_loc == -1 || el_layer != cur_layer) {
           continue;
        }

 	crg_ggrp (el_num, &ori_grptyp, &ori_grpnum, &ier2);	

	if (ori_grpnum && ori_grptyp != GRPTYP_OTHERS
                       && ori_grptyp != GRPTYP_COMSYM
                       && ori_grptyp != GRPTYP_WATCH
                       && ori_grptyp != GRPTYP_CCF     ) {

            ces_gtgnam((int)ori_grptyp, ori_grpnam, &ier2);
            for( ii = 0; ii < _numCurGrp; ii++ ) {
	       if(strcmp(_curGrpStr[ii], ori_grpnam) == 0) {
                 selection = ii + 1;
                 break;
               }
            }

            if(ii < _numCurGrp && 
               _chngToStrc.chng_flag[selection] == TRUE) {

               strcpy(dest_grpnam, 
                      _chngToStr[ _chngToStrc.current[selection]-1 ]);
               ces_gtgid(dest_grpnam, &grpid, &ier2);
               dest_grptyp = (char)grpid;

               /* Search on conversion table to see if there is entry
                * that has the same ori_grptyp, ori_grpnum and dest_grptyp.
                * If yes, get dest_grpnum from there.
                */
               found = FALSE;
               ptr = convert_tbl;
               while(ptr != NULL) {
		     if(ori_grptyp == ptr->ori_grptyp &&
                        dest_grptyp== ptr->dest_grptyp&&
                        ori_grpnum == ptr->ori_grpnum    ) {

                        dest_grpnum = ptr->dest_grpnum;
                        found = TRUE;
                        break;
                     }
                     ptr = ptr->next;
               }

               /*
                * If not found on conversion table, get next available
                * group number. Add new entry into conversion table.
                */
               if(!found) {
                  crg_ggnxt(dest_grptyp, &dest_grpnum, &ier2);

                  if(convert_tbl == NULL) {
                     convert_tbl = (struct convertTblStrc*)malloc(
                                    sizeof(struct convertTblStrc)  );

                     convert_tbl->ori_grptyp = ori_grptyp;
                     convert_tbl->dest_grptyp= dest_grptyp;
                     convert_tbl->ori_grpnum = ori_grpnum;
                     convert_tbl->dest_grpnum= dest_grpnum;
                     convert_tbl->next       = NULL;
                     convert_tbl->prev       = NULL;
                  }
                  else {
                     ptr = convert_tbl;
		     while(ptr->next != NULL) ptr = ptr->next;
                     ptr->next = (struct convertTblStrc*)malloc(
                                    sizeof(struct convertTblStrc)  );
                     ptr_prev  = ptr;
                     ptr = ptr->next;

                     ptr->ori_grptyp = ori_grptyp;
                     ptr->dest_grptyp= dest_grptyp;
                     ptr->ori_grpnum = ori_grpnum;
                     ptr->dest_grpnum= dest_grpnum;
                     ptr->next       = NULL;
                     ptr->prev       = ptr_prev;

                  }     
               } /* the end of if(!found... */


	       cvg_rdrec (cvg_getworkfile(), el_loc, &el, &ier2);

	       /*
                * Create a copy of the element with new group info,
                */
	       pgactv_setActvElm ( &el, el_loc);
               pgactv_getDevPts (&elN, &elX, &elY);
               pgvgf_saveNewElm(NULL, sys_D, &el, 
                     elN, elX, elY, FALSE, &new_location, &iret);
               cvg_setginf(cvg_getworkfile(), new_location, 
                           dest_grptyp, dest_grpnum, &iret);

               /*
                * Free TCA/GFA memory
                */
               if ( el.hdr.vg_type == TCA_ELM ) {
                  cvg_freeBkpts ( &el );
               }
	       else if ( el.hdr.vg_type == GFA_ELM ) {
                   cvg_freeElPtr ( &el );
               }
               
               cvg_rdrec(cvg_getworkfile(), new_location, &el, &iret);
               crg_set (&el, new_location, cur_layer, &iret);
	       crg_getinx (new_location, &new_num, &iret);
	       crg_get(new_num, &el_layer, filter, &llx, &lly, &urx, &ury, &iret);

	       if (m_llx > llx)
                   m_llx = llx;
               if (m_lly > lly)
                   m_lly = lly;
               if (m_urx < urx)
                   m_urx = urx;
               if (m_ury < ury)
                   m_ury = ury;

               /*
                * Mark elements in placement that are effected by
                * the new element, and get the area of influence back
                */
	       cvg_checkplace(&el, 0, new_location, &pl_found, inf_bbox, &iret);
               if (pl_found > 0) {
                   /*
                    * Update the refresh extent if the area impacted by
                    * placement is bigger 
                    */
                   m_llx = G_MIN(m_llx, inf_bbox[0]);
                   m_lly = G_MIN(m_lly, inf_bbox[2]);
                   m_urx = G_MAX(m_urx, inf_bbox[1]);
                   m_ury = G_MAX(m_ury, inf_bbox[3]);
                   update_crg = 1;
               }

               /*
                * Free TCA/GFA memory
                */
               if ( el.hdr.vg_type == TCA_ELM ) {
                   cvg_freeBkpts ( &el );
               }
	       else if ( el.hdr.vg_type == GFA_ELM ) {
                   cvg_freeElPtr ( &el );
               }
	       
	       pgundo_storeThisLoc(new_location, 
                                UNDO_ADD, &iret);

               /*
                * Mark elements in placement that are effected by
                * the delete, and get the area of influence back
                */
               cvg_rdrec(cvg_getworkfile(), el_loc, &el, &iret);
	       cvg_checkplace(&el, 1, el_loc, &pl_found, inf_bbox, &iret);
               if (pl_found > 0) {
                   /*
                    * Update the refresh extent if the area impacted by
                    * placement is bigger 
                    */
                   m_llx = G_MIN(m_llx, inf_bbox[0]);
                   m_lly = G_MIN(m_lly, inf_bbox[2]);
                   m_urx = G_MAX(m_urx, inf_bbox[1]);
                   m_ury = G_MAX(m_ury, inf_bbox[3]);
                   update_crg = 1;
               }

               /*
                * Free TCA/GFA memory
                */
               if ( el.hdr.vg_type == TCA_ELM ) {
                   cvg_freeBkpts ( &el );
               }
	       else if ( el.hdr.vg_type == GFA_ELM ) {
                   cvg_freeElPtr ( &el );
               }

               /* 
                * Mark the original element as deleted.
                */
               cvg_delet(cvg_getworkfile(), el_loc, TRUE, &ier2);
	       crg_get (el_num, &el_layer, filter, &llx, &lly, &urx, &ury, &ier2);
	
	       if (m_llx > llx)
                   m_llx = llx;
               if (m_lly > lly)
                   m_lly = lly;
               if (m_urx < urx)
                   m_urx = urx;
               if (m_ury < ury)
                   m_ury = ury;

               crg_clear(el_num, &ier2);
	       pgundo_storeThisLoc (el_loc, UNDO_DEL, &ier2);

            } /* the end of if(ii < _numCurGrp ... ) */

	} /* the end of if (ori_grpnum &&... */ 

    } /* for (el_num = 0 ... */
    pgundo_endStep();

    m_llx -= (float)extra;
    m_lly -= (float)extra;
    m_urx += (float)extra;
    m_ury += (float)extra;
    
    xpgpaste (m_llx, m_lly, m_urx, m_ury, &ier2);
    cvg_rfrsh (NULL, m_llx, m_lly, m_urx, m_ury, &ier2); 

    /*
     * If we may have impacted other elements with placement
     * we will need to rebuild the range records
     */
    if (update_crg) {
        crg_rebuild();
    }

    /*
     * Free conversion table
     */
    if(convert_tbl != NULL) {

       ptr = convert_tbl;
       while(ptr->next != NULL) ptr = ptr->next;
       do {
            ptr_prev = ptr->prev;
            free(ptr);
            ptr = ptr_prev;
       }
       while(ptr != NULL);

    }

}
Exemplo n.º 7
0
/* ARGSUSED */
static void pgconn_select ( Widget wid, XtPointer clnt, XEvent *event,
						Boolean *ctdr )
/************************************************************************
 * pgconn_select							*
 *									*
 * This function handles the selection callbacks			*
 *									*
 * static void pgconn_select (wid, clnt, event, ctdr )			*
 *									*
 * Input parameters:							*
 *	wid		Widget	calling widget				*
 *	clnt		XtPointer					*
 *	*event		XEvent						*
 *									*
 * Output parameters:							*
 *			NONE						*
 *									*
 **									*
 * Log:									*
 *  S. Law/GSC		09/98	Initial coding				*
 *  S. Law/GSC		09/98	Removed unnecessary refreshes		*
 *  E. Safford/GSC	09/98	fix ghost problem conn to 2 pt lines    *
 *  G. Krueger/EAI	10/98	Using table for mouse hints		*
 *  S. Law/GSC		09/98	added CLASS_SIGMETS			*
 *  S. Law/GSC		09/99	added parameter to mcanvw_set* functions*
 *  E. Safford/GSC	10/99	update for new xwcmn.h			*
 *  S. Law/GSC		02/00	added CCF				*
 *  S. Law/GSC		03/00	added parameter to pgutls_prepNew	*
 *  H. Zeng/EAI         04/00   changed cursor name                     *
 *  S. Law/GSC		06/00	changed to use xgtoff			*
 *  H. Zeng/EAI         11/00   modified for the new undo design        *
 *  A. Hardy/GSC        11/00   renamed coordinate system declaration   *
 *  H. Zeng/EAI         12/00   modified for multiple undo steps        *
 *  J. Wu/GSC		03/01	added "EXIT" hint to bottom panel       *
 *  J. Wu/SAIC		01/02	scan the current PGEN layer only	*
 *  E. Safford/SAIC	03/02	rename from _pgconn_select, add         *
 *				  pgutls_regroup(), clean up		*
 *  E. Safford/SAIC	04/02	check ier from cvg_scan to avoid UMR	*
 *  T. Lee/SAIC         11/03   added user directory to work_file       *
 *  T. Lee/SAIC		11/03	used cvg_getworkfile			*
 *  S. Danz/AWC         08/06   New flag to pgvgf_saveNewElm to place el*
 *  J. Wu/SAIC		06/07	connect GFAs      			*
 ***********************************************************************/
{ 
    float		xx, yy, llx, lly, urx, ury;
    float		*primary_x, *primary_y;
    float		secondary_x[MAXPTS], secondary_y[MAXPTS];
    int			primary_n, primary_loc, secondary_n;
    int			ier, near, test, xoff, yoff, cur_layer;
    int			start, grp_num1, grp_num2;
    char		grp_typ1, grp_typ2, warnMsg[256], value[10];
    char		mesg[] = {"Maximum vertices exceeded."};
    Boolean		primary_grouped = FALSE;
    Boolean		secondary_grouped = FALSE;

    static int		secondary_elnum;
    static int          secondary_loc;
    static Boolean	reverse_flag = FALSE;
    static VG_DBStruct	secondary_el;
    static VG_DBStruct	GFA_el;
    
    int			GFA_pts, GFA_newloc;
    float		GFA_x[MAXPTS], GFA_y[MAXPTS];
/*---------------------------------------------------------------------*/

    xgtoff (&xoff, &yoff, &ier);
    cur_layer = pglayer_getCurLayer ();

    if (event->xbutton.button == Button1) {

        if (_selectFlag) {     /* confirming secondary element */
	    	    	    
	    grp_typ1 = _primaryEl.hdr.grptyp;
	    grp_num1 = _primaryEl.hdr.grpnum;

	    if ( grp_typ1 > 0 && grp_num1 > 0 ) {
		primary_grouped = TRUE;
	    }

	    cvg_todev (&secondary_el, &secondary_n, secondary_x, 
		       secondary_y, &ier);

	    grp_typ2 = secondary_el.hdr.grptyp;
	    grp_num2 = secondary_el.hdr.grpnum;

	    if ( grp_typ2 > 0 && grp_num2 > 0 ) {
		secondary_grouped = TRUE;
	    }
	    	             
	    if ( _drawGhost ) {
	        near = pgactv_getNearPt ();
	        pgactv_getDevPts (&primary_n, &primary_x, &primary_y);

	        start = (FindNearEnd (0, near, (primary_n - 1)) == 0) ? 
		         0 : primary_n;


	        if (reverse_flag) {
		    pgutls_fReverseArray (secondary_n, secondary_x,
				      secondary_y);
	        }

	        pgactv_addPts (secondary_x, secondary_y, secondary_n, 
			       start, &ier);
            }
	    
	    if (ier == 0) {
		
		if ( _drawGhost ) {
		    pgactv_getDevPts (&primary_n, &primary_x, &primary_y);
                }		

/*
 *  Grouping the new element:
 *
 *  If the primary element was grouped, the new element stays in 
 *  that group. If the primary element was not grouped, but the 
 *  secondary element was, then put the new element in the 
 *  secondary element's group. 
 */
	        if ( !primary_grouped && secondary_grouped ) {
		    _primaryEl.hdr.grptyp = grp_typ2;
		    _primaryEl.hdr.grpnum = grp_num2;
		}
		
/*
 *  Save the new element:
 *  
 *  For non-GFAs or open FZLVLs, use points of both the primary
 *  and secondary elements.
 *  
 *  For closed GFAs,  use points resulting from smearing the primary
 *  and secondary elements.  
 *
 *  Note: The new GFA element will use the the primary element's 
 *        forecast hour, color, and line attributes. 
 */		
		if ( _drawGhost ) {
		    
		    pgundo_newStep();
		    
		    pgundo_storeThisLoc ( _primaryLoc, UNDO_DEL, &ier );
		    pgundo_storeThisLoc ( secondary_loc, UNDO_DEL, &ier );

		    pgutls_prepNew ( -1, &_primaryEl,  &llx, &lly, &urx, &ury,
				     &ier);
		    
		    pgvgf_saveNewElm ( cvg_getworkfile(), sys_D, &_primaryEl, 
				 primary_n, primary_x, primary_y, 
				 TRUE, &primary_loc, &ier );
		    
		    pgutls_redraw ( primary_loc, &_primaryEl, &ier );

		    pgundo_storeThisLoc ( primary_loc, UNDO_ADD, &ier);
                    
		}
		else {		
		    		    		    		    		    
		    pgvgf_saveNewElm ( cvg_getworkfile(), sys_M, &GFA_el, 
		                      0, GFA_x, GFA_y, 
		                      TRUE, &GFA_newloc, &ier );
		    		    		     		    
		    if ( ier >= 0 ) {
		        pgundo_newStep();
		    
		        pgundo_storeThisLoc ( _primaryLoc, UNDO_DEL, &ier );
		        pgundo_storeThisLoc ( secondary_loc, UNDO_DEL, &ier );
		        
		        pgactv_setActvElm ( &_primaryEl,  _primaryLoc );
		        pgutls_prepNew ( _primaryLoc, &_primaryEl,  
			                 &llx, &lly, &urx, &ury, &ier);
			
			pgutls_redraw ( GFA_newloc, &GFA_el, &ier );
		        
			pgundo_storeThisLoc ( GFA_newloc, UNDO_ADD, &ier );
		    }
		    else if ( ier == -28 ) { /* too few points in resulting smear */
	                cvg_getFld ( &GFA_el, TAG_GFA_TAG, value, &ier );
	                sprintf( warnMsg, "Unable to connect tag %s.\n It has too few points after smearing and/or snapping.\n", value );
	                NxmWarn_show( mcanvw_getDrawingW(), warnMsg );
		    }
		    
		    cvg_freeElPtr ( &GFA_el );

		}
		
/* 
 * set the secondary element as the active
 * one, so that prepNew can remove it
 */		
		pgactv_setActvElm (&secondary_el, secondary_loc);
		pgutls_prepNew (secondary_loc, &secondary_el, 
				&llx, &lly, &urx, &ury, &ier);
	        		
/*
 *  If both elements were grouped, then move all elements
 *  grouped with the secondary element into the primary
 *  element's group.
 */
		if ( primary_grouped && secondary_grouped ) {
  		    pgutls_regroup ( grp_typ2, grp_num2, 
		    		     grp_typ1, grp_num1, &ier ); 
		}

                pgundo_endStep();
                
/*
 *  Clean up for next connection.
 */
                if ( _isGFA ) {
		    cvg_freeElPtr ( &secondary_el );		
		    cvg_freeElPtr ( &_primaryEl );		
		}
		
		pghdlb_deselectAll ();
                pgactv_clearActv ();
	        pggst_clearGhost ( FALSE );
		
	    }
	    else {
		NxmWarn_show (wid, mesg);
	    }

	    mcanvw_setPressFunc ((XtEventHandler)&pgevt_locateElmCb, CURS_DEFAULT);
	    if ( _drawGhost ) mcanvw_disarmDrag ();

	    _selectFlag = FALSE;
	    mbotw_mouseSet(LMHINT_SELECT, MMHINT_EXIT);
	}
	else {	/* selecting secondary element */
 
 	    xx = (float) (event->xbutton.x + xoff); 
	    yy = (float) (event->xbutton.y + yoff);

	    test = False;
	    cvg_scan (NULL, cur_layer, (char)_primaryEl.hdr.vg_class, xx, yy,
		      0, &secondary_el, &secondary_loc, &near, &ier);

/*
 *  Verify elements only if no error returned from cvg_scan.
 */	
	    if ( ier >= 0 ) {
	        test = pgconn_verifyType ( &_primaryEl, &secondary_el); 
	    }

/* 
 *  Verify there are actually 2 elements, not the same element.
 */
	    if (test) {
		if (secondary_loc == pgactv_getElmLoc () ||
		    secondary_loc == 0) {
		    test = FALSE;
		}
	    }
	    

	    if ( test ) {
				
		crg_getinx ( secondary_loc, &secondary_elnum, &ier );
 	        
/*
 *  Get the points for the potential connect/join and use it
 *  to draw the ghost line so the user can have a feel of the
 *  result before making the confirmation.
 *  
 *  For non-GFAs or open FZLVLs, connect points of both the primary
 *  and secondary elements.
 *  
 *  For closed GFAs,  get points by smearing the primary and
 *  secondary elements. 
 *
 */
		if ( !_drawGhost ) {	        
		    
/*
 *  Select the second GFA.
 */
		    pghdlb_select ( &secondary_el, secondary_loc );
                                        
/*
 *  Smear two GFA polygons.
 */		    
	            GFA_pts = 0;
		    GFA_el.elem.gfa.info.nblocks = 0; 
		    pgconn_smear ( _primaryLoc, secondary_loc,		  
		  		   &GFA_el, &GFA_pts, GFA_x, GFA_y );
   		    
/*
 *  Ghost the resulting polygon.
 */
		    pggst_clearGhost (TRUE);
		    		    
                    pggst_setLineAttr ( _primaryEl.hdr.smooth, 
		                        (Boolean)_primaryEl.hdr.closed );
                    
		    pggst_addGhostPts ( GFA_pts, GFA_x, GFA_y, &ier );
		    
		    
		    pggst_drawGhost ( GST_NORMAL );
		                        
		}
		else { 
		
		    pggst_drawGhost (GST_NORMAL);

		    mcanvw_disarmDrag ();
						
		    cvg_todev (&secondary_el, &secondary_n, secondary_x, 
			       secondary_y, &ier);

		    if (FindNearEnd (0, near, (secondary_n - 1))) {
		        reverse_flag = TRUE;
		        pgutls_fReverseArray (secondary_n, secondary_x,
					      secondary_y);
		    }
		    else {
		        reverse_flag = FALSE;
		    }

		    pggst_replaceGhostPts (1, &secondary_x[0], 
				           &secondary_y[0], &ier);

		    pggst_addGhostPts ((secondary_n - 1), &secondary_x[1],
				        &secondary_y[1], &ier);

		    pggst_drawGhost (GST_NORMAL);

	        }
		   		
		_selectFlag = TRUE;
		mbotw_mouseSet(LMHINT_CONFIRM, MMHINT_CANCEL);
	    }
	}
    }
    else {
        if (_selectFlag) {     /* unselecting secondary element */
	    pghdlb_deselectEl ( secondary_elnum, TRUE );
	    pghdlb_displayAllSel ();

	    if ( _drawGhost ) {
	        xx = (float) (event->xbutton.x + xoff); 
	        yy = (float) (event->xbutton.y + yoff); 

	        _ghostX[_ghostN] = xx;
	        _ghostY[_ghostN] = yy;
  
	        pggst_clearGhost (FALSE);

	        pggst_addGhostPts ((_ghostN + 1), _ghostX, _ghostY, &ier);

	        pggst_drawGhost (GST_NORMAL);

	    }
	     
	    _selectFlag = FALSE;
	    mbotw_mouseSet(LMHINT_NEXT, MMHINT_DONE);
  
	    if ( _drawGhost ) {
	        mcanvw_setDragFunc((XtEventHandler)&pgconn_ghost, CURS_DEFAULT);
	    }
             
	    if ( _isGFA ) {
		cvg_freeElPtr ( &secondary_el );		
		if ( !_drawGhost ) cvg_freeElPtr ( &GFA_el );		
	    }

	}
	else {	/* unselecting primary element */
	    
	    if ( _isGFA ) {
		cvg_freeElPtr ( &_primaryEl );		
	    }
	    
	    mcanvw_disarmDynamic ();
	    _selectFlag = FALSE;

	    pghdlb_deselectAll();

	    mcanvw_setPressFunc ((XtEventHandler)&pgevt_locateElmCb, CURS_DEFAULT);

	    _selectFlag = FALSE;
	    mbotw_mouseSet(LMHINT_SELECT, MMHINT_EXIT);	    
	}
    }
}