~valavanisalex/ubuntu/precise/inkscape/fix-943984 : revision 41

inkscape-0.47pre1/src/dom/ls.h

#ifndef __LS_H__

#define __LS_H__

/**

* Phoebe DOM Implementation.

* This is a C++ approximation of the W3C DOM model, which follows

* fairly closely the specifications in the various .idl files, copies of

* which are provided for reference. Most important is this one:

* http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/idl-definitions.html

* Authors:

* Bob Jamison

* This library is free software; you can redistribute it and/or

* modify it under the terms of the GNU Lesser General Public

* License as published by the Free Software Foundation; either

* version 2.1 of the License, or (at your option) any later version.

* This library is distributed in the hope that it will be useful,

* but WITHOUT ANY WARRANTY; without even the implied warranty of

* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

* Lesser General Public License for more details.

* You should have received a copy of the GNU Lesser General Public

* License along with this library; if not, write to the Free Software

* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA

#include "dom.h"

#include "events.h"

#include "traversal.h"

#include "io/domstream.h"

namespace org

{

namespace w3c

{

namespace dom

{

namespace ls

{

//Local definitions

//The idl said Object. Since this is undefined, we will

//use our own class which is designed to be a bit similar to

//java.io streams

typedef dom::io::InputStream LSInputStream;

typedef dom::io::OutputStream LSOutputStream;

typedef dom::io::Reader LSReader;

typedef dom::io::Writer LSWriter;

//local definitions

typedef dom::DOMString DOMString;

typedef dom::DOMConfiguration DOMConfiguration;

typedef dom::Node Node;

typedef dom::NodePtr NodePtr;

typedef dom::Document Document;

typedef dom::DocumentPtr DocumentPtr;

typedef dom::Element Element;

typedef dom::ElementPtr ElementPtr;

//forward declarations

class LSParser;

class LSSerializer;

class LSInput;

class LSOutput;

class LSParserFilter;

class LSSerializerFilter;

/*#########################################################################

## LSException

#########################################################################*/

/**

* Maybe this should inherit from DOMException?

class LSException

{

public:

LSException(const DOMString &reasonMsg)

{ msg = reasonMsg; }

LSException(short theCode)

{

code = theCode;

100

}

101

102

virtual ~LSException() throw()

103

{}

104

105

/**

106

107

108

unsigned short code;

109

110

/**

111

112

113

DOMString msg;

114

115

/**

116

* Get a string, translated from the code.

117

* Like std::exception. Not in spec.

118

119

const char *what()

120

{ return msg.c_str(); }

121

122

123

124

};

125

126

127

/**

128

* LSExceptionCode

129

130

typedef enum

131

{

132

PARSE_ERR = 81,

133

SERIALIZE_ERR = 82

134

} XPathExceptionCode;

135

136

137

/*#########################################################################

138

## LSParserFilter

139

#########################################################################*/

140

141

/**

142

143

144

class LSParserFilter

145

{

146

public:

147

148

// Constants returned by startElement and acceptNode

149

typedef enum

150

{

151

FILTER_ACCEPT = 1,

152

FILTER_REJECT = 2,

153

FILTER_SKIP = 3,

154

FILTER_INTERRUPT = 4

155

} ReturnValues;

156

157

158

/**

159

160

161

virtual unsigned short startElement(const ElementPtr elementArg) =0;

162

163

/**

164

165

166

virtual unsigned short acceptNode(const NodePtr nodeArg) =0;

167

168

/**

169

170

171

virtual unsigned long getWhatToShow() =0;

172

173

//##################

174

//# Non-API methods

175

//##################

176

177

/**

178

179

180

virtual ~LSParserFilter() {}

181

182

183

184

};

185

186

/*#########################################################################

187

## LSInput

188

#########################################################################*/

189

190

