winamp/Src/Wasabi/api/wndmgr/alphamgr.cpp

#include <precomp.h>
#include "alphamgr.h"
#include <api/wndmgr/layout.h>
#include <api/skin/skinparse.h>
#ifdef _WIN32
#include <tataki/blending/blending.h>
#endif
#include <bfc/util/profiler.h>
#include <bfc/wasabi_std_wnd.h>

#ifndef PI
#define PI 3.1415926536
#endif

#define ALPHAMGR_HOVERCHECK    100
#define ALPHAMGR_UPDATEALPHA   200

AlphaMgr::AlphaMgr() {
	overlayout = NULL;
	timerclient_setTimer(ALPHAMGR_HOVERCHECK, 200);
	alllinked = 0;
	autoopacify = 0;
	fast_timer_on = 0;
	big_curtransparency = 0;
	big_status = STATUS_UNKNOWN;
	big_startalpha = 0;
	big_lasttimein = 0;
	extend_px = 0;
	global_alpha = 0;
	big_enterleave_time = 0;
    fadein_ms = 1;
    fadeout_ms = 1;
    holdtime_ms = 1;
}

AlphaMgr::~AlphaMgr() 
{
	timerclient_killTimer(ALPHAMGR_HOVERCHECK);
}

void AlphaMgr::addLayout(Layout *l)
{
  checkTimer();

  if (layouts.findItem((const wchar_t *)l))
      return;

  layouts.addItem(new AlphaMgrEntry(l));
}

void AlphaMgr::removeLayout(Layout *l) {
  int p=-1;
  AlphaMgrEntry *e = layouts.findItem((const wchar_t *)l, &p);
  if (p != -1) {
    if (e->getStatus() == STATUS_IN_FADINGON || e->getStatus() == STATUS_IN_ON) {
      updateInList(e, 0);
      checkTimer();
    }
    layouts.removeByPos(p);
    in_layouts.removeItem(e);
    delete e;
    checkTimer();
  }
}

// gets the currently needed transparency, according to layout overrides and global link, and then applies this
// transparency to the layout, it does not change anything in any data structure, this is only a visual update function
void AlphaMgr::updateTransparency(Layout *l) {
  if (!l) return;
  if (l->isInited()) {
    if (l->isTransparencySafe()) {
      int a = l->getTransparencyOverride();
      if (a == -1) {
        if (l->getNoParent()!=1) {
          if (a == -1 && hasAutoOpacity(l))
            a = getTransparency(l);
          else if (a == -1 && getAllLinked())
            a = getGlobalAlpha();
        }
        if (a == -1) {
          /* why the hell would it care if it's alllinked if it's an independent window ?? (noparent=1)
          if (getAllLinked())
            a = getGlobalAlpha();
          else 
          */
            a = l->getPaintingAlpha();
        }
      }
      l->setTransparency(a);
    } else {
      l->setTransparency(255);
    }
  }
}

// returns the alpha value for this slot, that's not necessarily the transparency that should be applied to the layout
// since overrides & calculations in updateTransparency and getTransparency should apply. 
int AlphaMgr::getAlpha(AlphaMgrEntry *e) {
  if (alllinked && e->getLayout()->getNoParent() != 1) return getGlobalAlpha();
  return e->getLayout()->getAlpha();
}

int AlphaMgr::getAlpha(Layout *l) {
  int p=-1;
  AlphaMgrEntry *e = layouts.findItem((const wchar_t *)l, &p);
  if (p != -1) return getAlpha(e);
  return l->getAlpha();
}

int AlphaMgr::getGlobalAlpha() {
  return global_alpha;
}

void AlphaMgr::updateAllTransparency() {
  foreach(layouts)
    updateTransparency(layouts.getfor()->getLayout());
  endfor;
}

void AlphaMgr::setGlobalAlpha(int a) {
  global_alpha = a;
  updateAllTransparency();
}

