returning actual Height and Width to wpf rectangle after dynamic change

Question

I have an app with the main window which contains a rectangle and a button that leads to another window in which the user enters information. After entering info, user clicks on a button and it returns him to the main window and changes the size accordingly. What I am trying to achieve is to return the ActualHeight and ActualWidth to the rectangle if a user presses the button in the main window again, kind of a refresh of rectangle. All the code is in the Main Window Button click event. If you need any specific information about the code, i will gladly give it to you.

private void buttonStart_Click(object sender, RoutedEventArgs e)
    {
        Questionnaire q = new Questionnaire();
        q.ShowDialog();

var size = q.textBoxNumberOfEmployees.Text;

        if (int.Parse(size) > 5 && int.Parse(size) < 15)
        {
            Rect1.Height = Rect1.ActualHeight - 10;
            Rect1.Width = Rect1.ActualWidth - 5;
        }

        else if (int.Parse(size) > 15 && int.Parse(size) < 30)
        {
            Rect1.Height = Rect1.ActualHeight - 15;
            Rect1.Width = Rect1.ActualWidth - 10;
        }
        else if (int.Parse(size) > 30 && int.Parse(size) < 100)
        {
            Rect1.Height = Rect1.ActualHeight - 30;
            Rect1.Width = Rect1.ActualWidth - 15;
        }
        else
        {
            Rect1.Height = Rect1.ActualHeight;
            Rect1.Width = Rect1.ActualWidth;
        }

Answer 1

You can store the original height and width of rectangle in variables in form load. Use those variables to make rectangle to original size bebore opening new window in button click. Following code goes at the top inside your form.

private int rect1width; private int rect1height;

In your form__load you write this at the end.

rect1width = Rect1.ActualWidth; rect1height = Rect1.ActualHeight;

In your button click code following code goes at top.

Rect1.Width = rect1width; Rect1.Height = rect1height;

Answer 2

Here is some seemingly long code, but it uses an MVC type design pattern and compounds with the state pattern. The only thing really missing to make it true MVC is Observers and observable interfaces that would subscribe to the Questionnaire.

public interface RectangleState
    {
        int myHeight { get; set; }
        int myWidth { get; set; }
    }
    public class RectangleModel
    {
        private static Rectangle Rect1;
        public RectangleModel(Rectangle rect1 )
        {
            Rect1 = rect1;
        }        
        private RectangleState state;
        public RectangleState State
        {
            get
            {
                return state;
            }
            set
            {
                state = value;
                ModifyState(value.myHeight, value.myWidth);
            }
        }
        private void ModifyState(int Height, int Width)
        {
            Rect1.Height = Height;
            Rect1.Width = Width;
        }
    }
    public class SmallState : RectangleState
    {
        public int myHeight { get; set; } = 20;
        public int myWidth { get; set; } = 80;
    }
    public class MediumState : RectangleState
    {
        public int myHeight { get; set; } = 25;
        public int myWidth { get; set; } = 90;
    }
    public class LargeState : RectangleState
    {
        public int myHeight { get; set; } = 35;
        public int myWidth { get; set; } = 120;
    }
    public class NormalState : RectangleState
    {
        public int myHeight { get; set; } = 30;
        public int myWidth { get; set; } = 100;
    }

Now all you need to do is plug in the conditions:

RectangleModel RM = new RectangleModel(myRectangle); // store this in your class as property;
            int size = 0;
            int.TryParse(q.textBoxNumberOfEmployees.Text, out size);
            if (size > 5 && size < 15)
            {
                RM.State = new SmallState();                
            }

            else if (size > 15 && size < 30)
            {
                RM.State = new MediumState();
            }
            else if (size > 30 && size < 100)
            {
                RM.State = new LargeState();
            }
            else
            {
                RM.State = new NormalState();
            }

If later you decide you want to change the default values on any of these you can change them. If you wish to add a new Rectangle shape or size you can add it. If you wish to create an adapter to further modify the rectangle, you can do so. This is a nice pattern. I know the answer looks overdone, but I think you will find it works solidly and is quite flexible when plugged into the code that accesses your questionaire.