#include "ph.h"
#include "RegistryKey.h"
#include "RegistryTree.h"

Include dependency graph for Completion.cpp:

Classes
class	CCompletionMatch

class	CCompletionList

Macros
#define	COMPLETION_BUFFER_SIZE 4096

Functions
BOOL	FillCompletion (const TCHAR *pszKey)

const TCHAR *	CompletionCallback (unsigned __int64 &rnIndex, const BOOL pblnForward, const TCHAR pszContext, const TCHAR *pszBegin)

void	InvalidateCompletion ()

Variables
CRegistryTree	Tree

BOOL	g_blnCompletionCycle = TRUE

class CCompletionList	g_Completion

Macro Definition Documentation

◆ COMPLETION_BUFFER_SIZE

#define COMPLETION_BUFFER_SIZE 4096

Definition at line 27 of file Completion.cpp.

Function Documentation

◆ CompletionCallback()

const TCHAR * CompletionCallback	(	unsigned __int64 &	rnIndex,
		const BOOL *	pblnForward,
		const TCHAR *	pszContext,
		const TCHAR *	pszBegin
	)

Definition at line 439 of file Completion.cpp.

{
  static TCHAR pszBuffer[COMPLETION_BUFFER_SIZE];
 
  // Find first non-white space in context
  while(*pszContext && _istspace(*pszContext))
    pszContext++;
 
  BOOL blnNewCompletion = TRUE;
  if (!g_Completion.IsNewCompletion(pszContext,pszBegin,blnNewCompletion))
  {
    ASSERT(FALSE);
    return NULL;
  }
 
  if (blnNewCompletion)
  {
    _tcsncpy(pszBuffer,pszBegin,COMPLETION_BUFFER_SIZE-1);
    pszBuffer[COMPLETION_BUFFER_SIZE-1] = 0;
    TCHAR *pszSeparator = pszBuffer; // set it to aby non null value
    if (_tcscmp(pszBuffer,_T("\\")))
    {
      pszSeparator = _tcsrchr(pszBuffer,_T('\\'));
      if (pszSeparator)
        *pszSeparator = 0;
    }
 
    if (!FillCompletion(pszSeparator?pszBuffer:NULL))
      return NULL;
  }
 
  unsigned __int64 nTotalItems = g_Completion.GetCount();
  if (nTotalItems == 0)
    return NULL;
 
  if (rnIndex >= nTotalItems)
    rnIndex = nTotalItems-1;
 
  if (pblnForward)
  {
    if (*pblnForward)
    {
      rnIndex++;
      if (rnIndex >= nTotalItems)
      {
        if (g_blnCompletionCycle)
          rnIndex = 0;
        else
          rnIndex--;
      }
    }
    else
    {
      if (rnIndex)
        rnIndex--;
      else if (g_blnCompletionCycle)
        rnIndex = nTotalItems-1;
    }
  }
  BOOL blnIsKey = FALSE;
  const TCHAR *pszName = g_Completion.Get(rnIndex,blnIsKey);
 
  ASSERT(pszName);
 
  _sntprintf(pszBuffer,COMPLETION_BUFFER_SIZE-1,_T("%s%s"),pszName,(blnIsKey?_T("\\"):_T("")));
  pszBuffer[COMPLETION_BUFFER_SIZE-1] = 0;
  return pszBuffer;
}

Referenced by co_IntCallSentMessageCallback(), co_IntSendMessageWithCallBack(), co_MsqSendMessageAsync(), and main().

◆ FillCompletion()

BOOL FillCompletion ( const TCHAR * pszKey )

Definition at line 332 of file Completion.cpp.

