void Pasteboard::writeSelection(Range* selectedRange, bool canSmartCopyOrDelete, Frame* frame)
{
GtkClipboard* clipboard = m_helper->getClipboard(frame);
DataObjectGtk* dataObject = DataObjectGtk::forClipboard(clipboard);
dataObject->setText(frame->selectedText());
dataObject->setMarkup(createMarkup(selectedRange, 0, AnnotateForInterchange, false, AbsoluteURLs));
m_helper->writeClipboardContents(clipboard);
}
void Pasteboard::writeSelection(Range* selectedRange, bool, Frame* frame)
{
WTF::String text = frame->editor()->selectedText();
WTF::String html = createMarkup(selectedRange, 0, AnnotateForInterchange);
WTF::String url = frame->document()->url().string();
BlackBerry::Platform::Clipboard::write(text, html, url);
}
void InspectorBackend::copyNode(long nodeId)
{
Node* node = nodeForId(nodeId);
if (!node)
return;
String markup = createMarkup(node);
Pasteboard::generalPasteboard()->writePlainText(markup);
}
String XMLSerializer::serializeToString(Node* node, ExceptionCode& ec)
{
if (!node) {
ec = TypeError;
return String();
}
return createMarkup(*node, IncludeNode, 0, DoNotResolveURLs, 0, XMLFragmentSerialization);
}
String XMLSerializer::serializeToString(Node* node, ExceptionState& exceptionState)
{
if (!node) {
exceptionState.throwDOMException(TypeError, "Invalid node value.");
return String();
}
return createMarkup(node);
}
void Editor::writeSelectionToPasteboard(Pasteboard& pasteboard)
{
PasteboardWebContent pasteboardContent;
pasteboardContent.canSmartCopyOrDelete = canSmartCopyOrDelete();
pasteboardContent.text = selectedTextForDataTransfer();
pasteboardContent.markup = createMarkup(*selectedRange(), nullptr, AnnotateForInterchange, false, ResolveNonLocalURLs);
pasteboardContent.callback = nullptr;
pasteboard.write(pasteboardContent);
}
void Pasteboard::writeSelection(Range& selectedRange, bool canSmartCopyOrDelete, Frame& frame, ShouldSerializeSelectedTextForClipboard shouldSerializeSelectedTextForClipboard)
{
m_dataObject->clearAll();
m_dataObject->setText(shouldSerializeSelectedTextForClipboard == IncludeImageAltTextForClipboard ? frame.editor().selectedTextForClipboard() : frame.editor().selectedText());
m_dataObject->setMarkup(createMarkup(selectedRange, 0, AnnotateForInterchange, false, ResolveNonLocalURLs));
if (m_gtkClipboard)
PasteboardHelper::defaultPasteboardHelper()->writeClipboardContents(m_gtkClipboard, canSmartCopyOrDelete ? PasteboardHelper::IncludeSmartPaste : PasteboardHelper::DoNotIncludeSmartPaste);
}
void Pasteboard::writeSelection(Range* selectedRange, bool canSmartCopyOrDelete, Frame* frame)
{
PasteboardHelper* helper = PasteboardHelper::defaultPasteboardHelper();
GtkClipboard* clipboard = helper->getClipboard(frame);
DataObjectGtk* dataObject = DataObjectGtk::forClipboard(clipboard);
dataObject->setText(frame->editor()->selectedText());
dataObject->setMarkup(createMarkup(selectedRange, 0, AnnotateForInterchange, false, ResolveNonLocalURLs));
helper->writeClipboardContents(clipboard, canSmartCopyOrDelete ? PasteboardHelper::IncludeSmartPaste : PasteboardHelper::DoNotIncludeSmartPaste);
}
void Pasteboard::writeSelection(Range* selectedRange, bool canSmartCopyOrDelete, Frame* frame)
{
if (wxTheClipboard->Open()) {
#if wxCHECK_VERSION(2, 9, 4)
wxTheClipboard->SetData(new wxHTMLDataObject(createMarkup(selectedRange, 0, AnnotateForInterchange)));
#endif
wxTheClipboard->SetData(new wxTextDataObject(frame->editor()->selectedText()));
wxTheClipboard->Close();
}
}
void ClipboardGtk::writeRange(Range* range, Frame* frame)
{
ASSERT(range);
m_dataObject->setText(frame->selectedText());
m_dataObject->setMarkup(createMarkup(range, 0, AnnotateForInterchange));
if (m_clipboard)
m_helper->writeClipboardContents(m_clipboard);
}
void Pasteboard::writeSelection(Range* selectedRange, bool canSmartCopyOrDelete, Frame* frame)
{
LOGD("writeSelection");
String html = createMarkup(selectedRange, 0 , AnnotateForInterchange , false );
String dataFormat = "HTML";
ExceptionCode ec = 0;
android::setDataToClipBoard(dataFormat , html);
}
void ClipboardGtk::writeRange(Range* range, Frame* frame)
{
ASSERT(range);
m_dataObject->setText(frame->editor()->selectedText());
m_dataObject->setMarkup(createMarkup(range, 0, AnnotateForInterchange, false, ResolveNonLocalURLs));
if (m_clipboard)
PasteboardHelper::defaultPasteboardHelper()->writeClipboardContents(m_clipboard);
}
void Pasteboard::writeSelection(Range* selectedRange, bool canSmartCopyOrDelete, Frame* frame)
{
GtkClipboard* clipboard = PasteboardHelper::clipboardForFrame(frame);
ASSERT(clipboard);
DataObjectGtk* dataObject = DataObjectGtk::forClipboard(clipboard);
ASSERT(dataObject);
dataObject->setText(frame->selectedText());
dataObject->setMarkup(createMarkup(selectedRange, 0, AnnotateForInterchange));
PasteboardHelper::helper()->writeClipboardContents(clipboard);
}
void DataTransfer::declareAndWriteDragImage(Element* element, const KURL& url, const String& title)
{
if (!m_dataObject)
return;
m_dataObject->setURLAndTitle(url, title);
// Write the bytes in the image to the file format.
writeImageToDataObject(m_dataObject.get(), element, url);
// Put img tag on the clipboard referencing the image
m_dataObject->setData(mimeTypeTextHTML, createMarkup(element, IncludeNode, ResolveAllURLs));
}
static xsltStylesheetPtr xsltStylesheetPointer(RefPtr<XSLStyleSheet>& cachedStylesheet, Node* stylesheetRootNode)
{
if (!cachedStylesheet && stylesheetRootNode) {
cachedStylesheet = XSLStyleSheet::create(stylesheetRootNode->parent() ? stylesheetRootNode->parent() : stylesheetRootNode,
stylesheetRootNode->document()->url().string());
cachedStylesheet->parseString(createMarkup(stylesheetRootNode));
}
if (!cachedStylesheet || !cachedStylesheet->document())
return 0;
return cachedStylesheet->compileStyleSheet();
}
void Editor::writeImageToPasteboard(Pasteboard& pasteboard, Element& imageElement, const URL&, const String& title)
{
PasteboardImage pasteboardImage;
if (!getImageForElement(imageElement, pasteboardImage.image))
return;
ASSERT(pasteboardImage.image);
pasteboardImage.url.url = imageElement.document().completeURL(stripLeadingAndTrailingHTMLSpaces(elementURL(imageElement)));
pasteboardImage.url.title = title;
pasteboardImage.url.markup = createMarkup(imageElement, IncludeNode, nullptr, ResolveAllURLs);
pasteboard.write(pasteboardImage);
}
void Pasteboard::writeSelection(Range* selectedRange, bool canSmartCopyOrDelete, Frame* frame)
{
GtkClipboard* clipboard = m_helper->getClipboard(frame);
gchar* text = g_strdup(frame->selectedText().utf8().data());
gchar* markup = g_strdup(createMarkup(selectedRange, 0, AnnotateForInterchange).utf8().data());
PasteboardSelectionData* data = new PasteboardSelectionData(text, markup);
gint n_targets;
GtkTargetEntry* targets = gtk_target_table_new_from_list(m_helper->getCopyTargetList(frame), &n_targets);
gtk_clipboard_set_with_data(clipboard, targets, n_targets,
clipboard_get_contents_cb, clipboard_clear_contents_cb, data);
gtk_target_table_free(targets, n_targets);
}
void Pasteboard::writeSelection(Range* selectedRange, bool canSmartCopyOrDelete, Frame* frame)
{
String html = createMarkup(selectedRange, 0, AnnotateForInterchange, false, ResolveNonLocalURLs);
ExceptionCode ec = 0;
KURL url = selectedRange->startContainer(ec)->document()->url();
String plainText = frame->editor()->selectedText();
#if OS(WINDOWS)
replaceNewlinesWithWindowsStyleNewlines(plainText);
#endif
replaceNBSPWithSpace(plainText);
PlatformSupport::clipboardWriteSelection(html, url, plainText, canSmartCopyOrDelete);
}
void Pasteboard::writeSelection(Range* selectedRange, bool canSmartCopyOrDelete, Frame* frame)
{
String html = createMarkup(selectedRange, 0, AnnotateForInterchange);
ExceptionCode ec = 0;
KURL url = selectedRange->startContainer(ec)->document()->url();
String plainText = frame->selectedText();
#if PLATFORM(WIN_OS)
replaceNewlinesWithWindowsStyleNewlines(plainText);
#endif
replaceNBSPWithSpace(plainText);
ChromiumBridge::clipboardWriteSelection(html, url, plainText, canSmartCopyOrDelete);
}
void DragController::declareAndWriteDragImage(Clipboard* clipboard, Element* element, const KURL& url, const String& label)
{
Pasteboard& pasteboard = clipboard->pasteboard();
// FIXME: Do we really need this check?
if (!pasteboard.writableDataObject())
return;
// Order is important here for Explorer's sake
pasteboard.writeURLToWritableDataObject(url, label);
pasteboard.writeImageToDataObject(element, url);
pasteboard.writeMarkup(createMarkup(element, IncludeNode, 0, ResolveAllURLs));
}
void DataTransfer::writeURL(Node* node, const KURL& url, const String& title) {
if (!m_dataObject)
return;
ASSERT(!url.isEmpty());
m_dataObject->setURLAndTitle(url, title);
// The URL can also be used as plain text.
m_dataObject->setData(mimeTypeTextPlain, url.getString());
// The URL can also be used as an HTML fragment.
m_dataObject->setHTMLAndBaseURL(
createMarkup(node, IncludeNode, ResolveAllURLs), url);
}
wxString wxWebFrame::GetPageSource()
{
if (m_impl->frame) {
if (m_impl->frame->view() && m_impl->frame->view()->layoutPending())
m_impl->frame->view()->layout();
WebCore::Document* doc = m_impl->frame->document();
if (doc) {
wxString source = createMarkup(doc);
return source;
}
}
return wxEmptyString;
}
static inline xmlDocPtr xmlDocPtrFromNode(Node* sourceNode, bool& shouldDelete)
{
RefPtr<Document> ownerDocument = sourceNode->document();
bool sourceIsDocument = (sourceNode == ownerDocument.get());
xmlDocPtr sourceDoc = 0;
if (sourceIsDocument && ownerDocument->transformSource())
sourceDoc = (xmlDocPtr)ownerDocument->transformSource()->platformSource();
if (!sourceDoc) {
sourceDoc = (xmlDocPtr)xmlDocPtrForString(ownerDocument->docLoader(), createMarkup(sourceNode),
sourceIsDocument ? ownerDocument->url().string() : String());
shouldDelete = sourceDoc;
}
return sourceDoc;
}
void Clipboard::writeRange(Range* selectedRange, LocalFrame* frame)
{
ASSERT(selectedRange);
if (!m_dataObject)
return;
m_dataObject->setHTMLAndBaseURL(createMarkup(selectedRange, 0, AnnotateForInterchange, false, ResolveNonLocalURLs), frame->document()->url());
String str = frame->selectedTextForClipboard();
#if OS(WIN)
replaceNewlinesWithWindowsStyleNewlines(str);
#endif
replaceNBSPWithSpace(str);
m_dataObject->setData(mimeTypeTextPlain, str);
}
void ClipboardGtk::declareAndWriteDragImage(Element* element, const KURL& url, const String& label, Frame* frame)
{
m_dataObject->setURL(url, label);
m_dataObject->setMarkup(createMarkup(element, IncludeNode, 0, ResolveAllURLs));
CachedImage* image = getCachedImage(element);
if (!image || !image->isLoaded())
return;
GRefPtr<GdkPixbuf> pixbuf = adoptGRef(image->imageForRenderer(element->renderer())->getGdkPixbuf());
if (!pixbuf)
return;
m_dataObject->setImage(pixbuf.get());
}
static void clipboard_get_contents_cb(GtkClipboard* clipboard, GtkSelectionData* selection_data, guint info, gpointer data)
{
WebKitWebView* webView = reinterpret_cast<WebKitWebView*>(data);
Frame* frame = core(webView)->focusController()->focusedOrMainFrame();
PassRefPtr<Range> selectedRange = frame->selection()->toNormalizedRange();
if (static_cast<gint>(info) == WEBKIT_WEB_VIEW_TARGET_INFO_HTML) {
String markup = createMarkup(selectedRange.get(), 0, AnnotateForInterchange);
gtk_selection_data_set(selection_data, selection_data->target, 8,
reinterpret_cast<const guchar*>(markup.utf8().data()), markup.utf8().length());
} else {
String text = selectedRange->text();
gtk_selection_data_set_text(selection_data, text.utf8().data(), text.utf8().length());
}
}
void ClipboardQt::writeRange(Range* range, Frame* frame)
{
ASSERT(range);
ASSERT(frame);
if (!m_writableData)
m_writableData = new QMimeData;
QString text = frame->editor()->selectedText();
text.replace(QChar(0xa0), QLatin1Char(' '));
m_writableData->setText(text);
m_writableData->setHtml(createMarkup(range, 0, AnnotateForInterchange, false, AbsoluteURLs));
#ifndef QT_NO_CLIPBOARD
if (!isForDragging())
QApplication::clipboard()->setMimeData(m_writableData);
#endif
}
void Pasteboard::writeSelection(Range* selectedRange, bool canSmartCopyOrDelete, Frame* frame)
{
QMimeData* md = new QMimeData;
QString text = frame->editor()->selectedText();
text.replace(QChar(0xa0), QLatin1Char(' '));
md->setText(text);
md->setHtml(createMarkup(selectedRange, 0, AnnotateForInterchange, false, AbsoluteURLs));
#ifndef QT_NO_CLIPBOARD
QApplication::clipboard()->setMimeData(md, m_selectionMode ?
QClipboard::Selection : QClipboard::Clipboard);
#endif
if (canSmartCopyOrDelete)
md->setData("application/vnd.qtwebkit.smartpaste", QByteArray());
}
static xsltStylesheetPtr xsltStylesheetPointer(RefPtr<XSLStyleSheet>& cachedStylesheet, Node* stylesheetRootNode)
{
if (!cachedStylesheet && stylesheetRootNode) {
cachedStylesheet = XSLStyleSheet::createForXSLTProcessor(stylesheetRootNode->parentNode() ? stylesheetRootNode->parentNode() : stylesheetRootNode,
stylesheetRootNode->document()->url().string(),
stylesheetRootNode->document()->url()); // FIXME: Should we use baseURL here?
// According to Mozilla documentation, the node must be a Document node, an xsl:stylesheet or xsl:transform element.
// But we just use text content regardless of node type.
cachedStylesheet->parseString(createMarkup(stylesheetRootNode));
}
if (!cachedStylesheet || !cachedStylesheet->document())
return 0;
return cachedStylesheet->compileStyleSheet();
}
String XMLSerializer::serializeToString(Node* node, ExceptionCode& ec)
{
if (!node)
return String();
if (!node->document()) {
// Due to the fact that DocumentType nodes are created by the DOMImplementation
// and not the Document, it is possible for it to not have a Document associated
// with it. It should be the only type of node where this is possible.
ASSERT(node->nodeType() == Node::DOCUMENT_TYPE_NODE);
ec = INVALID_ACCESS_ERR;
return String();
}
return createMarkup(node);
}
