~ubuntu-branches/ubuntu/precise/kompozer/precise

/* void onProgressChange (in nsIWebProgress aWebProgress, in nsIRequest aRequest, in long aCurSelfProgress, in long aMaxSelfProgress, in long aCurTotalProgress, in long aMaxTotalProgress); */

182

NS_IMETHODIMP nsAccessibilityService::OnProgressChange(nsIWebProgress *aWebProgress,

183

nsIRequest *aRequest, PRInt32 aCurSelfProgress, PRInt32 aMaxSelfProgress,

184

PRInt32 aCurTotalProgress, PRInt32 aMaxTotalProgress)

185

{

186

NS_NOTREACHED("notification excluded in AddProgressListener(...)");

187

return NS_OK;

188

}

189

190

/* void onLocationChange (in nsIWebProgress aWebProgress, in nsIRequest aRequest, in nsIURI location); */

191

NS_IMETHODIMP nsAccessibilityService::OnLocationChange(nsIWebProgress *aWebProgress,

192

nsIRequest *aRequest, nsIURI *location)

193

{

194

NS_NOTREACHED("notification excluded in AddProgressListener(...)");

195

return NS_OK;

196

}

197

198

/* void onStatusChange (in nsIWebProgress aWebProgress, in nsIRequest aRequest, in nsresult aStatus, in wstring aMessage); */

199

NS_IMETHODIMP nsAccessibilityService::OnStatusChange(nsIWebProgress *aWebProgress,

200

nsIRequest *aRequest, nsresult aStatus, const PRUnichar *aMessage)

201

{

202

NS_NOTREACHED("notification excluded in AddProgressListener(...)");

203

return NS_OK;

204

}

205

206

/* void onSecurityChange (in nsIWebProgress aWebProgress, in nsIRequest aRequest, in unsigned long state); */

207

NS_IMETHODIMP nsAccessibilityService::OnSecurityChange(nsIWebProgress *aWebProgress,

208

nsIRequest *aRequest, PRUint32 state)

209

{

210

NS_NOTREACHED("notification excluded in AddProgressListener(...)");

211

return NS_OK;

212

}

213

214

215

nsresult

216

nsAccessibilityService::GetInfo(nsISupports* aFrame, nsIFrame** aRealFrame, nsIWeakReference** aShell, nsIDOMNode** aNode)

217

{

218

NS_ASSERTION(aFrame,"Error -- 1st argument (aFrame) is null!!");

219

*aRealFrame = NS_STATIC_CAST(nsIFrame*, aFrame);

220

nsCOMPtr<nsIContent> content = (*aRealFrame)->GetContent();

221

nsCOMPtr<nsIDOMNode> node(do_QueryInterface(content));

222

if (!content || !node)

223

return NS_ERROR_FAILURE;

224

*aNode = node;

225

NS_IF_ADDREF(*aNode);

226

227

nsCOMPtr<nsIDocument> document = content->GetDocument();

228

if (!document)

229

return NS_ERROR_FAILURE;

230

231

#ifdef DEBUG

232

PRInt32 shells = document->GetNumberOfShells();

233

NS_ASSERTION(shells > 0,"Error no shells!");

234

#endif

235

236

// do_GetWR only works into a |nsCOMPtr| :-(

237

nsCOMPtr<nsIWeakReference> weakShell =

238

do_GetWeakReference(document->GetShellAt(0));

239

NS_IF_ADDREF(*aShell = weakShell);

240

241

return NS_OK;

242

}

243

244

nsresult

245

nsAccessibilityService::GetShellFromNode(nsIDOMNode *aNode, nsIWeakReference **aWeakShell)

246

{

247

nsCOMPtr<nsIDOMDocument> domDoc;

248

aNode->GetOwnerDocument(getter_AddRefs(domDoc));

249

nsCOMPtr<nsIDocument> doc(do_QueryInterface(domDoc));

250

if (!doc)

251

return NS_ERROR_INVALID_ARG;

252

253

// ---- Get the pres shell ----

254

nsIPresShell *shell = doc->GetShellAt(0);

255

if (!shell)

256

return NS_ERROR_FAILURE;

257

258

nsCOMPtr<nsIWeakReference> weakRef(do_GetWeakReference(shell));

259

260

*aWeakShell = weakRef;

261

NS_IF_ADDREF(*aWeakShell);

262

263

return NS_OK;

264

}

265

266