int AlphaMgr::getCurve(AlphaMgrEntry *e) {
  int n;
  int status = e ? e->getStatus() : getBigStatus();
  if (e == NULL) {
    n = MulDiv(Wasabi::Std::getTickCount()-getBigEnterLeaveTime(),256,status == STATUS_IN_FADINGON ? fadein_ms : fadeout_ms);
    if (n > 255) n = 255; if (n < 0) n = 0;
  } else {
    if (e->getEnterLeaveTime() == -1) return -1;
    n = MulDiv(Wasabi::Std::getTickCount()-e->getEnterLeaveTime(),256,status == STATUS_IN_FADINGON ? fadein_ms : fadeout_ms);
    if (n > 255) n = 255; if (n < 0) n = 0;
  }
  return n;
}

// returns the value of the transparency if no override applies, you still need to check overrides (see updatetransparency)
int AlphaMgr::getTransparency(Layout *l) {
  if (getAutoOpacify()) 
    l = NULL;
  if (l == NULL) {
    if (getBigStatus() == STATUS_UNKNOWN) { 
      setBigStatus(STATUS_OUT_OFF); 
      Layout *main = SkinParser::getMainLayout();
      if (main)
        big_curtransparency = main->getTransparency();
      else
        big_curtransparency = 255;
    }
  }
  AlphaMgrEntry *e = NULL;
  if (l) e = layouts.findItem((const wchar_t *)l);
  int s = e ? e->getStatus() : getBigStatus();
  if (e && s == STATUS_UNKNOWN) {
    initStatus(e);
    s = e->getStatus();
  }
  switch (s) {
    case STATUS_IN_OFF: return e ? getAlpha(e) : getGlobalAlpha();
    case STATUS_OUT_OFF: return e ? getAlpha(e) : getGlobalAlpha();
    case STATUS_IN_ON: return 255;
    case STATUS_OUT_FADINGOUT: {
      int n = e ? getCurve(e) : getCurve(NULL);
  	  float sintrans = (float)(sin(((float)n/255)*PI-PI/2)/2+0.5);
      int na;
      if (e)
        na = (int)(((float)(getAlpha(e) - e->getStartAlpha()) * sintrans) + e->getStartAlpha());
      else 
        na = (int)(((float)(getGlobalAlpha() - getBigStartAlpha()) * sintrans) + getBigStartAlpha());
      return na;
    }
    case STATUS_IN_FADINGON: {
      int n = e ? getCurve(e) : getCurve(NULL);
  	  float sintrans = (float)(sin(((float)n/255)*PI-PI/2)/2+0.5);
      int na;
      if (e)
        na = (int)(((float)(255 - e->getStartAlpha()) * sintrans) + e->getStartAlpha());
      else
        na = (int)(((float)(255 - getBigStartAlpha()) * sintrans) + getBigStartAlpha());
      return na;
    }
    default: return e ? getAlpha(e) : getGlobalAlpha();
  }
}

int AlphaMgr::hasAutoOpacityOnHover(Layout *l) {
  AlphaMgrEntry *e = layouts.findItem((const wchar_t *)l);
  if (e) return hasAutoOpacityOnHover(e);
  return 0;
}

int AlphaMgr::hasAutoOpacity(Layout *l) {
  AlphaMgrEntry *e = layouts.findItem((const wchar_t *)l);
  if (e) return hasAutoOpacity(e);
  return 0;
}

int AlphaMgr::hasAutoOpacityOnFocus(Layout *l) {
  AlphaMgrEntry *e = layouts.findItem((const wchar_t *)l);
  if (e) return hasAutoOpacityOnFocus(e);
  return 0;
}

int AlphaMgr::hasAutoOpacityOnFocus(AlphaMgrEntry *e) {
  if (alllinked) return autoopacify == 2;
  return e->getLayout()->getAutoOpacify() == 2 && e->getLayout()->getNoParent() != 1;
}

int AlphaMgr::hasAutoOpacityOnHover(AlphaMgrEntry *e) {
  if (alllinked) return autoopacify == 1;
  return e->getLayout()->getAutoOpacify() == 1 && e->getLayout()->getNoParent() != 1;
}

int AlphaMgr::hasAutoOpacity(AlphaMgrEntry *e) {
  if (alllinked) return autoopacify;
  return e->getLayout()->getAutoOpacify() && e->getLayout()->getNoParent() != 1;
}

