Question

I would have given some indication as to the actual issue in the title, but I can’t figure out what it is. All I can state is that the form, when implementing the appbar, no longer responds after I attempt to assign a value to a variable, thereby causing me to have to stop debugging and restart the machine to regain the desktop working area. The location of the error is noted in the code below, and I have only listed the code to the point of the error. Is there anything blatantly obvious here that I do not see?

static class Program
{
    [STAThread]
    static void Main()
    {
        Application.EnableVisualStyles();
        Application.SetCompatibleTextRenderingDefault(false);
        Application.Run(new Form1());
    }
}

public partial class Form1 : AppBar
{
    public Form1() : base()
    {
        InitializeComponent();
    }

    //This is a button on the test form.
    //When clicked, the form should become a desktop application bar
    //docked to the top of the desktop.
    private void t_Click(object sender, EventArgs e)
    {
        base.SET_APPBAR();
    }
}

public class AppBar : Form
{
    protected internal Size appbarSize;
    protected internal Point appbarLocation;
    protected internal bool appbarMode;
    private EDGES appbarEdge;
    private RECT appbarRect;

    private uint ID { get; private set; }
    private IntPtr HANDLE { get; private set; }

    //constructor
    public AppBar() : base () //no issues here
    {
        appbarEdge = EDGES.ABE_TOP;
        appbarRect = new RECT();
        ID = 0;
        HANDLE = this.Handle;
        appbarMode = false;
    }

    protected internal void SET_APPBAR()
    {
        if (IS_NEW())
        {
            QUERY_AND_SET_POSITION(ref appbarRect); //Never get to here
        }
    }

    private bool IS_NEW()
    {
        if (appbarMode) //so far, so good
        {
            return false;
        }
        while (ID == 0) 
        {
            CREATE_ID(); //ID is created, I have verified this.
        }
        this.FormBorderStyle = FormBorderStyle.FixedToolWindow; //BorderStyle does change
        appbarSize = this.Size; //Size is correct
        appbarLocation = this.Location; //still no issues
        NEW(); //this is where the error begins (see code further down)
        return appbarMode; //Never get here
    }

    private void CREATE_ID()
    {
        ID = Hooks.RegisterWindowMessage(Guid.NewGuid().ToString());
    }

    private void QUERY_AND_SET_POSITION(ref RECT appbarRect)
    {
        SET_APPBAR_SIZE(ref appbarRect);
        QUERY_POS(ref appbarRect);
        APPBAR_RESIZE(ref appbarRect);
        SET_POS(ref appbarRect);
        this.Location = new Point(appbarRect.left, appbarRect.top);
        appbarSize = new Size(appbarRect.right - appbarRect.left, appbarRect.bottom - appbarRect.top);
        this.Size = appbarSize;
    }

    private void SET_APPBAR_SIZE(ref RECT appbarRect)
    {
        switch (appbarEdge)
        {
            case (EDGES.ABE_BOTTOM):
                appbarRect.left = 0;
                appbarRect.right = SystemInformation.PrimaryMonitorSize.Width;
                appbarRect.top = SystemInformation.PrimaryMonitorSize.Height - appbarSize.Height;
                appbarRect.bottom = SystemInformation.PrimaryMonitorSize.Height;
                break;
            case (EDGES.ABE_LEFT):
                appbarRect.left = 0;
                appbarRect.right = appbarSize.Width;
                appbarRect.top = 0;
                appbarRect.bottom = SystemInformation.PrimaryMonitorSize.Height;
                break;
            case (EDGES.ABE_RIGHT):
                appbarRect.left = SystemInformation.PrimaryMonitorSize.Width - appbarSize.Width;
                appbarRect.right = SystemInformation.PrimaryMonitorSize.Width;
                appbarRect.top = 0;
                appbarRect.bottom = SystemInformation.PrimaryMonitorSize.Height;
                break;
            default:
                appbarRect.left = 0;
                appbarRect.right = SystemInformation.PrimaryMonitorSize.Width;
                appbarRect.top = SystemInformation.WorkingArea.Top;
                appbarRect.bottom = appbarSize.Height;
                break;
        }
    }

