/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */

/* vim: set ts=8 sts=2 et sw=2 tw=80: */

/* This Source Code Form is subject to the terms of the Mozilla Public

 * License, v. 2.0. If a copy of the MPL was not distributed with this

 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#include "nsNameSpaceManager.h"

#include "nsGkAtoms.h"

#include "nsIBoxObject.h"

#include "nsTreeColumns.h"

#include "nsTreeUtils.h"

#include "mozilla/ComputedStyle.h"

#include "nsContentUtils.h"

#include "nsTreeBodyFrame.h"

#include "mozilla/dom/Element.h"

#include "mozilla/dom/TreeBoxObject.h"

#include "mozilla/dom/TreeColumnBinding.h"

#include "mozilla/dom/TreeColumnsBinding.h"

using namespace mozilla;

// Column class that caches all the info about our column.

nsTreeColumn::nsTreeColumn(nsTreeColumns* aColumns, dom::Element* aElement)

  : mContent(aElement),

    mColumns(aColumns),

    mIndex(0),

    mPrevious(nullptr)

{

  NS_ASSERTION(aElement &&

               aElement->NodeInfo()->Equals(nsGkAtoms::treecol,

                                            kNameSpaceID_XUL),

               "nsTreeColumn's content must be a <xul:treecol>");

  Invalidate(IgnoreErrors());

}

nsTreeColumn::~nsTreeColumn()

{

  if (mNext) {

    mNext->SetPrevious(nullptr);

  }

}

NS_IMPL_CYCLE_COLLECTION_CLASS(nsTreeColumn)

NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(nsTreeColumn)

  NS_IMPL_CYCLE_COLLECTION_UNLINK_PRESERVED_WRAPPER

  NS_IMPL_CYCLE_COLLECTION_UNLINK(mContent)

  if (tmp->mNext) {

    tmp->mNext->SetPrevious(nullptr);

    NS_IMPL_CYCLE_COLLECTION_UNLINK(mNext)

  }

NS_IMPL_CYCLE_COLLECTION_UNLINK_END

NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(nsTreeColumn)

  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mContent)

  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mNext)

NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END

NS_IMPL_CYCLE_COLLECTION_TRACE_WRAPPERCACHE(nsTreeColumn)

NS_IMPL_CYCLE_COLLECTING_ADDREF(nsTreeColumn)

NS_IMPL_CYCLE_COLLECTING_RELEASE(nsTreeColumn)

// QueryInterface implementation for nsTreeColumn

NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(nsTreeColumn)

  NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY

  NS_INTERFACE_MAP_ENTRY(nsISupports)

  NS_INTERFACE_MAP_ENTRY_CONCRETE(nsTreeColumn)

NS_INTERFACE_MAP_END

nsIFrame*

nsTreeColumn::GetFrame()

{

  return mContent->GetPrimaryFrame();

}

bool

nsTreeColumn::IsLastVisible(nsTreeBodyFrame* aBodyFrame)

{

  NS_ASSERTION(GetFrame(), "should have checked for this already");

  // cyclers are fixed width, don't adjust them

  if (IsCycler())

    return false;

  // we're certainly not the last visible if we're not visible

  if (GetFrame()->GetRect().width == 0)

    return false;

  // try to find a visible successor

  for (nsTreeColumn *next = GetNext(); next; next = next->GetNext()) {

    nsIFrame* frame = next->GetFrame();

    if (frame && frame->GetRect().width > 0)

      return false;

  }

  return true;

}

nsresult

nsTreeColumn::GetRect(nsTreeBodyFrame* aBodyFrame, nscoord aY, nscoord aHeight, nsRect* aResult)

{

  nsIFrame* frame = GetFrame();

  if (!frame) {

    *aResult = nsRect();

    return NS_ERROR_FAILURE;

  }

  bool isRTL = aBodyFrame->StyleVisibility()->mDirection == NS_STYLE_DIRECTION_RTL;

  *aResult = frame->GetRect();

  aResult->y = aY;

  aResult->height = aHeight;

  if (isRTL)

    aResult->x += aBodyFrame->mAdjustWidth;

  else if (IsLastVisible(aBodyFrame))

    aResult->width += aBodyFrame->mAdjustWidth;

  return NS_OK;

}

nsresult

nsTreeColumn::GetXInTwips(nsTreeBodyFrame* aBodyFrame, nscoord* aResult)

{

  nsIFrame* frame = GetFrame();

  if (!frame) {

    *aResult = 0;

    return NS_ERROR_FAILURE;

  }

  *aResult = frame->GetRect().x;

  return NS_OK;

}

nsresult

nsTreeColumn::GetWidthInTwips(nsTreeBodyFrame* aBodyFrame, nscoord* aResult)

{

  nsIFrame* frame = GetFrame();

  if (!frame) {

    *aResult = 0;

    return NS_ERROR_FAILURE;

  }

  *aResult = frame->GetRect().width;

  if (IsLastVisible(aBodyFrame))

    *aResult += aBodyFrame->mAdjustWidth;

  return NS_OK;

}

void

nsTreeColumn::GetId(nsAString& aId) const

{

  aId = GetId();

}

void

nsTreeColumn::Invalidate(ErrorResult& aRv)

{

  nsIFrame* frame = GetFrame();

  if (NS_WARN_IF(!frame)) {

    aRv.Throw(NS_ERROR_FAILURE);

    return;

  }

  // Fetch the Id.

  mContent->GetAttr(kNameSpaceID_None, nsGkAtoms::id, mId);

  // If we have an Id, cache the Id as an atom.

  if (!mId.IsEmpty()) {

    mAtom = NS_Atomize(mId);

  }

  // Cache our index.

  nsTreeUtils::GetColumnIndex(mContent, &mIndex);

  const nsStyleVisibility* vis = frame->StyleVisibility();

  // Cache our text alignment policy.

  const nsStyleText* textStyle = frame->StyleText();

  mTextAlignment = textStyle->mTextAlign;

  // START or END alignment sometimes means RIGHT

  if ((mTextAlignment == NS_STYLE_TEXT_ALIGN_START &&

       vis->mDirection == NS_STYLE_DIRECTION_RTL) ||

      (mTextAlignment == NS_STYLE_TEXT_ALIGN_END &&

       vis->mDirection == NS_STYLE_DIRECTION_LTR)) {

    mTextAlignment = NS_STYLE_TEXT_ALIGN_RIGHT;

  } else if (mTextAlignment == NS_STYLE_TEXT_ALIGN_START ||

             mTextAlignment == NS_STYLE_TEXT_ALIGN_END) {

    mTextAlignment = NS_STYLE_TEXT_ALIGN_LEFT;

  }

  // Figure out if we're the primary column (that has to have indentation

  // and twisties drawn.

  mIsPrimary = mContent->AttrValueIs(kNameSpaceID_None,

                                     nsGkAtoms::primary,

                                     nsGkAtoms::_true,

                                     eCaseMatters);

  // Figure out if we're a cycling column (one that doesn't cause a selection

  // to happen).

  mIsCycler =

    mContent->AttrValueIs(kNameSpaceID_None, nsGkAtoms::cycler,

                          nsGkAtoms::_true, eCaseMatters);

  mIsEditable =

    mContent->AttrValueIs(kNameSpaceID_None, nsGkAtoms::editable,

                          nsGkAtoms::_true, eCaseMatters);

  mIsSelectable =

    !mContent->AttrValueIs(kNameSpaceID_None, nsGkAtoms::selectable,

                           nsGkAtoms::_false, eCaseMatters);

  mOverflow =

    mContent->AttrValueIs(kNameSpaceID_None, nsGkAtoms::overflow,

                          nsGkAtoms::_true, eCaseMatters);

  // Figure out our column type. Default type is text.

  mType = TreeColumn_Binding::TYPE_TEXT;

  static Element::AttrValuesArray typestrings[] =

    {&nsGkAtoms::checkbox, &nsGkAtoms::password,

     nullptr};

  switch (mContent->FindAttrValueIn(kNameSpaceID_None,

                                    nsGkAtoms::type,

                                    typestrings,

                                    eCaseMatters)) {

    case 0: mType = TreeColumn_Binding::TYPE_CHECKBOX; break;

    case 1: mType = TreeColumn_Binding::TYPE_PASSWORD; break;

  }

  // Fetch the crop style.

  mCropStyle = 0;

  static Element::AttrValuesArray cropstrings[] =

    {&nsGkAtoms::center, &nsGkAtoms::left, &nsGkAtoms::start, nullptr};

  switch (mContent->FindAttrValueIn(kNameSpaceID_None,

                                    nsGkAtoms::crop, cropstrings,

                                    eCaseMatters)) {

    case 0:

      mCropStyle = 1;

      break;

    case 1:

    case 2:

      mCropStyle = 2;

      break;

  }

}

nsIContent*

nsTreeColumn::GetParentObject() const

{

  return mContent;

}

/* virtual */ JSObject*