// we got a new layout to manage, and its status flags is not set, we should init it to something safe
void AlphaMgr::initStatus(AlphaMgrEntry *l, int applytransparency) {
  if (isMouseInLayout(l->getLayout())) {
	l->setEnterLeaveTime((uint32_t)-1);
    if (hasAutoOpacity(l)) {
      l->setStatus(STATUS_IN_FADINGON);
      l->onEnterLeave();
      l->setStartAlpha(l->getLayout()->getTransparency());
      checkTimer();
    } else {
      l->setStatus(STATUS_IN_OFF);
    }
    l->getLayout()->onMouseEnterLayout();
  } else {
    if (hasAutoOpacityOnHover(l)) {
      l->setStartAlpha(l->getLayout()->getTransparency());
      l->onEnterLeave();
      l->setStatus(STATUS_OUT_FADINGOUT);
      checkTimer();
    } else {
      l->setStatus(STATUS_OUT_OFF);
    }
    l->getLayout()->onMouseLeaveLayout();
  }
  if (applytransparency) updateTransparency(l->getLayout());
}

int AlphaMgr::isPointInLayout(Layout *l, int x, int y, api_region **rgn) 
{
  api_region *rg = NULL;
  if (!l) return 0;
  if (!l->isVisible()) return 0;
  RECT r,r2;
  l->getClientRect(&r);
  if (l->renderRatioActive()) l->multRatio(&r);
  l->getWindowRect(&r2);
  Wasabi::Std::offsetRect(&r, r2.left, r2.top);
//  OffsetRect(&r, r2.left, r2.top);
  if (x < r.left || x > r.right || y < r.top || y > r.bottom) return 0;
  if (rgn) {
    if (!*rgn) {
      rg = l->getComposedRegion();
      *rgn = rg;
    } else {
      rg = *rgn;
    }
  } else {
    rg = l->getComposedRegion();
  }
  if (!rgn) return 1;
  x -= r.left; y -= r.top;
  POINT pt={x,y};
  if (l->renderRatioActive()) l->divRatio((int*)&pt.x, (int*)&pt.y);
  if (l->getComposedRegion()->ptInRegion(&pt)) return 1;
  return 0;
}

int AlphaMgr::isFocusInLayout(Layout *l) {
  if (l->gotFocus()) return 1;
  OSWINDOWHANDLE fw = Wasabi::Std::Wnd::getFocus();
  while (fw) 
  {
    if (fw == l->gethWnd()) return 1;
    fw = Wasabi::Std::Wnd::getParent(fw);
  }
  return 0;
}

int AlphaMgr::isMouseInLayout(Layout *l) {
  int isin = 0;
  if (hasAutoOpacityOnFocus(l)) {
    return isFocusInLayout(l);
  } else {
    int x, y;
    api_region *r = NULL;
    Wasabi::Std::getMousePos(&x, &y);
    isin = isPointInLayout(l, x, y, &r);
    int ext = getExtendAutoOpacity();
    if (!isin && ext > 0) {
      isin = isPointInLayout(l, x-ext, y, &r);
      if (!isin) isin = isPointInLayout(l, x-ext, y-ext, &r);
      if (!isin) isin = isPointInLayout(l, x, y-ext, &r);
      if (!isin) isin = isPointInLayout(l, x+ext, y-ext, &r);
      if (!isin) isin = isPointInLayout(l, x+ext, y, &r);
      if (!isin) isin = isPointInLayout(l, x+ext, y+ext, &r);
      if (!isin) isin = isPointInLayout(l, x, y+ext, &r);
      if (!isin) isin = isPointInLayout(l, x-ext, y+ext, &r);
      if (!isin) isin = isPointInLayout(l, x-ext, y, &r);
    }
  }
  return isin;
}

int AlphaMgr::needForcedTransparencyFlag(Layout *l) {
  if (!l->isTransparencySafe()) return 0;
  if (l->isAlphaForced()) return 1;
  if (l->getTransparencyOverride() > 0) return 1; // should not be testing for < 255 here
  AlphaMgrEntry *e = layouts.findItem((const wchar_t *)l);
  if (hasAutoOpacity(e) && getAlpha(e) < 255) return 1;
  return 0;
}

