// Copyright 2014 PDFium Authors. All rights reserved.
|
// Use of this source code is governed by a BSD-style license that can be
|
// found in the LICENSE file.
|
|
// Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
|
|
#include "public/fpdf_text.h"
|
|
#include <algorithm>
|
#include <vector>
|
|
#include "core/fpdfapi/page/cpdf_page.h"
|
#include "core/fpdfdoc/cpdf_viewerpreferences.h"
|
#include "core/fpdftext/cpdf_linkextract.h"
|
#include "core/fpdftext/cpdf_textpage.h"
|
#include "core/fpdftext/cpdf_textpagefind.h"
|
#include "fpdfsdk/fsdk_define.h"
|
#include "third_party/base/numerics/safe_conversions.h"
|
#include "third_party/base/stl_util.h"
|
|
#ifdef PDF_ENABLE_XFA
|
#include "fpdfsdk/fpdfxfa/cpdfxfa_context.h"
|
#include "fpdfsdk/fpdfxfa/cpdfxfa_page.h"
|
#endif // PDF_ENABLE_XFA
|
|
#ifdef _WIN32
|
#include <tchar.h>
|
#endif
|
|
namespace {
|
|
constexpr size_t kBytesPerCharacter = sizeof(unsigned short);
|
|
CPDF_TextPage* CPDFTextPageFromFPDFTextPage(FPDF_TEXTPAGE text_page) {
|
return static_cast<CPDF_TextPage*>(text_page);
|
}
|
|
CPDF_TextPageFind* CPDFTextPageFindFromFPDFSchHandle(FPDF_SCHHANDLE handle) {
|
return static_cast<CPDF_TextPageFind*>(handle);
|
}
|
|
CPDF_LinkExtract* CPDFLinkExtractFromFPDFPageLink(FPDF_PAGELINK link) {
|
return static_cast<CPDF_LinkExtract*>(link);
|
}
|
|
} // namespace
|
|
FPDF_EXPORT FPDF_TEXTPAGE FPDF_CALLCONV FPDFText_LoadPage(FPDF_PAGE page) {
|
CPDF_Page* pPDFPage = CPDFPageFromFPDFPage(page);
|
if (!pPDFPage)
|
return nullptr;
|
|
#ifdef PDF_ENABLE_XFA
|
CPDFXFA_Page* pPage = (CPDFXFA_Page*)page;
|
CPDFXFA_Context* pContext = pPage->GetContext();
|
CPDF_ViewerPreferences viewRef(pContext->GetPDFDoc());
|
#else // PDF_ENABLE_XFA
|
CPDF_ViewerPreferences viewRef(pPDFPage->m_pDocument.Get());
|
#endif // PDF_ENABLE_XFA
|
|
CPDF_TextPage* textpage = new CPDF_TextPage(
|
pPDFPage, viewRef.IsDirectionR2L() ? FPDFText_Direction::Right
|
: FPDFText_Direction::Left);
|
textpage->ParseTextPage();
|
return textpage;
|
}
|
|
FPDF_EXPORT void FPDF_CALLCONV FPDFText_ClosePage(FPDF_TEXTPAGE text_page) {
|
delete CPDFTextPageFromFPDFTextPage(text_page);
|
}
|
|
FPDF_EXPORT int FPDF_CALLCONV FPDFText_CountChars(FPDF_TEXTPAGE text_page) {
|
if (!text_page)
|
return -1;
|
|
CPDF_TextPage* textpage = CPDFTextPageFromFPDFTextPage(text_page);
|
return textpage->CountChars();
|
}
|
|
FPDF_EXPORT unsigned int FPDF_CALLCONV
|
FPDFText_GetUnicode(FPDF_TEXTPAGE text_page, int index) {
|
if (!text_page)
|
return 0;
|
|
CPDF_TextPage* textpage = CPDFTextPageFromFPDFTextPage(text_page);
|
if (index < 0 || index >= textpage->CountChars())
|
return 0;
|
|
FPDF_CHAR_INFO charinfo;
|
textpage->GetCharInfo(index, &charinfo);
|
return charinfo.m_Unicode;
|
}
|
|
FPDF_EXPORT double FPDF_CALLCONV FPDFText_GetFontSize(FPDF_TEXTPAGE text_page,
|
int index) {
|
if (!text_page)
|
return 0;
|
CPDF_TextPage* textpage = CPDFTextPageFromFPDFTextPage(text_page);
|
|
if (index < 0 || index >= textpage->CountChars())
|
return 0;
|
|
FPDF_CHAR_INFO charinfo;
|
textpage->GetCharInfo(index, &charinfo);
|
return charinfo.m_FontSize;
|
}
|
|
FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV FPDFText_GetCharBox(FPDF_TEXTPAGE text_page,
|
int index,
|
double* left,
|
double* right,
|
double* bottom,
|
double* top) {
|
if (!text_page || index < 0)
|
return false;
|
|
CPDF_TextPage* textpage = CPDFTextPageFromFPDFTextPage(text_page);
|
if (index >= textpage->CountChars())
|
return false;
|
|
FPDF_CHAR_INFO charinfo;
|
textpage->GetCharInfo(index, &charinfo);
|
*left = charinfo.m_CharBox.left;
|
*right = charinfo.m_CharBox.right;
|
*bottom = charinfo.m_CharBox.bottom;
|
*top = charinfo.m_CharBox.top;
|
return true;
|
}
|
|
FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV
|
FPDFText_GetCharOrigin(FPDF_TEXTPAGE text_page,
|
int index,
|
double* x,
|
double* y) {
|
if (!text_page)
|
return false;
|
CPDF_TextPage* textpage = CPDFTextPageFromFPDFTextPage(text_page);
|
|
if (index < 0 || index >= textpage->CountChars())
|
return false;
|
FPDF_CHAR_INFO charinfo;
|
textpage->GetCharInfo(index, &charinfo);
|
*x = charinfo.m_Origin.x;
|
*y = charinfo.m_Origin.y;
|
return true;
|
}
|
|
// select
|
FPDF_EXPORT int FPDF_CALLCONV
|
FPDFText_GetCharIndexAtPos(FPDF_TEXTPAGE text_page,
|
double x,
|
double y,
|
double xTolerance,
|
double yTolerance) {
|
if (!text_page)
|
return -3;
|
|
CPDF_TextPage* textpage = CPDFTextPageFromFPDFTextPage(text_page);
|
return textpage->GetIndexAtPos(
|
CFX_PointF(static_cast<float>(x), static_cast<float>(y)),
|
CFX_SizeF(static_cast<float>(xTolerance),
|
static_cast<float>(yTolerance)));
|
}
|
|
FPDF_EXPORT int FPDF_CALLCONV FPDFText_GetText(FPDF_TEXTPAGE page,
|
int char_start,
|
int char_count,
|
unsigned short* result) {
|
if (!page || char_start < 0 || char_count < 0 || !result)
|
return 0;
|
|
CPDF_TextPage* textpage = CPDFTextPageFromFPDFTextPage(page);
|
int char_available = textpage->CountChars() - char_start;
|
if (char_available <= 0)
|
return 0;
|
|
char_count = std::min(char_count, char_available);
|
if (char_count == 0) {
|
// Writing out "", which has a character count of 1 due to the NUL.
|
*result = '\0';
|
return 1;
|
}
|
|
WideString str = textpage->GetPageText(char_start, char_count);
|
|
if (str.GetLength() > static_cast<size_t>(char_count))
|
str = str.Left(static_cast<size_t>(char_count));
|
|
// UFT16LE_Encode doesn't handle surrogate pairs properly, so it is expected
|
// the number of items to stay the same.
|
ByteString byte_str = str.UTF16LE_Encode();
|
size_t byte_str_len = byte_str.GetLength();
|
int ret_count = byte_str_len / kBytesPerCharacter;
|
|
ASSERT(ret_count <= char_count + 1); // +1 to account for the NUL terminator.
|
memcpy(result, byte_str.GetBuffer(byte_str_len), byte_str_len);
|
return ret_count;
|
}
|
|
FPDF_EXPORT int FPDF_CALLCONV FPDFText_CountRects(FPDF_TEXTPAGE text_page,
|
int start,
|
int count) {
|
if (!text_page)
|
return 0;
|
|
CPDF_TextPage* textpage = CPDFTextPageFromFPDFTextPage(text_page);
|
return textpage->CountRects(start, count);
|
}
|
|
FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV FPDFText_GetRect(FPDF_TEXTPAGE text_page,
|
int rect_index,
|
double* left,
|
double* top,
|
double* right,
|
double* bottom) {
|
if (!text_page)
|
return false;
|
|
CPDF_TextPage* textpage = CPDFTextPageFromFPDFTextPage(text_page);
|
CFX_FloatRect rect;
|
bool result = textpage->GetRect(rect_index, &rect);
|
|
*left = rect.left;
|
*top = rect.top;
|
*right = rect.right;
|
*bottom = rect.bottom;
|
return result;
|
}
|
|
FPDF_EXPORT int FPDF_CALLCONV FPDFText_GetBoundedText(FPDF_TEXTPAGE text_page,
|
double left,
|
double top,
|
double right,
|
double bottom,
|
unsigned short* buffer,
|
int buflen) {
|
if (!text_page)
|
return 0;
|
|
CPDF_TextPage* textpage = CPDFTextPageFromFPDFTextPage(text_page);
|
CFX_FloatRect rect((float)left, (float)bottom, (float)right, (float)top);
|
WideString str = textpage->GetTextByRect(rect);
|
|
if (buflen <= 0 || !buffer)
|
return str.GetLength();
|
|
ByteString cbUTF16Str = str.UTF16LE_Encode();
|
int len = cbUTF16Str.GetLength() / sizeof(unsigned short);
|
int size = buflen > len ? len : buflen;
|
memcpy(buffer, cbUTF16Str.GetBuffer(size * sizeof(unsigned short)),
|
size * sizeof(unsigned short));
|
cbUTF16Str.ReleaseBuffer(size * sizeof(unsigned short));
|
|
return size;
|
}
|
|
// Search
|
// -1 for end
|
FPDF_EXPORT FPDF_SCHHANDLE FPDF_CALLCONV
|
FPDFText_FindStart(FPDF_TEXTPAGE text_page,
|
FPDF_WIDESTRING findwhat,
|
unsigned long flags,
|
int start_index) {
|
if (!text_page)
|
return nullptr;
|
|
CPDF_TextPageFind* textpageFind =
|
new CPDF_TextPageFind(CPDFTextPageFromFPDFTextPage(text_page));
|
size_t len = WideString::WStringLength(findwhat);
|
textpageFind->FindFirst(
|
WideString::FromUTF16LE(findwhat, len), flags,
|
start_index >= 0 ? Optional<size_t>(start_index) : Optional<size_t>());
|
return textpageFind;
|
}
|
|
FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV FPDFText_FindNext(FPDF_SCHHANDLE handle) {
|
if (!handle)
|
return false;
|
|
CPDF_TextPageFind* textpageFind = CPDFTextPageFindFromFPDFSchHandle(handle);
|
return textpageFind->FindNext();
|
}
|
|
FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV FPDFText_FindPrev(FPDF_SCHHANDLE handle) {
|
if (!handle)
|
return false;
|
|
CPDF_TextPageFind* textpageFind = CPDFTextPageFindFromFPDFSchHandle(handle);
|
return textpageFind->FindPrev();
|
}
|
|
FPDF_EXPORT int FPDF_CALLCONV
|
FPDFText_GetSchResultIndex(FPDF_SCHHANDLE handle) {
|
if (!handle)
|
return 0;
|
|
CPDF_TextPageFind* textpageFind = CPDFTextPageFindFromFPDFSchHandle(handle);
|
return textpageFind->GetCurOrder();
|
}
|
|
FPDF_EXPORT int FPDF_CALLCONV FPDFText_GetSchCount(FPDF_SCHHANDLE handle) {
|
if (!handle)
|
return 0;
|
|
CPDF_TextPageFind* textpageFind = CPDFTextPageFindFromFPDFSchHandle(handle);
|
return textpageFind->GetMatchedCount();
|
}
|
|
FPDF_EXPORT void FPDF_CALLCONV FPDFText_FindClose(FPDF_SCHHANDLE handle) {
|
if (!handle)
|
return;
|
|
CPDF_TextPageFind* textpageFind = CPDFTextPageFindFromFPDFSchHandle(handle);
|
delete textpageFind;
|
handle = nullptr;
|
}
|
|
// web link
|
FPDF_EXPORT FPDF_PAGELINK FPDF_CALLCONV
|
FPDFLink_LoadWebLinks(FPDF_TEXTPAGE text_page) {
|
if (!text_page)
|
return nullptr;
|
|
CPDF_LinkExtract* pageLink =
|
new CPDF_LinkExtract(CPDFTextPageFromFPDFTextPage(text_page));
|
pageLink->ExtractLinks();
|
return pageLink;
|
}
|
|
FPDF_EXPORT int FPDF_CALLCONV FPDFLink_CountWebLinks(FPDF_PAGELINK link_page) {
|
if (!link_page)
|
return 0;
|
|
CPDF_LinkExtract* pageLink = CPDFLinkExtractFromFPDFPageLink(link_page);
|
return pdfium::base::checked_cast<int>(pageLink->CountLinks());
|
}
|
|
FPDF_EXPORT int FPDF_CALLCONV FPDFLink_GetURL(FPDF_PAGELINK link_page,
|
int link_index,
|
unsigned short* buffer,
|
int buflen) {
|
WideString wsUrl(L"");
|
if (link_page && link_index >= 0) {
|
CPDF_LinkExtract* pageLink = CPDFLinkExtractFromFPDFPageLink(link_page);
|
wsUrl = pageLink->GetURL(link_index);
|
}
|
ByteString cbUTF16URL = wsUrl.UTF16LE_Encode();
|
int required = cbUTF16URL.GetLength() / sizeof(unsigned short);
|
if (!buffer || buflen <= 0)
|
return required;
|
|
int size = std::min(required, buflen);
|
if (size > 0) {
|
int buf_size = size * sizeof(unsigned short);
|
memcpy(buffer, cbUTF16URL.GetBuffer(buf_size), buf_size);
|
}
|
return size;
|
}
|
|
FPDF_EXPORT int FPDF_CALLCONV FPDFLink_CountRects(FPDF_PAGELINK link_page,
|
int link_index) {
|
if (!link_page || link_index < 0)
|
return 0;
|
|
CPDF_LinkExtract* pageLink = CPDFLinkExtractFromFPDFPageLink(link_page);
|
return pdfium::CollectionSize<int>(pageLink->GetRects(link_index));
|
}
|
|
FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV FPDFLink_GetRect(FPDF_PAGELINK link_page,
|
int link_index,
|
int rect_index,
|
double* left,
|
double* top,
|
double* right,
|
double* bottom) {
|
if (!link_page || link_index < 0 || rect_index < 0)
|
return false;
|
|
CPDF_LinkExtract* pageLink = CPDFLinkExtractFromFPDFPageLink(link_page);
|
std::vector<CFX_FloatRect> rectArray = pageLink->GetRects(link_index);
|
if (rect_index >= pdfium::CollectionSize<int>(rectArray))
|
return false;
|
|
*left = rectArray[rect_index].left;
|
*right = rectArray[rect_index].right;
|
*top = rectArray[rect_index].top;
|
*bottom = rectArray[rect_index].bottom;
|
return true;
|
}
|
|
FPDF_EXPORT void FPDF_CALLCONV FPDFLink_CloseWebLinks(FPDF_PAGELINK link_page) {
|
delete CPDFLinkExtractFromFPDFPageLink(link_page);
|
}
|
