void VboManager::FreeObject(VboObject* object) { if (object) { VboBufRec& data = vBuffers[object->GetBufferId()]; PLuint len = data.vObjects.size(); for(PLuint i = 0; i<len; i++) { if (data.vObjects[i] == object) { if (i == len-1) { data.iUsedSpace -= data.vObjects.back()->GetDataLength(); data.vObjects.pop_back(); delete object; } else { data.vObjects[i] = 0; data.uFragmBlock++; data.uFragmLost += object->GetDataLength(); delete object; Compact(); } break; } } } }
NS_IMETHODIMP nsFolderCompactState::CompactFolders(nsIArray *aArrayOfFoldersToCompact, nsIArray *aOfflineFolderArray, nsIUrlListener *aUrlListener, nsIMsgWindow *aMsgWindow) { m_window = aMsgWindow; m_listener = aUrlListener; if (aArrayOfFoldersToCompact) m_folderArray = aArrayOfFoldersToCompact; else if (aOfflineFolderArray) { m_folderArray = aOfflineFolderArray; m_compactingOfflineFolders = true; aOfflineFolderArray = nsnull; } if (!m_folderArray) return NS_OK; m_compactAll = true; m_compactOfflineAlso = aOfflineFolderArray != nsnull; if (m_compactOfflineAlso) m_offlineFolderArray = aOfflineFolderArray; m_folderIndex = 0; nsresult rv = NS_OK; nsCOMPtr<nsIMsgFolder> firstFolder = do_QueryElementAt(m_folderArray, m_folderIndex, &rv); if (NS_SUCCEEDED(rv) && firstFolder) Compact(firstFolder, m_compactingOfflineFolders, aUrlListener, aMsgWindow); //start with first folder from here. return rv; }
void UndoRedoMgr::StartBlock(char* name){ URAction* pAction = new URAction(); pAction->lpszDescription = name; //-----[ are there too many Undo's ? ]--------------------------[ if(NumUndoGroups>=MAX_NUM_UNDOREDO_OPERATIONS){ DeleteOneUndoChain(UndoGroups[0]); // the oldest "undo" chain } //--------------------------------------------------------------/ //-----[ try to compact ]-------------[ if(!NumActionsStarted){ Compact(); } //------------------------------------/ //--------[ link in linked-list ]------------[ if(NumActionsStarted){ pAction->pPrevAction = pLastActionStarted; pLastActionStarted->pNextAction = pAction; } pLastActionStarted = pAction; NumActionsStarted++; //-------------------------------------------/ //------[ send the "action created" msg ]---------------------[ // this could change "NumActionsStarted"!! pAction->OnCreate(); //------------------------------------------------------------/ }
nsresult nsFolderCompactState::CompactNextFolder() { m_folderIndex++; PRUint32 cnt = 0; nsresult rv = m_folderArray->GetLength(&cnt); NS_ENSURE_SUCCESS(rv, rv); // m_folderIndex might be > cnt if we compact offline stores, // and get back here from OnStopRunningUrl. if (m_folderIndex >= cnt) { if (!m_compactOfflineAlso || m_compactingOfflineFolders) { CompactCompleted(NS_OK); return rv; } m_compactingOfflineFolders = true; nsCOMPtr<nsIMsgFolder> folder = do_QueryElementAt(m_folderArray, m_folderIndex-1, &rv); if (NS_SUCCEEDED(rv) && folder) return folder->CompactAllOfflineStores(this, m_window, m_offlineFolderArray); else NS_WARNING("couldn't get folder to compact offline stores"); } nsCOMPtr<nsIMsgFolder> folder = do_QueryElementAt(m_folderArray, m_folderIndex, &rv); if (NS_SUCCEEDED(rv) && folder) rv = Compact(folder, m_compactingOfflineFolders, m_listener, m_window); else CompactCompleted(rv); return rv; }
bool CudaAllocBuckets::Free(void* p) { AddressMap::iterator it = _addressMap.find(p); if(it == _addressMap.end()) { // If the pointer was not found in the address map, cudaFree it anyways // but return false. if(p) cudaFree(p); return false; } // Because we're freeing a page, it had better not be in the priority queue. MemList::iterator memIt = it->second; assert(memIt->priority == _priorityMap.end()); // Always free allocations larger than the largest bucket if(NumBuckets == memIt->bucket) FreeNode(memIt); else { it->second->priority = _priorityMap.insert( std::make_pair(_counter++ - memIt->bucket, memIt)); // Freed nodes are moved to the front, committed nodes are moved to the // end. MemList& list = _memLists[memIt->bucket]; list.splice(list.begin(), list, memIt); _committed -= BucketSizes[memIt->bucket]; } Compact(0); return true; }
void SourceBuffer::Complete(nsresult aStatus) { MutexAutoLock lock(mMutex); if (MOZ_UNLIKELY(mStatus)) { MOZ_ASSERT_UNREACHABLE("Called Complete more than once"); return; } if (MOZ_UNLIKELY(NS_SUCCEEDED(aStatus) && IsEmpty())) { // It's illegal to succeed without writing anything. aStatus = NS_ERROR_FAILURE; } mStatus = Some(aStatus); // Resume any waiting consumers now that we're complete. ResumeWaitingConsumers(); // If we still have active consumers, just return. if (mConsumerCount > 0) { return; } // Attempt to compact our buffer down to a single chunk. Compact(); }
void cStringList::FromPopen(cString cmdline) { ClearAll(); FILE* fileptr=NULL; fileptr=popen(cmdline, "r" ); if(fileptr!=NULL) { FromFile(fileptr); pclose(fileptr); } Compact(); if(Length()>1) if((*this)[-1]==(*this)[-2]) { (*this)[-1]=""; } Compact(); }
void FGXImage::Rotate(FGXImage &undo, int angle) { undo.width = width; undo.height = height; undo.res = res; undo.unit = unit; float a = angle * 3.14159 / 180; CPoint center(width / 2, height / 2); for (int i = 0; i < layers.size(); i++) { CPoint oldCenter = layers[i]->GetPosition().CenterPoint() - center; CPoint newCenter(center.x + oldCenter.x * cos(a) - oldCenter.y * sin(a), center.y + oldCenter.x * sin(a) + oldCenter.y * cos(a)); layers[i]->Rotate(*undo.AddLayer(), angle); CRect rect = layers[i]->GetPosition(); rect.OffsetRect(newCenter - rect.CenterPoint()); layers[i]->MoveTo(rect.left, rect.top); } Compact(); width = height = 0; RevealAll(); }
BOOL SimpleStorage::Create( LPCSTR fileName, LPCSTR groupName, UINT32 fileType, UINT8* data, UINT32 dataLength ) { BOOL retVal = FALSE; SIMPLESTORAGE_FILE_HEADER header; INT32 available; if(fileName == NULL) return FALSE; if(!Initialize()) return FALSE; if(!SeekToFile(fileName, groupName, header, TRUE)) { Compact(); if(!SeekToFile(fileName, groupName, header, TRUE)) return FALSE; } available = s_pCurrentStream->Length - s_pCurrentStream->CurrentIndex; if(available < (INT32)dataLength) { Compact(); if(!SeekToFile(fileName, groupName, header, TRUE)) return FALSE; } header.Signature = SIMPLESTORAGE_FILE_SIGNATURE; hal_strcpy_s(header.FileName, ARRAYSIZE(header.FileName), fileName); if(groupName == NULL) { header.Group[0] = 0; } else { hal_strcpy_s(header.Group, ARRAYSIZE(header.Group), groupName); } header.FileType = fileType; header.Length = dataLength; header.Attrib = 0xFFFFFFFF; // uninitialized flash header.HeaderCRC = SUPPORT_ComputeCRC(&header, sizeof(header) - sizeof(header.HeaderCRC) - sizeof(header.Attrib), 0); if(s_pCurrentStream->Write((UINT8*)&header, sizeof(header))) { retVal = s_pCurrentStream->Write((UINT8*)data, dataLength); } return retVal; }
bool CGLRTable::BuildGLRTable(Stroka /*GrammarFileName*/) { YASSERT(m_pWorkGrammar != NULL); // initializing m_RuleInfos, in order to be independent // from class CWorkGrammar while parsing BuildRuleInfo(m_pWorkGrammar->m_EncodedRules, m_RuleInfos); // creating a canonical LR(0) index item set collection CLRCollectionSet S; S.Compute(m_pWorkGrammar); yvector< yvector<CSLRCell> > table(S.m_ItemSets.size()); // building @table by CLRCollectionSet for (size_t i = 0; i < S.m_ItemSets.size(); ++i) { const yset<CLRItem>& items = S.m_ItemSets[i]; // tableLine is a new table line in SLR table, which should be added to the end of the table // we resize it to contain all symbols yvector<CSLRCell>& tableLine = table[i]; tableLine.resize(m_pWorkGrammar->m_UniqueGrammarItems.size()); // initializing shift actions and reduce actions for (yset<CLRItem>::const_iterator it = items.begin(); it != items.end(); ++it) { // "For terminal a, if A->X.aY in Ii and goto(Ii,a) = Ij, then set action[i,a] to shift j" if (!it->IsFinished() && m_pWorkGrammar->m_UniqueGrammarItems[it->GetSymbolNo()].m_Type != siMeta) { int SymbolNo = it->GetSymbolNo(); size_t NextState; if (S.GetGotoValue(SymbolNo, i, NextState) && (size_t)tableLine[SymbolNo].m_GotoLine != NextState) { YASSERT(tableLine[SymbolNo].m_GotoLine == -1); YASSERT(!tableLine[SymbolNo].m_bShift); tableLine[SymbolNo].m_bShift = true; tableLine[SymbolNo].m_GotoLine = NextState; } } // if A->X. is in Ii and A != S', for all terminals a in Follow(A) set action [i,a] // to reduce A->X if (it->IsFinished() && it->m_pRule->m_LeftPart != m_pWorkGrammar->GetNewRoot()) { const yset<size_t>& follow = m_pWorkGrammar->m_FollowSets[it->m_pRule->m_LeftPart]; for (yset<size_t>::const_iterator it1 = follow.begin(); it1 != follow.end(); ++it1) tableLine[*it1].m_ReduceRules.push_back(GetRuleInfo(it->m_pRule)); } } // going through non-terminal symbols, initializing GOTO table for non terminals for (size_t symbolNo = 0; symbolNo < m_pWorkGrammar->m_UniqueGrammarItems.size(); ++symbolNo) if (m_pWorkGrammar->m_UniqueGrammarItems[symbolNo].m_Type == siMeta) { size_t nextState; if (S.GetGotoValue(symbolNo, i, nextState)) { YASSERT(tableLine[symbolNo].m_GotoLine == -1); tableLine[symbolNo].m_GotoLine = nextState; } } } Compact(table); return true; };
int Engine::CompactAll(Context& ctx) { DataArray nss; ListNameSpaces(ctx, nss); for (size_t i = 0; i < nss.size(); i++) { KeyObject start, end; start.SetNameSpace(nss[i]); Compact(ctx, start, end); } return 0; }
void Table::doRecovery() { #ifdef WIN32_NOLIB recoveryDlg = CreateDialog(db->GetInstance(), MAKEINTRESOURCE(IDD_NDE_RECOVERY), NULL, RecoveryDlgProc); ShowWindow(recoveryDlg, SW_NORMAL); SetWindowPos(recoveryDlg, HWND_TOPMOST, 0, 0, 0, 0, SWP_NOMOVE|SWP_NOSIZE); SetForegroundWindow(recoveryDlg); UpdateWindow(recoveryDlg); #endif Compact(); #ifdef WIN32_NOLIB EnableWindow(GetDlgItem(recoveryDlg, IDOK), 1); #endif }
void SvnLogHandler::Process(const wxString& output) { // create new editor and set the output to it wxString changeLog (output); if(m_compact) { // remove non interesting lines changeLog = Compact(changeLog); } ChangeLogPage *page = new ChangeLogPage(GetPlugin()->GetManager()->GetTheApp()->GetTopWindow(), GetPlugin()); page->SetUrl(m_url); page->AppendText( changeLog ); GetPlugin()->GetManager()->AddPage( page, _("Change Log"), _("Change Log"), wxNullBitmap, true ); }
URAction* UndoRedoMgr::NewAction(URAction* pAction){ //-----[ are there too many Undo's ? ]--------------------------[ if(NumUndoGroups>=MAX_NUM_UNDOREDO_OPERATIONS){ DeleteOneUndoChain(UndoGroups[0]); // the oldest "undo" chain } //--------------------------------------------------------------/ //-----[ try to compact ]-------------[ if(!NumActionsStarted){ Compact(); } //------------------------------------/ //--------[ link in linked-list ]------------[ if(NumActionsStarted){ pAction->pPrevAction = pLastActionStarted; pLastActionStarted->pNextAction = pAction; } pLastActionStarted = pAction; NumActionsStarted++; //-------------------------------------------/ //------[ send the "action created" msg ]---------------------[ // this could change "NumActionsStarted"!! pAction->OnCreate(); //------------------------------------------------------------/ NumActionsStarted--; if(NumActionsStarted)return pAction; // if this action is not a group //--------[ register the UndoGroup[CurUndo] ]------[ URAction* edx = pLastActionStarted; pLastActionStarted = 0; while(edx->pPrevAction)edx = edx->pPrevAction; UndoGroups[NumUndoGroups]=edx; NumUndoGroups++; //-------------------------------------------------/ //--------[ delete all RedoGroups ]---------[ ClearRedoChains(); //------------------------------------------/ return pAction; }
bool cStringList::GetFiles(cString path, cString pattern, bool norec) { cString cmdline="find "+path; if(norec) cmdline+=" -maxdepth 1"; cmdline+=" -iname \""+pattern+"\" -type f"; ClearAll(); FromPopen(cmdline); if(Length()==0) { // cerr<<"length is 0, returning false"<<endl; return false; } //(*this)[-1]=""; Compact(); return true; }
void SourceBuffer::OnIteratorRelease() { MutexAutoLock lock(mMutex); MOZ_ASSERT(mConsumerCount > 0, "Consumer count doesn't add up"); mConsumerCount--; // If we still have active consumers, or we're not complete yet, then return. if (mConsumerCount > 0 || !mStatus) { return; } // Attempt to compact our buffer down to a single chunk. Compact(); }
void FreeTypeFontCache::AddGlyphData(UINT glyphindex, int width, int gdiWidth, FT_Referenced_BitmapGlyph glyph, FT_Render_Mode render_mode, int AAMode) { if (glyphindex & 0xffff0000 /*|| !g_ccbCache*/) { return; } //GC if (AddIncrement() >= FREETYPE_REQCOUNTMAX) { //TRACE(_T("Compact(0x%p)\n"), this); Compact(); } #ifdef _USE_ARRAY FreeTypeCharData** ppGlyph = _GetGlyph(glyphindex); if (*ppGlyph) { (*ppGlyph)->SetGlyph(render_mode, glyph); (*ppGlyph)->SetMruCounter(this); return; } #else GlyphCache::iterator it=m_GlyphCache.find(-(int)glyphindex); if (it!=m_GlyphCache.end()) //找到了旧数据 { FreeTypeCharData* ppChar = it->second; if (ppChar) { (ppChar)->SetGlyph(render_mode, glyph); (ppChar)->SetMruCounter(this); ppChar->SetWidth(width); ppChar->SetGDIWidth(gdiWidth); return; } } #endif //捛壛(glyph偺傒) FreeTypeCharData* p = new FreeTypeCharData(NULL, /*ppGlyph*/NULL, 0, glyphindex, width, MruIncrement(), gdiWidth, AAMode); if (p == NULL) { return; } p->SetGlyph(render_mode, glyph); #ifdef _USE_ARRAY *ppGlyph = p; #else m_GlyphCache[-(int)glyphindex]=p; #endif }
cudaError_t CudaAllocBuckets::Malloc(size_t size, void** p) { // Locate the bucket index and adjust the size of the allocation to the // bucket size. int bucket = LocateBucket(size); if(bucket < NumBuckets) size = BucketSizes[bucket]; // Peel off an already-allocated node and reuse it. MemList& list = _memLists[bucket]; if(list.size() && list.front().priority != _priorityMap.end()) { MemList::iterator memIt = list.begin(); _priorityMap.erase(memIt->priority); memIt->priority = _priorityMap.end(); list.splice(list.end(), list, memIt); _committed += size; *p = memIt->address->first; return cudaSuccess; } // Shrink if this allocation would put us over the limit. Compact(size); cudaError_t error = cudaSuccess; *p = 0; if(size) error = cudaMalloc(p, size); while((cudaErrorMemoryAllocation == error) && (_committed < _allocated)) { SetCapacity(_capacity - _capacity / 10); error = cudaMalloc(&p, size); } if(cudaSuccess != error) return error; MemList::iterator memIt = _memLists[bucket].insert(_memLists[bucket].end(), MemNode()); memIt->bucket = bucket; memIt->address = _addressMap.insert(std::make_pair(*p, memIt)).first; memIt->priority = _priorityMap.end(); _allocated += size; _committed += size; return cudaSuccess; }
nsVoidArray& nsVoidArray::operator=(const nsVoidArray& other) { PRInt32 otherCount = other.Count(); PRInt32 maxCount = GetArraySize(); if (otherCount) { if (otherCount > maxCount) { // frees old mImpl IF this succeeds if (!GrowArrayBy(otherCount-maxCount)) return *this; // XXX The allocation failed - don't do anything memcpy(mImpl->mArray, other.mImpl->mArray, otherCount * sizeof(mImpl->mArray[0])); mImpl->mCount = otherCount; } else { // the old array can hold the new array memcpy(mImpl->mArray, other.mImpl->mArray, otherCount * sizeof(mImpl->mArray[0])); mImpl->mCount = otherCount; // if it shrank a lot, compact it anyways if ((otherCount*2) < maxCount && maxCount > 100) { Compact(); // shrank by at least 50 entries } } #if DEBUG_VOIDARRAY if (mImpl->mCount > mMaxCount && mImpl->mCount < (PRInt32)(sizeof(MaxElements)/sizeof(MaxElements[0]))) { MaxElements[mImpl->mCount]++; MaxElements[mMaxCount]--; mMaxCount = mImpl->mCount; } #endif } else { // Why do we drop the buffer here when we don't in Clear()? SizeTo(0); } return *this; }
void FreeTypeFontCache::AddCharData(WCHAR wch, UINT glyphindex, int width, int gdiWidth, FT_Referenced_BitmapGlyph glyph, FT_Render_Mode render_mode, int AAMode) { if (glyphindex & 0xffff0000 /*|| !g_ccbCache*/) { return; } if (AddIncrement() >= FREETYPE_REQCOUNTMAX) { //先压缩,避免压缩后丢失的问题 Compact(); } #ifdef _USE_ARRAY FreeTypeCharData** ppChar = _GetChar(wch); if (*ppChar) { (*ppChar)->SetGlyph(render_mode, glyph); (*ppChar)->SetMruCounter(this); return; } #else GlyphCache::iterator it=m_GlyphCache.find(wch); if (it!=m_GlyphCache.end()) //找到了旧数据 { FreeTypeCharData* ppChar = it->second; if (ppChar) { ppChar->SetGlyph(render_mode, glyph); ppChar->SetMruCounter(this); ppChar->SetWidth(width); ppChar->SetGDIWidth(gdiWidth); return; } } #endif FreeTypeCharData* p = new FreeTypeCharData(/*ppChar*/NULL, NULL, wch, glyphindex, width, MruIncrement(), gdiWidth, AAMode); if (p == NULL) { return; } p->SetGlyph(render_mode, glyph); #ifdef _USE_ARRAY *ppChar = p; #else m_GlyphCache[wch]=p; #endif }
bool ON_Brep::SplitKinkyFaces( double kink_tol_radians, bool bCompactIfNeeded ) { bool rc = true; // see if splitting is required const int ecount = m_E.Count(); const int fcount = m_F.Count(); for (int j=0; j<fcount; j++) { if ( !SplitKinkyFace(j,kink_tol_radians) ) rc = false; } if (bCompactIfNeeded && ( fcount != m_F.Count() || ecount != m_E.Count()) ) { Compact(); } return true; }
bool cFileList::GetList(cString starting_path, cString pattern) { cString cmdline; if(cis) cmdline="find "+starting_path+" -iname \""+pattern+"\""; else cmdline="find "+starting_path+" -name \""+pattern+"\""; if(!rec) cmdline+=" -maxdepth 1"; // cout<<"about to execute:"<<cmdline<<endl; // pclose(FromFile(popen(cmdline+" -type f","r"))); pclose(FromFile(popen(cmdline,"r"))); cout<<endl; // cerr<<"found "<<Length()<<" entries"<<endl; if(Length()==0) return false; // for(int j=0; j<Length(); j++) cerr<<j+1<<"/"<<Length()<<":"<<Array[j]<<endl; // cout<<endl; Array[Length()-1]=""; //UCompact(); cFile *temp; if(starting_path[0]!='/') { for(int i=0; i<Length(); i++) { Array[i]=Array[i].ChopLf('/'); if(Array[i]!="") { temp=new cFile(Array[i],false,false,false); if(temp->IsDirectory()) Array[i]=""; delete temp; } } } // cout<<endl; // for(int j=0; j<Length(); j++) cerr<<j+1<<"/"<<Length()<<":"<<Array[j]<<endl; // cout<<endl; Compact(); // cout<<endl; // for(int j=0; j<Length(); j++) cerr<<j+1<<"/"<<Length()<<":"<<Array[j]<<endl; // cout<<endl; return true; }
FreeTypeFontCache* FreeTypeFontInfo::GetCache(FTC_ScalerRec& scaler, const LOGFONT& lf) { CCriticalSectionLock __lock(CCriticalSectionLock::CS_FONTCACHE); if (AddIncrement() > m_nMaxSizes) { //先压缩 Compact(); } int weight = lf.lfWeight; weight = weight < FW_BOLD ? 0: 1/*FW_BOLD*/; const bool italic = !!lf.lfItalic; if (scaler.height>0xfff || scaler.width>0xfff/* || scaler.height<0 || scaler.width<0*/) //超大字体不渲染 return NULL; FreeTypeFontCache* p = NULL; UINT hash=getCacheHash(scaler.height, weight, italic, lf.lfWidth ? scaler.width : 0); //计算hash CacheArray::iterator it=m_cache.find(hash); //寻找cache if (it!=m_cache.end())//cache存在 { p = it->second; goto OK; //返回cache } p = new FreeTypeFontCache(/*scaler.height, weight, italic,*/ MruIncrement()); if (!p) { return NULL; } if (m_cache[hash]=p) { goto OK; } delete p; return NULL; OK: Assert(p != NULL); if (p && p->Activate()) { DecIncrement(); //重复使用则减计数值 } return p; }
NS_IMETHODIMP nsFolderCompactState::OnStopRunningUrl(nsIURI *url, nsresult status) { if (m_parsingFolder) { m_parsingFolder = false; if (NS_SUCCEEDED(status)) status = Compact(m_folder, m_compactingOfflineFolders, m_listener, m_window); else if (m_compactAll) CompactNextFolder(); } else if (m_compactAll) // this should be the imap case only { nsCOMPtr <nsIMsgFolder> prevFolder = do_QueryElementAt(m_folderArray, m_folderIndex); if (prevFolder) prevFolder->SetMsgDatabase(nsnull); CompactNextFolder(); } else if (m_listener) { CompactCompleted(status); } return NS_OK; }
LRESULT CALLBACK DlgWndProc(HWND hwnd,UINT uMsg,WPARAM wParam,LPARAM lParam) { OPENFILENAME opfn; BROWSEINFO bi; TCHAR fn[512]; TCHAR fn2[512]; switch(uMsg) { case WM_COMMAND: switch((wParam<<16)>>16) { case IDC_BROWSEORI: memset(fn,0,512); memset(&opfn,0,sizeof(opfn)); opfn.lStructSize =sizeof(opfn); opfn.hwndOwner =hwnd; opfn.lpstrFilter =TEXT("DAT文件(*.dat)\0*.dat\0\0"); opfn.lpstrFile =fn; opfn.nMaxFile =512; opfn.Flags=OFN_FILEMUSTEXIST | OFN_PATHMUSTEXIST; if(::GetOpenFileName(&opfn)) { ::SetDlgItemText(hwnd,IDC_ORINAME,fn); } break; case IDC_RUN: if(::IsDlgButtonChecked(hwnd,IDC_RADIO_EXT)==BST_CHECKED) { ::GetDlgItemText(hwnd,IDC_ORINAME,fn,512); if(Extract(fn)==-1) MessageBox(hwnd,TEXT("解包失败!"),TEXT("摔14"),MB_OK|MB_ICONERROR); else MessageBox(hwnd,TEXT("解包完成!"),TEXT("摔14"),MB_OK); } else { ::GetDlgItemText(hwnd,IDC_NEWFOLDER,fn,512); ::GetDlgItemText(hwnd,IDC_ORINAME,fn2,512); if(Compact(fn,fn2)==-1) MessageBox(hwnd,TEXT("封装失败!"),TEXT("摔14"),MB_OK|MB_ICONERROR); else MessageBox(hwnd,TEXT("封装完成!"),TEXT("摔14"),MB_OK); } break; case IDC_BROWSENEW: memset(&bi,0,sizeof (bi)); bi.hwndOwner=hwnd; bi.pszDisplayName=fn; bi.lpszTitle=TEXT("选择文件夹"); bi.ulFlags=BIF_USENEWUI; LPITEMIDLIST idl; idl=SHBrowseForFolder(&bi); if(idl==NULL) break; if(!SHGetPathFromIDList(idl,fn)) break; ::SetDlgItemText(hwnd,IDC_NEWFOLDER,fn); break; case IDC_RADIO_EXT: if(wParam>>16==BN_CLICKED) { ext_main: EnableWindow(GetDlgItem(hwnd,IDC_BROWSENEW),FALSE); EnableWindow(GetDlgItem(hwnd,IDC_NEWFOLDER),FALSE); SetDlgItemText(hwnd,IDC_STATIC1,TEXT("原始脚本(如scr.dat)")); // SetDlgItemText(hwnd,IDC_STATIC2,TEXT("待封包目录(如scr文件夹)")); } break; case IDC_RADIO_COM: if(wParam>>16==BN_CLICKED) { EnableWindow(GetDlgItem(hwnd,IDC_BROWSENEW),TRUE); EnableWindow(GetDlgItem(hwnd,IDC_NEWFOLDER),TRUE); SetDlgItemText(hwnd,IDC_STATIC1,TEXT("新脚本(如scr1.dat)")); // SetDlgItemText(hwnd,IDC_STATIC2,TEXT("待封包目录(如scr文件夹)")); } break; } break; case WM_INITDIALOG: g_hWinMain=hwnd; CheckDlgButton(hwnd,IDC_RADIO_EXT,BST_CHECKED); goto ext_main; break; case WM_CLOSE: EndDialog(hwnd,0); } return 0; }
IO_stat MCParagraph::load(IO_handle stream, const char *version) { IO_stat stat; stat = IO_NORMAL; if (stat == IO_NORMAL) stat = IO_read_uint2(&m_text_size, stream); if (m_text_size == 1) { if (stat == IO_NORMAL) { char t_temp; uint4 t_temp_count; t_temp_count = 1; stat = IO_read(&t_temp, sizeof(uint1), t_temp_count, stream); } if (stat == IO_NORMAL) m_text_size = 0; } else if (m_text_size > 1) { if (stat == IO_NORMAL) { m_text = malloc(m_text_size); if (m_text == NULL) stat = IO_ERROR; } if (stat == IO_NORMAL) { uint4 t_temp_text_size; t_temp_text_size = m_text_size; stat = IO_read(m_text, sizeof(uint1), t_temp_text_size, stream); } if (stat == IO_NORMAL) { if (MCencryptstring != NULL) MCX_passde((char *)m_text, MCencryptstring, m_text_size); m_text_size -= 1; } } while(stat == IO_NORMAL) { uint1 t_type; stat = IO_read_uint1(&t_type, stream); if (stat != IO_NORMAL) break; uint4 t_block_offset, t_block_length, t_block_style; stat = load_block(stream, version, t_block_offset, t_block_length, t_block_style); if (stat != IO_NORMAL) break; // Make sure the block doesn't overrun the text buffer (shouldn't ever be // necessary...) t_block_length = MCU_min(m_text_size - t_block_offset, t_block_length); // Byte-swap the text to native byte-order if its unicode, otherwise translate // Mac<->ISO if necessary. const MCParagraphCharStyle *t_style_info; t_style_info = FetchCharStyle(t_block_style); if (t_style_info -> is_unicode) { uint4 t_length; t_length = t_block_length / 2; uint2 *t_ptr; t_ptr = (uint2 *)((uint1 *)m_text + t_block_offset); for(; t_length > 0; t_length -= 1) swap_uint2(t_ptr++); } else if (MCtranslatechars) { #ifdef _MACOSX IO_iso_to_mac((char *)m_text + t_block_offset, t_block_length); #else IO_mac_to_iso((char *)m_text + t_block_offset, t_block_length); #endif } // Replace the style in the given range with the style ReplaceStyles(t_block_offset, t_block_length, t_block_style); } if (stat == IO_NORMAL) { // If no styles were applied, we need to translate the text if (m_styles_size == 0 && MCtranslatechars && m_text_size > 0) #ifdef _MACOSX IO_iso_to_mac((char *)m_text, m_text_size); #else IO_mac_to_iso((char *)m_text, m_text_size); #endif Compact(); MCS_seek_cur(stream, -1); } return stat; }
void CudaAllocBuckets::Clear() { Compact(0); }
nsresult nsFontCache::GetMetricsFor(const nsFont& aFont, nsIAtom* aLanguage, gfxUserFontSet* aUserFontSet, nsIFontMetrics*& aMetrics) { // First check our cache // start from the end, which is where we put the most-recent-used element nsIFontMetrics* fm; PRInt32 n = mFontMetrics.Length() - 1; for (PRInt32 i = n; i >= 0; --i) { fm = mFontMetrics[i]; nsIThebesFontMetrics* tfm = static_cast<nsIThebesFontMetrics*>(fm); if (fm->Font().Equals(aFont) && tfm->GetUserFontSet() == aUserFontSet) { nsCOMPtr<nsIAtom> language; fm->GetLanguage(getter_AddRefs(language)); if (aLanguage == language.get()) { if (i != n) { // promote it to the end of the cache mFontMetrics.RemoveElementAt(i); mFontMetrics.AppendElement(fm); } tfm->GetThebesFontGroup()->UpdateFontList(); NS_ADDREF(aMetrics = fm); return NS_OK; } } } // It's not in the cache. Get font metrics and then cache them. aMetrics = nsnull; nsresult rv = CreateFontMetricsInstance(&fm); if (NS_FAILED(rv)) return rv; rv = fm->Init(aFont, aLanguage, mContext, aUserFontSet); if (NS_SUCCEEDED(rv)) { // the mFontMetrics list has the "head" at the end, because append // is cheaper than insert mFontMetrics.AppendElement(fm); aMetrics = fm; NS_ADDREF(aMetrics); return NS_OK; } fm->Destroy(); NS_RELEASE(fm); // One reason why Init() fails is because the system is running out of // resources. e.g., on Win95/98 only a very limited number of GDI // objects are available. Compact the cache and try again. Compact(); rv = CreateFontMetricsInstance(&fm); if (NS_FAILED(rv)) return rv; rv = fm->Init(aFont, aLanguage, mContext, aUserFontSet); if (NS_SUCCEEDED(rv)) { mFontMetrics.AppendElement(fm); aMetrics = fm; NS_ADDREF(aMetrics); return NS_OK; } fm->Destroy(); NS_RELEASE(fm); // could not setup a new one, send an old one (XXX search a "best // match"?) n = mFontMetrics.Length() - 1; // could have changed in Compact() if (n >= 0) { aMetrics = mFontMetrics[n]; NS_ADDREF(aMetrics); return NS_OK; } NS_POSTCONDITION(NS_SUCCEEDED(rv), "font metrics should not be null - bug 136248"); return rv; }
ptr<File> MemoryStream::ToFile() { Compact(); return dataSize < files[0]->GetSize() ? NEW(PartFile(files[0], files[0]->GetData(), dataSize)) : files[0]; }
void cStringList::FromPopen(cString cmdline, cString grepme) { FromPopen(cmdline); for(int i=0; i<Length(); i++) if(!(*this)[i].Contains(grepme)) { (*this)[i]=""; } Compact(); }