void AlphaMgr::checkTimer() {
  int fading = 0;
  foreach(layouts)
    AlphaMgrEntry *e = layouts.getfor();
    if (e->getStatus() == STATUS_IN_FADINGON || e->getStatus() == STATUS_OUT_FADINGOUT) { fading++; break; }
  endfor;
  if (getAutoOpacify() && getBigStatus() == STATUS_IN_FADINGON || getBigStatus() == STATUS_OUT_FADINGOUT) 
    fading++;
  if (fading && !fast_timer_on) { 
    timerclient_setTimer(ALPHAMGR_UPDATEALPHA, 20); 
    fast_timer_on = 1; 
  } else if (!fading && fast_timer_on) { 
    timerclient_killTimer(ALPHAMGR_UPDATEALPHA); 
    fast_timer_on = 0; 
  }
}

void AlphaMgr::doEndCheck(AlphaMgrEntry *e) {
  if (getCurve(e) == 255) {
    switch (e ? e->getStatus() : getBigStatus()) {
      case STATUS_IN_FADINGON:
        if (e) e->setStatus(STATUS_IN_ON); else setBigStatus(STATUS_IN_ON);
        break;
      case STATUS_OUT_FADINGOUT:
        if (e) e->setStatus(STATUS_OUT_OFF); else setBigStatus(STATUS_OUT_OFF);
        break;
    }
    checkTimer();
  }
}

void AlphaMgr::updateInList(AlphaMgrEntry *e, int isin) {
  if (isin) {
    if (in_layouts.searchItem(e) == -1) 
    in_layouts.addItem(e);
  } else {
    in_layouts.removeItem(e);
  }
  
  int big_isin = in_layouts.getNumItems() > 0;
  
  if (getAutoOpacify()) {
    if (big_isin) {
      // mouse is in a layout, autoopacity is on
      switch (getBigStatus()) {
        case STATUS_OUT_OFF: 
        case STATUS_OUT_FADINGOUT:
        case STATUS_IN_OFF: { 
          setBigStartAlpha(e->getLayout()->getTransparency());
          onBigEnterLeave();
          setBigStatus(STATUS_IN_FADINGON);
          checkTimer();
          break;
        }
        case STATUS_IN_FADINGON: 
          doEndCheck(NULL);
          break;
      }
    } else {
      // mouse out of all layouts, autoopacity is on
      switch (getBigStatus()) {
        case STATUS_IN_FADINGON: 
        case STATUS_IN_ON: {
          setBigStartAlpha(getTransparency(NULL));
          onBigEnterLeave();
          setBigStatus(STATUS_OUT_FADINGOUT);
          checkTimer();
          break;
        }
        case STATUS_OUT_FADINGOUT:
          doEndCheck(NULL);
          break;
      }
    }
  } else {
    if (big_isin) {
      // mouse is in a layout, no autoopacity
      setBigStatus(STATUS_IN_OFF);
    } else {
      // mouse is out of all layouts, no autoopacity
      setBigStatus(STATUS_OUT_OFF);
    }
  }
}

int AlphaMgr::isFocusingExternalWindow() 
{  
  OSWINDOWHANDLE fw = Wasabi::Std::Wnd::getFocus();
  if (isOurExternalWindow(fw)) return 1;
  return 0;
}