/**

267

* nsIAccessibilityService methods:

268

269

270

NS_IMETHODIMP

271

nsAccessibilityService::CreateOuterDocAccessible(nsIDOMNode* aDOMNode,

272

nsIAccessible **aOuterDocAccessible)

273

{

274

NS_ENSURE_ARG_POINTER(aDOMNode);

275

276

*aOuterDocAccessible = nsnull;

277

278

nsCOMPtr<nsIWeakReference> outerWeakShell;

279

GetShellFromNode(aDOMNode, getter_AddRefs(outerWeakShell));

280

NS_ENSURE_TRUE(outerWeakShell, NS_ERROR_FAILURE);

281

282

nsOuterDocAccessible *outerDocAccessible =

283

new nsOuterDocAccessible(aDOMNode, outerWeakShell);

284

NS_ENSURE_TRUE(outerDocAccessible, NS_ERROR_FAILURE);

285

286

NS_ADDREF(*aOuterDocAccessible = outerDocAccessible);

287

288

return NS_OK;

289

}

290

291

NS_IMETHODIMP

292

nsAccessibilityService::CreateRootAccessible(nsIPresShell *aShell,

293

nsIDocument* aDocument,

294

nsIAccessible **aRootAcc)

295

{

296

*aRootAcc = nsnull;

297

298

nsCOMPtr<nsIDOMNode> rootNode(do_QueryInterface(aDocument));

299

NS_ENSURE_TRUE(rootNode, NS_ERROR_FAILURE);

300

301

nsIDocument *parentDoc = aDocument->GetParentDocument();

302

303

nsIPresShell *presShell = aShell;

304

if (!presShell) {

305

presShell = aDocument->GetShellAt(0);

306

}

307

nsCOMPtr<nsIWeakReference> weakShell(do_GetWeakReference(presShell));

308

309

if (parentDoc) {

310

// We only create root accessibles for the true root, othewise create a

311

// doc accessible

312

*aRootAcc = new nsDocAccessibleWrap(rootNode, weakShell);

313

}

314

else {

315

*aRootAcc = new nsRootAccessibleWrap(rootNode, weakShell);

316

}

317

if (!*aRootAcc)

318

return NS_ERROR_OUT_OF_MEMORY;

319

320

nsCOMPtr<nsPIAccessNode> privateAccessNode(do_QueryInterface(*aRootAcc));

321

privateAccessNode->Init();

322

323

NS_ADDREF(*aRootAcc);

324

325

return NS_OK;

326

}

327

328

/**

329

* HTML widget creation

330

331

NS_IMETHODIMP

332

nsAccessibilityService::CreateHTML4ButtonAccessible(nsISupports *aFrame, nsIAccessible **_retval)

333

{

334

nsIFrame* frame;

335

nsCOMPtr<nsIDOMNode> node;

336

nsCOMPtr<nsIWeakReference> weakShell;

337

nsresult rv = GetInfo(aFrame, &frame, getter_AddRefs(weakShell), getter_AddRefs(node));

338

if (NS_FAILED(rv))

339

return rv;

340

341

*_retval = new nsHTML4ButtonAccessible(node, weakShell);

342

if (! *_retval)

343

return NS_ERROR_OUT_OF_MEMORY;

344

345

NS_ADDREF(*_retval);

346

return NS_OK;

347

}

348

349

NS_IMETHODIMP

350

nsAccessibilityService::CreateHTMLAreaAccessible(nsIWeakReference *aShell, nsIDOMNode *aDOMNode, nsIAccessible *aParent,

351

nsIAccessible **_retval)

352

{

353

*_retval = new nsHTMLAreaAccessible(aDOMNode, aParent, aShell);

354

355

if (! *_retval)

356

return NS_ERROR_OUT_OF_MEMORY;

357

358

NS_ADDREF(*_retval);

359

return NS_OK;

360

}

361

362

NS_IMETHODIMP

363

nsAccessibilityService::CreateHTMLBlockAccessible(nsISupports *aFrame, nsIAccessible **_retval)

364

{

365

#ifndef MOZ_ACCESSIBILITY_ATK

366

*_retval = nsnull;

367

return NS_ERROR_FAILURE;

368

#else

369

nsIFrame* frame;

370

nsCOMPtr<nsIDOMNode> node;

371

nsCOMPtr<nsIWeakReference> weakShell;

372

nsresult rv = GetInfo(aFrame, &frame, getter_AddRefs(weakShell), getter_AddRefs(node));

373

if (NS_FAILED(rv))

374

return rv;

375

376

*_retval = new nsHTMLBlockAccessible(node, weakShell);

377

if (! *_retval)

378

return NS_ERROR_OUT_OF_MEMORY;

379

380

NS_ADDREF(*_retval);

381

return NS_OK;

382

#endif

383

}

384

385

NS_IMETHODIMP

386

nsAccessibilityService::CreateHTMLButtonAccessible(nsISupports *aFrame, nsIAccessible **_retval)

387

{

388

nsIFrame* frame;

389

nsCOMPtr<nsIDOMNode> node;

390

nsCOMPtr<nsIWeakReference> weakShell;

391

nsresult rv = GetInfo(aFrame, &frame, getter_AddRefs(weakShell), getter_AddRefs(node));

392

if (NS_FAILED(rv))

393

return rv;

394

395

*_retval = new nsHTMLButtonAccessible(node, weakShell);

396

if (! *_retval)

397

return NS_ERROR_OUT_OF_MEMORY;

398

399

NS_ADDREF(*_retval);

400

return NS_OK;

401

}

402

403

NS_IMETHODIMP

404

nsAccessibilityService::CreateHTMLButtonAccessibleXBL(nsIDOMNode *aNode, nsIAccessible **_retval)

405

{

406

#ifdef MOZ_XUL

407

nsCOMPtr<nsIWeakReference> weakShell;

408

GetShellFromNode(aNode, getter_AddRefs(weakShell));

409

410

// reusing the HTML accessible widget and enhancing for XUL

411

*_retval = new nsHTML4ButtonAccessible(aNode, weakShell);

412

if (! *_retval)

413

return NS_ERROR_OUT_OF_MEMORY;

414

415

NS_ADDREF(*_retval);

416

#else

417

*_retval = nsnull;

418

#endif // MOZ_XUL

419

return NS_OK;

420

}

421

422

NS_IMETHODIMP

423

nsAccessibilityService::CreateHTMLCheckboxAccessible(nsISupports *aFrame, nsIAccessible **_retval)

424

{

425

nsIFrame* frame;

426

nsCOMPtr<nsIDOMNode> node;

427

nsCOMPtr<nsIWeakReference> weakShell;

428

nsresult rv = GetInfo(aFrame, &frame, getter_AddRefs(weakShell), getter_AddRefs(node));

429

if (NS_FAILED(rv))

430

return rv;

431

432

*_retval = new nsHTMLCheckboxAccessible(node, weakShell);

433

if (! *_retval)

434

return NS_ERROR_OUT_OF_MEMORY;

435

436

NS_ADDREF(*_retval);

437

return NS_OK;

438

}

439

440

NS_IMETHODIMP

441

nsAccessibilityService::CreateHTMLCheckboxAccessibleXBL(nsIDOMNode *aNode, nsIAccessible **_retval)

442

{

443

#ifdef MOZ_XUL

444

nsCOMPtr<nsIWeakReference> weakShell;

445

GetShellFromNode(aNode, getter_AddRefs(weakShell));

446

447

// reusing the HTML accessible widget and enhancing for XUL

448

*_retval = new nsHTMLCheckboxAccessible(aNode, weakShell);

449

if (! *_retval)

450

return NS_ERROR_OUT_OF_MEMORY;

451

452

NS_ADDREF(*_retval);

453

#else

454

*_retval = nsnull;

455

#endif // MOZ_XUL

456

return NS_OK;

457

}

458

459

NS_IMETHODIMP

460

nsAccessibilityService::CreateHTMLComboboxAccessible(nsIDOMNode* aDOMNode, nsISupports* aPresContext, nsIAccessible **_retval)

461

{

462

nsCOMPtr<nsIPresContext> presContext(do_QueryInterface(aPresContext));

463

NS_ASSERTION(presContext,"Error non prescontext passed to accessible factory!!!");

464

465

nsCOMPtr<nsIWeakReference> weakShell =

466

do_GetWeakReference(presContext->PresShell());

467

468

*_retval = new nsHTMLComboboxAccessible(aDOMNode, weakShell);

469

if (! *_retval)

470

return NS_ERROR_OUT_OF_MEMORY;

471

472

NS_ADDREF(*_retval);

473

return NS_OK;

474

}

475

476

NS_IMETHODIMP

477

nsAccessibilityService::CreateHTMLImageAccessible(nsISupports *aFrame, nsIAccessible **_retval)

478

{

479

nsIFrame* frame;

480

nsCOMPtr<nsIDOMNode> node;

481

nsCOMPtr<nsIWeakReference> weakShell;

482

nsresult rv = GetInfo(aFrame, &frame, getter_AddRefs(weakShell), getter_AddRefs(node));

483

if (NS_FAILED(rv))

484

return rv;

485

486

*_retval = nsnull;

487

nsCOMPtr<nsIDOMElement> domElement(do_QueryInterface(node));

488

if (domElement) {

489

#ifdef MOZ_ACCESSIBILITY_ATK

490

PRBool hasAttribute;

491

rv = domElement->HasAttribute(NS_LITERAL_STRING("usemap"), &hasAttribute);

492

if (NS_SUCCEEDED(rv) && hasAttribute) {

493

//There is a "use map"

494

*_retval = new nsHTMLImageMapAccessible(node, weakShell);

495

}

496

else

497

#endif //MOZ_ACCESSIBILITY_ATK

498

*_retval = new nsHTMLImageAccessible(node, weakShell);

499

}

500

501

if (! *_retval)

502

return NS_ERROR_OUT_OF_MEMORY;

503

504

NS_ADDREF(*_retval);

505

return NS_OK;

506

}

507

508

NS_IMETHODIMP

509

nsAccessibilityService::CreateHTMLGroupboxAccessible(nsISupports *aFrame, nsIAccessible **_retval)

510

{

511

nsIFrame* frame;

512

nsCOMPtr<nsIDOMNode> node;

513

nsCOMPtr<nsIWeakReference> weakShell;

514

nsresult rv = GetInfo(aFrame, &frame, getter_AddRefs(weakShell), getter_AddRefs(node));

515

if (NS_FAILED(rv))

516

return rv;

517

518

*_retval = new nsHTMLGroupboxAccessible(node, weakShell);

519

if (! *_retval)

520

return NS_ERROR_OUT_OF_MEMORY;

521

522

NS_ADDREF(*_retval);

523

return NS_OK;

524

}

525

526

NS_IMETHODIMP

527

nsAccessibilityService::CreateHTMLListboxAccessible(nsIDOMNode* aDOMNode, nsISupports* aPresContext, nsIAccessible **_retval)

528

{

529

nsCOMPtr<nsIPresContext> presContext(do_QueryInterface(aPresContext));

530

NS_ASSERTION(presContext,"Error non prescontext passed to accessible factory!!!");

531

532

nsCOMPtr<nsIWeakReference> weakShell =

533

do_GetWeakReference(presContext->PresShell());

534

535

*_retval = new nsHTMLSelectListAccessible(aDOMNode, weakShell);

536

if (! *_retval)

537

return NS_ERROR_OUT_OF_MEMORY;

538

539

NS_ADDREF(*_retval);

540

return NS_OK;

541

}

542

543

/**

544

* We can have several cases here.

545

* 1) a text or html embedded document where the contentDocument

546

* variable in the object element holds the content

547

* 2) web content that uses a plugin, which means we will

548

* have to go to the plugin to get the accessible content

549

* 3) An image or imagemap, where the image frame points back to

550

* the object element DOMNode

551

552

NS_IMETHODIMP

553

nsAccessibilityService::CreateHTMLObjectFrameAccessible(nsObjectFrame *aFrame,

554

nsIAccessible **aAccessible)

555

{

556

nsCOMPtr<nsIDOMNode> node;

557

nsCOMPtr<nsIWeakReference> weakShell;

558

nsIFrame *frame;

559

GetInfo(NS_STATIC_CAST(nsIFrame*, aFrame), &frame, getter_AddRefs(weakShell), getter_AddRefs(node));

560

561

// 1) for object elements containing either HTML or TXT documents

562

nsCOMPtr<nsIDOMDocument> domDoc;

563

nsCOMPtr<nsIDOMHTMLObjectElement> obj(do_QueryInterface(node));

564

if (obj)

565

obj->GetContentDocument(getter_AddRefs(domDoc));

566

else

567

domDoc = do_QueryInterface(node);

568

if (domDoc)

569

return CreateOuterDocAccessible(node, aAccessible);

570

571

#ifdef XP_WIN

572

// 2) for plugins

573

nsCOMPtr<nsIPluginInstance> pluginInstance ;

574

aFrame->GetPluginInstance(*getter_AddRefs(pluginInstance));

575

if (pluginInstance) {

576

HWND pluginPort = nsnull;

577

aFrame->GetPluginPort(&pluginPort);

578

if (pluginPort) {

579

*aAccessible = new nsHTMLWin32ObjectAccessible(node, weakShell, pluginPort);

580

if (*aAccessible) {

581

NS_ADDREF(*aAccessible);

582

return NS_OK;

583

}

584

}

585

}

586

#endif

587

588

// 3) for images and imagemaps, or anything else with a child frame

589

// we have the object frame, get the image frame

590

frame = aFrame->GetFirstChild(nsnull);

591

if (frame) {

592

return frame->GetAccessible(aAccessible);

593

}

594

return NS_ERROR_FAILURE;

595

}

596

597

NS_IMETHODIMP

598

nsAccessibilityService::CreateHTMLRadioButtonAccessible(nsISupports *aFrame, nsIAccessible **_retval)

599

{

600

nsIFrame* frame;

601

nsCOMPtr<nsIDOMNode> node;

602

nsCOMPtr<nsIWeakReference> weakShell;

603

nsresult rv = GetInfo(aFrame, &frame, getter_AddRefs(weakShell), getter_AddRefs(node));

604

if (NS_FAILED(rv))

605

return rv;

606

607

*_retval = new nsHTMLRadioButtonAccessible(node, weakShell);

608

if (! *_retval)

609

return NS_ERROR_OUT_OF_MEMORY;

610

611

NS_ADDREF(*_retval);

612

return NS_OK;

613

}

614

615

NS_IMETHODIMP

616

nsAccessibilityService::CreateHTMLRadioButtonAccessibleXBL(nsIDOMNode *aNode, nsIAccessible **_retval)

617

{

618

#ifdef MOZ_XUL

619

nsCOMPtr<nsIWeakReference> weakShell;

620

GetShellFromNode(aNode, getter_AddRefs(weakShell));

621

622

// reusing the HTML accessible widget and enhancing for XUL

623

*_retval = new nsHTMLRadioButtonAccessible(aNode, weakShell);

624

if (! *_retval)

625

return NS_ERROR_OUT_OF_MEMORY;

626

627

NS_ADDREF(*_retval);

628

#else

629

*_retval = nsnull;

630

#endif // MOZ_XUL

631

return NS_OK;

632

}

633

634

NS_IMETHODIMP

635

nsAccessibilityService::CreateHTMLSelectOptionAccessible(nsIDOMNode* aDOMNode,

636

nsIAccessible *aParent,

637

nsISupports* aPresContext,

638

nsIAccessible **_retval)

639

{

640

nsCOMPtr<nsIPresContext> presContext(do_QueryInterface(aPresContext));

641

NS_ASSERTION(presContext,"Error non prescontext passed to accessible factory!!!");

642

643

nsCOMPtr<nsIWeakReference> weakShell =

644

do_GetWeakReference(presContext->PresShell());

645

646

*_retval = new nsHTMLSelectOptionAccessible(aDOMNode, weakShell);

647

if (! *_retval)

648

return NS_ERROR_OUT_OF_MEMORY;

649

650

NS_ADDREF(*_retval);

651

return NS_OK;

652

}

653

654

NS_IMETHODIMP

655

nsAccessibilityService::CreateHTMLTableAccessible(nsISupports *aFrame, nsIAccessible **_retval)

656

{

657

nsIFrame* frame;

658

nsCOMPtr<nsIDOMNode> node;

659

nsCOMPtr<nsIWeakReference> weakShell;

660

nsresult rv = GetInfo(aFrame, &frame, getter_AddRefs(weakShell), getter_AddRefs(node));

661

if (NS_FAILED(rv))

662

return rv;

663

664

*_retval = new nsHTMLTableAccessibleWrap(node, weakShell);

665

if (! *_retval)

666

return NS_ERROR_OUT_OF_MEMORY;

667

668

NS_ADDREF(*_retval);

669

return NS_OK;

670

}

671

672

NS_IMETHODIMP

673

nsAccessibilityService::CreateHTMLTableCaptionAccessible(nsIDOMNode *aDOMNode, nsIAccessible **_retval)

674

{

675

NS_ENSURE_ARG_POINTER(aDOMNode);

676

677

nsresult rv = NS_OK;

678

679

nsCOMPtr<nsIWeakReference> weakShell;

680

rv = GetShellFromNode(aDOMNode, getter_AddRefs(weakShell));

681

NS_ENSURE_SUCCESS(rv, rv);

682

683

nsHTMLTableCaptionAccessible* accTableCaption =

684

new nsHTMLTableCaptionAccessible(aDOMNode, weakShell);

685

686

NS_ENSURE_TRUE(accTableCaption, NS_ERROR_OUT_OF_MEMORY);

687

688

*_retval = NS_STATIC_CAST(nsIAccessible *, accTableCaption);

689

NS_IF_ADDREF(*_retval);

690

691

return rv;

692

}

693

694

NS_IMETHODIMP

695

nsAccessibilityService::CreateHTMLTableHeadAccessible(nsIDOMNode *aDOMNode, nsIAccessible **_retval)

696

{

697

#ifndef MOZ_ACCESSIBILITY_ATK

698

*_retval = nsnull;

699

return NS_ERROR_FAILURE;

700

#else

701

NS_ENSURE_ARG_POINTER(aDOMNode);

702

703

nsresult rv = NS_OK;

704

705

nsCOMPtr<nsIWeakReference> weakShell;

706

rv = GetShellFromNode(aDOMNode, getter_AddRefs(weakShell));

707

NS_ENSURE_SUCCESS(rv, rv);

708

709

nsHTMLTableHeadAccessible* accTableHead =

710

new nsHTMLTableHeadAccessible(aDOMNode, weakShell);

711

712

NS_ENSURE_TRUE(accTableHead, NS_ERROR_OUT_OF_MEMORY);

713

714

*_retval = NS_STATIC_CAST(nsIAccessible *, accTableHead);

715

NS_IF_ADDREF(*_retval);

716

717

return rv;

718

#endif

719

}

720

721

NS_IMETHODIMP

722

nsAccessibilityService::CreateHTMLTableCellAccessible(nsISupports *aFrame, nsIAccessible **_retval)

723

{

724

nsIFrame* frame;

725

nsCOMPtr<nsIDOMNode> node;

726

nsCOMPtr<nsIWeakReference> weakShell;

727

nsresult rv = GetInfo(aFrame, &frame, getter_AddRefs(weakShell), getter_AddRefs(node));

728

if (NS_FAILED(rv))

729

return rv;

730

731

*_retval = new nsHTMLTableCellAccessibleWrap(node, weakShell);

732

if (! *_retval)

733

return NS_ERROR_OUT_OF_MEMORY;

734

735

NS_ADDREF(*_retval);

736

return NS_OK;

737

}

738

739

NS_IMETHODIMP

740

nsAccessibilityService::CreateHTMLTextAccessible(nsISupports *aFrame, nsIAccessible **_retval)

741

{

742

nsIFrame* frame;

743

nsCOMPtr<nsIDOMNode> node;

744

nsCOMPtr<nsIWeakReference> weakShell;

745

nsresult rv = GetInfo(aFrame, &frame, getter_AddRefs(weakShell), getter_AddRefs(node));

746

if (NS_FAILED(rv))

747

return rv;

748

749

*_retval = nsnull;

750

751

#ifndef MOZ_ACCESSIBILITY_ATK

752

nsCOMPtr<nsITextContent> textContent(do_QueryInterface(node));

753

if (textContent) {

754

// If empty text string, don't include in accessible tree

755

// Items with length 0 are already gone, we also need to check for single NBSP's

756

// or newlines, both of which indicate an empty text object

757

PRInt32 textLength = 0;

758

textContent->GetTextLength(&textLength);

759

if (textLength == 1) {

760

const nsTextFragment *textFrag;

761

textContent->GetText(&textFrag);

762

PRUnichar theChar = textFrag->CharAt(0);

763

// Check for NBSP (160) or newline

764

if (theChar == 160 || theChar=='\n')

765

return NS_ERROR_FAILURE;

766

}

767

nsCOMPtr<nsIDOMNode> parentNode;

768

node->GetParentNode(getter_AddRefs(parentNode));

769

nsCOMPtr<nsIDOMHTMLLegendElement> legend(do_QueryInterface(parentNode));

770

if (legend) // Expose <legend> as the name in a groupbox, not as a ROLE_TEXT accessible

771

return NS_ERROR_FAILURE;

772

}

773

774

*_retval = new nsHTMLTextAccessible(node, weakShell);

775

#else

776

// In ATK, we are only creating the accessible object for the text frame that is the FIRST

777

// text frame in its block.

778

// A depth-first traversal from its nearest parent block frame will produce a frame sequence like

779

// TTTBTTBTT... (B for block frame, T for text frame), so every T frame which is the immediate

780

// sibiling of B frame will be the FIRST text frame.

781

nsIFrame* parentFrame = nsAccessible::GetParentBlockFrame(frame);

782

if (! parentFrame)

783

return NS_ERROR_FAILURE;

784

785

nsCOMPtr<nsIPresShell> presShell(do_QueryReferent(weakShell));

786

nsCOMPtr<nsIPresContext> presContext;

787

presShell->GetPresContext(getter_AddRefs(presContext));

788

nsIFrame* childFrame = parentFrame->GetFirstChild(nsnull);

789

PRInt32 index = 0;

790

nsIFrame* firstTextFrame = nsnull;

791

PRBool ret = nsAccessible::FindTextFrame(index, presContext, childFrame, &firstTextFrame, frame);

792

if (!ret || index != 0)

793

return NS_ERROR_FAILURE;

794

795

*_retval = new nsHTMLBlockAccessible(node, weakShell);

796

#endif //MOZ_ACCESSIBILITY_ATK

797

if (! *_retval)

798

return NS_ERROR_OUT_OF_MEMORY;

799

800

NS_ADDREF(*_retval);

801

return NS_OK;

802

}

803

804

NS_IMETHODIMP

805

nsAccessibilityService::CreateHTMLTextFieldAccessible(nsISupports *aFrame, nsIAccessible **_retval)

806

{

807

nsIFrame* frame;

808

nsCOMPtr<nsIDOMNode> node;

809

nsCOMPtr<nsIWeakReference> weakShell;

810

nsresult rv = GetInfo(aFrame, &frame, getter_AddRefs(weakShell), getter_AddRefs(node));

811

if (NS_FAILED(rv))

812

return rv;

813

814

*_retval = new nsHTMLTextFieldAccessibleWrap(node, weakShell);

815

if (! *_retval)

816

return NS_ERROR_OUT_OF_MEMORY;

817

818

NS_ADDREF(*_retval);

819

return NS_OK;

820

}

821

822

NS_IMETHODIMP

823

nsAccessibilityService::CreateXULTextBoxAccessible(nsIDOMNode *aNode, nsIAccessible **_retval)

824

{

825

#ifdef MOZ_XUL

826

nsCOMPtr<nsIWeakReference> weakShell;

827

GetShellFromNode(aNode, getter_AddRefs(weakShell));

828

829

// reusing the HTML accessible widget and enhancing for XUL

830

*_retval = new nsHTMLTextFieldAccessible(aNode, weakShell);

831

if (! *_retval)

832

return NS_ERROR_OUT_OF_MEMORY;

833

834

NS_ADDREF(*_retval);

835

#else

836

*_retval = nsnull;

837

#endif // MOZ_XUL

838

return NS_OK;

839

}

840

841

NS_IMETHODIMP

842

nsAccessibilityService::CreateHTMLLabelAccessible(nsISupports *aFrame, nsIAccessible **_retval)

843

{

844

nsIFrame* frame;

845

nsCOMPtr<nsIDOMNode> node;

846

nsCOMPtr<nsIWeakReference> weakShell;

847

nsresult rv = GetInfo(aFrame, &frame, getter_AddRefs(weakShell), getter_AddRefs(node));

848

if (NS_FAILED(rv))

849

return rv;

850

851

*_retval = new nsHTMLLabelAccessible(node, weakShell);

852

if (! *_retval)

853

return NS_ERROR_OUT_OF_MEMORY;

854

855

NS_ADDREF(*_retval);

856

return NS_OK;

857

}

858

859

NS_IMETHODIMP

860

nsAccessibilityService::CreateHTMLHRAccessible(nsISupports *aFrame, nsIAccessible **_retval)

861

{

862

nsIFrame* frame;

863

nsCOMPtr<nsIDOMNode> node;

864

nsCOMPtr<nsIWeakReference> weakShell;

865

nsresult rv = GetInfo(aFrame, &frame, getter_AddRefs(weakShell), getter_AddRefs(node));

866

if (NS_FAILED(rv))

867

return rv;

868

869

*_retval = new nsHTMLHRAccessible(node, weakShell);

870

if (! *_retval)

871

return NS_ERROR_OUT_OF_MEMORY;

872

873

NS_ADDREF(*_retval);

874

return NS_OK;

875

}

876

877

/**

878

* XUL widget creation

879

* we can't ifdef this whole block because there is no way to exclude

880

* these methods from the idl definition conditionally (MOZ_XUL).

881

* XXXjgaunt what needs to happen is all of the CreateFooAcc() methods get re-written

882

* into a single method.

883

884

885

NS_IMETHODIMP nsAccessibilityService::CreateXULButtonAccessible(nsIDOMNode *aNode, nsIAccessible **_retval)

886

{

887

#ifdef MOZ_XUL

888

nsCOMPtr<nsIWeakReference> weakShell;

889

GetShellFromNode(aNode, getter_AddRefs(weakShell));

890

891

// reusing the HTML accessible widget and enhancing for XUL

892

*_retval = new nsXULButtonAccessible(aNode, weakShell);

893

if (! *_retval)

894

return NS_ERROR_OUT_OF_MEMORY;

895

896

NS_ADDREF(*_retval);

897

#else

898

*_retval = nsnull;

899

#endif // MOZ_XUL

900

return NS_OK;

901

}

902

903

NS_IMETHODIMP

904

nsAccessibilityService::CreateXULCheckboxAccessible(nsIDOMNode *aNode, nsIAccessible **_retval)

905

{

906

#ifdef MOZ_XUL

907

nsCOMPtr<nsIWeakReference> weakShell;

908

GetShellFromNode(aNode, getter_AddRefs(weakShell));

909

910

// reusing the HTML accessible widget and enhancing for XUL

911

*_retval = new nsXULCheckboxAccessible(aNode, weakShell);

912

if (! *_retval)

913

return NS_ERROR_OUT_OF_MEMORY;

914

915

NS_ADDREF(*_retval);

916

#else

917

*_retval = nsnull;

918

#endif // MOZ_XUL

919

return NS_OK;

920

}

921

922

NS_IMETHODIMP

923

nsAccessibilityService::CreateXULColorPickerAccessible(nsIDOMNode *aNode, nsIAccessible **_retval)

924

{

925

#ifdef MOZ_XUL

926

nsCOMPtr<nsIWeakReference> weakShell;

927

GetShellFromNode(aNode, getter_AddRefs(weakShell));

928

929

*_retval = new nsXULColorPickerAccessible(aNode, weakShell);

930

if (! *_retval)

931

return NS_ERROR_OUT_OF_MEMORY;

932

933

NS_ADDREF(*_retval);

934

#else

935

*_retval = nsnull;

936

#endif // MOZ_XUL

937

return NS_OK;

938

}

939

940

NS_IMETHODIMP

941

nsAccessibilityService::CreateXULColorPickerTileAccessible(nsIDOMNode *aNode, nsIAccessible **_retval)

942

{

943

#ifdef MOZ_XUL

944

nsCOMPtr<nsIWeakReference> weakShell;

945

GetShellFromNode(aNode, getter_AddRefs(weakShell));

946

947

*_retval = new nsXULColorPickerTileAccessible(aNode, weakShell);

948

if (! *_retval)

949

return NS_ERROR_OUT_OF_MEMORY;

950

951

NS_ADDREF(*_retval);

952

#else

953

*_retval = nsnull;

954

#endif // MOZ_XUL

955

return NS_OK;

956

}

957

958

NS_IMETHODIMP

959

nsAccessibilityService::CreateXULComboboxAccessible(nsIDOMNode *aNode, nsIAccessible **_retval)

960

{

961

#ifdef MOZ_XUL

962

nsCOMPtr<nsIWeakReference> weakShell;

963

GetShellFromNode(aNode, getter_AddRefs(weakShell));

964

965

*_retval = new nsXULComboboxAccessible(aNode, weakShell);

966

if (! *_retval)

967

return NS_ERROR_OUT_OF_MEMORY;

968

969

NS_ADDREF(*_retval);

970

#else

971

*_retval = nsnull;

972

#endif // MOZ_XUL

973

return NS_OK;

974

}

975

976

NS_IMETHODIMP

977

nsAccessibilityService::CreateXULDropmarkerAccessible(nsIDOMNode *aNode, nsIAccessible **_retval)

978

{

979

#ifdef MOZ_XUL

980

nsCOMPtr<nsIWeakReference> weakShell;

981

GetShellFromNode(aNode, getter_AddRefs(weakShell));

982

983

*_retval = new nsXULDropmarkerAccessible(aNode, weakShell);

984

if (! *_retval)

985

return NS_ERROR_OUT_OF_MEMORY;

986

987

NS_ADDREF(*_retval);

988

#else

989

*_retval = nsnull;

990

#endif // MOZ_XUL

991

return NS_OK;

992

}

993

994

NS_IMETHODIMP

995

nsAccessibilityService::CreateXULGroupboxAccessible(nsIDOMNode *aNode, nsIAccessible **_retval)

996

{

997

#ifdef MOZ_XUL

998

nsCOMPtr<nsIWeakReference> weakShell;

999

GetShellFromNode(aNode, getter_AddRefs(weakShell));

1000

1001

*_retval = new nsXULGroupboxAccessible(aNode, weakShell);

1002

if (! *_retval)

1003

return NS_ERROR_OUT_OF_MEMORY;

1004

1005

NS_ADDREF(*_retval);

1006

#else

1007

*_retval = nsnull;

1008

#endif // MOZ_XUL

1009

return NS_OK;

1010

}

1011

1012

NS_IMETHODIMP

1013

nsAccessibilityService::CreateXULImageAccessible(nsIDOMNode *aNode, nsIAccessible **_retval)

1014

{

1015

#ifdef MOZ_XUL

1016

// Don't include nameless images in accessible tree

1017

*_retval = nsnull;

1018

1019

nsCOMPtr<nsIDOMElement> elt(do_QueryInterface(aNode));

1020

if (!elt)

1021

return NS_ERROR_FAILURE;

1022

PRBool hasTextEquivalent;

1023

elt->HasAttribute(NS_LITERAL_STRING("tooltiptext"), &hasTextEquivalent); // Prefer value over tooltiptext

1024

if (!hasTextEquivalent) {

1025

return NS_OK;

1026

}

1027

1028

nsCOMPtr<nsIWeakReference> weakShell;

1029

GetShellFromNode(aNode, getter_AddRefs(weakShell));

1030

1031

*_retval = new nsHTMLImageAccessible(aNode, weakShell);

1032

if (! *_retval)

1033

return NS_ERROR_OUT_OF_MEMORY;

1034

1035

NS_ADDREF(*_retval);

1036

1037

#else

1038

*_retval = nsnull;

1039

#endif // MOZ_XUL

1040

return NS_OK;

1041

}

1042

1043

NS_IMETHODIMP

1044

nsAccessibilityService::CreateXULListboxAccessible(nsIDOMNode *aNode, nsIAccessible **_retval)

1045

{

1046

#ifdef MOZ_XUL

1047

nsCOMPtr<nsIWeakReference> weakShell;

1048

GetShellFromNode(aNode, getter_AddRefs(weakShell));

1049

1050

*_retval = new nsXULListboxAccessible(aNode, weakShell);

1051

if (! *_retval)

1052

return NS_ERROR_OUT_OF_MEMORY;

1053

1054

NS_ADDREF(*_retval);

1055

#else

1056

*_retval = nsnull;

1057

#endif // MOZ_XUL

1058

return NS_OK;

1059

}

1060

1061

NS_IMETHODIMP

1062

nsAccessibilityService::CreateXULListitemAccessible(nsIDOMNode *aNode, nsIAccessible **_retval)

1063

{

1064

#ifdef MOZ_XUL

1065

nsCOMPtr<nsIWeakReference> weakShell;

1066

GetShellFromNode(aNode, getter_AddRefs(weakShell));

1067

1068

*_retval = new nsXULListitemAccessible(aNode, weakShell);

1069

if (! *_retval)

1070

return NS_ERROR_OUT_OF_MEMORY;

1071

1072

NS_ADDREF(*_retval);

1073

#else

1074

*_retval = nsnull;

1075

#endif // MOZ_XUL

1076

return NS_OK;

1077

}

1078

1079

NS_IMETHODIMP

1080

nsAccessibilityService::CreateXULMenubarAccessible(nsIDOMNode *aNode, nsIAccessible **_retval)

1081

{

1082

#ifdef MOZ_XUL

1083

nsCOMPtr<nsIWeakReference> weakShell;

1084

GetShellFromNode(aNode, getter_AddRefs(weakShell));

1085

1086

*_retval = new nsXULMenubarAccessible(aNode, weakShell);

1087

if (! *_retval)

1088

return NS_ERROR_OUT_OF_MEMORY;

1089

1090

NS_ADDREF(*_retval);

1091

#else

1092

*_retval = nsnull;

1093

#endif // MOZ_XUL

1094

return NS_OK;

1095

}

1096

1097

NS_IMETHODIMP

1098

nsAccessibilityService::CreateXULMenuitemAccessible(nsIDOMNode *aNode, nsIAccessible **_retval)

1099

{

1100

#ifdef MOZ_XUL

1101

nsCOMPtr<nsIWeakReference> weakShell;

1102

GetShellFromNode(aNode, getter_AddRefs(weakShell));

1103

1104

*_retval = new nsXULMenuitemAccessible(aNode, weakShell);

1105

if (! *_retval)

1106

return NS_ERROR_OUT_OF_MEMORY;

1107

1108

NS_ADDREF(*_retval);

1109

#else

1110

*_retval = nsnull;

1111

#endif // MOZ_XUL

1112

return NS_OK;

1113

}

1114

1115

NS_IMETHODIMP

1116

nsAccessibilityService::CreateXULMenupopupAccessible(nsIDOMNode *aNode, nsIAccessible **_retval)

1117

{

1118

#ifdef MOZ_XUL

1119

nsCOMPtr<nsIWeakReference> weakShell;

1120

GetShellFromNode(aNode, getter_AddRefs(weakShell));

1121

1122

*_retval = new nsXULMenupopupAccessible(aNode, weakShell);

1123

if (! *_retval)

1124

return NS_ERROR_OUT_OF_MEMORY;

1125

1126

NS_ADDREF(*_retval);

1127

#else

1128

*_retval = nsnull;

1129

#endif // MOZ_XUL

1130

return NS_OK;

1131

}

1132

1133

NS_IMETHODIMP

1134

nsAccessibilityService::CreateXULMenuSeparatorAccessible(nsIDOMNode *aNode, nsIAccessible **_retval)

1135

{

1136

#ifdef MOZ_XUL

1137

nsCOMPtr<nsIWeakReference> weakShell;

1138

GetShellFromNode(aNode, getter_AddRefs(weakShell));

1139

1140

*_retval = new nsXULMenuSeparatorAccessible(aNode, weakShell);

1141

if (! *_retval)

1142

return NS_ERROR_OUT_OF_MEMORY;

1143

1144

NS_ADDREF(*_retval);

1145

#else

1146

*_retval = nsnull;

1147

#endif // MOZ_XUL

1148

return NS_OK;

1149

}

1150

1151

NS_IMETHODIMP

1152

nsAccessibilityService::CreateXULProgressMeterAccessible(nsIDOMNode *aNode, nsIAccessible **_retval)

1153

{

1154

#ifdef MOZ_XUL

1155

nsCOMPtr<nsIWeakReference> weakShell;

1156

GetShellFromNode(aNode, getter_AddRefs(weakShell));

1157

1158

*_retval = new nsXULProgressMeterAccessibleWrap(aNode, weakShell);

1159

if (! *_retval)

1160

return NS_ERROR_OUT_OF_MEMORY;

1161

1162

NS_ADDREF(*_retval);

1163

#else

1164

*_retval = nsnull;

1165

#endif // MOZ_XUL

1166

return NS_OK;

1167

}

1168

1169

NS_IMETHODIMP

1170

nsAccessibilityService::CreateXULRadioButtonAccessible(nsIDOMNode *aNode, nsIAccessible **_retval)

1171

{

1172

#ifdef MOZ_XUL

1173

nsCOMPtr<nsIWeakReference> weakShell;

1174

GetShellFromNode(aNode, getter_AddRefs(weakShell));

1175

1176

*_retval = new nsXULRadioButtonAccessible(aNode, weakShell);

1177

if (! *_retval)

1178

return NS_ERROR_OUT_OF_MEMORY;

1179

1180

NS_ADDREF(*_retval);

1181

#else

1182

*_retval = nsnull;

1183

#endif // MOZ_XUL

1184

return NS_OK;

1185

}

1186

1187

NS_IMETHODIMP

1188

nsAccessibilityService::CreateXULRadioGroupAccessible(nsIDOMNode *aNode, nsIAccessible **_retval)

1189

{

1190

#ifdef MOZ_XUL

1191

nsCOMPtr<nsIWeakReference> weakShell;

1192

GetShellFromNode(aNode, getter_AddRefs(weakShell));

1193

1194

*_retval = new nsXULRadioGroupAccessible(aNode, weakShell);

1195

if (! *_retval)

1196

return NS_ERROR_OUT_OF_MEMORY;

1197

1198

NS_ADDREF(*_retval);

1199

#else

1200

*_retval = nsnull;

1201

#endif // MOZ_XUL

1202

return NS_OK;

1203

}

1204

1205

NS_IMETHODIMP

1206

nsAccessibilityService::CreateXULSelectListAccessible(nsIDOMNode *aNode, nsIAccessible **_retval)

1207

{

1208

#ifdef MOZ_XUL

1209

nsCOMPtr<nsIWeakReference> weakShell;

1210

GetShellFromNode(aNode, getter_AddRefs(weakShell));

1211

1212

*_retval = new nsXULSelectListAccessible(aNode, weakShell);

1213

if (! *_retval)

1214

return NS_ERROR_OUT_OF_MEMORY;

1215

1216

NS_ADDREF(*_retval);

1217

#else

1218

*_retval = nsnull;

1219

#endif // MOZ_XUL

1220

return NS_OK;

1221

}

1222

1223

NS_IMETHODIMP

1224

nsAccessibilityService::CreateXULSelectOptionAccessible(nsIDOMNode *aNode, nsIAccessible **_retval)

1225

{

1226

#ifdef MOZ_XUL

1227

nsCOMPtr<nsIWeakReference> weakShell;

1228

GetShellFromNode(aNode, getter_AddRefs(weakShell));

1229

1230

*_retval = new nsXULSelectOptionAccessible(aNode, weakShell);

1231

if (! *_retval)

1232

return NS_ERROR_OUT_OF_MEMORY;

1233

1234

NS_ADDREF(*_retval);

1235

#else

1236

*_retval = nsnull;

1237

#endif // MOZ_XUL

1238

return NS_OK;

1239

}

1240

1241

NS_IMETHODIMP

1242

nsAccessibilityService::CreateXULStatusBarAccessible(nsIDOMNode *aNode, nsIAccessible **_retval)

1243

{

1244

#ifdef MOZ_XUL

1245

nsCOMPtr<nsIWeakReference> weakShell;

1246

GetShellFromNode(aNode, getter_AddRefs(weakShell));

1247

1248

*_retval = new nsXULStatusBarAccessible(aNode, weakShell);

1249

if (! *_retval)

1250

return NS_ERROR_OUT_OF_MEMORY;

1251

1252

NS_ADDREF(*_retval);

1253

#else

1254

*_retval = nsnull;

1255

#endif // MOZ_XUL

1256

return NS_OK;

1257

}

1258

1259

NS_IMETHODIMP

1260

nsAccessibilityService::CreateXULTextAccessible(nsIDOMNode *aNode, nsIAccessible **_retval)

1261

{

1262

#ifdef MOZ_XUL

1263

nsCOMPtr<nsIWeakReference> weakShell;

1264

GetShellFromNode(aNode, getter_AddRefs(weakShell));

1265

1266

// reusing the HTML accessible widget and enhancing for XUL

1267

*_retval = new nsXULTextAccessible(aNode, weakShell);

1268

if (! *_retval)

1269

return NS_ERROR_OUT_OF_MEMORY;

1270

1271

NS_ADDREF(*_retval);

1272

#else

1273

*_retval = nsnull;

1274

#endif // MOZ_XUL

1275

return NS_OK;

1276

}

1277

1278

/** The single tab in a dialog or tabbrowser/editor interface */

