root/BH13SPARQLBuilder/src/hozo/maptool/MapFactory.java @ 35

package hozo.maptool;


import java.awt.Color;
import java.awt.Font;
import java.io.File;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.List;
import java.util.Vector;

import javax.swing.JOptionPane;

import hozo.sparql.gui.SparqlBuilderPanel;

import org.biohackathon.SPARQLBuilder.OWL.ClassLink;
import org.biohackathon.SPARQLBuilder.OWL.Direction;
import org.biohackathon.SPARQLBuilder.OWL.Path;

/***縲€2008/10/18縲€#kozaki
縲€MAP逕滓�縺ｮ縺溘ａ縺ｫ�梧ｳ暮€繧ОWL縺ｮAPI縺九ｉ�後�繝��逕ｨ縺ｮ繝��繧ｿ繧剃ｽ懈�縺吶ｋ縺溘ａ縺ｮ
縲€繝｡繧ｽ繝�ラ鬘槭ｒ縺薙�繧ｯ繝ｩ繧ｹ縺ｫ縺ｾ縺ｨ繧√ｋ��

***/
public class MapFactory implements Runnable{

        ExtendBP exbp;
        public ExtendFrame exbpframe;
        Vector focal_points;//譛€蛻昴↓驕ｸ謚槭＠縺櫻ode(縺ｪ縺ｩ)繧剃ｿ晄戟縺吶ｋ
        boolean isSubLung;
        static boolean isGrayView=false;
        Vector<String> checked_nodes;
        boolean search_shortest=true;//繧ｵ繝ｼ繝√ヱ繧ｹ縺ｧ譛€遏ｭ繝代せ繧呈､懃ｴ｢縺吶ｋ
        int serch_depth = 10;//繧ｵ繝ｼ繝√ヱ繧ｹ縺ｧ譛€遏ｭ繝代せ繧呈､懃ｴ｢縺吶ｋ豺ｱ縺包ｼ域怙遏ｭ繝代せ讀懃ｴ｢繧偵＠縺ｪ縺�→縺阪�蠢�★菴ｿ縺�ｼ�
        Vector<ExbpNodeTemp> temp_nodes;
        
        SparqlBuilderPanel spBuilder;
        
        public static void main (String[] args) {
                MapFactory map = new MapFactory();
                //map.loadPathList(map.getDummyPathList());
        }
        
        public List<Path> getDummyPathList(){
                ArrayList pathlist = new ArrayList();
//              ArrayList class_link_list = new ArrayList<ClassLink>() {{
//                      add(new ClassLink("propertyURI", "linkedClassURI2", Direction.forward));
//                      add(new ClassLink("propertyURI2", "linkedClassURI3", Direction.forward));
//                      add(new ClassLink("propertyURI3", "linkedClassURI4", Direction.forward));
//                  }};
//              Path path = new Path("StartClass1", class_link_list);
//              pathlist.add(path);
//              
                return pathlist; 
        }
        
        public void setSPARQLbuilder(SparqlBuilderPanel builder){
                this.spBuilder = builder;
        }
        
//      void setSPARQLquery(Path path){
//              this.spBuilder;
//      }
        
        public MapFactory() {
                exbpframe = new ExtendFrame(this);
                exbp = exbpframe.getExtendBP();
                focal_points = new Vector<Object>();
                temp_nodes = new Vector<ExbpNodeTemp>();
                
//              focal_points.add("TEST");
//              focal_points.add("TEST2");
                
//              isSubLung=hze.isSubLang;
//              isGrayView=hze.isGrayView;//#kozaki 2009/07/28
//              exbp.setHZEditor(hze);
//              exbpframe.select_dialog = new EtendBPSelectDialog(exbp,exbpframe);
                exbpframe.setVisible(true);
        exbpframe.RefreshExbp();
        
//      if(focal_points.size()==1){
//              exbp.cmd_dialog.setCommandOptions(exbp.exbp_node_center);
//      }
//      
//      treeSelectDialog = new TreeSelectDialog(true);
//          treeSelectDialog.setHZEditor(this.hzEditor);
//          treeSelectDialog.setSubLang(this.isSubLung);
//          treeSelectDialog.setSize(450, 600);
//          
                }
        
