public FloatMenuOption_Group(string label, Action action, Designator designator,
MenuOptionPriority priority = MenuOptionPriority.Medium, Action mouseoverGuiAction = null,
Thing revalidateClickTarget = null)
: base(label, action, priority, mouseoverGuiAction, revalidateClickTarget)
{
this.designator = designator;
}
private static void SyncSurrogateToHackDesignator(SyncWorker sync, ref Designator designator)
{
if (sync.isWriting)
{
sync.Write((byte)surrogateToHackHackTypeField(designator));
sync.Write(surrogateToHackTargetField(designator));
var map = surrogateToHackMapField(designator);
// Looks like the map and cell are set in only one method, which is never called
// so we'll most likely end up never syncing them. I'm leaving it for safety, though.
if (map == null)
{
sync.Write(IntVec3.Invalid);
}
else
{
sync.Write(surrogateToHackPosField(designator));
sync.Write(map);
}
}
else
{
designator = (Designator)surrogateToHackConstructor.Invoke(new object[] { (int)sync.Read <byte>() });
surrogateToHackTargetField(designator) = sync.Read <Pawn>();
var pos = sync.Read <IntVec3>();
if (pos.IsValid)
{
surrogateToHackPosField(designator) = pos;
surrogateToHackMapField(designator) = sync.Read <Map>();
}
}
}
public static void DrawInspectGizmoGridFor(IEnumerable <object> selectedObjects, out Gizmo mouseoverGizmo)
{
mouseoverGizmo = null;
try
{
objList.Clear();
objList.AddRange(selectedObjects);
gizmoList.Clear();
for (int i = 0; i < objList.Count; i++)
{
ISelectable selectable = objList[i] as ISelectable;
if (selectable != null)
{
gizmoList.AddRange(selectable.GetGizmos());
}
}
for (int j = 0; j < objList.Count; j++)
{
Thing t = objList[j] as Thing;
if (t == null)
{
continue;
}
List <Designator> allDesignators = Find.ReverseDesignatorDatabase.AllDesignators;
for (int k = 0; k < allDesignators.Count; k++)
{
Designator des = allDesignators[k];
if (!des.CanDesignateThing(t).Accepted)
{
continue;
}
Command_Action command_Action = new Command_Action();
command_Action.defaultLabel = des.LabelCapReverseDesignating(t);
command_Action.icon = des.IconReverseDesignating(t, out var angle, out var offset);
command_Action.iconAngle = angle;
command_Action.iconOffset = offset;
command_Action.defaultDesc = des.DescReverseDesignating(t);
command_Action.order = ((des is Designator_Uninstall) ? (-11f) : (-20f));
command_Action.action = delegate
{
if (TutorSystem.AllowAction(des.TutorTagDesignate))
{
des.DesignateThing(t);
des.Finalize(somethingSucceeded: true);
}
};
command_Action.hotKey = des.hotKey;
command_Action.groupKey = des.groupKey;
gizmoList.Add(command_Action);
}
}
objList.Clear();
GizmoGridDrawer.DrawGizmoGrid(gizmoList, InspectPaneUtility.PaneWidthFor(Find.WindowStack.WindowOfType <IInspectPane>()) + GizmoGridDrawer.GizmoSpacing.y, out mouseoverGizmo);
gizmoList.Clear();
}
catch (Exception ex)
{
Log.ErrorOnce(ex.ToString(), 3427734);
}
}
public static bool NeverChangeIcon(Designator __instance, out Texture2D __result, out float angle, out Vector2 offset)
{
__result = __instance.icon;
offset = default(Vector2);
angle = 0f;
return(false);
}
private void RemoveSelectedDesignation(Designator designator, Map map)
{
// distinct designation defs on selected things
var selectedObjects = new HashSet <object>(Find.Selector.SelectedObjects);
var selectedDesignationDefs = map.designationManager.allDesignations
.Where(des => des.target.Thing != null && selectedObjects.Contains(des.target.Thing))
.GroupBy(des => des.def).Select(grp => grp.Key).ToArray();
var affectedThings = new HashSet <Thing>();
foreach (var designation in map.designationManager.allDesignations.ToArray())
{
if (selectedDesignationDefs.Contains(designation.def))
{
map.designationManager.RemoveDesignation(designation);
if (designation.target.Thing != null)
{
affectedThings.Add(designation.target.Thing);
}
}
}
if (affectedThings.Count > 0)
{
Messages.Message((CancelSelectedDesignationTextKey + SuccessMessageStringIdSuffix).Translate(selectedDesignationDefs.Length, affectedThings.Count), MessageTypeDefOf.TaskCompletion);
}
else
{
Messages.Message((CancelSelectedDesignationTextKey + FailureMessageStringIdSuffix).Translate(), MessageTypeDefOf.RejectInput);
}
}
public override ActivationResult Activate(Designator designator, Map map)
{
var playerFaction = Faction.OfPlayer;
var hitCount = DesignateAllThings(designator, map, t => t.Faction != playerFaction);
return(ActivationResult.FromCount(hitCount, BaseTextKey));
}
private static void CheckHotkey(string key, int orderNum)
{
//code from trying to add feature where hotkeys are allowed where their gizmos do not appear
/*
* if (Find.MainTabsRoot.OpenTab != null && Find.MainTabsRoot.OpenTab.defName.Equals("Inspect") && ((MainTabWindow_Inspect)Find.MainTabsRoot.OpenTab.TabWindow).ShouldShowPaneContents)
* {
* foreach (Gizmo gizmo in ((ISelectable)Find.Selector.SingleSelectedObject).GetGizmos())
* {
* Log.Error(Convert.ToString(gizmo.GetType()));
* }
* }
*/
if (Input.GetKeyDown(key))
{
Designator designator = DefDatabase <DesignationCategoryDef> .AllDefsListForReading[0].AllResolvedDesignators[orderNum];
if (Find.DesignatorManager.SelectedDesignator != designator)
{
Find.DesignatorManager.Select(designator);
if (CheckSelectedDesignatorValid())
{
designator.activateSound.PlayOneShotOnCamera((Map)null);
}
return;
}
SoundDefOf.CancelMode.PlayOneShotOnCamera((Map)null);
Find.DesignatorManager.Deselect();
}
}
public static void DrawInspectGizmoGridFor(IEnumerable <object> selectedObjects, out Gizmo mouseoverGizmo)
{
mouseoverGizmo = null;
try
{
InspectGizmoGrid.objList.Clear();
InspectGizmoGrid.objList.AddRange(selectedObjects);
InspectGizmoGrid.gizmoList.Clear();
for (int i = 0; i < InspectGizmoGrid.objList.Count; i++)
{
ISelectable selectable = InspectGizmoGrid.objList[i] as ISelectable;
if (selectable != null)
{
InspectGizmoGrid.gizmoList.AddRange(selectable.GetGizmos());
}
}
for (int j = 0; j < InspectGizmoGrid.objList.Count; j++)
{
Thing t = InspectGizmoGrid.objList[j] as Thing;
if (t != null)
{
List <Designator> allDesignators = Find.ReverseDesignatorDatabase.AllDesignators;
for (int k = 0; k < allDesignators.Count; k++)
{
Designator des = allDesignators[k];
if (des.CanDesignateThing(t).Accepted)
{
Command_Action command_Action = new Command_Action();
command_Action.defaultLabel = des.LabelCapReverseDesignating(t);
float iconAngle;
Vector2 iconOffset;
command_Action.icon = des.IconReverseDesignating(t, out iconAngle, out iconOffset);
command_Action.iconAngle = iconAngle;
command_Action.iconOffset = iconOffset;
command_Action.defaultDesc = des.DescReverseDesignating(t);
command_Action.order = ((!(des is Designator_Uninstall)) ? -20f : -11f);
command_Action.action = delegate()
{
if (TutorSystem.AllowAction(des.TutorTagDesignate))
{
des.DesignateThing(t);
des.Finalize(true);
}
};
command_Action.hotKey = des.hotKey;
command_Action.groupKey = des.groupKey;
InspectGizmoGrid.gizmoList.Add(command_Action);
}
}
}
}
InspectGizmoGrid.objList.Clear();
GizmoGridDrawer.DrawGizmoGrid(InspectGizmoGrid.gizmoList, InspectPaneUtility.PaneWidthFor(Find.WindowStack.WindowOfType <IInspectPane>()) + 20f, out mouseoverGizmo);
InspectGizmoGrid.gizmoList.Clear();
}
catch (Exception ex)
{
Log.ErrorOnce(ex.ToString(), 3427734, false);
}
}
private void MakeMatchingGrowZone()
{
Designator designator = DesignatorUtility.FindAllowedDesignator<Designator_ZoneAdd_Growing>();
designator.DesignateMultiCell(from tempCell in GrowableCells
where designator.CanDesignateCell(tempCell).Accepted
select tempCell);
}
// if designator has no custom context menu entries but has a stock context menu, still show a right click icon
// detection is not fool-proof, but it's good enough- and better than calling RightClickFloatMenuOptions
private static bool DesignatorShouldHaveFallbackContextMenuProvider(Designator designator)
{
try
{
if (designator.GetType() != typeof(Designator_Build))
{
var hasDesignation = AllowToolController.Instance.Reflection.DesignatorGetDesignationMethod.Invoke(designator, new object[0]) != null;
if (hasDesignation)
{
return(true);
}
var hasDesignateAll = (bool)AllowToolController.Instance.Reflection.DesignatorHasDesignateAllFloatMenuOptionField.GetValue(designator);
if (hasDesignateAll)
{
return(true);
}
var getOptionsMethod = designator.GetType().GetMethod("get_RightClickFloatMenuOptions", HugsLibUtility.AllBindingFlags);
var hasOptionsMethod = getOptionsMethod != null && getOptionsMethod.DeclaringType != typeof(Designator);
if (hasOptionsMethod)
{
return(true);
}
}
}
catch (Exception)
{
// no problem- the designator will just have no handler assigned
}
return(false);
}
public static void CheckForMiningResearch(GameRules __instance, Designator d, ref bool __result)
{
if (d is Designator_Mine && !MiningTechMod.MiningResearchSetting.Value().IsFinished)
{
__result = false;
}
}
public PlacementReport CanPlace(IntVec3 origin)
{
// get rotated cell position
var cell = origin + Position;
// if the designator's check passes, we can safely assume it's OK to build here
if (Designator.CanDesignateCell(cell).Accepted)
{
return(PlacementReport.CanPlace);
}
// otherwise, check if the same thing (or it's blueprint/frame stages) already exists here
// terrain and thing both have bluePrint and frame in thinglist, as are things. Terrains are not a thing, and retrieved with GetTerrain().
var cellDefs = cell.GetThingList(Find.VisibleMap).Select(thing => thing.def).ToList();
if (cellDefs.Contains(BuildableDef as ThingDef) ||
cell.GetTerrain(Find.VisibleMap) == BuildableDef as TerrainDef ||
cellDefs.Contains(BuildableDef.blueprintDef) ||
cellDefs.Contains(BuildableDef.frameDef))
{
return(PlacementReport.Alreadyplaced);
}
// finally, default to returning false.
return(PlacementReport.CanNotPlace);
}
private void DesignateWithPredicate(Designator designator, Map map, Func <Thing, bool> shouldDesignateThing = null, string successMessageKey = null)
{
int hitCount = 0;
foreach (var thing in map.listerThings.ThingsInGroup(DesignatorRequestGroup))
{
if (ValidForDesignation(thing) &&
designator.CanDesignateThing(thing).Accepted&&
!thing.def.designateHaulable &&
(shouldDesignateThing == null || shouldDesignateThing(thing)))
{
designator.DesignateThing(thing);
hitCount++;
}
}
if (successMessageKey == null)
{
successMessageKey = EntryTextKey + SuccessMessageStringIdSuffix;
}
if (hitCount > 0)
{
Messages.Message(successMessageKey.Translate(hitCount), MessageTypeDefOf.TaskCompletion);
}
else
{
Messages.Message((EntryTextKey + FailureMessageStringIdSuffix).Translate(), MessageTypeDefOf.RejectInput);
}
}
public override ActivationResult Activate(Designator designator, Map map)
{
var visibleRect = AllowToolUtility.GetVisibleMapRect();
return(MenuEntry_SelectSimilarAll.SelectSimilarWithFilter(designator, map,
BaseTextKey, BaseMessageKey, t => visibleRect.Contains(t.Position)));
}
public static void Postfix(DesignatorManager __instance, ref Designator __state)
{
if (!DesignatorShapes.ShowControls)
{
return;
}
var selectedDesignator = __instance.SelectedDesignator;
if (selectedDesignator == null)
{
return;
}
if (__state == selectedDesignator)
{
return;
}
DesignatorShapeDef shape;
var announce = true;
if (DesignatorShapes.Settings.AutoSelectShape || DesignatorShapes.CachedTool == null)
{
shape = selectedDesignator.DraggableDimensions switch
{
2 => DesignatorShapeDefOf.RectangleFilled,
_ => DesignatorShapeDefOf.Rectangle,
}
}
;
private static Designator_Build FindAllowedDesignatorRecursive(Designator designator, BuildableDef buildable, bool mustBeVisible)
{
if (!Current.Game.Rules.DesignatorAllowed(designator))
{
return(null);
}
if (mustBeVisible && !designator.Visible)
{
return(null);
}
Designator_Build designator_Build = designator as Designator_Build;
if (designator_Build != null && designator_Build.PlacingDef == buildable)
{
return(designator_Build);
}
Designator_Dropdown designator_Dropdown = designator as Designator_Dropdown;
if (designator_Dropdown != null)
{
for (int i = 0; i < designator_Dropdown.Elements.Count; i++)
{
Designator_Build designator_Build2 = FindAllowedDesignatorRecursive(designator_Dropdown.Elements[i], buildable, mustBeVisible);
if (designator_Build2 != null)
{
return(designator_Build2);
}
}
}
return(null);
}
public static bool DesignateMultiCell(Designator __instance, IEnumerable <IntVec3> __0)
{
if (!Multiplayer.ShouldSync)
{
return(true);
}
// No cells implies Finalize(false), which currently doesn't cause side effects
if (__0.Count() == 0)
{
return(true);
}
Designator designator = __instance;
Map map = Find.CurrentMap;
LoggingByteWriter writer = new LoggingByteWriter();
writer.log.Node("Designate multi cell: " + designator.GetType());
IntVec3[] cellArray = __0.ToArray();
WriteData(writer, DesignatorMode.MultiCell, designator);
Sync.WriteSync(writer, cellArray);
Multiplayer.Client.SendCommand(CommandType.Designator, map.uniqueID, writer.ToArray());
Multiplayer.WriterLog.nodes.Add(writer.log.current);
return(false);
}
private static void WriteData(ByteWriter data, DesignatorMode mode, Designator designator)
{
Type designatorType = designator.GetType();
Sync.WriteSync(data, mode);
Sync.WriteSync(data, (ushort)Array.IndexOf(Sync.designatorTypes, designatorType));
Sync.WriteSyncObject(data, designator, designatorType);
if (designator is Designator_AreaAllowed)
{
Sync.WriteSync(data, Designator_AreaAllowed.SelectedArea);
}
if (designator is Designator_Place place)
{
Sync.WriteSync(data, place.placingRot);
}
if (designator is Designator_Build build && build.PlacingDef.MadeFromStuff)
{
Sync.WriteSync(data, build.stuffDef);
}
if (designator is Designator_Install)
{
Sync.WriteSync(data, ThingToInstall());
}
if (designator is Designator_Zone)
{
Sync.WriteSync(data, Find.Selector.SelectedZone);
}
}
private static void WriteData(ByteWriter data, DesignatorMode mode, Designator designator)
{
Sync.WriteSync(data, mode);
Sync.WriteSync(data, designator);
if (designator is Designator_AreaAllowed)
{
Sync.WriteSync(data, Designator_AreaAllowed.SelectedArea);
}
if (designator is Designator_Place place)
{
Sync.WriteSync(data, place.placingRot);
}
if (designator is Designator_Build build && build.PlacingDef.MadeFromStuff)
{
Sync.WriteSync(data, build.stuffDef);
}
if (designator is Designator_Install)
{
Sync.WriteSync(data, ThingToInstall());
}
if (designator is Designator_Zone)
{
Sync.WriteSync(data, Find.Selector.SelectedZone);
}
}
protected void RemoveDesignationsAction(Designator designator, Map map)
{
int hitCountThings = 0;
int hitCountTiles = 0;
var manager = map.designationManager;
foreach (var des in manager.allDesignations.ToArray())
{
// skip planning designation, as so does cancel
if (des.def == null || !des.def.designateCancelable || des.def == DesignationDefOf.Plan)
{
continue;
}
if (des.target.Thing != null)
{
hitCountThings++;
}
else
{
hitCountTiles++;
}
manager.RemoveDesignation(des);
}
Messages.Message("Designator_context_cancel_desig_msg".Translate(hitCountThings, hitCountTiles), MessageSound.Benefit);
}
private void InjectDesignators()
{
var numDesignatorsInjected = 0;
foreach (var designatorDef in DefDatabase <ThingDesignatorDef> .AllDefs)
{
if (designatorDef.Injected)
{
continue;
}
var resolvedDesignators = designatorDef.Category.AllResolvedDesignators;
var insertIndex = -1;
for (var i = 0; i < resolvedDesignators.Count; i++)
{
if (resolvedDesignators[i].GetType() != designatorDef.insertAfter)
{
continue;
}
insertIndex = i;
break;
}
if (insertIndex >= 0)
{
Designator replacedDesignator = null;
if (designatorDef.replaces != null)
{
// remove the designator to replace, if specified
var replacedIndex = resolvedDesignators.FindIndex(des => designatorDef.replaces.IsInstanceOfType(des));
if (replacedIndex >= 0)
{
replacedDesignator = resolvedDesignators[replacedIndex];
resolvedDesignators.RemoveAt(replacedIndex);
// adjust index to compensate for removed element
if (replacedIndex < insertIndex)
{
insertIndex--;
}
}
else
{
Logger.Warning($"{designatorDef.defName} could not find {designatorDef.replaces} for replacement");
}
}
var designator = InstantiateDesignator(designatorDef.designatorClass, designatorDef, replacedDesignator);
resolvedDesignators.Insert(insertIndex + 1, designator);
designator.SetVisible(IsDesignatorEnabledInSettings(designatorDef));
activeDesignators.Add(new DesignatorEntry(designator, designatorDef.hotkeyDef));
numDesignatorsInjected++;
}
else
{
Logger.Error($"Failed to inject {designatorDef.defName} after {designatorDef.insertAfter.Name}");
}
designatorDef.Injected = true;
}
if (numDesignatorsInjected > 0)
{
Logger.Trace("Injected " + numDesignatorsInjected + " designators");
}
}
public override ActivationResult Activate(Designator designator, Map map)
{
var hitCount = DesignateAllThings(designator, map,
t => t is Plant p && p.Blighted && !p.HasDesignation(DesignationDefOf.CutPlant));
return(ActivationResult.FromCount(hitCount, BaseTextKey));
}
public void BeginListening(ThingIsRelevantFilter callback, Texture2D dragHighlightTex)
{
listening = true;
filterCallback = callback;
dragHighlightMat = MaterialPool.MatFrom(dragHighlightTex, ShaderDatabase.MetaOverlay, Color.white);
invokingDesignator = Find.MapUI.designatorManager.SelectedDesignator;
}
public override void ProcessInput(Event ev)
{
List <FloatMenuOption> list = new List <FloatMenuOption>();
for (int i = 0; i < this.elements.Count; i++)
{
Designator des = this.elements[i];
if (des.Visible)
{
list.Add(new FloatMenuOption(des.LabelCap, delegate
{
base.ProcessInput(ev);
Find.DesignatorManager.Select(des);
this.SetActiveDesignator(des, true);
}, MenuOptionPriority.Default, null, null, 0f, null, null));
}
}
FloatMenu floatMenu = new FloatMenu(list);
floatMenu.vanishIfMouseDistant = true;
floatMenu.onCloseCallback = delegate
{
this.activeDesignatorSet = true;
};
Find.WindowStack.Add(floatMenu);
Find.DesignatorManager.Select(this.activeDesignator);
}
public override ActivationResult Activate(Designator designator, Map map)
{
int hitCountThings = 0;
int hitCountTiles = 0;
var manager = map.designationManager;
foreach (var des in manager.allDesignations.ToArray())
{
// skip planning designation, as so does cancel
if (des.def == null || !des.def.designateCancelable || des.def == DesignationDefOf.Plan)
{
continue;
}
if (des.target.Thing != null)
{
hitCountThings++;
}
else
{
hitCountTiles++;
}
manager.RemoveDesignation(des);
}
return(ActivationResult.SuccessMessage("Designator_context_cancel_desig_msg".Translate(hitCountThings, hitCountTiles)));
}
public Designator ReplaceDesignator(Type searchingFor, Designator replacement)
{
DesignationCategoryDef designationCategoryDef = null;
Designator designator = null;
foreach (DesignationCategoryDef current in from dc in DefDatabase <DesignationCategoryDef> .AllDefs
orderby dc.order descending
select dc)
{
foreach (Designator current2 in current.resolvedDesignators)
{
if (current2.GetType().Equals(searchingFor))
{
designator = current2;
designationCategoryDef = current;
break;
}
}
if (designator != null)
{
break;
}
}
if (designator == null)
{
return(null);
}
int index = designationCategoryDef.resolvedDesignators.IndexOf(designator);
designationCategoryDef.resolvedDesignators[index] = replacement;
return(designator);
}
private static void AddIconReplacementSupport(Command_Toggle toggle, Designator standInDesignator)
{
if (AllowToolController.Instance.Handles.ReplaceIconsSetting.Value)
{
toggle.icon = standInDesignator.icon;
}
}
protected override void VisitDesignator(Designator designator)
{
if (!designator.IsPredefined())
{
ReplaceNonTerminal(designator, designator.Ref as ModelElement);
}
}
public override ActivationResult Activate(Designator designator, Map map)
{
// distinct designation defs on selected things
var selectedObjects = new HashSet <object>(Find.Selector.SelectedObjects);
// also include designations on cells of selected things
var selectedTilePositions = new HashSet <IntVec3>(
selectedObjects.Where(t => t is Thing)
.Select(t => ((Thing)t).Position)
);
var selectedDesignationDefs = map.designationManager.allDesignations
.Where(des => des.target.HasThing ? selectedObjects.Contains(des.target.Thing) : selectedTilePositions.Contains(des.target.Cell))
.Select(des => des.def)
.Distinct()
.ToArray();
var affectedDesignations = new HashSet <LocalTargetInfo>();
foreach (var designation in map.designationManager.allDesignations.ToArray())
{
if (selectedDesignationDefs.Contains(designation.def))
{
map.designationManager.RemoveDesignation(designation);
affectedDesignations.Add(designation.target);
}
}
return(affectedDesignations.Count > 0
? ActivationResult.Success(BaseMessageKey, selectedDesignationDefs.Length, affectedDesignations.Count)
: ActivationResult.Failure(BaseMessageKey));
}
// catch right-clicks and shift-clicks on supported designators and reverse designators. Left clicks return false.
public static bool TryProcessDesignatorInput(Designator designator)
{
try
{
if (Event.current.button == (int)MouseButtons.Left &&
HugsLibUtility.ShiftIsHeld &&
AllowToolController.Instance.Handles.ReverseDesignatorPickSetting)
{
return(TryPickDesignatorFromReverseDesignator(designator));
}
if (Event.current.button == (int)MouseButtons.Right)
{
if (designatorMenuProviders.TryGetValue(designator, out var provider))
{
provider.OpenContextMenu(designator);
return(true);
}
}
}
catch (Exception e)
{
AllowToolController.Logger.ReportException(e);
}
return(false);
}
public GPIO(Designator portExpander, byte pin, GPIOType input, CheckBox chk)
{
PortExpander = portExpander;
Pin = pin;
Input = input;
PullUp = (input==GPIOType.Input || input==GPIOType.nInput); //in our circuit all inputs require pullups
Chk = chk;
}
public static void DesignatorAllowedPostfix(Designator d, ref bool __result)
{
if (!__result || !(d is Designator_Build build))
{
return;
}
__result = CanBuild(__result, build.PlacingDef.defName);
}
public static void Add( Designator designator )
{
if( DesList == null )
{
return;
}
DesList.Add( designator );
}
protected override void VisitDesignator(Designator designator)
{
if (!designator.IsPredefined())
{
ReplaceNonTerminal(designator, designator.Ref as ModelElement);
}
}
public void BeginListening(ThingIsReleveantFilter callback, Texture2D dragHighlightTex) {
listening = true;
filterCallback = callback;
dragHighlightMat = MaterialPool.MatFrom(dragHighlightTex, ShaderDatabase.MetaOverlay, Color.white);
invokingDesignator = DesignatorManager.SelectedDesignator;
}
protected override void VisitDesignator(Designator designator)
{
ModelElement model = designator.Ref as ModelElement;
if (model != null && !designator.IsPredefined())
{
ReplaceText(model.ReferenceName(BaseLocation), designator.Start, designator.End);
}
}
