public void Load(ConfigNode node)
        {
            /* Load action ConfigNodes in order.
             * I'm unsure if node.GetNodes() will return the nodes in sequence,
             * so we'll have to sort it first.
             */

            name = node.GetValue("pid");
            pid  = new Guid(node.GetValue("pid"));

            List <ConfigNode> nodes = new List <ConfigNode>(node.GetNodes("Action"));

            nodes.Sort(
                (ConfigNode comp1, ConfigNode comp2) =>
            {
                int idx1 = 0;
                int idx2 = 0;
                comp1.TryGetValue("idx", ref idx1);
                comp2.TryGetValue("idx", ref idx2);

                return(idx1.CompareTo(idx2));
            }
                );

            foreach (ConfigNode actNode in nodes)
            {
                int idx = 0;
                actNode.TryGetValue("idx", ref idx);
                string type = actNode.GetValue("type");
                if (type == "SupplyLink")
                {
                    SupplyLink act = SupplyChainController.getLinkByGuid(new Guid(actNode.GetValue("id")));
                }
                else if (type == "ResourceTransfer")
                {
                    ResourceTransferAction act = new ResourceTransferAction();
                    act.Load(actNode);
                }
            }

            List <ConfigNode> setNodes = new List <ConfigNode>(node.GetNodes("ConditionSet"));

            foreach (ConfigNode setNode in setNodes)
            {
                List <SequenceCondition> condSet = new List <SequenceCondition>();

                List <ConfigNode> condNodes = new List <ConfigNode>(node.GetNodes("Condition"));
                foreach (ConfigNode condNode in condNodes)
                {
                    SequenceCondition condition = SequenceCondition.LoadFactory(condNode);
                    if (condition != null)
                    {
                        condSet.Add(condition);
                    }
                }

                conditions.Add(condSet);
            }
        }
        public override bool drawEditorWindow()
        {
            GUILayout.BeginVertical();

            /* Resource Transfer view */
            viewScrollPoint = GUILayout.BeginScrollView(viewScrollPoint);

            GUILayout.Label("Vessel: " + action.linkVessel.vessel.name);
            GUILayout.Label("At: " + action.linkVessel.currentLocation.name);

            if (SupplyChainController.instance.vesselsAtPoint.ContainsKey(action.linkVessel.currentLocation))
            {
                /* Vessel selector */
                foreach (Vessel v in SupplyChainController.instance.vesselsAtPoint[action.linkVessel.currentLocation])
                {
                    if (v.Equals(action.linkVessel.vessel))
                    {
                        continue;
                    }

                    if (GUILayout.Button(v.name))
                    {
                        if (SupplyChainController.isVesselTracked(v))
                        {
                            target = SupplyChainController.getVesselTrackingInfo(v);
                        }
                        else
                        {
                            target = new VesselData(v);
                        }

                        onUpdate();

                        selectedXfers  = new Dictionary <int, ResourceTransferAction.ResourceTransfer>();
                        xferDirections = new Dictionary <int, bool>();
                    }
                }

                if (target != null)
                {
                    /* Transfer details editor */
                    HashSet <int> targetRscTypes = target.getResourceTypesOnVessel();
                    HashSet <int> originRscTypes = action.linkVessel.getResourceTypesOnVessel();

                    List <int> combinedRscTypes = new List <int>();
                    foreach (int r in targetRscTypes)
                    {
                        if (originRscTypes.Contains(r))
                        {
                            combinedRscTypes.Add(r);
                        }
                    }


                    foreach (int rsc in combinedRscTypes)
                    {
                        GUILayout.BeginHorizontal();

                        if (!selectedXfers.ContainsKey(rsc))
                        {
                            selectedXfers.Add(rsc, new ResourceTransferAction.ResourceTransfer());
                            selectedXfers[rsc].resourceID = rsc;

                            xferDirections.Add(rsc, false);
                        }

                        GUILayout.Label(PartResourceLibrary.Instance.GetDefinition(rsc).name + ": ");

                        selectedXfers[rsc].type = (ResourceTransferAction.TransferType)GUILayout.SelectionGrid((int)selectedXfers[rsc].type, ResourceTransferEditor.resourceTransferTypeStrings, 3);
                        if (GUILayout.Button(xferDirections[rsc] ? "To Origin" : "To Target"))
                        {
                            xferDirections[rsc] = !xferDirections[rsc];
                        }

                        GUILayout.EndHorizontal();

                        try
                        {
                            selectedXfers[rsc].amount = Convert.ToDouble(GUILayout.TextField(selectedXfers[rsc].amount.ToString()));
                        } catch (FormatException e)
                        {
                            selectedXfers[rsc].amount = 0.0;
                        }

                        selectedXfers[rsc].amount = GUILayout.HorizontalSlider(
                            (float)selectedXfers[rsc].amount, 0, (orgCurResources[rsc] > tgtMaxResources[rsc]) ? (float)tgtMaxResources[rsc] : (float)orgCurResources[rsc]);
                    }
                }
            }
            else
            {
                GUILayout.Label("No vessels available to transfer with.");
            }

            if (GUILayout.Button("Apply"))
            {
                List <ResourceTransferAction.ResourceTransfer> toOrigin = new List <ResourceTransferAction.ResourceTransfer>();
                List <ResourceTransferAction.ResourceTransfer> toTarget = new List <ResourceTransferAction.ResourceTransfer>();

                foreach (ResourceTransferAction.ResourceTransfer xfer in selectedXfers.Values)
                {
                    if (xfer.type == ResourceTransferAction.TransferType.TRANSFER_AMOUNT && xfer.amount < 1)
                    {
                        continue;
                    }

                    if (xferDirections[xfer.resourceID])
                    {
                        toOrigin.Add(xfer);
                    }
                    else
                    {
                        toTarget.Add(xfer);
                    }
                }

                this.action.toTarget     = toTarget;
                this.action.toOrigin     = toOrigin;
                this.action.targetVessel = target;
            }

            if (GUILayout.Button("Back"))
            {
                return(true);
            }


            GUILayout.EndScrollView();
            GUILayout.EndVertical();

            return(false);
        }