/* Cette fonction redessine le rectangle autour d'une vue 3d de couleur color */
/* Si test n'e reaffiche pas les cotés communs avec la vue selectionnée       */
/* si pas test redessinne tout                                                */
fun paintSelectionDEV(mainwin,dev,color,test,seldev)=
  if dev==nil then nil
  else
    let _GETwindowPositionSize dev.V3dwin -> [x y w h] in
    let _GETwindowPositionSize seldev.V3dwin -> [sx sy sw sh] in
    {
      /* lignes horizontales */
      if (test && y-DECAL!=sy+sh)||(!test) then
        _PAINTrectangle mainwin x-DECAL y-DECAL w+2*DECAL DECAL DRAW_SOLID 1 color DRAW_SOLID color
      else nil;
      if (test && y+h!=sy-DECAL)||(!test) then
        _PAINTrectangle mainwin x-DECAL y+h w+2*DECAL DECAL DRAW_SOLID 1 color DRAW_SOLID color
      else nil;

      /* lignes verticales */
      if (test && x-DECAL!=sx+sw)||!test then
        _PAINTrectangle mainwin x-DECAL y-DECAL DECAL h+2*DECAL DRAW_SOLID 1 color DRAW_SOLID color
      else nil;
      if (test && x+w!=sx-DECAL)||!test then
        _PAINTrectangle mainwin x+w y-DECAL DECAL h+2*DECAL DRAW_SOLID 1 color DRAW_SOLID color
      else nil;
    };;



/* callback de focus d'une vue 3d */
fun cbUserFocus(view,dev)=
  /* affichage de la selection de vue */
  paintSelectionDEV dev.DEVmanager.MV3dWin dev.DEVselected3d UNSELECTED_COLOR 0 dev.DEVselected3d;
  paintSelectionDEV dev.DEVmanager.MV3dWin (set dev.DEVselected3d=view) SELECTED_COLOR 0 dev.DEVselected3d;
  evalStateViewBtn dev;
  0;;


/* callback de mouvement de la souris sur un objet */
fun cbUserCursorMoveObject(view,h,m,x,y,param)=
  let param -> [dev view typeview] in
  if (view!=dev.DEVselected3d) || (h!=dev.DEVlasth && m!=dev.DEVlastm) then
  {
    set dev.DEVlasth=h;
    set dev.DEVlastm=m;
    if dev.DEVtypeOperation&(OP_ROTOBJ|OP_MOVEOBJ|OP_SCALE) then
    {
      if dev.DEVlasth!=nil then
        setCursorView3d view MoveSelectCursor
      else
        resetCursorView3d view;
    }
    else nil;
  }
  else nil;
  0;;

/* callback de mouvement de la vue avec bouton appuye*/
fun cbUserCursorMove(x, y, param) =
  
  let param -> [dev view typeview] in
  if dev.DEVtypeOperation&OP_PAN then 
    movePAN view x y typeview
  else 
    if dev.DEVtypeOperation&OP_PROF then 
      movePROF view x y typeview
    else 
      if dev.DEVtypeOperation&OP_VIEW then 
        nil
      else 
        if dev.DEVtypeOperation&OP_MOVEOBJ then 
          moveOBJ dev view x y
        else 
          if dev.DEVtypeOperation&OP_ROTOBJ then 
            rotateOBJ dev view x y
          else 
            if dev.DEVtypeOperation&OP_SCALE then 
              scaleOBJ dev view x y
            else 
              nil;
  0
;;


fun cbUserDestroy(view,cam)=
  M3delObj view.V3dsession cam;
  set view.V3dsession=nil;
  set view.V3dcamera=nil;
  0
;;

/**************************************
Fonction renvoyant le texte correspondant
à la vue de type
***************************************/
fun getView3dName(type)=
  if type&VIEW_AVATAR then      _loc this "VIEW_AVAT" nil
  else if type&VIEW_LEFT then   _loc this "VIEW_LEFT" nil
  else if type&VIEW_RIGHT then  _loc this "VIEW_RIGHT" nil
  else if type&VIEW_BOTTOM then _loc this "VIEW_BOTTOM" nil
  else if type&VIEW_TOP then    _loc this "VIEW_TOP" nil
  else if type&VIEW_FRONT then  _loc this "VIEW_FRONT" nil
  else if type&VIEW_BACK then   _loc this "VIEW_BACK" nil
  else nil;;

