void ResultsTree::ShowHiddenResults()
{
//Clear the "hide" flag for each item
int filecount = mModel.rowCount();
for (int i = 0; i < filecount; i++) {
QStandardItem *file = mModel.item(i, 0);
if (!file)
continue;
QVariantMap data = file->data().toMap();
data["hide"] = false;
file->setData(QVariant(data));
int errorcount = file->rowCount();
for (int j = 0; j < errorcount; j++) {
QStandardItem *child = file->child(j, 0);
if (child) {
data = child->data().toMap();
data["hide"] = false;
child->setData(QVariant(data));
}
}
}
RefreshTree();
emit ResultsHidden(false);
}
LRESULT CHookedDlg::OnInitDialog(UINT , WPARAM , LPARAM , BOOL& )
{
DlgResize_Init();
CenterWindow(GetParent());
SetIcon(LoadIcon(_Module.GetResourceInstance(), MAKEINTRESOURCE(IDR_MAINFRAME)));
// Attach to controls
m_hookedTree.Attach(GetDlgItem(IDC_TREE_HOOKS));
m_unhookButton.Attach(GetDlgItem(IDC_UNHOOK));
m_closeButton.Attach(GetDlgItem(IDCANCEL));
// Setup image list
if(!m_imageList.Create(IDB_MODULES, 16, 1, RGB(0, 128, 128)))
{
return -1;
}
m_hookedTree.SetImageList(m_imageList, TVSIL_NORMAL);
// Render all hooked functions
RefreshTree();
return 0;
}
void SDetailsViewBase::UpdateFilteredDetails()
{
auto RootPropertyNode = GetRootNode();
if (RootPropertyNode.IsValid())
{
RootPropertyNode->FilterNodes(CurrentFilter.FilterStrings);
RootPropertyNode->ProcessSeenFlags(true);
for (int32 NodeIndex = 0; NodeIndex < ExternalRootPropertyNodes.Num(); ++NodeIndex)
{
TSharedPtr<FPropertyNode> PropertyNode = ExternalRootPropertyNodes[NodeIndex].Pin();
if (PropertyNode.IsValid())
{
PropertyNode->FilterNodes(CurrentFilter.FilterStrings);
PropertyNode->ProcessSeenFlags(true);
}
}
if (DetailLayout.IsValid())
{
DetailLayout->FilterDetailLayout(CurrentFilter);
}
RootTreeNodes = DetailLayout->GetRootTreeNodes();
}
RefreshTree();
}
void ResultsTree::ShowResults(ShowTypes::ShowType type, bool show)
{
if (type != ShowTypes::ShowNone && mShowSeverities.isShown(type) != show) {
mShowSeverities.show(type, show);
RefreshTree();
}
}
void ResultsTree::ShowResults(ShowTypes type, bool show)
{
if (type != SHOW_NONE && mShowTypes[type] != show)
{
mShowTypes[type] = show;
RefreshTree();
}
}
LRESULT CHookedDlg::OnUnhookAll(WORD /*wNotifyCode*/, WORD wID, HWND /*hWndCtl*/, BOOL& /*bHandled*/)
{
UnhookAll();
CMainFrame::Instance().m_ExportView.OnRefresh();
RefreshTree();
return 0;
}
void MyGameTreeCtrl::OnShowWindow(BOOL bShow, UINT nStatus)
{
if( !m_bInsertData )
{
RefreshTree();
}
CMyBtnTreeCtrl::OnShowWindow(bShow, nStatus);
}
void FDetailCategoryImpl::OnAdvancedDropdownClicked()
{
bUserShowAdvanced = !bUserShowAdvanced;
GConfig->SetBool( TEXT("DetailCategoriesAdvanced"), *CategoryPathName, bUserShowAdvanced, GEditorUserSettingsIni );
const bool bRefilterCategory = true;
RefreshTree( bRefilterCategory );
}
BOOL EditMetricsDlg::OnInitDialog()
{
CDialog::OnInitDialog();
// TODO: Add extra initialization here
RefreshTree();
return TRUE; // return TRUE unless you set the focus to a control
// EXCEPTION: OCX Property Pages should return FALSE
}
NS_IMETHODIMP nsAbView::Observe(nsISupports *aSubject, const char *aTopic, const PRUnichar *someData)
{
if (!strcmp(aTopic, NS_PREFBRANCH_PREFCHANGE_TOPIC_ID)) {
if (nsDependentString(someData).EqualsLiteral(PREF_MAIL_ADDR_BOOK_LASTNAMEFIRST)) {
nsresult rv = SetGeneratedNameFormatFromPrefs();
NS_ENSURE_SUCCESS(rv, rv);
rv = RefreshTree();
NS_ENSURE_SUCCESS(rv, rv);
}
}
return NS_OK;
}
LRESULT CWindowTreeDlg::DoCommand(int id, int /*msg*/)
{
switch (id)
{
case IDOK:
m_SelectedWindow = GetSelectedWindowHandle();
case IDCANCEL:
EndDialog(*this, id);
break;
case IDC_REFRESH:
RefreshTree();
break;
}
return 1;
}
LRESULT CWindowTreeDlg::DlgFunc(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
UNREFERENCED_PARAMETER(lParam);
switch (uMsg)
{
case WM_INITDIALOG:
{
InitDialog(hwndDlg, IDI_SENDMESSAGE);
m_resizer.Init(hwndDlg);
m_resizer.AddControl(hwndDlg, IDC_WINDOWTREE, RESIZER_TOPLEFTBOTTOMRIGHT);
m_resizer.AddControl(hwndDlg, IDC_REFRESH, RESIZER_BOTTOMRIGHT);
m_resizer.AddControl(hwndDlg, IDOK, RESIZER_BOTTOMRIGHT);
m_resizer.AddControl(hwndDlg, IDCANCEL, RESIZER_BOTTOMRIGHT);
ExtendFrameIntoClientArea(IDC_WINDOWTREE, IDC_WINDOWTREE, IDC_WINDOWTREE, IDC_WINDOWTREE);
m_aerocontrols.SubclassControl(GetDlgItem(*this, IDC_REFRESH));
m_aerocontrols.SubclassControl(GetDlgItem(*this, IDOK));
m_aerocontrols.SubclassControl(GetDlgItem(*this, IDCANCEL));
if (m_Dwm.IsDwmCompositionEnabled())
m_resizer.ShowSizeGrip(false);
RefreshTree();
}
return FALSE;
case WM_COMMAND:
return DoCommand(LOWORD(wParam), HIWORD(wParam));
case WM_SIZE:
{
m_resizer.DoResize(LOWORD(lParam), HIWORD(lParam));
}
break;
case WM_GETMINMAXINFO:
{
MINMAXINFO * mmi = (MINMAXINFO*)lParam;
mmi->ptMinTrackSize.x = m_resizer.GetDlgRect()->right;
mmi->ptMinTrackSize.y = m_resizer.GetDlgRect()->bottom;
return 0;
}
break;
default:
return FALSE;
}
return FALSE;
}
void RefreshTree(HWND hwndDlg, HTREEITEM hti)
{
HWND htree = GetDlgItem(hwndDlg, IDC_ROWTREE);
pROWCELL cell;
TVITEM tvi = { 0 };
if (hti == NULL) hti = TreeView_GetRoot(htree);
while (hti)
{
tvi.hItem = hti;
tvi.mask = TVIF_HANDLE;//|TVIF_IMAGE|TVIF_SELECTEDIMAGE|TVIF_TEXT;
TreeView_GetItem(htree, &tvi);
cell = (pROWCELL)tvi.lParam;
if (cell)
{
TCHAR buf[200] = { 0 };
if (!cell->child)
{
if (cell->type == 0)
mir_sntprintf(buf, TranslateT("Empty %s cell"), cell->cont == TC_COL ? TranslateT("column") : TranslateT("line"));
else
mir_tstrncpy(buf, TranslateTS(types[cell->type]), _countof(buf));
}
else
{
if (cell->type == 0)
mir_tstrncpy(buf, (cell->cont != TC_COL ? TranslateT("columns") : TranslateT("lines")), _countof(buf));
else
mir_sntprintf(buf, TranslateT("%s, contain %s"), TranslateTS(types[cell->type]), cell->cont != TC_COL ? TranslateT("columns") : TranslateT("lines"));
}
if (cell->layer) mir_tstrncat(buf, TranslateT(" layered"), _countof(buf) - mir_tstrlen(buf));
tvi.mask = TVIF_HANDLE | TVIF_TEXT;
tvi.pszText = buf;
TreeView_SetItem(htree, &tvi);
}
{
HTREEITEM child_hti = TreeView_GetChild(htree, hti);
if (child_hti) RefreshTree(hwndDlg, child_hti);
}
hti = TreeView_GetNextSibling(htree, hti);
}
RedrawWindow(hwndDlg, NULL, NULL, RDW_INVALIDATE | RDW_ERASE | RDW_UPDATENOW | RDW_ALLCHILDREN);
}
void SHierarchyView::Tick( const FGeometry& AllottedGeometry, const double InCurrentTime, const float InDeltaTime )
{
if ( bRebuildTreeRequested || bRefreshRequested )
{
if ( bRebuildTreeRequested )
{
RebuildTreeView();
}
RefreshTree();
RestoreExpandedItems();
OnEditorSelectionChanged();
bRefreshRequested = false;
bRebuildTreeRequested = false;
}
}
INT_PTR CALLBACK DlgTmplEditorOpts(HWND hwndDlg, UINT msg, WPARAM wParam, LPARAM lParam)
{
switch (msg) {
case WM_INITDIALOG:
{
int hbuf = 0, seq = 0;
HWND htree = GetDlgItem(hwndDlg, IDC_ROWTREE);
TranslateDialogDefault(hwndDlg);
rowOptTmplStr = db_get_sa(NULL, "ModernData", "RowTemplate");
if (!rowOptTmplStr)
rowOptTmplStr = mir_strdup("<TR />");
SendDlgItemMessage(hwndDlg, IDC_SPINCONTWIDTH, UDM_SETRANGE, 0, MAKELONG(999, 0));
SendDlgItemMessage(hwndDlg, IDC_SPINCONTHEIGHT, UDM_SETRANGE, 0, MAKELONG(999, 0));
int i, item;
for (i = 0; i < _countof(types); i++) {
item = SendDlgItemMessage(hwndDlg, IDC_CONTTYPE, CB_ADDSTRING, 0, (LPARAM)TranslateTS(types[i]));
SendDlgItemMessage(hwndDlg, IDC_CONTTYPE, CB_SETITEMDATA, item, 0);
}
SendDlgItemMessage(hwndDlg, IDC_CONTTYPE, CB_SETCURSEL, 0, 0);
TCHAR *h_alignment[] = { _T("left"), _T("hCenter"), _T("right") };
for (i = 0; i < _countof(h_alignment); i++) {
item = SendDlgItemMessage(hwndDlg, IDC_HALIGN, CB_ADDSTRING, 0, (LPARAM)TranslateTS(h_alignment[i]));
SendDlgItemMessage(hwndDlg, IDC_HALIGN, CB_SETITEMDATA, item, 0);
}
SendDlgItemMessage(hwndDlg, IDC_HALIGN, CB_SETCURSEL, 0, 0);
TCHAR *v_alignment[] = { _T("top"), _T("vCenter"), _T("bottom") };
for (i = 0; i < _countof(v_alignment); i++) {
item = SendDlgItemMessage(hwndDlg, IDC_VALIGN, CB_ADDSTRING, 0, (LPARAM)TranslateTS(v_alignment[i]));
SendDlgItemMessage(hwndDlg, IDC_VALIGN, CB_SETITEMDATA, item, 0);
}
SendDlgItemMessage(hwndDlg, IDC_VALIGN, CB_SETCURSEL, 0, 0);
rowDeleteTree(rowOptTmplRoot);
rowOptTmplRoot = NULL;
rowParse(rowOptTmplRoot, rowOptTmplRoot, rowOptTmplStr, hbuf, seq, rowOptTA);
seq = 0;
memset(rowOptTA, 0, sizeof(rowOptTA));
rowOptBuildTA(rowOptTmplRoot, (pROWCELL*)&rowOptTA, &seq);
rowOptFillRowTree(htree);
RefreshTree(hwndDlg, NULL);
TreeView_SelectItem(GetDlgItem(hwndDlg, IDC_ROWTREE), TreeView_GetRoot(GetDlgItem(hwndDlg, IDC_ROWTREE)));
rowOptShowSettings(hwndDlg);
}
return TRUE;
case WM_COMMAND:
{
HWND htree = GetDlgItem(hwndDlg, IDC_ROWTREE);
pROWCELL cell;
TVITEM tvi = { 0 };
HTREEITEM hti = TreeView_GetSelection(htree);
tvi.hItem = hti;
tvi.mask = TVIF_HANDLE | TVIF_IMAGE | TVIF_SELECTEDIMAGE;
TreeView_GetItem(htree, &tvi);
cell = (pROWCELL)tvi.lParam;
switch (LOWORD(wParam)) {
case IDC_CONTTYPE:
if (HIWORD(wParam) == CBN_SELENDOK) {
int index = SendDlgItemMessage(hwndDlg, IDC_CONTTYPE, CB_GETCURSEL, 0, 0);
cell->type = index;
RefreshTree(hwndDlg, NULL);
}
case IDC_VALIGN:
if (HIWORD(wParam) == CBN_SELENDOK) {
switch (SendDlgItemMessage(hwndDlg, IDC_VALIGN, CB_GETCURSEL, 0, 0)) {
case 0:
cell->valign = TC_TOP;
break;
case 1:
cell->valign = TC_VCENTER;
break;
case 2:
cell->valign = TC_BOTTOM;
break;
}
RefreshTree(hwndDlg, NULL);
}
case IDC_HALIGN:
if (HIWORD(wParam) == CBN_SELENDOK) {
switch (SendDlgItemMessage(hwndDlg, IDC_HALIGN, CB_GETCURSEL, 0, 0)) {
case 0:
cell->halign = TC_LEFT;
break;
case 1:
cell->halign = TC_HCENTER;
break;
case 2:
cell->halign = TC_RIGHT;
break;
}
RefreshTree(hwndDlg, NULL);
}
}
if (HIWORD(wParam) == BN_CLICKED) {
if (lParam == (LPARAM)GetDlgItem(hwndDlg, IDC_ADDCONTAINER))
// Adding new container
{
rowOptAddContainer(htree, hti);
}
else if (lParam == (LPARAM)GetDlgItem(hwndDlg, IDC_DELCONTAINER))
// Deleting container
{
rowOptDelContainer(htree, hti);
}
else if (lParam == (LPARAM)GetDlgItem(hwndDlg, IDC_CONTUP))
// Moving container to up
{
RedrawWindow(htree, &da, NULL, RDW_INVALIDATE | RDW_ERASE | RDW_UPDATENOW | RDW_ALLCHILDREN);
}
RefreshTree(hwndDlg, NULL);
RedrawWindow(GetParent(hwndDlg), NULL, NULL, RDW_INVALIDATE | RDW_ERASE | RDW_UPDATENOW | RDW_ALLCHILDREN);
}
return TRUE;
}
case WM_NOTIFY:
switch (((LPNMHDR)lParam)->idFrom) {
case IDC_ROWTREE:
if (((LPNMHDR)lParam)->code == NM_SETCURSOR)
rowOptShowSettings(hwndDlg);
if (((LPNMHDR)lParam)->code == NM_CLICK)
RedrawWindow(hwndDlg, &da, NULL, RDW_INVALIDATE | RDW_ERASE | RDW_UPDATENOW);
break;
case 0: // Apply or Ok button is pressed
return FALSE; // Temporary
break;
}
return TRUE;
case WM_PAINT:
if (rowOptTmplRoot) {
int i = 0;
// Drawning row template at properties page
PAINTSTRUCT ps;
HDC hdc = BeginPaint(hwndDlg, &ps);
TVITEM curItem;
curItem.hItem = TreeView_GetSelection(GetDlgItem(hwndDlg, IDC_ROWTREE));
curItem.mask = TVIF_HANDLE | TVIF_IMAGE | TVIF_SELECTEDIMAGE;
TreeView_GetItem(GetDlgItem(hwndDlg, IDC_ROWTREE), &curItem);
while (rowOptTA[i]) {
switch (rowOptTA[i]->type) {
case TC_AVATAR:
rowOptTA[i]->w = 25;
rowOptTA[i]->h = 30;
break;
case TC_STATUS:
case TC_EXTRA1:
case TC_EXTRA2:
case TC_EXTRA3:
case TC_EXTRA4:
case TC_EXTRA5:
case TC_EXTRA6:
case TC_EXTRA7:
case TC_EXTRA8:
case TC_EXTRA9:
rowOptTA[i]->w = 16;
rowOptTA[i]->h = 16;
break;
case TC_EXTRA:
rowOptTA[i]->w = 112;
rowOptTA[i]->h = 16;
break;
case TC_TEXT1:
case TC_TEXT2:
case TC_TEXT3:
rowOptTA[i]->w = 200;
rowOptTA[i]->h = 16;
break;
case TC_TIME:
rowOptTA[i]->w = 30;
rowOptTA[i]->h = 10;
default:
rowOptTA[i]->w = 0;
rowOptTA[i]->h = 0;
}
i++;
}
rowSizeWithReposition(rowOptTmplRoot, da.right - da.left);
i = -1;
while (rowOptTA[++i]) {
switch (rowOptTA[i]->type) {
case TC_SPACE:
case TC_FIXED:
case 0:
//if (rowOptTA[i] != (pROWCELL)curItem.lParam)
continue;
}
Rectangle(hdc,
rowOptTA[i]->r.left + da.left,
rowOptTA[i]->r.top + da.top,
rowOptTA[i]->r.right + da.left,
rowOptTA[i]->r.bottom + da.top);
}
EndPaint(hwndDlg, &ps);
return FALSE;
}
}
return FALSE;
}
/*
______________________________________________________________________________________________
Main
______________________________________________________________________________________________
*/
int main(int argc, char *argv[])
{
// --- Init Cluster variable ---------------------------------------------------------
// carmen 0 => local execution i.e. show time on screen
// carmen 1 => cluster execution i.e. refresh Performance.dat (default)
#if defined PARMPI
// --- MPI Runtime system initialization
// size - total number of processors
// rnak - current CPU
MPI_Init(&argc,&argv);
MPI_Comm_size(MPI_COMM_WORLD, &size);
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
#else
size=1;
rank=0;
#endif
if (argc == 2)
Cluster = atoi(argv[1]);
// --- Print messages on screen- -----------------------------------------------------
cout << "carmen: begin execution.\n\n";
printf("Carmen %4.2f \n",CarmenVersion);
cout << "Copyright (C) 2000-2005 by Olivier Roussel.\n";
cout << "All rights reserved.\n\n";
#if defined PARMPI
//Synchronize all parallel branches
MPI_Barrier(MPI_COMM_WORLD);
#endif
CPUTime.start();
// --- Create first node of the tree structure ---------------------------------------
Node *Mesh=0;
FineMesh *FMesh=0;
// --- Init global values (See Parameters.h and Parameters.cpp) ----------------------------
cout << "carmen: init computation ...\n";
InitParameters();
// --- Debug output information for parallel execution -------------------------------------
#if defined PARMPI
if (Multiresolution)
{
printf("\nParallel Multiresolution solver not implemented yet!\n");
exit(0);
}
printf("My Rank=%d\n",rank);
// --- Each CPU print his coordinates in the virtual processor cart ------------------------
printf("Cart_i = %d; Cart_j = %d; Cart_k = %d;\n",coords[0],coords[1],coords[2]);
// --- Each CPU print his computation domain
printf("Xmin = %lf; XMax = %lf;\n",XMin[1],XMax[1]);
printf("Ymin = %lf; YMax = %lf;\n",XMin[2],XMax[2]);
printf("Zmin = %lf; ZMax = %lf;\n",XMin[3],XMax[3]);
// --- And the local scale number ----------------------------------------------------------
printf("ScaleNb = %d\n",ScaleNb);
#endif
// --- Allocate ----------------------------------------------------------------------------
if (Multiresolution)
Mesh = new Node;
else
FMesh = new FineMesh;
// --- Init tree structure -----------------------------------------------------------------
if (Multiresolution)
{
InitTree(Mesh);
RefreshTree(Mesh);
}
// --- Compute initial integral values and init time step ----------------------------------
if (Multiresolution)
Mesh->computeIntegral();
else
FMesh->computeIntegral();
// -- Write integral values --
// -- Compute initial time step --
InitTimeStep();
if (rank==0) PrintIntegral("Integral.dat");
// --- Save initial values into files ------------------------------------------------------
if (PrintEvery == 0)
{
if (Multiresolution)
View(Mesh, "Tree_0.dat", "Mesh_0.dat", "Average_0.dat");
else
View(FMesh,"Average_0.dat");
}
// --- When PrintEvery != 0, save initial values into specific name format ---
if (PrintEvery != 0)
{
if (Multiresolution)
ViewEvery(Mesh, 0);
else
ViewEvery(FMesh, 0);
}
// --- Parallel execution only --------------------------------------------
// --- Save to disk DX header for ouput files -----------------------------
// --- This file is needed for the external postprocessing (merging files from the different processors)
#if defined PARMPI
real tempXMin[4];
real tempXMax[4];
// --- Save original task parameters for the parallel execution
int tempScaleNb=ScaleNb;
// --- Simulate sequantial running
ScaleNb=AllTaskScaleNb;
for (int i=0;i<4;i++)
{
tempXMin[i]=XMin[i];
tempXMax[i]=XMax[i];
// --- Simulate sequantial running
XMin[i]=AllXMin[i];
XMax[i]=AllXMax[i];
}
// --- Write header with parameters, as we have run sequantial code
if (rank==0) FMesh->writeHeader("header.txt");
// Restore variables
for (int i=0;i<4;i++)
{
XMin[i]=tempXMin[i];
XMax[i]=tempXMax[i];
}
ScaleNb=tempScaleNb;
#endif
// --- Done ---
cout << "carmen: done.\n";
// --- Write solver type ---
if (Multiresolution)
cout << "carmen: multiresolution (MR) solver.\n";
else
cout << "carmen: finite volume (FV) solver.\n";
// --- Write number of iterations ---
if (IterationNb == 1)
cout << "carmen: compute 1 iteration ...\n";
else
cout << "carmen: compute " << IterationNb << " iterations ...\n";
printf("\n\n\n");
// --- Begin time iteration ----------------------------------------------------------------
for (IterationNo = 1; IterationNo <= IterationNb; IterationNo++)
{
// --- Time evolution procedure ---
if (Multiresolution)
TimeEvolution(Mesh);
else
TimeEvolution(FMesh);
// --- Remesh ---
if (Multiresolution) Remesh(Mesh);
// --- Check CPU Time ---
CPUTime.check();
// --- Write information every (Refresh) iteration ---
if ((IterationNo-1)%Refresh == 0)
{
// - Write integral values -
if (rank==0) PrintIntegral("Integral.dat");
if (Cluster == 0)
ShowTime(CPUTime); // Show time on screen
//else
if (rank==0) Performance("carmen.prf"); // Refresh file "carmen.prf"
}
// --- Backup data every (10*Refresh) iteration ---
if ((IterationNo-1)%(10*Refresh) == 0 && UseBackup)
{
if (Multiresolution)
Backup(Mesh);
else
Backup(FMesh);
}
// --- Print solution if IterationNo = PrintIt1 to PrintIt6 ---
if (Multiresolution)
ViewIteration(Mesh);
else
ViewIteration(FMesh);
// --- Print solution if IterationNo is a multiple of PrintEvery ---
if (PrintEvery != 0)
{
if (IterationNo%PrintEvery == 0)
{
if (Multiresolution)
ViewEvery(Mesh, IterationNo);
else
ViewEvery(FMesh, IterationNo);
}
}
// --- End time iteration ------------------------------------------------------------------
}
// --- Backup final data ------------------------------------------------------------------
IterationNo--;
if (UseBackup)
{
if (Multiresolution)
Backup(Mesh);
else
Backup(FMesh);
}
// --- Write integral values ---------------------------------------------------------------
if (rank==0) PrintIntegral("Integral.dat");
IterationNo++;
// --- Save values into file ---------------------------------------------------------------
if (Multiresolution)
View(Mesh, "Tree.dat", "Mesh.dat", "Average.dat");
else
View(FMesh, "Average.dat");
cout << "\ncarmen: done.\n";
// --- Analyse performance and save it into file -------------------------------------------
if (rank==0) Performance("carmen.prf");
// --- End ---------------------------------------------------------------------------------
if (Multiresolution)
delete Mesh;
else
delete FMesh;
#if defined PARMPI
//free memory for the MPI runtime variables
delete[] disp;
delete[] blocklen;
int sz;
MPI_Buffer_detach(&MPIbuffer,&sz);
// for (int i = 0; i < 4*Dimension; i++) MPI_Request_free(&req[i]);
MPI_Finalize();
#endif
cout <<"carmen: end execution.\n";
return EXIT_SUCCESS;
}
NS_IMETHODIMP nsAbView::SwapFirstNameLastName()
{
if (!mTreeSelection)
return NS_OK;
PRInt32 selectionCount;
nsresult rv = mTreeSelection->GetRangeCount(&selectionCount);
NS_ENSURE_SUCCESS(rv, rv);
if (!selectionCount)
return NS_OK;
// Prepare for displayname generation
// No cache for pref and bundle since the swap operation is not executed frequently
bool displayNameAutoGeneration;
bool displayNameLastnamefirst = false;
nsCOMPtr<nsIPrefBranch2> pPrefBranchInt(do_GetService(NS_PREFSERVICE_CONTRACTID, &rv));
NS_ENSURE_SUCCESS(rv, rv);
rv = pPrefBranchInt->GetBoolPref(PREF_MAIL_ADDR_BOOK_DISPLAYNAME_AUTOGENERATION, &displayNameAutoGeneration);
NS_ENSURE_SUCCESS(rv, rv);
nsCOMPtr<nsIStringBundle> bundle;
if (displayNameAutoGeneration)
{
nsCOMPtr<nsIPrefLocalizedString> pls;
rv = pPrefBranchInt->GetComplexValue(PREF_MAIL_ADDR_BOOK_DISPLAYNAME_LASTNAMEFIRST,
NS_GET_IID(nsIPrefLocalizedString), getter_AddRefs(pls));
NS_ENSURE_SUCCESS(rv, rv);
nsString str;
pls->ToString(getter_Copies(str));
displayNameLastnamefirst = str.EqualsLiteral("true");
nsCOMPtr<nsIStringBundleService> bundleService = do_GetService(NS_STRINGBUNDLE_CONTRACTID, &rv);
NS_ENSURE_SUCCESS(rv, rv);
rv = bundleService->CreateBundle("chrome://messenger/locale/addressbook/addressBook.properties",
getter_AddRefs(bundle));
NS_ENSURE_SUCCESS(rv, rv);
}
for (PRInt32 i = 0; i < selectionCount; i++)
{
PRInt32 startRange;
PRInt32 endRange;
rv = mTreeSelection->GetRangeAt(i, &startRange, &endRange);
NS_ENSURE_SUCCESS(rv, NS_OK);
PRInt32 totalCards = mCards.Count();
if (startRange >= 0 && startRange < totalCards)
{
for (PRInt32 rangeIndex = startRange; rangeIndex <= endRange && rangeIndex < totalCards; rangeIndex++) {
nsCOMPtr<nsIAbCard> abCard;
rv = GetCardFromRow(rangeIndex, getter_AddRefs(abCard));
NS_ENSURE_SUCCESS(rv, rv);
// Swap FN/LN
nsAutoString fn, ln;
abCard->GetFirstName(fn);
abCard->GetLastName(ln);
if (!fn.IsEmpty() || !ln.IsEmpty())
{
abCard->SetFirstName(ln);
abCard->SetLastName(fn);
// Generate display name using the new order
if (displayNameAutoGeneration &&
!fn.IsEmpty() && !ln.IsEmpty())
{
nsString dnLnFn;
nsString dnFnLn;
const PRUnichar *nameString[2];
const PRUnichar *formatString;
// The format should stays the same before/after we swap the names
formatString = displayNameLastnamefirst ?
NS_LITERAL_STRING("lastFirstFormat").get() :
NS_LITERAL_STRING("firstLastFormat").get();
// Generate both ln/fn and fn/ln combination since we need both later
// to check to see if the current display name was edited
// note that fn/ln still hold the values before the swap
nameString[0] = ln.get();
nameString[1] = fn.get();
rv = bundle->FormatStringFromName(formatString,
nameString, 2, getter_Copies(dnLnFn));
NS_ENSURE_SUCCESS(rv, rv);
nameString[0] = fn.get();
nameString[1] = ln.get();
rv = bundle->FormatStringFromName(formatString,
nameString, 2, getter_Copies(dnFnLn));
NS_ENSURE_SUCCESS(rv, rv);
// Get the current display name
nsAutoString dn;
rv = abCard->GetDisplayName(dn);
NS_ENSURE_SUCCESS(rv, rv);
// Swap the display name if not edited
if (displayNameLastnamefirst)
{
if (dn.Equals(dnLnFn))
abCard->SetDisplayName(dnFnLn);
}
else
{
if (dn.Equals(dnFnLn))
abCard->SetDisplayName(dnLnFn);
}
}
// Swap phonetic names
rv = abCard->GetPropertyAsAString(kPhoneticFirstNameProperty, fn);
NS_ENSURE_SUCCESS(rv, rv);
rv = abCard->GetPropertyAsAString(kPhoneticLastNameProperty, ln);
NS_ENSURE_SUCCESS(rv, rv);
if (!fn.IsEmpty() || !ln.IsEmpty())
{
abCard->SetPropertyAsAString(kPhoneticFirstNameProperty, ln);
abCard->SetPropertyAsAString(kPhoneticLastNameProperty, fn);
}
}
}
}
}
// Update the tree
// Re-sort if either generated or phonetic name is primary or secondary sort,
// otherwise invalidate to reflect the change
rv = RefreshTree();
return rv;
}
void ResultsTree::FilterResults(const QString& filter)
{
mFilter = filter;
RefreshTree();
}
void MyGameTreeCtrl::IQQItemChangeOb_CountChange( unsigned int iNewCount )
{
RefreshTree();
}
void SDetailsViewBase::UpdateFilteredDetails()
{
RootTreeNodes.Reset();
FDetailNodeList InitialRootNodeList;
NumVisbleTopLevelObjectNodes = 0;
FRootPropertyNodeList& RootPropertyNodes = GetRootNodes();
CurrentFilter.bShowAllAdvanced = GetDefault<UEditorStyleSettings>()->bShowAllAdvancedDetails;
for(int32 RootNodeIndex = 0; RootNodeIndex < RootPropertyNodes.Num(); ++RootNodeIndex)
{
TSharedPtr<FComplexPropertyNode>& RootPropertyNode = RootPropertyNodes[RootNodeIndex];
if(RootPropertyNode.IsValid())
{
RootPropertyNode->FilterNodes(CurrentFilter.FilterStrings);
RootPropertyNode->ProcessSeenFlags(true);
for(int32 NodeIndex = 0; NodeIndex < ExternalRootPropertyNodes.Num(); ++NodeIndex)
{
TSharedPtr<FPropertyNode> PropertyNode = ExternalRootPropertyNodes[NodeIndex].Pin();
if(PropertyNode.IsValid())
{
PropertyNode->FilterNodes(CurrentFilter.FilterStrings);
PropertyNode->ProcessSeenFlags(true);
}
}
TSharedPtr<FDetailLayoutBuilderImpl>& DetailLayout = DetailLayouts[RootNodeIndex].DetailLayout;
if(DetailLayout.IsValid())
{
DetailLayout->FilterDetailLayout(CurrentFilter);
}
FDetailNodeList& LayoutRoots = DetailLayout->GetRootTreeNodes();
if(LayoutRoots.Num() > 0)
{
// A top level object nodes has a non-filtered away root so add one to the total number we have
++NumVisbleTopLevelObjectNodes;
InitialRootNodeList.Append(LayoutRoots);
}
}
}
// for multiple top level object we need to do a secondary pass on top level object nodes after we have determined if there is any nodes visible at all. If there are then we ask the details panel if it wants to show childen
for(TSharedRef<class IDetailTreeNode> RootNode : InitialRootNodeList)
{
if(RootNode->ShouldShowOnlyChildren())
{
RootNode->GetChildren(RootTreeNodes);
}
else
{
RootTreeNodes.Add(RootNode);
}
}
RefreshTree();
}
