}

            while (tc.kind() == TCKind.tk_alias) {
                // writeElementAlias(w,a,tc,order);
                tc = tc.content_type();
            }

            switch (tc.kind().value()) {

            case TCKind._tk_void:
                // nothing to do, it is any's sub node
                break;
            case TCKind._tk_short:
                currentType.setValueToTree("" + a.create_input_stream().read_short());
                break;
            case TCKind._tk_long:
                currentType.setValueToTree("" + a.create_input_stream().read_long());
                break;
            case TCKind._tk_ushort:
                currentType.setValueToTree("" + a.create_input_stream().read_ushort());
                break;
            case TCKind._tk_ulong:
                currentType.setValueToTree("" + a.create_input_stream().read_ulong());
                break;
            case TCKind._tk_float:
                currentType.setValueToTree("" + a.create_input_stream().read_float());
                break;
            case TCKind._tk_double:
                currentType.setValueToTree("" + a.create_input_stream().read_double());
                break;
            case TCKind._tk_boolean:
                currentType.setValueToTree("" + a.create_input_stream().read_boolean());
                break;
            case TCKind._tk_char:
                currentType.setValueToTree("" + a.create_input_stream().read_char());
                break;
            case TCKind._tk_octet:
                currentType.setValueToTree("" + a.create_input_stream().read_octet());
                break;
            case TCKind._tk_any: {
                // TODO:
                Any tmp = a.extract_any();
                String s = getAnyDisplayName(tmp, currentType);
                currentType.setValueToTree(s);
                writeElementFromAny((MNQMutableTreeNode) currentMtn.getFirstChild(), tmp, tmp
                        .type(), tree);
                break;
            }
            case TCKind._tk_objref: {
                org.omg.CORBA.Object obj = a.create_input_stream().read_Object();
                if (obj == null)
                    currentType.setValueToTree("null");
                else
                    currentType.setValueToTree(CorbaFacility.orb.object_to_string(obj));
                break;
            }
            case TCKind._tk_struct: {

                DynStruct dynstruct = (DynStruct) getDAF().create_dyn_any(a);
                org.omg.DynamicAny.NameValuePair[] members = dynstruct.get_members();
                for (int i = 0; i < members.length; i++) {
                    writeElementFromAny((MNQMutableTreeNode) currentMtn.getChildAt(i),
                            members[i].value, members[i].value.type(), tree);
                }
                break;
            }
            case TCKind._tk_union: {
                DynUnion dynunion = (DynUnion) getDAF().create_dyn_any(a);
                try {
                    Any aa = dynunion.member().to_any();
                    String s = getDiscrimitorName(dynunion.get_discriminator(), dynunion
                            .discriminator_kind());
                    System.out.println("xxxxxx=" + s);
                    currentType.setValueToTree(s);
                    // only one child or no child
                    if (!currentMtn.isLeaf()) {
                        writeElementFromAny((MNQMutableTreeNode) currentMtn.getFirstChild(), aa, aa
                                .type(), tree);
                    }
                } catch (InvalidValue e) {
                    // i dont know which discrimiter means no active
                    // member,so try it one by one
                    String[] ss = currentType.getMutiValue();
                    for (int i = 0; i < ss.length; i++) {
                        if (currentMtn.isLeaf())
                            break;
                        currentType.setValueToTree(ss[i]);
                    }
                }
                break;
            }
            case TCKind._tk_enum:
                DynEnum dynEnum = (DynEnum) getDAF().create_dyn_any(a);
                currentType.setValueToTree(dynEnum.get_as_string());
                break;
            case TCKind._tk_string:
                currentType.setValueToTree(a.create_input_stream().read_string());
                break;
            case TCKind._tk_sequence: {
                currentMtn.removeAllChildren(true);
                DynSequence dynseq;

                dynseq = (DynSequence) getDAF().create_dyn_any(a);

                Any[] contents = dynseq.get_elements();
                CTSequence stSelected = (CTSequence) currentType;
                for (int i = 0; i < contents.length; i++) {
                    TypeBase n_sib = stSelected.t_in.cloneType();
                    MNQMutableTreeNode dMTN_sib = new MNQMutableTreeNode(n_sib);
                    stSelected.dmtn.add(dMTN_sib);
                    n_sib.dmtn = dMTN_sib;
                    ArgsCellEditor.createTreeCellEditorComponent(dMTN_sib, tree);
                    // System.out.println("add a element for
                    // sequence="+currentMtn.toString());
                    MNQmainFrame.buildParaSibling(dMTN_sib, n_sib, tree);
                    writeElementFromAny(dMTN_sib, contents[i], contents[i].type(), tree);
                }
                ((DefaultTreeModel) MNQmainFrame.paraTree.getModel()).reload(stSelected.dmtn);
                // expand the tree
                // for (int i = 0; i <
                // MNQmainFrame.paraTree.getRowCount(); i++) {
                // MNQmainFrame.paraTree.expandRow(i);
                // }
                break;
            }
            case TCKind._tk_array: {
                currentMtn.removeAllChildren(true);
                DynArray dynarray = (DynArray) getDAF().create_dyn_any(a);
                Any[] contents = dynarray.get_elements();
                CTArray stSelected = (CTArray) currentType;
                for (int i = 0; i < contents.length; i++) {
                    TypeBase n_sib = stSelected.t_in.cloneType();
                    MNQMutableTreeNode dMTN_sib = new MNQMutableTreeNode(n_sib);
                    stSelected.dmtn.add(dMTN_sib);
                    n_sib.dmtn = dMTN_sib;
                    ArgsCellEditor.createTreeCellEditorComponent(dMTN_sib, tree);
                    MNQmainFrame.buildParaSibling(dMTN_sib, n_sib, tree);
                    writeElementFromAny(dMTN_sib, contents[i], contents[i].type(), tree);
                }
                ((DefaultTreeModel) MNQmainFrame.paraTree.getModel()).reload(stSelected.dmtn);
                // expand the tree
                // for (int i = 0; i <
                // MNQmainFrame.paraTree.getRowCount(); i++) {
                // MNQmainFrame.paraTree.expandRow(i);
                // }
                break;
            }
            case TCKind._tk_except: {
                // ExceptList->someExcept->someMember
                String s = getAnyDisplayName(a, currentType);

                currentType.setValueToTree(s);

                DynStruct dynstruct = (DynStruct) getDAF().create_dyn_any(a);
                org.omg.DynamicAny.NameValuePair[] members = dynstruct.get_members();
                MNQMutableTreeNode sub = (MNQMutableTreeNode) currentMtn.getFirstChild();
                for (int i = 0; i < members.length; i++) {
                    writeElementFromAny((MNQMutableTreeNode) sub.getChildAt(i), members[i].value,
                            members[i].value.type(), tree);
                }
                ((DefaultTreeModel) MNQmainFrame.paraTree.getModel()).reload(currentMtn);
                break;
            }
            case TCKind._tk_longlong:
                currentType.setValueToTree("" + a.create_input_stream().read_longlong());
                break;
            case TCKind._tk_ulonglong:
                currentType.setValueToTree("" + a.create_input_stream().read_ulonglong());
                break;
            case TCKind._tk_longdouble:
                currentType.setValueToTree("" + a.create_input_stream().read_double());
                break;
            case TCKind._tk_wchar:
                currentType.setValueToTree("" + a.create_input_stream().read_wchar());
                break;
            case TCKind._tk_wstring:
                currentType.setValueToTree("" + a.create_input_stream().read_wstring());
                break;
            // following not support yet
            case TCKind._tk_null:
            case TCKind._tk_fixed:
            case TCKind._tk_value:
            case TCKind._tk_value_box:
            case TCKind._tk_native:
            case TCKind._tk_abstract_interface:
            case TCKind._tk_TypeCode:
            case TCKind._tk_Principal:
            default:
                System.out.println("cannot save to type to tree,type=" + tc.kind().toString());
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static List anyToObject(final org.omg.CORBA.Any any, OpWriter w, int col, int lin) {
        List ret = new Vector();
        TCKind tck = any.type().kind();

        String id;
        try {
            TypeBase tb;
            id = any.type().id();
            // e.g. IDL:3gppsa5.org/AlarmIRPConstDefs/DN:1.0
            id = id.substring(4, id.length() - 4);
            id = id.replaceAll("/", "::");
            id = "::" + id;

            Object node;

            do {
                node = Warehouse.cname2node.get(id.replaceAll("::_", "::"));
                if (node != null)
                    break;
                if (id.equalsIgnoreCase(""))
                    break;
                id = id.substring(2);
                id = id.substring(id.indexOf("::"));
            } while (true);

            if (node != null) {
                if (node instanceof IdlType) {
                    w.writeNextParXXX(col, lin, id);
                    lin++;
                    tb = ((IdlType) node).toType();
                    ret.add(tb.extract(any));
                    ret.add(new Integer(lin));
                    return ret;
                } else if (node instanceof IdlInterface) {
                    w.writeNextParXXX(col, lin, id);
                    lin++;
                    tb = ((IdlInterface) node).toType();
                    ret.add(tb.extract(any));
                    ret.add(new Integer(lin));
                    return ret;
                } else {
                    // try the primitive
                }
            }
        } catch (BadKind e) {
            // primitive
        } catch (Exception e) {
            // try the primitive
        }

        if (tck.value() == org.omg.CORBA.TCKind.tk_float.value()) {
            w.writeNextParXXX(col, lin++, "tk_float");
            ret.add(new java.lang.Float(any.create_input_stream().read_float()));
        }
        if (tck.value() == org.omg.CORBA.TCKind.tk_double.value()) {
            w.writeNextParXXX(col, lin++, "tk_double");
            ret.add(new java.lang.Double(any.create_input_stream().read_double()));
        }
        if (tck.value() == org.omg.CORBA.TCKind.tk_longdouble.value()) {
            w.writeNextParXXX(col, lin++, "tk_longdouble");
            ret.add(new java.lang.Double(any.create_input_stream().read_double()));
        }
        if (tck.value() == org.omg.CORBA.TCKind.tk_short.value()) {
            w.writeNextParXXX(col, lin++, "tk_short");
            ret.add(new java.lang.Short(any.create_input_stream().read_short()));
        }
        if (tck.value() == org.omg.CORBA.TCKind.tk_long.value()) {
            w.writeNextParXXX(col, lin++, "tk_long");
            ret.add(new java.lang.Integer(any.create_input_stream().read_long()));
        }
        if (tck.value() == org.omg.CORBA.TCKind.tk_longlong.value()) {
            w.writeNextParXXX(col, lin++, "tk_longlong");
            ret.add(new java.lang.Long(any.create_input_stream().read_longlong()));
        }
        if (tck.value() == org.omg.CORBA.TCKind.tk_ushort.value()) {
            w.writeNextParXXX(col, lin++, "tk_ushort");
            ret.add(new java.lang.Short(any.create_input_stream().read_ushort()));
        }
        if (tck.value() == org.omg.CORBA.TCKind.tk_ulong.value()) {
            w.writeNextParXXX(col, lin++, "tk_ulong");
            ret.add(new java.lang.Integer(any.create_input_stream().read_ulong()));
        }
        if (tck.value() == org.omg.CORBA.TCKind.tk_ulonglong.value()) {
            w.writeNextParXXX(col, lin++, "tk_ulonglong");
            ret.add(new java.lang.Long(any.create_input_stream().read_ulonglong()));
        }
        if (tck.value() == org.omg.CORBA.TCKind.tk_char.value()) {
            w.writeNextParXXX(col, lin++, "tk_char");
            ret.add(new java.lang.Character(any.create_input_stream().read_char()));
        }
        if (tck.value() == org.omg.CORBA.TCKind.tk_wchar.value()) {
            w.writeNextParXXX(col, lin++, "tk_wchar");
            ret.add(new java.lang.Character(any.create_input_stream().read_wchar()));
        }
        if (tck.value() == org.omg.CORBA.TCKind.tk_boolean.value()) {
            w.writeNextParXXX(col, lin++, "tk_boolean");
            ret.add(new java.lang.Boolean(any.create_input_stream().read_boolean()));
        }
        if (tck.value() == org.omg.CORBA.TCKind.tk_octet.value()) {
            w.writeNextParXXX(col, lin++, "tk_octet");
            ret.add(new java.lang.Byte(any.create_input_stream().read_octet()));
        }
        if (tck.value() == org.omg.CORBA.TCKind.tk_any.value()) {
            w.writeNextParXXX(col, lin++, "tk_any");
            ret.add(any.create_input_stream().read_any());
        }
        if (tck.value() == org.omg.CORBA.TCKind.tk_void.value()) {
            w.writeNextParXXX(col, lin++, "tk_void");
            // nothing to do TODO check later whether it's useful
            ret.add(null);
        }
        if (tck.value() == org.omg.CORBA.TCKind.tk_string.value()) {
            w.writeNextParXXX(col, lin++, "tk_string");
            ret.add(any.create_input_stream().read_string());
        }
        if (tck.value() == org.omg.CORBA.TCKind.tk_wstring.value()) {
            w.writeNextParXXX(col, lin++, "tk_wstring");
            ret.add(any.create_input_stream().read_wstring());
        }

        ret.add(new Integer(lin));

        return ret;
    }
}