Update to v094r40 release.

byuu says:

Changelog:
- updated to newest hiro API
- SFC performance profile builds once again
- hiro: Qt port completed

Errata 1: the hiro/Qt target won't run tomoko just yet. Starts by
crashing inside InputSettings because hiro/Qt isn't forcefully selecting
the first item added to a ComboButton just yet. Even with a monkey patch
to get around that, the UI is incredibly unstable. Lots of geometry
calculation bugs, and a crash when you try and access certain folders in
the browser dialog. Lots of work left to be done there, sadly.

Errata 2: the hiro/Windows port has black backgrounds on all ListView
items. It's because I need to test for unassigned colors and grab the
default Windows brush colors in those cases.

Note: alternating row colors on multi-column ListView widgets is gone
now. Not a bug. May add it back later, but I'm not sure. It doesn't
interact nicely with per-cell background colors.

Things left to do:

First, I have to fix the Windows and Qt target bugs.

Next, I need to go through and revise the hiro API even more (nothing
too major.)

Next, I need to update icarus to use the new hiro API, and add support
for the SFC games database.

Next, I have to rewrite my TSV->BML cheat code tool.

Next, I need to post a final WIP of higan+icarus publicly and wait a few
days.

Next, I need to fix any bugs reported from the final WIP that I can.

Finally, I should be able to release v095.

hiro/qt/action/action.cpp

