steve
/
winamp
mirror of https://github.com/WinampDesktop/winamp.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
winamp/Src/Wasabi/api/wnd/basewnd.cpp

5744 lines
127 KiB
C++
Raw Normal View History

Initial community commit
2024-09-24 12:54:57 +00:00
#include <precomp.h>
#include <bfc/wasabi_std.h>
#include <bfc/wasabi_std_wnd.h>
#include <api/wnd/wndevent.h>
#include <bfc/bfc_assert.h>
#include <api/wnd/wndclass/tooltip.h>
#include <api/wnd/cursor.h>
#include <api/wnd/accessible.h>
#include <api/service/svcs/svc_accessibility.h>
#include <api/wnd/paintsets.h>
#include <api/wnd/PaintCanvas.h>
#ifdef _WIN32
#include <shellapi.h> // for HDROP
#endif
#include <tataki/canvas/bltcanvas.h>
#define DESKTOPALPHA
#define REFRESH_RATE 25
#define DRAWTIMERID 125
#include <api/wnd/basewnd.h>
#include <api/wnd/usermsg.h>
#include <api/wnd/paintcb.h>
#include <tataki/canvas/canvas.h>
#include <bfc/file/filename.h>
#include <tataki/region/region.h>
#include <api/wnd/wndclass/guiobjwnd.h>
#include <api/script/scriptguid.h>
#include <api/wnd/notifmsg.h>
#include <api/metrics/metricscb.h>
#include <api/wndmgr/gc.h>
#include <api/wndmgr/layout.h>
namespace Agave
{
#include "../Agave/Config/api_config.h"
}
//#define TIP_TIMER_ID 1601
#define TIP_DESTROYTIMER_ID 1602
#define TIP_AWAY_ID 1603
#define TIP_AWAY_DELAY 100
#define TIP_TIMER_THRESHOLD 350
#define TIP_LENGTH 3000
#define VCHILD_TIMER_ID_MIN 2000
#define VCHILD_TIMER_ID_MAX 2100
#define BUFFEREDMSG_TIMER_ID 1604
#define DEFERREDCB_INVALIDATE 0x201 // move to .h
#define DEFERREDCB_FOCUSFIRST 0x202 // move to .h
#define DC_KILLGHOST 0x204
#ifdef _WIN32
#define WM_DEFER_CALLBACK (WM_USER+0x333)
#endif
class DragSet : public PtrList<void>, public NamedW {};
//CUT? static void register_wndClass(HINSTANCE);
//CUT? #define ROOTSTRING "RootWnd"
//CUT? #define BASEWNDCLASSNAME "BaseWindow_" ROOTSTRING
#ifndef WM_MOUSEWHEEL
#define WM_MOUSEWHEEL 0x20A
#endif
static ifc_window *stickyWnd;
static RECT sticky;
static UINT WINAMP_WM_DIRECT_MOUSE_WHEEL = WM_NULL;
/*api_window *api_window::rootwndFromPoint(POINT &point, int level) {
api_window *wnd;
wnd = WASABI_API_WND->rootWndFromPoint(&point);
return api_window::rootwndFromRootWnd(wnd, level, &point);
}
api_window *api_window::rootwndFromRootWnd(api_window *wnd, int level, POINT *point) {
for (;;) {
if (wnd == NULL || level < 0) return NULL;
if (point) {
RECT r;
wnd->getWindowRect(&r);
if (!PtInRect(&r, *point)) return NULL; // PORT ME
}
if (level == 0) return wnd;
wnd = wnd->getRootWndParent();
level--;
}
// should never get here
}*/
static BOOL DisabledWindow_OnMouseClick(HWND hwnd)
{
DWORD windowStyle = (DWORD)GetWindowLongPtrW(hwnd, GWL_STYLE);
if (WS_DISABLED != ((WS_CHILD | WS_DISABLED) & windowStyle))
return FALSE;
HWND hActive = GetActiveWindow();
HWND hPopup = GetWindow(hwnd, GW_ENABLEDPOPUP);
BOOL beepOk = (hPopup == hActive || hwnd == GetWindow(hActive, GW_OWNER));
if (!beepOk && NULL == hPopup)
{
for (HWND hWalker = hwnd; ;)
{
hWalker = GetWindow(hWalker, GW_OWNER);
if (NULL == hWalker || (0 != (WS_CHILD & GetWindowLongPtrW(hWalker, GWL_STYLE))))
break;
if (hActive == GetWindow(hWalker, GW_ENABLEDPOPUP))
{
beepOk = TRUE;
break;
}
}
}
if (beepOk)
{
static const GUID accessibilityConfigGroupGUID =
{ 0xe2e7f4a, 0x7c51, 0x478f, { 0x87, 0x74, 0xab, 0xbc, 0xf6, 0xd5, 0xa8, 0x57 } };
#define GetBoolConfig(__group, __itemName, __default)\
((NULL != (__group)) && NULL != (item = group->GetItem(__itemName)) ? item->GetBool() : (__default))
waServiceFactory *serviceFactory = WASABI_API_SVC->service_getServiceByGuid(Agave::AgaveConfigGUID);
Agave::api_config *config = (NULL != serviceFactory) ? (Agave::api_config *)serviceFactory->getInterface() : NULL;
Agave::ifc_configgroup *group = (NULL != config) ? config->GetGroup(accessibilityConfigGroupGUID) : NULL;
Agave::ifc_configitem *item;
if (GetBoolConfig(group, L"modalflash", true))
{
FLASHWINFO flashInfo;
flashInfo.cbSize = sizeof(FLASHWINFO);
flashInfo.hwnd = hActive;
flashInfo.dwFlags = FLASHW_CAPTION;
flashInfo.uCount = 2;
flashInfo.dwTimeout = 100;
FlashWindowEx(&flashInfo);
}
if (GetBoolConfig(group, L"modalbeep", false))
MessageBeep(MB_OK);
if (NULL != config)
serviceFactory->releaseInterface(config);
}
else
{
for (HWND hWalker = hwnd; NULL == hPopup;)
{
hWalker = GetWindow(hWalker, GW_OWNER);
if (NULL == hWalker || (0 != (WS_CHILD & GetWindowLongPtrW(hWalker, GWL_STYLE))))
break;
hPopup = GetWindow(hWalker, GW_ENABLEDPOPUP);
}
SetWindowPos(hwnd, HWND_TOP, 0, 0, 0, 0, SWP_NOACTIVATE | SWP_NOSIZE | SWP_NOMOVE);
if (NULL != hPopup && hPopup != hwnd)
{
BringWindowToTop(hPopup);
SetActiveWindow(hPopup);
}
}
return TRUE;
}
int WndWatcher::viewer_onItemDeleted(ifc_dependent *item)
{
if (item == dep)
{
dep = NULL;
watcher->wndwatcher_onDeleteWindow(watched);
watched = NULL;
}
return 1;
}
BaseWnd::BaseWnd()
{
uiwaslocked = 0;
m_takenOver = 0;
rootfocus = NULL;
rootfocuswatcher.setWatcher(this);
alwaysontop = 0;
customdefaultcursor = NULL;
preventcancelcapture = 0;
ratiolinked = 1;
deleting = 0;
hinstance = NULL;
hwnd = NULL;
parentWnd = NULL;
dragging = 0;
prevtarg = NULL;
inputCaptured = 0;
btexture = NULL;
postoninit = 0;
inited = 0;
skipnextfocus = 0;
ncb = FALSE;
accessible = NULL;
tooltip = NULL;
tip_done = FALSE;
tipshowtimer = FALSE;
tipawaytimer = FALSE;
tipdestroytimer = FALSE;
start_hidden = 0;
notifyWindow = NULL;
lastClick[0] = 0;
lastClick[1] = 0;
lastClickP[0].x = 0;
lastClickP[0].y = 0;
lastClickP[1].x = 0;
lastClickP[1].y = 0;
destroying = FALSE;
curVirtualChildCaptured = NULL;
curVirtualChildFocus = NULL;
virtualCanvas = NULL; virtualCanvasH = virtualCanvasW = 0;
deferedInvalidRgn = NULL;
hasfocus = 0;
focus_on_click = 1;
lastnullregion = 0;
ratio = 1;
lastratio = 1;
rwidth = rheight = 0;
skin_id = -1;
wndalpha = 255;
activealpha = 255;
inactivealpha = 255;
w2k_alpha = 0; //FUCKO
scalecanvas = NULL;
clickthrough = 0;
mustquit = 0;
returnvalue = 0;
notifyid = 0;
cloaked = 0;
disable_tooltip_til_recapture = 0;
subtractorrgn = NULL;
composedrgn = NULL;
wndregioninvalid = 1;
regionop = REGIONOP_NONE;
rectrgn = 1;
need_flush_cascaderepaint = 0;
deferedCascadeRepaintRgn = NULL;
this_visible = 0;
this_enabled = 1;
renderbasetexture = 0;
oldCapture = NULL;
my_guiobject = NULL;
want_autoresize_after_init = 0;
resizecount = 0;
suggested_w = 320;
suggested_h = 200;
maximum_w = maximum_h = AUTOWH;
minimum_w = minimum_h = AUTOWH;
rx = 0;
ry = 0;
rwidth = 0;
rheight = 0;
allow_deactivate = 1;
minimized = 0;
inonresize = 0;
#ifndef WA3COMPATIBILITY
m_target = NULL;
#endif
nodoubleclick = noleftclick = norightclick = nomousemove = nocontextmnu = 0;
focusEventsEnabled = 1;
maximized = 0;
MEMSET(&restore_rect, 0, sizeof(RECT));
ghostbust = 0;
lastActiveWnd = NULL;
}
BaseWnd::~BaseWnd()
{
//ASSERT(virtualChildren.getNumItems() == 0);
childtabs.deleteAll();
if (WASABI_API_WND && WASABI_API_WND->getModalWnd() == this) WASABI_API_WND->popModalWnd(this);
destroying = TRUE;
curVirtualChildFocus = NULL;
#ifdef _WIN32
if (inputCaptured && GetCapture() == getOsWindowHandle()) ReleaseCapture();
#else
#warning port me
#endif
for (int i = 0;i < ghosthwnd.getNumItems();i++)
Wasabi::Std::Wnd::destroyWnd(ghosthwnd.enumItem(i));
if (hwnd != NULL && !m_takenOver)
{
#ifdef URLDROPS
if (acceptExternalDrops()) Wasabi::Std::Wnd::revokeDragNDrop(hwnd /*, &m_target*/);
#else
#ifndef WA3COMPATIBILITY
if (m_target != NULL)
{
Wasabi::Std::Wnd::revokeDragNDrop(hwnd);
}
#endif
#endif
int popact = !wantActivation();
if (popact) WASABI_API_WND->appdeactivation_push_disallow(this);
Wasabi::Std::Wnd::destroyWnd(hwnd);
if (popact) WASABI_API_WND->appdeactivation_pop_disallow(this);
}
deleteFrameBuffer(virtualCanvas);
virtualCanvas = NULL;
delete scalecanvas;
scalecanvas = NULL;
resetDragSet();
notifyParent(ChildNotify::DELETED);
if (tipdestroytimer)
killTimer(TIP_DESTROYTIMER_ID);
if (tipshowtimer)
{
// TODO: on the mac, use CreateMouseTrackingRegion
TRACKMOUSEEVENT tracker;
tracker.cbSize=sizeof(tracker);
tracker.dwFlags = TME_HOVER|TME_CANCEL;
tracker.hwndTrack = this->getOsWindowHandle();
tracker.dwHoverTime = TIP_TIMER_THRESHOLD;
TrackMouseEvent(&tracker);
}
if (tipawaytimer)
killTimer(TIP_AWAY_ID);
destroyTip();
delete tooltip;
if (uiwaslocked)
killTimer(BUFFEREDMSG_TIMER_ID);
if (deferedInvalidRgn)
delete deferedInvalidRgn;
delete composedrgn;
delete subtractorrgn;
delete deferedCascadeRepaintRgn;
if (parentWnd != NULL)
parentWnd->unregisterRootWndChild(this);
if (!m_takenOver && WASABI_API_WND) WASABI_API_WND->unregisterRootWnd(this);
hwnd = NULL;
}
int BaseWnd::init(ifc_window *parWnd, int nochild)
{
if (parWnd == NULL)
return 0;
OSWINDOWHANDLE phwnd = parWnd->getOsWindowHandle();
ASSERT(phwnd != NULL);
parentWnd = parWnd; // set default parent wnd
int ret = init(parWnd->getOsModuleHandle(), phwnd, nochild);
if (!ret)
parentWnd = NULL; // abort
return ret;
}
int BaseWnd::init(OSMODULEHANDLE moduleHandle, OSWINDOWHANDLE parent, int nochild)
{
RECT r;
int w, h;
ASSERTPR(getOsWindowHandle() == NULL, "don't you double init you gaybag");
hinstance = moduleHandle;
#ifdef _WIN32
ASSERT(hinstance != NULL);
#endif
//CUT register_wndClass(hinstance);
if (parent != NULL)
{
Wasabi::Std::Wnd::getClientRect(parent, &r);
}
else
{
Wasabi::Std::setRect(&r, 0, 0, getPreferences(SUGGESTED_W), getPreferences(SUGGESTED_H));
}
w = (r.right - r.left);
h = (r.bottom - r.top);
rwidth = w;
rheight = h;
rx = r.left;
ry = r.top;
int popact = !wantActivation();
if (popact) WASABI_API_WND->appdeactivation_push_disallow(this);
//CUThwnd = createWindow(r.left, r.top, w, h, nochild, parent, hinstance);
hwnd = Wasabi::Std::Wnd::createWnd(&r, nochild, acceptExternalDrops(), parent, hinstance, static_cast<ifc_window*>(this));
#ifdef __APPLE__
#warning remove me
Wasabi::Std::Wnd::showWnd(hwnd);
#endif
if (popact) WASABI_API_WND->appdeactivation_pop_disallow(this);
//ASSERT(hwnd != NULL); // lets fail nicely, this could happen for some win32 reason, we don't want to fail the whole app for it, so lets just fail the wnd
if (hwnd == NULL) return 0;
if (wantActivation()) bringToFront();
//CUT nreal++;
//FUCKO
#ifdef _WIN32 // PORT ME
#ifdef URLDROPS
if (acceptExternalDrops()) RegisterDragDrop(hwnd, &m_target);
#else
#ifndef WA3COMPATIBILITY
if (!m_target && WASABI_API_WND != NULL)
m_target = WASABI_API_WND->getDefaultDropTarget();
if (m_target != NULL)
{
RegisterDragDrop(hwnd, (IDropTarget *)m_target);
}
#endif
#endif
#endif
this_visible = 0;
onInit();
this_visible = !start_hidden;
onPostOnInit();
return 1;
}
#ifndef WA3COMPATIBILITY
void BaseWnd::setDropTarget(void *dt)
{
#ifdef _WIN32
if (isVirtual()) return ;
if (isInited() && m_target != NULL)
{
Wasabi::Std::Wnd::revokeDragNDrop(getOsWindowHandle());
m_target = NULL;
}
m_target = dt;
if (m_target != NULL && isInited())
{
RegisterDragDrop(gethWnd(), (IDropTarget *)m_target);
}
#else
#warning port me
#endif
}
void *BaseWnd::getDropTarget()
{
return m_target;
}
#endif
int BaseWnd::onInit()
{
const wchar_t *s = getName();
if (s != NULL)
setOSWndName(s);
inited = 1;
if (getParent())
getParent()->registerRootWndChild(this);
if (WASABI_API_WND != NULL)
WASABI_API_WND->registerRootWnd(this);
#ifdef _WIN32
if (!Wasabi::Std::Wnd::isDesktopAlphaAvailable())
w2k_alpha = 0; //FUCKO
if (w2k_alpha)
{
setLayeredWindow(1);
}
if (WM_NULL == WINAMP_WM_DIRECT_MOUSE_WHEEL)
WINAMP_WM_DIRECT_MOUSE_WHEEL = RegisterWindowMessageW(L"WINAMP_WM_DIRECT_MOUSE_WHEEL");
#endif
return 0;
}
int BaseWnd::onPostOnInit()
{
postoninit = 1; // from now on, isInited() returns 1;
if (want_autoresize_after_init) onResize();
else invalidateWindowRegion();
if (isVisible()) onSetVisible(1);
if (getTabOrder() == -1) setAutoTabOrder();
ifc_window *dp = getDesktopParent();
if ((dp == NULL || dp == this) && WASABI_API_TIMER != NULL)
postDeferredCallback(DEFERREDCB_FOCUSFIRST, 0, 500);
return 0;
}
void BaseWnd::setLayeredWindow(int i)
{
if (!Wasabi::Std::Wnd::isValidWnd(getOsWindowHandle())) return ;
if (!isInited()) return ;
Wasabi::Std::Wnd::setLayeredWnd(getOsWindowHandle(), i);
#if 0//CUT
if (i)
{
SetWindowLong(getOsWindowHandle(), GWL_EXSTYLE, GetWindowLong(getOsWindowHandle(), GWL_EXSTYLE) & ~WS_EX_LAYERED);
SetWindowLong(getOsWindowHandle(), GWL_EXSTYLE, GetWindowLong(getOsWindowHandle(), GWL_EXSTYLE) | WS_EX_LAYERED);
}
else
{
SetWindowLong(getOsWindowHandle(), GWL_EXSTYLE, GetWindowLong(getOsWindowHandle(), GWL_EXSTYLE) & ~WS_EX_LAYERED);
}
#endif
setTransparency(-1);
}
int BaseWnd::getCursorType(int x, int y)
{
if (!customdefaultcursor)
return BASEWND_CURSOR_POINTER;
return BASEWND_CURSOR_USERSET;
}
void BaseWnd::onSetName()
{
if (isInited() && !isVirtual())
Wasabi::Std::Wnd::setWndName(getOsWindowHandle(), getNameSafe());
notifyParent(ChildNotify::NAMECHANGED);
if (accessible)
accessible->onSetName(getName());
}
OSWINDOWHANDLE BaseWnd::getOsWindowHandle()
{
OSWINDOWHANDLE handle;
if ( isVirtual() )
handle = getParent()->getOsWindowHandle();
else
handle = hwnd;
return handle;
}
OSMODULEHANDLE BaseWnd::getOsModuleHandle()
{
return hinstance;
}
void BaseWnd::onTip()
{
tipshowtimer = FALSE;
tip_done = TRUE;
POINT p;
Wasabi::Std::getMousePos(&p);
if (WASABI_API_WND->rootWndFromPoint(&p) == (ifc_window *)this)
{
createTip();
setTimer(TIP_DESTROYTIMER_ID, TIP_LENGTH);
tipdestroytimer = TRUE;
}
setTimer(TIP_AWAY_ID, TIP_AWAY_DELAY);
tipawaytimer = TRUE;
}
void BaseWnd::timerCallback(int id)
{
switch (id)
{
case BUFFEREDMSG_TIMER_ID:
checkLockedUI();
break;
// case TIP_TIMER_ID:
//onTip();
//break;
case TIP_DESTROYTIMER_ID:
killTimer(TIP_DESTROYTIMER_ID);
killTimer(TIP_AWAY_ID);
tipawaytimer = FALSE;
tipdestroytimer = FALSE;
destroyTip();
break;
case TIP_AWAY_ID:
onTipMouseMove();
break;
}
}
int BaseWnd::isInited()
{
return inited;
}
int BaseWnd::isDestroying()
{
return destroying;
}
int BaseWnd::wantSiblingInvalidations()
{
return FALSE;
}
void BaseWnd::setRSize(int x, int y, int w, int h)
{
rwidth = w;
rheight = h;
rx = x;
ry = y;
}
void BaseWnd::resize(int x, int y, int w, int h, int wantcb)
{
inonresize = 1;
if (x == AUTOWH) x = NOCHANGE;
if (y == AUTOWH) y = NOCHANGE;
if (w == AUTOWH) w = NOCHANGE;
if (h == AUTOWH) h = NOCHANGE;
if (getNumMinMaxEnforcers() > 0)
{
int min_w = getPreferences(MINIMUM_W);
int min_h = getPreferences(MINIMUM_H);
int max_w = getPreferences(MAXIMUM_W);
int max_h = getPreferences(MAXIMUM_H);
if (min_w != AUTOWH && w != NOCHANGE && w < min_w) w = min_w;
if (max_w != AUTOWH && w != NOCHANGE && w > max_w) w = max_w;
if (min_h != AUTOWH && h != NOCHANGE && h < min_h) h = min_h;
if (max_h != AUTOWH && h != NOCHANGE && h > max_h) h = max_h;
}
int noresize = (w == NOCHANGE && h == NOCHANGE);
int nomove = (x == NOCHANGE && y == NOCHANGE)/* || (x == rx && y == ry)*/;
if (x == NOCHANGE) x = rx;
if (y == NOCHANGE) y = ry;
if (w == NOCHANGE) w = rwidth;
if (h == NOCHANGE) h = rheight;
#ifdef _DEBUG
ASSERT(x < 0xFFF0);
ASSERT(y < 0xFFF0);
ASSERT(w < 0xFFF0);
ASSERT(h < 0xFFF0);
#endif
double thisratio = getRenderRatio();
int different_ratio = (lastratio != thisratio);
lastratio = thisratio;
int noevent = (resizecount > 1 && w == rwidth && h == rheight);
//ifc_window *dp = getDesktopParent();
if (different_ratio == 1 && noevent == 1)
{
if (Wasabi::Std::Wnd::getTopmostChild(getOsWindowHandle()) != INVALIDOSWINDOWHANDLE)
noevent = 0;
invalidateWindowRegion();
}
RECT oldsize, newsize = Wasabi::Std::makeRect(x, y, w, h);
if (hwnd != NULL)
BaseWnd::getNonClientRect(&oldsize);
else
oldsize = newsize;
setRSize(x, y, w, h);
if (handleRatio() && renderRatioActive())
{
multRatio(&w, &h);
if (getParent() != NULL)
{
multRatio(&x, &y);
}
}
if (!noevent)
{
if (wantcb && isPostOnInit())
{
resizecount = MIN(5, ++resizecount);
if (!isVirtual())
invalidateWindowRegion();
onResize();
if (ensureWindowRegionValid())
updateWindowRegion();
}
}
if (getOsWindowHandle() != NULL)
{
RECT oldsizescaled;
getWindowRect(&oldsizescaled);
RECT newsizescaled = {x, y, x + w, y + h};
if (MEMCMP(&newsizescaled, &oldsizescaled, sizeof(RECT)))
{
//CUT SetWindowPos(getOsWindowHandle(), NULL, x, y, w, h,
//CUT SWP_NOZORDER |
//CUT SWP_NOACTIVATE |
//CUT (!wantRedrawOnResize() ? SWP_NOCOPYBITS: 0) |
//CUT (ncb ? SWP_NOCOPYBITS : 0) |
//CUT ( nomove ? SWP_NOMOVE : 0) |
//CUT ( noresize ? SWP_NOSIZE : 0) |
//CUT 0);
Wasabi::Std::Wnd::setWndPos( getOsWindowHandle(), NULL, x, y, w, h, TRUE, TRUE, !wantRedrawOnResize() || ncb, nomove, noresize );
}
//else
//{
// DebugStringW(L"BaseWnd::resize optimized\n");
//}
onAfterResize();
if (ncb)
invalidate();
else
{
RECT r;
if (hwnd != NULL)
{
if (newsize.left == oldsize.left && newsize.top == oldsize.top)
{
if (newsize.right > oldsize.right)
{
// growing in width
r.left = oldsize.right;
r.right = newsize.right;
r.top = newsize.top;
r.bottom = newsize.bottom;
invalidateRect(&r);
if (newsize.bottom > oldsize.bottom)
{
// growing in width & height
r.left = oldsize.left;
r.right = newsize.right;
r.top = oldsize.bottom;
r.bottom = newsize.bottom;
invalidateRect(&r);
}
}
else if (newsize.bottom > oldsize.bottom)
{
if (newsize.bottom > oldsize.bottom)
{
// growing in height
r.left = oldsize.left;
r.right = newsize.right;
r.top = oldsize.bottom;
r.bottom = newsize.bottom;
invalidateRect(&r);
}
}
}
}
}
}
inonresize = 0;
}
void BaseWnd::forcedOnResizeChain(ifc_window *w)
{
w->triggerEvent(TRIGGER_ONRESIZE);
int n = w->getNumRootWndChildren();
for (int i = 0;i < n;i++)
{
forcedOnResizeChain(w->enumRootWndChildren(i));
}
}
int BaseWnd::forcedOnResize()
{
forcedOnResizeChain(this);
return 1;
}
int BaseWnd::onResize()
{
if (!isVirtual() || (getRegionOp() != REGIONOP_NONE))
invalidateWindowRegion();
// you are not supposed to call onResize until after onInit has returned. If what you wanted was to generate
// an onResize event to do some custom client coordinates recalculations (ie: to apply on your children)
// then you don't need to do anything since onResize is going to be called after onInit() is done. If you still want to
// trigger it because your code might be called by onInit and after onInit, use isPostOnInit() as a test.
// if what you wanted was to signal a object that you just resized it, then you don't need to do anything beside
// resize(...), it will generate the event on its own if the window is inited, and will defer to until after onInit
// if it is not.
// shortly put: do not call onResize before or inside onInit()
// if you have any valid reason for doing that, i'd like to know about it so i can make it possible. -FG
#ifdef _DEBUG
if (!isPostOnInit())
{
//__asm int 3;
ASSERTPR(isPostOnInit(), "do not call onResize before or inside onInit()");
}
#endif
return FALSE;
}
void BaseWnd::resizeToClient(BaseWnd *wnd)
{
if (wnd != NULL)
wnd->resize(&clientRect());
}
int BaseWnd::onPostedMove()
{
/*
if (w2k_alpha && Wasabi::Std::Wnd::isDesktopAlphaAvailable() && !cloaked)
{
RECT r;
getWindowRect(&r);
Wasabi::Std::Wnd::moveLayeredWnd(hwnd, r.left, r.top);
}*/
return FALSE;
}
void BaseWnd::resize(RECT *r, int wantcb)
{
resize(r->left, r->top, r->right - r->left, r->bottom - r->top, wantcb);
}
void BaseWnd::move(int x, int y)
{
//DebugStringW( L"BaseWnd::move( x = %d, y = %d )\n", x, y );
setRSize(x, y, rwidth, rheight);
Wasabi::Std::Wnd::setWndPos( getOsWindowHandle(), NULL, x, y, 0, 0, TRUE, TRUE, ncb, FALSE, TRUE );
//CUT if (!ncb)
//CUT SetWindowPos(getOsWindowHandle(), NULL, x, y, 0, 0, SWP_NOSIZE|SWP_NOZORDER|SWP_NOACTIVATE|SWP_DEFERERASE);
//CUT else
//CUT SetWindowPos(getOsWindowHandle(), NULL, x, y, 0, 0, SWP_NOSIZE|SWP_NOZORDER|SWP_NOCOPYBITS|SWP_NOACTIVATE|SWP_DEFERERASE);
}
#ifdef EXPERIMENTAL_INDEPENDENT_AOT
BOOL CALLBACK EnumOwnedTopMostWindows(HWND hwnd, LPARAM lParam)
{
enumownedstruct *st = (enumownedstruct *)lParam;
if (hwnd != st->hthis && GetWindow(hwnd, GW_OWNER) == st->owner)
{
ifc_window *w = (ifc_window*)GetWindowLong(hwnd, GWL_USERDATA);
if (w != NULL && w->getAlwaysOnTop())
st->hlist->addItem(w);
}
return TRUE;
}
void BaseWnd::saveTopMosts()
{
HWND owner = GetWindow(getOsWindowHandle(), GW_OWNER);
enumownedstruct st;
ontoplist.removeAll();
if (owner != NULL)
{
st.owner = owner;
st.hlist = &ontoplist;
st.hthis = getOsWindowHandle();
EnumWindows(EnumOwnedTopMostWindows, (long)&st);
}
}
void BaseWnd::restoreTopMosts()
{
HWND owner = GetWindow(getOsWindowHandle(), GW_OWNER);
if (owner != NULL)
{
for (int i = 0;i < ontoplist.getNumItems();i++)
{
ontoplist.enumItem(i)->setAlwaysOnTop(1);
}
}
}
#endif
void BaseWnd::bringToFront()
{
// when we set a window to the top of the zorder (not topmost), win32 finds the owner and removes any topmost flag its children may
// have because it assumes we want this window over these, which we definitly don't. so we need to first go thru all the owner's children,
// make a list of the ones with a topmost flag, set this window on top, and set the topmost flags back. yay
ASSERT(!isVirtual());
#ifdef EXPERIMENTAL_INDEPENDENT_AOT
saveTopMosts();
#endif
//CUT SetWindowPos(getOsWindowHandle(), HWND_TOP, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE|SWP_DEFERERASE|SWP_NOOWNERZORDER);
Wasabi::Std::Wnd::bringToFront(getOsWindowHandle());
#ifdef EXPERIMENTAL_INDEPENDENT_AOT
restoreTopMosts();
#endif
}
void BaseWnd::bringToBack()
{
ASSERT(!isVirtual());
#ifdef EXPERIMENTAL_INDEPENDENT_AOT
saveTopMosts();
#endif
//CUT SetWindowPos(getOsWindowHandle(), HWND_BOTTOM, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE|SWP_DEFERERASE|SWP_NOOWNERZORDER);
Wasabi::Std::Wnd::sendToBack(getOsWindowHandle());
#ifdef EXPERIMENTAL_INDEPENDENT_AOT
restoreTopMosts();
#endif
}
void BaseWnd::setVisible(int show)
{
int visible = isVisible(1);
if (!!visible == !!show) return ;
invalidate();
this_visible = !!show;
/*if (!getParent() || getParent() == WASABI_API_WND->main_getRootWnd() && IsWindow(getOsWindowHandle())) {
if (!show) {
setLayeredWindow(0);
if (setLayeredWindowAttributes)
setLayeredWindowAttributes(hwnd, RGB(0,0,0), 255, LWA_ALPHA);
} else {
setLayeredWindow(w2k_alpha);
}
}*/
if (!getParent() || getParent() == WASABI_API_WND->main_getRootWnd() || getParent()->isVisible())
{
onSetVisible(show);
}
}
void BaseWnd::setCloaked(int cloak)
{
if (cloaked == cloak) return ;
cloaked = cloak;
if (isVirtual()) return ;
if (cloaked)
{
//CUTif (IsWindowVisible(getOsWindowHandle()))
//CUT ShowWindow(getOsWindowHandle(), SW_HIDE);
if (Wasabi::Std::Wnd::isWndVisible(getOsWindowHandle()))
Wasabi::Std::Wnd::hideWnd(getOsWindowHandle());
}
else
{
if (isVisible(1))
//CUTShowWindow(getOsWindowHandle(), SW_NORMAL);
Wasabi::Std::Wnd::showWnd(getOsWindowHandle());
}
}
void BaseWnd::onSetVisible(int show)
{
/* for debug purposes - don't delete please
#include "../../../studio/container.h"
#include "../../../studio/layout.h"
if (!show && getGuiObject() && STRCASEEQLSAFE(getGuiObject()->guiobject_getId(), "normal")) {
Layout *l = (Layout *)getInterface(layoutGuid);
if (l) {
if (l->getParentContainer() && STRCASEEQLSAFE(l->getParentContainer()->getId(), "main")) {
DebugString("Hiding main player\n");
}
}
}*/
if (!isVirtual())
if (hwnd != NULL)
if (!cloaked)
{
//CUT // SetWindowPos(getOsWindowHandle(),NULL,0,0,0,0,SWP_NOMOVE|SWP_NOSIZE|SWP_NOACTIVATE|SWP_NOZORDER|SWP_SHOWWINDOW);
//CUT ShowWindow(getOsWindowHandle(), show ? SW_SHOWNA : SW_HIDE);
if (show)
Wasabi::Std::Wnd::showWnd(getOsWindowHandle(), TRUE);
else
Wasabi::Std::Wnd::hideWnd(getOsWindowHandle());
}
/* if (!show)
postDeferredCallback(0x7849);
else {*/
foreach(rootwndchildren)
ifc_window *w = rootwndchildren.getfor();
if (w && w->isVisible(1)) // check internal flag only
w->onSetVisible(show);
endfor;
dependent_sendEvent(BaseWnd::depend_getClassGuid(), Event_SETVISIBLE, show);
//}
/* if (getDesktopParent() == this) {
cascadeRepaint(0);
}*/
/*#ifdef WIN32 // os-specific non virtual child wnd support
if (!isVirtual()) {
HWND w = GetWindow(getOsWindowHandle(), GW_CHILD);
while (w != NULL) {
api_window *rootwnd = (api_window*)GetWindowLong(w, GWL_USERDATA);
if (rootwnd && rootwnd != this)
if (rootwnd->isInited())
rootwnd->onSetVisible(show);
w = GetWindow(w, GW_HWNDNEXT);
}
}
#endif*/
if (!isVirtual())
{
if (!show)
{
deferedInvalidate();
delete virtualCanvas;
virtualCanvas = NULL;
}
}
invalidateWindowRegion();
}
void BaseWnd::setEnabled(int en)
{
int enabled = isEnabled(1);
if (!!enabled == !!en) return ;
invalidate();
this_enabled = !!en;
if (!getParent() || getParent() == WASABI_API_WND->main_getRootWnd() || getParent()->isEnabled())
{
onEnable(en);
}
}
int BaseWnd::isEnabled(int within)
{
if (!isVirtual() && !getOsWindowHandle()) return 0;
if (!this_enabled) return 0;
if (within) return this_enabled; // whatever, local
if (isVirtual()) // virtual, global
if (getParent())
return getParent()->isEnabled();
else
return 0;
// non virtual, global
//CUT if (GetWindowLong(getOsWindowHandle(), GWL_STYLE) & WS_POPUP) return this_enabled;
if (Wasabi::Std::Wnd::isPopup(getOsWindowHandle())) return this_enabled;
//CUT if (!Wasabi::Std::Wnd::isValidWnd(GetParent(gethWnd()))) return this_enabled;
if (!Wasabi::Std::Wnd::isValidWnd(Wasabi::Std::Wnd::getParent(getOsWindowHandle()))) return this_enabled;
if (getParent()) return getParent()->isEnabled(); // not a popup, check its parent or fail
return this_enabled;
}
int BaseWnd::onEnable(int en)
{
if (!isVirtual())
{
if (hwnd != NULL)
//CUT EnableWindow(getOsWindowHandle(), en);
Wasabi::Std::Wnd::setEnabled(getOsWindowHandle(), en);
foreach(rootwndchildren)
ifc_window *w = rootwndchildren.getfor();
if (w->isEnabled(1)) // check internal flag only
w->onEnable(en);
endfor;
}
return 1;
}
void BaseWnd::setFocus()
{
if (curVirtualChildFocus != NULL)
{
curVirtualChildFocus->onKillFocus();
curVirtualChildFocus = NULL;
}
onSetRootFocus(this);
//CUT SetFocus(getOsWindowHandle());
Wasabi::Std::Wnd::setFocus(getOsWindowHandle());
}
void BaseWnd::setFocusOnClick(int f)
{
focus_on_click = f;
}
api_region *BaseWnd::getDeferedInvalidRgn()
{
return deferedInvalidRgn;
}
void BaseWnd::deferedInvalidate()
{
if (!hasVirtualChildren() || !isVisible(1)) return ;
RECT r = Wasabi::Std::makeRect(0, 0, 0, 0);
getNonClientRect(&r);
deferedInvalidateRect(&r);
}
void BaseWnd::deferedInvalidateRect(RECT *r)
{
if (!hasVirtualChildren()) return ;
RegionI h(r);
deferedInvalidateRgn(&h);
}
void BaseWnd::deferedInvalidateRgn(api_region *h)
{
if (!hasVirtualChildren()) return ;
if (!deferedInvalidRgn)
{
deferedInvalidRgn = new RegionI();
}
deferedInvalidRgn->addRegion(h);
}
void BaseWnd::deferedValidate()
{
if (!hasVirtualChildren() || !isVisible(1)) return ;
RECT r = Wasabi::Std::makeRect(0,0,0,0);
getNonClientRect(&r);
deferedValidateRect(&r);
}
void BaseWnd::deferedValidateRect(RECT *r)
{
if (!hasVirtualChildren()) return ;
RegionI h(r);
deferedValidateRgn(&h);
}
void BaseWnd::deferedValidateRgn(api_region *h)
{
if (!hasVirtualChildren()) return ;
if (!deferedInvalidRgn) return ;
deferedInvalidRgn->subtractRgn(h);
}
int BaseWnd::hasVirtualChildren()
{
return 1; //virtualChildren.getNumItems() > 0;
}
void BaseWnd::invalidate()
{
invalidateFrom(this);
}
void BaseWnd::invalidateFrom(ifc_window *who)
{
if (hasVirtualChildren()) deferedInvalidate();
//CUT if (hwnd != NULL && isVisible(1)) InvalidateRect(getOsWindowHandle(), NULL, FALSE);
if (hwnd != NULL && isVisible(1))
Wasabi::Std::Wnd::invalidateRect(getOsWindowHandle());
}
void BaseWnd::invalidateRectFrom(RECT *r, ifc_window *who)
{
if (hasVirtualChildren()) deferedInvalidateRect(r);
RegionI rg(r);
invalidateRgnFrom(&rg, who);
}
void BaseWnd::invalidateRgn(api_region *r)
{
invalidateRgnFrom(r, this);
}
void BaseWnd::invalidateRect(RECT *r)
{
invalidateRectFrom(r, this);
}
void BaseWnd::invalidateRgnFrom(api_region *r, ifc_window *who)
{
if (parentWnd) parentWnd->onChildInvalidate(r, who);
PaintCallbackInfoI pc(NULL, r);
dependent_sendEvent(BaseWnd::depend_getClassGuid(), Event_ONINVALIDATE, 0, &pc);
if (hwnd != NULL && isVisible(1))
{
if (hasVirtualChildren())
{
api_region *_r = r->clone();
int j = virtualChildren.searchItem(who);
for (int i = 0;i < virtualChildren.getNumItems();i++)
{
ifc_window *w = virtualChildren[i];
if (w != who && w->wantSiblingInvalidations())
w->onSiblingInvalidateRgn(_r, who, j, i);
}
deferedInvalidateRgn(_r);
physicalInvalidateRgn(_r);
r->disposeClone(_r);
}
else
{
deferedInvalidateRgn(r);
physicalInvalidateRgn(r);
}
}
}
void BaseWnd::physicalInvalidateRgn(api_region *r)
{
if (hwnd != NULL && isVisible(1))
{
if (renderRatioActive())
{
api_region *clone = r->clone();
clone->scale(getRenderRatio(), getRenderRatio(), TRUE);
//CUT InvalidateRgn(getOsWindowHandle(), clone->getOSHandle(), FALSE);
Wasabi::Std::Wnd::invalidateRegion(getOsWindowHandle(), clone->getOSHandle());
r->disposeClone(clone);
}
else
//CUT InvalidateRgn(getOsWindowHandle(), r->getOSHandle(), FALSE);
Wasabi::Std::Wnd::invalidateRegion(getOsWindowHandle(), r->getOSHandle());
}
}
void BaseWnd::validate()
{
//CUT if (hwnd != NULL) ValidateRect(getOsWindowHandle(), NULL);
if (hwnd != NULL)
Wasabi::Std::Wnd::validateRect(getOsWindowHandle());
}
void BaseWnd::validateRect(RECT *r)
{
if (hwnd != NULL)
{
if (renderRatioActive())
{
RECT r2 = *r;
Wasabi::Std::scaleRect(&r2, getRenderRatio());
//CUT ValidateRect(getOsWindowHandle(), &r2);
Wasabi::Std::Wnd::validateRect(getOsWindowHandle(), &r2);
}
else
//CUT ValidateRect(getOsWindowHandle(), r);
Wasabi::Std::Wnd::validateRect(getOsWindowHandle(), r);
}
}
void BaseWnd::validateRgn(api_region *reg)
{
if (hwnd != NULL)
{
if (renderRatioActive())
{
api_region *clone = reg->clone();
clone->scale(getRenderRatio(), getRenderRatio(), TRUE);
//CUT ValidateRgn(getOsWindowHandle(), clone->getOSHandle());
Wasabi::Std::Wnd::validateRegion(getOsWindowHandle(), clone->getOSHandle());
reg->disposeClone(clone);
}
else
//CUT ValidateRgn(getOsWindowHandle(), reg->getOSHandle());
Wasabi::Std::Wnd::validateRegion(getOsWindowHandle(), reg->getOSHandle());
}
}
void BaseWnd::repaint()
{
/* if (hasVirtualChildren()) {
api_region *h = new api_region();
int s = GetUpdateRgn(getOsWindowHandle(), h->getHRGN(), FALSE);
if (s != NULLREGION && s != ERROR) {
virtualDrawRgn(h);
}
delete h;
}*/
//CUTif (hwnd != NULL) UpdateWindow(getOsWindowHandle());
if (hwnd != NULL)
Wasabi::Std::Wnd::update(getOsWindowHandle());
}
void BaseWnd::getClientRect(RECT *rect)
{
/* rect->left = rx;
rect->right = rx + rwidth;
rect->top = ry;
rect->bottom = ry + rheight;*/
//ASSERT(hwnd != NULL);
if (!Wasabi::Std::Wnd::isValidWnd(hwnd))
{
MEMSET(rect, 0, sizeof(RECT));
return ;
}
GetClientRect(getOsWindowHandle(), rect);
////Wasabi::Std::Wnd::getClientRect(getOsWindowHandle(), rect);
rect->right = rect->left + rwidth;
rect->bottom = rect->top + rheight;
}
RECT BaseWnd::clientRect()
{
RECT ret;
getClientRect(&ret);
return ret;
}
void BaseWnd::getNonClientRect(RECT *rect)
{
// ASSERT(hwnd != NULL);
if (!hwnd)
getClientRect(rect);
else
{
Wasabi::Std::Wnd::getClientRect(getOsWindowHandle(), rect);
if (getRenderRatio() != 1.0)
{
rect->right = rect->left + rwidth;
rect->bottom = rect->left + rheight;
}
}
/* rect->left = rx;
rect->right = rx + rwidth;
rect->top = ry;
rect->bottom = ry + rheight;*/
}
RECT BaseWnd::nonClientRect()
{
RECT ret;
getNonClientRect(&ret);
return ret;
}
void BaseWnd::getWindowRect(RECT *rect)
{
//CUT#ifdef WIN32
//CUT ASSERT(hwnd != NULL);
//CUT GetWindowRect(getOsWindowHandle(), rect);
//CUT#else
//CUT#error port me
//CUT#endif
Wasabi::Std::Wnd::getWindowRect(getOsWindowHandle(), rect);
}
// get position relative to parent (same coordinate system for basewnd & virtualwnd)
void BaseWnd::getPosition(POINT *pt)
{
pt->x = rx;
pt->y = ry;
}
void *BaseWnd::dependent_getInterface(const GUID *classguid)
{
HANDLEGETINTERFACE(ifc_window);
//CUT HANDLEGETINTERFACE(api_window);
return NULL;
}
RECT BaseWnd::windowRect()
{
RECT ret;
getWindowRect(&ret);
return ret;
}
void BaseWnd::clientToScreen(int *x, int *y)
{
int _x = x ? *x : 0;
int _y = y ? *y : 0;
if (renderRatioActive())
{
_x = (int)((double)_x * getRenderRatio());
_y = (int)((double)_y * getRenderRatio());
}
Wasabi::Std::Wnd::clientToScreen(getOsWindowHandle(), &_x, &_y);
if (x) *x = _x;
if (y) *y = _y;
}
void BaseWnd::clientToScreen(RECT *r)
{
clientToScreen((int*)&r->left, (int*)&r->top);
clientToScreen((int*)&r->right, (int*)&r->bottom);
}
void BaseWnd::clientToScreen(POINT *p)
{
clientToScreen((int *)&p->x, (int *)&p->y);
}
void BaseWnd::screenToClient(int *x, int *y)
{
//CUT POINT p;
int _x = x ? *x : 0;
int _y = y ? *y : 0;
//CUT ScreenToClient(getOsWindowHandle(), &p);
Wasabi::Std::Wnd::screenToClient(getOsWindowHandle(), &_x, &_y);
if (renderRatioActive())
{
_x = (int)((double)_x / getRenderRatio());
_y = (int)((double)_y / getRenderRatio());
}
if (x) *x = _x;
if (y) *y = _y;
}
void BaseWnd::screenToClient(RECT *r)
{
screenToClient((int*)&r->left, (int*)&r->top);
screenToClient((int*)&r->right, (int*)&r->bottom);
}
void BaseWnd::screenToClient(POINT *p)
{
screenToClient((int *)&p->x, (int *)&p->y);
}
void BaseWnd::setParent(ifc_window *newparent)
{
ASSERTPR(newparent != NULL, "quit being a weeny");
ASSERTPR(parentWnd == NULL || newparent == parentWnd, "can't reset parent");
parentWnd = newparent;
if (isInited())
{
OSWINDOWHANDLE w1 = getOsWindowHandle();
OSWINDOWHANDLE w2 = newparent->getOsWindowHandle();
if (w1 != w2)
//CUT SetParent(w1, w2);
Wasabi::Std::Wnd::setParent(w1, w2);
}
}
//FUCKO
int BaseWnd::reparent(ifc_window *newparent)
{
#ifdef _WIN32
if (!isVirtual())
{
if (isInited())
{
ifc_window *old = getParent();
if (!old && newparent)
{
::SetParent(getOsWindowHandle(), newparent->getOsWindowHandle());
SetWindowLong(getOsWindowHandle() , GWL_STYLE, GetWindowLong(getOsWindowHandle(), GWL_STYLE) & ~WS_POPUP);
SetWindowLong(getOsWindowHandle() , GWL_STYLE, GetWindowLong(getOsWindowHandle(), GWL_STYLE) | WS_CHILD);
}
else if (old && !newparent)
{
SetWindowLong(getOsWindowHandle() , GWL_STYLE, GetWindowLong(getOsWindowHandle(), GWL_STYLE) & ~WS_CHILD);
SetWindowLong(getOsWindowHandle() , GWL_STYLE, GetWindowLong(getOsWindowHandle(), GWL_STYLE) | WS_POPUP);
::SetParent(getOsWindowHandle(), NULL);
}
else
{
::SetParent(getOsWindowHandle(), newparent ? newparent->getOsWindowHandle() : NULL);
}
}
}
parentWnd = newparent;
onSetParent(newparent);
#ifdef WASABI_ON_REPARENT
WASABI_ON_REPARENT(getOsWindowHandle());
#endif
#else
#warning port me
#endif
return 1;
}
ifc_window *BaseWnd::getParent()
{
return parentWnd;
}
ifc_window *BaseWnd::getRootParent()
{
return this;
}
//PORTME
ifc_window *BaseWnd::getDesktopParent()
{
#ifdef _WIN32
// NONPORTABLE
HWND w = getOsWindowHandle();
HWND last = w;
if (!w) return NULL;
HWND p = w;
wchar_t cn[256] = {0};
while (p && !(GetWindowLong(p, GWL_STYLE) & WS_POPUP))
{
GetClassNameW(p, cn, 255); cn[255] = 0;
if (!wcscmp(cn, BASEWNDCLASSNAME))
last = p;
p = GetParent(p);
}
if (p)
{
GetClassNameW(p, cn, 255); cn[255] = 0;
if (!wcscmp(cn, BASEWNDCLASSNAME))
return (ifc_window*)GetWindowLongPtrW(p, GWLP_USERDATA);
else if (last != NULL)
return (ifc_window*)GetWindowLongPtrW(last, GWLP_USERDATA);
}
#else
#warning port me
#endif
return NULL;
}
int BaseWnd::notifyParent(int msg, int param1, int param2)
{
ifc_window *notifywnd = getNotifyWindow();
if (getParent() == NULL && notifywnd == NULL) return 0;
if (notifywnd == NULL) notifywnd = getParent();
ASSERT(notifywnd != NULL);
return notifywnd->childNotify(this, msg, param1, param2);
}
int BaseWnd::passNotifyUp(ifc_window *child, int msg, int param1, int param2)
{
// Same code as above to decide for whom we should notify.
ifc_window *notifywnd = getNotifyWindow();
if (getParent() == NULL && notifywnd == NULL) return 0;
if (notifywnd == NULL) notifywnd = getParent();
ASSERT(notifywnd != NULL);
// And here we just change the api_window pointer.
return notifywnd->childNotify(child, msg, param1, param2);
}
void BaseWnd::setNotifyId(int id)
{
notifyid = id;
}
int BaseWnd::getNotifyId()
{
return notifyid;
}
DragInterface *BaseWnd::getDragInterface()
{
return this;
}
ifc_window *BaseWnd::rootWndFromPoint(POINT *pt)
{
// pt is in client coordinates
int x = (int)((double)pt->x / getRenderRatio());
int y = (int)((double)pt->y / getRenderRatio());
ifc_window *ret = findRootWndChild(x, y);
if (ret == NULL) ret = this;
return ret;
}
int BaseWnd::rootwnd_paintTree(ifc_canvas *canvas, api_region *r)
{
BaseCloneCanvas c(canvas);
return paintTree(&c, r);
}
const wchar_t *BaseWnd::getRootWndName()
{
return getName();
}
const wchar_t *BaseWnd::getId()
{
return NULL;
}
void BaseWnd::setSkinId(int id)
{
skin_id = id;
}
void BaseWnd::setPreferences(int what, int v)
{
switch (what)
{
case MAXIMUM_W: maximum_w = v; break;
case MAXIMUM_H: maximum_h = v; break;
case MINIMUM_W: minimum_w = v; break;
case MINIMUM_H: minimum_h = v; break;
case SUGGESTED_W: suggested_w = v; break;
case SUGGESTED_H: suggested_h = v; break;
}
}
int BaseWnd::getPreferences(int what)
{
if (getNumMinMaxEnforcers() > 0)
{
int min_x = minimum_w, min_y = minimum_h, max_x = maximum_w, max_y = maximum_h, sug_x = suggested_w, sug_y = suggested_h;
for (int i = 0;i < getNumMinMaxEnforcers();i++)
{
int tmin_x = MINIMUM_W, tmin_y = MINIMUM_H, tmax_x = MAXIMUM_W, tmax_y = MAXIMUM_H, tsug_x = SUGGESTED_W, tsug_y = SUGGESTED_H;
ifc_window *w = enumMinMaxEnforcer(i);
if (w)
{
tmin_x = w->getPreferences(MINIMUM_W);
tmin_y = w->getPreferences(MINIMUM_H);
tmax_x = w->getPreferences(MAXIMUM_W);
tmax_y = w->getPreferences(MAXIMUM_H);
tsug_x = w->getPreferences(SUGGESTED_W);
tsug_y = w->getPreferences(SUGGESTED_H);
if (tmin_x == -1) tmin_x = AUTOWH;
if (tmin_y == -1) tmin_y = AUTOWH;
if (tmax_x == -1) tmax_x = AUTOWH;
if (tmax_y == -1) tmax_y = AUTOWH;
if (tsug_x == -1) tsug_x = AUTOWH;
if (tsug_y == -1) tsug_y = AUTOWH;
#ifndef DISABLE_SYSFONTSCALE
TextInfoCanvas textInfoCanvas(this);
double fontScale = textInfoCanvas.getSystemFontScale();
GuiObject *o = static_cast<GuiObject *>(getInterface(guiObjectGuid));
if (o != NULL)
{
if (o->guiobject_getAutoSysMetricsW())
{
if (tmin_x != AUTOWH) tmin_x = (int)((float)tmin_x * fontScale);
if (tmax_x != AUTOWH) tmax_x = (int)((float)tmax_x * fontScale);
if (tsug_x != AUTOWH) tsug_x = (int)((float)tsug_x * fontScale);
}
if (o->guiobject_getAutoSysMetricsH())
{
if (tmin_y != AUTOWH) tmin_y = (int)((float)tmin_y * fontScale);
if (tmax_y != AUTOWH) tmax_y = (int)((float)tmax_y * fontScale);
if (tsug_y != AUTOWH) tsug_y = (int)((float)tsug_y * fontScale);
}
}
#endif
RECT cor;
w->getNonClientRect(&cor);
RECT wr;
getNonClientRect(&wr);
int xdif = (wr.right - wr.left) - (cor.right - cor.left);
int ydif = (wr.bottom - wr.top) - (cor.bottom - cor.top);
if (tmin_x != AUTOWH) tmin_x += xdif;
if (tmin_y != AUTOWH) tmin_y += ydif;
if (tmax_x != AUTOWH) tmax_x += xdif;
if (tmax_y != AUTOWH) tmax_y += ydif;
if (tsug_x != AUTOWH) tsug_x += xdif;
if (tsug_y != AUTOWH) tsug_y += ydif;
}
if (min_x != AUTOWH) min_x = (tmin_x != AUTOWH) ? MAX(min_x, tmin_x) : min_x; else min_x = tmin_x;
if (max_x != AUTOWH) max_x = (tmax_x != AUTOWH) ? MAX(max_x, tmax_x) : max_x; else max_x = tmax_x;
if (min_y != AUTOWH) min_y = (tmin_y != AUTOWH) ? MAX(min_y, tmin_y) : min_y; else min_y = tmin_y;
if (max_y != AUTOWH) max_y = (tmax_y != AUTOWH) ? MAX(max_y, tmax_y) : max_y; else max_y = tmax_y;
if (sug_x != AUTOWH) sug_x = (tsug_x != AUTOWH) ? MAX(sug_x, tsug_x) : sug_x; else sug_x = tsug_x;
if (sug_y != AUTOWH) sug_y = (tsug_y != AUTOWH) ? MAX(sug_y, tsug_y) : sug_y; else sug_y = tsug_y;
}
if (min_x != AUTOWH && min_x == max_x) sug_x = min_x;
if (min_y != AUTOWH && min_y == max_y) sug_y = min_y;
switch (what)
{
case MINIMUM_W: return min_x;
case MINIMUM_H: return min_y;
case MAXIMUM_W: return max_x;
case MAXIMUM_H: return max_y;
case SUGGESTED_W: return sug_x;
case SUGGESTED_H: return sug_y;
}
}
switch (what)
{
case SUGGESTED_W: return suggested_w;
case SUGGESTED_H: return suggested_h;
case MAXIMUM_W: return maximum_w;
case MAXIMUM_H: return maximum_h;
case MINIMUM_W: return minimum_w;
case MINIMUM_H: return minimum_h;
}
return AUTOWH;
}
void BaseWnd::setStartHidden(int wtf)
{
start_hidden = wtf;
}
//PORTME
#ifdef _WIN32
#define EQUAL_CLSNAME(__name1, __name2)\
(CSTR_EQUAL == CompareStringW(MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), SORT_DEFAULT),\
NORM_IGNORECASE, (__name1), -1, (__name2), -1))
static BOOL BaseWnd_IsFrameWindow(HWND hwnd)
{
WCHAR szClass[64] = {0};
if (NULL == hwnd || !GetClassNameW(hwnd, szClass, ARRAYSIZE(szClass)))
return FALSE;
return EQUAL_CLSNAME(szClass, L"Winamp v1.x") ||
EQUAL_CLSNAME(szClass, L"BaseWindow_RootWnd");
}
LRESULT BaseWnd::wndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
if (!isDestroying()) switch (uMsg)
{
case WM_DEFER_CALLBACK:
timerclient_onDeferredCallback(wParam, lParam);
break;
case WM_SYSCOMMAND:
{
if ((wParam & 0xfff0) == SC_SCREENSAVE || (wParam & 0xfff0) == SC_MONITORPOWER)
{
ifc_window *main = WASABI_API_WND->main_getRootWnd();
if (main && main != this)
return SendMessageW(main->gethWnd(), uMsg, wParam, lParam);
}
break;
}
//CUT case WM_CREATE:
//CUT hwnd = hWnd;
//CUT break;
//CUT case WM_CLOSE:
//CUT return 0;
case WM_PAINT:
{
if (inonresize && !wantRedrawOnResize()) return 1;
ASSERT(hwnd != NULL);
if (!isVisible(1) || IsIconic(hWnd)) break;
RECT r;
if (GetUpdateRect(hWnd, &r, FALSE))
{
if (virtualOnPaint())
{
return 0;
}
}
}
break;
case WM_PRINTCLIENT:
{
bool old_cloaked = (!!cloaked);
cloaked = true;
DCCanvas dc((HDC)wParam, this);
paint(&dc, 0);
cloaked = old_cloaked;
if (lParam & PRF_CHILDREN)
{
RECT wnd_size;
GetWindowRect(hwnd, &wnd_size);
HWND child = GetWindow(hwnd, GW_CHILD);
while (child != NULL)
{
if (GetWindowLongPtrW(child, GWL_STYLE) & WS_VISIBLE)
{
RECT child_size;
GetWindowRect(child, &child_size);
if (child_size.right && child_size.bottom)
{
BltCanvas bitmap(child_size.right, child_size.bottom, child);;
SendMessageW(child, WM_PRINT, (WPARAM)bitmap.getHDC(), PRF_CHILDREN | PRF_CLIENT | PRF_NONCLIENT/*| PRF_OWNED*/);
//bitmap->makeAlpha(255);
//set alpha to 255
int w, h;
bitmap.getDim(&w, &h, NULL);
ARGB32 *m_pBits = (ARGB32 *)bitmap.getBits();
int nwords = w*h;
for (; nwords > 0; nwords--, m_pBits++)
{
unsigned char *pixel = (unsigned char *)m_pBits;
pixel[3] = 255; // alpha
}
POINT offset;
offset.x = child_size.left - wnd_size.left;
offset.y = child_size.top - wnd_size.top;
//BLENDFUNCTION blendFn;
//blendFn.BlendOp = AC_SRC_OVER;
//blendFn.BlendFlags = 0;
//blendFn.SourceConstantAlpha = 255;
//blendFn.AlphaFormat = 0;
//AlphaBlend((HDC)wParam, offset.x, offset.y, child_size.right-child_size.left, child_size.bottom-child_size.top,
// bitmap->getHDC(), 0, 0, child_size.right-child_size.left, child_size.bottom-child_size.top, blendFn);
StretchBlt((HDC)wParam, offset.x, offset.y, child_size.right-child_size.left, child_size.bottom-child_size.top,
bitmap.getHDC(), 0, 0, child_size.right-child_size.left, child_size.bottom-child_size.top, SRCCOPY);
}
}
child = GetWindow(child, GW_HWNDNEXT);
}
}
}
return 0;
//CUT case WM_NCPAINT: return 0;
//CUT case WM_SYNCPAINT: return 0;
case WM_SETCURSOR:
if (checkModal()) return TRUE;
if (hWnd == (HWND)wParam)
{
DWORD windowStyle = (DWORD)GetWindowLongPtrW(hWnd, GWL_STYLE);
switch(HIWORD(lParam))
{
case WM_LBUTTONDOWN:
case WM_RBUTTONDOWN:
case WM_MBUTTONDOWN:
case 0x020B/*WM_XBUTTONDOWN*/:
DisabledWindow_OnMouseClick(hWnd);
break;
}
int ct = BASEWND_CURSOR_POINTER;
int _x, _y;
Wasabi::Std::getMousePos(&_x, &_y);
screenToClient(&_x, &_y);
OSCURSORHANDLE c = NULL;
if (0 == (WS_DISABLED & windowStyle))
{
if (!handleVirtualChildMsg(WM_SETCURSOR, _x, _y, &ct, &c))
{
ct = getCursorType(_x, _y);
}
}
wchar_t *wincursor = NULL;
switch (ct)
{
case BASEWND_CURSOR_USERSET:
if (c == NULL)
c = getCustomCursor(_x, _y);
if (c != NULL)
{
SetCursor(c);
return TRUE;
}
else wincursor = IDC_ARROW; // Ensure to have at least a cursor
break;
case BASEWND_CURSOR_POINTER:
wincursor = IDC_ARROW;
break;
case BASEWND_CURSOR_NORTHSOUTH:
wincursor = IDC_SIZENS;
break;
case BASEWND_CURSOR_EASTWEST:
wincursor = IDC_SIZEWE;
break;
case BASEWND_CURSOR_NORTHWEST_SOUTHEAST:
wincursor = IDC_SIZENWSE;
break;
case BASEWND_CURSOR_NORTHEAST_SOUTHWEST:
wincursor = IDC_SIZENESW;
break;
case BASEWND_CURSOR_4WAY:
wincursor = IDC_SIZEALL;
break;
case BASEWND_CURSOR_EDIT:
wincursor = IDC_IBEAM;
break;
default:
wincursor = IDC_ARROW;
break;
}
if (wincursor != NULL)
{
SetCursor(LoadCursor(NULL, wincursor));
return TRUE;
}
}
return FALSE;
case WM_TIMER:
timerCallback((int)wParam);
return 0;
case WM_GETOBJECT:
if (lParam == OBJID_CLIENT)
{
Accessible *acc = getAccessibleObject();
if (acc != NULL)
{
LRESULT lAcc = acc->getOSHandle((int)wParam);
return lAcc;
}
}
break; // Fall through to DefWindowProc
case WM_SETFOCUS:
if (!focusEventsEnabled) break;
if (isInited())
{
if (rootfocus != NULL && rootfocus != this)
{
if (rootfocus != curVirtualChildFocus)
rootfocus->setFocus();
break;
}
else
{
if (wantFocus())
{
onGetFocus();
break;
}
else
{
ifc_window *w = getTab(TAB_GETFIRST);
if (w != NULL)
{
w->setFocus();
}
}
}
}
break;
case WM_KILLFOCUS:
{
ifc_window *rp = getRootParent();
if (!WASABI_API_WND->rootwndIsValid(rp) || !Wasabi::Std::Wnd::isValidWnd(rp->getOsWindowHandle())) break;
if (!focusEventsEnabled) break;
#ifdef WASABI_COMPILE_WND
if (WASABI_API_WND) WASABI_API_WND->forwardOnKillFocus(); // resets the keyboard active keys buffer
#endif
if (!WASABI_API_WND->rootwndIsValid(curVirtualChildFocus)) curVirtualChildFocus = NULL;
if (curVirtualChildFocus)
{
curVirtualChildFocus->onKillFocus();
curVirtualChildFocus = NULL;
}
else
if (hasfocus) onKillFocus();
break;
}
// dragging and dropping
case WM_LBUTTONDOWN:
{
if (lParam == 0xdeadc0de)
return 1;
if (bufferizeLockedUIMsg(uMsg, (int)wParam, (int)lParam))
return 0;
WASABI_API_WND->popupexit_check(this);
if (checkModal())
return 0;
abortTip();
int xPos = (signed short)LOWORD(lParam);
int yPos = (signed short)HIWORD(lParam);
xPos = (int)((float)xPos / getRenderRatio());
yPos = (int)((float)yPos / getRenderRatio());
if (!getCapture() && hasVirtualChildren() && handleVirtualChildMsg(WM_LBUTTONDOWN, xPos, yPos))
return 0;
if (isEnabled() && !dragging)
{
autoFocus(this);
int r = 0;
if (wantLeftClicks())
r = onLeftButtonDown(xPos, yPos);
if (checkDoubleClick(uMsg, xPos, yPos) && wantDoubleClicks() && onLeftButtonDblClk(xPos, yPos))
return 0;
return r;
}
}
break;
case WM_RBUTTONDOWN:
{
if (lParam == 0xdeadc0de) return 1;
if (bufferizeLockedUIMsg(uMsg, (int)wParam, (int)lParam)) return 0;
WASABI_API_WND->popupexit_check(this);
if (checkModal()) return 0;
abortTip();
int xPos = (signed short)LOWORD(lParam);
int yPos = (signed short)HIWORD(lParam);
xPos = (int)((float)xPos / getRenderRatio());
yPos = (int)((float)yPos / getRenderRatio());
if (!getCapture() && hasVirtualChildren())
if (handleVirtualChildMsg(WM_RBUTTONDOWN, xPos, yPos))
return 0;
if (isEnabled() && !dragging)
{
autoFocus(this);
int r = 0;
if (wantRightClicks())
r = onRightButtonDown(xPos, yPos);
if (checkDoubleClick(uMsg, xPos, yPos) && wantDoubleClicks()) if (onRightButtonDblClk(xPos, yPos)) return 0;
return r;
}
}
break;
case WM_MOUSEHOVER:
if (checkModal()) return 0;
if (!getCapture() && hasVirtualChildren())
if (handleVirtualChildMsg(WM_MOUSEHOVER, 0, 0))
return 0;
break;
case WM_MOUSEMOVE:
{
/* static int mm=0;
DebugString("mousemove %d\n", mm++);*/
if (checkModal()) return 0;
int xPos = (signed short)LOWORD(lParam);
int yPos = (signed short)HIWORD(lParam);
xPos = (int)((float)xPos / getRenderRatio());
yPos = (int)((float)yPos / getRenderRatio());
if (dragging)
{
POINT pt = {xPos, yPos};
clientToScreen(&pt);
ifc_window *targ;
int candrop = 0;
// find the window the mouse is over
targ = NULL;
if (stickyWnd)
{
RECT wr;
GetWindowRect(stickyWnd->getOsWindowHandle(), &wr);
if (pt.x >= wr.left - sticky.left &&
pt.x <= wr.right + sticky.right &&
pt.y >= wr.top - sticky.top &&
pt.y <= wr.bottom + sticky.bottom) targ = stickyWnd;
else stickyWnd = NULL;
}
if (targ == NULL && WASABI_API_WND) targ = WASABI_API_WND->rootWndFromPoint(&pt); // FG> not to self, check
DI prevtargdi(prevtarg);
DI targdi(targ);
if (prevtarg != targ)
{
// window switch
if (prevtarg != NULL) prevtargdi.dragLeave(this);
if (targ != NULL) targdi.dragEnter(this);
}
if (targ != NULL)
candrop = targdi.dragOver(pt.x, pt.y, this);
if (targ == NULL || !candrop)
SetCursor(LoadCursor(NULL, MAKEINTRESOURCE(IDC_NO)));
else
SetCursor(LoadCursor(NULL, MAKEINTRESOURCE(IDC_APPSTARTING)));
prevtarg = targ;
}
else if (isEnabled())
{
tipbeenchecked = FALSE;
if (!getCapture() && hasVirtualChildren())
{
if (handleVirtualChildMsg(WM_MOUSEMOVE, xPos, yPos))
return 0;
}
if (getCapture())
{
if (wantMouseMoves())
if (onMouseMove(xPos, yPos))
return 0;
}
if (!tipbeenchecked) onTipMouseMove();
return 0;
}
}
break;
case WM_LBUTTONUP:
{
if (lParam == 0xdeadc0de) return 1;
if (bufferizeLockedUIMsg(uMsg, (int)wParam, (int)lParam)) return 0;
if (checkModal()) return 0;
int xPos = (signed short)LOWORD(lParam);
int yPos = (signed short)HIWORD(lParam);
xPos = (int)((float)xPos / getRenderRatio());
yPos = (int)((float)yPos / getRenderRatio());
abortTip();
if (!dragging && !getCapture() && hasVirtualChildren())
{
if (handleVirtualChildMsg(WM_LBUTTONUP, xPos, yPos))
return 0;
}
if (dragging)
{
clientToScreen(&xPos, &yPos);
int res = 0;
if (prevtarg != NULL)
{
res = DI(prevtarg).dragDrop(this, xPos, yPos);
}
// inform source what happened
dragComplete(res);
resetDragSet();
prevtarg = NULL;
stickyWnd = NULL;
suggestedTitle = NULL;
SetCursor(LoadCursor(NULL, MAKEINTRESOURCE(IDC_ARROW)));
Wasabi::Std::Wnd::releaseCapture();
dragging = 0;
}
else if (isEnabled())
{
if (wantLeftClicks())
if (onLeftButtonUp(xPos, yPos)) return 0;
}
}
break;
case WM_RBUTTONUP:
{
if (lParam == 0xdeadc0de) return 1;
if (bufferizeLockedUIMsg(uMsg, (int)wParam, (int)lParam)) return 0;
if (checkModal()) return 0;
abortTip();
int xPos = (signed short)LOWORD(lParam);
int yPos = (signed short)HIWORD(lParam);
xPos = (int)((float)xPos / getRenderRatio());
yPos = (int)((float)yPos / getRenderRatio());
if (!getCapture() && hasVirtualChildren())
{
if (handleVirtualChildMsg(WM_RBUTTONUP, xPos, yPos))
return 0;
}
if (isEnabled() && !dragging)
{
if (wantRightClicks())
if (onRightButtonUp(xPos, yPos)) return 0;
}
}
break;
case WM_CONTEXTMENU:
{
if (bufferizeLockedUIMsg(uMsg, (int)wParam, (int)lParam)) return 0;
if (checkModal()) return 0;
ASSERT(hWnd != NULL);
int xPos = (signed short)LOWORD(lParam);
int yPos = (signed short)HIWORD(lParam);
if (hWnd == getOsWindowHandle())
{
if (wantContextMenus())
if (onContextMenu(xPos, yPos)) return 0;
}
else if (GetParent(hWnd) == getOsWindowHandle())
{
if (wantContextMenus())
if (onChildContextMenu(xPos, yPos)) return 0;
}
}
break;
case WM_ERASEBKGND:
return (onEraseBkgnd((HDC)wParam));
case WM_MOUSEWHEEL:
{
abortTip();
int l, a;
l = (short)HIWORD(wParam) / 120;
a = (short)HIWORD(wParam);
if (!l)
if (a > 0) l = 1;
else if (a < 0)l = 0;
a = l >= 0 ? l : -l;
if (GetAsyncKeyState(VK_MBUTTON)&0x8000)
{
if (l >= 0) l = 0; // Fast Forward 5s
else l = 1; // Rewind 5s
}
else
{
if (l >= 0) l = 2; // Volume up
else l = 3; // Volume down
}
int r = 0;
if (l & 1)
r = onMouseWheelDown(!(BOOL)(l & 2), a);
else
r = onMouseWheelUp(!(BOOL)(l & 2), a);
if (r == 0)
{
r = WASABI_API_WND->forwardOnMouseWheel(l, a);
}
// if it wasn't handled by this wnd, nor by the api, send it to the main wnd, unless we're it
if (r == 0)
{
if (WASABI_API_WND->main_getRootWnd() != this)
r = (int)SendMessageW(WASABI_API_WND->main_getRootWnd()->gethWnd(), uMsg, wParam, lParam);
}
return r;
}
case WM_WA_RELOAD:
{
if (wParam == 0)
freeResources();
else
reloadResources();
return 0;
}
case WM_WA_GETFBSIZE:
{
SIZE *s = (SIZE *)wParam;
s->cx = rwidth;
s->cy = rheight;
return 0;
}
case WM_USER + 8976: // wheel in tip, delete tip
abortTip();
return 0;
case WM_CHAR:
if (bufferizeLockedUIMsg(uMsg, (int)wParam, (int)lParam)) return 0;
if (WASABI_API_WND->interceptOnChar((TCHAR) wParam)) return 0;
if (curVirtualChildFocus == NULL)
{
if (onChar(((TCHAR) wParam))) return 0;
}
else
{
if (curVirtualChildFocus->onChar(((TCHAR) wParam))) return 0;
}
if (WASABI_API_WND && WASABI_API_WND->forwardOnChar(this, (TCHAR) wParam, (int)lParam)) return 0;
break;
case WM_KEYDOWN:
if (bufferizeLockedUIMsg(uMsg, (int)wParam, (int)lParam)) return 0;
if (WASABI_API_WND->interceptOnKeyDown((int) wParam)) return 0;
if (curVirtualChildFocus == NULL)
{
if (onKeyDown((int) wParam)) return 0;
}
else
{
if (curVirtualChildFocus->onKeyDown((int)wParam)) return 0;
}
if (WASABI_API_WND && WASABI_API_WND->forwardOnKeyDown(this, (int) wParam, (int)lParam)) return 0;
break;
case WM_KEYUP:
if (bufferizeLockedUIMsg(uMsg, (int)wParam, (int)lParam)) return 0;
if (WASABI_API_WND->interceptOnKeyUp((int) wParam)) return 0;
if (curVirtualChildFocus == NULL)
{
if (onKeyUp((int) wParam)) return 0;
}
else
{
if (curVirtualChildFocus->onKeyUp((int)wParam)) return 0;
}
if (WASABI_API_WND && WASABI_API_WND->forwardOnKeyUp(this, (int) wParam, (int)lParam)) return 0;
break;
case WM_SYSKEYDOWN:
if (bufferizeLockedUIMsg(uMsg, (int)wParam, (int)lParam)) return 0;
if (WASABI_API_WND->interceptOnSysKeyDown((int) wParam, (int)lParam)) return 0;
if (curVirtualChildFocus == NULL)
{
if (onSysKeyDown((int) wParam, (int)lParam)) return 0;
}
else
{
if (curVirtualChildFocus->onSysKeyDown((int)wParam, (int)lParam)) return 0;
}
if (WASABI_API_WND && WASABI_API_WND->forwardOnSysKeyDown(this, (int) wParam, (int)lParam)) return 0;
break;
case WM_SYSKEYUP:
if (bufferizeLockedUIMsg(uMsg, (int)wParam, (int)lParam)) return 0;
if (WASABI_API_WND->interceptOnSysKeyUp((int) wParam, (int)lParam)) return 0;
if (curVirtualChildFocus == NULL)
{
if (onSysKeyUp((int) wParam, (int)lParam)) return 0;
}
else
{
if (curVirtualChildFocus->onSysKeyUp((int)wParam, (int)lParam)) return 0;
}
if (WASABI_API_WND && WASABI_API_WND->forwardOnSysKeyUp(this, (int) wParam, (int)lParam)) return 0;
break;
case WM_MOUSEACTIVATE:
{
if (checkModal() || !wantActivation())
return MA_NOACTIVATE;
//SetFocus(getOsWindowHandle());
return MA_ACTIVATE;
}
case WM_ACTIVATEAPP:
if (wParam == FALSE)
{
if (WASABI_API_WND != NULL)
{
WASABI_API_WND->popupexit_signal();
WASABI_API_SYSCB->syscb_issueCallback(SysCallback::GC, GarbageCollectCallback::GARBAGECOLLECT);
WASABI_API_WND->kbdReset();
if (ghosthwnd.getNumItems() > 0 && ghostbust)
{
ghostbust = 0; postDeferredCallback(DC_KILLGHOST);
}
return 0;
}
}
break;
case WM_ACTIVATE:
switch(LOWORD(wParam))
{
case WA_ACTIVE:
case WA_CLICKACTIVE:
if (WASABI_API_WND != NULL)
WASABI_API_WND->popupexit_check(this);
onActivate();
if (WA_CLICKACTIVE == LOWORD(wParam))
{
POINT pt;
DWORD pts = GetMessagePos();
POINTSTOPOINT(pt, pts);
MapWindowPoints(HWND_DESKTOP, hwnd, &pt, 1);
HWND hTarget = ChildWindowFromPointEx(hwnd, pt, CWP_SKIPINVISIBLE | CWP_SKIPDISABLED | CWP_SKIPTRANSPARENT);
if (hTarget && hTarget != hwnd) lastActiveWnd = hTarget;
}
if (lastActiveWnd != hwnd && NULL != lastActiveWnd && IsWindow(lastActiveWnd))
{
SendMessageW(lastActiveWnd, uMsg, wParam, lParam);
return 0;
}
break;
default:
onDeactivate();
lastActiveWnd = GetFocus();
if (NULL != lastActiveWnd && !IsChild(hwnd, lastActiveWnd))
lastActiveWnd = NULL;
{
#ifndef ARRAYSIZE
#define ARRAYSIZE(x) (sizeof(x)/sizeof(*x))
#endif
if (NULL != lastActiveWnd && !BaseWnd_IsFrameWindow(lastActiveWnd))
{
while (lastActiveWnd)
{
if (BaseWnd_IsFrameWindow(GetWindow(lastActiveWnd, GW_OWNER)))
break;
lastActiveWnd = GetAncestor(lastActiveWnd, GA_PARENT);
}
}
}
if (lastActiveWnd != hwnd && NULL != lastActiveWnd)
{
SendMessageW(lastActiveWnd, uMsg, wParam, lParam);
return 0;
}
break;
}
break;
case WM_NCACTIVATE:
if (allowDeactivation())
return TRUE;
return FALSE;
case WM_WINDOWPOSCHANGING:
{
if (!isVirtual() && Wasabi::Std::Wnd::isPopup(hwnd))
{
WINDOWPOS *wp = (WINDOWPOS *)lParam;
if (wp->x != rx || wp->y != ry) wp->flags |= SWP_NOMOVE;
}
}
break;
case WM_WINDOWPOSCHANGED:
{
WINDOWPOS *lpwp = (WINDOWPOS *)lParam; // points to size and position data
if (lpwp->flags & SWP_HIDEWINDOW)
{
minimized = 1;
onMinimize();
}
else if (lpwp->flags & SWP_SHOWWINDOW)
{
minimized = 0;
onRestore();
}
if (!inonresize)
{
int w = rwidth;
int h = rheight;
multRatio(&w, &h);
if (lpwp->cx != w || lpwp->cy != h)
{
DebugStringW(L"external onResize\n");
w = lpwp->cx;
h = lpwp->cy;
divRatio(&w, &h);
setRSize(rx, ry, w, h);
if (isPostOnInit())
onResize();
}
}
onPostedMove();
return 0;
}
case WM_DROPFILES:
{
if (checkModal()) break;
WASABI_API_WND->pushModalWnd();
onExternalDropBegin();
HDROP h = (HDROP)wParam;
POINT dp = {0};
DragQueryPoint(h, &dp);
clientToScreen(&dp);
// build a file list
wchar_t buf[WA_MAX_PATH] = {0};
PtrList<FilenamePS> keep;
SetCursor(LoadCursor(NULL, IDC_WAIT));
//CUT #if UTF8
//CUT // doesn't really need UTF8, the "buf" is never written to.
//CUT // made to be NULL to enforce this concept.
int nfiles = DragQueryFile(h, 0xffffffff, NULL, 0);
//CUT #else
//CUT int nfiles = DragQueryFile(h, 0xffffffff, buf, sizeof(buf));
//CUT #endif
// convert them all to PlayItem *'s
for (int i = 0; i < nfiles; i++)
{
DragQueryFileW(h, i, buf, WA_MAX_PATH);
addDroppedFile(buf, &keep); // recursive
}
SetCursor(LoadCursor(NULL, IDC_ARROW));
dragging = 1;
if (dragEnter(this))
{
if (dragOver(dp.x, dp.y, this)) dragDrop(this, dp.x, dp.y);
}
else
{
dragLeave(this);
#ifdef FORWARD_DRAGNDROP
HWND w = WASABI_API_WND->main_getRootWnd()->gethWnd();
SendMessageW(w, WM_DROPFILES, wParam, lParam);
#endif
}
dragging = 0;
// remove data
keep.deleteAll();
resetDragSet();
onExternalDropEnd();
WASABI_API_WND->popModalWnd();
}
return 0; // dropfiles
case WM_CAPTURECHANGED:
/* static int cc=0;
DebugString("capture changed! %d\n", cc++);*/
if (preventcancelcapture) return 0;
inputCaptured = 0;
if (curVirtualChildCaptured != NULL)
{
ifc_window *w = curVirtualChildCaptured;
curVirtualChildCaptured = NULL;
w->onCancelCapture();
}
else
{
onCancelCapture();
}
return 0;
} //switch
if (WINAMP_WM_DIRECT_MOUSE_WHEEL == uMsg &&
WM_NULL != WINAMP_WM_DIRECT_MOUSE_WHEEL)
{
wndProc(hWnd, WM_MOUSEWHEEL, wParam, lParam);
return TRUE;
}
if (uMsg >= WM_USER)
{
int ret;
if (onUserMessage(uMsg, (int)wParam, (int)lParam, &ret))
return ret;
return 0;
}
return DefWindowProcW(hWnd, uMsg, wParam, lParam);
}
#endif
int BaseWnd::onUserMessage(int msg, int w, int l, int *r)
{
return 0;
}
int BaseWnd::checkDoubleClick(int b, int x, int y)
{
#ifdef _WIN32
uint32_t now = Wasabi::Std::getTickCount();
switch (b)
{
case WM_LBUTTONDOWN:
if (lastClick[0] > now - Wasabi::Std::getDoubleClickDelay())
{
lastClick[0] = 0;
if (ABS(lastClickP[0].x - x) > Wasabi::Std::getDoubleClickX() || ABS(lastClickP[0].y - y) > Wasabi::Std::getDoubleClickY()) return 0;
return 1;
}
lastClick[0] = now;
lastClickP[0].x = x;
lastClickP[0].y = y;
break;
case WM_RBUTTONDOWN:
if (lastClick[1] > now - Wasabi::Std::getDoubleClickDelay())
{
lastClick[1] = 0;
if (ABS(lastClickP[1].x - x) > Wasabi::Std::getDoubleClickX() || ABS(lastClickP[1].y - y) > Wasabi::Std::getDoubleClickY()) return 0;
return 1;
}
lastClick[1] = now;
lastClickP[1].x = x;
lastClickP[1].y = y;
break;
}
#else
#warning port me
#endif
return 0;
}
int BaseWnd::onMouseWheelUp(int click, int lines)
{
return 0;
}
int BaseWnd::onMouseWheelDown(int click, int lines)
{
return 0;
}
int BaseWnd::onContextMenu(int x, int y)
{
return 0;
}
int BaseWnd::onChildContextMenu(int x, int y)
{
return 0;
}
int BaseWnd::onDeferredCallback(intptr_t param1, intptr_t param2)
{
switch (param1)
{
case DEFERREDCB_FLUSHPAINT:
do_flushPaint();
break;
case DEFERREDCB_INVALIDATE:
if (isPostOnInit())
invalidate();
break;
case DC_KILLGHOST:
if (ghosthwnd.getNumItems() > 0)
{
preventcancelcapture = 1;
for (int i = 0;i < ghosthwnd.getNumItems();i++)
Wasabi::Std::Wnd::destroyWnd(ghosthwnd.enumItem(i));
ghosthwnd.freeAll();
preventcancelcapture = 0;
}
break;
case DEFERREDCB_FOCUSFIRST:
assignRootFocus(NULL);
if (Wasabi::Std::Wnd::getFocus() == getOsWindowHandle())
{
focusNext();
}
break;
case 0x7849 /*DEFERREDCB_ONHIDE*/:
{
foreach(rootwndchildren)
ifc_window *w = rootwndchildren.getfor();
if (w->isVisible(1)) // check internal flag only
w->onSetVisible(0);
endfor;
dependent_sendEvent(BaseWnd::depend_getClassGuid(), Event_SETVISIBLE, 0);
break;
}
}
return 0;
}
int BaseWnd::onPaint(Canvas *canvas)
{
#if 0
// example:
PaintCanvas c;
if (!c.beginPaint(this)) return 0;
(do some painting)
c will self -destruct on return
#endif
if (renderbasetexture)
{
PaintCanvas paintcanvas;
if (canvas == NULL)
{
if (!paintcanvas.beginPaint(this)) return 0;
canvas = &paintcanvas;
}
RECT r;
getNonClientRect(&r);
RenderBaseTexture(canvas, r);
}
return 0;
}
int BaseWnd::onPaint(Canvas *canvas, api_region *h)
{
if (!canvas) return onPaint(canvas);
#ifdef _WIN32
int sdc = SaveDC(canvas->getHDC());
#elif defined(__APPLE__)
CGContextSaveGState(canvas->getHDC());
#endif
canvas->selectClipRgn(h);
int rs = onPaint(canvas);
#ifdef _WIN32
RestoreDC(canvas->getHDC(), sdc);
#elif defined(__APPLE__)
CGContextRestoreGState(canvas->getHDC());
#endif
return rs;
}
int BaseWnd::getTransparency()
{
return wndalpha;
}
void BaseWnd::setTransparency(int amount)
{
//if (wndalpha == amount) return;
if (amount == 254) amount = 255;
if (amount == 1) amount = 0;
if (amount != -1) wndalpha = amount; else amount = wndalpha;
if (!Wasabi::Std::Wnd::isDesktopAlphaAvailable())
{
wndalpha = 255;
return ;
}
if (w2k_alpha)
{
invalidate();
return ;
}
#ifdef WIN32
if (!isInited() || isVirtual()) return ;
if (!Wasabi::Std::Wnd::isValidWnd(getOsWindowHandle())) return ;
if (amount < -1) amount = 0;
else if (amount > 255) amount = 255;
//CUT DWORD dwLong = GetWindowLong(hwnd, GWL_EXSTYLE);
if (amount == 255 && !forceTransparencyFlag())
{
Wasabi::Std::Wnd::setLayeredWnd(hwnd, FALSE);
//CUT if (dwLong & WS_EX_LAYERED)
//CUT SetWindowLong(hwnd, GWL_EXSTYLE, dwLong & ~WS_EX_LAYERED);
has_alpha_flag = 0;
}
else
{
if (!Wasabi::Std::Wnd::isLayeredWnd(hwnd))
Wasabi::Std::Wnd::setLayeredWnd(hwnd, TRUE);
//CUT if (!(dwLong & WS_EX_LAYERED))
//CUT SetWindowLong(hwnd, GWL_EXSTYLE, dwLong | WS_EX_LAYERED);
Wasabi::Std::Wnd::setLayeredAlpha(hwnd, amount);
//CUT setLayeredWindowAttributes(hwnd, RGB(0,0,0), amount, LWA_ALPHA);
has_alpha_flag = 1;
}
#endif
}
int BaseWnd::forceTransparencyFlag()
{
return 0;
}
int BaseWnd::beginCapture()
{
if (!getCapture())
{
disable_tooltip_til_recapture = 0;
curVirtualChildCaptured = NULL;
/* oldCapture = */Wasabi::Std::Wnd::setCapture(getOsWindowHandle());
/* if (oldCapture) {
DebugString("Stolen capture detected, this may be ok, but try to avoid it if possible. Saving old capture\n");
}*/
inputCaptured = 1;
}
return 1;
}
int BaseWnd::endCapture()
{
preventcancelcapture = 1;
if (Wasabi::Std::Wnd::getCapture() == getOsWindowHandle()) Wasabi::Std::Wnd::releaseCapture();
/* if (oldCapture) {
DebugString("Restoring old capture\n");
SetCapture(oldCapture);
oldCapture = NULL;
}*/
inputCaptured = 0;
preventcancelcapture = 0;
return 1;
}
int BaseWnd::getCapture()
{
if (inputCaptured && Wasabi::Std::Wnd::getCapture() == getOsWindowHandle() && curVirtualChildCaptured == NULL) return 1;
return 0;
}
void BaseWnd::cancelCapture()
{
if (curVirtualChildCaptured != NULL)
{
curVirtualChildCaptured->cancelCapture();
return ;
}
if (getCapture()) endCapture();
onCancelCapture();
}
int BaseWnd::onMouseMove(int x, int y)
{
onTipMouseMove();
return 0;
}
void BaseWnd::onTipMouseMove()
{
POINT p;
if (dragging) return ;
if (disable_tooltip_til_recapture) return ;
tipbeenchecked = TRUE;
Wasabi::Std::getMousePos(&p);
if (WASABI_API_WND->rootWndFromPoint(&p) != (ifc_window *)this)
{
// leaving area
tip_done = FALSE;
if (tipawaytimer)
killTimer(TIP_AWAY_ID);
tipawaytimer = FALSE;
if (tipshowtimer)
{
// TODO: on the mac, use CreateMouseTrackingRegion
TRACKMOUSEEVENT tracker;
tracker.cbSize=sizeof(tracker);
tracker.dwFlags = TME_HOVER|TME_CANCEL;
tracker.hwndTrack = this->getOsWindowHandle();
tracker.dwHoverTime = TIP_TIMER_THRESHOLD;
TrackMouseEvent(&tracker);
}
tipshowtimer = FALSE;
destroyTip();
}
else
{
// moving in area
const wchar_t *t = getTip();
if (!disable_tooltip_til_recapture && !tipshowtimer && !tip_done && t != NULL && *t != 0)
{
//entering area & need tip
// TODO: on the mac, use CreateMouseTrackingRegion
TRACKMOUSEEVENT tracker;
tracker.cbSize=sizeof(tracker);
tracker.dwFlags = TME_HOVER;
tracker.hwndTrack = this->getOsWindowHandle();
tracker.dwHoverTime = TIP_TIMER_THRESHOLD;
TrackMouseEvent(&tracker);
tipshowtimer = TRUE;
}
/*else if (tipshowtimer)
{
TRACKMOUSEEVENT tracker;
tracker.cbSize=sizeof(tracker);
tracker.dwFlags = TME_HOVER;
tracker.hwndTrack = this->getOsWindowHandle();
tracker.dwHoverTime = TIP_TIMER_THRESHOLD;
TrackMouseEvent(&tracker);
}*/
}
}
int BaseWnd::onLeftButtonDblClk(int x, int y)
{
return 0;
}
int BaseWnd::onRightButtonDblClk(int x, int y)
{
return 0;
}
int BaseWnd::onGetFocus()
{
// return TRUE if you override this
hasfocus = 1;
notifyParent(ChildNotify::GOTFOCUS);
getRootParent()->onSetRootFocus(this);
invalidate();
Accessible *a = getAccessibleObject();
if (a != NULL)
a->onGetFocus();
return 1;
}
int BaseWnd::onKillFocus()
{
// return TRUE if you override this
hasfocus = 0;
notifyParent(ChildNotify::KILLFOCUS);
invalidate();
return 1;
}
#if defined(_WIN64)
int BaseWnd::childNotify(ifc_window* child, int msg, int p1, int p2)
{
return 0;
}
#else
int BaseWnd::childNotify(ifc_window *child, int msg, intptr_t p1, intptr_t p2)
{
return 0;
}
#endif
int BaseWnd::addDragItem(const wchar_t *droptype, void *item)
{
ASSERT(droptype != NULL);
if (item == NULL) return -1;
DragSet *set;
int pos = dragCheckData(droptype);
if (pos == -1)
{
set = new DragSet();
set->setName(droptype);
dragsets.addItem(set);
pos = dragsets.getNumItems() - 1;
}
else set = dragsets[pos];
set->addItem(item);
return pos;
}
#ifdef _WIN32
int BaseWnd::handleDrag()
{
abortTip();
if (dragsets.getNumItems() == 0) return 0;
Wasabi::Std::Wnd::setCapture(hwnd);
SetCursor(LoadCursor(NULL, MAKEINTRESOURCE(IDC_APPSTARTING)));
dragging = 1;
stickyWnd = NULL;
return 1;
}
#endif
int BaseWnd::resetDragSet()
{
dragsets.deleteAll();
return 1;
}
int BaseWnd::dragEnter(ifc_window *sourceWnd)
{
ifc_window *rw = getParent(); //api_window::rootwndFromRootWnd(getParent()); //FG> note to self, check!
if (rw) return DI(rw).dragEnter(sourceWnd);
return 0;
}
int BaseWnd::dragSetSticky(ifc_window *wnd, int left, int right, int up, int down)
{
ASSERT(dragging);
stickyWnd = wnd;
if (left < 0) left = 0;
if (right < 0) right = 0;
if (up < 0) up = 0;
if (down < 0) down = 0;
Wasabi::Std::setRect(&sticky, left, up, right, down);
return 1;
}
void BaseWnd::setSuggestedDropTitle(const wchar_t *title)
{
ASSERT(title != NULL);
suggestedTitle = title;
}
const wchar_t *BaseWnd::dragGetSuggestedDropTitle()
{
return suggestedTitle; // can be NULL
}
int BaseWnd::dragCheckData(const wchar_t *type, int *nitems)
{
for (int i = 0; i < dragsets.getNumItems(); i++)
{
if (!WCSICMP(type, dragsets[i]->getName()))
{
if (nitems != NULL) *nitems = dragsets[i]->getNumItems();
return i;
}
}
return -1;
}
void *BaseWnd::dragGetData(int slot, int itemnum)
{
if (slot < 0 || slot >= dragsets.getNumItems()) return 0;
if (itemnum < 0 || itemnum >= dragsets[slot]->getNumItems()) return 0;
return dragsets[slot]->enumItem(itemnum);
}
void BaseWnd::addDroppedFile(const wchar_t *filename, PtrList<FilenamePS> *plist)
{
#ifdef RECURSE_SUBDIRS_ON_DROP
const char *slash = filename + STRLEN(filename) - 1;
for (; slash > filename; slash--) if (*slash == '/' || *slash == '\\') break;
if (STREQL(slash + 1, ".") || STREQL(slash + 1, "..")) return ;
char buf[WA_MAX_PATH] = {0};
STRCPY(buf, filename);
// try to resolve shortcuts
char *ext = buf + STRLEN(buf) - 1;
for (; ext > buf; ext--) if (*ext == '.' || *ext == '\\' || *ext == '/') break;
#ifdef WIN32
if (!STRICMP(ext, ".lnk"))
{
char buf2[MAX_PATH] = {0};
if (StdFile::resolveShortcut(buf, buf2)) STRCPY(buf, buf2);
}
#endif
int isdir = 0;
// handle root dir specially?
WIN32_FIND_DATA data = {0};
HANDLE r = FindFirstFile(buf, &data);
if (!r) return ;
FindClose(r);
if (data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) isdir = 1;
if (isdir)
{
onExternalDropDirScan(buf);
// enumerate that dir
char search[WA_MAX_PATH] = {0};
wsprintf(search, "%s\\*.*", buf);
HANDLE files = FindFirstFile(search, &data);
if (files == INVALID_HANDLE_VALUE) return ; // nothin' in it
for (;;)
{
wchar_t obuf[WA_MAX_PATH] = {0};
swprintf(obuf, L"%s\\%s", buf, data.cFileName);
addDroppedFile(obuf, plist);
if (!FindNextFile(files, &data))
{
FindClose(files);
return ;
}
}
// should never get here
}
else
{
addDragItem(DD_FILENAME, plist->addItem(new FilenamePS(StringPrintfW(L"file:%s", buf))));
}
#else
addDragItem(DD_FILENAME, plist->addItem(new FilenamePS(StringPrintfW(L"file:%s", filename))));
#endif
}
bool BaseWnd::getNoCopyBits(void)
{
return ncb;
}
void BaseWnd::setNoCopyBits(bool newncb)
{
ncb = newncb;
}
int BaseWnd::onEraseBkgnd(HDC dc)
{
return 1;
}
void BaseWnd::setIcon(OSICONHANDLE icon, int _small)
{
Wasabi::Std::Wnd::setIcon(getOsWindowHandle(), icon, !_small);
//CUT SendMessageW(getOsWindowHandle(), WM_SETICON, _small ? ICON_SMALL : ICON_BIG, (int)icon);
}
const wchar_t *BaseWnd::getTip()
{
return tip;
}
void BaseWnd::setTip(const wchar_t *_tooltip)
{
tip = _tooltip;
abortTip();
}
int BaseWnd::getStartHidden()
{
return start_hidden;
}
void BaseWnd::abortTip()
{
if (tipshowtimer)
{
// TODO: on the mac, use CreateMouseTrackingRegion
TRACKMOUSEEVENT tracker;
tracker.cbSize=sizeof(tracker);
tracker.dwFlags = TME_HOVER|TME_CANCEL;
tracker.hwndTrack = this->getOsWindowHandle();
tracker.dwHoverTime = TIP_TIMER_THRESHOLD;
TrackMouseEvent(&tracker);
}
tipshowtimer = FALSE;
if (tipawaytimer)
killTimer(TIP_AWAY_ID);
tipawaytimer = FALSE;
if (tipdestroytimer)
killTimer(TIP_DESTROYTIMER_ID);
tipdestroytimer = FALSE;
destroyTip();
tip_done = FALSE;
RECT r;
if (getOsWindowHandle() && Wasabi::Std::Wnd::getUpdateRect(getOsWindowHandle(), &r) != 0) // FG> avoids xoring over disapearing tip
repaint();
}
int BaseWnd::isVisible(int within)
{
if (!isVirtual() && !getOsWindowHandle()) return 0;
if (!this_visible) return 0;
if (within) return this_visible; // whatever, local
if (isVirtual()) // virtual, global
if (getParent())
return getParent()->isVisible();
else
return 0;
// non virtual, global
if (Wasabi::Std::Wnd::isPopup(getOsWindowHandle())) return this_visible;
if (!Wasabi::Std::Wnd::isValidWnd(Wasabi::Std::Wnd::getParent(getOsWindowHandle()))) return 0;
if (getParent()) return getParent()->isVisible(); // not a popup, check its parent or fail
return this_visible;
}
void BaseWnd::registerRootWndChild(ifc_window *child)
{
rootwndchildren.addItem(child);
if (child->isVirtual())
virtualChildren.addItem(child);
}
void BaseWnd::unregisterRootWndChild(ifc_window *child)
{
delTabOrderEntry(child);
rootwndchildren.removeItem(child);
if (curVirtualChildCaptured == child)
{
setVirtualChildCapture(NULL);
}
if (curVirtualChildFocus == child)
curVirtualChildFocus = NULL;
virtualChildren.removeItem(child);
//WASABI_API_WND->timer_remove(this, -1);
if (isPostOnInit() && isVisible())
postDeferredCallback(DEFERREDCB_INVALIDATE, 0);
}
int BaseWnd::isVirtual()
{
return 0;
}
//CUT?inline int isInRect(RECT *r,int x,int y) {
//CUT? if (x>=r->left&&x<=r->right&&y>=r->top&&y<=r->bottom) return 1;
//CUT? return 0;
//CUT?}
int BaseWnd::ensureVirtualCanvasOk()
{
RECT ncr;
if (isVirtual() && getParent()) return 1;
int size_w = rwidth;
int size_h = rheight;
if (!size_w || !size_h) return 0;
if (!virtualCanvas || virtualCanvasH != size_h || virtualCanvasW != size_w)
{
if (virtualCanvas)
{
deleteFrameBuffer(virtualCanvas);
virtualCanvas = NULL;
}
delete scalecanvas;
scalecanvas = NULL;
virtualCanvas = createFrameBuffer(size_w, size_h);
prepareFrameBuffer(virtualCanvas, size_w, size_h);
virtualCanvas->setBaseWnd(this);
virtualCanvasH = size_h; virtualCanvasW = size_w;
BaseWnd::getNonClientRect(&ncr);
deferedInvalidateRect(&ncr);
}
return 1;
}
Canvas *BaseWnd::createFrameBuffer(int w, int h)
{
return new BltCanvas(w, h, getOsWindowHandle());
}
void BaseWnd::prepareFrameBuffer(Canvas *canvas, int w, int h)
{
RECT r = {0, 0, w, h};
RegionI reg(&r);
virtualBeforePaint(&reg);
#ifdef _WIN32
canvas->selectClipRgn(NULL);
canvas->fillRect(&r, 0);
#elif defined(__APPLE__)
CGContextClearRect(canvas->getHDC(), CGRectInfinite); // TODO: make "clear" function in canvas
#endif
virtualAfterPaint(&reg);
}
void BaseWnd::deleteFrameBuffer(Canvas *canvas)
{
delete canvas;
}
// paints the client content, followed by the virtual child tree. recursive
int BaseWnd::paintTree(Canvas *canvas, api_region *r)
{
onPaint(canvas, r);
#ifdef WASABI_DRAW_FOCUS_RECT
if (gotFocus())
{
RECT ncr;
getNonClientRect(&ncr);
// try to use skinned focus rect
if (WASABI_API_WND->paintset_present(Paintset::FOCUSRECT))
WASABI_API_WND->paintset_render(Paintset::FOCUSRECT, canvas, &ncr, 128);
else // otherwise this looks kinda nice :P
canvas->drawRect(&ncr, 0, 0xFFFFFF, 128);
}
#endif
if (isVirtual() && !hasVirtualChildren()) return 0;
api_region *hostrgn = NULL;
api_region *update = r;
if (!(hwnd != NULL && getParent() == NULL))
{
hostrgn = getRegion();
update = r->clone();
if (hostrgn && !isRectRgn())
{
RECT ncr = clientRect();
api_region *hostclone = hostrgn->clone();
hostclone->addRegion(getComposedRegion());
hostclone->offset(ncr.left, ncr.top);
update->andRegion(hostclone);
hostrgn->disposeClone(hostclone);
}
}
RegionI client_update;
for (int i = 0;i < virtualChildren.getNumItems();i++)
{
if (!virtualChildren[i]->isVisible(1)) continue;
RECT rChild;
ifc_window *w = virtualChildren[i];
w->getNonClientRect(&rChild);
if ((rChild.right != rChild.left) && (rChild.bottom != rChild.top))
if (update->intersectRect(&rChild, &client_update))
{
w->paintTree(canvas, &client_update);
}
}
if (update != r) r->disposeClone(update);
return 1;
}
void BaseWnd::setVirtualCanvas(Canvas *c)
{
virtualCanvas = c;
}
int BaseWnd::pointInWnd(POINT *p)
{
RECT r;
if (!isVisible(1)) return 0;
getWindowRect(&r);
if (!Wasabi::Std::pointInRect(r, *p))
return 0;
for (int i = 0; i < getNumRootWndChildren(); i++)
{
ifc_window *c = enumRootWndChildren(i);
if (!c->isVisible(1)) continue;
RECT rChild;
c->getWindowRect(&rChild);
if (Wasabi::Std::pointInRect(rChild, *p))
return 0;
}
//NONPORTABLE
/* HWND child = GetWindow(getOsWindowHandle(), GW_CHILD);
while (child != NULL) {
if (IsWindowVisible(child)) {
RECT r2;
GetWindowRect(child, &r2);
if (Std::pointInRect(r2, *p))
return 0;
}
child = GetWindow(child, GW_HWNDNEXT);
}*/
return 1;
}
int BaseWnd::paint(Canvas *c, api_region *r)
{
if (isVirtual())
{
RegionI d;
RECT cr;
getClientRect(&cr);
if (r == NULL)
{
d.addRect(&cr);
}
else
{
d.addRegion(r);
d.offset(cr.left, cr.top);
}
ifc_window *rp = getRootParent();
deferedInvalidate();
rp->paint(NULL, &d);
BltCanvas *cc = static_cast<BltCanvas*>(rp->getFrameBuffer());
if (r != NULL) c->selectClipRgn(r);
cc->blit(cr.left, cr.top, c, 0, 0, cr.right - cr.left, cr.bottom - cr.top);
return 1;
}
if (!ensureVirtualCanvasOk()) return 0;
RegionI *deleteme = NULL;
if (r == NULL)
{
RECT cr;
getNonClientRect(&cr);
deleteme = new RegionI(&cr);
r = deleteme;
}
virtualBeforePaint(r);
RECT rcPaint;
r->getBox(&rcPaint);
double ra = getRenderRatio();
if (deferedInvalidRgn)
{
api_region *nr = NULL;
if (renderRatioActive())
{
nr = r->clone();
double d = 1.0 / ra;
nr->scale(d, d, TRUE);
}
if (deferedInvalidRgn->isEmpty() == 0)
{
// some deferednvalidated regions needs to be repainted
// TODO: need a "clear region" function in canvas
api_region *i = deferedInvalidRgn->clone();
#ifdef _WIN32
FillRgn(virtualCanvas->getHDC(), i->getOSHandle(), (HBRUSH)GetStockObject(BLACK_BRUSH));
#elif defined(__APPLE__)
CGContextSaveGState(virtualCanvas->getHDC());
virtualCanvas->selectClipRgn(i);
CGContextClearRect(virtualCanvas->getHDC(), CGRectInfinite);
// virtualCanvas->selectClipRgn(0);
CGContextRestoreGState(virtualCanvas->getHDC());
#endif
paintTree(virtualCanvas, i);
deferedValidateRgn(i);
deferedInvalidRgn->disposeClone(i);
}
if (nr) r->disposeClone(nr);
}
virtualAfterPaint(r);
if (c != NULL)
{
commitFrameBuffer(c, &rcPaint, ra); //TH WDP2-212
}
delete deleteme;
return 1;
}
int BaseWnd::virtualOnPaint()
{
#ifdef _WIN32
RECT cr;
getNonClientRect(&cr);
if (cr.left >= cr.right || cr.top >= cr.bottom) return 0;
if (!ensureVirtualCanvasOk()) return 0;
RegionI reg;
//CUT GetUpdateRgn(getOsWindowHandle(), r->getOSHandle(), FALSE);
Wasabi::Std::Wnd::getUpdateRegion(getOsWindowHandle(), reg.getOSHandle());
PaintCanvas paintcanvas;
if (!paintcanvas.beginPaint(this))
{
virtualAfterPaint(&reg); return 0;
}
// DO NOT DELETE - This looks like it does nothing, but it actually makes the GDI call us again with WM_PAINT if some window
// moves over this one between BeginPaint and EndPaint. We still use GetUpdateRgn so we don't have to check for
// the version of Windows. See doc. If this function is not available (should be here in 95/98/NT/2K, but we never know)
// then we use the rcPaint rect... less precise, but still works.
//CUT if (getRandomRgn) {
if (Wasabi::Std::Wnd::haveGetRandomRegion())
{
RegionI zap;
//CUT getRandomRgn(paintcanvas.getHDC(), zap.getOSHandle(), SYSRGN);
Wasabi::Std::Wnd::getRandomRegion(paintcanvas.getHDC(), zap.getOSHandle());
}
else
{
RECT z;
paintcanvas.getRcPaint(&z);
reg.setRect(&z);
}
// -------------
/*// for debug
HDC dc = GetDC(getOsWindowHandle());
InvertRgn(dc, r->getHRGN());
InvertRgn(dc, r->getHRGN());
ReleaseDC(getOsWindowHandle(), dc);*/
paint(&paintcanvas, &reg);
#else
#warning port me or remove me
#endif
return 1;
}
ifc_window *BaseWnd::enumVirtualChild(int _enum)
{
return virtualChildren[_enum];
}
int BaseWnd::getNumVirtuals()
{
return virtualChildren.getNumItems();
}
ifc_window *BaseWnd::enumRootWndChildren(int n)
{
return rootwndchildren.enumItem(n);
}
int BaseWnd::getNumRootWndChildren()
{
return rootwndchildren.getNumItems();
}
ifc_window *BaseWnd::findRootWndChild(int x, int y, int only_virtuals)
{
for (int i = getNumRootWndChildren() - 1; i > -1; i--)
{
RECT r;
ifc_window *child = enumRootWndChildren(i);
//DebugStringW(L"findRootWndChild = entering = %s\n", child->getId());
if (only_virtuals && !child->isVirtual()) continue;
child->getNonClientRect(&r);
int _x = x;
int _y = y;
if (!child->isVirtual())
{
POINT pt;
child->getPosition(&pt);
_x -= pt.x;
_y -= pt.y;
}
int iv = child->isVisible(1);
//int gpa = child->getPaintingAlpha();
POINT _p = Wasabi::Std::makePoint(_x, _y);
if (iv /*&& gpa > 0*/ && Wasabi::Std::pointInRect(r, _p))
{
// GROUP
ifc_window *z = child->findRootWndChild(_x, _y);
if (z) return z;
}
/*gpa > 0 &&*/
/*if (iv && _x>=r.left&&_x<=r.right&&_y>=r.top&&_y<=r.bottom && !child->isClickThrough() && child->ptInRegion(_x, _y)) {
return child;
}*/
}
return (!isClickThrough() && ptInRegion(x, y)) ? this : NULL;
}
//PORTME
int BaseWnd::handleVirtualChildMsg(UINT uMsg, int x, int y, void *p, void *d)
{
#ifdef _WIN32
ifc_window *child = NULL;
if (curVirtualChildCaptured)
child = curVirtualChildCaptured;
else
child = findRootWndChild(x, y, 1); // warning, can return this which is not virtual
// ASSERT(child != NULL); // BU this came up and I don't know why, looks like it should never happen
// FG> actually it can happen when coming back from a popup menu when cpu usage is high, the window might be
// hidden (destroying) and ptInRegion returns false.
if (!child) return 0;
//int isvirtual = child->isVirtual();
if (child) child = child->getForwardWnd();
if (child && child->isEnabled())
{
switch (uMsg)
{
case WM_LBUTTONDOWN:
/* if (isvirtual && child != curVirtualChildFocus)
focusVirtualChild(child);*/
autoFocus(child);
if (child->wantLeftClicks())
child->onLeftButtonDown(x, y);
if (child->checkDoubleClick(uMsg, x, y) && child->wantDoubleClicks())
child->onLeftButtonDblClk(x, y);
return 1;
case WM_RBUTTONDOWN:
/* if (isvirtual && child != curVirtualChildFocus)
focusVirtualChild(child);*/
autoFocus(child);
if (child->wantRightClicks())
child->onRightButtonDown(x, y);
if (child->checkDoubleClick(uMsg, x, y) && child->wantDoubleClicks())
child->onRightButtonDblClk(x, y);
return 1;
case WM_LBUTTONUP:
if (child->wantLeftClicks())
child->onLeftButtonUp(x, y);
return 1;
case WM_RBUTTONUP:
if (child->wantRightClicks())
child->onRightButtonUp(x, y);
return 1;
case WM_MOUSEMOVE:
{
if (curVirtualChildCaptured == child || (curVirtualChildCaptured == NULL))
{
if (child->wantMouseMoves())
child->onMouseMove(x, y);
return 1;
}
return 0;
}
case WM_MOUSEHOVER:
((BaseWnd *)child)->onTip();
break;
case WM_SETCURSOR:
int a = child->getCursorType(x, y);
if (!p) return 0;
*(int *)p = a;
if (a == BASEWND_CURSOR_USERSET)
{
OSCURSORHANDLE c = child->getCustomCursor(x, y);
if (!d) return 0;
*(OSCURSORHANDLE *)d = c;
}
return 1;
}
}
#else
#warning port me or remove me
#endif
return 0;
}
int BaseWnd::onLeftButtonDown(int x, int y)
{
disable_tooltip_til_recapture = 1;
abortTip();
return 0;
}
int BaseWnd::onLeftButtonUp(int x, int y)
{
disable_tooltip_til_recapture = 1;
abortTip();
return 0;
}
void BaseWnd::setVirtualChildCapture(ifc_window *child)
{
if (child)
{
if (!inputCaptured)
{
beginCapture();
}
}
else
{
endCapture();
}
curVirtualChildCaptured = child;
}
ifc_window *BaseWnd::getVirtualChildCapture()
{
if (inputCaptured && Wasabi::Std::Wnd::getCapture() == getOsWindowHandle())
return curVirtualChildCaptured;
else
if (inputCaptured) inputCaptured = 0;
return NULL;
}
ifc_window *BaseWnd::getBaseTextureWindow()
{
// return our base texture window if we have it
if (btexture)
return btexture;
// return our parent's if they have it
if (getParent())
return getParent()->getBaseTextureWindow();
else
return NULL;
}
void BaseWnd::renderBaseTexture(ifc_canvas *c, const RECT &r, int alpha)
{
WASABI_API_WND->skin_renderBaseTexture(getBaseTextureWindow(), c, r, this, alpha);
}
void BaseWnd::setBaseTextureWindow(ifc_window *w)
{
btexture = w;
}
void BaseWnd::setNotifyWindow(ifc_window *newnotify)
{
notifyWindow = newnotify;
}
ifc_window *BaseWnd::getNotifyWindow()
{
return destroying ? NULL : notifyWindow;
}
int BaseWnd::gotFocus()
{
return hasfocus && curVirtualChildFocus == NULL;
}
int BaseWnd::isActive()
{
OSWINDOWHANDLE h = hwnd;
if (h == NULL)
{
ifc_window *par = getParent();
if (par == NULL) return 0;
h = par->getOsWindowHandle();
}
if (h == NULL) return 0;
return (Wasabi::Std::Wnd::getActiveWindow() == h);
}
int BaseWnd::onChar(unsigned int c)
{
switch (c)
{
case 9: // TAB
if (Std::keyModifier(STDKEY_SHIFT))
focusPrevious();
else
focusNext();
return 1;
}
return 0;
}
/*int BaseWnd::focusVirtualChild(api_window *child) {
if (!gotFocus()) setFocus();
if (!child->wantFocus()) return 0;
setVirtualChildFocus(child);
return 1;
}*/
int BaseWnd::wantFocus()
{
return 0;
}
// Return 1 if there is a modal window that is not this
int BaseWnd::checkModal()
{
if (bypassModal()) return 0;
ifc_window *w = WASABI_API_WND->getModalWnd();
if (w && w != static_cast<ifc_window*>(this) && w != getDesktopParent())
{
return 1;
}
return 0;
}
int BaseWnd::cascadeRepaintFrom(ifc_window *who, int pack)
{
RECT r;
BaseWnd::getNonClientRect(&r);
return BaseWnd::cascadeRepaintRect(&r, pack);
}
int BaseWnd::cascadeRepaint(int pack)
{
return cascadeRepaintFrom(this, pack);
}
int BaseWnd::cascadeRepaintRgn(api_region *r, int pack)
{
return cascadeRepaintRgnFrom(r, this, pack);
}
int BaseWnd::cascadeRepaintRect(RECT *r, int pack)
{
return cascadeRepaintRectFrom(r, this, pack);
}
int BaseWnd::cascadeRepaintRectFrom(RECT *r, ifc_window *who, int pack)
{
RegionI reg(r);
int rt = cascadeRepaintRgnFrom(&reg, who, pack);
return rt;
}
void BaseWnd::_cascadeRepaintRgn(api_region *rg)
{
if (!ensureVirtualCanvasOk()) return ;
WndCanvas paintcanvas;
if (paintcanvas.attachToClient(this) == 0)
return;
virtualBeforePaint(rg);
deferedInvalidateRgn(rg);
paintTree(virtualCanvas, rg);
virtualAfterPaint(rg);
double ra = getRenderRatio();
RECT rcPaint;
rg->getBox(&rcPaint);
RECT rc;
getClientRect(&rc); //JF> this gets it in virtual (non-scaled) coordinates,
// so we need to do these comparisons before scaling.
rcPaint.bottom = MIN((int)rc.bottom, (int)rcPaint.bottom);
rcPaint.right = MIN((int)rc.right, (int)rcPaint.right);
if (renderRatioActive()) // probably faster than scaling the clone
{
rcPaint.left = (int)((rcPaint.left - 1) * ra);
rcPaint.top = (int)((rcPaint.top - 1) * ra);
rcPaint.right = (int)(rcPaint.right * ra + 0.999999);
rcPaint.bottom = (int)(rcPaint.bottom * ra + 0.999999);
}
rcPaint.left = MAX(0, (int)rcPaint.left);
rcPaint.top = MAX(0, (int)rcPaint.top);
rcPaint.right = MIN((int)rcPaint.right, (int)(rwidth * ra));
rcPaint.bottom = MIN((int)rcPaint.bottom, (int)(rheight * ra));
commitFrameBuffer(&paintcanvas, &rcPaint, ra);
}
void BaseWnd::packCascadeRepaintRgn(api_region *rg)
{
if (!deferedCascadeRepaintRgn) deferedCascadeRepaintRgn = new RegionI;
deferedCascadeRepaintRgn->addRegion(rg);
need_flush_cascaderepaint = 1;
}
int BaseWnd::cascadeRepaintRgnFrom(api_region *_rg, ifc_window *who, int pack)
{
api_region *rg = _rg->clone();
int j = virtualChildren.searchItem(who);
for (int i = 0; i < virtualChildren.getNumItems(); i++)
{
ifc_window *w = virtualChildren[i];
if (w != who && w->wantSiblingInvalidations())
w->onSiblingInvalidateRgn(rg, who, j, i);
}
if (!pack)
{
_cascadeRepaintRgn(rg);
}
else
{
packCascadeRepaintRgn(rg);
}
_rg->disposeClone(rg);
return 1;
}
void BaseWnd::setDesktopAlpha(int a)
{
if (a && !Wasabi::Std::Wnd::isDesktopAlphaAvailable()) return ;
if (a == w2k_alpha) return ;
w2k_alpha = a;
if (!a && scalecanvas)
{
delete scalecanvas;
scalecanvas = NULL;
}
setLayeredWindow(w2k_alpha);
onSetDesktopAlpha(a);
}
void BaseWnd::onSetDesktopAlpha(int a) { }
void BaseWnd::commitFrameBuffer(Canvas *paintcanvas, RECT *r, double ra)
{
if (w2k_alpha && Wasabi::Std::Wnd::isDesktopAlphaAvailable() && !cloaked)
{
//CUT BLENDFUNCTION blend= {AC_SRC_OVER, 0, wndalpha, AC_SRC_ALPHA };
//CUT POINT pt={0,0};
RECT spr;
getWindowRect(&spr);
//CUT POINT sp={spr.left,spr.top};
//CUT SIZE ss={spr.right-spr.left, spr.bottom-spr.top};
int sw = spr.right - spr.left, sh = spr.bottom - spr.top;
//CUT SysCanvas c;
if (handleRatio() && renderRatioActive())
{
// eek slow!
RECT r;
getWindowRect(&r);
int w = r.right - r.left;
int h = r.bottom - r.top;
if (!scalecanvas) scalecanvas = new BltCanvas(w, h, getOsWindowHandle());
virtualCanvas->stretchblit(0, 0, (int)((double)virtualCanvasW * 65536.0), (int)((double)virtualCanvasH * 65536.0), scalecanvas, 0, 0, w, h);
}
//CUT updateLayeredWindow(hwnd, c.getHDC(), &sp, &ss, (scalecanvas ? scalecanvas : virtualCanvas)->getHDC(), &pt, 0, &blend, ULW_ALPHA);
Wasabi::Std::Wnd::updateLayeredWnd(hwnd, spr.left, spr.top, sw, sh, (scalecanvas ? scalecanvas : virtualCanvas)->getHDC(), wndalpha);
}
else
{
if (ABS(ra - 1.0) <= 0.01)
{
virtualCanvas->blit(r->left, r->top, paintcanvas, r->left, r->top, r->right - r->left, r->bottom - r->top);
}
else
{
RECT tr = *r;
double invra = 65536.0 / ra;
int lp = tr.left;
int tp = tr.top;
int w = tr.right - tr.left;
int h = tr.bottom - tr.top;
int sx = (int)((double)lp * invra);
int sy = (int)((double)tp * invra);
int sw = (int)((double)w * invra);
int sh = (int)((double)h * invra);
virtualCanvas->stretchblit(sx, sy, sw, sh, paintcanvas, lp, tp, w, h);
}
}
}
void BaseWnd::flushPaint()
{
postDeferredCallback(DEFERREDCB_FLUSHPAINT, 0);
}
void BaseWnd::do_flushPaint()
{
if (!deferedInvalidRgn || deferedInvalidRgn->isEmpty()) return ;
api_region *r = deferedInvalidRgn->clone();
cascadeRepaintRgn(r);
deferedInvalidRgn->disposeClone(r);
deferedInvalidRgn->empty();
}
int BaseWnd::isMouseOver(int x, int y)
{
POINT pt = {x, y};
clientToScreen(&pt);
return (WASABI_API_WND->rootWndFromPoint(&pt) == this);
}
void BaseWnd::freeResources()
{}
void BaseWnd::reloadResources()
{
invalidate();
}
double BaseWnd::getRenderRatio()
{
if (!handleRatio()) return 1.0;
if (!ratiolinked) return ratio;
return getParent() ? getParent()->getRenderRatio() : ratio;
}
void BaseWnd::setRenderRatio(double r)
{
// "snap" to 1.0
if (ABS(r - 1.0) <= 0.02f) r = 1.0;
if (scalecanvas)
{
delete scalecanvas;
scalecanvas = NULL;
}
if (isInited() && r != ratio && !isVirtual() && (!getParent() || !ratiolinked))
{
// must scale size & region accordingly
RECT rc;
BaseWnd::getWindowRect(&rc);
rc.right = rc.left + rwidth;
rc.bottom = rc.top + rheight;
ratio = r;
resize(&rc);
invalidate();
if (isPostOnInit())
onRatioChanged();
}
}
void BaseWnd::setRatioLinked(int l)
{
ratiolinked = l;
if (isPostOnInit())
setRenderRatio(ratio);
}
int BaseWnd::renderRatioActive()
{
return ABS(getRenderRatio() - 1.0) > 0.01f;
}
void BaseWnd::multRatio(int *x, int *y)
{
double rr = getRenderRatio();
if (x) *x = (int)((double)(*x) * rr);
if (y) *y = (int)((double)(*y) * rr);
}
void BaseWnd::multRatio(RECT *r)
{
Wasabi::Std::scaleRect(r, getRenderRatio());
}
void BaseWnd::divRatio(int *x, int *y)
{
double rr = getRenderRatio();
if (x) *x = (int)((double)(*x) / rr + 0.5);
if (y) *y = (int)((double)(*y) / rr + 0.5);
}
void BaseWnd::divRatio(RECT *r)
{
double rr = getRenderRatio();
Wasabi::Std::scaleRect(r, 1./rr);
}
void BaseWnd::bringVirtualToFront(ifc_window *w)
{
changeChildZorder(w, 0);
}
void BaseWnd::bringVirtualToBack(ifc_window *w)
{
changeChildZorder(w, virtualChildren.getNumItems()-1);
}
void BaseWnd::bringVirtualAbove(ifc_window *w, ifc_window *b)
{
ASSERT(b->isVirtual());
int p = virtualChildren.searchItem(b);
if (p == -1) return ;
changeChildZorder(w, p);
}
void BaseWnd::bringVirtualBelow(ifc_window *w, ifc_window *b)
{
ASSERT(b->isVirtual());
int p = virtualChildren.searchItem(b);
if (p == -1) return ;
changeChildZorder(w, p + 1);
}
void BaseWnd::changeChildZorder(ifc_window *w, int newpos)
{
int p = newpos;
p = MAX(p, (int)0);
p = MIN(p, virtualChildren.getNumItems()-1);
RECT cr;
w->getClientRect(&cr);
PtrList<ifc_window> l;
int i;
for (i = 0;i < virtualChildren.getNumItems();i++)
if (virtualChildren[i] != w)
l.addItem(virtualChildren[i]);
p = virtualChildren.getNumItems() - newpos - 1;
virtualChildren.removeAll();
int done = 0;
for (i = 0;i < l.getNumItems();i++)
if (i == p && !done)
{
virtualChildren.addItem(w);
i--;
done++;
}
else
{
RECT dr, intersection;
l.enumItem(i)->getClientRect(&dr);
if (Wasabi::Std::rectIntersect(intersection, dr, &cr))
l[i]->invalidateRect(&intersection);
virtualChildren.addItem(l.enumItem(i));
}
if (i == p && !done)
virtualChildren.addItem(w);
w->invalidate();
}
int BaseWnd::onActivate()
{
if (hasVirtualChildren())
{
int l = getNumVirtuals();
for (int i = 0; i < l; i++)
{
ifc_window *r = enumVirtualChild(i);
r->onActivate();
}
}
return 0;
}
int BaseWnd::onDeactivate()
{
if (hasVirtualChildren())
{
int l = getNumVirtuals();
for (int i = 0; i < l; i++)
{
ifc_window *r = enumVirtualChild(i);
r->onDeactivate();
}
}
return 0;
}
int BaseWnd::getDesktopAlpha()
{
return w2k_alpha;
}
api_region *BaseWnd::getRegion()
{
return NULL;
}
//CUT int BaseWnd::isTransparencyAvailable() {
//CUT #ifdef WIN32
//CUT #else
//CUT #pragma warning port me!
//CUT #endif
//CUT return 0;
//CUT }
int BaseWnd::handleTransparency()
{
return 1; // by default all windows handle transparency, only windows blitting directly on the SCREEN (if you blit directly on the DC it's still ok),
} // for instance, a vis or a video using overlay should return 0, this will let the layout auto manage its alpha as that window is shown/hiden
void BaseWnd::setAlpha(int active, int inactive)
{
if (active == 254) active = 255;
if (active == 1) active = 0;
if (inactive == 254) inactive = 255;
if (inactive == 1) inactive = 0;
int oldactivealpha = activealpha;
active = MIN(255, MAX(0, active));
if (inactive != -1) inactive = MIN(255, MAX(0, inactive));
if (active != activealpha)
{
activealpha = active;
if (isActive())
{
invalidate();
if ((oldactivealpha == 0 || activealpha == 0) && (oldactivealpha != 0 || activealpha != 0))
invalidateWindowRegion();
}
}
if (inactive == -1) inactive = active;
if (inactive != inactivealpha)
{
inactivealpha = inactive;
if (!isActive())
{
invalidate();
if ((oldactivealpha == 0 || activealpha == 0) && (oldactivealpha != 0 || activealpha != 0))
invalidateWindowRegion();
}
}
}
void BaseWnd::getAlpha(int *active, int *inactive)
{
if (active) *active = activealpha;
if (inactive) *inactive = inactivealpha;
}
int BaseWnd::getPaintingAlpha(void)
{
int a = isActive() ? MIN(255, MAX(0, activealpha)) : MIN(255, MAX(0, inactivealpha));
ASSERT(a >= 0 && a <= 255);
if (getParent() && getParent()->isVirtual())
{
int b = getParent()->getPaintingAlpha();
a = (int)((double)a / 255.0 * (double)b);
}
if (a == 254) a = 255;
if (a == 1) a = 0;
if (!isEnabled()) a = (int)(a*0.6);
return a;
}
void BaseWnd::setClickThrough(int ct)
{
clickthrough = ct;
}
int BaseWnd::isClickThrough()
{
return clickthrough;
}
int BaseWnd::handleRatio()
{
return 1;
}
#include <api/script/objects/c_script/c_rootobj.h>
int BaseWnd::createTip()
{
destroyTip();
tooltip = new Tooltip(getTip());
return -1;
}
void BaseWnd::destroyTip()
{
// this is to avoid pb if destroytip() is being called by a time while destroying tip
Tooltip *tt = tooltip;
tooltip = NULL;
delete tt;
}
int BaseWnd::runModal()
{
//PORTME
#ifdef _WIN32
ifc_window *dp = getDesktopParent();
if (dp && dp != this)
return dp->runModal();
MSG msg;
// SetCapture(NULL);
SetFocus(getOsWindowHandle());
WASABI_API_WND->pushModalWnd(this);
returnvalue = 0;
mustquit = 0;
// Main message loop:
while (!mustquit)
{
mustquit = !GetMessage(&msg, NULL, 0, 0);
if (!msg.hwnd || !TranslateAccelerator(msg.hwnd, NULL, &msg))
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
}
WASABI_API_WND->popModalWnd(this);
// SetCapture(NULL);
return returnvalue;
#else
#warning port me
return 0;
#endif
}
void BaseWnd::endModal(int ret)
{
ifc_window *dp = getDesktopParent();
if (dp && dp != this)
{
dp->endModal(ret);
return ;
}
returnvalue = ret;
mustquit = 1;
}
int BaseWnd::wantAutoContextMenu()
{
return 1;
}
void BaseWnd::onCancelCapture()
{}
ifc_window *BaseWnd::getNextVirtualFocus(ifc_window *w)
{
if (w == NULL)
{
if (childtabs.getNumItems() > 0)
return childtabs.getFirst()->wnd;
}
int a = getTabOrderEntry(w) + 1;
if (a < childtabs.getNumItems())
return childtabs.enumItem(a)->wnd;
return NULL;
}
void BaseWnd::setVirtualChildFocus(ifc_window *w)
{
ASSERT(w && w->isVirtual());
if (curVirtualChildFocus)
curVirtualChildFocus->onKillFocus();
curVirtualChildFocus = w;
onSetRootFocus(w);
Wasabi::Std::Wnd::setFocus(getOsWindowHandle());
if (curVirtualChildFocus)
curVirtualChildFocus->onGetFocus();
}
int BaseWnd::ptInRegion(int x, int y)
{
RECT cr;
getNonClientRect(&cr);
POINT pt = {x - cr.left, y - cr.top};
api_region *reg = getRegion();
if (isRectRgn())
return (x >= cr.left && x <= cr.right && y >= cr.top && y <= cr.bottom);
return reg ? reg->ptInRegion(&pt) : 0;
}
api_region *BaseWnd::getComposedRegion()
{
ensureWindowRegionValid();
return composedrgn;
}
api_region *BaseWnd::getSubtractorRegion()
{
ensureWindowRegionValid();
return subtractorrgn;
}
int BaseWnd::ensureWindowRegionValid()
{
if (!isInited()) return 0;
if (wndregioninvalid)
{
computeComposedRegion();
return 1;
}
return 0;
}
void BaseWnd::invalidateWindowRegion()
{
wndregioninvalid = 1;
if (getParent()) getParent()->invalidateWindowRegion();
}
void BaseWnd::computeComposedRegion()
{
if (!isPostOnInit()) return ;
wndregioninvalid = 0;
RECT r;
getNonClientRect(&r);
api_region *reg = getRegion();
RegionI *_reg = NULL;
if (!reg)
{
_reg = new RegionI;
reg = _reg;
if (isRectRgn())
reg->setRect(&r);
}
else
if (isRectRgn())
reg->setRect(&r);
api_region *wr = reg->clone();
if (!subtractorrgn) subtractorrgn = new RegionI();
subtractorrgn->empty();
if (!composedrgn) composedrgn = new RegionI;
composedrgn->empty();
RegionI *subme = NULL;
RegionI *andme = NULL;
RegionI *orme = NULL;
// if subregion is now empty, we need to only use our region
RECT gr;
getNonClientRect(&gr);
for (int i = 0;i < virtualChildren.getNumItems();i++)
{
ifc_window *srw = virtualChildren.enumItem(i);
if (!srw->isVisible(1) || srw->getPaintingAlpha() == 0) continue;
if (srw->getRegionOp() != REGIONOP_NONE)
{
api_region *sr = srw->getComposedRegion();
if (sr)
{
api_region *osr = sr->clone();
RECT r;
srw->getNonClientRect(&r);
r.left -= gr.left;
r.top -= gr.top;
osr->offset(r.left, r.top);
/* sr->debug();
osr->debug();*/
if (srw->getRegionOp() == REGIONOP_OR)
{
if (!orme) orme = new RegionI;
orme->addRegion(osr);
}
else if (srw->getRegionOp() == REGIONOP_AND)
{
if (!andme) andme = new RegionI;
andme->addRegion(osr);
}
else if (srw->getRegionOp() == REGIONOP_SUB)
{
if (!subme) subme = new RegionI;
subme->addRegion(osr);
}
else if (srw->getRegionOp() == REGIONOP_SUB2)
{
if (!subme) subme = new RegionI;
subtractorrgn->addRegion(osr);
}
sr->disposeClone(osr);
}
}
api_region *sr = srw->getSubtractorRegion();
if (sr != NULL && !sr->isEmpty())
{
api_region *osr = sr->clone();
RECT r;
srw->getNonClientRect(&r);
r.left -= gr.left;
r.top -= gr.top;
osr->offset(r.left, r.top);
subtractorrgn->addRegion(osr);
sr->disposeClone(osr);
}
}
if (andme)
{
wr->andRegion(andme);
delete andme;
}
if (orme)
{
wr->addRegion(orme);
delete orme;
}
if (subme)
{
wr->subtractRgn(subme);
delete subme;
}
composedrgn->addRegion(wr);
reg->disposeClone(wr);
delete _reg;
}
void BaseWnd::updateWindowRegion()
{
if (!isPostOnInit() || isVirtual()) return ;
if (getDesktopAlpha())
{
// if desktopalpha is on, we can't use regions (thanks MS), we have to rely on the framebuffer correctness
//CUT SetWindowRgn(getOsWindowHandle(), NULL, FALSE);
Wasabi::Std::Wnd::setWndRegion(getOsWindowHandle(), NULL);
return ;
}
api_region *_r = getComposedRegion();
api_region *_s = getSubtractorRegion();
ASSERT(_r != NULL && _s != NULL);
api_region *z = _r->clone();
z->subtractRgn(_s);
assignWindowRegion(z);
_r->disposeClone(z);
}
// wr is NOT scaled!!!
void BaseWnd::assignWindowRegion(api_region *wr)
{
ASSERT(wr != NULL);
if (!isPostOnInit()) return ;
int isrect = wr->isRect();
RECT r;
BaseWnd::getWindowRect(&r);
//DebugStringW( L"\nBaseWnd::assignWindowRegion() r before - x = %d, y = %d, w = %d, h = %d \n", r.left, r.top, r.right - r.left, r.bottom - r.top );
r.right -= r.left;
r.left = 0;
r.bottom -= r.top;
r.top = 0;
//DebugStringW( L"BaseWnd::assignWindowRegion() r after - x = %d, y = %d, w = %d, h = %d \n", r.left, r.top, r.right - r.left, r.bottom - r.top );
RECT z;
wr->getBox(&z);
//DebugStringW( L"BaseWnd::assignWindowRegion() z before - x = %d, y = %d, w = %d, h = %d \n", z.left, z.top, z.right - z.left, z.bottom - z.top );
z.left = 0;
z.top = 0;
//DebugStringW( L"BaseWnd::assignWindowRegion() z after - x = %d, y = %d, w = %d, h = %d \n", z.left, z.top, z.right - z.left, z.bottom - z.top );
if (renderRatioActive())
{
double i = getRenderRatio();
wr->scale(i, i, FALSE);
}
RECT sz;
wr->getBox(&sz);
//DebugStringW( L"BaseWnd::assignWindowRegion() sz before - x = %d, y = %d, w = %d, h = %d \n", sz.left, sz.top, sz.right - sz.left, sz.bottom - sz.top );
sz.right -= sz.left;
sz.bottom -= sz.top;
sz.left = 0;
sz.top = 0;
//DebugStringW( L"BaseWnd::assignWindowRegion() sz after - x = %d, y = %d, w = %d, h = %d \n", sz.left, sz.top, sz.right - sz.left, sz.bottom - sz.top );
if (isrect &&
((z.right == rwidth && z.bottom == rheight) ||
(sz.left == r.left && sz.right == r.right && sz.top == r.top && sz.bottom == r.bottom) ||
(0)
)
)
{
//CUT SetWindowRgn(getOsWindowHandle(), NULL, TRUE);
if (!lastnullregion)
{
Wasabi::Std::Wnd::setWndRegion(getOsWindowHandle(), NULL, TRUE);
lastnullregion = 1;
}
}
else
{
//DebugStringW(L"setting region, rwidth = %d, rheight = %d, z.right = %d, z.bottom = %d\n", rwidth, rheight, z.right, z.bottom);
//CUT SetWindowRgn(getOsWindowHandle(), wr->makeWindowRegion(), TRUE);
Wasabi::Std::Wnd::setWndRegion(getOsWindowHandle(), wr->makeWindowRegion(), TRUE);
lastnullregion = 0;
}
}
void BaseWnd::performBatchProcesses()
{
// recompute the window region if needed and apply it to the HWND
if (wndregioninvalid && !isVirtual())
if (ensureWindowRegionValid())
updateWindowRegion();
if (need_flush_cascaderepaint)
{
_cascadeRepaintRgn(deferedCascadeRepaintRgn);
deferedCascadeRepaintRgn->empty();
need_flush_cascaderepaint = 0;
}
}
int BaseWnd::getRegionOp()
{
return regionop;
}
void BaseWnd::setRegionOp(int op)
{
if (regionop != op)
{
regionop = op;
invalidateWindowRegion();
}
}
int BaseWnd::isRectRgn()
{
return rectrgn;
}
void BaseWnd::setRectRgn(int i)
{
rectrgn = i;
}
TimerClient *BaseWnd::timerclient_getMasterClient()
{
if (!isVirtual()) return this;
ifc_window *w = getParent();
if (w)
{
TimerClient *tc = w->getTimerClient();
if (tc)
return tc->timerclient_getMasterClient();
}
return NULL;
}
void BaseWnd::timerclient_onMasterClientMultiplex()
{
performBatchProcesses();
}
TimerClient *BaseWnd::getTimerClient()
{
return this;
}
ifc_dependent *BaseWnd::rootwnd_getDependencyPtr()
{
return this;
}
ifc_dependent *BaseWnd::timerclient_getDependencyPtr()
{
return this;
}
void BaseWnd::addMinMaxEnforcer(ifc_window *w)
{
minmaxEnforcers.addItem(w);
signalMinMaxEnforcerChanged();
}
void BaseWnd::removeMinMaxEnforcer(ifc_window *w)
{
minmaxEnforcers.removeItem(w);
signalMinMaxEnforcerChanged();
}
void BaseWnd::signalMinMaxEnforcerChanged(void)
{
ifc_window *w = getDesktopParent();
if (w == NULL || w == this) onMinMaxEnforcerChanged();
else w->signalMinMaxEnforcerChanged();
}
int BaseWnd::getNumMinMaxEnforcers()
{
return minmaxEnforcers.getNumItems();
}
ifc_window *BaseWnd::enumMinMaxEnforcer(int n)
{
return minmaxEnforcers.enumItem(n);
}
int BaseWnd::onAction(const wchar_t *action, const wchar_t *param, int x, int y, intptr_t p1, intptr_t p2, void *data, size_t datalen, ifc_window *source)
{
return 1;
}
int BaseWnd::sendAction(ifc_window *target, const wchar_t *action, const wchar_t *param, int x, int y, intptr_t p1, intptr_t p2, void *data, size_t datalen)
{
ASSERT(target != NULL);
return target->onAction(action, param, x, y, p1, p2, data, datalen, this);
}
int BaseWnd::virtualBeforePaint(api_region *r)
{
if (!virtualCanvas) return 0;
PaintCallbackInfoI pc(virtualCanvas, r);
dependent_sendEvent(BaseWnd::depend_getClassGuid(), Event_ONPAINT, PaintCallback::BEFOREPAINT, &pc);
return 1;
}
int BaseWnd::virtualAfterPaint(api_region *r)
{
if (!virtualCanvas) return 0;
PaintCallbackInfoI pc(virtualCanvas, r);
dependent_sendEvent(BaseWnd::depend_getClassGuid(), Event_ONPAINT, PaintCallback::AFTERPAINT, &pc);
return 1;
}
int BaseWnd::timerclient_onDeferredCallback(intptr_t p1, intptr_t p2)
{
TimerClientI::timerclient_onDeferredCallback(p1, p2);
return onDeferredCallback(p1, p2);
}
void BaseWnd::timerclient_timerCallback(int id)
{
TimerClientI::timerclient_timerCallback(id);
timerCallback(id);
}
int BaseWnd::setTimer(int id, int ms)
{
return timerclient_setTimer(id, ms);
}
int BaseWnd::killTimer(int id)
{
return timerclient_killTimer(id);
}
void BaseWnd::postDeferredCallback(intptr_t p1, intptr_t p2, int mindelay)
{
#ifdef _WIN32
// TODO: re-enable, but post to some other window (e.g. some singleton window), not this window
// because our message pump might be blocked
// maybe make a hidden window in api_timer for this purpose
//if (mindelay)
timerclient_postDeferredCallback(p1, p2, mindelay);
//else
//PostMessage(hwnd, WM_DEFER_CALLBACK, p1, p2);
#else
#warning "port me - I can be optimized - don't use timers for this, use mac os x equiv of PostMessage!"
timerclient_postDeferredCallback(p1, p2, mindelay);
#endif
}
int BaseWnd::bypassModal()
{
return 0;
}
void BaseWnd::setRenderBaseTexture(int r)
{
renderbasetexture = r;
if (isInited()) invalidate();
}
int BaseWnd::getRenderBaseTexture()
{
return renderbasetexture;
}
GuiObject *BaseWnd::getGuiObject()
{
if (my_guiobject == NULL)
{
my_guiobject = static_cast<GuiObject *>(getInterface(guiObjectGuid));
}
return my_guiobject;
}
//CUT someday
int BaseWnd::getFlag(int flag)
{
/* switch (flag) {
}*/
return 0;
}
int BaseWnd::triggerEvent(int event, intptr_t p1, intptr_t p2)
{
//PORTME
switch (event)
{
case TRIGGER_ONRESIZE:
if (isPostOnInit())
onResize();
break;
case TRIGGER_INVALIDATE:
if (isPostOnInit())
invalidate();
break;
}
return 0;
}
void BaseWnd::registerAcceleratorSection(const wchar_t *name, int global)
{
#if defined(WASABI_COMPILE_LOCALES)
WASABI_API_LOCALE->locales_registerAcceleratorSection(name, this, global);
#endif
}
int BaseWnd::onAcceleratorEvent(const wchar_t *name)
{
for (int i = 0;i < getNumRootWndChildren();i++)
if (enumRootWndChildren(i)->onAcceleratorEvent(name))
return 1;
return 0;
}
int BaseWnd::allowDeactivation()
{
return allow_deactivate & ((WASABI_API_WND == NULL) || WASABI_API_WND->appdeactivation_isallowed(this));
}
void BaseWnd::onMinimize()
{
if (!isVirtual())
{
dropVirtualCanvas();
}
}
void BaseWnd::dropVirtualCanvas()
{
deferedInvalidate();
delete virtualCanvas;
virtualCanvas = NULL;
}
void BaseWnd::onRestore()
{
if (getDesktopParent() == this)
{
cascadeRepaint(TRUE);
}
}
ifc_window *BaseWnd::findWindow(const wchar_t *id)
{
RootWndFinder find_object;
find_object.reset();
find_object.setFindId(id);
ifc_window *ret = findWindowChain(&find_object);
#ifdef _DEBUG
if (ret == NULL)
DebugStringW(L"findWindow : window not found by id ! %s \n", id);
#endif
return ret;
}
ifc_window *BaseWnd::findWindowByInterface(GUID interface_guid)
{
RootWndFinder find_object;
find_object.reset();
find_object.setFindGuid(interface_guid);
ifc_window *ret = findWindowChain(&find_object);
#ifdef _DEBUG
char str[256] = {0};
nsGUID::toChar(interface_guid, str);
if (ret == NULL)
DebugStringW(L"findWindow : object not found by guid ! %s \n", str);
#endif
return ret;
}
ifc_window *BaseWnd::findWindowByCallback(FindObjectCallback *cb)
{
ifc_window *ret = findWindowChain(cb);
#ifdef _DEBUG
if (ret == NULL)
DebugStringW(L"findWindow : object not found by callback!\n");
#endif
return ret;
}
ifc_window *BaseWnd::findWindowChain(FindObjectCallback *cb, ifc_window *wcaller)
{
if (!cb) return NULL;
if (cb->findobjectcb_matchObject(this)) return this;
// first lets not look in subdirectories
for (int i = 0;i < getNumRootWndChildren();i++)
{
ifc_window *child = enumRootWndChildren(i);
if (!child || child == wcaller) continue;
if (cb->findobjectcb_matchObject(child))
return child;
}
// ok so it wasn't in our content, lets try to find it as a grandchildren
for (int i = 0;i < getNumRootWndChildren();i++)
{
ifc_window *child = enumRootWndChildren(i);
if (child->getNumRootWndChildren() > 0)
{
ifc_window *ret = child->findWindowChain(cb, this);
if (ret) return ret;
}
}
// so it wasnt one of our children, we'll hop the tree up one level and ask our parent to find it
// for us. of course, our parents are smart, they won't ask us back when asking our sibblings
ifc_window *p = getParent();
if (p != NULL && wcaller != p)
{
return p->findWindowChain(cb, this);
}
return NULL;
}
const wchar_t *BaseWnd::timerclient_getName()
{
tcname = StringPrintfW(L"name=\"%S\", id=\"%s\"", getRootWndName(), getId());
return tcname;
}
void BaseWnd::setTabOrder(int a)
{
if (getParent() != NULL)
getParent()->setVirtualTabOrder(this, a);
}
int BaseWnd::getTabOrder()
{
if (getParent() != NULL)
return getParent()->getVirtualTabOrder(this);
return -1;
}
void BaseWnd::recursive_setVirtualTabOrder(ifc_window *w, float a, float lambda)
{
ASSERT(w != NULL);
childtabs.setAutoSort(0);
int i = getTabOrderEntry(a);
if (i != -1)
{
TabOrderEntry *toe = childtabs.enumItem(i);
if (toe->wnd != w)
{
lambda += TABORDER_K;
if (lambda != 1.0)
recursive_setVirtualTabOrder(toe->wnd, a + lambda, lambda);
}
else
{
return ;
}
}
i = getTabOrderEntry(w);
if (i != -1)
{
delete childtabs.enumItem(i);
childtabs.removeByPos(i);
}
TabOrderEntry *toe = new TabOrderEntry;
toe->wnd = w;
toe->order = a;
childtabs.addItem(toe);
}
void BaseWnd::setVirtualTabOrder(ifc_window *w, int a)
{
if (a == -1)
{
delTabOrderEntry(w);
return ;
}
recursive_setVirtualTabOrder(w, (float)a);
}
int BaseWnd::getVirtualTabOrder(ifc_window *w)
{
int a = (int)getTabOrderEntry(w);
if (a == -1) return -1;
return (int)childtabs.enumItem(a);
}
int BaseWnd::getTabOrderEntry(ifc_window *w)
{
foreach(childtabs)
if (childtabs.getfor()->wnd == w)
return foreach_index;
endfor;
return -1;
}
void BaseWnd::delTabOrderEntry(int i)
{
int a = getTabOrderEntry((float)i);
if (a == -1) return ;
childtabs.removeByPos(a);
}
void BaseWnd::delTabOrderEntry(ifc_window *w)
{
int a = getTabOrderEntry(w);
if (a == -1) return ;
delete childtabs.enumItem(a);
childtabs.removeByPos(a);
}
int BaseWnd::getTabOrderEntry(float order)
{
foreach(childtabs)
if (childtabs.getfor()->order == order)
return foreach_index;
endfor;
return -1;
}
void BaseWnd::setAutoTabOrder()
{
if (!getParent()) return ;
getParent()->setVirtualAutoTabOrder(this);
}
void BaseWnd::setVirtualAutoTabOrder(ifc_window *w)
{
delTabOrderEntry(w);
float o = 0;
for (int i = 0;i < childtabs.getNumItems();i++)
{
o = MAX(o, childtabs.enumItem(i)->order);
}
setVirtualTabOrder(w, ((int)o) + 1);
}
void BaseWnd::focusNext()
{
ifc_window *dp = getDesktopParent();
if (dp != this)
{
if (dp != NULL)
dp->focusNext();
return ;
}
ifc_window *w = getTab(TAB_GETNEXT);
if (w != NULL) w->setFocus();
}
void BaseWnd::focusPrevious()
{
ifc_window *dp = getDesktopParent();
if (dp != this)
{
if (dp != NULL)
getDesktopParent()->focusPrevious();
return ;
}
ifc_window *w = getTab(TAB_GETPREVIOUS);
if (w != NULL) w->setFocus();
}
void BaseWnd::recursive_buildTabList(ifc_window *from, PtrList<ifc_window> *list)
{
for (int i = 0;i < from->getNumTabs();i++)
{
ifc_window *r = from->enumTab(i);
if (r->isVisible() && r->getPaintingAlpha() > 0)
{
if (r->wantFocus())
list->addItem(r);
recursive_buildTabList(r, list);
}
}
}
ifc_window *BaseWnd::getTab(int what)
{
PtrList<ifc_window> listnow;
recursive_buildTabList(this, &listnow);
int p = listnow.searchItem(rootfocus);
if (p == -1)
for (int i = 0; i < listnow.getNumItems(); i++)
{
ifc_window *r = listnow.enumItem(i);
if (r->gotFocus())
{
//DebugString("desync of rootfocus, fixing\n");
p = i;
assignRootFocus(r);
break;
}
}
if (what == TAB_GETNEXT && rootfocus != NULL)
{
p++;
if (p >= listnow.getNumItems())
p = 0;
return listnow.enumItem(p);
}
else if (what == TAB_GETPREVIOUS && rootfocus != NULL)
{
p--;
if (p < 0) p = listnow.getNumItems() - 1;
return listnow.enumItem(p);
}
else if (what == TAB_GETCURRENT)
{
return rootfocus;
}
else if (what == TAB_GETFIRST || (what == TAB_GETNEXT && rootfocus == NULL))
{
return listnow.getFirst();
}
else if (what == TAB_GETLAST || (what == TAB_GETPREVIOUS && rootfocus == NULL))
{
return listnow.getLast();
}
return NULL;
}
int BaseWnd::getNumTabs()
{
return childtabs.getNumItems();
}
ifc_window *BaseWnd::enumTab(int i)
{
childtabs.sort();
return childtabs.enumItem(i)->wnd;
}
void BaseWnd::onSetRootFocus(ifc_window *w)
{
assignRootFocus(w);
ifc_window *dp = getDesktopParent();
if (dp && dp != this) dp->onSetRootFocus(w);
}
void BaseWnd::autoFocus(ifc_window *w)
{
if (w->getFocusOnClick() && w->wantFocus())
{
w->setFocus();
return ;
}
ifc_window *g = w;
while (1)
{
ifc_window *p = g->getParent();
if (p == NULL) break;
ifc_window *dp = p->getDesktopParent();
if (dp && dp != p)
{
if (p->wantFocus() && p->getFocusOnClick())
{
p->setFocus();
return ;
}
g = p;
}
else
break;
}
}
void BaseWnd::setNoLeftClicks(int no)
{
noleftclick = no;
}
void BaseWnd::setNoRightClicks(int no)
{
norightclick = no;
}
void BaseWnd::setNoDoubleClicks(int no)
{
nodoubleclick = no;
}
void BaseWnd::setNoMouseMoves(int no)
{
nomousemove = no;
}
void BaseWnd::setNoContextMenus(int no)
{
nocontextmnu = no;
}
void BaseWnd::setDefaultCursor(Cursor *c)
{
customdefaultcursor = c;
}
OSCURSORHANDLE BaseWnd::getCustomCursor(int x, int y)
{
#ifdef _WIN32
return customdefaultcursor ? customdefaultcursor->getOSHandle() : NULL;
#else
#warning port me
return 0;
#endif
}
Accessible *BaseWnd::createNewAccObj()
{
waServiceFactory *f = WASABI_API_SVC->service_enumService(WaSvc::ACCESSIBILITY, 0);
if (f != NULL)
{
svc_accessibility *svc = castService<svc_accessibility>(f);
if (svc != NULL)
{
Accessible *a = svc->createAccessibleObject(this);
WASABI_API_SVC->service_release(svc);
return a;
}
}
return NULL;
}
Accessible *BaseWnd::getAccessibleObject(int createifnotexist)
{
if (!createifnotexist) return accessible;
if (!accessible)
accessible = createNewAccObj();
else
accessible->addRef();
return accessible;
}
int BaseWnd::accessibility_getState()
{
int state = 0;
if (!isVisible()) state |= STATE_SYSTEM_INVISIBLE;
//if (isVirtual() && !wantFocus()) state |= STATE_SYSTEM_INVISIBLE;
if (gotFocus()) state |= STATE_SYSTEM_FOCUSED;
return state;
}
void BaseWnd::activate()
{
Wasabi::Std::Wnd::setActiveWindow(getRootParent()->getOsWindowHandle());
}
void BaseWnd::setOSWndName(const wchar_t *name)
{
if (isVirtual()) return ;
//#ifdef COMPILE_WASABI_SKIN // for some reason this isn't being correctly defined
if (name)
{
Wasabi::Std::Wnd::setWndName(getOsWindowHandle(), name);
}
else
Wasabi::Std::Wnd::setWndName(getOsWindowHandle(), L"");
}
const wchar_t *BaseWnd::getOSWndName()
{
if (isVirtual()) return NULL;
wchar_t str[4096] = {0};
Wasabi::Std::Wnd::getWndName(getOsWindowHandle(), str, 4095);
str[4095] = '\0';
osname = str;
return osname;
}
#ifdef EXPERIMENTAL_INDEPENDENT_AOT
void BaseWnd::setAlwaysOnTop(int i)
{
// this function should not optimize itself
if (getDesktopParent() == this)
{
if (i)
{
//CUT SetWindowPos(getOsWindowHandle(), HWND_TOPMOST, 0,0,0,0, SWP_NOMOVE|SWP_NOSIZE|SWP_NOOWNERZORDER);
Wasabi::Std::Wnd::setTopmost(getOsWindowHandle(), TRUE);
}
else
{
saveTopMosts();
//CUT SetWindowPos(getOsWindowHandle(), HWND_NOTOPMOST, 0,0,0,0, SWP_NOMOVE|SWP_NOSIZE|SWP_NOOWNERZORDER);
Wasabi::Std::Wnd::setTopmost(getOsWindowHandle(), FALSE);
restoreTopMosts();
}
alwaysontop = i;
return ;
}
ifc_window *p = getParent();
if (p != NULL)
p->setAlwaysOnTop(i);
}
int BaseWnd::getAlwaysOnTop()
{
if (getDesktopParent() == this)
return alwaysontop;
ifc_window *p = getParent();
if (!p) return 0;
return p->getAlwaysOnTop();
}
#endif
void BaseWnd::wndwatcher_onDeleteWindow(ifc_window *w)
{
if (w == rootfocus)
{
rootfocus = NULL;
}
}
void BaseWnd::assignRootFocus(ifc_window *w)
{
rootfocuswatcher.watchWindow(w);
rootfocus = w;
}
Canvas *BaseWnd::getFrameBuffer()
{
return virtualCanvas;
}
void BaseWnd::setForeignWnd(int i)
{
m_takenOver = i;
}
int BaseWnd::bufferizeLockedUIMsg(int uMsg, int wParam, int lParam)
{
if (WASABI_API_SKIN && !WASABI_API_SKIN->skin_getLockUI()) return 0;
if (!uiwaslocked)
{
uiwaslocked = 1;
setTimer(BUFFEREDMSG_TIMER_ID, 20);
}
bufferedMsgStruct msg;
msg.msg = uMsg;
msg.wparam = wParam;
msg.lparam = lParam;
bufferedmsgs.addItem(msg);
return 1;
}
void BaseWnd::checkLockedUI()
{
//PORTME :(
#ifdef _WIN32
if (WASABI_API_SKIN && !WASABI_API_SKIN->skin_getLockUI())
{
uiwaslocked = 0;
killTimer(BUFFEREDMSG_TIMER_ID);
while (bufferedmsgs.getNumItems() > 0)
{
bufferedMsgStruct msg = bufferedmsgs.enumItem(0);
bufferedmsgs.delByPos(0);
SendMessageW(gethWnd(), msg.msg, msg.wparam, msg.lparam);
}
uiwaslocked = 0;
killTimer(BUFFEREDMSG_TIMER_ID);
}
#else
#warning port me
#endif
}
int BaseWnd::isMinimized()
{
ifc_window *w = getDesktopParent();
if (w == this || w == NULL) return minimized;
return w->isMinimized();
}
int BaseWnd::reinit()
{
#ifdef _WIN32
int nochild = (GetWindowLong(gethWnd(), GWL_STYLE) & WS_POPUP) ? 1 : 0;
int r = reinit(parentWnd ? parentWnd : WASABI_API_WND->main_getRootWnd(), nochild);
if (w2k_alpha)
setLayeredWindow(1);
return r;
#else
#warning port me!
#endif
}
int BaseWnd::reinit(ifc_window *parWnd, int nochild)
{
OSWINDOWHANDLE phwnd = parWnd->getOsWindowHandle();
ASSERT(phwnd != NULL);
int ret;
if (!nochild) parentWnd = parWnd;
else parentWnd = NULL;
ret = reinit(parWnd->getOsModuleHandle(), phwnd, nochild);
if (!ret) parentWnd = NULL; // abort
return ret;
}
int BaseWnd::reinit(OSMODULEHANDLE moduleHandle, OSWINDOWHANDLE parent, int nochild)
{
RECT r;
int w, h;
onBeforeReinit();
pushWindowRect();
preventcancelcapture = 1;
int _isvisible = isVisible(1);
int hadcapture = inputCaptured;
//DebugString("had capture = %d\n", hadcapture);
Wasabi::Std::Wnd::releaseCapture();
unparentHWNDChildren();
BaseWnd::getClientRect(&r);
hinstance = moduleHandle;
ASSERT(hinstance != NULL);
w = (r.right - r.left);
h = (r.bottom - r.top);
rwidth = w;
rheight = h;
rx = r.left;
ry = r.top;
WASABI_API_WND->appdeactivation_push_disallow(this);
// destroy old window
Wasabi::Std::Wnd::hideWnd(hwnd); //Wasabi::Std::Wnd::destroyWnd(hwnd);
ghosthwnd.addItem(hwnd);
hwnd = Wasabi::Std::Wnd::createWnd(&r, nochild, acceptExternalDrops(), parent, hinstance, static_cast<ifc_window*>(this));
#ifdef __APPLE__
#warning remove me
Wasabi::Std::Wnd::showWnd(hwnd);
#endif
WASABI_API_WND->appdeactivation_pop_disallow(this);
//ASSERT(hwnd != NULL); // lets fail nicely, this could happen for some win32 reason, we don't want to fail the whole app for it, so lets just fail the wnd
if (hwnd == NULL)
{
preventcancelcapture = 0;
return 0;
}
//CUT nreal++;
#ifdef _WIN32
//FUCKO
#ifdef URLDROPS
if (acceptExternalDrops()) RegisterDragDrop(hwnd, &m_target);
#elif !defined(WA3COMPATIBILITY)
if (!m_target && WASABI_API_WND != NULL)
m_target = WASABI_API_WND->getDefaultDropTarget();
if (m_target != NULL)
{
RegisterDragDrop(hwnd, (IDropTarget *)m_target);
}
#endif
#else
#warning port me - register drag & drop
#endif
this_visible = _isvisible;
//onInit();
//this_visible = !start_hidden;
reparentHWNDChildren();
popWindowRect();
invalidateWindowRegion();
updateWindowRegion();
if (this_visible)
Wasabi::Std::Wnd::showWnd(hwnd, FALSE);
if (hadcapture)
{
Wasabi::Std::Wnd::setCapture(hwnd);
}
preventcancelcapture = 0;
forcedOnResize();
redrawHWNDChildren();
//onPostOnInit();
onAfterReinit();
#ifdef WASABI_ON_REPARENT
WASABI_ON_REINIT(getOsWindowHandle());
#endif
return 1;
}
ReparentWndEntry::ReparentWndEntry(OSWINDOWHANDLE _wnd, OSWINDOWHANDLE parentwnd)
{
wnd = _wnd;
Wasabi::Std::Wnd::getWindowRect(wnd, &rect);
Wasabi::Std::Wnd::screenToClient(wnd, (int *)&(rect.left), (int *)&(rect.top));
Wasabi::Std::Wnd::clientToScreen(parentwnd, (int *)&(rect.left), (int *)&(rect.top));
}
void ReparentWndEntry::unparent()
{
Wasabi::Std::Wnd::setWndPos(wnd, NULL, rect.left, -30000, 0, 0, TRUE, TRUE, FALSE, FALSE, TRUE);
Wasabi::Std::Wnd::setParent(wnd, NULL);
}
void ReparentWndEntry::reparent(OSWINDOWHANDLE newparent)
{
Wasabi::Std::Wnd::setParent(wnd, newparent);
Wasabi::Std::Wnd::setWndPos(wnd, NULL, rect.left, rect.top, 0, 0, TRUE, TRUE, FALSE, FALSE, TRUE);
}
#ifdef _WIN32
void BaseWnd::unparentHWNDChildren()
{
// just in case
reparentwnds.deleteAll();
#ifndef WIN32
#error port me ! // make a list of all the children oswindows and reparent them to the desktop somewhere we can't see
#endif
OSWINDOWHANDLE wnd = GetWindow(getOsWindowHandle(), GW_CHILD);
while (wnd)
{
reparentwnds.addItem(new ReparentWndEntry(wnd, getOsWindowHandle()));
wnd = GetWindow(wnd, GW_HWNDNEXT);
}
foreach(reparentwnds)
reparentwnds.getfor()->unparent();
endfor;
}
#endif
void BaseWnd::reparentHWNDChildren()
{
// reparent to the new oswindowhandle
foreach(reparentwnds)
reparentwnds.getfor()->reparent(getOsWindowHandle());
endfor;
}
void BaseWnd::redrawHWNDChildren()
{
// reparent to the new oswindowhandle
foreach(reparentwnds)
Wasabi::Std::Wnd::update(getOsWindowHandle());
endfor;
}
void BaseWnd::maximize(int axis)
{
//DebugString("maximize!\n");
// if already maximized, don't use current rect, use restore_rect
if (!maximized)
{
restore_rect.left = rx;
restore_rect.top = ry;
restore_rect.right = rx + rwidth;
restore_rect.bottom = ry + rheight;
}
RECT nr = restore_rect;
RECT dr;
Wasabi::Std::getViewport(&dr, NULL, NULL, getOsWindowHandle(), 0);
if (axis & MAXIMIZE_WIDTH)
{
nr.left = dr.left;
nr.right = dr.right;
}
if (axis & MAXIMIZE_HEIGHT)
{
nr.top = dr.top;
nr.bottom = dr.bottom;
}
maximized = 1;
if (axis != 0) resize(&nr);
onMaximize();
}
void BaseWnd::restore(int what)
{
if (maximized)
{
//DebugString("restore!\n");
if (what == (RESTORE_X | RESTORE_Y | RESTORE_WIDTH | RESTORE_HEIGHT))
resize(&restore_rect);
else
{
resize((what & RESTORE_X) ? restore_rect.left : NOCHANGE,
(what & RESTORE_Y) ? restore_rect.top : NOCHANGE,
(what & RESTORE_WIDTH) ? restore_rect.right - restore_rect.left : NOCHANGE,
(what & RESTORE_HEIGHT) ? restore_rect.bottom - restore_rect.top : NOCHANGE);
}
maximized = 0;
onRestore();
}
}
void BaseWnd::pushWindowRect()
{
//DebugString("pushWindowRect\n");
RECT wr;
getWindowRect(&wr);
wr.right = wr.left + rwidth;
wr.bottom = wr.top + rheight;
windowrectstack.push(wr);
}
int BaseWnd::popWindowRect(RECT *rc, int applyhow)
{
//DebugString("popWindowRect\n");
if (windowrectstack.peek() == 0) return 0;
RECT _rc;
windowrectstack.pop(&_rc);
RECT r;
getWindowRect(&r);
divRatio(&r);
if (applyhow)
{
if (applyhow == PWR_POSITION)
{
move(_rc.left, _rc.top);
if (rc)
{
int w = r.right - r.left;
int h = r.bottom - r.top;
rc->left = _rc.left;
rc->top = _rc.top;
rc->right = rc->left + w;
rc->bottom = rc->top + h;
}
}
else
{
if (applyhow & PWR_X) r.left = _rc.left;
if (applyhow & PWR_Y) r.top = _rc.top;
if (applyhow & PWR_WIDTH) r.right = r.left + (_rc.right - _rc.left);
if (applyhow & PWR_HEIGHT) r.bottom = r.top + (_rc.bottom - _rc.top);
resizeToRect(&r);
if (rc) *rc = _rc;
}
}
else if (rc) *rc = _rc;
return 1;
}
void BaseWnd::setRestoredRect(RECT *r)
{
if (!r)
return ;
restore_rect = *r;
maximized = 1;
}
int BaseWnd::getRestoredRect(RECT *r)
{
if (!r)
return 0;
if (!maximized)
return 0;
*r = restore_rect;
return 1;
}
void BaseWnd::notifyDeferredMove(int x, int y)
{
rx = x;
ry = y;
}
void BaseWnd::setWindowTitle(const wchar_t *title)
{
Layout *l = static_cast<Layout *>(getInterface(layoutGuid));
if (l)
{
Container *c = l->getParentContainer();
if (c)
{
c->setName(title);
}
}
}
#ifdef __APPLE__
OSStatus BaseWnd::eventHandler(EventHandlerCallRef inHandlerCallRef, EventRef inEvent, void *inUserData)
{
return eventNotHandledErr;
}
#endif