bool xdelta::XdeltaEncoder::EncodeDiffMemoryBlock( const dung::Byte_t* newBlock, size_t newSize, const dung::Byte_t* oldBlock, size_t oldSize, dung::Byte_t*& diffBlock, size_t& diffSize )
{
const size_t reservedSize = max( newSize, 1024 );
diffBlock = SCARAB_NEW dung::Byte_t[ reservedSize ];
diffSize = 0;
int flags = MakeFlags( m_config );
m_errorCode = xd3_encode_memory( newBlock, newSize, oldBlock, oldSize, diffBlock, &diffSize, reservedSize, flags );
return m_errorCode == 0;
}
CString CChatListDlg::MakeListHash (void)
{
CString strResult;
for (POSITION pos = m_pDoc->m_ChatList.GetHeadPosition(); pos; )
{
CChatSocket * p = m_pDoc->m_ChatList.GetNext (pos);
// skip ones not yet connected
if (p->m_bDeleteMe ||
p->m_iChatStatus != eChatConnected)
continue;
strResult += CFormat ("%ul,%s,%s,%s",
p->m_iChatID,
(LPCTSTR) p->m_strRemoteUserName,
(LPCTSTR) p->m_strGroup,
(LPCTSTR) MakeFlags (p));
}
return strResult;
} // end of CChatListDlg::MakeListHash
void CChatListDlg::LoadList (void)
{
int nItem;
// remember which chat IDs were previously selected
m_SelectedList.RemoveAll ();
// and focussed
m_FocussedList.RemoveAll ();
// do selected ones
for (nItem = -1;
(nItem = m_ctlChatList.GetNextItem(nItem, LVNI_SELECTED)) != -1;)
m_SelectedList.AddTail (m_ctlChatList.GetItemData (nItem));
// do focussed ones
for (nItem = -1;
(nItem = m_ctlChatList.GetNextItem(nItem, LVNI_FOCUSED)) != -1;)
m_FocussedList.AddTail (m_ctlChatList.GetItemData (nItem));
nItem = 0;
m_ctlChatList.DeleteAllItems ();
for (POSITION pos = m_pDoc->m_ChatList.GetHeadPosition(); pos; nItem++)
{
CChatSocket * p = m_pDoc->m_ChatList.GetNext (pos);
// skip ones not yet connected
if (p->m_bDeleteMe ||
p->m_iChatStatus != eChatConnected)
continue;
CString strFlags = MakeFlags (p);
m_ctlChatList.InsertItem (nItem, p->m_strRemoteUserName); // eColumnChatName
m_ctlChatList.SetItemText (nItem, eColumnGroup, p->m_strGroup);
m_ctlChatList.SetItemText (nItem, eColumnFromIP, inet_ntoa (p->m_ServerAddr.sin_addr));
m_ctlChatList.SetItemText (nItem, eColumnCallIP, p->m_strAllegedAddress);
m_ctlChatList.SetItemText (nItem, eColumnCallPort, CFormat ("%ld", p->m_iAllegedPort));
m_ctlChatList.SetItemText (nItem, eColumnFlags, strFlags);
m_ctlChatList.SetItemData (nItem, p->m_iChatID);
if (m_SelectedList.Find (p->m_iChatID))
m_ctlChatList.SetItemState (nItem, LVIS_SELECTED,
LVIS_SELECTED);
if (m_FocussedList.Find (p->m_iChatID))
m_ctlChatList.SetItemState (nItem, LVIS_FOCUSED,
LVIS_FOCUSED);
}
// we have redone the list, redo the hash
m_strListHash = MakeListHash ();
t_chat_sort_param sort_param (m_pDoc, m_last_col, m_reverse);
m_ctlChatList.SortItems (CompareFunc, (LPARAM) &sort_param);
// set the 1st item to be selected - we do this here because sorting the
// list means our first item is not necessarily the 1st item in the list
if (m_SelectedList.IsEmpty ())
m_ctlChatList.SetItemState (0, LVIS_SELECTED,
LVIS_SELECTED);
if (m_FocussedList.IsEmpty ())
m_ctlChatList.SetItemState (0, LVIS_FOCUSED ,
LVIS_FOCUSED );
} // end of CChatListDlg::LoadList
static int CALLBACK CompareFunc ( LPARAM lParam1,
LPARAM lParam2,
LPARAM lParamSort)
{
ASSERT (lParamSort != NULL);
t_chat_sort_param * psort_param = (t_chat_sort_param *) lParamSort;
CChatSocket * item1 = psort_param->pDoc->GetChatSocket (lParam1);
CChatSocket * item2 = psort_param->pDoc->GetChatSocket (lParam2);
if (item1 == NULL || item2 == NULL)
return 0;
int iResult;
switch (psort_param->sortkey) // which sort key
{
case eColumnChatName:
iResult = item1->m_strRemoteUserName.CompareNoCase (item2->m_strRemoteUserName);
break;
case eColumnGroup:
iResult = item1->m_strGroup.CompareNoCase (item2->m_strGroup);
break;
case eColumnFromIP:
if (item1->m_ServerAddr.sin_addr.S_un.S_addr < item2->m_ServerAddr.sin_addr.S_un.S_addr)
iResult = -1;
else
if (item1->m_ServerAddr.sin_addr.S_un.S_addr > item2->m_ServerAddr.sin_addr.S_un.S_addr)
iResult = 1;
else
iResult = 0;
break;
case eColumnCallIP:
iResult = item1->m_strAllegedAddress.CompareNoCase (item2->m_strAllegedAddress);
break;
case eColumnCallPort:
if (item1->m_iAllegedPort < item2->m_iAllegedPort)
iResult = -1;
else
if (item1->m_iAllegedPort > item2->m_iAllegedPort)
iResult = 1;
else
iResult = 0;
break;
case eColumnFlags:
iResult = MakeFlags (item1).CompareNoCase (MakeFlags (item2));
break;
default: return 0;
} // end of switch
// if reverse sort wanted, reverse sense of result
if (psort_param->reverse)
iResult *= -1;
return iResult;
} // end of CompareFunc
NS_IMETHODIMP
sbStringTransformImpl::NormalizeString(const nsAString & aCharset,
PRUint32 aTransformFlags,
const nsAString & aInput,
nsAString & _retval)
{
nsString finalStr;
nsString inStr(aInput);
if(inStr.IsEmpty()) {
_retval.Truncate();
return NS_OK;
}
nsTArray<WORD> excludeChars[NTYPES];
nsTArray<WORD> includeChars[NTYPES];
DWORD dwFlags = MakeFlags(aTransformFlags,
excludeChars,
includeChars);
if(aTransformFlags & sbIStringTransform::TRANSFORM_LOWERCASE ||
aTransformFlags & sbIStringTransform::TRANSFORM_UPPERCASE) {
WCHAR *wszJunk = {0};
int requiredBufferSize = ::LCMapStringW(LOCALE_USER_DEFAULT,
dwFlags,
inStr.BeginReading(),
inStr.Length(),
wszJunk,
0);
nsString bufferStr;
int convertedChars =
::LCMapStringW(LOCALE_USER_DEFAULT,
dwFlags,
inStr.BeginReading(),
inStr.Length(),
bufferStr.BeginWriting(requiredBufferSize),
requiredBufferSize);
NS_ENSURE_TRUE(convertedChars == requiredBufferSize,
NS_ERROR_CANNOT_CONVERT_DATA);
finalStr = bufferStr;
inStr = bufferStr;
}
if(aTransformFlags & sbIStringTransform::TRANSFORM_IGNORE_NONSPACE ||
aTransformFlags & sbIStringTransform::TRANSFORM_IGNORE_SYMBOLS ||
aTransformFlags & sbIStringTransform::TRANSFORM_IGNORE_NONALPHANUM ||
aTransformFlags & sbIStringTransform::TRANSFORM_IGNORE_NONALPHANUM_IGNORE_SPACE) {
PRBool leadingOnly = aTransformFlags &
sbIStringTransform::TRANSFORM_IGNORE_LEADING;
PRBool bypassTest = PR_FALSE;
LPWSTR wszJunk = {0};
int requiredBufferSize = ::FoldStringW(MAP_COMPOSITE,
inStr.BeginReading(),
inStr.Length(),
wszJunk,
0);
nsString bufferStr;
int convertedChars =
::FoldStringW(MAP_COMPOSITE,
inStr.BeginReading(),
inStr.Length(),
bufferStr.BeginWriting(requiredBufferSize),
requiredBufferSize);
NS_ENSURE_TRUE(convertedChars == requiredBufferSize,
NS_ERROR_CANNOT_CONVERT_DATA);
LPWORD ct1 = new WORD[requiredBufferSize];
BOOL success = GetStringTypeW(CT_CTYPE1,
(LPWSTR) bufferStr.BeginReading(),
bufferStr.Length(),
&ct1[0]);
if(!success) {
delete [] ct1;
_retval.Truncate();
return NS_ERROR_CANNOT_CONVERT_DATA;
}
LPWORD ct2 = new WORD[requiredBufferSize];
success = GetStringTypeW(CT_CTYPE2,
(LPWSTR) bufferStr.BeginReading(),
bufferStr.Length(),
&ct2[0]);
if(!success) {
delete [] ct1;
delete [] ct2;
_retval.Truncate();
return NS_ERROR_CANNOT_CONVERT_DATA;
}
LPWORD ct3 = new WORD[requiredBufferSize];
success = GetStringTypeW(CT_CTYPE3,
(LPWSTR) bufferStr.BeginReading(),
bufferStr.Length(),
&ct3[0]);
if(!success) {
delete [] ct1;
delete [] ct2;
delete [] ct3;
_retval.Truncate();
return NS_ERROR_CANNOT_CONVERT_DATA;
}
LPWORD charTypes[NTYPES] = {ct1, ct2, ct3};
for(int current = 0; current < requiredBufferSize; ++current) {
PRBool validChar = PR_TRUE;
PRInt32 skipChars = 0;
if (!bypassTest) {
if (aTransformFlags & sbIStringTransform::TRANSFORM_IGNORE_KEEPNUMBERSYMBOLS) {
PRInt32 numberLength;
SB_ExtractLeadingNumber(bufferStr.BeginReading() + current, NULL, NULL, &numberLength);
if (numberLength > 0) {
finalStr.Append(bufferStr.BeginReading() + current, numberLength);
current += numberLength-1;
if (leadingOnly) {
bypassTest = PR_TRUE;
}
continue;
}
}
// first check if the char is excluded by any of its type flags
for (int type = FIRSTTYPE; type <= LASTTYPE && validChar; type++) {
PRUint32 excludeCharsLength = excludeChars[type].Length();
for(PRUint32 invalid = 0; invalid < excludeCharsLength; ++invalid) {
if(excludeChars[type][invalid] & charTypes[type][current]) {
validChar = PR_FALSE;
break;
}
}
}
// next, check if the char is in the included chars arrays. if all
// arrays are empty, allow all chars instead of none
PRBool found = PR_FALSE;
PRBool testedAnything = PR_FALSE;
for (int type = FIRSTTYPE;
type <= LASTTYPE && validChar && !found;
type++) {
PRUint32 includeCharsLength = includeChars[type].Length();
for(PRUint32 valid = 0; valid < includeCharsLength; ++valid) {
testedAnything = PR_TRUE;
if (includeChars[type][valid] & charTypes[type][current]) {
found = PR_TRUE;
break;
}
}
}
if (testedAnything &&
!found) {
validChar = PR_FALSE;
}
}
if(validChar) {
if (leadingOnly) {
bypassTest = PR_TRUE;
}
finalStr.Append(bufferStr.CharAt(current));
}
current += skipChars;
}
delete [] ct1;
delete [] ct2;
delete [] ct3;
}
_retval = finalStr;
return NS_OK;
}
/*---------------------------------------------------------------------------
*
* convert buffer contents into an element
*/
bool
ConvertBufferToElement (BufferType *Buffer)
{
ElementType *Element;
Cardinal group;
Cardinal pin_n = 1;
bool hasParts = false, crooked = false;
int onsolder;
bool warned = false;
if (Buffer->Data->pcb == 0)
Buffer->Data->pcb = PCB;
Element = CreateNewElement (PCB->Data, &PCB->Font, NoFlags (),
NULL, NULL, NULL, PASTEBUFFER->X,
PASTEBUFFER->Y, 0, 100,
MakeFlags (SWAP_IDENT ? ONSOLDERFLAG : NOFLAG),
false);
if (!Element)
return (false);
VIA_LOOP (Buffer->Data);
{
char num[8];
if (via->Mask < via->Thickness)
via->Mask = via->Thickness + 2 * MASKFRAME;
if (via->Name)
CreateNewPin (Element, via->X, via->Y, via->Thickness,
via->Clearance, via->Mask, via->DrillingHole,
NULL, via->Name, MaskFlags (via->Flags,
VIAFLAG | NOCOPY_FLAGS |
SELECTEDFLAG | WARNFLAG));
else
{
sprintf (num, "%d", pin_n++);
CreateNewPin (Element, via->X, via->Y, via->Thickness,
via->Clearance, via->Mask, via->DrillingHole,
NULL, num, MaskFlags (via->Flags,
VIAFLAG | NOCOPY_FLAGS | SELECTEDFLAG
| WARNFLAG));
}
hasParts = true;
}
END_LOOP;
for (onsolder = 0; onsolder < 2; onsolder ++)
{
int silk_layer;
int onsolderflag;
if ((!onsolder) == (!SWAP_IDENT))
{
silk_layer = component_silk_layer;
onsolderflag = NOFLAG;
}
else
{
silk_layer = solder_silk_layer;
onsolderflag = ONSOLDERFLAG;
}
#define MAYBE_WARN() \
if (onsolder && !hasParts && !warned) \
{ \
warned = true; \
Message \
(_("Warning: All of the pads are on the opposite\n" \
"side from the component - that's probably not what\n" \
"you wanted\n")); \
} \
/* get the component-side SM pads */
group = GetLayerGroupNumberByNumber (silk_layer);
GROUP_LOOP (Buffer->Data, group);
{
char num[8];
LINE_LOOP (layer);
{
sprintf (num, "%d", pin_n++);
CreateNewPad (Element, line->Point1.X,
line->Point1.Y, line->Point2.X,
line->Point2.Y, line->Thickness,
line->Clearance,
line->Thickness + line->Clearance, NULL,
line->Number ? line->Number : num,
MakeFlags (onsolderflag));
MAYBE_WARN();
hasParts = true;
}
END_LOOP;
POLYGON_LOOP (layer);
{
Coord x1, y1, x2, y2, w, h, t;
if (! polygon_is_rectangle (polygon))
{
crooked = true;
continue;
}
w = polygon->Points[2].X - polygon->Points[0].X;
h = polygon->Points[1].Y - polygon->Points[0].Y;
t = (w < h) ? w : h;
x1 = polygon->Points[0].X + t/2;
y1 = polygon->Points[0].Y + t/2;
x2 = x1 + (w-t);
y2 = y1 + (h-t);
sprintf (num, "%d", pin_n++);
CreateNewPad (Element,
x1, y1, x2, y2, t,
2 * Settings.Keepaway,
t + Settings.Keepaway,
NULL, num,
MakeFlags (SQUAREFLAG | onsolderflag));
MAYBE_WARN();
hasParts = true;
}
END_LOOP;
}
END_LOOP;
}
/* now add the silkscreen. NOTE: elements must have pads or pins too */
LINE_LOOP (&Buffer->Data->SILKLAYER);
{
if (line->Number && !NAMEONPCB_NAME (Element))
NAMEONPCB_NAME (Element) = strdup (line->Number);
CreateNewLineInElement (Element, line->Point1.X,
line->Point1.Y, line->Point2.X,
line->Point2.Y, line->Thickness);
hasParts = true;
}
END_LOOP;
ARC_LOOP (&Buffer->Data->SILKLAYER);
{
CreateNewArcInElement (Element, arc->X, arc->Y, arc->Width,
arc->Height, arc->StartAngle, arc->Delta,
arc->Thickness);
hasParts = true;
}
END_LOOP;
if (!hasParts)
{
DestroyObject (PCB->Data, ELEMENT_TYPE, Element, Element, Element);
Message (_("There was nothing to convert!\n"
"Elements must have some silk, pads or pins.\n"));
return (false);
}
if (crooked)
Message (_("There were polygons that can't be made into pins!\n"
"So they were not included in the element\n"));
Element->MarkX = Buffer->X;
Element->MarkY = Buffer->Y;
if (SWAP_IDENT)
SET_FLAG (ONSOLDERFLAG, Element);
SetElementBoundingBox (PCB->Data, Element, &PCB->Font);
ClearBuffer (Buffer);
MoveObjectToBuffer (Buffer->Data, PCB->Data, ELEMENT_TYPE, Element, Element,
Element);
SetBufferBoundingBox (Buffer);
return (true);
}
Impl(FiberUID uid, FiberFlags flags, const FiberCallback & callback, size_t szStackCommit, size_t szStackReserve)
: Impl(uid, CreateFiberEx(szStackCommit, szStackReserve, MakeFlags(flags), (LPFIBER_START_ROUTINE)FiberDispatcher::Dispatch, new FiberDispatcher(callback)))
{
}
Impl(FiberUID uid, FiberFlags flags)
: Impl(uid, ConvertThreadToFiberEx(this, MakeFlags(flags)))
{
}
