minidhdms.pkg

Go to the documentation of this file.

// -- processed by [filterPKG] --
/*
-----------------------------------------------------------------------------
This source file is part of OpenSpace3D
For the latest info, see http://www.openspace3d.com

Copyright (c) 2009 I-maginer

This program is free software; you can redistribute it and/or modify it under
the terms of the GNU Lesser General Public License as published by the Free Software
Foundation; either version 2 of the License, or (at your option) any later
version.

This program is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with
this program; if not, write to the Free Software Foundation, Inc., 59 Temple
Place - Suite 330, Boston, MA 02111-1307, USA, or go to
http://www.gnu.org/copyleft/lesser.txt

You may alternatively use this source under the terms of a specific version of
the OpenSpace3D Unrestricted License provided you have obtained such a license from
I-maginer.
-----------------------------------------------------------------------------
*/

/* ********************************************************************************************* /
  DMS compatibility
/ ********************************************************************************************* */

typeof DMSdebug=fun [S] I;

struct InitialTag{
cbITag (fun [S [User r1]] I);modITag (DMI);timeoutITag (I);
};
typedef struct mkInitialTag InitialTag;
struct ServerTag{
idSTag (I);flagSTag (I);
};
typedef struct mkServerTag ServerTag;

typedef Tag=
  localTag InitialTag
 |serverTag ServerTag;;

typeof listSentTags=[TagToServer r1];
struct TagToServer{
baseTTS (Tag);idTTS (I);timeoutTTS (I);
};
typedef struct mkTagToServer TagToServer;


typedef Pending=
  actionPending [DMI S S S [User r1] Tag]
 |msgPending S
 |hookPending I;;

struct DMI{
numDMI (I);chnDMI (Chn);nameDMI (S);classDMI (S);stateDMI (I);
  sonsDMI ([DMI r1]);fatherDMI (DMI);
  linkDMI ([[S I S S S] r1]);
  eventsDMI ([S r1]);
  paramDMI (S);
  zonesDMI ([[S r1] r1]);
  beforecloseDMI (fun[] I);
  actionDMI (fun [DMI S S S] I); actionsDMI ([[S fun [DMI S S [User r1] Tag] I] r1]);
  fifoDMI ([[Pending r1] [Pending r1]]);
  
  controlDMI ([[S r1] r1]);controlbufDMI (S);listDMI ([RSC r1]);curDMI (RSC);

  ulistDMI ([UserI r1]);uclassDMI ([[DMI S] r1]);cbUcreateDMI (fun [UserI] I);

  locDMI (tab [[S S] r1]);langDMI (S);
  neededDMI ([S r1]);neededbufDMI (S);thmDMI ([[S r1] r1]
 );
};
typedef struct mkDMI DMI;

struct User{
idU (I);flagU (I);
};
typedef struct mkUser User;

struct VTree{
commutVT (I);rightsVT ([S r1]);
};
typedef struct mkVTree VTree;

typedef Visibility=
 treeVisibility VTree;;

struct UserI{
userUI (User);classUI (S);paramUI ([[S r1]r1]);locUI (DMI);
  cbDeleteUI (fun[UserI] I);cbCommUI (fun[UserI S S] I); msgUI ([[S fun[UserI S S] I] r1]);
  cbChgUI (fun[UserI I S] I);visiUI (Visibility);
  
  uclassUI (DMI);cbClassDeleteUI (fun[UserI] I);cbClassCommUI (fun[UserI S S] I
 );
};
typedef struct mkUserI UserI;


typeof this=DMI;

typeof DMSserver=Chn;

typeof DMSnbDmi=I;

typeof DMSdmi=[[I DMI] r1];

var DMIok=0;
var DMIwait=1;
var DMIoff=2;
var DMIhook=3;