        public void loadPathList(Path[] pathlist){
                if(pathlist.length==0){
                        JOptionPane.showMessageDialog(null, "NO PATH!!");
                        return;
                }
                Path path = pathlist[0];
                
                this.exbp.exbp_node_center = new ExbpNode(getTempLabel(path.getStartClass()));

                for(int i = 0; i<pathlist.length; i++){
                        addPath(pathlist[i]);
                }
                this.exbpframe.RefreshExbp();
//              this.exbp.exbp_node_center = exbpnode;
//              exbpnode= new ExbpNode("Center");;
//              exbpnode.setChildrenColor(Color.red);
//              exbpnode.key="prop1";
//              this.exbp_node_center.addChild(exbpnode);
//              this.exbp_node_center.addChild(new ExbpNode("TEST2"));
//              this.exbp_node_center.addChild(new ExbpNode("TEST3"));
//              this.exbp_node_center.addChild(new ExbpNode("TEST4"));
                
                
        }

        
        
        void addPath(Path path){
                System.out.println("addPath"+path.getStartClass()+"--->"+path.getClassLinks().size());
                String target_class = path.getStartClass();
//              ExbpNode node = this.exbp.findExbpNode(target_class);
                ExbpNode node = this.exbp.exbp_node_center;
        
                
                List<ClassLink> links = path.getClassLinks();
                for(ClassLink link : links){
                        String next_class = link.getLinkedClassURI();
                        System.out.println("==>"+next_class);
                        /*
                        String next_class_lbl ="";
                        int index = next_class.lastIndexOf("/"); 
                        if(index>0 && index<next_class.length()){
                                next_class_lbl = next_class.substring(index+1);
                        }
                        else{
                                next_class_lbl = next_class;
                        }
                        
                        int index2 = next_class_lbl.lastIndexOf("#"); 
                        if(index2>0 && index2<next_class_lbl.length()){
                                next_class_lbl = next_class_lbl.substring(index2+1);
                        }

                        */
                        ExbpNode next_node = new ExbpNode(getTempLabel(next_class));
                        next_node.setOrgNode(path);

                        node.addChild(next_node);
                        node = next_node;
                        String prop = link.getPropertyURI();
                        
                        if(link.getDirection().equals(Direction.reverse)){
                                prop += "[<=]";
                        }
                        else if(link.getDirection().equals(Direction.both)){
                                prop += "[<=>]";
                        }
                        next_node.key = prop;                   
                }
                        
                
        }

        
        String getTempLabel(String next_class){
                String next_class_lbl ="";
                int index = next_class.lastIndexOf("/"); 
                if(index>0 && index<next_class.length()){
                        next_class_lbl = next_class.substring(index+1);
                }
                else{
                        next_class_lbl = next_class;
                }
                
                int index2 = next_class_lbl.lastIndexOf("#"); 
                if(index2>0 && index2<next_class_lbl.length()){
                        next_class_lbl = next_class_lbl.substring(index2+1);
                }
                
                return next_class_lbl;
        }
        
        //蜈�→縺ｪ繧畿ditor遲峨〒MapTool繧堤ｮ｡逅�＠縺ｦ縺�ｋVector繧定ｿ斐☆縲食ozo莉･螟悶〒縺ｯ繧ｪ繝ｼ繝舌�繝ｩ繧､繝峨☆繧九€�
        Vector getMapVec(){
                return null;    
        }
        
        //蜈�→縺ｪ繧九が繝ｳ繝医Ο繧ｸ繝ｼ縺ｮ繝輔ぃ繧､繝ｫ繧定ｿ斐☆縲食ozo莉･螟悶〒縺ｯ繧ｪ繝ｼ繝舌�繝ｩ繧､繝峨☆繧九€�
        File getFile(){
                return null;    
        }
        
        //縺吶∋縺ｦ縺ｮ繝ｭ繝ｼ繝ｫ縺ｮ荳€隕ｧ繧定ｿ斐☆
        Vector getRoleList(){
                Vector roles = new Vector();
/*              Enumeration en = this.hzEditor.WCEditor.browsingPanel.node_lists.elements();
                while(en.hasMoreElements()){
                        Node n =(Node)en.nextElement();
                        Enumeration slot_en = n.getSlots().elements();
                        while(slot_en.hasMoreElements()){
                                Slot slot =(Slot)slot_en.nextElement();
                                if(!roles.contains(slot.getRoleName())){
                                        roles.addElement(slot.getRoleName());
                                }
                        }
                }
                        */
                return roles;
        }

