Initial community commit

1 files changed, 384 insertions, 0 deletions

diff --git a/Src/Wasabi/api/wnd/wndapi.cpp b/Src/Wasabi/api/wnd/wndapi.cpp
new file mode 100644
index 00000000..25de4d94
--- /dev/null
+++ b/Src/Wasabi/api/wnd/wndapi.cpp
@@ -0,0 +1,384 @@
+#include <precomp.h>
+#include <api.h>
+#include "wndapi.h"
+#include <api/wnd/api_window.h>
+#include <tataki/canvas/ifc_canvas.h>
+
+#include <api/wnd/deactivatemgr.h>
+#include <api/wnd/wndtrack.h>
+
+#include <api/syscb/callbacks/consolecb.h>
+#include <api/wnd/keyboard.h>
+
+#ifdef WASABI_COMPILE_SKIN
+//  #include <api/skin/groupmgr.h>
+#endif
+
+#ifdef WASABI_COMPILE_PAINTSETS
+#ifdef WASABI_COMPILE_IMGLDR
+  #include <api/wnd/paintset.h>
+#endif
+#endif
+
+#ifdef WASABI_COMPILE_SKIN
+//#include <api/skin/skin.h>
+#endif
+#include <bfc/stack.h>
+#include <tataki/region/region.h>
+wnd_api *wndApi = NULL;
+
+#ifndef ODS
+#define ODS(msg1, msg2) __ODS(__LINE__, msg1, msg2, 0);
+#endif
+
+static Stack<ifc_window*> modal_wnd_stack;
+
+static void __ODS(int line, wchar_t *message1, wchar_t *message2, int severity) {
+  StringPrintfW s(L"wndApi(%d): %s: %s\n", line, message1, message2);
+#ifdef WIN32
+  DebugStringW(L"%s\n", s);
+#endif
+  WASABI_API_SYSCB->syscb_issueCallback(SysCallback::CONSOLE, ConsoleCallback::DEBUGMESSAGE, severity, reinterpret_cast<intptr_t>(s.getValue()));
+}
+
+WndApi::WndApi() 
+{
+}
+
+WndApi::~WndApi() 
+{
+
+}
+
+void WndApi::main_setRootWnd(ifc_window *w) {
+  genericwnd = w;
+}
+
+ifc_window *WndApi::main_getRootWnd() {
+  return genericwnd;
+}
+
+ifc_window *WndApi::getModalWnd() {
+  if (!modal_wnd_stack.peek()) return NULL;
+  return modal_wnd_stack.top();
+}
+
+void WndApi::pushModalWnd(ifc_window *w) {
+  modal_wnd_stack.push(w);
+}
+
+void WndApi::popModalWnd(ifc_window *w) {
+  if (getModalWnd() != w) return;
+  modal_wnd_stack.pop();
+}
+/* TODO: Benski> move to api_wndmgr */
+ifc_window *WndApi::rootWndFromPoint(POINT *pt) {
+  return WindowTracker::rootWndFromPoint(pt);
+}
+
+ifc_window *WndApi::rootWndFromOSHandle(OSWINDOWHANDLE wnd) {
+  return WindowTracker::rootWndFromHwnd(wnd);
+}
+
+void WndApi::registerRootWnd(ifc_window *wnd) {
+  WindowTracker::addRootWnd(wnd);
+}
+
+void WndApi::unregisterRootWnd(ifc_window *wnd) {
+  WindowTracker::removeRootWnd(wnd);
+}
+/* --- end TO MOVE ---*/
+
+int WndApi::rootwndIsValid(ifc_window *wnd) {
+  return windowTracker->checkWindow(wnd);
+}
+void WndApi::hookKeyboard(ifc_window *hooker) {
+  Keyboard::hookKeyboard(hooker);
+}
+
+void WndApi::unhookKeyboard(ifc_window *hooker) {
+  Keyboard::unhookKeyboard(hooker);
+}
+
+void WndApi::kbdReset() {
+  Keyboard::reset();
+}
+
+// so when a key is pressed in a basewnd, it is first intercepted and sent to these functions to check if the system should handle it instead of the wnd...
+
+int WndApi::interceptOnChar(unsigned int c) {
+  return Keyboard::interceptOnChar(c);
+}
+
+int WndApi::interceptOnKeyDown(int k) {
+  return Keyboard::interceptOnKeyDown(k);
+}
+
+int WndApi::interceptOnKeyUp(int k) {
+  return Keyboard::interceptOnKeyUp(k);
+}
+
+int WndApi::interceptOnSysKeyDown(int k, int kd) {
+  return Keyboard::interceptOnSysKeyDown(k, kd);
+}
+
+int WndApi::interceptOnSysKeyUp(int k, int kd) {
+  return Keyboard::interceptOnSysKeyUp(k, kd);
+}
+
+// ... if not, then it is sent to the wnd, and if the wnd doesn't need it, it is then forwarded to the system again, for default handling :
+
+int WndApi::forwardOnChar(ifc_window *from, unsigned int c, int kd) {
+  return Keyboard::onForwardOnChar(from, c, kd);
+}
+
+int WndApi::forwardOnKeyDown(ifc_window *from, int k, int kd) {
+  return Keyboard::onForwardOnKeyDown(from, k, kd);
+}
+
+int WndApi::forwardOnKeyUp(ifc_window *from, int k, int kd) {
+  return Keyboard::onForwardOnKeyUp(from, k, kd);
+}
+
+int WndApi::forwardOnSysKeyDown(ifc_window *from, int k, int kd) {
+  return Keyboard::onForwardOnSysKeyDown(from, k, kd);
+}
+
+int WndApi::forwardOnSysKeyUp(ifc_window *from, int k, int kd) {
+  return Keyboard::onForwardOnSysKeyUp(from, k, kd);
+}
+
+int WndApi::forwardOnKillFocus() {
+  return Keyboard::onForwardOnKillFocus();
+}
+
+void WndApi::popupexit_register(PopupExitCallback *cb, ifc_window *watched) 
+{
+  popupExitChecker.registerCallback(cb, watched);
+}
+void WndApi::popupexit_deregister(PopupExitCallback *cb) 
+{
+    popupExitChecker.deregisterCallback(cb);
+}
+
+int WndApi::popupexit_check(ifc_window *w) {
+  
+  return popupExitChecker.check(w);
+}
+
+void WndApi::popupexit_signal() 
+{
+  popupExitChecker.signal();
+}
+
+#define RenderBaseTexture renderBaseTexture //CUT
+void WndApi::skin_renderBaseTexture(ifc_window *basetexturewnd, ifc_canvas *c, const RECT *r, ifc_window *destwnd, int alpha) {
+  if (c == NULL) {
+    ODS(L"illegal param", L"c == NULL");
+    return;
+  }
+  if (basetexturewnd == NULL) {
+    ODS(L"illegal param", L"base == NULL");
+    BaseCloneCanvas canvas(c);
+    canvas.fillRect(r, 0xFF00FF);
+    return;
+  }
+  if (destwnd == NULL) {
+    ODS(L"illegal param", L"destwnd == NULL");
+    return;
+  }
+  renderBaseTexture(basetexturewnd, c, *r, destwnd, alpha);
+}
+
+void WndApi::skin_registerBaseTextureWindow(ifc_window *window, const wchar_t *bitmap) {
+  if (window == NULL) {
+    ODS(L"illegal param", L"window == NULL");
+    return;
+  }
+  BaseTexture *s = new BaseTexture(window, bitmap);
+  baseTextureList.addItem(s);
+}
+
+void WndApi::skin_unregisterBaseTextureWindow(ifc_window *window) {
+  if (window == NULL) {
+    ODS(L"illegal param", L"window == NULL");
+    return;
+  }
+  for (int i=0;i<baseTextureList.getNumItems();i++) {
+    if (baseTextureList.enumItem(i)->getWnd() == window) {
+      BaseTexture *s = baseTextureList.enumItem(i);
+      baseTextureList.delByPos(i);
+      delete s;
+      if (baseTextureList.getNumItems() == 0)
+        baseTextureList.removeAll();
+      break;
+    }
+  }
+}
+
+void WndApi::appdeactivation_push_disallow(ifc_window *from_whom) {
+  AppDeactivationMgr::push_disallow(from_whom);
+}
+
+void WndApi::appdeactivation_pop_disallow(ifc_window *from_whom) {
+  AppDeactivationMgr::pop_disallow(from_whom);
+}
+
+int WndApi::appdeactivation_isallowed(ifc_window *w) {
+  return AppDeactivationMgr::is_deactivation_allowed(w);
+}
+
+void WndApi::appdeactivation_setbypass(int i) {
+  AppDeactivationMgr::setbypass(i);
+}
+
+#ifdef WASABI_COMPILE_PAINTSETS
+#ifdef WASABI_COMPILE_IMGLDR
+
+void WndApi::paintset_render(int set, ifc_canvas *c, const RECT *r, int alpha) {
+  if (c == NULL) {
+		ODS(L"illegal param", L"c == NULL");
+    return;
+  }
+  if (r == NULL) {
+    ODS(L"illegal param", L"r == NULL");
+    return;
+  }
+  paintset_renderPaintSet(set, c, r, alpha);
+}
+
+#ifdef WASABI_COMPILE_FONTS
+void WndApi::paintset_renderTitle(const wchar_t *t, ifc_canvas *c, const RECT *r, int alpha) {
+  if (c == NULL) {
+    ODS(L"illegal param", L"c == NULL");
+    return;
+  }
+  if (r == NULL) {
+    ODS(L"illegal param", L"r == NULL");
+    return;
+  }
+  ::paintset_renderTitle(t, c, r, alpha);
+}
+#endif // WASABI_COMPILE_FONTS
+#endif // WASABI_COMPILE_IMGLDR
+#endif // WASABI_COMPILE_PAINTSETS
+
+BaseTexture *WndApi::getBaseTexture(ifc_window *b) {
+  if (b == NULL) return NULL;
+  for (int i=0;i<baseTextureList.getNumItems();i++)
+    if (baseTextureList.enumItem(i)->getWnd() == b)
+      return baseTextureList.enumItem(i);
+  return NULL;
+}
+
+void WndApi::renderBaseTexture(ifc_window *base, ifc_canvas *c, const RECT &r, ifc_window *dest, int alpha) {
+  renderBaseTexture(base, getBaseTexture(base), c, r, dest, alpha);
+}
+
+void WndApi::renderBaseTexture(ifc_window *base, BaseTexture *bt, ifc_canvas *c, const RECT &r, ifc_window *dest, int alpha) {
+  if (!bt) {
+    DebugString("Warning, no base texture found in renderBaseTexture\n");
+    return;
+  }
+
+  bt->renderBaseTexture(base, c, r, dest, alpha);
+}
+
+#ifndef SAFEROUND
+#define SAFEROUND(d) ((float)(int)d == d) ? (int)d : (d - (float)(int)d > 0) ? ((int)d)+1 : ((int)d)-1
+#endif
+
+void BaseTexture::renderBaseTexture(ifc_window *wndbase, ifc_canvas *c, const RECT &r, ifc_window *dest, int alpha) 
+{
+  // pick our basetexture
+  AutoSkinBitmap *b = &texture;
+
+  if(!b) return;
+
+  // srcRect is the source rectangle in the basetexture
+  RECT srcRect; 
+  // destProjectedRect is the basetexture rectangle projected to dest coordinates
+  RECT destProjectedRect; 
+  
+  ifc_window *p = dest;
+  POINT pt;
+  int sx=0, sy=0;
+  while (p && p != wndbase) {
+    if (!p->isVirtual()) {
+      p->getPosition(&pt);
+      sx += pt.x;
+      sy += pt.y;
+    }
+    p = p->getParent();
+  }
+  ASSERT(p);  
+
+  wndbase->getNonClientRect(&destProjectedRect);
+  Wasabi::Std::offsetRect(&destProjectedRect, -sx, -sy);
+
+  Wasabi::Std::setRect(&srcRect, 0, 0, b->getWidth(), b->getHeight());
+
+#if 0
+  // NONPORTABLE 
+  HDC hdc=c->getHDC();
+  HRGN oldRgn=CreateRectRgn(0,0,0,0);
+  HRGN newRgn=CreateRectRgnIndirect(&r);
+
+  int cs=GetClipRgn(hdc,oldRgn);
+
+  ExtSelectClipRgn(hdc,newRgn,(cs!=1)?RGN_COPY:RGN_AND);
+#endif
+#ifdef _WIN32
+  // TODO: review: wtf does this even accomplish?  we're still blitting to c at the end
+  BaseCloneCanvas clone(c);
+  RegionI oldRgn;
+  RegionI newRgn(&r);
+
+  int cs = clone.getClipRgn(&oldRgn);
+
+  if ( cs ) newRgn.andRegion(&oldRgn);
+
+  clone.selectClipRgn( &newRgn );
+#endif
+  b->stretchToRectAlpha(c, &srcRect, &destProjectedRect, alpha);
+
+#ifdef _WIN32
+  // TODO: review: wtf does this even accomplish?  we're still blitting to c at the end
+  clone.selectClipRgn(cs ? &oldRgn : NULL);
+#endif
+}
+
+int WndApi::forwardOnMouseWheel(int l, int a) {
+  return 0;
+}
+
+#ifdef WASABI_COMPILE_PAINTSETS
+int WndApi::paintset_present(int set) {
+  return ::paintset_present(set);
+}
+#endif
+
+void WndApi::setDefaultDropTarget(void *dt) {
+  default_drop_target = dt;
+}
+
+void *WndApi::getDefaultDropTarget() {
+  return default_drop_target;
+}
+
+int WndApi::pushKeyboardLock() {
+  return ++kbdlock;
+}
+
+int WndApi::popKeyboardLock() {
+  return --kbdlock;
+}
+
+int WndApi::isKeyboardLocked() {
+  return kbdlock;
+}
+
+ifc_window *WndApi::genericwnd = NULL;
+PtrList<BaseTexture> WndApi::baseTextureList;
+void *WndApi::default_drop_target = NULL;
+int WndApi::kbdlock = 0;