You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1424 lines
35 KiB
1424 lines
35 KiB
//
|
|
// candmgr.cpp
|
|
//
|
|
|
|
#include "private.h"
|
|
#include "globals.h"
|
|
#include "mscandui.h"
|
|
#include "candmgr.h"
|
|
#include "candutil.h"
|
|
|
|
|
|
/*============================================================================*/
|
|
/* */
|
|
/* C C A N D I D A T E I T E M */
|
|
/* */
|
|
/*============================================================================*/
|
|
|
|
/* C C A N D I D A T E I T E M */
|
|
/*------------------------------------------------------------------------------
|
|
|
|
Constructor of CCandidateItem
|
|
|
|
------------------------------------------------------------------------------*/
|
|
CCandidateItem::CCandidateItem( int iCandItem, ITfCandidateString *pCandStr )
|
|
{
|
|
ITfCandidateStringFlag *pCandStrFlag;
|
|
ITfCandidateStringInlineComment *pCandStrInlineComment;
|
|
ITfCandidateStringPopupComment *pCandStrPopupComment;
|
|
ITfCandidateStringColor *pCandStrColor;
|
|
ITfCandidateStringFixture *pCandStrFixture;
|
|
ITfCandidateStringIcon *pCandStrIcon;
|
|
BSTR bstr;
|
|
DWORD dwFlag;
|
|
BOOL fHasFlag;
|
|
|
|
Assert( pCandStr != NULL );
|
|
|
|
m_iCandItemOrg = iCandItem;
|
|
m_pCandStr = pCandStr;
|
|
m_pCandStr->AddRef();
|
|
|
|
m_nIndex = 0;
|
|
m_bstr = NULL;
|
|
m_bstrInlineComment = NULL;
|
|
m_bstrPopupComment = NULL;
|
|
m_dwPopupCommentGroupID = 0;
|
|
m_fHasColor = FALSE;
|
|
m_cr = RGB( 0, 0, 0 );
|
|
m_bstrPrefix = NULL;
|
|
m_bstrSuffix = NULL;
|
|
m_hIcon = NULL;
|
|
|
|
m_fVisible = TRUE;
|
|
m_fPopupCommentVisible = FALSE;
|
|
|
|
//
|
|
// get candidate string information
|
|
//
|
|
|
|
// index
|
|
|
|
m_pCandStr->GetIndex( &m_nIndex );
|
|
|
|
// candidate string
|
|
|
|
if (m_pCandStr->GetString( &bstr ) == S_OK && bstr != NULL) {
|
|
m_bstr = SysAllocString( bstr );
|
|
SysFreeString( bstr );
|
|
}
|
|
|
|
// flag
|
|
|
|
fHasFlag = FALSE;
|
|
if (m_pCandStr->QueryInterface( IID_ITfCandidateStringFlag, (void **)&pCandStrFlag ) == S_OK) {
|
|
fHasFlag = (pCandStrFlag->GetFlag( &dwFlag) == S_OK);
|
|
pCandStrFlag->Release();
|
|
}
|
|
|
|
// inline comment
|
|
|
|
if (!fHasFlag || (dwFlag & CANDUISTR_HASINLINECOMMENT) != 0) {
|
|
if (m_pCandStr->QueryInterface( IID_ITfCandidateStringInlineComment, (void **)&pCandStrInlineComment ) == S_OK) {
|
|
if (pCandStrInlineComment->GetInlineCommentString( &bstr ) == S_OK && bstr != NULL) {
|
|
m_bstrInlineComment = SysAllocString( bstr );
|
|
SysFreeString( bstr );
|
|
}
|
|
|
|
pCandStrInlineComment->Release();
|
|
}
|
|
}
|
|
|
|
// popup comment
|
|
|
|
if (!fHasFlag || (dwFlag & CANDUISTR_HASPOPUPCOMMENT) != 0) {
|
|
if (m_pCandStr->QueryInterface( IID_ITfCandidateStringPopupComment, (void **)&pCandStrPopupComment ) == S_OK) {
|
|
DWORD dwGroupID;
|
|
|
|
if (pCandStrPopupComment->GetPopupCommentString( &bstr ) == S_OK && bstr != NULL) {
|
|
m_bstrPopupComment = SysAllocString( bstr );
|
|
SysFreeString( bstr );
|
|
}
|
|
|
|
if (pCandStrPopupComment->GetPopupCommentGroupID( &dwGroupID ) == S_OK) {
|
|
m_dwPopupCommentGroupID = dwGroupID;
|
|
}
|
|
|
|
pCandStrPopupComment->Release();
|
|
}
|
|
}
|
|
|
|
// color
|
|
|
|
if (!fHasFlag || (dwFlag & CANDUISTR_HASCOLOR) != 0) {
|
|
if (m_pCandStr->QueryInterface( IID_ITfCandidateStringColor, (void **)&pCandStrColor ) == S_OK) {
|
|
CANDUICOLOR col;
|
|
|
|
if (pCandStrColor->GetColor( &col ) == S_OK) {
|
|
switch (col.type) {
|
|
case CANDUICOL_DEFAULT:
|
|
default: {
|
|
break;
|
|
}
|
|
|
|
case CANDUICOL_SYSTEM: {
|
|
m_fHasColor = TRUE;
|
|
m_cr = GetSysColor( col.nIndex );
|
|
break;
|
|
}
|
|
|
|
case CANDUICOL_COLORREF: {
|
|
m_fHasColor = TRUE;
|
|
m_cr = col.cr;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
pCandStrColor->Release();
|
|
}
|
|
}
|
|
|
|
// prefix/suffix string
|
|
|
|
if (!fHasFlag || (dwFlag & CANDUISTR_HASFIXTURE) != 0) {
|
|
if (m_pCandStr->QueryInterface( IID_ITfCandidateStringFixture, (void **)&pCandStrFixture ) == S_OK) {
|
|
if (pCandStrFixture->GetPrefixString( &bstr ) == S_OK && bstr != NULL) {
|
|
m_bstrPrefix = SysAllocString( bstr );
|
|
SysFreeString( bstr );
|
|
}
|
|
|
|
if (pCandStrFixture->GetSuffixString( &bstr ) == S_OK && bstr != NULL) {
|
|
m_bstrSuffix = SysAllocString( bstr );
|
|
SysFreeString( bstr );
|
|
}
|
|
|
|
pCandStrFixture->Release();
|
|
}
|
|
}
|
|
|
|
// icon
|
|
|
|
if (!fHasFlag || (dwFlag & CANDUISTR_HASICON) != 0) {
|
|
if (m_pCandStr->QueryInterface( IID_ITfCandidateStringIcon, (void **)&pCandStrIcon ) == S_OK) {
|
|
HICON hIcon = NULL;
|
|
|
|
if (pCandStrIcon->GetIcon( &hIcon ) == S_OK && hIcon != NULL) {
|
|
m_hIcon = hIcon;
|
|
}
|
|
|
|
pCandStrIcon->Release();
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/* ~ C C A N D I D A T E I T E M */
|
|
/*------------------------------------------------------------------------------
|
|
|
|
Destructor of CCandidateItem
|
|
|
|
------------------------------------------------------------------------------*/
|
|
CCandidateItem::~CCandidateItem( void )
|
|
{
|
|
// dispose buffers
|
|
|
|
if (m_bstr != NULL) {
|
|
SysFreeString( m_bstr );
|
|
}
|
|
|
|
if (m_bstrInlineComment != NULL) {
|
|
SysFreeString( m_bstrInlineComment );
|
|
}
|
|
|
|
if (m_bstrPopupComment != NULL) {
|
|
SysFreeString( m_bstrPopupComment );
|
|
}
|
|
|
|
if (m_bstrPrefix != NULL) {
|
|
SysFreeString( m_bstrPrefix );
|
|
}
|
|
|
|
if (m_bstrSuffix != NULL) {
|
|
SysFreeString( m_bstrSuffix );
|
|
}
|
|
|
|
// release candidate string
|
|
|
|
m_pCandStr->Release();
|
|
}
|
|
|
|
|
|
/* G E T I C A N D I T E M O R G */
|
|
/*------------------------------------------------------------------------------
|
|
|
|
Get index of candidat item
|
|
NOTE: this is index of candidate item in candidate list
|
|
(use to identify original index of candidate item)
|
|
|
|
------------------------------------------------------------------------------*/
|
|
int CCandidateItem::GetICandItemOrg( void )
|
|
{
|
|
return m_iCandItemOrg;
|
|
}
|
|
|
|
|
|
/* G E T I N D E X */
|
|
/*------------------------------------------------------------------------------
|
|
|
|
Get index of item
|
|
NOTE: this is index of candidate item stored in candidate string
|
|
(use to specify candidate item to client in notification)
|
|
|
|
------------------------------------------------------------------------------*/
|
|
ULONG CCandidateItem::GetIndex( void )
|
|
{
|
|
return m_nIndex;
|
|
}
|
|
|
|
|
|
/* G E T S T R I N G */
|
|
/*------------------------------------------------------------------------------
|
|
|
|
Get candidate string of item
|
|
|
|
------------------------------------------------------------------------------*/
|
|
LPCWSTR CCandidateItem::GetString( void )
|
|
{
|
|
return m_bstr;
|
|
}
|
|
|
|
|
|
/* G E T I N L I N E C O M M E N T */
|
|
/*------------------------------------------------------------------------------
|
|
|
|
Get inline comment
|
|
|
|
------------------------------------------------------------------------------*/
|
|
LPCWSTR CCandidateItem::GetInlineComment( void )
|
|
{
|
|
return m_bstrInlineComment;
|
|
}
|
|
|
|
|
|
/* G E T P O P U P C O M M E N T */
|
|
/*------------------------------------------------------------------------------
|
|
|
|
Get popup comment
|
|
|
|
------------------------------------------------------------------------------*/
|
|
LPCWSTR CCandidateItem::GetPopupComment( void )
|
|
{
|
|
return m_bstrPopupComment;
|
|
}
|
|
|
|
|
|
/* G E T P O P U P C O M M E N T G R O U P I D */
|
|
/*------------------------------------------------------------------------------
|
|
|
|
|
|
|
|
------------------------------------------------------------------------------*/
|
|
DWORD CCandidateItem::GetPopupCommentGroupID( void )
|
|
{
|
|
return m_dwPopupCommentGroupID;
|
|
}
|
|
|
|
|
|
/* G E T C O L O R */
|
|
/*------------------------------------------------------------------------------
|
|
|
|
Get color
|
|
|
|
------------------------------------------------------------------------------*/
|
|
BOOL CCandidateItem::GetColor( COLORREF *pcr )
|
|
{
|
|
Assert( pcr != NULL );
|
|
|
|
if (m_fHasColor) {
|
|
*pcr = m_cr;
|
|
return TRUE;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
/* G E T P R E F I X S T R I N G */
|
|
/*------------------------------------------------------------------------------
|
|
|
|
Get prefix string
|
|
|
|
------------------------------------------------------------------------------*/
|
|
LPCWSTR CCandidateItem::GetPrefixString( void )
|
|
{
|
|
return m_bstrPrefix;
|
|
}
|
|
|
|
|
|
/* G E T S U F F I X S T R I N G */
|
|
/*------------------------------------------------------------------------------
|
|
|
|
Get suffix string
|
|
|
|
------------------------------------------------------------------------------*/
|
|
LPCWSTR CCandidateItem::GetSuffixString( void )
|
|
{
|
|
return m_bstrSuffix;
|
|
}
|
|
|
|
|
|
/* G E T I C O N */
|
|
/*------------------------------------------------------------------------------
|
|
|
|
Get icon
|
|
|
|
------------------------------------------------------------------------------*/
|
|
HICON CCandidateItem::GetIcon( void )
|
|
{
|
|
return m_hIcon;
|
|
}
|
|
|
|
|
|
/* S E T V I S I B L E S T A T E */
|
|
/*------------------------------------------------------------------------------
|
|
|
|
Set visible status
|
|
|
|
------------------------------------------------------------------------------*/
|
|
void CCandidateItem::SetVisibleState( BOOL fVisible )
|
|
{
|
|
m_fVisible = fVisible;
|
|
}
|
|
|
|
|
|
/* I S V I S I B L E */
|
|
/*------------------------------------------------------------------------------
|
|
|
|
Get visible status
|
|
Returns TRUE when the item is visible, FALSE when invisible.
|
|
|
|
------------------------------------------------------------------------------*/
|
|
BOOL CCandidateItem::IsVisible( void )
|
|
{
|
|
return m_fVisible;
|
|
}
|
|
|
|
|
|
/* S E T P O P U P C O M M E N T S T A T E */
|
|
/*------------------------------------------------------------------------------
|
|
|
|
Set popup comment status
|
|
|
|
------------------------------------------------------------------------------*/
|
|
void CCandidateItem::SetPopupCommentState( BOOL fVisible )
|
|
{
|
|
m_fPopupCommentVisible = fVisible;
|
|
}
|
|
|
|
|
|
/* I S P O P U P C O M M E N T V I S I B L E */
|
|
/*------------------------------------------------------------------------------
|
|
|
|
Get visible status of popup comment
|
|
Returns TRUE when the popup comment of item is visible, FALSE when invisible.
|
|
|
|
------------------------------------------------------------------------------*/
|
|
BOOL CCandidateItem::IsPopupCommentVisible( void )
|
|
{
|
|
return m_fPopupCommentVisible;
|
|
}
|
|
|
|
|
|
/*============================================================================*/
|
|
/* */
|
|
/* C C A N D I D A T E L I S T */
|
|
/* */
|
|
/*============================================================================*/
|
|
|
|
/* C C A N D I D A T E L I S T */
|
|
/*------------------------------------------------------------------------------
|
|
|
|
Constructor of CCandidateList
|
|
|
|
------------------------------------------------------------------------------*/
|
|
CCandidateList::CCandidateList( CCandListMgr *pCandListMgr, ITfCandidateList *pCandList )
|
|
{
|
|
Assert( pCandListMgr != NULL );
|
|
Assert( pCandList != NULL );
|
|
|
|
m_pCandListMgr = pCandListMgr;
|
|
m_pOptionsList = NULL;
|
|
m_pCandList = pCandList;
|
|
m_rgCandItem = NULL;
|
|
m_nCandItem = 0;
|
|
|
|
m_pExtraCandItem = NULL;
|
|
m_bstrTip = NULL;
|
|
|
|
m_fRawData = FALSE;
|
|
m_bstrRawData = NULL;
|
|
m_hbmpRawData = NULL;
|
|
m_hemfRawData = NULL;
|
|
m_nIndexRawData = 0;
|
|
m_fIndexRawData = FALSE;
|
|
|
|
m_iItemSel = ICANDITEM_NULL;
|
|
|
|
//
|
|
|
|
if (m_pCandList != NULL) {
|
|
m_pCandList->AddRef();
|
|
}
|
|
}
|
|
|
|
CCandidateList::CCandidateList( CCandListMgr *pCandListMgr, ITfOptionsCandidateList *pCandList )
|
|
{
|
|
Assert( pCandListMgr != NULL );
|
|
Assert( pCandList != NULL );
|
|
|
|
m_pCandListMgr = pCandListMgr;
|
|
m_pOptionsList = pCandList;
|
|
m_pCandList = NULL;
|
|
m_rgCandItem = NULL;
|
|
m_nCandItem = 0;
|
|
|
|
m_pExtraCandItem = NULL;
|
|
m_bstrTip = NULL;
|
|
|
|
m_fRawData = FALSE;
|
|
m_bstrRawData = NULL;
|
|
m_hbmpRawData = NULL;
|
|
m_hemfRawData = NULL;
|
|
m_nIndexRawData = 0;
|
|
m_fIndexRawData = FALSE;
|
|
|
|
m_iItemSel = ICANDITEM_NULL;
|
|
|
|
//
|
|
|
|
if (m_pOptionsList != NULL) {
|
|
m_pOptionsList->AddRef();
|
|
}
|
|
}
|
|
|
|
/* ~ C C A N D I D A T E L I S T */
|
|
/*------------------------------------------------------------------------------
|
|
|
|
Destructor of CCandidateList
|
|
|
|
------------------------------------------------------------------------------*/
|
|
CCandidateList::~CCandidateList( void )
|
|
{
|
|
Uninitialize();
|
|
|
|
if (m_pCandList != NULL) {
|
|
m_pCandList->Release();
|
|
}
|
|
if (m_pOptionsList != NULL) {
|
|
m_pOptionsList->Release();
|
|
}
|
|
}
|
|
|
|
|
|
/* I N I T I A L I Z E */
|
|
/*------------------------------------------------------------------------------
|
|
|
|
Initialize CandidateList
|
|
|
|
------------------------------------------------------------------------------*/
|
|
HRESULT CCandidateList::Initialize( void )
|
|
{
|
|
ITfCandidateListExtraCandidate *pCandListExtraCand;
|
|
ITfCandidateListTip *pCandListTip;
|
|
ITfCandidateListRawData *pCandListRawData;
|
|
ITfCandidateString *pCandStr;
|
|
ULONG nCandItem;
|
|
ULONG i;
|
|
|
|
if (m_pCandList == NULL &&
|
|
m_pOptionsList == NULL) {
|
|
return E_INVALIDARG;
|
|
}
|
|
|
|
//
|
|
//
|
|
//
|
|
|
|
Assert( m_rgCandItem == NULL );
|
|
Assert( m_nCandItem == 0 );
|
|
|
|
//
|
|
// build options item list (if present)
|
|
//
|
|
|
|
if (m_pOptionsList) {
|
|
m_nCandItem = 0;
|
|
m_pOptionsList->GetOptionsCandidateNum( &nCandItem );
|
|
|
|
if (nCandItem != 0) {
|
|
m_rgCandItem = new CCandidateItem*[ nCandItem ];
|
|
|
|
if (m_rgCandItem == NULL)
|
|
return E_OUTOFMEMORY;
|
|
|
|
for (i = 0; i < nCandItem; i++) {
|
|
if (SUCCEEDED(m_pOptionsList->GetOptionsCandidate( i, &pCandStr ))) {
|
|
m_rgCandItem[m_nCandItem] = new CCandidateItem( m_nCandItem, pCandStr );;
|
|
m_nCandItem++;
|
|
|
|
pCandStr->Release();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// build candidate item list
|
|
//
|
|
|
|
if (m_pCandList) {
|
|
m_nCandItem = 0;
|
|
m_pCandList->GetCandidateNum( &nCandItem );
|
|
|
|
if (nCandItem != 0) {
|
|
m_rgCandItem = new CCandidateItem*[ nCandItem ];
|
|
|
|
if (m_rgCandItem == NULL)
|
|
return E_OUTOFMEMORY;
|
|
|
|
for (i = 0; i < nCandItem; i++) {
|
|
if (SUCCEEDED(m_pCandList->GetCandidate( i, &pCandStr ))) {
|
|
m_rgCandItem[m_nCandItem] = new CCandidateItem( m_nCandItem, pCandStr );;
|
|
m_nCandItem++;
|
|
|
|
pCandStr->Release();
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// get extended information of candidate list
|
|
//
|
|
|
|
// extra item
|
|
|
|
if (m_pCandList->QueryInterface( IID_ITfCandidateListExtraCandidate, (void **)&pCandListExtraCand ) == S_OK) {
|
|
if (pCandListExtraCand->GetExtraCandidate( &pCandStr ) == S_OK) {
|
|
m_pExtraCandItem = new CCandidateItem( ICANDITEM_EXTRA, pCandStr );
|
|
pCandStr->Release();
|
|
}
|
|
|
|
pCandListExtraCand->Release();
|
|
}
|
|
|
|
// tip string
|
|
|
|
if (m_pCandList->QueryInterface( IID_ITfCandidateListTip, (void **)&pCandListTip ) == S_OK) {
|
|
BSTR bstr;
|
|
|
|
if (pCandListTip->GetTipString( &bstr ) == S_OK) {
|
|
m_bstrTip = SysAllocString( bstr );
|
|
SysFreeString( bstr );
|
|
}
|
|
|
|
pCandListTip->Release();
|
|
}
|
|
|
|
// raw data
|
|
|
|
if (m_pCandList->QueryInterface( IID_ITfCandidateListRawData, (void **)&pCandListRawData ) == S_OK) {
|
|
CANDUIRAWDATA RawData;
|
|
|
|
// raw data
|
|
|
|
if (pCandListRawData->GetRawData( &RawData ) == S_OK) {
|
|
m_fRawData = TRUE;
|
|
m_kRawData = RawData.type;
|
|
|
|
switch (RawData.type) {
|
|
case CANDUIRDT_STRING: {
|
|
m_bstrRawData = SysAllocString( RawData.bstr );
|
|
SysFreeString( RawData.bstr );
|
|
break;
|
|
}
|
|
|
|
case CANDUIRDT_BITMAP: {
|
|
m_hbmpRawData = RawData.hbmp;
|
|
break;
|
|
}
|
|
|
|
case CANDUIRDT_METAFILE: {
|
|
m_hemfRawData = RawData.hemf;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// raw data index
|
|
|
|
if (pCandListRawData->GetRawDataIndex( &m_nIndexRawData ) == S_OK) {
|
|
m_fIndexRawData = TRUE;
|
|
}
|
|
|
|
pCandListRawData->Release();
|
|
}
|
|
}
|
|
|
|
// initialize selection
|
|
|
|
if (m_pOptionsList)
|
|
{
|
|
m_iItemSel = ICANDITEM_NULL;
|
|
}
|
|
else
|
|
{
|
|
m_iItemSel = 0;
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
/* U N I N I T I A L I Z E */
|
|
/*------------------------------------------------------------------------------
|
|
|
|
|
|
|
|
------------------------------------------------------------------------------*/
|
|
HRESULT CCandidateList::Uninitialize( void )
|
|
{
|
|
int i;
|
|
|
|
if (m_rgCandItem == NULL) {
|
|
Assert( m_nCandItem == 0 );
|
|
}
|
|
|
|
// dispose canditem objects
|
|
|
|
for (i = 0; i < m_nCandItem; i++) {
|
|
delete m_rgCandItem[i];
|
|
}
|
|
|
|
// dispose canditem list
|
|
|
|
if (m_rgCandItem != NULL) {
|
|
delete m_rgCandItem;
|
|
m_rgCandItem = NULL;
|
|
}
|
|
m_nCandItem = 0;
|
|
|
|
// dispose extra item
|
|
|
|
if (m_pExtraCandItem != NULL) {
|
|
delete m_pExtraCandItem;
|
|
m_pExtraCandItem = NULL;
|
|
}
|
|
|
|
// dispose tip
|
|
|
|
if (m_bstrTip != NULL) {
|
|
SysFreeString( m_bstrTip );
|
|
m_bstrTip = NULL;
|
|
}
|
|
|
|
// dispose raw data
|
|
|
|
m_fRawData = FALSE;
|
|
|
|
if (m_bstrRawData != NULL) {
|
|
SysFreeString( m_bstrRawData );
|
|
}
|
|
m_bstrRawData = NULL;
|
|
m_hbmpRawData = NULL;
|
|
m_hemfRawData = NULL;
|
|
|
|
m_nIndexRawData = 0;
|
|
m_fIndexRawData = FALSE;
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
/* G E T I T E M C O U N T */
|
|
/*------------------------------------------------------------------------------
|
|
|
|
Get count of candidate item object
|
|
|
|
------------------------------------------------------------------------------*/
|
|
int CCandidateList::GetItemCount( void )
|
|
{
|
|
return m_nCandItem;
|
|
}
|
|
|
|
|
|
/* G E T C A N D I D A T E I T E M */
|
|
/*------------------------------------------------------------------------------
|
|
|
|
Get candidate item object
|
|
|
|
------------------------------------------------------------------------------*/
|
|
CCandidateItem *CCandidateList::GetCandidateItem( int iItem )
|
|
{
|
|
if (0 <= iItem && iItem < m_nCandItem) {
|
|
return m_rgCandItem[ iItem ];
|
|
}
|
|
else if (iItem == ICANDITEM_EXTRA) {
|
|
return m_pExtraCandItem;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
|
|
/* S W A P C A N D I D A T E I T E M */
|
|
/*------------------------------------------------------------------------------
|
|
|
|
Swap two candidate items
|
|
NOTE: Only used from CCandFnSort.
|
|
NOTE: Do not send SetSelection notification here. It resets filtering
|
|
string and makes conflict filtering state.
|
|
|
|
------------------------------------------------------------------------------*/
|
|
void CCandidateList::SwapCandidateItem( int iItem1, int iItem2 )
|
|
{
|
|
if ((iItem1 != iItem2) && (0 <= iItem1 && iItem1 <= m_nCandItem) && (0 <= iItem2 && iItem2 <= m_nCandItem)) {
|
|
CCandidateItem *pCandItem1;
|
|
CCandidateItem *pCandItem2;
|
|
int iItemSel;
|
|
|
|
// swap items
|
|
|
|
pCandItem1 = m_rgCandItem[ iItem1 ];
|
|
pCandItem2 = m_rgCandItem[ iItem2 ];
|
|
m_rgCandItem[ iItem1 ] = pCandItem2;
|
|
m_rgCandItem[ iItem2 ] = pCandItem1;
|
|
|
|
// check selection
|
|
|
|
iItemSel = GetSelection();
|
|
if (iItemSel == iItem1) {
|
|
CCandidateList::SetSelection( iItem2 );
|
|
}
|
|
else if (iItemSel == iItem2) {
|
|
CCandidateList::SetSelection( iItem1 );
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/* G E T E X T R A C A N D I T E M */
|
|
/*------------------------------------------------------------------------------
|
|
|
|
|
|
|
|
------------------------------------------------------------------------------*/
|
|
CCandidateItem *CCandidateList::GetExtraCandItem( void )
|
|
{
|
|
return m_pExtraCandItem;
|
|
}
|
|
|
|
|
|
/* G E T E X T R A C A N D I T E M */
|
|
/*------------------------------------------------------------------------------
|
|
|
|
|
|
|
|
------------------------------------------------------------------------------*/
|
|
ULONG CCandidateList::GetExtraCandIndex( void )
|
|
{
|
|
if (m_pExtraCandItem == NULL) {
|
|
return 0;
|
|
}
|
|
|
|
return m_pExtraCandItem->GetIndex();
|
|
}
|
|
|
|
|
|
/* G E T T I P S T R I N G */
|
|
/*------------------------------------------------------------------------------
|
|
|
|
|
|
|
|
------------------------------------------------------------------------------*/
|
|
LPCWSTR CCandidateList::GetTipString( void )
|
|
{
|
|
return m_bstrTip;
|
|
}
|
|
|
|
|
|
/* F H A S R A W D A T A */
|
|
/*------------------------------------------------------------------------------
|
|
|
|
Returns TRUE when CandidateList has raw data
|
|
|
|
------------------------------------------------------------------------------*/
|
|
BOOL CCandidateList::FHasRawData( void )
|
|
{
|
|
return m_fRawData;
|
|
}
|
|
|
|
|
|
/* G E T R A W D A T A T Y P E */
|
|
/*------------------------------------------------------------------------------
|
|
|
|
Get raw data type
|
|
|
|
------------------------------------------------------------------------------*/
|
|
CANDUIRAWDATATYPE CCandidateList::GetRawDataType( void )
|
|
{
|
|
return m_kRawData;
|
|
}
|
|
|
|
|
|
/* G E T R A W D A T A S T R I N G */
|
|
/*------------------------------------------------------------------------------
|
|
|
|
Get raw data string
|
|
|
|
------------------------------------------------------------------------------*/
|
|
LPCWSTR CCandidateList::GetRawDataString( void )
|
|
{
|
|
return m_bstrRawData;
|
|
}
|
|
|
|
|
|
/* G E T R A W D A T A B I T M A P */
|
|
/*------------------------------------------------------------------------------
|
|
|
|
Get raw data bitmap
|
|
|
|
------------------------------------------------------------------------------*/
|
|
HBITMAP CCandidateList::GetRawDataBitmap( void )
|
|
{
|
|
return m_hbmpRawData;
|
|
}
|
|
|
|
|
|
/* G E T R A W D A T A M E T A F I L E */
|
|
/*------------------------------------------------------------------------------
|
|
|
|
Get raw data metafile
|
|
|
|
------------------------------------------------------------------------------*/
|
|
HENHMETAFILE CCandidateList::GetRawDataMetafile( void )
|
|
{
|
|
return m_hemfRawData;
|
|
}
|
|
|
|
|
|
/* G E T R A W D A T A I N D E X */
|
|
/*------------------------------------------------------------------------------
|
|
|
|
|
|
|
|
------------------------------------------------------------------------------*/
|
|
ULONG CCandidateList::GetRawDataIndex( void )
|
|
{
|
|
return m_nIndexRawData;
|
|
}
|
|
|
|
|
|
/* F R A W D A T A S E L E C T A B L E */
|
|
/*------------------------------------------------------------------------------
|
|
|
|
|
|
|
|
------------------------------------------------------------------------------*/
|
|
BOOL CCandidateList::FRawDataSelectable( void )
|
|
{
|
|
return (m_fRawData && m_fIndexRawData);
|
|
}
|
|
|
|
|
|
/* S E T S E L E C T I O N */
|
|
/*------------------------------------------------------------------------------
|
|
|
|
|
|
|
|
------------------------------------------------------------------------------*/
|
|
void CCandidateList::SetSelection( int iItem )
|
|
{
|
|
m_iItemSel = iItem;
|
|
}
|
|
|
|
|
|
/* G E T S E L E C T I O N */
|
|
/*------------------------------------------------------------------------------
|
|
|
|
|
|
|
|
------------------------------------------------------------------------------*/
|
|
int CCandidateList::GetSelection( void )
|
|
{
|
|
return m_iItemSel;
|
|
}
|
|
|
|
|
|
/* M A P I I T E M T O I N D E X */
|
|
/*------------------------------------------------------------------------------
|
|
|
|
|
|
|
|
------------------------------------------------------------------------------*/
|
|
HRESULT CCandidateList::MapIItemToIndex( int iItem, ULONG *pnIndex )
|
|
{
|
|
Assert( pnIndex != NULL );
|
|
|
|
if (0 <= iItem && iItem < m_nCandItem) {
|
|
*pnIndex = m_rgCandItem[ iItem ]->GetIndex();
|
|
return S_OK;
|
|
}
|
|
|
|
return E_FAIL;
|
|
}
|
|
|
|
|
|
/* M A P I N D E X T O I I T E M */
|
|
/*------------------------------------------------------------------------------
|
|
|
|
|
|
|
|
------------------------------------------------------------------------------*/
|
|
HRESULT CCandidateList::MapIndexToIItem( ULONG nIndex, int *piItem )
|
|
{
|
|
int iItem;
|
|
|
|
for (iItem = 0; iItem < m_nCandItem; iItem++) {
|
|
if (m_rgCandItem[ iItem ]->GetIndex() == nIndex) {
|
|
*piItem = iItem;
|
|
return S_OK;
|
|
}
|
|
}
|
|
|
|
return E_FAIL;
|
|
}
|
|
|
|
|
|
/*============================================================================*/
|
|
/* */
|
|
/* C C A N D L I S T M G R */
|
|
/* */
|
|
/*============================================================================*/
|
|
|
|
/* C C A N D L I S T M G R */
|
|
/*------------------------------------------------------------------------------
|
|
|
|
Constructor of CCandListMgr
|
|
|
|
------------------------------------------------------------------------------*/
|
|
CCandListMgr::CCandListMgr( void )
|
|
{
|
|
int i;
|
|
|
|
m_pCandUI = NULL;
|
|
m_pCandListObj = NULL;
|
|
m_pOptionsListObj = NULL;
|
|
|
|
for (i = 0; i < CANDLISTSINK_MAX; i++) {
|
|
m_rgCandListSink[i] = NULL;
|
|
}
|
|
}
|
|
|
|
|
|
/* ~ C C A N D L I S T M G R */
|
|
/*------------------------------------------------------------------------------
|
|
|
|
Destructor of CCandListMgr
|
|
|
|
------------------------------------------------------------------------------*/
|
|
CCandListMgr::~CCandListMgr( void )
|
|
{
|
|
Uninitialize();
|
|
}
|
|
|
|
|
|
/* I N I T I A L I Z E */
|
|
/*------------------------------------------------------------------------------
|
|
|
|
|
|
|
|
------------------------------------------------------------------------------*/
|
|
HRESULT CCandListMgr::Initialize( CCandidateUI *pCandUI )
|
|
{
|
|
m_pCandUI = pCandUI;
|
|
|
|
#if defined(DEBUG) || defined(_DEBUG)
|
|
// check all reference object are unregistered
|
|
|
|
for (int i = 0; i < CANDLISTSINK_MAX; i++) {
|
|
Assert( m_rgCandListSink[i] == NULL );
|
|
}
|
|
#endif
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
/* U N I N I T I A L I Z E */
|
|
/*------------------------------------------------------------------------------
|
|
|
|
|
|
|
|
------------------------------------------------------------------------------*/
|
|
HRESULT CCandListMgr::Uninitialize( void )
|
|
{
|
|
if (m_pOptionsListObj != NULL) {
|
|
delete m_pOptionsListObj;
|
|
m_pOptionsListObj = NULL;
|
|
}
|
|
|
|
if (m_pCandListObj != NULL) {
|
|
delete m_pCandListObj;
|
|
m_pCandListObj = NULL;
|
|
}
|
|
|
|
#if defined(DEBUG) || defined(_DEBUG)
|
|
// check all reference object are unregistered
|
|
|
|
for (int i = 0; i < CANDLISTSINK_MAX; i++) {
|
|
Assert( m_rgCandListSink[i] == NULL );
|
|
}
|
|
#endif
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
/* A D V I S E E V E N T S I N K */
|
|
/*------------------------------------------------------------------------------
|
|
|
|
Register event sink
|
|
|
|
------------------------------------------------------------------------------*/
|
|
HRESULT CCandListMgr::AdviseEventSink( CCandListEventSink *pSink )
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < CANDLISTSINK_MAX; i++) {
|
|
if (m_rgCandListSink[i] == NULL) {
|
|
m_rgCandListSink[i] = pSink;
|
|
return S_OK;
|
|
}
|
|
}
|
|
|
|
Assert( FALSE );
|
|
return E_FAIL;
|
|
}
|
|
|
|
|
|
/* U N A D V I S E E V E N T S I N K */
|
|
/*------------------------------------------------------------------------------
|
|
|
|
Unregister event sink
|
|
|
|
------------------------------------------------------------------------------*/
|
|
HRESULT CCandListMgr::UnadviseEventSink( CCandListEventSink *pSink )
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < CANDLISTSINK_MAX; i++) {
|
|
if (m_rgCandListSink[i] == pSink) {
|
|
m_rgCandListSink[i] = NULL;
|
|
return S_OK;
|
|
}
|
|
}
|
|
|
|
Assert( FALSE );
|
|
return E_FAIL;
|
|
}
|
|
|
|
|
|
/* N O T I F Y S E T C A N D L I S T */
|
|
/*------------------------------------------------------------------------------
|
|
|
|
Notify to candidate functions that candidate list has been set
|
|
|
|
------------------------------------------------------------------------------*/
|
|
void CCandListMgr::NotifySetCandList( void )
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < CANDLISTSINK_MAX; i++) {
|
|
if (m_rgCandListSink[i] != NULL) {
|
|
m_rgCandListSink[i]->OnSetCandidateList();
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/* N O T I F Y C L E A R C A N D L I S T */
|
|
/*------------------------------------------------------------------------------
|
|
|
|
Notify to candidate functions that candidate list has been cleared
|
|
|
|
------------------------------------------------------------------------------*/
|
|
void CCandListMgr::NotifyClearCandList( void )
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < CANDLISTSINK_MAX; i++) {
|
|
if (m_rgCandListSink[i] != NULL) {
|
|
m_rgCandListSink[i]->OnClearCandidateList();
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/* N O T I F Y C A N D I T E M U P D A T E */
|
|
/*------------------------------------------------------------------------------
|
|
|
|
Notify to candidate functions that candidate item has been updated
|
|
|
|
------------------------------------------------------------------------------*/
|
|
void CCandListMgr::NotifyCandItemUpdate( CCandListEventSink *pSink )
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < CANDLISTSINK_MAX; i++) {
|
|
if (m_rgCandListSink[i] != NULL && m_rgCandListSink[i] != pSink) {
|
|
m_rgCandListSink[i]->OnCandItemUpdate();
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/* N O T I F Y S E L E C T I O N C H A N G E D */
|
|
/*------------------------------------------------------------------------------
|
|
|
|
Notify to candidate functions that selection has been changed
|
|
|
|
------------------------------------------------------------------------------*/
|
|
void CCandListMgr::NotifySelectionChanged( CCandListEventSink *pSink )
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < CANDLISTSINK_MAX; i++) {
|
|
if (m_rgCandListSink[i] != NULL && m_rgCandListSink[i] != pSink) {
|
|
m_rgCandListSink[i]->OnSelectionChanged();
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/* S E T O P T I O N S E L E C T I O N */
|
|
/*------------------------------------------------------------------------------
|
|
|
|
SetSelection
|
|
|
|
------------------------------------------------------------------------------*/
|
|
HRESULT CCandListMgr::SetOptionSelection( int iItem, CCandListEventSink *pSink )
|
|
{
|
|
CCandidateItem *pCandItem;
|
|
|
|
Assert( GetCandList() != NULL );
|
|
|
|
// check if item is valid and visible
|
|
|
|
pCandItem = GetOptionsList()->GetCandidateItem( iItem );
|
|
if (pCandItem == NULL || !pCandItem->IsVisible()) {
|
|
return E_FAIL;
|
|
}
|
|
|
|
GetOptionsList()->SetSelection( iItem );
|
|
// NotifySelectionChanged( pSink );
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
/* S E T S E L E C T I O N */
|
|
/*------------------------------------------------------------------------------
|
|
|
|
SetSelection
|
|
|
|
------------------------------------------------------------------------------*/
|
|
HRESULT CCandListMgr::SetSelection( int iItem, CCandListEventSink *pSink )
|
|
{
|
|
CCandidateItem *pCandItem;
|
|
|
|
Assert( GetCandList() != NULL );
|
|
|
|
// check if item is valid and visible
|
|
|
|
pCandItem = GetCandList()->GetCandidateItem( iItem );
|
|
if (pCandItem == NULL || !pCandItem->IsVisible()) {
|
|
return E_FAIL;
|
|
}
|
|
|
|
GetCandList()->SetSelection( iItem );
|
|
NotifySelectionChanged( pSink );
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
/* S E T C A N D I D A T E L I S T */
|
|
/*------------------------------------------------------------------------------
|
|
|
|
Set candidate list
|
|
|
|
------------------------------------------------------------------------------*/
|
|
HRESULT CCandListMgr::SetCandidateList( ITfCandidateList *pCandList )
|
|
{
|
|
HRESULT hr;
|
|
|
|
if ((m_pCandListObj != NULL) || (m_pOptionsListObj !=NULL)) {
|
|
return E_FAIL;
|
|
}
|
|
|
|
// create candidate list object
|
|
|
|
m_pCandListObj = new CCandidateList( this, pCandList );
|
|
if (m_pCandListObj == NULL) {
|
|
return E_OUTOFMEMORY;
|
|
}
|
|
|
|
hr = m_pCandListObj->Initialize();
|
|
if (FAILED(hr)) {
|
|
delete m_pCandListObj;
|
|
m_pCandListObj = NULL;
|
|
}
|
|
|
|
CComPtr<ITfOptionsCandidateList> cpOptionsList;
|
|
if (pCandList && pCandList->QueryInterface(IID_ITfOptionsCandidateList, (void **)&cpOptionsList) == S_OK) {
|
|
m_pOptionsListObj = new CCandidateList( this, cpOptionsList);
|
|
if (m_pOptionsListObj == NULL) {
|
|
return E_OUTOFMEMORY;
|
|
}
|
|
hr = m_pOptionsListObj->Initialize();
|
|
if (FAILED(hr)) {
|
|
delete m_pOptionsListObj;
|
|
m_pOptionsListObj = NULL;
|
|
}
|
|
}
|
|
|
|
// send notification
|
|
|
|
NotifySetCandList();
|
|
return hr;
|
|
}
|
|
|
|
|
|
/* G E T O P T I O N S L I S T */
|
|
/*------------------------------------------------------------------------------
|
|
|
|
Get candidate list
|
|
|
|
------------------------------------------------------------------------------*/
|
|
HRESULT CCandListMgr::GetOptionsCandidateList( ITfOptionsCandidateList **ppCandList )
|
|
{
|
|
if (ppCandList == NULL) {
|
|
return E_INVALIDARG;
|
|
}
|
|
|
|
if (GetOptionsList() == NULL) {
|
|
return E_FAIL;
|
|
}
|
|
|
|
*ppCandList = GetOptionsList()->GetOptionsCandidateList();
|
|
(*ppCandList)->AddRef();
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
/* G E T C A N D I D A T E L I S T */
|
|
/*------------------------------------------------------------------------------
|
|
|
|
Get candidate list
|
|
|
|
------------------------------------------------------------------------------*/
|
|
HRESULT CCandListMgr::GetCandidateList( ITfCandidateList **ppCandList )
|
|
{
|
|
if (ppCandList == NULL) {
|
|
return E_INVALIDARG;
|
|
}
|
|
|
|
if (GetCandList() == NULL) {
|
|
return E_FAIL;
|
|
}
|
|
|
|
*ppCandList = GetCandList()->GetCandidateList();
|
|
(*ppCandList)->AddRef();
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
/* C L E A R C A N D I D A T E L I S T */
|
|
/*------------------------------------------------------------------------------
|
|
|
|
Clear candidate list
|
|
|
|
------------------------------------------------------------------------------*/
|
|
HRESULT CCandListMgr::ClearCandiateList( void )
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
if ((m_pCandListObj == NULL) && (NULL == m_pOptionsListObj)) {
|
|
return S_OK;
|
|
}
|
|
|
|
// dispose candidate list object
|
|
|
|
if (m_pCandListObj) {
|
|
hr = m_pCandListObj->Uninitialize();
|
|
|
|
delete m_pCandListObj;
|
|
m_pCandListObj = NULL;
|
|
}
|
|
|
|
if ((S_OK == hr) && m_pOptionsListObj) {
|
|
// disponse options list object if any
|
|
hr = m_pOptionsListObj->Uninitialize();
|
|
|
|
delete m_pOptionsListObj;
|
|
m_pOptionsListObj = NULL;
|
|
}
|
|
|
|
if (hr == S_OK) {
|
|
// send notification
|
|
|
|
NotifyClearCandList();
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
/*============================================================================*/
|
|
/* */
|
|
/* C C A N D U I S T Y L E E V E N T S I N K */
|
|
/* */
|
|
/*============================================================================*/
|
|
|
|
/* C C A N D U I S T Y L E E V E N T S I N K */
|
|
/*------------------------------------------------------------------------------
|
|
|
|
Constructor of CCandListEventSink
|
|
|
|
------------------------------------------------------------------------------*/
|
|
CCandListEventSink::CCandListEventSink( void )
|
|
{
|
|
m_pCandListMgr = NULL;
|
|
}
|
|
|
|
|
|
/* ~ C C A N D U I S T Y L E E V E N T S I N K */
|
|
/*------------------------------------------------------------------------------
|
|
|
|
Destructor of CCandListEventSink
|
|
|
|
------------------------------------------------------------------------------*/
|
|
CCandListEventSink::~CCandListEventSink( void )
|
|
{
|
|
Assert( m_pCandListMgr == NULL );
|
|
if (m_pCandListMgr != NULL) {
|
|
DoneEventSink();
|
|
}
|
|
}
|
|
|
|
|
|
/* I N I T E V E N T S I N K */
|
|
/*------------------------------------------------------------------------------
|
|
|
|
Register candidate UI style event sink
|
|
|
|
------------------------------------------------------------------------------*/
|
|
HRESULT CCandListEventSink::InitEventSink( CCandListMgr *pCandListMgr )
|
|
{
|
|
Assert( pCandListMgr != NULL );
|
|
Assert( m_pCandListMgr == NULL );
|
|
|
|
if (pCandListMgr == NULL) {
|
|
return E_FAIL;
|
|
}
|
|
|
|
m_pCandListMgr = pCandListMgr;
|
|
return m_pCandListMgr->AdviseEventSink( this );
|
|
}
|
|
|
|
|
|
/* D O N E E V E N T S I N K */
|
|
/*------------------------------------------------------------------------------
|
|
|
|
Unregister candidate UI style event sink
|
|
|
|
------------------------------------------------------------------------------*/
|
|
HRESULT CCandListEventSink::DoneEventSink( void )
|
|
{
|
|
HRESULT hr;
|
|
|
|
Assert( m_pCandListMgr != NULL );
|
|
|
|
if (m_pCandListMgr == NULL) {
|
|
return E_FAIL;
|
|
}
|
|
|
|
hr = m_pCandListMgr->UnadviseEventSink( this );
|
|
m_pCandListMgr = NULL;
|
|
|
|
return hr;
|
|
}
|
|
|