/**

191

192

193

class LSInput

194

{

195

public:

196

197

/**

198

199

200

virtual LSReader *getCharacterStream() const

201

{ return characterStream; }

202

203

/**

204

205

206

virtual void setCharacterStream(const LSReader *val)

207

{ characterStream = (LSReader *)val; }

208

209

/**

210

211

212

virtual LSInputStream *getByteStream() const

213

{ return byteStream; }

214

215

/**

216

217

218

virtual void setByteStream(const LSInputStream *val)

219

{ byteStream = (LSInputStream *)val; }

220

221

/**

222

223

224

virtual DOMString getStringData() const

225

{ return stringData; }

226

227

/**

228

229

230

virtual void setStringData(const DOMString &val)

231

{ stringData = val; }

232

233

/**

234

235

236

virtual DOMString getSystemId() const

237

{ return systemId; }

238

239

/**

240

241

242

virtual void setSystemId(const DOMString &val)

243

{ systemId = val; }

244

245

/**

246

247

248

virtual DOMString getPublicId() const

249

{ return publicId; }

250

251

/**

252

253

254

virtual void setPublicId(const DOMString &val)

255

{ publicId = val; }

256

257

/**

258

259

260

virtual DOMString getBaseURI() const

261

{ return baseURI; }

262

263

/**

264

265

266

virtual void setBaseURI(const DOMString &val)

267

{ baseURI = val; }

268

269

/**

270

271

272

virtual DOMString getEncoding() const

273

{ return encoding; }

274

275

/**

276

277

278

virtual void setEncoding(const DOMString &val)

279

{ encoding = val; }

280

281

/**

282

283

284

virtual bool getCertifiedText() const

285

{ return certifiedText; }

286

287

/**

288

289

290

virtual void setCertifiedText(bool val)

291

{ certifiedText = val; }

292

293

//##################

294

//# Non-API methods

295

//##################

296

297

298

/**

299

300

301

LSInput()

302

{

303

characterStream = NULL;

304

byteStream = NULL;

305

stringData = "";

306

systemId = "";

307

publicId = "";

308

baseURI = "";

309

encoding = "";

310

certifiedText = false;

311

}

312

313

314

315

/**

316

317

318

LSInput(const LSInput &other)

319

{

320

characterStream = other.characterStream;

321

byteStream = other.byteStream;

322

stringData = other.stringData;

323

systemId = other.systemId;

324

publicId = other.publicId;

325

baseURI = other.baseURI;

326

encoding = other.encoding;

327

certifiedText = other.certifiedText;

328

}

329

330

/**

331

332

333

virtual ~LSInput()

334

{}

335

336

private:

337

338

LSReader *characterStream;

339

LSInputStream *byteStream;

340

DOMString stringData;

341

DOMString systemId;

342

DOMString publicId;

343

DOMString baseURI;

344

DOMString encoding;

345

bool certifiedText;

346

347

348

};

349

350

351

/*#########################################################################

352

## LSParser

353

#########################################################################*/

354

355

/**

356

357

358

class LSParser

359

{

360

public:

361

362

363

/**

364

365

366

virtual DOMConfiguration *getDomConfig()

367

{ return NULL; }

368

369

/**

370

371

372

virtual LSParserFilter *getFilter()

373

{ return filter; }

374

375

/**

376

377

378

virtual void setFilter(const LSParserFilter *val)

379

{ filter = (LSParserFilter *)val; }

380

381

/**

382

383

384

virtual bool getAsync()

385

{ return false; }

386

387

/**

388

389

390

virtual bool getBusy()

391

{ return false; }

392

393

/**

394

395

396

virtual DocumentPtr parse(const LSInput &/*input*/)

397

throw(dom::DOMException, LSException)

398

{ return NULL; }

399

400

401

/**

402

403

404

virtual DocumentPtr parseURI(const DOMString &/*uri*/)

405

throw(dom::DOMException, LSException)

406

{ return NULL; }

407

408

typedef enum

409

{

410

ACTION_APPEND_AS_CHILDREN = 1,

411

ACTION_REPLACE_CHILDREN = 2,

412

ACTION_INSERT_BEFORE = 3,

413

ACTION_INSERT_AFTER = 4,

414

ACTION_REPLACE = 5

415

} ActionTypes;

416

417

418

/**

419

420

421

virtual NodePtr parseWithContext(const LSInput &/*input*/,

422

const NodePtr /*contextArg*/,

423

unsigned short /*action*/)

424

throw(dom::DOMException, LSException)

425

{ return NULL; }

426

427

/**

428

429

430

virtual void abort()

431

{}

432

433

434

435

//##################

436

//# Non-API methods

437

//##################

438

439

/**

440

441

442

LSParser()

443

{

444

filter = NULL;

445

}

446

447

/**

448

449

450

LSParser(const LSParser &other)

451

{

452

filter = other.filter;

453

}

454

455

/**

456

457

458

virtual ~LSParser() {}

459

460

protected:

461

462

LSParserFilter *filter;

463

};

464

465

466

467

/*#########################################################################

468

## LSResourceResolver

469

#########################################################################*/

