Well there is still a problem if the cleanup code gets an error. Perhaps you can save and update an error code but still making sure you release all handles, even when something fails.

Actually now I see you are using the code space to store variables. This is going to be problematic if you ever want to open two windows of the same class because this makes the code not-thread-safe and not-reentrant. I wonder why you didn't use the stack (as would be more usual and cause less problems)?

This may cause problems only if you would create two instances of the main window class inside the same program.

Moreover, if you run this program in any number of instances this also not be an issue here because each of the instances of the application has own separated space for code and data and this also won't cause any problems.

But people tend to use and modify examples for their own use. If it was a full program I would not say anything, but for an example we expect people to copy and use for various purposes, not just the posted purpose.

I have one question: I would like to use constants that are hidden inside the procedure, as for example TRIVERTEX structure that will never be modified, can I left them there (for initialization of the window background)? I think that in this case shouldn't be a problem with data conflict because these values would be always constant and I would like to have some data in one place, tightly tied with the window procedure body.

Doesn't assemble in the FASM beta 1.71.08. Couldn't discern why - working well otherwise. Probably still bugs being worked out of the new label code.

struct TRIVERTEX
  x        dd ?
  y        dd ?
  Red    dw  ?
  Green dw ?
  Blue   dw ?
  Alpha dw ?
ends
    

;...
section '.text' code readable writeable executable

        HwndMain        dd 0    ; A handle of the main application window.
;...    

MHajduk: Are you aware that you are still writing to your code section?

Code:

;...
section '.text' code readable writeable executable

        HwndMain        dd 0    ; A handle of the main application window.
;...    

(...)

; The data section.
;
section '.data' data readable writeable

        HwndMain        dd 0    ; A handle of the main application window.

        HwndBis         dd 0    ; A handle of the additional resizable application
                                ; window.

(...)
                                
; The code section.
;
section '.code' code readable executable

        start:

(...)    

        ; The error handling routine that organizes the program flow when any of
        ; API functions returns zero value.
        ;
        ErrorRoutine16:
                ; Zeroize bits of the eax register from the 16th to the 31st one.
                ; Done to assure that the eax register won't contain any "garbage"
                ; after calling API functions returning 16-bit result.
                ;
                and     eax, 0xFFFF

        ErrorRoutine:
                ; Check value stored in the eax register. If it's nonzero then
                ; return to the address following the place the error procedure
                ; has been called.
                ;
                test    eax, eax
                jz      @f

                retn    4

                ; Check value of the last error that has occured.
                ;
                @@:
                invoke  GetLastError
                test    eax, eax
                jnz     @f

                ; If there was no error, i.e. the 'GetLastError' function returned
                ; 'ERROR_SUCCESS', we return to the place when the 'ErrorRoutine'
                ; procedure was called and remove the 'ReturnTo' address stored on
                ; the stack before the procedure call.
                ;
                retn    4

                @@:
                ; If there was an error, we display a message box with a human readable
                ; description of the error, remove the address of the procedure caller
                ; and return to the 'ReturnTo' address.
                ;
                stdcall ShowLastError, NULL, eax

                add     esp, 4
                retn
    

macro   IfErr   ReturnTo
{
        push    ReturnTo
        call    ErrorRoutine
}

macro   IfErr16 ReturnTo
{
        push    ReturnTo
        call    ErrorRoutine16
}    

stdcall ErrorRoutine, <ReturnTo>

and

stdcall ErrorRoutine16, <ReturnTo>

Yeah, it was an unintended and unwanted "heritage" of the previous version when data & code were mixed in one section.

I sometimes find it quite depressing to think about how many times I have rewritten the same piece of code before I can finally get it right.

For me, a gram of planning can be worth a tonne of future rewards.