/// <summary>
/// Select all text in the text item that has the focus.
/// </summary>
private void SelectAll()
{
CanvasItem item = DisplayedItem;
if (item != null)
{
item.SelectAll();
}
}
/// <summary>
/// Draw curve using canvas until line index.
/// </summary>
/// <param name="canvas">Canvas item</param>
/// <param name="index">Line index</param>
public void DrawUntil(CanvasItem canvas, int index)
{
var limit = Mathf.Max(0, Mathf.Min(index, Count));
for (var i = 0; i < limit; ++i)
{
_lines[i].Draw(canvas);
}
}
private void CreateItem(SoldierInfo s)
{
GameObject go = NDLoad.LoadWndItem("CanvasItem", MyHead.Parent);
CanvasItem c = go.GetComponent <CanvasItem>();
if (c != null)
{
c.SetCanvasItem(s, 1);
}
}
public override Node2D GenerateOn(CanvasItem node)
{
node.QueueFreeChildren();
ObstacleAppearance appearance = ObstacleAppearance.New();
node.AddChild(appearance);
appearance.SetAppearance(id);
appearance.Position = OFFSET;
return(appearance);
}
public override Node2D GenerateOn(CanvasItem node)
{
node.QueueFreeChildren();
CharacterAppearance appearance = CharacterAppearance.New();
node.AddChild(appearance);
appearance.data = this;
appearance.Position = OFFSET;
return(appearance);
}
/// <summary>
/// Check if we are in a godot visibility group
/// </summary>
private void ProcessGroups(CanvasItem node, bool add)
{
foreach (string groupName in node.GetGroups())
{
if (groupName.StartsWith(VISIBILITY_GROUP_NAME))
{
string name = groupName.Replace(VISIBILITY_GROUP_NAME, "");
ProcessVisibilityGroupMember(node, name, add);
}
}
}
public static void AddVisibilityGroupMember(string groupName, CanvasItem node)
{
if (!Instance.VisibilityGroupVisible.ContainsKey(groupName))
{
Instance.VisibilityGroupVisible.Add(groupName, true);
Instance.VisibilityGroupMembers.Add(groupName, new List <CanvasItem>());
Button btn = AddButton(groupName, Instance.VisibilityGridParent, () => ToggleGroup(groupName));
btn.Modulate = Colors.Green;
}
Instance.VisibilityGroupMembers[groupName].Add(node);
}
public bool TryGetSelectedSoldier(int id, ref CanvasItem item)
{
for (int i = 0; i < m_SelectedSoldier.Count; i++)
{
if (m_SelectedSoldier[i].Soldier.ID == id)
{
item = m_SelectedSoldier[i];
return(true);
}
}
return(false);
}
public static void DrawBorder(CanvasItem canvas)
{
if (Lib.Node.BoderEnabled)
{
var vps = canvas.GetViewportRect().Size;
int thickness = 4;
var color = new Color(Lib.Node.BorderColorHtmlCode);
canvas.DrawLine(new Vector2(0, 1), new Vector2(vps.x, 1), color, thickness);
canvas.DrawLine(new Vector2(1, 0), new Vector2(1, vps.y), color, thickness);
canvas.DrawLine(new Vector2(vps.x - 1, vps.y), new Vector2(vps.x - 1, 1), color, thickness);
canvas.DrawLine(new Vector2(vps.x, vps.y - 1), new Vector2(1, vps.y - 1), color, thickness);
}
}
// Called when the node enters the scene tree for the first time.
public override void _Ready()
{
_tween = FindNode("Tween") as Tween;
_parent = GetParent <CanvasItem>();
_origMod = _parent.Modulate;
_fadeMod = new Color(_origMod.r, _origMod.g, _origMod.b, 0);
_nextMod = _fadeMod;
FadeOut();
if (Simple == false)
{
_tween.Start();
}
}
public Node2D GenerateOnWithOutline(CanvasItem node, Combat.Alignment alignment)
{
Node2D appearance = GenerateOn(node);
Color outlineColor = alignment switch
{
Combat.Alignment.FRIENDLY => FRIENDLY_COLOR,
Combat.Alignment.HOSTILE => HOSTILE_COLOR,
_ => NEUTRAL_COLOR,
};
(appearance?.Material as ShaderMaterial)?.SetShaderParam("outline", outlineColor);
return(appearance);
}
public void MoveBackCall(CanvasItem i)
{
CanvasItem item = null;
i.m_bSelect = false;
if (m_CrewList.TryGetValue(i.Soldier.ID, out item))
{
item.GetComponent <Collider>().enabled = true;
item.m_bSelect = false;
item.SetMaskActive(false);
}
Destroy(i.gameObject);
}
private void Translation_DG(CanvasItem canvasItem, int iX, int iY)
{
if (canvasItem == null)
{
return;
}
//
foreach (BaseItem one in canvasItem.BaseItems)
{
one.Translation(iX, iY);
//
this.Translation_DG(one as CanvasItem, iX, iY);
}
}
public void DelayCallBack(object o)
{
GameObjectActionExcute gae = GetComponent <GameObjectActionExcute>();
if (gae)
{
GameObjectActionWait wait = gae.GetCurrentAction() as GameObjectActionWait;
if (wait != null)
{
CanvasItem selecteditem = wait.Data1 as CanvasItem;
selecteditem.m_bSelect = false;
}
}
}
private void ProcessClass(CanvasItem node, bool add)
{
DebugVisibilityGroups attr = DebugReflectionUtil.FindClassAttributeInNode <DebugVisibilityGroups>(node.GetType());
if (attr == null)
{
return;
}
foreach (string name in attr.Groups)
{
ProcessVisibilityGroupMember(node, name, add);
}
}
private void ProcessVisibilityGroupMember(CanvasItem node, string name, bool add)
{
if (add)
{
DebugButtonMenu.AddVisibilityGroupMember(name, node);
if (!DebugButtonMenu.IsGroupVisible(name))
{
node.Visible = false;
}
}
else
{
DebugButtonMenu.RemoveVisibilityGroupMember(name, node);
}
}
public CanvasItemData (CanvasItem item,
EventHandler<SizeGripEventArgs> SizeGripMouseEntered,
EventHandler<SizeGripEventArgs> SizeGripMouseLeft)
{
this.item = item;
focusDecorator = new FocusDecorator(item);
sizeGripDecorator = new SizeGripDecorator(item);
sizeGripDecorator.SizeGripMouseEnter += SizeGripMouseEntered;
sizeGripDecorator.SizeGripMouseLeave += SizeGripMouseLeft;
item.AddDecorator(focusDecorator);
item.AddDecorator(sizeGripDecorator);
}
private void AddSoldier(SoldierInfo Soldier)
{
GameObject go = NDLoad.LoadWndItem("CanvasItem", MyHead.ListParent.transform);
if (go)
{
CanvasItem item = go.GetComponent <CanvasItem>();
if (item)
{
m_lItems.Add(item);
item.SetCanvasItem(Soldier);
item.ShowBearDestroy(true);
}
}
}
private void AddBuild(BuildInfo WareHouse)
{
if (MyHead.ListParent == null || MyHead.CanvasItem == null)
{
NGUIUtil.DebugLog("ShipCanvasDialogWnd ListParent || CanvasItem is null!!!");
return;
}
GameObject go = NGUITools.AddChild(MyHead.ListParent, MyHead.CanvasItem);
CanvasItem item = go.GetComponent <CanvasItem>();
if (item)
{
item.SetCanvasItem(WareHouse);
}
}
public void SetUp()
{
_item = new FakeCanvasItem();
_items = new List <CanvasItem> {
_item
};
_mockPropertyService = new Mock <IDependencyPropertyService>();
_mockRenderer = new Mock <ICanvasRenderer>();
_mockVisualService = new Mock <IVisualService>();
_control = new CanvasControlHarness(
_mockPropertyService.Object,
_mockRenderer.Object,
_mockVisualService.Object);
}
/*
* Draws a grid of tetris cells onto any canvas node, with a given cell width.
*/
public static void DrawTetrisGrid(CanvasItem node, IGrid <TetrisCell> grid, float cellWidth)
{
var textures = node.GetNode <TetrominoTextures>("/root/gui/tetromino_textures").Textures;
foreach (var pos in Utils.Range2D(grid.Cells.GetSize()))
{
if (grid.Cells[pos.Y][pos.X] != TetrisCell.Empty)
{
node.DrawTextureRect(
textures[grid.Cells[pos.Y][pos.X]],
new Rect2(pos.X * cellWidth, pos.Y * cellWidth, cellWidth, cellWidth),
false
);
}
}
}
public static Vector2 SimpleRayCast(CanvasItem spaceNode, Vector2 from, Vector2 to, out bool success)
{
Physics2DDirectSpaceState physicsState = Physics2DServer.SpaceGetDirectState(spaceNode.GetWorld2d().Space);
Dictionary result = physicsState.IntersectRay(from, to, GodotUtility.MakeGDArray(spaceNode));
if (result.ContainsKey("position"))
{
success = true;
return((Vector2)result["position"]);
}
else
{
success = false;
return(new Vector2());
}
}
private bool SelectCompnentMouseDown_DG(CanvasItem canvasItem, Point point)
{
if (canvasItem == null)
{
return(false);
}
//
foreach (BaseItem one in canvasItem.BaseItems)
{
if (this.SelectCompnentMouseDown(one as RibbonGalleryItem, point))
{
return(true);
}
if (this.SelectCompnentMouseDown(one as ButtonGroupItem, point))
{
return(true);
}
if (this.SelectCompnentMouseDown_DG(one as BaseItemStackExItem, point))
{
return(true);
}
if (this.SelectCompnentMouseDown_DG(one as BaseItemStackItem, point))
{
return(true);
}
if (this.SelectCompnentMouseDown_DG(one as CanvasItem, point))
{
return(true);
}
//
if (one.DesignMouseClickRectangleContainsEx(point))
{
ISelectionService pSelectionService = GetService(typeof(ISelectionService)) as ISelectionService;
if (pSelectionService != null)
{
this.m_Item1 = one;
this.m_MouseDownPoint = point;
pSelectionService.SetSelectedComponents(new Component[] { one as Component }, SelectionTypes.Primary);
this.m_DescriptionMenuPopupPanel.Refresh();
return(true);
}
}
}
//
return(false);
}
public async void Add(CanvasItem newNode, float delay = 0)
{
// Fade-in effect
Tween tween = new Tween();
tween.InterpolateProperty(newNode, "modulate", Colors.Transparent, Colors.White, 0.5f,
Tween.TransitionType.Linear, Tween.EaseType.InOut, delay);
tween.Connect("tween_all_completed", tween, "queue_free");
newNode.AddChild(tween);
newNode.Modulate = Colors.Transparent;
container.AddChild(newNode); // We actually add the thing here
tween.Start();
// Wait for the scrollbar to recalculate and scroll to the bottom
await ToSignal(GetTree(), "idle_frame");
scroll.ScrollVertical = (int)scroll.GetVScrollbar().MaxValue;
}
void SetUI()
{
NGUIUtil.SetLableText <string>(MyHead.Lbl01, (m_preInfo.m_strength_grow * 0.01).ToString());
NGUIUtil.SetLableText <string>(MyHead.Lbl02, (m_curInfo.m_strength_grow * 0.01).ToString());
NGUIUtil.SetLableText <string>(MyHead.Lbl03, (m_preInfo.m_intelligence_grow * 0.01).ToString());
NGUIUtil.SetLableText <string>(MyHead.Lbl04, (m_curInfo.m_intelligence_grow * 0.01).ToString());
NGUIUtil.SetLableText <string>(MyHead.Lbl05, (m_preInfo.m_agility_grow * 0.01).ToString());
NGUIUtil.SetLableText <string>(MyHead.Lbl06, (m_curInfo.m_agility_grow * 0.01).ToString());
if (MyHead.AfterItem != null)
{
GameObject go = NDLoad.LoadWndItem("CanvasItem", MyHead.AfterItem.transform);
if (go)
{
CanvasItem item = go.GetComponent <CanvasItem>();
if (item)
{
item.SetCanvasItem(m_curInfo, 0, false);
}
}
}
if (MyHead.PreItem != null)
{
GameObject go = NDLoad.LoadWndItem("CanvasItem", MyHead.PreItem.transform);
if (go)
{
CanvasItem item = go.GetComponent <CanvasItem>();
if (item)
{
item.SetCanvasItem(m_preInfo, 0, false);
}
}
}
float strAddNum = Mathf.Abs((m_curInfo.m_strength_grow - m_preInfo.m_strength_grow) * 0.01f);
float intAddNum = Mathf.Abs((m_curInfo.m_intelligence_grow - m_preInfo.m_intelligence_grow) * 0.01f);
float agiAddNum = Mathf.Abs((m_curInfo.m_agility_grow - m_preInfo.m_agility_grow) * 0.01f);
MyHead.LblAdd1.text = "(" + NGUIUtil.GetStringByKey(88800047) + "+" + (strAddNum).ToString() + ")";
MyHead.LblAdd2.text = "(" + NGUIUtil.GetStringByKey(88800049) + "+" + (intAddNum).ToString() + ")";
MyHead.LblAdd3.text = "(" + NGUIUtil.GetStringByKey(88800048) + "+" + (agiAddNum).ToString() + ")";
}
public void SetUp()
{
_item = new FakeCanvasItem()
{
Id = 1
};
_items = new List <CanvasItem> {
_item
};
_row = new RowBuilder().WithId(1).Build();
_rows = new List <Row> {
_row
};
_mockMessageBus = new Mock <IMessageBus>();
_mockMessageBus.Setup(p => p.Execute(It.IsAny <GetAllRowsQuery>()))
.Returns(_rows);
_command = new SelectCommand(
_mockMessageBus.Object);
}
/// <summary>
/// 加载头像列表
/// </summary>
private void LoadHeadList(List <SoldierInfo> l, UITable Parent, int soldierType)
{
//异常判断
if (Parent == null)
{
return;
}
//清空原有列表
EmptyHeadList(Parent.gameObject, soldierType);
if (l == null || l.Count == 0)
{
return;
}
foreach (SoldierInfo soldierInfo in l)
{
GameObject go = NDLoad.LoadWndItem("CanvasItem", Parent.transform);
if (go != null)
{
CanvasItem item = go.GetComponent <CanvasItem>();
if (item)
{
m_CrewList.Add(soldierInfo.ID, item);
item.SetCanvasItem(soldierInfo, 3);
//item.ItemIndex = itemIndex++;
go.name = soldierInfo.m_name;
//NGUIUtil.SetItemPanelDepth(go, Parent.GetComponentInParent<UIPanel>());
if (IsContains(soldierInfo.ID))
{
item.SetMaskActive(true);
}
}
}
}
//RestoreGoCombatData();
//排列，避免堆叠
NGUIUtil.RepositionTable(Parent.gameObject);
}
public static RayCastHitInfo RayCastObject(CanvasItem spaceNode, Vector2 from, Vector2 to, out bool success)
{
Physics2DDirectSpaceState physicsState = Physics2DServer.SpaceGetDirectState(spaceNode.GetWorld2d().Space);
Dictionary result = physicsState.IntersectRay(from, to, GodotUtility.MakeGDArray(spaceNode));
if (result.ContainsKey("position"))
{
success = true;
RayCastHitInfo info = new RayCastHitInfo();
info.position = (Vector2)result["position"];
if (result.ContainsKey("collider"))
{
info.collider = (Godot.Object)result["collider"];
}
return(info);
}
else
{
success = false;
return(null);
}
}
public void SetUp()
{
_controlSize = new Size();
_item = new CanvasCircle();
_items = new List <CanvasItem> {
_item
};
_mockContextMenuViewModel = new Mock <IScatterPlotContextMenuViewModel>();
_mockQueries = new Mock <IScatterPlotViewModelQueries>();
_mockQueries.Setup(p => p.GetItems(It.IsAny <Size>()))
.Returns(_items);
_mockQueries.Setup(p => p.GetSelectedItems(_items))
.Returns(_items);
_mockCommands = new Mock <IScatterPlotViewModelCommands>();
_viewModel = new ScatterPlotViewModel(
_mockContextMenuViewModel.Object,
_mockQueries.Object,
_mockCommands.Object);
}
public void SetData(SoldierInfo preInfo, SoldierInfo curInfo)
{
SetSoldierPhoto(preInfo.SoldierTypeID);
NGUIUtil.SetLableText <int>(MyHead.LblPreCombatPower, preInfo.m_combat_power);
NGUIUtil.SetLableText <int>(MyHead.LblCurCombatPower, curInfo.m_combat_power);
NGUIUtil.SetLableText <int>(MyHead.LblPreHp, preInfo.m_hp);
NGUIUtil.SetLableText <int>(MyHead.LblCurHp, curInfo.m_hp);
SetNewSkill(curInfo, preInfo);
if (MyHead.AfterItem != null)
{
GameObject go = NDLoad.LoadWndItem("CanvasItem", MyHead.AfterItem.transform);
if (go)
{
CanvasItem item = go.GetComponent <CanvasItem>();
if (item)
{
item.SetCanvasItem(curInfo, 0, false);
}
}
}
if (MyHead.PreItem != null)
{
GameObject go = NDLoad.LoadWndItem("CanvasItem", MyHead.PreItem.transform);
if (go)
{
CanvasItem item = go.GetComponent <CanvasItem>();
if (item)
{
item.SetCanvasItem(preInfo, 0, false);
}
}
}
}
private void SetUI()
{
MyHead.LblDefanNum.text = m_oldBuildInfo.m_DefensePower.ToString();
MyHead.LblAfterDefanNum.text = m_buildInfo.m_DefensePower.ToString();
MyHead.LblHpNum.text = m_oldBuildInfo.m_hp.ToString();
MyHead.LblAfterHpNum.text = m_buildInfo.m_hp.ToString();
if (MyHead.AfterItem != null)
{
GameObject go = NDLoad.LoadWndItem("CanvasItem", MyHead.AfterItem.transform);
if (go)
{
CanvasItem item = go.GetComponent <CanvasItem>();
if (item)
{
item.SetCanvasItem(m_buildInfo, false);
item.HiddenTrapNumLabel();
}
}
}
if (MyHead.PreItem != null)
{
GameObject go = NDLoad.LoadWndItem("CanvasItem", MyHead.PreItem.transform);
if (go)
{
CanvasItem item = go.GetComponent <CanvasItem>();
if (item)
{
item.SetCanvasItem(m_oldBuildInfo, false);
item.HiddenTrapNumLabel();
}
}
}
SetSkill();
}
public int GetModelIndex (CanvasItem item)
{
int i;
return model_indices.TryGetValue (item, out i) ? i : -1;
}
protected void SetModelIndex (CanvasItem item, int index)
{
model_indices[item] = index;
}
public void RemoveCanvasItem (CanvasItem item)
{
itemsList.Remove(itemsData[item]);
Stack<Route> routesToRemove = new Stack<Route>();
foreach (Route r in diagramRouter.Routes)
{
if (r.From == item || r.To == item)
routesToRemove.Push(r);
}
foreach (Route r in routesToRemove)
diagramRouter.RemoveRoute(r);
diagramRouter.RemoveItem (item);
ClassCanvasItem classItem = item as ClassCanvasItem;
if (classItem != null)
{
classesToData.Remove (classItem.RepresentedClassType);
}
LayoutChanged(this, EventArgs.Empty);
}
/// <summary>
/// Retruns a copy of the the canvas items list as an array.
/// </summary>
public CanvasItem[] GetCanvasItems()
{
CanvasItem[] items = new CanvasItem[itemsList.Count];
int i = 0;
foreach (CanvasItemData item in itemsList)
items[i++] = item.Item;
return items;
}
private void AddCanvasItem(CanvasItem item)
{
this.Canvas.AddCanvasItem(item);
StoreCurrentCanvas();
}
private void RemoveCanvasItem(CanvasItem item)
{
this.Canvas.RemoveCanvasItem(item);
StoreCurrentCanvas();
}
void MoveItem(CanvasView view, Gdk.EventButton evnt, CanvasItem item)
{
double wx, wy;
view.WindowToWorld (evnt.X, evnt.Y, out wx, out wy);
item.Move (wx, wy);
}
public CanvasItemEventArgs (CanvasItem canvasItem)
{
this.canvasItem = canvasItem;
}
public void AddCanvasItem (CanvasItem item)
{
diagramRouter.AddItem(item);
CanvasItemData itemData = new CanvasItemData(item, SizeGripMouseEntered, SizeGripMouseLeft);
itemsData[item] = itemData;
ClassCanvasItem classItem = item as ClassCanvasItem;
if (classItem != null)
{
classesToData.Add(classItem.RepresentedClassType, itemData);
foreach (CanvasItemData ci in itemsList)
{
ClassCanvasItem cci = ci.Item as ClassCanvasItem;
if (cci != null)
{
Route r = null;
if (cci.RepresentedClassType == classItem.RepresentedClassType.BaseClass)
r = diagramRouter.AddRoute(item, cci);
else if (classItem.RepresentedClassType == cci.RepresentedClassType.BaseClass)
r = diagramRouter.AddRoute(cci, classItem);
if (r != null)
r.EndShape = new RouteInheritanceShape();
}
}
}
itemsList.AddLast(itemData);
item.RedrawNeeded += HandleRedraw;
item.LayoutChanged += HandleItemLayoutChange;
item.PositionChanging += HandleItemPositionChange;
item.SizeChanging += HandleItemSizeChange;
}
void GrabHandle(CanvasView view, Gdk.EventButton evnt, CanvasItem item)
{
if (item is CanvasLine) {
/*
wx, wy = view.window_to_world(event.x, event.y)
dist, glue, glue_to = view.canvas.glue_handle (first, wx, wy)
if glue_to and (dist <= view.handle_layer.glue_distance):
glue_to.connect_handle(first)
view.handle_layer.grab_handle(last)
*/
Handle first = null;
Handle last = null;
bool started = true;
foreach (Handle handle in item.Handles) {
if (started)
first = handle;
else
last = handle;
started = false;
}
view.HandleLayer.GrabHandle (first);
} else if (item is CanvasElement) {
Handle handle_se = null;
int counter = 0;
foreach (Handle handle in item.Handles) {
if (counter++ != (int)CanvasElementHandle.Se) {
continue;
}
handle_se = handle;
}
view.HandleLayer.GrabHandle (handle_se);
}
}
