1256 dimensions = [] |
1256 dimensions = [] |
1257 for dimension in vartype_content.getdimension(): |
1257 for dimension in vartype_content.getdimension(): |
1258 dimensions.append((dimension.getlower(), dimension.getupper())) |
1258 dimensions.append((dimension.getlower(), dimension.getupper())) |
1259 base_type = vartype_content.baseType.getcontent() |
1259 base_type = vartype_content.baseType.getcontent() |
1260 base_type_type = base_type.getLocalTag() |
1260 base_type_type = base_type.getLocalTag() |
1261 if base_type is None or base_type_type in ["string", "wstring"]: |
1261 if base_type_type == "derived": |
|
1262 base_type_name = base_type.getname() |
|
1263 else: |
1262 base_type_name = base_type_type.upper() |
1264 base_type_name = base_type_type.upper() |
1263 else: |
|
1264 base_type_name = base_type.getname() |
|
1265 tempvar["Type"] = ("array", base_type_name, dimensions) |
1265 tempvar["Type"] = ("array", base_type_name, dimensions) |
1266 else: |
1266 else: |
1267 tempvar["Type"] = vartype_content_type.upper() |
1267 tempvar["Type"] = vartype_content_type.upper() |
1268 |
1268 |
1269 tempvar["Edit"] = True |
1269 tempvar["Edit"] = True |
1270 |
1270 |
1271 initial = var.getinitialValue() |
1271 initial = var.getinitialValue() |
1272 if initial is not None: |
1272 if initial is not None: |
1273 tempvar["Initial Value"] = initial.getvalue() |
1273 tempvar["Initial Value"] = initial.getvalue() |
1274 else: |
1274 else: |
1275 tempvar["Initial Value"] = "" |
1275 tempvar["Initial Value"] = "" |
2458 block.settypeName(blocktype) |
2458 block.settypeName(blocktype) |
2459 blocktype_infos = self.GetBlockType(blocktype) |
2459 blocktype_infos = self.GetBlockType(blocktype) |
2460 if blocktype_infos["type"] != "function" and blockname is not None: |
2460 if blocktype_infos["type"] != "function" and blockname is not None: |
2461 block.setinstanceName(blockname) |
2461 block.setinstanceName(blockname) |
2462 self.AddEditedElementPouVar(tagname, blocktype, blockname) |
2462 self.AddEditedElementPouVar(tagname, blocktype, blockname) |
2463 element.addinstance("block", block) |
2463 element.addinstance(block) |
2464 self.Project.RefreshElementUsingTree() |
2464 self.Project.RefreshElementUsingTree() |
2465 |
2465 |
2466 def SetEditedElementBlockInfos(self, tagname, id, infos): |
2466 def SetEditedElementBlockInfos(self, tagname, id, infos): |
2467 element = self.GetEditedElement(tagname) |
2467 element = self.GetEditedElement(tagname) |
2468 if element is not None: |
2468 if element is not None: |
2504 block.sety(value) |
2504 block.sety(value) |
2505 elif param == "connectors": |
2505 elif param == "connectors": |
2506 block.inputVariables.setvariable([]) |
2506 block.inputVariables.setvariable([]) |
2507 block.outputVariables.setvariable([]) |
2507 block.outputVariables.setvariable([]) |
2508 for connector in value["inputs"]: |
2508 for connector in value["inputs"]: |
2509 variable = plcopen.inputVariables_variable() |
2509 variable = PLCOpenParser.CreateElement("variable", "inputVariables") |
|
2510 block.inputVariables.appendvariable(variable) |
2510 variable.setformalParameter(connector.GetName()) |
2511 variable.setformalParameter(connector.GetName()) |
2511 if connector.IsNegated(): |
2512 if connector.IsNegated(): |
2512 variable.setnegated(True) |
2513 variable.setnegated(True) |
2513 if connector.GetEdge() != "none": |
2514 if connector.GetEdge() != "none": |
2514 variable.setedge(connector.GetEdge()) |
2515 variable.setedge(connector.GetEdge()) |
2515 position = connector.GetRelPosition() |
2516 position = connector.GetRelPosition() |
2516 variable.connectionPointIn.setrelPositionXY(position.x, position.y) |
2517 variable.connectionPointIn.setrelPositionXY(position.x, position.y) |
2517 self.SetConnectionWires(variable.connectionPointIn, connector) |
2518 self.SetConnectionWires(variable.connectionPointIn, connector) |
2518 block.inputVariables.appendvariable(variable) |
|
2519 for connector in value["outputs"]: |
2519 for connector in value["outputs"]: |
2520 variable = plcopen.outputVariables_variable() |
2520 variable = PLCOpenParser.CreateElement("variable", "outputVariables") |
|
2521 block.outputVariables.appendvariable(variable) |
2521 variable.setformalParameter(connector.GetName()) |
2522 variable.setformalParameter(connector.GetName()) |
2522 if connector.IsNegated(): |
2523 if connector.IsNegated(): |
2523 variable.setnegated(True) |
2524 variable.setnegated(True) |
2524 if connector.GetEdge() != "none": |
2525 if connector.GetEdge() != "none": |
2525 variable.setedge(connector.GetEdge()) |
2526 variable.setedge(connector.GetEdge()) |
2526 position = connector.GetRelPosition() |
2527 position = connector.GetRelPosition() |
2527 variable.addconnectionPointOut() |
2528 variable.addconnectionPointOut() |
2528 variable.connectionPointOut.setrelPositionXY(position.x, position.y) |
2529 variable.connectionPointOut.setrelPositionXY(position.x, position.y) |
2529 block.outputVariables.appendvariable(variable) |
2530 block.tostring() |
2530 self.Project.RefreshElementUsingTree() |
2531 self.Project.RefreshElementUsingTree() |
2531 |
2532 |
2532 def AddEditedElementVariable(self, tagname, id, type): |
2533 def AddEditedElementVariable(self, tagname, id, var_type): |
2533 element = self.GetEditedElement(tagname) |
2534 element = self.GetEditedElement(tagname) |
2534 if element is not None: |
2535 if element is not None: |
2535 if type == INPUT: |
2536 variable = PLCOpenParser.CreateElement( |
2536 name = "inVariable" |
2537 {INPUT: "inVariable", |
2537 variable = plcopen.fbdObjects_inVariable() |
2538 OUTPUT: "outVariable", |
2538 elif type == OUTPUT: |
2539 INOUT: "inOutVariable"}[var_type], "fbdObjects") |
2539 name = "outVariable" |
|
2540 variable = plcopen.fbdObjects_outVariable() |
|
2541 elif type == INOUT: |
|
2542 name = "inOutVariable" |
|
2543 variable = plcopen.fbdObjects_inOutVariable() |
|
2544 variable.setlocalId(id) |
2540 variable.setlocalId(id) |
2545 element.addinstance(name, variable) |
2541 element.addinstance(variable) |
2546 |
2542 |
2547 def SetEditedElementVariableInfos(self, tagname, id, infos): |
2543 def SetEditedElementVariableInfos(self, tagname, id, infos): |
2548 element = self.GetEditedElement(tagname) |
2544 element = self.GetEditedElement(tagname) |
2549 if element is not None: |
2545 if element is not None: |
2550 variable = element.getinstance(id) |
2546 variable = element.getinstance(id) |
2551 if variable is None: |
2547 if variable is None: |
2552 return |
2548 return |
2553 for param, value in infos.items(): |
2549 for param, value in infos.items(): |
2554 if param == "name": |
2550 if param == "name": |
2555 variable.setexpression(value) |
2551 expression = PLCOpenParser.CreateElement("expression", variable.getLocalTag()) |
|
2552 expression.text = value |
|
2553 variable.setexpression(expression) |
2556 elif param == "executionOrder" and variable.getexecutionOrderId() != value: |
2554 elif param == "executionOrder" and variable.getexecutionOrderId() != value: |
2557 element.setelementExecutionOrder(variable, value) |
2555 element.setelementExecutionOrder(variable, value) |
2558 elif param == "height": |
2556 elif param == "height": |
2559 variable.setheight(value) |
2557 variable.setheight(value) |
2560 elif param == "width": |
2558 elif param == "width": |
2586 position = input.GetRelPosition() |
2584 position = input.GetRelPosition() |
2587 variable.addconnectionPointIn() |
2585 variable.addconnectionPointIn() |
2588 variable.connectionPointIn.setrelPositionXY(position.x, position.y) |
2586 variable.connectionPointIn.setrelPositionXY(position.x, position.y) |
2589 self.SetConnectionWires(variable.connectionPointIn, input) |
2587 self.SetConnectionWires(variable.connectionPointIn, input) |
2590 |
2588 |
2591 def AddEditedElementConnection(self, tagname, id, type): |
2589 def AddEditedElementConnection(self, tagname, id, connection_type): |
2592 element = self.GetEditedElement(tagname) |
2590 element = self.GetEditedElement(tagname) |
2593 if element is not None: |
2591 if element is not None: |
2594 if type == CONNECTOR: |
2592 connection = PLCOpenParser.CreateElement( |
2595 name = "connector" |
2593 {CONNECTOR: "connector", |
2596 connection = plcopen.commonObjects_connector() |
2594 CONTINUATION: "continuation"}[connection_type], "commonObjects") |
2597 elif type == CONTINUATION: |
|
2598 name = "continuation" |
|
2599 connection = plcopen.commonObjects_continuation() |
|
2600 connection.setlocalId(id) |
2595 connection.setlocalId(id) |
2601 element.addinstance(name, connection) |
2596 element.addinstance(connection) |
2602 |
2597 |
2603 def SetEditedElementConnectionInfos(self, tagname, id, infos): |
2598 def SetEditedElementConnectionInfos(self, tagname, id, infos): |
2604 element = self.GetEditedElement(tagname) |
2599 element = self.GetEditedElement(tagname) |
2605 if element is not None: |
2600 if element is not None: |
2606 connection = element.getinstance(id) |
2601 connection = element.getinstance(id) |
2617 connection.setx(value) |
2612 connection.setx(value) |
2618 elif param == "y": |
2613 elif param == "y": |
2619 connection.sety(value) |
2614 connection.sety(value) |
2620 elif param == "connector": |
2615 elif param == "connector": |
2621 position = value.GetRelPosition() |
2616 position = value.GetRelPosition() |
2622 if isinstance(connection, plcopen.commonObjects_continuation): |
2617 if isinstance(connection, PLCOpenParser.GetElementClass("continuation", "commonObjects")): |
2623 connection.addconnectionPointOut() |
2618 connection.addconnectionPointOut() |
2624 connection.connectionPointOut.setrelPositionXY(position.x, position.y) |
2619 connection.connectionPointOut.setrelPositionXY(position.x, position.y) |
2625 elif isinstance(connection, plcopen.commonObjects_connector): |
2620 elif isinstance(connection, PLCOpenParser.GetElementClass("connector", "commonObjects")): |
2626 connection.addconnectionPointIn() |
2621 connection.addconnectionPointIn() |
2627 connection.connectionPointIn.setrelPositionXY(position.x, position.y) |
2622 connection.connectionPointIn.setrelPositionXY(position.x, position.y) |
2628 self.SetConnectionWires(connection.connectionPointIn, value) |
2623 self.SetConnectionWires(connection.connectionPointIn, value) |
2629 |
2624 |
2630 def AddEditedElementComment(self, tagname, id): |
2625 def AddEditedElementComment(self, tagname, id): |
2631 element = self.GetEditedElement(tagname) |
2626 element = self.GetEditedElement(tagname) |
2632 if element is not None: |
2627 if element is not None: |
2633 comment = plcopen.commonObjects_comment() |
2628 comment = PLCOpenParser.CreateElement("comment", "commonObjects") |
2634 comment.setlocalId(id) |
2629 comment.setlocalId(id) |
2635 element.addinstance("comment", comment) |
2630 element.addinstance(comment) |
2636 |
2631 |
2637 def SetEditedElementCommentInfos(self, tagname, id, infos): |
2632 def SetEditedElementCommentInfos(self, tagname, id, infos): |
2638 element = self.GetEditedElement(tagname) |
2633 element = self.GetEditedElement(tagname) |
2639 if element is not None: |
2634 if element is not None: |
2640 comment = element.getinstance(id) |
2635 comment = element.getinstance(id) |
2648 elif param == "x": |
2643 elif param == "x": |
2649 comment.setx(value) |
2644 comment.setx(value) |
2650 elif param == "y": |
2645 elif param == "y": |
2651 comment.sety(value) |
2646 comment.sety(value) |
2652 |
2647 |
2653 def AddEditedElementPowerRail(self, tagname, id, type): |
2648 def AddEditedElementPowerRail(self, tagname, id, powerrail_type): |
2654 element = self.GetEditedElement(tagname) |
2649 element = self.GetEditedElement(tagname) |
2655 if element is not None: |
2650 if element is not None: |
2656 if type == LEFTRAIL: |
2651 powerrail = PLCOpenParser.CreateElement( |
2657 name = "leftPowerRail" |
2652 {LEFTRAIL: "leftPowerRail", |
2658 powerrail = plcopen.ldObjects_leftPowerRail() |
2653 RIGHTRAIL: "rightPowerRail"}[powerrail_type], "ldObjects") |
2659 elif type == RIGHTRAIL: |
|
2660 name = "rightPowerRail" |
|
2661 powerrail = plcopen.ldObjects_rightPowerRail() |
|
2662 powerrail.setlocalId(id) |
2654 powerrail.setlocalId(id) |
2663 element.addinstance(name, powerrail) |
2655 element.addinstance(powerrail) |
2664 |
2656 |
2665 def SetEditedElementPowerRailInfos(self, tagname, id, infos): |
2657 def SetEditedElementPowerRailInfos(self, tagname, id, infos): |
2666 element = self.GetEditedElement(tagname) |
2658 element = self.GetEditedElement(tagname) |
2667 if element is not None: |
2659 if element is not None: |
2668 powerrail = element.getinstance(id) |
2660 powerrail = element.getinstance(id) |
2676 elif param == "x": |
2668 elif param == "x": |
2677 powerrail.setx(value) |
2669 powerrail.setx(value) |
2678 elif param == "y": |
2670 elif param == "y": |
2679 powerrail.sety(value) |
2671 powerrail.sety(value) |
2680 elif param == "connectors": |
2672 elif param == "connectors": |
2681 if isinstance(powerrail, plcopen.ldObjects_leftPowerRail): |
2673 if isinstance(powerrail, PLCOpenParser.GetElementClass("leftPowerRail", "ldObjects")): |
2682 powerrail.setconnectionPointOut([]) |
2674 powerrail.setconnectionPointOut([]) |
2683 for connector in value["outputs"]: |
2675 for connector in value["outputs"]: |
2684 position = connector.GetRelPosition() |
2676 position = connector.GetRelPosition() |
2685 connection = plcopen.leftPowerRail_connectionPointOut() |
2677 connection = PLCOpenParser.CreateElement("connectionPointOut", "leftPowerRail") |
|
2678 powerrail.appendconnectionPointOut(connection) |
2686 connection.setrelPositionXY(position.x, position.y) |
2679 connection.setrelPositionXY(position.x, position.y) |
2687 powerrail.connectionPointOut.append(connection) |
2680 elif isinstance(powerrail, PLCOpenParser.GetElementClass("rightPowerRail", "ldObjects")): |
2688 elif isinstance(powerrail, plcopen.ldObjects_rightPowerRail): |
|
2689 powerrail.setconnectionPointIn([]) |
2681 powerrail.setconnectionPointIn([]) |
2690 for connector in value["inputs"]: |
2682 for connector in value["inputs"]: |
2691 position = connector.GetRelPosition() |
2683 position = connector.GetRelPosition() |
2692 connection = plcopen.connectionPointIn() |
2684 connection = PLCOpenParser.CreateElement("connectionPointIn", "rightPowerRail") |
|
2685 powerrail.appendconnectionPointIn(connection) |
2693 connection.setrelPositionXY(position.x, position.y) |
2686 connection.setrelPositionXY(position.x, position.y) |
2694 self.SetConnectionWires(connection, connector) |
2687 self.SetConnectionWires(connection, connector) |
2695 powerrail.connectionPointIn.append(connection) |
2688 |
2696 |
|
2697 def AddEditedElementContact(self, tagname, id): |
2689 def AddEditedElementContact(self, tagname, id): |
2698 element = self.GetEditedElement(tagname) |
2690 element = self.GetEditedElement(tagname) |
2699 if element is not None: |
2691 if element is not None: |
2700 contact = plcopen.ldObjects_contact() |
2692 contact = PLCOpenParser.CreateElement("contact", "ldObjects") |
2701 contact.setlocalId(id) |
2693 contact.setlocalId(id) |
2702 element.addinstance("contact", contact) |
2694 element.addinstance(contact) |
2703 |
2695 |
2704 def SetEditedElementContactInfos(self, tagname, id, infos): |
2696 def SetEditedElementContactInfos(self, tagname, id, infos): |
2705 element = self.GetEditedElement(tagname) |
2697 element = self.GetEditedElement(tagname) |
2706 if element is not None: |
2698 if element is not None: |
2707 contact = element.getinstance(id) |
2699 contact = element.getinstance(id) |
2708 if contact is None: |
2700 if contact is None: |
2709 return |
2701 return |
2710 for param, value in infos.items(): |
2702 for param, value in infos.items(): |
2711 if param == "name": |
2703 if param == "name": |
2712 contact.setvariable(value) |
2704 variable = PLCOpenParser.CreateElement("variable", "contact") |
|
2705 variable.text = value |
|
2706 contact.setvariable(variable) |
2713 elif param == "type": |
2707 elif param == "type": |
2714 if value == CONTACT_NORMAL: |
2708 if value == CONTACT_NORMAL: |
2715 contact.setnegated(False) |
2709 contact.setnegated(False) |
2716 contact.setedge("none") |
2710 contact.setedge("none") |
2717 elif value == CONTACT_REVERSE: |
2711 elif value == CONTACT_REVERSE: |
2743 contact.connectionPointOut.setrelPositionXY(position.x, position.y) |
2737 contact.connectionPointOut.setrelPositionXY(position.x, position.y) |
2744 |
2738 |
2745 def AddEditedElementCoil(self, tagname, id): |
2739 def AddEditedElementCoil(self, tagname, id): |
2746 element = self.GetEditedElement(tagname) |
2740 element = self.GetEditedElement(tagname) |
2747 if element is not None: |
2741 if element is not None: |
2748 coil = plcopen.ldObjects_coil() |
2742 coil = PLCOpenParser.CreateElement("coil", "ldObjects") |
2749 coil.setlocalId(id) |
2743 coil.setlocalId(id) |
2750 element.addinstance("coil", coil) |
2744 element.addinstance(coil) |
2751 |
2745 |
2752 def SetEditedElementCoilInfos(self, tagname, id, infos): |
2746 def SetEditedElementCoilInfos(self, tagname, id, infos): |
2753 element = self.GetEditedElement(tagname) |
2747 element = self.GetEditedElement(tagname) |
2754 if element is not None: |
2748 if element is not None: |
2755 coil = element.getinstance(id) |
2749 coil = element.getinstance(id) |
2756 if coil is None: |
2750 if coil is None: |
2757 return |
2751 return |
2758 for param, value in infos.items(): |
2752 for param, value in infos.items(): |
2759 if param == "name": |
2753 if param == "name": |
2760 coil.setvariable(value) |
2754 variable = PLCOpenParser.CreateElement("variable", "coil") |
|
2755 variable.text = value |
|
2756 coil.setvariable(variable) |
2761 elif param == "type": |
2757 elif param == "type": |
2762 if value == COIL_NORMAL: |
2758 if value == COIL_NORMAL: |
2763 coil.setnegated(False) |
2759 coil.setnegated(False) |
2764 coil.setstorage("none") |
2760 coil.setstorage("none") |
2765 coil.setedge("none") |
2761 coil.setedge("none") |
2803 coil.connectionPointOut.setrelPositionXY(position.x, position.y) |
2799 coil.connectionPointOut.setrelPositionXY(position.x, position.y) |
2804 |
2800 |
2805 def AddEditedElementStep(self, tagname, id): |
2801 def AddEditedElementStep(self, tagname, id): |
2806 element = self.GetEditedElement(tagname) |
2802 element = self.GetEditedElement(tagname) |
2807 if element is not None: |
2803 if element is not None: |
2808 step = plcopen.sfcObjects_step() |
2804 step = PLCOpenParser.CreateElement("step", "sfcObjects") |
2809 step.setlocalId(id) |
2805 step.setlocalId(id) |
2810 element.addinstance("step", step) |
2806 element.addinstance(step) |
2811 |
2807 |
2812 def SetEditedElementStepInfos(self, tagname, id, infos): |
2808 def SetEditedElementStepInfos(self, tagname, id, infos): |
2813 element = self.GetEditedElement(tagname) |
2809 element = self.GetEditedElement(tagname) |
2814 if element is not None: |
2810 if element is not None: |
2815 step = element.getinstance(id) |
2811 step = element.getinstance(id) |
2853 step.deleteconnectionPointOutAction() |
2849 step.deleteconnectionPointOutAction() |
2854 |
2850 |
2855 def AddEditedElementTransition(self, tagname, id): |
2851 def AddEditedElementTransition(self, tagname, id): |
2856 element = self.GetEditedElement(tagname) |
2852 element = self.GetEditedElement(tagname) |
2857 if element is not None: |
2853 if element is not None: |
2858 transition = plcopen.sfcObjects_transition() |
2854 transition = PLCOpenParser.CreateElement("transition", "sfcObjects") |
2859 transition.setlocalId(id) |
2855 transition.setlocalId(id) |
2860 element.addinstance("transition", transition) |
2856 element.addinstance(transition) |
2861 |
2857 |
2862 def SetEditedElementTransitionInfos(self, tagname, id, infos): |
2858 def SetEditedElementTransitionInfos(self, tagname, id, infos): |
2863 element = self.GetEditedElement(tagname) |
2859 element = self.GetEditedElement(tagname) |
2864 if element is not None: |
2860 if element is not None: |
2865 transition = element.getinstance(id) |
2861 transition = element.getinstance(id) |
2891 position = output_connector.GetRelPosition() |
2887 position = output_connector.GetRelPosition() |
2892 transition.addconnectionPointOut() |
2888 transition.addconnectionPointOut() |
2893 transition.connectionPointOut.setrelPositionXY(position.x, position.y) |
2889 transition.connectionPointOut.setrelPositionXY(position.x, position.y) |
2894 elif infos.get("type", None) == "connection" and param == "connection" and value: |
2890 elif infos.get("type", None) == "connection" and param == "connection" and value: |
2895 transition.setconditionContent("connection", None) |
2891 transition.setconditionContent("connection", None) |
2896 self.SetConnectionWires(transition.condition.content["value"], value) |
2892 self.SetConnectionWires(transition.condition.content, value) |
2897 |
2893 |
2898 def AddEditedElementDivergence(self, tagname, id, type): |
2894 def AddEditedElementDivergence(self, tagname, id, divergence_type): |
2899 element = self.GetEditedElement(tagname) |
2895 element = self.GetEditedElement(tagname) |
2900 if element is not None: |
2896 if element is not None: |
2901 if type == SELECTION_DIVERGENCE: |
2897 divergence = PLCOpenParser.CreateElement( |
2902 name = "selectionDivergence" |
2898 {SELECTION_DIVERGENCE: "selectionDivergence", |
2903 divergence = plcopen.sfcObjects_selectionDivergence() |
2899 SELECTION_CONVERGENCE: "selectionConvergence", |
2904 elif type == SELECTION_CONVERGENCE: |
2900 SIMULTANEOUS_DIVERGENCE: "simultaneousDivergence", |
2905 name = "selectionConvergence" |
2901 SIMULTANEOUS_CONVERGENCE: "simultaneousConvergence"}.get( |
2906 divergence = plcopen.sfcObjects_selectionConvergence() |
2902 divergence_type), "sfcObjects") |
2907 elif type == SIMULTANEOUS_DIVERGENCE: |
|
2908 name = "simultaneousDivergence" |
|
2909 divergence = plcopen.sfcObjects_simultaneousDivergence() |
|
2910 elif type == SIMULTANEOUS_CONVERGENCE: |
|
2911 name = "simultaneousConvergence" |
|
2912 divergence = plcopen.sfcObjects_simultaneousConvergence() |
|
2913 divergence.setlocalId(id) |
2903 divergence.setlocalId(id) |
2914 element.addinstance(name, divergence) |
2904 element.addinstance(divergence) |
|
2905 |
|
2906 DivergenceTypes = [ |
|
2907 (divergence_type, |
|
2908 PLCOpenParser.GetElementClass(divergence_type, "sfcObjects")) |
|
2909 for divergence_type in ["selectionDivergence", "simultaneousDivergence", |
|
2910 "selectionConvergence", "simultaneousConvergence"]] |
|
2911 |
|
2912 def GetDivergenceType(self, divergence): |
|
2913 for divergence_type, divergence_class in self.DivergenceTypes: |
|
2914 if isinstance(divergence, divergence_class): |
|
2915 return divergence_type |
|
2916 return None |
2915 |
2917 |
2916 def SetEditedElementDivergenceInfos(self, tagname, id, infos): |
2918 def SetEditedElementDivergenceInfos(self, tagname, id, infos): |
2917 element = self.GetEditedElement(tagname) |
2919 element = self.GetEditedElement(tagname) |
2918 if element is not None: |
2920 if element is not None: |
2919 divergence = element.getinstance(id) |
2921 divergence = element.getinstance(id) |
2928 divergence.setx(value) |
2930 divergence.setx(value) |
2929 elif param == "y": |
2931 elif param == "y": |
2930 divergence.sety(value) |
2932 divergence.sety(value) |
2931 elif param == "connectors": |
2933 elif param == "connectors": |
2932 input_connectors = value["inputs"] |
2934 input_connectors = value["inputs"] |
2933 if isinstance(divergence, (plcopen.sfcObjects_selectionDivergence, plcopen.sfcObjects_simultaneousDivergence)): |
2935 divergence_type = self.GetDivergenceType(divergence) |
|
2936 if divergence_type in ["selectionDivergence", "simultaneousDivergence"]: |
2934 position = input_connectors[0].GetRelPosition() |
2937 position = input_connectors[0].GetRelPosition() |
2935 divergence.addconnectionPointIn() |
2938 divergence.addconnectionPointIn() |
2936 divergence.connectionPointIn.setrelPositionXY(position.x, position.y) |
2939 divergence.connectionPointIn.setrelPositionXY(position.x, position.y) |
2937 self.SetConnectionWires(divergence.connectionPointIn, input_connectors[0]) |
2940 self.SetConnectionWires(divergence.connectionPointIn, input_connectors[0]) |
2938 else: |
2941 else: |
2939 divergence.setconnectionPointIn([]) |
2942 divergence.setconnectionPointIn([]) |
2940 for input_connector in input_connectors: |
2943 for input_connector in input_connectors: |
2941 position = input_connector.GetRelPosition() |
2944 position = input_connector.GetRelPosition() |
2942 if isinstance(divergence, plcopen.sfcObjects_selectionConvergence): |
2945 connection = PLCOpenParser.CreateElement("connectionPointIn", divergence_type) |
2943 connection = plcopen.selectionConvergence_connectionPointIn() |
2946 divergence.appendconnectionPointIn(connection) |
2944 else: |
|
2945 connection = plcopen.connectionPointIn() |
|
2946 connection.setrelPositionXY(position.x, position.y) |
2947 connection.setrelPositionXY(position.x, position.y) |
2947 self.SetConnectionWires(connection, input_connector) |
2948 self.SetConnectionWires(connection, input_connector) |
2948 divergence.appendconnectionPointIn(connection) |
|
2949 output_connectors = value["outputs"] |
2949 output_connectors = value["outputs"] |
2950 if isinstance(divergence, (plcopen.sfcObjects_selectionConvergence, plcopen.sfcObjects_simultaneousConvergence)): |
2950 if divergence_type in ["selectionConvergence", "simultaneousConvergence"]: |
2951 position = output_connectors[0].GetRelPosition() |
2951 position = output_connectors[0].GetRelPosition() |
2952 divergence.addconnectionPointOut() |
2952 divergence.addconnectionPointOut() |
2953 divergence.connectionPointOut.setrelPositionXY(position.x, position.y) |
2953 divergence.connectionPointOut.setrelPositionXY(position.x, position.y) |
2954 else: |
2954 else: |
2955 divergence.setconnectionPointOut([]) |
2955 divergence.setconnectionPointOut([]) |
2956 for output_connector in output_connectors: |
2956 for output_connector in output_connectors: |
2957 position = output_connector.GetRelPosition() |
2957 position = output_connector.GetRelPosition() |
2958 if isinstance(divergence, plcopen.sfcObjects_selectionDivergence): |
2958 connection = PLCOpenParser.CreateElement("connectionPointOut", divergence_type) |
2959 connection = plcopen.selectionDivergence_connectionPointOut() |
2959 divergence.appendconnectionPointOut(connection) |
2960 else: |
|
2961 connection = plcopen.simultaneousDivergence_connectionPointOut() |
|
2962 connection.setrelPositionXY(position.x, position.y) |
2960 connection.setrelPositionXY(position.x, position.y) |
2963 divergence.appendconnectionPointOut(connection) |
2961 |
2964 |
|
2965 def AddEditedElementJump(self, tagname, id): |
2962 def AddEditedElementJump(self, tagname, id): |
2966 element = self.GetEditedElement(tagname) |
2963 element = self.GetEditedElement(tagname) |
2967 if element is not None: |
2964 if element is not None: |
2968 jump = plcopen.sfcObjects_jumpStep() |
2965 jump = PLCOpenParser.CreateElement("jumpStep", "sfcObjects") |
2969 jump.setlocalId(id) |
2966 jump.setlocalId(id) |
2970 element.addinstance("jumpStep", jump) |
2967 element.addinstance(jump) |
2971 |
2968 |
2972 def SetEditedElementJumpInfos(self, tagname, id, infos): |
2969 def SetEditedElementJumpInfos(self, tagname, id, infos): |
2973 element = self.GetEditedElement(tagname) |
2970 element = self.GetEditedElement(tagname) |
2974 if element is not None: |
2971 if element is not None: |
2975 jump = element.getinstance(id) |
2972 jump = element.getinstance(id) |
2993 self.SetConnectionWires(jump.connectionPointIn, value) |
2990 self.SetConnectionWires(jump.connectionPointIn, value) |
2994 |
2991 |
2995 def AddEditedElementActionBlock(self, tagname, id): |
2992 def AddEditedElementActionBlock(self, tagname, id): |
2996 element = self.GetEditedElement(tagname) |
2993 element = self.GetEditedElement(tagname) |
2997 if element is not None: |
2994 if element is not None: |
2998 actionBlock = plcopen.commonObjects_actionBlock() |
2995 actionBlock = PLCOpenParser.CreateElement("actionBlock", "commonObjects") |
2999 actionBlock.setlocalId(id) |
2996 actionBlock.setlocalId(id) |
3000 element.addinstance("actionBlock", actionBlock) |
2997 element.addinstance(actionBlock) |
3001 |
2998 |
3002 def SetEditedElementActionBlockInfos(self, tagname, id, infos): |
2999 def SetEditedElementActionBlockInfos(self, tagname, id, infos): |
3003 element = self.GetEditedElement(tagname) |
3000 element = self.GetEditedElement(tagname) |
3004 if element is not None: |
3001 if element is not None: |
3005 actionBlock = element.getinstance(id) |
3002 actionBlock = element.getinstance(id) |
3024 |
3021 |
3025 def RemoveEditedElementInstance(self, tagname, id): |
3022 def RemoveEditedElementInstance(self, tagname, id): |
3026 element = self.GetEditedElement(tagname) |
3023 element = self.GetEditedElement(tagname) |
3027 if element is not None: |
3024 if element is not None: |
3028 instance = element.getinstance(id) |
3025 instance = element.getinstance(id) |
3029 if isinstance(instance, plcopen.fbdObjects_block): |
3026 if isinstance(instance, PLCOpenParser.GetElementClass("block", "fbdObjects")): |
3030 self.RemoveEditedElementPouVar(tagname, instance.gettypeName(), instance.getinstanceName()) |
3027 self.RemoveEditedElementPouVar(tagname, instance.gettypeName(), instance.getinstanceName()) |
3031 element.removeinstance(id) |
3028 element.removeinstance(id) |
3032 self.Project.RefreshElementUsingTree() |
3029 self.Project.RefreshElementUsingTree() |
3033 |
3030 |
3034 def GetEditedResourceVariables(self, tagname, debug = False): |
3031 def GetEditedResourceVariables(self, tagname, debug = False): |