1279

NS_IMETHODIMP nsAccessibilityService::CreateXULTabAccessible(nsIDOMNode *aNode, nsIAccessible **_retval)

1280

{

1281

#ifdef MOZ_XUL

1282

nsCOMPtr<nsIWeakReference> weakShell;

1283

GetShellFromNode(aNode, getter_AddRefs(weakShell));

1284

1285

*_retval = new nsXULTabAccessible(aNode, weakShell);

1286

if (! *_retval)

1287

return NS_ERROR_OUT_OF_MEMORY;

1288

1289

NS_ADDREF(*_retval);

1290

#else

1291

*_retval = nsnull;

1292

#endif // MOZ_XUL

1293

return NS_OK;

1294

}

1295

1296

/** A combination of a tabs object and a tabpanels object */

1297

NS_IMETHODIMP nsAccessibilityService::CreateXULTabBoxAccessible(nsIDOMNode *aNode, nsIAccessible **_retval)

1298

{

1299

#ifdef MOZ_XUL

1300

nsCOMPtr<nsIWeakReference> weakShell;

1301

GetShellFromNode(aNode, getter_AddRefs(weakShell));

1302

1303

*_retval = new nsXULTabBoxAccessible(aNode, weakShell);

1304

if (! *_retval)

1305

return NS_ERROR_OUT_OF_MEMORY;

1306

1307

NS_ADDREF(*_retval);

1308

#else

1309

*_retval = nsnull;

1310

#endif // MOZ_XUL

1311

return NS_OK;

1312

}