fun cbUserPostRender(surface,wh,param)=
  let param -> [dev view type] in
  {
    /*exec dev.DEVsavePostRender with [surface wh]; disable !!! */
    _SDRAWtext surface dev.DEVfont 0 0 0 make_rgb 255 255 255 getView3dName type;
    renderAxisView dev.DEVaxis view dev.DEVselected3d type;
  };
  0;;

/*********************************************
Fonction de construction du cube de selection
d'un objet
Renvoie le h3d du cube crée
**********************************************/
fun evalSelectCube(session,h,name,color)=
  let M3calcObb session h -> [pos [xsize ysize zsize]] in
  let xsize+DECAL_SELECT-> x in
  let ysize+DECAL_SELECT-> y in
  let zsize+DECAL_SELECT-> z in
  let strbuild ("material"::"mat_selection"::"{"::nil)::
               ("color"::(itoh color)::nil)::
               ("}"::nil)::
               ("mesh"::name::"{"::nil)::
               ("0 0 0 0 0 0"::nil)::
               ((itoa (-x))::(itoa y)::(itoa (-z))::nil)::
               ((itoa x)::(itoa y)::(itoa (-z))::nil)::
               ((itoa (-x))::(itoa (-y))::(itoa (-z))::nil)::
               ((itoa x)::(itoa (-y))::(itoa (-z))::nil)::
               ((itoa (-x))::(itoa y)::(itoa z)::nil)::
               ((itoa x)::(itoa y)::(itoa z)::nil)::
               ((itoa (-x))::(itoa (-y))::(itoa z)::nil)::
               ((itoa x)::(itoa (-y))::(itoa z)::nil)::
               ("mat_selection"::nil)::
               ("0 2 3 1"::nil)::
               ("4 5 7 6"::nil)::
               ("0 1 5 4"::nil)::
               ("1 3 7 5"::nil)::
               ("3 2 6 7"::nil)::
               ("2 0 4 6"::nil)::
               ("}"::nil)::
               nil -> strbox in
  {

    M3loadString session strbox h;
    let M3getMat session "mat_selection" -> m in
    {
      M3setMaterialTransparency session m BOX_TRANSPARENCY_COEFF;
      M3setType session m (M3getType session m)|4
    };
    let M3getFirstSon session h -> cube in
    {
      M3setObjVec session cube pos;
      [pos cube]
    };
  };;

fun setSelectCubeColor(session,color)=
  M3setMaterialFlat session M3getMat session "mat_selection" color;;

/*******************************************
Fonction de selection d'un objet dans l'
editeur dynamique
Renvoie 0
********************************************/
fun selectObject(dev,view,o,m,x,y)=
  let dev.DEVselectedObj -> oldselected in
	{
    set dev.DEVselectedMat3d=m;
    set dev.DEVselectedObj=o;

    if dev.DEVselectedObj!=nil && dev.DEVselectedObj!= oldselected  then
    {

      /* modification des coordonées dans le toolbar */
      setToolBarPos dev.DEVselectedObj view dev.DEVtypeCoords;
      setToolBarAng dev.DEVselectedObj view dev.DEVtypeCoords;
      setToolBarScale dev.DEVselectedObj view;
      setToolBarSize dev.DEVselectedObj view;

      /* destruction de la boite precedente et creation de la nouvelle */
      C3D_RemoveIgnored3DObject dev.DEVselectbox;
      M3delObj view.V3dsession dev.DEVselectbox;
      set dev.DEVselectcolor=htoi "ffffff";
      let evalSelectCube view.V3dsession
                         dev.DEVselectedObj "select"
                         dev.DEVselectcolor -> [pos cube] in
      {
        set dev.DEVselectboxpos=pos;
        set dev.DEVselectbox=cube;
        C3D_AddIgnored3DObject dev.DEVselectbox;
        0
      }
    }
    else if dev.DEVselectedObj==nil then
    {
      /* modification des coordonées dans le toolbar */
      setToolBarPos dev.DEVselectedObj view dev.DEVtypeCoords;
      setToolBarAng dev.DEVselectedObj view dev.DEVtypeCoords;
      setToolBarScale dev.DEVselectedObj view;
      setToolBarSize dev.DEVselectedObj view;

      /* destruction de la boite precedente et creation de la nouvelle */
      C3D_RemoveIgnored3DObject dev.DEVselectbox;
      M3delObj view.V3dsession dev.DEVselectbox;
      set dev.DEVselectboxpos=nil;
      set dev.DEVselectbox=nil;
      0
    }
    else nil;

    /* creation de l'axe de l'objet si l'operation est deplacement objet*/
    if dev.DEVtypeOperation&(OP_ROTOBJ|OP_MOVEOBJ|OP_SCALE) && dev.DEVselectedObj!=dev.DEVaxis.AVrefobject then
    {
      dsAxisView dev.DEVaxis;
      set dev.DEVaxis=nil;
      let getView3dSize view -> [w h] in
        set dev.DEVaxis=newAxisView dev.DEVselectedObj
                                    w h
                                    (if dev.DEVtypeOperation&OP_SCALE then
                                        AXIS_SINGLE
                                     else
                                        AXIS_TRIEDRE
                                    )
    }
    else nil;
  };
  0;;