/* communication constructors */
defcom Cgoto=goto S;; /* message to scol engine */
defcom Clang=lang S;; /* define client language */
defcom Center=enter I I S S S;; /* entering site : activeX, version, versionname, trace, enter */
defcom Cping=ping;;
defcom Csend=send I S;; /* send an intra-message */
defcom Cevent=event I S S S S I;; /* send an inter-message module event param rep ulist tag */
defcom CcliDel=cliDel I;; /* indicates that a client module destroyed itself */
defcom CsendUI=sendUI I I S S;; /* send message to a user instance : mod, ui, action, param */
defcom Cdeltag=deltag I;; /* a tag should be destroyed : id */
defcom Cfiretag=firetag I S S;; /* a tag should be fired : id, param, ulist */
defcom Chook=hook I I S I;; /* send a hook inactive message : numfrom, nummod, action, id */
defcom Cdestroyed=destroyed;; /* send a message to the activeX container */
defcom Clogin=login S;;

/* script constructors */
defcom SIniDMI=IniDMI S;;
defcom Sreg=reg I;;
defcom Sregch=regch;;
defcom Sload=_load S;;

/* proto */
proto _DMSgetByHandle=fun[I] DMI;
proto _on_=fun[u0 Comm] I;
proto _DMSrootModule=fun[] DMI;


/* ********************************************************************************************* /

/ ********************************************************************************************* */
niltest(a,b){
if a==nil then b else a;
}


Tunder(s){
if strcmp s "_" then s else nil;
}


swbystr(a,b){
let a->[x _] in !strcmp x b;
}


getSwitchStr(l,s){
search_in_list l @swbystr s;
}


/* hook inactive management */
typeof hookInactiveList=[[I [[S I] r1]] r1];
var newHookid=0;


_newHook(){
set newHookid=newHookid+1;
}


var tagnumber=0;
newtagnumber(){
set tagnumber=tagnumber+1;
}


conc(p,q){
if p==nil then q else (hd p)::conc tl p q;
}


/* return wether a string element is in a list */
strFindList(l,a){
if l==nil then 0 else let l->[x n] in
 if !strcmp a x then 1 else strFindList n a;
}


/* ulist management */
getUlist(l){
if l==nil then nil else let l->[u nxt] in
 (itoa u.idU)::getUlist nxt;
}


getUliststring(l){
if l==nil then nil
 else strbuild (getUlist l)::nil;
}


/* tag management */
sendServerTag(t){
if t==nil then nil else 
 match t with
  (localTag x -> let newtagnumber -> id in
   (set listSentTags=(mkTagToServer [t id x.timeoutITag])::listSentTags;
    id));
}


_DMStagKeepAlive(t){
match t with
  (serverTag x -> set x.flagSTag=1);
}


makeLocalTag(d,tag){
if tag==nil then nil
 else let tag->[cb timeout _] in localTag mkInitialTag [cb d time+timeout];
}


_on_(srv,msg){
_on DMSserver msg;
}


_DMSrootModule(){
switch DMSdmi 0;
}


_DMSgetByHandle(h){
switch DMSdmi h;
}


_DMSdefineActions(d,l){
set d.actionsDMI=conc l d.actionsDMI;
}


_DMSremoveActions(d,l){
if l==nil then 0
 else let getSwitchStr d.actionsDMI hd l -> x in
 (if x==nil then nil else set d.actionsDMI=remove_from_list d.actionsDMI x;
  _DMSremoveActions d tl l);
}


_DMSfindActionStartedByName(l, name){
let sizelist l -> size in
  let nil -> ndata in
  let 0 -> i in
  (
    while i < size do
    (
      let nth_list l i -> [action _ ] in
      if (strcmp name (substr action 0 (strlen name))) then nil else
        set ndata = conc ndata action::nil;
      
      set i = i + 1;
    );
    ndata;
  );
}


_DMSremoveActionStartedByName(d, name){
let _DMSfindActionStartedByName d.actionsDMI name -> l in
    _DMSremoveActions d l;
}


