CEzLcd::~CEzLcd()
{
// delete all the screens
LCD_PAGE_LIST::iterator it = m_LCDPageListMono.begin();
while(it != m_LCDPageListMono.end())
{
CEzLcdPage *page_ = *it;
LCDUIASSERT(NULL != page_);
delete page_;
++it;
}
it = m_LCDPageListColor.begin();
while(it != m_LCDPageListColor.end())
{
CEzLcdPage *page_ = *it;
LCDUIASSERT(NULL != page_);
delete page_;
++it;
}
m_connection.Shutdown();
DeleteCriticalSection(&m_ButtonCS);
}
HANDLE CEzLcdPage::AddSkinnedProgressBar(LGProgressBarType type)
{
LCDUIASSERT(LG_FILLED == type || LG_CURSOR == type || LG_DOT_CURSOR == type);
CLCDSkinnedProgressBar *pProgressBar_ = new CLCDSkinnedProgressBar();
LCDUIASSERT(NULL != pProgressBar_);
pProgressBar_->Initialize();
pProgressBar_->SetOrigin(0, 0);
pProgressBar_->SetSize(160, LG_PROGRESS_BAR_INITIAL_HEIGHT);
pProgressBar_->SetRange(LG_PROGRESS_BAR_RANGE_MIN, LG_PROGRESS_BAR_RANGE_MAX );
pProgressBar_->SetPos(static_cast<FLOAT>(LG_PROGRESS_BAR_RANGE_MIN));
pProgressBar_->SetObjectType(LG_PROGRESS_BAR);
// Map the progress style into what the UI classes understand
CLCDProgressBar::ePROGRESS_STYLE eStyle = CLCDProgressBar::STYLE_FILLED;
switch (type)
{
case LG_FILLED:
eStyle = CLCDProgressBar::STYLE_FILLED;
break;
case LG_CURSOR:
eStyle = CLCDProgressBar::STYLE_CURSOR;
break;
case LG_DOT_CURSOR:
eStyle = CLCDProgressBar::STYLE_DASHED_CURSOR;
break;
}
pProgressBar_->SetProgressStyle(eStyle);
AddObject(pProgressBar_);
return pProgressBar_;
}
HANDLE CEzLcdPage::AddColorProgressBar(LGProgressBarType type)
{
LCDUIASSERT(LG_FILLED == type || LG_CURSOR == type || LG_DOT_CURSOR == type);
CLCDColorProgressBar *pProgressBar_ = new CLCDColorProgressBar();
LCDUIASSERT(NULL != pProgressBar_);
pProgressBar_->Initialize();
pProgressBar_->SetOrigin(0, 0);
pProgressBar_->SetSize(LG_PROGRESS_BAR_INITIAL_WIDTH_COLOR, LG_PROGRESS_BAR_INITIAL_HEIGHT_COLOR);
pProgressBar_->SetRange(LG_PROGRESS_BAR_RANGE_MIN, LG_PROGRESS_BAR_RANGE_MAX );
pProgressBar_->SetPos(static_cast<FLOAT>(LG_PROGRESS_BAR_RANGE_MIN));
pProgressBar_->SetObjectType(LG_PROGRESS_BAR);
pProgressBar_->EnableBorder(TRUE);
// Map the progress style into what the UI classes understand
CLCDProgressBar::ePROGRESS_STYLE eStyle = CLCDProgressBar::STYLE_FILLED;
switch (type)
{
case LG_FILLED:
eStyle = CLCDProgressBar::STYLE_FILLED;
break;
//Dot cursor does not look good on color, so only using the regular cursor
case LG_CURSOR:
case LG_DOT_CURSOR:
eStyle = CLCDProgressBar::STYLE_CURSOR;
break;
}
pProgressBar_->SetProgressStyle(eStyle);
AddObject(pProgressBar_);
return pProgressBar_;
}
void CLCDGfxBase::BeginDraw(void)
{
LCDUIASSERT(NULL != m_hBitmap);
LCDUIASSERT(NULL == m_hPrevBitmap);
if(NULL == m_hPrevBitmap)
{
m_hPrevBitmap = (HBITMAP) SelectObject(m_hDC, m_hBitmap);
SetTextColor(m_hDC, RGB(255, 255, 255));
SetBkColor(m_hDC, RGB(0, 0, 0));
}
}
void CLCDGfxBase::EndDraw(void)
{
LCDUIASSERT(NULL != m_hPrevBitmap);
if(NULL != m_hPrevBitmap)
{
GdiFlush();
m_hPrevBitmap = (HBITMAP) SelectObject(m_hDC, m_hPrevBitmap);
LCDUIASSERT(m_hPrevBitmap == m_hBitmap);
m_hPrevBitmap = NULL;
}
}
HRESULT CLCDOutput::Initialize(lgLcdConnectContext* pContext, BOOL bUseWindow)
{
UNREFERENCED_PARAMETER(bUseWindow);
DWORD res = ERROR_SUCCESS;
CLCDManager::Initialize();
// initialize our screens
LCD_MGR_LIST::iterator it = m_LCDMgrList.begin();
while(it != m_LCDMgrList.end())
{
CLCDManager *pMgr = *it;
LCDUIASSERT(NULL != pMgr);
pMgr->Initialize();
++it;
}
// LCD Stuff
LCDUIASSERT(lInitCount >= 0);
if(1 == InterlockedIncrement(&lInitCount))
{
// need to call lgLcdInit once
res = lgLcdInit();
if (ERROR_SUCCESS != res)
{
InterlockedDecrement(&lInitCount);
LCDUITRACE(_T("WARNING: lgLcdInit failed\n"));
return E_FAIL;
}
}
m_lcdConnectCtxEx.appFriendlyName = _T("My App");
m_lcdConnectCtxEx.isPersistent = FALSE;
m_lcdConnectCtxEx.isAutostartable = FALSE;
m_lcdConnectCtxEx.connection = LGLCD_INVALID_CONNECTION;
// Initialize the added version 3.0 API fields
m_lcdConnectCtxEx.dwAppletCapabilitiesSupported = LGLCD_APPLET_CAP_BASIC;
m_lcdConnectCtxEx.dwReserved1 = 0;
m_lcdConnectCtxEx.onNotify.notificationCallback = NULL;
m_lcdConnectCtxEx.onNotify.notifyContext = NULL;
// if user passed in the context, fill it up
if (NULL != pContext)
{
memcpy(&m_lcdConnectCtxEx, pContext, sizeof(lgLcdConnectContext));
}
return S_OK;
}
/****f* LCD.SDK/SetVisible(HANDLE.handle,BOOL.visible)
* NAME
* HRESULT SetVisible(HANDLE handle, BOOL visible) -- Set
* corresponding object to be visible or invisible on the page being
* worked on.
* INPUTS
* handle - handle to the object.
* visible - set to FALSE to make object invisible, TRUE to make it
* visible (default).
* RETURN VALUE
* S_OK if succeeded.
* E_FAIL otherwise.
******
*/
HRESULT CEzLcd::SetVisible(HANDLE handle, BOOL visible)
{
CLCDBase* myObject_ = (CLCDBase*)handle;
LCDUIASSERT(NULL != myObject_);
LCDUIASSERT(NULL != myObject_);
if (NULL != myObject_)
{
myObject_->Show(visible);
return S_OK;
}
return E_FAIL;
}
/****f* LCD.SDK/SetOrigin(HANDLE.handle,INT.XOrigin,INT.YOrigin)
* NAME
* HRESULT SetOrigin(HANDLE handle, INT XOrigin, INT YOrigin) -- Set
* the origin of an object. The origin corresponds to the furthest
* pixel on the upper left corner of an object.
* INPUTS
* handle - handle to the object.
* XOrigin - x axis part of the origin.
* YOrigin - y axis part of the origin.
* RETURN VALUE
* S_OK if succeeded.
* E_FAIL otherwise.
******
*/
HRESULT CEzLcd::SetOrigin(HANDLE handle, INT XOrigin, INT YOrigin)
{
CLCDBase* myObject_ = (CLCDBase*)handle;
LCDUIASSERT(NULL != myObject_);
LCDUIASSERT(NULL != myObject_);
if (NULL != myObject_)
{
myObject_->SetOrigin(XOrigin, YOrigin);
return S_OK;
}
return E_FAIL;
}
void CLCDGfxBase::ClearScreen(void)
{
// this means, we're inside BeginDraw()/EndDraw()
LCDUIASSERT(NULL != m_hPrevBitmap);
RECT rc = { 0, 0, m_nWidth, m_nHeight };
FillRect(m_hDC, &rc, (HBRUSH) GetStockObject(BLACK_BRUSH));
}
lgLcdBitmap* CLCDGfxColor::GetLCDScreen(void)
{
LCDUIASSERT(m_pLCDScreen == (lgLcdBitmap *) &m_LCDScreen);
m_LCDScreen.hdr.Format = LGLCD_BMP_FORMAT_QVGAx32;
memcpy(m_LCDScreen.pixels, m_pBitmapBits, m_nWidth * m_nHeight * 4);
return m_pLCDScreen;
}
void CLCDGfxBase::Shutdown(void)
{
if(NULL != m_hBitmap)
{
DeleteObject(m_hBitmap);
m_hBitmap = NULL;
m_pBitmapBits = NULL;
}
LCDUIASSERT(NULL == m_hPrevBitmap);
m_hPrevBitmap = NULL;
if(NULL != m_pBitmapInfo)
{
delete [] m_pBitmapInfo;
m_pBitmapInfo = NULL;
}
if(NULL != m_hDC)
{
DeleteDC(m_hDC);
m_hDC = NULL;
}
m_nWidth = 0;
m_nHeight = 0;
}
void CLCDCollection::OnDraw(CLCDGfxBase &rGfx)
{
if(!IsVisible())
{
return;
}
//iterate through your objects and draw them
LCD_OBJECT_LIST::iterator it = m_Objects.begin();
while(it != m_Objects.end())
{
CLCDBase *pObject = *it++;
LCDUIASSERT(NULL != pObject);
if (pObject->IsVisible())
{
pObject->OnPrepareDraw(rGfx);
// create the clip region
HRGN hRgn = CreateRectRgn(pObject->GetOrigin().x, pObject->GetOrigin().y,
pObject->GetOrigin().x + pObject->GetWidth(),
pObject->GetOrigin().y + pObject->GetHeight());
// ensure that controls only draw within their specified region
SelectClipRgn(rGfx.GetHDC(), hRgn);
// free the region (a copy is used in the call above)
DeleteObject(hRgn);
// offset the control at its origin so controls use (0,0)
POINT ptPrevViewportOrg = { 0, 0 };
SetViewportOrgEx(rGfx.GetHDC(),
pObject->GetOrigin().x,
pObject->GetOrigin().y,
&ptPrevViewportOrg);
// allow controls to supply additional translation
// this allows controls to move freely within the confined viewport
OffsetViewportOrgEx(rGfx.GetHDC(),
pObject->GetLogicalOrigin().x,
pObject->GetLogicalOrigin().y,
NULL);
pObject->OnDraw(rGfx);
// set the clipping region to nothing
SelectClipRgn(rGfx.GetHDC(), NULL);
// restore the viewport origin
SetViewportOrgEx(rGfx.GetHDC(),
ptPrevViewportOrg.x,
ptPrevViewportOrg.y,
NULL);
// restore the viewport origin offset
OffsetViewportOrgEx(rGfx.GetHDC(), 0, 0, NULL);
}
}
}
void CLCDOutput::ClearBitmap(lgLcdBitmap160x43x1* pCurrentBitmap)
{
LCDUIASSERT(NULL != pCurrentBitmap);
if (pCurrentBitmap)
{
pCurrentBitmap->hdr.Format = LGLCD_BMP_FORMAT_160x43x1;
ZeroMemory(pCurrentBitmap->pixels, sizeof(pCurrentBitmap->pixels));
}
}
/****f* LCD.SDK/SetProgressBarSize(HANDLE.handle,INT.width,INT.height)
* NAME
* HRESULT SetProgressBarSize(HANDLE handle, INT width, INT height) --
* Set size of progress bar.
* INPUTS
* handle - handle to the object.
* width - x axis part of the size.
* height - y axis part of the size (a good default value is 5).
* RETURN VALUE
* S_OK if succeeded.
* E_FAIL otherwise.
******
*/
HRESULT CEzLcd::SetProgressBarSize(HANDLE handle, INT width, INT height)
{
CLCDBase* myObject_ = (CLCDBase*)handle;
LCDUIASSERT(NULL != myObject_);
if (NULL != myObject_)
{
LCDUIASSERT(LG_PROGRESS_BAR == myObject_->GetObjectType());
// only allow this function for progress bars
if (LG_PROGRESS_BAR == myObject_->GetObjectType())
{
myObject_->SetSize(width, height);
return S_OK;
}
}
return E_FAIL;
}
void CLCDOutput::Shutdown(void)
{
CloseAndDisconnect();
if(0 == InterlockedDecrement(&lInitCount))
{
lgLcdDeInit();
}
LCDUIASSERT(lInitCount >= 0);
}
HRESULT CEzLcdPage::SetOrigin(HANDLE handle, INT originX, INT originY)
{
CLCDBase* myObject_ = GetObject(handle);
LCDUIASSERT(NULL != myObject_);
LCDUIASSERT(NULL != myObject_);
//SIZE size_ = myObject_->GetSize();
//LGObjectType objectType_ = myObject_->GetObjectType();
if (NULL != myObject_)
{
myObject_->SetOrigin(originX, originY);
return S_OK;
}
return E_FAIL;
}
void CLCDOutput::Update(DWORD dwTimestamp)
{
if (m_pActiveScreen)
{
m_pActiveScreen->Update(dwTimestamp);
}
// check for expiration
if (m_pActiveScreen && m_pActiveScreen->HasExpired())
{
m_pActiveScreen = NULL;
//m_nPriority = LGLCD_PRIORITY_FYI; -> needs to go so that if a
// program sets priority to LGLCD_PRIORITY_BACKGROUND, that
// priority sticks.
OnScreenExpired(m_pActiveScreen);
// Clear the bitmap
ClearBitmap(m_pLastBitmap);
// find the next active screen
LCD_MGR_LIST::iterator it = m_LCDMgrList.begin();
while(it != m_LCDMgrList.end())
{
CLCDManager *pMgr = *it;
LCDUIASSERT(NULL != pMgr);
if (!pMgr->HasExpired())
{
ActivateScreen(pMgr);
//m_nPriority = LGLCD_PRIORITY_FYI; -> needs to go so that if a
// program sets priority to LGLCD_PRIORITY_BACKGROUND, that
// priority sticks.
break;
}
++it;
}
// if no screen found, empty the screen at idle priority
if (NULL == m_pActiveScreen)
{
if (LGLCD_INVALID_DEVICE != m_hDevice)
{
lgLcdUpdateBitmap(m_hDevice, &CLCDManager::GetLCDScreen()->hdr,
LGLCD_ASYNC_UPDATE(LGLCD_PRIORITY_IDLE_NO_SHOW));
}
}
}
// check for lcd devices
if (LGLCD_INVALID_DEVICE == m_hDevice)
{
EnumerateDevices();
}
}
/****f* LCD.SDK/SetProgressBarBackgroundColor(HANDLE.handle,COLORREF.color)
* NAME
* HRESULT SetProgressBarBackgroundColor(HANDLE handle, COLORREF color)
* -- For color only. Set the backgroundcolor of the progress bar.
* INPUTS
* handle - handle to the object.
* color - color to set the background.
* RETURN VALUE
* S_OK if succeeded.
* E_FAIL otherwise.
******
*/
HRESULT CEzLcd::SetProgressBarBackgroundColor(HANDLE handle, COLORREF color)
{
CLCDBase* myObject_ = (CLCDBase*)handle;
if (NULL != myObject_)
{
LCDUIASSERT(LG_PROGRESS_BAR == myObject_->GetObjectType());
// only allow this function for progress bars
if (LG_PROGRESS_BAR == myObject_->GetObjectType())
{
CLCDColorProgressBar *progressBar_ = static_cast<CLCDColorProgressBar*>(myObject_);
LCDUIASSERT(NULL != progressBar_);
progressBar_->SetBackgroundColor(color);
return S_OK;
}
}
return E_FAIL;
}
void CLCDGfx::DrawFilledRect(int nX, int nY, int nWidth, int nHeight)
{
// this means, we're inside BeginDraw()/EndDraw()
LCDUIASSERT(NULL != m_hPrevBitmap);
HBRUSH hPrevBrush = (HBRUSH) SelectObject(m_hDC, GetStockObject(WHITE_BRUSH));
RECT r = { nX, nY, nX + nWidth, nY + nHeight };
::FillRect(m_hDC, &r, hPrevBrush);
SelectObject(m_hDC, hPrevBrush);
}
/****f* LCD.SDK/SetProgressBarPosition(HANDLE.handle,FLOAT.percentage)
* NAME
* HRESULT SetProgressBarPosition(HANDLE handle, FLOAT percentage) --
* Set position of the progress bar's cursor.
* INPUTS
* handle - handle to the object.
* percentage - percentage of progress (0 to 100).
* RETURN VALUE
* S_OK if succeeded.
* E_FAIL otherwise.
******
*/
HRESULT CEzLcd::SetProgressBarPosition(HANDLE handle, FLOAT percentage)
{
CLCDBase* myObject_ = (CLCDBase*)handle;
if (NULL != myObject_)
{
LCDUIASSERT(LG_PROGRESS_BAR == myObject_->GetObjectType());
// only allow this function for progress bars
if (LG_PROGRESS_BAR == myObject_->GetObjectType())
{
CLCDProgressBar *progressBar_ = static_cast<CLCDProgressBar*>(myObject_);
LCDUIASSERT(NULL != progressBar_);
progressBar_->SetPos(percentage);
return S_OK;
}
}
return E_FAIL;
}
/****f* LCD.SDK/SetSkinnedProgressBarFiller(HANDLE.handle,HBITMAP.filler,INT.width,INT.height)
* NAME
* HRESULT SetSkinnedProgressBarFiller(HANDLE handle, HBITMAP filler,
* INT width, INT height) -- Sets the filler bitmap of the progress
* bar, which needs to be the same size as the background.
* INPUTS
* handle - Handle to the progress bar.
* filler - Handle to the bitmap to display as the filler.
* width, height - Size of the image (needs to be the same size as
* background).
* RETURN VALUE
* S_OK if succeeded.
* E_FAIL otherwise.
******
*/
HRESULT CEzLcd::SetSkinnedProgressBarFiller(HANDLE handle, HBITMAP filler, INT width, INT height)
{
CLCDBase* myObject_ = (CLCDBase*)handle;
if (NULL != myObject_)
{
LCDUIASSERT(LG_PROGRESS_BAR == myObject_->GetObjectType());
// only allow this function for progress bars
if (LG_PROGRESS_BAR == myObject_->GetObjectType())
{
CLCDSkinnedProgressBar *progressBar_ = static_cast<CLCDSkinnedProgressBar*>(myObject_);
LCDUIASSERT(NULL != progressBar_);
progressBar_->SetFiller(filler, width, height);
return S_OK;
}
}
return E_FAIL;
}
void CLCDGfx::DrawLine(int nX1, int nY1, int nX2, int nY2)
{
// this means, we're inside BeginDraw()/EndDraw()
LCDUIASSERT(NULL != m_hPrevBitmap);
HPEN hPrevPen = (HPEN) SelectObject(m_hDC, GetStockObject(WHITE_PEN));
::MoveToEx(m_hDC, nX1, nY1, NULL);
::LineTo(m_hDC, nX2, nY2);
SelectObject(m_hDC, hPrevPen);
}
void CLCDCollection::ResetUpdate(void)
{
LCD_OBJECT_LIST::iterator it = m_Objects.begin();
while(it != m_Objects.end())
{
CLCDBase *pObject = *it;
LCDUIASSERT(NULL != pObject);
pObject->ResetUpdate();
++it;
}
}
lgLcdBitmap160x43x1 *CLCDGfx::GetLCDScreen(void)
{
LCDUIASSERT(NULL != m_pLCDScreen);
if(NULL != m_pLCDScreen)
{
m_pLCDScreen->hdr.Format = LGLCD_BMP_FORMAT_160x43x1;
memcpy(m_pLCDScreen->pixels, m_pBitmapBits, m_nWidth * m_nHeight);
}
return m_pLCDScreen;
}
void CLCDCollection::OnUpdate(DWORD dwTimestamp)
{
LCD_OBJECT_LIST::iterator it = m_Objects.begin();
while(it != m_Objects.end())
{
CLCDBase *pObject = *it;
LCDUIASSERT(NULL != pObject);
pObject->OnUpdate(dwTimestamp);
++it;
}
}
lgLcdBitmap* CLCDGfxBase::GetLCDScreen(void)
{
LCDUIASSERT(NULL != m_pLCDScreen);
if(NULL != m_pLCDScreen)
{
// monochrome, as well as color pixels start at the same offset...
memcpy(m_pLCDScreen->bmp_mono.pixels, m_pBitmapBits, m_nWidth * m_nHeight * 4);
}
return m_pLCDScreen;
}
HRESULT CEzLcdPage::SetProgressBarColors(HANDLE handle, COLORREF cursorcolor, COLORREF bordercolor)
{
CLCDBase* myObject_ = GetObject(handle);
if (NULL != myObject_)
{
LCDUIASSERT(LG_PROGRESS_BAR == myObject_->GetObjectType());
// only allow this function for progress bars
if (LG_PROGRESS_BAR == myObject_->GetObjectType())
{
CLCDColorProgressBar *progressBar_ = static_cast<CLCDColorProgressBar*>(myObject_);
LCDUIASSERT(NULL != progressBar_);
progressBar_->SetCursorColor(cursorcolor);
progressBar_->SetBorderColor(bordercolor);
return S_OK;
}
}
return E_FAIL;
}
CEzLcdPage::~CEzLcdPage()
{
LCD_OBJECT_LIST::iterator it_ = m_Objects.begin();
while(it_ != m_Objects.end())
{
CLCDBase *pObject_ = *it_;
LCDUIASSERT(NULL != pObject_);
delete pObject_;
++it_;
}
}
HANDLE CEzLcdPage::AddBitmap(INT width, INT height)
{
CLCDBitmap *bitmap_ = new CLCDBitmap();
LCDUIASSERT(NULL != bitmap_);
bitmap_->Initialize();
bitmap_->SetOrigin(0, 0);
bitmap_->SetSize(width, height);
AddObject(bitmap_);
return bitmap_;
}
void CLCDText::SetText(LPCTSTR szText)
{
LCDUIASSERT(NULL != szText);
if(szText && _tcscmp(m_sText.c_str(), szText))
{
m_sText.assign(szText);
m_nTextLength = m_sText.size();
m_dtp.iLeftMargin = 0;
m_dtp.iRightMargin = 0;
m_bRecalcExtent = TRUE;
}
}