@@ -1,6 +1,15 @@
-namespace phoenix {
+#if defined(Hiro_Action)
 
-void pAction::setEnabled(bool enabled) {
+namespace hiro {
+
+auto pAction::construct() -> void {
+}
+
+auto pAction::destruct() -> void {
+}
+
+auto pAction::setEnabled(bool enabled) -> void {
+/*
   if(dynamic_cast<Menu*>(&action)) {
     ((Menu&)action).p.qtMenu->setEnabled(enabled);
   } else if(dynamic_cast<Separator*>(&action)) {
@@ -12,9 +21,11 @@ void pAction::setEnabled(bool enabled) {
   } else if(dynamic_cast<RadioItem*>(&action)) {
     ((RadioItem&)action).p.qtAction->setEnabled(enabled);
   }
+*/
 }
 
-void pAction::setFont(string font) {
+auto pAction::setFont(const string& font) -> void {
+/*
   QFont qtFont = pFont::create(font);
 
   if(dynamic_cast<Menu*>(&action)) {
@@ -28,9 +39,11 @@ void pAction::setFont(string font) {
   } else if(dynamic_cast<RadioItem*>(&action)) {
     ((RadioItem&)action).p.qtAction->setFont(qtFont);
   }
+*/
 }
 
-void pAction::setVisible(bool visible) {
+auto pAction::setVisible(bool visible) -> void {
+/*
   if(dynamic_cast<Menu*>(&action)) {
     ((Menu&)action).p.qtMenu->menuAction()->setVisible(visible);
   } else if(dynamic_cast<Separator*>(&action)) {
@@ -42,12 +55,33 @@ void pAction::setVisible(bool visible) {
   } else if(dynamic_cast<RadioItem*>(&action)) {
     ((RadioItem&)action).p.qtAction->setVisible(visible);
   }
+*/
 }
 
-void pAction::constructor() {
+auto pAction::_parentMenu() -> maybe<pMenu&> {
+  if(auto parent = self().parentMenu()) {
+    if(auto self = parent->self()) return *self;
+  }
+  return nothing;
 }
 
-void pAction::destructor() {
+auto pAction::_parentMenuBar() -> maybe<pMenuBar&> {
+  if(auto parent = self().parentMenuBar()) {
+    if(auto self = parent->self()) return *self;
+  }
+  return nothing;
+}
+
+auto pAction::_parentPopupMenu() -> maybe<pPopupMenu&> {
+  if(auto parent = self().parentPopupMenu()) {
+    if(auto self = parent->self()) return *self;
+  }
+  return nothing;
+}
+
+auto pAction::_setState() -> void {
 }
 
 }
+
+#endif

hiro/qt/action/action.hpp

@@ -0,0 +1,20 @@
+#if defined(Hiro_Action)
+
+namespace hiro {
+
+struct pAction : pObject {
+  Declare(Action, Object)
+
+  auto setEnabled(bool enabled) -> void override;
+  auto setFont(const string& font) -> void override;
+  auto setVisible(bool visible) -> void override;
+
+  auto _parentMenu() -> maybe<pMenu&>;
+  auto _parentMenuBar() -> maybe<pMenuBar&>;
+  auto _parentPopupMenu() -> maybe<pPopupMenu&>;
+  virtual auto _setState() -> void;
+};
+
+}
+
+#endif

hiro/qt/action/check-item.cpp

@@ -1,28 +0,0 @@
-namespace phoenix {
-
-void pCheckItem::setChecked(bool checked) {
-  qtAction->setChecked(checked);
-}
-
-void pCheckItem::setText(string text) {
-  qtAction->setText(QString::fromUtf8(text));
-}
-
-void pCheckItem::constructor() {
-  qtAction = new QAction(0);
-  qtAction->setCheckable(true);
-  connect(qtAction, SIGNAL(triggered()), SLOT(onToggle()));
-}
-
-void pCheckItem::destructor() {
-  if(action.state.menu) action.state.menu->remove(checkItem);
-  delete qtAction;
-  qtAction = nullptr;
-}
-
-void pCheckItem::onToggle() {
-  checkItem.state.checked = qtAction->isChecked();
-  if(checkItem.onToggle) checkItem.onToggle();
-}
-
-}

hiro/qt/action/item.cpp

@@ -1,26 +0,0 @@
-namespace phoenix {
-
-void pItem::setImage(const image& image) {
-  qtAction->setIcon(CreateIcon(image));
-}
-
-void pItem::setText(string text) {
-  qtAction->setText(QString::fromUtf8(text));
-}
-
-void pItem::constructor() {
-  qtAction = new QAction(0);
-  connect(qtAction, SIGNAL(triggered()), SLOT(onActivate()));
-}
-
-void pItem::destructor() {
-  if(action.state.menu) action.state.menu->remove(item);
-  delete qtAction;
-  qtAction = nullptr;
-}
-
-void pItem::onActivate() {
-  if(item.onActivate) item.onActivate();
-}
-
-}

hiro/qt/action/menu-check-item.cpp

@@ -0,0 +1,46 @@
+#if defined(Hiro_MenuCheckItem)
+
+namespace hiro {
+
+auto pMenuCheckItem::construct() -> void {
+  qtMenuCheckItem = new QtMenuCheckItem(*this);
+  qtMenuCheckItem->setCheckable(true);
+  qtMenuCheckItem->connect(qtMenuCheckItem, SIGNAL(triggered()), SLOT(onToggle()));
+
+  if(auto parent = _parentMenu()) {
+    parent->qtMenu->addAction(qtMenuCheckItem);
+  }
+
+  if(auto parent = _parentPopupMenu()) {
+    parent->qtPopupMenu->addAction(qtMenuCheckItem);
+  }
+
+  _setState();
+}
+
+auto pMenuCheckItem::destruct() -> void {
+  delete qtMenuCheckItem;
+  qtMenuCheckItem = nullptr;
+}
+
+auto pMenuCheckItem::setChecked(bool checked) -> void {
+  _setState();
+}
+
+auto pMenuCheckItem::setText(const string& text) -> void {
+  _setState();
+}
+
+auto pMenuCheckItem::_setState() -> void {
+  qtMenuCheckItem->setChecked(state().checked);
+  qtMenuCheckItem->setText(QString::fromUtf8(state().text));
+}
+
+auto QtMenuCheckItem::onToggle() -> void {
+  p.state().checked = isChecked();
+  p.self().doToggle();
+}
+
+}
+
+#endif

hiro/qt/action/menu-check-item.hpp

@@ -0,0 +1,18 @@
+#if defined(Hiro_MenuCheckItem)
+
+namespace hiro {
+
+struct pMenuCheckItem : pAction {
+  Declare(MenuCheckItem, Action)
+
+  auto setChecked(bool checked) -> void;
+  auto setText(const string& text) -> void;
+
+  auto _setState() -> void override;
+
+  QtMenuCheckItem* qtMenuCheckItem = nullptr;
+};
+
+}
+
+#endif

hiro/qt/action/menu-item.cpp

@@ -0,0 +1,44 @@
+#if defined(Hiro_MenuItem)
+
+namespace hiro {
+
+auto pMenuItem::construct() -> void {
+  qtMenuItem = new QtMenuItem(*this);
+  qtMenuItem->connect(qtMenuItem, SIGNAL(triggered()), SLOT(onActivate()));
+
+  if(auto parent = _parentMenu()) {
+    parent->qtMenu->addAction(qtMenuItem);
+  }
+
+  if(auto parent = _parentPopupMenu()) {
+    parent->qtPopupMenu->addAction(qtMenuItem);
+  }
+
+  _setState();
+}
+
+auto pMenuItem::destruct() -> void {
+  delete qtMenuItem;
+  qtMenuItem = nullptr;
+}
+
+auto pMenuItem::setIcon(const image& icon) -> void {
+  _setState();
+}
+
+auto pMenuItem::setText(const string& text) -> void {
+  _setState();
+}
+
+auto pMenuItem::_setState() -> void {
+  qtMenuItem->setIcon(CreateIcon(state().icon));
+  qtMenuItem->setText(state().text);
+}
+
+auto QtMenuItem::onActivate() -> void {
+  p.self().doActivate();
+}
+
+}
+
+#endif

hiro/qt/action/menu-item.hpp

@@ -0,0 +1,18 @@
+#if defined(Hiro_MenuItem)
+
+namespace hiro {
+
+struct pMenuItem : pAction {
+  Declare(MenuItem, Action)
+
+  auto setIcon(const image& icon) -> void;
+  auto setText(const string& text) -> void;
+
+  auto _setState() -> void override;
+
+  QtMenuItem* qtMenuItem = nullptr;
+};
+
+}
+
+#endif

hiro/qt/action/menu-radio-item.cpp

@@ -0,0 +1,65 @@
+#if defined(Hiro_MenuRadioItem)
+
+namespace hiro {
+
+auto pMenuRadioItem::construct() -> void {
+  qtMenuRadioItem = new QtMenuRadioItem(*this);
+  qtActionGroup = new QActionGroup(nullptr);
+  qtMenuRadioItem->setCheckable(true);
+  qtMenuRadioItem->setActionGroup(qtActionGroup);
+  qtMenuRadioItem->setChecked(true);
+  qtMenuRadioItem->connect(qtMenuRadioItem, SIGNAL(triggered()), SLOT(onActivate()));
+
+  if(auto parent = _parentMenu()) {
+    parent->qtMenu->addAction(qtMenuRadioItem);
+  }
+
+  if(auto parent = _parentPopupMenu()) {
+    parent->qtPopupMenu->addAction(qtMenuRadioItem);
+  }
+
+  _setState();
+}
+
+auto pMenuRadioItem::destruct() -> void {
+  delete qtMenuRadioItem;
+  delete qtActionGroup;
+  qtMenuRadioItem = nullptr;
+  qtActionGroup = nullptr;
+}
+
+auto pMenuRadioItem::setChecked() -> void {
+  _setState();
+}
+
+auto pMenuRadioItem::setGroup(sGroup group) -> void {
+  _setState();
+}
+
+auto pMenuRadioItem::setText(const string& text) -> void {
+  _setState();
+}
+
+auto pMenuRadioItem::_setState() -> void {
+  if(auto group = state().group) {
+    if(auto object = group->object(0)) {
+      if(auto menuRadioItem = dynamic_cast<mMenuRadioItem*>(object.data())) {
+        if(auto self = menuRadioItem->self()) {
+          qtMenuRadioItem->setActionGroup(self->qtActionGroup);
+        }
+      }
+    }
+  }
+  qtMenuRadioItem->setChecked(state().checked);
+  qtMenuRadioItem->setText(QString::fromUtf8(state().text));
+}
+
+auto QtMenuRadioItem::onActivate() -> void {
+  if(p.state().checked) return;
+  p.state().checked = true;
+  p.self().doActivate();
+}
+
+}
+
+#endif

hiro/qt/action/menu-radio-item.hpp

@@ -0,0 +1,20 @@
+#if defined(Hiro_MenuRadioItem)
+
+namespace hiro {
+
+struct pMenuRadioItem : pAction {
+  Declare(MenuRadioItem, Action)
+
+  auto setChecked() -> void;
+  auto setGroup(sGroup group) -> void;
+  auto setText(const string& text) -> void;
+
+  auto _setState() -> void override;
+
+  QtMenuRadioItem* qtMenuRadioItem = nullptr;
+  QActionGroup* qtActionGroup = nullptr;
+};
+
+}
+
+#endif

hiro/qt/action/menu-separator.cpp

@@ -0,0 +1,25 @@
+#if defined(Hiro_MenuSeparator)
+
+namespace hiro {
+
+auto pMenuSeparator::construct() -> void {
+  qtMenuSeparator = new QAction(nullptr);
+  qtMenuSeparator->setSeparator(true);
+
+  if(auto parent = _parentMenu()) {
+    parent->qtMenu->addAction(qtMenuSeparator);
+  }
+
+  if(auto parent = _parentPopupMenu()) {
+    parent->qtPopupMenu->addAction(qtMenuSeparator);
+  }
+}
+
+auto pMenuSeparator::destruct() -> void {
+  delete qtMenuSeparator;
+  qtMenuSeparator = nullptr;
+}
+
+}
+
+#endif

hiro/qt/action/menu-separator.hpp

@@ -0,0 +1,13 @@
+#if defined(Hiro_MenuSeparator)
+
+namespace hiro {
+
+struct pMenuSeparator : pAction {
+  Declare(MenuSeparator, Action)
+
+  QAction* qtMenuSeparator = nullptr;
+};
+
+}
+
+#endif

hiro/qt/action/menu.cpp

@@ -1,56 +1,60 @@
-namespace phoenix {
+#if defined(Hiro_Menu)
 
-void pMenu::append(Action& action) {
-  if(dynamic_cast<Menu*>(&action)) {
-    qtMenu->addMenu(((Menu&)action).p.qtMenu);
-  } else if(dynamic_cast<Separator*>(&action)) {
-    qtMenu->addAction(((Separator&)action).p.qtAction);
-  } else if(dynamic_cast<Item*>(&action)) {
-    qtMenu->addAction(((Item&)action).p.qtAction);
-  } else if(dynamic_cast<CheckItem*>(&action)) {
-    qtMenu->addAction(((CheckItem&)action).p.qtAction);
-  } else if(dynamic_cast<RadioItem*>(&action)) {
-    qtMenu->addAction(((RadioItem&)action).p.qtAction);
-  }
-}
+namespace hiro {
 
-void pMenu::remove(Action& action) {
-  if(dynamic_cast<Menu*>(&action)) {
-    //QMenu::removeMenu() does not exist
-    qtMenu->clear();
-    for(auto& action : menu.state.action) append(action);
-  } else if(dynamic_cast<Separator*>(&action)) {
-    qtMenu->removeAction(((Separator&)action).p.qtAction);
-  } else if(dynamic_cast<Item*>(&action)) {
-    qtMenu->removeAction(((Item&)action).p.qtAction);
-  } else if(dynamic_cast<CheckItem*>(&action)) {
-    qtMenu->removeAction(((CheckItem&)action).p.qtAction);
-  } else if(dynamic_cast<RadioItem*>(&action)) {
-    qtMenu->removeAction(((CheckItem&)action).p.qtAction);
-  }
-}
-
-void pMenu::setFont(string font) {
-  qtMenu->setFont(pFont::create(font));
-  for(auto &item : menu.state.action) item.p.setFont(font);
-}
-
-void pMenu::setImage(const image& image) {
-  qtMenu->setIcon(CreateIcon(image));
-}
-
-void pMenu::setText(string text) {
-  qtMenu->setTitle(QString::fromUtf8(text));
-}
-
-void pMenu::constructor() {
+auto pMenu::construct() -> void {
   qtMenu = new QMenu;
+
+  if(auto parent = _parentMenu()) {
+    parent->qtMenu->addMenu(qtMenu);
+  }
+
+  if(auto parent = _parentMenuBar()) {
+    if(auto window = parent->_parent()) {
+      window->qtMenuBar->addMenu(qtMenu);
+    }
+  }
+
+  if(auto parent = _parentPopupMenu()) {
+    parent->qtPopupMenu->addMenu(qtMenu);
+  }
+
+  _setState();
 }
 
-void pMenu::destructor() {
-  if(action.state.menu) action.state.menu->remove(menu);
+auto pMenu::destruct() -> void {
   delete qtMenu;
   qtMenu = nullptr;
 }
 
+auto pMenu::append(sAction action) -> void {
 }
+
+auto pMenu::remove(sAction action) -> void {
+}
+
+auto pMenu::setFont(const string& font) -> void {
+  _setState();
+}
+
+auto pMenu::setIcon(const image& icon) -> void {
+  _setState();
+}
+
+auto pMenu::setText(const string& text) -> void {
+  _setState();
+}
+
+auto pMenu::_setState() -> void {
+  qtMenu->setFont(pFont::create(self().font(true)));
+  qtMenu->setIcon(CreateIcon(state().icon));
+  qtMenu->setTitle(QString::fromUtf8(state().text));
+
+  for(auto& action : state().actions) {
+    if(auto self = action->self()) self->setFont(action->font(true));
+  }
+}
+
+}
+
+#endif

hiro/qt/action/menu.hpp

@@ -0,0 +1,21 @@
+#if defined(Hiro_Menu)
+
+namespace hiro {
+
+struct pMenu : public pAction {
+  Declare(Menu, Action)
+
+  auto append(sAction action) -> void;
+  auto remove(sAction action) -> void;
+  auto setFont(const string& font) -> void override;
+  auto setIcon(const image& icon) -> void;
+  auto setText(const string& text) -> void;
+
+  auto _setState() -> void override;
+
+  QMenu* qtMenu = nullptr;
+};
+
+}
+
+#endif

hiro/qt/action/radio-item.cpp

@@ -1,42 +0,0 @@
-namespace phoenix {
-
-void pRadioItem::setChecked() {
-  lock();
-  for(auto& item : radioItem.state.group) {
-    bool checkState = item.p.qtAction == qtAction;
-    item.state.checked = checkState;
-    item.p.qtAction->setChecked(checkState);
-  }
-  unlock();
-}
-
-void pRadioItem::setGroup(const group<RadioItem>& group) {
-}
-
-void pRadioItem::setText(string text) {
-  qtAction->setText(QString::fromUtf8(text));
-}
-
-void pRadioItem::constructor() {
-  qtAction = new QAction(0);
-  qtGroup = new QActionGroup(0);
-  qtAction->setCheckable(true);
-  qtAction->setActionGroup(qtGroup);
-  qtAction->setChecked(true);
-  connect(qtAction, SIGNAL(triggered()), SLOT(onActivate()));
-}
-
-void pRadioItem::destructor() {
-  if(action.state.menu) action.state.menu->remove(radioItem);
-  delete qtAction;
-  qtAction = nullptr;
-}
-
-void pRadioItem::onActivate() {
-  if(!radioItem.state.checked) {
-    setChecked();
-    if(!locked() && radioItem.onActivate) radioItem.onActivate();
-  }
-}
-
-}

hiro/qt/action/separator.cpp

@@ -1,14 +0,0 @@
-namespace phoenix {
-
-void pSeparator::constructor() {
-  qtAction = new QAction(0);
-  qtAction->setSeparator(true);
-}
-
-void pSeparator::destructor() {
-  if(action.state.menu) action.state.menu->remove(separator);
-  delete qtAction;
-  qtAction = nullptr;
-}
-
-}