nsTreeColumn::WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto)

{

  return dom::TreeColumn_Binding::Wrap(aCx, this, aGivenProto);

}

Element*

nsTreeColumn::Element()

{

  return mContent;

}

int32_t

nsTreeColumn::GetX(mozilla::ErrorResult& aRv)

{

  nsIFrame* frame = GetFrame();

  if (NS_WARN_IF(!frame)) {

    aRv.Throw(NS_ERROR_FAILURE);

    return 0;

  }

  return nsPresContext::AppUnitsToIntCSSPixels(frame->GetRect().x);

}

int32_t

nsTreeColumn::GetWidth(mozilla::ErrorResult& aRv)

{

  nsIFrame* frame = GetFrame();

  if (NS_WARN_IF(!frame)) {

    aRv.Throw(NS_ERROR_FAILURE);

    return 0;

  }

  return nsPresContext::AppUnitsToIntCSSPixels(frame->GetRect().width);

}

nsTreeColumns::nsTreeColumns(nsTreeBodyFrame* aTree)

  : mTree(aTree)

{

}

nsTreeColumns::~nsTreeColumns()

{

  nsTreeColumns::InvalidateColumns();

}

NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE_0(nsTreeColumns)

// QueryInterface implementation for nsTreeColumns

NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(nsTreeColumns)

  NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY

  NS_INTERFACE_MAP_ENTRY(nsISupports)

