diff --git a/bitsdojo_window_linux/lib/src/native_api.dart b/bitsdojo_window_linux/lib/src/native_api.dart
index fde6db9..464b64d 100644
--- a/bitsdojo_window_linux/lib/src/native_api.dart
+++ b/bitsdojo_window_linux/lib/src/native_api.dart
@@ -93,6 +93,11 @@ typedef Void TSetWindowTitle(IntPtr window, Pointer<Utf8> title);
 typedef DSetWindowTitle = void Function(int window, Pointer<Utf8> title);
 final DSetWindowTitle setWindowTitle = _theAPI.ref.setWindowTitle.asFunction();
 
+// setTopmost
+typedef Void TSetTopmost(IntPtr window, Int32 topmost);
+typedef DSetTopmost = void Function(int window, int topmost);
+final DSetTopmost setTopmost = _theAPI.ref.setTopMost.asFunction();
+
 class BDWAPI extends Struct {
   external Pointer<NativeFunction<TGetAppWindowHandle>> getAppWindowHandle;
   external Pointer<NativeFunction<TGetScreenRect>> getScreenRect;
@@ -110,6 +115,7 @@ class BDWAPI extends Struct {
   external Pointer<NativeFunction<TMaximizeWindow>> maximizeWindow;
   external Pointer<NativeFunction<TUnmaximizeWindow>> unmaximizeWindow;
   external Pointer<NativeFunction<TSetWindowTitle>> setWindowTitle;
+  external Pointer<NativeFunction<TSetTopmost>> setTopMost;
 }
 
 typedef Pointer<BDWAPI> TBitsdojoWindowAPI();
diff --git a/bitsdojo_window_linux/lib/src/window.dart b/bitsdojo_window_linux/lib/src/window.dart
index d223248..e4957d6 100644
--- a/bitsdojo_window_linux/lib/src/window.dart
+++ b/bitsdojo_window_linux/lib/src/window.dart
@@ -201,6 +201,12 @@ class GtkWindow extends DesktopWindow {
         handle!, _maxSize!.width.toInt(), _maxSize!.height.toInt());
   }
 
+  @override
+  set topmost(bool topmost) {
+    if (!isValidHandle(handle, "set topmost")) return;
+    native.setTopmost(handle!, topmost ? 1 : 0);
+  }
+
   @override
   set size(Size newSize) {
     if (!isValidHandle(handle, "set size")) return;
diff --git a/bitsdojo_window_linux/linux/api.cpp b/bitsdojo_window_linux/linux/api.cpp
index f63debd..1a0dfa3 100644
--- a/bitsdojo_window_linux/linux/api.cpp
+++ b/bitsdojo_window_linux/linux/api.cpp
@@ -18,7 +18,8 @@ BDWAPI _theAPI = {
     minimizeWindow,
     maximizeWindow,
     unmaximizeWindow,
-    setWindowTitle
+    setWindowTitle,
+    setTopmost
 };
 
 } // namespace bitsdojo_window
diff --git a/bitsdojo_window_linux/linux/api.h b/bitsdojo_window_linux/linux/api.h
index eae98b9..f1259f4 100644
--- a/bitsdojo_window_linux/linux/api.h
+++ b/bitsdojo_window_linux/linux/api.h
@@ -26,6 +26,7 @@ typedef struct _BDWAPI {
     TMaximizeWindow maximizeWindow;
     TUnmaximizeWindow unmaximizeWindow;
     TSetWindowTitle setWindowTitle;
+    TSetTopmost setTopmost;
 } BDWAPI;
 
 }  // namespace bitsdojo_window
diff --git a/bitsdojo_window_linux/linux/api_impl.cpp b/bitsdojo_window_linux/linux/api_impl.cpp
index 2db919c..8d5c9ab 100644
--- a/bitsdojo_window_linux/linux/api_impl.cpp
+++ b/bitsdojo_window_linux/linux/api_impl.cpp
@@ -209,4 +209,8 @@ void setWindowTitle(GtkWindow* window, const gchar* title) {
     g_idle_add_full(G_PRIORITY_HIGH_IDLE, setWindowTitleProc, params, NULL);
 }
 
