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); }