NS_INTERFACE_MAP_END

NS_IMPL_CYCLE_COLLECTING_ADDREF(nsTreeColumns)

NS_IMPL_CYCLE_COLLECTING_RELEASE(nsTreeColumns)

nsIContent*

nsTreeColumns::GetParentObject() const

{

  return mTree ? mTree->GetBaseElement() : nullptr;

}

/* virtual */ JSObject*

nsTreeColumns::WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto)

{

  return dom::TreeColumns_Binding::Wrap(aCx, this, aGivenProto);

}

dom::TreeBoxObject*

nsTreeColumns::GetTree() const

{

  return mTree ? static_cast<mozilla::dom::TreeBoxObject*>(mTree->GetTreeBoxObject()) : nullptr;

}

uint32_t

nsTreeColumns::Count()

{

  EnsureColumns();

  uint32_t count = 0;

  for (nsTreeColumn* currCol = mFirstColumn; currCol; currCol = currCol->GetNext()) {

    ++count;

  }

  return count;

}

nsTreeColumn*

nsTreeColumns::GetLastColumn()

{

  EnsureColumns();

  nsTreeColumn* currCol = mFirstColumn;

  while (currCol) {

    nsTreeColumn* next = currCol->GetNext();

    if (!next) {

      return currCol;

    }

    currCol = next;

  }

  return nullptr;

}

nsTreeColumn*

nsTreeColumns::GetSortedColumn()

{

  EnsureColumns();

  for (nsTreeColumn* currCol = mFirstColumn; currCol; currCol = currCol->GetNext()) {

    if (nsContentUtils::HasNonEmptyAttr(currCol->mContent, kNameSpaceID_None,

                                        nsGkAtoms::sortDirection)) {

      return currCol;

    }

  }

  return nullptr;

}

nsTreeColumn*

nsTreeColumns::GetKeyColumn()

{

  EnsureColumns();

  nsTreeColumn* first = nullptr;

  nsTreeColumn* primary = nullptr;

  nsTreeColumn* sorted = nullptr;

  for (nsTreeColumn* currCol = mFirstColumn; currCol; currCol = currCol->GetNext()) {

    // Skip hidden columns.

    if (currCol->mContent->AttrValueIs(kNameSpaceID_None,

                                       nsGkAtoms::hidden,

                                       nsGkAtoms::_true,

                                       eCaseMatters))

      continue;

    // Skip non-text column

    if (currCol->GetType() != TreeColumn_Binding::TYPE_TEXT)

      continue;

    if (!first)

      first = currCol;

    if (nsContentUtils::HasNonEmptyAttr(currCol->mContent, kNameSpaceID_None,

                                        nsGkAtoms::sortDirection)) {

      // Use sorted column as the key.

      sorted = currCol;

      break;

    }

    if (currCol->IsPrimary())

      if (!primary)

        primary = currCol;

  }

  if (sorted)

    return sorted;

  if (primary)

    return primary;

  return first;

}

nsTreeColumn*

nsTreeColumns::GetColumnFor(dom::Element* aElement)

{

  EnsureColumns();

  for (nsTreeColumn* currCol = mFirstColumn; currCol; currCol = currCol->GetNext()) {

    if (currCol->mContent == aElement) {

      return currCol;

    }

  }

  return nullptr;

}

