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

/* vim: set ts=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 "InterfaceInitFuncs.h"

#include "Accessible-inl.h"

#include "AccessibleWrap.h"

#include "nsAccUtils.h"

#include "TableAccessible.h"

#include "TableCellAccessible.h"

#include "nsMai.h"

#include "ProxyAccessible.h"

#include "nsArrayUtils.h"

#include "mozilla/Likely.h"

using namespace mozilla::a11y;

extern "C" {

static gint

GetColumnSpanCB(AtkTableCell* aCell)

{

  AccessibleWrap* accWrap = GetAccessibleWrap(ATK_OBJECT(aCell));

  if (accWrap) {

    return accWrap->AsTableCell()->ColExtent();

  }

  if (ProxyAccessible* proxy = GetProxy(ATK_OBJECT(aCell))) {

    return proxy->ColExtent();

  }

  return 0;

}

static gboolean

GetRowSpanCB(AtkTableCell* aCell)

{

  AccessibleWrap* accWrap = GetAccessibleWrap(ATK_OBJECT(aCell));

  if (accWrap) {

    return accWrap->AsTableCell()->RowExtent();

  }

  if (ProxyAccessible* proxy = GetProxy(ATK_OBJECT(aCell))) {

    return proxy->RowExtent();

  }

  return 0;

}

static gboolean

GetPositionCB(AtkTableCell* aCell, gint* aRow, gint* aCol)

{

  if (AccessibleWrap* accWrap = GetAccessibleWrap(ATK_OBJECT(aCell))) {

    TableCellAccessible* cell = accWrap->AsTableCell();

    if (!cell) {

      return false;

    }

    *aRow = cell->RowIdx();

    *aCol = cell->ColIdx();

    return true;

  }

  if (ProxyAccessible* proxy = GetProxy(ATK_OBJECT(aCell))) {

    uint32_t rowIdx = 0, colIdx = 0;

    proxy->GetPosition(&rowIdx, &colIdx);

    *aCol = colIdx;

    *aRow = rowIdx;

    return true;

  }

  return false;

}

static gboolean

GetColumnRowSpanCB(AtkTableCell* aCell, gint* aCol, gint* aRow,

                   gint* aColExtent, gint* aRowExtent) {

  if (AccessibleWrap* accWrap = GetAccessibleWrap(ATK_OBJECT(aCell))) {

    TableCellAccessible* cellAcc = accWrap->AsTableCell();

    if (!cellAcc) {

      return false;

    }

    *aCol = cellAcc->ColIdx();

    *aRow = cellAcc->RowIdx();

    *aColExtent = cellAcc->ColExtent();

    *aRowExtent = cellAcc->ColExtent();

    return true;

  }

  if (ProxyAccessible* proxy = GetProxy(ATK_OBJECT(aCell))) {

    uint32_t colIdx = 0, rowIdx = 0, colExtent = 0, rowExtent = 0;

    proxy->GetColRowExtents(&colIdx, &rowIdx, &colExtent, &rowExtent);

    *aCol = colIdx;

    *aRow = rowIdx;

    *aColExtent = colExtent;

    *aRowExtent = rowExtent;

  return true;

  }

  return false;

}

static AtkObject*

GetTableCB(AtkTableCell* aTableCell)

{

  AccessibleWrap* accWrap = GetAccessibleWrap(ATK_OBJECT(aTableCell));

  if (accWrap) {

    TableAccessible* table = accWrap->AsTableCell()->Table();

    if (!table) {

      return nullptr;

    }

    Accessible* tableAcc = table->AsAccessible();

    return tableAcc ? AccessibleWrap::GetAtkObject(tableAcc) : nullptr;

  }

  if (ProxyAccessible* proxy = GetProxy(ATK_OBJECT(aTableCell))) {

    ProxyAccessible* table = proxy->TableOfACell();

    return table ? GetWrapperFor(table) : nullptr;

  }

  return nullptr;

}

static GPtrArray*

GetColumnHeaderCellsCB(AtkTableCell* aCell)

{

  if (AccessibleWrap* accWrap = GetAccessibleWrap(ATK_OBJECT(aCell))) {

    AutoTArray<Accessible*, 10> headers;

    accWrap->AsTableCell()->ColHeaderCells(&headers);

    if (headers.IsEmpty()) {

      return nullptr;

    }

    GPtrArray* atkHeaders = g_ptr_array_sized_new(headers.Length());

    for (Accessible* header: headers) {

      AtkObject* atkHeader = AccessibleWrap::GetAtkObject(header);

      g_object_ref(atkHeader);

      g_ptr_array_add(atkHeaders, atkHeader);

    }

    return atkHeaders;

  }

  if (ProxyAccessible* proxy = GetProxy(ATK_OBJECT(aCell))) {

    AutoTArray<ProxyAccessible*, 10> headers;

    proxy->ColHeaderCells(&headers);

    if (headers.IsEmpty()) {

      return nullptr;

    }

    GPtrArray* atkHeaders = g_ptr_array_sized_new(headers.Length());

    for (ProxyAccessible* header: headers) {

      AtkObject* atkHeader = GetWrapperFor(header);

      g_object_ref(atkHeader);

      g_ptr_array_add(atkHeaders, atkHeader);

    }

    return atkHeaders;

  }

  return nullptr;

}

static GPtrArray*

GetRowHeaderCellsCB(AtkTableCell* aCell)

{

  if (AccessibleWrap* accWrap = GetAccessibleWrap(ATK_OBJECT(aCell))) {

    AutoTArray<Accessible*, 10> headers;

    accWrap->AsTableCell()->RowHeaderCells(&headers);

    if (headers.IsEmpty()) {

      return nullptr;

    }

    GPtrArray* atkHeaders = g_ptr_array_sized_new(headers.Length());

    for (Accessible* header: headers) {

      AtkObject* atkHeader = AccessibleWrap::GetAtkObject(header);

      g_object_ref(atkHeader);

      g_ptr_array_add(atkHeaders, atkHeader);

    }

    return atkHeaders;

  }

  if (ProxyAccessible* proxy = GetProxy(ATK_OBJECT(aCell))) {

    AutoTArray<ProxyAccessible*, 10> headers;

    proxy->RowHeaderCells(&headers);

    if (headers.IsEmpty()) {

      return nullptr;

    }

    GPtrArray* atkHeaders = g_ptr_array_sized_new(headers.Length());

    for (ProxyAccessible* header: headers) {

      AtkObject* atkHeader = GetWrapperFor(header);

      g_object_ref(atkHeader);

      g_ptr_array_add(atkHeaders, atkHeader);

    }

    return atkHeaders;

  }

  return nullptr;

}

}

void

tableCellInterfaceInitCB(AtkTableCellIface* aIface)

{

  NS_ASSERTION(aIface, "no interface!");

  if (MOZ_UNLIKELY(!aIface))

    return;

  aIface->get_column_span = GetColumnSpanCB;

  aIface->get_column_header_cells = GetColumnHeaderCellsCB;

  aIface->get_position = GetPositionCB;

  aIface->get_row_span = GetRowSpanCB;

  aIface->get_row_header_cells = GetRowHeaderCellsCB;

  aIface->get_row_column_span = GetColumnRowSpanCB;

  aIface->get_table = GetTableCB;

}