void
nsTreeContentView::InsertRowFor(nsIContent* aParent, nsIContent* aChild)
{
int32_t grandParentIndex = -1;
bool insertRow = false;
nsCOMPtr<nsIContent> grandParent = aParent->GetParent();
nsIAtom* grandParentTag = grandParent->Tag();
if (grandParent->IsXUL() && grandParentTag == nsGkAtoms::tree) {
// Allow insertion to the outermost container.
insertRow = true;
}
else {
// Test insertion to an inner container.
// First try to find this parent in our array of rows, if we find one
// we can be sure that all other parents are open too.
grandParentIndex = FindContent(grandParent);
if (grandParentIndex >= 0) {
// Got it, now test if it is open.
if (mRows[grandParentIndex]->IsOpen())
insertRow = true;
}
}
if (insertRow) {
int32_t index = 0;
GetIndexInSubtree(aParent, aChild, &index);
int32_t count = InsertRow(grandParentIndex, index, aChild);
if (mBoxObject)
mBoxObject->RowCountChanged(grandParentIndex + index + 1, count);
}
}
void
nsTreeContentView::CloseContainer(int32_t aIndex)
{
Row* row = mRows[aIndex];
row->SetOpen(false);
int32_t count = RemoveSubtree(aIndex);
if (mBoxObject) {
mBoxObject->InvalidateRow(aIndex);
mBoxObject->RowCountChanged(aIndex + 1, -count);
}
}
void
nsTreeContentView::OpenContainer(int32_t aIndex)
{
Row* row = mRows[aIndex];
row->SetOpen(true);
int32_t count = EnsureSubtree(aIndex);
if (mBoxObject) {
mBoxObject->InvalidateRow(aIndex);
mBoxObject->RowCountChanged(aIndex + 1, count);
}
}
void CSoftUpdateWidget::setUpgradeData(const QMap<QString, QMap<QString, SoftData> >& data)
{
//类别, <软件名称，软件数据>
QMap<QString, SoftData> upgrade;
QMapIterator<QString, QMap<QString, SoftData> > iter(data);
while(iter.hasNext())
{
iter.next();
QMapIterator<QString, SoftData> iter2(iter.value());
while(iter2.hasNext())
{
iter2.next();
if(iter2.value().state == SMonitor::Upgrade)
{
upgrade.insert(iter2.key(), iter2.value());
}
}
}
m_tableWidget->updateTable(upgrade);
emit RowCountChanged(m_tableWidget->rowCount());
changeTrayIconState();
}
void CSoftUpdateWidget::showIndependentItem(QString strKey, QString version, bool bShow)
{
m_tableWidget->showIndependentItem(strKey, version, bShow);
emit RowCountChanged(m_tableWidget->rowCount());
changeTrayIconState();
}
void CSoftUpdateWidget::InstallFinished(const QString& key)
{
m_tableWidget->removeItem(key);
emit RowCountChanged(m_tableWidget->rowCount());
changeTrayIconState();
}
void
nsTreeContentView::ContentRemoved(nsIDocument *aDocument,
nsIContent* aContainer,
nsIContent* aChild,
int32_t aIndexInContainer,
nsIContent* aPreviousSibling)
{
NS_ASSERTION(aChild, "null ptr");
// Make sure this notification concerns us.
// First check the tag to see if it's one that we care about.
nsIAtom *tag = aChild->Tag();
// We don't consider non-XUL nodes.
if (!aChild->IsXUL() || !aContainer->IsXUL())
return;
if (tag != nsGkAtoms::treeitem &&
tag != nsGkAtoms::treeseparator &&
tag != nsGkAtoms::treechildren &&
tag != nsGkAtoms::treerow &&
tag != nsGkAtoms::treecell) {
return;
}
// If we have a legal tag, go up to the tree/select and make sure
// that it's ours.
for (nsIContent* element = aContainer; element != mBody; element = element->GetParent()) {
if (!element)
return; // this is not for us
nsIAtom *parentTag = element->Tag();
if (element->IsXUL() && parentTag == nsGkAtoms::tree)
return; // this is not for us
}
// Lots of codepaths under here that do all sorts of stuff, so be safe.
nsCOMPtr<nsIMutationObserver> kungFuDeathGrip(this);
if (tag == nsGkAtoms::treechildren) {
int32_t index = FindContent(aContainer);
if (index >= 0) {
Row* row = mRows[index];
row->SetEmpty(true);
int32_t count = RemoveSubtree(index);
// Invalidate also the row to update twisty.
if (mBoxObject) {
mBoxObject->InvalidateRow(index);
mBoxObject->RowCountChanged(index + 1, -count);
}
}
}
else if (tag == nsGkAtoms::treeitem ||
tag == nsGkAtoms::treeseparator
) {
int32_t index = FindContent(aChild);
if (index >= 0) {
int32_t count = RemoveRow(index);
if (mBoxObject)
mBoxObject->RowCountChanged(index, -count);
}
}
else if (tag == nsGkAtoms::treerow) {
int32_t index = FindContent(aContainer);
if (index >= 0 && mBoxObject)
mBoxObject->InvalidateRow(index);
}
else if (tag == nsGkAtoms::treecell) {
nsCOMPtr<nsIContent> parent = aContainer->GetParent();
if (parent) {
int32_t index = FindContent(parent);
if (index >= 0 && mBoxObject)
mBoxObject->InvalidateRow(index);
}
}
}
void
nsTreeContentView::ContentInserted(nsIDocument *aDocument,
nsIContent* aContainer,
nsIContent* aChild,
int32_t /* unused */)
{
NS_ASSERTION(aChild, "null ptr");
// Make sure this notification concerns us.
// First check the tag to see if it's one that we care about.
nsIAtom *childTag = aChild->Tag();
// Don't allow non-XUL nodes.
if (!aChild->IsXUL() || !aContainer->IsXUL())
return;
if (childTag != nsGkAtoms::treeitem &&
childTag != nsGkAtoms::treeseparator &&
childTag != nsGkAtoms::treechildren &&
childTag != nsGkAtoms::treerow &&
childTag != nsGkAtoms::treecell) {
return;
}
// If we have a legal tag, go up to the tree/select and make sure
// that it's ours.
for (nsIContent* element = aContainer; element != mBody; element = element->GetParent()) {
if (!element)
return; // this is not for us
nsIAtom *parentTag = element->Tag();
if (element->IsXUL() && parentTag == nsGkAtoms::tree)
return; // this is not for us
}
// Lots of codepaths under here that do all sorts of stuff, so be safe.
nsCOMPtr<nsIMutationObserver> kungFuDeathGrip(this);
if (childTag == nsGkAtoms::treechildren) {
int32_t index = FindContent(aContainer);
if (index >= 0) {
Row* row = mRows[index];
row->SetEmpty(false);
if (mBoxObject)
mBoxObject->InvalidateRow(index);
if (row->IsContainer() && row->IsOpen()) {
int32_t count = EnsureSubtree(index);
if (mBoxObject)
mBoxObject->RowCountChanged(index + 1, count);
}
}
}
else if (childTag == nsGkAtoms::treeitem ||
childTag == nsGkAtoms::treeseparator) {
InsertRowFor(aContainer, aChild);
}
else if (childTag == nsGkAtoms::treerow) {
int32_t index = FindContent(aContainer);
if (index >= 0 && mBoxObject)
mBoxObject->InvalidateRow(index);
}
else if (childTag == nsGkAtoms::treecell) {
nsCOMPtr<nsIContent> parent = aContainer->GetParent();
if (parent) {
int32_t index = FindContent(parent);
if (index >= 0 && mBoxObject)
mBoxObject->InvalidateRow(index);
}
}
}
void
nsTreeContentView::AttributeChanged(nsIDocument* aDocument,
dom::Element* aElement,
int32_t aNameSpaceID,
nsIAtom* aAttribute,
int32_t aModType)
{
// Lots of codepaths under here that do all sorts of stuff, so be safe.
nsCOMPtr<nsIMutationObserver> kungFuDeathGrip(this);
// Make sure this notification concerns us.
// First check the tag to see if it's one that we care about.
nsIAtom* tag = aElement->Tag();
if (mBoxObject && (aElement == mRoot || aElement == mBody)) {
mBoxObject->ClearStyleAndImageCaches();
mBoxObject->Invalidate();
}
// We don't consider non-XUL nodes.
nsIContent* parent = nullptr;
if (!aElement->IsXUL() ||
((parent = aElement->GetParent()) && !parent->IsXUL())) {
return;
}
if (tag != nsGkAtoms::treecol &&
tag != nsGkAtoms::treeitem &&
tag != nsGkAtoms::treeseparator &&
tag != nsGkAtoms::treerow &&
tag != nsGkAtoms::treecell) {
return;
}
// If we have a legal tag, go up to the tree/select and make sure
// that it's ours.
for (nsIContent* element = aElement; element != mBody; element = element->GetParent()) {
if (!element)
return; // this is not for us
nsIAtom *parentTag = element->Tag();
if (element->IsXUL() && parentTag == nsGkAtoms::tree)
return; // this is not for us
}
// Handle changes of the hidden attribute.
if (aAttribute == nsGkAtoms::hidden &&
(tag == nsGkAtoms::treeitem || tag == nsGkAtoms::treeseparator)) {
bool hidden = aElement->AttrValueIs(kNameSpaceID_None,
nsGkAtoms::hidden,
nsGkAtoms::_true, eCaseMatters);
int32_t index = FindContent(aElement);
if (hidden && index >= 0) {
// Hide this row along with its children.
int32_t count = RemoveRow(index);
if (mBoxObject)
mBoxObject->RowCountChanged(index, -count);
}
else if (!hidden && index < 0) {
// Show this row along with its children.
nsCOMPtr<nsIContent> parent = aElement->GetParent();
if (parent) {
InsertRowFor(parent, aElement);
}
}
return;
}
if (tag == nsGkAtoms::treecol) {
if (aAttribute == nsGkAtoms::properties) {
if (mBoxObject) {
nsCOMPtr<nsITreeColumns> cols;
mBoxObject->GetColumns(getter_AddRefs(cols));
if (cols) {
nsCOMPtr<nsIDOMElement> element = do_QueryInterface(aElement);
nsCOMPtr<nsITreeColumn> col;
cols->GetColumnFor(element, getter_AddRefs(col));
mBoxObject->InvalidateColumn(col);
}
}
}
}
else if (tag == nsGkAtoms::treeitem) {
int32_t index = FindContent(aElement);
if (index >= 0) {
Row* row = mRows[index];
if (aAttribute == nsGkAtoms::container) {
bool isContainer =
aElement->AttrValueIs(kNameSpaceID_None, nsGkAtoms::container,
nsGkAtoms::_true, eCaseMatters);
row->SetContainer(isContainer);
if (mBoxObject)
mBoxObject->InvalidateRow(index);
}
else if (aAttribute == nsGkAtoms::open) {
bool isOpen =
aElement->AttrValueIs(kNameSpaceID_None, nsGkAtoms::open,
nsGkAtoms::_true, eCaseMatters);
bool wasOpen = row->IsOpen();
if (! isOpen && wasOpen)
CloseContainer(index);
else if (isOpen && ! wasOpen)
OpenContainer(index);
}
else if (aAttribute == nsGkAtoms::empty) {
bool isEmpty =
aElement->AttrValueIs(kNameSpaceID_None, nsGkAtoms::empty,
nsGkAtoms::_true, eCaseMatters);
row->SetEmpty(isEmpty);
if (mBoxObject)
mBoxObject->InvalidateRow(index);
}
}
}
else if (tag == nsGkAtoms::treeseparator) {
int32_t index = FindContent(aElement);
if (index >= 0) {
if (aAttribute == nsGkAtoms::properties && mBoxObject) {
mBoxObject->InvalidateRow(index);
}
}
}
else if (tag == nsGkAtoms::treerow) {
if (aAttribute == nsGkAtoms::properties) {
nsCOMPtr<nsIContent> parent = aElement->GetParent();
if (parent) {
int32_t index = FindContent(parent);
if (index >= 0 && mBoxObject) {
mBoxObject->InvalidateRow(index);
}
}
}
}
else if (tag == nsGkAtoms::treecell) {
if (aAttribute == nsGkAtoms::ref ||
aAttribute == nsGkAtoms::properties ||
aAttribute == nsGkAtoms::mode ||
aAttribute == nsGkAtoms::src ||
aAttribute == nsGkAtoms::value ||
aAttribute == nsGkAtoms::label) {
nsIContent* parent = aElement->GetParent();
if (parent) {
nsCOMPtr<nsIContent> grandParent = parent->GetParent();
if (grandParent && grandParent->IsXUL()) {
int32_t index = FindContent(grandParent);
if (index >= 0 && mBoxObject) {
// XXX Should we make an effort to invalidate only cell ?
mBoxObject->InvalidateRow(index);
}
}
}
}
}
}