LONG CSerialEx::StopListener (DWORD dwTimeout)
{
// Check if the thread is running
if (m_hThread)
{
// Set the flag that the thread must be stopped
m_fStopping = true;
// Cancel the pending WaitEvent, but we won't do this using
// CancelIo. This would break Win95 compatibility and some
// USB serial dongles cannot handle CancelIo correctly. By
// setting the event mask again, the call will also be
// completed before the thread exits.
SetMask(GetEventMask());
// Wait until the watcher thread has stopped
::WaitForSingleObject(m_hThread,dwTimeout);
// The thread has stopped
m_fStopping = false;
// Close handle to the thread
::CloseHandle(m_hThread);
m_hThread = 0;
}
// Return the error
m_lLastError = ERROR_SUCCESS;
return m_lLastError;
}
/*
================
CSyntaxRichEditCtrl::Init
================
*/
void CSyntaxRichEditCtrl::Init(void)
{
// get the Rich Edit ITextDocument to use the wonky TOM interface
IRichEditOle *ire = GetIRichEditOle();
IUnknown *iu = (IUnknown *)ire;
if (iu == NULL || iu->QueryInterface(tom::IID_ITextDocument, (void **) &m_TextDoc) != S_OK) {
m_TextDoc = NULL;
}
InitFont();
InitSyntaxHighlighting();
SetEventMask(GetEventMask() | ENM_CHANGE | ENM_KEYEVENTS | ENM_MOUSEEVENTS | ENM_PROTECTED); // ENM_SCROLLEVENTS
EnableToolTips(TRUE);
// create auto complete list box
CRect rect(0, 0, AUTOCOMPLETE_WIDTH, AUTOCOMPLETE_HEIGHT);
autoCompleteListBox.Create(WS_DLGFRAME | WS_VISIBLE | WS_VSCROLL | LBS_SORT | LBS_NOTIFY, rect, this, IDC_LISTBOX_AUTOCOMPLETE);
autoCompleteListBox.SetFont(GetParent()->GetFont());
autoCompleteListBox.ShowWindow(FALSE);
// create function parameter tool tip
funcParmToolTip.Create(WS_VISIBLE | WS_BORDER, rect, this, IDC_EDITBOX_FUNCPARMS);
funcParmToolTip.SetFont(GetParent()->GetFont());
funcParmToolTip.ShowWindow(FALSE);
}
LONG CSerial::SetEventChar (BYTE bEventChar, bool fAdjustMask)
{
// Reset error state
m_lLastError = ERROR_SUCCESS;
// Check if the device is open
if (m_hFile == 0)
{
// Set the internal error code
m_lLastError = ERROR_INVALID_HANDLE;
// Issue an error and quit
_RPTF0(_CRT_WARN,"CSerial::SetEventChar - Device is not opened\n");
return m_lLastError;
}
// Obtain the DCB structure for the device
CDCB dcb;
if (!::GetCommState(m_hFile,&dcb))
{
// Obtain the error code
m_lLastError = ::GetLastError();
// Display a warning
_RPTF0(_CRT_WARN,"CSerial::SetEventChar - Unable to obtain DCB information\n");
return m_lLastError;
}
// Set the new event character
dcb.EvtChar = char(bEventChar);
// Adjust the event mask, to make sure the event will be received
if (fAdjustMask)
{
// Enable 'receive event character' event. Note that this
// will generate an EEventNone if there is an asynchronous
// WaitCommEvent pending.
SetMask(GetEventMask() | EEventRcvEv);
}
// Set the new DCB structure
if (!::SetCommState(m_hFile,&dcb))
{
// Obtain the error code
m_lLastError = ::GetLastError();
// Display a warning
_RPTF0(_CRT_WARN,"CSerial::SetEventChar - Unable to set DCB information\n");
return m_lLastError;
}
// Return successful
return m_lLastError;
}
void CUrlRichEditCtrl::PreSubclassWindow()
{
SetEventMask(GetEventMask() | ENM_CHANGE | ENM_DROPFILES | ENM_DRAGDROPDONE );
DragAcceptFiles();
// enable multilevel undo
SendMessage(EM_SETTEXTMODE, TM_MULTILEVELUNDO);
m_ncBorder.Initialize(GetSafeHwnd());
CRichEditBaseCtrl::PreSubclassWindow();
}
int CUrlRichEditCtrl::OnCreate(LPCREATESTRUCT lpCreateStruct)
{
if (CRichEditBaseCtrl::OnCreate(lpCreateStruct) == -1)
return -1;
SetEventMask(GetEventMask() | ENM_CHANGE | ENM_DROPFILES | ENM_DRAGDROPDONE | ENM_LINK);
DragAcceptFiles();
// enable multilevel undo
SendMessage(EM_SETTEXTMODE, TM_MULTILEVELUNDO);
m_ncBorder.Initialize(GetSafeHwnd());
return 0;
}
LRESULT CScriptEditView::OnCreate(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& )
{
LRESULT lRet = DefWindowProc( uMsg, wParam, lParam );
if( lRet != -1 )
{
m_font = AtlGetDefaultGuiFont();
SetFont( m_font );
SetOptions( ECOOP_OR, ECO_SELECTIONBAR );
SetTabStopWidth();
SetEventMask( GetEventMask() | ENM_CHANGE );
SetModify( FALSE );
}
return lRet;
}
void CRichEditCtrlX::SetSyntaxColoring(const LPCTSTR* ppszKeywords, LPCTSTR pszSeperators)
{
int i = 0;
while (ppszKeywords[i] != NULL)
m_astrKeywords.Add(ppszKeywords[i++]);
m_strSeperators = pszSeperators;
if (m_astrKeywords.GetCount() == 0)
m_strSeperators.Empty();
else
{
SetEventMask(GetEventMask() | ENM_CHANGE);
GetDefaultCharFormat(m_cfDef);
m_cfKeyword = m_cfDef;
m_cfKeyword.dwMask |= CFM_COLOR;
m_cfKeyword.dwEffects &= ~CFE_AUTOCOLOR;
m_cfKeyword.crTextColor = RGB(0,0,255);
ASSERT( GetTextMode() & TM_MULTILEVELUNDO );
}
}
void StreamSocket::DoWrite()
{
if (sendq.empty())
return;
if (!error.empty() || fd < 0)
{
ServerInstance->Logs->Log("SOCKET", LOG_DEBUG, "DoWrite on errored or closed socket");
return;
}
if (GetIOHook())
{
int rv = -1;
try
{
while (error.empty() && !sendq.empty())
{
if (sendq.size() > 1 && sendq[0].length() < 1024)
{
// Avoid multiple repeated SSL encryption invocations
// This adds a single copy of the queue, but avoids
// much more overhead in terms of system calls invoked
// by the IOHook.
//
// The length limit of 1024 is to prevent merging strings
// more than once when writes begin to block.
std::string tmp;
tmp.reserve(1280);
while (!sendq.empty() && tmp.length() < 1024)
{
tmp.append(sendq.front());
sendq.pop_front();
}
sendq.push_front(tmp);
}
std::string& front = sendq.front();
int itemlen = front.length();
{
rv = GetIOHook()->OnStreamSocketWrite(this, front);
if (rv > 0)
{
// consumed the entire string, and is ready for more
sendq_len -= itemlen;
sendq.pop_front();
}
else if (rv == 0)
{
// socket has blocked. Stop trying to send data.
// IOHook has requested unblock notification from the socketengine
// Since it is possible that a partial write took place, adjust sendq_len
sendq_len = sendq_len - itemlen + front.length();
return;
}
else
{
SetError("Write Error"); // will not overwrite a better error message
return;
}
}
}
}
catch (CoreException& modexcept)
{
ServerInstance->Logs->Log("SOCKET", LOG_DEBUG, "%s threw an exception: %s",
modexcept.GetSource().c_str(), modexcept.GetReason().c_str());
}
}
else
{
// don't even try if we are known to be blocking
if (GetEventMask() & FD_WRITE_WILL_BLOCK)
return;
// start out optimistic - we won't need to write any more
int eventChange = FD_WANT_EDGE_WRITE;
while (error.empty() && sendq_len && eventChange == FD_WANT_EDGE_WRITE)
{
// Prepare a writev() call to write all buffers efficiently
int bufcount = sendq.size();
// cap the number of buffers at MYIOV_MAX
if (bufcount > MYIOV_MAX)
{
bufcount = MYIOV_MAX;
}
int rv_max = 0;
int rv;
{
SocketEngine::IOVector iovecs[MYIOV_MAX];
for (int i = 0; i < bufcount; i++)
{
iovecs[i].iov_base = const_cast<char*>(sendq[i].data());
iovecs[i].iov_len = sendq[i].length();
rv_max += sendq[i].length();
}
rv = SocketEngine::WriteV(this, iovecs, bufcount);
}
if (rv == (int)sendq_len)
{
// it's our lucky day, everything got written out. Fast cleanup.
// This won't ever happen if the number of buffers got capped.
sendq_len = 0;
sendq.clear();
}
else if (rv > 0)
{
// Partial write. Clean out strings from the sendq
if (rv < rv_max)
{
// it's going to block now
eventChange = FD_WANT_FAST_WRITE | FD_WRITE_WILL_BLOCK;
}
sendq_len -= rv;
while (rv > 0 && !sendq.empty())
{
std::string& front = sendq.front();
if (front.length() <= (size_t)rv)
{
// this string got fully written out
rv -= front.length();
sendq.pop_front();
}
else
{
// stopped in the middle of this string
front.erase(0, rv);
rv = 0;
}
}
}
else if (rv == 0)
{
error = "Connection closed";
}
else if (SocketEngine::IgnoreError())
{
eventChange = FD_WANT_FAST_WRITE | FD_WRITE_WILL_BLOCK;
}
else if (errno == EINTR)
{
// restart interrupted syscall
errno = 0;
}
else
{
error = SocketEngine::LastError();
}
}
if (!error.empty())
{
// error - kill all events
SocketEngine::ChangeEventMask(this, FD_WANT_NO_READ | FD_WANT_NO_WRITE);
}
else
{
SocketEngine::ChangeEventMask(this, eventChange);
}
}
}
void CRichEditCtrlExtn::SetWindowText(LPCWSTR lpszString)
{
int iError;
CRichEditCtrl::SetWindowText(L"");
ShowWindow(SW_HIDE);
CString cs_formatstring(lpszString);
CString cs_plaintext = GetTextFormatting(cs_formatstring, iError);
if (iError != 0) {
// Had an error - show unchanged text
CRichEditCtrl::SetWindowText(cs_formatstring);
} else {
CRichEditCtrl::SetWindowText(cs_plaintext);
CHARFORMAT2 cf2;
// Now apply formating
if (!m_vFormat.empty()) {
std::sort(m_vFormat.begin(), m_vFormat.end(), iStartCompare);
std::vector<st_format>::const_iterator format_iter;
SecureZeroMemory(&cf2, sizeof(cf2));
cf2.cbSize = sizeof(cf2);
for (format_iter = m_vFormat.begin();
format_iter != m_vFormat.end(); format_iter++) {
SetSel(format_iter->iStart, format_iter->iEnd);
GetSelectionCharFormat(cf2);
if (format_iter->entrytype == Bold) {
cf2.dwMask |= CFM_BOLD;
cf2.dwEffects |= CFE_BOLD;
} else if (format_iter->entrytype == Italic) {
cf2.dwMask |= CFM_ITALIC;
cf2.dwEffects |= CFE_ITALIC;
} else if (format_iter->entrytype == Underline) {
cf2.dwMask |= CFM_UNDERLINE;
cf2.dwEffects |= CFE_UNDERLINE;
} else if (format_iter->entrytype == Colour) {
cf2.dwMask = CFM_COLOR;
cf2.crTextColor = format_iter->cr;
cf2.dwEffects &= ~CFE_AUTOCOLOR;
} else if (format_iter->entrytype == Size) {
cf2.dwMask = CFM_SIZE;
cf2.yHeight = (format_iter->iSize) * 20;
} else if (format_iter->entrytype == Name) {
cf2.dwMask = CFM_FACE;
#if (_MSC_VER >= 1400)
memcpy_s(cf2.szFaceName, sizeof(cf2.szFaceName),
format_iter->tcszFACENAME, sizeof(format_iter->tcszFACENAME));
#else
memcpy(cf2.szFaceName, Name_iter->tcszFACENAME,
sizeof(format_iter->tcszFACENAME));
#endif
}
SetSelectionCharFormat(cf2);
}
}
if (!m_vALink.empty()) {
SetEventMask(GetEventMask() | ENM_LINK);
std::vector<ALink>::const_iterator ALink_iter;
SecureZeroMemory(&cf2, sizeof(cf2));
cf2.cbSize = sizeof(cf2);
cf2.dwMask = CFM_LINK;
cf2.dwEffects = CFE_LINK;
for (ALink_iter = m_vALink.begin(); ALink_iter != m_vALink.end(); ALink_iter++) {
SetSel(ALink_iter->iStart, ALink_iter->iEnd);
SetSelectionCharFormat(cf2);
}
} else {
SetEventMask(GetEventMask() & ~ENM_LINK);
}
}
ShowWindow(SW_SHOW);
}
void CEmoticonRichEditCtrl::setUrlDetection(BOOL bUse)
{
SetEventMask(GetEventMask() | ENM_LINK );
SendMessage( EM_AUTOURLDETECT, bUse, NULL);
}