int AlphaMgr::isOverExternalWindow() 
{
  int x, y;
  Wasabi::Std::getMousePos(&x, &y);
  int ext = getExtendAutoOpacity();

  POINT pt;
  pt.x = x; pt.y = y;
  OSWINDOWHANDLE w = Wasabi::Std::Wnd::getWindowFromPoint(pt);
  if (isOurExternalWindow(w)) return 1;
  pt.x = x-ext; pt.y = y-ext;
  w = Wasabi::Std::Wnd::getWindowFromPoint(pt);
  if (isOurExternalWindow(w)) return 1;
  pt.x = x; pt.y = y-ext;
  w = Wasabi::Std::Wnd::getWindowFromPoint(pt);
  if (isOurExternalWindow(w)) return 1;
  pt.x = x+ext; pt.y = y-ext;
  w = Wasabi::Std::Wnd::getWindowFromPoint(pt);
  if (isOurExternalWindow(w)) return 1;
  pt.x = x+ext; pt.y = y;
  w = Wasabi::Std::Wnd::getWindowFromPoint(pt);
  if (isOurExternalWindow(w)) return 1;
  pt.x = x+ext; pt.y = y+ext;
  w = Wasabi::Std::Wnd::getWindowFromPoint(pt);
  if (isOurExternalWindow(w)) return 1;
  pt.x = x; pt.y = y+ext;
  w = Wasabi::Std::Wnd::getWindowFromPoint(pt);
  if (isOurExternalWindow(w)) return 1;
  pt.x = x-ext; pt.y = y+ext;
  w = Wasabi::Std::Wnd::getWindowFromPoint(pt);
  if (isOurExternalWindow(w)) return 1;
  pt.x = x-ext; pt.y = y;
  w = Wasabi::Std::Wnd::getWindowFromPoint(pt);
  if (isOurExternalWindow(w)) return 1;
  return 0;
}

int AlphaMgr::isWasabiWindow(OSWINDOWHANDLE w) 
{
#ifdef _WIN32
  wchar_t classname[256]=L"";
  GetClassNameW(w, classname, 255);
  return (w == WASABI_API_WND->main_getRootWnd()->gethWnd() || !wcscmp(classname, BASEWNDCLASSNAME));
#else
#warning port me
  return 1;
#endif
}

int AlphaMgr::isMenuWindow(OSWINDOWHANDLE w) 
{
#ifdef _WIN32
  char classname[256]="";
  GetClassNameA(w, classname, 255);
  return STRCASEEQL(classname, "#32768");
#else
  return 0;
#warning port me
#endif
}

int AlphaMgr::isOurExternalWindow(OSWINDOWHANDLE w)
{
  OSWINDOWHANDLE wnd = w;
  if (isWasabiWindow(w)) 
    return 0;

  if (isMenuWindow(wnd)) {
    wnd = Wasabi::Std::Wnd::getFocus();
    if (isWasabiWindow(wnd) || isOurExternalWindow(wnd)) 
      return 1; 
  }
  
  while (wnd) 
  {
    if (Wasabi::Std::Wnd::isPopup(wnd))
    { 
      if (isWasabiWindow(wnd)) 
        return 0; 
      OSWINDOWHANDLE _w = Wasabi::Std::Wnd::getParent(wnd);
#ifdef _WIN32
      if (!_w) _w = GetWindow(wnd, GW_OWNER);
#else
#warning port me
#endif
      if (!wnd) _w = wnd;
      return (_w == WASABI_API_WND->main_getRootWnd()->gethWnd() || isWasabiWindow(_w) || isOurExternalWindow(_w));
    }
    wnd = Wasabi::Std::Wnd::getParent(wnd);
  }
  return 0;
}

void AlphaMgr::preHoverCheck(AlphaMgrEntry *e) {
  int isin = isMouseInLayout(e->getLayout());
  uint32_t last = e->getLastTimeIn();
  uint32_t lastbig = getBigLastTimeIn();
  if (isin) { e->onLastIn(); onBigLastIn(); }
  if (!getAutoOpacify()) {
    if (!isin && last != 0 && (last > Wasabi::Std::getTickCount() - holdtime_ms))
      isin = 1;
  } else {
    if (!isin && lastbig != 0 && (lastbig > Wasabi::Std::getTickCount() - holdtime_ms))
      isin = 1;
  }
  if (!isin) {
    if (hasAutoOpacityOnFocus(e)) {
      if (isFocusingExternalWindow()) isin = 1;
    } else {
      if (isOverExternalWindow()) isin = 1;
    }
  }
  e->setNextIn(isin);
  updateInList(e, isin);
}

void AlphaMgr::hoverCheck(Layout *l) {
  AlphaMgrEntry *e = layouts.findItem((const wchar_t *)l);
  if (e) hoverCheck(e);
}