removeDmiById(id){
let sizelist DMSdmi -> size in
  let nil -> ndata in
  let 0 -> i in
  (
    while i < size do
    (
      let nth_list DMSdmi i -> elem in
      let elem -> [eid _] in
      if eid == id then nil else
        set ndata = conc ndata elem::nil;
      set i = i + 1;
    );
    set DMSdmi = ndata;
  );
  0;
}


addDmiById(id, d){
let switch DMSdmi id -> dd in
  if dd == nil then nil else
    removeDmiById id;
  
  set DMSdmi = conc DMSdmi [id d]::nil;
  d;
}


cbDebugConsol(mess){
_fooS strcat ">>>>>>>>>>>>>> Mini DHDMS debug > " mess;
  0;
}


createDMI(){
let switch DMSdmi 0 -> old in
  let mkDMI [0 _channel "root" "root" 0
    nil nil
    nil nil
    nil
    nil
    nil nil nil
    old.fifoDMI
    nil nil nil nil
    nil nil nil
    nil nil nil nil nil]
  ->d in
  (
    addDmiById 0 d;
    
    set DMSdebug = @cbDebugConsol;
    set this = _DMSrootModule;
    set DMSserver = _channel;
  );
}


/* fire events */
fireEvent2(d,args,k){
if d==nil then nil
 else if d.stateDMI!=DMIok || (k && d.fifoDMI!=nil) then
 (set d.fifoDMI=addFifo args d.fifoDMI;
  match args with (actionPending [_ _ _ _ _ tag] -> _DMStagKeepAlive tag);
  0)
 else
  match args with
  (actionPending [from act para repl ulist tag] ->
    (
      exec DMSdebug with [strcatn "Action : "::act::" with param : "::(if para == nil then "NIL" else para)::nil];
      if d.actionDMI==nil then execch d.chnDMI switchstr d.actionsDMI act [from act para ulist tag]
      else execch d.chnDMI d.actionDMI [from act para repl];
    )
  )    
 |(msgPending c -> _scriptc d.chnDMI strcat "__" c)
 |(_->nil);
}


fireEvent(i,args){
let _DMSgetByHandle i -> d in
 if d==nil then
  match args with
  (
    actionPending [from act _ _ _ tag] -> 
    
    if 0==switchstr (switch hookInactiveList i) act
    then let _newHook -> n in
    (
      set d=mkDMI [i nil nil nil DMIhook nil nil nil nil nil nil  nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil];      

      addDmiById i d;
      
      set d.fifoDMI=addFifo hookPending n d.fifoDMI;
      set d.fifoDMI=addFifo args d.fifoDMI;
      _on_ nil Chook [from.numDMI i act n];
      _DMStagKeepAlive tag;
      nil
    )
    else nil
  )
 else fireEvent2 d args 1;
}


DMSevent3(from,param,reply,ulist,tag,l,event){
if l==nil then 0
 else let l->[[ev num action param2 reply2] nxt] in
 (if strcmp ev event then nil
  else
  //$BB test if link param exist use in priority
  let if param2 == nil then param else param2 -> param in
  (
     exec DMSdebug with [strcatn "Event : "::ev::" with param : "::(if param == nil then "NIL" else param)::nil];
     fireEvent num actionPending [from action niltest param param2 niltest reply reply2 ulist tag];
  );
  DMSevent3 from param reply ulist tag nxt event);
}  


DMSevent2(d,ev,para,repl,ulist,tag){
if strFindList d.eventsDMI ev then _on_ nil Cevent [d.numDMI ev para repl getUliststring ulist sendServerTag tag] else nil;
    DMSevent3 d para repl ulist tag d.linkDMI ev;
}


_DMSevent(d,ev,para,repl){
DMSevent2 d ev para repl nil nil;
}


_DMSeventTag(d,ev,param,ulist,tag){
DMSevent2 d ev param nil ulist makeLocalTag d tag;
}