/************************************
Fonction de deselection de l'objet
selectionné
Renvoie 0
*************************************/
fun unselectObject(dev,view)=
  /* destrcution de la boite de selection */
  C3D_RemoveIgnored3DObject dev.DEVselectbox;
  M3delObj view.V3dsession dev.DEVselectbox;
  set dev.DEVselectbox=nil;
  set dev.DEVselectedObj=nil;
  set dev.DEVselectedMat3d=nil;

  /* destruction de l'axe */
  dsAxisView dev.DEVaxis;
  set dev.DEVaxis=nil;

  /* mise à jour du toolbar */
  setToolBarPos nil view dev.DEVtypeCoords;
  setToolBarAng nil view dev.DEVtypeCoords;
  setToolBarScale nil view;
  setToolBarSize nil view;

  0;;



fun cbUserClick(x, y, btn, o, m, param) =

  dyndebg "dyneditor.viewc.pkg"::"cbUserClick"::nil;
  let param-> [dev view] in
  if dev.DEVcanEdit==1 && (btn==2 || (btn==1 && dev.DEVtypeOperation&(OP_MOVEOBJ|OP_ROTOBJ|OP_SCALE))) then
  (
    if btn==1 && testClickOnAxis dev.DEVaxis view x y then
      1
      /* si on click sur un des axes pas de modifications de la boite de selection*/
      /* pas de traitement du click */
    else
      if btn==2 then
        if o == nil || (OB_SearchObj3DAvatar ObList o) == nil then
        (
        	selectObject dev view o m x y;
          if dev.DEVtypeView&VIEW_FOUR || (dev.DEVtypeView&VIEW_ONE && dev.DEVselected3d!=dev.DEVbd3d && !dev.DEVcanEdit) then  /* modif 11-10 */
            nil
          else
            drawMenu dev view x y dev.DEVselectedObj dev.DEVselectedMat3d;
          1
        )
        else /* avatar */
          0
      else 
        0;
  )
  else 0
;;


fun cbUserUnClick(x, y, btn, o, m, param) =
  
  let param -> [dev view] in
  if (btn==1&& dev.DEVtypeOperation&(OP_MOVEOBJ|OP_ROTOBJ|OP_SCALE)) then
    testUnClickOnAxis dev dev.DEVaxis view x y
  else 
    nil;
  0
;;


fun cbUserResize(view, w, h, dev) =
  
  if (dev.DEVtypeView&VIEW_FOUR) then
    let (w-3*DECAL)/2 -> w2 in
    let (h-3*DECAL)/2 -> h2 in
    let 2*DECAL+w2  -> posx2 in
    let 2*DECAL+h2  -> posy2 in
    let 
      if view==dev.DEVhg3d then
        [DECAL  DECAL]
      else 
        if view==dev.DEVhd3d then 
          [posx2  DECAL]
        else 
          if view==dev.DEVbg3d then 
            [DECAL  posy2]
          else 
            if view==dev.DEVbd3d then 
              [posx2  posy2]
            else 
              nil  
    -> [x y] in
    (
      resizeView3d view x y w2 h2;
      resizeAxisView dev.DEVaxis w2 h2
    )
  else
  (
      resizeView3d view 0 0 w h;
      topView3d dev.DEVselected3d;    /* MODIF 11-10 */
      resizeAxisView dev.DEVaxis w h;
  );
  0
;;


fun cbUserMngPreRender(mng, dev)= 
  
  if dev.DEVcanEdit==1 && dev.DEVselectedObj!=nil then
  ( 
    let htoi "7f7f7f" -> ndx in
    set dev.DEVselectcolor=dev.DEVselectcolor&ndx+ndx;
    setSelectCubeColor dev.DEVbd3d.V3dsession dev.DEVselectcolor;
  )
  else 
    nil;
  0
