aeeimagectl.c

test return point or point as param

                     y = pme->m_rc.y;
                     cy = pme->m_rc.dy;
                     if(pme->m_bScrollX){
                        cy -= pme->m_nSBWidth;
                     }
                     if( wYPos >= y && wYPos <= (y + cy) ){
                        nRange = cy;
                        nScrollRange = pme->m_ii.cy - cy;

                        nLen = nRange / (pme->m_ii.cy/cy);
                        if(nLen < 2)
                           nLen = 2;
                        pnOffset = &pme->m_yOffset;
                        wGenericPos = wYPos;
                        wBase = y;
                     }
                  }
               }else{
                  if( wYPos >= ((pme->m_rc.y + pme->m_rc.dy) - pme->m_nSBWidth)
                     && wYPos < (pme->m_rc.y + pme->m_rc.dy) ){
                     int x,cx;
                     // Inside the Scrollbar still
                     x = pme->m_rc.x;
                     cx = pme->m_rc.dx;
                     if(pme->m_bScrollY){
                        cx -= pme->m_nSBWidth;
                     }
                     if( wXPos >= x && wXPos <= (x + cx) ){
                        nRange = cx;
                        nScrollRange = pme->m_ii.cx - cx;

                        nLen = nRange / (pme->m_ii.cx/cx);
                        if(nLen < 2)
                           nLen = 2;
                        pnOffset = &pme->m_xOffset;
                        wGenericPos = wXPos;
                        wBase = x;
                     }
                  }
               }
               if( pnOffset ){
                  // Solve for Idx
                  wIdx = (((wGenericPos-wBase)-pme->m_ptTracker.wThumbOffset)*nScrollRange)/(nRange-nLen);

                  if(wIdx > nScrollRange)
                     wIdx = nScrollRange;
                  else if(wIdx < 0)
                     wIdx = 0;

                  if( *pnOffset != wIdx ){
                     // Only redraw a scrolled item
                     *pnOffset = wIdx;
                     IIMAGE_SetParm(pme->m_pImage, IPARM_OFFSET, pme->m_xOffset, pme->m_yOffset);
                     ImageCtl_RedrawCB(pme);
                  }
               }
            }else{
               // Need to check the timer, since this only cares
               // IF the pen is moved when the thumb is stalled
               // AND the move was in the direction of the flow
               if( !(pme->m_ptTracker.cbFlags & PTRCK_GEN_TMRSET) 
                  && pme->m_ptTracker.cbHit & PTRCK_NOTTHUMB ){
                  ImageCtl_ScrollByPos(pme, ((pme->m_ptTracker.cbHit & PTRCK_HIT_BELOW) ? 1 : -1), AEE_GET_X(dwp), AEE_GET_Y(dwp));
               }
            }
            return TRUE;
         }
      }
      break;
      case EVT_PEN_DOWN:
      {
         AEERect  rctFrame, rctThumb;
         int16    wXPos = AEE_GET_X(dwp);
         int16    wYPos = AEE_GET_Y(dwp);

         if( !ImageCtl_GetScrollBarRects(pme, &rctFrame, &rctThumb, TRUE) ){
            // Check the overall frame first to see if it is within the vertical scrollbar element
            if( PT_IN_RECT(wXPos, wYPos, rctFrame) ){
               // Note: X Range is already OK by checking the FRAME bounds above

               pme->m_ptTracker.cbHit = 0;
               // Check the thumb first!
               // Don't want to restrict the thumb from the scroll edges, 
               // so entire width is valid given it is in vertical thumb range
               if( wYPos >= rctThumb.y && wYPos <= (rctThumb.y + rctThumb.dy) ){
                  pme->m_ptTracker.cbHit = PTRCK_HIT_THUMB;
               }else if( wYPos < rctThumb.y ){
                  pme->m_ptTracker.cbHit = PTRCK_HIT_ABOVE;
               }else{
                  pme->m_ptTracker.cbHit = PTRCK_HIT_BELOW;
               }
               pme->m_ptTracker.cbHit |= PTRCK_HIT_VSCRL;
               pme->m_ptTracker.wThumbOffset = wYPos - rctThumb.y;
               pme->m_ptTracker.ptPosition.x = wXPos;
               pme->m_ptTracker.ptPosition.y = wYPos;
               if( pme->m_ptTracker.cbHit & PTRCK_NOTTHUMB ){
                  ImageCtl_ScrollTimerCB(pme);
                  pme->m_ptTracker.cbFlags |= PTRCK_GEN_TMRSET;
                  ISHELL_SetTimer(pme->m_pShell, pme->m_arPenRepeat.dwStart, (PFNNOTIFY)ImageCtl_ScrollTimerCB, (void *)pme);
               }
               return TRUE;
            }
         }
         if( !ImageCtl_GetScrollBarRects(pme, &rctFrame, &rctThumb, FALSE) ){
            // Check the overall frame first to see if it is within the horizontal scrollbar element
            if( PT_IN_RECT(wXPos, wYPos, rctFrame) ){
               // Note: Y Range is already OK by checking the FRAME bounds above

               pme->m_ptTracker.cbHit = 0;
               // Check the thumb first!
               // Don't want to restrict the thumb from the scroll edges, 
               // so entire width is valid given it is in vertical thumb range
               if( wXPos >= rctThumb.x && wXPos <= (rctThumb.x + rctThumb.dx) ){
                  pme->m_ptTracker.cbHit = PTRCK_HIT_THUMB;
               }else if( wXPos < rctThumb.x ){
                  pme->m_ptTracker.cbHit = PTRCK_HIT_ABOVE;
               }else{
                  pme->m_ptTracker.cbHit = PTRCK_HIT_BELOW;
               }
               pme->m_ptTracker.wThumbOffset = wXPos - rctThumb.x;
               pme->m_ptTracker.ptPosition.x = wXPos;
               pme->m_ptTracker.ptPosition.y = wYPos;
               if( pme->m_ptTracker.cbHit & PTRCK_NOTTHUMB ){
                  ImageCtl_ScrollTimerCB(pme);
                  pme->m_ptTracker.cbFlags |= PTRCK_GEN_TMRSET;
                  ISHELL_SetTimer(pme->m_pShell, pme->m_arPenRepeat.dwStart, (PFNNOTIFY)ImageCtl_ScrollTimerCB, (void *)pme);
               }
               return TRUE;
            }
         }
         pme->m_ptTracker.cbHit = pme->m_ptTracker.cbFlags = 0;
         pme->m_ptTracker.wThumbOffset = 0;
         pme->m_ptTracker.ptPosition.x = pme->m_ptTracker.ptPosition.y = 0;
         if( PT_IN_RECT(wXPos, wYPos, pme->m_rc) ){
            return TRUE;
         }
      }
      break;
      case EVT_PEN_UP:
      {
         boolean bRet = (pme->m_ptTracker.cbHit ? TRUE : FALSE);
         // Reset stored data to initial values
         pme->m_ptTracker.cbFlags &= ~PTRCK_GEN_TMRSET;
         ISHELL_CancelTimer(pme->m_pShell, NULL, pme);
         pme->m_ptTracker.cbHit = pme->m_ptTracker.cbFlags = 0;
         pme->m_ptTracker.wThumbOffset = 0;
         pme->m_ptTracker.ptPosition.x = pme->m_ptTracker.ptPosition.y = 0;
         return bRet;
      }
   }
   if (evt == EVT_CTL_ADD_ITEM)
   {
      CtlAddItem* pai = (CtlAddItem*)dwp;
      if (!pai)
         return(TRUE);	// we handled the event, but didn't really do much

      if (pai->pImage)
         ImageCtl_SetImage(po, pai->pImage);

      else // image might be coming from the resource, try to load
      {
         IImage* pImage = ISHELL_LoadResImage(pme->m_pShell,
                                              pai->pszResText, pai->wImage);

         if (pImage)
         {
            ImageCtl_SetImage(po, pImage);
            IIMAGE_Release(pImage);
         }
      }

      return(TRUE);
   }

   if (evt == EVT_KEY && pme->m_bActive && pme->m_pImage)
   {
      int   nSB;
      boolean bMoved = FALSE;

      nSB = pme->m_nSBWidth;
      if (pme->m_dwProps & CP_BORDER)
         nSB++;

      switch (wp)
      {
      case AVK_UP:
         if (pme->m_yOffset <= 0)
            return(FALSE);
         bMoved = TRUE;
         pme->m_yOffset--;
         break;
            
      case AVK_DOWN:
         if (pme->m_yOffset + (pme->m_rc.dy - nSB) >= pme->m_ii.cy)
            return(FALSE);
         bMoved = TRUE;
         pme->m_yOffset++;
         break;

      case AVK_RIGHT:
         if (pme->m_xOffset + (pme->m_rc.dx - nSB) >= pme->m_ii.cxFrame)
            return(FALSE);
         bMoved = TRUE;
         pme->m_xOffset++;
         break;

      case AVK_LEFT:
         if (pme->m_xOffset <= 0)
            return(FALSE);
         bMoved = TRUE;
         pme->m_xOffset--;
         break;

      case AVK_SELECT:
         if( ISHELL_HandleEvent(pme->m_pShell, EVT_CTL_TAB, (uint16)1, (uint32)po) )
            return TRUE;
         break;

      case AVK_CLR:
         if( ISHELL_HandleEvent(pme->m_pShell, EVT_CTL_TAB, (uint16)0, (uint32)po) )
            return TRUE;
         break;

      default:
         return (IIMAGE_HandleEvent(pme->m_pImage, evt, wp, dwp));

      }	// switch
      
      IIMAGE_SetParm(pme->m_pImage, IPARM_OFFSET, pme->m_xOffset, pme->m_yOffset);
      ImageCtl_RedrawCB(pme);
      return bMoved;
   }	// if 
   
   return(FALSE);
}

