Update to v106r46 release.

byuu says:

Changelog:

  - bsnes, higan: simplified make output; reordered rules
  - hiro: added Window::set(Minimum,Maximum)Size() [only implemented in
    GTK+ so far]
  - bsnes: only allow the window to be shrunk to the 1x multiplier size
  - bsnes: refactored Integral Scaling checkbox to {Center, Scale,
    Stretch} radio selection
  - nall: call fflush() after nall::print() to stdout or stderr [needed
    for msys2/bash]
  - bsnes, higan: program/interface.cpp renamed to program/platform.cpp
  - bsnes: trim ".shader/" from names in Settings→Shader menu
  - bsnes: Settings→Shader menu updated on video driver changes
  - bsnes: remove missing games from recent files list each time it is
    updated
  - bsnes: video multiplier menu generated dynamically based on largest
    monitor size at program startup
  - bsnes: added shrink window and center window function to video
    multiplier menu
  - bsnes: de-minimize presentation window when exiting fullscreen mode
    or changing video multiplier
  - bsnes: center the load game dialog against the presentation window
    (important for multi-monitor setups)
  - bsnes: screenshots are not immediate instead of delayed one frame
  - bsnes: added frame advance menu option and hotkey
  - bsnes: added enable cheats checkbox and hotkey; can be used to
    quickly enable/disable all active cheats

Errata:

  - hiro/Windows: `SW_MINIMIZED`, `SW_MAXIMIZED `=> `SW_MINIMIZE`,
    `SW_MAXIMIZE`
  - hiro/Windows: add pMonitor::workspace()
  - hiro/Windows: add setMaximized(), setMinimized() in
    pWindow::construct()
  - bsnes: call setCentered() after setMaximized(false)

hiro/cocoa/window.cpp

@@ -330,6 +330,22 @@ auto pWindow::setGeometry(Geometry geometry) -> void {
   unlock();
 }
 
