public void UpdateCanvases()
{
if (_destroyed)
{
return;
}
ClearCanvasStates();
var canvases = Object.FindObjectsOfType <Canvas>().AsEnumerable();
if (Game.IsInstance() && Game.Instance.actScene != null && Game.Instance.actScene.AdvScene != null)
{
canvases = canvases.Union(Game.Instance.actScene.AdvScene.GetComponentsInChildren <Canvas>(true)); // Also finds disabled canvases, necessary in some cases
}
foreach (var canvase in canvases)
{
var cs = new CanvasState(canvase);
if (cs.Raycaster != null && cs.HasSelectables())
{
if (cs.Canvas.renderMode == RenderMode.ScreenSpaceCamera)
{
cs.Raycaster.StartCoroutine(ChangeCanvasRenderModeCo(cs.Canvas));
}
_canvases.Add(cs);
}
else
{
cs.Dispose();
}
}
}
protected CanvasState(CanvasState prototype)
{
StrokeDashPattern = prototype.StrokeDashPattern;
StrokeSize = prototype.StrokeSize;
Transform = new AffineTransform(prototype.Transform);
Scale = prototype.Scale;
}
public void SetAlpha1ThenFade()
{
canvasGroup.alpha = 1f;
canvasGroup.blocksRaycasts = true;
canvasGroup.interactable = true;
canvasState = CanvasState.FadeOut;
}
public MainPage()
{
_State = CanvasState.Unloaded;
this.InitializeComponent();
ShowStatusBar();
RootPage = this;
}
private void SetAlpha1()
{
canvasGroup.alpha = 1f;
canvasGroup.blocksRaycasts = true;
canvasGroup.interactable = true;
canvasState = CanvasState.Idle;
}
private void SetCnvMode(CanvasState state)
{
SetToGray();
if (state == cnvState)
{
state = CanvasState.NormalMode;
}
cnvState = state;
ReSyncOnEditor();
Editor.ChangeOpacity(cnvMap.Children, slrDepth.Value, opaqueView, cnvState);
switch (state)
{
case CanvasState.NormalMode:
grdNormalMode.Background = selectedMode;
break;
case CanvasState.EntityMode:
grdEntityMode.Background = selectedMode;
break;
case CanvasState.TileAttributeMode:
grdAttributeMode.Background = selectedMode;
break;
}
}
private void ResetTextEditState()
{
editedTextBox.Parent.Controls.Remove(editedTextBox);
editedTextBox = null;
editedTextView = null;
state = CanvasState.Ready;
}
public void ShowPlaybackCanvas(KeyCode key)
{
if (Input.GetKeyDown(key))
{
canvasState = CanvasState.VISIBLE;
playbackCanvas.SetActive(true);
}
}
public void HidePlaybackCanvas(KeyCode key)
{
if (Input.GetKeyDown(key))
{
canvasState = CanvasState.INVISIBLE;
playbackCanvas.SetActive(false);
}
}
private void Reset(object o)
{
canvasState = CanvasState.StartingValue;
vertices.Clear();
FirstVertex = null;
SecondVertex = null;
Cursor = Cursors.Arrow;
(o as Canvas).Children.Clear();
}
public void MainToAddMessage()
{
Screen.orientation = ScreenOrientation.Portrait;
MainCanvas.SetActive(false);
AddMessageCanvas.SetActive(true);
// 狀態
state = CanvasState.STATE_ADD;
}
/// <summary>
/// Triggered when the animation outro ends
/// </summary>
public virtual void OnAnimationEndEnd()
{
m_state = CanvasState.close;
m_isOpen = false;
EventManager.Instance.TriggerEvent(new UiEvent(this, m_state));
//if(onUICanvasClose != null)
// onUICanvasClose (this);
}
/// <summary>
/// Triggered when the animation intro ends
/// </summary>
public virtual void OnAnimationIntroEnd()
{
m_state = CanvasState.open;
m_isOpen = true;
EventManager.Instance.TriggerEvent(new UiEvent(this, m_state));
//if(onUICanvasOpen != null)
// onUICanvasOpen (this);
}
private void LoadShapes(CanvasState canvasState)
{
var shapesCollection = canvasState.Adapt <ObservableCollection <Shape> >();
foreach (var shape in shapesCollection)
{
shape.StateChanging += ShapeOnStateChanging;
shape.Selected += ShapeOnSelected;
_shapes.Add(shape);
}
}
// Show Canvas method to enable canvas component
protected void ShowCanvas(EnableDirection m_direction)
{
_direction = m_direction;
_currentState = CanvasState.Enabled;
OnScreenShowCalled();
EnableDisableCanvas(true);
if (m_showAnimationListeners.Count <= 0)
{
OnScreenLoaded();
}
}
public void BackToMain()
{
Screen.orientation = ScreenOrientation.LandscapeRight;
MainCanvas.SetActive(true);
AddMessageCanvas.SetActive(false);
ReadMessageCanvas.SetActive(false);
// 狀態
state = CanvasState.STATE_MAIN;
}
/// <summary>
/// I do not use the start or awake to init the canvas i call taht fundtion from the Navigation controller.
/// </summary>
public virtual void Init()
{
m_animation = gameObject.GetComponent <Animation> ();
m_textFields = gameObject.GetComponentsInChildren <Text> ();
m_state = CanvasState.close;
if (m_animation != null)
{
m_animation.Stop();
}
}
// Move canvas to the front of player every frame
private IEnumerator MoveToFrontOfPlayer()
{
while (Vector3.Distance(transform.position, GetFrontOfPlayer()) >= 0.05f)
{
transform.eulerAngles = playerCam.transform.eulerAngles;
float speed = 4f * Time.deltaTime;
transform.position = Vector3.MoveTowards(transform.position, GetFrontOfPlayer(), speed);
yield return(null);
}
currentState = CanvasState.InScreen;
}
public virtual void OnNotify(CanvasState _currentState, EnableDirection _direction)
{
if (_currentState == CanvasState.Enabled)
{
StartShowAnimation(_direction);
}
else
{
StartHideAnimation(_direction);
}
}
// Hide Canvas method to disable canvas component
protected void HideCanvas(EnableDirection m_direction)
{
_direction = m_direction;
_currentState = CanvasState.Disabled;
OnScreenHideCalled();
// Debug.Log("---m_hideAnimationListener "+m_hideAnimationListeners.Count,gameObject);
if (m_hideAnimationListeners.Count <= 0)
{
EnableDisableCanvas(false);
OnScreenHidden();
}
}
public virtual void EndDraw()
{
if (frame == null)
{
lastFrame = new CanvasState();
return;
}
lastFrame = new CanvasState(currentFrame);
currentFrame = new List <MySprite>();
frame.Value.Dispose();
}
private CanvasState CanvasStateConstruct(ObservableCollection <Shape> shapes)
{
var canvasState = new CanvasState();
var canvasStateShapesDto = shapes.OfType <RectangleShape>().Adapt <RectangleShapeDto[]>();
var polylineShapeDto = shapes.OfType <PolylineShape>().Adapt <PolylineShapeDto[]>();
var shapesList = new List <ShapeDto>();
shapesList.AddRange(canvasStateShapesDto);
shapesList.AddRange(polylineShapeDto);
canvasState.ShapesDto = shapesList.ToArray();
return(canvasState);
}
/// <summary>
/// Close UI canvas
/// </summary>
public virtual void Close()
{
m_state = CanvasState.closing;
EventManager.Instance.TriggerEvent(new UiEvent(this, m_state));
if (m_animation != null)
{
m_animation.Play("Outro");
}
else
{
OnAnimationEndEnd();
}
}
private void MouseLeftButtonUp()
{
if (canvasState == CanvasState.DragingVertex)
{
if (draggingEllipse != null)
{
draggingEllipse.Stroke = new SolidColorBrush(Colors.BurlyWood);
Canvas.SetZIndex(draggingEllipse, 0);
}
draggingLines.Clear();
draggingVertext = null;
draggingEllipse = null;
canvasState = CanvasState.StartingValue;
}
}
/// <summary>
/// Open ui canvas
/// </summary>
/// <param name="param">Parameter.</param>
public virtual void Open(System.Object param)
{
m_state = CanvasState.opening;
EventManager.Instance.TriggerEvent(new UiEvent(this, m_state));
if (m_animation != null)
{
m_animation.Play("Intro");
}
else
{
OnAnimationIntroEnd();
}
}
private void canNetwork_MouseDown(object sender, MouseEventArgs e)
{
ClickTime = DateTime.Now;
ClickItem = canNetwork.GetItem(e.X, e.Y);
ClickPosition = new Point(e.X, e.Y);
if (ClickItem == null)
{
State = CanvasState.Create;
}
else
{
State = CanvasState.None;
}
switch (e.Button)
{
case MouseButtons.Left:
{
break;
}
case MouseButtons.None:
{
break;
}
case MouseButtons.Right:
{
break;
}
case MouseButtons.Middle:
{
break;
}
case MouseButtons.XButton1:
{
break;
}
case MouseButtons.XButton2:
{
break;
}
}
}
internal void MouseUp(Point point)
{
if (state == CanvasState.Dragging)
{
if (canvasView.ActiveDropRegion && EffectiveDropRegion(ViewBounds(dragged), canvasView.DropRegion))
{
ConnectBlocks(canvasView.DropRegion, draggedModel);
Update();
}
state = CanvasState.Ready;
DropRegions.Clear();
canvasView.ResetDropRegion();
Update(new Rectangle(new Point(0, 0), canvasSize));
}
}
void Update()
{
if (canvasGroup == null)
{
Debug.LogWarning(gameObject.name + "(" + this + ") has no CanvasGroup Component."); return;
}
switch (canvasState)
{
case CanvasState.Alpha0:
canvasGroup.alpha = 0f;
canvasGroup.blocksRaycasts = false;
canvasGroup.interactable = false;
canvasState = CanvasState.Idle;
break;
case CanvasState.Alpha1:
SetAlpha1();
break;
case CanvasState.FadeOut:
canvasGroup.blocksRaycasts = false;
canvasGroup.interactable = false;
canvasGroup.alpha = Mathf.MoveTowards(canvasGroup.alpha, 0f, (1f / fadeTime) * Time.deltaTime);
if (canvasGroup.alpha == 0f)
{
canvasState = CanvasState.Idle;
}
break;
case CanvasState.FadeIn:
canvasGroup.alpha = Mathf.MoveTowards(canvasGroup.alpha, 1f, (1f / fadeTime) * Time.deltaTime);
if (canvasGroup.alpha == 1f)
{
canvasGroup.blocksRaycasts = true;
canvasGroup.interactable = true;
canvasState = CanvasState.Idle;
}
break;
case CanvasState.Idle:
default:
break;
}
}
void Start()
{
Camera[] cams = FindObjectsOfType <Camera>();
foreach (Camera c in cams)
{
PhotonView pv = c.GetComponentInParent <PhotonView>();
if (pv == null || !c.isActiveAndEnabled)
{
continue;
}
else
{
playerCam = c;
break;
}
}
currentState = CanvasState.InScreen;
}
public override void EndDraw()
{
foreach (KeyValuePair <IMyTextPanel, PanelRenderer> kv in panels)
{
using (var frame = kv.Key.DrawFrame())
{
foreach (MySprite s in currentFrame)
{
MySprite sprite = s;
kv.Value.Adjust(ref sprite);
frame.Add(sprite);
}
}
}
lastFrame = new CanvasState(currentFrame);
currentFrame = new List <MySprite>();
}
public BlockController(Graphics textMetrics, Font textFont, Size canvasSize, Func<TextBox> textBoxMaker)
{
this.Modified += delegate(object sender) { };
blockSpace = new BlockSpace();
blockSpace.OnTopLevelAdded += new TopLevelEvent(blockSpace_OnTopLevelAdded);
blockSpace.OnTopLevelDeleted += new TopLevelEvent(blockSpace_OnTopLevelDeleted);
blockSpace.OnTopLevelMoved += new TopLevelEvent(blockSpace_OnTopLevelMoved);
palette = new Palette(new Size(canvasSize.Width - 20, 60), textMetrics, textFont);
palette.Modified += new PaletteModifiedEvent(palette_Modified);
canvasView = new CanvasView(textMetrics, canvasSize, allViews, DropRegions, textFont, palette);
this.canvasSize = canvasSize;
state = CanvasState.Ready;
viewFactory = new BlockViewFactory(textMetrics, textFont, blockSpace, blockViews,
()=>Modified(this));
this.textBoxMaker = textBoxMaker;
}
public SaveCommand(CanvasState iMenu)
{
itemMenu = iMenu;
}
public DeleteCommand(CanvasState iMenu)
{
itemMenu = iMenu;
}
/// <summary>
/// Restores the last canvas state.
/// </summary>
public void Restore()
{
state = stack.Pop();
graphics.Restore(state.state);
}
/// <summary>
/// Saves the current canvas state.
/// </summary>
public void Save()
{
state.state = graphics.Save();
stack.Push(state);
state = (CanvasState) state.Clone();
}
public PasteCommand(CanvasState iMenu)
{
itemMenu = iMenu;
}
public static void AddCurrentSate(List<UIElement> Prams)
{
CanvasState doc = new CanvasState(Prams);
Command cmd = new CanvasCommand(doc);
UndoStack.Push(cmd);
}
internal void MouseUp(Point point)
{
if (state == CanvasState.Dragging)
{
if (canvasView.ActiveDropRegion && EffectiveDropRegion(ViewBounds(dragged), canvasView.DropRegion))
{
ConnectBlocks(canvasView.DropRegion, draggedModel);
Update();
}
state = CanvasState.Ready;
DropRegions.Clear();
canvasView.ResetDropRegion();
Update(new Rectangle(new Point(0, 0), canvasSize));
}
}
public CanvasCommand(CanvasState canvas)
{
canvasState = canvas;
}
private void ResetTextEditState()
{
editedTextBox.Parent.Controls.Remove(editedTextBox);
editedTextBox = null;
editedTextView = null;
state = CanvasState.Ready;
}
public NewCommand(CanvasState iMenu)
{
itemMenu = iMenu;
}
public CopyCommand(CanvasState iMenu)
{
itemMenu = iMenu;
}
internal void MouseDown(Point p)
{
if (state == CanvasState.TextEditing)
{
// Since the mousedown registered, we've clicked outside the textbox
ResetTextEditState();
}
else if (state == CanvasState.Ready)
{
if (canvasView.PaletteRect.Contains(p))
{
int x = canvasView.PaletteRect.Left;
int y = canvasView.PaletteRect.Top;
IBlock[] defaultArgs;
string funcName = palette.HitTest(p.Offseted(-x, -y), out defaultArgs);
if (funcName != "")
{
IBlock b = blockSpace.makeNewBlock(funcName,defaultArgs);
TopLevelScript s = AddTopLevel(b, p.Offseted(-5, -5));
dragged = blockViews[b];
draggingOrigin = p;
draggedModel = s;
state = CanvasState.Dragging;
PrepareDropRegions(b);
Update(ViewBounds(dragged));
return;
}
}
IBlockView hit = HitTest(p);
if (hit == null)
return;
if (!allViews.ContainsKey(hit))
{
if (hit.Model.ParentRelationship.Type == ParentRelationshipType.Stack)
{
int i = hit.Model.ParentRelationship.Index;
Point np = hit.AbsolutePos();
Rectangle bounds = ViewBounds(hit.AbsoluteAncestor());
BlockStack parent = (BlockStack)hit.Model.ParentRelationship.Parent;
TopLevelScript splitted = SplitBlockStack(parent, i, np);
Update(bounds);
draggedModel = splitted;
hit = blockViews[splitted.Block];
}
else if (hit.Model.ParentRelationship.Type == ParentRelationshipType.Arg)
{
if (hit is ITextualView)
{
// We shouldn't detach e.g a number argument from its block
// but we should enable the user to edit it
SetEditState((ITextualView) hit);
return;
}
int i = hit.Model.ParentRelationship.Index;
Point np = hit.AbsolutePos();
Rectangle bounds = ViewBounds(hit.AbsoluteAncestor());
InvokationBlock parent = (InvokationBlock)hit.Model.ParentRelationship.Parent;
TopLevelScript splitted = TakeoutBlockArgument(parent, i, np);
Update(bounds);
draggedModel = splitted;
hit = blockViews[splitted.Block];
}
else if (hit.Model.ParentRelationship.Type == ParentRelationshipType.FormalParameter)
{
ProcDefBlock pd = (ProcDefBlock ) hit.Model.ParentRelationship.Parent;
VarAccessBlock va = new VarAccessBlock((VarDefBlock)pd.Bits[hit.Model.ParentRelationship.Index]);
TopLevelScript tls = AddTopLevel(va, p);
hit = ViewFromBlock(va);
draggedModel = tls;
}
else if (hit.Model.ParentRelationship.Type == ParentRelationshipType.None)
{
hit = null;
draggedModel = null;
}
}
else
{
draggedModel = blockSpace.FindScript(hit.Model);
}
if (hit != null)
{
dragged = hit;
draggingOrigin = p;
state = CanvasState.Dragging;
PrepareDropRegions(hit.Model);
}
Update();
}
}
private void SetEditState(ITextualView v)
{
editedTextView = v;
ITextualBlock model = (ITextualBlock)v.Model;
editedTextModel = model;
originalEditedText = model.Text;
TextBox tb = textBoxMaker();
editedTextBox = tb;
tb.Text = model.Text;
tb.Location = v.AbsolutePos();
tb.Size = v.Assemble().Size;
tb.TextChanged += new EventHandler(argTextBox_TextChanged);
tb.KeyDown += new KeyEventHandler(argTextBox_KeyDown);
tb.Show();
tb.Select();
state = CanvasState.TextEditing;
}