1313

1314

/** The display area for a dialog or tabbrowser interface */

1315

NS_IMETHODIMP nsAccessibilityService::CreateXULTabPanelsAccessible(nsIDOMNode *aNode, nsIAccessible **_retval)

1316

{

1317

#ifdef MOZ_XUL

1318

nsCOMPtr<nsIWeakReference> weakShell;

1319

GetShellFromNode(aNode, getter_AddRefs(weakShell));

1320

1321

*_retval = new nsXULTabPanelsAccessible(aNode, weakShell);

1322

if (! *_retval)

1323

return NS_ERROR_OUT_OF_MEMORY;

1324

1325

NS_ADDREF(*_retval);

1326

#else

1327

*_retval = nsnull;

1328

#endif // MOZ_XUL

1329

return NS_OK;

1330

}

1331

1332

/** The collection of tab objects, useable in the TabBox and independant of as well */

1333

NS_IMETHODIMP nsAccessibilityService::CreateXULTabsAccessible(nsIDOMNode *aNode, nsIAccessible **_retval)

1334

{

1335

#ifdef MOZ_XUL

1336

nsCOMPtr<nsIWeakReference> weakShell;

1337

GetShellFromNode(aNode, getter_AddRefs(weakShell));

1338

1339

*_retval = new nsXULTabsAccessible(aNode, weakShell);

1340

if (! *_retval)

1341

return NS_ERROR_OUT_OF_MEMORY;

1342

1343

NS_ADDREF(*_retval);

1344

#else

1345

*_retval = nsnull;

1346

#endif // MOZ_XUL

1347

return NS_OK;

1348

}

