Dynamic visual list of images
There are a few things that you should refactor to be able to optimize your code better. Currently everthing sits inside the Click event handler and it's too much to handle there. 

You are not able to focus on particular task like that. You should separate the operations and create new methods and properties for them. Here's how you could start. It's not 100% perfect (like the hard coded picture box BackColor) yet but it should give you an idea how to start refactoring your current solution.



Create a new panel control with a picture box inside (you can create a property for it so that you can set the image later). In this control you can implement all the logic that should handle the resize.

Give it a few properties that you can set and calculate the size and location values dynamiclly and internally. Use a flag (like IsEnlarged) to track whether a panel is in its normal or enlarged size rather than hard coded sizes. Here you can handle the Click event and take proper actions to modify the panel and the picture box.

class ResizablePanel : Panel
{
    private bool _isEnlarged;

    public ResizablePanel()
    {
        Controls.Add(new PictureBox
        {
            BackColor = Color.PaleGoldenrod
        });

        Click += PanelOrPicktureBox_Click;
        Controls[0].Click += PanelOrPicktureBox_Click;
    }

    public bool IsEnlarged
    {
        get { return _isEnlarged; }
        set
        {
            if (value == _isEnlarged)
            {
                return;
            }

            _isEnlarged = value;
            Size = _isEnlarged ? EnlargedSize : NormalSize;
            ResizePictureBox();
            TranslatePanel();

            if (IsEnlarged)
            {
                Enlarged?.Invoke(this, EventArgs.Empty);
            }
        }
    }

    public Size NormalSize { get; set; }

    public Size EnlargedSize { get; set; }

    public Size BorderSize { get; set; }

    public void Initialize()
    {
        Size = _isEnlarged ? EnlargedSize : NormalSize;
        ResizePictureBox();
        TranslatePanel();
    }

    private void ResizePictureBox()
    {
        var pictureBox = Controls[0] as PictureBox;

        pictureBox.Location = new Point
        {
            X = BorderSize.Width,
            Y = BorderSize.Height
        };

        // multiply by 2 becasue border size specifies only its width and we
        // need to two of them, one for each side
        pictureBox.Size = new Size
        {
            Width = Size.Width - (BorderSize.Width * 2),
            Height = Size.Height - (BorderSize.Height * 2)
        };
    }

    private void TranslatePanel()
    {
        if (IsEnlarged)
        {
            Location = new Point
            {
                X = Location.X - ((EnlargedSize.Width - NormalSize.Width) / 2),
                Y = Location.Y - ((EnlargedSize.Height - NormalSize.Height) / 2),
            };
        }
        else
        {
            Location = new Point
            {
                X = Location.X + ((EnlargedSize.Width - NormalSize.Width) / 2),
                Y = Location.Y + ((EnlargedSize.Height - NormalSize.Height) / 2),
            };
        }
    }

    private void PanelOrPicktureBox_Click(object sender, EventArgs e)
    {
        IsEnlarged = !IsEnlarged;
    }
}


You also can create your panels dinamiclly and give them some initial values.

private void CreatePictureBoxes()
{
    var pictureBoxCount = 4;

    var panelNormalSize = new Size(52, 52);
    var panelEnlargedSize = new Size(66, 66);
    var borderSize = new Size(5, 5);

    for (var i = 0; i &lt; pictureBoxCount; i++)
    {
        var panel = new ResizablePanel
        {
            NormalSize = panelNormalSize,
            EnlargedSize = panelEnlargedSize,
            BorderSize = borderSize,
            IsEnlarged = false,
            // 3 is just a random border width multiplier to create gaps between the controls
            Location = new Point
            {
                X = panelNormalSize.Width * i + borderSize.Width * 3 * (i + 1),
                Y = borderSize.Height * 3
            },
            BackColor = Color.DarkMagenta,
        };
        panel.Initialize();

        Controls.Add(panel);
    }
}


Initialize the panels:

public Form1()
{
    InitializeComponent();
    CreatePictureBoxes();
}


And this is how it looks like:






  When one gets clicked, all other images turn back 'small'


Add an event to your new panel and raise it when it gets enlarged. You can then handle this event in the main form and set all other panels to IsEnlarged = false

public event EventHandler Enlarged;

public bool IsEnlarged
{
    get { return _isEnlarged; }
    set
    {
        // prevents multiple changes
        if (value == _isEnlarged)
        {
            return;
        }

        _isEnlarged = value;
        Size = _isEnlarged ? EnlargedSize : NormalSize;
        ResizePictureBox();
        TranslatePanel();

        // raise the event (using C# 6)
        if (IsEnlarged)
        {
            Enlarged?.Invoke(this, EventArgs.Empty);
        }
    }
}


Subscribe to the event during the initialization:

panel.Enlarged += Panel_Enlarged;


Handle the event:

private void Panel_Enlarged(object sender, EventArgs e)
{
    var otherPanels = Controls.OfType&lt;ResizablePanel&gt;().Where(rp =&gt; rp != sender &amp;&amp; rp.IsEnlarged);
    foreach (var otherPanel in otherPanels)
    {
        otherPanel.IsEnlarged = false;
    }
}



  when a 'enlarged' image gets clicked, nothing happens


Just modify the PanelOrPictureBoxClick event handler like this:

IsEnlarged = true;