    private void APPBAR_RESIZE(ref RECT appbarRect)
    {
        switch (appbarEdge)
        {
            case (EDGES.ABE_TOP):
                appbarRect.bottom = appbarRect.top + appbarSize.Height;
                break;
            case (EDGES.ABE_BOTTOM):
                appbarRect.top = appbarRect.bottom - appbarSize.Height;
                break;
            case (EDGES.ABE_LEFT):
                appbarRect.right = appbarRect.left + appbarSize.Width;
                break;
            case (EDGES.ABE_RIGHT):
                appbarRect.left = appbarRect.right - appbarSize.Width;
                break;
        }
    }

    private void APPBAR_CALLBACK(ref Message apiMessage)
    {
        switch ((NOTIFICATIONS)(uint)apiMessage.WParam)//? on int vs uint here
        {
            case (NOTIFICATIONS.ABN_STATECHANGE):
                STATE_CHANGE();
                break;
            case (NOTIFICATIONS.ABN_POSCHANGED):
                QUERY_AND_SET_POSITION(ref appbarRect);
                break;
            case (NOTIFICATIONS.ABN_FULLSCREENAPP):
                if ((int)apiMessage.LParam != 0)
                {
                    this.SendToBack();
                    this.TopMost = false;
                }
                else
                {
                    STATE_CHANGE();
                }
                break;
            case (NOTIFICATIONS.ABN_WINDOWARRANGE):
                //first call
                if ((int)apiMessage.LParam != 0)
                {
                    this.Visible = false;
                }
                //second call
                else
                {
                    this.Visible = true;
                }
                break;
        }
    }

    protected override void WndProc(ref Message apiMessage)
    {
        if (appbarMode)
        {
            if (HANDLE == apiMessage.HWnd)
            {
                APPBAR_CALLBACK(ref apiMessage);
            }
            else if (apiMessage.Msg == (int)API_MESSAGES.WM_ACTIVATE)
            {
                ACTIVATE();
            }
            else if (apiMessage.Msg == (int)API_MESSAGES.WM_WINDOWPOSCHANGED)
            {
                WINDOW_POS_CHANGED();
            }
        }
        base.WndProc(ref apiMessage);
    }

    private void NEW()
    {
        APPBARDATA data = new APPBARDATA(); //no apparent issue
        data.cbSize = (uint)Marshal.SizeOf(data); //no apparent issue
        data.hWnd = HANDLE; //no apparent issue
        data.uCallbackMessage = ID; //no apparent issue
        if (Hooks.SHAppBarMessage((uint)DWORD.ABM_NEW, ref data) != 0) //SHAppBar returns 1 (true)
        {
            //no issue if I were to place a MessageBox here
            appbarMode = true; // why in the world is this causing an issue?????
            //can't do anything from this point
        }
    }
}

public static class Hooks
{
    [DllImport("shell32.dll", EntryPoint = "SHAppBarMessage")]
    public static extern uint SHAppBarMessage(uint dwMessage, ref APPBARDATA pData);

    [DllImport("user32.dll", EntryPoint = "RegisterWindowMessage")]
    public static extern uint RegisterWindowMessage(
        [MarshalAs(UnmanagedType.LPTStr)]
        string lpString);
}

After whatever the issue is occurs, I can’t click on any button or close the form. Desktop working area is always appropriately resized. Hopefully all of this makes sense to someone. Thanks for looking in advance.

Answer 1

The problem is that you’re performing a long running operation in the UI thread. This is blocking the UI thread and preventing it from doing anything else (from painting changes, responding to button click or mouse move events, etc.).

You need to perform your long running operation(s) in a background thread. While you can do this manually, using a BackgroundWorker is preferable as it is designed for exactly this application. Not only will it create/configure the background thread for you, but it provides simple and easy to use mechanisms for updating the UI when your background task is completed, updating the UI with progress while the task is working, etc.

Note that while in a background thread you cannot access UI elements; they need to be accessed from the UI thread. You should move all code that gets information from the UI to before you start the background task (saving it for later in local variables or fields) and you should move all code to update the UI based on the results to the end, (in the RunWorkerCompleted event, if using a BackgroundWorker). All of the events other than DoWork for the BackgroundWorker are all executed in the UI thread, and so can access your UI Controls.