void AlphaMgr::hoverCheck(AlphaMgrEntry *e, int applytransparency) {
  if (e->getStatus() == STATUS_UNKNOWN) 
    initStatus(e);

  int isin = e->getNextIn();
   
  if (getAutoOpacify()) {
    isin = big_status == STATUS_IN_FADINGON || big_status == STATUS_IN_ON || big_status == STATUS_IN_OFF;
  }
  if (hasAutoOpacity(e)) {
    if (isin) {
      // mouse is in, autoopacity is on
      switch (e->getStatus()) {
        case STATUS_OUT_OFF: 
        case STATUS_OUT_FADINGOUT:
        case STATUS_IN_OFF: 
          e->setStartAlpha(e->getLayout()->getTransparency());
          e->onEnterLeave();
          e->setStatus(STATUS_IN_FADINGON);
          checkTimer();
          e->getLayout()->onMouseEnterLayout();
          break;
        case STATUS_IN_FADINGON:
          doEndCheck(e);
          break;
      }
    } else {
      // mouse is out, autoopacity is on
      switch (e->getStatus()) {
        case STATUS_IN_FADINGON: 
        case STATUS_IN_ON: 
          e->setStartAlpha(e->getLayout()->getTransparency());
          e->onEnterLeave();
          e->setStatus(STATUS_OUT_FADINGOUT);
          checkTimer();
          e->getLayout()->onMouseLeaveLayout();
          break;
        case STATUS_OUT_FADINGOUT:
          doEndCheck(e);
          break;
      }
    }
  } else {
    if (isin) {
      // mouse is in, no autoopacity
      e->setStatus(STATUS_IN_OFF);
    } else {
      // mouse is out, no autoopacity
      e->setStatus(STATUS_OUT_OFF);
    }
  }
//  if (applytransparency) updateTransparency(e->getLayout());
}

void AlphaMgr::timerclient_timerCallback(int id) {
  switch(id) {
    case ALPHAMGR_HOVERCHECK: {
      foreach(layouts)
        AlphaMgrEntry *e = layouts.getfor();
        preHoverCheck(e);
      endfor;
      foreach(layouts)
        AlphaMgrEntry *e = layouts.getfor();
        hoverCheck(e);
      endfor;
    }
    break;
    case ALPHAMGR_UPDATEALPHA: {
      foreach(layouts)
        AlphaMgrEntry *e = layouts.getfor();
        if (e->getStatus() == STATUS_IN_FADINGON || e->getStatus() == STATUS_OUT_FADINGOUT) updateTransparency(e->getLayout());
      endfor;
    }
    break;
  }
}

int AlphaMgr::getBigCurTransparency() {
  switch (getBigStatus()) {
    case STATUS_IN_FADINGON:
    case STATUS_OUT_FADINGOUT:
      return getTransparency(NULL);
    case STATUS_IN_ON:
      return 255;
    case STATUS_IN_OFF:
    case STATUS_OUT_OFF:
      return getGlobalAlpha();
    default: return getTransparency(NULL);
  }
}

void AlphaMgr::setBigStartAlpha(int a) {
  big_startalpha = a;
}

void AlphaMgr::setBigStatus(int s) {
  big_status = s;
}

void AlphaMgr::onBigEnterLeave() {
  big_enterleave_time = Wasabi::Std::getTickCount();
}

uint32_t AlphaMgr::getBigEnterLeaveTime() {
  return big_enterleave_time;
}

void AlphaMgr::setAutoOpacify(int l) { 
  autoopacify = l; 
  resetTimer();
  if (l == 0) {
    foreach(layouts)
      if (layouts.getfor()->getStatus() == STATUS_IN_FADINGON) layouts.getfor()->setStatus(STATUS_IN_OFF);
      if (layouts.getfor()->getStatus() == STATUS_OUT_FADINGOUT) layouts.getfor()->setStatus(STATUS_OUT_OFF);
    endfor;
  }
  updateAllTransparency();
}

void AlphaMgr::resetTimer() {
  timerclient_killTimer(ALPHAMGR_HOVERCHECK);
  if (autoopacify == 1 && alllinked)
    timerclient_setTimer(ALPHAMGR_HOVERCHECK, 99);
  else
    timerclient_setTimer(ALPHAMGR_HOVERCHECK, 300);
}