nsTreeColumn*

nsTreeColumns::NamedGetter(const nsAString& aId, bool& aFound)

{

  EnsureColumns();

  for (nsTreeColumn* currCol = mFirstColumn; currCol; currCol = currCol->GetNext()) {

    if (currCol->GetId().Equals(aId)) {

      aFound = true;

      return currCol;

    }

  }

  aFound = false;

  return nullptr;

}

nsTreeColumn*

nsTreeColumns::GetNamedColumn(const nsAString& aId)

{

  bool dummy;

  return NamedGetter(aId, dummy);

}

void

nsTreeColumns::GetSupportedNames(nsTArray<nsString>& aNames)

{

  for (nsTreeColumn* currCol = mFirstColumn; currCol; currCol = currCol->GetNext()) {

    aNames.AppendElement(currCol->GetId());

  }

}

nsTreeColumn*

nsTreeColumns::IndexedGetter(uint32_t aIndex, bool& aFound)

{

  EnsureColumns();

  for (nsTreeColumn* currCol = mFirstColumn; currCol; currCol = currCol->GetNext()) {

    if (currCol->GetIndex() == static_cast<int32_t>(aIndex)) {

      aFound = true;

      return currCol;

    }

  }

  aFound = false;

  return nullptr;

}

nsTreeColumn*

nsTreeColumns::GetColumnAt(uint32_t aIndex)

{

  bool dummy;

  return IndexedGetter(aIndex, dummy);

}

void

nsTreeColumns::InvalidateColumns()

{

  for (nsTreeColumn* currCol = mFirstColumn; currCol;

       currCol = currCol->GetNext()) {

    currCol->SetColumns(nullptr);

  }

  mFirstColumn = nullptr;

}

void

nsTreeColumns::RestoreNaturalOrder()

{

  if (!mTree) {

    return;

  }

  nsIContent* content = mTree->GetBaseElement();

  // Strong ref, since we'll be setting attributes

  nsCOMPtr<nsIContent> colsContent =

    nsTreeUtils::GetImmediateChild(content, nsGkAtoms::treecols);

  if (!colsContent) {

    return;

  }

  int32_t i = 0;

  for (nsINode* child = colsContent->GetFirstChild();

       child; child = child->GetNextSibling()) {

    nsAutoString ordinal;

    ordinal.AppendInt(i++);

    if (child->IsElement()) {

      child->AsElement()->SetAttr(kNameSpaceID_None, nsGkAtoms::ordinal, ordinal,

                                  true);

    }

  }

  nsTreeColumns::InvalidateColumns();

  if (mTree) {

    mTree->Invalidate();

  }

}

nsTreeColumn*

nsTreeColumns::GetPrimaryColumn()

{

  EnsureColumns();

  for (nsTreeColumn* currCol = mFirstColumn; currCol; currCol = currCol->GetNext()) {

    if (currCol->IsPrimary()) {

      return currCol;

    }

  }

  return nullptr;

}

void

nsTreeColumns::EnsureColumns()

{

  if (mTree && !mFirstColumn) {

    nsIContent* treeContent = mTree->GetBaseElement();

    nsIContent* colsContent =

      nsTreeUtils::GetDescendantChild(treeContent, nsGkAtoms::treecols);

    if (!colsContent)

      return;

    nsIContent* colContent =

      nsTreeUtils::GetDescendantChild(colsContent, nsGkAtoms::treecol);

    if (!colContent)

      return;

    nsIFrame* colFrame = colContent->GetPrimaryFrame();

    if (!colFrame)

      return;

    colFrame = colFrame->GetParent();

    if (!colFrame)

      return;

    colFrame = colFrame->PrincipalChildList().FirstChild();

    if (!colFrame)

      return;

    // Now that we have the first visible column,

    // we can enumerate the columns in visible order

    nsTreeColumn* currCol = nullptr;

    while (colFrame) {

      nsIContent* colContent = colFrame->GetContent();

      if (colContent->NodeInfo()->Equals(nsGkAtoms::treecol,

                                         kNameSpaceID_XUL)) {

        // Create a new column structure.

        nsTreeColumn* col = new nsTreeColumn(this, colContent->AsElement());

        if (!col)

          return;

        if (currCol) {

          currCol->SetNext(col);

          col->SetPrevious(currCol);

        }

        else {

          mFirstColumn = col;

        }

        currCol = col;

      }

      colFrame = colFrame->GetNextSibling();

    }

  }

}