1349

1350

NS_IMETHODIMP nsAccessibilityService::CreateXULToolbarAccessible(nsIDOMNode *aNode, nsIAccessible **_retval)

1351

{

1352

#ifdef MOZ_XUL

1353

nsCOMPtr<nsIWeakReference> weakShell;

1354

GetShellFromNode(aNode, getter_AddRefs(weakShell));

1355

1356

*_retval = new nsXULToolbarAccessible(aNode, weakShell);

1357

if (! *_retval)

1358

return NS_ERROR_OUT_OF_MEMORY;

1359

1360

NS_ADDREF(*_retval);

1361

#else

1362

*_retval = nsnull;

1363

#endif // MOZ_XUL

1364

return NS_OK;

1365

}

1366

1367

NS_IMETHODIMP nsAccessibilityService::CreateXULToolbarSeparatorAccessible(nsIDOMNode *aNode, nsIAccessible **_retval)

1368

{

1369

#ifdef MOZ_XUL

1370

nsCOMPtr<nsIWeakReference> weakShell;

1371

GetShellFromNode(aNode, getter_AddRefs(weakShell));

1372

1373

*_retval = new nsXULToolbarSeparatorAccessible(aNode, weakShell);

1374

if (! *_retval)

1375

return NS_ERROR_OUT_OF_MEMORY;

1376

1377

NS_ADDREF(*_retval);

1378

#else

1379

*_retval = nsnull;

1380

#endif // MOZ_XUL

1381

return NS_OK;

1382

}