        //蜈�→縺ｪ繧九が繝ｳ繝医Ο繧ｸ繝ｼ縺ｧ縺ｮ驕ｸ謚橸ｼ医け繝ｪ繝�け�牙�逅�€食ozo莉･螟悶〒縺ｯ繧ｪ繝ｼ繝舌�繝ｩ繧､繝峨☆繧九€�
        void selected(ExbpNode exbpnode){
//              this.hzEditor.WCEditor.browsingPanel.Jump(exbpnode.getHozoNode());      
        }

        //蜈�→縺ｪ繧九が繝ｳ繝医Ο繧ｸ繝ｼ縺ｧ縺ｮ驕ｸ謚橸ｼ医け繝ｪ繝�け�牙�逅�€食ozo莉･螟悶〒縺ｯ繧ｪ繝ｼ繝舌�繝ｩ繧､繝峨☆繧九€�
        void selectedClear(){
//              this.hzEditor.WCEditor.definitionPanel.uncursel();
//              this.hzEditor.WCEditor.browsingPanel.pick(null, false);
        }
        //Open縺励◆MAP縺ｨ繧ｪ繝ｳ繝医Ο繧ｸ繝ｼ縺ｮ蜈�ョ繝ｼ繧ｿ縺ｮ蟇ｾ蠢懊▼縺�
        void setOrgNodes(){
                /*
                if (this.hzEditor==null) {
                        System.out.println("ERROR!!:::HzEditor is NOT FOUND!");
                        return;
                }
                
                Enumeration en =exbp.nodes.elements();
                while(en.hasMoreElements()){
                        ExbpNode node =(ExbpNode)en.nextElement();
                        String lbl = node.getLabel();
                        Node org_node;
                        if(lbl.endsWith("[RH]")){
                                lbl=lbl.substring(0,lbl.indexOf("[RH]"));
                                //System.out.println(node.getLabel()+"====>"+lbl);
                                if(this.isSubLung){
                                        org_node = this.hzEditor.WCEditor.findNodeWithSubLang(lbl);
                                }
                                else{
                                        org_node = this.hzEditor.findRH(lbl);
                                }
                        }
                        else{
                                if(this.isSubLung){
                                        org_node = this.hzEditor.WCEditor.findNodeWithSubLang(lbl);
                                }
                                else{
                                        org_node = this.hzEditor.findNode(lbl);
                                }
                        }
                        node.setOrgNode(org_node);
                        if(org_node!=null){
                                //System.out.println("setOrgNodes:::"+lbl+"<=>"+org_node.getLabel());
                        }else{
                                //System.out.println("setOrgNodes:::"+lbl+"<=>NOT FOUND!");
                        }
                }
                        */
        }
        