+void setTopmost(GtkWindow* window, int topmost){
+    gtk_window_set_keep_above(window,topmost == 1 ? TRUE : FALSE);
+}
+
 }  // namespace bitsdojo_window
diff --git a/bitsdojo_window_linux/linux/api_impl.h b/bitsdojo_window_linux/linux/api_impl.h
index 86e19ba..c96972b 100644
--- a/bitsdojo_window_linux/linux/api_impl.h
+++ b/bitsdojo_window_linux/linux/api_impl.h
@@ -49,6 +49,9 @@ namespace bitsdojo_window {
 
     typedef void (*TSetWindowTitle)(GtkWindow*, const gchar *);
     void setWindowTitle(GtkWindow* window, const gchar *title);
+
+    typedef void (*TSetTopmost)(GtkWindow*, int);
+    void setTopmost(GtkWindow* window,int topmost);
 }
 
 #endif // _BDW_API_IMPL_
diff --git a/bitsdojo_window_macos/lib/src/window.dart b/bitsdojo_window_macos/lib/src/window.dart
index 0b61d45..02090a4 100644
--- a/bitsdojo_window_macos/lib/src/window.dart
+++ b/bitsdojo_window_macos/lib/src/window.dart
@@ -238,4 +238,10 @@ class MacOSWindow extends DesktopWindow {
     if (!isValidHandle(handle, "maximizeOrRestore")) return;
     maximizeOrRestoreWindow(handle!);
   }
+
+  @override
+  set topmost(bool topmost) {
+    // TODO: implement topmost
+    throw UnimplementedError();
+  }
 }