1383

1384

NS_IMETHODIMP nsAccessibilityService::CreateXULTooltipAccessible(nsIDOMNode *aNode, nsIAccessible **_retval)

1385

{

1386

#ifdef MOZ_XUL

1387

#ifndef MOZ_ACCESSIBILITY_ATK

1388

nsCOMPtr<nsIWeakReference> weakShell;

1389

GetShellFromNode(aNode, getter_AddRefs(weakShell));

1390

1391

*_retval = new nsXULTooltipAccessible(aNode, weakShell);

1392

if (! *_retval)

1393

return NS_ERROR_OUT_OF_MEMORY;

1394

1395

NS_ADDREF(*_retval);

1396

#else

1397

*_retval = nsnull;

1398

#endif // MOZ_ACCESSIBILITY_ATK

1399

#else

1400

*_retval = nsnull;

1401

#endif // MOZ_XUL

1402

return NS_OK;

1403

}

1404

1405

NS_IMETHODIMP nsAccessibilityService::CreateXULTreeAccessible(nsIDOMNode *aNode, nsIAccessible **_retval)

1406

{

1407

#ifdef MOZ_XUL

1408

nsCOMPtr<nsIWeakReference> weakShell;

1409

GetShellFromNode(aNode, getter_AddRefs(weakShell));

1410

1411

*_retval = new nsXULTreeAccessibleWrap(aNode, weakShell);

1412

if (! *_retval)

1413

return NS_ERROR_OUT_OF_MEMORY;

1414

1415

NS_ADDREF(*_retval);

1416

#else

1417

*_retval = nsnull;

1418

#endif // MOZ_XUL

1419

return NS_OK;

1420

}

