package processes;

import java.beans.BeanDescriptor;
import java.beans.EventSetDescriptor;
import java.beans.IntrospectionException;
import java.beans.MethodDescriptor;
import java.beans.ParameterDescriptor;
import java.beans.PropertyDescriptor;
import java.beans.PropertyEditor;
import java.lang.reflect.Method;
import java.util.HashMap;

import org.apache.beehive.controls.api.ControlException;
import org.apache.beehive.controls.runtime.bean.BeanPersistenceDelegate;
import org.apache.beehive.controls.runtime.packaging.ControlEventSetDescriptor;

@SuppressWarnings("all")
public class MyTaskCtrlBeanBeanInfo
extends com.bea.control.TaskControlBeanBeanInfo
{
    static final Method _suspendTaskMethod;
    static final Method _setClaimDueBusinessDateSystemCalendarMethod;
    static final Method _setCompletionDueBusinessDateSystemCalendarMethod;
    static final Method _setResponseMethod;
    static final Method _getResponseMethod;
    static final Method _setOwnerMethod;
    static final Method _setClaimDueBusinessDateMethod;
    static final Method _createMethod;
    static final Method _setPriorityMethod;
    static final Method _setClaimDueDateMethod;
    static final Method _setCommentMethod;
    static final Method _resumeTaskMethod;
    static final Method _getPropertyMethod;
    static final Method _setCompletionDueBusinessDateMethod;
    static final Method _setPropertyMethod;
    static final Method _setCompletionDueDateMethod;
    static final Method _assignTaskToUserInGroupMethod;
    static final Method _removePropertyMethod;
    static final Method _createTaskByNameMethod;
    static final Method _assignTaskToUserMethod;
    static final Method _abortTaskMethod;
    static final Method _setRequestMethod;
    static final Method _setPermissionsMethod;
    static final Method _assignTaskToUsersAndGroupsMethod;
    static final Method _getRequestMethod;
    static final Method _CallbackIntf_onTaskAbortedEvent;
    static final Method _CallbackIntf_onTaskCompletedEvent;
    static final Method _CallbackIntf_onTaskOverdueEvent;
    
    //
    // This HashMap will map from a Method to the array of names for parameters of the
    // method.  This is necessary because parameter name data isn't carried along in the
    // class file, but if available can enable ease of use by referencing parameters by
    // the declared name (vs. by index).
    //
    // This map should be read-only after its initialization in the static block, hence
    // using a plain HashMap is thread-safe.
    //
    static HashMap<Method, String []> _methodParamMap = new HashMap<Method, String []>();
    
    static
    {
        
        
        try
        {
            _suspendTaskMethod = processes.MyTaskCtrl.class.getMethod("suspendTask", new Class [] {});
            _methodParamMap.put(_suspendTaskMethod, new String [] {  });
            _setClaimDueBusinessDateSystemCalendarMethod = processes.MyTaskCtrl.class.getMethod("setClaimDueBusinessDateSystemCalendar", new Class [] {java.lang.String.class});
            _methodParamMap.put(_setClaimDueBusinessDateSystemCalendarMethod, new String [] { "duration" });
            _setCompletionDueBusinessDateSystemCalendarMethod = processes.MyTaskCtrl.class.getMethod("setCompletionDueBusinessDateSystemCalendar", new Class [] {java.lang.String.class});
            _methodParamMap.put(_setCompletionDueBusinessDateSystemCalendarMethod, new String [] { "duration" });
            _setResponseMethod = processes.MyTaskCtrl.class.getMethod("setResponse", new Class [] {org.apache.xmlbeans.XmlObject.class});
            _methodParamMap.put(_setResponseMethod, new String [] { "xml" });
            _getResponseMethod = processes.MyTaskCtrl.class.getMethod("getResponse", new Class [] {});
            _methodParamMap.put(_getResponseMethod, new String [] {  });
            _setOwnerMethod = processes.MyTaskCtrl.class.getMethod("setOwner", new Class [] {java.lang.String.class});
            _methodParamMap.put(_setOwnerMethod, new String [] { "owner" });
            _setClaimDueBusinessDateMethod = processes.MyTaskCtrl.class.getMethod("setClaimDueBusinessDate", new Class [] {java.lang.String.class, java.lang.String.class});
            _methodParamMap.put(_setClaimDueBusinessDateMethod, new String [] { "duration", "calendarID" });
            _createMethod = processes.MyTaskCtrl.class.getMethod("create", new Class [] {});
            _methodParamMap.put(_createMethod, new String [] {  });
            _setPriorityMethod = processes.MyTaskCtrl.class.getMethod("setPriority", new Class [] {java.lang.Integer.class});
            _methodParamMap.put(_setPriorityMethod, new String [] { "priority" });
            _setClaimDueDateMethod = processes.MyTaskCtrl.class.getMethod("setClaimDueDate", new Class [] {java.util.Date.class});
            _methodParamMap.put(_setClaimDueDateMethod, new String [] { "date" });
            _setCommentMethod = processes.MyTaskCtrl.class.getMethod("setComment", new Class [] {java.lang.String.class});
            _methodParamMap.put(_setCommentMethod, new String [] { "comment" });
            _resumeTaskMethod = processes.MyTaskCtrl.class.getMethod("resumeTask", new Class [] {});
            _methodParamMap.put(_resumeTaskMethod, new String [] {  });
            _getPropertyMethod = processes.MyTaskCtrl.class.getMethod("getProperty", new Class [] {java.lang.String.class});
            _methodParamMap.put(_getPropertyMethod, new String [] { "name" });
            _setCompletionDueBusinessDateMethod = processes.MyTaskCtrl.class.getMethod("setCompletionDueBusinessDate", new Class [] {java.lang.String.class, java.lang.String.class});
            _methodParamMap.put(_setCompletionDueBusinessDateMethod, new String [] { "duration", "calendarID" });
            _setPropertyMethod = processes.MyTaskCtrl.class.getMethod("setProperty", new Class [] {java.lang.String.class, java.lang.String.class});
            _methodParamMap.put(_setPropertyMethod, new String [] { "name", "value" });
            _setCompletionDueDateMethod = processes.MyTaskCtrl.class.getMethod("setCompletionDueDate", new Class [] {java.util.Date.class});
            _methodParamMap.put(_setCompletionDueDateMethod, new String [] { "date" });
            _assignTaskToUserInGroupMethod = processes.MyTaskCtrl.class.getMethod("assignTaskToUserInGroup", new Class [] {java.lang.String.class});
            _methodParamMap.put(_assignTaskToUserInGroupMethod, new String [] { "group" });
            _removePropertyMethod = processes.MyTaskCtrl.class.getMethod("removeProperty", new Class [] {java.lang.String.class});
            _methodParamMap.put(_removePropertyMethod, new String [] { "name" });
            _createTaskByNameMethod = processes.MyTaskCtrl.class.getMethod("createTaskByName", new Class [] {java.lang.String.class});
            _methodParamMap.put(_createTaskByNameMethod, new String [] { "name" });
            _assignTaskToUserMethod = processes.MyTaskCtrl.class.getMethod("assignTaskToUser", new Class [] {java.lang.String.class});
            _methodParamMap.put(_assignTaskToUserMethod, new String [] { "user" });
            _abortTaskMethod = processes.MyTaskCtrl.class.getMethod("abortTask", new Class [] {});
            _methodParamMap.put(_abortTaskMethod, new String [] {  });
            _setRequestMethod = processes.MyTaskCtrl.class.getMethod("setRequest", new Class [] {org.apache.xmlbeans.XmlObject.class});
            _methodParamMap.put(_setRequestMethod, new String [] { "xml" });
            _setPermissionsMethod = processes.MyTaskCtrl.class.getMethod("setPermissions", new Class [] {java.lang.Boolean.class, java.lang.Boolean.class, java.lang.Boolean.class});
            _methodParamMap.put(_setPermissionsMethod, new String [] { "aborted", "returned", "reassigned" });
            _assignTaskToUsersAndGroupsMethod = processes.MyTaskCtrl.class.getMethod("assignTaskToUsersAndGroups", new Class [] {java.lang.String[].class, java.lang.String[].class});
            _methodParamMap.put(_assignTaskToUsersAndGroupsMethod, new String [] { "users", "groups" });
            _getRequestMethod = processes.MyTaskCtrl.class.getMethod("getRequest", new Class [] {});
            _methodParamMap.put(_getRequestMethod, new String [] {  });
            _CallbackIntf_onTaskAbortedEvent = processes.MyTaskCtrl.CallbackIntf.class.getMethod("onTaskAborted", new Class [] {org.apache.xmlbeans.XmlObject.class});
            _methodParamMap.put(_CallbackIntf_onTaskAbortedEvent, new String [] { "response" });
            _CallbackIntf_onTaskCompletedEvent = processes.MyTaskCtrl.CallbackIntf.class.getMethod("onTaskCompleted", new Class [] {org.apache.xmlbeans.XmlObject.class});
            _methodParamMap.put(_CallbackIntf_onTaskCompletedEvent, new String [] { "response" });
            _CallbackIntf_onTaskOverdueEvent = processes.MyTaskCtrl.CallbackIntf.class.getMethod("onTaskOverdue", new Class [] {java.util.Date.class});
            _methodParamMap.put(_CallbackIntf_onTaskOverdueEvent, new String [] { "time" });
        }
        catch (NoSuchMethodException __bc_nsme)
        {
            throw new ExceptionInInitializerError(__bc_nsme);
        }
    }
    
    /**
    * Default null-arg constructor used to create a new BeanInfo instance
    */
    public MyTaskCtrlBeanBeanInfo()
    {
        super(processes.MyTaskCtrlBean.class);
    }
    
    /**
    * Protected constructor used if this BeanInfo class is extended.
    */
    protected MyTaskCtrlBeanBeanInfo(Class beanClass)
    {
        super(beanClass);
    }
    
    // java.beans.BeanInfo.getBeanDescriptor
    public BeanDescriptor getBeanDescriptor()
    {
        BeanDescriptor bd = new BeanDescriptor(processes.MyTaskCtrlBean.class);
        bd.setName( "MyTaskCtrlBean" );
        bd.setDisplayName( "MyTaskCtrlBean" );
        
        //
        // The org.apache.beehive.controls.runtime.bean.BeanPersistenceDelegate class
        // implements the XMLDecode delegation model for all Control JavaBean types. It
        // provides optimized XML persistance based upon the Control runtime architecture.
        // The 'persistenceDelegate' attribute of a BeanDescriptor is used by XMLEncoder to
        // locate a delegate for a particular JavaBean type.
        //
        bd.setValue("persistenceDelegate", new BeanPersistenceDelegate());
        
        return bd;
    }
    
    /**
    * Stores MethodDescriptor descriptors for this bean and its superclasses into
    * an array, starting at the specified index
    */
    protected void initMethodDescriptors(MethodDescriptor [] methodDescriptors, int index)
    throws java.beans.IntrospectionException
    {
        String [] __bc_paramNames;
        ParameterDescriptor [] __bc_paramDescriptors;
        MethodDescriptor md;
        
        //
        // Declare MethodDescriptor for suspendTask()
        //
        __bc_paramNames = _methodParamMap.get(_suspendTaskMethod);
        __bc_paramDescriptors = new ParameterDescriptor[__bc_paramNames.length];
        for (int j = 0; j < __bc_paramNames.length; j++)
        {
            __bc_paramDescriptors[j] = new ParameterDescriptor();
            __bc_paramDescriptors[j].setName(__bc_paramNames[j]);
            __bc_paramDescriptors[j].setDisplayName(__bc_paramNames[j]);
        }
        md = new MethodDescriptor(_suspendTaskMethod, __bc_paramDescriptors);
        methodDescriptors[index++] = md;
        
        //
        // Declare MethodDescriptor for setClaimDueBusinessDateSystemCalendar(duration)
        //
        __bc_paramNames = _methodParamMap.get(_setClaimDueBusinessDateSystemCalendarMethod);
        __bc_paramDescriptors = new ParameterDescriptor[__bc_paramNames.length];
        for (int j = 0; j < __bc_paramNames.length; j++)
        {
            __bc_paramDescriptors[j] = new ParameterDescriptor();
            __bc_paramDescriptors[j].setName(__bc_paramNames[j]);
            __bc_paramDescriptors[j].setDisplayName(__bc_paramNames[j]);
        }
        md = new MethodDescriptor(_setClaimDueBusinessDateSystemCalendarMethod, __bc_paramDescriptors);
        methodDescriptors[index++] = md;
        
        //
        // Declare MethodDescriptor for setCompletionDueBusinessDateSystemCalendar(duration)
        //
        __bc_paramNames = _methodParamMap.get(_setCompletionDueBusinessDateSystemCalendarMethod);
        __bc_paramDescriptors = new ParameterDescriptor[__bc_paramNames.length];
        for (int j = 0; j < __bc_paramNames.length; j++)
        {
            __bc_paramDescriptors[j] = new ParameterDescriptor();
            __bc_paramDescriptors[j].setName(__bc_paramNames[j]);
            __bc_paramDescriptors[j].setDisplayName(__bc_paramNames[j]);
        }
        md = new MethodDescriptor(_setCompletionDueBusinessDateSystemCalendarMethod, __bc_paramDescriptors);
        methodDescriptors[index++] = md;
        
        //
        // Declare MethodDescriptor for setResponse(xml)
        //
        __bc_paramNames = _methodParamMap.get(_setResponseMethod);
        __bc_paramDescriptors = new ParameterDescriptor[__bc_paramNames.length];
        for (int j = 0; j < __bc_paramNames.length; j++)
        {
            __bc_paramDescriptors[j] = new ParameterDescriptor();
            __bc_paramDescriptors[j].setName(__bc_paramNames[j]);
            __bc_paramDescriptors[j].setDisplayName(__bc_paramNames[j]);
        }
        md = new MethodDescriptor(_setResponseMethod, __bc_paramDescriptors);
        methodDescriptors[index++] = md;
        
        //
        // Declare MethodDescriptor for getResponse()
        //
        __bc_paramNames = _methodParamMap.get(_getResponseMethod);
        __bc_paramDescriptors = new ParameterDescriptor[__bc_paramNames.length];
        for (int j = 0; j < __bc_paramNames.length; j++)
        {
            __bc_paramDescriptors[j] = new ParameterDescriptor();
            __bc_paramDescriptors[j].setName(__bc_paramNames[j]);
            __bc_paramDescriptors[j].setDisplayName(__bc_paramNames[j]);
        }
        md = new MethodDescriptor(_getResponseMethod, __bc_paramDescriptors);
        methodDescriptors[index++] = md;
        
        //
        // Declare MethodDescriptor for setOwner(owner)
        //
        __bc_paramNames = _methodParamMap.get(_setOwnerMethod);
        __bc_paramDescriptors = new ParameterDescriptor[__bc_paramNames.length];
        for (int j = 0; j < __bc_paramNames.length; j++)
        {
            __bc_paramDescriptors[j] = new ParameterDescriptor();
            __bc_paramDescriptors[j].setName(__bc_paramNames[j]);
            __bc_paramDescriptors[j].setDisplayName(__bc_paramNames[j]);
        }
        md = new MethodDescriptor(_setOwnerMethod, __bc_paramDescriptors);
        methodDescriptors[index++] = md;
        
        //
        // Declare MethodDescriptor for setClaimDueBusinessDate(duration, calendarID)
        //
        __bc_paramNames = _methodParamMap.get(_setClaimDueBusinessDateMethod);
        __bc_paramDescriptors = new ParameterDescriptor[__bc_paramNames.length];
        for (int j = 0; j < __bc_paramNames.length; j++)
        {
            __bc_paramDescriptors[j] = new ParameterDescriptor();
            __bc_paramDescriptors[j].setName(__bc_paramNames[j]);
            __bc_paramDescriptors[j].setDisplayName(__bc_paramNames[j]);
        }
        md = new MethodDescriptor(_setClaimDueBusinessDateMethod, __bc_paramDescriptors);
        methodDescriptors[index++] = md;
        
        //
        // Declare MethodDescriptor for create()
        //
        __bc_paramNames = _methodParamMap.get(_createMethod);
        __bc_paramDescriptors = new ParameterDescriptor[__bc_paramNames.length];
        for (int j = 0; j < __bc_paramNames.length; j++)
        {
            __bc_paramDescriptors[j] = new ParameterDescriptor();
            __bc_paramDescriptors[j].setName(__bc_paramNames[j]);
            __bc_paramDescriptors[j].setDisplayName(__bc_paramNames[j]);
        }
        md = new MethodDescriptor(_createMethod, __bc_paramDescriptors);
        methodDescriptors[index++] = md;
        
        //
        // Declare MethodDescriptor for setPriority(priority)
        //
        __bc_paramNames = _methodParamMap.get(_setPriorityMethod);
        __bc_paramDescriptors = new ParameterDescriptor[__bc_paramNames.length];
        for (int j = 0; j < __bc_paramNames.length; j++)
        {
            __bc_paramDescriptors[j] = new ParameterDescriptor();
            __bc_paramDescriptors[j].setName(__bc_paramNames[j]);
            __bc_paramDescriptors[j].setDisplayName(__bc_paramNames[j]);
        }
        md = new MethodDescriptor(_setPriorityMethod, __bc_paramDescriptors);
        methodDescriptors[index++] = md;
        
        //
        // Declare MethodDescriptor for setClaimDueDate(date)
        //
        __bc_paramNames = _methodParamMap.get(_setClaimDueDateMethod);
        __bc_paramDescriptors = new ParameterDescriptor[__bc_paramNames.length];
        for (int j = 0; j < __bc_paramNames.length; j++)
        {
            __bc_paramDescriptors[j] = new ParameterDescriptor();
            __bc_paramDescriptors[j].setName(__bc_paramNames[j]);
            __bc_paramDescriptors[j].setDisplayName(__bc_paramNames[j]);
        }
        md = new MethodDescriptor(_setClaimDueDateMethod, __bc_paramDescriptors);
        methodDescriptors[index++] = md;
        
        //
        // Declare MethodDescriptor for setComment(comment)
        //
        __bc_paramNames = _methodParamMap.get(_setCommentMethod);
        __bc_paramDescriptors = new ParameterDescriptor[__bc_paramNames.length];
        for (int j = 0; j < __bc_paramNames.length; j++)
        {
            __bc_paramDescriptors[j] = new ParameterDescriptor();
            __bc_paramDescriptors[j].setName(__bc_paramNames[j]);
            __bc_paramDescriptors[j].setDisplayName(__bc_paramNames[j]);
        }
        md = new MethodDescriptor(_setCommentMethod, __bc_paramDescriptors);
        methodDescriptors[index++] = md;
        
        //
        // Declare MethodDescriptor for resumeTask()
        //
        __bc_paramNames = _methodParamMap.get(_resumeTaskMethod);
        __bc_paramDescriptors = new ParameterDescriptor[__bc_paramNames.length];
        for (int j = 0; j < __bc_paramNames.length; j++)
        {
            __bc_paramDescriptors[j] = new ParameterDescriptor();
            __bc_paramDescriptors[j].setName(__bc_paramNames[j]);
            __bc_paramDescriptors[j].setDisplayName(__bc_paramNames[j]);
        }
        md = new MethodDescriptor(_resumeTaskMethod, __bc_paramDescriptors);
        methodDescriptors[index++] = md;
        
        //
        // Declare MethodDescriptor for getProperty(name)
        //
        __bc_paramNames = _methodParamMap.get(_getPropertyMethod);
        __bc_paramDescriptors = new ParameterDescriptor[__bc_paramNames.length];
        for (int j = 0; j < __bc_paramNames.length; j++)
        {
            __bc_paramDescriptors[j] = new ParameterDescriptor();
            __bc_paramDescriptors[j].setName(__bc_paramNames[j]);
            __bc_paramDescriptors[j].setDisplayName(__bc_paramNames[j]);
        }
        md = new MethodDescriptor(_getPropertyMethod, __bc_paramDescriptors);
        methodDescriptors[index++] = md;
        
        //
        // Declare MethodDescriptor for setCompletionDueBusinessDate(duration, calendarID)
        //
        __bc_paramNames = _methodParamMap.get(_setCompletionDueBusinessDateMethod);
        __bc_paramDescriptors = new ParameterDescriptor[__bc_paramNames.length];
        for (int j = 0; j < __bc_paramNames.length; j++)
        {
            __bc_paramDescriptors[j] = new ParameterDescriptor();
            __bc_paramDescriptors[j].setName(__bc_paramNames[j]);
            __bc_paramDescriptors[j].setDisplayName(__bc_paramNames[j]);
        }
        md = new MethodDescriptor(_setCompletionDueBusinessDateMethod, __bc_paramDescriptors);
        methodDescriptors[index++] = md;
        
        //
        // Declare MethodDescriptor for setProperty(name, value)
        //
        __bc_paramNames = _methodParamMap.get(_setPropertyMethod);
        __bc_paramDescriptors = new ParameterDescriptor[__bc_paramNames.length];
        for (int j = 0; j < __bc_paramNames.length; j++)
        {
            __bc_paramDescriptors[j] = new ParameterDescriptor();
            __bc_paramDescriptors[j].setName(__bc_paramNames[j]);
            __bc_paramDescriptors[j].setDisplayName(__bc_paramNames[j]);
        }
        md = new MethodDescriptor(_setPropertyMethod, __bc_paramDescriptors);
        methodDescriptors[index++] = md;
        
        //
        // Declare MethodDescriptor for setCompletionDueDate(date)
        //
        __bc_paramNames = _methodParamMap.get(_setCompletionDueDateMethod);
        __bc_paramDescriptors = new ParameterDescriptor[__bc_paramNames.length];
        for (int j = 0; j < __bc_paramNames.length; j++)
        {
            __bc_paramDescriptors[j] = new ParameterDescriptor();
            __bc_paramDescriptors[j].setName(__bc_paramNames[j]);
            __bc_paramDescriptors[j].setDisplayName(__bc_paramNames[j]);
        }
        md = new MethodDescriptor(_setCompletionDueDateMethod, __bc_paramDescriptors);
        methodDescriptors[index++] = md;
        
        //
        // Declare MethodDescriptor for assignTaskToUserInGroup(group)
        //
        __bc_paramNames = _methodParamMap.get(_assignTaskToUserInGroupMethod);
        __bc_paramDescriptors = new ParameterDescriptor[__bc_paramNames.length];
        for (int j = 0; j < __bc_paramNames.length; j++)
        {
            __bc_paramDescriptors[j] = new ParameterDescriptor();
            __bc_paramDescriptors[j].setName(__bc_paramNames[j]);
            __bc_paramDescriptors[j].setDisplayName(__bc_paramNames[j]);
        }
        md = new MethodDescriptor(_assignTaskToUserInGroupMethod, __bc_paramDescriptors);
        methodDescriptors[index++] = md;
        
        //
        // Declare MethodDescriptor for removeProperty(name)
        //
        __bc_paramNames = _methodParamMap.get(_removePropertyMethod);
        __bc_paramDescriptors = new ParameterDescriptor[__bc_paramNames.length];
        for (int j = 0; j < __bc_paramNames.length; j++)
        {
            __bc_paramDescriptors[j] = new ParameterDescriptor();
            __bc_paramDescriptors[j].setName(__bc_paramNames[j]);
            __bc_paramDescriptors[j].setDisplayName(__bc_paramNames[j]);
        }
        md = new MethodDescriptor(_removePropertyMethod, __bc_paramDescriptors);
        methodDescriptors[index++] = md;
        
        //
        // Declare MethodDescriptor for createTaskByName(name)
        //
        __bc_paramNames = _methodParamMap.get(_createTaskByNameMethod);
        __bc_paramDescriptors = new ParameterDescriptor[__bc_paramNames.length];
        for (int j = 0; j < __bc_paramNames.length; j++)
        {
            __bc_paramDescriptors[j] = new ParameterDescriptor();
            __bc_paramDescriptors[j].setName(__bc_paramNames[j]);
            __bc_paramDescriptors[j].setDisplayName(__bc_paramNames[j]);
        }
        md = new MethodDescriptor(_createTaskByNameMethod, __bc_paramDescriptors);
        methodDescriptors[index++] = md;
        
        //
        // Declare MethodDescriptor for assignTaskToUser(user)
        //
        __bc_paramNames = _methodParamMap.get(_assignTaskToUserMethod);
        __bc_paramDescriptors = new ParameterDescriptor[__bc_paramNames.length];
        for (int j = 0; j < __bc_paramNames.length; j++)
        {
            __bc_paramDescriptors[j] = new ParameterDescriptor();
            __bc_paramDescriptors[j].setName(__bc_paramNames[j]);
            __bc_paramDescriptors[j].setDisplayName(__bc_paramNames[j]);
        }
        md = new MethodDescriptor(_assignTaskToUserMethod, __bc_paramDescriptors);
        methodDescriptors[index++] = md;
        
        //
        // Declare MethodDescriptor for abortTask()
        //
        __bc_paramNames = _methodParamMap.get(_abortTaskMethod);
        __bc_paramDescriptors = new ParameterDescriptor[__bc_paramNames.length];
        for (int j = 0; j < __bc_paramNames.length; j++)
        {
            __bc_paramDescriptors[j] = new ParameterDescriptor();
            __bc_paramDescriptors[j].setName(__bc_paramNames[j]);
            __bc_paramDescriptors[j].setDisplayName(__bc_paramNames[j]);
        }
        md = new MethodDescriptor(_abortTaskMethod, __bc_paramDescriptors);
        methodDescriptors[index++] = md;
        
        //
        // Declare MethodDescriptor for setRequest(xml)
        //
        __bc_paramNames = _methodParamMap.get(_setRequestMethod);
        __bc_paramDescriptors = new ParameterDescriptor[__bc_paramNames.length];
        for (int j = 0; j < __bc_paramNames.length; j++)
        {
            __bc_paramDescriptors[j] = new ParameterDescriptor();
            __bc_paramDescriptors[j].setName(__bc_paramNames[j]);
            __bc_paramDescriptors[j].setDisplayName(__bc_paramNames[j]);
        }
        md = new MethodDescriptor(_setRequestMethod, __bc_paramDescriptors);
        methodDescriptors[index++] = md;
        
        //
        // Declare MethodDescriptor for setPermissions(aborted, returned, reassigned)
        //
        __bc_paramNames = _methodParamMap.get(_setPermissionsMethod);
        __bc_paramDescriptors = new ParameterDescriptor[__bc_paramNames.length];
        for (int j = 0; j < __bc_paramNames.length; j++)
        {
            __bc_paramDescriptors[j] = new ParameterDescriptor();
            __bc_paramDescriptors[j].setName(__bc_paramNames[j]);
            __bc_paramDescriptors[j].setDisplayName(__bc_paramNames[j]);
        }
        md = new MethodDescriptor(_setPermissionsMethod, __bc_paramDescriptors);
        methodDescriptors[index++] = md;
        
        //
        // Declare MethodDescriptor for assignTaskToUsersAndGroups(users, groups)
        //
        __bc_paramNames = _methodParamMap.get(_assignTaskToUsersAndGroupsMethod);
        __bc_paramDescriptors = new ParameterDescriptor[__bc_paramNames.length];
        for (int j = 0; j < __bc_paramNames.length; j++)
        {
            __bc_paramDescriptors[j] = new ParameterDescriptor();
            __bc_paramDescriptors[j].setName(__bc_paramNames[j]);
            __bc_paramDescriptors[j].setDisplayName(__bc_paramNames[j]);
        }
        md = new MethodDescriptor(_assignTaskToUsersAndGroupsMethod, __bc_paramDescriptors);
        methodDescriptors[index++] = md;
        
        //
        // Declare MethodDescriptor for getRequest()
        //
        __bc_paramNames = _methodParamMap.get(_getRequestMethod);
        __bc_paramDescriptors = new ParameterDescriptor[__bc_paramNames.length];
        for (int j = 0; j < __bc_paramNames.length; j++)
        {
            __bc_paramDescriptors[j] = new ParameterDescriptor();
            __bc_paramDescriptors[j].setName(__bc_paramNames[j]);
            __bc_paramDescriptors[j].setDisplayName(__bc_paramNames[j]);
        }
        md = new MethodDescriptor(_getRequestMethod, __bc_paramDescriptors);
        methodDescriptors[index++] = md;
        
        
        //
        // Add method descriptors from parent BeanInfo
        //
        super.initMethodDescriptors(methodDescriptors, index);
    }
    
    public MethodDescriptor [] getMethodDescriptors()
    {
        MethodDescriptor [] __bc_methodDescriptors = new MethodDescriptor[36];
        try
        {
            initMethodDescriptors(__bc_methodDescriptors, 0);
        }
        catch (java.beans.IntrospectionException __bc_ie)
        {
            throw new ControlException("Unable to create MethodDescriptor", __bc_ie);
        }
        return __bc_methodDescriptors;
    }
    
    /**
    * Stores PropertyDescriptor descriptors for this bean and its superclasses into
    * an array, starting at the specified index
    */
    protected void initPropertyDescriptors(PropertyDescriptor [] propDescriptors, int index)
    throws java.beans.IntrospectionException
    {
        PropertyDescriptor pd;
        
        pd = new PropertyDescriptor( "controlImplementation" , processes.MyTaskCtrlBean.class, "getControlImplementation", "setControlImplementation");
        propDescriptors[index++] = pd;
        
        //
        // add property descriptors for any getter/setters defined in control interface
        //
        pd = new PropertyDescriptor( "completionDueDate" , processes.MyTaskCtrlBean.class, null, "setCompletionDueDate");
        propDescriptors[index++] = pd;
        pd = new PropertyDescriptor( "claimDueBusinessDateSystemCalendar" , processes.MyTaskCtrlBean.class, null, "setClaimDueBusinessDateSystemCalendar");
        propDescriptors[index++] = pd;
        pd = new PropertyDescriptor( "owner" , processes.MyTaskCtrlBean.class, null, "setOwner");
        propDescriptors[index++] = pd;
        pd = new PropertyDescriptor( "comment" , processes.MyTaskCtrlBean.class, null, "setComment");
        propDescriptors[index++] = pd;
        pd = new PropertyDescriptor( "claimDueDate" , processes.MyTaskCtrlBean.class, null, "setClaimDueDate");
        propDescriptors[index++] = pd;
        pd = new PropertyDescriptor( "request" , processes.MyTaskCtrlBean.class, "getRequest", "setRequest");
        propDescriptors[index++] = pd;
        pd = new PropertyDescriptor( "priority" , processes.MyTaskCtrlBean.class, null, "setPriority");
        propDescriptors[index++] = pd;
        pd = new PropertyDescriptor( "completionDueBusinessDateSystemCalendar" , processes.MyTaskCtrlBean.class, null, "setCompletionDueBusinessDateSystemCalendar");
        propDescriptors[index++] = pd;
        pd = new PropertyDescriptor( "response" , processes.MyTaskCtrlBean.class, "getResponse", "setResponse");
        propDescriptors[index++] = pd;
        
        //
        // Add property descriptors from parent BeanInfo
        //
        super.initPropertyDescriptors(propDescriptors, index);
    }
    
    // java.beans.BeanInfo.getPropertyDescriptors
    public PropertyDescriptor [] getPropertyDescriptors()
    {
        PropertyDescriptor [] __bc_propDescriptors = new PropertyDescriptor[18];
        try
        {
            initPropertyDescriptors(__bc_propDescriptors, 0);
        }
        catch (java.beans.IntrospectionException __bc_ie)
        {
            throw new ControlException("Unable to create PropertyDescriptor", __bc_ie);
        }
        return __bc_propDescriptors;
    }
    
    //
    // Adds the EventDescriptors for CallbackIntf to the EventDescriptor array, starting
    // at index
    //
    protected void initCallbackIntfEvents(MethodDescriptor [] eventDescriptors, int index)
    {
        String [] __bc_paramNames;
        ParameterDescriptor [] __bc_paramDescriptors;
        MethodDescriptor md;
        
        //
        // Build a method descriptor for each event method in the event set
        //
        
        //
        // Declare MethodDescriptor for onTaskAborted(response)
        //
        __bc_paramNames = _methodParamMap.get(_CallbackIntf_onTaskAbortedEvent);
        __bc_paramDescriptors = new ParameterDescriptor[__bc_paramNames.length];
        for (int k = 0; k < __bc_paramNames.length; k++)
        {
            __bc_paramDescriptors[k] = new ParameterDescriptor();
            __bc_paramDescriptors[k].setName(__bc_paramNames[k]);
            __bc_paramDescriptors[k].setDisplayName(__bc_paramNames[k]);
        }
        md = new MethodDescriptor(_CallbackIntf_onTaskAbortedEvent, __bc_paramDescriptors);
        eventDescriptors[index++] = md;
        
        //
        // Declare MethodDescriptor for onTaskCompleted(response)
        //
        __bc_paramNames = _methodParamMap.get(_CallbackIntf_onTaskCompletedEvent);
        __bc_paramDescriptors = new ParameterDescriptor[__bc_paramNames.length];
        for (int k = 0; k < __bc_paramNames.length; k++)
        {
            __bc_paramDescriptors[k] = new ParameterDescriptor();
            __bc_paramDescriptors[k].setName(__bc_paramNames[k]);
            __bc_paramDescriptors[k].setDisplayName(__bc_paramNames[k]);
        }
        md = new MethodDescriptor(_CallbackIntf_onTaskCompletedEvent, __bc_paramDescriptors);
        eventDescriptors[index++] = md;
        
        //
        // Declare MethodDescriptor for onTaskOverdue(time)
        //
        __bc_paramNames = _methodParamMap.get(_CallbackIntf_onTaskOverdueEvent);
        __bc_paramDescriptors = new ParameterDescriptor[__bc_paramNames.length];
        for (int k = 0; k < __bc_paramNames.length; k++)
        {
            __bc_paramDescriptors[k] = new ParameterDescriptor();
            __bc_paramDescriptors[k].setName(__bc_paramNames[k]);
            __bc_paramDescriptors[k].setDisplayName(__bc_paramNames[k]);
        }
        md = new MethodDescriptor(_CallbackIntf_onTaskOverdueEvent, __bc_paramDescriptors);
        eventDescriptors[index++] = md;
        
        //
        // Add events from the parent EventSet
        //
        initCallbackEvents(eventDescriptors, index);
    }
    
    
    protected void initEventSetDescriptors(EventSetDescriptor [] eventSetDescriptors, int index)
    throws java.beans.IntrospectionException
    {
        MethodDescriptor [] __bc_eventDescriptors;
        EventSetDescriptor __bc_esd;
        Method __bc_addListener, __bc_removeListener, __bc_getListeners;
        Class __bc_eventIntf;
        
        __bc_eventIntf = processes.MyTaskCtrl.CallbackIntf.class;
        
        //
        // Find the add/remove listener methods
        //
        try
        {
            __bc_addListener =
            processes.MyTaskCtrlBean.class.getDeclaredMethod("addCallbackIntfListener",
            new Class [] { __bc_eventIntf });
            __bc_removeListener =
            processes.MyTaskCtrlBean.class.getDeclaredMethod("removeCallbackIntfListener",
            new Class [] { __bc_eventIntf });
            __bc_getListeners =
            processes.MyTaskCtrlBean.class.getDeclaredMethod("getCallbackIntfListeners",
            new Class [] {});
        }
        catch (NoSuchMethodException __bc_nsme)
        {
            // This is moderately lame, but there is no checked exception declared for this
            // method.  This could only happen as a result of a mismatch between bean class
            // and introspector codegen.
            throw new ControlException("Unable to locate listener method", __bc_nsme);
        }
        
        //
        // Build the MethodDescriptor array contain all event set events
        //
        __bc_eventDescriptors = new MethodDescriptor[3];
        initCallbackIntfEvents(__bc_eventDescriptors, 0);
        
        try
        {
            __bc_esd = new ControlEventSetDescriptor(localizeString("callbackIntf"),
            __bc_eventIntf, __bc_eventDescriptors, __bc_addListener, __bc_removeListener, __bc_getListeners);
            __bc_esd.setUnicast(false);
        }
        catch (IntrospectionException __bc_ie)
        {
            throw new ControlException("Unable to create EventDescriptor", __bc_ie);
        }
        eventSetDescriptors[index++] = __bc_esd;
        
        
        //
        // Add event set descriptors from parent BeanInfo
        //
        super.initEventSetDescriptors(eventSetDescriptors, index);
    }
    
    // java.beans.BeanInfo.getEventSetDescriptors
    public EventSetDescriptor [] getEventSetDescriptors()
    {
        EventSetDescriptor [] __bc_eventSetDescriptors = new EventSetDescriptor[2];
        try
        {
            initEventSetDescriptors(__bc_eventSetDescriptors, 0);
        }
        catch (java.beans.IntrospectionException __bc_ie)
        {
            throw new ControlException("Unable to create EventSetDescriptor", __bc_ie);
        }
        return __bc_eventSetDescriptors;
    }
}
