activexcomponent.java

用java和windows的word应用的通用编程接口 关联起来

                argString += "=";
                if (argType == Variant.VariantDispatch){
                    Dispatch foo = (Dispatch)args[i].getDispatch();
                    argString+=foo;
                } else if ((argType & Variant.VariantBoolean) == 
                            Variant.VariantBoolean){
                    // do the boolean thing
                    if ((argType & Variant.VariantByref) ==
                            Variant.VariantByref){
                            // boolean by ref
                            argString += args[i].getBooleanRef();
                        } else {
                            // boolean by value
                            argString += args[i].getBoolean();
                        }
                } else if ((argType & Variant.VariantString) == 
                    Variant.VariantString){
                    // do the string thing
                    if ((argType & Variant.VariantByref) ==
                            Variant.VariantByref){
                            // string by ref
                            argString += args[i].getStringRef();
                        } else {
                            // string by value
                            argString += args[i].getString();
                        }
                } else {
                    argString+=args[i].toString();
                }
            }
            System.out.println(description +argString);
        }
    }
    
    /*==============================================================
     * 
     * covers for dispatch call methods
     *=============================================================*/

    /**
     * makes a dispatch call for the passed in action and no parameter
     * @param callAction
     * @return ActiveXComponent representing the results of the call
     */
    public ActiveXComponent invokeGetComponent(String callAction){
        return new ActiveXComponent(invoke(callAction).toDispatch());
    }
    
    /**
     * makes a dispatch call for the passed in action and single parameter
     * @param callAction
     * @param parameter
     * @return ActiveXComponent representing the results of the call
     */
    public ActiveXComponent invokeGetComponent(String callAction, 
            Variant parameter){
        return new ActiveXComponent(invoke(callAction, parameter).toDispatch());
    }
    
    /**
     * makes a dispatch call for the passed in action and single parameter
     * @param callAction
     * @param parameter1
     * @param parameter2
     * @return ActiveXComponent representing the results of the call
     */
    public ActiveXComponent invokeGetComponent(String callAction, 
            Variant parameter1, Variant parameter2){
        return new ActiveXComponent(invoke(callAction, 
                parameter1, parameter2).toDispatch());
    }
    
    /**
     * makes a dispatch call for the passed in action and single parameter
     * @param callAction
     * @param parameter1
     * @param parameter2
     * @param parameter3
     * @return ActiveXComponent representing the results of the call
     */
    public ActiveXComponent invokeGetComponent(String callAction, 
            Variant parameter1, 
            Variant parameter2, 
            Variant parameter3){
        return new ActiveXComponent(invoke(callAction, 
                parameter1, parameter2, parameter3).toDispatch());
    }
    
    /**
     * makes a dispatch call for the passed in action and single parameter
     * @param callAction
     * @param parameter1
     * @param parameter2
     * @param parameter3
     * @param parameter4
     * @return ActiveXComponent representing the results of the call
     */
    public ActiveXComponent invokeGetComponent(String callAction, 
            Variant parameter1, 
            Variant parameter2, 
            Variant parameter3,
            Variant parameter4){
        return new ActiveXComponent(invoke(callAction, 
                parameter1, parameter2, parameter3, parameter4)
                .toDispatch());
    }
    
    /**
     * invokes a single parameter call on this dispatch
     * that returns no value
     * @param actionCommand
     * @param parameter
     * @return a Variant but that may be null for some calls
     */
    public Variant invoke(String actionCommand, String parameter){
        return Dispatch.call(this, actionCommand, parameter);
    }
    
    /**
     * makes a dispatch call to the passed in action with a single boolean parameter
     * @param actionCommand
     * @param parameter
     * @return Variant result
     */
    public Variant invoke(String actionCommand, boolean parameter){
        return Dispatch.call(this, actionCommand, new Variant(parameter));
    }

    /**
     * makes a dispatch call to the passed in action with a single int parameter
     * @param actionCommand
     * @param parameter
     * @return Variant result of the invoke (Dispatch.call)
     */
    public Variant invoke(String actionCommand, int parameter){
        return Dispatch.call(this, actionCommand, new Variant(parameter));
    }
    
    /**
     * makes a dispatch call to the passed in action with a string and integer parameter
     * (this was put in for some application)
     * @param actionCommand
     * @param parameter1
     * @param parameter2
     * @return Variant result
     */
    public Variant invoke(String actionCommand, String parameter1, int parameter2){
        return Dispatch.call(this, actionCommand, parameter1, new Variant(parameter2));
    }

    /**
     * makes a dispatch call to the passed in action with two 
     * integer parameters
     * (this was put in for some application)
     * @param actionCommand
     * @param parameter1
     * @param parameter2
     * @return a Variant but that may be null for some calls
     */
    public Variant invoke(String actionCommand, 
            int parameter1, int parameter2){
        return Dispatch.call(this, actionCommand, 
                new Variant(parameter1),new Variant(parameter2));
    }
    /**
     * makes a dispatch call for the passed in action and single parameter
     * @param callAction
     * @param parameter
     * @return a Variant but that may be null for some calls
     */
    public Variant invoke(String callAction, Variant parameter){
        return Dispatch.call(this,callAction, parameter);
    }
    
    /**
     * makes a dispatch call for the passed in action and two parameter
     * @param callAction
     * @param parameter1
     * @param parameter2
     * @return a Variant but that may be null for some calls
     */
    public Variant invoke(String callAction, 
            Variant parameter1, 
            Variant parameter2){
        return Dispatch.call(this,callAction, parameter1,parameter2);
    }
    
    /**
     * makes a dispatch call for the passed in action and two parameter
     * @param callAction
     * @param parameter1
     * @param parameter2
     * @param parameter3
     * @return Variant result data
     */
    public Variant invoke(String callAction, 
            Variant parameter1, 
            Variant parameter2, 
            Variant parameter3){
        return Dispatch.call(this,callAction, 
                parameter1, parameter2, parameter3);
    }


    /**
     * calls call() with 4 variant parameters
     * @param callAction
     * @param parameter1
     * @param parameter2
     * @param parameter3
     * @param parameter4
     * @return Variant result data
     */
    public Variant invoke(String callAction, 
            Variant parameter1, 
            Variant parameter2, 
            Variant parameter3,
            Variant parameter4){
        return Dispatch.call(this,callAction, 
                parameter1, parameter2, parameter3, parameter4);
    }
    
    
    /**
     * makes a dispatch call for the passed in action and no parameter
     * @param callAction
     * @return a Variant but that may be null for some calls
     */
    public Variant invoke(String callAction){
        return Dispatch.call(this,callAction);
    }
    
    /**
     * This is really a cover for call(String,Variant[]) that should be eliminated
     * call with a variable number of args mainly used for quit.
     * @param name
     * @param args
     * @return Variant returned by the invoke (Dispatch.callN)
     */
    public Variant invoke(String name, Variant[] args)
    {
      return Dispatch.callN(this, name, args);
    }

    
}