1421

1422

NS_IMETHODIMP nsAccessibilityService::CreateXULTreeColumnsAccessible(nsIDOMNode *aNode, nsIAccessible **_retval)

1423

{

1424

#ifdef MOZ_XUL

1425

nsCOMPtr<nsIWeakReference> weakShell;

1426

GetShellFromNode(aNode, getter_AddRefs(weakShell));

1427

1428

*_retval = new nsXULTreeColumnsAccessibleWrap(aNode, weakShell);

1429

if (! *_retval)

1430

return NS_ERROR_OUT_OF_MEMORY;

1431

1432

NS_ADDREF(*_retval);

1433

#else

1434

*_retval = nsnull;

1435

#endif // MOZ_XUL

1436

return NS_OK;

1437

}

1438

1439

NS_IMETHODIMP nsAccessibilityService::CreateXULTreeColumnitemAccessible(nsIDOMNode *aNode, nsIAccessible **_retval)

1440

{

1441

#ifdef MOZ_XUL

1442

nsCOMPtr<nsIWeakReference> weakShell;

1443

GetShellFromNode(aNode, getter_AddRefs(weakShell));

1444

1445

*_retval = new nsXULTreeColumnitemAccessible(aNode, weakShell);

1446

if (! *_retval)

1447

return NS_ERROR_OUT_OF_MEMORY;

1448

1449

NS_ADDREF(*_retval);

1450

#else

1451

*_retval = nsnull;

1452

#endif // MOZ_XUL

1453

return NS_OK;

1454

}

1455

1456

1457

NS_IMETHODIMP nsAccessibilityService::GetCachedAccessible(nsIDOMNode *aNode,

1458

nsIWeakReference *aWeakShell,

1459

nsIAccessible **aAccessible)

1460

{

1461

nsCOMPtr<nsIAccessNode> accessNode;

1462

nsresult rv = GetCachedAccessNode(aNode, aWeakShell, getter_AddRefs(accessNode));

1463

nsCOMPtr<nsIAccessible> accessible(do_QueryInterface(accessNode));

1464

NS_IF_ADDREF(*aAccessible = accessible);

1465

return rv;

1466

}

1467

1468

NS_IMETHODIMP nsAccessibilityService::GetCachedAccessNode(nsIDOMNode *aNode,

1469

nsIWeakReference *aWeakShell,

1470

nsIAccessNode **aAccessNode)

1471

{

1472

nsCOMPtr<nsIAccessibleDocument> accessibleDoc;

1473

nsAccessNode::GetDocAccessibleFor(aWeakShell, getter_AddRefs(accessibleDoc));

1474

1475

if (!accessibleDoc) {

1476

*aAccessNode = nsnull;

1477

return NS_ERROR_FAILURE;

1478

}

1479

1480

return accessibleDoc->GetCachedAccessNode(NS_STATIC_CAST(void*, aNode), aAccessNode);

1481

}

1482

1483

