对命令结束函数进行编码

现在您已经看到了伪代码并处理了一些重要细节，请将 reactor 回调中的存根代码替换为以下内容：gp:command-ended

(defun gp:command-ended (reactor command-list
                         / objReactor
                         reactorToChange reactorData
                         coordinateValues currentPoints
                         newReactorData newPts
                         tileList
                         )
  (cond
    ;; CONDITION 1 - POLYLINE ERASED (Erase command)
    ;; If one or more polyline borders are being erased (indicated
    ;; by the presence of *reactorsToRemove*), erase the tiles
    ;; within the border, then remove the reactor.
    (*reactorsToRemove*
      (foreach objReactor *reactorsToRemove*
        (gp:erase-tiles objReactor)
      )
      (setq *reactorsToRemove* nil)
    )

    ;; CONDITION 2 - LOST ASSOCIATIVITY (Move, Rotate, etc.)
    ;; If associativity has been lost (undo, move, etc.), then
    ;; erase the tiles within each border
    ;; 
    ((and *lostassociativity* *reactorsToChange*)
      (foreach reactorToChange *reactorsToChange*
        (gp:erase-tiles reactorToChange)
      )
      (setq *reactorsToChange* nil)
    )

    ;; CONDITION 3 - GRIP_STRETCH 
    ;; In this case, the associativity of the tiles to the path is
    ;; kept, but the path and the tiles will need to be
    ;; recalculated and redrawn. A GRIP_STRETCH can only be
    ;; performed on a single POLYLINE at a time.
    ((and (not *lostassociativity*)
      *polytochange*
      *reactorsToChange*
      (member "GRIP_STRETCH" command-list)
      ;; for a GRIP_STRETCH, there will be only one reactor in
      ;; the global *reactorsToChange*.
      (setq reactorData
         (vlr-data (setq reactorToChange
                  (car *reactorsToChange*)
                 )
               )
        )
     )

     ;; First, erase the tiles within the polyline border.
     (gp:erase-tiles reactorToChange)

     ;; Next, get the current coordinate values of the polyline
     ;; vertices.
     (setq coordinateValues
       (vlax-safearray->list
         (vlax-variant-value
           (vla-get-coordinates *polyToChange*)
         )
       )
     )

     ;; If the outline is a lightweight polyline, you have
     ;; 2d points, so use utility function xyList->ListOfPoints
     ;; to convert the coordinate data into lists of
     ;; ((x y) (x y) ...) points. Otherwise, use the
     ;; xyzList->ListOfPoints function that deals
     ;; with 3d points, and converts the coordinate data into
     ;; lists of ((x y z) (x y z) ... ) points.
     (setq CurrentPoints
        (if (= (vla-get-ObjectName *polytochange*) "AcDbPolyline")
          (xyList->ListOfPoints coordinateValues)
          (xyzList->ListOfPoints coordinateValues)
        )
     )

     ;; Send this new information to RedefinePolyBorder -- this
     ;; will return the new Polyline Border
     (setq NewReactorData
       (gp:RedefinePolyBorder CurrentPoints reactorData)
     )

     ;; Get all the border Points and ...
     (setq newpts
            (list
              (cdr (assoc 12 NewReactorData))
              (cdr (assoc 13 NewReactorData))
              (cdr (assoc 14 NewReactorData))
              (cdr (assoc 15 NewReactorData))
            )
     )

     ;; ...update the outline of the polyline with the new points
     ;; calculated above.  If dealing with a lightweight polyline,
     ;; convert these points to 2D (since all the points in
     ;; newpts are 3D), otherwise leave them alone.
     (if (= (cdr (assoc 4 NewReactorData)) "LIGHT")
       (setq newpts (mapcar '(lambda (point)
                        (3dPoint->2dPoint Point)
                      )
                      newpts
                    )
       )
     )

     ;; Now update the polyline with the correct points.
     (vla-put-coordinates
       *polytochange*

       ;; For description of the list->variantArray see utils.lsp.
       (gp:list->variantArray (apply 'append newpts))
     )

     ;; Now use the current definition of the NewReactorData, 
     ;; which is really the same as the garden path data
     ;; structure. The only exception is that the field (100) 
     ;; containing the list of tiles is nil.  This is OK since
     ;; gp:Calculate-and-Draw-Tiles does not require this field 
     ;; to draw the tiles. In fact this function creates the tiles
     ;; and returns a list of drawn tiles.
     (setq tileList (gp:Calculate-and-Draw-Tiles
              ;; path data list without correct tile list
              NewReactorData
              ;; Object creation function
              ;; Within a reactor this *MUST* be ActiveX
              "ActiveX"
              )
     )

     ;; Now that you have received all the tiles drawn, rebuild
     ;; the data structure with the correct tileList value and
     ;; reset the data property in the reactor.
     ;; Update the tiles associated with the polyline border.
     (setq NewReactorData
        (subst (cons 100 tileList)
           (assoc 100 NewReactorData)
           NewReactorData
           )
     )

     ;; By now you have the new data associated with the polyline.
     ;; All there is left to do is associate it with the reactor
     ;; using vlr-data-set.
     (vlr-data-set (car *reactorsToChange*) NewReactorData)

     ;; Remove all references to the temporary
     ;; variables *polytochange* and *reactorsToChange*.
     (setq *polytochange*     nil
       *reactorsToChange* nil
       )
     )
    )
    ;; Delete any items in the *Safe-to-Delete* global if you can!!!
    (Gp:Safe-Delete (car command-list))
   (princ)
 )