470

471

/**

472

473

474

class LSResourceResolver

475

{

476

public:

477

478

/**

479

480

481

virtual LSInput resolveResource(const DOMString &/*type*/,

482

const DOMString &/*namespaceURI*/,

483

const DOMString &/*publicId*/,

484

const DOMString &/*systemId*/,

485

const DOMString &/*baseURI*/)

486

{

487

LSInput input;

488

//do something

489

return input;

490

}

491

492

//##################

493

//# Non-API methods

494

//##################

495

496

/**

497

498

499

LSResourceResolver() {}

500

501

/**

502

503

504

LSResourceResolver(const LSResourceResolver &/*other*/)

505

{

506

}

507

508

/**

509

510

511

virtual ~LSResourceResolver() {}

512

513

514

515

};

516

517

/*#########################################################################

518

## LSOutput

519

#########################################################################*/

520

521

/**

522

523

524

class LSOutput

525

{

526

public:

527

528

/**

529

530

531

virtual LSWriter *getCharacterStream() const

532

{ return characterStream; }

533

534

/**

535

536

537

virtual void setCharacterStream(const LSWriter *val)

538

{ characterStream = (LSWriter *)val; }

539

540

/**

541

542

543

virtual LSOutputStream *getByteStream() const

544

{ return byteStream; }

545

546

/**

547

548

549

virtual void setByteStream(const LSOutputStream *val)

550

{ byteStream = (LSOutputStream *) val; }

551

552

/**

553

554

555

virtual DOMString getSystemId() const

556

{ return systemId; }

557

558

/**

559

560

561

virtual void setSystemId(const DOMString &val)

562

{ systemId = val; }

563

564

/**

565

566

567

virtual DOMString getEncoding() const

568

{ return encoding; }

569

570

/**

571

572

573

virtual void setEncoding(const DOMString &val)

574

{ encoding = val; }

575

576

577

//##################

578

//# Non-API methods

579

//##################

580

581

/**

582

583

584

LSOutput()

585

{

586

characterStream = NULL;

587

byteStream = NULL;

588

systemId = "";

589

encoding = "";

590

}

591

592

593

/**

594

595

596

LSOutput(const LSOutput &other)

597

{

598

characterStream = other.characterStream;

599

byteStream = other.byteStream;

600

systemId = other.systemId;

601

encoding = other.encoding;

602

}

603

604

/**

605

606

607

virtual ~LSOutput()

608

{}

609

610

private:

611

612

LSWriter *characterStream;

613

LSOutputStream *byteStream;

614

DOMString systemId;

615

DOMString encoding;

616

617

};

618

619

620

/*#########################################################################

621

## LSSerializer

622

#########################################################################*/

623

624

/**

625

626

627

class LSSerializer

628

{

629

public:

630

631

/**

632

633

634

virtual DOMConfiguration *getDomConfig()

635

{ return NULL; }

636

637

/**

638

639

640

virtual DOMString getNewLine()

641

{ return newLine; }

642

/**

643

644

645

virtual void setNewLine(const DOMString &val)

646

{ newLine = val; }

647

648

/**

649

650

651

virtual LSSerializerFilter *getFilter()

652

{ return filter; }

653

654

/**

655

656

657

virtual void setFilter(const LSSerializerFilter *val)

658

{ filter = (LSSerializerFilter *)val; }

659

660

/**

661

662

663

virtual bool write(const NodePtr /*nodeArg*/,

664

const LSOutput &/*destination*/)

665

throw (LSException)

666

{ return false; }

667

668

/**

669

670

671

virtual bool writeToURI(const NodePtr /*nodeArg*/,

672

const DOMString &/*uri*/)

673

throw(LSException)

674

{ return false; }

675

676

/**

677

678

679

virtual DOMString writeToString(const NodePtr /*nodeArg*/)

680

throw(dom::DOMException, LSException)

681

{

682

DOMString str;

683

return str;

684

}

685

686

//##################

687

//# Non-API methods

688

//##################

689

690

