wxDataViewItem GetPrevItem( wxDataViewCtrl const& aView, wxDataViewItem const& aItem )
{
auto prevItem = GetPrevSibling( aView, aItem );
if( !prevItem.IsOk() )
{
prevItem = aView.GetModel()->GetParent( aItem );
}
else if( aView.IsExpanded( prevItem ) )
{
wxDataViewItemArray children;
aView.GetModel()->GetChildren( prevItem, children );
prevItem = children[children.size() - 1];
}
return prevItem;
}
//******************************************************************
// Function Name : GetPrevInDisplayOrder
// Function :
// Param : void
// Return : SECTreeNode *
// Create :
// Update : ±èÁ¤¹®, 2009/10/09 VS 2008 Upgrade¸¦ À§ÇÑ ÀÛ¾÷
// Comment :
//******************************************************************
SECTreeNode *SECTreeNode::GetPrevInDisplayOrder(void) const
{
if( GetPrevSibling() )
{
SECTreeNode *pBRC=GetPrevSibling()->GetBottomRightChild();
if( pBRC )
return pBRC;
return GetPrevSibling();
}
return GetParent();
}
void P3DPlantModelTreeCtrl::OnSetStemModelQuadClick
(wxCommandEvent &event)
{
P3DBranchModel *BranchModel;
P3DStemModel *StemModel;
BranchModel = ((P3DPlantModelTreeCtrlItemData*)(GetItemData(GetSelection())))->GetBranchModel();
StemModel = P3DApp::GetApp()->CreateStemModelQuad();
unsigned int SubBranchIndex;
wxTreeItemId ItemId;
wxTreeItemId ParentItemId;
SubBranchIndex = 0;
ItemId = GetSelection();
ParentItemId = GetItemParent(ItemId);
while ((ItemId = GetPrevSibling(ItemId)).IsOk())
{
SubBranchIndex++;
}
P3DApp::GetApp()->ExecEditCmd
(new ChangeStemModelCommand
(GetBranchModelByItemId(ParentItemId),
SubBranchIndex,
BranchModel,
StemModel,
(ParentItemId == GetRootItem()) ?
(P3DBranchingAlg*)new P3DBranchingAlgBase() :
(P3DBranchingAlg*)new P3DBranchingAlgStd(),
this,
BranchPanel));
}
// Returns TRUE if we're at the end of the tab list
static BOOL NEAR
AtEndOfTabList(HWND hwndDlg)
{
HWND hCtl;
BOOL bShift;
// See whether we should check for the end of the tab list or
// the shift-tab list
bShift = GetKeyState(VK_SHIFT) < 0;
// Get the control that currently has focus
hCtl = GetFocus();
assert(IsChild(hwndDlg, hCtl));
// Get the first-level child for the control. This matters for controls
// like a combo box which have child windows
while (GetParent(hCtl) != hwndDlg)
hCtl = GetParent(hCtl);
// Look for another child window that's enabled and wants TAB keys
do {
hCtl = bShift ? GetPrevSibling(hCtl) : GetNextSibling(hCtl);
if (hCtl == NULL)
return TRUE; // no more child windows
} while ((GetWindowStyle(hCtl) & (WS_DISABLED | WS_TABSTOP)) != WS_TABSTOP);
return FALSE;
}
void P3DPlantModelTreeCtrl::OnRemoveStemClick
(wxCommandEvent &event)
{
P3DBranchModel *BranchModel;
P3DBranchModel *ParentBranchModel;
wxTreeItemId ParentId;
wxTreeItemId ItemId;
wxTreeItemId CurrItemId;
unsigned int SubBranchIndex;
ItemId = GetSelection();
ParentId = GetItemParent(ItemId);
if (!ParentId.IsOk())
{
return;
}
SubBranchIndex = 0;
CurrItemId = ItemId;
while (CurrItemId.IsOk())
{
SubBranchIndex++;
CurrItemId = GetPrevSibling(CurrItemId);
}
ParentBranchModel = ((P3DPlantModelTreeCtrlItemData*)(GetItemData(ParentId)))->GetBranchModel();
P3DApp::GetApp()->ExecEditCmd
(new P3DRemoveStemCommand(ParentBranchModel,SubBranchIndex - 1,this));
}
wxTreeItemId PHPFileLayoutTree::TryGetPrevItem(wxTreeItemId item)
{
wxCHECK_MSG(item.IsOk(), wxTreeItemId(), wxT("invalid tree item"));
// find out the starting point
wxTreeItemId prevItem = GetPrevSibling(item);
if(!prevItem.IsOk()) {
prevItem = GetItemParent(item);
if(prevItem == GetRootItem()) {
return wxTreeItemId();
}
}
// from there we must be able to navigate until this item
while(prevItem.IsOk()) {
ScrollTo(prevItem);
if(!IsVisible(prevItem)) {
return wxTreeItemId();
}
const wxTreeItemId nextItem = GetNextVisible(prevItem);
if(!nextItem.IsOk() || nextItem == item) return prevItem;
prevItem = nextItem;
}
return wxTreeItemId();
}
void WatchWindow::AddWatch(const wxString& expression)
{
wxString temp = expression;
temp.Trim().Trim(false);
if (!temp.empty())
{
wxTreeItemIdValue cookie;
wxTreeItemId lastItem = GetLastChild(m_root, cookie);
// The last item should be our blank item.
assert(lastItem.IsOk());
lastItem = GetPrevSibling(lastItem);
wxTreeItemId item;
if (lastItem.IsOk())
{
item = InsertItem(m_root, lastItem, temp);
}
else
{
item = PrependItem(m_root, temp);
}
UpdateItem(item);
}
}
void
nsFrameIterator::Prev()
{
// recursive-oid method to get prev frame
nsIFrame *result = nsnull;
nsIFrame *parent = getCurrent();
if (!parent)
parent = getLast();
if (mType == eLeaf) {
// Drill down to last leaf
while ((result = GetLastChild(parent))) {
parent = result;
}
} else if (mType == ePostOrder) {
result = GetLastChild(parent);
if (result)
parent = result;
}
if (parent != getCurrent()) {
result = parent;
} else {
while (parent) {
result = GetPrevSibling(parent);
if (result) {
if (mType != ePostOrder) {
parent = result;
while ((result = GetLastChild(parent))) {
parent = result;
}
result = parent;
}
break;
} else {
result = GetParentFrameNotPopup(parent);
if (!result || IsRootFrame(result) ||
(mLockScroll && result->GetType() == nsGkAtoms::scrollFrame)) {
result = nsnull;
break;
}
if (mType == ePreOrder)
break;
parent = result;
}
}
}
setCurrent(result);
if (!result) {
setOffEdge(-1);
setLast(parent);
}
}
// Get the prev sibling, or parents prev sibling, or grandpa's prev sibling...
nsINode*
nsContentIterator::GetPrevSibling(nsINode *aNode,
nsTArray<PRInt32> *aIndexes)
{
if (!aNode)
return nsnull;
nsINode *parent = aNode->GetNodeParent();
if (!parent)
return nsnull;
PRInt32 indx = 0;
NS_ASSERTION(!aIndexes || !aIndexes->IsEmpty(),
"ContentIterator stack underflow");
if (aIndexes && !aIndexes->IsEmpty())
{
// use the last entry on the Indexes array for the current index
indx = (*aIndexes)[aIndexes->Length()-1];
}
else
indx = mCachedIndex;
// reverify that the index of the current node hasn't changed
// ignore result this time - the index may now be out of range.
nsINode *sib = parent->GetChildAt(indx);
if (sib != aNode)
{
// someone changed our index - find the new index the painful way
indx = parent->IndexOf(aNode);
}
// indx is now canonically correct
if (indx > 0 && (sib = parent->GetChildAt(--indx)))
{
// update index cache
if (aIndexes && !aIndexes->IsEmpty())
{
aIndexes->ElementAt(aIndexes->Length()-1) = indx;
}
else mCachedIndex = indx;
}
else if (parent != mCommonParent)
{
if (aIndexes && !aIndexes->IsEmpty())
{
// pop node off the stack, go up one level and try again.
aIndexes->RemoveElementAt(aIndexes->Length()-1);
}
return GetPrevSibling(parent, aIndexes);
}
return sib;
}
bool CocaSystemTree::moveUp( const coca::INode& node )
{
wxTreeItemId id = findId( node );
if ( !id.IsOk() ) { return false; }
wxTreeItemId parentId = GetItemParent( id );
if ( !parentId.IsOk() ) { return false; }
wxTreeItemId previousId = GetPrevSibling( id );
if ( !previousId.IsOk() ) { return false; }
// ready to move
bool wasSelected = ( id == GetSelection() );
Delete( id );
previousId = GetPrevSibling( previousId );
if ( !previousId.IsOk() )
{
id = PrependItem( parentId,
EditorTools::getName( node ), EditorTools::getImageIndex( node ),
-1, new ItemData( node ) );
}
else
{
id = InsertItem( parentId, previousId,
EditorTools::getName( node ), EditorTools::getImageIndex( node ),
-1, new ItemData( node ) );
}
COCA_ASSERT( id.IsOk() );
SetItemTextColour( id, EditorTools::getTextColour( node ) );
addChildren( node, id );
if ( wasSelected ) { SelectItem( id ); }
return true;
}
BOOL WLTreeItemAL::Show(BOOL bShow)
{
if (bShow)
{
if (m_dwStatus & TIS_HIDE)
{
m_dwStatus &= ~TIS_HIDE ;
if (IsVisible())
{
// 通知父窗体高度变化
//long lNewHeight = m_szClient.cy ;
long lNewHeight = CalcBranchHeight() ;
NotifyParentHeightChanged(0, lNewHeight, FALSE) ;
int y = ((WLTreeItemAL*)GetParentItem())->GetItemHeight() ;
HWLTREEITEM hPrevSibling = GetPrevSibling() ;
while (hPrevSibling != NULL)
{
if (hPrevSibling->IsVisible())
{
RECT rcItem ;
hPrevSibling->GetRectInParent(&rcItem) ;
y = rcItem.bottom ;
break ;
}
hPrevSibling = hPrevSibling->GetPrevSibling() ;
}
SetWndLessPos(0, y, 0, lNewHeight, SWLP_Y | SWLP_CY | SWLP_SHOW) ;
}
return TRUE ;
}
}
else
{
if (!(m_dwStatus & TIS_HIDE))
{
m_dwStatus |= TIS_HIDE ;
if (!IsVisible())
{
// 通知父窗体高度变化
long lOldHeight = m_szClient.cy ;
NotifyParentHeightChanged(lOldHeight, 0, FALSE) ;
SetWndLessPos(0, 0, 0, 0, SWLP_HIDE) ;
}
return TRUE ;
}
}
return FALSE ;
}
void P3DPlantModelTreeCtrl::OnSetStemModelGMeshClick
(wxCommandEvent &event)
{
wxTreeItemId ItemId;
wxTreeItemId ParentItemId;
P3DBranchModel *BranchModel;
P3DBranchModel *NewBranchModel;
P3DStemModelGMesh *StemModel;
int PluginIndex;
const P3DPluginInfoVector &GMeshPlugins = P3DApp::GetApp()->GetGMeshPlugins();
unsigned int SubBranchIndex;
PluginIndex = event.GetId() - wxID_GMESH_PLUGIN_FIRST;
if ((PluginIndex < 0) || (PluginIndex >= GMeshPlugins.size()))
{
return;
}
ItemId = GetSelection();
ParentItemId = GetItemParent(ItemId);
BranchModel = ((P3DPlantModelTreeCtrlItemData*)(GetItemData(ItemId)))->GetBranchModel();
P3DGMeshData *MeshData = P3DPlugLuaRunGMeshGenerator(GMeshPlugins[PluginIndex].GetFileName());
if (MeshData == 0)
{
return;
}
StemModel = new P3DStemModelGMesh();
StemModel->SetMeshData(MeshData);
SubBranchIndex = 0;
while ((ItemId = GetPrevSibling(ItemId)).IsOk())
{
SubBranchIndex++;
}
P3DApp::GetApp()->ExecEditCmd
(new ChangeStemModelCommand
(GetBranchModelByItemId(ParentItemId),
SubBranchIndex,
BranchModel,
StemModel,
(ParentItemId == GetRootItem()) ?
(P3DBranchingAlg*)new P3DBranchingAlgBase() :
(P3DBranchingAlg*)new P3DBranchingAlgStd(),
this,
BranchPanel));
}
void P3DPlantModelTreeCtrl::OnSetStemModelWingsClick
(wxCommandEvent &event)
{
P3DBranchModel *BranchModel;
P3DBranchModel *ParentBranchModel;
const P3DStemModelTube *ParentStemModel;
P3DStemModel *StemModel;
P3DBranchingAlg *BranchingAlg;
wxTreeItemId ParentId;
ParentId = GetItemParent(GetSelection());
if (!ParentId.IsOk())
{
return;
}
ParentBranchModel = ((P3DPlantModelTreeCtrlItemData*)(GetItemData(ParentId)))->GetBranchModel();
ParentStemModel = dynamic_cast<const P3DStemModelTube*>(ParentBranchModel->GetStemModel());
if (ParentStemModel == 0)
{
return;
}
BranchModel = ((P3DPlantModelTreeCtrlItemData*)(GetItemData(GetSelection())))->GetBranchModel();
StemModel = new P3DStemModelWings(ParentStemModel);
BranchingAlg = new P3DBranchingAlgWings();
unsigned int SubBranchIndex;
wxTreeItemId ItemId;
wxTreeItemId ParentItemId;
SubBranchIndex = 0;
ItemId = GetSelection();
ParentItemId = GetItemParent(ItemId);
while ((ItemId = GetPrevSibling(ItemId)).IsOk())
{
SubBranchIndex++;
}
P3DApp::GetApp()->ExecEditCmd
(new ChangeStemModelCommand
(ParentBranchModel,
SubBranchIndex,
BranchModel,
StemModel,
BranchingAlg,
this,
BranchPanel));
}
nsIFrame*
nsFrameIterator::GetLastChild(nsIFrame* aFrame)
{
nsIFrame* result = GetLastChildInner(aFrame);
if (mLockScroll && result && result->GetType() == nsGkAtoms::scrollFrame)
return nsnull;
if (result && mFollowOOFs) {
result = nsPlaceholderFrame::GetRealFrameFor(result);
if (IsPopupFrame(result))
result = GetPrevSibling(result);
}
return result;
}
wxTreeItemId wxTreeCtrlEx::GetPrevItemSimple(wxTreeItemId const& item) const
{
wxTreeItemId cur = GetPrevSibling(item);
if (cur.IsOk()) {
while (cur.IsOk() && HasChildren(cur) && IsExpanded(cur)) {
cur = GetLastChild(cur);
}
}
else {
cur = GetItemParent(item);
if (cur.IsOk() && cur == GetRootItem() && (GetWindowStyle() & wxTR_HIDE_ROOT)) {
cur = wxTreeItemId();
}
}
return cur;
}
nsIFrame*
nsFrameIterator::GetPrevSibling(nsIFrame* aFrame)
{
nsIFrame* result = nsnull;
if (mFollowOOFs)
aFrame = GetPlaceholderFrame(aFrame);
if (aFrame) {
result = GetPrevSiblingInner(aFrame);
if (result && mFollowOOFs)
result = nsPlaceholderFrame::GetRealFrameFor(result);
}
if (mFollowOOFs && IsPopupFrame(result))
result = GetPrevSibling(result);
return result;
}
wxTreeItemId cbTreeCtrl::GetPrevVisible(const wxTreeItemId& item) const
{
wxTreeItemId previous = GetPrevSibling(item);
if (previous.IsOk())
{
while (ItemHasChildren(previous) && IsExpanded(previous))
{
wxTreeItemId child = GetLastChild(previous);
if (!child.IsOk())
break;
else
previous = child;
}
}
else
previous = GetItemParent(item);
return previous;
}
nsINode*
nsContentIterator::PrevNode(nsINode *aNode, nsTArray<PRInt32> *aIndexes)
{
nsINode *prevNode = nsnull;
nsINode *n = aNode;
if (mPre) // if we are a Pre-order iterator, use pre-order
{
nsINode *parent = n->GetNodeParent();
nsINode *nSibling = nsnull;
PRInt32 indx = 0;
// get the cached index
NS_ASSERTION(!aIndexes || !aIndexes->IsEmpty(),
"ContentIterator stack underflow");
if (aIndexes && !aIndexes->IsEmpty())
{
// use the last entry on the Indexes array for the current index
indx = (*aIndexes)[aIndexes->Length()-1];
}
else indx = mCachedIndex;
// reverify that the index of the current node hasn't changed.
// not super cheap, but a lot cheaper than IndexOf(), and still O(1).
// ignore result this time - the index may now be out of range.
if (indx >= 0)
nSibling = parent->GetChildAt(indx);
if (nSibling != n)
{
// someone changed our index - find the new index the painful way
indx = parent->IndexOf(n);
}
// indx is now canonically correct
if (indx && (nSibling = parent->GetChildAt(--indx)))
{
// update cache
if (aIndexes && !aIndexes->IsEmpty())
{
// replace an entry on the index stack
aIndexes->ElementAt(aIndexes->Length()-1) = indx;
}
else mCachedIndex = indx;
// prev node is siblings "deep right" child
return GetDeepLastChild(nSibling, aIndexes);
}
// else it's the parent
// update cache
if (aIndexes && !aIndexes->IsEmpty())
{
// pop an entry off the index stack
aIndexes->RemoveElementAt(aIndexes->Length()-1);
}
else mCachedIndex = 0; // this might be wrong, but we are better off guessing
prevNode = parent;
}
else // post-order
{
PRInt32 numChildren = n->GetChildCount();
// if it has children then prev node is last child
if (numChildren)
{
nsINode *nLastChild = n->GetChildAt(--numChildren);
// update cache
if (aIndexes)
{
// push an entry on the index stack
aIndexes->AppendElement(numChildren);
}
else mCachedIndex = numChildren;
return nLastChild;
}
// else prev sibling is previous
prevNode = GetPrevSibling(n, aIndexes);
}
return prevNode;
}
void CLocalTreeView::Refresh()
{
wxLogNull nullLog;
const wxString separator = wxFileName::GetPathSeparator();
std::list<t_dir> dirsToCheck;
#ifdef __WXMSW__
int prevErrorMode = SetErrorMode(SEM_FAILCRITICALERRORS);
wxTreeItemIdValue tmp;
wxTreeItemId child = GetFirstChild(m_drives, tmp);
while (child)
{
if (IsExpanded(child))
{
wxString drive = GetItemText(child);
int pos = drive.Find(_T(" "));
if (pos != -1)
drive = drive.Left(pos);
t_dir dir;
dir.dir = drive + separator;
dir.item = child;
dirsToCheck.push_back(dir);
}
child = GetNextSibling(child);
}
#else
t_dir dir;
dir.dir = separator;
dir.item = GetRootItem();
dirsToCheck.push_back(dir);
#endif
CFilterDialog filter;
while (!dirsToCheck.empty())
{
t_dir dir = dirsToCheck.front();
dirsToCheck.pop_front();
wxDir find(dir.dir);
if (!find.IsOpened())
{
// Dir does exist (listed in parent) but may not be accessible.
// Recurse into children anyhow, they might be accessible again.
wxTreeItemIdValue value;
wxTreeItemId child = GetFirstChild(dir.item, value);
while (child)
{
t_dir subdir;
subdir.dir = dir.dir + GetItemText(child) + separator;
subdir.item = child;
dirsToCheck.push_back(subdir);
child = GetNextSibling(child);
}
continue;
}
wxString file;
bool found = find.GetFirst(&file, _T(""), wxDIR_DIRS | wxDIR_HIDDEN);
std::list<wxString> dirs;
while (found)
{
if (file == _T(""))
{
wxGetApp().DisplayEncodingWarning();
found = find.GetNext(&file);
continue;
}
wxFileName fn(dir.dir + file);
const bool isDir = fn.DirExists();
wxLongLong size;
wxStructStat buf;
int result = wxStat(fn.GetFullPath(), &buf);
if (!isDir && !result)
size = buf.st_size;
else
size = -1;
int attributes;
#ifdef __WXMSW__
DWORD tmp = GetFileAttributes(fn.GetFullPath());
if (tmp == INVALID_FILE_ATTRIBUTES)
attributes = 0;
else
attributes = tmp;
#else
if (!result)
attributes = buf.st_mode & 0x777;
else
attributes = -1;
#endif //__WXMSW__
if (!filter.FilenameFiltered(file, isDir, size , true, attributes))
dirs.push_back(file);
found = find.GetNext(&file);
}
dirs.sort(sortfunc);
bool inserted = false;
wxTreeItemId child = GetLastChild(dir.item);
std::list<wxString>::reverse_iterator iter = dirs.rbegin();
while (child && iter != dirs.rend())
{
#ifdef __WXMSW__
int cmp = GetItemText(child).CmpNoCase(*iter);
#else
int cmp = GetItemText(child).Cmp(*iter);
#endif
if (!cmp)
{
if (!IsExpanded(child))
{
wxTreeItemId subchild = GetLastChild(child);
if (subchild && GetItemText(subchild) == _T(""))
{
if (!HasSubdir(dir.dir + *iter + separator))
Delete(subchild);
}
else if (!subchild)
{
if (HasSubdir(dir.dir + *iter + separator))
AppendItem(child, _T(""));
}
else
{
t_dir subdir;
subdir.dir = dir.dir + *iter + separator;
subdir.item = child;
dirsToCheck.push_front(subdir);
}
}
else
{
t_dir subdir;
subdir.dir = dir.dir + *iter + separator;
subdir.item = child;
dirsToCheck.push_front(subdir);
}
child = GetPrevSibling(child);
iter++;
}
else if (cmp > 0)
{
wxTreeItemId sel = GetSelection();
while (sel && sel != child)
sel = GetItemParent(sel);
wxTreeItemId prev = GetPrevSibling(child);
if (!sel)
Delete(child);
child = prev;
}
else if (cmp < 0)
{
wxString fullname = dir.dir + *iter + separator;
wxTreeItemId newItem = AppendItem(dir.item, *iter, GetIconIndex(::dir, fullname), GetIconIndex(opened_dir, fullname));
if (HasSubdir(fullname))
AppendItem(newItem, _T(""));
iter++;
inserted = true;
}
}
while (child)
{
wxTreeItemId sel = GetSelection();
while (sel && sel != child)
sel = GetItemParent(sel);
wxTreeItemId prev = GetPrevSibling(child);
if (!sel)
Delete(child);
child = prev;
}
while (iter != dirs.rend())
{
wxString fullname = dir.dir + *iter + separator;
wxTreeItemId newItem = AppendItem(dir.item, *iter, GetIconIndex(::dir, fullname), GetIconIndex(opened_dir, fullname));
if (HasSubdir(fullname))
AppendItem(newItem, _T(""));
iter++;
inserted = true;
}
if (inserted)
SortChildren(dir.item);
}
#ifdef __WXMSW__
SetErrorMode(prevErrorMode);
#endif
}
wxTreeItemId BFBackupTree::AddVolume(wxTreeItemId idParent,
const wxString& strVol,
const wxString& strAdd)
{
wxTreeItemId idReturn;
bool bJustAdded = false;
// find the right position for the volume item
if (ItemHasChildren(GetRootItem()) == true)
{
wxTreeItemId idPrev;
wxTreeItemIdValue idCookie;
for (idPrev = GetFirstChild(GetRootItem(), idCookie);
idPrev.IsOk();
idPrev = GetNextSibling(idPrev))
{
// add the new volume before the current one
if ( GetItemText(idPrev) > strVol )
{
idPrev = GetPrevSibling(idPrev);
idReturn = InsertItem
(
idParent,
idPrev,
strVol,
-1,
-1,
new BFBackupTreeItemData ( BFInvalidOID, strAdd )
);
bJustAdded = true;
break;
}
}
}
// just append the volume if no position was found
if (bJustAdded == false)
{
// append the volume item
idReturn = AppendItem
(
idParent,
strVol,
-1,
-1,
new BFBackupTreeItemData ( BFInvalidOID, strAdd)
);
}
// set the volume icon
wxFSVolume vol(strVol + wxFILE_SEP_PATH);
switch(vol.GetKind())
{
case wxFS_VOL_FLOPPY:
if ( strVol.StartsWith("A:") || strVol.StartsWith("B:") )
SetItemImage(idReturn, BFIconTable::volume_floppy, wxTreeItemIcon_Normal);
else
SetItemImage(idReturn, BFIconTable::volume_removable, wxTreeItemIcon_Normal);
break;
case wxFS_VOL_DVDROM:
case wxFS_VOL_CDROM:
SetItemImage(idReturn, BFIconTable::volume_cdrom, wxTreeItemIcon_Normal);
break;
case wxFS_VOL_NETWORK:
case wxFS_VOL_DISK:
case wxFS_VOL_OTHER:
default:
SetItemImage(idReturn, BFIconTable::volume_harddisk, wxTreeItemIcon_Normal);
break;
};
return idReturn;
}
void CLocalTreeView::Refresh()
{
wxLogNull nullLog;
const wxString separator = wxFileName::GetPathSeparator();
std::list<t_dir> dirsToCheck;
#ifdef __WXMSW__
int prevErrorMode = SetErrorMode(SEM_FAILCRITICALERRORS);
wxTreeItemIdValue tmp;
wxTreeItemId child = GetFirstChild(m_drives, tmp);
while (child)
{
if (IsExpanded(child))
{
wxString drive = GetItemText(child);
int pos = drive.Find(_T(" "));
if (pos != -1)
drive = drive.Left(pos);
t_dir dir;
dir.dir = drive + separator;
dir.item = child;
dirsToCheck.push_back(dir);
}
child = GetNextSibling(child);
}
#else
t_dir dir;
dir.dir = separator;
dir.item = GetRootItem();
dirsToCheck.push_back(dir);
#endif
CFilterManager filter;
while (!dirsToCheck.empty())
{
t_dir dir = dirsToCheck.front();
dirsToCheck.pop_front();
// Step 1: Check if directory exists
CLocalFileSystem local_filesystem;
if (!local_filesystem.BeginFindFiles(dir.dir, true))
{
// Dir does exist (listed in parent) but may not be accessible.
// Recurse into children anyhow, they might be accessible again.
wxTreeItemIdValue value;
wxTreeItemId child = GetFirstChild(dir.item, value);
while (child)
{
t_dir subdir;
subdir.dir = dir.dir + GetItemText(child) + separator;
subdir.item = child;
dirsToCheck.push_back(subdir);
child = GetNextSibling(child);
}
continue;
}
// Step 2: Enumerate subdirectories on disk and sort them
std::list<wxString> dirs;
wxString file;
const wxLongLong size(-1);
bool was_link;
bool is_dir;
int attributes;
wxDateTime date;
while (local_filesystem.GetNextFile(file, was_link, is_dir, 0, &date, &attributes))
{
if (file == _T(""))
{
wxGetApp().DisplayEncodingWarning();
continue;
}
if (filter.FilenameFiltered(file, dir.dir, true, size, true, attributes, date.IsValid() ? &date : 0))
continue;
dirs.push_back(file);
}
dirs.sort(sortfunc);
bool inserted = false;
// Step 3: Merge list of subdirectories with subtree.
wxTreeItemId child = GetLastChild(dir.item);
std::list<wxString>::reverse_iterator iter = dirs.rbegin();
while (child || iter != dirs.rend())
{
int cmp;
if (child && iter != dirs.rend())
#ifdef __WXMSW__
cmp = GetItemText(child).CmpNoCase(*iter);
#else
cmp = GetItemText(child).Cmp(*iter);
#endif
else if (child)
cmp = 1;
else
cmp = -1;
if (!cmp)
{
// Found item with same name. Mark it for further processing
if (!IsExpanded(child))
{
wxString path = dir.dir + *iter + separator;
if (!CheckSubdirStatus(child, path))
{
t_dir subdir;
subdir.dir = path;
subdir.item = child;
dirsToCheck.push_front(subdir);
}
}
else
{
t_dir subdir;
subdir.dir = dir.dir + *iter + separator;
subdir.item = child;
dirsToCheck.push_front(subdir);
}
child = GetPrevSibling(child);
++iter;
}
else if (cmp > 0)
{
// Subdirectory currently in tree no longer exists.
// Delete child from tree, unless current selection
// is in the subtree.
wxTreeItemId sel = GetSelection();
while (sel && sel != child)
sel = GetItemParent(sel);
wxTreeItemId prev = GetPrevSibling(child);
if (!sel)
Delete(child);
child = prev;
}
else if (cmp < 0)
{
// New subdirectory, add treeitem
wxString fullname = dir.dir + *iter + separator;
wxTreeItemId newItem = AppendItem(dir.item, *iter, GetIconIndex(::dir, fullname),
#ifdef __WXMSW__
-1
#else
GetIconIndex(opened_dir, fullname)
#endif
);
CheckSubdirStatus(newItem, fullname);
++iter;
inserted = true;
}
}
if (inserted)
SortChildren(dir.item);
}
void CRemoteTreeView::RefreshItem(wxTreeItemId parent, const CDirectoryListing& listing, bool will_select_parent)
{
SetItemImages(parent, false);
wxTreeItemIdValue cookie;
wxTreeItemId child = GetFirstChild(parent, cookie);
if (!child || GetItemText(child).empty()) {
DisplayItem(parent, listing);
return;
}
CFilterManager filter;
wxString const path = listing.path.GetPath();
wxArrayString dirs;
for (unsigned int i = 0; i < listing.GetCount(); ++i) {
if (!listing[i].is_dir())
continue;
if (!filter.FilenameFiltered(listing[i].name, path, true, -1, false, 0, listing[i].time))
dirs.push_back(listing[i].name);
}
auto const& sortFunc = CFileListCtrlSortBase::GetCmpFunction(m_nameSortMode);
dirs.Sort(sortFunc);
bool inserted = false;
child = GetLastChild(parent);
wxArrayString::reverse_iterator iter = dirs.rbegin();
while (child && iter != dirs.rend()) {
int cmp = sortFunc(GetItemText(child), *iter);
if (!cmp) {
CServerPath childPath = listing.path;
childPath.AddSegment(*iter);
CDirectoryListing subListing;
if (m_pState->m_pEngine->CacheLookup(childPath, subListing) == FZ_REPLY_OK) {
if (!GetLastChild(child) && HasSubdirs(subListing, filter))
AppendItem(child, _T(""), -1, -1);
SetItemImages(child, false);
}
else
SetItemImages(child, true);
child = GetPrevSibling(child);
++iter;
}
else if (cmp > 0) {
// Child no longer exists
wxTreeItemId sel = GetSelection();
while (sel && sel != child)
sel = GetItemParent(sel);
wxTreeItemId prev = GetPrevSibling(child);
if (!sel || will_select_parent)
Delete(child);
child = prev;
}
else if (cmp < 0) {
// New directory
CServerPath childPath = listing.path;
childPath.AddSegment(*iter);
CDirectoryListing subListing;
if (m_pState->m_pEngine->CacheLookup(childPath, subListing) == FZ_REPLY_OK) {
wxTreeItemId childItem = AppendItem(parent, *iter, 0, 2, 0);
if (childItem) {
SetItemImages(childItem, false);
if (HasSubdirs(subListing, filter)) {
AppendItem(childItem, _T(""), -1, -1);
}
}
}
else {
wxTreeItemId childItem = AppendItem(parent, *iter, 1, 3, 0);
if (childItem) {
SetItemImages(childItem, true);
}
}
++iter;
inserted = true;
}
}
while (child) {
// Child no longer exists
wxTreeItemId sel = GetSelection();
while (sel && sel != child)
sel = GetItemParent(sel);
wxTreeItemId prev = GetPrevSibling(child);
if (!sel || will_select_parent)
Delete(child);
child = prev;
}
while (iter != dirs.rend()) {
CServerPath childPath = listing.path;
childPath.AddSegment(*iter);
CDirectoryListing subListing;
if (m_pState->m_pEngine->CacheLookup(childPath, subListing) == FZ_REPLY_OK) {
wxTreeItemId childItem = AppendItem(parent, *iter, 0, 2, 0);
if (childItem) {
SetItemImages(childItem, false);
if (HasSubdirs(subListing, filter)) {
AppendItem(childItem, _T(""), -1, -1);
}
}
}
else {
wxTreeItemId childItem = AppendItem(parent, *iter, 1, 3, 0);
if (childItem) {
SetItemImages(childItem, true);
}
}
++iter;
inserted = true;
}
if (inserted)
SortChildren(parent);
}
void CRemoteTreeView::RefreshItem(wxTreeItemId parent, const CDirectoryListing& listing, bool will_select_parent)
{
SetItemImages(parent, false);
wxTreeItemIdValue cookie;
wxTreeItemId child = GetFirstChild(parent, cookie);
if (!child || GetItemText(child) == _T(""))
{
DisplayItem(parent, listing);
return;
}
CFilterManager filter;
const wxString path = listing.path.GetPath();
std::list<wxString> dirs;
for (unsigned int i = 0; i < listing.GetCount(); i++)
{
if (!listing[i].is_dir())
continue;
if (!filter.FilenameFiltered(listing[i].name, path, true, -1, false, 0, listing[i].has_date() ? &listing[i].time : 0))
dirs.push_back(listing[i].name);
}
dirs.sort(sortfunc);
bool inserted = false;
child = GetLastChild(parent);
std::list<wxString>::reverse_iterator iter = dirs.rbegin();
while (child && iter != dirs.rend())
{
int cmp = GetItemText(child).CmpNoCase(*iter);
if (!cmp)
cmp = GetItemText(child).Cmp(*iter);
if (!cmp)
{
CServerPath path = listing.path;
path.AddSegment(*iter);
CDirectoryListing subListing;
if (m_pState->m_pEngine->CacheLookup(path, subListing) == FZ_REPLY_OK)
{
if (!GetLastChild(child) && HasSubdirs(subListing, filter))
AppendItem(child, _T(""), -1, -1);
SetItemImages(child, false);
}
else
SetItemImages(child, true);
child = GetPrevSibling(child);
iter++;
}
else if (cmp > 0)
{
// Child no longer exists
wxTreeItemId sel = GetSelection();
while (sel && sel != child)
sel = GetItemParent(sel);
wxTreeItemId prev = GetPrevSibling(child);
if (!sel || will_select_parent)
Delete(child);
child = prev;
}
else if (cmp < 0)
{
// New directory
CServerPath path = listing.path;
path.AddSegment(*iter);
CDirectoryListing subListing;
if (m_pState->m_pEngine->CacheLookup(path, subListing) == FZ_REPLY_OK)
{
wxTreeItemId child = AppendItem(parent, *iter, 0, 2, 0);
SetItemImages(child, false);
if (HasSubdirs(subListing, filter))
AppendItem(child, _T(""), -1, -1);
}
else
{
wxTreeItemId child = AppendItem(parent, *iter, 1, 3, 0);
if (child)
SetItemImages(child, true);
}
iter++;
inserted = true;
}
}
while (child)
{
// Child no longer exists
wxTreeItemId sel = GetSelection();
while (sel && sel != child)
sel = GetItemParent(sel);
wxTreeItemId prev = GetPrevSibling(child);
if (!sel || will_select_parent)
Delete(child);
child = prev;
}
while (iter != dirs.rend())
{
CServerPath path = listing.path;
path.AddSegment(*iter);
CDirectoryListing subListing;
if (m_pState->m_pEngine->CacheLookup(path, subListing) == FZ_REPLY_OK)
{
wxTreeItemId child = AppendItem(parent, *iter, 0, 2, 0);
SetItemImages(child, false);
if (HasSubdirs(subListing, filter))
AppendItem(child, _T(""), -1, -1);
}
else
{
wxTreeItemId child = AppendItem(parent, *iter, 1, 3, 0);
SetItemImages(child, true);
}
iter++;
inserted = true;
}
if (inserted)
SortChildren(parent);
}
void CLocalTreeView::Refresh()
{
wxLogNull nullLog;
const wxString separator = wxFileName::GetPathSeparator();
std::list<t_dir> dirsToCheck;
#ifdef __WXMSW__
int prevErrorMode = SetErrorMode(SEM_FAILCRITICALERRORS);
wxTreeItemIdValue tmp;
wxTreeItemId child = GetFirstChild(m_drives, tmp);
while (child)
{
if (IsExpanded(child))
{
wxString drive = GetItemText(child);
int pos = drive.Find(_T(" "));
if (pos != -1)
drive = drive.Left(pos);
t_dir dir;
dir.dir = drive + separator;
dir.item = child;
dirsToCheck.push_back(dir);
}
child = GetNextSibling(child);
}
#else
t_dir dir;
dir.dir = separator;
dir.item = GetRootItem();
dirsToCheck.push_back(dir);
#endif
CFilterManager filter;
while (!dirsToCheck.empty())
{
t_dir dir = dirsToCheck.front();
dirsToCheck.pop_front();
CLocalFileSystem local_filesystem;
if (!local_filesystem.BeginFindFiles(dir.dir, true))
{
// Dir does exist (listed in parent) but may not be accessible.
// Recurse into children anyhow, they might be accessible again.
wxTreeItemIdValue value;
wxTreeItemId child = GetFirstChild(dir.item, value);
while (child)
{
t_dir subdir;
subdir.dir = dir.dir + GetItemText(child) + separator;
subdir.item = child;
dirsToCheck.push_back(subdir);
child = GetNextSibling(child);
}
continue;
}
std::list<wxString> dirs;
wxString file;
const wxLongLong size(-1);
bool was_link;
bool is_dir;
int attributes;
while (local_filesystem.GetNextFile(file, was_link, is_dir, 0, 0, &attributes))
{
if (file == _T(""))
{
wxGetApp().DisplayEncodingWarning();
continue;
}
if (filter.FilenameFiltered(file, dir.dir, true, size, true, attributes))
continue;
dirs.push_back(file);
}
dirs.sort(sortfunc);
bool inserted = false;
wxTreeItemId child = GetLastChild(dir.item);
std::list<wxString>::reverse_iterator iter = dirs.rbegin();
while (child && iter != dirs.rend())
{
#ifdef __WXMSW__
int cmp = GetItemText(child).CmpNoCase(*iter);
#else
int cmp = GetItemText(child).Cmp(*iter);
#endif
if (!cmp)
{
if (!IsExpanded(child))
{
wxString path = dir.dir + *iter + separator;
if (!CheckSubdirStatus(child, path))
{
t_dir subdir;
subdir.dir = path;
subdir.item = child;
dirsToCheck.push_front(subdir);
}
}
else
{
t_dir subdir;
subdir.dir = dir.dir + *iter + separator;
subdir.item = child;
dirsToCheck.push_front(subdir);
}
child = GetPrevSibling(child);
iter++;
}
else if (cmp > 0)
{
wxTreeItemId sel = GetSelection();
while (sel && sel != child)
sel = GetItemParent(sel);
wxTreeItemId prev = GetPrevSibling(child);
if (!sel)
Delete(child);
child = prev;
}
else if (cmp < 0)
{
wxString fullname = dir.dir + *iter + separator;
wxTreeItemId newItem = AppendItem(dir.item, *iter, GetIconIndex(::dir, fullname),
#ifdef __WXMSW__
-1
#else
GetIconIndex(opened_dir, fullname)
#endif
);
CheckSubdirStatus(newItem, fullname);
iter++;
inserted = true;
}
}
while (child)
{
wxTreeItemId sel = GetSelection();
while (sel && sel != child)
sel = GetItemParent(sel);
wxTreeItemId prev = GetPrevSibling(child);
if (!sel)
Delete(child);
child = prev;
}
while (iter != dirs.rend())
{
wxString fullname = dir.dir + *iter + separator;
wxTreeItemId newItem = AppendItem(dir.item, *iter, GetIconIndex(::dir, fullname),
#ifdef __WXMSW__
-1
#else
GetIconIndex(opened_dir, fullname)
#endif
);
CheckSubdirStatus(newItem, fullname);
iter++;
inserted = true;
}
if (inserted)
SortChildren(dir.item);
}
#ifdef __WXMSW__
SetErrorMode(prevErrorMode);
#endif
}
nsresult nsContentSubtreeIterator::Init(nsIDOMRange* aRange)
{
if (!aRange)
return NS_ERROR_NULL_POINTER;
mIsDone = PR_FALSE;
mRange = aRange;
// get the start node and offset, convert to nsINode
nsCOMPtr<nsIDOMNode> commonParent;
nsCOMPtr<nsIDOMNode> startParent;
nsCOMPtr<nsIDOMNode> endParent;
nsCOMPtr<nsINode> nStartP;
nsCOMPtr<nsINode> nEndP;
nsCOMPtr<nsINode> n;
nsINode *firstCandidate = nsnull;
nsINode *lastCandidate = nsnull;
PRInt32 indx, startIndx, endIndx;
// get common content parent
if (NS_FAILED(aRange->GetCommonAncestorContainer(getter_AddRefs(commonParent))) || !commonParent)
return NS_ERROR_FAILURE;
mCommonParent = do_QueryInterface(commonParent);
// get start content parent
if (NS_FAILED(aRange->GetStartContainer(getter_AddRefs(startParent))) || !startParent)
return NS_ERROR_FAILURE;
nStartP = do_QueryInterface(startParent);
aRange->GetStartOffset(&startIndx);
// get end content parent
if (NS_FAILED(aRange->GetEndContainer(getter_AddRefs(endParent))) || !endParent)
return NS_ERROR_FAILURE;
nEndP = do_QueryInterface(endParent);
aRange->GetEndOffset(&endIndx);
// short circuit when start node == end node
if (startParent == endParent)
{
nsINode* nChild = nStartP->GetChildAt(0);
if (!nChild) // no children, must be a text node or empty container
{
// all inside one text node - empty subtree iterator
MakeEmpty();
return NS_OK;
}
else
{
if (startIndx == endIndx) // collapsed range
{
MakeEmpty();
return NS_OK;
}
}
}
// cache ancestors
#if 0
nsContentUtils::GetAncestorsAndOffsets(startParent, startIndx,
&mStartNodes, &mStartOffsets);
#endif
nsContentUtils::GetAncestorsAndOffsets(endParent, endIndx,
&mEndNodes, &mEndOffsets);
// find first node in range
aRange->GetStartOffset(&indx);
if (!nStartP->GetChildCount()) // no children, start at the node itself
{
n = nStartP;
}
else
{
nsINode* nChild = nStartP->GetChildAt(indx);
if (!nChild) // offset after last child
{
n = nStartP;
}
else
{
firstCandidate = nChild;
}
}
if (!firstCandidate)
{
// then firstCandidate is next node after cN
firstCandidate = GetNextSibling(n, nsnull);
if (!firstCandidate)
{
MakeEmpty();
return NS_OK;
}
}
firstCandidate = GetDeepFirstChild(firstCandidate, nsnull);
// confirm that this first possible contained node
// is indeed contained. Else we have a range that
// does not fully contain any node.
PRBool nodeBefore, nodeAfter;
if (NS_FAILED(nsRange::CompareNodeToRange(firstCandidate, aRange,
&nodeBefore, &nodeAfter)))
return NS_ERROR_FAILURE;
if (nodeBefore || nodeAfter)
{
MakeEmpty();
return NS_OK;
}
// cool, we have the first node in the range. Now we walk
// up its ancestors to find the most senior that is still
// in the range. That's the real first node.
if (NS_FAILED(GetTopAncestorInRange(firstCandidate, address_of(mFirst))))
return NS_ERROR_FAILURE;
// now to find the last node
aRange->GetEndOffset(&indx);
PRInt32 numChildren = nEndP->GetChildCount();
if (indx > numChildren) indx = numChildren;
if (!indx)
{
n = nEndP;
}
else
{
if (!numChildren) // no children, must be a text node
{
n = nEndP;
}
else
{
lastCandidate = nEndP->GetChildAt(--indx);
NS_ASSERTION(lastCandidate,
"tree traversal trouble in nsContentSubtreeIterator::Init");
}
}
if (!lastCandidate)
{
// then lastCandidate is prev node before n
lastCandidate = GetPrevSibling(n, nsnull);
}
lastCandidate = GetDeepLastChild(lastCandidate, nsnull);
// confirm that this last possible contained node
// is indeed contained. Else we have a range that
// does not fully contain any node.
if (NS_FAILED(nsRange::CompareNodeToRange(lastCandidate, aRange, &nodeBefore,
&nodeAfter)))
return NS_ERROR_FAILURE;
if (nodeBefore || nodeAfter)
{
MakeEmpty();
return NS_OK;
}
// cool, we have the last node in the range. Now we walk
// up its ancestors to find the most senior that is still
// in the range. That's the real first node.
if (NS_FAILED(GetTopAncestorInRange(lastCandidate, address_of(mLast))))
return NS_ERROR_FAILURE;
mCurNode = mFirst;
return NS_OK;
}
nsresult
nsContentIterator::Init(nsIRange* aRange)
{
NS_ENSURE_ARG_POINTER(aRange);
mIsDone = PR_FALSE;
// get common content parent
mCommonParent = aRange->GetCommonAncestor();
NS_ENSURE_TRUE(mCommonParent, NS_ERROR_FAILURE);
// get the start node and offset
PRInt32 startIndx = aRange->StartOffset();
nsINode* startNode = aRange->GetStartParent();
NS_ENSURE_TRUE(startNode, NS_ERROR_FAILURE);
// get the end node and offset
PRInt32 endIndx = aRange->EndOffset();
nsINode* endNode = aRange->GetEndParent();
NS_ENSURE_TRUE(endNode, NS_ERROR_FAILURE);
PRBool startIsData = startNode->IsNodeOfType(nsINode::eDATA_NODE);
// short circuit when start node == end node
if (startNode == endNode)
{
// Check to see if we have a collapsed range, if so,
// there is nothing to iterate over.
//
// XXX: CharacterDataNodes (text nodes) are currently an exception,
// since we always want to be able to iterate text nodes at
// the end points of a range.
if (!startIsData && startIndx == endIndx)
{
MakeEmpty();
return NS_OK;
}
if (startIsData)
{
// It's a textnode.
NS_ASSERTION(startNode->IsNodeOfType(nsINode::eCONTENT),
"Data node that's not content?");
mFirst = static_cast<nsIContent*>(startNode);
mLast = mFirst;
mCurNode = mFirst;
RebuildIndexStack();
return NS_OK;
}
}
// Find first node in range.
nsIContent *cChild = nsnull;
if (!startIsData && NodeHasChildren(startNode))
cChild = startNode->GetChildAt(startIndx);
if (!cChild) // no children, must be a text node
{
// XXXbz no children might also just mean no children. So I'm not
// sure what that comment above is talking about.
if (mPre)
{
// XXX: In the future, if start offset is after the last
// character in the cdata node, should we set mFirst to
// the next sibling?
if (!startIsData)
{
mFirst = GetNextSibling(startNode, nsnull);
// Does mFirst node really intersect the range?
// The range could be 'degenerate', ie not collapsed
// but still contain no content.
if (mFirst &&
!NodeIsInTraversalRange(mFirst, mPre, startNode, startIndx,
endNode, endIndx)) {
mFirst = nsnull;
}
}
else {
NS_ASSERTION(startNode->IsNodeOfType(nsINode::eCONTENT),
"Data node that's not content?");
mFirst = static_cast<nsIContent*>(startNode);
}
}
else {
// post-order
if (startNode->IsNodeOfType(nsINode::eCONTENT)) {
mFirst = static_cast<nsIContent*>(startNode);
} else {
// What else can we do?
mFirst = nsnull;
}
}
}
else
{
if (mPre)
mFirst = cChild;
else // post-order
{
mFirst = GetDeepFirstChild(cChild, nsnull);
// Does mFirst node really intersect the range?
// The range could be 'degenerate', ie not collapsed
// but still contain no content.
if (mFirst &&
!NodeIsInTraversalRange(mFirst, mPre, startNode, startIndx,
endNode, endIndx))
mFirst = nsnull;
}
}
// Find last node in range.
PRBool endIsData = endNode->IsNodeOfType(nsINode::eDATA_NODE);
if (endIsData || !NodeHasChildren(endNode) || endIndx == 0)
{
if (mPre) {
if (endNode->IsNodeOfType(nsINode::eCONTENT)) {
mLast = static_cast<nsIContent*>(endNode);
} else {
// Not much else to do here...
mLast = nsnull;
}
}
else // post-order
{
// XXX: In the future, if end offset is before the first
// character in the cdata node, should we set mLast to
// the prev sibling?
if (!endIsData)
{
mLast = GetPrevSibling(endNode, nsnull);
if (!NodeIsInTraversalRange(mLast, mPre, startNode, startIndx,
endNode, endIndx))
mLast = nsnull;
}
else {
NS_ASSERTION(endNode->IsNodeOfType(nsINode::eCONTENT),
"Data node that's not content?");
mLast = static_cast<nsIContent*>(endNode);
}
}
}
else
{
PRInt32 indx = endIndx;
cChild = endNode->GetChildAt(--indx);
if (!cChild) // No child at offset!
{
NS_NOTREACHED("nsContentIterator::nsContentIterator");
return NS_ERROR_FAILURE;
}
if (mPre)
{
mLast = GetDeepLastChild(cChild, nsnull);
if (!NodeIsInTraversalRange(mLast, mPre, startNode, startIndx,
endNode, endIndx)) {
mLast = nsnull;
}
}
else { // post-order
mLast = cChild;
}
}
// If either first or last is null, they both
// have to be null!
if (!mFirst || !mLast)
{
mFirst = nsnull;
mLast = nsnull;
}
mCurNode = mFirst;
mIsDone = !mCurNode;
if (!mCurNode)
mIndexes.Clear();
else
RebuildIndexStack();
return NS_OK;
}
