void tempControl_DeleteTemplate(object sender, TemplateEventArgs e)
{
var p = _panels.Peek() as StackPanel;
PanelInfo pi = p.Tag as PanelInfo;
_tempMgr.Delete(e.Name, pi.DataType);
}
void titleControl_BackClick(object sender, EventArgs e)
{
var p = _panels.Pop() as StackPanel;
PanelInfo pi = p.Tag as PanelInfo;
object instance = null;
try {
instance = CreateTypeInstance(p);
} catch (FailedDeserializingCommandException ex) {
if (!ShowDiscardCommandChangesDialog(ex))
{
_panels.Push(p);
return;
}
else
{
instance = pi.InitialObject;
}
}
var currPanel = _panels.Peek() as StackPanel;
SetAttributeValue(currPanel, pi.AttributeName, instance);
ScrollBackToPreviousControl(pi);
}
public void LevelStart()
{
if ((levelController.Current.world == 0) && (levelController.Current.level == 0))
{
PanelStory.SetActive(true);
PanelInfo.SetActive(false);
}
else
{
PanelStory.SetActive(false);
PanelInfo.SetActive(true);
}
text.text = "";
statusText.text = "";
code.text = "";
instructionCount = 0;
instructionHeaderText2.text = "World " + (levelController.Current.world + 1) + ", Level " + (levelController.Current.level + 1);
instructionBodyText2.text = System.Text.RegularExpressions.Regex.Unescape(levelController.Current.instructions);
// instructionTextOld.text = instructionText.text;
panelAllCode.SetActive(false);
allCode.Clear();
updateScoreText();
}
private void OpenDependPanel(int uiID, PanelInfo masterInfo, Action <AbstractPanel> listener, int sortIndexOffset, params object[] args)
{
if (masterInfo == null)
{
Log.e("DependPanel Can not open with null Parent.");
return;
}
PanelInfo panelInfo = LoadPanelInfo(uiID);
if (panelInfo == null)
{
return;
}
panelInfo.AddMaster(masterInfo.panelID, sortIndexOffset, args);
if (panelInfo.isReady)
{
//ReSortPanel();
SetPanelSortingOrderDirty();
panelInfo.AddOpenCallback(listener);
}
else
{
panelInfo.AddOpenCallback(listener);
panelInfo.LoadPanelResAsync();
}
}
//处理面板隐藏逻辑
private void ProcessPanelGameObjectActiveState()
{
int mask = (int)m_TopPanelHideMask;
for (int i = m_ActivePanelInfoList.Count - 1; i >= 0; --i)
{
PanelInfo panelInfo = m_ActivePanelInfoList[i];
if (panelInfo.sortIndex < 0)
{
panelInfo.SetActive(false, false);
continue;
}
if (((mask ^ (int)PanelHideMask.Hide) & (int)PanelHideMask.Hide) == 0)
{
panelInfo.SetActive(false, false);
}
else
{
if (((mask ^ (int)PanelHideMask.UnInteractive) & (int)PanelHideMask.UnInteractive) == 0)
{
panelInfo.SetActive(true, false);
}
else
{
panelInfo.SetActive(true, true);
}
}
mask |= panelInfo.hideMask;
}
}
public void ClosePanel(AbstractPanel panel)
{
if (panel == null)
{
return;
}
PanelInfo panelInfo = FindPanelInfoByPanelID(panel.panelID);
//该面板的管理失效，直接移除
if (panelInfo == null)
{
panelInfo = GetPanelFromCache(panel.uiID, false);
if (panelInfo == null)
{
Log.e("Not Find PanelInfo For Panel:" + panel.name);
panel.OnPanelClose(true);
GameObject.Destroy(panel.gameObject);
}
return;
}
ClosePanelInfo(panelInfo);
//ReSortPanel();
SetPanelSortingOrderDirty();
}
public void CloseDependPanel <T>(int master, T uiID) where T : IConvertible
{
int eID = uiID.ToInt32(null);
List <int> needClosePanel = new List <int>();
for (int i = m_ActivePanelInfoList.Count - 1; i >= 0; --i)
{
if (m_ActivePanelInfoList[i].uiID == eID)
{
m_ActivePanelInfoList[i].RemoveMaster(master);
if (m_ActivePanelInfoList[i].nextMaster <= 0)
{
needClosePanel.Add(m_ActivePanelInfoList[i].panelID);
}
}
}
if (needClosePanel.Count > 0)
{
for (int i = needClosePanel.Count - 1; i >= 0; --i)
{
PanelInfo info = FindPanelInfoByPanelID(needClosePanel[i]);
if (info != null)
{
ClosePanelInfo(info);
}
}
}
SetPanelSortingOrderDirty();
//ReSortPanel();
}
protected virtual void ChangeToNormalPanel()
{
// make sure the panel's center is visible
panel.centerRenderer.enabled = true;
// make sure it doesn't still have that hole
Material baseMaterial;
string materialPath = "Materials/";
if (panel.owner == Combatant.player)
{
materialPath += "Blue";
}
else
{
materialPath += "Red";
}
baseMaterial = Resources.Load <Material>(materialPath);
panel.material = baseMaterial;
// get and apply the normal panel data
PanelInfo normalPanel = panelDatabase.GetPanel("Normal Panel");
panel.ChangeTo(normalPanel);
}
public void OpenPanel <T>(T uiID, PanelType panelType, Action <AbstractPanel> listener, params object[] args)
where T : IConvertible
{
PanelInfo panelInfo = LoadPanelInfo(uiID.ToInt32(null));
if (panelInfo == null)
{
return;
}
panelInfo.sortIndex = m_UIRoot.RequireNextPanelSortingOrder(panelType);
panelInfo.AddMaster(panelInfo.panelID, 0, args);
if (panelInfo.isReady)
{
SetPanelSortingOrderDirty();
//ReSortPanel();
panelInfo.AddOpenCallback(listener);
}
else
{
panelInfo.AddOpenCallback(listener);
panelInfo.LoadPanelResAsync();
}
}
/// <summary>Populate panel-by-panel properties that are shared by all panel types.</summary>
/// <param name="panelInfo">Data to populate from.</param>
private void PopulateCommonProperties(PanelInfo panelInfo)
{
if (panelInfo.Properties.ContainsKey(Property.Backdrop))
{
SetBackdrop(panelInfo.Properties[Property.Backdrop]);
}
}
public void TestApplyChangesToBusinessObject_DoesNothingAsChangesAreAlreadyAppliedForWin()
{
//---------------Set up test pack-------------------
Sample.CreateClassDefWithTwoPropsOneInteger();
Sample sampleBO = new Sample();
const string startText = "startText";
const string endText = "endText";
sampleBO.SampleText = startText;
sampleBO.SampleInt = 1;
IPanelInfo panelInfo = new PanelInfo();
PanelInfo.FieldInfo sampleTextFieldInfo = CreateFieldInfo("SampleText");
PanelInfo.FieldInfo sampleIntFieldInfo = CreateFieldInfo("SampleInt");
panelInfo.FieldInfos.Add(sampleTextFieldInfo);
panelInfo.FieldInfos.Add(sampleIntFieldInfo);
panelInfo.BusinessObject = sampleBO;
sampleTextFieldInfo.InputControl.Text = endText;
//---------------Assert Precondition----------------
Assert.AreEqual(endText, sampleBO.SampleText);
//---------------Execute Test ----------------------
panelInfo.ApplyChangesToBusinessObject();
//---------------Test Result -----------------------
Assert.AreEqual(endText, sampleBO.SampleText);
Assert.AreEqual(1, sampleBO.SampleInt);
}
public override void Execute()
{
// check if there is anything above this panel
Ray above = new Ray(panel.transform.position, panel.transform.up);
RaycastHit[] hits = Physics.RaycastAll(above, 5);
LivingEntityController livingThing = null;
bool foundLivingThing = false;
for (int i = 0; i < hits.Length; i++)
{
livingThing = hits[i].transform.GetComponent <LivingEntityController>();
if (livingThing != null)
{
wasSteppedOn = true;
foundLivingThing = true;
break;
}
}
if (wasSteppedOn && !foundLivingThing)
{
// apparently something stepped off of this panel, so it's time to break it
PanelInfo brokenPanel = PanelDatabase.instance.GetPanel("Broken Panel");
panel.ChangeTo(brokenPanel);
}
}
//resumes the game from the paused state
public void closePanelInfo()
{
Time.timeScale = 1;
PanelInfo.SetActive(false);
SoundManager.instance.PlayBGMusic(worldMusic);
SoundManager.instance.PlayBGChatter(chatter);
}
public void TestApplyChangesToBusinessObject()
{
//---------------Set up test pack-------------------
Sample.CreateClassDefWithTwoPropsOneInteger();
Sample sampleBO = new Sample();
const string startText = "startText";
const string endText = "endText";
sampleBO.SampleText = startText;
sampleBO.SampleInt = 1;
IPanelInfo panelInfo = new PanelInfo();
PanelInfo.FieldInfo sampleTextFieldInfo = CreateFieldInfo("SampleText");
PanelInfo.FieldInfo sampleIntFieldInfo = CreateFieldInfo("SampleInt");
panelInfo.FieldInfos.Add(sampleTextFieldInfo);
panelInfo.FieldInfos.Add(sampleIntFieldInfo);
panelInfo.BusinessObject = sampleBO;
sampleTextFieldInfo.InputControl.Text = endText;
//---------------Assert Precondition----------------
Assert.AreEqual(startText, sampleBO.SampleText);
//---------------Execute Test ----------------------
panelInfo.ApplyChangesToBusinessObject();
//---------------Test Result -----------------------
Assert.AreEqual(endText, sampleBO.SampleText);
Assert.AreEqual(1, sampleBO.SampleInt);
}
protected void SetPanelAnchorParent(PanelBase panel, PanelInfo info)
{
switch (info.mAnchor)
{
case (PanelAnchor.Top):
{
panel.gameObject.transform.parent = mAnchorTop;
break;
}
case (PanelAnchor.TopLeft):
{
panel.gameObject.transform.parent = mAnchorTopLeft;
break;
}
case (PanelAnchor.TopRight):
{
panel.gameObject.transform.parent = mAnchorTopRight;
break;
}
case (PanelAnchor.Center):
{
panel.gameObject.transform.parent = mAnchorCenter;
break;
}
case (PanelAnchor.Left):
{
panel.gameObject.transform.parent = mAnchorLeft;
break;
}
case (PanelAnchor.Right):
{
panel.gameObject.transform.parent = mAnchorRight;
break;
}
case (PanelAnchor.Bottom):
{
panel.gameObject.transform.parent = mAnchorBottom;
break;
}
case (PanelAnchor.BottomLeft):
{
panel.gameObject.transform.parent = mAnchorBottomLeft;
break;
}
case (PanelAnchor.BottomRight):
{
panel.gameObject.transform.parent = mAnchorBottomRight;
break;
}
}
}
/// <summary>
/// Builds a single storyboard from the next set of lines in the file.
/// </summary>
/// <param name="lines">The remaining lines of data.</param>
/// <returns>A StoryboardData object.</returns>
private StoryboardData ProcessStoryboard(Queue <NumberedLine> lines, string name)
{
var panels = new List <PanelInfo>();
var properties = new Dictionary <string, string>();
var panelProps = new Dictionary <string, string>();
var moreLinesInBoard = true;
while (lines.Count > 0 && moreLinesInBoard)
{
var next = lines.Peek().Text.TrimStart();
// No more lines in the storyboard
if (next.StartsWith(Symbol.LabelLine))
{
moreLinesInBoard = false;
}
// Parse a storyboard property
else if (next.StartsWith(Symbol.BoardProperty))
{
ParseProperty(lines.Dequeue(), properties);
}
// Parse a panel property
else if (next.StartsWith(Symbol.PanelProperty))
{
ParseProperty(lines.Dequeue(), panelProps);
}
else if (!string.IsNullOrWhiteSpace(next))
{
PanelInfo panelInfo = null;
// Parse a narrative panel
if (next.StartsWith(Symbol.NarrativeLine))
{
panelInfo = ParseNarrativePanel(lines, panelProps);
}
// Parse a decision panel
else if (next.StartsWith(Symbol.PromptLine))
{
panelInfo = ParseDecisionPanel(lines, panelProps);
}
// Parse an auto-branch
else if (next.StartsWith(Symbol.ConditionOpen) || next.TrimStart().StartsWith(Symbol.BranchLine))
{
panelInfo = ParseBranchPanel(lines, panelProps);
}
// If a panel was successfully parsed, add it to the list and start a new property set.
if (panelInfo != null)
{
panels.Add(panelInfo);
panelProps = new Dictionary <string, string>();
}
}
else
{
_ = lines.Dequeue();
}
}
return(new StoryboardData(name, panels, properties));
}
void setPanelActive(PanelInfo panelInfo)
{
for (int i = 0; i < panelInfos.Length; i++)
{
bool active = panelInfos[i].Equals(panelInfo);
panelInfos[i].panel.SetActive(active);
}
}
public override void initThink(PanelInfo panel_info)
{
setSkillInfo();
m_HandIndex = -1;
m_SkillOrder = m_SkillWorksInfo.getElementOrder(panel_info, MEMBER_ORDER);
}
public bool Equal(PanelInfo data)
{
if (data._viewId == _viewId && data._viewType == _viewType)
{
return(true);
}
return(false);
}
/// <summary>
/// Create a layer instance as defined by DataRow.
/// </summary>
/// <param name="dr">DataRow defining the layer</param>
/// <param name="imageList">List of images used in the level</param>
public Layer(DataRow dr, ArrayList imageList)
{
Debug.Assert(imageList.Count > 0,
"Layer.Layer: Image list must be loaded before Layer");
Debug.Assert(dr != null,
"Layer.Layer: DataRow invalid");
// Initialize the panel data
for (int i = 0; i < panels.Length; i++)
{
panels[i] = new PanelInfo();
Debug.Assert(panels[i] != null,
"Layer.Layer: Failed to initialize PanelInfo");
}
// Read in the general information
screenX = int.Parse((string)dr["X"],
CultureInfo.InvariantCulture);
screenYValue = int.Parse((string)dr["Y"],
CultureInfo.InvariantCulture);
scrollPerFrame = float.Parse((string)dr["ScrollRate"],
CultureInfo.InvariantCulture);
resetScrollPerFrame = scrollPerFrame;
// Read in the image sequence. Each element in the list is
// an index into imageList representing an image in the background
ReadSequence((string)dr["ScrollIndices"]);
// Set the width and height of the layer
imageWidth = 0;
imageHeight = 0;
// Cycle through the sequence to determine some layer
// parameters and set the images' source keys
foreach (byte b in sequence)
{
IBitmap bmp = (IBitmap)imageList[sequence[b]];
Debug.Assert(bmp != null,
string.Format(CultureInfo.InvariantCulture,
"Layer.Layer: Bitmap {0} is invalid", b));
if (bmp.Width > imageWidth)
{
imageWidth = bmp.Width;
}
if (bmp.Height > imageHeight)
{
imageHeight = bmp.Height;
}
}
// Verify that the sequence is valid
VerifySequence(imageList);
}
public void TestPanelInfos()
{
//---------------Execute Test ----------------------
IPanelInfo panelInfo = new PanelInfo();
//---------------Test Result -----------------------
Assert.IsNotNull(panelInfo.PanelInfos);
Assert.AreEqual(0, panelInfo.PanelInfos.Count);
}
public void ChangeData(PanelInfo _Pi)
{
PartName.text = _Pi.PartName;
PartInfo.text = _Pi.PartDescription;
PartImage.sprite = _Pi.PartImage;
part = _Pi.PartType;
Anim.SetBool("Show", true);
state = true;
}
//Pauses the game and timescale
/*public void showPanelInfo()
* {
* Time.timeScale = 0.0001F;
* PanelInfo.SetActive(true);
* }*/
//resumes the game from the paused state
public void closePanelInfo()
{
Time.timeScale = 1;
PanelInfo.SetActive(false);
// Debug.Log(string.Format("done"));
SoundManager.instance.PlayBGMusic(worldMusic);
SoundManager.instance.PlayBGChatter(chatter);
showTutorialPanels();
}
public AbstractPanel FindPanel <T>(T uiID) where T : IConvertible
{
PanelInfo info = GetPanelFromActive(uiID.ToInt32(null));
if (info == null)
{
return(null);
}
return(info.abstractPanel);
}
private StackPanel CreateDataPanel(Type type, string attribute, object value)
{
StackPanel mainPanel = new StackPanel();
mainPanel.HorizontalAlignment = System.Windows.HorizontalAlignment.Left;
mainPanel.Margin = new Thickness(0, 0, 0, 0);
mainPanel.Background = Brushes.Transparent;
mainPanel.Width = CONTROL_WIDTH; // 480;
var panelInfo = new PanelInfo()
{
DataType = type, AttributeName = attribute, ChildControl = mainPanel
};
mainPanel.Tag = panelInfo;
CreateTitlePart(mainPanel, type, attribute, value);
double h = 0;
foreach (UserControl c in mainPanel.Children.OfType <UserControl>())
{
h += c.Height;
}
ScrollViewer scroller = new ScrollViewer();
scroller.VerticalScrollBarVisibility = ScrollBarVisibility.Auto;
scroller.CanContentScroll = false;
scroller.Width = CONTROL_WIDTH; // 500
scroller.Margin = new Thickness(0, 0, 0, 0);
scroller.Height = this.ActualHeight - h;
scroller.Style = FindResource("FavsScrollViewer") as Style;
// Stack Panel for Input Controls
StackPanel p = new StackPanel();
p.HorizontalAlignment = System.Windows.HorizontalAlignment.Left;
//p.Margin = new Thickness(0,0,0,0);
p.Background = Brushes.Transparent;
p.Tag = panelInfo;
p.Width = CONTROL_WIDTH - 30; // remove space for the scrollbar;
scroller.Content = p;
mainPanel.Children.Add(scroller);
_panels.Push(p);
theStack.Children.Add(mainPanel);
this.Width = theStack.Children.Count * 1000;
return(p);
}
void tempControl_CreateTemplate(object sender, TemplateEventArgs e)
{
var p = _panels.Peek() as StackPanel;
PanelInfo pi = p.Tag as PanelInfo;
object instance = CreateTypeInstance(p);
_tempMgr.Store(e.Name, pi.DataType, instance, e.IsDefault);
e.Value = instance;
}
public void SetPanelStateDirtyByPanelId(int panelId)
{
PanelInfo info = FindPanelInfoByPanelID(panelId);
if (info == null)
{
return;
}
info.SetStateDirty();
}
/// <summary>
/// Register a panel and save as PanelInfo
/// </summary>
public void RegisterPanel(string name, string resPath, int depth, PanelAnchor anchor)
{
if (mPanelInfoMap.ContainsKey(name))
{
Debug.Log("panel name={0} already registered");
return;
}
PanelInfo info = new PanelInfo(name, resPath, depth, anchor);
mPanelInfoMap.Add(name, info);
}
private PanelInfo GetPageControlsPanelInfo(SPContentTypeCollection contentTypes, CultureInfo culture)
{
SPContentType type = contentTypes[ContentTypeId.PageTemplate];
PanelInfo info = new PanelInfo();
info = new PanelInfo();
info.displayName = type.Name;// ""; //Resources.GetStringEx("ToolboxPanelNamePageControls", culture);
info.controlListId = type.Id.ToString();
info.panelTypeIdentifier = pageControlspanelTypeIdentifier;
return(info);
}
public AbstractPage FindPanelPage <T>(int panelID, T uiID) where T : IConvertible
{
PanelInfo info = FindPanelInfoByPanelID(panelID);
if (info == null)
{
return(null);
}
return(info.GetPage(uiID.ToInt32(null)));
}
/// <summary>
/// For things like changing a normal panel to a broken one, etc.
/// </summary>
/// <param name="newPanel"></param>
public void ChangeTo(PanelInfo newPanel)
{
if (this.panelInfo.Equals(newPanel))
{
Debug.LogWarning(name + ": this panel is already a " + newPanel.name);
}
else
{
panelInfo = newPanel;
ApplyPanelData();
}
}
public void TestPanel()
{
//---------------Set up test pack-------------------
IPanelInfo panelInfo = new PanelInfo();
IPanel panel = CreatePanel();
//---------------Assert Precondition----------------
Assert.IsNull(panelInfo.Panel);
//---------------Execute Test ----------------------
panelInfo.Panel = panel;
//---------------Test Result -----------------------
Assert.AreSame(panel, panelInfo.Panel);
}
public void TestFieldInfos_WrongPropertyNameGivesUsefulError()
{
//---------------Set up test pack-------------------
IPanelInfo panelInfo = new PanelInfo();
//---------------Execute Test ----------------------
try
{
PanelInfo.FieldInfo fieldInfo = panelInfo.FieldInfos["invalidPropName"];
Assert.Fail("Expected to throw an InvalidPropertyNameException");
}
//---------------Test Result -----------------------
catch (InvalidPropertyNameException ex)
{
StringAssert.Contains("A label for the property invalidPropName was not found", ex.Message);
}
}
public void TestPanelInfos()
{
//---------------Execute Test ----------------------
IPanelInfo panelInfo = new PanelInfo();
//---------------Test Result -----------------------
Assert.IsNotNull(panelInfo.PanelInfos);
Assert.AreEqual(0, panelInfo.PanelInfos.Count);
}
///<summary>
/// Builds a Panel for a single Tab as defined in the <see cref="UIForm"/>.
/// There will be one <see cref="IPanelInfo"/> for the defined uiForm.<br/>
/// If there are multiple tabs defined for the <paramref name="uiForm"/> then
/// an actual <see cref="ITabPage"/> is created for each <see cref="UIFormTab"/>
/// and the <see cref="IPanel"/> created by <see cref="BuildPanelForTab"/> will
/// be placed on this TabPage.<br></br>
/// Else the <see cref="IPanel"/> is placed on the form directly.
///</summary>
/// <param name="uiForm">The UIForm object that indicates which controls
/// to create and how the controls are laid out</param>
///<param name="groupControlCreator">The <see cref="GroupControlCreator"/></param>
/// <returns>Returns an IPanelInfo object that contains access to the
/// BusinessObject instance, the created panel, and all the controls,
/// mappers, labels and error providers that were created.
/// </returns>
public IPanelInfo BuildPanelForForm(IUIForm uiForm, GroupControlCreator groupControlCreator)
{
if (uiForm == null) throw new ArgumentNullException("uiForm");
if (groupControlCreator == null) throw new ArgumentNullException("groupControlCreator");
var panelInfo = new PanelInfo();
// generic interface
foreach (UIFormTab formTab in uiForm)
{
var tabPagePanelInfo = BuildPanelForTab(formTab);
panelInfo.PanelInfos.Add(tabPagePanelInfo);
foreach (PanelInfo.FieldInfo fieldInfo in tabPagePanelInfo.FieldInfos)
{
panelInfo.FieldInfos.Add(fieldInfo);
}
if (tabPagePanelInfo.MinimumPanelHeight > panelInfo.MinimumPanelHeight)
{
panelInfo.MinimumPanelHeight = tabPagePanelInfo.MinimumPanelHeight;
}
}
IPanel mainPanel;
if (panelInfo.PanelInfos.Count == 0)
{
mainPanel = ControlFactory.CreatePanel();
}
else if (panelInfo.PanelInfos.Count == 1)
{
mainPanel = panelInfo.PanelInfos[0].Panel;
int lesserHeight = panelInfo.MinimumPanelHeight;
if (uiForm.Height < lesserHeight) lesserHeight = uiForm.Height;
mainPanel.MinimumSize = new Size(uiForm.Width, lesserHeight);
}
else
{
var groupControl = groupControlCreator();
foreach (var childPanelInfo in panelInfo.PanelInfos)
{
var uiFormTab = childPanelInfo.UIFormTab;
var childPanel = childPanelInfo.Panel;
groupControl.AddControl(childPanel, uiFormTab.Name, childPanel.Height, childPanel.Width);
}
var panel = ControlFactory.CreatePanel();
groupControl.Dock = DockStyle.Fill;
panel.MinimumSize = groupControl.Size;
panel.Controls.Add(groupControl);
mainPanel = panel;
}
panelInfo.Panel = mainPanel;
mainPanel.Name = _controlNamingStrategy.GetUIFormControlName(uiForm);
mainPanel.Size = new Size(uiForm.Width, uiForm.Height);
panelInfo.UIForm = uiForm;
return panelInfo;
}
/// <summary>
/// Constructs a panel for editing the data of a single instance
/// of a BusinessObject, using the control layout as specified in
/// a <see cref="UIFormTab"/> object.
/// </summary>
/// <param name="formTab">The tab object that indicates which controls
/// to create and how the controls are laid out</param>
/// <returns>Returns an IPanelInfo object that contains access to the
/// BusinessObject instance, the created panel, and all the controls,
/// mappers, labels and error providers that were created.
/// </returns>
public IPanelInfo BuildPanelForTab(UIFormTab formTab)
{
if (formTab == null) throw new ArgumentNullException("formTab");
var panel = ControlFactory.CreatePanel();
var panelInfo = new PanelInfo();
var layoutManager = SetupLayoutManager(formTab, panel);
panelInfo.LayoutManager = layoutManager;
panelInfo.Panel = panel;
AddFieldsToLayoutManager(formTab, panelInfo);
SetupInputControlColumnWidth(panelInfo, formTab);
panel.Width = layoutManager.GetFixedWidthIncludingGaps();
panel.Height = layoutManager.GetFixedHeightIncludingGaps();
Size minSize = new Size(panel.Width, panel.Height);
panel.MinimumSize = minSize;
panelInfo.UIFormTab = formTab;
panelInfo.MinimumPanelHeight = panel.Height;
panelInfo.UIForm = formTab.UIForm;
return panelInfo;
}
bool IsFixed(PanelInfo pi)
{
return !pi.Resize && (pi == panel1 ? panel2 : panel1).Resize;
}
private void ScrollBackToPreviousControl(PanelInfo pi)
{
DoubleAnimation anim = new DoubleAnimation();
anim.From = ( _panels.Count ) * -CONTROL_WIDTH;
anim.To = anim.From + CONTROL_WIDTH;
anim.Duration = new Duration(new TimeSpan(0, 0, 0, 0, SCROLLTO_CONTROL_SPEED));
anim.RepeatBehavior = new RepeatBehavior(1);
anim.Completed += (s2, e2) => { theStack.Children.Remove(pi.ChildControl); };
anim.AccelerationRatio = 0.5;
anim.DecelerationRatio = 0.5;
TranslateTransform trans = new TranslateTransform();
theStack.RenderTransform = trans;
trans.BeginAnimation(TranslateTransform.XProperty, anim);
}
private StackPanel CreateDataPanel(Type type, string attribute, object value)
{
StackPanel mainPanel = new StackPanel();
mainPanel.HorizontalAlignment = System.Windows.HorizontalAlignment.Left;
mainPanel.Margin = new Thickness(0, 0, 0, 0);
mainPanel.Background = Brushes.Transparent;
mainPanel.Width = CONTROL_WIDTH; // 480;
var panelInfo = new PanelInfo() { DataType = type, AttributeName = attribute, ChildControl = mainPanel };
mainPanel.Tag = panelInfo;
CreateTitlePart(mainPanel, type, attribute, value);
double h = 0;
foreach( UserControl c in mainPanel.Children.OfType<UserControl>() )
h += c.Height;
ScrollViewer scroller = new ScrollViewer();
scroller.VerticalScrollBarVisibility = ScrollBarVisibility.Auto;
scroller.CanContentScroll = false;
scroller.Width = CONTROL_WIDTH; // 500
scroller.Margin = new Thickness(0, 0, 0, 0);
scroller.Height = this.ActualHeight - h;
scroller.Style = FindResource("FavsScrollViewer") as Style;
// Stack Panel for Input Controls
StackPanel p = new StackPanel();
p.HorizontalAlignment = System.Windows.HorizontalAlignment.Left;
//p.Margin = new Thickness(0,0,0,0);
p.Background = Brushes.Transparent;
p.Tag = panelInfo;
p.Width = CONTROL_WIDTH - 30; // remove space for the scrollbar;
scroller.Content = p;
mainPanel.Children.Add(scroller);
_panels.Push(p);
theStack.Children.Add(mainPanel);
this.Width = theStack.Children.Count * 1000;
return p;
}
public void TestFieldInfos()
{
//---------------Set up test pack-------------------
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
IPanelInfo panelInfo = new PanelInfo();
//---------------Test Result -----------------------
Assert.IsNotNull(panelInfo.FieldInfos);
Assert.AreEqual(0, panelInfo.FieldInfos.Count);
}
// public void Show() {
// animator.SetBool("isShowing", true);
// }
//
// public void Hide() {
// animator.SetBool("isShowing", false);
// }
public void SetPanelInfo(PanelInfo panelInfo) {
SetTitle(panelInfo.title);
SetDescription(panelInfo.description);
SetHeaderColor(panelInfo.headerColor);
}
public void TestSetBusinessObjectUpdatesControlMappers()
{
//---------------Set up test pack-------------------
Sample.CreateClassDefWithTwoPropsOneInteger();
IPanelInfo panelInfo = new PanelInfo();
panelInfo.FieldInfos.Add(CreateFieldInfo("SampleText"));
panelInfo.FieldInfos.Add(CreateFieldInfo("SampleInt"));
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
Sample sampleBO = new Sample();
panelInfo.BusinessObject = sampleBO;
//---------------Test Result -----------------------
Assert.AreSame(sampleBO, panelInfo.BusinessObject);
Assert.AreSame(sampleBO, panelInfo.FieldInfos[0].ControlMapper.BusinessObject);
Assert.AreSame(sampleBO, panelInfo.FieldInfos[1].ControlMapper.BusinessObject);
}
