public void ConvertToPixelCoordinates(float relativeX, float relativeY, object xUnitType, object yUnitType, float parentWidth, float parentHeight,
float fileWidth, float fileHeight, out float absoluteX, out float absoluteY)
{
try
{
GeneralUnitType generalX = GeneralUnitType.PixelsFromSmall;
if (xUnitType != null)
{
generalX = ConvertToGeneralUnit(xUnitType);
}
GeneralUnitType generalY = GeneralUnitType.PixelsFromSmall;
if (yUnitType != null)
{
generalY = ConvertToGeneralUnit(yUnitType);
}
absoluteX = relativeX;
absoluteY = relativeY;
if (generalX == GeneralUnitType.Percentage)
{
absoluteX = parentWidth * relativeX / 100.0f;
}
else if (generalX == GeneralUnitType.PixelsFromMiddle)
{
absoluteX = parentWidth / 2.0f + relativeX;
}
else if (generalX == GeneralUnitType.PixelsFromLarge)
{
absoluteX = parentWidth + relativeX;
}
else if (generalX == GeneralUnitType.PercentageOfFile)
{
absoluteX = fileWidth * relativeX / 100.0f;
}
if (generalY == GeneralUnitType.Percentage)
{
absoluteY = parentHeight * relativeY / 100.0f;
}
else if (generalY == GeneralUnitType.PixelsFromMiddle)
{
absoluteY = parentHeight / 2.0f + relativeY;
}
else if (generalY == GeneralUnitType.PixelsFromLarge)
{
absoluteY = parentHeight + relativeY;
}
else if (generalY == GeneralUnitType.PercentageOfFile)
{
absoluteY = fileHeight * relativeY / 100.0f;
}
}
catch (Exception e)
{
throw e;
}
}
public static bool GetIsPixelBased(this GeneralUnitType unitType)
{
return(unitType == GeneralUnitType.PixelsFromSmall ||
unitType == GeneralUnitType.PixelsFromMiddle ||
unitType == GeneralUnitType.PixelsFromMiddleInverted ||
unitType == GeneralUnitType.PixelsFromLarge);
}
private void AdjustEnumerationVariableValue(Gum.DataTypes.Variables.VariableSave variableSave, ElementSave element, ref string variableValue, ref string variableType)
{
if (variableSave.Type == "Gum.Managers.PositionUnitType" || variableSave.Type == "PositionUnitType")
{
string rootName = variableSave.GetRootName();
// convert from PositionUnitType to GeneralUnitType
GeneralUnitType convertedValue =
UnitConverter.ConvertToGeneralUnit((PositionUnitType)variableSave.Value);
variableValue = convertedValue.ToString();
variableType = "Gum.Converters.GeneralUnitType";
}
string prefix = variableType;
if (mTypeToQualifiedTypes.ContainsKey(prefix))
{
prefix = mTypeToQualifiedTypes[prefix];
}
else
{
ModifyVariableTypeForProperty(ref prefix, variableSave, element);
}
variableValue = prefix + "." + variableValue;
}
public void ConvertToPixelCoordinates(float relativeX, float relativeY, GeneralUnitType generalX, GeneralUnitType generalY,
float parentWidth, float parentHeight,
float fileWidth, float fileHeight, out float absoluteX, out float absoluteY)
{
if (generalX == GeneralUnitType.PixelsFromSmall)
{
absoluteX = relativeX;
}
else if (generalX == GeneralUnitType.Percentage)
{
absoluteX = parentWidth * relativeX / 100.0f;
}
else if (generalX == GeneralUnitType.PixelsFromMiddle)
{
absoluteX = parentWidth / 2.0f + relativeX;
}
else if (generalX == GeneralUnitType.PixelsFromLarge)
{
absoluteX = parentWidth + relativeX;
}
else if (generalX == GeneralUnitType.PercentageOfFile)
{
absoluteX = fileWidth * relativeX / 100.0f;
}
else
{
throw new NotImplementedException();
}
if (generalY == GeneralUnitType.PixelsFromSmall)
{
absoluteY = relativeY;
}
else if (generalY == GeneralUnitType.Percentage)
{
absoluteY = parentHeight * relativeY / 100.0f;
}
else if (generalY == GeneralUnitType.PixelsFromMiddle)
{
absoluteY = parentHeight / 2.0f + relativeY;
}
else if (generalY == GeneralUnitType.PixelsFromMiddleInverted)
{
absoluteY = parentHeight / 2.0f - relativeY;
}
else if (generalY == GeneralUnitType.PixelsFromLarge)
{
absoluteY = parentHeight + relativeY;
}
else if (generalY == GeneralUnitType.PercentageOfFile)
{
absoluteY = fileHeight * relativeY / 100.0f;
}
else
{
throw new NotImplementedException();
}
}
private static float AdjustAmountAccordingToUnitType(string baseVariableName, float amount, object unitsVariableAsObject)
{
GeneralUnitType generalUnitType = UnitConverter.ConvertToGeneralUnit(unitsVariableAsObject);
float xAmount;
float yAmount;
if (baseVariableName == "X" || baseVariableName == "Width")
{
xAmount = amount;
yAmount = 0;
}
else
{
xAmount = 0;
yAmount = amount;
}
if (generalUnitType == GeneralUnitType.PixelsFromMiddleInverted)
{
return(amount * -1);
}
else if (generalUnitType != GeneralUnitType.PixelsFromLarge && generalUnitType != GeneralUnitType.PixelsFromMiddle && generalUnitType != GeneralUnitType.PixelsFromSmall)
{
float parentWidth;
float parentHeight;
float fileWidth;
float fileHeight;
float outX;
float outY;
IRenderableIpso ipso = WireframeObjectManager.Self.GetSelectedRepresentation();
ipso.GetFileWidthAndHeightOrDefault(out fileWidth, out fileHeight);
ipso.GetParentWidthAndHeight(
ProjectManager.Self.GumProjectSave.DefaultCanvasWidth, ProjectManager.Self.GumProjectSave.DefaultCanvasHeight,
out parentWidth, out parentHeight);
var unitsVariable = UnitConverter.ConvertToGeneralUnit(unitsVariableAsObject);
UnitConverter.Self.ConvertToUnitTypeCoordinates(xAmount, yAmount, unitsVariable, unitsVariable, ipso.Width, ipso.Height, parentWidth, parentHeight, fileWidth, fileHeight,
out outX, out outY);
if (baseVariableName == "X" || baseVariableName == "Width")
{
return(outX);
}
else
{
return(outY);
}
}
else
{
return(amount);
}
}
public static GeneralUnitType Flip(this GeneralUnitType unitType)
{
switch (unitType)
{
case GeneralUnitType.PixelsFromSmall: return(GeneralUnitType.PixelsFromLarge);
case GeneralUnitType.PixelsFromLarge: return(GeneralUnitType.PixelsFromSmall);
}
return(unitType);
}
public void ConvertToUnitTypeCoordinates(float absoluteX, float absoluteY, object xUnitType, object yUnitType, float parentWidth, float parentHeight, float fileWidth, float fileHeight, out float relativeX, out float relativeY)
{
GeneralUnitType generalX = GeneralUnitType.PixelsFromSmall;
if (xUnitType != null)
{
generalX = ConvertToGeneralUnit(xUnitType);
}
GeneralUnitType generalY = GeneralUnitType.PixelsFromSmall;
if (yUnitType != null)
{
generalY = ConvertToGeneralUnit(yUnitType);
}
relativeX = absoluteX;
relativeY = absoluteY;
if (generalX == GeneralUnitType.Percentage)
{
relativeX = 100 * absoluteX / parentWidth;
}
else if (generalX == GeneralUnitType.PixelsFromMiddle)
{
relativeX = absoluteX - parentWidth / 2.0f;
}
else if (generalX == GeneralUnitType.PixelsFromLarge)
{
relativeX = absoluteX - parentWidth;
}
else if (generalX == GeneralUnitType.PercentageOfFile)
{
relativeX = 100 * absoluteX / fileWidth;
}
if (generalY == GeneralUnitType.Percentage)
{
relativeY = 100 * absoluteY / parentHeight;
}
else if (generalY == GeneralUnitType.PixelsFromMiddle)
{
relativeY = absoluteY - parentHeight / 2.0f;
}
else if (generalY == GeneralUnitType.PixelsFromLarge)
{
relativeY = absoluteY - parentHeight;
}
else if (generalY == GeneralUnitType.PercentageOfFile)
{
relativeY = 100 * absoluteY / fileHeight;
}
}
public static bool TryConvertToGeneralUnit(object unitType, out GeneralUnitType result)
{
result = GeneralUnitType.PixelsFromSmall;
try
{
result = ConvertToGeneralUnit(unitType);
return(true);
}
catch
{
return(false);
}
}
public float ConvertYPosition(float yToConvert, GeneralUnitType fromUnit, GeneralUnitType toUnit, float parentHeight)
{
float throwaway = 0;
float pixelY;
// convert from whatever unit to pixel:
ConvertToPixelCoordinates(0, yToConvert, GeneralUnitType.PixelsFromLarge, fromUnit, 0, parentHeight, 0, 0, out throwaway, out pixelY);
float convertedY;
// now from pixel back to whatever unit type:
ConvertToUnitTypeCoordinates(0, pixelY, GeneralUnitType.PixelsFromLarge, toUnit, 0, parentHeight, 0, 0, out throwaway, out convertedY);
return(convertedY);
}
public float ConvertXPosition(float xToConvert, GeneralUnitType fromUnit, GeneralUnitType toUnit, float parentWidth)
{
float throwaway = 0;
float pixelX;
// convert from whatever unit to pixel:
ConvertToPixelCoordinates(xToConvert, 0, fromUnit, GeneralUnitType.PixelsFromLarge, parentWidth, 0, 0, 0, out pixelX, out throwaway);
float convertedX;
// now from pixel back to whatever unit type:
ConvertToUnitTypeCoordinates(pixelX, 0, toUnit, GeneralUnitType.PixelsFromLarge, parentWidth, 0, 0, 0, out convertedX, out throwaway);
return(convertedX);
}
public void ConvertToPixelCoordinates(float relativeX, float relativeY, GeneralUnitType generalX, GeneralUnitType generalY, float parentWidth, float parentHeight,
float fileWidth, float fileHeight, out float absoluteX, out float absoluteY)
{
absoluteX = relativeX;
absoluteY = relativeY;
if (generalX == GeneralUnitType.Percentage)
{
absoluteX = parentWidth * relativeX / 100.0f;
}
else if (generalX == GeneralUnitType.PixelsFromMiddle)
{
absoluteX = parentWidth / 2.0f + relativeX;
}
else if (generalX == GeneralUnitType.PixelsFromLarge)
{
absoluteX = parentWidth + relativeX;
}
else if (generalX == GeneralUnitType.PercentageOfFile)
{
absoluteX = fileWidth * relativeX / 100.0f;
}
if (generalY == GeneralUnitType.Percentage)
{
absoluteY = parentHeight * relativeY / 100.0f;
}
else if (generalY == GeneralUnitType.PixelsFromMiddle)
{
absoluteY = parentHeight / 2.0f + relativeY;
}
else if(generalY == GeneralUnitType.PixelsFromMiddleInverted)
{
absoluteY = parentHeight / 2.0f - relativeY;
}
else if (generalY == GeneralUnitType.PixelsFromLarge)
{
absoluteY = parentHeight + relativeY;
}
else if (generalY == GeneralUnitType.PercentageOfFile)
{
absoluteY = fileHeight * relativeY / 100.0f;
}
}
public void ConvertToUnitTypeCoordinates(float absoluteX, float absoluteY, GeneralUnitType generalX, GeneralUnitType generalY, float parentWidth, float parentHeight, float fileWidth, float fileHeight, out float relativeX, out float relativeY)
{
relativeX = absoluteX;
relativeY = absoluteY;
if (generalX == GeneralUnitType.Percentage)
{
relativeX = 100 * absoluteX / parentWidth;
}
else if (generalX == GeneralUnitType.PixelsFromMiddle)
{
relativeX = absoluteX - parentWidth / 2.0f;
}
else if (generalX == GeneralUnitType.PixelsFromLarge)
{
relativeX = absoluteX - parentWidth;
}
else if (generalX == GeneralUnitType.PercentageOfFile)
{
relativeX = 100 * absoluteX / fileWidth;
}
if (generalY == GeneralUnitType.Percentage)
{
relativeY = 100 * absoluteY / parentHeight;
}
else if (generalY == GeneralUnitType.PixelsFromMiddle)
{
relativeY = absoluteY - parentHeight / 2.0f;
}
else if (generalY == GeneralUnitType.PixelsFromMiddleInverted)
{
relativeY = -absoluteY - parentHeight / 2.0f;
}
else if (generalY == GeneralUnitType.PixelsFromLarge)
{
relativeY = absoluteY - parentHeight;
}
else if (generalY == GeneralUnitType.PercentageOfFile)
{
relativeY = 100 * absoluteY / fileHeight;
}
}
public void ConvertToUnitTypeCoordinates(float pixelXToConvert, float pixelYToConvert, GeneralUnitType generalX, GeneralUnitType generalY,
// owner X and Y values are needed if the object is using percentage of other unit value
float ownerWidthInPixels, float ownerHeightInPixels,
float parentWidth, float parentHeight, float fileWidth, float fileHeight, out float relativeX, out float relativeY)
{
relativeY = pixelYToConvert;
if (generalX == GeneralUnitType.PixelsFromSmall)
{
relativeX = pixelXToConvert;
}
else if (generalX == GeneralUnitType.Percentage)
{
relativeX = 100 * pixelXToConvert / parentWidth;
}
else if (generalX == GeneralUnitType.PixelsFromMiddle)
{
relativeX = pixelXToConvert - parentWidth / 2.0f;
}
else if (generalX == GeneralUnitType.PixelsFromLarge)
{
relativeX = pixelXToConvert - parentWidth;
}
else if (generalX == GeneralUnitType.PercentageOfFile)
{
relativeX = 100 * pixelXToConvert / fileWidth;
}
else if (generalX == GeneralUnitType.MaintainFileAspectRatio)
{
// This requires possibly doing Y beforeX, so we'll just keep it for now:
relativeX = pixelXToConvert;
}
else if (generalX == GeneralUnitType.PercentageOfOtherDimension)
{
relativeX = pixelXToConvert / (ownerHeightInPixels / 100f);
}
else
{
throw new NotImplementedException();
}
if (generalY == GeneralUnitType.PixelsFromSmall)
{
relativeY = pixelYToConvert;
}
else if (generalY == GeneralUnitType.Percentage)
{
relativeY = 100 * pixelYToConvert / parentHeight;
}
else if (generalY == GeneralUnitType.PixelsFromMiddle)
{
relativeY = pixelYToConvert - parentHeight / 2.0f;
}
else if (generalY == GeneralUnitType.PixelsFromMiddleInverted)
{
relativeY = -pixelYToConvert - parentHeight / 2.0f;
}
else if (generalY == GeneralUnitType.PixelsFromLarge)
{
relativeY = pixelYToConvert - parentHeight;
}
else if (generalY == GeneralUnitType.MaintainFileAspectRatio)
{
throw new NotImplementedException();
}
else if (generalY == GeneralUnitType.PercentageOfFile)
{
relativeY = 100 * pixelYToConvert / fileHeight;
}
else if (generalY == GeneralUnitType.PercentageOfOtherDimension)
{
relativeY = pixelYToConvert / (ownerWidthInPixels / 100f);
}
else if (generalY == GeneralUnitType.PixelsFromBaseline)
{
// This won't convert properly (currently) - maybe eventually?
relativeY = pixelYToConvert;
}
else
{
throw new NotImplementedException();
}
}
public System.Collections.Generic.IEnumerable <GeneralUnit> GetByType(GeneralUnitType Type)
{
return(_generalUnitRepository.FindBy(x => x.GeneralType == Type));
}
private static float AdjustAmountAccordingToUnitType(string baseVariableName, float amount, object unitsVariableAsObject)
{
GeneralUnitType generalUnitType = UnitConverter.ConvertToGeneralUnit(unitsVariableAsObject);
float xAmount;
float yAmount;
if (baseVariableName == "X" || baseVariableName == "Width")
{
xAmount = amount;
yAmount = 0;
}
else
{
xAmount = 0;
yAmount = amount;
}
if (generalUnitType == GeneralUnitType.PixelsFromMiddleInverted)
{
return(amount * -1);
}
else if (generalUnitType != GeneralUnitType.PixelsFromLarge &&
generalUnitType != GeneralUnitType.PixelsFromMiddle &&
generalUnitType != GeneralUnitType.PixelsFromSmall &&
generalUnitType != GeneralUnitType.PixelsFromBaseline)
{
float parentWidth;
float parentHeight;
float fileWidth;
float fileHeight;
float outX;
float outY;
var ipso = WireframeObjectManager.Self.GetSelectedRepresentation();
ipso.GetFileWidthAndHeightOrDefault(out fileWidth, out fileHeight);
ipso.GetParentWidthAndHeight(
ProjectManager.Self.GumProjectSave.DefaultCanvasWidth, ProjectManager.Self.GumProjectSave.DefaultCanvasHeight,
out parentWidth, out parentHeight);
var unitsVariable = UnitConverter.ConvertToGeneralUnit(unitsVariableAsObject);
UnitConverter.Self.ConvertToUnitTypeCoordinates(xAmount, yAmount, unitsVariable, unitsVariable,
ipso.Width, ipso.Height,
parentWidth, parentHeight,
fileWidth, fileHeight,
out outX, out outY);
if (generalUnitType == GeneralUnitType.PercentageOfFile)
{
// need to amplify the value based on the ratio of what is displayed to the file size
if (baseVariableName == "Width")
{
var ratio = ipso.TextureWidth / fileWidth;
if (float.IsPositiveInfinity(ratio) == false && ratio != 0)
{
outX /= ratio;
}
}
if (baseVariableName == "Height")
{
var ratio = ipso.TextureHeight / fileHeight;
if (float.IsPositiveInfinity(ratio) == false && ratio != 0)
{
outY /= ratio;
}
}
}
if (baseVariableName == "X" || baseVariableName == "Width")
{
return(outX);
}
else
{
return(outY);
}
}
else
{
return(amount);
}
}
public void ConvertToUnitTypeCoordinates(float pixelXToConvert, float pixelYToConvert, GeneralUnitType generalX, GeneralUnitType generalY,
// owner X and Y values are needed if the object is using percentage of other unit value
float ownerWidthInPixels, float ownerHeightInPixels,
float parentWidth, float parentHeight, float fileWidth, float fileHeight, out float relativeX, out float relativeY)
{
relativeY = pixelYToConvert;
if (generalX == GeneralUnitType.PixelsFromSmall)
{
relativeX = pixelXToConvert;
}
else if (generalX == GeneralUnitType.Percentage)
{
relativeX = 100 * pixelXToConvert / parentWidth;
}
else if (generalX == GeneralUnitType.PixelsFromMiddle)
{
relativeX = pixelXToConvert - parentWidth / 2.0f;
}
else if (generalX == GeneralUnitType.PixelsFromLarge)
{
relativeX = pixelXToConvert - parentWidth;
}
else if (generalX == GeneralUnitType.PercentageOfFile)
{
relativeX = 100 * pixelXToConvert / fileWidth;
}
else if (generalX == GeneralUnitType.PercentageOfOtherDimension)
{
relativeX = pixelXToConvert / (ownerHeightInPixels / 100f);
}
else
{
throw new NotImplementedException();
}
if (generalY == GeneralUnitType.PixelsFromSmall)
{
relativeY = pixelYToConvert;
}
else if (generalY == GeneralUnitType.Percentage)
{
relativeY = 100 * pixelYToConvert / parentHeight;
}
else if (generalY == GeneralUnitType.PixelsFromMiddle)
{
relativeY = pixelYToConvert - parentHeight / 2.0f;
}
else if (generalY == GeneralUnitType.PixelsFromMiddleInverted)
{
relativeY = -pixelYToConvert - parentHeight / 2.0f;
}
else if (generalY == GeneralUnitType.PixelsFromLarge)
{
relativeY = pixelYToConvert - parentHeight;
}
else if (generalY == GeneralUnitType.PercentageOfFile)
{
relativeY = 100 * pixelYToConvert / fileHeight;
}
else if (generalY == GeneralUnitType.PercentageOfOtherDimension)
{
relativeY = pixelYToConvert / (ownerWidthInPixels / 100f);
}
else
{
throw new NotImplementedException();
}
}
private void ReactIfChangedMemberIsUnitType(ElementSave parentElement, string changedMember, object oldValueAsObject)
{
bool wasAnythingSet = false;
string variableToSet = null;
StateSave stateSave = SelectedState.Self.SelectedStateSave;
float valueToSet = 0;
if (changedMember == "X Units" || changedMember == "Y Units" || changedMember == "Width Units" || changedMember == "Height Units")
{
GeneralUnitType oldValue;
if (UnitConverter.TryConvertToGeneralUnit(oldValueAsObject, out oldValue))
{
IRenderableIpso currentIpso =
WireframeObjectManager.Self.GetSelectedRepresentation();
float parentWidth = ObjectFinder.Self.GumProjectSave.DefaultCanvasWidth;
float parentHeight = ObjectFinder.Self.GumProjectSave.DefaultCanvasHeight;
float fileWidth = 0;
float fileHeight = 0;
float thisWidth = 0;
float thisHeight = 0;
if (currentIpso != null)
{
currentIpso.GetFileWidthAndHeightOrDefault(out fileWidth, out fileHeight);
if (currentIpso.Parent != null)
{
parentWidth = currentIpso.Parent.Width;
parentHeight = currentIpso.Parent.Height;
}
thisWidth = currentIpso.Width;
thisHeight = currentIpso.Height;
}
float outX = 0;
float outY = 0;
bool isWidthOrHeight = false;
object unitTypeAsObject = EditingManager.GetCurrentValueForVariable(changedMember, SelectedState.Self.SelectedInstance);
GeneralUnitType unitType = UnitConverter.ConvertToGeneralUnit(unitTypeAsObject);
XOrY xOrY = XOrY.X;
if (changedMember == "X Units")
{
variableToSet = "X";
xOrY = XOrY.X;
}
else if (changedMember == "Y Units")
{
variableToSet = "Y";
xOrY = XOrY.Y;
}
else if (changedMember == "Width Units")
{
variableToSet = "Width";
isWidthOrHeight = true;
xOrY = XOrY.X;
}
else if (changedMember == "Height Units")
{
variableToSet = "Height";
isWidthOrHeight = true;
xOrY = XOrY.Y;
}
float valueOnObject = 0;
if (stateSave.TryGetValue <float>(GetQualifiedName(variableToSet), out valueOnObject))
{
var defaultUnitType = GeneralUnitType.PixelsFromSmall;
if (xOrY == XOrY.X)
{
UnitConverter.Self.ConvertToPixelCoordinates(
valueOnObject, 0, oldValue, defaultUnitType, parentWidth, parentHeight, fileWidth, fileHeight, out outX, out outY);
UnitConverter.Self.ConvertToUnitTypeCoordinates(
outX, outY, unitType, defaultUnitType, thisWidth, thisHeight, parentWidth, parentHeight, fileWidth, fileHeight, out valueToSet, out outY);
}
else
{
UnitConverter.Self.ConvertToPixelCoordinates(
0, valueOnObject, defaultUnitType, oldValue, parentWidth, parentHeight, fileWidth, fileHeight, out outX, out outY);
UnitConverter.Self.ConvertToUnitTypeCoordinates(
outX, outY, defaultUnitType, unitType, thisWidth, thisHeight, parentWidth, parentHeight, fileWidth, fileHeight, out outX, out valueToSet);
}
wasAnythingSet = true;
}
}
}
if (wasAnythingSet)
{
InstanceSave instanceSave = SelectedState.Self.SelectedInstance;
if (SelectedState.Self.SelectedInstance != null)
{
variableToSet = SelectedState.Self.SelectedInstance.Name + "." + variableToSet;
}
stateSave.SetValue(variableToSet, valueToSet, instanceSave);
}
}
public void ConvertToUnitTypeCoordinates(float absoluteX, float absoluteY, GeneralUnitType generalX, GeneralUnitType generalY, float parentWidth, float parentHeight, float fileWidth, float fileHeight, out float relativeX, out float relativeY)
{
relativeX = absoluteX;
relativeY = absoluteY;
if (generalX == GeneralUnitType.Percentage)
{
relativeX = 100 * absoluteX / parentWidth;
}
else if (generalX == GeneralUnitType.PixelsFromMiddle)
{
relativeX = absoluteX - parentWidth / 2.0f;
}
else if (generalX == GeneralUnitType.PixelsFromLarge)
{
relativeX = absoluteX - parentWidth;
}
else if (generalX == GeneralUnitType.PercentageOfFile)
{
relativeX = 100 * absoluteX / fileWidth;
}
if (generalY == GeneralUnitType.Percentage)
{
relativeY = 100 * absoluteY / parentHeight;
}
else if (generalY == GeneralUnitType.PixelsFromMiddle)
{
relativeY = absoluteY - parentHeight / 2.0f;
}
else if(generalY == GeneralUnitType.PixelsFromMiddleInverted)
{
relativeY = -absoluteY - parentHeight / 2.0f;
}
else if (generalY == GeneralUnitType.PixelsFromLarge)
{
relativeY = absoluteY - parentHeight;
}
else if (generalY == GeneralUnitType.PercentageOfFile)
{
relativeY = 100 * absoluteY / fileHeight;
}
}
private static float GetDimensionFromEdges(float smallEdge, float bigEdge, GeneralUnitType units)
{
float dimensionToReturn = 0;
if (units == GeneralUnitType.PixelsFromSmall)
{
smallEdge = 0;
bigEdge = System.Math.Max(0, bigEdge);
dimensionToReturn = bigEdge - smallEdge;
}
else if (units == GeneralUnitType.PixelsFromMiddle)
{
// use the full width
float abs1 = System.Math.Abs(smallEdge);
float abs2 = System.Math.Abs(bigEdge);
dimensionToReturn = 2 * System.Math.Max(abs1, abs2);
}
else if (units == GeneralUnitType.PixelsFromLarge)
{
smallEdge = System.Math.Min(0, smallEdge);
bigEdge = 0;
dimensionToReturn = bigEdge - smallEdge;
}
return dimensionToReturn;
}
private void ReactIfChangedMemberIsUnitType(ElementSave parentElement, string changedMember, object oldValueAsObject)
{
bool wasAnythingSet = false;
string variableToSet = null;
StateSave stateSave = SelectedState.Self.SelectedStateSave;
float valueToSet = 0;
var wereUnitValuesChanged =
changedMember == "X Units" || changedMember == "Y Units" || changedMember == "Width Units" || changedMember == "Height Units";
var shouldAttemptValueChange = wereUnitValuesChanged && ProjectManager.Self.GumProjectSave?.ConvertVariablesOnUnitTypeChange == true;
if (shouldAttemptValueChange)
{
GeneralUnitType oldValue;
if (UnitConverter.TryConvertToGeneralUnit(oldValueAsObject, out oldValue))
{
IRenderableIpso currentIpso =
WireframeObjectManager.Self.GetSelectedRepresentation();
float parentWidth = ObjectFinder.Self.GumProjectSave.DefaultCanvasWidth;
float parentHeight = ObjectFinder.Self.GumProjectSave.DefaultCanvasHeight;
float fileWidth = 0;
float fileHeight = 0;
float thisWidth = 0;
float thisHeight = 0;
if (currentIpso != null)
{
currentIpso.GetFileWidthAndHeightOrDefault(out fileWidth, out fileHeight);
if (currentIpso.Parent != null)
{
parentWidth = currentIpso.Parent.Width;
parentHeight = currentIpso.Parent.Height;
}
thisWidth = currentIpso.Width;
thisHeight = currentIpso.Height;
}
float outX = 0;
float outY = 0;
bool isWidthOrHeight = false;
object unitTypeAsObject = EditingManager.GetCurrentValueForVariable(changedMember, SelectedState.Self.SelectedInstance);
GeneralUnitType unitType = UnitConverter.ConvertToGeneralUnit(unitTypeAsObject);
XOrY xOrY = XOrY.X;
if (changedMember == "X Units")
{
variableToSet = "X";
xOrY = XOrY.X;
}
else if (changedMember == "Y Units")
{
variableToSet = "Y";
xOrY = XOrY.Y;
}
else if (changedMember == "Width Units")
{
variableToSet = "Width";
isWidthOrHeight = true;
xOrY = XOrY.X;
}
else if (changedMember == "Height Units")
{
variableToSet = "Height";
isWidthOrHeight = true;
xOrY = XOrY.Y;
}
float valueOnObject = 0;
if (AttemptToPersistPositionsOnUnitChanges && stateSave.TryGetValue <float>(GetQualifiedName(variableToSet), out valueOnObject))
{
var defaultUnitType = GeneralUnitType.PixelsFromSmall;
if (xOrY == XOrY.X)
{
UnitConverter.Self.ConvertToPixelCoordinates(
valueOnObject, 0, oldValue, defaultUnitType, parentWidth, parentHeight, fileWidth, fileHeight, out outX, out outY);
UnitConverter.Self.ConvertToUnitTypeCoordinates(
outX, outY, unitType, defaultUnitType, thisWidth, thisHeight, parentWidth, parentHeight, fileWidth, fileHeight, out valueToSet, out outY);
}
else
{
UnitConverter.Self.ConvertToPixelCoordinates(
0, valueOnObject, defaultUnitType, oldValue, parentWidth, parentHeight, fileWidth, fileHeight, out outX, out outY);
UnitConverter.Self.ConvertToUnitTypeCoordinates(
outX, outY, defaultUnitType, unitType, thisWidth, thisHeight, parentWidth, parentHeight, fileWidth, fileHeight, out outX, out valueToSet);
}
wasAnythingSet = true;
}
}
}
if (wasAnythingSet && AttemptToPersistPositionsOnUnitChanges && !float.IsPositiveInfinity(valueToSet))
{
InstanceSave instanceSave = SelectedState.Self.SelectedInstance;
string unqualifiedVariableToSet = variableToSet;
if (SelectedState.Self.SelectedInstance != null)
{
variableToSet = SelectedState.Self.SelectedInstance.Name + "." + variableToSet;
}
stateSave.SetValue(variableToSet, valueToSet, instanceSave);
// Force update everything on the spot. We know we can just set this value instead of forcing a full refresh:
var gue = WireframeObjectManager.Self.GetSelectedRepresentation();
if (gue != null)
{
gue.SetProperty(unqualifiedVariableToSet, valueToSet);
}
GumCommands.Self.GuiCommands.RefreshPropertyGrid(force: true);
}
}
public static bool TryConvertToGeneralUnit(object unitType, out GeneralUnitType result)
{
result = GeneralUnitType.PixelsFromSmall;
try
{
result = ConvertToGeneralUnit(unitType);
return true;
}
catch
{
return false;
}
}
