From e603b7143c322fbfdbe3bcd99b67a20d2168413f Mon Sep 17 00:00:00 2001 From: alexwild Date: Fri, 24 Aug 2007 10:15:39 +0000 Subject: Logitech G15 Support, Part 1/2 git-svn-id: https://mpc-hc.svn.sourceforge.net/svnroot/mpc-hc/trunk@159 10f7b99b-c216-0410-bff0-8a66a9350fd8 --- src/ui/LCDUI/LCDAnimatedBitmap.cpp | 163 ++++++++ src/ui/LCDUI/LCDAnimatedBitmap.h | 49 +++ src/ui/LCDUI/LCDBase.cpp | 324 +++++++++++++++ src/ui/LCDUI/LCDBase.h | 84 ++++ src/ui/LCDUI/LCDBitmap.cpp | 87 ++++ src/ui/LCDUI/LCDBitmap.h | 37 ++ src/ui/LCDUI/LCDCollection.cpp | 196 +++++++++ src/ui/LCDUI/LCDCollection.h | 48 +++ src/ui/LCDUI/LCDGfx.cpp | 342 +++++++++++++++ src/ui/LCDUI/LCDGfx.h | 77 ++++ src/ui/LCDUI/LCDManager.cpp | 204 +++++++++ src/ui/LCDUI/LCDManager.h | 49 +++ src/ui/LCDUI/LCDOutput.cpp | 822 +++++++++++++++++++++++++++++++++++++ src/ui/LCDUI/LCDOutput.h | 101 +++++ src/ui/LCDUI/LCDProgressBar.cpp | 270 ++++++++++++ src/ui/LCDUI/LCDProgressBar.h | 66 +++ src/ui/LCDUI/LCDScrollingText.cpp | 294 +++++++++++++ src/ui/LCDUI/LCDScrollingText.h | 65 +++ src/ui/LCDUI/LCDText.cpp | 396 ++++++++++++++++++ src/ui/LCDUI/LCDText.h | 71 ++++ src/ui/LCDUI/LCDUI.sln | 25 ++ src/ui/LCDUI/LCDUI.vcproj | 343 ++++++++++++++++ 22 files changed, 4113 insertions(+) create mode 100644 src/ui/LCDUI/LCDAnimatedBitmap.cpp create mode 100644 src/ui/LCDUI/LCDAnimatedBitmap.h create mode 100644 src/ui/LCDUI/LCDBase.cpp create mode 100644 src/ui/LCDUI/LCDBase.h create mode 100644 src/ui/LCDUI/LCDBitmap.cpp create mode 100644 src/ui/LCDUI/LCDBitmap.h create mode 100644 src/ui/LCDUI/LCDCollection.cpp create mode 100644 src/ui/LCDUI/LCDCollection.h create mode 100644 src/ui/LCDUI/LCDGfx.cpp create mode 100644 src/ui/LCDUI/LCDGfx.h create mode 100644 src/ui/LCDUI/LCDManager.cpp create mode 100644 src/ui/LCDUI/LCDManager.h create mode 100644 src/ui/LCDUI/LCDOutput.cpp create mode 100644 src/ui/LCDUI/LCDOutput.h create mode 100644 src/ui/LCDUI/LCDProgressBar.cpp create mode 100644 src/ui/LCDUI/LCDProgressBar.h create mode 100644 src/ui/LCDUI/LCDScrollingText.cpp create mode 100644 src/ui/LCDUI/LCDScrollingText.h create mode 100644 src/ui/LCDUI/LCDText.cpp create mode 100644 src/ui/LCDUI/LCDText.h create mode 100644 src/ui/LCDUI/LCDUI.sln create mode 100644 src/ui/LCDUI/LCDUI.vcproj (limited to 'src/ui') diff --git a/src/ui/LCDUI/LCDAnimatedBitmap.cpp b/src/ui/LCDUI/LCDAnimatedBitmap.cpp new file mode 100644 index 000000000..497fa40dd --- /dev/null +++ b/src/ui/LCDUI/LCDAnimatedBitmap.cpp @@ -0,0 +1,163 @@ +//************************************************************************ +// +// LCDAnimatedBitmap.cpp +// +// The CLCDAnimatedBitmap class draws animated bitmaps onto the LCD. +// An animated bitmap consists of a tiled bitmap representing the +// animation. The tile size is set with the SetSubpicWidth. +// +// Logitech LCD SDK +// +// Copyright 2005 Logitech Inc. +//************************************************************************ + +#include "LCDAnimatedBitmap.h" + + +//************************************************************************ +// +// CLCDAnimatedBitmap::CLCDAnimatedBitmap +// +//************************************************************************ + +CLCDAnimatedBitmap::CLCDAnimatedBitmap() +{ + m_dwCurrSubpic = m_dwTotalSubpics = 0; +} + + +//************************************************************************ +// +// CLCDAnimatedBitmap::CLCDAnimatedBitmap +// +//************************************************************************ + +CLCDAnimatedBitmap::~CLCDAnimatedBitmap() +{ + +} + + +//************************************************************************ +// +// CLCDAnimatedBitmap::Initialize +// +//************************************************************************ + +HRESULT CLCDAnimatedBitmap::Initialize(void) +{ + m_dwRate = 250; + m_dwElapsedTime = 0; + m_dwLastUpdate = GetTickCount(); + + return CLCDBitmap::Initialize(); +} + + +//************************************************************************ +// +// CLCDAnimatedBitmap::ResetUpdate +// +//************************************************************************ + +void CLCDAnimatedBitmap::ResetUpdate(void) +{ + m_dwCurrSubpic = 0; + m_dwLastUpdate = GetTickCount(); +} + + +//************************************************************************ +// +// CLCDAnimatedBitmap::SetSubpicWidth +// +//************************************************************************ + +void CLCDAnimatedBitmap::SetSubpicWidth(DWORD dwWidth) +{ + m_dwSubpicWidth = dwWidth; + LCDUIASSERT(NULL != m_hBitmap); + LCDUIASSERT(0 != dwWidth); + if((NULL != m_hBitmap) && (0 != dwWidth)) + { + // figure out how many tiles we have + BITMAP bitmap; + if(GetObject(m_hBitmap, sizeof(bitmap), &bitmap)) + { + m_dwTotalSubpics = bitmap.bmWidth / dwWidth; + SetLogicalSize(bitmap.bmWidth, bitmap.bmHeight); + } + else + { + m_dwTotalSubpics = 0; + } + } + else + { + m_dwTotalSubpics = 0; + } +} + +//************************************************************************ +// +// CLCDAnimatedBitmap::SetAnimationRate +// +//************************************************************************ + +void CLCDAnimatedBitmap::SetAnimationRate(DWORD dwRate) +{ + m_dwRate = dwRate; +} + + +//************************************************************************ +// +// CLCDAnimatedBitmap::OnUpdate +// +//************************************************************************ + +void CLCDAnimatedBitmap::OnUpdate(DWORD dwTimestamp) +{ + m_dwElapsedTime = (dwTimestamp - m_dwLastUpdate); +} + + +//************************************************************************ +// +// CLCDAnimatedBitmap::OnDraw +// +//************************************************************************ + +void CLCDAnimatedBitmap::OnDraw(CLCDGfx &rGfx) +{ + if(m_dwTotalSubpics > 0) + { + int xoffs = m_dwCurrSubpic * m_dwSubpicWidth; + + DWORD increment = m_dwElapsedTime / m_dwRate; + if(increment > 0) + { + m_dwCurrSubpic += increment; + m_dwCurrSubpic %= m_dwTotalSubpics; + m_dwElapsedTime %= m_dwRate; + m_dwLastUpdate = GetTickCount(); + } + + // stolen from: CLCDBitmap::OnDraw(rGfx); + if(m_hBitmap) + { + HDC hCompatibleDC = CreateCompatibleDC(rGfx.GetHDC()); + HBITMAP hOldBitmap = (HBITMAP)SelectObject(hCompatibleDC, m_hBitmap); + + // get + BitBlt(rGfx.GetHDC(), 0, 0, m_Size.cx, m_Size.cy, hCompatibleDC, xoffs, 0, m_dwROP); + + // restores + SelectObject(hCompatibleDC, hOldBitmap); + DeleteDC(hCompatibleDC); + } + } +} + + +//** end of LCDAnimatedBitmap.cpp **************************************** diff --git a/src/ui/LCDUI/LCDAnimatedBitmap.h b/src/ui/LCDUI/LCDAnimatedBitmap.h new file mode 100644 index 000000000..492959cd1 --- /dev/null +++ b/src/ui/LCDUI/LCDAnimatedBitmap.h @@ -0,0 +1,49 @@ +//************************************************************************ +// +// LCDAnimatedBitmap.h +// +// The CLCDAnimatedBitmap class draws animated bitmaps onto the LCD. +// An animated bitmap consists of a tiled bitmap representing the +// animation. The tile size is set with the SetSubpicWidth. +// +// Logitech LCD SDK +// +// Copyright 2005 Logitech Inc. +//************************************************************************ + +#ifndef _LCDANIMATEDBITMAP_H_INCLUDED_ +#define _LCDANIMATEDBITMAP_H_INCLUDED_ + +#include "LCDBase.h" +#include "LCDBitmap.h" + +class CLCDAnimatedBitmap : public CLCDBitmap +{ +public: + CLCDAnimatedBitmap(); + virtual ~CLCDAnimatedBitmap(); + + virtual HRESULT Initialize(void); + virtual void ResetUpdate(void); + + void SetSubpicWidth(DWORD dwWidth); + void SetAnimationRate(DWORD dwRate); // milliseconds/subpicture + +protected: + virtual void OnUpdate(DWORD dwTimestamp); + virtual void OnDraw(CLCDGfx &rGfx); + +private: + DWORD m_dwElapsedTime; // elapsed time in state + DWORD m_dwRate; // milliseconds per subpicture + DWORD m_dwLastUpdate; // milliseconds + + DWORD m_dwSubpicWidth; + DWORD m_dwCurrSubpic; + DWORD m_dwTotalSubpics; +}; + + +#endif // !_LCDANIMATEDBITMAP_H_INCLUDED_ + +//** end of LCDBitmap.h ************************************************** diff --git a/src/ui/LCDUI/LCDBase.cpp b/src/ui/LCDUI/LCDBase.cpp new file mode 100644 index 000000000..4b4c585d9 --- /dev/null +++ b/src/ui/LCDUI/LCDBase.cpp @@ -0,0 +1,324 @@ +//************************************************************************ +// +// LCDBase.cpp +// +// The CLCDBase class is the generic base class for all lcd ui objects +// +// Logitech LCD SDK +// +// Copyright 2005 Logitech Inc. +//************************************************************************ + +#include "LCDBase.h" + + +//************************************************************************ +// +// CLCDBase::CLCDBase +// +//************************************************************************ + +CLCDBase::CLCDBase(void) +{ + m_Size.cx = 0; + m_Size.cy = 0; + m_Origin.x = 0; + m_Origin.y = 0; + m_bVisible = TRUE; + m_bInverted = FALSE; + ZeroMemory(&m_ptLogical, sizeof(m_ptLogical)); + ZeroMemory(&m_sizeLogical, sizeof(m_sizeLogical)); + m_nBkMode = TRANSPARENT; + m_objectType = LG_UNKNOWN; +} + + +//************************************************************************ +// +// CLCDBase::~CLCDBase +// +//************************************************************************ + +CLCDBase::~CLCDBase(void) +{ +} + + +//************************************************************************ +// +// CLCDBase::Initialize +// +//************************************************************************ + +HRESULT CLCDBase::Initialize(void) +{ + return S_OK; +} + + +//************************************************************************ +// +// CLCDBase::Shutdown +// +//************************************************************************ + +void CLCDBase::Shutdown(void) +{ +} + + +//************************************************************************ +// +// CLCDBase::SetOrigin +// +//************************************************************************ + +void CLCDBase::SetOrigin(POINT pt) +{ + m_Origin = pt; +} + + +//************************************************************************ +// +// CLCDBase::SetOrigin +// +//************************************************************************ + +void CLCDBase::SetOrigin(int nX, int nY) +{ + POINT pt = { nX, nY }; + SetOrigin(pt); +} + + +//************************************************************************ +// +// CLCDBase::GetOrigin +// +//************************************************************************ + +POINT& CLCDBase::GetOrigin(void) +{ + return m_Origin; +} + + +//************************************************************************ +// +// CLCDBase::SetSize +// +//************************************************************************ + +void CLCDBase::SetSize(SIZE& size) +{ + m_Size = size; + SetLogicalSize(m_Size); +} + + +//************************************************************************ +// +// CLCDBase::SetSize +// +//************************************************************************ + +void CLCDBase::SetSize(int nCX, int nCY) +{ + SIZE size = { nCX, nCY }; + SetSize(size); +} + + +//************************************************************************ +// +// CLCDBase::GetSize +// +//************************************************************************ + +SIZE& CLCDBase::GetSize(void) +{ + return m_Size; +} + + +//************************************************************************ +// +// CLCDBase::SetLogicalOrigin +// +//************************************************************************ + +void CLCDBase::SetLogicalOrigin(POINT& pt) +{ + m_ptLogical = pt; +} + + +//************************************************************************ +// +// CLCDBase::SetLogicalOrigin +// +//************************************************************************ + +void CLCDBase::SetLogicalOrigin(int nX, int nY) +{ + m_ptLogical.x = nX; + m_ptLogical.y = nY; +} + + +//************************************************************************ +// +// CLCDBase::GetLogicalOrigin +// +//************************************************************************ + +POINT& CLCDBase::GetLogicalOrigin(void) +{ + return m_ptLogical; +} + + +//************************************************************************ +// +// CLCDBase::SetLogicalSize +// +//************************************************************************ + +void CLCDBase::SetLogicalSize(SIZE& size) +{ + m_sizeLogical = size; +} + + +//************************************************************************ +// +// CLCDBase::SetLogicalSize +// +//************************************************************************ + +void CLCDBase::SetLogicalSize(int nCX, int nCY) +{ + m_sizeLogical.cx = nCX; + m_sizeLogical.cy = nCY; +} + + +//************************************************************************ +// +// CLCDBase::GetLogicalSize +// +//************************************************************************ + +SIZE& CLCDBase::GetLogicalSize(void) +{ + return m_sizeLogical; +} + + +//************************************************************************ +// +// CLCDBase::Show +// +//************************************************************************ + +void CLCDBase::Show(BOOL bShow) +{ + m_bVisible = bShow; +} + + +//************************************************************************ +// +// BOOL CLCDBase:: +// +//************************************************************************ + +BOOL CLCDBase::IsVisible(void) +{ + return m_bVisible; +} + + +//************************************************************************ +// +// CLCDBase::Invert +// +//************************************************************************ + +void CLCDBase::Invert(BOOL bEnable) +{ + m_bInverted = bEnable; +} + + +//************************************************************************ +// +// CLCDBase::ResetUpdate +// +//************************************************************************ + +void CLCDBase::ResetUpdate(void) +{ + // do nothing +} + + +//************************************************************************ +// +// CLCDBase::OnUpdate +// +//************************************************************************ + +void CLCDBase::OnUpdate(DWORD dwTimestamp) +{ + UNREFERENCED_PARAMETER(dwTimestamp); +} + + +//************************************************************************ +// +// CLCDBase::SetBackgroundMode +// +//************************************************************************ + +void CLCDBase::SetBackgroundMode(int nMode) +{ + m_nBkMode = nMode; +} + + +//************************************************************************ +// +// CLCDBase::GetBackgroundMode +// +//************************************************************************ + +int CLCDBase::GetBackgroundMode() +{ + return m_nBkMode; +} + +//************************************************************************ +// +// CLCDBase::GetObjectType +// +//************************************************************************ + +const LGObjectType CLCDBase::GetObjectType() +{ + return m_objectType; +} + +//************************************************************************ +// +// CLCDBase::SetObjectType +// +//************************************************************************ + +void CLCDBase::SetObjectType(const LGObjectType type) +{ + m_objectType = type; +} + +//** end of LCDBase.cpp ************************************************** diff --git a/src/ui/LCDUI/LCDBase.h b/src/ui/LCDUI/LCDBase.h new file mode 100644 index 000000000..dbf677cc7 --- /dev/null +++ b/src/ui/LCDUI/LCDBase.h @@ -0,0 +1,84 @@ +//************************************************************************ +// +// LCDBase.h +// +// The CLCDBase class is the generic base class for all lcd ui objects +// +// Logitech LCD SDK +// +// Copyright 2005 Logitech Inc. +//************************************************************************ + +#ifndef _LCDBASE_H_INCLUDED_ +#define _LCDBASE_H_INCLUDED_ + +#include "LCDGfx.h" + + +typedef enum +{ + LG_SCROLLING_TEXT, LG_STATIC_TEXT, LG_ICON, LG_PROGRESS_BAR, LG_UNKNOWN +} LGObjectType; + +class CLCDBase +{ +public: + CLCDBase(void); + virtual ~CLCDBase(void); + +public: + virtual HRESULT Initialize(void); + virtual void Shutdown(void); + + virtual void SetOrigin(POINT pt); + virtual void SetOrigin(int nX, int nY); + virtual POINT& GetOrigin(void); + + virtual void SetSize(SIZE& size); + virtual void SetSize(int nCX, int nCY); + virtual SIZE& GetSize(void); + + virtual int GetWidth(void) { return GetSize().cx; } + virtual int GetHeight(void) { return GetSize().cy; }; + + virtual void Show(BOOL bShow); + virtual BOOL IsVisible(); + + virtual void Invert(BOOL bEnable); + virtual void ResetUpdate(void); + + // local coordinates + virtual void SetLogicalOrigin(POINT& rLogical); + virtual void SetLogicalOrigin(int nX, int nY); + virtual POINT& GetLogicalOrigin(void); + virtual void SetLogicalSize(SIZE& size); + virtual void SetLogicalSize(int nCX, int nCY); + virtual SIZE& GetLogicalSize(void); + + virtual void SetBackgroundMode(int nMode); + virtual int GetBackgroundMode(); + + virtual const LGObjectType GetObjectType(); + virtual void SetObjectType(const LGObjectType type); + +public: + virtual void OnDraw(CLCDGfx &rGfx) = 0; + virtual void OnUpdate(DWORD dwTimestamp); + +protected: + SIZE m_Size; + POINT m_Origin; + BOOL m_bVisible; + BOOL m_bInverted; + + POINT m_ptLogical; + SIZE m_sizeLogical; + int m_nBkMode; + + LGObjectType m_objectType; +}; + + +#endif // !_LCDBASE_H_INCLUDED_ + +//** end of LCDBase.h **************************************************** diff --git a/src/ui/LCDUI/LCDBitmap.cpp b/src/ui/LCDUI/LCDBitmap.cpp new file mode 100644 index 000000000..559a88a5b --- /dev/null +++ b/src/ui/LCDUI/LCDBitmap.cpp @@ -0,0 +1,87 @@ +//************************************************************************ +// +// LCDBitmap.cpp +// +// The CLCDBitmap class draws bitmaps onto the LCD. +// +// Logitech LCD SDK +// +// Copyright 2005 Logitech Inc. +//************************************************************************ + +#include "LCDBitmap.h" + + +//************************************************************************ +// +// CLCDBitmap::CLCDBitmap +// +//************************************************************************ + +CLCDBitmap::CLCDBitmap() +{ + m_hBitmap = NULL; + m_dwROP = SRCCOPY; +} + + +//************************************************************************ +// +// CLCDBitmap::CLCDBitmap +// +//************************************************************************ + +CLCDBitmap::~CLCDBitmap() +{ + +} + + +//************************************************************************ +// +// CLCDBitmap::SetBitmap +// +//************************************************************************ + +void CLCDBitmap::SetBitmap(HBITMAP hBitmap) +{ + LCDUIASSERT(NULL != hBitmap); + m_hBitmap = hBitmap; +} + + +//************************************************************************ +// +// CLCDBitmap::SetBitmap +// +//************************************************************************ + +void CLCDBitmap::SetROP(DWORD dwROP) +{ + m_dwROP = dwROP; +} + + +//************************************************************************ +// +// CLCDBitmap::OnDraw +// +//************************************************************************ + +void CLCDBitmap::OnDraw(CLCDGfx &rGfx) +{ + if(m_hBitmap) + { + HDC hCompatibleDC = CreateCompatibleDC(rGfx.GetHDC()); + HBITMAP hOldBitmap = (HBITMAP)SelectObject(hCompatibleDC, m_hBitmap); + + BitBlt(rGfx.GetHDC(), 0, 0, m_Size.cx, m_Size.cy, hCompatibleDC, m_ptLogical.x, m_ptLogical.y, m_dwROP); + + // restores + SelectObject(hCompatibleDC, hOldBitmap); + DeleteDC(hCompatibleDC); + } +} + + +//** end of LCDBitmap.cpp ************************************************ diff --git a/src/ui/LCDUI/LCDBitmap.h b/src/ui/LCDUI/LCDBitmap.h new file mode 100644 index 000000000..1ac1a6103 --- /dev/null +++ b/src/ui/LCDUI/LCDBitmap.h @@ -0,0 +1,37 @@ +//************************************************************************ +// +// LCDBitmap.h +// +// The CLCDBitmap class draws bitmaps onto the LCD. +// +// Logitech LCD SDK +// +// Copyright 2005 Logitech Inc. +//************************************************************************ + +#ifndef _LCDBITMAP_H_INCLUDED_ +#define _LCDBITMAP_H_INCLUDED_ + +#include "LCDBase.h" + +class CLCDBitmap : public CLCDBase +{ +public: + CLCDBitmap(); + virtual ~CLCDBitmap(); + + void SetBitmap(HBITMAP hBitmap); + void SetROP(DWORD dwROP); + +protected: + virtual void OnDraw(CLCDGfx &rGfx); + HBITMAP m_hBitmap; + DWORD m_dwROP; + +private: +}; + + +#endif // !_LCDBITMAP_H_INCLUDED_ + +//** end of LCDBitmap.h ************************************************** diff --git a/src/ui/LCDUI/LCDCollection.cpp b/src/ui/LCDUI/LCDCollection.cpp new file mode 100644 index 000000000..edba28599 --- /dev/null +++ b/src/ui/LCDUI/LCDCollection.cpp @@ -0,0 +1,196 @@ +//************************************************************************ +// +// LCDCollection.cpp +// +// The CLCDCollection class is a generic collection of CLCDBase objects. +// +// Logitech LCD SDK +// +// Copyright 2005 Logitech Inc. +//************************************************************************ + +#include "LCDCollection.h" + + +//************************************************************************ +// +// CLCDCollection::CLCDCollection +// +//************************************************************************ + +CLCDCollection::CLCDCollection(void) +{ +} + + +//************************************************************************ +// +// CLCDCollection::~CLCDCollection +// +//************************************************************************ + +CLCDCollection::~CLCDCollection(void) +{ +} + + +//************************************************************************ +// +// CLCDCollection::AddObject +// +//************************************************************************ + +BOOL CLCDCollection::AddObject(CLCDBase* pObject) +{ + //TODO: handle addition of same object twice... + m_Objects.push_back(pObject); + return TRUE; +} + + +//************************************************************************ +// +// CLCDCollection::RemoveObject +// +//************************************************************************ + +BOOL CLCDCollection::RemoveObject(CLCDBase* pObject) +{ + LCD_OBJECT_LIST::iterator it = m_Objects.begin(); + while(it != m_Objects.end()) + { + if (*it == pObject) + { + m_Objects.erase(it); + break; + } + ++it; + } + return FALSE; +} + + +//************************************************************************ +// +// CLCDCollection::OnDraw +// +//************************************************************************ + +void CLCDCollection::OnDraw(CLCDGfx &rGfx) +{ + LCD_OBJECT_LIST::iterator it = m_Objects.begin(); + while(it != m_Objects.end()) + { + CLCDBase *pObject = *it; + LCDUIASSERT(NULL != pObject); + + if (!pObject->IsVisible()) + { + ++it; + continue; + } + + // 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); + + ++it; + } +} + + +//************************************************************************ +// +// CLCDCollection::OnUpdate +// +//************************************************************************ + +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; + } +} + + +//************************************************************************ +// +// CLCDCollection::ResetUpdate +// +//************************************************************************ + +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; + } +} + + +//************************************************************************ +// +// CLCDCollection::Show +// +//************************************************************************ + +void CLCDCollection::Show(BOOL bShow) +{ + LCD_OBJECT_LIST::iterator it = m_Objects.begin(); + while(it != m_Objects.end()) + { + CLCDBase *pObject = *it; + LCDUIASSERT(NULL != pObject); + pObject->Show(bShow); + ++it; + } + + CLCDBase::Show(bShow); +} + + +//** end of LCDCollection.cpp ******************************************** diff --git a/src/ui/LCDUI/LCDCollection.h b/src/ui/LCDUI/LCDCollection.h new file mode 100644 index 000000000..0f4547222 --- /dev/null +++ b/src/ui/LCDUI/LCDCollection.h @@ -0,0 +1,48 @@ +//************************************************************************ +// +// LCDCollection.h +// +// The CLCDCollection class is a generic collection of CLCDBase objects. +// +// Logitech LCD SDK +// +// Copyright 2005 Logitech Inc. +//************************************************************************ + +#ifndef _LCDCOLLECTION_H_INCLUDED_ +#define _LCDCOLLECTION_H_INCLUDED_ + +#include "LCDBase.h" + + +#include +using namespace std; +typedef list LCD_OBJECT_LIST; +typedef LCD_OBJECT_LIST::iterator LCD_OBJECT_LIST_ITER; + + +class CLCDCollection : public CLCDBase +{ +public: + CLCDCollection(); + virtual ~CLCDCollection(); + + // collection objects use relative origin + BOOL AddObject(CLCDBase* pObject); + BOOL RemoveObject(CLCDBase* pObject); + + virtual void ResetUpdate(void); + virtual void Show(BOOL bShow); + +public: + virtual void OnDraw(CLCDGfx &rGfx); + virtual void OnUpdate(DWORD dwTimestamp); + +protected: + LCD_OBJECT_LIST m_Objects; +}; + + +#endif // !_LCDCOLLECTION_H_INCLUDED_ + +//** end of LCDCollection.h ********************************************** diff --git a/src/ui/LCDUI/LCDGfx.cpp b/src/ui/LCDUI/LCDGfx.cpp new file mode 100644 index 000000000..480a27793 --- /dev/null +++ b/src/ui/LCDUI/LCDGfx.cpp @@ -0,0 +1,342 @@ +//************************************************************************ +// +// LCDGfx.cpp +// +// The CLCDGfx class abstracts GDI/bitmap details. It is used in the +// OnDraw event. +// +// Logitech LCD SDK +// +// Copyright 2005 Logitech Inc. +//************************************************************************ + +#include "LCDGfx.h" + + +//************************************************************************ +// +// CLCDGfx::CLCDGfx +// +//************************************************************************ + +CLCDGfx::CLCDGfx(void) +: m_nWidth(0), + m_nHeight(0), + m_pLCDScreen(NULL), + m_pBitmapInfo(NULL), + m_hDC(NULL), + m_hBitmap(NULL), + m_hPrevBitmap(NULL), + m_pBitmapBits(NULL) +{ +} + + +//************************************************************************ +// +// CLCDGfx::~CLCDGfx +// +//************************************************************************ + +CLCDGfx::~CLCDGfx(void) +{ + Shutdown(); +} + + +//************************************************************************ +// +// CLCDGfx::Initialize +// +//************************************************************************ + +HRESULT CLCDGfx::Initialize(int nWidth, int nHeight) +{ + m_nWidth = nWidth; + m_nHeight = nHeight; + + m_hDC = CreateCompatibleDC(NULL); + if(NULL == m_hDC) + { + LCDUITRACE(_T("CLCDGfx::Initialize(): failed to create compatible DC.\n")); + Shutdown(); + return E_FAIL; + } + + int nBMISize = sizeof(BITMAPINFO) + 256 * sizeof(RGBQUAD); + m_pBitmapInfo = (BITMAPINFO *) new BYTE [nBMISize]; + if(NULL == m_pBitmapInfo) + { + LCDUITRACE(_T("CLCDGfx::Initialize(): failed to allocate bitmap info.\n")); + Shutdown(); + return E_OUTOFMEMORY; + } + + ZeroMemory(m_pBitmapInfo, nBMISize); + m_pBitmapInfo->bmiHeader.biSize = sizeof(m_pBitmapInfo->bmiHeader); + m_pBitmapInfo->bmiHeader.biWidth = m_nWidth; + m_pBitmapInfo->bmiHeader.biHeight = -m_nHeight; + m_pBitmapInfo->bmiHeader.biPlanes = 1; + m_pBitmapInfo->bmiHeader.biBitCount = 8; + m_pBitmapInfo->bmiHeader.biCompression = BI_RGB; + m_pBitmapInfo->bmiHeader.biSizeImage = + (m_nWidth * + m_nHeight * + m_pBitmapInfo->bmiHeader.biBitCount) / 8; + m_pBitmapInfo->bmiHeader.biXPelsPerMeter = 3200; + m_pBitmapInfo->bmiHeader.biYPelsPerMeter = 3200; + m_pBitmapInfo->bmiHeader.biClrUsed = 256; + m_pBitmapInfo->bmiHeader.biClrImportant = 256; + + for(int nColor = 0; nColor < 256; ++nColor) + { + m_pBitmapInfo->bmiColors[nColor].rgbRed = (BYTE)((nColor > 128) ? 255 : 0); + m_pBitmapInfo->bmiColors[nColor].rgbGreen = (BYTE)((nColor > 128) ? 255 : 0); + m_pBitmapInfo->bmiColors[nColor].rgbBlue = (BYTE)((nColor > 128) ? 255 : 0); + m_pBitmapInfo->bmiColors[nColor].rgbReserved = 0; + } + + m_hBitmap = CreateDIBSection(m_hDC, m_pBitmapInfo, DIB_RGB_COLORS, (PVOID *) &m_pBitmapBits, NULL, 0); + if(NULL == m_hBitmap) + { + LCDUITRACE(_T("CLCDGfx::Initialize(): failed to create bitmap.\n")); + Shutdown(); + return E_FAIL; + } + + m_pLCDScreen = new lgLcdBitmap160x43x1; + if(NULL == m_pLCDScreen) + { + LCDUITRACE(_T("CLCDGfx::Initialize(): failed to allocate the lcd screen structure.\n")); + Shutdown(); + return E_OUTOFMEMORY; + } + + return S_OK; +} + + +//************************************************************************ +// +// CLCDGfx::Shutdown +// +//************************************************************************ + +void CLCDGfx::Shutdown(void) +{ + if(NULL != m_pLCDScreen) + { + delete m_pLCDScreen; + m_pLCDScreen = NULL; + } + + 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; +} + + +//************************************************************************ +// +// CLCDGfx::BeginDraw +// +//************************************************************************ + +void CLCDGfx::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)); + } +} + + +//************************************************************************ +// +// CLCDGfx::ClearScreen +// +//************************************************************************ + +void CLCDGfx::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)); +} + + +//************************************************************************ +// +// CLCDGfx::SetPixel +// +//************************************************************************ + +void CLCDGfx::SetPixel(int nX, int nY, BYTE bValue) +{ + // this means, we're inside BeginDraw()/EndDraw() + LCDUIASSERT(NULL != m_hPrevBitmap); + ::SetPixel(m_hDC, nX, nY, bValue ? RGB(255, 255, 255) : RGB(0, 0, 0)); +} + + +//************************************************************************ +// +// CLCDGfx::DrawLine +// +//************************************************************************ + +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); +} + + +//************************************************************************ +// +// CLCDGfx::DrawFilledRect +// +//************************************************************************ + +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); +} + + +//************************************************************************ +// +// CLCDGfx::DrawText +// +//************************************************************************ + +void CLCDGfx::DrawText(int nX, int nY, LPCTSTR sText) +{ + // map mode text, with transparency + int nOldMapMode = SetMapMode(m_hDC, MM_TEXT); + int nOldBkMode = SetBkMode(m_hDC, TRANSPARENT); + + ::TextOut(m_hDC, nX, nY, sText, (int)_tcslen(sText)); + + // restores + SetMapMode(m_hDC, nOldMapMode); + SetBkMode(m_hDC, nOldBkMode); + +} + + +//************************************************************************ +// +// CLCDGfx::EndDraw +// +//************************************************************************ + +void CLCDGfx::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; + } +} + + +//************************************************************************ +// +// CLCDGfx::GetHDC +// +//************************************************************************ + +HDC CLCDGfx::GetHDC(void) +{ + LCDUIASSERT(NULL != m_hDC); + return m_hDC; +} + + +//************************************************************************ +// +// CLCDGfx::GetLCDScreen +// +//************************************************************************ + +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; +} + + +//************************************************************************ +// +// CLCDGfx::GetBitmapInfo +// +//************************************************************************ + +BITMAPINFO *CLCDGfx::GetBitmapInfo(void) +{ + LCDUIASSERT(NULL != m_pBitmapInfo); + return m_pBitmapInfo; +} + + +//************************************************************************ +// +// CLCDGfx::GetHBITMAP +// +//************************************************************************ + +HBITMAP CLCDGfx::GetHBITMAP(void) +{ + LCDUIASSERT(NULL != m_hBitmap); + return m_hBitmap; +} + + +//** end of LCDGfx.cpp *************************************************** diff --git a/src/ui/LCDUI/LCDGfx.h b/src/ui/LCDUI/LCDGfx.h new file mode 100644 index 000000000..09bde311b --- /dev/null +++ b/src/ui/LCDUI/LCDGfx.h @@ -0,0 +1,77 @@ +//************************************************************************ +// +// LCDGfx.h +// +// The CLCDGfx class abstracts GDI/bitmap details. It is used in the +// OnDraw event. +// +// Logitech LCD SDK +// +// Copyright 2005 Logitech Inc. +//************************************************************************ + +#ifndef _LCDGFX_H_INCLUDED_ +#define _LCDGFX_H_INCLUDED_ + +#include +#include +#include + + +#ifndef LCDUITRACE + // .NET compiler uses __noop intrinsic + #if _MSC_VER > 1300 + #define LCDUITRACE __noop + #else + #define LCDUITRACE (void)0 + #endif +#endif + +#ifndef LCDUIASSERT + // .NET compiler uses __noop intrinsic + #if _MSC_VER > 1300 + #define LCDUIASSERT __noop + #else + #define LCDUIASSERT (void)0 + #endif +#endif + + + +class CLCDGfx +{ +public: + CLCDGfx(void); + virtual ~CLCDGfx(void); + + HRESULT Initialize(int nWidth, int nHeight); + void Shutdown(void); + + void BeginDraw(void); + void ClearScreen(void); + void SetPixel(int nX, int nY, BYTE bValue); + void DrawLine(int nX1, int nY1, int nX2, int nY2); + void DrawFilledRect(int nX, int nY, int nWidth, int nHeight); + void DrawText(int nX, int nY, LPCTSTR sText); + void EndDraw(void); + + HDC GetHDC(void); + lgLcdBitmap160x43x1 *GetLCDScreen(void); + BITMAPINFO *GetBitmapInfo(void); + HBITMAP GetHBITMAP(void); + +protected: + int m_nWidth; + int m_nHeight; + lgLcdBitmap160x43x1 *m_pLCDScreen; + BITMAPINFO *m_pBitmapInfo; + HDC m_hDC; + HBITMAP m_hBitmap; + HBITMAP m_hPrevBitmap; + PBYTE m_pBitmapBits; +}; + + +#endif // !_LCDGFX_H_INCLUDED_ + +//** end of LCDGfx.h ***************************************************** diff --git a/src/ui/LCDUI/LCDManager.cpp b/src/ui/LCDUI/LCDManager.cpp new file mode 100644 index 000000000..3d83b9165 --- /dev/null +++ b/src/ui/LCDUI/LCDManager.cpp @@ -0,0 +1,204 @@ +//************************************************************************ +// +// LCDManager.cpp +// +// The CLCDManager class is the representation of a "Screen". LCD UI class +// objects are added here. +// +// Logitech LCD SDK +// +// Copyright 2005 Logitech Inc. +//************************************************************************ + +#include "LCDManager.h" + + +//************************************************************************ +// +// CLCDManager::CLCDManager +// +//************************************************************************ + +CLCDManager::CLCDManager(void) +{ + m_dwElapsedTime = 0; + m_dwExpirationTime = 0; + m_dwStartTime = 0; +} + + +//************************************************************************ +// +// CLCDManager::~CLCDManager +// +//************************************************************************ + +CLCDManager::~CLCDManager(void) +{ + Shutdown(); +} + + +//************************************************************************ +// +// CLCDManager::Initialize +// +//************************************************************************ + +HRESULT CLCDManager::Initialize(void) +{ + HRESULT hRes = CLCDCollection::Initialize(); + if(FAILED(hRes)) + { + LCDUITRACE(_T("CLCDManager::Initialize(): failed to initialize base class.\n")); + Shutdown(); + return hRes; + } + + SetOrigin(0, 0); + SetSize(LGLCD_BMP_WIDTH, LGLCD_BMP_HEIGHT); + + hRes = m_Gfx.Initialize(GetWidth(), GetHeight()); + if(FAILED(hRes)) + { + LCDUITRACE(_T("CLCDManager::Initialize(): failed to initialize graphics component.\n")); + Shutdown(); + return hRes; + } + + return S_OK; +} + + +//************************************************************************ +// +// CLCDManager::Shutdown +// +//************************************************************************ + +void CLCDManager::Shutdown(void) +{ + m_Gfx.Shutdown(); +} + + +//************************************************************************ +// +// CLCDManager::GetLCDScreen +// +//************************************************************************ + +lgLcdBitmap160x43x1 *CLCDManager::GetLCDScreen(void) +{ + return m_Gfx.GetLCDScreen(); +} + + +//************************************************************************ +// +// CLCDManager::GetBitmapInfo +// +//************************************************************************ + +BITMAPINFO *CLCDManager::GetBitmapInfo(void) +{ + return m_Gfx.GetBitmapInfo(); +} + + +//************************************************************************ +// +// CLCDManager::Draw +// +//************************************************************************ + +HRESULT CLCDManager::Draw(void) +{ + LCDUIASSERT(NULL != m_Gfx.GetHDC()); + LCDUIASSERT(NULL != m_Gfx.GetHBITMAP()); + if((NULL == m_Gfx.GetHDC()) || (NULL == m_Gfx.GetHBITMAP())) + { + LCDUITRACE(_T("CLCDManager::Draw(): trying to draw without successful Initialize() first.!\n")); + return E_FAIL; + } + + // select our bitmap into the Gfx DC + m_Gfx.BeginDraw(); + + m_Gfx.ClearScreen(); + + // invoke LCD UI Elements + OnDraw(m_Gfx); + + // select it back out of it + m_Gfx.EndDraw(); + + return S_OK; +} + + +//************************************************************************ +// +// CLCDManager::Update +// +//************************************************************************ + +void CLCDManager::Update(DWORD dwTimestamp) +{ + LCDUIASSERT(m_dwStartTime != 0); + m_dwElapsedTime = (dwTimestamp - m_dwStartTime); + CLCDCollection::OnUpdate(dwTimestamp); +} + + +//************************************************************************ +// +// CLCDManager::SetExpiration +// +//************************************************************************ + +void CLCDManager::SetExpiration(DWORD dwMilliseconds) +{ + m_dwStartTime = GetTickCount(); + m_dwElapsedTime = 0; + m_dwExpirationTime = dwMilliseconds; +} + + +//************************************************************************ +// +// CLCDManager::HasExpired +// +//************************************************************************ + +BOOL CLCDManager::HasExpired(void) +{ + return (!m_dwStartTime || (m_dwElapsedTime > m_dwExpirationTime)); +} + + +//************************************************************************ +// +// CLCDManager::OnLCDButtonDown +// +//************************************************************************ + +void CLCDManager::OnLCDButtonDown(int nButton) +{ + UNREFERENCED_PARAMETER(nButton); +} + + +//************************************************************************ +// +// CLCDManager::OnLCDButtonUp +// +//************************************************************************ + +void CLCDManager::OnLCDButtonUp(int nButton) +{ + UNREFERENCED_PARAMETER(nButton); +} + + +//** end of LCDManager.cpp *********************************************** diff --git a/src/ui/LCDUI/LCDManager.h b/src/ui/LCDUI/LCDManager.h new file mode 100644 index 000000000..c564b74da --- /dev/null +++ b/src/ui/LCDUI/LCDManager.h @@ -0,0 +1,49 @@ +//************************************************************************ +// +// LCDManager.h +// +// The CLCDManager class is the representation of a "Screen". LCD UI class +// objects are added here. +// +// Logitech LCD SDK +// +// Copyright 2005 Logitech Inc. +//************************************************************************ + +#ifndef _LCDMANAGER_H_INCLUDED_ +#define _LCDMANAGER_H_INCLUDED_ + +#include "LCDCollection.h" + + +class CLCDManager : public CLCDCollection +{ +public: + CLCDManager(); + virtual ~CLCDManager(); + + virtual HRESULT Initialize(void); + virtual void Shutdown(void); + + lgLcdBitmap160x43x1 *GetLCDScreen(void); + BITMAPINFO *GetBitmapInfo(void); + + virtual HRESULT Draw(void); + virtual void Update(DWORD dwTimestamp); + + virtual void OnLCDButtonDown(int nButton); + virtual void OnLCDButtonUp(int nButton); + + void SetExpiration(DWORD dwMilliseconds); + virtual BOOL HasExpired(void); + +private: + CLCDGfx m_Gfx; + + DWORD m_dwStartTime, m_dwElapsedTime, m_dwExpirationTime; +}; + + +#endif // !_LCDMANAGER_H_INCLUDED_ + +//** end of LCDManager.h ************************************************* diff --git a/src/ui/LCDUI/LCDOutput.cpp b/src/ui/LCDUI/LCDOutput.cpp new file mode 100644 index 000000000..e63cf1264 --- /dev/null +++ b/src/ui/LCDUI/LCDOutput.cpp @@ -0,0 +1,822 @@ +//************************************************************************ +// +// LCDOutput.cpp +// +// The CLCDOutput class manages LCD hardware enumeration and screen +// management. +// +// Logitech LCD SDK +// +// Copyright 2005 Logitech Inc. +//************************************************************************ + +#include "LCDOutput.h" + +#pragma comment(lib, "lgLcd.lib") + +// to keep track of clients that use multiple CLCDOutput instances +// within the same app +static LONG lInitCount = 0; + +//************************************************************************ +// +// CLCDOutput::CLCDOutput +// +//************************************************************************ + +CLCDOutput::CLCDOutput() +{ + m_pActiveScreen = NULL; + m_bLocked = FALSE; + m_hDevice = LGLCD_INVALID_DEVICE; + m_hConnection = LGLCD_INVALID_CONNECTION; + m_nPriority = LGLCD_PRIORITY_NORMAL; + ZeroMemory(&m_lcdConnectCtxEx, sizeof(m_lcdConnectCtxEx)); + m_bDisplayLocked = FALSE; + m_bSetAsForeground = FALSE; + + // Setup default device families + m_dwDeviceFamiliesSupported = LGLCD_DEVICE_FAMILY_KEYBOARD_G15 | + LGLCD_DEVICE_FAMILY_JACKBOX | + LGLCD_DEVICE_FAMILY_SPEAKERS_Z10; + m_dwDeviceFamiliesSupportedReserved1 = 0; +} + +//************************************************************************ +// +// CLCDOutput::~CLCDOutput +// +//************************************************************************ + +CLCDOutput::~CLCDOutput() +{ + +} + + +//************************************************************************ +// +// CLCDOutput::Initialize +// +//************************************************************************ + +HRESULT CLCDOutput::Initialize() +{ + return Initialize((lgLcdConnectContext *)NULL, FALSE); +} + + +//************************************************************************ +// +// CLCDOutput::Initialize +// +// NOTE: Initialize should always return S_OK +//************************************************************************ + +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; +} + +//************************************************************************ +// +// CLCDOutput::Initialize +// +// NOTE: Initialize should always return S_OK +//************************************************************************ + +HRESULT CLCDOutput::Initialize(lgLcdConnectContextEx* pContextEx, 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; + + // if user passed in the context, fill it up + if (NULL != pContextEx) + { + memcpy(&m_lcdConnectCtxEx, pContextEx, sizeof(lgLcdConnectContextEx)); + } + + return S_OK; +} + +//************************************************************************ +// +// CLCDOutput::Shutdown +// +//************************************************************************ + +void CLCDOutput::Shutdown(void) +{ + CloseAndDisconnect(); + if(0 == InterlockedDecrement(&lInitCount)) + { + lgLcdDeInit(); + } + LCDUIASSERT(lInitCount >= 0); +} + + +//************************************************************************ +// +// CLCDOutput::Draw +// +//************************************************************************ + +HRESULT CLCDOutput::Draw() +{ + DWORD dwPriorityToUse; + + if (m_pActiveScreen) + { + m_pActiveScreen->Draw(); + dwPriorityToUse = LGLCD_ASYNC_UPDATE(m_nPriority); + } + else + { + dwPriorityToUse = LGLCD_ASYNC_UPDATE(LGLCD_PRIORITY_IDLE_NO_SHOW); + } + + lgLcdBitmap160x43x1* pScreen = GetLCDScreen(); + if (pScreen && (LGLCD_INVALID_DEVICE != m_hDevice) && (LGLCD_PRIORITY_IDLE_NO_SHOW != dwPriorityToUse)) + { + DWORD res = ERROR_SUCCESS; + res = lgLcdUpdateBitmap(m_hDevice, &pScreen->hdr, dwPriorityToUse); + + HandleErrorFromAPI(res); + + // read the soft buttons + ReadButtons(); + } + + return S_OK; +} + + +//************************************************************************ +// +// CLCDOutput::Update +// +//************************************************************************ + +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); + + // 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(); + } +} + + +//************************************************************************ +// +// CLCDOutput::HasHardwareChanged +// +//************************************************************************ + +BOOL CLCDOutput::HasHardwareChanged(void) +{ + if(LGLCD_INVALID_DEVICE != m_hDevice) + { + // ping to see whether we're still alive + DWORD dwButtonState = 0; + + DWORD res = lgLcdReadSoftButtons(m_hDevice, &dwButtonState); + + HandleErrorFromAPI(res); + } + + // check for lcd devices + if (LGLCD_INVALID_DEVICE == m_hDevice) + { + EnumerateDevices(); + } + else + { + // we still have our device; + return FALSE; + } + + // we got a new device + return LGLCD_INVALID_DEVICE != m_hDevice; +} + + +//************************************************************************ +// +// CLCDOutput::GetLCDScreen +// +//************************************************************************ + +lgLcdBitmap160x43x1 *CLCDOutput::GetLCDScreen(void) +{ + return m_pActiveScreen ? m_pActiveScreen->GetLCDScreen() : CLCDManager::GetLCDScreen(); +} + + +//************************************************************************ +// +// CLCDOutput::GetBitmapInfo +// +//************************************************************************ + +BITMAPINFO *CLCDOutput::GetBitmapInfo(void) +{ + return m_pActiveScreen ? m_pActiveScreen->GetBitmapInfo() : CLCDManager::GetBitmapInfo(); +} + + +//************************************************************************ +// +// CLCDOutput::ReadButtons +// +//************************************************************************ + +void CLCDOutput::ReadButtons() +{ + if(IsOpened()) + { + DWORD dwButtonState = 0; + + DWORD res = lgLcdReadSoftButtons(m_hDevice, &dwButtonState); + if (ERROR_SUCCESS != res) + { + LCDUITRACE(_T("lgLcdReadSoftButtons failed: unplug?\n")); + HandleErrorFromAPI(res); + } + + if (m_dwButtonState == dwButtonState) + return; + + // handle the buttons + HandleButtonState(dwButtonState, LGLCDBUTTON_BUTTON0); + HandleButtonState(dwButtonState, LGLCDBUTTON_BUTTON1); + HandleButtonState(dwButtonState, LGLCDBUTTON_BUTTON2); + HandleButtonState(dwButtonState, LGLCDBUTTON_BUTTON3); + + m_dwButtonState = dwButtonState; + } +} + + +//************************************************************************ +// +// CLCDOutput::HandleButtonState +// +//************************************************************************ + +void CLCDOutput::HandleButtonState(DWORD dwButtonState, DWORD dwButton) +{ + if ( (m_dwButtonState & dwButton) && !(dwButtonState & dwButton) ) + { + LCDUITRACE(_T("Button 0x%x released\n"), dwButton); + OnLCDButtonUp(dwButton); + } + if ( !(m_dwButtonState & dwButton) && (dwButtonState & dwButton) ) + { + LCDUITRACE(_T("Button 0x%x pressed\n"), dwButton); + OnLCDButtonDown(dwButton); + } +} + + +//************************************************************************ +// +// CLCDOutput::OnLCDButtonDown +// +//************************************************************************ + +void CLCDOutput::OnLCDButtonDown(int nButton) +{ + if (m_pActiveScreen) + { + m_pActiveScreen->OnLCDButtonDown(nButton); + } +} + + +//************************************************************************ +// +// CLCDOutput::OnLCDButtonUp +// +//************************************************************************ + +void CLCDOutput::OnLCDButtonUp(int nButton) +{ + if (m_pActiveScreen) + { + m_pActiveScreen->OnLCDButtonUp(nButton); + } +} + + +//************************************************************************ +// +// CLCDOutput::ActivateScreen +// +//************************************************************************ + +void CLCDOutput::ActivateScreen(CLCDManager* pScreen) +{ + if (m_bLocked) + return; + m_pActiveScreen = pScreen; +} + + +//************************************************************************ +// +// CLCDOutput::LockScreen +// +//************************************************************************ + +void CLCDOutput::LockScreen(CLCDManager* pScreen) +{ + if (m_bLocked) + return; + + m_pActiveScreen = pScreen; + m_bLocked = TRUE; +} + + +//************************************************************************ +// +// CLCDOutput::UnlockScreen +// +//************************************************************************ + +void CLCDOutput::UnlockScreen() +{ + m_bLocked = FALSE; + m_pActiveScreen = NULL; +} + + +//************************************************************************ +// +// CLCDOutput::IsLocked +// +//************************************************************************ + +BOOL CLCDOutput::IsLocked() +{ + return m_bLocked; +} + + +//************************************************************************ +// +// CLCDOutput::AddScreen +// +//************************************************************************ + +void CLCDOutput::AddScreen(CLCDManager* pScreen) +{ + m_LCDMgrList.push_back(pScreen); +} + + +//************************************************************************ +// +// CLCDOutput::AnyDeviceOfThisFamilyPresent +// +//************************************************************************ + +BOOL CLCDOutput::AnyDeviceOfThisFamilyPresent(DWORD dwDeviceFamilyWanted, DWORD dwReserved1) +{ + lgLcdDeviceDescEx descEx; + + if (LGLCD_INVALID_CONNECTION == m_hConnection) + { + if (ERROR_SUCCESS == lgLcdConnectEx(&m_lcdConnectCtxEx)) + { + // make sure we don't work with a stale device handle + m_hConnection = m_lcdConnectCtxEx.connection; + m_hDevice = LGLCD_INVALID_CONNECTION; + } + else + { + return FALSE; + } + } + + // Setup the device family to use next time + lgLcdSetDeviceFamiliesToUse(m_hConnection, dwDeviceFamilyWanted, dwReserved1); + + ZeroMemory(&descEx, sizeof(lgLcdDeviceDescEx)); + DWORD res = ERROR_SUCCESS; + + res = lgLcdEnumerateEx(m_hConnection, 0, &descEx); + + if (ERROR_SUCCESS != res) + { + if(ERROR_NO_MORE_ITEMS != res) + { + // something happened. Let's close this. + CloseAndDisconnect(); + return FALSE; + } + + // Go back to the previous device family we were using + lgLcdSetDeviceFamiliesToUse(m_hConnection, m_dwDeviceFamiliesSupported, + m_dwDeviceFamiliesSupportedReserved1); + + return FALSE; + } + + // Go back to what was being used + lgLcdSetDeviceFamiliesToUse(m_hConnection, m_dwDeviceFamiliesSupported, + m_dwDeviceFamiliesSupportedReserved1); + + return TRUE; +} + +//************************************************************************ +// +// CLCDOutput::SetDeviceFamiliesSupported +// +//************************************************************************ + +void CLCDOutput::SetDeviceFamiliesSupported(DWORD dwDeviceFamiliesSupported, DWORD dwReserved1) +{ + m_dwDeviceFamiliesSupported = dwDeviceFamiliesSupported; + m_dwDeviceFamiliesSupportedReserved1 = dwReserved1; + + if (LGLCD_INVALID_CONNECTION == m_hConnection) + { + if (ERROR_SUCCESS == lgLcdConnectEx(&m_lcdConnectCtxEx)) + { + // make sure we don't work with a stale device handle + m_hConnection = m_lcdConnectCtxEx.connection; + m_hDevice = LGLCD_INVALID_CONNECTION; + } + else + { + return; + } + } + + // close the lcd device before we open up another + if (LGLCD_INVALID_DEVICE != m_hDevice) + { + lgLcdClose(m_hDevice); + m_hDevice = LGLCD_INVALID_DEVICE; + + } + + // Setup the device family to use next time + lgLcdSetDeviceFamiliesToUse(m_hConnection, m_dwDeviceFamiliesSupported, m_dwDeviceFamiliesSupportedReserved1); +} + +//************************************************************************ +// +// CLCDOutput::EnumerateDevices +// +//************************************************************************ + +void CLCDOutput::EnumerateDevices() +{ + lgLcdDeviceDescEx descEx; + + if (LGLCD_INVALID_CONNECTION == m_hConnection) + { + if (ERROR_SUCCESS == lgLcdConnectEx(&m_lcdConnectCtxEx)) + { + // make sure we don't work with a stale device handle + m_hConnection = m_lcdConnectCtxEx.connection; + m_hDevice = LGLCD_INVALID_CONNECTION; + } + else + { + return; + } + } + + // close the lcd device before we open up another + if (LGLCD_INVALID_DEVICE != m_hDevice) + { + lgLcdClose(m_hDevice); + m_hDevice = LGLCD_INVALID_DEVICE; + + } + + // Setup the device family to use next time + lgLcdSetDeviceFamiliesToUse(m_hConnection, m_dwDeviceFamiliesSupported, m_dwDeviceFamiliesSupportedReserved1); + + ZeroMemory(&descEx, sizeof(lgLcdDeviceDescEx)); + DWORD res = ERROR_SUCCESS; + + res = lgLcdEnumerateEx(m_hConnection, 0, &descEx); + if (ERROR_SUCCESS != res) + { + if(ERROR_NO_MORE_ITEMS != res) + { + // something happened. Let's close this. + CloseAndDisconnect(); + } + return; + } +// ERROR_NO_MORE_ITEMS + lgLcdOpenContext open_ctx; + ZeroMemory(&open_ctx, sizeof(open_ctx)); + + open_ctx.connection = m_hConnection; + open_ctx.index = 0; + res = lgLcdOpen(&open_ctx); + if (ERROR_SUCCESS != res) + return; + m_hDevice = open_ctx.device; + m_dwButtonState = 0; + + // restores + SetAsForeground(m_bSetAsForeground); +} + + +//************************************************************************ +// +// CLCDOutput::HandleErrorFromAPI +// +//************************************************************************ +void CLCDOutput::HandleErrorFromAPI(DWORD dwRes) +{ + switch(dwRes) + { + // all is well + case ERROR_SUCCESS: + break; + // we lost our device + case ERROR_DEVICE_NOT_CONNECTED: + LCDUITRACE(_T("lgLcdAPI returned with ERROR_DEVICE_NOT_CONNECTED, closing device\n")); + OnClosingDevice(m_hDevice); + break; + default: + LCDUITRACE(_T("lgLcdAPI returned with other error (0x%08x) closing device and connection\n")); + OnClosingDevice(m_hDevice); + OnDisconnecting(m_hConnection); + // something else happened, such as LCDMon that was terminated + break; + } +} + +//************************************************************************ +// +// CLCDOutput::SetScreenPriority +// +//************************************************************************ +void CLCDOutput::SetScreenPriority(DWORD priority) +{ + m_nPriority = priority; + if (LGLCD_PRIORITY_IDLE_NO_SHOW == m_nPriority) + { + // send an empty bitmap at idle priority + if (LGLCD_INVALID_DEVICE != m_hDevice) + { + lgLcdUpdateBitmap(m_hDevice, &CLCDManager::GetLCDScreen()->hdr, + LGLCD_ASYNC_UPDATE(LGLCD_PRIORITY_IDLE_NO_SHOW)); + } + } +} + +//************************************************************************ +// +// CLCDOutput::GetScreenPriority +// +//************************************************************************ +DWORD CLCDOutput::GetScreenPriority() +{ + return m_nPriority; +} + +//************************************************************************ +// +// CLCDOutput::GetDeviceHandle +// +//************************************************************************ +INT CLCDOutput::GetDeviceHandle() +{ + return m_hDevice; +} + +//************************************************************************ +// +// CLCDOutput::CloseAndDisconnect +// +//************************************************************************ + +void CLCDOutput::CloseAndDisconnect() +{ + OnClosingDevice(m_hDevice); + OnDisconnecting(m_hConnection); +} + + +//************************************************************************ +// +// CLCDOutput::OnScreenExpired +// +//************************************************************************ + +void CLCDOutput::OnScreenExpired(CLCDManager* pScreen) +{ + UNREFERENCED_PARAMETER(pScreen); + UnlockScreen(); +} + + +//************************************************************************ +// +// CLCDOutput::OnClosingDevice +// +//************************************************************************ + +void CLCDOutput::OnClosingDevice(int hDevice) +{ + UNREFERENCED_PARAMETER(hDevice); + LCDUITRACE(_T("CLCDOutput::OnClosingDevice\n")); + if (IsOpened()) + { + lgLcdClose(m_hDevice); + m_hDevice = LGLCD_INVALID_DEVICE; + } +} + +//************************************************************************ +// +// CLCDOutput::OnDisconnecting +// +//************************************************************************ + +void CLCDOutput::OnDisconnecting(int hConnection) +{ + UNREFERENCED_PARAMETER(hConnection); + LCDUITRACE(_T("CLCDOutput::OnDisconnecting\n")); + // let's hope our device is already gone + LCDUIASSERT(!IsOpened()); + + if (LGLCD_INVALID_CONNECTION != m_hConnection) + { + lgLcdDisconnect(m_hConnection); + m_hConnection = LGLCD_INVALID_CONNECTION; + } +} + +//************************************************************************ +// +// CLCDOutput::IsOpened +// +//************************************************************************ + +BOOL CLCDOutput::IsOpened() +{ + return (LGLCD_INVALID_DEVICE != m_hDevice); +} + + +//************************************************************************ +// +// CLCDOutput::SetAsForeground +// +//************************************************************************ + +void CLCDOutput::SetAsForeground(BOOL bSetAsForeground) +{ + /*DWORD dwSet = */bSetAsForeground ? LGLCD_LCD_FOREGROUND_APP_YES : LGLCD_LCD_FOREGROUND_APP_NO; + m_bSetAsForeground = bSetAsForeground; + if (LGLCD_INVALID_DEVICE != m_hDevice) + { + lgLcdSetAsLCDForegroundApp(m_hDevice, bSetAsForeground); + } +} + +//** end of LCDOutput.cpp ************************************************ diff --git a/src/ui/LCDUI/LCDOutput.h b/src/ui/LCDUI/LCDOutput.h new file mode 100644 index 000000000..0b447157b --- /dev/null +++ b/src/ui/LCDUI/LCDOutput.h @@ -0,0 +1,101 @@ +//************************************************************************ +// +// LCDOutput.h +// +// The CLCDOutput class manages LCD hardware enumeration and screen +// management. +// +// Logitech LCD SDK +// +// Copyright 2005 Logitech Inc. +//************************************************************************ + +#ifndef _CLCDOUTPUT_H_INCLUDED_ +#define _CLCDOUTPUT_H_INCLUDED_ + +#include "LCDManager.h" +#include +#include "vector" + +using namespace std; + +typedef vector LCD_MGR_LIST; +typedef LCD_MGR_LIST::iterator LCD_MGR_LIST_ITER; + +class CLCDOutput : public CLCDManager +{ + +public: + CLCDOutput(); + virtual ~CLCDOutput(); + + void AddScreen(CLCDManager* pScreen); + + void LockScreen(CLCDManager* pScreen); + void UnlockScreen(); + BOOL IsLocked(); + + BOOL IsOpened(); + void SetAsForeground(BOOL bSetAsForeground); + BOOL AnyDeviceOfThisFamilyPresent(DWORD dwDeviceFamilyWanted, DWORD dwReserved1); + void SetDeviceFamiliesSupported(DWORD dwDeviceFamiliesSupported, DWORD dwReserved1); + + void SetScreenPriority(DWORD priority); + DWORD GetScreenPriority(); + + INT GetDeviceHandle(); + + HRESULT Initialize(lgLcdConnectContext* pContext, BOOL bUseWindow = FALSE); + HRESULT Initialize(lgLcdConnectContextEx* pContextEx, BOOL bUseWindow = FALSE); + + // returns TRUE if a new display was enumerated + BOOL HasHardwareChanged(void); + + // CLCDBase + virtual HRESULT Initialize(); + virtual HRESULT Draw(); + virtual void Update(DWORD dwTimestamp); + virtual void Shutdown(void); + + // CLCDManager + lgLcdBitmap160x43x1 *GetLCDScreen(void); + BITMAPINFO *GetBitmapInfo(void); + +protected: + void ActivateScreen(CLCDManager* pScreen); + void ReadButtons(); + void HandleButtonState(DWORD dwButtonState, DWORD dwButton); + void HandleErrorFromAPI(DWORD dwRes); + void CloseAndDisconnect(); + + virtual void OnLCDButtonDown(int nButton); + virtual void OnLCDButtonUp(int nButton); + +protected: + virtual void OnScreenExpired(CLCDManager* pScreen); + virtual void OnClosingDevice(int hDevice); + virtual void OnDisconnecting(int hConnection); + +protected: + CLCDManager* m_pActiveScreen; + + // list + LCD_MGR_LIST m_LCDMgrList; + + void EnumerateDevices(); + int m_hConnection; + int m_hDevice; + DWORD m_nPriority; + BOOL m_bLocked, m_bDisplayLocked; + DWORD m_dwButtonState; + BOOL m_bSetAsForeground; + +// lgLcdConnectContext m_lcdConnectCtx; + lgLcdConnectContextEx m_lcdConnectCtxEx; + DWORD m_dwDeviceFamiliesSupported; + DWORD m_dwDeviceFamiliesSupportedReserved1; +}; + +#endif // !_CLCDOUTPUT_H_INCLUDED_ + +//** end of CLCDOutput.h ************************************************* diff --git a/src/ui/LCDUI/LCDProgressBar.cpp b/src/ui/LCDUI/LCDProgressBar.cpp new file mode 100644 index 000000000..978cb2558 --- /dev/null +++ b/src/ui/LCDUI/LCDProgressBar.cpp @@ -0,0 +1,270 @@ +//************************************************************************ +// +// LCDProgressBar.cpp +// +// The CLCDProgressBar class draws a progress bar onto the LCD. +// +// Logitech LCD SDK +// +// Copyright 2005 Logitech Inc. +//************************************************************************ + +#include "LCDProgressBar.h" + +//************************************************************************ +// +// CLCDProgressBar::CLCDProgressBar +// +//************************************************************************ + +CLCDProgressBar::CLCDProgressBar() +{ + m_Pos = 0; + m_eStyle = STYLE_CURSOR; + m_Range.nMin = 0; + m_Range.nMax = 100; + m_nCursorWidth = 5; + m_hPen = NULL; +} + + +//************************************************************************ +// +// CLCDProgressBar::~CLCDProgressBar +// +//************************************************************************ + +CLCDProgressBar::~CLCDProgressBar() +{ + if (m_hPen != NULL) + { + ::DeleteObject(m_hPen); + m_hPen = NULL; + } +} + + +//************************************************************************ +// +// CLCDProgressBar:Initialize +// +//************************************************************************ + +HRESULT CLCDProgressBar::Initialize() +{ + + m_hBrush = (HBRUSH)GetStockObject(WHITE_BRUSH); + m_hPen = ::CreatePen(PS_DOT, 1, RGB(255, 255, 255)); + + return CLCDBase::Initialize(); +} + + +//************************************************************************ +// +// CLCDProgressBar::OnDraw +// +//************************************************************************ + +void CLCDProgressBar::OnDraw(CLCDGfx &rGfx) +{ + HPEN hOldPen; + + rGfx.ClearScreen(); + + // draw the border + RECT r = { 0, 0, GetWidth(), GetHeight() }; + + FrameRect(rGfx.GetHDC(), &r, m_hBrush); + + // draw the progress + switch(m_eStyle) + { + case STYLE_CURSOR: + { + int nCursorPos = (int)Scalef((float)m_Range.nMin, (float)m_Range.nMax, + (float)1, (float)(GetWidth() - m_nCursorWidth-1), + m_Pos); + r.left = nCursorPos; + r.right = r.left + m_nCursorWidth; + FillRect(rGfx.GetHDC(), &r, m_hBrush); + } + break; + case STYLE_FILLED_V: + case STYLE_FILLED_H: + { + int nBar = (int)Scalef((float)m_Range.nMin, (float)m_Range.nMax, + 0.0f, (m_eStyle == STYLE_FILLED_H ? (float)GetWidth() : (float)GetHeight())-4, + m_Pos); + r.left = r.left+2; + r.bottom = r.bottom-2; + if (m_eStyle == STYLE_FILLED_H) + { + r.right = nBar+2; + r.top = r.top+2; + } + else + { + r.right = r.right-2; + r.top = r.bottom-nBar; + } + + FillRect(rGfx.GetHDC(), &r, m_hBrush); + } + break; + case STYLE_DASHED_CURSOR: + { + int nCursorPos = (int)Scalef((float)m_Range.nMin, (float)m_Range.nMax, + (float)1, (float)(GetWidth() - m_nCursorWidth-1), + m_Pos); + r.left = nCursorPos; + r.right = r.left + m_nCursorWidth; + FillRect(rGfx.GetHDC(), &r, m_hBrush); + hOldPen = (HPEN)::SelectObject(rGfx.GetHDC(), m_hPen); + + ::MoveToEx(rGfx.GetHDC(), 0, (r.bottom - r.top)/2, NULL); + ::LineTo(rGfx.GetHDC(), nCursorPos, (r.bottom - r.top)/2); + ::SelectObject(rGfx.GetHDC(), hOldPen); + } + break; + default: + break; + } +} + + +//************************************************************************ +// +// CLCDProgressBar::ResetUpdate +// +//************************************************************************ + +void CLCDProgressBar::ResetUpdate() +{ + +} + + +//************************************************************************ +// +// CLCDProgressBar::SetRange +// +//************************************************************************ + +void CLCDProgressBar::SetRange(__int64 nMin, __int64 nMax) +{ + m_Range.nMin = nMin; + m_Range.nMax = nMax; +} + + +//************************************************************************ +// +// CLCDProgressBar::SetRange +// +//************************************************************************ + +void CLCDProgressBar::SetRange(RANGE& Range) +{ + m_Range = Range; +} + + +//************************************************************************ +// +// CLCDProgressBar::GetRange +// +//************************************************************************ + +RANGE& CLCDProgressBar::GetRange() +{ + return m_Range; +} + + +//************************************************************************ +// +// CLCDProgressBar::SetPos +// +//************************************************************************ + +__int64 CLCDProgressBar::SetPos(__int64 Pos) +{ + return ( m_Pos = max(m_Range.nMin, min(Pos, m_Range.nMax)) ); +} + + +//************************************************************************ +// +// CLCDProgressBar::GetPos +// +//************************************************************************ + +__int64 CLCDProgressBar::GetPos() +{ + return m_Pos; +} + + +//************************************************************************ +// +// CLCDProgressBar::EnableCursor +// +//************************************************************************ + +void CLCDProgressBar::EnableCursor(BOOL bEnable) +{ + m_eStyle = bEnable ? STYLE_CURSOR : STYLE_FILLED_H; +} + +//************************************************************************ +// +// CLCDProgressBar::SetProgressStyle +// +//************************************************************************ + +void CLCDProgressBar::SetProgressStyle(ePROGRESS_STYLE eStyle) +{ + m_eStyle = eStyle; +} + +//************************************************************************ +// +// CLCDProgressBar::Scalef +// +//************************************************************************ + +float CLCDProgressBar::Scalef(float fFromMin, float fFromMax, + float fToMin, float fToMax, __int64 fFromValue) +{ + + // normalize the input + float fFromValueN = (fFromValue - fFromMin) / (fFromMax - fFromMin); + + // now scale to the output + float fToRange = fToMax - fToMin; + + return ( fToMin + (fFromValueN * fToRange) ); +} + + +//************************************************************************ +// +// CLCDProgressBar::Scale +// +//************************************************************************ + +int CLCDProgressBar::Scale(int nFromMin, int nFromMax, + int nToMin, int nToMax, __int64 nFromValue) +{ + return (int)Scalef( + (float)nFromMin, + (float)nFromMax, + (float)nToMin, + (float)nToMax, + nFromValue + ); +} + + +//** end of LCDProgressBar.cpp ******************************************* diff --git a/src/ui/LCDUI/LCDProgressBar.h b/src/ui/LCDUI/LCDProgressBar.h new file mode 100644 index 000000000..346bf6c2b --- /dev/null +++ b/src/ui/LCDUI/LCDProgressBar.h @@ -0,0 +1,66 @@ +//************************************************************************ +// +// LCDProgressBar.h +// +// The CLCDProgressBar class draws a progress bar onto the LCD. +// +// Logitech LCD SDK +// +// Copyright 2005 Logitech Inc. +//************************************************************************ + +#ifndef _LCDPROGRESSBAR_H_INCLUDED_ +#define _LCDPROGRESSBAR_H_INCLUDED_ + +#include "LCDBase.h" + +typedef struct RANGE +{ + __int64 nMin; + __int64 nMax; + +}RANGE, *LPRANGE; + +enum ePROGRESS_STYLE { STYLE_FILLED_H, STYLE_FILLED_V, STYLE_CURSOR, STYLE_DASHED_CURSOR }; + +class CLCDProgressBar : public CLCDBase +{ +public: + enum ePROGRESS_STYLE { STYLE_FILLED_H, STYLE_FILLED_V, STYLE_CURSOR, STYLE_DASHED_CURSOR }; + + CLCDProgressBar(); + virtual ~CLCDProgressBar(); + + // CLCDBase + virtual HRESULT Initialize(void); + virtual void OnDraw(CLCDGfx &rGfx); + virtual void ResetUpdate(void); + + // CLCDProgressBar + virtual void SetRange(__int64 nMin, __int64 nMax); + virtual void SetRange(RANGE& Range); + virtual RANGE& GetRange(void); + virtual __int64 SetPos(__int64 fPos); + virtual __int64 GetPos(void); + virtual void EnableCursor(BOOL bEnable); + virtual void SetProgressStyle(ePROGRESS_STYLE eStyle); + +protected: + float Scalef(float fFromMin, float fFromMax, + float fToMin, float fToMax, __int64 fFromValue); + int Scale(int nFromMin, int nFromMax, + int nToMin, int nToMax, __int64 nFromValue); + +private: + RANGE m_Range; + __int64 m_Pos; + ePROGRESS_STYLE m_eStyle; + HBRUSH m_hBrush; + HPEN m_hPen; + int m_nCursorWidth; +}; + + +#endif // !_LCDPROGRESSBAR_H_INCLUDED_ + +//** end of LCDProgressBar.h ********************************************* diff --git a/src/ui/LCDUI/LCDScrollingText.cpp b/src/ui/LCDUI/LCDScrollingText.cpp new file mode 100644 index 000000000..880fc505a --- /dev/null +++ b/src/ui/LCDUI/LCDScrollingText.cpp @@ -0,0 +1,294 @@ +//************************************************************************ +// +// LCDScrollingText.cpp +// +// The CLCDScrollingText class draws scrolling text onto the LCD. +// +// Logitech LCD SDK +// +// Copyright 2005 Logitech Inc. +//************************************************************************ + +#include "LCDScrollingText.h" + + +//************************************************************************ +// +// CLCDScrollingText::CLCDScrollingText +// +//************************************************************************ + +CLCDScrollingText::CLCDScrollingText() +{ + m_eState = STATE_START_DELAY; + m_eScrollDir = SCROLL_HORZ; + m_bRepeat = TRUE; +} + + +//************************************************************************ +// +// CLCDScrollingText::~CLCDScrollingText +// +//************************************************************************ + +CLCDScrollingText::~CLCDScrollingText() +{ + +} + + +//************************************************************************ +// +// CLCDScrollingText::Initialize +// +//************************************************************************ + +HRESULT CLCDScrollingText::Initialize(void) +{ + m_dwStartDelay = 1000; + m_dwSpeed = 20; + m_nScrollingDistance = -1; + m_dwLastUpdate = 0; + m_dwEllapsedTime = 0; + m_dwLastUpdate = GetTickCount(); + m_fTotalDistance = 0; + m_eScrollDir = SCROLL_HORZ; + m_dwEndDelay = 1000; + m_bRepeat = TRUE; + + return CLCDText::Initialize(); +} + + +//************************************************************************ +// +// CLCDScrollingText::ResetUpdate +// +//************************************************************************ + +void CLCDScrollingText::ResetUpdate(void) +{ + m_eState = STATE_START_DELAY; + m_dwEllapsedTime = 0; + m_dwLastUpdate = GetTickCount(); + m_nScrollingDistance = -1; + m_fTotalDistance = 0; + SetLeftMargin(0); + SetLogicalOrigin(0, 0); + + CLCDText::ResetUpdate(); +} + + +//************************************************************************ +// +// CLCDScrollingText::SetStartDelay +// +//************************************************************************ + +void CLCDScrollingText::SetStartDelay(DWORD dwMilliseconds) +{ + m_dwStartDelay = dwMilliseconds; +} + + +//************************************************************************ +// +// CLCDScrollingText::SetEndDelay +// +//************************************************************************ + +void CLCDScrollingText::SetEndDelay(DWORD dwMilliseconds) +{ + m_dwEndDelay = dwMilliseconds; +} + + +//************************************************************************ +// +// CLCDScrollingText::SetSpeed +// +//************************************************************************ + +void CLCDScrollingText::SetSpeed(DWORD dwSpeed) +{ + m_dwSpeed = dwSpeed; +} + + +//************************************************************************ +// +// CLCDScrollingText::SetScrollDirection +// +//************************************************************************ + +void CLCDScrollingText::SetScrollDirection(eSCROLL_DIR eScrollDir) +{ + m_eScrollDir = eScrollDir; + SetWordWrap(eScrollDir == SCROLL_VERT); + ResetUpdate(); +} + + +//************************************************************************ +// +// CLCDScrollingText::GetScrollDirection +// +//************************************************************************ + +CLCDScrollingText::eSCROLL_DIR CLCDScrollingText::GetScrollDirection() +{ + return m_eScrollDir; +} + + +//************************************************************************ +// +// CLCDScrollingText::SetText +// +//************************************************************************ + +void CLCDScrollingText::SetText(LPCTSTR szText) +{ + if (_tcscmp(szText, m_sText.c_str())) + { + ResetUpdate(); + } + + CLCDText::SetText(szText); +} + + +//************************************************************************ +// +// CLCDScrollingText::IsScrollingDone +// +//************************************************************************ + +BOOL CLCDScrollingText::IsScrollingDone() +{ + return (STATE_DONE == m_eState); +} + + +//************************************************************************ +// +// CLCDScrollingText::EnableRepeat +// +//************************************************************************ + +void CLCDScrollingText::EnableRepeat(BOOL bEnable) +{ + m_bRepeat = bEnable; +} + + +//************************************************************************ +// +// CLCDScrollingText::OnUpdate +// +//************************************************************************ + +void CLCDScrollingText::OnUpdate(DWORD dwTimestamp) +{ + m_dwEllapsedTime = (dwTimestamp - m_dwLastUpdate); +} + + +//************************************************************************ +// +// CLCDScrollingText::OnDraw +// +//************************************************************************ + +void CLCDScrollingText::OnDraw(CLCDGfx &rGfx) +{ + if (!m_nTextLength) + return; + + // calculate the scrolling distance + if (-1 == m_nScrollingDistance) + { + CLCDText::OnDraw(rGfx); + + if (SCROLL_VERT == m_eScrollDir) + { + // determine how far we have to travel until scrolling stops + m_nScrollingDistance = ((GetHeight()) >= GetVExtent().cy) ? + 0 : (GetVExtent().cy - GetHeight()); + SetLogicalSize(GetVExtent().cx, GetVExtent().cy); + } + else + { + // determine how far we have to travel until scrolling stops + m_nScrollingDistance = ((GetWidth()) >= GetHExtent().cx) ? + 0 : (GetHExtent().cx - GetWidth()); + SetLogicalSize(max(GetSize().cx, GetHExtent().cx), GetHExtent().cy); + } + } + + switch(m_eState) + { + case STATE_START_DELAY: + if (m_dwEllapsedTime > m_dwStartDelay) + { + m_eState = STATE_SCROLL; + m_dwEllapsedTime = 0; + m_dwLastUpdate = GetTickCount(); + } + break; + case STATE_END_DELAY: + if (m_dwEllapsedTime > m_dwEndDelay) + { + if (m_bRepeat) + { + ResetUpdate(); + break; + } + m_dwEllapsedTime = 0; + m_dwLastUpdate = GetTickCount(); + m_eState = STATE_DONE; + } + break; + case STATE_SCROLL: + { + // TODO: add some anti-aliasing on the movement + + // how much time has ellapsed? + // given the speed, what is the total displacement? + float fDistance = (float)(m_dwSpeed * m_dwEllapsedTime) / 1000.0f; + m_fTotalDistance += fDistance; + + // we dont want the total distnace exceed our scrolling distance + int nTotalOffset = min((int)m_fTotalDistance, m_nScrollingDistance); + + if (SCROLL_VERT == m_eScrollDir) + { + SetLogicalOrigin(GetLogicalOrigin().x, -1 * nTotalOffset); + } + else + { + SetLogicalOrigin(-1 * nTotalOffset, GetLogicalOrigin().y); + } + + m_dwLastUpdate = GetTickCount(); + + if (nTotalOffset == m_nScrollingDistance) + { + m_eState = STATE_END_DELAY; + } + } + break; + case STATE_DONE: + break; + + default: + break; + } + + CLCDText::OnDraw(rGfx); +} + + +//** end of LCDScrollingText.cpp ***************************************** diff --git a/src/ui/LCDUI/LCDScrollingText.h b/src/ui/LCDUI/LCDScrollingText.h new file mode 100644 index 000000000..8438c3952 --- /dev/null +++ b/src/ui/LCDUI/LCDScrollingText.h @@ -0,0 +1,65 @@ +//************************************************************************ +// +// LCDScrollingText.h +// +// The CLCDScrollingText class draws scrolling text onto the LCD. +// +// Logitech LCD SDK +// +// Copyright 2005 Logitech Inc. +//************************************************************************ + +#ifndef _LCDSCROLLINGTEXT_H_INCLUDED_ +#define _LCDSCROLLINGTEXT_H_INCLUDED_ + +#include "LCDBase.h" +#include "LCDText.h" + +class CLCDScrollingText : public CLCDText +{ +public: + CLCDScrollingText(); + virtual ~CLCDScrollingText(); + + // CLCDBase + virtual HRESULT Initialize(void); + virtual void ResetUpdate(void); + + // CLCDText + virtual void SetText(LPCTSTR szText); + + void SetStartDelay(DWORD dwMilliseconds); + void SetEndDelay(DWORD dwMilliseconds); + void EnableRepeat(BOOL bEnable); + void SetSpeed(DWORD dwSpeed); + + enum eSCROLL_DIR { SCROLL_HORZ, SCROLL_VERT}; + void SetScrollDirection(eSCROLL_DIR eScrollDir); + eSCROLL_DIR GetScrollDirection(); + BOOL IsScrollingDone(); + +protected: + virtual void OnUpdate(DWORD dwTimestamp); + virtual void OnDraw(CLCDGfx &rGfx); + +private: + enum eSCROLL_STATES { STATE_START_DELAY, STATE_SCROLL, STATE_END_DELAY, STATE_DONE}; + + DWORD m_dwEllapsedTime; // ellapsed time in state + DWORD m_dwStartDelay; // milliseconds + DWORD m_dwEndDelay; // milliseconds + DWORD m_dwSpeed; // pixels/second + DWORD m_dwLastUpdate; // milliseconds + BOOL m_bRepeat; // repeat + + int m_nScrollingDistance; + float m_fTotalDistance; + + eSCROLL_DIR m_eScrollDir; + eSCROLL_STATES m_eState; +}; + + +#endif // !_LCDSCROLLINGTEXT_H_INCLUDED_ + +//** end of LCDScrollingText.h ******************************************* diff --git a/src/ui/LCDUI/LCDText.cpp b/src/ui/LCDUI/LCDText.cpp new file mode 100644 index 000000000..e9441d77a --- /dev/null +++ b/src/ui/LCDUI/LCDText.cpp @@ -0,0 +1,396 @@ +//************************************************************************ +// +// LCDText.cpp +// +// The CLCDText class draws simple text onto the LCD. +// +// Logitech LCD SDK +// +// Copyright 2005 Logitech Inc. +//************************************************************************ + +#include "LCDText.h" + + +//************************************************************************ +// +// CLCDText::CLCDText +// +//************************************************************************ + +CLCDText::CLCDText() +{ + m_nTextLength = 0; + m_hFont = NULL; + m_sText.clear(); + m_crColor = RGB(255, 255, 255); // white + m_bRecalcExtent = TRUE; + ZeroMemory(&m_dtp, sizeof(DRAWTEXTPARAMS)); + m_dtp.cbSize = sizeof(DRAWTEXTPARAMS); + m_nTextFormat = m_nTextAlignment = (DT_LEFT | DT_NOPREFIX); + m_nTextAlignment = DT_LEFT; + ZeroMemory(&m_sizeVExtent, sizeof(m_sizeVExtent)); + ZeroMemory(&m_sizeHExtent, sizeof(m_sizeHExtent)); +} + + +//************************************************************************ +// +// CLCDText::~CLCDText +// +//************************************************************************ + +CLCDText::~CLCDText() +{ + + if (m_hFont) + { + DeleteObject(m_hFont); + m_hFont = NULL; + } +} + + +//************************************************************************ +// +// CLCDText::Initialize +// +//************************************************************************ + +HRESULT CLCDText::Initialize() +{ + + m_hFont = (HFONT) GetStockObject(DEFAULT_GUI_FONT); + if(NULL != m_hFont) + { + SetFontPointSize(DEFAULT_POINTSIZE); + } + + return (NULL != m_hFont) ? S_OK : E_OUTOFMEMORY; +} + + +//************************************************************************ +// +// CLCDText::SetFont +// +//************************************************************************ + +void CLCDText::SetFont(LOGFONT& lf) +{ + if (m_hFont) + { + DeleteObject(m_hFont); + m_hFont = NULL; + } + + m_hFont = CreateFontIndirect(&lf); + m_bRecalcExtent = TRUE; +} + + +//************************************************************************ +// +// CLCDText::GetFont +// +//************************************************************************ + +HFONT CLCDText::GetFont() +{ + return m_hFont; +} + + +//************************************************************************ +// +// CLCDText::SetFontFaceName +// +//************************************************************************ + +void CLCDText::SetFontFaceName(LPCTSTR szFontName) +{ + // if NULL, uses the default gui font + if (NULL == szFontName) + return; + + LOGFONT lf; + ZeroMemory(&lf, sizeof(lf)); + GetObject(m_hFont, sizeof(LOGFONT), &lf); + + _tcsncpy(lf.lfFaceName, szFontName, LF_FACESIZE); + + SetFont(lf); +} + + +//************************************************************************ +// +// CLCDText::SetFontPointSize +// +//************************************************************************ + +void CLCDText::SetFontPointSize(int nPointSize) +{ + LOGFONT lf; + ZeroMemory(&lf, sizeof(lf)); + GetObject(m_hFont, sizeof(LOGFONT), &lf); + + lf.lfHeight = -MulDiv(nPointSize, DEFAULT_DPI, 72); + + SetFont(lf); +} + + +//************************************************************************ +// +// CLCDText::SetFontWeight +// +//************************************************************************ + +void CLCDText::SetFontWeight(int nWeight) +{ + LOGFONT lf; + ZeroMemory(&lf, sizeof(lf)); + GetObject(m_hFont, sizeof(LOGFONT), &lf); + + lf.lfWeight = nWeight; + + SetFont(lf); +} + + +//************************************************************************ +// +// CLCDText::SetText +// +//************************************************************************ + +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; + } +} + + +//************************************************************************ +// +// CLCDText::GetText +// +//************************************************************************ + +LPCTSTR CLCDText::GetText() +{ + return m_sText.c_str(); +} + + +//************************************************************************ +// +// CLCDText::SetWordWrap +// +//************************************************************************ + +void CLCDText::SetWordWrap(BOOL bEnable) +{ + if (bEnable) + { + m_nTextFormat |= DT_WORDBREAK; + } + else + { + m_nTextFormat &= ~DT_WORDBREAK; + } + m_bRecalcExtent = TRUE; +} + + +//************************************************************************ +// +// CLCDText::SetLeftMargin +// +//************************************************************************ + +void CLCDText::SetLeftMargin(int nLeftMargin) +{ + m_dtp.iLeftMargin = nLeftMargin; +} + + +//************************************************************************ +// +// CLCDText::SetRightMargin +// +//************************************************************************ + +void CLCDText::SetRightMargin(int nRightMargin) +{ + m_dtp.iRightMargin = nRightMargin; +} + + +//************************************************************************ +// +// CLCDText::GetLeftMargin +// +//************************************************************************ + +int CLCDText::GetLeftMargin(void) +{ + return m_dtp.iLeftMargin; +} + + +//************************************************************************ +// +// CLCDText::GetRightMargin +// +//************************************************************************ + +int CLCDText::GetRightMargin(void) +{ + return m_dtp.iRightMargin; +} + + +//************************************************************************ +// +// CLCDText::GetVExtent +// +//************************************************************************ + +SIZE& CLCDText::GetVExtent() +{ + return m_sizeVExtent; +} + + +//************************************************************************ +// +// CLCDText::GetHExtent +// +//************************************************************************ + +SIZE& CLCDText::GetHExtent() +{ + return m_sizeHExtent; +} + + +//************************************************************************ +// +// CLCDText::SetAlignment +// +//************************************************************************ + +void CLCDText::SetAlignment(int nAlignment) +{ + m_nTextFormat &= ~m_nTextAlignment; + m_nTextFormat |= nAlignment; + m_nTextAlignment = nAlignment; +} + + +//************************************************************************ +// +// CLCDText::DrawText +// +//************************************************************************ + +void CLCDText::DrawText(CLCDGfx &rGfx) +{ + // draw the text + RECT rBoundary = { 0, 0,0 + GetLogicalSize().cx, 0 + GetLogicalSize().cy }; + DrawTextEx(rGfx.GetHDC(), (LPTSTR)m_sText.c_str(), static_cast(m_nTextLength), &rBoundary, m_nTextFormat, &m_dtp); + +// LCDUITRACE(_T("Drawing %s at (%d,%d)-(%d-%d) lmargin=%d, rmargin=%d\n"), +// m_sText.c_str(), m_Origin.x, m_Origin.y, GetWidth(), GetHeight(), +// m_dtp.iLeftMargin, m_dtp.iRightMargin); + + if (m_bInverted) + { + InvertRect(rGfx.GetHDC(), &rBoundary); + } +} + + +//************************************************************************ +// +// CLCDText::OnDraw +// +//************************************************************************ + +void CLCDText::OnDraw(CLCDGfx &rGfx) +{ + + if (GetBackgroundMode() == OPAQUE) + { + // clear the clipped area + RECT rcClp = { 0, 0, m_Size.cx, m_Size.cy }; + FillRect(rGfx.GetHDC(), &rcClp, (HBRUSH) GetStockObject(BLACK_BRUSH)); + + // clear the logical area + RECT rcLog = { 0, 0, m_sizeLogical.cx, m_sizeLogical.cy }; + FillRect(rGfx.GetHDC(), &rcLog, (HBRUSH) GetStockObject(BLACK_BRUSH)); + } + + if (m_nTextLength) + { + + // map mode text, with transparency + int nOldMapMode = SetMapMode(rGfx.GetHDC(), MM_TEXT); + int nOldBkMode = SetBkMode(rGfx.GetHDC(), GetBackgroundMode()); + + // select current font + HFONT hOldFont = (HFONT)SelectObject(rGfx.GetHDC(), m_hFont); + + // select color + COLORREF crOldTextColor = SetTextColor(rGfx.GetHDC(), m_crColor); + + if (m_bRecalcExtent) + { + int nTextFormat; + + RECT rExtent; + // calculate vertical extent with word wrap + nTextFormat = (m_nTextFormat | DT_WORDBREAK | DT_CALCRECT); + rExtent.left = rExtent.top = 0; + rExtent.right = GetWidth(); + rExtent.bottom = GetHeight(); + DrawTextEx(rGfx.GetHDC(), (LPTSTR)m_sText.c_str(), static_cast(m_nTextLength), &rExtent, nTextFormat, &m_dtp); + m_sizeVExtent.cx = rExtent.right; + m_sizeVExtent.cy = rExtent.bottom; + + // calculate horizontal extent w/o word wrap + nTextFormat = (m_nTextFormat | DT_CALCRECT); + rExtent.left = rExtent.top = 0; + rExtent.right = GetWidth(); + rExtent.bottom = GetHeight(); + DrawTextEx(rGfx.GetHDC(), (LPTSTR)m_sText.c_str(), static_cast(m_nTextLength), &rExtent, nTextFormat, &m_dtp); + m_sizeHExtent.cx = rExtent.right; + m_sizeHExtent.cy = rExtent.bottom; + + m_bRecalcExtent = FALSE; + } + + if (IsVisible()) + { + DrawText(rGfx); + } + + // restores + SetMapMode(rGfx.GetHDC(), nOldMapMode); + SetTextColor(rGfx.GetHDC(), crOldTextColor); + SetBkMode(rGfx.GetHDC(), nOldBkMode); + SelectObject(rGfx.GetHDC(), hOldFont); + } +} + +//** end of LCDText.cpp ************************************************** + diff --git a/src/ui/LCDUI/LCDText.h b/src/ui/LCDUI/LCDText.h new file mode 100644 index 000000000..3a74f746f --- /dev/null +++ b/src/ui/LCDUI/LCDText.h @@ -0,0 +1,71 @@ +//************************************************************************ +// +// LCDText.h +// +// The CLCDText class draws simple text onto the LCD. +// +// Logitech LCD SDK +// +// Copyright 2005 Logitech Inc. +//************************************************************************ + +#ifndef _LCDTEXT_H_INCLUDED_ +#define _LCDTEXT_H_INCLUDED_ + +#include "LCDBase.h" + +#include +using namespace std; + +class CLCDText : public CLCDBase +{ + +public: + CLCDText(); + virtual ~CLCDText(); + + virtual HRESULT Initialize(void); + + virtual void SetFont(LOGFONT& lf); + virtual void SetFontFaceName(LPCTSTR szFontName); + virtual void SetFontPointSize(int nPointSize); + virtual void SetFontWeight(int nWeight); + + virtual HFONT GetFont(); + virtual void SetText(LPCTSTR szText); + virtual LPCTSTR GetText(); + virtual void SetWordWrap(BOOL bEnable); + virtual SIZE& GetVExtent(); + virtual SIZE& GetHExtent(); + virtual void SetLeftMargin(int nLeftMargin); + virtual int GetLeftMargin(void); + virtual void SetRightMargin(int nRightMargin); + virtual int GetRightMargin(void); + virtual void SetAlignment(int nAlignment = DT_LEFT); + + virtual void OnDraw(CLCDGfx &rGfx); + + enum { DEFAULT_DPI = 96, DEFAULT_POINTSIZE = 8 }; + +protected: + void DrawText(CLCDGfx &rGfx); + +#ifdef UNICODE + std::wstring m_sText; +#else + std::string m_sText; +#endif + HFONT m_hFont; + COLORREF m_crColor; + basic_string ::size_type m_nTextLength; + UINT m_nTextFormat; + BOOL m_bRecalcExtent; + DRAWTEXTPARAMS m_dtp; + int m_nTextAlignment; + SIZE m_sizeVExtent, m_sizeHExtent; +}; + + +#endif // !_LCDTEXT_H_INCLUDED_ + +//** end of LCDText.h **************************************************** diff --git a/src/ui/LCDUI/LCDUI.sln b/src/ui/LCDUI/LCDUI.sln new file mode 100644 index 000000000..1440c1439 --- /dev/null +++ b/src/ui/LCDUI/LCDUI.sln @@ -0,0 +1,25 @@ +Microsoft Visual Studio Solution File, Format Version 9.00 +# Visual Studio 2005 +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "LCDUI", "LCDUI.vcproj", "{476B97B4-F079-4A44-AF89-52CA30C35E28}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug Unicode|Win32 = Debug Unicode|Win32 + Debug|Win32 = Debug|Win32 + Release Unicode|Win32 = Release Unicode|Win32 + Release|Win32 = Release|Win32 + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {476B97B4-F079-4A44-AF89-52CA30C35E28}.Debug Unicode|Win32.ActiveCfg = Debug Unicode|Win32 + {476B97B4-F079-4A44-AF89-52CA30C35E28}.Debug Unicode|Win32.Build.0 = Debug Unicode|Win32 + {476B97B4-F079-4A44-AF89-52CA30C35E28}.Debug|Win32.ActiveCfg = Debug|Win32 + {476B97B4-F079-4A44-AF89-52CA30C35E28}.Debug|Win32.Build.0 = Debug|Win32 + {476B97B4-F079-4A44-AF89-52CA30C35E28}.Release Unicode|Win32.ActiveCfg = Release Unicode|Win32 + {476B97B4-F079-4A44-AF89-52CA30C35E28}.Release Unicode|Win32.Build.0 = Release Unicode|Win32 + {476B97B4-F079-4A44-AF89-52CA30C35E28}.Release|Win32.ActiveCfg = Release|Win32 + {476B97B4-F079-4A44-AF89-52CA30C35E28}.Release|Win32.Build.0 = Release|Win32 + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection +EndGlobal diff --git a/src/ui/LCDUI/LCDUI.vcproj b/src/ui/LCDUI/LCDUI.vcproj new file mode 100644 index 000000000..cd9a656a9 --- /dev/null +++ b/src/ui/LCDUI/LCDUI.vcproj @@ -0,0 +1,343 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + -- cgit v1.2.3