void nekoSystemButtonInstance::Update(float32 frameTime)
{
if(mBtState >= ESBS_ROLLOVER)
{
if(GetNekoNovel()->GetCurrentGame()->GetPickedInstance() != this)
mBtState = ESBS_NORMAL;
}
// 체크 버튼 처리..
if(mCheckButton && mBtState != ESBS_ROLLOVER)
{
switch(mBtType)
{
case ESBIT_WINDOWMODE:
if(!GetNekoNovel()->GetVideoDriver()->IsFullScreen() == mValue)
mBtState = ESBS_PRESSED;
else if(mBtState == ESBS_PRESSED)
mBtState = ESBS_NORMAL;
break;
case ESBIT_PRINT_DELAY:
if(GetNekoNovel()->GetCurrentGame()->GetEnvironment().mPrintDelay == mValue)
mBtState = ESBS_PRESSED;
else
mBtState = ESBS_NORMAL;
break;
case ESBIT_ALWAYS_TOP:
mBtState = ESBS_NORMAL;
if(GetNekoNovel()->IsAlwaysTop())
{
if(mArguments3 > 0)
mBtState = ESBS_PRESSED;
}
else
{
if(!mArguments3)
mBtState = ESBS_PRESSED;
}
break;
case ESBIT_SET_VARIABLE:
if(nekoVariable::If(EOT_EQUAL, mArguments1, mArguments2))
mBtState = ESBS_PRESSED;
else
mBtState = ESBS_NORMAL;
break;
}
}
if(!(GetFlags() & EBIF_SIZE_LOADED) && mTextures[ESBS_NORMAL] && mTextures[EBS_NORMAL]->GetState() == EHRS_LOADED)
{
if(!mBoundingBox.GetWidth())
mBoundingBox.SetWidth(mTextures[ESBS_NORMAL]->GetSize().x);
if(!mBoundingBox.GetHeight())
mBoundingBox.SetHeight(mTextures[ESBS_NORMAL]->GetSize().y);
AddFlags(EBIF_SIZE_LOADED);
}
// Autosize Property.
if((GetFlags() & EBIF_AUTO_SIZE_X) && mTextures[mBtState] && mTextures[mBtState]->GetState() == EHRS_LOADED)
{
mBoundingBox.SetWidth(mTextures[mBtState]->GetSize().x);
}
if((GetFlags() & EBIF_AUTO_SIZE_Y) && mTextures[mBtState] && mTextures[mBtState]->GetState() == EHRS_LOADED)
{
mBoundingBox.SetHeight(mTextures[mBtState]->GetSize().y);
}
}
void KSnapShot::Shot(KListView * list)
{
unsigned char * start = NULL;
MEMORY_BASIC_INFORMATION info;
KPEFile module;
void * lastmodule = NULL;
typedef enum { nMaxHeaps = 10 };
HANDLE ProcHeaps[nMaxHeaps];
int heaps = GetProcessHeaps(nMaxHeaps, ProcHeaps);
while ( VirtualQuery(start, & info, sizeof(info)) )
{
KRegion * pRegion = NULL;
// compute CRC for committed region
if (info.State == MEM_COMMIT)
{
pRegion = FindRegion(start, info.RegionSize);
if (pRegion)
{
pRegion->type = info.Type;
pRegion->lastcrc = pRegion->crc;
pRegion->crc = m_crc.Update(0, start, info.RegionSize);
pRegion->count ++;
}
}
if (list)
{
TCHAR temp[MAX_PATH];
const TCHAR * p ;
if ( pRegion && pRegion->count>=2 )
{
wsprintf(temp, "%04x", pRegion->lastcrc);
list->AddItem(0, temp, ( pRegion->lastcrc != pRegion->crc ) + 1);
}
else
list->AddItem(0, " ", 0);
if ( pRegion )
{
wsprintf(temp, "%04x", pRegion->crc);
list->AddItem(1, temp);
}
wsprintf(temp, "%08lx", info.BaseAddress); list->AddItem(2, temp);
wsprintf(temp, "%08lx", info.RegionSize); list->AddItem(3, temp);
switch (info.State)
{
case MEM_FREE: p = "F "; break;
case MEM_RESERVE: p = "R "; break;
case MEM_COMMIT: p = "C "; break;
default: p = "? ";
}
strcpy(temp, p);
if ( info.State != MEM_FREE)
{
switch (info.Type)
{
case MEM_IMAGE: p = "I "; break;
case MEM_MAPPED: p = "M "; break;
case MEM_PRIVATE: p = "P "; break;
default: p = "? ";
}
strcat(temp, p);
AddFlags(temp, info.AllocationProtect, Protections, sizeof(Protections)/sizeof(Protections[0]));
}
list->AddItem(4, temp);
/*
char t[MAX_PATH];
wsprintf(t, "%8lx ", info.AllocationBase);
strcat(temp, t);
if (info.State != MEM_RESERVE)
AddFlags(temp, info.Protect, Protections, sizeof(Protections)/sizeof(Protections[0]));
*/
if (info.State != MEM_FREE )
if ( GetModuleFileName((HINSTANCE) info.BaseAddress, temp, sizeof(temp)) )
{
if (lastmodule)
{
module.Unload();
lastmodule = NULL;
}
if ( module.Load(temp) )
lastmodule = info.BaseAddress;
// remove the directory path, keep only the filename
if ( strchr(temp, '\\') )
{
for (char *p = strchr(temp, '\\') + 1;
strchr(p, '\\');
p = strchr(p, '\\') + 1);
list->AddItem(5, p);
}
else
list->AddItem(5, temp);
}
else
{
const char * p = NULL;
if (lastmodule != NULL)
p = module.GetSectionName((unsigned) info.BaseAddress - (unsigned) lastmodule);
if (p == NULL)
for (int h=0; h<heaps; h++)
if ( info.BaseAddress == ProcHeaps[h] )
{
wsprintf(temp, "Heap %d", h+1);
p = temp;
break;
}
if (p == NULL)
if ( ( (unsigned) (& p) >= (unsigned) info.BaseAddress ) &&
( (unsigned) (& p) < (unsigned) info.BaseAddress + info.RegionSize ) )
p = "Stack";
if ( p )
list->AddItem(5, p);
}
}
start += info.RegionSize;
if (start == 0)
break;
}
if (lastmodule)
module.Unload();
}
//-----------------------------------------------------------------------------------------------
Variable::Variable(const Variable &obj)
:IValue(cmVAR)
{
Assign(obj);
AddFlags(IToken::flVOLATILE);
}
void CPsTree::PopupMenu()
{
HMENU hPopup;
MENUITEMINFO mii;
TVHITTESTINFO hti;
TVITEM tvi;
POINT pt;
int iItem, i;
// init popup menu
if (!(hPopup = CreatePopupMenu()))
return;
ZeroMemory(&mii, sizeof(MENUITEMINFO));
mii.cbSize = sizeof(mii);
mii.fMask = MIIM_STRING|MIIM_ID;
// get cursor postion
GetCursorPos(&pt);
hti.pt = pt;
ScreenToClient(_hWndTree, &hti.pt);
tvi.mask = TVIF_PARAM|TVIF_CHILDREN;
// find treeitem under cursor
TreeView_HitTest(_hWndTree, &hti);
if (hti.flags & (TVHT_ONITEM|TVHT_ONITEMRIGHT)) {
tvi.hItem = hti.hItem;
TreeView_GetItem(_hWndTree, &tvi);
if (!db_get_b(NULL, MODNAME, SET_PROPSHEET_READONLYLABEL, FALSE)) {
mii.dwTypeData = TranslateT("Rename Item");
mii.wID = 32001;
InsertMenuItem(hPopup, 0, FALSE, &mii);
}
// do not allow hiding groups
if (tvi.cChildren) {
mii.fMask |= MIIM_STATE;
mii.fState = MFS_DISABLED;
}
mii.dwTypeData = TranslateT("Hide Item");
mii.wID = 32000;
InsertMenuItem(hPopup, 0, FALSE, &mii);
}
else {
// add hidden items to menu
mii.wID = 0;
for (i = 0; i < _numItems; i++) {
if (!_pItems[i]->Hti()) {
mii.dwTypeData = _pItems[i]->Label();
mii.wID = 100 + i;
InsertMenuItem(hPopup, 0, FALSE, &mii);
}
}
// add headline
if (mii.wID > 0) {
mii.fMask |= MIIM_STATE;
mii.fState = MFS_DISABLED;
mii.dwTypeData = TranslateT("Show Items:");
mii.wID = 0;
InsertMenuItem(hPopup, 0, TRUE, &mii);
mii.fMask |= MIIM_FTYPE;
mii.fType = MFT_SEPARATOR;
InsertMenuItem(hPopup, 1, TRUE, &mii);
InsertMenuItem(hPopup, ++i, TRUE, &mii);
}
mii.fMask &= ~(MIIM_FTYPE|MIIM_STATE);
mii.dwTypeData = TranslateT("Reset to defaults");
mii.wID = 32004;
InsertMenuItem(hPopup, ++i, TRUE, &mii);
}
// show the popup menu
iItem = TrackPopupMenu(hPopup, TPM_RETURNCMD, pt.x, pt.y, 0, _hWndTree, NULL);
DestroyMenu(hPopup);
switch (iItem) {
// hide the item
case 32000:
HideItem(tvi.lParam);
break;
// rename the item
case 32001:
BeginLabelEdit(tvi.hItem);
break;
// reset current tree
case 32004:
DBResetState();
break;
// show a hidden item
default:
if ((iItem -= 100) >= 0 && ShowItem(iItem, NULL))
AddFlags(PSTVF_STATE_CHANGED|PSTVF_POS_CHANGED);
break;
}
}
/** \fn DVBSignalMonitor::UpdateValues()
* \brief Fills in frontend stats and emits status Qt signals.
*
* This is automatically called by MonitorLoop(), after Start()
* has been used to start the signal monitoring thread.
*/
void DVBSignalMonitor::UpdateValues(void)
{
if (!running || exit)
return;
if (streamHandlerStarted)
{
if (!streamHandler->IsRunning())
{
error = QObject::tr("Error: stream handler died");
update_done = true;
return;
}
EmitStatus();
if (IsAllGood())
SendMessageAllGood();
// TODO dtv signals...
update_done = true;
return;
}
AddFlags(kSigMon_WaitForSig);
DVBChannel *dvbchannel = GetDVBChannel();
if (!dvbchannel)
return;
// Handle retuning after rotor has turned
if (HasFlags(SignalMonitor::kDVBSigMon_WaitForPos))
{
if (dvbchannel->GetRotor())
{
if (!streamHandler->IsRetuneAllowed())
streamHandler->SetRetuneAllowed(true, this, dvbchannel);
streamHandler->RetuneMonitor();
}
else
RemoveFlags(SignalMonitor::kDVBSigMon_WaitForPos);
}
bool wasLocked = false, isLocked = false;
uint sig = 0, snr = 0, ber = 0, ublocks = 0;
// Get info from card
bool has_lock = dvbchannel->HasLock();
if (HasFlags(kSigMon_WaitForSig))
sig = (uint) (dvbchannel->GetSignalStrength() * 65535);
if (HasFlags(kDVBSigMon_WaitForSNR))
snr = (uint) (dvbchannel->GetSNR() * 65535);
if (HasFlags(kDVBSigMon_WaitForBER))
ber = (uint) dvbchannel->GetBitErrorRate();
if (HasFlags(kDVBSigMon_WaitForUB))
ublocks = (uint) dvbchannel->GetUncorrectedBlockCount();
has_lock |= streamHandler->IsRunning();
// Set SignalMonitorValues from info from card.
{
QMutexLocker locker(&statusLock);
// BER and UB are actually uint32 values, but we
// clamp them at 64K. This is because these values
// are acutally cumulative, but we don't try to
// normalize these to a time period.
wasLocked = signalLock.IsGood();
signalLock.SetValue((has_lock) ? 1 : 0);
isLocked = signalLock.IsGood();
if (HasFlags(kSigMon_WaitForSig))
signalStrength.SetValue(sig);
if (HasFlags(kDVBSigMon_WaitForSNR))
signalToNoise.SetValue(snr);
if (HasFlags(kDVBSigMon_WaitForBER))
bitErrorRate.SetValue(ber);
if (HasFlags(kDVBSigMon_WaitForUB))
uncorrectedBlocks.SetValue(ublocks);
}
// Debug output
if (wasLocked != isLocked)
{
VERBOSE(VB_CHANNEL, LOC + "UpdateValues -- Signal "
<<(isLocked ? "Locked" : "Lost"));
}
EmitStatus();
if (IsAllGood())
SendMessageAllGood();
// Start table monitoring if we are waiting on any table
// and we have a lock.
if (isLocked && GetStreamData() &&
(!HasFlags(kDVBSigMon_WaitForPos) || rotorPosition.IsGood()) &&
HasAnyFlag(kDTVSigMon_WaitForPAT | kDTVSigMon_WaitForPMT |
kDTVSigMon_WaitForMGT | kDTVSigMon_WaitForVCT |
kDTVSigMon_WaitForNIT | kDTVSigMon_WaitForSDT))
{
GetStreamData()->AddListeningPID(MPEG_PAT_PID);
streamHandler->AddListener(GetStreamData(), true, false);
streamHandlerStarted = true;
}
update_done = true;
}
JSBool
WrapObject(JSContext *cx, JSObject *parent, jsval *vp, XPCWrappedNative* wn)
{
NS_ASSERTION(XPCPerThreadData::IsMainThread(cx),
"Can't do this off the main thread!");
// Our argument should be a wrapped native object, but the caller may have
// passed it in as an optimization.
JSObject *wrappedObj;
if (JSVAL_IS_PRIMITIVE(*vp) ||
!(wrappedObj = JSVAL_TO_OBJECT(*vp)) ||
wrappedObj->getClass() == &XOWClass) {
return JS_TRUE;
}
if (!wn &&
!(wn = XPCWrappedNative::GetAndMorphWrappedNativeOfJSObject(cx, wrappedObj))) {
return JS_TRUE;
}
CheckWindow(wn);
// The parent must be the inner global object for its scope.
parent = JS_GetGlobalForObject(cx, parent);
OBJ_TO_INNER_OBJECT(cx, parent);
if (!parent) {
return JS_FALSE;
}
XPCWrappedNativeWithXOW *wnxow = nsnull;
if (wn->NeedsXOW()) {
JSObject *innerWrappedObj = wrappedObj;
OBJ_TO_INNER_OBJECT(cx, innerWrappedObj);
if (!innerWrappedObj) {
return JS_FALSE;
}
if (innerWrappedObj == parent) {
wnxow = static_cast<XPCWrappedNativeWithXOW *>(wn);
JSObject *xow = wnxow->GetXOW();
if (xow) {
*vp = OBJECT_TO_JSVAL(xow);
return JS_TRUE;
}
}
}
XPCWrappedNative *parentwn =
XPCWrappedNative::GetWrappedNativeOfJSObject(cx, parent);
XPCWrappedNativeScope *parentScope;
if (NS_LIKELY(parentwn)) {
parentScope = parentwn->GetScope();
} else {
parentScope = XPCWrappedNativeScope::FindInJSObjectScope(cx, parent);
}
JSObject *outerObj = nsnull;
WrappedNative2WrapperMap *map = parentScope->GetWrapperMap();
outerObj = map->Find(wrappedObj);
if (outerObj) {
NS_ASSERTION(outerObj->getClass() == &XOWClass,
"What crazy object are we getting here?");
*vp = OBJECT_TO_JSVAL(outerObj);
if (wnxow) {
// NB: wnxow->GetXOW() must have returned false.
SetFlags(cx, outerObj, AddFlags(GetFlags(cx, outerObj), FLAG_IS_CACHED));
wnxow->SetXOW(outerObj);
}
return JS_TRUE;
}
outerObj = JS_NewObjectWithGivenProto(cx, js::Jsvalify(&XOWClass), nsnull,
parent);
if (!outerObj) {
return JS_FALSE;
}
jsval flags = INT_TO_JSVAL(wnxow ? FLAG_IS_CACHED : 0);
if (!JS_SetReservedSlot(cx, outerObj, sWrappedObjSlot, *vp) ||
!JS_SetReservedSlot(cx, outerObj, sFlagsSlot, flags) ||
!JS_SetReservedSlot(cx, outerObj, XPC_XOW_ScopeSlot,
PRIVATE_TO_JSVAL(parentScope))) {
return JS_FALSE;
}
*vp = OBJECT_TO_JSVAL(outerObj);
map->Add(wn->GetScope()->GetWrapperMap(), wrappedObj, outerObj);
if(wnxow) {
wnxow->SetXOW(outerObj);
}
return JS_TRUE;
}
/** \fn FirewireSignalMonitor::UpdateValues(void)
* \brief Fills in frontend stats and emits status Qt signals.
*
* This function uses five ioctl's FE_READ_SNR, FE_READ_SIGNAL_STRENGTH
* FE_READ_BER, FE_READ_UNCORRECTED_BLOCKS, and FE_READ_STATUS to obtain
* statistics from the frontend.
*
* This is automatically called by MonitorLoop(), after Start()
* has been used to start the signal monitoring thread.
*/
void FirewireSignalMonitor::UpdateValues(void)
{
if (!running || exit)
return;
if (dtvMonitorRunning)
{
EmitStatus();
if (IsAllGood())
SendMessageAllGood();
// TODO dtv signals...
update_done = true;
return;
}
if (stb_needs_to_wait_for_power &&
(stb_wait_for_power_timer.elapsed() < (int)kPowerTimeout))
{
return;
}
stb_needs_to_wait_for_power = false;
FirewireChannel *fwchan = dynamic_cast<FirewireChannel*>(channel);
if (!fwchan)
return;
if (HasFlags(kFWSigMon_WaitForPower) && !HasFlags(kFWSigMon_PowerMatch))
{
bool retried = false;
while (true)
{
FirewireDevice::PowerState power = fwchan->GetPowerState();
if (FirewireDevice::kAVCPowerOn == power)
{
AddFlags(kFWSigMon_PowerSeen | kFWSigMon_PowerMatch);
}
else if (FirewireDevice::kAVCPowerOff == power)
{
AddFlags(kFWSigMon_PowerSeen);
fwchan->SetPowerState(true);
stb_wait_for_power_timer.start();
stb_needs_to_wait_for_power = true;
}
else
{
bool qfailed = (FirewireDevice::kAVCPowerQueryFailed == power);
if (qfailed && !retried)
{
retried = true;
continue;
}
LOG(VB_RECORD, LOG_WARNING,
"Can't determine if STB is power on, assuming it is...");
AddFlags(kFWSigMon_PowerSeen | kFWSigMon_PowerMatch);
}
break;
}
}
bool isLocked = !HasFlags(kFWSigMon_WaitForPower) ||
HasFlags(kFWSigMon_WaitForPower | kFWSigMon_PowerMatch);
if (isLocked && stb_needs_retune)
{
fwchan->Retune();
isLocked = stb_needs_retune = false;
}
SignalMonitor::UpdateValues();
{
QMutexLocker locker(&statusLock);
if (!scriptStatus.IsGood())
return;
}
// Set SignalMonitorValues from info from card.
{
QMutexLocker locker(&statusLock);
signalStrength.SetValue(isLocked ? 100 : 0);
signalLock.SetValue(isLocked ? 1 : 0);
}
EmitStatus();
if (IsAllGood())
SendMessageAllGood();
// Start table monitoring if we are waiting on any table
// and we have a lock.
if (isLocked && GetStreamData() &&
HasAnyFlag(kDTVSigMon_WaitForPAT | kDTVSigMon_WaitForPMT |
kDTVSigMon_WaitForMGT | kDTVSigMon_WaitForVCT |
kDTVSigMon_WaitForNIT | kDTVSigMon_WaitForSDT))
{
tableMonitorThread = new FirewireTableMonitorThread(this);
LOG(VB_CHANNEL, LOG_INFO, LOC + "UpdateValues() -- "
"Waiting for table monitor to start");
while (!dtvMonitorRunning)
usleep(5000);
LOG(VB_CHANNEL, LOG_INFO, LOC + "UpdateValues() -- "
"Table monitor started");
}
update_done = true;
}
void AuxEquipItem::BuildExtendedPacket(unsigned char *buffer, long &index)
{
AddFlags(ExtendedFlags, sizeof(ExtendedFlags), buffer, index);
if (ExtendedFlags[0] & 0x10) //ExtendedFlags[2] & 0x04
{
AddData(buffer, Data->ItemTemplateID, index);
}
if (ExtendedFlags[0] & 0x20) //ExtendedFlags[2] & 0x08
{
AddData(buffer, Data->StackCount, index);
}
if (ExtendedFlags[0] & 0x40) //ExtendedFlags[2] & 0x10
{
AddData(buffer, Data->Price, index);
}
if (ExtendedFlags[0] & 0x80) //ExtendedFlags[2] & 0x20
{
AddData(buffer, Data->AveCost, index);
}
if (ExtendedFlags[1] & 0x01) //ExtendedFlags[2] & 0x40
{
AddData(buffer, Data->Structure, index);
}
if (ExtendedFlags[1] & 0x02) //ExtendedFlags[2] & 0x80
{
AddData(buffer, Data->Quality, index);
}
if (ExtendedFlags[1] & 0x04) //ExtendedFlags[3] & 0x01
{
AddString(buffer, Data->InstanceInfo, index);
}
if (ExtendedFlags[1] & 0x08) //ExtendedFlags[3] & 0x02
{
AddString(buffer, Data->ActivatedEffectInstanceInfo, index);
}
if (ExtendedFlags[1] & 0x10) //ExtendedFlags[3] & 0x04
{
AddString(buffer, Data->EquipEffectInstanceInfo, index);
}
if (ExtendedFlags[1] & 0x20) //ExtendedFlags[3] & 0x08
{
AddString(buffer, Data->BuilderName, index);
}
if (ExtendedFlags[1] & 0x40) //ExtendedFlags[3] & 0x10
{
AddData(buffer, Data->ReadyTime, index);
}
if (ExtendedFlags[1] & 0x80) //ExtendedFlags[3] & 0x20
{
AddData(buffer, Data->TargetRange, index);
}
if (ExtendedFlags[2] & 0x01) //ExtendedFlags[3] & 0x40
{
AddData(buffer, Data->ItemState, index);
}
if (ExtendedFlags[2] & 0x02) //ExtendedFlags[3] & 0x80
{
Effect.BuildExtendedPacket(buffer, index);
}
else if (ExtendedFlags[3] & 0x80)
{
AddData(buffer, char(0x05), index);
}
}
void AuxShipInv::BuildExtendedPacket(unsigned char *buffer, long &index)
{
AddFlags(ExtendedFlags, sizeof(ExtendedFlags), buffer, index);
if (ExtendedFlags[0] & 0x10) //ExtendedFlags[1] & 0x80
{
AddData(buffer, Data->CargoSpace, index);
}
if (ExtendedFlags[0] & 0x20) //ExtendedFlags[2] & 0x01
{
AddString(buffer, Data->EquipMountModel, index);
}
if (ExtendedFlags[0] & 0x40) //ExtendedFlags[2] & 0x02
{
Mounts.BuildExtendedPacket(buffer, index);
}
else if (ExtendedFlags[2] & 0x02)
{
AddData(buffer, char(0x05), index);
}
if (ExtendedFlags[0] & 0x80) //ExtendedFlags[2] & 0x04
{
MountBones.BuildExtendedPacket(buffer, index);
}
else if (ExtendedFlags[2] & 0x04)
{
AddData(buffer, char(0x05), index);
}
if (ExtendedFlags[1] & 0x01) //ExtendedFlags[2] & 0x08
{
AddData(buffer, Data->FutureWeapons, index);
}
if (ExtendedFlags[1] & 0x02) //ExtendedFlags[2] & 0x10
{
AddData(buffer, Data->FutureDevices, index);
}
if (ExtendedFlags[1] & 0x04) //ExtendedFlags[2] & 0x20
{
CargoInv.BuildExtendedPacket(buffer, index);
}
else if (ExtendedFlags[2] & 0x20)
{
AddData(buffer, char(0x05), index);
}
if (ExtendedFlags[1] & 0x08) //ExtendedFlags[2] & 0x40
{
EquipInv.BuildExtendedPacket(buffer, index);
}
else if (ExtendedFlags[2] & 0x40)
{
AddData(buffer, char(0x05), index);
}
if (ExtendedFlags[1] & 0x10) //ExtendedFlags[2] & 0x80
{
AmmoInv.BuildExtendedPacket(buffer, index);
}
else if (ExtendedFlags[2] & 0x80)
{
AddData(buffer, char(0x05), index);
}
if (ExtendedFlags[1] & 0x20) //ExtendedFlags[3] & 0x01
{
HullInv.BuildExtendedPacket(buffer, index);
}
else if (ExtendedFlags[3] & 0x01)
{
AddData(buffer, char(0x05), index);
}
if (ExtendedFlags[1] & 0x40) //ExtendedFlags[3] & 0x02
{
TradeInv.BuildExtendedPacket(buffer, index);
}
else if (ExtendedFlags[3] & 0x02)
{
AddData(buffer, char(0x05), index);
}
}
int
FilterAddSummaryInfo(Document *doc, DStoreDocInfo *info)
{
char buf[CONN_BUFSIZE + 1];
TCHAR tbuf[TBUF_CHARS + 1];
Field *f;
snprintf(buf, sizeof(buf), GUID_FMT, info->guid);
utf8towcs(tbuf, buf, TBUF_CHARS);
doc->add(*Field::Keyword(_T("nmap.guid"), tbuf));
snprintf(buf, sizeof(buf), GUID_FMT, info->conversation);
utf8towcs(tbuf, buf, TBUF_CHARS);
doc->add(*Field::Keyword(_T("nmap.conversation"), tbuf));
if (info->type & STORE_DOCTYPE_FOLDER) {
utf8towcs(tbuf, "folder", TBUF_CHARS);
doc->add(*Field::Keyword(_T("nmap.type"), tbuf));
}
if (info->type & STORE_DOCTYPE_SHARED) {
utf8towcs(tbuf, "shared", TBUF_CHARS);
doc->add(*Field::Keyword(_T("nmap.type"), tbuf));
}
AddFlags(doc, info);
char sortstr[CONN_BUFSIZE];
char *type = NULL;
switch (info->type) {
BongoCalTime t;
case STORE_DOCTYPE_MAIL:
type = "mail";
t = BongoCalTimeNewFromUint64(info->data.mail.sent, FALSE, NULL);
BongoCalTimeToIcal(t, sortstr, sizeof(sortstr));
break;
case STORE_DOCTYPE_EVENT:
type = "event";
snprintf(sortstr, sizeof(sortstr), "%s%x",
info->data.event.start, info->guid);
break;
case STORE_DOCTYPE_AB:
type = "addressbook";
/* FIXME: use the contact name */
t = BongoCalTimeNewFromUint64(info->timeCreatedUTC, FALSE, NULL);
BongoCalTimeToIcal(t, sortstr, sizeof(sortstr));
break;
case STORE_DOCTYPE_CONVERSATION:
type = "conversation";
/* FIXME: use the contact name */
t = BongoCalTimeNewFromUint64(info->data.conversation.lastMessageDate, FALSE, NULL);
BongoCalTimeToIcal(t, sortstr, sizeof(sortstr));
break;
default:
break;
}
if (type != NULL) {
utf8towcs(tbuf, type, TBUF_CHARS);
doc->add(*Field::Keyword(_T("nmap.type"), tbuf));
utf8towcs(tbuf, sortstr, TBUF_CHARS);
doc->add(*Field::Keyword(_T("nmap.sort"), tbuf));
}
return 0;
}
void AuxStats::BuildExtendedPacket(unsigned char *buffer, long &index)
{
AddFlags(ExtendedFlags, sizeof(ExtendedFlags), buffer, index);
if (ExtendedFlags[0] & 0x10) //ExtendedFlags[2] & 0x08
{
AddData(buffer, Data->Defence, index);
}
if (ExtendedFlags[0] & 0x20) //ExtendedFlags[2] & 0x10
{
AddData(buffer, Data->MissleDefence, index);
}
if (ExtendedFlags[0] & 0x40) //ExtendedFlags[2] & 0x20
{
AddData(buffer, Data->Speed, index);
}
if (ExtendedFlags[0] & 0x80) //ExtendedFlags[2] & 0x40
{
AddData(buffer, Data->WarpSpeed, index);
}
if (ExtendedFlags[1] & 0x01) //ExtendedFlags[2] & 0x80
{
AddData(buffer, Data->WarpPowerLevel, index);
}
if (ExtendedFlags[1] & 0x02) //ExtendedFlags[3] & 0x01
{
AddData(buffer, Data->TurnRate, index);
}
if (ExtendedFlags[1] & 0x04) //ExtendedFlags[3] & 0x02
{
AddData(buffer, Data->ScanRange, index);
}
if (ExtendedFlags[1] & 0x08) //ExtendedFlags[3] & 0x04
{
AddData(buffer, Data->Visibility, index);
}
if (ExtendedFlags[1] & 0x10) //ExtendedFlags[3] & 0x08
{
AddData(buffer, Data->ResistImpact, index);
}
if (ExtendedFlags[1] & 0x20) //ExtendedFlags[3] & 0x10
{
AddData(buffer, Data->ResistExplosion, index);
}
if (ExtendedFlags[1] & 0x40) //ExtendedFlags[3] & 0x20
{
AddData(buffer, Data->ResistPlasma, index);
}
if (ExtendedFlags[1] & 0x80) //ExtendedFlags[3] & 0x40
{
AddData(buffer, Data->ResistEnergy, index);
}
if (ExtendedFlags[2] & 0x01) //ExtendedFlags[3] & 0x80
{
AddData(buffer, Data->ResistEMP, index);
}
if (ExtendedFlags[2] & 0x02) //ExtendedFlags[4] & 0x01
{
AddData(buffer, Data->ResistChemical, index);
}
if (ExtendedFlags[2] & 0x04) //ExtendedFlags[4] & 0x02
{
AddData(buffer, Data->ResistPsionic, index);
}
}
SNORTRULEHDR void CPcreOption::FromPattern(const CDllString &strPat)
{
CDllString strTemp = strPat;
FormatPattern(strTemp);
if (HasFlags(CRuleOption::HASNOT))
{
return;
}
STRING str = strTemp.Data();
STRING_ITER iBeg = str.begin(), iEnd = str.end();
STRING strSuffix;
if (*iBeg == '/')
{
++iBeg;
for(--iEnd; *iEnd != '/' && iEnd != str.begin(); --iEnd);
if (iBeg >= iEnd)
{
TTHROW(TI_INVALIDDATA);
}
strSuffix = STRING(iEnd + 1, str.end());
}
m_strPcre.Assign(STRING(iBeg, iEnd).c_str());
for(STRING_ITER j = strSuffix.begin(); j != strSuffix.end(); ++j)
{
switch (*j)
{
case 'A':
AddFlags(PF_A);
if (m_strPcre[0] != '^')
{
m_strPcre.Insert(0, '^');
}
continue;
case 'R':
AddFlags(PF_R);
continue;
case 'i':
AddFlags(PF_i);
continue;
case 's':
AddFlags(PF_s);
continue;
case 'm':
AddFlags(PF_m);
continue;
case 'x':
AddFlags(PF_x);
continue;
case 'E':
AddFlags(PF_E);
continue;
case 'G':
AddFlags(PF_G);
continue;
case 'U':
AddFlags(PF_U);
continue;
case 'B':
AddFlags(PF_B);
continue;
case 'P':
AddFlags(PF_P);
continue;
case 'H':
AddFlags(PF_H);
continue;
case 'M':
AddFlags(PF_M);
continue;
case 'C':
AddFlags(PF_C);
continue;
case 'O':
AddFlags(PF_O);
continue;
case 'I':
AddFlags(PF_I);
continue;
case 'D':
AddFlags(PF_D);
continue;
case 'K':
AddFlags(PF_K);
continue;
case 'S':
AddFlags(PF_S);
continue;
case 'Y':
AddFlags(PF_Y);
continue;
default:
TTHROW(TI_INVALIDDATA);
}
}
if (m_strPcre[0] == '^')
{
AddFlags(PF_A);
}
}
/*---------------------------------------------------------------------------
*
* break buffer element into pieces
*/
bool
SmashBufferElement (BufferType *Buffer)
{
ElementType *element;
Cardinal group;
LayerType *clayer, *slayer;
if (Buffer->Data->ElementN != 1)
{
Message (_("Error! Buffer doesn't contain a single element\n"));
return (false);
}
/*
* At this point the buffer should contain just a single element.
* Now we detach the single element from the buffer and then clear the
* buffer, ready to receive the smashed elements. As a result of detaching
* it the single element is orphaned from the buffer and thus will not be
* free()'d by FreeDataMemory (called via ClearBuffer). This leaves it
* around for us to smash bits off it. It then becomes our responsibility,
* however, to free the single element when we're finished with it.
*/
element = Buffer->Data->Element->data;
Buffer->Data->Element = NULL;
Buffer->Data->ElementN = 0;
ClearBuffer (Buffer);
ELEMENTLINE_LOOP (element);
{
CreateNewLineOnLayer (&Buffer->Data->SILKLAYER,
line->Point1.X, line->Point1.Y,
line->Point2.X, line->Point2.Y,
line->Thickness, 0, NoFlags ());
if (line)
line->Number = STRDUP (NAMEONPCB_NAME (element));
}
END_LOOP;
ARC_LOOP (element);
{
CreateNewArcOnLayer (&Buffer->Data->SILKLAYER,
arc->X, arc->Y, arc->Width, arc->Height, arc->StartAngle,
arc->Delta, arc->Thickness, 0, NoFlags ());
}
END_LOOP;
PIN_LOOP (element);
{
FlagType f = NoFlags ();
AddFlags (f, VIAFLAG);
if (TEST_FLAG (HOLEFLAG, pin))
AddFlags (f, HOLEFLAG);
CreateNewVia (Buffer->Data, pin->X, pin->Y,
pin->Thickness, pin->Clearance, pin->Mask,
pin->DrillingHole, pin->Number, f);
}
END_LOOP;
group =
GetLayerGroupNumberByNumber (SWAP_IDENT ? solder_silk_layer :
component_silk_layer);
clayer = &Buffer->Data->Layer[PCB->LayerGroups.Entries[group][0]];
group =
GetLayerGroupNumberByNumber (SWAP_IDENT ? component_silk_layer :
solder_silk_layer);
slayer = &Buffer->Data->Layer[PCB->LayerGroups.Entries[group][0]];
PAD_LOOP (element);
{
LineType *line;
line = CreateNewLineOnLayer (TEST_FLAG (ONSOLDERFLAG, pad) ? slayer : clayer,
pad->Point1.X, pad->Point1.Y,
pad->Point2.X, pad->Point2.Y,
pad->Thickness, pad->Clearance, NoFlags ());
if (line)
line->Number = STRDUP (pad->Number);
}
END_LOOP;
FreeElementMemory (element);
g_slice_free (ElementType, element);
return (true);
}
bool AuxPlayerIndex::BuildPacket(unsigned char *buffer, long &index)
{
if (!(Flags[0] & 0x02))
{
return false;
}
index = 0;
AddData(buffer, u32(0), index);
AddData(buffer, short(0), index);
AddData(buffer, char(1), index);
AddFlags(Flags, sizeof(Flags), buffer, index);
if (Flags[0] & 0x10) //ExtendedFlags[2] & 0x40
{
AddData(buffer, Data.Credits, index);
}
if (Flags[0] & 0x20) //ExtendedFlags[2] & 0x80
{
AddData(buffer, Data.XPDebt, index);
}
if (Flags[0] & 0x40) //ExtendedFlags[3] & 0x01
{
SecureInv.BuildPacket(buffer, index);
}
if (Flags[0] & 0x80) //ExtendedFlags[3] & 0x02
{
VendorInv.BuildPacket(buffer, index);
}
if (Flags[1] & 0x01) //ExtendedFlags[3] & 0x04
{
RewardInv.BuildPacket(buffer, index);
}
if (Flags[1] & 0x02) //ExtendedFlags[3] & 0x08
{
OverflowInv.BuildPacket(buffer, index);
}
if (Flags[1] & 0x04) //ExtendedFlags[3] & 0x10
{
RPGInfo.BuildPacket(buffer, index);
}
if (Flags[1] & 0x08) //ExtendedFlags[3] & 0x20
{
AddString(buffer, Data.CommunityEventFlags, index);
}
if (Flags[1] & 0x10) //ExtendedFlags[3] & 0x40
{
AddData(buffer,Data.MusicID,index);
}
if (Flags[1] & 0x20) //ExtendedFlags[3] & 0x80
{
Missions.BuildPacket(buffer, index);
}
if (Flags[1] & 0x40) //ExtendedFlags[4] & 0x01
{
Reputation.BuildPacket(buffer, index);
}
if (Flags[1] & 0x80) //ExtendedFlags[4] & 0x02
{
AddData(buffer, Data.PIPAvatarID, index);
}
if (Flags[2] & 0x01) //ExtendedFlags[4] & 0x04
{
AddString(buffer, Data.RegistrationStarbase, index);
}
if (Flags[2] & 0x02) //ExtendedFlags[4] & 0x08
{
AddString(buffer, Data.RegistrationStarbaseSector, index);
}
if (Flags[2] & 0x04) //ExtendedFlags[4] & 0x10
{
AddString(buffer, Data.SectorName, index);
}
if (Flags[2] & 0x08) //ExtendedFlags[4] & 0x20
{
AddData(buffer, Data.SectorNum, index);
}
if (Flags[2] & 0x10) //ExtendedFlags[4] & 0x40
{
AddData(buffer, Data.ClientSendUITriggers ,index);
}
if (Flags[2] & 0x20) //ExtendedFlags[4] & 0x80
{
GroupInfo.BuildPacket(buffer, index);
}
*((short *) &buffer[4]) = short(index - 6);
memset(Flags,0,sizeof(Flags));
return true;
}
bool AuxMobIndex::BuildDiffPacket(unsigned char *buffer, long &index)
{
//The only thing that can change on a mob is its Shields/Hull
//Along with all of the Interup members and the EngineState
//Possibly the IS flags
//The rest of the data is send with the Create/Click packets and WILL NOT CHANGE
index = 0;
if (!GameID || !(Flags[0] & 0x02))
{
return false;
}
AddData(buffer, GameID, index);
AddData(buffer, short(0), index);
AddData(buffer, char(1), index);
AddFlags(Flags, sizeof(Flags), buffer, index);
if (Flags[1] & 0x04) //ExtendedFlags[8] & 0x10
{
Shield.BuildPacket(buffer, index);
}
if (Flags[1] & 0x10) //ExtendedFlags[8] & 0x40
{
AddData(buffer,Data.HullPoints,index);
}
if (Flags[3] & 0x01) //ExtendedFlags[10] & 0x04
{
AddData(buffer,char(Data.IsCountermeasureActive),index);
}
if (Flags[3] & 0x02) //ExtendedFlags[10] & 0x08
{
AddData(buffer,char(Data.IsIncapacitated),index);
}
if (Flags[3] & 0x04) //ExtendedFlags[10] & 0x10
{
AddData(buffer,char(Data.IsOrganic),index);
}
if (Flags[3] & 0x08) //ExtendedFlags[10] & 0x20
{
AddData(buffer,char(Data.IsInPVP),index);
}
if (Flags[3] & 0x20) //ExtendedFlags[10] & 0x80
{
AddData(buffer,char(Data.IsRescueBeaconActive),index);
}
if (Flags[4] & 0x10) //ExtendedFlags[11] & 0x40
{
AddData(buffer,Data.GlobalWarpState,index);
}
if (Flags[5] & 0x02) //ExtendedFlags[12] & 0x08
{
QuadrantDamage.BuildPacket(buffer, index);
}
if (Flags[5] & 0x04) //ExtendedFlags[12] & 0x10
{
DamageSpot.BuildPacket(buffer, index);
}
if (Flags[5] & 0x08) //ExtendedFlags[12] & 0x20
{
DamageLine.BuildPacket(buffer, index);
}
if (Flags[5] & 0x10) //ExtendedFlags[12] & 0x40
{
DamageBlotch.BuildPacket(buffer, index);
}
if (Flags[6] & 0x04) //ExtendedFlags[13] & 0x10
{
AddData(buffer,Data.EngineThrustState,index);
}
if (Flags[7] & 0x02) //ExtendedFlags[14] & 0x08
{
AddString(buffer,Data.InterruptibleAbilityName,index);
}
if (Flags[7] & 0x04) //ExtendedFlags[14] & 0x10
{
AddData(buffer,Data.InterruptState,index);
}
if (Flags[7] & 0x08) //ExtendedFlags[14] & 0x20
{
AddData(buffer,Data.InterruptibleActivationTime,index);
}
if (Flags[7] & 0x10) //ExtendedFlags[14] & 0x40
{
AddData(buffer,Data.InterruptProgress,index);
}
*((short *) &buffer[4]) = short(index - 6);
memset(Flags,0,sizeof(Flags));
return true;
}
void FEElement::Select(const Vec2& pos)
{
AddFlags(EFEFlag_Selected);
}