        //蜈�→縺ｪ繧軌bject縺九ｉFocalPoint縺ｨ縺ｪ繧畿xbpNode繧剃ｽ懊ｋ縲食ozo莉･螟悶〒縺ｯ繧ｪ繝ｼ繝舌�繝ｩ繧､繝峨☆繧九€�
        ExbpNode[] setFocalPoints(){
//              if (this.hzEditor==null) return null;
                
                ExbpNode[] exbpnodes = null;

                exbp.nodes.removeAllElements();
                
//              Vector<Node> chi_nodes;         
//              GraphicObject gobj=null;
//              Object ob=null;

                if (focal_points.size() == 1) {//�代▽縺ｮNode繧帝∈謚槭＠縺滄圀縺ｮ蜃ｦ逅�
                        Object gobj = focal_points.firstElement(); 
            //gobj =(GraphicObject) focal_points.firstElement(); 
            
                        if(gobj instanceof String){
                                exbp.exbp_node_center =new ExbpNode((String)gobj);
                                exbp.exbp_node_center.setOrgNode(gobj);
                                exbp.nodes.add(exbp.exbp_node_center);
                                exbpnodes = new ExbpNode[1];
                                exbpnodes[0]=exbp.exbp_node_center;
                        }
                        else if(gobj instanceof Object){
                                System.out.println("*** ERROR:Node繧帝∈謚槭☆繧句ｿ�ｦ√′縺ゅｊ縺ｾ縺�:" );
                        }
                        else{//驕ｸ謚槭↑縺励�蝣ｴ蜷医��後お繝ｩ繝ｼ繧貞�縺励※邨ゆｺ�
                                
                                JOptionPane.showMessageDialog(exbpframe, 
                                                "You Have to select [Node]!",
                                                "ERROR",
                                                JOptionPane.ERROR_MESSAGE);
                                System.out.println("ERROR:Node繧帝∈謚槭☆繧句ｿ�ｦ√′縺ゅｊ縺ｾ縺�:" );
                                exbpframe.dispose();
                        }                               
                }
        else {//隍�焚Node繧帝∈謚槭＠縺滄圀縺ｮ蜃ｦ逅�
                        if(focal_points.size() > 1){
                    exbp.exbp_node_center = new ExbpNode("(ROOT)");
                    exbp.nodes.addElement(exbp.exbp_node_center);

                    Vector chi_nodes = new Vector();
                                Enumeration node_en = focal_points.elements();
                    while(node_en.hasMoreElements()){
                                        Object gobj2 = node_en.nextElement();
                                        if(gobj2 instanceof String){
                                                ExbpNode chinode = new ExbpNode((String)gobj2);
                                                chinode.setOrgNode(gobj2);
                                                exbp.exbp_node_center.addChild(chinode);
                                                exbp.nodes.add(chinode);
                                        }
                                        
                                        exbpnodes = new ExbpNode[exbp.exbp_node_center.children.size()];
                                        for(int i=0;i<exbp.exbp_node_center.children.size();i++){
                                                exbpnodes[i]=(ExbpNode)exbp.exbp_node_center.children.elementAt(i);
                                        }
                                }
                        }               
                else{//Node繧定ｦ矩∈謚槭�髫帙�蜃ｦ逅�
                        JOptionPane.showMessageDialog(exbpframe, 
                                        "You Have to select [Node]!",
                                        "ERROR",
                                        JOptionPane.ERROR_MESSAGE);
                        System.out.println("ERROR:Node繧帝∈謚槭☆繧句ｿ�ｦ√′縺ゅｊ縺ｾ縺�);
                        exbpframe.dispose();                    
                        }                       
       }
                
                return exbpnodes;
        }
        
        /*
        //蜈�→縺ｪ繧軌bject縺九ｉExbpNode繧剃ｽ懊ｋ縲食ozo莉･螟悶〒縺ｯ繧ｪ繝ｼ繝舌�繝ｩ繧､繝峨☆繧九€�
        ExbpNode makeExbpNode(Object obj){
                if(!(obj instanceof String)){
                        //System.out.println("ERROR@makeChildNodes():obj is NOT Node!");
                        return null;
                }
                
                Node node =(Node)obj;
                ExbpNode exbpnode;
                
                
                //#kozaki 2009/08/19縲€Slot縺ｮ蜃ｦ逅�ｒ霑ｽ蜉
                if(node instanceof hozo.oe.gobj.Slot){
                        if(!((Slot)node).getRHname().equals("")){
                                node = this.hzEditor.findRH(((Slot)node).getRHname());
                        }
                        else{
                                
                        }       
                }
                
                if(node instanceof hozo.oe.gobj.NodeRH){
                        if(this.isSubLung){
                                exbpnode= new ExbpNode(node.getSubLabel()+"[RH]");
                                }
                        else{
                                exbpnode= new ExbpNode(node.getLabel()+"[RH]");
                        }                       
                }
                else{
                        if(this.isSubLung){
                                exbpnode= new ExbpNode(node.getSubLabel());
                                }
                        else{
                                exbpnode= new ExbpNode(node.getLabel());
                        }                       
                }
                
                exbpnode.setOrgNode(obj);
                //exbp.nodes.add(exbpnode);
                
                return exbpnode;
        }*/
        
        
        //�代▽縺ｮExbpNode縺ｫ繧ｳ繝槭Φ繝峨ｒ驕ｩ蠢懊＠縺ｦ荳倶ｽ孔xbpNode繧定ｿｽ蜉縺吶ｋ縲食ozo莉･螟悶〒縺ｮ繧ｪ繝ｼ繝舌�繝ｩ繧､繝峨�蠢�ｦ√↑縺励€�
        //縲€繧ｳ繝槭Φ繝画ｯ弱↓繝｡繧ｽ繝�ラ繧偵が繝ｼ繝舌�繝ｩ繧､繝峨☆繧�
        void makeChildNodes(ExbpNode exbpnode, String command){
        /*      if(!(exbpnode.getOrgNode() instanceof Node)){
                        //System.out.println("ERROR@makeChildNodes():orgnode is NOT Node!");
                        return;
                }
                
//              exbpnode.children.removeAllElements();  
//              System.out.println("makeChildNodes():::command="+command);
                removeAllChildren(exbpnode);    
                
                        
                if(command.equals("isa")){ // ?縲€荳倶ｽ肴ｦょｿｵ縺ｮ謚ｽ蜃ｺ is-a
                        makeChildNodeISA(exbpnode);
                        }
                else if(command.equals("super")){// ?荳贋ｽ肴ｦょｿｵ縺ｮ謚ｽ蜃ｺ
                        makeChildNodeSuper(exbpnode);
                        }                       
                else if(command.startsWith(":")){// 蜿ら�蜈��謚ｽ蜃ｺ縲€Refereed to
                        makeChildNodeRefered(exbpnode,command);
                        }
                // #hirota 08/08/19 繧ｳ繝槭Φ繝臥ｵ仙粋
                else if(command.startsWith(";")){ // (old)繝ｭ繝ｼ繝ｫ謖�ｮ壹≠繧翫€€�九€€荳倶ｽ肴ｦょｿｵ謖�ｮ壹≠繧�
                        makeChildNodeRoleSub(exbpnode,command);
                        }
                else if(command.equals("any-h")){ // ? depend-on 竊� #hirota 11/26  迴ｾ蝨ｨ縺ｮ隕也せ縺君ode縺ｮ縺ｨ縺阪€¨ode縺ｮ繧ｹ繝ｭ繝�ヨ縺ｮRH繧定｡ｨ遉ｺ
                        makeChildNodeDependOnRH(exbpnode,command); 
                        }
                else if(command.equals("++s")){// ?縲€depend on 縲€竊舌さ繝ｳ繝�く繧ｹ繝医ｒ蜿悶ｊ蜃ｺ縺�
                        makeChildNodeDependOnContext(exbpnode,command);         
                        }
                else if(command.equals("++P")){//  playable 髢｢菫�?縲€竊�all
                        makeChildNodePlayable(exbpnode);
                }
                else if(command.startsWith("++p")){// playable 髢｢菫�?縲€竊�label 謖�ｮ�
                        makeChildNodePlayableByLabel(exbpnode, command);
                        }
                else if(command.equals("++c")){ // ?縲€playable 竊�繝励Ξ繧､繝､繝ｼ縺ｮ蜿悶ｊ蜃ｺ縺�
                        makeChildNodePlayer(exbpnode);
                        }
                else if(command.startsWith("++r:")){// ?髢｢菫よｦょｿｵ縺ｮ蜿悶ｊ蜃ｺ縺� ++r:Lable 
                        makeChildNodeRelationConcept(exbpnode,command); 
                }
                else if(command.equals("++R")){ // ++R  蜈ｨ驛ｨ蜿悶ｊ蜃ｺ縺�
                        makeChildNodeRelationAll(exbpnode);
                        }       
                else if(command.startsWith("super_isa")){ // #hirota 08/09/03 蜈�ｼ滓ｦょｿｵ縺ｮ蜿悶ｊ蜃ｺ縺�super+isa)
                        makeChildNodeBrothers(exbpnode);
                        }
                else if(command.startsWith("_")){//             繧ｯ繝ｩ繧ｹ蛻ｶ邏�ｒ霎ｿ繧句�逅�€€only RH
                        makeChildNodeCConlyRH(exbpnode,command);
                        }
                else{
                        makeChildNodeReferringTo(exbpnode,command);// 繧ｯ繝ｩ繧ｹ蛻ｶ邏�ｒ霎ｿ繧句�逅�
                        }
                        */
                }
        
        public void run(){
                //SerachPath(target_nodes,target_cls); 
        }
        
        public void stop(){
//              pbar_frame.stop();
//              pbar_frame=null;                        
        }
        
        ExbpNode[] target_nodes;
//      Node[] target_cls;
        int[] match_num;
//      ProgressFrame pbar_frame;
        
/*      
        public void SearchPathAsThread(ExbpNode[] nodes, Node[] cls){
                pbar_frame = new ProgressFrame("Serach Path","Now,Searching..., Please wait.");
                pbar_frame.frame.setAlwaysOnTop(true);
                pbar_frame.frame.setLocation(exbp.cmd_dialog.getWidth(),100);
                
                
                target_nodes = nodes;
                target_cls =cls;
                match_num = new int[cls.length];
                for(int i=0;i<match_num.length;i++){
                        match_num[i]=0;
                }
                
                Thread thread = new Thread(this);
                thread.start(); 
                

        }*/
        /*
        
        void checkMatchCount(){
                match_num = new int[target_cls.length];
                for(int i=0;i<match_num.length;i++){
                        match_num[i]=0;
                }
                
                Enumeration en = this.exbp.nodes.elements();
                while(en.hasMoreElements()){
                        ExbpNode node = (ExbpNode)en.nextElement();
                        Object obj = node.getOrgNode();
                        if(obj instanceof Node){
                                Node hozonode=(Node)obj;
                                for(int i=0;i<target_cls.length;i++){
                                        if(target_cls[i] instanceof Node){
                                                if(hozonode.isSubclassOf((Node)target_cls[i])
                                                                || hozonode.equals(target_cls[i])){
                                                        match_num[i]++;
                                                }
                                        }
                                }
                        }
                }
                
                for(int i=0;i<target_cls.length;i++){
                        System.out.println(
                                        target_cls[i].getLabel()+" = "+
                                        match_num[i]);
                }
        }
        */
        
        //#kozaki縲€2009/02/13縲€蟇ｾ雎｡繝弱�繝峨ｒ隍�焚縺ｫ諡｡蠑ｵ      
//      public void SerachPath(ExbpNode[] nodes, Node[] target_cls/*String[] cls_lists*/){}

//      private Vector<ExbpNode> SerachPath(Vector<ExbpNode> nodes,
//                      Node[] cls_lists,Vector<ExbpNode> match_nodes){}
        
        void removeAllChildren(ExbpNode exbpnode){
                this.exbp.nodes.removeAll(exbpnode.children);
                exbpnode.children.removeAllElements();  
        }

        //谺｡縺ｫ縺溘←繧九ヮ繝ｼ繝峨�繝ｪ繧ｹ繝医ｒ蜿門ｾ励☆繧�
        //窶ｻ荳€蠎ｦ縺溘←縺｣縺溘％縺ｨ縺ｮ縺ゅｋ繝��繧ｿ縺ｯ�荊emp_nodes縺ｫ菫晄戟縺輔ｌ�後◎縺｡繧峨ｒ霑斐☆
//      Vector<ExbpNode> getChildNodeFromTemp(ExbpNode exbpnode, String cmd){}

        
        void explore(ExbpNode exbpnode, boolean all, String cmd){
        /*      ExbpNode[] exbpnodes=new ExbpNode[1];
                
                if(!all){
                        exbpnodes=new ExbpNode[1];
                        exbpnodes[0]=exbpnode;
                }
                else{
                        int layer = exbpnode.getLocatedLayer();
                        exbpnodes=exbp.getExbpNodesAtLear(layer,true);
                }
                
                for(int l=0;l<exbpnodes.length;l++){
                        if(exbpnodes[l].visible){
                                this.makeChildNodeReferringToDirectly(exbpnodes[l], cmd);
                                this.makeChildNodeRefered(exbpnodes[l], ":Any");
                                
                                //exbpnodes[l].children.removeAllElements();
//                              Vector temp_children = getChildNodeFromTemp(exbpnodes[l],cmd);
//                              Enumeration en = temp_children.elements();
//                              while(en.hasMoreElements()){
//                                      ExbpNode chi = (ExbpNode)en.nextElement();
//                                      exbpnodes[l].addChild(chi);
//                                      chi.setVisible(true);
//                              }
                        }
                }*/
                
        }

        void clearSubPath(ExbpNode exbpnode){
                ExbpNode[] exbpnodes=new ExbpNode[1];
                
                int layer = exbpnode.getLocatedLayer();
                exbpnodes=exbp.getExbpNodesAtLear(layer,true);
                
                
                for(int l=0;l<exbpnodes.length;l++){
                        if(exbpnodes[l].visible){
                                this.removeAllChildren(exbpnodes[l]);
                        }
                }
                
        }

        
        //蜷�さ繝槭Φ繝峨ｒ驕ｩ逕ｨ縺励◆縺ｨ縺阪↓縺溘←繧九ヮ繝ｼ繝峨ｒ縺励ｉ縺ｹ縺ｦ�卦ree縺ｮ繧ｳ繝槭Φ繝峨Μ繧ｹ繝医↓蜈･繧後ｋ��
//      void setCommandsTree(ExbpNode[] exbpnodes){}
        
public void makeChildNodeSuper(ExbpNode exbpnode) {}


private void makeSlotRelatedExbpNode(ExbpNode exbpnode, String command) {}

//      #kozaki 2008/08/17縲€繧ｹ繝ｭ繝�ヨ縺ｧ髢｢騾｣縺励◆讎ょｿｵ繧定ｾｿ繧句�逅�∈縺ｮ蛻�ｲ�
//      private void makeSlotRelatedExbpNode(ExbpNode par_exbpnode, Node node, String command){}
        
        
        //#kozaki 2008/08/12縲€繧ｯ繝ｩ繧ｹ蛻ｶ邏�ｒ霎ｿ繧句�逅�ｒ迢ｬ遶�
//      private void makeExbpNodeCC(ExbpNode par_exbpnode,      //隕ｪ縺ｨ縺ｪ繧畿xbpNode
//                                                              Slot slot,                              //霎ｿ繧句ｯｾ雎｡縺ｨ縺ｪ繧九せ繝ｭ繝�ヨ
//                                                              Node slot_node,                 //繧ｯ繝ｩ繧ｹ蛻ｶ邏�→縺励※蜿ら�縺励※縺�ｋ繝弱�繝�
//                                                              Node node,                              //霎ｿ繧九せ繝ｭ繝�ヨ繧呈戟縺､繝弱�繝�
//                                                              String command,         //霎ｿ繧九さ繝槭Φ繝�
//                                                              String match_key                //荳€閾ｴ縺励◆繧ｳ繝槭Φ繝会ｼ井ｸ贋ｽ阪せ繝ｭ繝�ヨ縺ｮ蜃ｦ逅�畑��
//                                                              ){}
        
//      public void makeChildNodeISA(ExbpNode exbpnode){}

        
        // ?
//      private void makeChildNodeRefered(ExbpNode exbpnode, String command) {}

        //      ?窶�(old)繝ｭ繝ｼ繝ｫ謖�ｮ壹≠繧翫€€�九€€荳倶ｽ肴ｦょｿｵ謖�ｮ壹≠繧�
//      public void makeChildNodeRoleSub(ExbpNode exbpnode,String command) {}

        // ? depend-on 竊� #hirota 11/26  迴ｾ蝨ｨ縺ｮ隕也せ縺君ode縺ｮ縺ｨ縺阪€¨ode縺ｮ繧ｹ繝ｭ繝�ヨ縺ｮRH繧定｡ｨ遉ｺ
//      public void makeChildNodeDependOnRH(ExbpNode exbpnode,String NodeCC) {}
        
        
        
        // ?縲€depend on 縲€竊舌さ繝ｳ繝�く繧ｹ繝医ｒ蜿悶ｊ蜃ｺ縺�#hirota add 09/11/09
//      public void makeChildNodeDependOnContext(ExbpNode exbpnode,String command) {}
        
//  playable 髢｢菫�?縲€竊�all
//      public void makeChildNodePlayable(ExbpNode exbpnode) {}

        // playable 髢｢菫�?縲€竊�label 謖�ｮ�
//      private void makeChildNodePlayableByLabel(ExbpNode exbpnode,String command) {}

         // ?縲€playable 竊�繝励Ξ繧､繝､繝ｼ縺ｮ蜿悶ｊ蜃ｺ縺�
//      public void makeChildNodePlayer(ExbpNode exbpnode) {}   
//      private void makeChildNodeRelationConcept(ExbpNode exbpnode,String command) {}  
        
//       ++R  蜈ｨ驛ｨ蜿悶ｊ蜃ｺ縺�邯呎価繧ｪ繝励す繝ｧ繝ｳ縺ゅｊ縺ｮ縺ｨ縺搾ｼ�
//      public void makeChildNodeRelationAllToDirectry(ExbpNode exbpnode) {}
        // ++R  蜈ｨ驛ｨ蜿悶ｊ蜃ｺ縺�
//      public void makeChildNodeRelationAll(ExbpNode exbpnode) {}      
        
        // #hirota 08/09/03 蜈�ｼ滓ｦょｿｵ縺ｮ蜿悶ｊ蜃ｺ縺�super+isa)
//      private void makeChildNodeBrothers(ExbpNode exbpnode) {}        
        
        //      繧ｯ繝ｩ繧ｹ蛻ｶ邏�ｒ霎ｿ繧句�逅�€€only RH
//      private void makeChildNodeCConlyRH(ExbpNode exbpnode,String command) {} 
        
        //      繧ｯ繝ｩ繧ｹ蛻ｶ邏�ｒ霎ｿ繧句�逅�€€
//      private void makeChildNodeReferringTo(ExbpNode exbpnode,String command) {}      

//      繧ｯ繝ｩ繧ｹ蛻ｶ邏�ｒ霎ｿ繧句�逅��繧ｵ繝悶せ繝ｭ繝�ヨ繧貞性縺ｾ縺ｪ縺�€€#kozaki縲€2009/08/19
//      private void makeChildNodeReferringToDirectly(ExbpNode exbpnode,String command) {}      

        
//      String[] getOtionLists(Vector<ExbpNode> exbpnodes){}
        
        
/*      public String[] getSelectedClass(String[] labels){
                TreeSelectDialog treeSelectDialog = new TreeSelectDialog(true);
            treeSelectDialog.setHZEditor(this.hzEditor);
            treeSelectDialog.setSubLang(this.isSubLung);
            treeSelectDialog.updateTree();
            //treeSelectDialog.setSize(320, 450);
            if(labels.length>0){
                        String label = labels[0];
                        for(int i=1;i<labels.length;i++){
                                label +=" "+"\\" + Slot.OR_DELIMITER+" "+labels[i];
                        }
                        treeSelectDialog.setSelectedTreeDialog(labels, label);
            }
            treeSelectDialog.setVisible(true);
        if (treeSelectDialog.isOK()) {
                String[] cls_lists = treeSelectDialog.getSelectedHozoNodesByLabel();
//              String opt = treeSelectDialog.getSelected();
//              if(opt==null){
//                              opt="Any";
//                      }
//              String[] cls_lists = opt.split(" "+"\\" + Slot.OR_DELIMITER+" ");
            return cls_lists;
        }
        return null;
        }*/
        
//      public Object[] getSelectedClasses(String target_cls){}
        
//      public Node[] getSelectedClassesAsNode(String target_cls){}

//      public Node getHozoNode(String lbl){}   
        
//      public boolean isSubClassOfSelectedClasses(Object node, Object[] target_classes){}
        
//      public boolean isSubClass(Object node, Object target){}

        //#kozaki 2009/02/13縲€Node[]繧担tring[]縺ｫ螟画鋤
//      public String[] NodesToStrings(Node[] nodes){}
        
        //#kozaki 2009/02/13縲€繧ｯ繝ｩ繧ｹ荳€隕ｧ繧誰ode[]縺ｧ蜿門ｾ�
//      public Node[] getSelectedClassNodes(Node[] nodes){}

        //#hirota 2009/05/18縲€髢｢菫よｦょｿｵ荳€隕ｧ繧誰ode[]縺ｧ蜿門ｾ�
//      public Node[] getSelectedClassNodes2(Node[] nodes){
//       return null;   
//      }
        
        //#kozaki 09/02/15
//      public void setSubLang(boolean b){}
        
}