;;


/**************************************
Fonction initialisant la camera d'une vue
suivant son type
***************************************/              /* MODIF 11-10 */
fun setView3dCameraAngle(view, type)=
  
  if type&VIEW_AVATAR then 
    nil
  else 
    if type&VIEW_LEFT then
      M3setObjAng view.V3dsession view.V3dcamera [16384 0 0]
    else 
      if type&VIEW_RIGHT then
      (
        M3setObjVec view.V3dsession view.V3dcamera [0 0 0];
        M3setObjAng view.V3dsession view.V3dcamera [(-16384) 0 0];
      )
      else 
        if type&VIEW_BOTTOM then
        (
          M3setObjVec view.V3dsession view.V3dcamera [0 1000 0];
          M3setObjAng view.V3dsession view.V3dcamera [0 16384 0];
        )
        else 
          if type&VIEW_TOP then
            M3setObjAng view.V3dsession view.V3dcamera [0 (-16384) 0]
          else 
            if type&VIEW_FRONT then
            (
              M3setObjVec view.V3dsession view.V3dcamera [0 0 0];
              M3setObjAng view.V3dsession view.V3dcamera [0 0 0];
            )
            else 
              if type&VIEW_BACK then
                M3setObjAng view.V3dsession view.V3dcamera [(-32768) 0 0]
              else 
                nil
;;


/* fonction d'affectation des callbacks utilisateurs d'une vue 3d */
fun setView3dCallbacks(view,session,cam,dev,type)=
  dyndebg "dyneditor.viewc.pkg"::"setView3dCallbacks"::nil;

  let strcatn (getView3dName type)::"camera"::nil -> desc in
  {
    M3loadString session
                 strcatn "camera "::desc::" {\n0 0 0 0 0 0\n100 100 200 100\n20 80000 130000\n}\n"::nil /* MODIF 11-10 */
                 shell;
    let M3getObj session desc -> newcam in
    {
       setView3dcbEnd view mkfun2 @cbUserDestroy newcam;
       setView3dCameraSession view session (if (view!=dev.DEVbd3d) then newcam else cam);
    }
  };

  setView3dCameraAngle view type;
  setView3dcbPostRender view mkfun3 @cbUserPostRender [dev view type];
  setView3dcbFocus view mkfun2 @cbUserFocus dev;
  setView3dcbResize view mkfun4 @cbUserResize dev;
  if view!=dev.DEVbd3d then
  (
    setView3dcbClick view mkfun6 @cbUserClick [dev view];
    setView3dcbUnClick view mkfun6 @cbUserUnClick [dev view];
    setView3dcbCursorMoveCoords view mkfun3 @cbUserCursorMove [dev view type];
    setView3dcbReflexesObject view nil nil nil mkfun6 @cbUserCursorMoveObject [dev view type];
  )
  else 
    nil
;;


/* fonction reflexe de paint sur le view manager */
fun cbDEVpaint(v3dmng,dev)=
  if (dev.DEVtypeView&VIEW_FOUR) then
  {
    if dev.DEVselected3d==dev.DEVhg3d then nil
    else
      paintSelectionDEV v3dmng.MV3dWin
                        dev.DEVhg3d
                        UNSELECTED_COLOR
                        1
                        dev.DEVselected3d;

    if dev.DEVselected3d==dev.DEVhd3d then nil
    else
      paintSelectionDEV v3dmng.MV3dWin
                        dev.DEVhd3d
                        UNSELECTED_COLOR
                        1
                        dev.DEVselected3d;

    if dev.DEVselected3d==dev.DEVbg3d then nil
    else
      paintSelectionDEV v3dmng.MV3dWin
                        dev.DEVbg3d
                        UNSELECTED_COLOR
                        1
                        dev.DEVselected3d;

    if dev.DEVselected3d==dev.DEVbd3d then nil
    else
      paintSelectionDEV v3dmng.MV3dWin
                        dev.DEVbd3d
                        UNSELECTED_COLOR
                        1
                        dev.DEVselected3d;

    paintSelectionDEV v3dmng.MV3dWin dev.DEVselected3d SELECTED_COLOR 0 dev.DEVselected3d;
  }
  else nil;
  0;;






