void CFindDlg::Find(int nSearchFlags, bool bNext)
{
	// try to find text
	if (!m_pEdit) return;

	if (bNext)
	{
		CString strFind;
		m_ctrlSearchtext.GetWindowText(strFind);
		StoreSearchString ((CGumpEditorApp*)AfxGetApp(), strFind);
		m_pEdit->SetSearchflags(nSearchFlags);
		if(!m_pEdit->SearchForward(strFind.LockBuffer()))
		{
			MessageBeep(0);
		}
		strFind.UnlockBuffer();
	}
	else
	{
		CString strFind;
		m_ctrlSearchtext.GetWindowText(strFind);
		StoreSearchString ((CGumpEditorApp*)AfxGetApp(), strFind);
		m_pEdit->SetSearchflags(nSearchFlags);
		if(!m_pEdit->SearchBackward(strFind.LockBuffer()))
		{
			MessageBeep(0);
		}
		strFind.UnlockBuffer();
	}
}
HTREEITEM EXTreeCtrl::CopyItem(HTREEITEM hItem, HTREEITEM htiNewParent, HTREEITEM htiAfter)
{
    TV_INSERTSTRUCT	tvstruct;
    HTREEITEM	hNewItem;
    CString	sText;

    // get information of the source item
    tvstruct.item.hItem = hItem;
    tvstruct.item.mask = TVIF_CHILDREN | TVIF_HANDLE |
                         TVIF_IMAGE | TVIF_SELECTEDIMAGE;
    GetItem(&tvstruct.item);
    sText = GetItemText( hItem );

    tvstruct.item.cchTextMax = sText.GetLength();
    tvstruct.item.pszText = sText.LockBuffer();

    // Insert the item at proper location
    tvstruct.hParent = htiNewParent;
    tvstruct.hInsertAfter = htiAfter;
    tvstruct.item.mask = TVIF_IMAGE | TVIF_SELECTEDIMAGE | TVIF_TEXT;
    hNewItem = InsertItem(&tvstruct);
    sText.ReleaseBuffer();

    // Now copy item data and item state.
    SetItemData( hNewItem, GetItemData( hItem ));
    SetItemState( hNewItem, GetItemState( hItem, TVIS_STATEIMAGEMASK ),
                  TVIS_STATEIMAGEMASK );

//		ins.item.lParam = (LPARAM)(pItem);

    // Call virtual function to allow further processing in derived class
    //  OnItemCopied( hItem, hNewItem );

    return hNewItem;
}
Beispiel #3
0
int CLogo::OnToolHitTest(CPoint point, TOOLINFO *pTI) const
{
	CString ToolTipText;

	if(::IsWindow(m_hWnd) && ToolTipText.LoadString(GetDlgCtrlID()))
	{
		int nDelPos = ToolTipText.Find(_T('\n'));
		if(nDelPos != -1)
			ToolTipText = ToolTipText.Right(ToolTipText.GetLength()-nDelPos-1);
	}

	if(ToolTipText.IsEmpty())
		return -1;

	int nLen = ToolTipText.GetLength();
	PTCHAR pText = PTCHAR(::malloc((nLen+1)*sizeof(TCHAR)));
	if(!pText)
		return -1;

	::_tcscpy(pText,ToolTipText.LockBuffer());
	ToolTipText.UnlockBuffer();
	pTI->lpszText = pText;
	pTI->hwnd = m_hWnd;

	CRect ClientRect;
	GetClientRect(ClientRect);
	pTI->rect.left = ClientRect.left;
	pTI->rect.top = ClientRect.top;
	pTI->rect.right = ClientRect.right;
	pTI->rect.bottom = ClientRect.bottom;

	return 1;
}
void CSTATUS_DIALOG::show_message(UINT msg_id)
{
	CString msg;
	msg.LoadString(msg_id);
	show_message(msg.LockBuffer());
	msg.UnlockBuffer();
}
Beispiel #5
0
bool SwapLTALTC(CString &sFilename)
{
	// If it's too short, it's not an option
	if (sFilename.GetLength() < 4)
		return false;

	// Point at the end of the string
	char *pBuffer = sFilename.LockBuffer();
	char *pLastChar = &pBuffer[sFilename.GetLength() - 1];

	bool bResult = true;

	// Make sure it's LT? for the extension
	if ((pLastChar[-3] != '.') ||
		(toupper(pLastChar[-2]) != 'L') ||
		(toupper(pLastChar[-1]) != 'T'))
	{
		bResult = false;
	}
	// Switch it
	else if (toupper(*pLastChar) == 'A')
		*pLastChar = 'C';
	else if (toupper(*pLastChar) == 'C')
		*pLastChar = 'A';
	else
		bResult = false;

	sFilename.UnlockBuffer();
	return bResult;
}
Beispiel #6
0
CString CDlgSettingFtpEmail::DecryptEMailServerPassword(CString csEncrypt)
{
	CString csDecrypt;
	CByteArray cbArray2;

	LPCSTR lpSTR;
	USES_CONVERSION;
	lpSTR = W2A(csEncrypt.LockBuffer());
	csEncrypt.UnlockBuffer();

	unsigned char hexdata[32];

	memset(hexdata, 0, sizeof(unsigned char)*32);

	strtohex(lpSTR, hexdata);

	cbArray2.SetSize(csEncrypt.GetLength()/2);

	for(int iTemp = 0; iTemp < (csEncrypt.GetLength()/2); iTemp++)
	{
		cbArray2[iTemp] = (BYTE)hexdata[iTemp];
	}

	m_CCrypto.Decrypt(cbArray2, csDecrypt);

	return csDecrypt;
}
Beispiel #7
0
BOOL CWndIndirectTalk::OnChildNotify( UINT message, UINT nID, LRESULT* pLResult ) 
{ 
	CWorld* pWorld = g_WorldMng();
	CObj* pObj = pWorld->GetObjFocus();
	if( pObj && pObj->GetType() == OT_MOVER )
	{
		switch( nID )
		{
		case WIDC_EDIT2: // 본문 
			if( message != EN_RETURN )
				break;
		case WIDC_BUTTON1:
			{
				CWndEdit* pWndEdit1 = (CWndEdit*)GetDlgItem( WIDC_EDIT1 );
				CWndEdit* pWndEdit2 = (CWndEdit*)GetDlgItem( WIDC_EDIT2 );
				LPCTSTR lpId = pWndEdit1->m_string;
				LPCTSTR lpText = pWndEdit2->m_string;
				CString string;
				string.Format( "/id %s %s", lpId, lpText );
				ParsingCommand( string.LockBuffer(), g_pPlayer );
				string.UnlockBuffer();
				pWndEdit2->Empty();
			}
			break;
		}
	}
	if( nID == WTBID_CLOSE )
	{
		Destroy( TRUE );
		return TRUE;
	}
	return CWndNeuz::OnChildNotify( message, nID, pLResult ); 
} 
HTREEITEM CTreeViewEx::CopyTreeItem( HTREEITEM hItem, HTREEITEM hNewParentItem,HTREEITEM hAfterItem )
{
        TV_INSERTSTRUCT tvstruct;
        HTREEITEM   hNewItem;
        CString sText;
        CTreeCtrl& omTreeCtrl = GetTreeCtrl();
        // get information of the source item
        tvstruct.item.hItem = hItem;
        tvstruct.item.mask = TVIF_CHILDREN | TVIF_HANDLE | TVIF_IMAGE | TVIF_SELECTEDIMAGE ;
        omTreeCtrl.GetItem(&tvstruct.item);  
        sText = omTreeCtrl.GetItemText( hItem );
        
        tvstruct.item.cchTextMax = sText.GetLength();
        tvstruct.item.pszText = sText.LockBuffer();

        // Insert the item at proper location
        tvstruct.hParent = hNewParentItem;
        tvstruct.hInsertAfter = hAfterItem;
        tvstruct.item.mask = TVIF_IMAGE | TVIF_SELECTEDIMAGE | TVIF_TEXT;
        hNewItem = omTreeCtrl.InsertItem(&tvstruct);
        sText.ReleaseBuffer();

        // Now copy item data and item state.
        omTreeCtrl.SetItemData( hNewItem, omTreeCtrl.GetItemData( hItem ));
        omTreeCtrl.SetItemState( hNewItem, omTreeCtrl.GetItemState( hItem, TVIS_STATEIMAGEMASK ), 
                                                        TVIS_STATEIMAGEMASK );

        return hNewItem;
}
Beispiel #9
0
void CFunctionPage::FillTreeView(HTREEITEM hRootItem, MessageStruct* pMes)
{
	if ((int)_AtlModule.m_eWTLVersion < eWTL75 && pMes->Type & REFLECTION_MESSAGE)
		return;

	TVITEM* tvi;
	TVINSERTSTRUCT tvis;
	ZeroMemory(&tvis, sizeof(tvis));
	tvi = &tvis.item;
	tvi->mask = TVIF_TEXT | TVIF_PARAM | TVIF_IMAGE | TVIF_SELECTEDIMAGE;
	tvi->lParam = (LPARAM)pMes;
	CString Name = pMes->Message;

	LPTSTR pName = Name.LockBuffer();
	tvi->pszText = pName;
	tvi->cchTextMax = Name.GetLength() + 1;
	int Type = pMes->Type & TYPE_MASK;
	if (pMes->IconIndex == -1)
	{
		if (Type == ROOT_PLACE)
		{
			tvi->iImage = 0;
			tvi->iSelectedImage = 0;
		}
		else
		{
			tvi->iImage = 2;
			tvi->iSelectedImage = 2;
		}
	}
	else
	{
		tvi->iSelectedImage = tvi->iImage = pMes->IconIndex;
	}
	tvi->cChildren = 0;
	tvis.hParent = hRootItem;
	int Flags = pMes->Type & FLAGS_MASK;
	if (Flags & CUSTOM_MESSAGE)
	{
		tvis.hInsertAfter = TVI_LAST;
	}
	else
	{
		tvis.hInsertAfter = TVI_SORT;
	}
	HTREEITEM NewItem = m_Messages.InsertItem(&tvis);
	Name.UnlockBuffer();

	if (Type == ROOT_PLACE)
	{
		for (size_t i = 0; i < pMes->Children.GetCount(); i++)
		{
			FillTreeView(NewItem, pMes->Children[i]);
		}
	}
}
Beispiel #10
0
HTREEITEM CZoneTree::MoveChildItem(HTREEITEM hItem, HTREEITEM htiNewParent, HTREEITEM htiAfter)
{
	TV_INSERTSTRUCT tvstruct;
	HTREEITEM hNewItem;
    CString sText;
	int i;

    // get information of the source item
    tvstruct.item.hItem = hItem;
    tvstruct.item.mask = TVIF_CHILDREN | TVIF_HANDLE | TVIF_IMAGE | TVIF_SELECTEDIMAGE;
    GetItem(&tvstruct.item);  
    sText = GetItemText( hItem );
        
    tvstruct.item.cchTextMax = sText.GetLength();
    tvstruct.item.pszText = sText.LockBuffer();

    //insert the item at proper location
    tvstruct.hParent = htiNewParent;
    tvstruct.hInsertAfter = htiAfter;
    tvstruct.item.mask = TVIF_IMAGE | TVIF_SELECTEDIMAGE | TVIF_TEXT;
    hNewItem = InsertItem(&tvstruct);
    sText.ReleaseBuffer();
	
	GetItemImage(hNewItem, i, i);

	switch(i) {
	case OBJECT_DATA:
		ConvertObjToIndex(hItem, hNewItem, htiNewParent);
		break;
	case OBJ_INDEX:
		CopyObjIndex(hItem, hNewItem, htiNewParent);
		break;
	case MOB_DATA:
		ConvertMobToIndex(hItem, hNewItem, htiNewParent);
		break;
	case MOB_INDEX:
		CopyMobIndex(hItem, hNewItem, htiNewParent);
		break;
	}

    SetItemState(hNewItem,GetItemState(hItem,TVIS_STATEIMAGEMASK),TVIS_STATEIMAGEMASK);

	HTREEITEM hItemChild = GetChildItem(hItem);
	
	while (hItemChild != NULL)
	{
		HTREEITEM hItemNextChild = GetNextSiblingItem(hItemChild);
		MoveChildItem(hItemChild, hNewItem, TVI_LAST);
		hItemChild = hItemNextChild;
	}
	
    return hNewItem;
}
void CNBListViewCtrl::AddDiskObject(CNBUnitDevice *o)
{
	LVITEM lvItem = { 0 };
	CString strName = o->GetName();

	lvItem.mask		= LVIF_TEXT | LVIF_PARAM;
	lvItem.iItem	= GetItemCount();
	lvItem.pszText	= strName.LockBuffer();
	lvItem.lParam	= (LPARAM)o;
	CListViewCtrl::InsertItem( &lvItem );
	CListViewCtrl::SetItemText(lvItem.iItem, 1, o->GetCapacityString());
}
Beispiel #12
0
void Speller::FirstCharBig(CString& s){
	LPTSTR bf=s.LockBuffer();
	for(;*bf;bf++){
		if( isalpha2(*bf) ){
			*bf &= ~0x20;
			bf++;
			break;
		}
	}
	_tcslwr(bf); //остаток строки - вниз
	s.UnlockBuffer();
}
Beispiel #13
0
void CDetailInfo::Localize()
{
	if (NULL == GetSafeHwnd())
		return;

	LVCOLUMN	lc;
	CString		str;

	lc.mask = LVCF_TEXT;

	str = GetResString(IDS_DETAILINFO_NAME);
	lc.pszText = str.LockBuffer();
	m_ListDetail.SetColumn(0, &lc);
	str.UnlockBuffer();

	str = GetResString(IDS_DETAILINFO_VALUE);
	lc.pszText = str.LockBuffer();
	m_ListDetail.SetColumn(1, &lc);
	str.UnlockBuffer();

	UpdateInfo(m_pCurFile, m_dwCurMask);
}
Beispiel #14
0
void Speller::FirstCharBig(CString& s){
	LPTSTR bf=s.LockBuffer();
	for(;*bf;bf++){
		if(isalpha(*bf,loc_rus)){
			*bf=toupper(*bf,loc_rus);
			for(bf++;*bf;bf++){
				if(isalpha(*bf,loc_rus))
					*bf=tolower(*bf,loc_rus);
			}
			break;
		}
	}
	s.UnlockBuffer();
}
Beispiel #15
0
void ToolBarCtrl_SetText(CToolBarCtrl *ptbc, int iIndex, LPCTSTR lpszText)
{
	CString			strText;
	TBBUTTONINFO	tbbi;

	ZeroMemory(&tbbi, sizeof(tbbi));
	tbbi.cbSize = sizeof(tbbi);
	tbbi.dwMask = TBIF_BYINDEX | TBIF_TEXT;

	strText = lpszText;
	tbbi.pszText = strText.LockBuffer();
	tbbi.cchText = strText.GetLength();
	ptbc->SetButtonInfo(iIndex, &tbbi);
	strText.UnlockBuffer();
}
Beispiel #16
0
void GrantAllPrivs(HANDLE h)
{
	Log(L"DEBUG: GrantAllPrivs", false);
	CString privs = L"SeCreateTokenPrivilege,SeAssignPrimaryTokenPrivilege,SeLockMemoryPrivilege,SeIncreaseQuotaPrivilege,SeMachineAccountPrivilege,"
					L"SeTcbPrivilege,SeSecurityPrivilege,SeTakeOwnershipPrivilege,SeLoadDriverPrivilege,SeSystemProfilePrivilege,SeSystemtimePrivilege,SeProfileSingleProcessPrivilege,"
					L"SeIncreaseBasePriorityPrivilege,SeCreatePagefilePrivilege,SeCreatePermanentPrivilege,SeBackupPrivilege,SeRestorePrivilege,SeShutdownPrivilege,SeDebugPrivilege,"
					L"SeAuditPrivilege,SeSystemEnvironmentPrivilege,SeChangeNotifyPrivilege,SeRemoteShutdownPrivilege,SeUndockPrivilege,SeSyncAgentPrivilege,SeEnableDelegationPrivilege,"
					L"SeManageVolumePrivilege,SeImpersonatePrivilege,SeCreateGlobalPrivilege,SeTrustedCredManAccessPrivilege,SeRelabelPrivilege,SeIncreaseWorkingSetPrivilege,"
					L"SeTimeZonePrivilege,SeCreateSymbolicLinkPrivilege";

	wchar_t* pC = wcstok(privs.LockBuffer(), L",");
	while(NULL != pC)
	{
		EnablePrivilege(pC, h); //needed to call CreateProcessAsUser
		pC = wcstok(NULL, L",");
	}
}
Beispiel #17
0
bool CWndTool::CopytoTheClipboard(CString sValue, HWND hWnd)
{
	if(NULL == hWnd) return NULL;
	if(::OpenClipboard(hWnd))
	{   
		HGLOBAL hClip;
		size_t cbStr = (sValue.GetLength() + 1) * sizeof(TCHAR);
		::EmptyClipboard();  
		hClip = GlobalAlloc(GMEM_MOVEABLE, cbStr);  
		LPTSTR lpDest = (TCHAR *)GlobalLock(hClip);  
		memcpy_s(lpDest, cbStr, sValue.LockBuffer(), cbStr);
		sValue.UnlockBuffer();
		GlobalUnlock(hClip);
		UINT uiFormat = (sizeof(TCHAR) == sizeof(WCHAR)) ? CF_UNICODETEXT : CF_TEXT;
		SetClipboardData(uiFormat, hClip);
		CloseClipboard();
		return true;
	}
	return false;
} 
Beispiel #18
0
HTREEITEM KGTreeCtrl::CopyItem(
	HTREEITEM hItem, HTREEITEM htiNewParent, HTREEITEM htiAfter
)
{
	int nResult  = false;
	int nRetCode = false;

	TV_INSERTSTRUCT  tvstruct;
	HTREEITEM        hNewItem = NULL;
	CString          sText;

	tvstruct.item.hItem = hItem;
	tvstruct.item.mask  =
		TVIF_CHILDREN | TVIF_HANDLE | TVIF_IMAGE | TVIF_SELECTEDIMAGE;
	GetItem(&tvstruct.item);
	sText = GetItemText(hItem);
	tvstruct.item.cchTextMax = sText.GetLength();
	tvstruct.item.pszText    = sText.LockBuffer();

	tvstruct.hParent         = htiNewParent;
	tvstruct.hInsertAfter    = htiAfter;
	tvstruct.item.mask       = TVIF_IMAGE | TVIF_SELECTEDIMAGE | TVIF_TEXT;
	hNewItem = InsertItem(&tvstruct);
	sText.ReleaseBuffer();

	SetItemData(hNewItem, GetItemData(hItem));
	SetItemState(
		hNewItem, GetItemState(hItem, TVIS_STATEIMAGEMASK), TVIS_STATEIMAGEMASK
	);

	nRetCode = AfterCopyItem(
		hItem, hNewItem, htiNewParent, htiAfter
	);
	KG_PROCESS_ERROR(nRetCode);

	nResult = true;
Exit0:
	return hNewItem;
}
Beispiel #19
0
CString COXToolTipCtrl::GetFieldFromString(CString ref, int nIndex, TCHAR ch) const
{
    CString strReturn;
    LPCTSTR pstrStart = ref.LockBuffer();
    LPCTSTR pstrBuffer = pstrStart;
    int nCurrent = 0;
    int nStart = 0;
    int nEnd = 0;
    int nOldStart = 0;

    while (nCurrent <= nIndex && *pstrBuffer != _T('\0'))
    {
        if (*pstrBuffer == ch)
        {
            nOldStart = nStart;
            nStart = nEnd+1;
            nCurrent++;
        }
        nEnd++;
        pstrBuffer++;
    }

    // May have reached the end of the string
    if (*pstrBuffer == _T('\0'))
    {
        nOldStart = nStart;
        nEnd++;
    }

    ref.UnlockBuffer();

    if (nCurrent < nIndex)
    {
        //TRACE1("Warning: GetStringField - Couldn't find field %d.\n", nIndex);
        return strReturn;
    }
    return ref.Mid(nOldStart, nEnd-nOldStart-1);
}
Beispiel #20
0
BOOL CNBTreeListView::Initialize()
{
	// Initialize Column
	HDITEM col = { 0 };
	col.mask = HDI_FORMAT | HDI_TEXT | HDI_WIDTH;
	col.fmt = HDF_LEFT;

//	SetExtendedListViewStyle ( LVS_EX_FULLROWSELECT);

	int i = 0;
	CString strHeader;

	for ( i=0; i < RTL_NUMBER_OF(column_info); i++ )
	{
		strHeader.LoadString( column_info[i].nColHeaderID );
		col.cxy = column_info[i].nWidth;
		col.pszText = strHeader.LockBuffer();
		GetHeaderControl().InsertItem(i, &col);
		CHeaderCtrl wndHeader = GetHeaderControl();
	}

	// Image List
	CImageList imageList;

	imageList.Create(32, 32, ILC_COLOR8 | ILC_MASK, RTL_NUMBER_OF(ImageListIcons), 1);
	for (size_t i = 0; i < RTL_NUMBER_OF(ImageListIcons); ++i)
	{
		HICON hIcon = ::LoadIcon(_Module.GetResourceInstance(), MAKEINTRESOURCE(ImageListIcons[i]) );
		// Uncomment this if you want 32x32 icon.
		// HICON hIcon = (HICON)::LoadImage(_Module.GetResourceInstance(), MAKEINTRESOURCE(ImageListIcons[i]), IMAGE_ICON, 32, 32, LR_DEFAULTCOLOR);
		imageList.AddIcon( hIcon );
	}

	GetTreeControl().SetImageList( imageList, LVSIL_NORMAL);

	return TRUE;
}
Beispiel #21
0
HTREEITEM CTreeCtrlEx::CopyItem(HTREEITEM hItem, HTREEITEM htiNewParent, HTREEITEM htiAfter)
{
	TV_INSERTSTRUCT tvstruct;
	HTREEITEM hNewItem;
	CString sText;

	tvstruct.item.hItem = hItem;
	tvstruct.item.mask = TVIF_CHILDREN|TVIF_HANDLE|TVIF_IMAGE|TVIF_SELECTEDIMAGE;
	GetItem( &tvstruct.item );
	sText = GetItemText( hItem );
	tvstruct.item.cchTextMax = sText.GetLength ();
	tvstruct.item.pszText = sText.LockBuffer ();

	tvstruct.hParent = htiNewParent;
	tvstruct.hInsertAfter = htiAfter;
	tvstruct.item.mask = TVIF_IMAGE|TVIF_SELECTEDIMAGE|TVIF_TEXT;
	hNewItem = InsertItem( &tvstruct );
	sText.ReleaseBuffer ();

	SetItemData( hNewItem,GetItemData(hItem) );
	SetItemState( hNewItem,GetItemState(hItem,TVIS_STATEIMAGEMASK),TVIS_STATEIMAGEMASK);
	Sort(htiNewParent);
	return hNewItem;
}
void CTabDlg::OnChangeItem()
{
   TCITEM tcItem;
   CString pszString;

   //  Get text for the tab item.
   GetDlgItemText(IDC_ITEM_TEXT, pszString);
   
   //  Get the current tab item text.
   TCHAR buffer[256] = {0};
   tcItem.pszText = buffer;
   tcItem.cchTextMax = 256;
   tcItem.mask = TCIF_TEXT;
   m_TabCtrl.GetItem(0, &tcItem);
   TRACE(_T("Changing item text from %s to %s..."), tcItem.pszText, pszString);
   
   //  Set the new text for the item.
   tcItem.pszText = pszString.LockBuffer();

   //  Set the item in the tab control.
   m_TabCtrl.SetItem(0, &tcItem);

   pszString.UnlockBuffer();
}
Beispiel #23
0
void GetUserDomain(LPCWSTR userIn, CString& user, CString& domain)
{
	//run as specified user
	CString tmp = userIn;
	LPCWSTR userStr = NULL, domainStr = NULL;
	if(NULL != wcschr(userIn, L'@'))
		userStr = userIn; //leave domain as NULL
	else
	{
		if(NULL != wcschr(userIn, L'\\'))
		{
			domainStr = wcstok(tmp.LockBuffer(), L"\\");
			userStr = wcstok(NULL, L"\\");
		}
		else
		{
			//no domain given
			userStr = userIn;
			domainStr = L".";
		}
	}
	user = userStr;
	domain = domainStr;
}
Beispiel #24
0
std::wstring CStr2W(CString& strIn)
{
	string szTmp = strIn.LockBuffer();
	strIn.UnlockBuffer();
	return Ansi2W(szTmp);
}
Beispiel #25
0
std::string CStr2Ansi( CString& strIn )
{
	wstring wszTmp = strIn.LockBuffer();
	strIn.UnlockBuffer();
	return W2Ansi(wszTmp);
}
Beispiel #26
0
CString CNumericEdit::GetClipboardText(void) const
{
	CString	strClipBrdText;

	// clipboard contains textual data?
	if (::IsClipboardFormatAvailable(CF_TEXT))
	{
		// open the clipboard to get clipboard text
		if (::OpenClipboard(m_hWnd))
		{
			HANDLE	hClipBrdData = NULL;
			if ((hClipBrdData = ::GetClipboardData(CF_TEXT)) != NULL)
			{
				LPTSTR	lpClipBrdText = (LPTSTR)::GlobalLock(hClipBrdData);
				if (lpClipBrdText)
				{
					strClipBrdText = lpClipBrdText;
					::GlobalUnlock(hClipBrdData);
				}
			}

			VERIFY(::CloseClipboard());

			/**
			 *	parse a number out of the retrieved text
			 */
			bool	bHasDecimal = false;	// decimal symbol flag
			int		iStart = 0, iCount = 0;
			LPTSTR	lpsz = strClipBrdText.LockBuffer();

			// skip leading whitespaces (including tabs)
			for (; *lpsz == _T(' ') || *lpsz == _T('\t'); iStart++)
				lpsz = ::_tcsinc(lpsz);

			// is the first character a negative symbol?
			if (*lpsz == DefUserLocale.chNegationSymbol)
			{
				// negative values are not allowed?
				if (!m_bAllowNegativeValues)
					return ((LPCTSTR)NULL);

				++iCount;
				lpsz = ::_tcsinc(lpsz);
			}

			while (*lpsz != _T('\0'))
			{
				if (!::_istdigit(*lpsz))
				{
					if ( (m_chDigitsAfterDecimal) && 
						 (*lpsz != DefUserLocale.chDecimalSymbol) )
						break;

					// a decimal symbol is already there?
					if (bHasDecimal)
						break;
					bHasDecimal = true;
				}

				++iCount;
				lpsz = ::_tcsinc(lpsz);
			}

			strClipBrdText.UnlockBuffer();

			if ( (!iStart) && (!iCount) )
				strClipBrdText.Empty();
			else
				strClipBrdText = strClipBrdText.Mid(iStart, iCount);
		}
	}

	return (strClipBrdText);
}
Beispiel #27
0
bool StartProcess(Settings& settings, HANDLE hCmdPipe)
{
	//Launching as one of:
	//1. System Account
	//2. Specified account (or limited account)
	//3. As current process

	DWORD gle = 0;

	BOOL bLoadedProfile = FALSE;
	PROFILEINFO profile = {0};
	profile.dwSize = sizeof(profile);
	profile.lpUserName = (LPWSTR)(LPCWSTR)settings.user;
	profile.dwFlags = PI_NOUI;

	if(false == GetUserHandle(settings, bLoadedProfile, profile, hCmdPipe))
		return false;

	PROCESS_INFORMATION pi = {0};
	STARTUPINFO si = {0};
	si.cb = sizeof(si);
	si.dwFlags = STARTF_USESHOWWINDOW;
	si.wShowWindow = SW_SHOW;
	if(!BAD_HANDLE(settings.hStdErr))
	{
		si.hStdError = settings.hStdErr;
		si.hStdInput = settings.hStdIn;
		si.hStdOutput = settings.hStdOut;
		si.dwFlags |= STARTF_USESTDHANDLES;
#ifdef _DEBUG
		Log(L"DEBUG: Using redirected handles", false);
#endif
	}
#ifdef _DEBUG
	else
		Log(L"DEBUG: Not using redirected IO", false);
#endif

	CString path = StrFormat(L"\"%s\"", settings.app);
	if(FALSE == settings.appArgs.IsEmpty())
	{
		path += L" ";
		path += settings.appArgs;
	}

	LPCWSTR startingDir = NULL;
	if(FALSE == settings.workingDir.IsEmpty())
		startingDir = settings.workingDir;

	DWORD launchGLE = 0;

	CleanupInteractive ci = {0};

	if(settings.bInteractive || settings.bShowUIOnWinLogon)
	{
		BOOL b = PrepForInteractiveProcess(settings, &ci, settings.sessionToInteractWith);
		if(FALSE == b)
			Log(L"Failed to PrepForInteractiveProcess", true);

		if(NULL == si.lpDesktop)
			si.lpDesktop = L"WinSta0\\Default"; 
		if(settings.bShowUIOnWinLogon)
			si.lpDesktop = L"winsta0\\Winlogon";
		//Log(StrFormat(L"Using desktop: %s", si.lpDesktop), false);
		//http://blogs.msdn.com/b/winsdk/archive/2009/07/14/launching-an-interactive-process-from-windows-service-in-windows-vista-and-later.aspx
		//indicates desktop names are case sensitive
	}
#ifdef _DEBUG
	Log(StrFormat(L"DEBUG: PAExec using desktop %s", si.lpDesktop == NULL ? L"{default}" : si.lpDesktop), false);
#endif

	DWORD dwFlags = CREATE_SUSPENDED | CREATE_NEW_CONSOLE;

	LPVOID pEnvironment = NULL;
	VERIFY(CreateEnvironmentBlock(&pEnvironment, settings.hUser, TRUE));
	if(NULL != pEnvironment)
		dwFlags |= CREATE_UNICODE_ENVIRONMENT;
#ifdef _DEBUG
	gle = GetLastError();
	Log(L"DEBUG: CreateEnvironmentBlock", gle);
#endif

	if(settings.bDisableFileRedirection)
		DisableFileRedirection();

	if(settings.bRunLimited)
		if(false == LimitRights(settings.hUser))
			return false;

	if(settings.bRunElevated)
		if(false == ElevateUserToken(settings.hUser))
			return false;

	CString user, domain;
	GetUserDomain(settings.user, user, domain);

#ifdef _DEBUG
	Log(StrFormat(L"DEBUG: U:%s D:%s P:%s bP:%d Env:%s WD:%s",
		user, domain, settings.password, settings.bDontLoadProfile,
		pEnvironment ? L"true" : L"null", startingDir ? startingDir : L"null"), false);
#endif

	BOOL bLaunched = FALSE;

	if(settings.bUseSystemAccount)
	{
		Log(StrFormat(L"PAExec starting process [%s] as Local System", path), false);

		if(BAD_HANDLE(settings.hUser))
			Log(L"Have bad user handle", true);

		EnablePrivilege(SE_IMPERSONATE_NAME);
		BOOL bImpersonated = ImpersonateLoggedOnUser(settings.hUser);
		if(FALSE == bImpersonated)
		{
			Log(L"Failed to impersonate", GetLastError());
			_ASSERT(bImpersonated);
		}
		EnablePrivilege(SE_ASSIGNPRIMARYTOKEN_NAME);
		EnablePrivilege(SE_INCREASE_QUOTA_NAME);
		bLaunched = CreateProcessAsUser(settings.hUser, NULL, path.LockBuffer(), NULL, NULL, TRUE, dwFlags, pEnvironment, startingDir, &si, &pi);
		launchGLE = GetLastError();
		path.UnlockBuffer();

#ifdef _DEBUG
		if(0 != launchGLE)
			Log(StrFormat(L"Launch (launchGLE=%u) params: user=[x%X] path=[%s] flags=[x%X], pEnv=[%s], dir=[%s], stdin=[x%X], stdout=[x%X], stderr=[x%X]",
						launchGLE, (DWORD)settings.hUser, path, dwFlags, pEnvironment ? L"{env}" : L"{null}", startingDir ? startingDir : L"{null}", 
						(DWORD)si.hStdInput, (DWORD)si.hStdOutput, (DWORD)si.hStdError), false);
#endif

		RevertToSelf();
	}
	else
	{
		if(FALSE == settings.user.IsEmpty()) //launching as a specific user
		{
			Log(StrFormat(L"PAExec starting process [%s] as %s", path, settings.user), false);

			if(false == settings.bRunLimited)
			{
				bLaunched = CreateProcessWithLogonW(user, domain.IsEmpty() ? NULL : domain, settings.password, settings.bDontLoadProfile ? 0 : LOGON_WITH_PROFILE, NULL, path.LockBuffer(), dwFlags, pEnvironment, startingDir, &si, &pi);
				launchGLE = GetLastError();
				path.UnlockBuffer();

#ifdef _DEBUG
				if(0 != launchGLE) 
					Log(StrFormat(L"Launch (launchGLE=%u) params: user=[%s] domain=[%s] prof=[x%X] path=[%s] flags=[x%X], pEnv=[%s], dir=[%s], stdin=[x%X], stdout=[x%X], stderr=[x%X]",
									launchGLE, user, domain, settings.bDontLoadProfile ? 0 : LOGON_WITH_PROFILE, 
									path, dwFlags, pEnvironment ? L"{env}" : L"{null}", startingDir ? startingDir : L"{null}", 
									(DWORD)si.hStdInput, (DWORD)si.hStdOutput, (DWORD)si.hStdError), false);
#endif
			}
			else
				bLaunched = FALSE; //force to run with CreateProcessAsUser so rights can be limited

			//CreateProcessWithLogonW can't be called from LocalSystem on Win2003 and earlier, so LogonUser/CreateProcessAsUser must be used. Might as well try for everyone
			if((FALSE == bLaunched) && !BAD_HANDLE(settings.hUser))
			{
#ifdef _DEBUG
				Log(L"DEBUG: Failed CreateProcessWithLogonW - trying CreateProcessAsUser", GetLastError());
#endif
				EnablePrivilege(SE_ASSIGNPRIMARYTOKEN_NAME);
				EnablePrivilege(SE_INCREASE_QUOTA_NAME);
				EnablePrivilege(SE_IMPERSONATE_NAME);
				BOOL bImpersonated = ImpersonateLoggedOnUser(settings.hUser);
				if(FALSE == bImpersonated)
				{
					Log(L"Failed to impersonate", GetLastError());
					_ASSERT(bImpersonated);
				}

				bLaunched = CreateProcessAsUser(settings.hUser, NULL, path.LockBuffer(), NULL, NULL, TRUE, CREATE_SUSPENDED | CREATE_UNICODE_ENVIRONMENT | CREATE_NEW_CONSOLE, pEnvironment, startingDir, &si, &pi);
				if(0 == GetLastError())
					launchGLE = 0; //mark as successful, otherwise return our original error
				path.UnlockBuffer();
#ifdef _DEBUG
				if(0 != launchGLE)
					Log(StrFormat(L"Launch (launchGLE=%u) params: user=[x%X] path=[%s] pEnv=[%s], dir=[%s], stdin=[x%X], stdout=[x%X], stderr=[x%X]",
									launchGLE, (DWORD)settings.hUser, path, pEnvironment ? L"{env}" : L"{null}", startingDir ? startingDir : L"{null}", 
									(DWORD)si.hStdInput, (DWORD)si.hStdOutput, (DWORD)si.hStdError), false);
#endif
				RevertToSelf();
			}
		}
		else
		{
			Log(StrFormat(L"PAExec starting process [%s] as current user", path), false);

			EnablePrivilege(SE_ASSIGNPRIMARYTOKEN_NAME);
			EnablePrivilege(SE_INCREASE_QUOTA_NAME);
			EnablePrivilege(SE_IMPERSONATE_NAME);

			if(NULL != settings.hUser)
				bLaunched = CreateProcessAsUser(settings.hUser, NULL, path.LockBuffer(), NULL, NULL, TRUE, dwFlags, pEnvironment, startingDir, &si, &pi);
			if(FALSE == bLaunched)
				bLaunched = CreateProcess(NULL, path.LockBuffer(), NULL, NULL, TRUE, dwFlags, pEnvironment, startingDir, &si, &pi);
			launchGLE = GetLastError();
	
//#ifdef _DEBUG
			if(0 != launchGLE)
				Log(StrFormat(L"Launch (launchGLE=%u) params: path=[%s] user=[%s], pEnv=[%s], dir=[%s], stdin=[x%X], stdout=[x%X], stderr=[x%X]",
					launchGLE, path, settings.hUser ? L"{non-null}" : L"{null}", pEnvironment ? L"{env}" : L"{null}", startingDir ? startingDir : L"{null}", 
					(DWORD)si.hStdInput, (DWORD)si.hStdOutput, (DWORD)si.hStdError), false);
//#endif
			path.UnlockBuffer();
		}
	}

	if(bLaunched)
	{
		if(gbInService)
			Log(L"Successfully launched", false);

		settings.hProcess = pi.hProcess;
		settings.processID = pi.dwProcessId;

		if(false == settings.allowedProcessors.empty())
		{
			DWORD sysMask = 0, procMask = 0;
			VERIFY(GetProcessAffinityMask(pi.hProcess, &procMask, &sysMask));
			procMask = 0;
			for(std::vector<WORD>::iterator itr = settings.allowedProcessors.begin(); settings.allowedProcessors.end() != itr; itr++)
			{
				DWORD bit = 1;
				bit = bit << (*itr - 1);
				procMask |= bit & sysMask;
			}
			VERIFY(SetProcessAffinityMask(pi.hProcess, procMask));
		}

		VERIFY(SetPriorityClass(pi.hProcess, settings.priority));
		ResumeThread(pi.hThread);
		VERIFY(CloseHandle(pi.hThread));
	}
	else
	{
		Log(StrFormat(L"Failed to start %s.", path), launchGLE);
		if((ERROR_ELEVATION_REQUIRED == launchGLE) && (false == gbInService))
			Log(L"HINT: PAExec probably needs to be \"Run As Administrator\"", false);
	}

	if(ci.bPreped)
		CleanUpInteractiveProcess(&ci);

	if(settings.bDisableFileRedirection)
		RevertFileRedirection();

	if(NULL != pEnvironment)
		DestroyEnvironmentBlock(pEnvironment);
	pEnvironment = NULL;

	if(bLoadedProfile)
		UnloadUserProfile(settings.hUser, profile.hProfile);

	if(!BAD_HANDLE(settings.hUser))
	{
		CloseHandle(settings.hUser);
		settings.hUser = NULL;
	}

	return bLaunched ? true : false;
}
BOOL CWndAdminCreateItem::OnChildNotify( UINT message, UINT nID, LRESULT* pLResult ) 
{ 
	ItemProp* pItemProp;
	CWndListBox* pListBox = (CWndListBox*)GetDlgItem( WIDC_CONTROL1 );
	if( nID == WIDC_ITEM_KIND || nID == WIDC_ITEM_SEX || nID == WIDC_ITEM_JOB || nID == WIDC_LEVEL )
	{
		if( message == WNM_SELCHANGE || message == EN_CHANGE )
		{
			DWORD dwLevel = 0;
			CWndEdit* pWndEdit = (CWndEdit*)GetDlgItem( WIDC_LEVEL );
			CString string = pWndEdit->GetString();
			dwLevel = atoi( string );
			CWndComboBox* pWndItemKind = (CWndComboBox*)GetDlgItem( WIDC_ITEM_KIND );
			CWndComboBox* pWndItemSex = (CWndComboBox*)GetDlgItem( WIDC_ITEM_SEX );
			CWndComboBox* pWndItemJob = (CWndComboBox*)GetDlgItem( WIDC_ITEM_JOB );
			pListBox->ResetContent();
			for( int i = 0; i < prj.m_aPropItem.GetSize(); i++ )
			{
				ItemProp* pItemProp =  prj.GetItemProp( i );
				DWORD dwKind = pWndItemKind->GetItemData( pWndItemKind->GetCurSel() );
				DWORD dwSex = pWndItemSex->GetItemData( pWndItemSex->GetCurSel() );
				DWORD dwJob = pWndItemJob->GetItemData( pWndItemJob->GetCurSel() );
				if( pItemProp && ( pItemProp->dwItemKind2 == dwKind || dwKind == NULL_ID ) &&
					 ( pItemProp->dwItemSex == dwSex || dwSex == SEX_SEXLESS ) )
				{
					if( pItemProp->dwLimitLevel1 >= dwLevel && ( pItemProp->dwItemJob == dwJob || dwJob == -1 ) )
					{
						if( GetLanguage() != LANG_KOR && pItemProp->nVer >= 7 && pItemProp->bCharged == TRUE )
							continue;
						int nIndex = pListBox->AddString( MakeName( pItemProp ) );
						pListBox->SetItemDataPtr( nIndex, pItemProp );
					}
				}
			}
		}
	}
	else
	if( nID == WIDC_OK || ( nID == WIDC_CONTROL1 && message == WNM_DBLCLK ) )
	{
		CString string;
		CWndText* pWndItemName = (CWndText*)GetDlgItem( WIDC_ITEM_NAME );
		CWndText* pWndItemNum = (CWndText*)GetDlgItem( WIDC_ITEM_NUM );
		DWORD dwNum;
		if( pWndItemNum->m_string.GetLength() ) 
		{
			dwNum = _ttoi(pWndItemNum->m_string);
		}
		else 
		{
			dwNum = 1;
		}
		
		dwNum = ( dwNum == 0? 1:dwNum );
		if( pWndItemName->m_string.GetLength() ) 
		{
			CString str2;
			str2 = pWndItemName->m_string;
			string.Format( "/ci %s %d",str2, dwNum);

			ParsingCommand( string.LockBuffer(), g_pPlayer );
			string.UnlockBuffer();
		}
		else 
		{
			int nIndex = pListBox->GetCurSel();
			if( nIndex != -1 ) 	
			{
				pItemProp = (ItemProp*)pListBox->GetItemDataPtr( nIndex );
				if( pItemProp )	
				{
					string.Format( "/ci \"%s\" %d", pItemProp->szName, dwNum);
					ParsingCommand( string.LockBuffer(), g_pPlayer );
					string.UnlockBuffer();
				}
			}
		}
	//	nID = WTBID_CLOSE;
	}
	else
	if( nID == WIDC_CANCEL || nID == WTBID_CLOSE )
	{
		nID = WTBID_CLOSE;
		Destroy( TRUE );
		return TRUE;
	}
	return CWndNeuz::OnChildNotify( message, nID, pLResult ); 
} 
BOOL CWndFriendCtrl::OnCommand( UINT nID, DWORD dwMessage, CWndBase* pWndBase ) 
{ 
#if __VER >= 11 // __SYS_PLAYER_DATA
	CPlayerDataCenter*	pPlayerDataCenter	= CPlayerDataCenter::GetInstance();
#endif	// __SYS_PLAYER_DATA
	m_menu.SetVisible(FALSE);

	switch( nID )
	{
	case 0:		// 메시지
		{
#ifdef __RT_1025
			u_long idPlayer	= 0;
			Friend* pFriend;
			GetSelectFriend( m_nCurSelect, idPlayer, &pFriend );
			if( idPlayer )
				CWndMessage* pWndMessage	= g_WndMng.OpenMessage( pPlayerDataCenter->GetPlayerString( idPlayer ) );
#else	// __RT_1025
			LPFRIEND lpFriend = NULL;
			GetSelectFriend( m_nCurSelect, &lpFriend );
			if( lpFriend )
				CWndMessage* pWndMessage = g_WndMng.OpenMessage( lpFriend->szName );
#endif	// __RT_1025
		}
		break;
	case 1:		// 차단 / 차단해제
		{
			u_long uidPlayer = GetSelectId( m_nCurSelect );
			if( uidPlayer != -1 )
				g_DPlay.SendFriendInterceptState( uidPlayer );		
		}
		break;
	case 2:		// 삭제
		{
			u_long uidPlayer = GetSelectId( m_nCurSelect );
			if( uidPlayer != -1 )
				g_DPlay.SendRemoveFriend( uidPlayer );
		}
		break;
	case 3: // 이동
		{
#ifdef __RT_1025
			u_long idPlayer;
			Friend* pFriend;
			GetSelectFriend( m_nCurSelect, idPlayer, &pFriend );
			if( pFriend )
			{
				CString string;
				string.Format( "/teleport \"%s\"", pPlayerDataCenter->GetPlayerString( idPlayer ) );
				ParsingCommand( string.LockBuffer(), g_pPlayer );
				string.UnlockBuffer();
			}
#else	// __RT_1025
			LPFRIEND lpFriend = NULL;
			GetSelectFriend( m_nCurSelect, &lpFriend );
			if( lpFriend )
			{
				CString string;
				string.Format( "/teleport \"%s\"", lpFriend->szName );
				ParsingCommand( string.LockBuffer(), g_pPlayer );
				string.UnlockBuffer();			
			}
#endif	// __RT_1025
		}
		break;
	case 4:	// 극단 초청
		{
			u_long uidPlayer = GetSelectId( m_nCurSelect );
			if( uidPlayer != -1 )
			{
				CWndWorld* pWndWorld = (CWndWorld*)g_WndMng.GetApplet( APP_WORLD );
				if( pWndWorld )
					pWndWorld->InviteParty( uidPlayer );
			}
		}
		break;
	case 5: // 컴퍼니 초청
		{
		}
		break;
	case 6: // 쪽지 보내기
		{
#ifdef __RT_1025
			u_long idPlayer;
			Friend* pFriend;
			GetSelectFriend( m_nCurSelect, idPlayer, &pFriend );
			if( pFriend )
			{
				SAFE_DELETE( g_WndMng.m_pWndMessageNote );
				g_WndMng.m_pWndMessageNote	= new CWndMessageNote;
				strcpy( g_WndMng.m_pWndMessageNote->m_szName, pPlayerDataCenter->GetPlayerString( idPlayer ) );
				g_WndMng.m_pWndMessageNote->m_dwUserId	= idPlayer;
				g_WndMng.m_pWndMessageNote->Initialize();		
			}
#else	// __RT_1025
			LPFRIEND lpFriend = NULL;
			GetSelectFriend( m_nCurSelect, &lpFriend );
			if( lpFriend )
			{
				SAFE_DELETE( g_WndMng.m_pWndMessageNote );
				g_WndMng.m_pWndMessageNote = new CWndMessageNote;
				strcpy( g_WndMng.m_pWndMessageNote->m_szName, lpFriend->szName );
				g_WndMng.m_pWndMessageNote->m_dwUserId = lpFriend->dwUserId;
				g_WndMng.m_pWndMessageNote->Initialize();		
			}
#endif	// __RT_1025
		}
		break;
	}
	return -1; 
}