/*===========================================================================

Public Method - Resets the clock control. See AEEAClock.h

===========================================================================*/
static void ImageCtl_Reset(IImageCtl * po)
{
   ImageCtl * pme   = (ImageCtl *)po;

   aee_releaseobj((void **)(&pme->m_pImage));
   pme->m_bActive = FALSE;
   pme->m_bStarted = FALSE;
   pme->m_bScrollX = pme->m_bScrollY = FALSE;
   MEMSET((void *)&pme->m_ptTracker, 0, sizeof(pme->m_ptTracker));
   MEMSET((void *)&pme->m_ptViewSize, 0, sizeof(pme->m_ptViewSize));
}

/*===========================================================================

Public Method - Redraws the clock. See AEEAClock.h

===========================================================================*/
static boolean ImageCtl_Redraw(IImageCtl * po)
{
   ImageCtl *     pme = (ImageCtl *)po;
   AEERect        rc;

   if(!pme->m_pImage)
      return(FALSE);

   if(!pme->m_ii.cxFrame)
      IIMAGE_GetInfo(pme->m_pImage, &pme->m_ii);

   rc = pme->m_rc;

   if(pme->m_dwProps & CP_BORDER){
      IDISPLAY_FrameRect(pme->m_pDisplay,&rc);
      rc.x++;
      rc.y++;
      rc.dx -= 2;
      rc.dy -= 2;
   }

   ImageCtl_CheckScroll(pme);

   if(pme->m_bStarted)
      IIMAGE_Draw(pme->m_pImage,rc.x,rc.y);
   else{
      pme->m_bStarted = TRUE;
      IIMAGE_Start(pme->m_pImage, rc.x, rc.y);
   }

   if(pme->m_bActive && (pme->m_bScrollX || pme->m_bScrollY)){
      if(pme->m_bScrollY)
         ImageCtl_DrawScrollBar(pme,TRUE);

      if(pme->m_bScrollX)
         ImageCtl_DrawScrollBar(pme,FALSE);
   }

   IDISPLAY_Update(pme->m_pDisplay);

   return(TRUE);
}


/*===========================================================================

Public Method - Sets flags/properties for the analog clock. See AEEAClock.h

===========================================================================*/
static void ImageCtl_SetProperties(IImageCtl * po, uint32 dwProps)
{
   ImageCtl * pme = (ImageCtl *)po;