{
  g_Completion.DeleteList();
  LONG nError;
  CRegistryKey Key;
  TCHAR *pszSubkeyName = NULL;
  DWORD dwMaxSubkeyNameLength;
  TCHAR *pszValueName = NULL;
  DWORD dwMaxValueNameSize;
 
  if (!Tree.GetKey(pszKey?pszKey:_T("."),KEY_ENUMERATE_SUB_KEYS|KEY_QUERY_VALUE,Key))
    return FALSE;
 
  BOOL blnCompletionOnKeys = TRUE;
  BOOL blnCompletionOnValues = TRUE;
 
/*  if ((_tcsnicmp(pchContext,DIR_CMD,DIR_CMD_LENGTH) == 0)||
        (_tcsnicmp(pchContext,CD_CMD,CD_CMD_LENGTH) == 0)||
        (_tcsnicmp(pchContext,OWNER_CMD,OWNER_CMD_LENGTH) == 0)||
        (_tcsnicmp(pchContext,DACL_CMD,DACL_CMD_LENGTH) == 0)||
        (_tcsnicmp(pchContext,SACL_CMD,SACL_CMD_LENGTH) == 0))
    {
        blnCompletionOnValues = FALSE;
    }*/
//  else if (_tcsnicmp(pchContext,VALUE_CMD,VALUE_CMD_LENGTH) == 0)
//  {
//      blnCompletionOnKeys = FALSE;
//  }
 
  size_t nKeyNameSize = 0;
  if (pszKey)
  {
    nKeyNameSize = _tcslen(pszKey);
    if (_tcscmp(pszKey,_T("\\")))
      nKeyNameSize++;
  }
 
  if (blnCompletionOnKeys)
  {
    nError = Key.GetSubkeyNameMaxLength(dwMaxSubkeyNameLength);
    if (nError != ERROR_SUCCESS)
      return FALSE;
 
    pszSubkeyName = new (std::nothrow) TCHAR[nKeyNameSize+dwMaxSubkeyNameLength+1];
    if (!pszSubkeyName)
      goto Abort;
 
    if (pszKey)
      _stprintf(pszSubkeyName,_tcscmp(pszKey,_T("\\"))?_T("%s\\"):_T("%s"),pszKey);
 
    Key.InitSubkeyEnumeration(pszSubkeyName+nKeyNameSize,dwMaxSubkeyNameLength);
    while ((nError = Key.GetNextSubkeyName()) == ERROR_SUCCESS)
      if (!g_Completion.Add(pszSubkeyName,TRUE))
      {
        ASSERT(FALSE);
        goto Abort;
      }
    if ((nError != ERROR_SUCCESS)&&(nError != ERROR_NO_MORE_ITEMS))
    {
      ASSERT(FALSE);
      goto Abort;
    }
  }
 
  if (blnCompletionOnValues)
  {
    nError = Key.GetMaxValueNameLength(dwMaxValueNameSize);
    if (nError != ERROR_SUCCESS)
    {
      ASSERT(FALSE);
      goto Abort;
    }
 
    pszValueName = new (std::nothrow) TCHAR[nKeyNameSize+dwMaxValueNameSize+1];
    if (!pszValueName)
      goto Abort;
 
    if (pszKey)
      _stprintf(pszValueName,_tcscmp(pszKey,_T("\\"))?_T("%s\\"):_T("%s"),pszKey);
 
    Key.InitValueEnumeration(pszValueName+nKeyNameSize,dwMaxValueNameSize,NULL,0,NULL);
    while((nError = Key.GetNextValue()) == ERROR_SUCCESS)
      if (!g_Completion.Add(pszValueName,FALSE))
      {
        ASSERT(FALSE);
        goto Abort;
      }
    if ((nError != ERROR_SUCCESS)&&(nError != ERROR_NO_MORE_ITEMS))
    {
      ASSERT(FALSE);
      goto Abort;
    }
  }
 
  if (pszValueName)
    delete[] pszValueName;
  if (pszSubkeyName)
    delete[] pszSubkeyName;
  return TRUE;
Abort:
  if (pszValueName)
    delete[] pszValueName;
  if (pszSubkeyName)
    delete[] pszSubkeyName;
  return FALSE;
}