/************************************
Fonction d'initialisation de l'
editeur dynamique
*************************************/
fun newDynEditorView(mng,view)=
  let getView3dSize view -> [w h] in
  let mkDynEditorView[mng.MV3dChannel
                      mng
                      nil
                      nil
                      nil
                      view
                      nil
                      nil
                      nil  /* menu */
                      _CRfont mng.MV3dChannel 16 0 0 "Arial"
                      VIEW_ONE
                      DYN_NORM
                      0
                      COORDS_RELATIF
                      nil
                      nil
                      nil
                      nil
                      htoi "ffffff"
                      OP_VIEW
                      nil
                      nil
                      /*getRoom view cel.Cel3dobj*/
                      view.V3dcbMoveObject
                      view.V3dcbCursorMoveObject
                      view.V3dcbClickObject
                      view.V3dcbDClickObject
                      view.V3dcbPostRender
                 ]-> dev in
   {
      /* initialisation du click dans la vue 3d */
      setView3dcbClick view mkfun6 @cbUserClick [dev view];
      setView3dManagerPreRender mng mkfun2 @cbUserMngPreRender dev;
      dev
   };;


/************************************
Fonction de creation de la vue
editeur dynamique
*************************************/
fun crDynEditorView(dev)=
  dyndebg "dyneditor.viewc.pkg"::"crDynEditorView"::nil;
  let dev.DEVmanager.MV3dSize -> [w h] in
  let (w-3*DECAL)/2 -> w2 in
  let (h-3*DECAL)/2 -> h2 in
  let 2*DECAL+w2  -> posx2 in
  let 2*DECAL+h2  -> posy2 in
  let make_rgb 128 128 128 -> grey in
  {

    /* initialisation du menu */
    set dev.DEVtypeMenu=dev.DEVtypeMenu|DYN_EDIT;
    set dev.DEVtypeOperation=OP_VIEW;
    set dev.DEVsavePostRender=dev.DEVbd3d.V3dcbPostRender;

    setView3dCallbacks dev.DEVbd3d dev.DEVbd3d.V3dsession dev.DEVbd3d.V3dcamera dev VIEW_AVATAR;
    setView3dManagerPaint dev.DEVmanager mkfun2 @cbDEVpaint dev;

    /* focus sur la vue avatar */
    _SETfocus dev.DEVbd3d.V3dwin;
    setToolBarPos dev.DEVselectedObj dev.DEVbd3d dev.DEVtypeCoords;
    setToolBarAng dev.DEVselectedObj dev.DEVbd3d dev.DEVtypeCoords;
    setToolBarScale dev.DEVselectedObj dev.DEVbd3d;
    setToolBarSize dev.DEVselectedObj dev.DEVbd3d;
    dev
  }
;;

/************************************
Fonction qui reset les reflexes relatifs
aux objets dans la vue 3d view
*************************************/
fun resetAvatarViewMoveReflexes(dev) =
  
  setView3dcbReflexesObject dev.DEVbd3d
                            nil
                            nil
                            dev.DEVsaveMoveObject
                            mkfun6 @cbUserCursorMoveObject [dev dev.DEVbd3d VIEW_AVATAR];
  
  setView3dcbCursorMoveCoords dev.DEVbd3d mkfun3 @cbUserCursorMove [dev dev.DEVbd3d VIEW_AVATAR];
  setView3dcbUnClick dev.DEVbd3d mkfun6 @cbUserUnClick [dev dev.DEVbd3d];
  0
;;


/************************************
Fonction qui restaure les reflexes
relatifs aux objets dans la vue 3d
view
*************************************/
fun restoreAvatarViewReflexes(dev)=
  setView3dcbReflexesObject dev.DEVbd3d
                            dev.DEVsaveClickObject
                            dev.DEVsaveDClickObject
                            dev.DEVsaveMoveObject
                            dev.DEVsaveCursorMoveObject;
  setView3dcbCursorMoveCoords dev.DEVbd3d nil;
  setView3dcbUnClick dev.DEVbd3d nil;
  0;;


/*************************************
Fonction de destruction de la vue
editeur dynamique
**************************************/
fun dsDynEditorView(dev)=
  /* destruction des trois vues filaires */
  dsView3d dev.DEVhg3d;
  dsView3d dev.DEVhd3d;
  dsView3d dev.DEVbg3d;

  set dev.DEVhg3d=nil;
  set dev.DEVhd3d=nil;
  set dev.DEVbg3d=nil;

  set dev.DEVtypeView=VIEW_ONE;
  set dev.DEVtypeOperation=OP_VIEW;
  set dev.DEVtypeMenu=DYN_NORM;

  /* restauration des callbacks de la vue avatar */
  restoreAvatarViewReflexes dev; 
  dsAxisView dev.DEVaxis;
  set dev.DEVaxis=nil;
  resetCursorView3d dev.DEVbd3d;
  setView3dcbPostRender dev.DEVbd3d dev.DEVsavePostRender;

  /* restauration de la taille de la vue avatar */
  let dev.DEVmanager.MV3dSize -> [w h] in
    resizeView3d dev.DEVbd3d 0 0 w h;
  0;;

