public static void RemoveItems(IProjectVersion version, string[] items)
{
foreach (var name in items)
{
TearDownComposite(name);
var steelArr = version.DefaultStructureArrangement;
var subArrs = steelArr.ElementaryArrangements;
var arr = subArrs.FirstOrDefault(a => a.Names.Contains(name));
if (arr == null)
{
continue;
}
arr.Remove(name);
var itemVM = FindItemByName(BrowserVM.ActualRoot, name);
if (itemVM == null)
{
continue;
}
var nodeVM = itemVM.Parent;
var method = nodeVM.GetType().GetMethod("RemoveChild", BindingFlags.NonPublic | BindingFlags.Instance);
method.Invoke(nodeVM, new object[] { itemVM });
((ObjectBrowserNodeViewModel)nodeVM).NotifyCountChanged();
}
}
public static void AddItems(IProjectVersion version, IEnumerable <string> path, string[] items)
{
var vm = BrowserVM;
var node = GetNode(version, vm, vm.ActualRoot, path);
AddDrawablesToNode(vm, node, items);
}
private static ObjectBrowserNodeViewModel GetNode(IProjectVersion version, NapaArrangementBrowserViewModel vm,
ObjectBrowserNodeViewModel root, IEnumerable <string> path)
{
if (!path.Any())
{
return(root);
}
var children = GetChildren(root);
ObjectBrowserItemViewModel node;
if (children.TryGetValue(path.First(), out node))
{
return(GetNode(version, vm, node as ObjectBrowserNodeViewModel, path.Skip(1)));
}
var arr = version.GetArrangement(root.Name);
Napa.Alfred.EventProxy.WithDelayedEvents(() => {
Napa.Alfred.EventProxy.WithDelayedGMEvents(() => {
var subArr = GetSubArr(version, arr, path.First());
if (subArr == null)
{
throw new InvalidOperationException("Cannot create STR path " + string.Join(":", path));
}
PopulateArrangement(vm, subArr, root);
});
});
return(GetNode(version, vm, root, path));
}
private MainVerticalZone GetMainVerticalZone(IProjectVersion version)
{
var x = SurfaceObject.CenterOfGravity.X;
return(MainVerticalZone
.GetMainVerticalZones(version)
.FirstOrDefault(z => z.Range.IsIncluding(x, 0.01)));
}
private static IHierarchicalArrangement GetSubArr(IProjectVersion version,
IHierarchicalArrangement parent, string name)
{
var subArr = version.GetArrangement(name);
if (subArr == null)
{
subArr = parent.AddSubArrangement(name);
}
return(subArr);
}
public IHierarchicalArrangement GetArrangement(IProjectVersion version)
{
var mvzArrName = GetArrangementName();
var mvzArr = version.GetArrangement(mvzArrName);
if (mvzArr == null)
{
var strSteel = version.GetArrangement("STR*STEEL");
mvzArr = strSteel.AddSubArrangement(mvzArrName);
}
return(mvzArr);
}
private IHierarchicalArrangement GetLeafArrangement(IProjectVersion version, MainVerticalZone mvz, DeckZone dz)
{
var name = GetArrangementName(mvz, dz);
var deckArr = dz.GetArrangement(version, mvz);
var leafArr = deckArr.SubArrangements.FirstOrDefault(arr => arr.Name == name);
if (leafArr == null)
{
leafArr = deckArr.AddSubArrangement(name);
}
return(leafArr);
}
public string[] GetArrangementPath(IProjectVersion version)
{
var mvz = GetMainVerticalZone(version);
var deckZone = GetDeckZone(version, mvz);
return(new[] {
"STR*STEEL",
mvz.GetArrangementName(),
deckZone.GetArrangementName(mvz),
GetArrangementName(mvz, deckZone)
});
}
public IHierarchicalArrangement GetArrangement(IProjectVersion version, MainVerticalZone mvz)
{
var name = GetArrangementName(mvz);
var mvzArr = mvz.GetArrangement(version);
var deckArr = mvzArr.SubArrangements.FirstOrDefault(arr => arr.Name == name);
if (deckArr == null)
{
deckArr = mvzArr.AddSubArrangement(name);
}
return(deckArr);
}
public bool AssignStructureType(IProjectVersion version, string structureType)
{
var dMgr = Alfred.GraphicsService.DrawableManager;
var geom = dMgr.GetFromCache(SurfaceObject.Name) as CompositeGeometry;
if (geom == null)
{
return(false);
}
geom.StructureType = structureType;
return(true);
}
public bool AssingStructureType(IProjectVersion version)
{
string structureType = null;
string originalObjectName;
if (IsReflectedObject(out originalObjectName))
{
var mainObject = version.SteelManager.DefaultModel.GetMainObjectByName(originalObjectName);
if (mainObject != null && mainObject.StructureType != null)
{
structureType = mainObject.StructureType.Name;
}
}
return(AssignStructureType(version, structureType ?? GetStructureType()));
}
private DeckZone GetDeckZone(IProjectVersion version, MainVerticalZone mvz)
{
var p = SurfaceObject.CenterOfGravity;
return(DeckZone.GetDefinedDeckZones(version)
.Select(z => {
var s = version.GeometryManager.GetSurface(z.Surface);
var pClosest = s.GetClosestPoint(p);
return new { Zone = z, Point = pClosest };
}).OrderBy(item => item.Point.GetDistance(p))
.Take(2)
.OrderByDescending(item => item.Point.Z)
.Select(item => item.Zone)
.FirstOrDefault());
}
public bool AssignLabels(IProjectVersion version)
{
var mvz = GetMainVerticalZone(version);
var dz = GetDeckZone(version, mvz);
var currentLabels = Napa.Core.Geometry.Labeling.GetLabels(SurfaceObject.Name);
var labels = new[] {
mvz.Name,
"DECK_" + dz.ID,
GetGenericStructureType()
}.Concat(currentLabels)
.Distinct();
Napa.Core.Geometry.Labeling.SetLabels(SurfaceObject.Name, labels);
return(true);
}
private IHierarchicalArrangement GetArrangement(IProjectVersion version)
{
var mvz = GetMainVerticalZone(version);
if (mvz == null)
{
return(null);
}
var deckZone = GetDeckZone(version, mvz);
if (deckZone == null)
{
return(null);
}
return(GetLeafArrangement(version, mvz, deckZone));
}
public void Run(IProjectVersion version, string name)
{
try {
var so = version.GeometryManager.GetSurfaceObject(name);
if (so == null)
{
return;
}
var helper = new ArrangementHelper(so);
var path = helper.GetArrangementPath(version);
ObjectBrowserHelper.AddItems(version, path, new[] { name });
helper.AssingStructureType(version);
helper.AssignLabels(version);
} catch (Exception e) {
Console.WriteLine(e.StackTrace);
throw e;
}
}
public static IEnumerable <DeckZone> GetDefinedDeckZones(IProjectVersion version)
{
var name = "TAB*DECKS";
var t = version.GetTable(name);
if (t == null)
{
return(Enumerable.Empty <DeckZone>());
}
return(t.Rows
.Cast <IRow>()
.Select(r => new DeckZone()
{
ID = r.GetStringValue("NAME"),
Surface = r.GetStringValue("SURFACE")
})
.ToList());
}
public static IEnumerable <MainVerticalZone> GetMainVerticalZones(IProjectVersion version)
{
var name = "TAB*MVZ";
var t = version.GetTable(name);
if (t == null)
{
return(Enumerable.Empty <MainVerticalZone>());
}
return(t.Rows.Cast <IRow>()
.Select(r => new MainVerticalZone()
{
Name = r.GetStringValue("NAME"),
Min = ShipCoordinate.Create(r.GetStringValue("LLIMIT")),
Max = ShipCoordinate.Create(r.GetStringValue("ULIMIT")),
Index = r.GetStringValue("NR")
})
.OrderByDescending(mvz => mvz.Name)
.ToList());
}
///<summary>
/// Update version method.
///</summary>
/// <exception cref="MCException"></exception>
public bool UpdateVersion(IProjectVersion version)
{
var mc = CreateMantisClientProxyInstance();
try
{
return mc.mc_project_version_update(Username, Password, version.Id.ToString(), ((ProjectVersion)version).Data);
}
catch (Exception ex)
{
if (version != null)
{
throw new MCException(String.Format("Could not add version {0}", version.Id), ex);
}
throw new MCException("Could not add version", ex);
}
finally
{
mc.CloseSafely();
}
}
///<summary>
/// Submit the specified version details.
///</summary>
/// <exception cref="MCException"></exception>
public long AddVersion(IProjectVersion version)
{
var mc = CreateMantisClientProxyInstance();
try
{
return Convert.ToInt64(mc.mc_project_version_add(Username, Password, ((ProjectVersion)version).Data));
}
catch (Exception ex)
{
if (version != null)
{
throw new MCException(String.Format("Could not add version {0}", version.Id), ex);
}
throw new MCException("Could not add version", ex);
}
finally
{
mc.CloseSafely();
}
}
