| ############################################################################### |
| # Copyright (c) 2011, 2012, 2013, 2014 Red Hat, Inc. |
| # All rights reserved. |
| # This program is made available under the terms of the |
| # Eclipse Public License v1.0 which accompanies this distribution, |
| # and is available at http://www.eclipse.org/legal/epl-v10.html |
| # |
| # Contributors: |
| # Red Hat, Inc. - initial API and implementation |
| ############################################################################### |
| Activator_Error=An error occured |
| InputMessageAdapter_0=Input Message |
| MessageAdapter_Message_1=Message |
| OperationAdapter_Operation_1=Operation |
| OperationAdapter_0={0} - {1} |
| OutputMessageAdapter_0=Output Message |
| PartAdapter_Part_1=Part |
| PortTypeAdapter_Port_Type_2=Interface |
| FaultAdapter_Fault_1=Fault |
| XSDAttributeDeclarationAdapter_XSD_Attribute_1=XSD Attribute |
| XSDElementDeclarationAdapter_XSD_Element_1=XSD Element |
| XSDTypeDefinitionAdapter_XSD_Type_1=XSD Type |
| XSDSimpleTypeDefinitionAdapter_0=Simple Type Definition |
| XSDComplexTypeDefinitionAdapter_0=Complex Type Definition |
| XSDSchemaAdapter_0=Schema |
| XSDSchemaAdapter_1=Schema targetNamespace={0} |
| XSDSchemaTreeNode_0=Schema |
| XSDSchemaTreeNode_1=Schema targetNamespace={0} |
| |
| SchemaImportDialog_Browse_WSDL_Title=Browse for a WSDL File to Import |
| SchemaImportDialog_Browse_XML_Title=Browse for an XML File to Import |
| SchemaImportDialog_Browse_XSD_Title=Browse for an XML Schema File to Import |
| SchemaImportDialog_Import_Type_Title=Import Type |
| SchemaImportDialog_Import_Source_Title=Import Source |
| SchemaImportDialog_Workspace_Button=Workspace |
| SchemaImportDialog_File_System_Button=File System |
| SchemaImportDialog_URL_Button=URL |
| SchemaImportDialog_Location_Label=Location: |
| SchemaImportDialog_Browse_Button=Browse ... |
| SchemaImportDialog_Select_Resource_Title=Select a Workspace Resource to Import |
| SchemaImportDialog_Types_Label=Available Types: |
| SchemaImportDialog_Structure_Label=Structure: |
| SchemaImportDialog_Invalid_Location=Invalid location syntax. |
| SchemaImportDialog_Ports_Title=Ports and Partner Links: |
| SchemaImportDialog_Loading_Message=Loading {0} ... |
| SchemaImportDialog_Loaded_Message=Loaded {0} [{1}ms] |
| SchemaImportDialog_Load_Failed_Message=Failed to load {0} [{1}ms] |
| |
| SchemaImportDialog_XSD_Button=XML Schema (XSD) |
| SchemaImportDialog_WSDL_Button=Web Service Definition (WSDL) |
| SchemaImportDialog_Java_Button=Java |
| SchemaImportDialog_Browse_Java_Title=Browse for a Java type to Import |
| SchemaImportDialog_Java_Types_Label=Java Types: |
| SchemaImportDialog_Load_Button=Load |
| SchemaImportDialog_Type_Label=Type: |
| SchemaImportDialog_BPMN2_Button=BPMN 2.0 Diagram (BPMN2) |
| SchemaImportDialog_Browse_BPMN2_Title=Browse for a BPMN2 File to Import |
| SchemaImportDialog_Interfaces_Label=Interfaces and Participants: |
| SchemaImportDialog_Select_Java_Message=Please select a Java Type |
| |
| ModelTreeLabelProvider_s1_s2={0} \: {1} |
| |
| Bpmn2EditorAppearancePreferencePage_Apply_All=Apply changes to all |
| Bpmn2EditorAppearancePreferencePage_Labels_Title=Labels |
| Bpmn2EditorPreferencePage_Colors_Group=Colors and Line Styles |
| Bpmn2EditorPreferencePage_GraphicalElements_Group=Graphical Elements |
| |
| Bpmn2EditorPreferencePage_GridHeight=Grid Height |
| Bpmn2EditorPreferencePage_GridWidth=Grid Width |
| Bpmn2EditorPreferencePage_SnapToGrid=Snap to Grid |
| |
| Bpmn2EditorPreferencePage_DefaultHeight=Default Height |
| Bpmn2EditorPreferencePage_DefaultWidth=Default Width |
| Bpmn2EditorPreferencePage_UseDefaultSize=Use defaults instead of size defined in BPMN2 files |
| |
| Bpmn2EditorPreferencePage_Change_Button=Change |
| Bpmn2EditorPreferencePage_Fill_Color_Label=&Background Color: |
| Bpmn2EditorPreferencePage_Foreground_Color_Label=&Foreground Color: |
| Bpmn2EditorPreferencePage_Label_Color_Label=&Label Color: |
| Bpmn2EditorPreferencePage_Label_Font_Label=Label &Font: |
| Bpmn2EditorPreferencePage_MultiSelected_Color_Label=&Multi-Selected Color: |
| Bpmn2EditorPreferencePage_Routing_Style_Label=Routing Style: |
| Bpmn2EditorPreferencePage_Label_Location_Label=Location relative to Figure: |
| Bpmn2EditorPreferencePage_Selected_Color_Label=&Selected Color: |
| Bpmn2HomePreferencePage_Default_DI_Values_Title=Default values for BPMN Diagram Interchange (DI) optional attributes |
| Bpmn2PreferencePage_HomePage_Description=General settings for the BPMN2 Modeler |
| Bpmn2PreferencePage_HomePage_Resolve_Externals_Always=Always |
| Bpmn2PreferencePage_HomePage_Resolve_Externals_Never=Never |
| Bpmn2PreferencePage_HomePage_Resolve_Externals_Prompt=Prompt |
| Bpmn2PropertyPage_Enable_BPMN2_Project_Nature=Enable BPMN2 Project Nature |
| Bpmn2PropertyPage_HomePage_Description=Project specific settings for the BPMN2 Modeler |
| |
| # |
| # Long descriptions of BPMN2 elements |
| UI_UnknownDiagram_description = The Diagram Type has not yet been defined. |
| UI_Process_description = A Process describes a sequence or flow of Activities in an organization with the objective of carrying out work. \ |
| A Process is depicted as a graph of Flow Elements, which are a set of Activities, Events, Gateways, and \ |
| Sequence Flows that define finite execution semantics. Processes can be defined at any level from \ |
| enterprise-wide Processes to Processes performed by a single person. Low-level Processes can be grouped \ |
| together to achieve a common business goal. |
| UI_Choreography_description = A Choreography formalizes the way business \ |
| Participants coordinate their interactions. The focus is not on orchestrations of the work performed within these \ |
| Participants, but rather on the exchange of information (Messages) between these Participants. |
| UI_Collaboration_description = A Collaboration usually contains two or more Pools, representing the Participants in the Collaboration. \ |
| The Message exchange between the Participants is shown by a Message Flow that connects two Pools (or the objects \ |
| within the Pools). The Messages associated with the Message Flows MAY also be shown. \ |
| A Pool MAY be empty, a "black box", or MAY show a Process within ("white box"). Choreographies MAY be shown in \ |
| between the Pools as they bisect the Message Flows between the Pools. All combinations of Pools, Processes, \ |
| and a Choreography are allowed in a Collaboration. |
| |
| UI_SequenceFlow_description = A Sequence Flow is used to show the order that \ |
| Activities will be performed in a Process or a Choreography. \ |
| A Sequence Flow can optionally define a condition Expression, indicating that control will be passed down the \ |
| Sequence Flow only if the Expression evaluates to true. This Expression is typically used when the source of \ |
| the Sequence Flow is a Gateway or an Activity. \ |
| A Sequence Flow that has an Exclusive, Inclusive, or Complex Gateway or an Activity as its source can also be \ |
| defined as "default". Such a Sequence Flow will have a marker to show that it is a default flow. The default \ |
| Sequence Flow is taken only if all the other outgoing Sequence Flows from the Activity or \ |
| Gateway are not valid (i.e., their condition Expressions are false). |
| UI_MessageFlow_description = A Message Flow is used to show the flow of Messages between two Participants that are \ |
| prepared to send and receive them. In BPMN, two separate Pools in a Collaboration Diagram will represent the two \ |
| Participants (e.g., PartnerEntities and/or PartnerRoles). |
| UI_Association_description = An Association is used to link information and Artifacts with BPMN graphical elements. \ |
| Text Annotations and other Artifacts can be Associated with the graphical elements. An arrowhead on the Association indicates \ |
| a direction of flow (e.g., data), when appropriate. |
| UI_DataInputAssociation_description = Data Associations are used to link Data Objects with Activity inputs or outputs. \ |
| An arrowhead indicates the direction of the flow of data. |
| UI_DataOutputAssociation_description = Data Associations are used to link Data Objects with Activity inputs or outputs. \ |
| An arrowhead indicates the direction of the flow of data. |
| |
| UI_Task_description = A Task is an atomic Activity that is included within a Process. \ |
| A Task is used when the work in the Process is not broken down to a finer level of Process detail. |
| UI_Task_tooltip = Simple Task |
| UI_ManualTask_description = A Manual Task is a Task that is not managed by any business process engine. It can be considered as an unmanaged \ |
| Task, unmanaged in the sense of that the business process engine does not track the start and completion of such a Task. \ |
| An example of this could be a paper based instruction for a telephone technician to install a telephone at a customer location. |
| UI_ManualTask_tooltip = Manual Task |
| UI_UserTask_description = A User Task is a typical workflow Task where a human performer performs the Task with the assistance of a \ |
| software application. The lifecycle of the Task is managed by a software component (called task manager) and is \ |
| typically executed in the context of a Process. \ |
| The User Task can be implemented using different technologies, specified by the implementation attribute. Besides \ |
| the Web service technology, any technology can be used. A User Task for instance can be implemented using WSHumanTask \ |
| by setting the implementation attribute to http://docs.oasis-open.org/ns/bpel4people/ws-humantask/protocol/200803. |
| UI_UserTask_tooltip = User Task |
| UI_BusinessRuleTask_description = A Business Rule Task provides a mechanism for the Process to provide input to a Business Rules Engine and to get \ |
| the output of calculations that the Business Rules Engine might provide. |
| UI_BusinessRuleTask_tooltip = Business Rule Task |
| UI_ServiceTask_description = A Service Task is a Task that uses some sort of service, which could be a Web service or an automated application. |
| UI_ServiceTask_tooltip = Service Task |
| UI_SendTask_description = A Send Task is a simple Task that is designed to send a Message to an external Participant (relative to the \ |
| Process). Once the Message has been sent, the Task is completed. |
| UI_SendTask_tooltip = Send Task |
| UI_ReceiveTask_description = A Receive Task is a simple Task that is designed to wait for a Message to arrive from an external Participant \ |
| (relative to the Process). Once the Message has been received, the Task is completed. |
| UI_ReceiveTask_tooltip = Receive Task |
| UI_ChoreographyTask_description = A Choreography Task is an atomic Activity in a Choreography Process. It represents an Interaction, which is one \ |
| or two Message exchanges between two Participants. |
| UI_ScriptTask_description = A Script Task is executed by a business process engine.\ |
| The modeler or implementer defines a script in a language that the engine can interpret.\ |
| When the Task is ready to start, the engine will execute the script.\ |
| When the script is completed, the Task will also be completed. |
| |
| UI_StartEvent_description = As the name implies, the Start Event indicates where a particular Process will start. In terms of Sequence Flows, the\ |
| Start Event starts the flow of the Process, and thus, will not have any incoming Sequence Flows and no Sequence\ |
| Flow can connect to a Start Event. \ |
| A Start Event may have one or more event triggers (Event Definitions) which cause the Process to be initiated. |
| UI_EndEvent_description = As the name implies, the End Event indicates where a Process will end. In terms of Sequence Flows, the End \ |
| Event ends the flow of the Process, and thus, will not have any outgoing Sequence Flows and no Sequence Flow can \ |
| connect from an End Event. \ |
| An End Event may have one or more triggers (Event Definitions), which are passed back to an invoking or containing Process (if any). |
| UI_IntermediateThrowEvent_description = The Intermediate Throw Event is used to report some kind of condition (Event Definition) to \ |
| an invoking or containing Process. The receiving Process should be designed so that it is prepared to handle the event with either a \ |
| Start Event, Intermediate Catch Event or a Boundary Event. |
| UI_IntermediateCatchEvent_description = The Intermediate Catch Event is used to handle some kind of condition (Event Definition) \ |
| that has occurred within the process or in an external process. |
| UI_BoundaryEvent_description = Boundary Events are attached to the borders of an Activity and are used to handle conditions (Event Definitions) \ |
| that may have resulted during execution of the Activity. |
| |
| UI_DataStore_description = A DataStore provides a mechanism for Activities to retrieve or update stored information that will persist beyond the scope of the Process. \ |
| The same DataStore can be visualized, through a Data Store Reference, in one or more places in the Process. |
| UI_DataStoreReference_description = A DataStore provides a mechanism for Activities to retrieve or update stored information that will persist beyond the scope of the Process. \ |
| The same DataStore can be visualized, through a Data Store Reference, in one or more places in the Process. |
| UI_DataInput_description = Activities and Processes often required data in order to execute. In addition they may produce data during or as a result of execution. \ |
| Data requirements are captured as Data Inputs and Input Sets. |
| UI_DataOutput_description = Activities and Processes often required data in order to execute. In addition they may produce data during or as a result of execution. \ |
| Data that is produced is captured using Data Outputs and Output Sets. |
| UI_ItemDefinition_description = Specifies the nature and structure of data objects that can be manipulated, transferred, transformed and stored in a Process. \ |
| Data Objects can be either physical in nature, such as the mechanical part of a vehicle, or informational, such as a catalog of the mechanical parts of a vehicle. \ |
| Informational items are typically represented as data structures, which are defined by the Type Language of the Process or in an Import file. |
| UI_Message_description = A Message represents the content of a communication between two Participants. |
| |
| UI_Error_description = An Error represents the content of an Error Event or the Fault of a failed Operation. An ItemDefinition is \ |
| used to specify the structure of the Error. An Error is generated when there is a critical problem in the processing of \ |
| an Activity or when the execution of an Operation failed. |
| UI_Signal_description = A Signal defines a more general, non-error condition for \ |
| interrupting Activities such as the successful completion of another Activity. \ |
| An ItemDefinition is used to specify the structure of the Signal. |
| UI_Escalation_description = An Escalation identifies a business situation that a Process might need to react to. An ItemDefinition is used \ |
| to specify the structure of the Escalation. |
| UI_EndPoint_description = The EndPoint is an extension element that may be used by a particular implementation to define Service types and addressing, etc. |
| UI_Category_description = Categories, which have user-defined semantics, can be used for documentation or analysis purposes. \ |
| For example, activities can be categorized as being customer oriented vs. support oriented. |
| UI_Interface_description = An Interface defines a set of operations that are implemented by Services. |
| UI_Operation_description = An Operation defines Messages that are consumed and, optionally, produced by an Interface when the Operation is called. \ |
| It can also define zero or more errors that are returned when operation fails. |
| UI_CancelEventDefinition_description = Cancel Events are only used in the context of modeling Transaction Sub-Processes. \ |
| Cancel Events are sent when a Transaction is canceled. |
| UI_CompensateEventDefinition_description = Compensation Events are used in the context of triggering or handling compensation of \ |
| a failed Activity by undoing steps that were already successfully completed, because their results and \ |
| possibly side effects are no longer desired and need to be reversed. |
| UI_ConditionalEventDefinition_description = |
| UI_ErrorEventDefinition_description = |
| UI_EscalationEventDefinition_description = |
| UI_LingEventDefinition_description = |
| UI_MessageEventDefinition_description = |
| UI_SignalEventDefinition_description = |
| UI_TerminateEventDefinition_description = |
| UI_TimerEventDefinition_description = |
| |
| UI_DataObject_description = Data Objects are the primary construct for modeling data within the Process flow.\ |
| A Data Object has a well-defined lifecycle and structure. A Data Object can appear multiple times in a Process diagram,\ |
| each of which references the same Data Object instance. These references are used to simplify diagram connections. |
| UI_DataObjectReference_description = Data Objects are the primary construct for modeling data within the Process flow.\ |
| A Data Object has a well-defined lifecycle and structure. A Data Object can appear multiple times in a Process diagram,\ |
| each of which references the same Data Object instance. These references are used to simplify diagram connections. |
| UI_ExclusiveGateway_description = A diverging Exclusive Gateway (Decision) is used to create alternative paths within a Process flow. This is basically \ |
| the "diversion point in the road" for a Process. For a given instance of the Process, only one of the paths can be taken. \ |
| A Decision can be thought of as a question that is asked at a particular point in the Process. The question has a defined \ |
| set of alternative answers. Each answer is associated with a condition Expression that is associated with a Gateway's \ |
| outgoing Sequence Flows. |
| UI_InclusiveGateway_description = A diverging Inclusive Gateway (Inclusive Decision) can be used to create alternative but also parallel paths within a \ |
| Process flow. Unlike the Exclusive Gateway, all condition Expressions are evaluated. The true evaluation of one \ |
| condition Expression does not exclude the evaluation of other condition Expressions. All Sequence Flows with \ |
| a true evaluation will be traversed by a token. Since each path is considered to be independent, all combinations of the \ |
| paths MAY be taken, from zero to all. However, it should be designed so that at least one path is taken. |
| UI_ParallelGateway_description = A Parallel Gateway is used to synchronize (combine) parallel flows and to create parallel flows. \ |
| A Parallel Gateway creates parallel paths without checking any conditions; each outgoing Sequence Flow is passed control upon execution of this Gateway. \ |
| For incoming flows, the Parallel Gateway will wait for all incoming flows before triggering the flow through its outgoing Sequence Flows. |
| UI_EventBasedGateway_description = The Event-Based Gateway represents a branching point in the Process where the alternative paths that follow the \ |
| Gateway are based on Events that occur, rather than the evaluation of Expressions using Process data (as with an \ |
| Exclusive or Inclusive Gateway). A specific Event, usually the receipt of a Message, determines the path that will \ |
| be taken. Basically, the decision is made by another Participant, based on data that is not visible to Process, thus, \ |
| requiring the use of the Event-Based Gateway. |
| UI_ComplexGateway_description = The Complex Gateway can be used to model complex synchronization behavior. An Expression \ |
| is used to describe the precise behavior. For example, this Expression could specify that \ |
| three out of five incoming Sequence Flows are needed to activate the Gateway. The outgoing paths that are taken \ |
| by the Gateway is determined by conditions on the outgoing Sequence Flows as in the split behavior of the Inclusive Gateway. |
| |
| UI_Participant_description = A Pool is the graphical representation of a Participant in a Collaboration or Choreography and can be a \ |
| specific PartnerEntity (e.g., a company) or can be a more general PartnerRole (e.g., a buyer, seller, or \ |
| manufacturer). A Pool MAY or MAY NOT reference a Process. A Pool is NOT REQUIRED to contain a Process, \ |
| i.e., it can be a black box. |
| UI_ParticipantBand_description = A Participant Band in a Choreography Task represents one of the partners in a business transaction. \ |
| Only one of the Participants may the initiator (the light colored band) of the business transaction. \ |
| The non-initiating Participants are shown as dark colored bands. |
| UI_Lane_description = A Lane is a sub-partition within a Process (often within a Pool) used to organize and categorize Activities within a Pool. \ |
| Lanes are often used for such things as internal roles (e.g., Manager, \ |
| Associate), systems (e.g., an enterprise application), an internal department (e.g., shipping, finance), etc. In addition, \ |
| Lanes can be nested or defined in a matrix. For example, there could be an outer set of Lanes for \ |
| company departments and then an inner set of Lanes for roles within each department. |
| UI_SubProcess_description = A Sub-Process is an Activity whose internal details have been modeled using Activities, Gateways, Events, and \ |
| Sequence Flows. Sub-Processes define a contextual scope that can be used for attribute visibility, transactional \ |
| scope, for the handling of exceptions, of Events, or for compensation. A Sub-Process can be in a collapsed view that hides its details \ |
| or in an expanded view that shows its details within the view of the Process in which it is contained. |
| UI_Transaction_description = A Transaction is a specialized Sub-Process that is executed atomically, that is, all of its contained activities \ |
| either execute successfully to completion, or their combined effects (primarily on data) are rolled back. |
| UI_SubChoreography_description = A Sub-Choreography is a compound Activity in that it has detail that is defined as a flow of other Activities, in this \ |
| case, a Choreography. Each Sub-Choreography involves two or more Participants. The name of the Sub-Choreography and each of the Participants are all displayed \ |
| in the different bands that make up the graphical notation. There are two or more Participant Bands and one Sub-Process Name Band. |
| UI_CallActivity_description = A Call Activity identifies a point in the Process where a global Process or a Global Task is used. The Call \ |
| Activity acts as a wrapper for the invocation of a global Process or Global Task within the execution. The \ |
| activation of a call Activity results in the transfer of control to the called global Process or Global Task. |
| UI_Conversation_description = A Conversation is an atomic element for a Conversation (Collaboration) diagram. It represents a set of Message \ |
| Flows grouped together based on a concept and/or a CorrelationKey. A Conversation will involve two or more Participants. |
| UI_ConversationLink_description = Conversation Links are used to connect Conversations to and from Participants (Pools.) |
| UI_CallConversation_description = A Call Conversation identifies a place in the Conversation (Collaboration) where a global Conversation or a \ |
| GlobalConversation is used. |
| UI_SubConversation_description = A Sub-Conversation is a ConversationNode that is a hierarchical division within the parent Collaboration. \ |
| A Sub-Conversation is a graphical object within a Collaboration, but it also can be expanded to show the lower level \ |
| details of the Conversation, which consist of Message Flows, Conversations, and/or other Sub-Conversations. \ |
| The Sub-Conversation shares the Participants of its parent Conversation. |
| UI_CallChoreography_description = A Call Choreography identifies a point in the Process where a global Choreography or a Global Choreography Task is used. \ |
| The Call Choreography acts as a place holder for the inclusion of the Choreography element it is calling. |
| UI_AdHocSubProcess_description = An Ad-Hoc Sub-Process contains any number of embedded inner Activities \ |
| and is intended to be executed with a more flexible ordering compared to the typical routing of Processes. \ |
| The contained Activities are executed sequentially or in parallel, they can be executed multiple times in an \ |
| order that is only constrained through the specified Sequence Flows, Gateways, and data connections. |
| UI_Group_description = The Group object is an Artifact that provides a visual mechanism to group elements of a diagram informally. \ |
| A Group is not an Activity or any Flow Object, and, therefore, cannot connect to Sequence \ |
| Flows or Message Flows. In addition, Groups are not constrained by restrictions of Pools and Lanes. This means \ |
| that a Group can stretch across the boundaries of a Pool to surround Diagram elements, often to \ |
| identify Activities that exist within a distributed business-to-business transaction. \ |
| Groups are often used to highlight certain sections of a Diagram and do not affect the flow of the Process. |
| UI_TextAnnotation_description = Text Annotations are a mechanism for providing additional information to the reader of a BPMN Diagram. \ |
| The Text Annotation object can be connected to a specific object on the Diagram with an Association, but does not \ |
| affect the flow of the Process. |
| |
| |
| UI_Any_name_description = Descriptive name |
| UI_Documentation_text_description = Comments or other documentation about this activity.\n\ |
| This is ignored during process execution. |
| UI_Any_isForCompensation_description = \ |
| A flag that identifies whether this Activity is intended for the purposes of\n\ |
| compensation.\n\n\ |
| If false, then this Activity executes as a result of normal execution flow.\n\ |
| If true, this Activity is only activated when a Compensation Event is\n\ |
| detected and initiated under Compensation Event visibility scope |
| UI_DataInput_name_description = \ |
| Name of the Input Data Item to which a Process variable\n\ |
| or expression is assigned before the activity is executed. |
| UI_DataInputAssociation_sourceRef_description = \ |
| A Process variable assigned to the activity's Input Data Item\n\ |
| before the activity is executed |
| UI_DataOutput_name_description = \ |
| Name of the Output Data Item containing the results of the activity (if any).\n\ |
| The results are assigned to a Process variable before execution of the Process continues. |
| UI_DataOutputAssociation_targetRef_description = \ |
| A Process variable to which the activity's results (if any) are assigned. |
| UI_Any_implementation_description = \ |
| specifies the technology that will be used to send\n\ |
| and receive the Messages. Valid values are "Unspecified"\n\ |
| for leaving the implementation technology open,\n\ |
| "WebService" for the Web service technology or a URI\n\ |
| identifying any other technology or coordination protocol. |
| UI_Any_operationRef_description = \ |
| Specifies the operation that is invoked by a Service Task. |
| UI_Any_messageRef_description = \ |
| Message to be sent or received by this task. |
| UI_Any_instantiate_description = \ |
| If checked, causes a new instance of the Process to be created. |
| UI_Any_itemSubjectRef_description = \ |
| Specification of the items that are stored or conveyed by the parameter:\n\ |
| defines the data structure, cardinality, data state and nature of the item. |
| UI_Any_itemKind_description = \ |
| Defines the nature of the data item:\n\ |
| Physical - some kind of real object, such as an Invoice or an Order, which\n\ |
| MAY eventually be represented as a data structure in an executable Process.\n\ |
| Physical items should only be used for documentation purposes, or as place\n\ |
| holders for data structures to be defined later in the Process development.\n\ |
| Information - a data structure that explicitly defines the ordering\n\ |
| and data types of the individual elements, such as an XML Schema or a Java type. |
| UI_Any_isCollection_description = \ |
| If checked, the data item is a collection of elements rather than a single instance. |
| UI_Any_structureRef_description = \ |
| If the Item Kind is \"Physical\" this is a free-form description of the physical item and can not be directly\n\ |
| manipulated by an executable Process.\n\ |
| If Item Kind is \"Information\" this defines the item's data structure, for example an XML Schema or Java type. |
| UI_Any_dataState_description = \ |
| Defines the state of the data, for example an Order may be "Submitted", "Rejected", "Fulfilled" etc. |
| |
| CommonLabels_Data_Type=Data Type |
| DefaultSchemaImportDialog_XSD_Type=XSD Schema |
| DefaultSchemaImportDialog_XML_Filter=XML Files |
| DefaultSchemaImportDialog_XSD_Filter=XML Schema Files |
| DefaultSchemaImportDialog_WSDL_Type=WSDL |
| DefaultSchemaImportDialog_BPMN2_Type=BPMN2 |
| DefaultSchemaImportDialog_Missing_Namespace_Message=This {0} does not define a target namespace |
| DefaultSchemaImportDialog_All=All |
| DefaultSchemaImportDialog_BPMN2_Filter_1=BPMN 2.0 Diagram Files |
| DefaultSchemaImportDialog_BPMN2_Filter_2=BPMN 2.0 Diagram Files |
| DefaultSchemaImportDialog_Java_Filter_1=Java Source Files |
| DefaultSchemaImportDialog_Java_Filter_2=Compiled Java Files |
| DefaultSchemaImportDialog_Java_Filter_3=Java Archives |
| DefaultSchemaImportDialog_WSDL_Filter=WSDL Definition Files |