+auto pWindow::setMaximized(bool maximized) -> void {
+  //todo
+}
+
+auto pWindow::setMaximumSize(Size size) -> void {
+  //todo
+}
+
+auto pWindow::setMinimized(bool minimized) -> void {
+  //todo
+}
+
+auto pWindow::setMinimumSize(Size size) -> void {
+  //todo
+}
+
 auto pWindow::setModal(bool modal) -> void {
   @autoreleasepool {
     if(modal == true) {

hiro/cocoa/window.hpp

@@ -44,6 +44,10 @@ struct pWindow : pObject {
   auto setFocused() -> void override;
   auto setFullScreen(bool fullScreen) -> void;
   auto setGeometry(Geometry geometry) -> void;
+  auto setMaximized(bool maximized) -> void;
+  auto setMaximumSize(Size size) -> void;
+  auto setMinimized(bool minimized) -> void;
+  auto setMinimumSize(Size size) -> void;
   auto setModal(bool modal) -> void;
   auto setResizable(bool resizable) -> void;
   auto setTitle(const string& text) -> void;

hiro/core/core.hpp

@@ -446,9 +446,10 @@ struct Monitor {
   Monitor() = delete;
 
   static auto count() -> uint;
-  static auto dpi(uint monitor) -> Position;
-  static auto geometry(uint monitor) -> Geometry;
+  static auto dpi(maybe<uint> monitor = nothing) -> Position;
+  static auto geometry(maybe<uint> monitor = nothing) -> Geometry;
   static auto primary() -> uint;
+  static auto workspace(maybe<uint> monitor = nothing) -> Geometry;
 };
 #endif
 
@@ -695,7 +696,11 @@ struct mWindow : mObject {
   auto fullScreen() const -> bool;
   auto geometry() const -> Geometry;
   auto layout() const -> Layout;
+  auto maximized() const -> bool;
+  auto maximumSize() const -> Size;
   auto menuBar() const -> MenuBar;
+  auto minimized() const -> bool;
+  auto minimumSize() const -> Size;
   auto modal() const -> bool;
   auto onClose(const function<void ()>& callback = {}) -> type&;
   auto onDrop(const function<void (string_vector)>& callback = {}) -> type&;
@@ -718,6 +723,10 @@ struct mWindow : mObject {
   auto setFrameSize(Size size) -> type&;
   auto setFullScreen(bool fullScreen = true) -> type&;
   auto setGeometry(Geometry geometry) -> type&;
+  auto setMaximized(bool maximized = true) -> type&;
+  auto setMaximumSize(Size size = {}) -> type&;
+  auto setMinimized(bool minimized = true) -> type&;
+  auto setMinimumSize(Size size = {}) -> type&;
   auto setModal(bool modal = true) -> type&;
   auto setPosition(Position position) -> type&;
   auto setResizable(bool resizable = true) -> type&;
@@ -734,6 +743,10 @@ struct mWindow : mObject {
     bool fullScreen = false;
     Geometry geometry = {128, 128, 256, 256};
     sLayout layout;
+    bool maximized = false;
+    Size maximumSize;
+    bool minimized = false;
+    Size minimumSize;
     sMenuBar menuBar;
     bool modal = false;
     function<void ()> onClose;

hiro/core/monitor.cpp

@@ -4,16 +4,20 @@ auto Monitor::count() -> uint {
   return pMonitor::count();
 }
 
-auto Monitor::dpi(uint monitor) -> Position {
-  return pMonitor::dpi(monitor);
+auto Monitor::dpi(maybe<uint> monitor) -> Position {
+  return pMonitor::dpi(monitor ? monitor() : primary());
 }
 
-auto Monitor::geometry(uint monitor) -> Geometry {
-  return pMonitor::geometry(monitor);
+auto Monitor::geometry(maybe<uint> monitor) -> Geometry {
+  return pMonitor::geometry(monitor ? monitor() : primary());
 }
 
 auto Monitor::primary() -> uint {
   return pMonitor::primary();
 }
 
+auto Monitor::workspace(maybe<uint> monitor) -> Geometry {
+  return pMonitor::workspace(monitor ? monitor() : primary());
+}
+
 #endif

hiro/core/shared.hpp

@@ -956,7 +956,11 @@ struct Window : sWindow {
   auto fullScreen() const { return self().fullScreen(); }
   auto geometry() const { return self().geometry(); }
   auto layout() const { return self().layout(); }
+  auto maximized() const { return self().maximized(); }
+  auto maximumSize() const { return self().maximumSize(); }
   auto menuBar() const { return self().menuBar(); }
+  auto minimized() const { return self().minimized(); }
+  auto minimumSize() const { return self().minimumSize(); }
   auto modal() const { return self().modal(); }
   auto onClose(const function<void ()>& callback = {}) { return self().onClose(callback), *this; }
   auto onDrop(const function<void (string_vector)>& callback = {}) { return self().onDrop(callback), *this; }
@@ -979,6 +983,10 @@ struct Window : sWindow {
   auto setFrameSize(Size size) { return self().setFrameSize(size), *this; }
   auto setFullScreen(bool fullScreen = true) { return self().setFullScreen(fullScreen), *this; }
   auto setGeometry(Geometry geometry) { return self().setGeometry(geometry), *this; }
+  auto setMaximized(bool maximized) { return self().setMaximized(maximized), *this; }
+  auto setMaximumSize(Size size = {}) { return self().setMaximumSize(size), *this; }
+  auto setMinimized(bool minimized) { return self().setMinimized(minimized), *this; }
+  auto setMinimumSize(Size size = {}) { return self().setMinimumSize(size), *this; }
   auto setModal(bool modal = true) { return self().setModal(modal), *this; }
   auto setPosition(Position position) { return self().setPosition(position), *this; }
   auto setResizable(bool resizable = true) { return self().setResizable(resizable), *this; }

hiro/core/window.cpp

@@ -95,10 +95,26 @@ auto mWindow::layout() const -> Layout {
   return state.layout;
 }
 
+auto mWindow::maximized() const -> bool {
+  return state.maximized;
+}
+
+auto mWindow::maximumSize() const -> Size {
+  return state.maximumSize;
+}
+
 auto mWindow::menuBar() const -> MenuBar {
   return state.menuBar;
 }
 
+auto mWindow::minimized() const -> bool {
+  return state.minimized;
+}
+
+auto mWindow::minimumSize() const -> Size {
+  return state.minimumSize;
+}
+
 auto mWindow::modal() const -> bool {
   return state.modal;
 }
@@ -245,6 +261,30 @@ auto mWindow::setGeometry(Geometry geometry) -> type& {
   return *this;
 }
 
+auto mWindow::setMaximized(bool maximized) -> type& {
+  state.maximized = maximized;
+  signal(setMaximized, maximized);
+  return *this;
+}
+
+auto mWindow::setMaximumSize(Size size) -> type& {
+  state.maximumSize = size;
+  signal(setMaximumSize, size);
+  return *this;
+}
+
+auto mWindow::setMinimized(bool minimized) -> type& {
+  state.minimized = minimized;
+  signal(setMinimized, minimized);
+  return *this;
+}
+
+auto mWindow::setMinimumSize(Size size) -> type& {
+  state.minimumSize = size;
+  signal(setMinimumSize, size);
+  return *this;
+}
+
 auto mWindow::setModal(bool modal) -> type& {
   state.modal = modal;
   signal(setModal, modal);

hiro/gtk/desktop.cpp

@@ -45,6 +45,8 @@ auto pDesktop::workspace() -> Geometry {
     gdk_screen_get_height(gdk_screen_get_default())
   };
   #endif
+
+  return {};
 }
 
 }

hiro/gtk/monitor.cpp

@@ -1,25 +1,61 @@
 #if defined(Hiro_Monitor)
 
+//GTK 3.22 adds new monitor functions
+//using GTK 2.x functions as FreeBSD 10.1 uses GTK 3.8
+
 namespace hiro {
 
 auto pMonitor::count() -> uint {
+  #if HIRO_GTK==2 || 1
   return gdk_screen_get_n_monitors(gdk_screen_get_default());
+  #elif HIRO_GTK==3
+  return gdk_display_get_n_monitors(gdk_display_get_default());
+  #endif
 }
 
 auto pMonitor::dpi(uint monitor) -> Position {
-  //GTK+ does not support either per-monitor or per-axis DPI reporting
+  #if HIRO_GTK==2 || 1
+  //GTK2 does not support either per-monitor or per-axis DPI reporting
   float dpi = round(gdk_screen_get_resolution(gdk_screen_get_default()));
   return {dpi, dpi};
+  #elif HIRO_GTK==3
+  auto gdkMonitor = gdk_display_get_monitor(gdk_display_get_default(), monitor);
+  return {
+    round(gdk_monitor_get_width(gdkMonitor) / (gdk_monitor_get_width_mm(gdkMonitor) / 25.4)),
+    round(gdk_monitor_get_height(gdkMonitor) / (gdk_monitor_get_height_mm(gdkMonitor) / 25.4))
+  };
+  #endif
 }
 
 auto pMonitor::geometry(uint monitor) -> Geometry {
-  GdkRectangle rectangle = {0};
+  GdkRectangle rectangle = {};
+  #if HIRO_GTK==2 || 1
   gdk_screen_get_monitor_geometry(gdk_screen_get_default(), monitor, &rectangle);
+  #elif HIRO_GTK==3
+  auto gdkMonitor = gdk_display_get_monitor(gdk_display_get_default(), monitor);
+  gdk_monitor_get_geometry(monitor, &rectangle);
+  #endif
   return {rectangle.x, rectangle.y, rectangle.width, rectangle.height};
 }
 
 auto pMonitor::primary() -> uint {
+  #if HIRO_GTK==2 || 1
   return gdk_screen_get_primary_monitor(gdk_screen_get_default());
+  #elif HIRO_GTK==3
+  return gdk_display_get_primary_monitor(gdk_display_get_default());
+  #endif
+}
+
+auto pMonitor::workspace(uint monitor) -> Geometry {
+  #if HIRO_GTK==2 || 1
+  //todo: can this be done on a per-monitor basis with raw Xlib / Win32 APIs?
+  return pDesktop::workspace();
+  #elif HIRO_GTK==3
+  auto gdkMonitor = gdk_display_get_monitor(gdk_display_get_default(), monitor);
+  GdkRectangle rectangle = {};
+  gdk_monitor_get_workarea(monitor, &rectangle);
+  return {rectangle.x, rectangle.y, rectangle.width, rectangle.height};
+  #endif
 }
 
 }

hiro/gtk/monitor.hpp

@@ -7,6 +7,7 @@ struct pMonitor {
   static auto dpi(uint monitor) -> Position;
   static auto geometry(uint monitor) -> Geometry;
   static auto primary() -> uint;
+  static auto workspace(uint monitor) -> Geometry;
 };
 
 }

hiro/gtk/object.hpp

@@ -18,10 +18,18 @@ struct pObject {
   virtual auto setFont(const Font& font) -> void;
   virtual auto setVisible(bool visible) -> void;
 
-  auto locked() const -> bool { return locks != 0 || Application::state.quit; }
+  auto locked() const -> bool { return locks || Application::state.quit; }
   auto lock() -> void { ++locks; }
   auto unlock() -> void { --locks; }
 
+  struct Lock {
+    Lock(pObject& self) : self(self) { self.locks++; }
+    ~Lock() { self.locks--; }
+
+    pObject& self;
+  };
+  auto acquire() -> Lock { return {*this}; }
+
   mObject& reference;
   signed locks = 0;
 };

hiro/gtk/widget/horizontal-scroll-bar.cpp

@@ -33,11 +33,10 @@ auto pHorizontalScrollBar::minimumSize() const -> Size {
 }
 
 auto pHorizontalScrollBar::setLength(unsigned length) -> void {
-  lock();
+  auto lock = acquire();
   length += length == 0;
   gtk_range_set_range(GTK_RANGE(gtkWidget), 0, max(1u, length - 1));
   gtk_range_set_increments(GTK_RANGE(gtkWidget), 1, length >> 3);
-  unlock();
 }
 
 auto pHorizontalScrollBar::setPosition(unsigned position) -> void {

hiro/gtk/widget/vertical-scroll-bar.cpp

@@ -33,11 +33,10 @@ auto pVerticalScrollBar::minimumSize() const -> Size {
 }
 
 auto pVerticalScrollBar::setLength(unsigned length) -> void {
-  lock();
+  auto lock = acquire();
   length += length == 0;
   gtk_range_set_range(GTK_RANGE(gtkWidget), 0, max(1u, length - 1));
   gtk_range_set_increments(GTK_RANGE(gtkWidget), 1, length >> 3);
-  unlock();
 }
 
 auto pVerticalScrollBar::setPosition(unsigned position) -> void {

hiro/gtk/window.cpp

@@ -128,6 +128,10 @@ static auto Window_keyRelease(GtkWidget* widget, GdkEventKey* event, pWindow* p)
 }
 
 static auto Window_sizeAllocate(GtkWidget* widget, GtkAllocation* allocation, pWindow* p) -> void {
+  //size-allocate is sent before window-state-event when maximizing a window
+  //this means Window::onSize() handler would have the old maximized state if we used the latter signal
+  p->_synchronizeState();
+
   //size-allocate sent from gtk_fixed_move(); detect if layout unchanged and return
   if(allocation->width == p->lastAllocation.width
   && allocation->height == p->lastAllocation.height) return;
@@ -153,6 +157,20 @@ static auto Window_sizeRequest(GtkWidget* widget, GtkRequisition* requisition, p
   requisition->height = p->state().geometry.height();
 }
 
+static auto Window_stateEvent(GtkWidget* widget, GdkEvent* event, pWindow* p) -> void {
+  p->_synchronizeState();
+
+/*if(event->type == GDK_WINDOW_STATE) {
+    auto windowStateEvent = (GdkEventWindowState*)event;
+    if(windowStateEvent->changed_mask & GDK_WINDOW_STATE_MAXIMIZED) {
+      p->state().maximized = windowStateEvent->new_window_state & GDK_WINDOW_STATE_MAXIMIZED;
+    }
+    if(windowStateEvent->changed_mask & GDK_WINDOW_STATE_ICONIFIED) {
+      p->state().minimized = windowStateEvent->new_window_state & GDK_WINDOW_STATE_ICONIFIED;
+    }
+  }*/
+}
+
 auto pWindow::construct() -> void {
   lastAllocation.width  = 0;
   lastAllocation.height = 0;
@@ -204,6 +222,8 @@ auto pWindow::construct() -> void {
   setDroppable(state().droppable);
   setGeometry(state().geometry);
   setResizable(state().resizable);
+  setMaximized(state().maximized);
+  setMinimized(state().minimized);
   setTitle(state().title);
 
   g_signal_connect(G_OBJECT(widget), "delete-event", G_CALLBACK(Window_close), (gpointer)this);
@@ -224,6 +244,7 @@ auto pWindow::construct() -> void {
   widgetClass->get_preferred_width = Window_getPreferredWidth;
   widgetClass->get_preferred_height = Window_getPreferredHeight;
   #endif
+  g_signal_connect(G_OBJECT(widget), "window-state-event", G_CALLBACK(Window_stateEvent), (gpointer)this);
 }
 
 auto pWindow::destruct() -> void {
@@ -323,10 +344,8 @@ auto pWindow::setGeometry(Geometry geometry) -> void {
   Geometry margin = frameMargin();
   gtk_window_move(GTK_WINDOW(widget), geometry.x() - margin.x(), geometry.y() - margin.y());
 
-  GdkGeometry geom;
-  geom.min_width  = state().resizable ? 1 : state().geometry.width();
-  geom.min_height = state().resizable ? 1 : state().geometry.height();
-  gtk_window_set_geometry_hints(GTK_WINDOW(widget), GTK_WIDGET(widget), &geom, GDK_HINT_MIN_SIZE);
+  setMaximumSize(state().maximumSize);
+  setMinimumSize(state().minimumSize);
 
   gtk_widget_set_size_request(formContainer, geometry.width(), geometry.height());
   auto time1 = chrono::millisecond();
@@ -337,6 +356,42 @@ auto pWindow::setGeometry(Geometry geometry) -> void {
   while(chrono::millisecond() - time2 < 20) gtk_main_iteration_do(false);
 }
 
+auto pWindow::setMaximized(bool maximized) -> void {
+  auto lock = acquire();
+  if(maximized) {
+    gtk_window_maximize(GTK_WINDOW(widget));
+  } else {
+    gtk_window_unmaximize(GTK_WINDOW(widget));
+  }
+}
+
+auto pWindow::setMaximumSize(Size size) -> void {
+  if(size.height()) size.setHeight(size.height() + _menuHeight() + _statusHeight());
+
+  GdkGeometry geometry;
+  geometry.max_width  = !state().resizable ? state().geometry.width()  : size.width()  ? size.width()  : 32767;
+  geometry.max_height = !state().resizable ? state().geometry.height() : size.height() ? size.height() : 32767;
+  gtk_window_set_geometry_hints(GTK_WINDOW(widget), nullptr, &geometry, GDK_HINT_MAX_SIZE);
+}
+
+auto pWindow::setMinimized(bool minimized) -> void {
+  auto lock = acquire();
+  if(minimized) {
+    gtk_window_iconify(GTK_WINDOW(widget));
+  } else {
+    gtk_window_deiconify(GTK_WINDOW(widget));
+  }
+}
+
+auto pWindow::setMinimumSize(Size size) -> void {
+  if(size.height()) size.setHeight(size.height() + _menuHeight() + _statusHeight());
+
+  GdkGeometry geometry;
+  geometry.min_width  = !state().resizable ? state().geometry.width()  : size.width()  ? size.width()  : 1;
+  geometry.min_height = !state().resizable ? state().geometry.height() : size.height() ? size.height() : 1;
+  gtk_window_set_geometry_hints(GTK_WINDOW(widget), nullptr, &geometry, GDK_HINT_MIN_SIZE);
+}
+
 auto pWindow::setModal(bool modal) -> void {
   if(modal) {
     gtk_window_set_modal(GTK_WINDOW(widget), true);
@@ -479,6 +534,69 @@ auto pWindow::_statusHeight() const -> signed {
   return gtk_widget_get_visible(gtkStatus) ? settings.geometry.statusHeight : 0;
 }
 
+//GTK doesn't add gtk_window_is_maximized() until 3.12;
+//and doesn't appear to have a companion gtk_window_is_(hidden,iconic,minimized);
+//so we have to do this the hard way
+auto pWindow::_synchronizeState() -> void {
+  if(!gtk_widget_get_realized(widget)) return;
+
+  #if defined(DISPLAY_WINDOWS)
+  auto window = GDK_WINDOW_HWND(gtk_widget_get_window(widget));
+
+  bool maximized = IsZoomed(window);
+  bool minimized = IsIconic(window);
+
+  bool doSize = false;
+  if(state().minimized != minimized) doSize = true;
+
+  state().maximized = maximized;
+  state().minimized = minimized;
+
+  if(doSize) self().doSize();
+  #endif
+
+  #if defined(DISPLAY_XORG)
+  auto display = XOpenDisplay(nullptr);
+  int screen = DefaultScreen(display);
+  auto window = GDK_WINDOW_XID(gtk_widget_get_window(widget));
+  XlibAtom wmState = XInternAtom(display, "_NET_WM_STATE", XlibTrue);
+  XlibAtom atom;
+  int format;
+  unsigned long items, after;
+  unsigned char* data = nullptr;
+  int result = XGetWindowProperty(
+    display, window, wmState, 0, LONG_MAX, XlibFalse, AnyPropertyType, &atom, &format, &items, &after, &data
+  );
+  auto atoms = (unsigned long*)data;
+  if(result == Success) {
+    bool maximizedHorizontal = false;
+    bool maximizedVertical = false;
+    bool minimized = false;
+
+    for(auto index : range(items)) {
+      auto memory = XGetAtomName(display, atoms[index]);
+      auto name = string{memory};
+      if(name == "_NET_WM_STATE_MAXIMIZED_HORZ") maximizedHorizontal = true;
+      if(name == "_NET_WM_STATE_MAXIMIZED_VERT") maximizedVertical = true;
+      if(name == "_NET_WM_STATE_HIDDEN") minimized = true;
+      XFree(memory);
+    }
+
+    bool doSize = false;
+    //maximize sends size-allocate, which triggers doSize()
+    if(state().minimized != minimized) doSize = true;
+
+    //windows do not act bizarrely when maximized in only one direction
+    //so for this reason, consider a window maximized only if it's in both directions
+    state().maximized = maximizedHorizontal && maximizedVertical;
+    state().minimized = minimized;
+
+    if(doSize) self().doSize();
+  }
+  XCloseDisplay(display);
+  #endif
+}
+
 }
 
 #endif

hiro/gtk/window.hpp

@@ -20,6 +20,10 @@ struct pWindow : pObject {
   auto setFocused() -> void override;
   auto setFullScreen(bool fullScreen) -> void;
   auto setGeometry(Geometry geometry) -> void;
+  auto setMaximized(bool maximized) -> void;
+  auto setMaximumSize(Size size) -> void;
+  auto setMinimized(bool minimized) -> void;
+  auto setMinimumSize(Size size) -> void;
   auto setModal(bool modal) -> void;
   auto setResizable(bool resizable) -> void;
   auto setTitle(const string& title) -> void;
@@ -37,6 +41,7 @@ struct pWindow : pObject {
   auto _setStatusText(const string& text) -> void;
   auto _setStatusVisible(bool visible) -> void;
   auto _statusHeight() const -> signed;
+  auto _synchronizeState() -> void;
 
   GtkWidget* widget = nullptr;
   GtkWidget* menuContainer = nullptr;

hiro/qt/window.cpp

@@ -154,6 +154,22 @@ auto pWindow::setGeometry(Geometry geometry) -> void {
   unlock();
 }
 
+auto pWindow::setMaximized(bool maximized) -> void {
+  //todo
+}
+
+auto pWindow::setMaximumSize(Size size) -> void {
+  //todo
+}
+
+auto pWindow::setMinimized(bool minimized) -> void {
+  //todo
+}
+
+auto pWindow::setMinimumSize(Size size) -> void {
+  //todo
+}
+
 auto pWindow::setModal(bool modal) -> void {
   if(modal) {
     //windowModality can only be enabled while window is invisible

hiro/qt/window.hpp

@@ -20,6 +20,10 @@ struct pWindow : pObject {
   auto setFocused() -> void override;
   auto setFullScreen(bool fullScreen) -> void;
   auto setGeometry(Geometry geometry) -> void;
+  auto setMaximized(bool maximized) -> void;
+  auto setMaximumSize(Size size) -> void;
+  auto setMinimized(bool minimized) -> void;
+  auto setMinimumSize(Size size) -> void;
   auto setModal(bool modal) -> void;
   auto setResizable(bool resizable) -> void;
   auto setTitle(const string& text) -> void;

hiro/windows/utility.cpp

@@ -339,24 +339,17 @@ static auto CALLBACK Shared_windowProc(WindowProc windowProc, HWND hwnd, UINT ms
     break;
   }
 
-  #if defined(Hiro_TableView)
-  case AppMessage::TableView_doPaint: {
-    if(auto tableView = (mTableView*)lparam) {
-      if(auto self = tableView->self()) InvalidateRect(self->hwnd, nullptr, true);
-    }
+  case WM_SIZE: {
+    bool maximized = IsZoomed(pWindow->hwnd);
+    bool minimized = IsIconic(pWindow->hwnd);
+
+    window->state.maximized = maximized;
+    window->state.minimized = minimized;
+
+    //todo: call Window::doSize() ?
     break;
   }
 
-  case AppMessage::TableView_onActivate: {
-    if(auto tableView = (mTableView*)lparam) tableView->doActivate();
-    break;
-  }
-
-  case AppMessage::TableView_onChange: {
-    if(auto tableView = (mTableView*)lparam) tableView->doChange();
-  }
-  #endif
-
   case WM_HSCROLL:
   case WM_VSCROLL: {
     if(!lparam) break;
@@ -389,6 +382,24 @@ static auto CALLBACK Shared_windowProc(WindowProc windowProc, HWND hwnd, UINT ms
 
     break;
   }
+
+  #if defined(Hiro_TableView)
+  case AppMessage::TableView_doPaint: {
+    if(auto tableView = (mTableView*)lparam) {
+      if(auto self = tableView->self()) InvalidateRect(self->hwnd, nullptr, true);
+    }
+    break;
+  }
+
+  case AppMessage::TableView_onActivate: {
+    if(auto tableView = (mTableView*)lparam) tableView->doActivate();
+    break;
+  }
+
+  case AppMessage::TableView_onChange: {
+    if(auto tableView = (mTableView*)lparam) tableView->doChange();
+  }
+  #endif
   }
 
   return windowProc(hwnd, msg, wparam, lparam);

hiro/windows/window.cpp

@@ -136,6 +136,27 @@ auto pWindow::setGeometry(Geometry geometry) -> void {
   unlock();
 }
 
+auto pWindow::setMaximized(bool maximized) -> void {
+  if(state().minimized) return;
+  lock();
+  ShowWindow(hwnd, maximized ? SW_MAXIMIZED : SW_SHOWNOACTIVATE);
+  unlock();
+}
+
+auto pWindow::setMaximumSize(Size size) -> void {
+  //todo
+}
+
+auto pWindow::setMinimized(bool minimized) -> void {
+  lock();
+  ShowWindow(hwnd, minimized ? SW_MINIMIZED : state().maximized ? SW_MAXIMIZED : SW_SHOWNOACTIVATE);
+  unlock();
+}
+
+auto pWindow::setMinimumSize(Size size) -> void {
+  //todo
+}
+
 auto pWindow::setModal(bool modality) -> void {
   if(modality) {
     _modalityUpdate();

hiro/windows/window.hpp

@@ -21,6 +21,10 @@ struct pWindow : pObject {
   auto setFont(const Font& font) -> void override;
   auto setFullScreen(bool fullScreen) -> void;
   auto setGeometry(Geometry geometry) -> void;
+  auto setMaximized(bool maximized) -> void;
+  auto setMaximumSize(Size size) -> void;
+  auto setMinimized(bool minimized) -> void;
+  auto setMinimumSize(Size size) -> void;
   auto setModal(bool modal) -> void;
   auto setResizable(bool resizable) -> void;
   auto setTitle(string text) -> void;