00001
00027
#include "dom/dom_exception.h"
00028
#include "xml/dom_docimpl.h"
00029
#include "xml/dom2_rangeimpl.h"
00030
00031
using namespace DOM;
00032
00033 Range::Range()
00034 {
00035
00036 impl = 0;
00037 }
00038
00039 Range::Range(
const Document rootContainer)
00040 {
00041
if(rootContainer.
handle())
00042 {
00043 impl =
new RangeImpl(rootContainer.
handle()->docPtr());
00044 impl->ref();
00045 }
00046
else
00047 impl = 0;
00048 }
00049
00050 Range::Range(
const Range &other)
00051 {
00052 impl = other.impl;
00053
if (impl) impl->ref();
00054 }
00055
00056 Range::Range(
const Node startContainer,
const long startOffset,
const Node endContainer,
const long endOffset)
00057 {
00058
if (startContainer.
isNull() || endContainer.
isNull()) {
00059
throw DOMException(DOMException::NOT_FOUND_ERR);
00060 }
00061
00062
if (!startContainer.
handle()->getDocument() ||
00063 startContainer.
handle()->getDocument() != endContainer.
handle()->getDocument()) {
00064
throw DOMException(DOMException::WRONG_DOCUMENT_ERR);
00065 }
00066
00067 impl =
new RangeImpl(startContainer.
handle()->docPtr(),startContainer.
handle(),startOffset,endContainer.
handle(),endOffset);
00068 impl->ref();
00069 }
00070
00071 Range::Range(RangeImpl *i)
00072 {
00073 impl = i;
00074
if (impl) impl->ref();
00075 }
00076
00077 Range &Range::operator = (
const Range &other)
00078 {
00079
if ( impl != other.impl ) {
00080
if (impl) impl->deref();
00081 impl = other.impl;
00082
if (impl) impl->ref();
00083 }
00084
return *
this;
00085 }
00086
00087 Range::~Range()
00088 {
00089
if (impl) impl->deref();
00090 }
00091
00092
Node Range::startContainer()
const
00093
{
00094
if (!impl)
00095
throw DOMException(DOMException::INVALID_STATE_ERR);
00096
00097
int exceptioncode = 0;
00098 NodeImpl *r = impl->startContainer(exceptioncode);
00099 throwException(exceptioncode);
00100
return r;
00101 }
00102
00103
long Range::startOffset()
const
00104
{
00105
if (!impl)
00106
throw DOMException(DOMException::INVALID_STATE_ERR);
00107
00108
int exceptioncode = 0;
00109
long r = impl->startOffset(exceptioncode);
00110 throwException(exceptioncode);
00111
return r;
00112
00113 }
00114
00115
Node Range::endContainer()
const
00116
{
00117
if (!impl)
00118
throw DOMException(DOMException::INVALID_STATE_ERR);
00119
00120
int exceptioncode = 0;
00121 NodeImpl *r = impl->endContainer(exceptioncode);
00122 throwException(exceptioncode);
00123
return r;
00124 }
00125
00126
long Range::endOffset()
const
00127
{
00128
if (!impl)
00129
throw DOMException(DOMException::INVALID_STATE_ERR);
00130
00131
int exceptioncode = 0;
00132
long r = impl->endOffset(exceptioncode);
00133 throwException(exceptioncode);
00134
return r;
00135 }
00136
00137
bool Range::collapsed()
const
00138
{
00139
if (!impl)
00140
throw DOMException(DOMException::INVALID_STATE_ERR);
00141
00142
int exceptioncode = 0;
00143
bool r = impl->collapsed(exceptioncode);
00144 throwException(exceptioncode);
00145
return r;
00146 }
00147
00148
Node Range::commonAncestorContainer()
00149 {
00150
if (!impl)
00151
throw DOMException(DOMException::INVALID_STATE_ERR);
00152
00153
int exceptioncode = 0;
00154 NodeImpl *r = impl->commonAncestorContainer(exceptioncode);
00155 throwException(exceptioncode);
00156
return r;
00157 }
00158
00159
void Range::setStart(
const Node &refNode,
long offset )
00160 {
00161
if (!impl)
00162
throw DOMException(DOMException::INVALID_STATE_ERR);
00163
00164
int exceptioncode = 0;
00165 impl->setStart(refNode.
handle(),offset,exceptioncode);
00166 throwException(exceptioncode);
00167 }
00168
00169
void Range::setEnd(
const Node &refNode,
long offset )
00170 {
00171
if (!impl)
00172
throw DOMException(DOMException::INVALID_STATE_ERR);
00173
00174
int exceptioncode = 0;
00175 impl->setEnd(refNode.
handle(),offset,exceptioncode);
00176 throwException(exceptioncode);
00177 }
00178
00179
void Range::setStartBefore(
const Node &refNode )
00180 {
00181
if (!impl)
00182
throw DOMException(DOMException::INVALID_STATE_ERR);
00183
00184
00185
int exceptioncode = 0;
00186 impl->setStartBefore(refNode.
handle(),exceptioncode);
00187 throwException(exceptioncode);
00188 }
00189
00190
void Range::setStartAfter(
const Node &refNode )
00191 {
00192
if (!impl)
00193
throw DOMException(DOMException::INVALID_STATE_ERR);
00194
00195
int exceptioncode = 0;
00196 impl->setStartAfter(refNode.
handle(),exceptioncode);
00197 throwException(exceptioncode);
00198 }
00199
00200
void Range::setEndBefore(
const Node &refNode )
00201 {
00202
if (!impl)
00203
throw DOMException(DOMException::INVALID_STATE_ERR);
00204
00205
int exceptioncode = 0;
00206 impl->setEndBefore(refNode.
handle(),exceptioncode);
00207 throwException(exceptioncode);
00208 }
00209
00210
void Range::setEndAfter(
const Node &refNode )
00211 {
00212
if (!impl)
00213
throw DOMException(DOMException::INVALID_STATE_ERR);
00214
00215
int exceptioncode = 0;
00216 impl->setEndAfter(refNode.
handle(),exceptioncode);
00217 throwException(exceptioncode);
00218 }
00219
00220
void Range::collapse(
bool toStart )
00221 {
00222
if (!impl)
00223
throw DOMException(DOMException::INVALID_STATE_ERR);
00224
00225
int exceptioncode = 0;
00226 impl->collapse(toStart,exceptioncode);
00227 throwException(exceptioncode);
00228 }
00229
00230
void Range::selectNode(
const Node &refNode )
00231 {
00232
if (!impl)
00233
throw DOMException(DOMException::INVALID_STATE_ERR);
00234
00235
int exceptioncode = 0;
00236 impl->selectNode(refNode.
handle(),exceptioncode);
00237 throwException(exceptioncode);
00238 }
00239
00240
void Range::selectNodeContents(
const Node &refNode )
00241 {
00242
if (!impl)
00243
throw DOMException(DOMException::INVALID_STATE_ERR);
00244
00245
int exceptioncode = 0;
00246 impl->selectNodeContents(refNode.
handle(),exceptioncode);
00247 throwException(exceptioncode);
00248 }
00249
00250
short Range::compareBoundaryPoints( CompareHow how,
const Range &sourceRange )
00251 {
00252
if (!impl)
00253
throw DOMException(DOMException::INVALID_STATE_ERR);
00254
00255
int exceptioncode = 0;
00256
short r = impl->compareBoundaryPoints(how,sourceRange.handle(),exceptioncode);
00257 throwException(exceptioncode);
00258
return r;
00259 }
00260
00261
bool Range::boundaryPointsValid( )
00262 {
00263
if (!impl)
00264
throw DOMException(DOMException::INVALID_STATE_ERR);
00265
00266
return impl->boundaryPointsValid();
00267 }
00268
00269
void Range::deleteContents( )
00270 {
00271
if (!impl)
00272
throw DOMException(DOMException::INVALID_STATE_ERR);
00273
00274
int exceptioncode = 0;
00275 impl->deleteContents(exceptioncode);
00276 throwException(exceptioncode);
00277 }
00278
00279
DocumentFragment Range::extractContents( )
00280 {
00281
if (!impl)
00282
throw DOMException(DOMException::INVALID_STATE_ERR);
00283
00284
int exceptioncode = 0;
00285 DocumentFragmentImpl *r = impl->extractContents(exceptioncode);
00286 throwException(exceptioncode);
00287
return r;
00288 }
00289
00290
DocumentFragment Range::cloneContents( )
00291 {
00292
if (!impl)
00293
throw DOMException(DOMException::INVALID_STATE_ERR);
00294
00295
int exceptioncode = 0;
00296 DocumentFragmentImpl *r = impl->cloneContents(exceptioncode);
00297 throwException(exceptioncode);
00298
return r;
00299 }
00300
00301
void Range::insertNode(
const Node &newNode )
00302 {
00303
if (!impl)
00304
throw DOMException(DOMException::INVALID_STATE_ERR);
00305
00306
int exceptioncode = 0;
00307 impl->insertNode(newNode.
handle(),exceptioncode);
00308 throwException(exceptioncode);
00309 }
00310
00311
void Range::surroundContents(
const Node &newParent )
00312 {
00313
if (!impl)
00314
throw DOMException(DOMException::INVALID_STATE_ERR);
00315
00316
int exceptioncode = 0;
00317 impl->surroundContents(newParent.
handle(),exceptioncode);
00318 throwException(exceptioncode);
00319 }
00320
00321 Range Range::cloneRange( )
00322 {
00323
if (!impl)
00324
throw DOMException(DOMException::INVALID_STATE_ERR);
00325
00326
int exceptioncode = 0;
00327 RangeImpl *r = impl->cloneRange(exceptioncode);
00328 throwException(exceptioncode);
00329
return r;
00330 }
00331
00332
DOMString Range::toString( )
00333 {
00334
if (!impl)
00335
throw DOMException(DOMException::INVALID_STATE_ERR);
00336
00337
int exceptioncode = 0;
00338
DOMString r = impl->toString(exceptioncode);
00339 throwException(exceptioncode);
00340
return r;
00341
00342 }
00343
00344
DOMString Range::toHTML( )
00345 {
00346
if (!impl)
00347
throw DOMException(DOMException::INVALID_STATE_ERR);
00348
00349
return impl->toHTML();
00350 }
00351
00352
DocumentFragment Range::createContextualFragment(
const DOMString &html )
00353 {
00354
if (!impl)
00355
throw DOMException(DOMException::INVALID_STATE_ERR);
00356
00357
int exceptioncode = 0;
00358
DocumentFragment r = impl->createContextualFragment(html, exceptioncode);
00359 throwException(exceptioncode);
00360
return r;
00361 }
00362
00363
00364
void Range::detach( )
00365 {
00366
if (!impl)
00367
throw DOMException(DOMException::INVALID_STATE_ERR);
00368
00369
int exceptioncode = 0;
00370 impl->detach(exceptioncode);
00371 throwException(exceptioncode);
00372 }
00373
00374
bool Range::isDetached()
const
00375
{
00376
if (!impl)
00377
throw DOMException(DOMException::INVALID_STATE_ERR);
00378
00379
return impl->isDetached();
00380 }
00381
00382 RangeImpl *Range::handle()
const
00383
{
00384
return impl;
00385 }
00386
00387
bool Range::isNull()
const
00388
{
00389
return (impl == 0);
00390 }
00391
00392
void Range::throwException(
int exceptioncode)
const
00393
{
00394
if (!exceptioncode)
00395
return;
00396
00397
00398
if (exceptioncode >= RangeException::_EXCEPTION_OFFSET && exceptioncode <= RangeException::_EXCEPTION_MAX)
00399
throw RangeException(static_cast<RangeException::RangeExceptionCode>(exceptioncode-RangeException::_EXCEPTION_OFFSET));
00400
else
00401
throw DOMException(exceptioncode);
00402 }
00403
00404
00405