/**

1484

* GetAccessibleFor - get an nsIAccessible from a DOM node

1485

1486

1487

NS_IMETHODIMP nsAccessibilityService::GetAccessibleFor(nsIDOMNode *aNode,

1488

nsIAccessible **aAccessible)

1489

{

1490

// It's not ideal to call this -- it will assume shell #0

1491

// Some of our old test scripts still use it

1492

nsCOMPtr<nsIContent> content(do_QueryInterface(aNode));

1493

nsCOMPtr<nsIDocument> doc;

1494

if (content) {

1495

doc = content->GetDocument();

1496

}

1497

else {// Could be document node

1498

doc = do_QueryInterface(aNode);

1499

}

1500

if (!doc)

1501

return NS_ERROR_FAILURE;

1502

1503

nsIPresShell *presShell = doc->GetShellAt(0);

1504

return GetAccessibleInShell(aNode, presShell, aAccessible);

1505

}

1506

1507

NS_IMETHODIMP nsAccessibilityService::GetAccessibleInWindow(nsIDOMNode *aNode,

1508

nsIDOMWindow *aWin,

1509

nsIAccessible **aAccessible)

1510

{

1511

nsCOMPtr<nsIWebNavigation> webNav(do_GetInterface(aWin));

1512

nsCOMPtr<nsIDocShell> docShell(do_QueryInterface(webNav));

1513

if (!docShell)

1514

return NS_ERROR_FAILURE;

1515

1516

nsCOMPtr<nsIPresShell> presShell;

1517

docShell->GetPresShell(getter_AddRefs(presShell));

1518

return GetAccessibleInShell(aNode, presShell, aAccessible);

1519

}

1520

1521

NS_IMETHODIMP nsAccessibilityService::GetAccessibleInShell(nsIDOMNode *aNode,

1522

nsIPresShell *aPresShell,

1523

nsIAccessible **aAccessible)

1524

{

1525

nsCOMPtr<nsIWeakReference> weakShell(do_GetWeakReference(aPresShell));

1526

return GetAccessible(aNode, aPresShell, weakShell, aAccessible);

1527

}

1528

1529

NS_IMETHODIMP nsAccessibilityService::GetAccessibleInWeakShell(nsIDOMNode *aNode,

1530

nsIWeakReference *aWeakShell,

1531

nsIAccessible **aAccessible)

1532

{

1533

nsCOMPtr<nsIPresShell> presShell(do_QueryReferent(aWeakShell));

1534

return GetAccessible(aNode, presShell, aWeakShell, aAccessible);

1535

}

1536

1537

nsresult nsAccessibilityService::GetAccessible(nsIDOMNode *aNode,

1538

nsIPresShell *aPresShell,

1539

nsIWeakReference *aWeakShell,

1540

nsIAccessible **aAccessible)

1541

{

1542

*aAccessible = nsnull;

1543

if (!aPresShell || !aWeakShell) {

1544

return NS_ERROR_FAILURE;

1545

}

1546

1547

NS_ASSERTION(aNode, "GetAccessibleFor() called with no node.");

1548

1549

#ifdef DEBUG_aaronl

1550

// Please leave this in for now, it's a convenient debugging method

1551

nsAutoString name;

1552

aNode->GetLocalName(name);

1553

if (name.EqualsIgnoreCase("browser"))

1554

printf("## aaronl debugging tag name\n");

1555

1556

nsAutoString attrib;

1557

nsCOMPtr<nsIDOMElement> element(do_QueryInterface(aNode));

1558

if (element) {

1559

element->GetAttribute(NS_LITERAL_STRING("type"), attrib);

1560

if (attrib.Equals(NS_LITERAL_STRING("checkbox")))

1561

printf("## aaronl debugging attribute\n");

1562

}

1563

#endif

1564

1565

// Check to see if we already have an accessible for this

1566

// node in the cache

1567

nsCOMPtr<nsIAccessNode> accessNode;

1568

GetCachedAccessNode(aNode, aWeakShell, getter_AddRefs(accessNode));

1569

1570

nsCOMPtr<nsIAccessible> newAcc;

1571

if (accessNode) {

1572

// Retrieved from cache

1573

// QI might not succeed if it's a node that's not accessible

1574

newAcc = do_QueryInterface(accessNode);

1575

NS_IF_ADDREF(*aAccessible = newAcc);

1576

return NS_OK;

1577

}

1578

1579

// No cache entry, so we must create the accessible

1580

1581

// XUL elements may implement nsIAccessibleProvider via XBL

1582

// This allows them to say what kind of accessible to create

1583

nsCOMPtr<nsIAccessibleProvider> accProv(do_QueryInterface(aNode));

1584

if (accProv) {

1585

accProv->GetAccessible(getter_AddRefs(newAcc));

1586

if (! newAcc)

1587

return NS_ERROR_FAILURE;

1588

PRUint32 role, state;

1589

newAcc->GetRole(&role);

1590

// don't create the accessible object for popup widget when it's not visible

1591

if (role == nsIAccessible::ROLE_MENUPOPUP) {

1592

newAcc->GetState(&state);

1593

if (state & (nsIAccessible::STATE_INVISIBLE | nsIAccessible::STATE_OFFSCREEN))

1594

return NS_ERROR_FAILURE;

1595

}

1596

nsCOMPtr<nsPIAccessNode> privateAccessNode = do_QueryInterface(newAcc);

1597

privateAccessNode->Init(); // Add to cache, etc.

1598

*aAccessible = newAcc;

1599

NS_ADDREF(*aAccessible);

1600

return NS_OK;

1601

}

1602

1603

#ifdef MOZ_XUL

1604

nsCOMPtr<nsIDOMXULElement> xulElement(do_QueryInterface(aNode));

1605

if (xulElement)

1606

return NS_ERROR_FAILURE;

1607

#endif // MOZ_XUL

1608

1609

// ---- Get the document for this node ----

1610

nsCOMPtr<nsIDocument> doc;

1611

nsCOMPtr<nsIDocument> nodeIsDoc(do_QueryInterface(aNode));

1612

if (nodeIsDoc)

1613

doc = nodeIsDoc;

1614

else {

1615

nsCOMPtr<nsIDOMDocument> domDoc;

1616

aNode->GetOwnerDocument(getter_AddRefs(domDoc));

1617

if (!domDoc)

1618

return NS_ERROR_INVALID_ARG;

1619

doc = do_QueryInterface(domDoc);

1620

}

1621

if (!doc)

1622

return NS_ERROR_INVALID_ARG;

1623

1624

// ---- Check if area node ----

1625

nsCOMPtr<nsIDOMHTMLAreaElement> areaContent(do_QueryInterface(aNode));

1626

if (areaContent) // Area elements are implemented in nsHTMLImageAccessible as children of the image

1627

return NS_ERROR_FAILURE; // Return, otherwise the image frame looks like an accessible object in the wrong place

1628

1629

// ---- Check if we need outer owning doc ----

1630

nsCOMPtr<nsIContent> content(do_QueryInterface(aNode));

1631

if (!content && nodeIsDoc) {

1632

// This happens when we're on the document node, which will not QI to an nsIContent,

1633

nsCOMPtr<nsIAccessibleDocument> accessibleDoc;

1634

nsAccessNode::GetDocAccessibleFor(aWeakShell, getter_AddRefs(accessibleDoc));

1635

if (accessibleDoc) {

1636

newAcc = do_QueryInterface(accessibleDoc);

1637

NS_ASSERTION(newAcc, "nsIAccessibleDocument is not an nsIAccessible");

1638

}

1639

else {

1640

CreateRootAccessible(aPresShell, doc, getter_AddRefs(newAcc)); // Does Init() for us

1641

NS_ASSERTION(newAcc, "No root/doc accessible created");

1642

}

1643

1644

NS_ADDREF(*aAccessible = newAcc );

1645

return NS_OK;

1646

}

1647

1648

NS_ASSERTION(content, "GetAccessibleFor() called with no content.");

1649

1650

// ---- Try using frame to get nsIAccessible ----

1651

nsIFrame* frame = nsnull;

1652

aPresShell->GetPrimaryFrameFor(content, &frame);

1653

if (!frame)

1654

return NS_ERROR_FAILURE;

1655

1656

frame->GetAccessible(getter_AddRefs(newAcc));

1657

1658

#ifndef MOZ_ACCESSIBILITY_ATK

1659

// ---- If link, create link accessible ----

1660

if (!newAcc) {

1661

// is it a link?

1662

nsCOMPtr<nsILink> link(do_QueryInterface(aNode));

1663

if (link) {

1664

newAcc = new nsHTMLLinkAccessible(aNode, aWeakShell);

1665

}

1666

}

1667

#endif //MOZ_ACCESSIBILITY_ATK

1668

1669

// ---- If <select> <option>, create select option accessible

1670

1671

if (!newAcc) {

1672

nsCOMPtr<nsIDOMHTMLOptionElement> optionElement(do_QueryInterface(aNode));

1673

if (optionElement) {

1674

newAcc = new nsHTMLSelectOptionAccessible(aNode, aWeakShell);

1675

}

1676

}

1677

// See if this is an <optgroup>,

1678

// create the accessible for the optgroup.

1679

if (!newAcc) {

1680

nsCOMPtr<nsIDOMHTMLOptGroupElement> optGroupElement(do_QueryInterface(aNode));

1681

if (optGroupElement) {

1682

newAcc = new nsHTMLSelectOptGroupAccessible(aNode, aWeakShell);

1683

}

1684

}

1685

1686

if (!newAcc)

1687

return NS_ERROR_FAILURE;

1688

1689

nsCOMPtr<nsPIAccessNode> privateAccessNode = do_QueryInterface(newAcc);

1690

privateAccessNode->Init(); // Add to cache, etc.

1691

1692

*aAccessible = newAcc;

1693

NS_ADDREF(*aAccessible);

1694

1695

return NS_OK;

1696

}

1697

1698

//////////////////////////////////////////////////////////////////////

1699

//////////////////////////////////////////////////////////////////////

1700

1701

nsresult

1702

nsAccessibilityService::GetAccessibilityService(nsIAccessibilityService** aResult)

1703

{

1704

NS_PRECONDITION(aResult != nsnull, "null ptr");

1705

if (! aResult)

1706

return NS_ERROR_NULL_POINTER;

1707

1708

*aResult = nsnull;

1709

if (!nsAccessibilityService::gAccessibilityService) {

1710

gAccessibilityService = new nsAccessibilityService();

1711

if (!gAccessibilityService ) {

1712

return NS_ERROR_OUT_OF_MEMORY;

1713

}

1714

}

1715

*aResult = nsAccessibilityService::gAccessibilityService;

1716

NS_ADDREF(*aResult);

1717

return NS_OK;

1718

}

1719

1720

nsresult

1721

NS_GetAccessibilityService(nsIAccessibilityService** aResult)

1722

{

1723

return nsAccessibilityService::GetAccessibilityService(aResult);

1724

}

1725

Older »