/**

691

692

693

LSSerializer()

694

{

695

filter = NULL;

696

newLine = "\n";

697

}

698

699

/**

700

701

702

LSSerializer(const LSSerializer &other)

703

{

704

filter = other.filter;

705

newLine = other.newLine;

706

}

707

708

/**

709

710

711

virtual ~LSSerializer() {}

712

713

protected:

714

715

LSSerializerFilter *filter;

716

DOMString newLine;

717

718

};

719

720

/*#########################################################################

721

## LSProgressEvent

722

#########################################################################*/

723

724

/**

725

726

727

class LSProgressEvent : virtual public events::Event

728

{

729

public:

730

731

/**

732

733

734

virtual LSInput &getInput()

735

{

736

return input;

737

}

738

739

/**

740

741

742

virtual unsigned long getPosition()

743

{ return position; }

744

745

/**

746

747

748

virtual unsigned long getTotalSize()

749

{ return totalSize; }

750

751

//##################

752

//# Non-API methods

753

//##################

754

755

/**

756

757

758

LSProgressEvent(const LSInput &inputArg, unsigned long positionArg,

759

unsigned long totalSizeArg) : input((LSInput &)inputArg)

760

{

761

position = positionArg;

762

totalSize = totalSizeArg;

763

}

764

765

766

/**

767

768

769

LSProgressEvent(const LSProgressEvent &other)

770

: events::Event(other) , input(other.input)

771

{

772

position = other.position;

773

totalSize = other.totalSize;

774

}

775

776

777

/**

778

779

780

virtual ~LSProgressEvent() {}

781

782

protected:

783

784

LSInput &input;

785

unsigned long position;

786

unsigned long totalSize;

787

788

};

789

790

/*#########################################################################

791

## LSLoadEvent

792

#########################################################################*/

793

794

/**

795

796

797

class LSLoadEvent : public events::Event

798

{

799

public:

800

801

/**

802

803

804

virtual DocumentPtr getNewDocument()

805

{ return newDocument; }

806

807

/**

808

809

810

virtual LSInput &getInput()

811

{ return input; }

812

813

//##################

814

//# Non-API methods

815

//##################

816

817

/**

818

819

820

LSLoadEvent(const LSInput &inputArg,

821

const DocumentPtr docArg)

822

: input((LSInput &)inputArg)

823

{ newDocument = docArg; }

824

825

/**

826

827

828

LSLoadEvent(const LSLoadEvent &other)

829

: events::Event(other) , input(other.input)

830

{

831

newDocument = other.newDocument;

832

}

833

834

/**

835

836

837

virtual ~LSLoadEvent() {}

838

839

protected:

840

841

DocumentPtr newDocument;

842

843

LSInput &input;

844

845

846

};

847

848

849

850

/*#########################################################################

851

## LSSerializerFilter

852

#########################################################################*/

853

854

/**

855

856

857

class LSSerializerFilter : virtual public traversal::NodeFilter

858

{

859

public:

860

861

/**

862

863

864

virtual unsigned long getWhatToShow() =0;

865

866

//##################

867

//# Non-API methods

868

//##################

869

870

/**

871

872

873

virtual ~LSSerializerFilter() {}

874

};

875

876

877

878

879

/*#########################################################################

880

## DOMImplementationLS

881

#########################################################################*/

882

883

/**

884

885

886

class DOMImplementationLS

887

{

888

public:

889

890

typedef enum

891

{

892

MODE_SYNCHRONOUS = 1,

893

MODE_ASYNCHRONOUS = 2

894

} DOMImplementationLSMode;

895

896

/**

897

* To use, for this and subclasses:

898

* LSParser &parser = myImplementation.createLSParser(mode, schemaType);

899

900

virtual LSParser &createLSParser(unsigned short mode,

901

const DOMString &schemaType)

902

throw (dom::DOMException) =0;

903

904

/**

905

* To use, for this and subclasses:

906

* LSSerializer &serializer = myImplementation.createLSSerializer();

907

908

909

virtual LSSerializer &createLSSerializer() =0;

910

911

/**

912

913

914

virtual LSInput createLSInput() =0;

915

916

/**

917

918

919

virtual LSOutput createLSOutput() =0;

920

921

//##################

922

//# Non-API methods

923

//##################

924

925

/**

926

927

928

virtual ~DOMImplementationLS() {}

929

};

930

931

932

933

934

} //namespace ls

935

} //namespace dom

936

} //namespace w3c

937

} //namespace org

938

939

940

#endif // __LS_H__

941

942

/*#########################################################################

943

## E N D O F F I L E

944

#########################################################################*/

945

Older »