Switching between fullscreen and maximized

[explorer-source]

I'm trying to rewrite existing .cpp code to pure dart but it doesn't work and I don't know why it's not throwing Exception also

class MyApp extends StatelessWidget {
  const MyApp({super.key});

  @override
  Widget build(BuildContext context) {
    bool isFullscreen = false;
    return GetMaterialApp(
      home: Scaffold(
        body: Center(
          child: ElevatedButton(
            onPressed: () {
              final hwnd = GetActiveWindow();
              if (isFullscreen) {
                final result = SetWindowPos(
                    hwnd,
                    HWND_TOPMOST,
                    0,
                    0,
                    GetSystemMetrics(SM_CXSCREEN),
                    GetSystemMetrics(SM_CYSCREEN),
                    SWP_FRAMECHANGED | SWP_SHOWWINDOW);
                if (FAILED(result)) {
                  throw WindowsException(result);
                }
              } else {
                final rectMonitor = calloc<RECT>();
                SystemParametersInfo(SPI_GETWORKAREA, 0, rectMonitor, 0);

                int x = rectMonitor.ref.left;
                int y = rectMonitor.ref.top;
                int width = rectMonitor.ref.right - rectMonitor.ref.left;
                int height = rectMonitor.ref.bottom - rectMonitor.ref.top;

                final result = SetWindowPos(hwnd, HWND_NOTOPMOST, x, y, width,
                    height, SWP_FRAMECHANGED | SWP_SHOWWINDOW);
                if (FAILED(result)) {
                  throw WindowsException(result);
                }
              }
              isFullscreen = !isFullscreen;
            },
            child: Text('TOGGLE'),
          ),
        ),
      ),
    );
  }
}

this is my .cpp code that I'm trying to convert, it works

void MethodCall::enableFullscreen()
{
    HWND hWnd = GetActiveWindow();

    // Set the window position and size to cover the entire screen
    SetWindowPos(hWnd, HWND_TOPMOST,
        0, 0,
        GetSystemMetrics(SM_CXSCREEN), GetSystemMetrics(SM_CYSCREEN),
        SWP_FRAMECHANGED | SWP_SHOWWINDOW);

    UpdateWindow(hWnd);

    result->Success(flutter::EncodableValue(true));
}

void MethodCall::disableFullscreen()
{
    HWND hWnd = GetActiveWindow();
        
    RECT rectMonitor;
    SystemParametersInfo(SPI_GETWORKAREA, 0, &rectMonitor, 0);

    // Compute the dimensions of the window to fill the monitor's work area
    int x = rectMonitor.left;
    int y = rectMonitor.top;
    int width = rectMonitor.right - rectMonitor.left;
    int height = rectMonitor.bottom - rectMonitor.top;

    // Set the window position and size to the previous values
    SetWindowPos(hWnd, HWND_NOTOPMOST,
        x, y,
        width, height,
        SWP_FRAMECHANGED | SWP_SHOWWINDOW);
    
    UpdateWindow(hWnd);

    result->Success(flutter::EncodableValue(true));
}

[ilopX]

import 'dart:ffi';

import 'package:ffi/ffi.dart';
import 'package:flutter/material.dart';
import 'package:win32/win32.dart';

void main() {
  runApp(const MyApp());
}

class MyApp extends StatefulWidget {
  const MyApp({super.key});

  @override
  State<MyApp> createState() => _MyAppState();
}

class _MyAppState extends State<MyApp> {
  bool _isFullscreen = false;
  late int hwnd;

  @override
  void initState() {
    hwnd = findMainWindow()!;
    super.initState();
  }

  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      home: Scaffold(
        backgroundColor: Colors.black,
        body: Center(
          child: ElevatedButton(
            onPressed: () {
              fullScreen = !fullScreen;
            },
            child: const Text('TOGGLE'),
          ),
        ),
      ),
    );
  }

  set fullScreen(bool isFullScreen) {
    _isFullscreen = isFullScreen;

    if (isFullScreen) {
      var style = GetWindowLongPtr(hwnd, GWL_STYLE);
      style &= ~(WS_CAPTION);
      SetWindowLongPtr(hwnd, GWL_STYLE, style);
      ShowWindowAsync(hwnd, SW_SHOWMAXIMIZED);
    } else {
      var style = GetWindowLongPtr(hwnd, GWL_STYLE);
      style |= WS_CAPTION;
      SetWindowLongPtr(hwnd, GWL_STYLE, style);
      ShowWindowAsync(hwnd, SW_RESTORE);
    }
  }

  bool get fullScreen => _isFullscreen;
}

int? findMainWindow() {
  final processId = GetCurrentProcessId();
  final data = calloc<EnumWindowsData>()
    ..ref.hwnd = 0
    ..ref.processId = processId;

  final callback = Pointer.fromFunction<EnumWindowsProc>(
    _enumWindowsCallback,
    0,
  );

  try {
    do {
      EnumWindows(callback, data.address);
    } while (data.ref.hwnd == 0);
  } finally {
    free(data);
  }

  return data.ref.hwnd == 0 ? null : data.ref.hwnd;
}

final class EnumWindowsData extends Struct {
  @IntPtr()
  external int hwnd;

  @IntPtr()
  external int processId;
}

int _enumWindowsCallback(int hwnd, int lParam) {
  final data = Pointer<EnumWindowsData>.fromAddress(lParam);

  final processId = calloc<Uint32>();
  try {
    GetWindowThreadProcessId(hwnd, processId);

    if (processId.value != data.ref.processId) {
      return TRUE;
    }
  } finally {
    free(processId);
  }

  final own = GetWindow(hwnd, GW_OWNER);
  if (own != 0) {
    return TRUE;
  }

  data.ref.hwnd = hwnd;
  return FALSE; // stop enums
}