/************************************
Fonction d'initialisation de la vue
globale d'edition dynamique
*************************************/
fun initGlobalEditorView(mng,v3d)=
  dyndebg "dyneditor.viewc.pkg"::"initGlobalEditorView"::nil;

  /* initialisation de la vue globale */
  set DEVview=newDynEditorView mng v3d;
  0;;

proto TOOL_Init = fun [DynEditorView] I;;

/************************************
Fonction d'ouverture de la vue
globale d'edition dynamique
*************************************/
fun openGlobalEditorView()=
  set SELECTED_COLOR=make_rgb 255 0 0;
  set UNSELECTED_COLOR=make_rgb 255 255 255;

  /* initialisation des curseurs */
  
  let 
    if _platform == 3 then
      [ HandCursorMACBmp ProfCursorMACBmp MoveSelectMACBmp]
    else
      [ HandCursorBmp ProfCursorBmp MoveSelectBmp]
  -> [Hand Prof Move] in
  (
  
  let _LDbitmap _channel _checkpack Hand -> cur in
  (
    set HandCursor = _CRcursor _channel cur 9 3 0 0xFFFFFF;
    set ListBmp=cur::ListBmp;
  );
  let _LDbitmap _channel _checkpack Prof -> cur in
  (
    set ProfCursor = _CRcursor _channel cur 16 16 0 0xFFFFFF;
    set ListBmp=cur::ListBmp;
  );
  let _LDbitmap _channel _checkpack Move -> cur in
  (
    set MoveSelectCursor=_CRcursor _channel cur 16 16 0 0xFFFFFF;
    set ListBmp=cur::ListBmp;
  );
  );
  TOOL_Init DEVview;

  crDynEditorView DEVview;

  0;;

/*****************************************
Fonction d'activation ou de desactivation
du mode d'edition dynamique
******************************************/
fun changeModeGlobalEditorView(ui,action,param)=
  set DEVview.DEVcanEdit=1;
  0
;;


fun DYNEDITOR_Close () =
  set DEVview.DEVcanEdit=0;
  unselectObject DEVview DEVview.DEVbd3d;
  
  TRANSPEDIT_CloseAll;
  LIGHTEDIT_CloseAll;
  FILTEREDIT_CloseAll;
  COLOREDIT_CloseAll;
  dsPosBar;
  DYNBOX_DestroyInterface;
  closeExplorateur;
  
  if DEVview.DEVtypeMenu&DYN_EDIT then
  (
    closeGlobalEditorView;
    set DEVview.DEVtypeMenu = DEVview.DEVtypeMenu & ~DYN_EDIT;
  )
  else nil;
  closePluginBrowser;
  PLUGEDIT_Close;
  
  if DEVview.DEVtypeMenu&DYN_PLUGBROWS then
    set DEVview.DEVtypeMenu = DEVview.DEVtypeMenu & ~DYN_PLUGBROWS
  else nil;
  UsendMessage ObUi DYNEDITORmyOb "close" nil;
  0
;;

fun dsBmps(l)=
  if l==nil then 0
  else let l -> [bmp nxt] in
  {
     _DSbitmap bmp;
     dsBmps nxt;
  };;


/************************************
Fonction de fermeture de la vue
globale d'edition dynamique
*************************************/
fun closeGlobalEditorView()=
  /* destruction bmps et curseurs */
  dsBmps ListBmp;
  _DScursor HandCursor;
  _DScursor ProfCursor;

  /* destruction de la vue editeur et reaafichage de la vue 3d*/
  dsDynEditorView DEVview;

  /* on cache l'explorateur et on ferme la barre d'outils */
  closeExplorateur;
  TOOL_Close
;;



/************************************
Fonction de desinitialisation de la
vue globale d'edition dynamique
*************************************/
fun unInitGlobalEditorView()=
  _DSfont DEVview.DEVfont;
  dsAxisView DEVview.DEVaxis;
  set DEVview.DEVaxis=nil;
  set DEVview=nil;
  0;;