--- a/accessible/src/atk/nsAccessibleWrap.cpp
+++ b/accessible/src/atk/nsAccessibleWrap.cpp
@@ -371,35 +371,35 @@ NS_IMETHODIMP nsAccessibleWrap::GetNativ
if (!IsEmbeddedObject(this)) {
// We don't create ATK objects for nsIAccessible plain text leaves
return NS_ERROR_FAILURE;
}
GType type = GetMaiAtkType(CreateMaiInterfaces());
NS_ENSURE_TRUE(type, NS_ERROR_FAILURE);
mAtkObject =
- NS_REINTERPRET_CAST(AtkObject *,
- g_object_new(type, NULL));
+ reinterpret_cast<AtkObject *>
+ (g_object_new(type, NULL));
NS_ENSURE_TRUE(mAtkObject, NS_ERROR_OUT_OF_MEMORY);
atk_object_initialize(mAtkObject, this);
mAtkObject->role = ATK_ROLE_INVALID;
mAtkObject->layer = ATK_LAYER_INVALID;
}
*aOutAccessible = mAtkObject;
return NS_OK;
}
AtkObject *
nsAccessibleWrap::GetAtkObject(void)
{
void *atkObj = nsnull;
GetNativeInterface(&atkObj);
- return NS_STATIC_CAST(AtkObject *, atkObj);
+ return static_cast<AtkObject *>(atkObj);
}
// Get AtkObject from nsIAccessible interface
/* static */
AtkObject *
nsAccessibleWrap::GetAtkObject(nsIAccessible * acc)
{
void *atkObjPtr = nsnull;
@@ -685,17 +685,17 @@ initializeCB(AtkObject *aAtkObj, gpointe
* maybe it has later
*/
if (ATK_OBJECT_CLASS(parent_class)->initialize)
ATK_OBJECT_CLASS(parent_class)->initialize(aAtkObj, aData);
/* initialize object */
MAI_ATK_OBJECT(aAtkObj)->accWrap =
- NS_STATIC_CAST(nsAccessibleWrap*, aData);
+ static_cast<nsAccessibleWrap*>(aData);
#ifdef MAI_LOGGING
++sMaiAtkObjCreated;
#endif
MAI_LOG_DEBUG(("MaiAtkObj Create obj=%p for AccWrap=%p, all=%d, left=%d\n",
(void*)aAtkObj, (void*)aData, sMaiAtkObjCreated,
(sMaiAtkObjCreated-sMaiAtkObjDeleted)));
}
@@ -777,17 +777,17 @@ getRoleCB(AtkObject *aAtkObj)
if (aAtkObj->role == ATK_ROLE_INVALID) {
PRUint32 accRole, atkRole;
nsresult rv = accWrap->GetFinalRole(&accRole);
NS_ENSURE_SUCCESS(rv, ATK_ROLE_INVALID);
atkRole = atkRoleMap[accRole]; // map to the actual value
NS_ASSERTION(atkRoleMap[nsIAccessibleRole::ROLE_LAST_ENTRY] ==
kROLE_ATK_LAST_ENTRY, "ATK role map skewed");
- aAtkObj->role = NS_STATIC_CAST(AtkRole, atkRole);
+ aAtkObj->role = static_cast<AtkRole>(atkRole);
}
return aAtkObj->role;
}
AtkAttributeSet *
GetAttributeSet(nsIAccessible* aAccessible)
{
AtkAttributeSet *objAttributeSet = nsnull;
@@ -962,17 +962,17 @@ getIndexInParentCB(AtkObject *aAtkObj)
nsCOMPtr<nsIAccessible> sibling;
parent->GetFirstChild(getter_AddRefs(sibling));
if (!sibling) {
return -1; // Error, parent has no children
}
PRInt32 currentIndex = 0;
- while (sibling != NS_STATIC_CAST(nsIAccessible*, accWrap)) {
+ while (sibling != static_cast<nsIAccessible*>(accWrap)) {
NS_ASSERTION(sibling, "Never ran into the same child that we started from");
if (!sibling) {
return -1;
}
if (nsAccessible::IsEmbeddedObject(sibling)) {
++ currentIndex;
}
@@ -1055,27 +1055,27 @@ refRelationSetCB(AtkObject *aAtkObj)
nsIAccessibleRelation::RELATION_EMBEDS,
nsIAccessibleRelation::RELATION_FLOWS_TO,
nsIAccessibleRelation::RELATION_FLOWS_FROM,
nsIAccessibleRelation::RELATION_DESCRIBED_BY,
nsIAccessibleRelation::RELATION_DESCRIPTION_FOR,
};
for (PRUint32 i = 0; i < NS_ARRAY_LENGTH(relationType); i++) {
- relation = atk_relation_set_get_relation_by_type(relation_set, NS_STATIC_CAST(AtkRelationType, relationType[i]));
+ relation = atk_relation_set_get_relation_by_type(relation_set, static_cast<AtkRelationType>(relationType[i]));
if (relation) {
atk_relation_set_remove(relation_set, relation);
}
nsIAccessible* accRelated;
nsresult rv = accWrap->GetAccessibleRelated(relationType[i], &accRelated);
if (NS_SUCCEEDED(rv) && accRelated) {
accessible_array[0] = nsAccessibleWrap::GetAtkObject(accRelated);
relation = atk_relation_new(accessible_array, 1,
- NS_STATIC_CAST(AtkRelationType, relationType[i]));
+ static_cast<AtkRelationType>(relationType[i]));
atk_relation_set_add(relation_set, relation);
g_object_unref(relation);
}
}
return relation_set;
}
@@ -1091,17 +1091,17 @@ nsAccessibleWrap *GetAccessibleWrap(AtkO
return nsnull;
}
NS_ENSURE_TRUE(tmpAccWrap->GetAtkObject() == aAtkObj, nsnull);
nsRefPtr<nsApplicationAccessibleWrap> appAccWrap =
nsAccessNode::GetApplicationAccessible();
nsAccessibleWrap* tmpAppAccWrap =
- NS_STATIC_CAST(nsAccessibleWrap*, appAccWrap.get());
+ static_cast<nsAccessibleWrap*>(appAccWrap.get());
if (tmpAppAccWrap != tmpAccWrap && !tmpAccWrap->IsValidObject())
return nsnull;
return tmpAccWrap;
}
NS_IMETHODIMP
@@ -1113,17 +1113,17 @@ nsAccessibleWrap::FireAccessibleEvent(ns
nsCOMPtr<nsIAccessible> accessible;
aEvent->GetAccessible(getter_AddRefs(accessible));
NS_ENSURE_TRUE(accessible, NS_ERROR_FAILURE);
PRUint32 type = 0;
rv = aEvent->GetEventType(&type);
NS_ENSURE_SUCCESS(rv, rv);
- nsAccEvent *event = NS_REINTERPRET_CAST(nsAccEvent*, aEvent);
+ nsAccEvent *event = reinterpret_cast<nsAccEvent*>(aEvent);
void *eventData = event->mEventData;
AtkObject *atkObj = nsAccessibleWrap::GetAtkObject(accessible);
// We don't create ATK objects for nsIAccessible plain text leaves,
// just return NS_OK in such case
if (!atkObj) {
NS_ASSERTION(type == nsIAccessibleEvent::EVENT_SHOW ||
@@ -1210,33 +1210,33 @@ nsAccessibleWrap::FireAccessibleEvent(ns
break;
case nsIAccessibleEvent::EVENT_TABLE_ROW_INSERT:
MAI_LOG_DEBUG(("\n\nReceived: EVENT_TABLE_ROW_INSERT\n"));
NS_ASSERTION(eventData, "Event needs event data");
if (!eventData)
break;
- pAtkTableChange = NS_REINTERPRET_CAST(AtkTableChange *, eventData);
+ pAtkTableChange = reinterpret_cast<AtkTableChange *>(eventData);
g_signal_emit_by_name(atkObj,
"row_inserted",
// After which the rows are inserted
pAtkTableChange->index,
// The number of the inserted
pAtkTableChange->count);
break;
case nsIAccessibleEvent::EVENT_TABLE_ROW_DELETE:
MAI_LOG_DEBUG(("\n\nReceived: EVENT_TABLE_ROW_DELETE\n"));
NS_ASSERTION(eventData, "Event needs event data");
if (!eventData)
break;
- pAtkTableChange = NS_REINTERPRET_CAST(AtkTableChange *, eventData);
+ pAtkTableChange = reinterpret_cast<AtkTableChange *>(eventData);
g_signal_emit_by_name(atkObj,
"row_deleted",
// After which the rows are deleted
pAtkTableChange->index,
// The number of the deleted
pAtkTableChange->count);
break;
@@ -1247,33 +1247,33 @@ nsAccessibleWrap::FireAccessibleEvent(ns
break;
case nsIAccessibleEvent::EVENT_TABLE_COLUMN_INSERT:
MAI_LOG_DEBUG(("\n\nReceived: EVENT_TABLE_COLUMN_INSERT\n"));
NS_ASSERTION(eventData, "Event needs event data");
if (!eventData)
break;
- pAtkTableChange = NS_REINTERPRET_CAST(AtkTableChange *, eventData);
+ pAtkTableChange = reinterpret_cast<AtkTableChange *>(eventData);
g_signal_emit_by_name(atkObj,
"column_inserted",
// After which the columns are inserted
pAtkTableChange->index,
// The number of the inserted
pAtkTableChange->count);
break;
case nsIAccessibleEvent::EVENT_TABLE_COLUMN_DELETE:
MAI_LOG_DEBUG(("\n\nReceived: EVENT_TABLE_COLUMN_DELETE\n"));
NS_ASSERTION(eventData, "Event needs event data");
if (!eventData)
break;
- pAtkTableChange = NS_REINTERPRET_CAST(AtkTableChange *, eventData);
+ pAtkTableChange = reinterpret_cast<AtkTableChange *>(eventData);
g_signal_emit_by_name(atkObj,
"column_deleted",
// After which the columns are deleted
pAtkTableChange->index,
// The number of the deleted
pAtkTableChange->count);
break;
@@ -1316,27 +1316,27 @@ nsAccessibleWrap::FireAccessibleEvent(ns
case nsIAccessibleEvent::EVENT_MENU_END:
MAI_LOG_DEBUG(("\n\nReceived: EVENT_MENU_END\n"));
break;
case nsIAccessibleEvent::EVENT_WINDOW_ACTIVATE:
{
MAI_LOG_DEBUG(("\n\nReceived: EVENT_WINDOW_ACTIVATED\n"));
nsDocAccessibleWrap *accDocWrap =
- NS_STATIC_CAST(nsDocAccessibleWrap *, accessible.get());
+ static_cast<nsDocAccessibleWrap *>(accessible.get());
accDocWrap->mActivated = PR_TRUE;
guint id = g_signal_lookup ("activate", MAI_TYPE_ATK_OBJECT);
g_signal_emit(atkObj, id, 0);
} break;
case nsIAccessibleEvent::EVENT_WINDOW_DEACTIVATE:
{
MAI_LOG_DEBUG(("\n\nReceived: EVENT_WINDOW_DEACTIVATED\n"));
nsDocAccessibleWrap *accDocWrap =
- NS_STATIC_CAST(nsDocAccessibleWrap *, accessible.get());
+ static_cast<nsDocAccessibleWrap *>(accessible.get());
accDocWrap->mActivated = PR_FALSE;
guint id = g_signal_lookup ("deactivate", MAI_TYPE_ATK_OBJECT);
g_signal_emit(atkObj, id, 0);
} break;
case nsIAccessibleEvent::EVENT_DOCUMENT_LOAD_COMPLETE:
{
MAI_LOG_DEBUG(("\n\nReceived: EVENT_DOCUMENT_LOAD_COMPLETE\n"));
@@ -1452,39 +1452,39 @@ nsAccessibleWrap::FireAtkPropChangedEven
AtkObject *aObject)
{
MAI_LOG_DEBUG(("\n\nReceived: EVENT_PROPERTY_CHANGED\n"));
AtkPropertyChange *pAtkPropChange;
AtkPropertyValues values = { NULL };
nsAccessibleWrap *oldAccWrap = nsnull, *newAccWrap = nsnull;
- nsAccEvent *event = NS_REINTERPRET_CAST(nsAccEvent*, aEvent);
+ nsAccEvent *event = reinterpret_cast<nsAccEvent*>(aEvent);
- pAtkPropChange = NS_REINTERPRET_CAST(AtkPropertyChange *, event->mEventData);
+ pAtkPropChange = reinterpret_cast<AtkPropertyChange *>(event->mEventData);
values.property_name = sAtkPropertyNameArray[pAtkPropChange->type];
NS_ASSERTION(pAtkPropChange, "Event needs event data");
if (!pAtkPropChange)
return NS_OK;
MAI_LOG_DEBUG(("\n\nthe type of EVENT_PROPERTY_CHANGED: %d\n\n",
pAtkPropChange->type));
switch (pAtkPropChange->type) {
case PROP_TABLE_CAPTION:
case PROP_TABLE_SUMMARY:
if (pAtkPropChange->oldvalue)
- oldAccWrap = NS_REINTERPRET_CAST(nsAccessibleWrap *,
- pAtkPropChange->oldvalue);
+ oldAccWrap = reinterpret_cast<nsAccessibleWrap *>
+ (pAtkPropChange->oldvalue);
if (pAtkPropChange->newvalue)
- newAccWrap = NS_REINTERPRET_CAST(nsAccessibleWrap *,
- pAtkPropChange->newvalue);
+ newAccWrap = reinterpret_cast<nsAccessibleWrap *>
+ (pAtkPropChange->newvalue);
if (oldAccWrap && newAccWrap) {
g_value_init(&values.old_value, G_TYPE_POINTER);
g_value_set_pointer(&values.old_value,
oldAccWrap->GetAtkObject());
g_value_init(&values.new_value, G_TYPE_POINTER);
g_value_set_pointer(&values.new_value,
newAccWrap->GetAtkObject());
@@ -1492,18 +1492,18 @@ nsAccessibleWrap::FireAtkPropChangedEven
break;
case PROP_TABLE_COLUMN_DESCRIPTION:
case PROP_TABLE_COLUMN_HEADER:
case PROP_TABLE_ROW_HEADER:
case PROP_TABLE_ROW_DESCRIPTION:
g_value_init(&values.new_value, G_TYPE_INT);
g_value_set_int(&values.new_value,
- *NS_REINTERPRET_CAST(gint *,
- pAtkPropChange->newvalue));
+ *reinterpret_cast<gint *>
+ (pAtkPropChange->newvalue));
break;
//Perhaps need more cases in the future
default:
g_value_init (&values.old_value, G_TYPE_POINTER);
g_value_set_pointer (&values.old_value, pAtkPropChange->oldvalue);
g_value_init (&values.new_value, G_TYPE_POINTER);
g_value_set_pointer (&values.new_value, pAtkPropChange->newvalue);
--- a/accessible/src/atk/nsAppRootAccessible.cpp
+++ b/accessible/src/atk/nsAppRootAccessible.cpp
@@ -564,18 +564,18 @@ nsApplicationAccessibleWrap::Unload()
NS_IMETHODIMP
nsApplicationAccessibleWrap::GetNativeInterface(void **aOutAccessible)
{
*aOutAccessible = nsnull;
if (!mAtkObject) {
mAtkObject =
- NS_REINTERPRET_CAST(AtkObject *,
- g_object_new(MAI_TYPE_ATK_OBJECT, NULL));
+ reinterpret_cast<AtkObject *>
+ (g_object_new(MAI_TYPE_ATK_OBJECT, NULL));
NS_ENSURE_TRUE(mAtkObject, NS_ERROR_OUT_OF_MEMORY);
atk_object_initialize(mAtkObject, this);
mAtkObject->role = ATK_ROLE_INVALID;
mAtkObject->layer = ATK_LAYER_INVALID;
}
*aOutAccessible = mAtkObject;
--- a/accessible/src/atk/nsMaiHyperlink.cpp
+++ b/accessible/src/atk/nsMaiHyperlink.cpp
@@ -145,18 +145,18 @@ MaiHyperlink::GetAtkHyperlink(void)
if (mMaiAtkHyperlink)
return mMaiAtkHyperlink;
nsCOMPtr<nsIAccessibleHyperLink> accessIf(do_QueryInterface(mHyperlink));
if (!accessIf)
return nsnull;
mMaiAtkHyperlink =
- NS_REINTERPRET_CAST(AtkHyperlink *,
- g_object_new(mai_atk_hyperlink_get_type(), NULL));
+ reinterpret_cast<AtkHyperlink *>
+ (g_object_new(mai_atk_hyperlink_get_type(), NULL));
NS_ASSERTION(mMaiAtkHyperlink, "OUT OF MEMORY");
NS_ENSURE_TRUE(mMaiAtkHyperlink, nsnull);
/* be sure to initialize it with "this" */
MaiHyperlink::Initialize(mMaiAtkHyperlink, this);
return mMaiAtkHyperlink;
}
@@ -255,51 +255,51 @@ gint
getEndIndexCB(AtkHyperlink *aLink)
{
nsIAccessibleHyperLink *accHyperlink = get_accessible_hyperlink(aLink);
NS_ENSURE_TRUE(accHyperlink, -1);
PRInt32 endIndex = -1;
nsresult rv = accHyperlink->GetEndIndex(&endIndex);
- return (NS_FAILED(rv)) ? -1 : NS_STATIC_CAST(gint, endIndex);
+ return (NS_FAILED(rv)) ? -1 : static_cast<gint>(endIndex);
}
gint
getStartIndexCB(AtkHyperlink *aLink)
{
nsIAccessibleHyperLink *accHyperlink = get_accessible_hyperlink(aLink);
NS_ENSURE_TRUE(accHyperlink, -1);
PRInt32 startIndex = -1;
nsresult rv = accHyperlink->GetStartIndex(&startIndex);
- return (NS_FAILED(rv)) ? -1 : NS_STATIC_CAST(gint, startIndex);
+ return (NS_FAILED(rv)) ? -1 : static_cast<gint>(startIndex);
}
gboolean
isValidCB(AtkHyperlink *aLink)
{
nsIAccessibleHyperLink *accHyperlink = get_accessible_hyperlink(aLink);
NS_ENSURE_TRUE(accHyperlink, FALSE);
PRBool isValid = PR_FALSE;
nsresult rv = accHyperlink->IsValid(&isValid);
- return (NS_FAILED(rv)) ? FALSE : NS_STATIC_CAST(gboolean, isValid);
+ return (NS_FAILED(rv)) ? FALSE : static_cast<gboolean>(isValid);
}
gint
getAnchorCountCB(AtkHyperlink *aLink)
{
nsIAccessibleHyperLink *accHyperlink = get_accessible_hyperlink(aLink);
NS_ENSURE_TRUE(accHyperlink, -1);
PRInt32 count = -1;
nsresult rv = accHyperlink->GetAnchors(&count);
- return (NS_FAILED(rv)) ? -1 : NS_STATIC_CAST(gint, count);
+ return (NS_FAILED(rv)) ? -1 : static_cast<gint>(count);
}
// Check if aHyperlink is a valid MaiHyperlink, and return the
// nsIAccessibleHyperLink related.
nsIAccessibleHyperLink *
get_accessible_hyperlink(AtkHyperlink *aHyperlink)
{
NS_ENSURE_TRUE(MAI_IS_ATK_HYPERLINK(aHyperlink), nsnull);
--- a/accessible/src/atk/nsMaiInterfaceAction.cpp
+++ b/accessible/src/atk/nsMaiInterfaceAction.cpp
@@ -70,17 +70,17 @@ gint
getActionCountCB(AtkAction *aAction)
{
nsAccessibleWrap *accWrap = GetAccessibleWrap(ATK_OBJECT(aAction));
if (!accWrap)
return 0;
PRUint8 num = 0;
nsresult rv = accWrap->GetNumActions(&num);
- return (NS_FAILED(rv)) ? 0 : NS_STATIC_CAST(gint, num);
+ return (NS_FAILED(rv)) ? 0 : static_cast<gint>(num);
}
const gchar *
getActionDescriptionCB(AtkAction *aAction, gint aActionIndex)
{
nsAccessibleWrap *accWrap = GetAccessibleWrap(ATK_OBJECT(aAction));
if (!accWrap)
return nsnull;
--- a/accessible/src/atk/nsMaiInterfaceTable.cpp
+++ b/accessible/src/atk/nsMaiInterfaceTable.cpp
@@ -103,17 +103,17 @@ getIndexAtCB(AtkTable *aTable, gint aRow
accWrap->QueryInterface(NS_GET_IID(nsIAccessibleTable),
getter_AddRefs(accTable));
NS_ENSURE_TRUE(accTable, -1);
PRInt32 index;
nsresult rv = accTable->GetIndexAt(aRow, aColumn, &index);
NS_ENSURE_SUCCESS(rv, -1);
- return NS_STATIC_CAST(gint, index);
+ return static_cast<gint>(index);
}
gint
getColumnAtIndexCB(AtkTable *aTable, gint aIndex)
{
nsAccessibleWrap *accWrap = GetAccessibleWrap(ATK_OBJECT(aTable));
if (!accWrap)
return -1;
@@ -122,17 +122,17 @@ getColumnAtIndexCB(AtkTable *aTable, gin
accWrap->QueryInterface(NS_GET_IID(nsIAccessibleTable),
getter_AddRefs(accTable));
NS_ENSURE_TRUE(accTable, -1);
PRInt32 col;
nsresult rv = accTable->GetColumnAtIndex(aIndex, &col);
NS_ENSURE_SUCCESS(rv, -1);
- return NS_STATIC_CAST(gint, col);
+ return static_cast<gint>(col);
}
gint
getRowAtIndexCB(AtkTable *aTable, gint aIndex)
{
nsAccessibleWrap *accWrap = GetAccessibleWrap(ATK_OBJECT(aTable));
if (!accWrap)
return -1;
@@ -141,17 +141,17 @@ getRowAtIndexCB(AtkTable *aTable, gint a
accWrap->QueryInterface(NS_GET_IID(nsIAccessibleTable),
getter_AddRefs(accTable));
NS_ENSURE_TRUE(accTable, -1);
PRInt32 row;
nsresult rv = accTable->GetRowAtIndex(aIndex, &row);
NS_ENSURE_SUCCESS(rv, -1);
- return NS_STATIC_CAST(gint, row);
+ return static_cast<gint>(row);
}
gint
getColumnCountCB(AtkTable *aTable)
{
nsAccessibleWrap *accWrap = GetAccessibleWrap(ATK_OBJECT(aTable));
if (!accWrap)
return -1;
@@ -160,17 +160,17 @@ getColumnCountCB(AtkTable *aTable)
accWrap->QueryInterface(NS_GET_IID(nsIAccessibleTable),
getter_AddRefs(accTable));
NS_ENSURE_TRUE(accTable, -1);
PRInt32 count;
nsresult rv = accTable->GetColumns(&count);
NS_ENSURE_SUCCESS(rv, -1);
- return NS_STATIC_CAST(gint, count);
+ return static_cast<gint>(count);
}
gint
getRowCountCB(AtkTable *aTable)
{
nsAccessibleWrap *accWrap = GetAccessibleWrap(ATK_OBJECT(aTable));
if (!accWrap)
return -1;
@@ -179,17 +179,17 @@ getRowCountCB(AtkTable *aTable)
accWrap->QueryInterface(NS_GET_IID(nsIAccessibleTable),
getter_AddRefs(accTable));
NS_ENSURE_TRUE(accTable, -1);
PRInt32 count;
nsresult rv = accTable->GetRows(&count);
NS_ENSURE_SUCCESS(rv, -1);
- return NS_STATIC_CAST(gint, count);
+ return static_cast<gint>(count);
}
gint
getColumnExtentAtCB(AtkTable *aTable,
gint aRow, gint aColumn)
{
nsAccessibleWrap *accWrap = GetAccessibleWrap(ATK_OBJECT(aTable));
if (!accWrap)
@@ -199,17 +199,17 @@ getColumnExtentAtCB(AtkTable *aTable,
accWrap->QueryInterface(NS_GET_IID(nsIAccessibleTable),
getter_AddRefs(accTable));
NS_ENSURE_TRUE(accTable, -1);
PRInt32 extent;
nsresult rv = accTable->GetColumnExtentAt(aRow, aColumn, &extent);
NS_ENSURE_SUCCESS(rv, -1);
- return NS_STATIC_CAST(gint, extent);
+ return static_cast<gint>(extent);
}
gint
getRowExtentAtCB(AtkTable *aTable,
gint aRow, gint aColumn)
{
nsAccessibleWrap *accWrap = GetAccessibleWrap(ATK_OBJECT(aTable));
if (!accWrap)
@@ -219,17 +219,17 @@ getRowExtentAtCB(AtkTable *aTable,
accWrap->QueryInterface(NS_GET_IID(nsIAccessibleTable),
getter_AddRefs(accTable));
NS_ENSURE_TRUE(accTable, -1);
PRInt32 extent;
nsresult rv = accTable->GetRowExtentAt(aRow, aColumn, &extent);
NS_ENSURE_SUCCESS(rv, -1);
- return NS_STATIC_CAST(gint, extent);
+ return static_cast<gint>(extent);
}
AtkObject*
getCaptionCB(AtkTable *aTable)
{
nsAccessibleWrap *accWrap = GetAccessibleWrap(ATK_OBJECT(aTable));
if (!accWrap)
return nsnull;
@@ -370,17 +370,17 @@ getSelectedColumnsCB(AtkTable *aTable, g
gint *atkColumns = g_new(gint, size);
if (!atkColumns) {
NS_WARNING("OUT OF MEMORY");
return nsnull;
}
//copy
for (PRUint32 index = 0; index < size; ++index)
- atkColumns[index] = NS_STATIC_CAST(gint, columns[index]);
+ atkColumns[index] = static_cast<gint>(columns[index]);
nsMemory::Free(columns);
*aSelected = atkColumns;
return size;
}
gint
getSelectedRowsCB(AtkTable *aTable, gint **aSelected)
@@ -405,17 +405,17 @@ getSelectedRowsCB(AtkTable *aTable, gint
gint *atkRows = g_new(gint, size);
if (!atkRows) {
NS_WARNING("OUT OF MEMORY");
return nsnull;
}
//copy
for (PRUint32 index = 0; index < size; ++index)
- atkRows[index] = NS_STATIC_CAST(gint, rows[index]);
+ atkRows[index] = static_cast<gint>(rows[index]);
nsMemory::Free(rows);
*aSelected = atkRows;
return size;
}
gboolean
isColumnSelectedCB(AtkTable *aTable, gint aColumn)
@@ -426,44 +426,44 @@ isColumnSelectedCB(AtkTable *aTable, gin
nsCOMPtr<nsIAccessibleTable> accTable;
accWrap->QueryInterface(NS_GET_IID(nsIAccessibleTable),
getter_AddRefs(accTable));
NS_ENSURE_TRUE(accTable, FALSE);
PRBool outValue;
nsresult rv = accTable->IsColumnSelected(aColumn, &outValue);
- return NS_FAILED(rv) ? FALSE : NS_STATIC_CAST(gboolean, outValue);
+ return NS_FAILED(rv) ? FALSE : static_cast<gboolean>(outValue);
}
gboolean
isRowSelectedCB(AtkTable *aTable, gint aRow)
{
nsAccessibleWrap *accWrap = GetAccessibleWrap(ATK_OBJECT(aTable));
if (!accWrap)
return FALSE;
nsCOMPtr<nsIAccessibleTable> accTable;
accWrap->QueryInterface(NS_GET_IID(nsIAccessibleTable),
getter_AddRefs(accTable));
NS_ENSURE_TRUE(accTable, FALSE);
PRBool outValue;
nsresult rv = accTable->IsRowSelected(aRow, &outValue);
- return NS_FAILED(rv) ? FALSE : NS_STATIC_CAST(gboolean, outValue);
+ return NS_FAILED(rv) ? FALSE : static_cast<gboolean>(outValue);
}
gboolean
isCellSelectedCB(AtkTable *aTable, gint aRow, gint aColumn)
{
nsAccessibleWrap *accWrap = GetAccessibleWrap(ATK_OBJECT(aTable));
if (!accWrap)
return FALSE;
nsCOMPtr<nsIAccessibleTable> accTable;
accWrap->QueryInterface(NS_GET_IID(nsIAccessibleTable),
getter_AddRefs(accTable));
NS_ENSURE_TRUE(accTable, FALSE);
PRBool outValue;
nsresult rv = accTable->IsCellSelected(aRow, aColumn, &outValue);
- return NS_FAILED(rv) ? FALSE : NS_STATIC_CAST(gboolean, outValue);
+ return NS_FAILED(rv) ? FALSE : static_cast<gboolean>(outValue);
}
--- a/accessible/src/atk/nsMaiInterfaceText.cpp
+++ b/accessible/src/atk/nsMaiInterfaceText.cpp
@@ -74,17 +74,17 @@ textInterfaceInitCB(AtkTextIface *aIface
}
void ConvertTexttoAsterisks(nsAccessibleWrap* accWrap, nsAString& aString)
{
// convert each char to "*" when it's "password text"
PRUint32 accRole;
accWrap->GetRole(&accRole);
- if (NS_STATIC_CAST(AtkRole, accRole) == ATK_ROLE_PASSWORD_TEXT) {
+ if (static_cast<AtkRole>(accRole) == ATK_ROLE_PASSWORD_TEXT) {
for (PRUint32 i = 0; i < aString.Length(); i++)
aString.Replace(i, 1, NS_LITERAL_STRING("*"));
}
}
gchar *
getTextCB(AtkText *aText, gint aStartOffset, gint aEndOffset)
{
@@ -182,21 +182,21 @@ getCharacterAtOffsetCB(AtkText *aText, g
/* gnuichar is guint32 in glib */
PRUnichar uniChar;
nsresult rv =
accText->GetCharacterAtOffset(aOffset, &uniChar);
// convert char to "*" when it's "password text"
PRUint32 accRole;
accWrap->GetRole(&accRole);
- if (NS_STATIC_CAST(AtkRole, accRole) == ATK_ROLE_PASSWORD_TEXT) {
+ if (static_cast<AtkRole>(accRole) == ATK_ROLE_PASSWORD_TEXT) {
uniChar = '*';
}
- return (NS_FAILED(rv)) ? 0 : NS_STATIC_CAST(gunichar, uniChar);
+ return (NS_FAILED(rv)) ? 0 : static_cast<gunichar>(uniChar);
}
gchar *
getTextBeforeOffsetCB(AtkText *aText, gint aOffset,
AtkTextBoundary aBoundaryType,
gint *aStartOffset, gint *aEndOffset)
{
nsAccessibleWrap *accWrap = GetAccessibleWrap(ATK_OBJECT(aText));
@@ -232,17 +232,17 @@ getCaretOffsetCB(AtkText *aText)
nsCOMPtr<nsIAccessibleText> accText;
accWrap->QueryInterface(NS_GET_IID(nsIAccessibleText),
getter_AddRefs(accText));
NS_ENSURE_TRUE(accText, 0);
PRInt32 offset;
nsresult rv = accText->GetCaretOffset(&offset);
- return (NS_FAILED(rv)) ? 0 : NS_STATIC_CAST(gint, offset);
+ return (NS_FAILED(rv)) ? 0 : static_cast<gint>(offset);
}
AtkAttributeSet *
getRunAttributesCB(AtkText *aText, gint aOffset,
gint *aStartOffset,
gint *aEndOffset)
{
nsAccessibleWrap *accWrap = GetAccessibleWrap(ATK_OBJECT(aText));
@@ -353,17 +353,17 @@ getCharacterCountCB(AtkText *aText)
nsCOMPtr<nsIAccessibleText> accText;
accWrap->QueryInterface(NS_GET_IID(nsIAccessibleText),
getter_AddRefs(accText));
NS_ENSURE_TRUE(accText, 0);
PRInt32 count = 0;
nsresult rv = accText->GetCharacterCount(&count);
- return (NS_FAILED(rv)) ? 0 : NS_STATIC_CAST(gint, count);
+ return (NS_FAILED(rv)) ? 0 : static_cast<gint>(count);
}
gint
getOffsetAtPointCB(AtkText *aText,
gint aX, gint aY,
AtkCoordType aCoords)
{
nsAccessibleWrap *accWrap = GetAccessibleWrap(ATK_OBJECT(aText));
@@ -378,17 +378,17 @@ getOffsetAtPointCB(AtkText *aText,
PRInt32 offset = 0;
PRUint32 geckoCoordType;
if (aCoords == ATK_XY_SCREEN)
geckoCoordType = nsIAccessibleCoordinateType::COORDTYPE_SCREEN_RELATIVE;
else
geckoCoordType = nsIAccessibleCoordinateType::COORDTYPE_WINDOW_RELATIVE;
accText->GetOffsetAtPoint(aX, aY, geckoCoordType, &offset);
- return NS_STATIC_CAST(gint, offset);
+ return static_cast<gint>(offset);
}
gint
getTextSelectionCountCB(AtkText *aText)
{
nsAccessibleWrap *accWrap = GetAccessibleWrap(ATK_OBJECT(aText));
if (!accWrap)
return nsnull;
--- a/accessible/src/base/nsAccessNode.cpp
+++ b/accessible/src/base/nsAccessNode.cpp
@@ -193,17 +193,17 @@ NS_IMETHODIMP nsAccessNode::Shutdown()
mDOMNode = nsnull;
mWeakShell = nsnull;
return NS_OK;
}
NS_IMETHODIMP nsAccessNode::GetUniqueID(void **aUniqueID)
{
- *aUniqueID = NS_STATIC_CAST(void*, mDOMNode);
+ *aUniqueID = static_cast<void*>(mDOMNode);
return NS_OK;
}
NS_IMETHODIMP nsAccessNode::GetOwnerWindow(void **aWindow)
{
nsCOMPtr<nsIAccessibleDocument> docAccessible(GetDocAccessible());
NS_ASSERTION(docAccessible, "No root accessible pointer back, Init() not called.");
return docAccessible->GetWindowHandle(aWindow);
@@ -654,17 +654,17 @@ void nsAccessNode::GetComputedStyleDecla
/***************** Hashtable of nsIAccessNode's *****************/
already_AddRefed<nsIAccessibleDocument>
nsAccessNode::GetDocAccessibleFor(nsIWeakReference *aPresShell)
{
nsIAccessibleDocument *docAccessible = nsnull;
nsCOMPtr<nsIAccessNode> accessNode;
- gGlobalDocAccessibleCache.Get(NS_STATIC_CAST(void*, aPresShell), getter_AddRefs(accessNode));
+ gGlobalDocAccessibleCache.Get(static_cast<void*>(aPresShell), getter_AddRefs(accessNode));
if (accessNode) {
CallQueryInterface(accessNode, &docAccessible);
}
return docAccessible;
}
already_AddRefed<nsIAccessibleDocument>
nsAccessNode::GetDocAccessibleFor(nsISupports *aContainer, PRBool aCanCreate)
--- a/accessible/src/base/nsAccessibilityService.cpp
+++ b/accessible/src/base/nsAccessibilityService.cpp
@@ -120,17 +120,17 @@ nsAccessibilityService::nsAccessibilityS
nsCOMPtr<nsIObserverService> observerService =
do_GetService("@mozilla.org/observer-service;1");
if (!observerService)
return;
observerService->AddObserver(this, NS_XPCOM_SHUTDOWN_OBSERVER_ID, PR_FALSE);
nsCOMPtr<nsIWebProgress> progress(do_GetService(NS_DOCUMENTLOADER_SERVICE_CONTRACTID));
if (progress) {
- progress->AddProgressListener(NS_STATIC_CAST(nsIWebProgressListener*,this),
+ progress->AddProgressListener(static_cast<nsIWebProgressListener*>(this),
nsIWebProgress::NOTIFY_STATE_DOCUMENT |
nsIWebProgress::NOTIFY_LOCATION);
}
nsAccessNodeWrap::InitAccessibility();
}
nsAccessibilityService::~nsAccessibilityService()
{
@@ -150,17 +150,17 @@ nsAccessibilityService::Observe(nsISuppo
if (!nsCRT::strcmp(aTopic, NS_XPCOM_SHUTDOWN_OBSERVER_ID)) {
nsCOMPtr<nsIObserverService> observerService =
do_GetService("@mozilla.org/observer-service;1");
if (observerService) {
observerService->RemoveObserver(this, NS_XPCOM_SHUTDOWN_OBSERVER_ID);
}
nsCOMPtr<nsIWebProgress> progress(do_GetService(NS_DOCUMENTLOADER_SERVICE_CONTRACTID));
if (progress) {
- progress->RemoveProgressListener(NS_STATIC_CAST(nsIWebProgressListener*,this));
+ progress->RemoveProgressListener(static_cast<nsIWebProgressListener*>(this));
}
nsAccessNodeWrap::ShutdownAccessibility();
}
return NS_OK;
}
// nsIWebProgressListener
NS_IMETHODIMP nsAccessibilityService::OnStateChange(nsIWebProgress *aWebProgress,
@@ -274,17 +274,17 @@ NS_IMETHODIMP nsAccessibilityService::On
return NS_OK;
}
nsresult
nsAccessibilityService::GetInfo(nsISupports* aFrame, nsIFrame** aRealFrame, nsIWeakReference** aShell, nsIDOMNode** aNode)
{
NS_ASSERTION(aFrame,"Error -- 1st argument (aFrame) is null!!");
- *aRealFrame = NS_STATIC_CAST(nsIFrame*, aFrame);
+ *aRealFrame = static_cast<nsIFrame*>(aFrame);
nsCOMPtr<nsIContent> content = (*aRealFrame)->GetContent();
nsCOMPtr<nsIDOMNode> node(do_QueryInterface(content));
if (!content || !node)
return NS_ERROR_FAILURE;
*aNode = node;
NS_IF_ADDREF(*aNode);
nsCOMPtr<nsIDocument> document = content->GetDocument();
@@ -646,17 +646,17 @@ nsAccessibilityService::CreateHTMLListbo
*/
NS_IMETHODIMP
nsAccessibilityService::CreateHTMLObjectFrameAccessible(nsObjectFrame *aFrame,
nsIAccessible **aAccessible)
{
nsCOMPtr<nsIDOMNode> node;
nsCOMPtr<nsIWeakReference> weakShell;
nsIFrame *frame;
- GetInfo(NS_STATIC_CAST(nsIFrame*, aFrame), &frame, getter_AddRefs(weakShell), getter_AddRefs(node));
+ GetInfo(static_cast<nsIFrame*>(aFrame), &frame, getter_AddRefs(weakShell), getter_AddRefs(node));
*aAccessible = nsnull;
if (!frame || frame->GetRect().IsEmpty()) {
return NS_ERROR_FAILURE;
}
// 1) for object elements containing either HTML or TXT documents
nsCOMPtr<nsIDOMDocument> domDoc;
nsCOMPtr<nsIDOMHTMLObjectElement> obj(do_QueryInterface(node));
@@ -758,17 +758,17 @@ nsAccessibilityService::CreateHTMLTableH
rv = GetShellFromNode(aDOMNode, getter_AddRefs(weakShell));
NS_ENSURE_SUCCESS(rv, rv);
nsHTMLTableHeadAccessibleWrap* accTableHead =
new nsHTMLTableHeadAccessibleWrap(aDOMNode, weakShell);
NS_ENSURE_TRUE(accTableHead, NS_ERROR_OUT_OF_MEMORY);
- *_retval = NS_STATIC_CAST(nsIAccessible *, accTableHead);
+ *_retval = static_cast<nsIAccessible *>(accTableHead);
NS_IF_ADDREF(*_retval);
return rv;
#endif
}
NS_IMETHODIMP
nsAccessibilityService::CreateHTMLTableCellAccessible(nsISupports *aFrame, nsIAccessible **_retval)
@@ -917,17 +917,17 @@ NS_IMETHODIMP nsAccessibilityService::Ge
nsCOMPtr<nsIAccessibleDocument> accessibleDoc =
nsAccessNode::GetDocAccessibleFor(aWeakShell);
if (!accessibleDoc) {
*aAccessNode = nsnull;
return NS_ERROR_FAILURE;
}
- return accessibleDoc->GetCachedAccessNode(NS_STATIC_CAST(void*, aNode), aAccessNode);
+ return accessibleDoc->GetCachedAccessNode(static_cast<void*>(aNode), aAccessNode);
}
NS_IMETHODIMP
nsAccessibilityService::GetStringRole(PRUint32 aRole, nsAString& aString)
{
if ( aRole >= NS_ARRAY_LENGTH(kRoleNames)) {
aString.AssignLiteral("unknown");
return NS_OK;
@@ -1719,17 +1719,17 @@ nsresult nsAccessibilityService::GetAcce
}
NS_IMETHODIMP nsAccessibilityService::AddNativeRootAccessible(void * aAtkAccessible, nsIAccessible **aRootAccessible)
{
#ifdef MOZ_ACCESSIBILITY_ATK
nsNativeRootAccessibleWrap* rootAccWrap =
new nsNativeRootAccessibleWrap((AtkObject*)aAtkAccessible);
- *aRootAccessible = NS_STATIC_CAST(nsIAccessible*, rootAccWrap);
+ *aRootAccessible = static_cast<nsIAccessible*>(rootAccWrap);
NS_ADDREF(*aRootAccessible);
nsRefPtr<nsApplicationAccessibleWrap> appRoot =
nsAccessNode::GetApplicationAccessible();
NS_ENSURE_STATE(appRoot);
appRoot->AddRootAccessible(*aRootAccessible);
--- a/accessible/src/base/nsAccessible.cpp
+++ b/accessible/src/base/nsAccessible.cpp
@@ -187,23 +187,23 @@ PRBool nsAccessible::IsTextInterfaceSupp
nsresult nsAccessible::QueryInterface(REFNSIID aIID, void** aInstancePtr)
{
// Custom-built QueryInterface() knows when we support nsIAccessibleSelectable
// based on role attribute and waistate:multiselectable
*aInstancePtr = nsnull;
if (aIID.Equals(NS_GET_IID(nsIAccessible))) {
- *aInstancePtr = NS_STATIC_CAST(nsIAccessible*, this);
+ *aInstancePtr = static_cast<nsIAccessible*>(this);
NS_ADDREF_THIS();
return NS_OK;
}
if(aIID.Equals(NS_GET_IID(nsPIAccessible))) {
- *aInstancePtr = NS_STATIC_CAST(nsPIAccessible*, this);
+ *aInstancePtr = static_cast<nsPIAccessible*>(this);
NS_ADDREF_THIS();
return NS_OK;
}
if (aIID.Equals(NS_GET_IID(nsIAccessibleSelectable))) {
nsCOMPtr<nsIContent> content(do_QueryInterface(mDOMNode));
if (!content) {
return NS_ERROR_FAILURE; // This accessible has been shut down
@@ -215,34 +215,34 @@ nsresult nsAccessible::QueryInterface(RE
// If either attribute (role or multiselectable) change, then we'll
// destroy this accessible so that we can follow COM identity rules.
static nsIContent::AttrValuesArray strings[] =
{&nsAccessibilityAtoms::_empty, &nsAccessibilityAtoms::_false, nsnull};
if (content->FindAttrValueIn(kNameSpaceID_WAIProperties ,
nsAccessibilityAtoms::multiselectable,
strings, eCaseMatters) ==
nsIContent::ATTR_VALUE_NO_MATCH) {
- *aInstancePtr = NS_STATIC_CAST(nsIAccessibleSelectable*, this);
+ *aInstancePtr = static_cast<nsIAccessibleSelectable*>(this);
NS_ADDREF_THIS();
}
}
}
if (aIID.Equals(NS_GET_IID(nsIAccessibleValue))) {
if (mRoleMapEntry && mRoleMapEntry->valueRule != eNoValue) {
- *aInstancePtr = NS_STATIC_CAST(nsIAccessibleValue*, this);
+ *aInstancePtr = static_cast<nsIAccessibleValue*>(this);
NS_ADDREF_THIS();
}
}
if (aIID.Equals(NS_GET_IID(nsIAccessibleHyperLink))) {
nsCOMPtr<nsIAccessible> parent(GetParent());
nsCOMPtr<nsIAccessibleHyperText> hyperTextParent(do_QueryInterface(parent));
if (hyperTextParent) {
- *aInstancePtr = NS_STATIC_CAST(nsIAccessibleHyperLink*, this);
+ *aInstancePtr = static_cast<nsIAccessibleHyperLink*>(this);
NS_ADDREF_THIS();
return NS_OK;
}
return NS_ERROR_NO_INTERFACE;
}
return nsAccessNode::QueryInterface(aIID, aInstancePtr);
}
@@ -250,17 +250,17 @@ nsresult nsAccessible::QueryInterface(RE
nsAccessible::nsAccessible(nsIDOMNode* aNode, nsIWeakReference* aShell): nsAccessNodeWrap(aNode, aShell),
mParent(nsnull), mFirstChild(nsnull), mNextSibling(nsnull), mRoleMapEntry(nsnull),
mAccChildCount(eChildCountUninitialized)
{
#ifdef NS_DEBUG_X
{
nsCOMPtr<nsIPresShell> shell(do_QueryReferent(aShell));
printf(">>> %p Created Acc - DOM: %p PS: %p",
- (void*)NS_STATIC_CAST(nsIAccessible*, this), (void*)aNode,
+ (void*)static_cast<nsIAccessible*>(this), (void*)aNode,
(void*)shell.get());
nsCOMPtr<nsIContent> content = do_QueryInterface(aNode);
if (content) {
nsAutoString buf;
if (content->NodeInfo())
content->NodeInfo()->GetQualifiedName(buf);
printf(" Con: %s@%p", NS_ConvertUTF16toUTF8(buf).get(), (void *)content.get());
if (NS_SUCCEEDED(GetName(buf))) {
@@ -2805,17 +2805,17 @@ NS_IMETHODIMP nsAccessible::GetNativeInt
return NS_ERROR_NOT_IMPLEMENTED;
}
void nsAccessible::DoCommandCallback(nsITimer *aTimer, void *aClosure)
{
NS_ASSERTION(gDoCommandTimer, "How did we get here if there was no gDoCommandTimer?");
NS_RELEASE(gDoCommandTimer);
- nsIContent *content = NS_REINTERPRET_CAST(nsIContent*, aClosure);
+ nsIContent *content = reinterpret_cast<nsIContent*>(aClosure);
nsCOMPtr<nsIDOMXULElement> xulElement(do_QueryInterface(content));
if (xulElement) {
xulElement->Click();
}
else {
nsIDocument *doc = content->GetDocument();
if (!doc) {
return;
--- a/accessible/src/base/nsAccessible.h
+++ b/accessible/src/base/nsAccessible.h
@@ -63,17 +63,17 @@ struct nsRect;
class nsIContent;
class nsIFrame;
class nsIPresShell;
class nsIDOMNode;
class nsIAtom;
class nsIView;
// When mNextSibling is set to this, it indicates there ar eno more siblings
-#define DEAD_END_ACCESSIBLE NS_STATIC_CAST(nsIAccessible*, (void*)1)
+#define DEAD_END_ACCESSIBLE static_cast<nsIAccessible*>((void*)1)
// Saves a data member -- if child count equals this value we haven't
// cached children or child count yet
enum { eChildCountUninitialized = -1 };
class nsAccessibleDOMStringList : public nsIDOMDOMStringList
{
public:
--- a/accessible/src/base/nsApplicationAccessible.cpp
+++ b/accessible/src/base/nsApplicationAccessible.cpp
@@ -138,17 +138,17 @@ nsApplicationAccessible::GetChildAt(PRIn
PRUint32 count = 0;
nsresult rv = NS_OK;
if (mChildren) {
rv = mChildren->GetLength(&count);
NS_ENSURE_SUCCESS(rv, rv);
}
- if (aChildNum >= NS_STATIC_CAST(PRInt32, count) || count == 0)
+ if (aChildNum >= static_cast<PRInt32>(count) || count == 0)
return NS_ERROR_INVALID_ARG;
if (aChildNum < 0)
aChildNum = count - 1;
nsCOMPtr<nsIWeakReference> childWeakRef;
rv = mChildren->QueryElementAt(aChildNum, NS_GET_IID(nsIWeakReference),
getter_AddRefs(childWeakRef));
@@ -208,17 +208,17 @@ nsApplicationAccessible::CacheChildren()
previousAccessible = do_QueryInterface(accessible);
previousAccessible->SetParent(this);
}
}
PRUint32 count = 0;
mChildren->GetLength(&count);
- mAccChildCount = NS_STATIC_CAST(PRInt32, count);
+ mAccChildCount = static_cast<PRInt32>(count);
}
}
// nsApplicationAccessible
nsresult
nsApplicationAccessible::AddRootAccessible(nsIAccessible *aRootAccessible)
{
--- a/accessible/src/base/nsDocAccessible.cpp
+++ b/accessible/src/base/nsDocAccessible.cpp
@@ -511,17 +511,17 @@ NS_IMETHODIMP nsDocAccessible::Init()
return rv;
}
NS_IMETHODIMP nsDocAccessible::Destroy()
{
if (mWeakShell) {
- gGlobalDocAccessibleCache.Remove(NS_STATIC_CAST(void*, mWeakShell));
+ gGlobalDocAccessibleCache.Remove(static_cast<void*>(mWeakShell));
}
return Shutdown();
}
NS_IMETHODIMP nsDocAccessible::Shutdown()
{
if (!mWeakShell) {
return NS_OK; // Already shutdown
@@ -817,17 +817,17 @@ NS_IMETHODIMP nsDocAccessible::FireDocLo
}
nsAccUtils::FireAccEvent(aEventType, this);
return NS_OK;
}
void nsDocAccessible::ScrollTimerCallback(nsITimer *aTimer, void *aClosure)
{
- nsDocAccessible *docAcc = NS_REINTERPRET_CAST(nsDocAccessible*, aClosure);
+ nsDocAccessible *docAcc = reinterpret_cast<nsDocAccessible*>(aClosure);
if (docAcc && docAcc->mScrollPositionChangedTicks &&
++docAcc->mScrollPositionChangedTicks > 2) {
// Whenever scroll position changes, mScrollPositionChangeTicks gets reset to 1
// We only want to fire accessibilty scroll event when scrolling stops or pauses
// Therefore, we wait for no scroll events to occur between 2 ticks of this timer
// That indicates a pause in scrolling, so we fire the accessibilty scroll event
nsAccUtils::FireAccEvent(nsIAccessibleEvent::EVENT_SCROLLING_END, docAcc);
@@ -1230,17 +1230,17 @@ nsDocAccessible::FireDelayedAccessibleEv
}
}
mEventsToFire.AppendObject(aEvent);
if (!isTimerStarted) {
// This is be the first delayed event in queue, start timer
// so that event gets fired via FlushEventsCallback
mFireEventTimer->InitWithFuncCallback(FlushEventsCallback,
- NS_STATIC_CAST(nsPIAccessibleDocument*, this),
+ static_cast<nsPIAccessibleDocument*>(this),
0, nsITimer::TYPE_ONE_SHOT);
}
return NS_OK;
}
NS_IMETHODIMP nsDocAccessible::FlushPendingEvents()
{
@@ -1289,17 +1289,17 @@ NS_IMETHODIMP nsDocAccessible::FlushPend
}
}
mEventsToFire.Clear(); // Clear out array
return NS_OK;
}
void nsDocAccessible::FlushEventsCallback(nsITimer *aTimer, void *aClosure)
{
- nsPIAccessibleDocument *accessibleDoc = NS_STATIC_CAST(nsPIAccessibleDocument*, aClosure);
+ nsPIAccessibleDocument *accessibleDoc = static_cast<nsPIAccessibleDocument*>(aClosure);
NS_ASSERTION(accessibleDoc, "How did we get here without an accessible document?");
accessibleDoc->FlushPendingEvents();
}
void nsDocAccessible::RefreshNodes(nsIDOMNode *aStartNode, PRUint32 aChangeEvent)
{
NS_ASSERTION(aChangeEvent != nsIAccessibleEvent::EVENT_SHOW,
"nsDocAccessible::RefreshNodes isn't supposed to work with show event.");
@@ -1310,17 +1310,17 @@ void nsDocAccessible::RefreshNodes(nsIDO
do {
GetCachedAccessNode(iterNode, getter_AddRefs(accessNode));
if (accessNode) {
// Accessibles that implement their own subtrees,
// like html combo boxes and xul trees must shutdown all of their own
// children when they override Shutdown()
// Don't shutdown our doc object!
- if (accessNode != NS_STATIC_CAST(nsIAccessNode*, this)) {
+ if (accessNode != static_cast<nsIAccessNode*>(this)) {
nsCOMPtr<nsIAccessible> accessible(do_QueryInterface(accessNode));
if (accessible) {
// Fire menupopupend events for menu popups that go away
PRUint32 role = Role(accessible);
if (role == nsIAccessibleRole::ROLE_MENUPOPUP) {
nsCOMPtr<nsIDOMNode> domNode;
accessNode->GetDOMNode(getter_AddRefs(domNode));
@@ -1540,17 +1540,17 @@ void nsDocAccessible::DocLoadCallback(ns
{
// Doc has finished loading, fire "load finished" event
// By using short timer we can wait make the window visible,
// which it does asynchronously. This avoids confusing the screen reader with a
// hidden window. Waiting also allows us to see of the document has focus,
// which is important because we only fire doc loaded events for focused documents.
nsDocAccessible *docAcc =
- NS_REINTERPRET_CAST(nsDocAccessible*, aClosure);
+ reinterpret_cast<nsDocAccessible*>(aClosure);
if (!docAcc) {
return;
}
// Fire doc finished event
nsCOMPtr<nsIDOMNode> docDomNode;
docAcc->GetDOMNode(getter_AddRefs(docDomNode));
nsCOMPtr<nsIDocument> doc(do_QueryInterface(docDomNode));
--- a/accessible/src/base/nsRootAccessible.cpp
+++ b/accessible/src/base/nsRootAccessible.cpp
@@ -89,17 +89,17 @@
#include "nsApplicationAccessibleWrap.h"
#endif
// Expanded version of NS_IMPL_ISUPPORTS_INHERITED2
// so we can QI directly to concrete nsRootAccessible
NS_IMPL_QUERY_HEAD(nsRootAccessible)
NS_IMPL_QUERY_BODY(nsIDOMEventListener)
if (aIID.Equals(NS_GET_IID(nsRootAccessible)))
- foundInterface = NS_REINTERPRET_CAST(nsISupports*, this);
+ foundInterface = reinterpret_cast<nsISupports*>(this);
else
NS_IMPL_QUERY_TAIL_INHERITING(nsDocAccessible)
NS_IMPL_ADDREF_INHERITED(nsRootAccessible, nsDocAccessible)
NS_IMPL_RELEASE_INHERITED(nsRootAccessible, nsDocAccessible)
//-----------------------------------------------------
// construction
@@ -861,17 +861,17 @@ void nsRootAccessible::GetTargetNode(nsI
return;
}
NS_ADDREF(*aTargetNode = eventTarget);
}
void nsRootAccessible::FireFocusCallback(nsITimer *aTimer, void *aClosure)
{
- nsRootAccessible *rootAccessible = NS_STATIC_CAST(nsRootAccessible*, aClosure);
+ nsRootAccessible *rootAccessible = static_cast<nsRootAccessible*>(aClosure);
NS_ASSERTION(rootAccessible, "How did we get here without a root accessible?");
rootAccessible->FireCurrentFocusEvent();
}
NS_IMETHODIMP
nsRootAccessible::Init()
{
nsresult rv = nsDocAccessibleWrap::Init();
--- a/accessible/src/html/nsHTMLSelectAccessible.cpp
+++ b/accessible/src/html/nsHTMLSelectAccessible.cpp
@@ -127,17 +127,17 @@ void nsHTMLSelectableAccessible::iterato
mOption->GetSelected(&isSelected);
if (isSelected) {
nsCOMPtr<nsIDOMNode> optionNode(do_QueryInterface(mOption));
aAccService->GetAccessibleInWeakShell(optionNode, mWeakShell, getter_AddRefs(tempAccess));
}
}
if (tempAccess)
- aSelectedAccessibles->AppendElement(NS_STATIC_CAST(nsISupports*, tempAccess), PR_FALSE);
+ aSelectedAccessibles->AppendElement(static_cast<nsISupports*>(tempAccess), PR_FALSE);
}
PRBool nsHTMLSelectableAccessible::iterator::GetAccessibleIfSelected(PRInt32 aIndex,
nsIAccessibilityService *aAccService,
nsPresContext *aContext,
nsIAccessible **aAccessible)
{
PRBool isSelected = PR_FALSE;
@@ -560,17 +560,17 @@ nsHTMLSelectOptionAccessible::GetAttribu
nsCOMPtr<nsIDOMNode> itemNode;
while (NS_SUCCEEDED(siblings->Item(posInSet ++, getter_AddRefs(itemNode))) &&
itemNode != mDOMNode) {
// Keep looping, to increment posInSet
}
}
nsAccUtils::SetAccGroupAttrs(aAttributes, level, posInSet,
- NS_STATIC_CAST(PRInt32, setSize));
+ static_cast<PRInt32>(setSize));
return NS_OK;
}
nsIFrame* nsHTMLSelectOptionAccessible::GetBoundsFrame()
{
PRUint32 state;
nsCOMPtr<nsIContent> content = GetSelectState(&state);
if (state & nsIAccessibleStates::STATE_COLLAPSED) {
@@ -1165,17 +1165,17 @@ nsHTMLComboboxTextFieldAccessible::nsHTM
nsIWeakReference* aShell):
nsHTMLTextFieldAccessible(aDOMNode, aShell)
{
}
NS_IMETHODIMP nsHTMLComboboxTextFieldAccessible::GetUniqueID(void **aUniqueID)
{
// Since mDOMNode is same as for our parent, use |this| pointer as the unique Id
- *aUniqueID = NS_STATIC_CAST(void*, this);
+ *aUniqueID = static_cast<void*>(this);
return NS_OK;
}
/**
* Gets the bounds for the BlockFrame.
* Walks the Frame tree and checks for proper frames.
*/
void nsHTMLComboboxTextFieldAccessible::GetBoundsRect(nsRect& aBounds, nsIFrame** aBoundingFrame)
@@ -1285,17 +1285,17 @@ NS_IMETHODIMP nsHTMLComboboxButtonAccess
aName.AssignLiteral("open");
return NS_OK;
}
NS_IMETHODIMP nsHTMLComboboxButtonAccessible::GetUniqueID(void **aUniqueID)
{
// Since mDOMNode is same for all tree item, use |this| pointer as the unique Id
- *aUniqueID = NS_STATIC_CAST(void*, this);
+ *aUniqueID = static_cast<void*>(this);
return NS_OK;
}
/**
* Gets the bounds for the gfxButtonControlFrame.
* Walks the Frame tree and checks for proper frames.
*/
void nsHTMLComboboxButtonAccessible::GetBoundsRect(nsRect& aBounds, nsIFrame** aBoundingFrame)
@@ -1417,17 +1417,17 @@ NS_IMETHODIMP nsHTMLComboboxListAccessib
{
NS_IF_ADDREF(*aParent = mParent);
return NS_OK;
}
NS_IMETHODIMP nsHTMLComboboxListAccessible::GetUniqueID(void **aUniqueID)
{
// Since mDOMNode is same for all tree item, use |this| pointer as the unique Id
- *aUniqueID = NS_STATIC_CAST(void*, this);
+ *aUniqueID = static_cast<void*>(this);
return NS_OK;
}
/**
* Gets the bounds for the areaFrame.
* Walks the Frame tree and checks for proper frames.
*/
void nsHTMLComboboxListAccessible::GetBoundsRect(nsRect& aBounds, nsIFrame** aBoundingFrame)
--- a/accessible/src/html/nsHTMLTextAccessible.cpp
+++ b/accessible/src/html/nsHTMLTextAccessible.cpp
@@ -162,17 +162,17 @@ NS_IMETHODIMP
nsHTMLBRAccessible::GetState(PRUint32 *aState, PRUint32 *aExtraState)
{
*aState = nsIAccessibleStates::STATE_READONLY;
return NS_OK;
}
NS_IMETHODIMP nsHTMLBRAccessible::GetName(nsAString& aName)
{
- aName = NS_STATIC_CAST(PRUnichar, '\n'); // Newline char
+ aName = static_cast<PRUnichar>('\n'); // Newline char
return NS_OK;
}
nsHTMLLabelAccessible::nsHTMLLabelAccessible(nsIDOMNode* aDomNode, nsIWeakReference* aShell):
nsTextAccessible(aDomNode, aShell)
{
}
@@ -308,17 +308,17 @@ nsHTMLListBulletAccessible::
{
mBulletText += ' '; // Otherwise bullets are jammed up against list text
}
NS_IMETHODIMP
nsHTMLListBulletAccessible::GetUniqueID(void **aUniqueID)
{
// Since mDOMNode is same as for list item, use |this| pointer as the unique Id
- *aUniqueID = NS_STATIC_CAST(void*, this);
+ *aUniqueID = static_cast<void*>(this);
return NS_OK;
}
NS_IMETHODIMP
nsHTMLListBulletAccessible::Shutdown()
{
mBulletText.Truncate();
mWeakParent = nsnull;
--- a/accessible/src/html/nsHyperTextAccessible.cpp
+++ b/accessible/src/html/nsHyperTextAccessible.cpp
@@ -76,39 +76,39 @@ nsresult nsHyperTextAccessible::QueryInt
// in order for HTML document accessibles to get support for these interfaces
// However at some point we may push <body> to implement the interfaces and
// return nsDocAccessible to inherit from nsAccessibleWrap
if (aIID.Equals(NS_GET_IID(nsIAccessibleText))) {
// If |this| contains any children
PRInt32 numChildren;
GetChildCount(&numChildren);
if (numChildren > 0) {
- *aInstancePtr = NS_STATIC_CAST(nsIAccessibleText*, this);
+ *aInstancePtr = static_cast<nsIAccessibleText*>(this);
NS_ADDREF_THIS();
return NS_OK;
}
return NS_ERROR_NO_INTERFACE;
}
if (aIID.Equals(NS_GET_IID(nsIAccessibleHyperText))) {
if (IsHyperText()) {
// If |this| contains text and embedded objects
- *aInstancePtr = NS_STATIC_CAST(nsIAccessibleHyperText*, this);
+ *aInstancePtr = static_cast<nsIAccessibleHyperText*>(this);
NS_ADDREF_THIS();
return NS_OK;
}
return NS_ERROR_NO_INTERFACE;
}
if (aIID.Equals(NS_GET_IID(nsIAccessibleEditableText))) {
// If this contains editable text
PRUint32 state, extState;
GetState(&state, &extState);
if (extState & nsIAccessibleStates::EXT_STATE_EDITABLE) {
- *aInstancePtr = NS_STATIC_CAST(nsIAccessibleEditableText*, this);
+ *aInstancePtr = static_cast<nsIAccessibleEditableText*>(this);
NS_ADDREF_THIS();
return NS_OK;
}
return NS_ERROR_NO_INTERFACE;
}
}
return nsAccessible::QueryInterface(aIID, aInstancePtr);
--- a/accessible/src/mac/mozAccessible.mm
+++ b/accessible/src/mac/mozAccessible.mm
@@ -323,17 +323,17 @@ GetNativeFromGeckoAccessible(nsIAccessib
}
// GetUnignoredParent() returns null when there is no unignored accessible all the way up to
// the root accessible. so we'll have to return whatever native accessible is above our root accessible
// (which might be the owning NSWindow in the application, for example).
//
// get the native root accessible, and tell it to return its first parent unignored accessible.
nsRefPtr<nsRootAccessible> root(mGeckoAccessible->GetRootAccessible());
- id nativeParent = GetNativeFromGeckoAccessible(NS_STATIC_CAST(nsIAccessible*, root));
+ id nativeParent = GetNativeFromGeckoAccessible(static_cast<nsIAccessible*>(root));
NSAssert1 (nativeParent, @"!!! we can't find a parent for %@", self);
return GetClosestInterestingAccessible(nativeParent);
}
- (BOOL)hasRepresentedView
{
return NO;
@@ -505,17 +505,17 @@ GetNativeFromGeckoAccessible(nsIAccessib
#endif
NSAssert1(![self accessibilityIsIgnored], @"trying to set focus to ignored element! (%@)", self);
NSAccessibilityPostNotification(GetObjectOrRepresentedView(self),
NSAccessibilityFocusedUIElementChangedNotification);
}
- (NSWindow*)window
{
- nsAccessibleWrap *accWrap = NS_STATIC_CAST (nsAccessibleWrap*, mGeckoAccessible);
+ nsAccessibleWrap *accWrap = static_cast<nsAccessibleWrap*>(mGeckoAccessible);
NSWindow *nativeWindow = nil;
accWrap->GetNativeWindow ((void**)&nativeWindow);
NSAssert1(nativeWindow, @"Could not get native window for %@", self);
return nativeWindow;
}
- (void)invalidateChildren
--- a/accessible/src/mac/mozDocAccessible.mm
+++ b/accessible/src/mac/mozDocAccessible.mm
@@ -39,17 +39,17 @@
#include "nsRootAccessibleWrap.h"
#import "mozDocAccessible.h"
#import "mozView.h"
static id <mozAccessible, mozView> getNativeViewFromRootAccessible (nsAccessible *accessible)
{
- nsRootAccessibleWrap *root = NS_STATIC_CAST (nsRootAccessibleWrap*, accessible);
+ nsRootAccessibleWrap *root = static_cast<nsRootAccessibleWrap*>(accessible);
id <mozAccessible, mozView> nativeView = nil;
root->GetNativeWidget ((void**)&nativeView);
return nativeView;
}
#pragma mark -
@implementation mozRootAccessible
--- a/accessible/src/mac/nsAccessibleWrap.h
+++ b/accessible/src/mac/nsAccessibleWrap.h
@@ -112,20 +112,20 @@ class nsAccessibleWrap : public nsAccess
// we don't create a native object if we're child of a "flat" accessible; for example, on OS X buttons
// shouldn't have any children, because that makes the OS confused.
//
// to maintain a scripting environment where the XPCOM accessible hierarchy look the same
// on all platforms, we still let the C++ objects be created though.
nsCOMPtr<nsIAccessible> curParent = GetParent();
while (curParent) {
- nsAccessibleWrap *ancestorWrap = NS_STATIC_CAST(nsAccessibleWrap*, (nsIAccessible*)curParent.get());
+ nsAccessibleWrap *ancestorWrap = static_cast<nsAccessibleWrap*>((nsIAccessible*)curParent.get());
if (ancestorWrap->IsFlat())
return PR_TRUE;
- curParent = NS_STATIC_CAST(nsAccessibleWrap*, (nsIAccessible*)curParent.get())->GetParent();
+ curParent = static_cast<nsAccessibleWrap*>((nsIAccessible*)curParent.get())->GetParent();
}
// no parent was flat
return PR_FALSE;
}
// Wrapper around our native object.
AccessibleWrapper *mNativeWrapper;
};
--- a/accessible/src/mac/nsAccessibleWrap.mm
+++ b/accessible/src/mac/nsAccessibleWrap.mm
@@ -209,17 +209,17 @@ nsAccessibleWrap::GetUnignoredChildCount
return 0;
PRInt32 childCount = 0;
GetChildCount(&childCount);
nsCOMPtr<nsIAccessible> curAcc;
while (NextChild(curAcc)) {
- nsAccessibleWrap *childWrap = NS_STATIC_CAST(nsAccessibleWrap*, (nsIAccessible*)curAcc.get());
+ nsAccessibleWrap *childWrap = static_cast<nsAccessibleWrap*>((nsIAccessible*)curAcc.get());
// if the current child is not ignored, count it.
if (!childWrap->IsIgnored())
++childCount;
// if it's flat, we don't care to inspect its children.
if (childWrap->IsFlat())
continue;
@@ -251,17 +251,17 @@ nsAccessibleWrap::GetUnignoredChildren(n
{
nsCOMPtr<nsIAccessible> curAcc;
// we're flat; there are no children.
if (IsFlat())
return;
while (NextChild(curAcc)) {
- nsAccessibleWrap *childWrap = NS_STATIC_CAST(nsAccessibleWrap*, (nsIAccessible*)curAcc.get());
+ nsAccessibleWrap *childWrap = static_cast<nsAccessibleWrap*>((nsIAccessible*)curAcc.get());
if (childWrap->IsIgnored()) {
// element is ignored, so try adding its children as substitutes, if it has any.
if (!childWrap->IsFlat()) {
nsTArray<nsRefPtr<nsAccessibleWrap> > children;
childWrap->GetUnignoredChildren(children);
if (!children.IsEmpty()) {
// add the found unignored descendants to the array.
aChildrenArray.AppendElements(children);
@@ -272,17 +272,17 @@ nsAccessibleWrap::GetUnignoredChildren(n
aChildrenArray.AppendElement(childWrap);
}
}
already_AddRefed<nsIAccessible>
nsAccessibleWrap::GetUnignoredParent()
{
nsCOMPtr<nsIAccessible> parent(GetParent());
- nsAccessibleWrap *parentWrap = NS_STATIC_CAST(nsAccessibleWrap*, (nsIAccessible*)parent.get());
+ nsAccessibleWrap *parentWrap = static_cast<nsAccessibleWrap*>((nsIAccessible*)parent.get());
if (!parentWrap)
return nsnull;
// recursively return the parent, until we find one that is not ignored.
if (parentWrap->IsIgnored())
return parentWrap->GetUnignoredParent();
nsIAccessible *outValue = nsnull;
--- a/accessible/src/msaa/CAccessibleAction.cpp
+++ b/accessible/src/msaa/CAccessibleAction.cpp
@@ -51,18 +51,18 @@
// IUnknown
STDMETHODIMP
CAccessibleAction::QueryInterface(REFIID iid, void** ppv)
{
*ppv = NULL;
if (IID_IAccessibleAction == iid) {
- *ppv = NS_STATIC_CAST(IAccessibleAction*, this);
- (NS_REINTERPRET_CAST(IUnknown*, *ppv))->AddRef();
+ *ppv = static_cast<IAccessibleAction*>(this);
+ (reinterpret_cast<IUnknown*>(*ppv))->AddRef();
return S_OK;
}
return E_NOINTERFACE;
}
// IAccessibleAction
@@ -84,33 +84,33 @@ CAccessibleAction::nActions(long *aNumAc
STDMETHODIMP
CAccessibleAction::doAction(long aActionIndex)
{
nsCOMPtr<nsIAccessible> acc(do_QueryInterface(this));
if (!acc)
return E_FAIL;
- PRUint8 index = NS_STATIC_CAST(PRUint8, aActionIndex);
+ PRUint8 index = static_cast<PRUint8>(aActionIndex);
if (NS_SUCCEEDED(acc->DoAction(index)))
return S_OK;
return E_FAIL;
}
STDMETHODIMP
CAccessibleAction::get_description(long aActionIndex, BSTR *aDescription)
{
*aDescription = NULL;
nsCOMPtr<nsIAccessible> acc(do_QueryInterface(this));
if (!acc)
return E_FAIL;
nsAutoString description;
- PRUint8 index = NS_STATIC_CAST(PRUint8, aActionIndex);
+ PRUint8 index = static_cast<PRUint8>(aActionIndex);
if (NS_FAILED(acc->GetActionDescription(index, description)))
return E_FAIL;
if (!description.IsVoid()) {
return ::SysReAllocStringLen(aDescription, description.get(),
description.Length());
}
@@ -125,27 +125,27 @@ CAccessibleAction::get_keyBinding(long a
*aKeyBinding = NULL;
aNumBinding = 0;
nsCOMPtr<nsIAccessible> acc(do_QueryInterface(this));
if (!acc)
return E_FAIL;
nsCOMPtr<nsIDOMDOMStringList> keys;
- PRUint8 index = NS_STATIC_CAST(PRUint8, aActionIndex);
+ PRUint8 index = static_cast<PRUint8>(aActionIndex);
nsresult rv = acc->GetKeyBindings(index, getter_AddRefs(keys));
if (NS_FAILED(rv))
return E_FAIL;
PRUint32 length = 0;
keys->GetLength(&length);
- PRBool aUseNumMaxBinding = length > NS_STATIC_CAST(PRUint32, aNumMaxBinding);
+ PRBool aUseNumMaxBinding = length > static_cast<PRUint32>(aNumMaxBinding);
- PRUint32 maxBinding = NS_STATIC_CAST(PRUint32, aNumMaxBinding);
+ PRUint32 maxBinding = static_cast<PRUint32>(aNumMaxBinding);
PRUint32 numBinding = length > maxBinding ? maxBinding : length;
*aNumBinding = numBinding;
*aKeyBinding = new BSTR[numBinding];
if (!*aKeyBinding)
return E_OUTOFMEMORY;
@@ -166,17 +166,17 @@ CAccessibleAction::get_name(long aAction
{
*aName = NULL;
nsCOMPtr<nsIAccessible> acc(do_QueryInterface(this));
if (!acc)
return E_FAIL;
nsAutoString name;
- PRUint8 index = NS_STATIC_CAST(PRUint8, aActionIndex);
+ PRUint8 index = static_cast<PRUint8>(aActionIndex);
if (NS_FAILED(acc->GetActionName(index, name)))
return E_FAIL;
if (!name.IsVoid())
return ::SysReAllocStringLen(aName, name.get(), name.Length());
return S_OK;
}
--- a/accessible/src/msaa/CAccessibleComponent.cpp
+++ b/accessible/src/msaa/CAccessibleComponent.cpp
@@ -62,18 +62,18 @@ enum {
// IUnknown
STDMETHODIMP
CAccessibleComponent::QueryInterface(REFIID iid, void** ppv)
{
*ppv = NULL;
if (IID_IAccessibleComponent == iid) {
- *ppv = NS_STATIC_CAST(IAccessibleComponent*, this);
- (NS_REINTERPRET_CAST(IUnknown*, *ppv))->AddRef();
+ *ppv = static_cast<IAccessibleComponent*>(this);
+ (reinterpret_cast<IUnknown*>(*ppv))->AddRef();
return S_OK;
}
return E_NOINTERFACE;
}
// IAccessibleComponent
--- a/accessible/src/msaa/CAccessibleEditableText.cpp
+++ b/accessible/src/msaa/CAccessibleEditableText.cpp
@@ -59,18 +59,18 @@ STDMETHODIMP
CAccessibleEditableText::QueryInterface(REFIID iid, void** ppv)
{
*ppv = NULL;
if (IID_IAccessibleEditableText == iid) {
nsCOMPtr<nsIAccessibleEditableText> editTextAcc(do_QueryInterface(this));
if (!editTextAcc)
return E_NOINTERFACE;
- *ppv = NS_STATIC_CAST(IAccessibleEditableText*, this);
- (NS_REINTERPRET_CAST(IUnknown*, *ppv))->AddRef();
+ *ppv = static_cast<IAccessibleEditableText*>(this);
+ (reinterpret_cast<IUnknown*>(*ppv))->AddRef();
return S_OK;
}
return E_NOINTERFACE;
}
// IAccessibleEditableText
--- a/accessible/src/msaa/CAccessibleHyperlink.cpp
+++ b/accessible/src/msaa/CAccessibleHyperlink.cpp
@@ -60,18 +60,18 @@ CAccessibleHyperlink::QueryInterface(REF
{
*ppv = NULL;
if (IID_IAccessibleHyperlink == iid) {
nsCOMPtr<nsIAccessibleHyperLink> acc(do_QueryInterface(this));
if (!acc)
return E_NOINTERFACE;
- *ppv = NS_STATIC_CAST(IAccessibleHyperlink*, this);
- (NS_REINTERPRET_CAST(IUnknown*, *ppv))->AddRef();
+ *ppv = static_cast<IAccessibleHyperlink*>(this);
+ (reinterpret_cast<IUnknown*>(*ppv))->AddRef();
return S_OK;
}
return CAccessibleAction::QueryInterface(iid, ppv);
}
// IAccessibleHyperlink
@@ -94,17 +94,17 @@ CAccessibleHyperlink::get_anchor(long aI
return E_FAIL;
void *instancePtr = NULL;
nsresult rv = winAccessNode->QueryNativeInterface(IID_IUnknown,
&instancePtr);
if (NS_FAILED(rv))
return E_FAIL;
- IUnknown *unknownPtr = NS_STATIC_CAST(IUnknown*, instancePtr);
+ IUnknown *unknownPtr = static_cast<IUnknown*>(instancePtr);
aAnchor->ppunkVal = &unknownPtr;
aAnchor->vt = VT_UNKNOWN;
return S_OK;
}
STDMETHODIMP
CAccessibleHyperlink::get_anchorTarget(long aIndex, VARIANT *aAnchorTarget)
--- a/accessible/src/msaa/CAccessibleHypertext.cpp
+++ b/accessible/src/msaa/CAccessibleHypertext.cpp
@@ -54,18 +54,18 @@ CAccessibleHypertext::QueryInterface(REF
{
*ppv = NULL;
if (IID_IAccessibleHypertext == iid) {
nsCOMPtr<nsIAccessibleHyperText> hyperAcc(do_QueryInterface(this));
if (!hyperAcc)
return E_NOINTERFACE;
- *ppv = NS_STATIC_CAST(IAccessibleHypertext*, this);
- (NS_REINTERPRET_CAST(IUnknown*, *ppv))->AddRef();
+ *ppv = static_cast<IAccessibleHypertext*>(this);
+ (reinterpret_cast<IUnknown*>(*ppv))->AddRef();
return S_OK;
}
return CAccessibleText::QueryInterface(iid, ppv);
}
// IAccessibleHypertext
@@ -102,17 +102,17 @@ CAccessibleHypertext::get_hyperlink(long
nsCOMPtr<nsIWinAccessNode> winAccessNode(do_QueryInterface(hyperLink));
if (!winAccessNode)
return E_FAIL;
void *instancePtr = NULL;
nsresult rv = winAccessNode->QueryNativeInterface(IID_IAccessibleHyperlink,
&instancePtr);
- *aHyperlink = NS_STATIC_CAST(IAccessibleHyperlink*, instancePtr);
+ *aHyperlink = static_cast<IAccessibleHyperlink*>(instancePtr);
return NS_FAILED(rv) ? E_FAIL : S_OK;
}
STDMETHODIMP
CAccessibleHypertext::get_hyperlinkIndex(long aCharIndex, long *aHyperlinkIndex)
{
*aHyperlinkIndex = 0;
--- a/accessible/src/msaa/CAccessibleImage.cpp
+++ b/accessible/src/msaa/CAccessibleImage.cpp
@@ -55,18 +55,18 @@ CAccessibleImage::QueryInterface(REFIID
{
*ppv = NULL;
if (IID_IAccessibleImage == iid) {
nsCOMPtr<nsIAccessibleImage> imageAcc(do_QueryInterface(this));
if (!imageAcc)
return E_FAIL;
- *ppv = NS_STATIC_CAST(IAccessibleImage*, this);
- (NS_REINTERPRET_CAST(IUnknown*, *ppv))->AddRef();
+ *ppv = static_cast<IAccessibleImage*>(this);
+ (reinterpret_cast<IUnknown*>(*ppv))->AddRef();
return S_OK;
}
return E_NOINTERFACE;
}
// IAccessibleImage
--- a/accessible/src/msaa/CAccessibleTable.cpp
+++ b/accessible/src/msaa/CAccessibleTable.cpp
@@ -56,18 +56,18 @@
// IUnknown
STDMETHODIMP
CAccessibleTable::QueryInterface(REFIID iid, void** ppv)
{
*ppv = NULL;
if (IID_IAccessibleTable == iid) {
- *ppv = NS_STATIC_CAST(IAccessibleTable*, this);
- (NS_REINTERPRET_CAST(IUnknown*, *ppv))->AddRef();
+ *ppv = static_cast<IAccessibleTable*>(this);
+ (reinterpret_cast<IUnknown*>(*ppv))->AddRef();
return S_OK;
}
return E_NOINTERFACE;
}
// IAccessibleTable
@@ -90,17 +90,17 @@ CAccessibleTable::get_accessibleAt(long
return E_FAIL;
void *instancePtr = NULL;
nsresult rv = winAccessNode->QueryNativeInterface(IID_IAccessible2,
&instancePtr);
if (NS_FAILED(rv))
return E_FAIL;
- *aAccessible = NS_STATIC_CAST(IUnknown*, instancePtr);
+ *aAccessible = static_cast<IUnknown*>(instancePtr);
return S_OK;
}
STDMETHODIMP
CAccessibleTable::get_caption(IUnknown **aAccessible)
{
*aAccessible = NULL;
@@ -117,17 +117,17 @@ CAccessibleTable::get_caption(IUnknown *
return E_FAIL;
void *instancePtr = NULL;
nsresult rv = winAccessNode->QueryNativeInterface(IID_IAccessible2,
&instancePtr);
if (NS_FAILED(rv))
return E_FAIL;
- *aAccessible = NS_STATIC_CAST(IUnknown*, instancePtr);
+ *aAccessible = static_cast<IUnknown*>(instancePtr);
return S_OK;
}
STDMETHODIMP
CAccessibleTable::get_childIndex(long aRowIndex, long aColumnIndex,
long *aChildIndex)
{
*aChildIndex = 0;
@@ -203,17 +203,17 @@ CAccessibleTable::get_columnHeader(IAcce
if (!winAccessNode)
return E_FAIL;
void *instancePtr = NULL;
rv = winAccessNode->QueryNativeInterface(IID_IAccessibleTable, &instancePtr);
if (NS_FAILED(rv))
return E_FAIL;
- *aAccessibleTable = NS_STATIC_CAST(IAccessibleTable*, instancePtr);
+ *aAccessibleTable = static_cast<IAccessibleTable*>(instancePtr);
return S_OK;
}
STDMETHODIMP
CAccessibleTable::get_columnIndex(long aChildIndex, long *aColumnIndex)
{
*aColumnIndex = 0;
@@ -343,17 +343,17 @@ CAccessibleTable::get_rowHeader(IAccessi
return E_FAIL;
void *instancePtr = NULL;
rv = winAccessNode->QueryNativeInterface(IID_IAccessibleTable,
&instancePtr);
if (NS_FAILED(rv))
return E_FAIL;
- *aAccessibleTable = NS_STATIC_CAST(IAccessibleTable*, instancePtr);
+ *aAccessibleTable = static_cast<IAccessibleTable*>(instancePtr);
return S_OK;
}
