bool ClientLayerManager::EndTransactionInternal(DrawPaintedLayerCallback aCallback, void* aCallbackData, EndTransactionFlags) { PROFILER_LABEL("ClientLayerManager", "EndTransactionInternal", js::ProfileEntry::Category::GRAPHICS); #ifdef MOZ_LAYERS_HAVE_LOG MOZ_LAYERS_LOG((" ----- (beginning paint)")); Log(); #endif profiler_tracing("Paint", "Rasterize", TRACING_INTERVAL_START); NS_ASSERTION(InConstruction(), "Should be in construction phase"); mPhase = PHASE_DRAWING; ClientLayer* root = ClientLayer::ToClientLayer(GetRoot()); mTransactionIncomplete = false; // Apply pending tree updates before recomputing effective // properties. GetRoot()->ApplyPendingUpdatesToSubtree(); mPaintedLayerCallback = aCallback; mPaintedLayerCallbackData = aCallbackData; GetRoot()->ComputeEffectiveTransforms(Matrix4x4()); root->RenderLayer(); if (!mRepeatTransaction && !GetRoot()->GetInvalidRegion().IsEmpty()) { GetRoot()->Mutated(); } if (!mIsRepeatTransaction) { mAnimationReadyTime = TimeStamp::Now(); GetRoot()->StartPendingAnimations(mAnimationReadyTime); } mPaintedLayerCallback = nullptr; mPaintedLayerCallbackData = nullptr; // Go back to the construction phase if the transaction isn't complete. // Layout will update the layer tree and call EndTransaction(). mPhase = mTransactionIncomplete ? PHASE_CONSTRUCTION : PHASE_NONE; NS_ASSERTION(!aCallback || !mTransactionIncomplete, "If callback is not null, transaction must be complete"); if (gfxPlatform::GetPlatform()->DidRenderingDeviceReset()) { FrameLayerBuilder::InvalidateAllLayers(this); } return !mTransactionIncomplete; }
VOID* KBinaryTree::SearchData(VOID* data, ULONG dwCompareParam) { KLocker locker(&m_KSynchroObject); KBinaryTreeNode* pNode = GetRoot(); VOID* pData = NULL; if (pNode != NULL) { pNode = pNode->SearchByNode(data, m_pCompare, dwCompareParam); if (pNode != NULL) pData = pNode->m_pData; } return pData; }
NS_IMETHODIMP nsHTMLEditor::ShowInlineTableEditingUI(nsIDOMElement * aCell) { NS_ENSURE_ARG_POINTER(aCell); // do nothing if aCell is not a table cell... if (!nsHTMLEditUtils::IsTableCell(aCell)) return NS_OK; if (mInlineEditedCell) { NS_ERROR("call HideInlineTableEditingUI first"); return NS_ERROR_UNEXPECTED; } // the resizers and the shadow will be anonymous children of the body nsIDOMElement *bodyElement = GetRoot(); NS_ENSURE_TRUE(bodyElement, NS_ERROR_NULL_POINTER); CreateAnonymousElement(NS_LITERAL_STRING("a"), bodyElement, NS_LITERAL_STRING("mozTableAddColumnBefore"), PR_FALSE, getter_AddRefs(mAddColumnBeforeButton)); CreateAnonymousElement(NS_LITERAL_STRING("a"), bodyElement, NS_LITERAL_STRING("mozTableRemoveColumn"), PR_FALSE, getter_AddRefs(mRemoveColumnButton)); CreateAnonymousElement(NS_LITERAL_STRING("a"), bodyElement, NS_LITERAL_STRING("mozTableAddColumnAfter"), PR_FALSE, getter_AddRefs(mAddColumnAfterButton)); CreateAnonymousElement(NS_LITERAL_STRING("a"), bodyElement, NS_LITERAL_STRING("mozTableAddRowBefore"), PR_FALSE, getter_AddRefs(mAddRowBeforeButton)); CreateAnonymousElement(NS_LITERAL_STRING("a"), bodyElement, NS_LITERAL_STRING("mozTableRemoveRow"), PR_FALSE, getter_AddRefs(mRemoveRowButton)); CreateAnonymousElement(NS_LITERAL_STRING("a"), bodyElement, NS_LITERAL_STRING("mozTableAddRowAfter"), PR_FALSE, getter_AddRefs(mAddRowAfterButton)); AddMouseClickListener(mAddColumnBeforeButton); AddMouseClickListener(mRemoveColumnButton); AddMouseClickListener(mAddColumnAfterButton); AddMouseClickListener(mAddRowBeforeButton); AddMouseClickListener(mRemoveRowButton); AddMouseClickListener(mAddRowAfterButton); mInlineEditedCell = aCell; return RefreshInlineTableEditingUI(); }
void LayerManagerComposite::BeginTransaction() { mInTransaction = true; if (!mCompositor->Ready()) { return; } mIsCompositorReady = true; if (Compositor::GetBackend() == LayersBackend::LAYERS_OPENGL || Compositor::GetBackend() == LayersBackend::LAYERS_BASIC) { mClonedLayerTreeProperties = LayerProperties::CloneFrom(GetRoot()); } }
FileInfo FileSourceFS::Lookup(const std::string &path) { const std::string fullpath = JoinPathBelow(GetRoot(), path); const std::wstring wfullpath = transcode_utf8_to_utf16(fullpath); DWORD attrs = GetFileAttributesW(wfullpath.c_str()); const FileInfo::FileType ty = file_type_for_attributes(attrs); Time::DateTime modtime; if (ty == FileInfo::FT_FILE || ty == FileInfo::FT_DIR) { HANDLE hfile = CreateFileW(wfullpath.c_str(), GENERIC_READ, FILE_SHARE_READ, 0, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0); if (hfile != INVALID_HANDLE_VALUE) { modtime = file_modtime_for_handle(hfile); CloseHandle(hfile); } } return MakeFileInfo(path, ty, modtime); }
bool Styx::Update(GameTime time) { Playfield const &pf = *GetPlayfield(); // create set of possibile directions to move in std::vector<Direction> choices; for (int n = 0; n < 4; ++n) { Direction dir = (Direction::Type)n; // can't reverse direction if (dir.Opposite() == direction) continue; Playfield::Element element = pf.At(location + dir.GetVector()); if (element == Playfield::Line) { choices.push_back(Direction::Type(n)); } } // if we have no where to go, reverse if (choices.empty()) { direction = direction.Opposite(); } else { // choose new random direction SetDirection(choices[rand() % choices.size()]); if (move_toward_player && choices.size() > 1) { Point pos_player = GetRoot()->GetWorld()->GetPlayer()->GetLocation(); float min_dist = 0; bool first = true; foreach (Direction dir, choices) { float dist = (location + dir.GetVector() - pos_player).Length(); if (first || dist < min_dist) { first = false; min_dist = dist; SetDirection(dir); } } }
bool CBlurayDirectory::GetDirectory(const CURL& url, CFileItemList &items) { Dispose(); m_url = url; std::string root = m_url.GetHostName(); std::string file = m_url.GetFileName(); URIUtils::RemoveSlashAtEnd(file); URIUtils::RemoveSlashAtEnd(root); m_dll = new DllLibbluray(); if (!m_dll->Load()) { CLog::Log(LOGERROR, "CBlurayDirectory::GetDirectory - failed to load dll"); return false; } m_dll->bd_register_dir(DllLibbluray::dir_open); m_dll->bd_register_file(DllLibbluray::file_open); m_dll->bd_set_debug_handler(DllLibbluray::bluray_logger); m_dll->bd_set_debug_mask(DBG_CRIT | DBG_BLURAY | DBG_NAV); m_bd = m_dll->bd_open(root.c_str(), NULL); if(!m_bd) { CLog::Log(LOGERROR, "CBlurayDirectory::GetDirectory - failed to open %s", root.c_str()); return false; } if(file == "root") GetRoot(items); else if(file == "root/titles") GetTitles(false, items); else { CURL url2 = GetUnderlyingCURL(url); CDirectory::CHints hints; hints.flags = m_flags; if (!CDirectory::GetDirectory(url2, items, hints)) return false; } items.AddSortMethod(SortByTrackNumber, 554, LABEL_MASKS("%L", "%D", "%L", "")); // FileName, Duration | Foldername, empty items.AddSortMethod(SortBySize, 553, LABEL_MASKS("%L", "%I", "%L", "%I")); // FileName, Size | Foldername, Size return true; }
////////////////////////////////////////////////////////////////// PUBLIC //---------------------------------------------------- Fonctions publiques int main ( void ) { InitMemoire ( ); racine = GetRoot ( ); FILE * lecture = fopen ( "input.txt" , "r"); uint64_t * nombre = malloc ( sizeof ( uint64_t ) ); while ( EOF != (fscanf ( lecture, "%" PRIu64 "", nombre ) ) ) { get_prime_factors ( * nombre ); print_prime_factors ( * nombre ); } End ( racine ); return 0; } //----- fin de Main
FileInfo FileSourceFS::Lookup(const std::string &path) { const std::string fullpath = JoinPathBelow(GetRoot(), path); struct stat statinfo; FileInfo::FileType ty; if (stat(fullpath.c_str(), &statinfo) == 0) { if (S_ISREG(statinfo.st_mode)) { ty = FileInfo::FT_FILE; } else if (S_ISDIR(statinfo.st_mode)) { ty = FileInfo::FT_DIR; } else { ty = FileInfo::FT_SPECIAL; } } else { ty = FileInfo::FT_NON_EXISTENT; } return MakeFileInfo(path, ty); }
void BubbleTree::PrepareDrawing() { DrawTree::PrepareDrawing(); /* if (minmax) { double max = ComputeMaxNodeVal(root); double min = ComputeMinNodeVal(root); cerr << min << '\t' << max << '\n'; // exit(1); minnodeval = min; nodescale = maxnodeval / sqrt(max - min); } else { */ double max = ComputeMaxNodeVal(GetRoot()); nodescale = maxnodeval / exp(0.5 * nodepower * log(max)); // } }
void PdfPagesTree::DeletePageFromNode( PdfObject* pParent, const PdfObjectList & rlstParents, int nIndex, PdfObject* pPage ) { if( !pParent || !pPage ) { PODOFO_RAISE_ERROR( ePdfError_InvalidHandle ); } // 1. Delete the reference from the kids array of pParent // 2. Decrease count of every node in lstParents (which also includes pParent) // 3. Remove empty page nodes // TODO: Tell cache to free page object // 1. Delete reference this->DeletePageNode( pParent, nIndex ) ; // 2. Decrease count PdfObjectList::const_reverse_iterator itParents = rlstParents.rbegin(); while( itParents != rlstParents.rend() ) { this->ChangePagesCount( *itParents, -1 ); ++itParents; } // 3. Remove empty pages nodes itParents = rlstParents.rbegin(); while( itParents != rlstParents.rend() ) { // Never delete root node if( IsEmptyPageNode( *itParents ) && *itParents != GetRoot() ) { PdfObject* pParentOfNode = *(itParents + 1); int nKidsIndex = this->GetPosInKids( *itParents, pParentOfNode ); DeletePageNode( pParentOfNode, nKidsIndex ); // Delete empty page nodes delete this->GetObject()->GetOwner()->RemoveObject( (*itParents)->Reference() ); } ++itParents; } }
inline void solve(void) { scanf("%d%d%d", &p, &a, &k); Divid(p - 1); if (p == 2) { if (k == 0) printf("%d\n%d\n", 1, 0); else printf("%d\n%d\n",1, 1); return; } int g = GetRoot(p); int tmp = Pow(g, a, p); VII ret = BabyStep(tmp, k, p); SII Ans; for (VII::iterator it = ret.begin(); it != ret.end(); it++) { Ans.insert(Pow(g, *it, p)); } printf("%d\n", Ans.size()); for (SII::iterator it = Ans.begin(); it != Ans.end(); it++) printf("%d\n", *it); }
void wxXmlRcEditDocument::Upgrade() { int v1,v2,v3,v4; long version; wxXmlNode *node = GetRoot(); wxString verstr = wxT("0.0.0.0"); node->GetPropVal(wxT("version"),verstr); if (wxSscanf(verstr.c_str(), wxT("%i.%i.%i.%i"), &v1, &v2, &v3, &v4) == 4) version = v1*256*256*256+v2*256*256+v3*256+v4; else version = 0; if (!version) { UpgradeNode(node); } node->DeleteProperty(wxT("version")); node->AddProperty(wxT("version"), WX_XMLRES_CURRENT_VERSION_STRING); }
void CPDF_Document::DeletePage(int iPage) { CPDF_Dictionary* pRoot = GetRoot(); if (!pRoot) { return; } CPDF_Dictionary* pPages = pRoot->GetDict("Pages"); if (!pPages) { return; } int nPages = pPages->GetInteger("Count"); if (iPage < 0 || iPage >= nPages) { return; } CFX_ArrayTemplate<CPDF_Dictionary*> stack; stack.Add(pPages); if (InsertDeletePDFPage(this, pPages, iPage, NULL, FALSE, stack) < 0) { return; } m_PageList.RemoveAt(iPage); }
// GetNamespaces void COpcXmlDocument::GetNamespaces(COpcStringMap& cNamespaces) { // clear the current set. cNamespaces.RemoveAll(); // check for a valid root element. COpcXmlElement cElement(GetRoot()); if (cElement == NULL) { return; } // add the namespace for the root element. COpcString cPrefix = cElement.GetPrefix(); if (!cPrefix.IsEmpty()) { cNamespaces[cPrefix] = cElement.GetNamespace(); } // fetch the attributes from the root element. COpcXmlAttributeList cAttributes; if (cElement.GetAttributes(cAttributes) > 0) { for (UINT ii = 0; ii < cAttributes.GetSize(); ii++) { if (cAttributes[ii].GetPrefix() == OPCXML_NAMESPACE_ATTRIBUTE) { COpcString cName = cAttributes[ii].GetQualifiedName().GetName(); // don't add the default namespace. if (!cName.IsEmpty()) { cNamespaces[cName] = cAttributes[ii].GetValue(); } } } } }
NS_IMETHODIMP nsHTMLEditor::HideInlineTableEditingUI() { mInlineEditedCell = nsnull; RemoveMouseClickListener(mAddColumnBeforeButton); RemoveMouseClickListener(mRemoveColumnButton); RemoveMouseClickListener(mAddColumnAfterButton); RemoveMouseClickListener(mAddRowBeforeButton); RemoveMouseClickListener(mRemoveRowButton); RemoveMouseClickListener(mAddRowAfterButton); // get the presshell's document observer interface. nsCOMPtr<nsIPresShell> ps; GetPresShell(getter_AddRefs(ps)); // We allow the pres shell to be null; when it is, we presume there // are no document observers to notify, but we still want to // UnbindFromTree. // get the root content node. nsIDOMElement *bodyElement = GetRoot(); nsCOMPtr<nsIContent> bodyContent( do_QueryInterface(bodyElement) ); NS_ENSURE_TRUE(bodyContent, NS_ERROR_FAILURE); DeleteRefToAnonymousNode(mAddColumnBeforeButton, bodyContent, ps); mAddColumnBeforeButton = nsnull; DeleteRefToAnonymousNode(mRemoveColumnButton, bodyContent, ps); mRemoveColumnButton = nsnull; DeleteRefToAnonymousNode(mAddColumnAfterButton, bodyContent, ps); mAddColumnAfterButton = nsnull; DeleteRefToAnonymousNode(mAddRowBeforeButton, bodyContent, ps); mAddRowBeforeButton = nsnull; DeleteRefToAnonymousNode(mRemoveRowButton, bodyContent, ps); mRemoveRowButton = nsnull; DeleteRefToAnonymousNode(mAddRowAfterButton, bodyContent, ps); mAddRowAfterButton = nsnull; return NS_OK; }
bool CBlurayDirectory::GetDirectory(const CStdString& path, CFileItemList &items) { Dispose(); m_url.Parse(path); CStdString root = m_url.GetHostName(); CStdString file = m_url.GetFileName(); URIUtils::RemoveSlashAtEnd(file); m_dll = new DllLibbluray(); if (!m_dll->Load()) { CLog::Log(LOGERROR, "CBlurayDirectory::GetDirectory - failed to load dll"); return false; } m_dll->bd_register_dir(DllLibbluray::dir_open); m_dll->bd_register_file(DllLibbluray::file_open); m_dll->bd_set_debug_handler(DllLibbluray::bluray_logger); m_dll->bd_set_debug_mask(DBG_CRIT | DBG_BLURAY | DBG_NAV); m_bd = m_dll->bd_open(root.c_str(), NULL); if(!m_bd) { CLog::Log(LOGERROR, "CBlurayDirectory::GetDirectory - failed to open %s", root.c_str()); return false; } if(file == "") GetRoot(items); else if(file == "titles") GetTitles(false, items); else return false; items.AddSortMethod(SORT_METHOD_TRACKNUM , 554, LABEL_MASKS("%L", "%D", "%L", "")); // FileName, Duration | Foldername, empty items.AddSortMethod(SORT_METHOD_SIZE , 553, LABEL_MASKS("%L", "%I", "%L", "%I")); // FileName, Size | Foldername, Size return true; }
bool Button::HandleEventSelf(const SDL_Event& ev) { switch (ev.type) { case SDL_MOUSEBUTTONDOWN: { if ((ev.button.button == SDL_BUTTON_LEFT) && MouseOver(ev.button.x, ev.button.y) && gui->MouseOverElement(GetRoot(), ev.motion.x, ev.motion.y)) { clicked = true; }; break; } case SDL_MOUSEBUTTONUP: { if ((ev.button.button == SDL_BUTTON_LEFT) && MouseOver(ev.button.x, ev.button.y) && clicked) { if (!Clicked.empty()) { Clicked(); } else { LogObject() << "Button " << label << " clicked without callback"; } clicked = false; return true; } } case SDL_MOUSEMOTION: { if (MouseOver(ev.motion.x, ev.motion.y) && gui->MouseOverElement(GetRoot(), ev.motion.x, ev.motion.y)) { hovered = true; } else { hovered = false; clicked = false; } break; } } return false; }
//! called during the initialization of the entity void SFXManager::Init() { super::Init(); m_Root = GetRoot(); m_PlayerPulseManager = static_cast<PulseManager*>(GetChildByName("PlayerPulseManager")); m_PlayerLaserManager = static_cast<LaserManager*>(GetChildByName("PlayerLaserManager")); m_PlayerPelletManager = static_cast<PelletManager*>(GetChildByName("PlayerPelletManager")); m_PlayerSidePulseManager = static_cast<PulseManager*>(GetChildByName("PlayerSidePulseManager")); m_PlayerSideLaserManager = static_cast<LaserManager*>(GetChildByName("PlayerSideLaserManager")); m_PlayerSidePelletManager = static_cast<PelletManager*>(GetChildByName("PlayerSidePelletManager")); m_EnemyPulseManager = static_cast<PulseManager*>(GetChildByName("EnemyPulseManager")); m_BossPulseManager = static_cast<PulseManager*>(GetChildByName("BossPulseManager")); m_EnemyLaserManager = static_cast<LaserManager*>(GetChildByName("EnemyLaserManager")); m_EnemyPelletManager = static_cast<PelletManager*>(GetChildByName("EnemyPelletManager")); if(Entity* pSkyBox = m_Root->GetChildByType("SkyBoxEntity")) { m_SkyBoxMaterial = pSkyBox->GetComponent<GraphicComponent>()->GetMaterial(); } }
/// Tries to open an existing file; if not, creates a new one. /// Clears contents if unexpected root node name. /// Reports problems in a message box. /// @param parent Window to parent message boxes. /// @param filename Name only of file - will be created in standard user config directory. SavedState::SavedState(wxWindow * parent, const wxString & filename) { mFilename = wxStandardPaths::Get().GetUserConfigDir() + wxFileName::GetPathSeparator() + filename; bool ok = false; if (!wxFile::Exists(mFilename)) { wxMessageDialog dlg(parent, wxT("No saved preferences file found. Default values will be used."), wxT("No saved preferences")); dlg.ShowModal(); } else if (!Load(mFilename)) { //already produces a warning message box } else if (wxT("Ingexgui") != GetRoot()->GetName()) { wxMessageDialog dlg(parent, wxT("Saved preferences file \"") + mFilename + wxT("\": has unrecognised data: re-creating with default values."), wxT("Unrecognised saved preferences"), wxICON_EXCLAMATION | wxOK); dlg.ShowModal(); } else { ok = true; } if (!ok) { SetRoot(new wxXmlNode(wxXML_ELEMENT_NODE, wxT("Ingexgui"))); Save(); } }
bool wxXmlDocument::Save(wxOutputStream& stream, int indentstep) const { if ( !IsOk() ) return false; wxString s; wxMBConv *convMem = NULL, *convFile; #if wxUSE_UNICODE convFile = new wxCSConv(GetFileEncoding()); convMem = NULL; #else if ( GetFileEncoding().CmpNoCase(GetEncoding()) != 0 ) { convFile = new wxCSConv(GetFileEncoding()); convMem = new wxCSConv(GetEncoding()); } else // file and in-memory encodings are the same, no conversion needed { convFile = convMem = NULL; } #endif s.Printf(wxT("<?xml version=\"%s\" encoding=\"%s\"?>\n"), GetVersion().c_str(), GetFileEncoding().c_str()); OutputString(stream, s); OutputNode(stream, GetRoot(), 0, convMem, convFile, indentstep); OutputString(stream, wxT("\n")); delete convFile; delete convMem; return true; }
int main(int argc, char **argv) { RootStruct *root = GetRoot(); word maxav = 0; while (TRUE) { word av = root->LoadAverage; if (av > maxav) maxav = av; if (argc == 1) { printf("LowPriAv: %8lu, HiPriLat: %8lu, MaxLat: %8lu\n", av ,root->Latency,root->MaxLatency); printf("MaxAv: %lu\n", maxav); printf("LocalMsgs: %8lu, BuffMsgs: %8lu, Time: %8lu\n", root->LocalMsgs,root->BufferedMsgs,root->Time); printf("Timer: %#8lx, %ld\n\n", root->Timer, root->Timer); } else if (argc == 2) { IOdebug("LowPriAv: %x, HiPriLat: %x, MaxLat: %x", av ,root->Latency,root->MaxLatency); IOdebug("MaxAv: %x", maxav); IOdebug("LocalMsgs: %x, BuffMsgs: %x, Time: %x", root->LocalMsgs,root->BufferedMsgs,root->Time); IOdebug("Timer: %x\n", root->Timer); } else { donowt(3); } Delay(OneSec); } }
bool FileSourceFS::ReadDirectory(const std::string &dirpath, std::vector<FileInfo> &output) { size_t output_head_size = output.size(); const std::wstring wsearchglob = transcode_utf8_to_utf16(JoinPathBelow(GetRoot(), dirpath)) + L"/*"; WIN32_FIND_DATAW findinfo; HANDLE dirhandle = FindFirstFileW(wsearchglob.c_str(), &findinfo); DWORD err; if (dirhandle == INVALID_HANDLE_VALUE) { err = GetLastError(); // if the directory was empty we succeeded even though FindFirstFile failed return (err == ERROR_FILE_NOT_FOUND); } do { std::string fname = transcode_utf16_to_utf8(findinfo.cFileName, wcslen(findinfo.cFileName)); if (fname != "." && fname != "..") { const FileInfo::FileType ty = file_type_for_attributes(findinfo.dwFileAttributes); const Time::DateTime modtime = datetime_for_filetime(findinfo.ftLastWriteTime); output.push_back(MakeFileInfo(JoinPath(dirpath, fname), ty, modtime)); } if (! FindNextFileW(dirhandle, &findinfo)) { err = GetLastError(); } else err = ERROR_SUCCESS; } while (err == ERROR_SUCCESS); FindClose(dirhandle); if (err != ERROR_NO_MORE_FILES) { output.resize(output_head_size); return false; } std::sort(output.begin() + output_head_size, output.end()); return true; }
bool nuiZoomView::Load(const nuiXMLNode* pNode) { nuiComposite::Load(pNode); mAlwaysDisplayVScrollbar = false; mAlwaysDisplayHScrollbar = false; mHorizontalZoomLevel = 1.f; mVerticalZoomLevel = 1.f; nglString hscroll = nuiGetString(pNode, _T("HorizontalScrollBar"), nglString::Empty); nglString vscroll = nuiGetString(pNode, _T("VerticalScrollBar"), nglString::Empty); nglString hslider = nuiGetString(pNode, _T("HorizontalSlider"), nglString::Empty); nglString vslider = nuiGetString(pNode, _T("VerticalSlider"), nglString::Empty); nuiContainerPtr pTop = GetRoot(); mpHorizontalScrollbar = dynamic_cast<nuiScrollBar*>(pTop->GetChild(hscroll)); mpVerticalScrollbar = dynamic_cast<nuiScrollBar*>(pTop->GetChild(vscroll)); mpHorizontalSlider = dynamic_cast<nuiSlider*>(pTop->GetChild(hslider)); mpVerticalSlider = dynamic_cast<nuiSlider*>(pTop->GetChild(vslider)); if (mpHorizontalScrollbar) mSVSink.Connect(mpHorizontalScrollbar->GetRange().ValueChanged, &nuiZoomView::Scrolled); if (mpVerticalScrollbar) mSVSink.Connect(mpVerticalScrollbar->GetRange().ValueChanged, &nuiZoomView::Scrolled); if (mpHorizontalSlider) mSVSink.Connect(mpHorizontalSlider->GetRange().Changed, &nuiZoomView::Zoomed); if (mpVerticalSlider) mSVSink.Connect(mpVerticalSlider->GetRange().Changed, &nuiZoomView::Zoomed); mSVSink.Connect(ChildAdded, &nuiZoomView::OnChildAdded); mSVSink.Connect(ChildDeleted, &nuiZoomView::OnChildRemoved); return true; }
NS_IMETHODIMP HTMLEditor::HideInlineTableEditingUI() { mInlineEditedCell = nullptr; RemoveMouseClickListener(mAddColumnBeforeButton); RemoveMouseClickListener(mRemoveColumnButton); RemoveMouseClickListener(mAddColumnAfterButton); RemoveMouseClickListener(mAddRowBeforeButton); RemoveMouseClickListener(mRemoveRowButton); RemoveMouseClickListener(mAddRowAfterButton); // get the presshell's document observer interface. nsCOMPtr<nsIPresShell> ps = GetPresShell(); // We allow the pres shell to be null; when it is, we presume there // are no document observers to notify, but we still want to // UnbindFromTree. // get the root content node. nsCOMPtr<nsIContent> bodyContent = GetRoot(); DeleteRefToAnonymousNode(mAddColumnBeforeButton, bodyContent, ps); mAddColumnBeforeButton = nullptr; DeleteRefToAnonymousNode(mRemoveColumnButton, bodyContent, ps); mRemoveColumnButton = nullptr; DeleteRefToAnonymousNode(mAddColumnAfterButton, bodyContent, ps); mAddColumnAfterButton = nullptr; DeleteRefToAnonymousNode(mAddRowBeforeButton, bodyContent, ps); mAddRowBeforeButton = nullptr; DeleteRefToAnonymousNode(mRemoveRowButton, bodyContent, ps); mRemoveRowButton = nullptr; DeleteRefToAnonymousNode(mAddRowAfterButton, bodyContent, ps); mAddRowAfterButton = nullptr; return NS_OK; }
int main(void) { long go; GetRoot(); /* Also creates a child process for transcribing stdout */ GetParms(); MakeFiles(); /* in test directory */ InitRPC(); MakeWorkers(); GetConns(); GetVar(&go, "Say when: "); DoBindings(); MakeClients(); /* wait for all clients to get ready */ while (ClientsReady < Clients) LWP_DispatchProcess(); LWP_NoYieldSignal((char *)&ClientsReady); LWP_WaitProcess((char *)main); /* infinite wait */ return 0; /* make compiler happy */ }
int main(int argc, char **argv) { int i; RootStruct *root = GetRoot(); MIInfo *mi = root->MISysMem; RRDCommon *rrdc; Memory *m; if(argc > 1 && !strcmp(argv[1],"-p")) waiting = TRUE; printf("Memory Indirection Information:\n"); forever { word tablesize = mi->MITableSize; word *mitable = (word *)mi->MITable; if (tablesize == 0) { printf("memory indirection table has not been initialised yet\n"); break; } printf("\nMITable = %8x\n",(word)mitable); printf("MITableSize = %d\n",tablesize); printf("freehandles = %d\n",mi->MIFreeSlots); for ( i=0; i < tablesize; i++) { rrdc = (RRDCommon *)mitable[i]; if (rrdc == NULL) continue; /* unused slot in MI table */ printf("Block: %d @ %#x size: %d",i,(word)rrdc,rrdc->TotalSize); m = ((Memory *)rrdc)-1; if(m->Size & Memory_Size_Reloc) puts(" is unlocked"); else puts(" is LOCKED"); switch (rrdc->Magic) { case RRDFileMagic: { RRDFileBlock *rrdf = (RRDFileBlock *)rrdc; printf("Type: File, file Id: %d, name: /ram/sys/%s\n",rrdf->FileId,rrdf->FullName); break; } case RRDDirMagic: { RRDDirBlock *rrdd = (RRDDirBlock *)rrdc; printf("Type: Directory, name: /ram/sys/%s\n",rrdd->FullName); break; } case RRDBuffMagic: { RRDBuffBlock *rrdb = (RRDBuffBlock *)rrdc; printf("Type: File Buffer, file Id: %d PosInFile: %d\n",rrdb->FileId,rrdb->Pos); break; } case RRDSymbMagic: { RRDSymbBlock *rrds = (RRDSymbBlock *)rrdc; printf("Type: Symbolic Link, /ram/sys/%s, -> %s\n",rrds->FullName,rrds->FullName + strlen(rrds->FullName) + 1); break; } default: printf("Unknown block type! (%#x)\n",rrdc->Magic); } putchar('\n'); } if (!waiting) break; else Pause(); } }
/** * Packs <code>nArgs<code> function arguments plus the zero-th argument (the * function itself) from <code>iCaller</code>'s stack into the data transfer * object <code>iDto</code>. */ void CGEN_PROTECTED CProcess::Marshal ( CDlpObject* iDto, CFunction* iCaller, INT32 nArgs ) { CData* idSign = NULL; // Signature table StkItm* pStkItm = NULL; // Stack item to marshal INT32 nArg = 0; // Argument loop counter #ifndef USE_FORK CDlpObject* iRoot = NULL; CDlpObject* iSrc = NULL; CDlpObject* iDst = NULL; CData* idGlob = NULL; // Globals table CData* idIncl = NULL; // Includes table hscan_t hs; hnode_t* hn; SWord* lpWord = NULL; char* psClsName; char* psInsName; #endif // Marshal function arguments // ------------------------------------ idSign = (CData*)CDlpObject_Instantiate(iDto,"data",PRC_S_IDSIGN,FALSE); // Create signature table CData_AddComp(idSign,"name",L_SSTR); // Add component to table for (nArg=0; nArg<=nArgs; nArg++) // Loop over arguments { // >> pStkItm = iCaller->StackGet(0); // Get stack top Pack(iDto,idSign,pStkItm,NULL); // Pack into data transfer object iCaller->Pop(FALSE); // Remove stack top } // << #ifndef USE_FORK // Marshal global variables // ------------------------------------ iRoot = GetRoot(); // Get root function if (m_bGlobal && iRoot) // /global option set { // >> idGlob = (CData*)CDlpObject_Instantiate(iDto,"data",PRC_S_IDGLOB,FALSE); // Create globals table CData_AddComp(idGlob,"clas",L_SSTR); // Add component to table CData_AddComp(idGlob,"name",L_SSTR); // Add component to table hash_scan_begin(&hs,iRoot->m_lpDictionary); // Initialize while ((hn = hash_scan_next(&hs))!=NULL) // Loop over root function's dict. { // >> lpWord = (SWord*)hnode_get(hn); // Get pointer to SWord struct if ((lpWord->nWordType == WL_TYPE_INSTANCE) && lpWord->lpData) // Entry is a non-NULL instance { // >> iSrc = (CDlpObject*)lpWord->lpData; // Get instance pointer psClsName = iSrc->m_lpClassName; // Get pointer to class name psInsName = iSrc->m_lpInstanceName; // Get pointer to instance name //if (CDlpObject_OfKind("function",iSrc)) continue; // No functions, please if (iSrc==iCaller) continue; // Not the caller! if (iSrc->m_nClStyle & CS_SINGLETON) continue; // No singletons! if (CDlpObject_FindInstanceWord(m_iDto,psInsName,NULL)) continue; // Shadowed by an argument iDst = CDlpObject_Instantiate(m_iDto,psClsName,psInsName,FALSE); // Create copy to pack iDst->Copy(iSrc); // Copy content CData_AddRecs(idGlob,1,10); // Add index entry CData_Sstore(idGlob,psClsName,CData_GetNRecs(idGlob)-1,0); // Write index entry CData_Sstore(idGlob,psInsName,CData_GetNRecs(idGlob)-1,1); // Write index entry } // << } // << } // << // Marshal includes // ------------------------------------ if (m_bInclude && iRoot) // /include option set { // >> idIncl = (CData*)CDlpObject_Instantiate(iDto,"data",PRC_S_IDINCL,FALSE); // Create include table CData_Copy(idIncl,((CFunction*)iRoot)->m_idSfl); // Copy includes } // << #endif }
float LayerManagerComposite::ComputeRenderIntegrity() { // We only ever have incomplete rendering when progressive tiles are enabled. Layer* root = GetRoot(); if (!gfxPlatform::GetPlatform()->UseProgressivePaint() || !root) { return 1.f; } FrameMetrics rootMetrics = LayerMetricsWrapper::TopmostScrollableMetrics(root); if (!rootMetrics.IsScrollable()) { // The root may not have any scrollable metrics, in which case rootMetrics // will just be an empty FrameMetrics. Instead use the actual metrics from // the root layer. rootMetrics = LayerMetricsWrapper(root).Metrics(); } ParentLayerIntRect bounds = RoundedToInt(rootMetrics.GetCompositionBounds()); IntRect screenRect(bounds.x, bounds.y, bounds.width, bounds.height); float lowPrecisionMultiplier = 1.0f; float highPrecisionMultiplier = 1.0f; #ifdef MOZ_WIDGET_ANDROID // Use the transform on the primary scrollable layer and its FrameMetrics // to find out how much of the viewport the current displayport covers nsTArray<Layer*> rootScrollableLayers; GetRootScrollableLayers(rootScrollableLayers); if (rootScrollableLayers.Length() > 0) { // This is derived from the code in // AsyncCompositionManager::TransformScrollableLayer Layer* rootScrollable = rootScrollableLayers[0]; const FrameMetrics& metrics = LayerMetricsWrapper::TopmostScrollableMetrics(rootScrollable); Matrix4x4 transform = rootScrollable->GetEffectiveTransform(); transform.PostScale(metrics.GetPresShellResolution(), metrics.GetPresShellResolution(), 1); // Clip the screen rect to the document bounds Rect documentBounds = transform.TransformBounds(Rect(metrics.GetScrollableRect().x - metrics.GetScrollOffset().x, metrics.GetScrollableRect().y - metrics.GetScrollOffset().y, metrics.GetScrollableRect().width, metrics.GetScrollableRect().height)); documentBounds.RoundOut(); screenRect = screenRect.Intersect(IntRect(documentBounds.x, documentBounds.y, documentBounds.width, documentBounds.height)); // If the screen rect is empty, the user has scrolled entirely into // over-scroll and so we can be considered to have full integrity. if (screenRect.IsEmpty()) { return 1.0f; } // Work out how much of the critical display-port covers the screen bool hasLowPrecision = false; if (!metrics.GetCriticalDisplayPort().IsEmpty()) { hasLowPrecision = true; highPrecisionMultiplier = GetDisplayportCoverage(metrics.GetCriticalDisplayPort(), transform, screenRect); } // Work out how much of the display-port covers the screen if (!metrics.GetDisplayPort().IsEmpty()) { if (hasLowPrecision) { lowPrecisionMultiplier = GetDisplayportCoverage(metrics.GetDisplayPort(), transform, screenRect); } else { lowPrecisionMultiplier = highPrecisionMultiplier = GetDisplayportCoverage(metrics.GetDisplayPort(), transform, screenRect); } } } // If none of the screen is covered, we have zero integrity. if (highPrecisionMultiplier <= 0.0f && lowPrecisionMultiplier <= 0.0f) { return 0.0f; } #endif // MOZ_WIDGET_ANDROID nsIntRegion screenRegion(screenRect); nsIntRegion lowPrecisionScreenRegion(screenRect); Matrix4x4 transform; ComputeRenderIntegrityInternal(root, screenRegion, lowPrecisionScreenRegion, transform); if (!screenRegion.IsEqual(screenRect)) { // Calculate the area of the region. All rects in an nsRegion are // non-overlapping. float screenArea = screenRect.width * screenRect.height; float highPrecisionIntegrity = screenRegion.Area() / screenArea; float lowPrecisionIntegrity = 1.f; if (!lowPrecisionScreenRegion.IsEqual(screenRect)) { lowPrecisionIntegrity = lowPrecisionScreenRegion.Area() / screenArea; } return ((highPrecisionIntegrity * highPrecisionMultiplier) + (lowPrecisionIntegrity * lowPrecisionMultiplier)) / 2; } return 1.f; }
bool ClientLayerManager::EndTransactionInternal(DrawPaintedLayerCallback aCallback, void* aCallbackData, EndTransactionFlags) { PaintTelemetry::AutoRecord record(PaintTelemetry::Metric::Rasterization); AutoProfilerTracing tracing("Paint", "Rasterize"); Maybe<TimeStamp> startTime; if (gfxPrefs::LayersDrawFPS()) { startTime = Some(TimeStamp::Now()); } #ifdef WIN32 if (aCallbackData) { // Content processes don't get OnPaint called. So update here whenever we // may do Thebes drawing. gfxDWriteFont::UpdateClearTypeUsage(); } #endif AUTO_PROFILER_LABEL("ClientLayerManager::EndTransactionInternal", GRAPHICS); #ifdef MOZ_LAYERS_HAVE_LOG MOZ_LAYERS_LOG((" ----- (beginning paint)")); Log(); #endif NS_ASSERTION(InConstruction(), "Should be in construction phase"); mPhase = PHASE_DRAWING; ClientLayer* root = ClientLayer::ToClientLayer(GetRoot()); mTransactionIncomplete = false; // Apply pending tree updates before recomputing effective // properties. GetRoot()->ApplyPendingUpdatesToSubtree(); mPaintedLayerCallback = aCallback; mPaintedLayerCallbackData = aCallbackData; GetRoot()->ComputeEffectiveTransforms(Matrix4x4()); // Skip the painting if the device is in device-reset status. if (!gfxPlatform::GetPlatform()->DidRenderingDeviceReset()) { if (gfxPrefs::AlwaysPaint() && XRE_IsContentProcess()) { TimeStamp start = TimeStamp::Now(); root->RenderLayer(); mLastPaintTime = TimeStamp::Now() - start; } else { root->RenderLayer(); } } else { gfxCriticalNote << "LayerManager::EndTransaction skip RenderLayer()."; } if (!mRepeatTransaction && !GetRoot()->GetInvalidRegion().IsEmpty()) { GetRoot()->Mutated(); } if (!mIsRepeatTransaction) { mAnimationReadyTime = TimeStamp::Now(); GetRoot()->StartPendingAnimations(mAnimationReadyTime); } mPaintedLayerCallback = nullptr; mPaintedLayerCallbackData = nullptr; // Go back to the construction phase if the transaction isn't complete. // Layout will update the layer tree and call EndTransaction(). mPhase = mTransactionIncomplete ? PHASE_CONSTRUCTION : PHASE_NONE; NS_ASSERTION(!aCallback || !mTransactionIncomplete, "If callback is not null, transaction must be complete"); if (gfxPlatform::GetPlatform()->DidRenderingDeviceReset()) { FrameLayerBuilder::InvalidateAllLayers(this); } if (startTime) { PaintTiming& pt = mForwarder->GetPaintTiming(); pt.rasterMs() = (TimeStamp::Now() - startTime.value()).ToMilliseconds(); } return !mTransactionIncomplete; }