private void DrawHelpButton()
{
GUILayout.Space(33);
Rect position = new Rect(Window.position.width - 37, 2, 34, 26);
using (var helpMenuContent = ControlContent.Basic(
RotorzEditorStyles.Skin.ContextHelp,
TileLang.ParticularText("Action", "Help")
)) {
if (EditorInternalUtility.DropdownMenu(position, helpMenuContent, RotorzEditorStyles.Instance.FlatButton))
{
var helpMenu = new EditorMenu();
helpMenu.AddCommand(TileLang.ParticularText("Action", "Show Tips"))
.Checked(ControlContent.TrailingTipsVisible)
.Action(() => {
ControlContent.TrailingTipsVisible = !ControlContent.TrailingTipsVisible;
});
--position.y;
helpMenu.ShowAsDropdown(position);
}
}
}
/// <inheritdoc/>
public override void OnExtendedPropertiesGUI()
{
var emptyBrush = Brush as EmptyBrush;
using (var content = ControlContent.WithTrailableTip(
TileLang.ParticularText("Property", "Always Add Container"),
TileLang.Text("Add tile container object even when not needed by brush.")
)) {
emptyBrush.alwaysAddContainer = EditorGUILayout.ToggleLeft(content, emptyBrush.alwaysAddContainer);
ExtraEditorGUI.TrailingTip(content);
}
using (var content = ControlContent.WithTrailableTip(
TileLang.ParticularText("Property", "Add Collider"),
TileLang.Text("Automatically adds box collider to painted tile.")
)) {
emptyBrush.addCollider = EditorGUILayout.ToggleLeft(content, emptyBrush.addCollider);
if (emptyBrush.addCollider)
{
++EditorGUI.indentLevel;
emptyBrush.colliderType = (ColliderType)EditorGUILayout.EnumPopup(emptyBrush.colliderType);
--EditorGUI.indentLevel;
}
ExtraEditorGUI.TrailingTip(content);
}
}
/// <summary>
/// Wraps the given text caption or existing DOM node(s) in a structural element
/// containing the menu item's contents.
/// </summary>
/// <param name="content">Menu item contents.</param>
/// <param name="dom">DOM helper for document interaction.</param>
/// <returns>Menu item content element.</returns>
private HTMLElement createContent(ControlContent content, dom.DomHelper dom)
{
var contentClassName = this.getCompositeCssClass_(
goog.ui.MenuItemRenderer.CompositeCssClassIndex_.CONTENT);
return(dom.createDom(goog.dom.TagName.DIV, contentClassName, content));
}
private static ControlContent AlignmentContent(string label, SnapAxis axis)
{
Texture2D icon;
string tip;
switch (axis.Alignment)
{
default:
case SnapAlignment.Points:
icon = RotorzEditorStyles.Skin.SnapPoints;
tip = TileLang.ParticularText("SnapAlignment", "Points");
break;
case SnapAlignment.Cells:
icon = RotorzEditorStyles.Skin.SnapCells;
tip = TileLang.ParticularText("SnapAlignment", "Cells");
break;
case SnapAlignment.Free:
icon = label == "X" ? RotorzEditorStyles.Skin.SnapFreeX : RotorzEditorStyles.Skin.SnapFreeY;
tip = TileLang.ParticularText("SnapAlignment", "Free");
break;
}
return(ControlContent.Basic(icon, tip));
}
private void DrawProceduralField(TilesetBrush brush, Tileset tileset)
{
using (var content = ControlContent.WithTrailableTip(
TileLang.ParticularText("Property", "Procedural"),
TileLang.Text("Allows individual atlas brushes to override property of tileset.")
)) {
// Need to make width of "Procedural" popup shorter.
GUILayout.BeginHorizontal(GUILayout.Width(200));
InheritYesNo newProcedural = (InheritYesNo)EditorGUILayout.EnumPopup(content, brush.procedural);
if (newProcedural != brush.procedural)
{
brush.procedural = newProcedural;
if (!brush.IsProcedural)
{
// Ensure that required procedural mesh exists!
if (BrushUtility.EnsureTilesetMeshExists(tileset, brush.tileIndex))
{
AssetDatabase.ImportAsset(AssetDatabase.GetAssetPath(tileset.tileMeshAsset));
}
}
}
Rect position = GUILayoutUtility.GetLastRect();
GUI.Label(new Rect(position.x + position.width, position.y, 100, position.height), "= " + (brush.IsProcedural ? TileLang.Text("Procedural") : TileLang.Text("Non-Procedural")), EditorStyles.miniLabel);
GUILayout.EndHorizontal();
ExtraEditorGUI.TrailingTip(content);
}
}
public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
{
var idProperty = property.FindPropertyRelative("id");
var labelProperty = property.FindPropertyRelative("label");
float initialLabelWidth = EditorGUIUtility.labelWidth;
EditorGUIUtility.labelWidth = 64;
if (ProjectSettings.Instance.ShowCategoryIds)
{
using (var content = ControlContent.Basic(
labelText: string.Format(
/* 0: category id */
TileLang.Text("Id: {0}"),
idProperty.intValue
)
)) {
position = EditorGUI.PrefixLabel(position, content);
}
}
labelProperty.stringValue = EditorGUI.TextField(position, labelProperty.stringValue);
EditorGUIUtility.labelWidth = initialLabelWidth;
}
public FrmLogin(ControlContent come)
{
InitializeComponent();
this.Shown += new EventHandler(FrmLoginDb_Shown);
this.FormClosed += new FormClosedEventHandler(FrmLoginDb_FormClosed);
runcome = come;
}
private void DrawToolbar()
{
GUILayout.BeginHorizontal(EditorStyles.toolbar);
EditorGUI.BeginDisabledGroup(PrefabUtility.GetPrefabType(this.target) == PrefabType.Prefab || this.targets.Length != 1);
if (this.target.IsEditable && GUILayout.Button(TileLang.OpensWindow(TileLang.ParticularText("Action", "Build Prefab")), RotorzEditorStyles.Instance.ToolbarButtonPaddedExtra))
{
TileSystemCommands.Command_BuildPrefab(this.target);
GUIUtility.ExitGUI();
}
EditorGUI.EndDisabledGroup();
GUILayout.FlexibleSpace();
using (var content = ControlContent.Basic(
RotorzEditorStyles.Skin.GridToggle,
TileLang.ParticularText("Action", "Toggle Grid Display")
)) {
RtsPreferences.ShowGrid.Value = GUILayout.Toggle(RtsPreferences.ShowGrid, content, RotorzEditorStyles.Instance.ToolbarButtonPadded);
}
using (var content = ControlContent.Basic(
RotorzEditorStyles.Skin.ChunkToggle,
TileLang.ParticularText("Action", "Toggle Chunk Display")
)) {
RtsPreferences.ShowChunks.Value = GUILayout.Toggle(RtsPreferences.ShowChunks, content, RotorzEditorStyles.Instance.ToolbarButtonPadded);
}
EditorGUILayout.Space();
this.DrawHelpButton();
GUILayout.EndHorizontal();
}
/// <inheritdoc/>
protected override void DoEnable()
{
this.titleContent = new GUIContent(string.Format(
/* 0: name of product */
TileLang.Text("Preferences - {0}"),
ProductInfo.Name
));
this.InitialSize = this.minSize = new Vector2(500, 342);
this.maxSize = new Vector2(500, 10000);
this.wantsMouseMove = true;
this.tabs = new GUIContent[] {
ControlContent.Basic(TileLang.ParticularText("Preferences|TabLabel", "Tools")),
ControlContent.Basic(TileLang.ParticularText("Preferences|TabLabel", "Painting")),
ControlContent.Basic(TileLang.ParticularText("Preferences|TabLabel", "Grid")),
ControlContent.Basic(TileLang.ParticularText("Preferences|TabLabel", "Misc"))
};
this.scrolling = new Vector2[this.tabs.Length];
this.toolsAdaptor = new GenericListAdaptor <ToolBase>(ToolManager.Instance.toolsInUserOrder, this.DrawAvailableToolEntry, 22);
this.GatherLocaleOptions();
}
private void DrawTabs()
{
GUILayout.BeginHorizontal();
for (int i = 0; i < this.tabs.Length; ++i)
{
using (var tabLabelContent = ControlContent.Basic(this.tabs[i].Label)) {
Rect position = GUILayoutUtility.GetRect(tabLabelContent, RotorzEditorStyles.Instance.Tab);
int controlID = GUIUtility.GetControlID(FocusType.Passive, position);
switch (Event.current.GetTypeForControl(controlID))
{
case EventType.MouseDown:
if (position.Contains(Event.current.mousePosition))
{
s_SelectedTab = i;
Event.current.Use();
}
break;
case EventType.Repaint:
RotorzEditorStyles.Instance.Tab.Draw(position, tabLabelContent, false, false, s_SelectedTab == i, false);
break;
}
}
}
GUILayout.Box(GUIContent.none, RotorzEditorStyles.Instance.TabBackground);
GUILayout.EndHorizontal();
}
private void DrawPrimarySecondaryBrushSwitcher()
{
Rect r;
GUILayout.Space(5);
GUILayout.BeginHorizontal();
GUILayout.FlexibleSpace();
GUILayout.Label(RotorzEditorStyles.Skin.MouseLeft);
GUILayout.Box(GUIContent.none, RotorzEditorStyles.Instance.SelectedBrushPreviewBox);
r = GUILayoutUtility.GetLastRect();
if (ToolUtility.SelectedBrush != null)
{
RotorzEditorGUI.DrawBrushPreview(new Rect(r.x + 2, r.y + 2, r.width - 4, r.height - 4), ToolUtility.SelectedBrush);
}
else
{
GUI.Label(r, TileLang.ParticularText("Action", "Erase"), RotorzEditorStyles.Instance.MiniCenteredLabel);
}
GUILayout.Space(10);
GUILayout.Label(RotorzEditorStyles.Skin.MouseRight);
GUILayout.Box(GUIContent.none, RotorzEditorStyles.Instance.SelectedBrushPreviewBox);
r = GUILayoutUtility.GetLastRect();
if (ToolUtility.SelectedBrushSecondary != null)
{
RotorzEditorGUI.DrawBrushPreview(new Rect(r.x + 2, r.y + 2, r.width - 4, r.height - 4), ToolUtility.SelectedBrushSecondary);
}
else
{
GUI.Label(r, TileLang.ParticularText("Action", "Erase"), RotorzEditorStyles.Instance.MiniCenteredLabel);
}
GUILayout.Space(5);
using (var content = ControlContent.Basic(
RotorzEditorStyles.Skin.SwitchPrimarySecondary,
TileLang.ParticularText("Action", "Switch primary and secondary brushes (X)")
)) {
if (RotorzEditorGUI.HoverButton(content, GUILayout.Height(42)))
{
Brush t = ToolUtility.SelectedBrush;
ToolUtility.SelectedBrush = ToolUtility.SelectedBrushSecondary;
ToolUtility.SelectedBrushSecondary = t;
GUIUtility.ExitGUI();
}
}
GUILayout.FlexibleSpace();
GUILayout.EndHorizontal();
GUILayout.Space(5);
}
/// <summary>
/// Use to draw menu button somewhere within designer window.
/// </summary>
/// <remarks>
/// <para>Custom menu items can be added to menu by providing a custom implementation
/// of <see cref="AddItemsToMenu"/>.</para>
/// </remarks>
/// <param name="position">Position of button in space of editor window.</param>
/// <param name="tooltip">Tooltip text.</param>
protected void DrawMenuButton(Rect position, string tooltip = null)
{
using (var content = ControlContent.Basic(RotorzEditorStyles.Skin.GearButton, tooltip)) {
if (EditorInternalUtility.DropdownMenu(position, content, RotorzEditorStyles.Instance.FlatButton))
{
this.DisplayMenu(new Rect(position.x, position.y, position.width, position.height - 1));
GUIUtility.ExitGUI();
}
}
}
private void DrawMaintainTilePositionsInWorld(ref bool flag)
{
++EditorGUI.indentLevel;
// "Maintain tile positions in world space"
using (var content = ControlContent.Basic(TileLang.ParticularText("Property", "Maintain tile positions in world space"))) {
flag = EditorGUILayout.ToggleLeft(content, flag);
}
--EditorGUI.indentLevel;
}
/// <inheritdoc/>
protected override void DoGUI()
{
Event e = Event.current;
Rect position;
GUILayout.Space(10);
// Draw header area.
using (var titleContent = ControlContent.Basic(ProductInfo.Name)) {
position = GUILayoutUtility.GetRect(1, 100);
if (e.type == EventType.Repaint)
{
Rect headerBackgroundPosition = new Rect(position.x - 2, position.y - 12, position.width + 4, position.height);
if (EditorGUIUtility.isProSkin)
{
GUI.DrawTexture(headerBackgroundPosition, EditorGUIUtility.whiteTexture);
}
else
{
RotorzEditorStyles.Instance.TransparentBox.Draw(headerBackgroundPosition, GUIContent.none, false, false, false, false);
}
Texture2D texAssetBadge = RotorzEditorStyles.Skin.Badge;
GUI.DrawTexture(new Rect(position.x + position.width - texAssetBadge.width - 6, position.y - 3, texAssetBadge.width, texAssetBadge.height), texAssetBadge);
}
position.x += 10;
position.width -= 10;
GUI.Label(position, titleContent, this.labelTitleStyle);
Rect versionLabelPosition = new Rect(position.x, position.y + this.labelTitleStyle.CalcHeight(titleContent, position.width), position.width, 42);
GUI.Label(versionLabelPosition, this.versionString, this.labelVersionStyle);
GUILayout.BeginHorizontal();
this.AddLink(TileLang.ParticularText("Online", "Repository"), "https://github.com/rotorz/unity3d-tile-system", "https://github.com/rotorz/unity3d-tile-system");
GUILayout.EndHorizontal();
}
ExtraEditorGUI.SeparatorLight(marginTop: 17, marginBottom: 7);
// Draw footer area.
var vendorBadge = RotorzEditorStyles.Skin.VendorBadge;
position = GUILayoutUtility.GetRect(1, vendorBadge.height + 5);
if (e.type == EventType.Repaint)
{
GUI.DrawTexture(new Rect(position.x + 7, position.y - 2, vendorBadge.width, vendorBadge.height), vendorBadge);
position.y -= 4;
this.labelLowerRightStyle.Draw(position, "©2011-2017 Rotorz Limited. All rights reserved.", false, false, false, false);
}
}
public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
{
Rect rect = new Rect(position.x, position.y, position.width, EditorGUIUtility.singleLineHeight + 1);
var propActive = property.FindPropertyRelative("isActive");
ExtraEditorGUI.ToggleLeft(rect, propActive, label);
rect.y = rect.yMax + 1;
if (propActive.boolValue)
{
++EditorGUI.indentLevel;
using (var content = ControlContent.Basic(
TileLang.ParticularText("Property", "Snap Threshold")
)) {
var propSnapThreshold = property.FindPropertyRelative("snapThreshold");
EditorGUI.PropertyField(rect, propSnapThreshold, content);
rect.y = rect.yMax + 1;
}
using (var content = ControlContent.Basic(
TileLang.ParticularText("Property", "Keep Separate")
)) {
var propKeepSeparate = property.FindPropertyRelative("keepSeparate");
DrawKeepSeparateField(rect, propKeepSeparate, content);
rect.y = rect.yMax + 1;
}
using (var content = ControlContent.Basic(
TileLang.ParticularText("Property", "Include tiles flagged as solid")
)) {
var propIncludeSolidTiles = property.FindPropertyRelative("includeSolidTiles");
ExtraEditorGUI.ToggleLeft(rect, propIncludeSolidTiles, content);
rect.y = rect.yMax + 1;
if (propIncludeSolidTiles.boolValue)
{
++EditorGUI.indentLevel;
using (var content2 = ControlContent.Basic(
TileLang.ParticularText("Property", "Collider Type")
)) {
var propSolidTileColliderType = property.FindPropertyRelative("solidTileColliderType");
EditorGUI.PropertyField(rect, propSolidTileColliderType, content2);
}
--EditorGUI.indentLevel;
}
}
--EditorGUI.indentLevel;
}
}
private void DrawTilesetNameField()
{
GUILayout.Label(TileLang.ParticularText("Property", "Tileset"), RotorzEditorStyles.Instance.LabelMiddleLeft);
this.inputTilesetName = EditorGUILayout.TextField(this.inputTilesetName, RotorzEditorStyles.Instance.TextFieldRoundEdge);
var currentTilesetName = Tileset.name;
if (this.inputTilesetName != currentTilesetName)
{
string filteredName = this.inputTilesetName;
// Limit to 70 characters.
if (filteredName.Length > 70)
{
filteredName = filteredName.Substring(0, 70);
}
// Restrict to alphanumeric characters.
filteredName = Regex.Replace(filteredName, "[^- A-Za-z0-9_+!~#()]+", "");
using (var content = ControlContent.Basic(
"",
TileLang.ParticularText("Action", "Restore Current Name")
)) {
if (GUILayout.Button(content, RotorzEditorStyles.Instance.TextFieldRoundEdgeCancelButton))
{
GUIUtility.keyboardControl = 0;
this.inputTilesetName = currentTilesetName;
GUIUtility.ExitGUI();
}
}
using (var content = ControlContent.Basic(
TileLang.ParticularText("Action", "Rename")
)) {
if (!string.IsNullOrEmpty(filteredName) && filteredName != currentTilesetName)
{
if (GUILayout.Button(content, RotorzEditorStyles.Instance.ButtonPaddedExtra))
{
currentTilesetName = this.inputTilesetName = filteredName;
this.OnRename(this.inputTilesetName);
GUIUtility.ExitGUI();
}
}
}
}
else
{
GUILayout.Label(GUIContent.none, RotorzEditorStyles.Instance.TextFieldRoundEdgeCancelButtonEmpty);
}
}
protected override void OnHeaderGUI()
{
Rect position = GUILayoutUtility.GetRect(0, 46);
if (Event.current.type == EventType.Repaint)
{
GUI.skin.box.Draw(position, GUIContent.none, false, false, false, false);
GUI.DrawTexture(new Rect(7, 7, 32, 32), RotorzEditorStyles.Skin.Icon_PresetTileSystem);
string headerText = targets.Length == 1
? string.Format(
/* 0: name of tile system preset */
TileLang.Text("{0} (Tile System Preset)"),
target.name
)
: string.Format(
/* 0: quantity of selected tile system presets */
TileLang.Text("{0} Tile System Presets"),
targets.Length
);
EditorStyles.largeLabel.Draw(new Rect(48, 7, position.width - 48, position.height), headerText, false, false, false, false);
}
Rect menuPosition = new Rect(position.width - 25, 7, 22, 16);
if (GUI.Button(menuPosition, RotorzEditorStyles.Skin.SmallGearButton, GUIStyle.none))
{
this.ShowContextMenu(menuPosition);
GUIUtility.ExitGUI();
}
EditorGUI.BeginDisabledGroup(targets.Length != 1);
{
using (var content = ControlContent.Basic(
TileLang.ParticularText("Action", "Create Tile System")
)) {
Vector2 createButtonSize = EditorStyles.miniButton.CalcSize(content);
Rect createButtonPosition = new Rect(position.width - createButtonSize.x - 5, 24, createButtonSize.x, createButtonSize.y);
if (GUI.Button(createButtonPosition, content, EditorStyles.miniButton))
{
var tileSystemGO = TileSystemPresetUtility.CreateTileSystemFromPreset((TileSystemPreset)target);
Selection.activeObject = tileSystemGO;
Undo.RegisterCreatedObjectUndo(tileSystemGO, content.LabelContent.text);
}
}
}
EditorGUI.EndDisabledGroup();
GUILayout.Space(5);
}
private bool ToolButton(GUIContent content, bool on = false)
{
Rect position = GUILayoutUtility.GetRect(content, s_ToolButtonStyle);
int controlID = RotorzEditorGUI.GetHoverControlID(position, content.image != null ? content.text : null);
switch (Event.current.GetTypeForControl(controlID))
{
case EventType.MouseDown:
if (Event.current.button == 0 && position.Contains(Event.current.mousePosition))
{
GUIUtility.hotControl = controlID;
Event.current.Use();
}
break;
case EventType.MouseUp:
if (GUIUtility.hotControl == controlID)
{
GUIUtility.hotControl = 0;
Event.current.Use();
return(position.Contains(Event.current.mousePosition));
}
break;
case EventType.MouseDrag:
if (GUIUtility.hotControl == controlID)
{
Event.current.Use();
}
break;
case EventType.Repaint:
if (content.image != null)
{
using (var tempContent = ControlContent.Basic(content.image)) {
s_ToolButtonStyle.Draw(position, tempContent, controlID, on);
}
}
else
{
using (var tempContent = ControlContent.Basic(content.text)) {
s_ToolButtonStyle.Draw(position, tempContent, controlID, on);
}
}
break;
}
return(false);
}
private void DrawAtlasParametersGUI()
{
EditorGUIUtility.labelWidth = 1;
EditorGUIUtility.fieldWidth = 105;
GUILayout.BeginVertical();
EditorGUI.BeginChangeCheck();
{
ExtraEditorGUI.AbovePrefixLabel(TileLang.ParticularText("Property", "Tile Width (px)"));
this.inputTileWidth = EditorGUILayout.IntField(this.inputTileWidth, GUILayout.Width(60));
ExtraEditorGUI.AbovePrefixLabel(TileLang.ParticularText("Property", "Tile Height (px)"));
this.inputTileHeight = EditorGUILayout.IntField(this.inputTileHeight, GUILayout.Width(60));
}
if (EditorGUI.EndChangeCheck())
{
this.ClearExpandedAutotileAtlas();
// Automatically load uncompressed version of autotile artwork if it has
// not already been loaded.
if (this.inputNewAutotileArtworkUncompressed == null)
{
this.LoadUncompressedAutotileArtwork(this.inputNewAutotileArtwork);
}
}
GUILayout.Space(10);
//this.alpha = GUILayout.Toggle(this.alpha, "Alpha Blending");
using (var content = ControlContent.Basic(
TileLang.ParticularText("Property", "Procedural"),
TileLang.Text("Autotile brushes are always procedural, however atlas brushes of an autotile atlas can be non-procedural if desired.")
)) {
this.inputProcedural = GUILayout.Toggle(this.inputProcedural, content);
}
using (var content = ControlContent.Basic(
TileLang.ParticularText("Property", "Clamp Edges"),
TileLang.Text("Indicates if outer edges should always be clamped. Often not appropriate when secondary tile acts as ground.")
)) {
if (this.autotileTileset.AutotileLayout == AutotileLayout.Extended && this.inputBorderSize > 0)
{
this.inputClampEdges = GUILayout.Toggle(this.inputClampEdges, content);
}
}
GUILayout.EndVertical();
}
/// <summary>
/// Draw "Paint Around Existing Tiles" toggle.
/// </summary>
/// <remarks>
/// <para>This method should be called within horizontally flowing layout.</para>
/// </remarks>
protected void DrawPaintAroundExistingTilesOption()
{
if (!this.SupportsPaintAroundExistingTiles)
{
throw new InvalidOperationException("This tool does not support the 'Paint Around Existing Tiles' option. Consider overriding `SupportsPaintAroundExistingTiles`.");
}
using (var content = ControlContent.Basic(
RotorzEditorStyles.Skin.GetActive(RotorzEditorStyles.Skin.RectanglePaintAround, ToolUtility.PaintAroundExistingTiles),
TileLang.ParticularText("Property", "Paint Around Existing Tiles")
)) {
Rect position = GUILayoutUtility.GetRect(33, 24);
ToolUtility.PaintAroundExistingTiles = RotorzEditorGUI.HoverToggle(position, content, ToolUtility.PaintAroundExistingTiles, RotorzEditorStyles.Instance.FlatButtonNoMargin);
}
}
/// <summary>
/// </summary>
/// Takes a menu item's root element, and sets its content to the given text
/// caption or DOM structure. Overrides the superclass immplementation by
/// making sure that the checkbox structure (for selectable/checkable menu
/// items) is preserved.
/// <param name="element">The item's root element.</param>
/// <param name="content">Text caption or DOM structure to be</param>
/// set as the item's content.
public override void setContent(HTMLElement element, ControlContent content)
{
// Save the checkbox element, if present.
var contentElement = this.getContentElement(element);
var checkBoxElement =
this.hasCheckBoxStructure(element) ? contentElement.FirstChild : null;
base.setContent(element, content);
if (checkBoxElement != null && !this.hasCheckBoxStructure(element))
{
// The call to setContent() blew away the checkbox element; reattach it.
contentElement.InsertBefore(
checkBoxElement, contentElement.FirstChild ?? null);
}
}
private void DrawVariationShifter()
{
Rect position = GUILayoutUtility.GetRect(17, 0);
position.x += 2;
position.height = 27;
Rect plusButtonPosition = new Rect(position.x, position.y - 4, 17, 17);
using (var content = ControlContent.Basic("", this._shiftToNextVariationTooltip)) {
if (RotorzEditorGUI.HoverButton(plusButtonPosition, content))
{
++this.VariationShiftCount;
}
}
Rect minusButtonPosition = new Rect(position.x, position.yMax - 14, 17, 17);
using (var content = ControlContent.Basic("", this._shiftToPrevVariationTooltip)) {
if (RotorzEditorGUI.HoverButton(minusButtonPosition, content))
{
--this.VariationShiftCount;
}
}
if (Event.current.type == EventType.Repaint)
{
Color restoreColor = GUI.color;
if (!GUI.enabled)
{
GUI.color = new Color(1f, 1f, 1f, 0.4f);
}
plusButtonPosition.x += 6;
plusButtonPosition.y += 5;
plusButtonPosition.width = 5;
plusButtonPosition.height = 7;
GUI.DrawTextureWithTexCoords(plusButtonPosition, RotorzEditorStyles.Skin.VariationOffsetSelector, new Rect(0f, 0.5f, 1f, 0.5f));
minusButtonPosition.x += 6;
minusButtonPosition.y += 5;
minusButtonPosition.width = 5;
minusButtonPosition.height = 7;
GUI.DrawTextureWithTexCoords(minusButtonPosition, RotorzEditorStyles.Skin.VariationOffsetSelector, new Rect(0f, 0f, 1f, 0.5f));
GUI.color = restoreColor;
}
}
private void DrawPreferredLanguageField()
{
EditorGUILayout.BeginHorizontal();
// "Preferred Language (BETA)"
using (var content = ControlContent.Basic(TileLang.Text("Preferred Language (BETA)"))) {
EditorGUI.BeginChangeCheck();
this.preferredCultureIndex = EditorGUILayout.Popup(content, this.preferredCultureIndex, this.availableCultureLabels);
if (EditorGUI.EndChangeCheck())
{
var selectedCulture = this.availableCultures[this.preferredCultureIndex];
PackageLanguageManager.SetPreferredCulture(selectedCulture);
}
}
GUILayout.Space(32);
using (var content = ControlContent.Basic(
RotorzEditorStyles.Skin.RefreshIcon,
TileLang.ParticularText("Action", "Refresh")
)) {
Rect refreshButtonPosition = GUILayoutUtility.GetLastRect();
refreshButtonPosition.x = refreshButtonPosition.xMax - 31 + 3;
refreshButtonPosition.y = refreshButtonPosition.y - 1;
refreshButtonPosition.width = 31;
refreshButtonPosition.height = 21;
if (RotorzEditorGUI.HoverButton(refreshButtonPosition, content))
{
PackageLanguageManager.ReloadAll();
}
}
EditorGUILayout.EndHorizontal();
string translators = TileLang.Text("__Translators__").Trim();
if (!string.IsNullOrEmpty(translators) && translators != "-" && translators != "__Translators__")
{
string message = string.Format(
/* list of special people names */
TileLang.Text("Special Thanks: {0}"),
translators
);
EditorGUILayout.HelpBox(message, MessageType.None);
}
}
private void DrawCreatorSection()
{
GUILayout.Label(TileLang.Text("Brushes"), EditorStyles.boldLabel);
{
using (var content = ControlContent.Basic(
TileLang.ParticularText("Property", "Brushes Folder")
)) {
this.propertyBrushesFolderRelativePath.stringValue = RotorzEditorGUI.RelativeAssetPathTextField(content, this.propertyBrushesFolderRelativePath.stringValue, false);
}
GUILayout.Space(3);
Rect totalButtonPosition = EditorGUI.IndentedRect(EditorGUILayout.GetControlRect(true, 20));
Rect buttonPosition = totalButtonPosition;
buttonPosition.x += EditorGUIUtility.labelWidth;
buttonPosition.width = (buttonPosition.width - EditorGUIUtility.labelWidth) / 2f - 2;
if (GUI.Button(buttonPosition, TileLang.OpensWindow(TileLang.ParticularText("Action", "Browse"))))
{
this.BrushesFolder_Browse_Clicked();
}
buttonPosition.x = buttonPosition.xMax + 4;
if (GUI.Button(buttonPosition, TileLang.ParticularText("Action", "Reset")))
{
this.BrushesFolder_Reset_Clicked();
}
}
GUILayout.Label(TileLang.Text("Tilesets"), EditorStyles.boldLabel);
{
using (var content = ControlContent.Basic(
TileLang.ParticularText("Property", "Opaque Material Template")
)) {
EditorGUILayout.PropertyField(this.propertyOpaqueTilesetMaterialTemplate, content);
}
using (var content = ControlContent.Basic(
TileLang.ParticularText("Property", "Transparent Material Template")
)) {
EditorGUILayout.PropertyField(this.propertyTransparentTilesetMaterialTemplate, content);
}
RotorzEditorGUI.InfoBox(TileLang.Text("Default materials are created when no material templates are specified."));
}
}
/// <summary>
/// Returns the given items in a table with {@code size.width} columns and
/// {@code size.height} rows. If the table is too big, empty cells will be
/// created as needed. If the table is too small, the items that don't fit
/// will not be rendered.
/// </summary>
/// <param name="items"> Palette items.</param>
/// <param name="size"> Palette size (columns x rows); both dimensions
/// must be specified as numbers.</param>
/// <param name="dom"> DOM helper for document interaction.</param>
/// <returns>Palette table element.</returns>
public HTMLElement createGrid(ControlContent items, goog.math.Size size, goog.dom.DomHelper dom)
{
var rows = new JsArray <Node>();
for (int row = 0, index = 0; row < size.height; row++)
{
var cells = new JsArray <Node>();
for (var column = 0; column < size.width; column++)
{
var item = items != null?items.AsArray()[index++] : null;
cells.Push(this.createCell(item, dom));
}
rows.Push(this.createRow(cells, dom));
}
return(this.createTable(rows, dom));
}
/// <inheritdoc/>
public override void DrawSecondaryMenuButton(Rect position)
{
EditorGUI.BeginDisabledGroup(this.TilesetBrush.Tileset == null);
using (var content = ControlContent.Basic(
RotorzEditorStyles.Skin.GotoTileset,
TileLang.FormatActionWithShortcut(
TileLang.ParticularText("Action", "Goto Tileset"), "F3"
)
)) {
if (RotorzEditorGUI.HoverButton(position, content))
{
this.OnViewTileset();
GUIUtility.ExitGUI();
}
}
EditorGUI.EndDisabledGroup();
}
private void DrawHelpButton()
{
using (var content = ControlContent.Basic(RotorzEditorStyles.Skin.ContextHelp)) {
Rect position = GUILayoutUtility.GetRect(content, RotorzEditorStyles.Instance.ToolbarButtonPadded);
if (EditorInternalUtility.DropdownMenu(position, content, RotorzEditorStyles.Instance.ToolbarButtonPadded))
{
var helpMenu = new EditorMenu();
helpMenu.AddCommand(TileLang.ParticularText("Action", "Show Tips"))
.Checked(ControlContent.TrailingTipsVisible)
.Action(() => {
ControlContent.TrailingTipsVisible = !ControlContent.TrailingTipsVisible;
});
--position.y;
helpMenu.ShowAsDropdown(position);
}
}
}
/// <inheritdoc/>
public override void OnToolOptionsGUI()
{
Rect position;
GUILayout.BeginHorizontal();
this.DrawStandardOptionsGUI();
GUILayout.FlexibleSpace();
using (var content = ControlContent.Basic(
RotorzEditorStyles.Skin.GetActive(RotorzEditorStyles.Skin.RectangleFill, ToolUtility.FillCenter),
TileLang.ParticularText("Property", "Fill Center")
)) {
position = GUILayoutUtility.GetRect(21 + 12, 19 + 5);
if (RotorzEditorGUI.HoverToggle(position, content, ToolUtility.FillCenter, RotorzEditorStyles.Instance.FlatButtonNoMargin))
{
ToolUtility.FillCenter = true;
}
}
using (var content = ControlContent.Basic(
RotorzEditorStyles.Skin.GetActive(RotorzEditorStyles.Skin.RectangleOutline, !ToolUtility.FillCenter),
TileLang.ParticularText("Property", "Draw Outline")
)) {
position = GUILayoutUtility.GetRect(21 + 12, 19 + 5);
if (RotorzEditorGUI.HoverToggle(position, content, !ToolUtility.FillCenter, RotorzEditorStyles.Instance.FlatButtonNoMargin))
{
ToolUtility.FillCenter = false;
}
}
RotorzEditorGUI.VerticalSeparatorLight();
// "Paint Around Existing Tiles"
this.DrawPaintAroundExistingTilesOption();
GUILayout.Space(3);
GUILayout.EndHorizontal();
ExtraEditorGUI.SeparatorLight();
}
/// <inheritdoc/>
public override void DrawSecondaryMenuButton(Rect position)
{
var brushRecord = BrushDatabase.Instance.FindRecord(this.AliasBrush.target);
EditorGUI.BeginDisabledGroup(brushRecord == null || brushRecord.IsMaster);
{
using (var content = ControlContent.Basic(
RotorzEditorStyles.Skin.GotoTarget,
TileLang.FormatActionWithShortcut(
TileLang.ParticularText("Action", "Goto Target Brush"), "F3"
)
)) {
if (RotorzEditorGUI.HoverButton(position, content))
{
this.ShowTargetBrushInDesigner();
GUIUtility.ExitGUI();
}
}
}
EditorGUI.EndDisabledGroup();
}
private void DrawDialogButtons()
{
if (GUILayout.Button(TileLang.ParticularText("Action", "OK"), ExtraEditorStyles.Instance.BigButton))
{
this.OnButtonOK();
}
GUILayout.Space(3);
if (GUILayout.Button(TileLang.ParticularText("Action", "Cancel"), ExtraEditorStyles.Instance.BigButton))
{
this.OnButtonCancel();
}
if (this.onDefineOrientation2 != null)
{
GUILayout.FlexibleSpace();
Rect togglePosition = GUILayoutUtility.GetRect(0, 34);
togglePosition.x += (togglePosition.width - 60) / 2;
togglePosition.width = 60;
using (var toggleContent = ControlContent.Basic(
image: this.RotationalSymmetry
? RotorzEditorStyles.Skin.ToggleRotationalSymmetryOn
: RotorzEditorStyles.Skin.ToggleRotationalSymmetry
,
tipText: TileLang.ParticularText("Action", "Toggle Rotational Symmetry")
)) {
this.RotationalSymmetry = RotorzEditorGUI.HoverToggle(togglePosition, toggleContent, this.RotationalSymmetry, GUI.skin.button);
}
}
GUILayout.FlexibleSpace();
if (GUILayout.Button(TileLang.ParticularText("Action", "Invert"), ExtraEditorStyles.Instance.BigButton))
{
this.OnButtonInvert();
}
}