diff --git a/bitsdojo_window_platform_interface/lib/window.dart b/bitsdojo_window_platform_interface/lib/window.dart
index d803230..3664cd8 100644
--- a/bitsdojo_window_platform_interface/lib/window.dart
+++ b/bitsdojo_window_platform_interface/lib/window.dart
@@ -18,6 +18,8 @@ abstract class DesktopWindow {
   set minSize(Size? newSize);
   set maxSize(Size? newSize);
 
+  set topmost(bool topmost);
+
   Alignment? get alignment;
   set alignment(Alignment? newAlignment);
 
diff --git a/bitsdojo_window_platform_interface/lib/window_not_implemented.dart b/bitsdojo_window_platform_interface/lib/window_not_implemented.dart
index 0342491..89e88a2 100644
--- a/bitsdojo_window_platform_interface/lib/window_not_implemented.dart
+++ b/bitsdojo_window_platform_interface/lib/window_not_implemented.dart
@@ -39,6 +39,10 @@ class NotImplementedWindow extends DesktopWindow {
     throw UnimplementedError('maxSize setter has not been implemented.');
   }
 
+  set topmost(bool toomost) {
+    throw UnimplementedError('topmost setter has not been implemented.');
+  }
+
   Alignment get alignment {
     throw UnimplementedError('alignment getter has not been implemented.');
   }
diff --git a/bitsdojo_window_windows/lib/src/window.dart b/bitsdojo_window_windows/lib/src/window.dart
index 7e79600..77cda44 100644
--- a/bitsdojo_window_windows/lib/src/window.dart
+++ b/bitsdojo_window_windows/lib/src/window.dart
@@ -293,4 +293,11 @@ class WinWindow extends WinDesktopWindow {
   void startDragging() {
     BitsdojoWindowPlatform.instance.dragAppWindow();
   }
+
+  @override
+  set topmost(bool topmost) {
+    if (!isValidHandle(handle, "topmost")) return;
+
+    PostMessage(handle!, WM_USER + 1, topmost ? 1 : 0, 0);
+  }
 }
diff --git a/bitsdojo_window_windows/windows/bitsdojo_window.cpp b/bitsdojo_window_windows/windows/bitsdojo_window.cpp
index 0a3aa61..c44f7c6 100644
--- a/bitsdojo_window_windows/windows/bitsdojo_window.cpp
+++ b/bitsdojo_window_windows/windows/bitsdojo_window.cpp
@@ -8,7 +8,8 @@
 #include "./window_util.h"
 #include "./include/bitsdojo_window_windows/bitsdojo_window_plugin.h"
 
-namespace bitsdojo_window {
+namespace bitsdojo_window
+{
 
     HWND flutter_window = nullptr;
     HWND flutter_child_window = nullptr;
@@ -24,18 +25,22 @@ namespace bitsdojo_window {
     BOOL restore_by_moving = FALSE;
     BOOL during_size_move = FALSE;
     BOOL dpi_changed_during_size_move = FALSE;
-    SIZE min_size = { 0, 0 };
-    SIZE max_size = { 0, 0 };
+    SIZE min_size = {0, 0};
+    SIZE max_size = {0, 0};
     // Amount to cut when window is maximized
     int window_cut_on_maximize = 0;
 
+    BOOL is_active = FALSE;
+    BOOL need_topmost = FALSE;
+
     // Forward declarations
     int init();
     void monitorFlutterWindows();
 
     auto bdw_init = init();
 
-    bool isBitsdojoWindowLoaded(){
+    bool isBitsdojoWindowLoaded()
+    {
         return is_bitsdojo_window_loaded;
     }
 
@@ -53,7 +58,8 @@ namespace bitsdojo_window {
         return 1;
     }
 
-    void setWindowCutOnMaximize(int value) {
+    void setWindowCutOnMaximize(int value)
+    {
         window_cut_on_maximize = value;
     }
 
@@ -69,7 +75,8 @@ namespace bitsdojo_window {
         max_size.cy = height;
     }
 
-    void setWindowCanBeShown(bool value) {
+    void setWindowCanBeShown(bool value)
+    {
         window_can_be_shown = value;
     }
 
@@ -88,7 +95,7 @@ namespace bitsdojo_window {
     {
         if (code == HCBT_CREATEWND)
         {
-            auto createParams = reinterpret_cast<CBT_CREATEWND*>(lparam);
+            auto createParams = reinterpret_cast<CBT_CREATEWND *>(lparam);
             if (!createParams->lpcs->lpCreateParams)
             {
                 return 0;
@@ -138,7 +145,8 @@ namespace bitsdojo_window {
         int resizeBorder = GetSystemMetricsForDpi(SM_CXSIZEFRAME, currentDpi);
         int borderPadding = GetSystemMetricsForDpi(SM_CXPADDEDBORDER, currentDpi);
         bool isMaximized = IsZoomed(window);
-        if (isMaximized) {
+        if (isMaximized)
+        {
             return borderPadding;
         }
         return resizeBorder + borderPadding;
@@ -146,7 +154,7 @@ namespace bitsdojo_window {
 
     void extendIntoClientArea(HWND hwnd)
     {
-        MARGINS margins = { 0, 0, 1, 0 };
+        MARGINS margins = {0, 0, 1, 0};
         DwmExtendFrameIntoClientArea(hwnd, &margins);
     }
 
@@ -155,7 +163,7 @@ namespace bitsdojo_window {
         bool isMaximized = IsZoomed(flutter_window);
         if (isMaximized)
             return HTCLIENT;
-        POINT pt = { GET_X_LPARAM(lparam), GET_Y_LPARAM(lparam) };
+        POINT pt = {GET_X_LPARAM(lparam), GET_Y_LPARAM(lparam)};
         ScreenToClient(window, &pt);
         RECT rc;
         GetClientRect(window, &rc);
@@ -195,8 +203,8 @@ namespace bitsdojo_window {
         return HTCLIENT;
     }
 
-
-    RECT getScreenRectForWindow(HWND window) {
+    RECT getScreenRectForWindow(HWND window)
+    {
         MONITORINFO monitorInfo = {};
         monitorInfo.cbSize = DWORD(sizeof(MONITORINFO));
         auto monitor = MonitorFromWindow(window, MONITOR_DEFAULTTONEAREST);
@@ -204,7 +212,8 @@ namespace bitsdojo_window {
         return monitorInfo.rcMonitor;
     }
 
-    RECT getWorkingScreenRectForWindow(HWND window) {
+    RECT getWorkingScreenRectForWindow(HWND window)
+    {
         MONITORINFO monitorInfo = {};
         monitorInfo.cbSize = DWORD(sizeof(MONITORINFO));
         auto monitor = MonitorFromWindow(window, MONITOR_DEFAULTTONEAREST);
@@ -212,22 +221,26 @@ namespace bitsdojo_window {
         return monitorInfo.rcWork;
     }
 
-    void adjustPositionOnRestoreByMove(HWND window, WINDOWPOS* winPos) {
-        if (restore_by_moving == FALSE) return;
+    void adjustPositionOnRestoreByMove(HWND window, WINDOWPOS *winPos)
+    {
+        if (restore_by_moving == FALSE)
+            return;
 
         auto screenRect = getWorkingScreenRectForWindow(window);
-        
-        if (winPos->y < screenRect.top) {
+
+        if (winPos->y < screenRect.top)
+        {
             winPos->y = screenRect.top;
         }
     }
 
-    void adjustMaximizedSize(HWND window, WINDOWPOS* winPos) {
+    void adjustMaximizedSize(HWND window, WINDOWPOS *winPos)
+    {
         auto screenRect = getWorkingScreenRectForWindow(window);
         if ((winPos->x < screenRect.left) &&
             (winPos->y < screenRect.top) &&
-            (winPos->cx > (screenRect.right - screenRect.left))
-            && (winPos->cy > (screenRect.bottom - screenRect.top))) {            
+            (winPos->cx > (screenRect.right - screenRect.left)) && (winPos->cy > (screenRect.bottom - screenRect.top)))
+        {
             winPos->x = screenRect.left;
             winPos->y = screenRect.top;
             winPos->cx = screenRect.right - screenRect.left;
@@ -235,31 +248,35 @@ namespace bitsdojo_window {
         }
     }
 
-    void adjustMaximizedRects(HWND window, NCCALCSIZE_PARAMS* params) {
+    void adjustMaximizedRects(HWND window, NCCALCSIZE_PARAMS *params)
+    {
         auto screenRect = getWorkingScreenRectForWindow(window);
-        for (int i = 0; i < 3; i++) {
+        for (int i = 0; i < 3; i++)
+        {
             if ((params->rgrc[i].left < screenRect.left) &&
                 (params->rgrc[i].top < screenRect.top) &&
                 (params->rgrc[i].right > screenRect.right) &&
-                (params->rgrc[i].bottom > screenRect.bottom)) {                
+                (params->rgrc[i].bottom > screenRect.bottom))
+            {
                 params->rgrc[i].left = screenRect.left;
                 params->rgrc[i].top = screenRect.top;
                 params->rgrc[i].right = screenRect.right;
                 params->rgrc[i].bottom = screenRect.bottom;
             }
-        }        
+        }
     }
 
-    double getScaleFactor(HWND window) {
+    double getScaleFactor(HWND window)
+    {
         UINT dpi = GetDpiForWindow(window);
         return dpi / 96.0;
     }
 
     LRESULT handle_nccalcsize(HWND window, WPARAM wparam, LPARAM lparam)
     {
-        auto params = reinterpret_cast<NCCALCSIZE_PARAMS*>(lparam);
+        auto params = reinterpret_cast<NCCALCSIZE_PARAMS *>(lparam);
         adjustMaximizedSize(window, params->lppos);
-        adjustMaximizedRects(window,params);
+        adjustMaximizedRects(window, params);
 
         auto initialRect = params->rgrc[0];
         auto defaultResult = DefSubclassProc(window, WM_NCCALCSIZE, wparam, lparam);
@@ -284,7 +301,7 @@ namespace bitsdojo_window {
             params->rgrc[0].right += sidesCut;
             params->rgrc[0].bottom += sidesCut;
         }
-        else 
+        else
         {
             params->rgrc[0].top -= 1;
         }
@@ -294,7 +311,8 @@ namespace bitsdojo_window {
 
     const static long kWmDpiChangedBeforeParent = 0x02E2;
 
-    void fixDPIScaling() {
+    void fixDPIScaling()
+    {
         SendMessage(flutter_child_window, kWmDpiChangedBeforeParent, 0, 0);
         forceChildRefresh();
     }
@@ -303,24 +321,25 @@ namespace bitsdojo_window {
     {
         switch (message)
         {
-            case WM_CREATE: {
-                LRESULT result = DefSubclassProc(window, message, wparam, lparam);
-                fixDPIScaling();
-                return result;
-            }
-            case WM_NCHITTEST:
+        case WM_CREATE:
+        {
+            LRESULT result = DefSubclassProc(window, message, wparam, lparam);
+            fixDPIScaling();
+            return result;
+        }
+        case WM_NCHITTEST:
+        {
+            if (has_custom_frame == FALSE)
             {
-                if (has_custom_frame == FALSE)
-                {
-                    break;
-                }
-                LRESULT result = handle_nchittest(window, wparam, lparam);
-                if (result != HTCLIENT)
-                {
-                    return HTTRANSPARENT;
-                }
                 break;
             }
+            LRESULT result = handle_nchittest(window, wparam, lparam);
+            if (result != HTCLIENT)
+            {
+                return HTTRANSPARENT;
+            }
+            break;
+        }
         }
         return DefSubclassProc(window, message, wparam, lparam);
     }
@@ -334,7 +353,7 @@ namespace bitsdojo_window {
         SetWindowPos(flutter_child_window, 0, 0, 0, width, height, SWP_NOMOVE | SWP_NOACTIVATE);
     }
 
-    void getSizeOnScreen(SIZE* size)
+    void getSizeOnScreen(SIZE *size)
     {
         UINT dpi = GetDpiForWindow(flutter_window);
         double scale_factor = dpi / 96.0;
@@ -367,19 +386,20 @@ namespace bitsdojo_window {
         return true;
     }
 
-    void handle_bdw_action(HWND window, WPARAM action, LPARAM actionData){
+    void handle_bdw_action(HWND window, WPARAM action, LPARAM actionData)
+    {
         switch (action)
         {
         case BDW_SETWINDOWPOS:
         {
-            auto param = (SWPParam*)(actionData);
+            auto param = (SWPParam *)(actionData);
             SetWindowPos(window, 0, param->x, param->y, param->cx, param->cy, param->uFlags);
             HeapFree(GetProcessHeap(), 0, param);
             break;
         }
         case BDW_SETWINDOWTEXT:
         {
-            auto param = (SWTParam*)(actionData);
+            auto param = (SWTParam *)(actionData);
             SetWindowText(window, param->text);
             HeapFree(GetProcessHeap(), 0, (LPVOID)param->text);
             HeapFree(GetProcessHeap(), 0, param);
@@ -393,196 +413,225 @@ namespace bitsdojo_window {
         }
     }
 
-
-
-LRESULT CALLBACK main_window_proc(HWND window, UINT message, WPARAM wparam, LPARAM lparam, UINT_PTR subclssID, DWORD_PTR refData)
-{
-    switch (message)
-    {
-    case WM_ERASEBKGND:
+    LRESULT CALLBACK main_window_proc(HWND window, UINT message, WPARAM wparam, LPARAM lparam, UINT_PTR subclssID, DWORD_PTR refData)
     {
-        return 1;
-    }
-    case WM_NCCREATE:
-    {
-        flutter_window = window;
-        auto style = GetWindowLongPtr(window, GWL_STYLE);
-        style = style | WS_CLIPCHILDREN;
-        SetWindowLongPtr(window, GWL_STYLE, style);
-        SetProp(window, L"BitsDojoWindow", (HANDLE)(1));
-        break;
-    }
-    case WM_NCHITTEST:
-    {
-        if (has_custom_frame == FALSE)
+        switch (message)
         {
-            break;
+        case WM_ERASEBKGND:
+        {
+            return 1;
         }
-        return handle_nchittest(window, wparam, lparam);
-    }
-    case WM_NCCALCSIZE:
-    {
-        if (has_custom_frame == FALSE)
+        case WM_NCCREATE:
         {
+            flutter_window = window;
+            auto style = GetWindowLongPtr(window, GWL_STYLE);
+            style = style | WS_CLIPCHILDREN;
+            SetWindowLongPtr(window, GWL_STYLE, style);
+            SetProp(window, L"BitsDojoWindow", (HANDLE)(1));
             break;
         }
-        return handle_nccalcsize(window, wparam, lparam);
-    }
-    case WM_CREATE:
-    {
-        auto createStruct = reinterpret_cast<CREATESTRUCT *>(lparam);
-        LRESULT result = DefSubclassProc(window, message, wparam, lparam);
-        if (has_custom_frame == TRUE)
+        case WM_NCHITTEST:
         {
-            extendIntoClientArea(window);
-            SetWindowPos(window, nullptr, 0, 0, 0, 0, SWP_FRAMECHANGED | SWP_NOMOVE | SWP_NOSIZE | SWP_DRAWFRAME);
+            if (has_custom_frame == FALSE)
+            {
+                break;
+            }
+            return handle_nchittest(window, wparam, lparam);
         }
-        centerOnMonitorContainingMouse(window, createStruct->cx, createStruct->cy);
-        if (visible_on_startup == TRUE)
+        case WM_NCCALCSIZE:
         {
-            setWindowCanBeShown(TRUE);
-            forceChildRefresh();
-        }
-        return result;
-    }
-    case WM_DPICHANGED:
-    {
-        if (during_size_move == TRUE) {
-            dpi_changed_during_size_move = TRUE;
-        }
-        forceChildRefresh();
-        break;
-    }
-    case WM_SIZE:
-    {
-        if (during_minimize == TRUE) {
-                return 0;
+            if (has_custom_frame == FALSE)
+            {
+                break;
+            }
+            return handle_nccalcsize(window, wparam, lparam);
         }
-        if (bypass_wm_size == TRUE)
+        case WM_CREATE:
         {
-            return DefWindowProc(window, message, wparam, lparam);
+            auto createStruct = reinterpret_cast<CREATESTRUCT *>(lparam);
+            LRESULT result = DefSubclassProc(window, message, wparam, lparam);
+            if (has_custom_frame == TRUE)
+            {
+                extendIntoClientArea(window);
+                SetWindowPos(window, nullptr, 0, 0, 0, 0, SWP_FRAMECHANGED | SWP_NOMOVE | SWP_NOSIZE | SWP_DRAWFRAME);
+            }
+            centerOnMonitorContainingMouse(window, createStruct->cx, createStruct->cy);
+            if (visible_on_startup == TRUE)
+            {
+                setWindowCanBeShown(TRUE);
+                forceChildRefresh();
+            }
+            return result;
         }
-        break;
-    }
-    case WM_SYSCOMMAND:
-    {
-        if (wparam == SC_MINIMIZE)
+        case WM_DPICHANGED:
         {
-            during_minimize = TRUE;
+            if (during_size_move == TRUE)
+            {
+                dpi_changed_during_size_move = TRUE;
+            }
+            forceChildRefresh();
+            break;
         }
-        if (wparam == SC_MAXIMIZE)
+        case WM_SIZE:
         {
-            during_maximize = TRUE;
+            if (during_minimize == TRUE)
+            {
+                return 0;
+            }
+            if (bypass_wm_size == TRUE)
+            {
+                return DefWindowProc(window, message, wparam, lparam);
+            }
+            break;
         }
-        if (wparam == SC_RESTORE)
+        case WM_SYSCOMMAND:
         {
-            during_restore = TRUE;
-        }
-        LRESULT result = DefSubclassProc(window, message, wparam, lparam);
-        during_minimize = FALSE;
-        during_maximize = FALSE;
-        during_restore = FALSE;
-        return result;
-    }
-    case WM_WINDOWPOSCHANGING:
-    {
-        auto winPos = reinterpret_cast<WINDOWPOS *>(lparam);
-        bool isResize = !(winPos->flags & SWP_NOSIZE);
-        if (has_custom_frame && isResize) {
-            adjustMaximizedSize(window, winPos);
-            adjustPositionOnRestoreByMove(window, winPos);
+            if (wparam == SC_MINIMIZE)
+            {
+                during_minimize = TRUE;
+            }
+            if (wparam == SC_MAXIMIZE)
+            {
+                during_maximize = TRUE;
+            }
+            if (wparam == SC_RESTORE)
+            {
+                during_restore = TRUE;
+            }
+            LRESULT result = DefSubclassProc(window, message, wparam, lparam);
+            during_minimize = FALSE;
+            during_maximize = FALSE;
+            during_restore = FALSE;
+            return result;
         }
-        BOOL isShowWindow = ((winPos->flags & SWP_SHOWWINDOW) == SWP_SHOWWINDOW);
-        
-        if ((isShowWindow == TRUE) && (window_can_be_shown == FALSE) && (visible_on_startup == FALSE))
+        case WM_WINDOWPOSCHANGING:
         {
-            winPos->flags &= ~SWP_SHOWWINDOW;
-        }
+            auto winPos = reinterpret_cast<WINDOWPOS *>(lparam);
+            bool isResize = !(winPos->flags & SWP_NOSIZE);
+            if (has_custom_frame && isResize)
+            {
+                adjustMaximizedSize(window, winPos);
+                adjustPositionOnRestoreByMove(window, winPos);
+            }
+            BOOL isShowWindow = ((winPos->flags & SWP_SHOWWINDOW) == SWP_SHOWWINDOW);
 
-        break;
-    }
-    case WM_WINDOWPOSCHANGED:
-    {
-        auto winPos = reinterpret_cast<WINDOWPOS*>(lparam);
-        bool isResize = !(winPos->flags & SWP_NOSIZE);
-        if (has_custom_frame && isResize) {
-            
-            adjustMaximizedSize(window, winPos);
-            adjustPositionOnRestoreByMove(window, winPos);
-        }
+            if ((isShowWindow == TRUE) && (window_can_be_shown == FALSE) && (visible_on_startup == FALSE))
+            {
+                winPos->flags &= ~SWP_SHOWWINDOW;
+            }
 
-        if (false == window_can_be_shown) {
             break;
         }
+        case WM_WINDOWPOSCHANGED:
+        {
+            auto winPos = reinterpret_cast<WINDOWPOS *>(lparam);
+            bool isResize = !(winPos->flags & SWP_NOSIZE);
+            if (has_custom_frame && isResize)
+            {
+
+                adjustMaximizedSize(window, winPos);
+                adjustPositionOnRestoreByMove(window, winPos);
+            }
+
+            if (false == window_can_be_shown)
+            {
+                break;
+            }
 
-        if (bypass_wm_size == TRUE)
+            if (bypass_wm_size == TRUE)
+            {
+                if (isResize && (!during_minimize) && (winPos->cx != 0))
+                {
+                    adjustChildWindowSize();
+                }
+            }
+            break;
+        }
+        case WM_GETMINMAXINFO:
         {
-            if (isResize && (!during_minimize) && (winPos->cx != 0))
+            auto info = reinterpret_cast<MINMAXINFO *>(lparam);
+            if ((min_size.cx != 0) && (min_size.cy != 0))
+            {
+                SIZE minSize = min_size;
+                getSizeOnScreen(&minSize);
+                info->ptMinTrackSize.x = minSize.cx;
+                info->ptMinTrackSize.y = minSize.cy;
+            }
+            if ((max_size.cx != 0) && (max_size.cy != 0))
             {
-                adjustChildWindowSize();
+                SIZE maxSize = max_size;
+                getSizeOnScreen(&maxSize);
+                info->ptMaxTrackSize.x = maxSize.cx;
+                info->ptMaxTrackSize.y = maxSize.cy;
             }
+            return 0;
         }
-        break;
-    }
-    case WM_GETMINMAXINFO:
-    {
-        auto info = reinterpret_cast<MINMAXINFO *>(lparam);
-        if ((min_size.cx != 0) && (min_size.cy != 0))
+        case WM_ENTERSIZEMOVE:
         {
-            SIZE minSize = min_size;
-            getSizeOnScreen(&minSize);
-            info->ptMinTrackSize.x = minSize.cx;
-            info->ptMinTrackSize.y = minSize.cy;
+            bool isMaximized = IsMaximized(window);
+            during_size_move = TRUE;
+            if (isMaximized)
+            {
+                restore_by_moving = TRUE;
+            }
+            break;
         }
-        if ((max_size.cx != 0) && (max_size.cy != 0))
+        case WM_EXITSIZEMOVE:
         {
-            SIZE maxSize = max_size;
-            getSizeOnScreen(&maxSize);
-            info->ptMaxTrackSize.x = maxSize.cx;
-            info->ptMaxTrackSize.y = maxSize.cy;
+            during_size_move = FALSE;
+            if (dpi_changed_during_size_move)
+            {
+                forceChildRefresh();
+            }
+            dpi_changed_during_size_move = FALSE;
+            restore_by_moving = FALSE;
+            break;
         }
-        return 0;
-    }
-    case WM_ENTERSIZEMOVE:
-    {
-        bool isMaximized = IsMaximized(window);
-        during_size_move = TRUE;
-        if (isMaximized) {
-            restore_by_moving = TRUE;
-        }        
-        break;
-    }
-    case WM_EXITSIZEMOVE:
-    {
-        during_size_move = FALSE;
-        if (dpi_changed_during_size_move) {         
-            forceChildRefresh();
+        case WM_BDW_ACTION:
+        {
+            handle_bdw_action(window, wparam, lparam);
+            break;
         }
-        dpi_changed_during_size_move = FALSE;
-        restore_by_moving = FALSE;        
-        break;
-    }
-    case WM_BDW_ACTION:
-    {
-        handle_bdw_action(window, wparam, lparam);        
-        break;
-    }
-    default:
-        break;
+        case WM_ACTIVATE:
+        {
+            if (need_topmost)
+            {
+                SetWindowPos(window, HWND_TOPMOST, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE);
+            }
+            break;
+        }
+        case WM_USER + 1:
+        {
+            if ((int)wparam == 1)
+            {
+                if (is_active)
+                    SetWindowPos(window, HWND_TOPMOST, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE);
+                else
+                    need_topmost = TRUE;
+            }
+            else
+            {
+                need_topmost = FALSE;
+                SetWindowPos(window, HWND_NOTOPMOST, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE);
+            }
+            break;
+        }
+        default:
+            break;
+        }
+        return DefSubclassProc(window, message, wparam, lparam);
     }
-    return DefSubclassProc(window, message, wparam, lparam);
-}
 
-bool dragAppWindow()
-{
-    if (flutter_window == nullptr)
+    bool dragAppWindow()
     {
-        return false;
+        if (flutter_window == nullptr)
+        {
+            return false;
+        }
+        ReleaseCapture();
+        SendMessage(flutter_window, WM_SYSCOMMAND, SC_MOVE | HTCAPTION, 0);
+        return true;
     }
-    ReleaseCapture();
-    SendMessage(flutter_window, WM_SYSCOMMAND, SC_MOVE | HTCAPTION, 0);
-    return true;
-}
 
 } // bitsdojo_window namespace