DWORD GuiAcquireMutex(HANDLE hMutex, DWORD dwTimeout)
{
 if(hMutex == INVALID_HANDLE_VALUE)
   return ERROR_INVALID_HANDLE;
 
 long long llNow;
 long long llStart        = GetMilliTime();
 long long llEnd          = llStart + (long long) dwTimeout;
 DWORD     dwShortTimeout = 1000;        // 1 second
 DWORD     dwLastError;
 DWORD     dwWaitResult;

Again:

 dwLastError  = 0; // Success
 dwWaitResult = WaitForSingleObject(hMutex, dwShortTimeout);

 switch(dwWaitResult)
  {
   case WAIT_FAILED:

        llNow = GetMilliTime();
        
        if(llNow < llEnd)
         {
          if(g_bQuit)
           {
            dwLastError = ERROR_COUNTER_TIMEOUT;

            SetLastError(dwLastError);
            return dwLastError;
           }
          
          Ctrl::GuiSleep(1000); // Never sleeps for 1000 ms (always returns immediately)
          goto Again;
         }

        dwLastError = GetLastError();
        break;

   case WAIT_TIMEOUT:

        llNow = GetMilliTime();
        
        if(llNow < llEnd)
         {
          if(g_bQuit)
           {
            dwLastError = ERROR_COUNTER_TIMEOUT;

            SetLastError(dwLastError);
            return dwLastError;
           }
           
          Ctrl::GuiSleep(1000); // Never sleeps for 1000 ms (always returns immediately)
          goto Again;
         }

        dwLastError = ERROR_COUNTER_TIMEOUT;

        SetLastError(dwLastError);
  }

 return dwLastError;
}

DWORD GuiAcquireMutex(HANDLE hMutex, DWORD dwTimeout)
{
	if(hMutex == INVALID_HANDLE_VALUE)
		return ERROR_INVALID_HANDLE;
 
	DWORD     dwLastError = -1;

	while ( !g_bQuit && dwLastError != 0 )
	{
		dwLastError  = 0; // Success

		switch( WaitForSingleObject(hMutex, dwShortTimeout ) )
		{
		case WAIT_FAILED:
			Do_Set_LastError_Accordingly();
			break;
			
		case WAIT_TIMEOUT:
			dwLastError = ERROR_COUNTER_TIMEOUT;
			break;
		}
		// consider measure how long it takes ProcessEvents to finish,
		// if very quick, consider add a Sleep(500) or something like that
		// to avoid keeping CPU busy for nothing.
		topwin.ProcessEvents();
		if(TooSoon() )
		{
			Sleep (500);
		}
	}
	SetLastError (dwLastError) ;

	return dwLastError;
}

DWORD GuiAcquireMutex(HANDLE hMutex, DWORD dwTimeout)
{
  static int inthecall;

  if( inthecall )
       return ERROR_IN_CALL; // define this value yourself
  ++inthecall;
  if(hMutex == INVALID_HANDLE_VALUE)
   return ERROR_INVALID_HANDLE;
 
 long long llNow;
 long long llStart        = GetMilliTime();
 long long llEnd          = llStart + (long long) dwTimeout;
 DWORD     dwShortTimeout = 1000;        // 1 second
 DWORD     dwLastError;
 DWORD     dwWaitResult;
   ....

	void Start(){
		static int cnt;
		if( cnt!= 0 )
			return;
		++ cnt;
		stop_requested = false;
		log.Clear();
		badguy.Run([this]{
			LOG("Badguy running...\n"); // CHANGE THIS
			Mutex::Lock _(mut);
			LOG("Badguy now owns the Mutex.\n");  // CHANGE THIS
			while(!stop_requested && !IsShutdownThreads() ){
				Sleep(50);
			}
			LOG("Stop requested, Badguy exiting and releasing the Mutex...\n"); // AND THIS
		});

		// wait for badguy to acquire the mutex
		while(mut.TryEnter()){
			mut.Leave();
			ProcessEvents();
			Sleep(100);
		}

		log.Append("Trying to acquire the mutex...\n");
		GuiAcquireMutex();
		--cnt;
	}

#include <CtrlLib/CtrlLib.h>

using namespace Upp;

#define LAYOUTFILE <DeadMutex/DeadMutex.lay>
#include <CtrlCore/lay.h>

static std::atomic<bool> fin;

class DeadMutex : public WithDeadMutexLayout<TopWindow> {
	
	typedef DeadMutex CLASSNAME;
	
public:
	DeadMutex()
	{
		CtrlLayout(*this, "Window title");
		start.WhenPush = THISFN(Start);
		stop.WhenPush = [this]{ fin = true; };
		WhenClose = [this]{ ShutdownThreads(); Break(); };
	}
	
	void Start(){
		Thread().Run([=] {
			{
				GuiLock __; // EnterGuiMutex()
				log.Append("Badguy instance running & owned the gui mutex...\n");
				// LeaveGuiMutex();
			}
			while(!fin && !IsShutdownThreads() ){
				Sleep(50);
			}
			GuiLock __;
			log.Append("Stop requested, Badguy instance exiting...\n");
			fin = false;
		});
	}
};

GUI_APP_MAIN
{
	DeadMutex().Run();
}