void BlockableDisplayNode::RefreshAfter() { DisplayDirector* director = GetDisplayDirector(); if (director == NULL) throw InternalException("BlockableDisplayNode::RefreshDocAfter(): not attached to director."); director->RefreshDocAfter(Top()); }
VfsPosix::Directory::Directory (const char *dirname) throw (InternalException) { dir = opendir (dirname); if (dir == NULL) throw InternalException (errnoToString (errno)); }
void Rotate(RectMatrixCol& U, RectMatrixCol& V, Real tau, Real s) { REPORT // (U, V) = (U, V) * (c, s) where tau = s/(1+c), c^2 + s^2 = 1 int n = U.n; if (n != V.n) { Tracer tr("newmatrm"); Throw(InternalException("Dimensions differ in Rotate")); } Real* u = U.store; Real* v = V.store; int su = U.spacing; int sv = V.spacing; //while (n--) //{ // Real zu = *u; Real zv = *v; // *u -= s * (zv + zu * tau); *v += s * (zu - zv * tau); // u += su; v += sv; //} if (n) for(;;) { Real zu = *u; Real zv = *v; *u -= s * (zv + zu * tau); *v += s * (zu - zv * tau); if (!(--n)) break; u += su; v += sv; } }
char* ScratchPadAllocator::AllocateMemory( int size ) { // Will be set if we dont return in the for loop so we can append a chunk. MemoryChunk* lastMemoryChunkInChain = NULL; // See if any of the blocks in the chain have the memory we need and if so return it. for( MemoryChunk* currentMemoryChunk = mMemoryChunkHead; currentMemoryChunk != NULL; currentMemoryChunk = currentMemoryChunk->nextChunk ) { char* possibleReturnValue = currentMemoryChunk->TryToAllocate( size ); if(possibleReturnValue != NULL) return possibleReturnValue; lastMemoryChunkInChain = currentMemoryChunk; } // Get a suitable new chunk ensuring we can get our memory from it. MemoryChunk* newMemoryChunk = allocateAndInitializeChunk(size); char* returnValue = newMemoryChunk->TryToAllocate( size ); if(returnValue == NULL) throw InternalException("mMemoryChunkHead->TryToAllocate( size ) should always sucseed here."); // Place the new meory chunk in the chain. if(lastMemoryChunkInChain != NULL) lastMemoryChunkInChain->nextChunk = newMemoryChunk; else mMemoryChunkHead = newMemoryChunk; return returnValue; }
_ObjectBase* _HiddenObject::asPointer(const char* baseName) { // If "list iterator couldn't be dereference" was reported, // That mean the object doesn't exist and there must be a bug if(!baseName) throw InternalException(CREATE_STANDARD_MESSAGE("baseName is null")); return pointers.find(Utility::getHiddenDirectBase(name.c_str(), baseName))->second; }
// Must be called with 'state_mutex' held. void ThreadPool::spawnSpareThreads () throw (InternalException) { unsigned long nthreads = spareThreads.getNumElements () + busyThreads.getNumElements (); unsigned long tocreate = 0; if (nthreads < minThreads) tocreate = minThreads - nthreads; Ref<WorkerThread> workerThread; for (unsigned long i = 0; i < tocreate; i++) { try { /* Throws InternalException */ workerThread = grab (new WorkerThread (this)); spareThreads.append (workerThread); } catch (Exception &exc) { if (spareThreads.getNumElements () + busyThreads.getNumElements () == 0) { throw InternalException ( String::forPrintTask ( (Pr ("MyCpp.ThreadPool.spawnSpareThreads: " "failed to spawn the first thread: ")) (Pr (exc.getMessage ()))), exc.clone ()); } else { errf->print ("MyCpp.ThreadPool.spawnSpareThreads: " "WARNING: failed to spawn a thread"); } } } }
void check(t current, string const & name) { if (current < min || current > max) { throw InternalException(name + ": Invalid Rail: " + railToString(current)); } }
SHARED_LIBRARY_HANDLE PlatformLoadLibrary(const char* const name) { SHARED_LIBRARY_HANDLE handle = dlopen(name, RTLD_LAZY); if (handle == NULL) { throw InternalException("FirebirdApiBinding::Initialize - Could not find or load the firebird client library."); } return handle; }
void SelectGlyphsAction::Do(DisplayDirector* director) { TextDisplayNode* firstNode = dynamic_cast<TextDisplayNode*>(director->DisplayNodeFor(firstText)); if (firstNode == NULL) throw InternalException("SelectGlyphsAction::Do: first TextDisplayNode doesn't exist."); Glyph* firstGlyph = firstNode->GlyphAtOffset(firstOffset); if (firstGlyph == NULL) throw InternalException("SelectGlyphsAction::Do: first glyph doesn't exist."); TextDisplayNode* lastNode = dynamic_cast<TextDisplayNode*>(director->DisplayNodeFor(lastText)); if (lastNode == NULL) throw InternalException("SelectGlyphsAction::Do: last TextDisplayNode doesn't exist."); Glyph* lastGlyph = lastNode->GlyphAtOffset(lastOffset); if (lastGlyph == NULL) throw InternalException("SelectGlyphsAction::Do: last glyph doesn't exist."); director->SetSelection(new GlyphsSelection(GlyphRef(firstNode, firstGlyph), GlyphRef(lastNode, lastGlyph))); }
int BlockableDisplayNode::LeftSpace() { BlockableDisplayNode* parentNode = dynamic_cast<BlockableDisplayNode*>(parent); if (parentNode == NULL) throw InternalException("BlockableDisplayNode has non-block parent."); return parentNode->LeftSpace() + GetPropertyInPixels("margin-left", false); }
Ref<Vfs::StatData> VfsPosix::stat (const char *_name) throw (InternalException) { Ref<String> name = String::forPrintTask ((Pr (root_path)) (Pr ("/")) (Pr (_name))); struct stat stat_buf; int rv = ::stat (name->getData (), &stat_buf); if (rv == -1) { throw InternalException (errnoToString (errno)); } else if (rv != 0) throw InternalException (); Ref<StatData> stat_data = grab (new StatData); if (S_ISBLK (stat_buf.st_mode)) stat_data->file_type = FileType_BlockDevice; else if (S_ISCHR (stat_buf.st_mode)) stat_data->file_type = FileType_CharacterDevice; else if (S_ISDIR (stat_buf.st_mode)) stat_data->file_type = FileType_Directory; else if (S_ISFIFO (stat_buf.st_mode)) stat_data->file_type = FileType_Fifo; else if (S_ISREG (stat_buf.st_mode)) stat_data->file_type = FileType_RegularFile; else if (S_ISLNK (stat_buf.st_mode)) stat_data->file_type = FileType_SymbolicLink; else if (S_ISSOCK (stat_buf.st_mode)) stat_data->file_type = FileType_Socket; else throw InternalException (); stat_data->size = (unsigned long long) stat_buf.st_size; return stat_data; }
Element* EmptyPlaceholderSelection::GetElement() { for (DisplayNode* node = textNode->Parent(); node; node = node->Parent()) { ElementDisplayNode* elementNode = dynamic_cast<ElementDisplayNode*>(node); if (elementNode) return elementNode->GetElement(); } if (useAssertions) throw InternalException("EmptyPlaceholderSelection: parent isn't an ElementDisplayNode."); return NULL; }
Ref<String> VfsPosix::Directory::getNextEntry () throw (InternalException) { ArrayHolder<unsigned char> dirent_array (sizeof (struct dirent) + NAME_MAX + 1); struct dirent * const dirent = (struct dirent*) &dirent_array [0]; struct dirent *retp; int rv = readdir_r (dir, dirent, &retp); if (rv != 0) throw InternalException (errnoToString (rv)); if (retp == NULL) return NULL; if (retp != dirent) throw InternalException (); return grab (new String (dirent->d_name)); }
void RectMatrixRowCol::Divide(const RectMatrixRowCol& rmrc, Real r) { REPORT int i = n; Real* s = store; int d = spacing; Real* s1 = rmrc.store; int d1 = rmrc.spacing; if (i!=rmrc.n) { Tracer tr("newmatrm"); Throw(InternalException("Dimensions differ in Divide")); } if (i) for (;;) { *s = *s1 / r; if (!(--i)) break; s += d; s1 += d1; } }
Dir::t railToDirForward(t current) { static Dir::t result[] = {Dir::east, Dir::north, Dir::northeast, Dir::southeast}; check(current, "Rail::railToDirForward()"); if (current == junction || current == rubble) { throw InternalException( "Rail::railToDirForward(): No inherent direction: " + railToString(current)); } return result[current]; }
Ref<AsyncFile> VfsPosix::openAsyncFile (const char *_filename, unsigned long open_flags, AccessMode access_mode) throw (InternalException) { Ref<String> filename = String::forPrintTask ((Pr (root_path)) (Pr ("/")) (Pr (_filename))); try { return grab (static_cast <AsyncFile*> (new NativeAsyncFile (filename->getData (), open_flags, access_mode))); } catch (Exception &exc) { throw InternalException (String::nullString (), exc.clone ()); } }
Dir::t correctDirection(t current, Dir::t oldDir) { static const string functionName = "Rail::correctDirection()"; check(current, functionName); Dir::check(oldDir, functionName); Dir::t result = oldDir; if (current == junction) { result = oldDir; } else if (current == rubble) { throw InternalException(functionName + ": Encountered rubble"); } else { Dir::t forward = railToDirForward(current); Dir::t backward = railToDirBackward(current); if (oldDir == forward || oldDir == Dir::left(forward) || oldDir == Dir::right(forward)) { result = forward; } else if (oldDir == backward || oldDir == Dir::left(backward) || oldDir == Dir::right(backward)) { result = backward; } else { throw InternalException(functionName + ": Perpendicular direction: " + railToString(current) + " -- " + Dir::dirToString(oldDir)); } } return result; }
Real RectMatrixRowCol::operator*(const RectMatrixRowCol& rmrc) const { REPORT long_Real sum = 0.0; int i = n; Real* s = store; int d = spacing; Real* s1 = rmrc.store; int d1 = rmrc.spacing; if (i!=rmrc.n) { Tracer tr("newmatrm"); Throw(InternalException("Dimensions differ in *")); } if (i) for(;;) { sum += (long_Real)*s * *s1; if (!(--i)) break; s += d; s1 += d1; } return (Real)sum; }
void add_pdb_radii(Hierarchies hs) { for (unsigned int i = 0; i < hs.size(); ++i) { add_pdb_radii(hs[i]); canonicalize(hs[i]); } IMP_IF_CHECK(USAGE_AND_INTERNAL) { for (unsigned int i = 0; i < hs.size(); ++i) { if (!hs[i].get_is_valid(true)) { IMP_ERROR("Invalid hierarchy produced "); IMP_ERROR_WRITE(IMP::core::show<Hierarchy>(hs[i], IMP_STREAM)); throw InternalException("Bad hierarchy"); // should clean up } } } }
void ComplexScale(RectMatrixCol& U, RectMatrixCol& V, Real x, Real y) { REPORT int n = U.n; if (n != V.n) { Tracer tr("newmatrm"); Throw(InternalException("Dimensions differ in ComplexScale")); } Real* u = U.store; Real* v = V.store; int su = U.spacing; int sv = V.spacing; if (n) for (;;) { Real z = *u * x - *v * y; *v = *u * y + *v * x; *u = z; if (!(--n)) break; u += su; v += sv; } }
void Rotate(RectMatrixCol& U, RectMatrixCol& V, Real tau, Real s) { REPORT int n = U.n; if (n != V.n) { Tracer tr("newmatrm"); Throw(InternalException("Dimensions differ in Rotate")); } Real* u = U.store; Real* v = V.store; int su = U.spacing; int sv = V.spacing; if (n) for(;;) { Real zu = *u; Real zv = *v; *u -= s * (zv + zu * tau); *v += s * (zu - zv * tau); if (!(--n)) break; u += su; v += sv; } }
/** * Sets mAuthSvcInfo member variable * Throws: InternalException upon error */ void AgentProfileService::setAuthSvcInfo(std::string authURL) { try { URL verifyURL(authURL); } catch (InternalException &iex) { throw InternalException("AuthService::setAuthSvcInfo()", "Malformed URL.", AM_AUTH_FAILURE); } mAuthSvcInfo.setFromString(authURL); Log::log(logModule, Log::LOG_MAX_DEBUG, "Number of servers in service:%d, '%s'.", mAuthSvcInfo.getNumberOfServers(), authURL.c_str()); return; }
std::shared_ptr<TrainStrategy> TrainStrategy::create( algorithm::AAMAlgorithm alg, int channels) { std::shared_ptr<TrainStrategy> ptr; switch (alg) { case algorithm::conventional: ptr = std::make_shared<TrainConventional>(channels); break; case algorithm::inverseComposition: ptr = std::make_shared<TrainIC2D>(channels); break; default: throw InternalException(); } return ptr; }
void DisplayDirector::SetupDisplayNodes() // to be called by any subclass' ctor, after the stylesheet is set up { // find the document's DisplayNode docDisplayNode = dynamic_cast<DocumentDisplayNode*>(DisplayNodeFor(docSource->GetDocument())); if (docDisplayNode == NULL) throw InternalException("Couldn't get the DocumentDisplayNode!"); // load docDisplayNode->Load(this); docDisplayNode->UpdateProperties(); // layout docDisplayNode->BlockLayout(); // notify the docSource (we do this *after* setting up the display nodes // so it will be able to set a selection, etc.) docSource->AttachedToDirector(this); }
void OnReadable(ServerInterface<TcpChannelCache<ChannelDataT, CacheSize> >* pInterface) { int dwRemainSize = CacheSize - pInterface->m_Channel.Data.dwCacheAvailableSize; if(dwRemainSize <= 0) { Disconnect(); throw InternalException((boost::format("[%s:%d][error] package cache is full.") % __FILE__ % __LINE__).str().c_str()); } IOBuffer ioRecvBuffer(&pInterface->m_Channel.Data.cPackageCache[pInterface->m_Channel.Data.dwCacheAvailableSize], dwRemainSize); pInterface->m_Channel >> ioRecvBuffer; if(ioRecvBuffer.GetReadSize() == 0) { Disconnect(); } else { pInterface->m_Channel.Data.dwCacheAvailableSize += ioRecvBuffer.GetReadSize(); IOBuffer in(pInterface->m_Channel.Data.cPackageCache, pInterface->m_Channel.Data.dwCacheAvailableSize, pInterface->m_Channel.Data.dwCacheAvailableSize); this->OnMessage(pInterface->m_Channel, in); pInterface->m_Channel.Data.dwCacheAvailableSize = in.GetReadSize() - in.GetReadPosition(); if(in.GetReadPosition() > 0 && pInterface->m_Channel.Data.dwCacheAvailableSize > 0) { memmove(pInterface->m_Channel.Data.cPackageCache, &pInterface->m_Channel.Data.cPackageCache[in.GetReadPosition()], pInterface->m_Channel.Data.dwCacheAvailableSize); } } }
UnicharStream::UnicharResult Utf8UnicharStream::doGetNextUnichar (Unichar * const ret_uc) { char cbuf [7] = {}; unsigned long i = 0; for (i = 0; i < 6; i++) { char c; ByteStream::ByteResult bres; bres = byte_stream->getNextByte (&c); if (bres == ByteStream::ByteEof) { if (i != 0) break; return UnicharEof; } if (bres != ByteStream::ByteNormal) abortIfReached (); cbuf [i] = c; if (utf8_validate_sz (cbuf, NULL)) { if (ret_uc != NULL) *ret_uc = utf8_valid_to_unichar (cbuf); return UnicharNormal; } } errf->print ("Scruffy.Utf8UnicharStream: " "input is not valid UTF-8") .pendl (); // throw ParsingException (fpos); throw InternalException (); }
void Codec20::checkForErrorsInResponseStatus(Transport& transport, HeaderParams& params, uint8_t status) const { try { switch (status) { case HotRodConstants::INVALID_MAGIC_OR_MESSAGE_ID_STATUS: case HotRodConstants::REQUEST_PARSING_ERROR_STATUS: case HotRodConstants::UNKNOWN_COMMAND_STATUS: case HotRodConstants::SERVER_ERROR_STATUS: case HotRodConstants::COMMAND_TIMEOUT_STATUS: case HotRodConstants::UNKNOWN_VERSION_STATUS: { // If error, the body of the message just contains a message std::string msgFromServer = transport.readString(); if (msgFromServer.find("SuspectException") != std::string::npos || msgFromServer.find("SuspectedException") != std::string::npos) { // Handle both Infinispan's and JGroups' suspicions // TODO: This will be better handled with its own status id in version 2 of protocol throw RemoteNodeSuspectException(msgFromServer, params.messageId, status); } else { throw HotRodClientException(msgFromServer); //, params.messageId, status); } } default: { throw InternalException("Unknown status: " + status); } } } catch (const Exception &) { // Some operations require invalidating the transport switch (status) { case HotRodConstants::INVALID_MAGIC_OR_MESSAGE_ID_STATUS: case HotRodConstants::REQUEST_PARSING_ERROR_STATUS: case HotRodConstants::UNKNOWN_COMMAND_STATUS: case HotRodConstants::UNKNOWN_VERSION_STATUS: { transport.invalidate(); } } throw; } }
void GlyphsSelection::AcceptKey(string_slice key, DisplayDirector* director) { int offset; if (tagEditor || key == "\t") TagSelection::AcceptKey(key, director); else if (key == "\n") { // not supported yet /***/ } else if (key == Keys::LeftArrowKey) { offset = firstGlyph.textNode->OffsetOfGlyph(firstGlyph.glyph); director->SetSelection(firstGlyph.textNode->GetSelectionAtOffset(offset)); director->ScrollToSelection(); } else if (key == Keys::RightArrowKey) { offset = lastGlyph.textNode->OffsetOfGlyph(lastGlyph.glyph) + lastGlyph.glyph->NumCharsInText(); director->SetSelection(lastGlyph.textNode->GetSelectionAtOffset(offset)); director->ScrollToSelection(); } else { String newText = key; if (key == "\b" || key == Keys::DelKey) newText = ""; ReplaceText(newText, director); #ifdef NOT_ANYMORE // set up DisplayNode* ancestor = firstGlyph.CommonAncestorWith(lastGlyph); if (ancestor == NULL) throw InternalException("GlyphsSelection::AcceptKey: No common ancestor."); bool hasFirstText = (firstGlyph.textNode->Parent() == ancestor); bool hasLastText = (lastGlyph.textNode->Parent() == ancestor); bool oneText = (firstGlyph.textNode == lastGlyph.textNode); bool hasNodes = (!oneText && (!hasFirstText || !hasLastText || firstGlyph.textNode->NextSibling() != firstGlyph.textNode)); CompositeAction* action = new CompositeAction(); action->AddAction(new RestoreGlyphsSelectionAction()); // clear out anything that's there if (oneText) { unsigned long startOffset = firstGlyph.StartOffset(); action->AddAction(new DeleteCharsAction(firstGlyph.textNode->GetText(), startOffset, lastGlyph.EndOffset() - startOffset)); } else { if (hasFirstText) { Text* firstText = firstGlyph.textNode->GetText(); unsigned long offset = firstGlyph.StartOffset(); action->AddAction(new DeleteCharsAction(firstText, offset, firstText->Length() - offset)); } if (hasLastText) { action->AddAction(new DeleteCharsAction(lastGlyph.textNode->GetText(), 0, lastGlyph.EndOffset())); } if (hasNodes) { ElementDisplayNode* ancestorDisplayNode = dynamic_cast<ElementDisplayNode*>(ancestor); if (ancestorDisplayNode == NULL) throw InternalException("GlyphsSelection::AcceptKey: ancestor isn't an element."); Element* ancestorElement = ancestorDisplayNode->GetElement(); Node* firstDeleteNode = firstGlyph.textNode->GetText(); while (firstDeleteNode->ParentNode() != ancestorElement) firstDeleteNode = firstDeleteNode->ParentNode(); if (hasFirstText) firstDeleteNode = firstDeleteNode->NextSibling(); Node* lastDeleteNode = lastGlyph.textNode->GetText(); while (lastDeleteNode->ParentNode() != ancestorElement) lastDeleteNode = lastDeleteNode->ParentNode(); if (hasLastText) lastDeleteNode = lastDeleteNode->PreviousSibling(); action->AddAction(new RemoveNodesAction(firstDeleteNode, lastDeleteNode)); } } // add in the key if (key == "\b" || key == Keys::DelKey) { // just select Text* selectText = NULL; unsigned long selectOffset = 0; if (oneText || hasFirstText) { selectText = firstGlyph.textNode->GetText(); selectOffset = firstGlyph.StartOffset(); } else if (hasLastText) { selectText = lastGlyph.textNode->GetText(); selectOffset = 0; } else { // we don't handle this yet (point selection between two Elements) /***/ } if (selectText) action->AddAction(new SelectPointAction(selectText, selectOffset)); } else { Text* destText; unsigned long destOffset; if (oneText || hasFirstText) { destText = firstGlyph.textNode->GetText(); destOffset = firstGlyph.StartOffset(); } else if (hasLastText) { destText = lastGlyph.textNode->GetText(); destOffset = 0; } else { NewTextAction* newTextAction = new NewTextAction(firstGlyph.textNode->GetText()->OwnerDocument()); action->AddAction(newTextAction); destText = newTextAction->GetText(); destOffset = 0; } action->AddAction(new AddCharsAction(key, destText, destOffset)); // this will do the selection also } // go! director->DoAction(action); #endif } }
void GlyphsSelection::ReplaceText(String newText, DisplayDirector* director) { // set up DisplayNode* ancestor = firstGlyph.CommonAncestorWith(lastGlyph); if (ancestor == NULL) throw InternalException("GlyphsSelection::AcceptKey: No common ancestor."); bool hasFirstText = (firstGlyph.textNode->Parent() == ancestor); bool hasLastText = (lastGlyph.textNode->Parent() == ancestor); bool oneText = (firstGlyph.textNode == lastGlyph.textNode); bool hasNodes = (!oneText && (!hasFirstText || !hasLastText || firstGlyph.textNode->NextSibling() != firstGlyph.textNode)); CompositeAction* action = new CompositeAction(); action->AddAction(new RestoreGlyphsSelectionAction()); // clear out anything that's there if (oneText) { unsigned long startOffset = firstGlyph.StartOffset(); action->AddAction(new DeleteCharsAction(firstGlyph.textNode->GetText(), startOffset, lastGlyph.EndOffset() - startOffset)); } else { if (hasFirstText) { Text* firstText = firstGlyph.textNode->GetText(); unsigned long offset = firstGlyph.StartOffset(); action->AddAction(new DeleteCharsAction(firstText, offset, firstText->Length() - offset)); } if (hasLastText) { action->AddAction(new DeleteCharsAction(lastGlyph.textNode->GetText(), 0, lastGlyph.EndOffset())); } if (hasNodes) { ElementDisplayNode* ancestorDisplayNode = dynamic_cast<ElementDisplayNode*>(ancestor); if (ancestorDisplayNode == NULL) throw InternalException("GlyphsSelection::AcceptKey: ancestor isn't an element."); Element* ancestorElement = ancestorDisplayNode->GetElement(); Node* firstDeleteNode = firstGlyph.textNode->GetText(); while (firstDeleteNode->ParentNode() != ancestorElement) firstDeleteNode = firstDeleteNode->ParentNode(); if (hasFirstText) firstDeleteNode = firstDeleteNode->NextSibling(); Node* lastDeleteNode = lastGlyph.textNode->GetText(); while (lastDeleteNode->ParentNode() != ancestorElement) lastDeleteNode = lastDeleteNode->ParentNode(); if (hasLastText) lastDeleteNode = lastDeleteNode->PreviousSibling(); action->AddAction(new RemoveNodesAction(firstDeleteNode, lastDeleteNode)); } } // if we're replacing it with nothing, just select the point if (newText.empty()) { // just select Text* selectText = NULL; unsigned long selectOffset = 0; if (oneText || hasFirstText) { selectText = firstGlyph.textNode->GetText(); selectOffset = firstGlyph.StartOffset(); } else if (hasLastText) { selectText = lastGlyph.textNode->GetText(); selectOffset = 0; } else { // we don't handle this yet (point selection between two Elements) /***/ } if (selectText) action->AddAction(new SelectPointAction(selectText, selectOffset)); } // add in the new text else { Text* destText; unsigned long destOffset; if (oneText || hasFirstText) { destText = firstGlyph.textNode->GetText(); destOffset = firstGlyph.StartOffset(); } else if (hasLastText) { destText = lastGlyph.textNode->GetText(); destOffset = 0; } else { NewTextAction* newTextAction = new NewTextAction(firstGlyph.textNode->GetText()->OwnerDocument()); action->AddAction(newTextAction); destText = newTextAction->GetText(); destOffset = 0; } action->AddAction(new AddCharsAction(newText, destText, destOffset)); // this will do the selection also } // do it director->DoAction(action); }
String GlyphsSelection::GetXMLCopy() { // handle single-text case bool singleText = (firstGlyph.textNode == lastGlyph.textNode); if (singleText) { int startOffset = firstGlyph.StartOffset(); int endOffset = lastGlyph.EndOffset(); return firstGlyph.textNode->GetText()->SubstringData(startOffset, endOffset - startOffset); } // get info about the structure DisplayNode* ancestor = firstGlyph.CommonAncestorWith(lastGlyph); bool startsWithText = (firstGlyph.textNode->Parent() == ancestor); bool endsWithText = (lastGlyph.textNode->Parent() == ancestor); // find out where the first and last embedded elements are // first ElementDisplayNode* firstElementDisplayNode = NULL; if (!startsWithText) { // it's the element the first glyph is in DisplayNode* firstElementNode = firstGlyph.textNode; while (firstElementNode) { if (firstElementNode->Parent() == ancestor) break; firstElementNode = firstElementNode->Parent(); } firstElementDisplayNode = dynamic_cast<ElementDisplayNode*>(firstElementNode); } else { firstElementDisplayNode = dynamic_cast<ElementDisplayNode*>(firstGlyph.textNode->NextSibling()); } if (firstElementDisplayNode == NULL) throw InternalException("GlyphsSelection::GetXMLCopy: Couldn't find firstElementNode."); Node* firstElement = firstElementDisplayNode->GetElement(); // last ElementDisplayNode* lastElementDisplayNode = NULL; if (!endsWithText) { // it's the element the last glyph is in DisplayNode* lastElementNode = lastGlyph.textNode; while (lastElementNode) { if (lastElementNode->Parent() == ancestor) break; lastElementNode = lastElementNode->Parent(); } lastElementDisplayNode = dynamic_cast<ElementDisplayNode*>(lastElementNode); } else { lastElementDisplayNode = dynamic_cast<ElementDisplayNode*>(lastGlyph.textNode->PreviousSibling()); } if (lastElementDisplayNode == NULL) throw InternalException("GlyphsSelection::GetXMLCopy: Couldn't find lastElementNode."); Node* lastElement = lastElementDisplayNode->GetElement(); // write the selection XMLStringWriter writer(NULL); if (startsWithText) { Text* startText = firstGlyph.textNode->GetText(); int startOffset = firstGlyph.StartOffset(); String startData = startText->SubstringData(startOffset, startText->Length() - startOffset); writer.AppendString(startData); } for (Node* node = firstElement; ; node = node->NextSibling()) { writer.AppendNode(node); if (node == lastElement) break; } if (endsWithText) { Text* endText = lastGlyph.textNode->GetText(); int endOffset = lastGlyph.EndOffset(); String endData = endText->SubstringData(0, endOffset); writer.AppendString(endData); } return writer.GetString(); }