getModLinkByLink(event, action, param, reply){
let sizelist this.linkDMI -> size in
  let nil -> ndata in
  let 0 -> i in
  (
    while i < size && ndata == nil do
    (
      let nth_list this.linkDMI i -> link in
      let link -> [oevent onum oaction oparam oreply] in
      (
        if (!strcmp oevent event) && (onum == 0) && (!strcmp oaction action) && (!strcmp oparam param) then
          set ndata = link
        else nil;
      );
      set i = i + 1;
    );
    ndata;
  );
}


delModLink(slink){
let hd strextr slink -> [nevent [naction [nparam [nreply [ncond _]]]]] in
  let getModLinkByLink nevent naction (Tunder nparam) (Tunder nreply) -> link in
    set this.linkDMI = remove_from_list this.linkDMI link;
  0;
}


setModLink(oldlink, newlink){
let hd strextr oldlink -> [oevent [oaction [oparam [oreply [ocond _]]]]] in
  let hd strextr newlink -> [nevent [naction [nparam [nreply [ncond _]]]]] in
  let getModLinkByLink nevent naction (Tunder nparam) (Tunder nreply) -> existlink in
  if existlink != nil then
  (
    0;
  )
  else
  (
    if oldlink == nil then
    (
      //add link
      set this.linkDMI = conc this.linkDMI [nevent 0 naction (Tunder nparam) (Tunder nreply)]::nil;
      1;
    )
    else
    (
      let getModLinkByLink oevent oaction (Tunder oparam) (Tunder oreply) -> olink in
      (
        set this.linkDMI = remove_from_list this.linkDMI olink;
        set this.linkDMI = conc this.linkDMI [nevent 0 naction (Tunder nparam) (Tunder nreply)]::nil;
      );
      1;
    );
  );
}


clearModLinks(){
set this.linkDMI = nil;
  0;
}


/* ********************************************************************************************* /
  Empty functions for dhdms compatibility
/ ********************************************************************************************* */
UsendMessage(p1, p2, p3){
0;
}

piUi(p1){
0;
}

UcbMessage(p1, p2){
0;
}

UgetParam(p1, p2){
""::nil;
}

UsendSrv(d, ui, sid, params){
0;
}


UcbComm(d, ui, cbfun){
0;
}


listcat(p, q){
if p==nil then
    q
  else
    (hd p)::listcat (tl p) q;
}


/* ********************************************************************************************* /
  C3dx definitions
/ ********************************************************************************************* */
typeof s3dMainSession=V3Dsession;
typeof v3dMain=V3Dview;

struct C3DXdata{

  C3DX_channel (Chn);                                                 // channel
  C3DX_window (EdWindow);                                            // main window  
  C3DX_sName (S);                                                   // scene name and resources group name
  C3DX_sSceneFile (S);                                                   // current xml scene file
  C3DX_3dView (V3Dview);                                             // 3d View
  C3DX_3dScene (V3Dsession);                                          // main 3d session
  C3DX_3dLoader (V3Dsession);                                          // animated Loader view 3d session
  C3DX_lCursor ([[I ObjCursor] r1]);                                  // list of available cursors
  C3DX_bEditMode (I);                                                   // edition mode state  
  C3DX_lGroups ([[I C3DXgroup] r1]);                                  // group objects list [idx C3DXgroup]  
  C3DX_lUserInstance ([UserI r1]);                                          // user instance list
  C3DX_owner (UserI
  
  );
};
typedef struct mkC3DXdata C3DXdata;


struct C3DXgroup{

  C3DXGRP_iIndex (I);                                                  // index                                                   
  C3DXGRP_sXmlPath (S                                                   );// xml file
  
  
};
typedef struct mkC3DXgroup C3DXgroup;


struct C3DXeditor{

  C3DXE_win (EdWindow                                             );// dms zone
    
  
};
typedef struct mkC3DXeditor C3DXeditor;


typeof strC3DX=C3DXdata;

c3dXsession(){
s3dMainSession;
}
c3dXview(){
v3dMain;
}
c3dXwin(){
v3dMain.V3D_win;
}
DMSwin(){
v3dMain.V3D_win;
}

// -- [/filterPKG] --

---