/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4; fill-column: 100 -*- */ /* * This file is part of the LibreOffice project. * * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ #include #include #include #include #include #include #ifdef IOS #include #include #include #include #include #import #import #include #endif #ifdef LINUX #include #endif #ifdef ANDROID #include #endif #ifdef EMSCRIPTEN #include #endif #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #ifdef IOS #include #endif #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #ifdef IOS #include #endif #include #include #include #include #ifdef _WIN32 #include #endif #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include // Needed for getUndoManager() #include #include #include #include #include #include #include #include "../app/cmdlineargs.hxx" // We also need to hackily be able to start the main libreoffice thread: #include "../app/sofficemain.h" #include "../app/officeipcthread.hxx" #include #include "lokinteractionhandler.hxx" #include "lokclipboard.hxx" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include using namespace css; using namespace vcl; using namespace desktop; using namespace utl; static LibLibreOffice_Impl *gImpl = nullptr; static bool lok_preinit_2_called = false; static std::weak_ptr< LibreOfficeKitClass > gOfficeClass; static std::weak_ptr< LibreOfficeKitDocumentClass > gDocumentClass; static void SetLastExceptionMsg(const OUString& s = OUString()) { SAL_WARN_IF(!s.isEmpty(), "lok", "lok exception '" + s + "'"); if (gImpl) gImpl->maLastExceptionMsg = s; } namespace { struct ExtensionMap { const char *extn; const char *filterName; }; class TraceEventDumper : public AutoTimer { static const int dumpTimeoutMS = 5000; public: TraceEventDumper() : AutoTimer( "Trace Event dumper" ) { SetTimeout(dumpTimeoutMS); Start(); } virtual void Invoke() override { flushRecordings(); } static void flushRecordings() { const css::uno::Sequence aEvents = comphelper::TraceEvent::getRecordingAndClear(); OStringBuffer aOutput; for (const auto &s : aEvents) { aOutput.append(OUStringToOString(s, RTL_TEXTENCODING_UTF8) + "\n"); } if (aOutput.getLength() > 0) { OString aChunk = aOutput.makeStringAndClear(); if (gImpl && gImpl->mpCallback) gImpl->mpCallback(LOK_CALLBACK_PROFILE_FRAME, aChunk.getStr(), gImpl->mpCallbackData); } } }; } // unnamed namespace static TraceEventDumper *traceEventDumper = nullptr; const ExtensionMap aWriterExtensionMap[] = { { "doc", "MS Word 97" }, { "docm", "MS Word 2007 XML VBA" }, { "docx", "MS Word 2007 XML" }, { "fodt", "OpenDocument Text Flat XML" }, { "html", "HTML (StarWriter)" }, { "odt", "writer8" }, { "ott", "writer8_template" }, { "pdf", "writer_pdf_Export" }, { "epub", "EPUB" }, { "rtf", "Rich Text Format" }, { "txt", "Text" }, { "xhtml", "XHTML Writer File" }, { "png", "writer_png_Export" }, { "xml", "writer_indexing_export" }, { nullptr, nullptr } }; const ExtensionMap aCalcExtensionMap[] = { { "csv", "Text - txt - csv (StarCalc)" }, { "fods", "OpenDocument Spreadsheet Flat XML" }, { "html", "HTML (StarCalc)" }, { "ods", "calc8" }, { "ots", "calc8_template" }, { "pdf", "calc_pdf_Export" }, { "xhtml", "XHTML Calc File" }, { "xls", "MS Excel 97" }, { "xlsm", "Calc MS Excel 2007 VBA XML" }, { "xlsx", "Calc MS Excel 2007 XML" }, { "png", "calc_png_Export" }, { nullptr, nullptr } }; const ExtensionMap aImpressExtensionMap[] = { { "fodp", "OpenDocument Presentation Flat XML" }, { "html", "impress_html_Export" }, { "odg", "impress8_draw" }, { "odp", "impress8" }, { "otp", "impress8_template" }, { "pdf", "impress_pdf_Export" }, { "potm", "Impress MS PowerPoint 2007 XML Template" }, { "pot", "MS PowerPoint 97 Vorlage" }, { "pptm", "Impress MS PowerPoint 2007 XML VBA" }, { "pptx", "Impress MS PowerPoint 2007 XML" }, { "pps", "MS PowerPoint 97 Autoplay" }, { "ppt", "MS PowerPoint 97" }, { "svg", "impress_svg_Export" }, { "xhtml", "XHTML Impress File" }, { "png", "impress_png_Export"}, { nullptr, nullptr } }; const ExtensionMap aDrawExtensionMap[] = { { "fodg", "draw_ODG_FlatXML" }, { "html", "draw_html_Export" }, { "odg", "draw8" }, { "pdf", "draw_pdf_Export" }, { "svg", "draw_svg_Export" }, { "xhtml", "XHTML Draw File" }, { "png", "draw_png_Export"}, { nullptr, nullptr } }; static OUString getUString(const char* pString) { if (pString == nullptr) return OUString(); std::string_view sString(pString, strlen(pString)); return OStringToOUString(sString, RTL_TEXTENCODING_UTF8); } // Tolerate embedded \0s etc. static char *convertOString(const OString &rStr) { char* pMemory = static_cast(malloc(rStr.getLength() + 1)); assert(pMemory); // don't tolerate failed allocations. memcpy(pMemory, rStr.getStr(), rStr.getLength() + 1); return pMemory; } static char *convertOUString(std::u16string_view aStr) { return convertOString(OUStringToOString(aStr, RTL_TEXTENCODING_UTF8)); } /// Try to convert a relative URL to an absolute one, unless it already looks like a URL. static OUString getAbsoluteURL(const char* pURL) { OUString aURL(getUString(pURL)); if (aURL.isEmpty()) return aURL; // convert relative paths to absolute ones OUString aWorkingDir; osl_getProcessWorkingDir(&aWorkingDir.pData); if (!aWorkingDir.endsWith("/")) aWorkingDir += "/"; try { return rtl::Uri::convertRelToAbs(aWorkingDir, aURL); } catch (const rtl::MalformedUriException &) { } return OUString(); } std::vector desktop::jsonToPropertyValuesVector(const char* pJSON) { std::vector aArguments; if (pJSON && pJSON[0] != '\0') { aArguments = comphelper::JsonToPropertyValues(pJSON); } return aArguments; } static bool extractLinks(const uno::Reference< container::XNameAccess >& xLinks, bool subcontent, OUStringBuffer& jsonText) { const uno::Sequence< OUString > aNames( xLinks->getElementNames() ); const sal_uLong nLinks = aNames.getLength(); const OUString* pNames = aNames.getConstArray(); const OUString aProp_LinkDisplayName( "LinkDisplayName" ); const OUString aProp_LinkTarget( "com.sun.star.document.LinkTarget" ); bool bIsTarget = false; for( sal_uLong i = 0; i < nLinks; i++ ) { uno::Any aAny; OUString aLink( *pNames++ ); bool bError = false; try { aAny = xLinks->getByName( aLink ); } catch(const uno::Exception&) { // if the name of the target was invalid (like empty headings) // no object can be provided bError = true; } if(bError) continue; uno::Reference< beans::XPropertySet > xTarget; if( aAny >>= xTarget ) { try { // get name to display aAny = xTarget->getPropertyValue( aProp_LinkDisplayName ); OUString aDisplayName; aAny >>= aDisplayName; OUString aStrDisplayname ( aDisplayName ); if (subcontent) { jsonText.append("\""); jsonText.append(aStrDisplayname); jsonText.append("\": \""); jsonText.append(aLink); jsonText.append("\""); if (i < nLinks-1) { jsonText.append(", "); } } else { uno::Reference< lang::XServiceInfo > xSI( xTarget, uno::UNO_QUERY ); bIsTarget = xSI->supportsService( aProp_LinkTarget ); if (i != 0) { if (!bIsTarget) jsonText.append("}"); if (i < nLinks) { jsonText.append(", "); } } jsonText.append("\""); jsonText.append(aStrDisplayname); jsonText.append("\": "); if (bIsTarget) { jsonText.append("true"); continue; } jsonText.append("{"); } uno::Reference< document::XLinkTargetSupplier > xLTS( xTarget, uno::UNO_QUERY ); if( xLTS.is() ) { extractLinks(xLTS->getLinks(), true, jsonText); } } catch(...) { SAL_WARN("lok", "extractLinks: Exception"); } } } return bIsTarget; } static void unoAnyToJson(tools::JsonWriter& rJson, const char * pNodeName, const uno::Any& anyItem) { auto aNode = rJson.startNode(pNodeName); OUString aType = anyItem.getValueTypeName(); rJson.put("type", aType.toUtf8().getStr()); if (aType == "string") rJson.put("value", anyItem.get().toUtf8().getStr()); else if (aType == "unsigned long") rJson.put("value", OString::number(anyItem.get()).getStr()); else if (aType == "long") rJson.put("value", OString::number(anyItem.get()).getStr()); else if (aType == "[]any") { uno::Sequence aSeq; if (anyItem >>= aSeq) { auto valueNode = rJson.startNode("value"); for (auto i = 0; i < aSeq.getLength(); ++i) { unoAnyToJson(rJson, OString::number(i).getStr(), aSeq[i]); } } } } static int lcl_getViewId(std::string_view payload); namespace desktop { RectangleAndPart RectangleAndPart::Create(const OString& rPayload) { RectangleAndPart aRet; if (rPayload.startsWith("EMPTY")) // payload starts with "EMPTY" { aRet.m_aRectangle = tools::Rectangle(0, 0, SfxLokHelper::MaxTwips, SfxLokHelper::MaxTwips); if (comphelper::LibreOfficeKit::isPartInInvalidation()) { int nSeparatorPos = rPayload.indexOf(',', 6); bool bHasMode = nSeparatorPos > 0; if (bHasMode) { aRet.m_nPart = o3tl::toInt32(rPayload.subView(6, nSeparatorPos - 6)); assert(rPayload.getLength() > nSeparatorPos); aRet.m_nMode = o3tl::toInt32(rPayload.subView(nSeparatorPos + 1)); } else { aRet.m_nPart = o3tl::toInt32(rPayload.subView(6)); aRet.m_nMode = 0; } } return aRet; } // Read ', , , [, , ]'. C++ streams are simpler but slower. const char* pos = rPayload.getStr(); const char* end = rPayload.getStr() + rPayload.getLength(); tools::Long nLeft = rtl_str_toInt64_WithLength(pos, 10, end - pos); while( *pos != ',' ) ++pos; ++pos; assert(pos < end); tools::Long nTop = rtl_str_toInt64_WithLength(pos, 10, end - pos); while( *pos != ',' ) ++pos; ++pos; assert(pos < end); tools::Long nWidth = rtl_str_toInt64_WithLength(pos, 10, end - pos); while( *pos != ',' ) ++pos; ++pos; assert(pos < end); tools::Long nHeight = rtl_str_toInt64_WithLength(pos, 10, end - pos); tools::Long nPart = INT_MIN; tools::Long nMode = 0; if (comphelper::LibreOfficeKit::isPartInInvalidation()) { while( *pos != ',' ) ++pos; ++pos; assert(pos < end); nPart = rtl_str_toInt64_WithLength(pos, 10, end - pos); while( *pos && *pos != ',' ) ++pos; if (*pos) { ++pos; assert(pos < end); nMode = rtl_str_toInt64_WithLength(pos, 10, end - pos); } } aRet.m_aRectangle = SanitizedRectangle(nLeft, nTop, nWidth, nHeight); aRet.m_nPart = nPart; aRet.m_nMode = nMode; return aRet; } tools::Rectangle RectangleAndPart::SanitizedRectangle(tools::Long nLeft, tools::Long nTop, tools::Long nWidth, tools::Long nHeight) { if (nWidth <= 0 || nHeight <= 0) return tools::Rectangle(); // The top-left corner starts at (0, 0). // Anything negative is invalid. if (nLeft < 0) { nWidth += nLeft; nLeft = 0; } if (nTop < 0) { nHeight += nTop; nTop = 0; } if (nWidth > 0 && nHeight > 0) return tools::Rectangle(nLeft, nTop, nLeft + nWidth, nTop + nHeight); // Else set empty rect. return tools::Rectangle(); } tools::Rectangle RectangleAndPart::SanitizedRectangle(const tools::Rectangle& rect) { return SanitizedRectangle(rect.Left(), rect.Top(), rect.getOpenWidth(), rect.getOpenHeight()); } const OString& CallbackFlushHandler::CallbackData::getPayload() const { if(PayloadString.isEmpty()) { // Do to-string conversion on demand, as many calls will get dropped without // needing the string. if(PayloadObject.which() == 1) PayloadString = getRectangleAndPart().toString(); } return PayloadString; } void CallbackFlushHandler::CallbackData::updateRectangleAndPart(const RectangleAndPart& rRectAndPart) { PayloadObject = rRectAndPart; PayloadString.clear(); // will be set on demand if needed } const RectangleAndPart& CallbackFlushHandler::CallbackData::getRectangleAndPart() const { // TODO: In case of unittests, they do not pass invalidations in binary but as text messages. // LO core should preferably always pass binary for performance. if(PayloadObject.which() != 1) PayloadObject = RectangleAndPart::Create(PayloadString); return boost::get(PayloadObject); } boost::property_tree::ptree& CallbackFlushHandler::CallbackData::setJson(const std::string& payload) { boost::property_tree::ptree aTree; std::stringstream aStream(payload); boost::property_tree::read_json(aStream, aTree); // Let boost normalize the payload so it always matches the cache. setJson(aTree); // Return reference to the cached object. return boost::get(PayloadObject); } void CallbackFlushHandler::CallbackData::setJson(const boost::property_tree::ptree& rTree) { std::stringstream aJSONStream; constexpr bool bPretty = false; // Don't waste time and bloat logs. boost::property_tree::write_json(aJSONStream, rTree, bPretty); PayloadString = OString(o3tl::trim(aJSONStream.str())); PayloadObject = rTree; } const boost::property_tree::ptree& CallbackFlushHandler::CallbackData::getJson() const { assert(PayloadObject.which() == 2); return boost::get(PayloadObject); } int CallbackFlushHandler::CallbackData::getViewId() const { if (isCached()) { assert(PayloadObject.which() == 3); return boost::get(PayloadObject); } return lcl_getViewId(getPayload()); } bool CallbackFlushHandler::CallbackData::validate() const { switch (PayloadObject.which()) { // Not cached. case 0: return true; // RectangleAndPart. case 1: return getRectangleAndPart().toString().getStr() == getPayload(); // Json. case 2: { std::stringstream aJSONStream; boost::property_tree::write_json(aJSONStream, getJson(), false); const std::string aExpected = boost::trim_copy(aJSONStream.str()); return getPayload() == std::string_view(aExpected); } // View id. case 3: return getViewId() == lcl_getViewId( getPayload()); default: assert(!"Unknown variant type; please add an entry to validate."); } return false; } } // namespace desktop static bool lcl_isViewCallbackType(const int type) { switch (type) { case LOK_CALLBACK_CELL_VIEW_CURSOR: case LOK_CALLBACK_GRAPHIC_VIEW_SELECTION: case LOK_CALLBACK_INVALIDATE_VIEW_CURSOR: case LOK_CALLBACK_TEXT_VIEW_SELECTION: case LOK_CALLBACK_VIEW_CURSOR_VISIBLE: return true; default: return false; } } static bool isUpdatedType(int type) { switch (type) { case LOK_CALLBACK_TEXT_SELECTION: case LOK_CALLBACK_TEXT_SELECTION_START: case LOK_CALLBACK_TEXT_SELECTION_END: return true; default: return false; } } static bool isUpdatedTypePerViewId(int type) { switch (type) { case LOK_CALLBACK_INVALIDATE_VISIBLE_CURSOR: case LOK_CALLBACK_INVALIDATE_VIEW_CURSOR: case LOK_CALLBACK_TEXT_VIEW_SELECTION: return true; default: return false; } } static int lcl_getViewId(std::string_view payload) { // this is a cheap way how to get the viewId from a JSON message; proper // parsing is terribly expensive, and we just need the viewId here size_t viewIdPos = payload.find("viewId"); if (viewIdPos == std::string::npos) return 0; size_t numberPos = payload.find(":", viewIdPos + 6); if (numberPos == std::string::npos) return 0; for (++numberPos; numberPos < payload.length(); ++numberPos) { if (payload[numberPos] == ',' || payload[numberPos] == '}' || (payload[numberPos] >= '0' && payload[numberPos] <= '9')) break; } if (numberPos < payload.length() && payload[numberPos] >= '0' && payload[numberPos] <= '9') return o3tl::toInt32(payload.substr(numberPos)); return 0; } namespace { std::string extractCertificate(const std::string & certificate) { const std::string header("-----BEGIN CERTIFICATE-----"); const std::string footer("-----END CERTIFICATE-----"); std::string result; size_t pos1 = certificate.find(header); if (pos1 == std::string::npos) return result; size_t pos2 = certificate.find(footer, pos1 + 1); if (pos2 == std::string::npos) return result; pos1 = pos1 + header.length(); pos2 = pos2 - pos1; return certificate.substr(pos1, pos2); } std::string extractPrivateKey(const std::string & privateKey) { const std::string header("-----BEGIN PRIVATE KEY-----"); const std::string footer("-----END PRIVATE KEY-----"); std::string result; size_t pos1 = privateKey.find(header); if (pos1 == std::string::npos) return result; size_t pos2 = privateKey.find(footer, pos1 + 1); if (pos2 == std::string::npos) return result; pos1 = pos1 + header.length(); pos2 = pos2 - pos1; return privateKey.substr(pos1, pos2); } OUString lcl_getCurrentDocumentMimeType(const LibLODocument_Impl* pDocument) { SfxBaseModel* pBaseModel = dynamic_cast(pDocument->mxComponent.get()); if (!pBaseModel) return ""; SfxObjectShell* pObjectShell = pBaseModel->GetObjectShell(); if (!pObjectShell) return ""; SfxMedium* pMedium = pObjectShell->GetMedium(); if (!pMedium) return ""; auto pFilter = pMedium->GetFilter(); if (!pFilter) return ""; return pFilter->GetMimeType(); } // Gets an undo manager to enter and exit undo context. Needed by ToggleOrientation css::uno::Reference< css::document::XUndoManager > getUndoManager( const css::uno::Reference< css::frame::XFrame >& rxFrame ) { const css::uno::Reference< css::frame::XController >& xController = rxFrame->getController(); if ( xController.is() ) { const css::uno::Reference< css::frame::XModel >& xModel = xController->getModel(); if ( xModel.is() ) { const css::uno::Reference< css::document::XUndoManagerSupplier > xSuppUndo( xModel, css::uno::UNO_QUERY_THROW ); return css::uno::Reference< css::document::XUndoManager >( xSuppUndo->getUndoManager(), css::uno::UNO_SET_THROW ); } } return css::uno::Reference< css::document::XUndoManager > (); } // Adjusts page margins for Writer doc. Needed by ToggleOrientation void ExecuteMarginLRChange( const tools::Long nPageLeftMargin, const tools::Long nPageRightMargin, SvxLongLRSpaceItem* pPageLRMarginItem) { pPageLRMarginItem->SetLeft( nPageLeftMargin ); pPageLRMarginItem->SetRight( nPageRightMargin ); SfxViewShell::Current()->GetDispatcher()->ExecuteList(SID_ATTR_PAGE_LRSPACE, SfxCallMode::RECORD, { pPageLRMarginItem }); } // Adjusts page margins for Writer doc. Needed by ToggleOrientation void ExecuteMarginULChange( const tools::Long nPageTopMargin, const tools::Long nPageBottomMargin, SvxLongULSpaceItem* pPageULMarginItem) { pPageULMarginItem->SetUpper( nPageTopMargin ); pPageULMarginItem->SetLower( nPageBottomMargin ); SfxViewShell::Current()->GetDispatcher()->ExecuteList(SID_ATTR_PAGE_ULSPACE, SfxCallMode::RECORD, { pPageULMarginItem }); } // Main function which toggles page orientation of the Writer doc. Needed by ToggleOrientation void ExecuteOrientationChange() { SfxViewFrame* pViewFrm = SfxViewFrame::Current(); if (!pViewFrm) return; std::unique_ptr pPageItem(new SvxPageItem(SID_ATTR_PAGE)); // 1mm in twips rounded // This should be in sync with MINBODY in sw/source/uibase/sidebar/PageMarginControl.hxx constexpr tools::Long MINBODY = o3tl::toTwips(1, o3tl::Length::mm); css::uno::Reference< css::document::XUndoManager > mxUndoManager( getUndoManager( pViewFrm->GetFrame().GetFrameInterface() ) ); if ( mxUndoManager.is() ) mxUndoManager->enterUndoContext( "" ); const SvxSizeItem* pSizeItem; pViewFrm->GetBindings().GetDispatcher()->QueryState(SID_ATTR_PAGE_SIZE, pSizeItem); std::unique_ptr pPageSizeItem(pSizeItem->Clone()); const SvxLongLRSpaceItem* pLRSpaceItem; pViewFrm->GetBindings().GetDispatcher()->QueryState(SID_ATTR_PAGE_LRSPACE, pLRSpaceItem); std::unique_ptr pPageLRMarginItem(pLRSpaceItem->Clone()); const SvxLongULSpaceItem* pULSpaceItem; pViewFrm->GetBindings().GetDispatcher()->QueryState(SID_ATTR_PAGE_ULSPACE, pULSpaceItem); std::unique_ptr pPageULMarginItem(pULSpaceItem->Clone()); { bool bIsLandscape = false; if ( pPageSizeItem->GetSize().Width() > pPageSizeItem->GetSize().Height()) bIsLandscape = true; // toggle page orientation pPageItem->SetLandscape(!bIsLandscape); // swap the width and height of the page size const tools::Long nRotatedWidth = pPageSizeItem->GetSize().Height(); const tools::Long nRotatedHeight = pPageSizeItem->GetSize().Width(); pPageSizeItem->SetSize(Size(nRotatedWidth, nRotatedHeight)); // apply changed attributes if (SfxViewShell::Current()) { SfxViewShell::Current()->GetDispatcher()->ExecuteList(SID_ATTR_PAGE_SIZE, SfxCallMode::RECORD, { pPageSizeItem.get(), pPageItem.get() }); } } // check, if margin values still fit to the changed page size. // if not, adjust margin values { const tools::Long nML = pPageLRMarginItem->GetLeft(); const tools::Long nMR = pPageLRMarginItem->GetRight(); const tools::Long nTmpPW = nML + nMR + MINBODY; const tools::Long nPW = pPageSizeItem->GetSize().Width(); if ( nTmpPW > nPW ) { if ( nML <= nMR ) { ExecuteMarginLRChange( pPageLRMarginItem->GetLeft(), nMR - (nTmpPW - nPW ), pPageLRMarginItem.get() ); } else { ExecuteMarginLRChange( nML - (nTmpPW - nPW ), pPageLRMarginItem->GetRight(), pPageLRMarginItem.get() ); } } const tools::Long nMT = pPageULMarginItem->GetUpper(); const tools::Long nMB = pPageULMarginItem->GetLower(); const tools::Long nTmpPH = nMT + nMB + MINBODY; const tools::Long nPH = pPageSizeItem->GetSize().Height(); if ( nTmpPH > nPH ) { if ( nMT <= nMB ) { ExecuteMarginULChange( pPageULMarginItem->GetUpper(), nMB - ( nTmpPH - nPH ), pPageULMarginItem.get() ); } else { ExecuteMarginULChange( nMT - ( nTmpPH - nPH ), pPageULMarginItem->GetLower(), pPageULMarginItem.get() ); } } } if ( mxUndoManager.is() ) mxUndoManager->leaveUndoContext(); } void setupSidebar(std::u16string_view sidebarDeckId = u"") { SfxViewShell* pViewShell = SfxViewShell::Current(); SfxViewFrame* pViewFrame = pViewShell ? &pViewShell->GetViewFrame() : nullptr; if (pViewFrame) { if (!pViewFrame->GetChildWindow(SID_SIDEBAR)) pViewFrame->SetChildWindow(SID_SIDEBAR, false /* create it */, true /* focus */); pViewFrame->ShowChildWindow(SID_SIDEBAR, true); // Force synchronous population of panels SfxChildWindow *pChild = pViewFrame->GetChildWindow(SID_SIDEBAR); if (!pChild) return; auto pDockingWin = dynamic_cast(pChild->GetWindow()); if (!pDockingWin) return; pViewFrame->ShowChildWindow( SID_SIDEBAR ); const rtl::Reference& xController = pDockingWin->GetOrCreateSidebarController(); xController->FadeIn(); xController->RequestOpenDeck(); if (!sidebarDeckId.empty()) { xController->SwitchToDeck(sidebarDeckId); } else { xController->SwitchToDefaultDeck(); } pDockingWin->SyncUpdate(); } else SetLastExceptionMsg("No view shell or sidebar"); } void hideSidebar() { SfxViewShell* pViewShell = SfxViewShell::Current(); SfxViewFrame* pViewFrame = pViewShell ? &pViewShell->GetViewFrame() : nullptr; if (pViewFrame) pViewFrame->SetChildWindow(SID_SIDEBAR, false , false ); else SetLastExceptionMsg("No view shell or sidebar"); } } // end anonymous namespace // Could be anonymous in principle, but for the unit testing purposes, we // declare it in init.hxx. OUString desktop::extractParameter(OUString& rOptions, std::u16string_view rName) { OUString aValue; OUString aNameEquals(OUString::Concat(rName) + "="); OUString aCommaNameEquals(OUString::Concat(",") + rName + "="); int nIndex = -1; if (rOptions.startsWith(aNameEquals)) { size_t nLen = aNameEquals.getLength(); int nComma = rOptions.indexOf(",", nLen); if (nComma >= 0) { aValue = rOptions.copy(nLen, nComma - nLen); rOptions = rOptions.copy(nComma + 1); } else { aValue = rOptions.copy(nLen); rOptions.clear(); } } else if ((nIndex = rOptions.indexOf(aCommaNameEquals)) >= 0) { size_t nLen = aCommaNameEquals.getLength(); int nComma = rOptions.indexOf(",", nIndex + nLen); if (nComma >= 0) { aValue = rOptions.copy(nIndex + nLen, nComma - nIndex - nLen); rOptions = OUString::Concat(rOptions.subView(0, nIndex)) + rOptions.subView(nComma); } else { aValue = rOptions.copy(nIndex + nLen); rOptions = rOptions.copy(0, nIndex); } } return aValue; } extern "C" { static void doc_destroy(LibreOfficeKitDocument* pThis); static int doc_saveAs(LibreOfficeKitDocument* pThis, const char* pUrl, const char* pFormat, const char* pFilterOptions); static int doc_getDocumentType(LibreOfficeKitDocument* pThis); static int doc_getParts(LibreOfficeKitDocument* pThis); static char* doc_getPartPageRectangles(LibreOfficeKitDocument* pThis); static int doc_getPart(LibreOfficeKitDocument* pThis); static void doc_setPart(LibreOfficeKitDocument* pThis, int nPart); static void doc_selectPart(LibreOfficeKitDocument* pThis, int nPart, int nSelect); static void doc_moveSelectedParts(LibreOfficeKitDocument* pThis, int nPosition, bool bDuplicate); static char* doc_getPartName(LibreOfficeKitDocument* pThis, int nPart); static void doc_setPartMode(LibreOfficeKitDocument* pThis, int nPartMode); static int doc_getEditMode(LibreOfficeKitDocument* pThis); static void doc_paintTile(LibreOfficeKitDocument* pThis, unsigned char* pBuffer, const int nCanvasWidth, const int nCanvasHeight, const int nTilePosX, const int nTilePosY, const int nTileWidth, const int nTileHeight); #ifdef IOS static void doc_paintTileToCGContext(LibreOfficeKitDocument* pThis, void* rCGContext, const int nCanvasWidth, const int nCanvasHeight, const int nTilePosX, const int nTilePosY, const int nTileWidth, const int nTileHeight); #endif static void doc_paintPartTile(LibreOfficeKitDocument* pThis, unsigned char* pBuffer, const int nPart, const int nMode, const int nCanvasWidth, const int nCanvasHeight, const int nTilePosX, const int nTilePosY, const int nTileWidth, const int nTileHeight); static int doc_getTileMode(LibreOfficeKitDocument* pThis); static void doc_getDocumentSize(LibreOfficeKitDocument* pThis, long* pWidth, long* pHeight); static void doc_getDataArea(LibreOfficeKitDocument* pThis, long nTab, long* pCol, long* pRow); static void doc_initializeForRendering(LibreOfficeKitDocument* pThis, const char* pArguments); static void doc_registerCallback(LibreOfficeKitDocument* pThis, LibreOfficeKitCallback pCallback, void* pData); static void doc_postKeyEvent(LibreOfficeKitDocument* pThis, int nType, int nCharCode, int nKeyCode); static void doc_setBlockedCommandList(LibreOfficeKitDocument* pThis, int nViewId, const char* blockedCommandList); static void doc_postWindowExtTextInputEvent(LibreOfficeKitDocument* pThis, unsigned nWindowId, int nType, const char* pText); static void doc_removeTextContext(LibreOfficeKitDocument* pThis, unsigned nLOKWindowId, int nCharBefore, int nCharAfter); static void doc_sendDialogEvent(LibreOfficeKitDocument* pThis, unsigned long long int nLOKWindowId, const char* pArguments); static void doc_postWindowKeyEvent(LibreOfficeKitDocument* pThis, unsigned nLOKWindowId, int nType, int nCharCode, int nKeyCode); static void doc_postMouseEvent (LibreOfficeKitDocument* pThis, int nType, int nX, int nY, int nCount, int nButtons, int nModifier); static void doc_postWindowMouseEvent (LibreOfficeKitDocument* pThis, unsigned nLOKWindowId, int nType, int nX, int nY, int nCount, int nButtons, int nModifier); static void doc_postWindowGestureEvent(LibreOfficeKitDocument* pThis, unsigned nLOKWindowId, const char* pType, int nX, int nY, int nOffset); static void doc_postUnoCommand(LibreOfficeKitDocument* pThis, const char* pCommand, const char* pArguments, bool bNotifyWhenFinished); static void doc_setWindowTextSelection(LibreOfficeKitDocument* pThis, unsigned nLOKWindowId, bool swap, int nX, int nY); static void doc_setTextSelection (LibreOfficeKitDocument* pThis, int nType, int nX, int nY); static char* doc_getTextSelection(LibreOfficeKitDocument* pThis, const char* pMimeType, char** pUsedMimeType); static int doc_getSelectionType(LibreOfficeKitDocument* pThis); static int doc_getSelectionTypeAndText(LibreOfficeKitDocument* pThis, const char* pMimeType, char** pText, char** pUsedMimeType); static int doc_getClipboard (LibreOfficeKitDocument* pThis, const char **pMimeTypes, size_t *pOutCount, char ***pOutMimeTypes, size_t **pOutSizes, char ***pOutStreams); static int doc_setClipboard (LibreOfficeKitDocument* pThis, const size_t nInCount, const char **pInMimeTypes, const size_t *pInSizes, const char **pInStreams); static bool doc_paste(LibreOfficeKitDocument* pThis, const char* pMimeType, const char* pData, size_t nSize); static void doc_setGraphicSelection (LibreOfficeKitDocument* pThis, int nType, int nX, int nY); static void doc_resetSelection (LibreOfficeKitDocument* pThis); static char* doc_getCommandValues(LibreOfficeKitDocument* pThis, const char* pCommand); static void doc_setClientZoom(LibreOfficeKitDocument* pThis, int nTilePixelWidth, int nTilePixelHeight, int nTileTwipWidth, int nTileTwipHeight); static void doc_setClientVisibleArea(LibreOfficeKitDocument* pThis, int nX, int nY, int nWidth, int nHeight); static void doc_setOutlineState(LibreOfficeKitDocument* pThis, bool bColumn, int nLevel, int nIndex, bool bHidden); static int doc_createView(LibreOfficeKitDocument* pThis); static int doc_createViewWithOptions(LibreOfficeKitDocument* pThis, const char* pOptions); static void doc_destroyView(LibreOfficeKitDocument* pThis, int nId); static void doc_setView(LibreOfficeKitDocument* pThis, int nId); static int doc_getView(LibreOfficeKitDocument* pThis); static int doc_getViewsCount(LibreOfficeKitDocument* pThis); static bool doc_getViewIds(LibreOfficeKitDocument* pThis, int* pArray, size_t nSize); static void doc_setViewLanguage(LibreOfficeKitDocument* pThis, int nId, const char* language); static unsigned char* doc_renderFontOrientation(LibreOfficeKitDocument* pThis, const char *pFontName, const char *pChar, int* pFontWidth, int* pFontHeight, int pOrientation); static unsigned char* doc_renderFont(LibreOfficeKitDocument* pThis, const char *pFontName, const char *pChar, int* pFontWidth, int* pFontHeight); static char* doc_getPartHash(LibreOfficeKitDocument* pThis, int nPart); static void doc_paintWindow(LibreOfficeKitDocument* pThis, unsigned nLOKWindowId, unsigned char* pBuffer, const int nX, const int nY, const int nWidth, const int nHeight); static void doc_paintWindowDPI(LibreOfficeKitDocument* pThis, unsigned nLOKWindowId, unsigned char* pBuffer, const int nX, const int nY, const int nWidth, const int nHeight, const double fDPIScale); static void doc_paintWindowForView(LibreOfficeKitDocument* pThis, unsigned nLOKWindowId, unsigned char* pBuffer, const int nX, const int nY, const int nWidth, const int nHeight, const double fDPIScale, int viewId); static void doc_postWindow(LibreOfficeKitDocument* pThis, unsigned nLOKWindowId, int nAction, const char* pData); static char* doc_getPartInfo(LibreOfficeKitDocument* pThis, int nPart); static bool doc_insertCertificate(LibreOfficeKitDocument* pThis, const unsigned char* pCertificateBinary, const int nCertificateBinarySize, const unsigned char* pPrivateKeyBinary, const int nPrivateKeyBinarySize); static bool doc_addCertificate(LibreOfficeKitDocument* pThis, const unsigned char* pCertificateBinary, const int nCertificateBinarySize); static int doc_getSignatureState(LibreOfficeKitDocument* pThis); static size_t doc_renderShapeSelection(LibreOfficeKitDocument* pThis, char** pOutput); static void doc_resizeWindow(LibreOfficeKitDocument* pThis, unsigned nLOKWindowId, const int nWidth, const int nHeight); static void doc_completeFunction(LibreOfficeKitDocument* pThis, const char*); static void doc_sendFormFieldEvent(LibreOfficeKitDocument* pThis, const char* pArguments); static bool doc_renderSearchResult(LibreOfficeKitDocument* pThis, const char* pSearchResult, unsigned char** pBitmapBuffer, int* pWidth, int* pHeight, size_t* pByteSize); static void doc_sendContentControlEvent(LibreOfficeKitDocument* pThis, const char* pArguments); static void doc_setViewTimezone(LibreOfficeKitDocument* pThis, int nId, const char* timezone); } // extern "C" namespace { ITiledRenderable* getTiledRenderable(LibreOfficeKitDocument* pThis) { LibLODocument_Impl* pDocument = static_cast(pThis); return dynamic_cast(pDocument->mxComponent.get()); } #ifndef IOS /* * Unfortunately clipboard creation using UNO is insanely baroque. * we also need to ensure that this works for the first view which * has no clear 'createView' called for it (unfortunately). */ rtl::Reference forceSetClipboardForCurrentView(LibreOfficeKitDocument *pThis) { ITiledRenderable* pDoc = getTiledRenderable(pThis); rtl::Reference xClip(LOKClipboardFactory::getClipboardForCurView()); SAL_INFO("lok", "Set to clipboard for view " << xClip.get()); // FIXME: using a hammer here - should not be necessary if all tests used createView. pDoc->setClipboard(uno::Reference(xClip->getXI(), UNO_QUERY)); return xClip; } #endif const vcl::Font* FindFont(std::u16string_view rFontName) { SfxObjectShell* pDocSh = SfxObjectShell::Current(); if (!pDocSh) return nullptr; const SvxFontListItem* pFonts = static_cast(pDocSh->GetItem(SID_ATTR_CHAR_FONTLIST)); const FontList* pList = pFonts ? pFonts->GetFontList() : nullptr; if (pList && !rFontName.empty()) if (sal_Handle hMetric = pList->GetFirstFontMetric(rFontName)) return &FontList::GetFontMetric(hMetric); return nullptr; } vcl::Font FindFont_FallbackToDefault(std::u16string_view rFontName) { if (auto pFound = FindFont(rFontName)) return *pFound; return OutputDevice::GetDefaultFont(DefaultFontType::SANS_UNICODE, LANGUAGE_NONE, GetDefaultFontFlags::NONE); } } // anonymous namespace LibLODocument_Impl::LibLODocument_Impl(uno::Reference xComponent, int nDocumentId) : mxComponent(std::move(xComponent)) , mnDocumentId(nDocumentId) { assert(nDocumentId != -1 && "Cannot set mnDocumentId to -1"); m_pDocumentClass = gDocumentClass.lock(); if (!m_pDocumentClass) { m_pDocumentClass = std::make_shared(); m_pDocumentClass->nSize = sizeof(LibreOfficeKitDocumentClass); m_pDocumentClass->destroy = doc_destroy; m_pDocumentClass->saveAs = doc_saveAs; m_pDocumentClass->getDocumentType = doc_getDocumentType; m_pDocumentClass->getParts = doc_getParts; m_pDocumentClass->getPartPageRectangles = doc_getPartPageRectangles; m_pDocumentClass->getPart = doc_getPart; m_pDocumentClass->setPart = doc_setPart; m_pDocumentClass->selectPart = doc_selectPart; m_pDocumentClass->moveSelectedParts = doc_moveSelectedParts; m_pDocumentClass->getPartName = doc_getPartName; m_pDocumentClass->setPartMode = doc_setPartMode; m_pDocumentClass->getEditMode = doc_getEditMode; m_pDocumentClass->paintTile = doc_paintTile; #ifdef IOS m_pDocumentClass->paintTileToCGContext = doc_paintTileToCGContext; #endif m_pDocumentClass->paintPartTile = doc_paintPartTile; m_pDocumentClass->getTileMode = doc_getTileMode; m_pDocumentClass->getDocumentSize = doc_getDocumentSize; m_pDocumentClass->getDataArea = doc_getDataArea; m_pDocumentClass->initializeForRendering = doc_initializeForRendering; m_pDocumentClass->registerCallback = doc_registerCallback; m_pDocumentClass->postKeyEvent = doc_postKeyEvent; m_pDocumentClass->postWindowExtTextInputEvent = doc_postWindowExtTextInputEvent; m_pDocumentClass->removeTextContext = doc_removeTextContext; m_pDocumentClass->postWindowKeyEvent = doc_postWindowKeyEvent; m_pDocumentClass->postMouseEvent = doc_postMouseEvent; m_pDocumentClass->postWindowMouseEvent = doc_postWindowMouseEvent; m_pDocumentClass->sendDialogEvent = doc_sendDialogEvent; m_pDocumentClass->postUnoCommand = doc_postUnoCommand; m_pDocumentClass->setTextSelection = doc_setTextSelection; m_pDocumentClass->setWindowTextSelection = doc_setWindowTextSelection; m_pDocumentClass->getTextSelection = doc_getTextSelection; m_pDocumentClass->getSelectionType = doc_getSelectionType; m_pDocumentClass->getSelectionTypeAndText = doc_getSelectionTypeAndText; m_pDocumentClass->getClipboard = doc_getClipboard; m_pDocumentClass->setClipboard = doc_setClipboard; m_pDocumentClass->paste = doc_paste; m_pDocumentClass->setGraphicSelection = doc_setGraphicSelection; m_pDocumentClass->resetSelection = doc_resetSelection; m_pDocumentClass->getCommandValues = doc_getCommandValues; m_pDocumentClass->setClientZoom = doc_setClientZoom; m_pDocumentClass->setClientVisibleArea = doc_setClientVisibleArea; m_pDocumentClass->setOutlineState = doc_setOutlineState; m_pDocumentClass->createView = doc_createView; m_pDocumentClass->destroyView = doc_destroyView; m_pDocumentClass->setView = doc_setView; m_pDocumentClass->getView = doc_getView; m_pDocumentClass->getViewsCount = doc_getViewsCount; m_pDocumentClass->getViewIds = doc_getViewIds; m_pDocumentClass->renderFont = doc_renderFont; m_pDocumentClass->renderFontOrientation = doc_renderFontOrientation; m_pDocumentClass->getPartHash = doc_getPartHash; m_pDocumentClass->paintWindow = doc_paintWindow; m_pDocumentClass->paintWindowDPI = doc_paintWindowDPI; m_pDocumentClass->paintWindowForView = doc_paintWindowForView; m_pDocumentClass->postWindow = doc_postWindow; m_pDocumentClass->resizeWindow = doc_resizeWindow; m_pDocumentClass->setViewLanguage = doc_setViewLanguage; m_pDocumentClass->getPartInfo = doc_getPartInfo; m_pDocumentClass->insertCertificate = doc_insertCertificate; m_pDocumentClass->addCertificate = doc_addCertificate; m_pDocumentClass->getSignatureState = doc_getSignatureState; m_pDocumentClass->renderShapeSelection = doc_renderShapeSelection; m_pDocumentClass->postWindowGestureEvent = doc_postWindowGestureEvent; m_pDocumentClass->createViewWithOptions = doc_createViewWithOptions; m_pDocumentClass->completeFunction = doc_completeFunction; m_pDocumentClass->sendFormFieldEvent = doc_sendFormFieldEvent; m_pDocumentClass->renderSearchResult = doc_renderSearchResult; m_pDocumentClass->setBlockedCommandList = doc_setBlockedCommandList; m_pDocumentClass->sendContentControlEvent = doc_sendContentControlEvent; m_pDocumentClass->setViewTimezone = doc_setViewTimezone; gDocumentClass = m_pDocumentClass; } pClass = m_pDocumentClass.get(); #ifndef IOS forceSetClipboardForCurrentView(this); #endif } LibLODocument_Impl::~LibLODocument_Impl() { try { mxComponent->dispose(); } catch (const css::lang::DisposedException&) { TOOLS_WARN_EXCEPTION("lok", "failed to dispose document"); } } static OUString getGenerator() { OUString sGenerator( Translate::ExpandVariables("%PRODUCTNAME %PRODUCTVERSION%PRODUCTEXTENSION (%1)")); OUString os("$_OS"); ::rtl::Bootstrap::expandMacros(os); return sGenerator.replaceFirst("%1", os); } extern "C" { CallbackFlushHandler::TimeoutIdle::TimeoutIdle( CallbackFlushHandler* handler ) : Timer( "lokit timer callback" ) , mHandler( handler ) { // A second timer with higher priority, it'll ensure we flush in reasonable time if we get too busy // to get POST_PAINT priority processing. Otherwise it could take a long time to flush. SetPriority(TaskPriority::DEFAULT); SetTimeout( 100 ); // 100 ms } void CallbackFlushHandler::TimeoutIdle::Invoke() { mHandler->Invoke(); } // One of these is created per view to handle events cf. doc_registerCallback CallbackFlushHandler::CallbackFlushHandler(LibreOfficeKitDocument* pDocument, LibreOfficeKitCallback pCallback, void* pData) : Idle( "lokit idle callback" ), m_pDocument(pDocument), m_pCallback(pCallback), m_pData(pData), m_nDisableCallbacks(0), m_TimeoutIdle( this ) { SetPriority(TaskPriority::POST_PAINT); // Add the states that are safe to skip duplicates on, even when // not consequent (i.e. do no emit them if unchanged from last). m_states.emplace(LOK_CALLBACK_TEXT_SELECTION, "NIL"); m_states.emplace(LOK_CALLBACK_GRAPHIC_SELECTION, "NIL"); m_states.emplace(LOK_CALLBACK_INVALIDATE_VISIBLE_CURSOR, "NIL"); m_states.emplace(LOK_CALLBACK_STATE_CHANGED, "NIL"); m_states.emplace(LOK_CALLBACK_MOUSE_POINTER, "NIL"); m_states.emplace(LOK_CALLBACK_CELL_CURSOR, "NIL"); m_states.emplace(LOK_CALLBACK_CELL_FORMULA, "NIL"); m_states.emplace(LOK_CALLBACK_CELL_ADDRESS, "NIL"); m_states.emplace(LOK_CALLBACK_CURSOR_VISIBLE, "NIL"); m_states.emplace(LOK_CALLBACK_SET_PART, "NIL"); m_states.emplace(LOK_CALLBACK_TABLE_SELECTED, "NIL"); m_states.emplace(LOK_CALLBACK_TAB_STOP_LIST, "NIL"); m_states.emplace(LOK_CALLBACK_RULER_UPDATE, "NIL"); m_states.emplace(LOK_CALLBACK_STATUS_INDICATOR_SET_VALUE, "NIL"); } CallbackFlushHandler::~CallbackFlushHandler() { Stop(); } CallbackFlushHandler::queue_type2::iterator CallbackFlushHandler::toQueue2(CallbackFlushHandler::queue_type1::iterator pos) { int delta = std::distance(m_queue1.begin(), pos); return m_queue2.begin() + delta; } CallbackFlushHandler::queue_type2::reverse_iterator CallbackFlushHandler::toQueue2(CallbackFlushHandler::queue_type1::reverse_iterator pos) { int delta = std::distance(m_queue1.rbegin(), pos); return m_queue2.rbegin() + delta; } void CallbackFlushHandler::setUpdatedType( int nType, bool value ) { assert(isUpdatedType(nType)); if( m_updatedTypes.size() <= o3tl::make_unsigned( nType )) m_updatedTypes.resize( nType + 1 ); // new are default-constructed, i.e. false m_updatedTypes[ nType ] = value; if(value) startTimer(); } void CallbackFlushHandler::resetUpdatedType( int nType ) { setUpdatedType( nType, false ); } void CallbackFlushHandler::setUpdatedTypePerViewId( int nType, int nViewId, int nSourceViewId, bool value ) { assert(isUpdatedTypePerViewId(nType)); std::vector& types = m_updatedTypesPerViewId[ nViewId ]; if( types.size() <= o3tl::make_unsigned( nType )) types.resize( nType + 1 ); // new are default-constructed, i.e. 'set' is false types[ nType ] = PerViewIdData{ value, nSourceViewId }; if(value) startTimer(); } void CallbackFlushHandler::resetUpdatedTypePerViewId( int nType, int nViewId ) { assert(isUpdatedTypePerViewId(nType)); bool allViewIds = false; // Handle specially messages that do not have viewId for backwards compatibility. if( nType == LOK_CALLBACK_INVALIDATE_VISIBLE_CURSOR && !comphelper::LibreOfficeKit::isViewIdForVisCursorInvalidation()) allViewIds = true; if( !allViewIds ) { setUpdatedTypePerViewId( nType, nViewId, -1, false ); return; } for( auto& it : m_updatedTypesPerViewId ) { std::vector& types = it.second; if( types.size() >= o3tl::make_unsigned( nType )) types[ nType ].set = false; } } void CallbackFlushHandler::libreOfficeKitViewCallback(int nType, const OString& pPayload) { CallbackData callbackData(pPayload); queue(nType, callbackData); } void CallbackFlushHandler::libreOfficeKitViewCallbackWithViewId(int nType, const OString& pPayload, int nViewId) { CallbackData callbackData(pPayload, nViewId); queue(nType, callbackData); } void CallbackFlushHandler::libreOfficeKitViewInvalidateTilesCallback(const tools::Rectangle* pRect, int nPart, int nMode) { CallbackData callbackData(pRect, nPart, nMode); queue(LOK_CALLBACK_INVALIDATE_TILES, callbackData); } void CallbackFlushHandler::libreOfficeKitViewUpdatedCallback(int nType) { assert(isUpdatedType( nType )); std::unique_lock lock(m_mutex); SAL_INFO("lok", "Updated: [" << nType << "]"); setUpdatedType(nType, true); } void CallbackFlushHandler::libreOfficeKitViewUpdatedCallbackPerViewId(int nType, int nViewId, int nSourceViewId) { assert(isUpdatedTypePerViewId( nType )); std::unique_lock lock(m_mutex); SAL_INFO("lok", "Updated: [" << nType << "]"); setUpdatedTypePerViewId(nType, nViewId, nSourceViewId, true); } void CallbackFlushHandler::dumpState(rtl::OStringBuffer &rState) { // NB. no locking rState.append("\nView:\t"); rState.append(static_cast(m_viewId)); rState.append("\n\tDisableCallbacks:\t"); rState.append(static_cast(m_nDisableCallbacks)); rState.append("\n\tStates:\n"); for (const auto &i : m_states) { rState.append("\n\t\t"); rState.append(static_cast(i.first)); rState.append("\t"); rState.append(i.second); } } void CallbackFlushHandler::libreOfficeKitViewAddPendingInvalidateTiles() { // Invoke() will call flushPendingLOKInvalidateTiles(), so just make sure the timer is active. startTimer(); } void CallbackFlushHandler::queue(const int type, const OString& data) { CallbackData callbackData(data); queue(type, callbackData); } void CallbackFlushHandler::queue(const int type, CallbackData& aCallbackData) { comphelper::ProfileZone aZone("CallbackFlushHandler::queue"); SAL_INFO("lok", "Queue: [" << type << "]: [" << aCallbackData.getPayload() << "] on " << m_queue1.size() << " entries."); bool bIsChartActive = false; bool bIsComment = false; if (type == LOK_CALLBACK_GRAPHIC_SELECTION) { LokChartHelper aChartHelper(SfxViewShell::Current()); bIsChartActive = aChartHelper.GetWindow() != nullptr; } else if (type == LOK_CALLBACK_COMMENT) { bIsComment = true; } if (callbacksDisabled() && !bIsChartActive && !bIsComment) { // We drop notifications when this is set, except for important ones. // When we issue a complex command (such as .uno:InsertAnnotation) // there will be multiple notifications. On the first invalidation // we will start painting, but other events will get fired // while the complex command in question executes. // We don't want to suppress everything here on the wrong assumption // that no new events are fired during painting. if (type != LOK_CALLBACK_STATE_CHANGED && type != LOK_CALLBACK_INVALIDATE_TILES && type != LOK_CALLBACK_INVALIDATE_VISIBLE_CURSOR && type != LOK_CALLBACK_CURSOR_VISIBLE && type != LOK_CALLBACK_VIEW_CURSOR_VISIBLE && type != LOK_CALLBACK_TEXT_SELECTION && type != LOK_CALLBACK_TEXT_SELECTION_START && type != LOK_CALLBACK_TEXT_SELECTION_END && type != LOK_CALLBACK_MEDIA_SHAPE && type != LOK_CALLBACK_REFERENCE_MARKS) { SAL_INFO("lok", "Skipping while painting [" << type << "]: [" << aCallbackData.getPayload() << "]."); return; } // In Writer we drop all notifications during painting. if (doc_getDocumentType(m_pDocument) == LOK_DOCTYPE_TEXT) return; } // Suppress invalid payloads. if (type == LOK_CALLBACK_INVALIDATE_VISIBLE_CURSOR && aCallbackData.getPayload().indexOf(", 0, 0, ") != -1 && aCallbackData.getPayload().indexOf("\"hyperlink\":\"\"") == -1 && aCallbackData.getPayload().indexOf("\"hyperlink\": {}") == -1) { // The cursor position is often the relative coordinates of the widget // issuing it, instead of the absolute one that we expect. // This is temporary however, and, once the control is created and initialized // correctly, it eventually emits the correct absolute coordinates. SAL_INFO("lok", "Skipping invalid event [" << type << "]: [" << aCallbackData.getPayload() << "]."); return; } std::unique_lock lock(m_mutex); // Update types should be received via the updated callbacks for performance, // getting them as normal callbacks is technically not wrong, but probably should be avoided. // Reset the updated flag if we get a normal message. if(isUpdatedType(type)) { SAL_INFO("lok", "Received event with updated type [" << type << "] as normal callback"); resetUpdatedType(type); } if(isUpdatedTypePerViewId(type)) { SAL_INFO("lok", "Received event with updated type [" << type << "] as normal callback"); resetUpdatedTypePerViewId(type, aCallbackData.getViewId()); } // drop duplicate callbacks for the listed types switch (type) { case LOK_CALLBACK_TEXT_SELECTION_START: case LOK_CALLBACK_TEXT_SELECTION_END: case LOK_CALLBACK_TEXT_SELECTION: case LOK_CALLBACK_GRAPHIC_SELECTION: case LOK_CALLBACK_GRAPHIC_VIEW_SELECTION: case LOK_CALLBACK_INVALIDATE_VISIBLE_CURSOR: case LOK_CALLBACK_INVALIDATE_VIEW_CURSOR: case LOK_CALLBACK_STATE_CHANGED: case LOK_CALLBACK_MOUSE_POINTER: case LOK_CALLBACK_CELL_CURSOR: case LOK_CALLBACK_CELL_VIEW_CURSOR: case LOK_CALLBACK_CELL_FORMULA: case LOK_CALLBACK_CELL_ADDRESS: case LOK_CALLBACK_CELL_SELECTION_AREA: case LOK_CALLBACK_CURSOR_VISIBLE: case LOK_CALLBACK_VIEW_CURSOR_VISIBLE: case LOK_CALLBACK_SET_PART: case LOK_CALLBACK_TEXT_VIEW_SELECTION: case LOK_CALLBACK_INVALIDATE_HEADER: case LOK_CALLBACK_WINDOW: case LOK_CALLBACK_CALC_FUNCTION_LIST: case LOK_CALLBACK_INVALIDATE_SHEET_GEOMETRY: case LOK_CALLBACK_REFERENCE_MARKS: case LOK_CALLBACK_CELL_AUTO_FILL_AREA: { const auto& pos = std::find(m_queue1.rbegin(), m_queue1.rend(), type); auto pos2 = toQueue2(pos); if (pos != m_queue1.rend() && pos2->getPayload() == aCallbackData.getPayload()) { SAL_INFO("lok", "Skipping queue duplicate [" << type << + "]: [" << aCallbackData.getPayload() << "]."); return; } } break; } if (type == LOK_CALLBACK_TEXT_SELECTION && aCallbackData.isEmpty()) { const auto& posStart = std::find(m_queue1.rbegin(), m_queue1.rend(), LOK_CALLBACK_TEXT_SELECTION_START); auto posStart2 = toQueue2(posStart); if (posStart != m_queue1.rend()) posStart2->clear(); const auto& posEnd = std::find(m_queue1.rbegin(), m_queue1.rend(), LOK_CALLBACK_TEXT_SELECTION_END); auto posEnd2 = toQueue2(posEnd); if (posEnd != m_queue1.rend()) posEnd2->clear(); } // When payload is empty discards any previous state. if (aCallbackData.isEmpty()) { switch (type) { case LOK_CALLBACK_TEXT_SELECTION_START: case LOK_CALLBACK_TEXT_SELECTION_END: case LOK_CALLBACK_TEXT_SELECTION: case LOK_CALLBACK_GRAPHIC_SELECTION: case LOK_CALLBACK_INVALIDATE_VISIBLE_CURSOR: case LOK_CALLBACK_INVALIDATE_TILES: if (removeAll(type)) SAL_INFO("lok", "Removed dups of [" << type << "]: [" << aCallbackData.getPayload() << "]."); break; } } else { switch (type) { // These are safe to use the latest state and ignore previous // ones (if any) since the last overrides previous ones. case LOK_CALLBACK_TEXT_SELECTION_START: case LOK_CALLBACK_TEXT_SELECTION_END: case LOK_CALLBACK_TEXT_SELECTION: case LOK_CALLBACK_MOUSE_POINTER: case LOK_CALLBACK_CELL_CURSOR: case LOK_CALLBACK_CELL_FORMULA: case LOK_CALLBACK_CELL_ADDRESS: case LOK_CALLBACK_CURSOR_VISIBLE: case LOK_CALLBACK_SET_PART: case LOK_CALLBACK_STATUS_INDICATOR_SET_VALUE: case LOK_CALLBACK_RULER_UPDATE: { if (removeAll(type)) SAL_INFO("lok", "Removed dups of [" << type << "]: [" << aCallbackData.getPayload() << "]."); } break; // These are safe to use the latest state and ignore previous // ones (if any) since the last overrides previous ones, // but only if the view is the same. case LOK_CALLBACK_CELL_VIEW_CURSOR: case LOK_CALLBACK_GRAPHIC_VIEW_SELECTION: case LOK_CALLBACK_INVALIDATE_VIEW_CURSOR: case LOK_CALLBACK_INVALIDATE_VISIBLE_CURSOR: case LOK_CALLBACK_TEXT_VIEW_SELECTION: case LOK_CALLBACK_VIEW_CURSOR_VISIBLE: case LOK_CALLBACK_CALC_FUNCTION_LIST: case LOK_CALLBACK_FORM_FIELD_BUTTON: { // deleting the duplicate of visible cursor message can cause hyperlink popup not to show up on second/or more click on the same place. // If the hyperlink is not empty we can bypass that to show the popup const bool hyperLinkException = type == LOK_CALLBACK_INVALIDATE_VISIBLE_CURSOR && aCallbackData.getPayload().indexOf("\"hyperlink\":\"\"") == -1 && aCallbackData.getPayload().indexOf("\"hyperlink\": {}") == -1; if(!hyperLinkException) { const int nViewId = aCallbackData.getViewId(); removeAll(type, [nViewId] (const CallbackData& elemData) { return (nViewId == elemData.getViewId()); } ); } } break; case LOK_CALLBACK_INVALIDATE_TILES: if (processInvalidateTilesEvent(type, aCallbackData)) return; break; // State changes with same name override previous ones with a different value. // Ex. ".uno:PageStatus=Slide 20 of 83" overwrites any previous PageStatus. case LOK_CALLBACK_STATE_CHANGED: { // Compare the state name=value and overwrite earlier entries with same name. const auto pos = aCallbackData.getPayload().indexOf('='); if (pos != -1) { const std::string_view name = aCallbackData.getPayload().subView(0, pos + 1); // This is needed because otherwise it creates some problems when // a save occurs while a cell is still edited in Calc. if (name != ".uno:ModifiedStatus=") { removeAll(type, [&name] (const CallbackData& elemData) { return elemData.getPayload().startsWith(name); } ); } } } break; case LOK_CALLBACK_WINDOW: if (processWindowEvent(type, aCallbackData)) return; break; case LOK_CALLBACK_GRAPHIC_SELECTION: { // remove only selection ranges and 'EMPTY' messages // always send 'INPLACE' and 'INPLACE EXIT' messages removeAll(type, [] (const CallbackData& elemData) { return (elemData.getPayload().indexOf("INPLACE") == -1); }); } break; } } // Validate that the cached data and the payload string are identical. assert(aCallbackData.validate() && "Cached callback payload object and string mismatch!"); m_queue1.emplace_back(type); m_queue2.emplace_back(aCallbackData); SAL_INFO("lok", "Queued #" << (m_queue1.size() - 1) << " [" << type << "]: [" << aCallbackData.getPayload() << "] to have " << m_queue1.size() << " entries."); #ifdef DBG_UTIL { // Dump the queue state and validate cached data. int i = 1; std::ostringstream oss; if (m_queue1.empty()) oss << "Empty"; else oss << m_queue1.size() << " items\n"; auto it1 = m_queue1.begin(); auto it2 = m_queue2.begin(); for (; it1 != m_queue1.end(); ++it1, ++it2) oss << i++ << ": [" << *it1 << "] [" << it2->getPayload() << "].\n"; SAL_INFO("lok", "Current Queue: " << oss.str()); assert( std::all_of( m_queue2.begin(), m_queue2.end(), [](const CallbackData& c) { return c.validate(); })); } #endif lock.unlock(); startTimer(); } bool CallbackFlushHandler::processInvalidateTilesEvent(int type, CallbackData& aCallbackData) { RectangleAndPart rcNew = aCallbackData.getRectangleAndPart(); if (rcNew.isEmpty()) { SAL_INFO("lok", "Skipping invalid event [" << type << "]: [" << aCallbackData.getPayload() << "]."); return true; } // If we have to invalidate all tiles, we can skip any new tile invalidation. // Find the last INVALIDATE_TILES entry, if any to see if it's invalidate-all. const auto& pos = std::find(m_queue1.rbegin(), m_queue1.rend(), LOK_CALLBACK_INVALIDATE_TILES); if (pos != m_queue1.rend()) { auto pos2 = toQueue2(pos); const RectangleAndPart& rcOld = pos2->getRectangleAndPart(); if (rcOld.isInfinite() && (rcOld.m_nPart == -1 || rcOld.m_nPart == rcNew.m_nPart) && (rcOld.m_nMode == rcNew.m_nMode)) { SAL_INFO("lok", "Skipping queue [" << type << "]: [" << aCallbackData.getPayload() << "] since all tiles need to be invalidated."); return true; } if ((rcOld.m_nPart == -1 || rcOld.m_nPart == rcNew.m_nPart) && (rcOld.m_nMode == rcNew.m_nMode)) { // If fully overlapping. if (rcOld.m_aRectangle.Contains(rcNew.m_aRectangle)) { SAL_INFO("lok", "Skipping queue [" << type << "]: [" << aCallbackData.getPayload() << "] since overlaps existing all-parts."); return true; } } } if (rcNew.isInfinite()) { SAL_INFO("lok", "Have Empty [" << type << "]: [" << aCallbackData.getPayload() << "] so removing all with part " << rcNew.m_nPart << "."); removeAll(LOK_CALLBACK_INVALIDATE_TILES, [&rcNew](const CallbackData& elemData) { // Remove exiting if new is all-encompassing, or if of the same part. return ((rcNew.m_nPart == -1 || rcNew.m_nPart == elemData.getRectangleAndPart().m_nPart) && (rcNew.m_nMode == elemData.getRectangleAndPart().m_nMode)); }); } else { const auto rcOrig = rcNew; SAL_INFO("lok", "Have [" << type << "]: [" << aCallbackData.getPayload() << "] so merging overlapping."); removeAll(LOK_CALLBACK_INVALIDATE_TILES,[&rcNew](const CallbackData& elemData) { const RectangleAndPart& rcOld = elemData.getRectangleAndPart(); if (rcNew.m_nPart != -1 && rcOld.m_nPart != -1 && (rcOld.m_nPart != rcNew.m_nPart || rcOld.m_nMode != rcNew.m_nMode)) { SAL_INFO("lok", "Nothing to merge between new: " << rcNew.toString() << ", and old: " << rcOld.toString()); return false; } if (rcNew.m_nPart == -1) { // Don't merge unless fully overlapped. SAL_INFO("lok", "New " << rcNew.toString() << " has " << rcOld.toString() << "?"); if (rcNew.m_aRectangle.Contains(rcOld.m_aRectangle) && rcOld.m_nMode == rcNew.m_nMode) { SAL_INFO("lok", "New " << rcNew.toString() << " engulfs old " << rcOld.toString() << "."); return true; } } else if (rcOld.m_nPart == -1) { // Don't merge unless fully overlapped. SAL_INFO("lok", "Old " << rcOld.toString() << " has " << rcNew.toString() << "?"); if (rcOld.m_aRectangle.Contains(rcNew.m_aRectangle) && rcOld.m_nMode == rcNew.m_nMode) { SAL_INFO("lok", "New " << rcNew.toString() << " engulfs old " << rcOld.toString() << "."); return true; } } else { const tools::Rectangle rcOverlap = rcNew.m_aRectangle.GetIntersection(rcOld.m_aRectangle); const bool bOverlap = !rcOverlap.IsEmpty() && rcOld.m_nMode == rcNew.m_nMode; SAL_INFO("lok", "Merging " << rcNew.toString() << " & " << rcOld.toString() << " => " << rcOverlap.toString() << " Overlap: " << bOverlap); if (bOverlap) { rcNew.m_aRectangle.Union(rcOld.m_aRectangle); SAL_INFO("lok", "Merged: " << rcNew.toString()); return true; } } // Keep others. return false; }); if (rcNew.m_aRectangle != rcOrig.m_aRectangle) { SAL_INFO("lok", "Replacing: " << rcOrig.toString() << " by " << rcNew.toString()); if (rcNew.m_aRectangle.GetWidth() < rcOrig.m_aRectangle.GetWidth() || rcNew.m_aRectangle.GetHeight() < rcOrig.m_aRectangle.GetHeight()) { SAL_WARN("lok", "Error: merged rect smaller."); } } } aCallbackData.updateRectangleAndPart(rcNew); // Queue this one. return false; } bool CallbackFlushHandler::processWindowEvent(int type, CallbackData& aCallbackData) { const OString& payload = aCallbackData.getPayload(); boost::property_tree::ptree& aTree = aCallbackData.setJson(payload.getStr()); const unsigned nLOKWindowId = aTree.get("id", 0); const std::string aAction = aTree.get("action", ""); if (aAction == "invalidate") { std::string aRectStr = aTree.get("rectangle", ""); // no 'rectangle' field => invalidate all of the window => // remove all previous window part invalidations if (aRectStr.empty()) { removeAll(LOK_CALLBACK_WINDOW,[&nLOKWindowId](const CallbackData& elemData) { const boost::property_tree::ptree& aOldTree = elemData.getJson(); if (nLOKWindowId == aOldTree.get("id", 0) && aOldTree.get("action", "") == "invalidate") { return true; } return false; }); } else { // if we have to invalidate all of the window, ignore // any part invalidation message bool invAllExist = false; auto it1 = m_queue1.rbegin(); auto it2 = m_queue2.rbegin(); for (;it1 != m_queue1.rend(); ++it1, ++it2) { if (*it1 != LOK_CALLBACK_WINDOW) continue; const boost::property_tree::ptree& aOldTree = it2->getJson(); if (nLOKWindowId == aOldTree.get("id", 0) && aOldTree.get("action", "") == "invalidate" && aOldTree.get("rectangle", "").empty()) { invAllExist = true; break; } } // we found a invalidate-all window callback if (invAllExist) { SAL_INFO("lok.dialog", "Skipping queue [" << type << "]: [" << payload << "] since whole window needs to be invalidated."); return true; } std::istringstream aRectStream(aRectStr); tools::Long nLeft, nTop, nWidth, nHeight; char nComma; aRectStream >> nLeft >> nComma >> nTop >> nComma >> nWidth >> nComma >> nHeight; tools::Rectangle aNewRect(nLeft, nTop, nLeft + nWidth, nTop + nHeight); bool currentIsRedundant = false; removeAll(LOK_CALLBACK_WINDOW, [&aNewRect, &nLOKWindowId, ¤tIsRedundant](const CallbackData& elemData) { const boost::property_tree::ptree& aOldTree = elemData.getJson(); if (aOldTree.get("action", "") == "invalidate") { // Not possible that we encounter an empty rectangle here; we already handled this case above. std::istringstream aOldRectStream(aOldTree.get("rectangle", "")); tools::Long nOldLeft, nOldTop, nOldWidth, nOldHeight; char nOldComma; aOldRectStream >> nOldLeft >> nOldComma >> nOldTop >> nOldComma >> nOldWidth >> nOldComma >> nOldHeight; const tools::Rectangle aOldRect = tools::Rectangle( nOldLeft, nOldTop, nOldLeft + nOldWidth, nOldTop + nOldHeight); if (nLOKWindowId == aOldTree.get("id", 0)) { if (aNewRect == aOldRect) { SAL_INFO("lok.dialog", "Duplicate rect [" << aNewRect.toString() << "]. Skipping new."); // We have a rectangle in the queue already that makes the current Callback useless. currentIsRedundant = true; return false; } // new one engulfs the old one? else if (aNewRect.Contains(aOldRect)) { SAL_INFO("lok.dialog", "New rect [" << aNewRect.toString() << "] engulfs old [" << aOldRect.toString() << "]. Replacing old."); return true; } // old one engulfs the new one? else if (aOldRect.Contains(aNewRect)) { SAL_INFO("lok.dialog", "Old rect [" << aOldRect.toString() << "] engulfs new [" << aNewRect.toString() << "]. Skipping new."); // We have a rectangle in the queue already that makes the current Callback useless. currentIsRedundant = true; return false; } else { // Overlapping rects. const tools::Rectangle aPreMergeRect = aNewRect; aNewRect.Union(aOldRect); SAL_INFO("lok.dialog", "Merging rects [" << aPreMergeRect.toString() << "] & [" << aOldRect.toString() << "] = [" << aNewRect.toString() << "]. Replacing old."); return true; } } } // keep rest return false; }); // Do not enqueue if redundant. if (currentIsRedundant) return true; aTree.put("rectangle", aNewRect.toString().getStr()); aCallbackData.setJson(aTree); assert(aCallbackData.validate() && "Validation after setJson failed!"); } } else if (aAction == "created") { // Remove all previous actions on same dialog, if we are creating it anew. removeAll(LOK_CALLBACK_WINDOW,[&nLOKWindowId](const CallbackData& elemData) { const boost::property_tree::ptree& aOldTree = elemData.getJson(); if (nLOKWindowId == aOldTree.get("id", 0)) return true; return false; }); VclPtr pWindow = vcl::Window::FindLOKWindow(nLOKWindowId); if (!pWindow) { gImpl->maLastExceptionMsg = "Document doesn't support dialog rendering, or window not found."; return false; } #ifndef IOS auto xClip = forceSetClipboardForCurrentView(m_pDocument); uno::Reference xClipboard(xClip); pWindow->SetClipboard(xClipboard); #endif } else if (aAction == "size_changed") { // A size change is practically re-creation of the window. // But at a minimum it's a full invalidation. removeAll(LOK_CALLBACK_WINDOW, [&nLOKWindowId](const CallbackData& elemData) { const boost::property_tree::ptree& aOldTree = elemData.getJson(); if (nLOKWindowId == aOldTree.get("id", 0)) { const std::string aOldAction = aOldTree.get("action", ""); if (aOldAction == "invalidate") return true; } return false; }); } // Queue this one. return false; } void CallbackFlushHandler::enqueueUpdatedTypes() { if( m_updatedTypes.empty() && m_updatedTypesPerViewId.empty()) return; assert(m_viewId >= 0); SfxViewShell* viewShell = SfxViewShell::GetFirst( false, [this](const SfxViewShell* shell) { return shell->GetViewShellId().get() == m_viewId; } ); assert(viewShell != nullptr); // First move data to local structures, so that callbacks don't possibly modify it. std::vector updatedTypes; std::swap(updatedTypes, m_updatedTypes); boost::container::flat_map> updatedTypesPerViewId; std::swap(updatedTypesPerViewId, m_updatedTypesPerViewId); // Some types must always precede other types, for example // LOK_CALLBACK_TEXT_SELECTION_START and LOK_CALLBACK_TEXT_SELECTION_END // must always precede LOK_CALLBACK_TEXT_SELECTION if present. // Only these types should be present (see isUpdatedType()) and should be processed in this order. static const int orderedUpdatedTypes[] = { LOK_CALLBACK_TEXT_SELECTION_START, LOK_CALLBACK_TEXT_SELECTION_END, LOK_CALLBACK_TEXT_SELECTION }; // Only these types should be present (see isUpdatedTypePerViewId()) and (as of now) // the order doesn't matter. static const int orderedUpdatedTypesPerViewId[] = { LOK_CALLBACK_INVALIDATE_VISIBLE_CURSOR, LOK_CALLBACK_INVALIDATE_VIEW_CURSOR, LOK_CALLBACK_TEXT_VIEW_SELECTION }; for( int type : orderedUpdatedTypes ) { if(o3tl::make_unsigned( type ) < updatedTypes.size() && updatedTypes[ type ]) { enqueueUpdatedType( type, viewShell, m_viewId ); } } for( const auto& it : updatedTypesPerViewId ) { int viewId = it.first; const std::vector& types = it.second; for( int type : orderedUpdatedTypesPerViewId ) { if(o3tl::make_unsigned( type ) < types.size() && types[ type ].set) { SfxViewShell* sourceViewShell = viewShell; const int sourceViewId = types[ type ].sourceViewId; if( sourceViewId != m_viewId ) { assert(sourceViewId >= 0); sourceViewShell = SfxViewShell::GetFirst( false, [sourceViewId](const SfxViewShell* shell) { return shell->GetViewShellId().get() == sourceViewId; } ); } if(sourceViewShell == nullptr) { SAL_INFO("lok", "View #" << sourceViewId << " no longer found for updated event [" << type << "]"); continue; // View removed, probably cleaning up. } enqueueUpdatedType( type, sourceViewShell, viewId ); } } } } void CallbackFlushHandler::enqueueUpdatedType( int type, const SfxViewShell* viewShell, int viewId ) { if (type == LOK_CALLBACK_INVALIDATE_VISIBLE_CURSOR) { if (const SfxViewShell* viewShell2 = LokStarMathHelper(viewShell).GetSmViewShell()) viewShell = viewShell2; } std::optional payload = viewShell->getLOKPayload( type, viewId ); if(!payload) return; // No actual payload to send. CallbackData callbackData(*payload, viewId); m_queue1.emplace_back(type); m_queue2.emplace_back(callbackData); SAL_INFO("lok", "Queued updated [" << type << "]: [" << callbackData.getPayload() << "] to have " << m_queue1.size() << " entries."); } void CallbackFlushHandler::Invoke() { comphelper::ProfileZone aZone("CallbackFlushHandler::Invoke"); if (!m_pCallback) return; // Get any pending invalidate tile events. This will call our callbacks, // so it must be done before taking the mutex. assert(m_viewId >= 0); if(SfxViewShell* viewShell = SfxViewShell::GetFirst( false, [this](const SfxViewShell* shell) { return shell->GetViewShellId().get() == m_viewId; } )) { viewShell->flushPendingLOKInvalidateTiles(); } std::unique_lock lock(m_mutex); // Append messages for updated types, fetch them only now. enqueueUpdatedTypes(); SAL_INFO("lok", "Flushing " << m_queue1.size() << " elements."); auto it1 = m_queue1.begin(); auto it2 = m_queue2.begin(); for (; it1 != m_queue1.end(); ++it1, ++it2) { const int type = *it1; const auto& payload = it2->getPayload(); const int viewId = lcl_isViewCallbackType(type) ? it2->getViewId() : -1; SAL_INFO("lok", "processing event: [" << type << ',' << viewId << "]: [" << payload << "]."); // common code-path for events on this view: if (viewId == -1) { sal_Int32 idx; // key-value pairs if (type == LOK_CALLBACK_STATE_CHANGED && (idx = payload.indexOf('=')) != -1) { OString key = payload.copy(0, idx); OString value = payload.copy(idx+1); const auto stateIt = m_lastStateChange.find(key); if (stateIt != m_lastStateChange.end()) { // If the value didn't change, it's safe to ignore. if (stateIt->second == value) { SAL_INFO("lok", "Skipping new state duplicate: [" << type << "]: [" << payload << "]."); continue; } SAL_INFO("lok", "Replacing a state element [" << type << "]: [" << payload << "]."); stateIt->second = value; } else { SAL_INFO("lok", "Inserted a new state element: [" << type << "]: [" << payload << "]"); m_lastStateChange.emplace(key, value); } } else { const auto stateIt = m_states.find(type); if (stateIt != m_states.end()) { // If the state didn't change, it's safe to ignore. if (stateIt->second == payload) { SAL_INFO("lok", "Skipping duplicate [" << type << "]: [" << payload << "]."); continue; } stateIt->second = payload; } } } else // less common path for events relating to other views { const auto statesIt = m_viewStates.find(viewId); if (statesIt != m_viewStates.end()) { auto& states = statesIt->second; const auto stateIt = states.find(type); if (stateIt != states.end()) { // If the state didn't change, it's safe to ignore. if (stateIt->second == payload) { SAL_INFO("lok", "Skipping view duplicate [" << type << ',' << viewId << "]: [" << payload << "]."); continue; } SAL_INFO("lok", "Replacing an element in view states [" << type << ',' << viewId << "]: [" << payload << "]."); stateIt->second = payload; } else { SAL_INFO("lok", "Inserted a new element in view states: [" << type << ',' << viewId << "]: [" << payload << "]"); states.emplace(type, payload); } } } m_pCallback(type, payload.getStr(), m_pData); } m_queue1.clear(); m_queue2.clear(); Stop(); m_TimeoutIdle.Stop(); } void CallbackFlushHandler::startTimer() { if (!IsActive()) Start(); if (!m_TimeoutIdle.IsActive()) m_TimeoutIdle.Start(); } bool CallbackFlushHandler::removeAll(int type) { bool bErased = false; auto it1 = m_queue1.begin(); for(;;) { it1 = std::find(it1, m_queue1.end(), type); if(it1 == m_queue1.end()) break; m_queue2.erase(toQueue2(it1)); it1 = m_queue1.erase(it1); bErased = true; } return bErased; } bool CallbackFlushHandler::removeAll(int type, const std::function& rTestFunc) { bool bErased = false; auto it1 = m_queue1.begin(); for(;;) { it1 = std::find(it1, m_queue1.end(), type); if(it1 == m_queue1.end()) break; auto it2 = toQueue2(it1); if (rTestFunc(*it2)) { m_queue2.erase(it2); it1 = m_queue1.erase(it1); bErased = true; } else ++it1; } return bErased; } void CallbackFlushHandler::addViewStates(int viewId) { const auto& result = m_viewStates.emplace(viewId, decltype(m_viewStates)::mapped_type()); if (!result.second && result.first != m_viewStates.end()) { result.first->second.clear(); } } void CallbackFlushHandler::removeViewStates(int viewId) { m_viewStates.erase(viewId); } static void doc_destroy(LibreOfficeKitDocument *pThis) { comphelper::ProfileZone aZone("doc_destroy"); SolarMutexGuard aGuard; #ifndef IOS LOKClipboardFactory::releaseClipboardForView(-1); #endif LibLODocument_Impl *pDocument = static_cast(pThis); delete pDocument; } static void lo_destroy (LibreOfficeKit* pThis); static int lo_initialize (LibreOfficeKit* pThis, const char* pInstallPath, const char* pUserProfilePath); static LibreOfficeKitDocument* lo_documentLoad (LibreOfficeKit* pThis, const char* pURL); static char * lo_getError (LibreOfficeKit* pThis); static void lo_freeError (char* pFree); static LibreOfficeKitDocument* lo_documentLoadWithOptions (LibreOfficeKit* pThis, const char* pURL, const char* pOptions); static void lo_registerCallback (LibreOfficeKit* pThis, LibreOfficeKitCallback pCallback, void* pData); static char* lo_getFilterTypes(LibreOfficeKit* pThis); static void lo_setOptionalFeatures(LibreOfficeKit* pThis, unsigned long long features); static void lo_setDocumentPassword(LibreOfficeKit* pThis, const char* pURL, const char* pPassword); static char* lo_getVersionInfo(LibreOfficeKit* pThis); static int lo_runMacro (LibreOfficeKit* pThis, const char* pURL); static bool lo_signDocument(LibreOfficeKit* pThis, const char* pUrl, const unsigned char* pCertificateBinary, const int nCertificateBinarySize, const unsigned char* pPrivateKeyBinary, const int nPrivateKeyBinarySize); static char* lo_extractRequest(LibreOfficeKit* pThis, const char* pFilePath); static void lo_trimMemory(LibreOfficeKit* pThis, int nTarget); static void lo_runLoop(LibreOfficeKit* pThis, LibreOfficeKitPollCallback pPollCallback, LibreOfficeKitWakeCallback pWakeCallback, void* pData); static void lo_sendDialogEvent(LibreOfficeKit* pThis, unsigned long long int nLOKWindowId, const char* pArguments); static void lo_setOption(LibreOfficeKit* pThis, const char* pOption, const char* pValue); static void lo_dumpState(LibreOfficeKit* pThis, const char* pOptions, char** pState); LibLibreOffice_Impl::LibLibreOffice_Impl() : m_pOfficeClass( gOfficeClass.lock() ) , maThread(nullptr) , mpCallback(nullptr) , mpCallbackData(nullptr) , mOptionalFeatures(0) { if(!m_pOfficeClass) { m_pOfficeClass = std::make_shared(); m_pOfficeClass->nSize = sizeof(LibreOfficeKitClass); m_pOfficeClass->destroy = lo_destroy; m_pOfficeClass->documentLoad = lo_documentLoad; m_pOfficeClass->getError = lo_getError; m_pOfficeClass->freeError = lo_freeError; m_pOfficeClass->documentLoadWithOptions = lo_documentLoadWithOptions; m_pOfficeClass->registerCallback = lo_registerCallback; m_pOfficeClass->getFilterTypes = lo_getFilterTypes; m_pOfficeClass->setOptionalFeatures = lo_setOptionalFeatures; m_pOfficeClass->setDocumentPassword = lo_setDocumentPassword; m_pOfficeClass->getVersionInfo = lo_getVersionInfo; m_pOfficeClass->runMacro = lo_runMacro; m_pOfficeClass->signDocument = lo_signDocument; m_pOfficeClass->runLoop = lo_runLoop; m_pOfficeClass->sendDialogEvent = lo_sendDialogEvent; m_pOfficeClass->setOption = lo_setOption; m_pOfficeClass->dumpState = lo_dumpState; m_pOfficeClass->extractRequest = lo_extractRequest; m_pOfficeClass->trimMemory = lo_trimMemory; gOfficeClass = m_pOfficeClass; } pClass = m_pOfficeClass.get(); } LibLibreOffice_Impl::~LibLibreOffice_Impl() { } namespace { #ifdef IOS void paintTileToCGContext(ITiledRenderable* pDocument, void* rCGContext, const Size nCanvasSize, const int nTilePosX, const int nTilePosY, const int nTileWidth, const int nTileHeight) { SystemGraphicsData aData; aData.rCGContext = reinterpret_cast(rCGContext); ScopedVclPtrInstance pDevice(aData, Size(1, 1), DeviceFormat::WITHOUT_ALPHA); pDevice->SetBackground(Wallpaper(COL_TRANSPARENT)); pDevice->SetOutputSizePixel(nCanvasSize); pDocument->paintTile(*pDevice, nCanvasSize.Width(), nCanvasSize.Height(), nTilePosX, nTilePosY, nTileWidth, nTileHeight); } void paintTileIOS(LibreOfficeKitDocument* pThis, unsigned char* pBuffer, const int nCanvasWidth, const int nCanvasHeight, const double fDPIScale, const int nTilePosX, const int nTilePosY, const int nTileWidth, const int nTileHeight) { CGContextRef pCGContext = CGBitmapContextCreate(pBuffer, nCanvasWidth, nCanvasHeight, 8, nCanvasWidth * 4, CGColorSpaceCreateDeviceRGB(), kCGImageAlphaPremultipliedFirst | kCGImageByteOrder32Little); CGContextTranslateCTM(pCGContext, 0, nCanvasHeight); CGContextScaleCTM(pCGContext, fDPIScale, -fDPIScale); doc_paintTileToCGContext(pThis, (void*) pCGContext, nCanvasWidth, nCanvasHeight, nTilePosX, nTilePosY, nTileWidth, nTileHeight); CGContextRelease(pCGContext); } #endif void setLanguageAndLocale(OUString const & aLangISO) { SvtSysLocaleOptions aLocalOptions; aLocalOptions.SetLocaleConfigString(aLangISO); aLocalOptions.SetUILocaleConfigString(aLangISO); aLocalOptions.Commit(); } void setFormatSpecificFilterData(std::u16string_view sFormat, comphelper::SequenceAsHashMap & rFilterDataMap) { if (sFormat == u"pdf") { // always export bookmarks, which is needed for annotations rFilterDataMap["ExportBookmarks"] <<= true; } } } // anonymous namespace // Wonder global state ... static uno::Reference xContext; static uno::Reference xSFactory; static uno::Reference xFactory; static LibreOfficeKitDocument* lo_documentLoad(LibreOfficeKit* pThis, const char* pURL) { return lo_documentLoadWithOptions(pThis, pURL, nullptr); } static LibreOfficeKitDocument* lo_documentLoadWithOptions(LibreOfficeKit* pThis, const char* pURL, const char* pOptions) { comphelper::ProfileZone aZone("lo_documentLoadWithOptions"); SolarMutexGuard aGuard; static int nDocumentIdCounter = 0; LibLibreOffice_Impl* pLib = static_cast(pThis); pLib->maLastExceptionMsg.clear(); const OUString aURL(getAbsoluteURL(pURL)); if (aURL.isEmpty()) { pLib->maLastExceptionMsg = "Filename to load was not provided."; SAL_INFO("lok", "URL for load is empty"); return nullptr; } pLib->maLastExceptionMsg.clear(); if (!xContext.is()) { pLib->maLastExceptionMsg = "ComponentContext is not available"; SAL_INFO("lok", "ComponentContext is not available"); return nullptr; } uno::Reference xComponentLoader = frame::Desktop::create(xContext); if (!xComponentLoader.is()) { pLib->maLastExceptionMsg = "ComponentLoader is not available"; SAL_INFO("lok", "ComponentLoader is not available"); return nullptr; } try { // 'Language=...' is an option that LOK consumes by itself, and does // not pass it as a parameter to the filter OUString aOptions = getUString(pOptions); const OUString aLanguage = extractParameter(aOptions, u"Language"); bool isValidLangTag = LanguageTag::isValidBcp47(aLanguage, nullptr); if (!aLanguage.isEmpty() && isValidLangTag) { static bool isLoading = true; if (isLoading) { // Capture the language used to load the document. SfxLokHelper::setLoadLanguage(aLanguage); isLoading = false; } SfxLokHelper::setDefaultLanguage(aLanguage); // Set the LOK language tag, used for dialog tunneling. comphelper::LibreOfficeKit::setLanguageTag(LanguageTag(aLanguage)); comphelper::LibreOfficeKit::setLocale(LanguageTag(aLanguage)); SAL_INFO("lok", "Set document language to " << aLanguage); // use with care - it sets it for the entire core, not just the // document setLanguageAndLocale(aLanguage); // Need to reset the static initialized values SvNumberFormatter::resetTheCurrencyTable(); } // Set the timezone, if not empty. const OUString aTimezone = extractParameter(aOptions, u"Timezone"); if (!aTimezone.isEmpty()) { SfxLokHelper::setDefaultTimezone(true, aTimezone); } else { // Default to the TZ envar, if set. const char* tz = ::getenv("TZ"); if (tz) { SfxLokHelper::setDefaultTimezone(true, OStringToOUString(tz, RTL_TEXTENCODING_UTF8)); } else { SfxLokHelper::setDefaultTimezone(false, OUString()); } } const OUString aDeviceFormFactor = extractParameter(aOptions, u"DeviceFormFactor"); SfxLokHelper::setDeviceFormFactor(aDeviceFormFactor); const OUString aBatch = extractParameter(aOptions, u"Batch"); if (!aBatch.isEmpty()) { Application::SetDialogCancelMode(DialogCancelMode::LOKSilent); } const OUString sFilterOptions = aOptions; rtl::Reference const pInteraction( new LOKInteractionHandler("load", pLib)); auto const pair(pLib->mInteractionMap.insert(std::make_pair(aURL.toUtf8(), pInteraction))); comphelper::ScopeGuard const g([&] () { if (pair.second) { pLib->mInteractionMap.erase(aURL.toUtf8()); } }); uno::Reference const xInteraction(pInteraction); int nMacroSecurityLevel = 1; const OUString aMacroSecurityLevel = extractParameter(aOptions, u"MacroSecurityLevel"); if (!aMacroSecurityLevel.isEmpty()) { double nNumber; sal_uInt32 nFormat = 1; SvNumberFormatter aFormatter(::comphelper::getProcessComponentContext(), LANGUAGE_ENGLISH_US); if (aFormatter.IsNumberFormat(aMacroSecurityLevel, nFormat, nNumber)) nMacroSecurityLevel = static_cast(nNumber); } SvtSecurityOptions::SetMacroSecurityLevel(nMacroSecurityLevel); #if defined(ANDROID) && HAVE_FEATURE_ANDROID_LOK sal_Int16 nMacroExecMode = document::MacroExecMode::USE_CONFIG; #else const OUString aEnableMacrosExecution = extractParameter(aOptions, u"EnableMacrosExecution"); sal_Int16 nMacroExecMode = aEnableMacrosExecution == "true" ? document::MacroExecMode::USE_CONFIG : document::MacroExecMode::NEVER_EXECUTE; #endif // set AsTemplate explicitly false to be able to load template files // as regular files, otherwise we cannot save them; it will try // to bring saveas dialog which cannot work with LOK case uno::Sequence aFilterOptions{ comphelper::makePropertyValue("FilterOptions", sFilterOptions), comphelper::makePropertyValue("InteractionHandler", xInteraction), comphelper::makePropertyValue("MacroExecutionMode", nMacroExecMode), comphelper::makePropertyValue("AsTemplate", false), comphelper::makePropertyValue("Silent", !aBatch.isEmpty()) }; /* TODO sal_Int16 nUpdateDoc = document::UpdateDocMode::ACCORDING_TO_CONFIG; aFilterOptions[3].Name = "UpdateDocMode"; aFilterOptions[3].Value <<= nUpdateDoc; */ OutputDevice::StartTrackingFontMappingUse(); const int nThisDocumentId = nDocumentIdCounter++; SfxViewShell::SetCurrentDocId(ViewShellDocId(nThisDocumentId)); uno::Reference xComponent = xComponentLoader->loadComponentFromURL( aURL, "_blank", 0, aFilterOptions); assert(!xComponent.is() || pair.second); // concurrent loading of same URL ought to fail if (!xComponent.is()) { pLib->maLastExceptionMsg = "loadComponentFromURL returned an empty reference"; SAL_INFO("lok", "Document can't be loaded - " << pLib->maLastExceptionMsg); return nullptr; } LibLODocument_Impl* pDocument = new LibLODocument_Impl(xComponent, nThisDocumentId); // After loading the document, its initial view is the "current" view. if (pLib->mpCallback) { int nState = doc_getSignatureState(pDocument); pLib->mpCallback(LOK_CALLBACK_SIGNATURE_STATUS, OString::number(nState).getStr(), pLib->mpCallbackData); } auto aFontMappingUseData = OutputDevice::FinishTrackingFontMappingUse(); if (aFontMappingUseData.size() > 0) { SAL_INFO("lok.fontsubst", "================ Original substitutions:"); for (const auto &i : aFontMappingUseData) { SAL_INFO("lok.fontsubst", i.mOriginalFont); for (const auto &j : i.mUsedFonts) SAL_INFO("lok.fontsubst", " " << j); } } // Filter out font substitutions that actually aren't any substitutions, like "Liberation // Serif" -> "Liberation Serif/Regular". If even one of the "substitutions" of a font is to // the same font, don't count that as a missing font. aFontMappingUseData.erase (std::remove_if(aFontMappingUseData.begin(), aFontMappingUseData.end(), [](OutputDevice::FontMappingUseItem x) { // If the original font had an empty style and one of its // replacement fonts has the same family name, we assume the font is // present. The root problem here is that the code that collects // font substitutions tends to get just empty styles for the font // that is being substituted, as vcl::Font::GetStyleName() tends to // return an empty string. (Italicness is instead indicated by what // vcl::Font::GetItalic() returns and boldness by what // vcl::Font::GetWeight() returns.) if (x.mOriginalFont.indexOf('/') == -1) for (const auto &j : x.mUsedFonts) if (j == x.mOriginalFont || j.startsWith(Concat2View(x.mOriginalFont + "/"))) return true; return false; }), aFontMappingUseData.end()); // Filter out substitutions where a proprietary font has been substituted by a // metric-compatible one. Obviously this is just a heuristic and implemented only for some // well-known cases. aFontMappingUseData.erase (std::remove_if(aFontMappingUseData.begin(), aFontMappingUseData.end(), [](OutputDevice::FontMappingUseItem x) { // Again, handle only cases where the original font does not include // a style. Unclear whether there ever will be a style part included // in the mOriginalFont. if (x.mOriginalFont.indexOf('/') == -1) for (const auto &j : x.mUsedFonts) if ((x.mOriginalFont == "Arial" && j.startsWith("Liberation Sans/")) || (x.mOriginalFont == "Times New Roman" && j.startsWith("Liberation Serif/")) || (x.mOriginalFont == "Courier New" && j.startsWith("Liberation Mono/")) || (x.mOriginalFont == "Arial Narrow" && j.startsWith("Liberation Sans Narrow/")) || (x.mOriginalFont == "Cambria" && j.startsWith("Caladea/")) || (x.mOriginalFont == "Calibri" && j.startsWith("Carlito/")) || (x.mOriginalFont == "Palatino Linotype" && j.startsWith("P052/")) || // Perhaps a risky heuristic? If some glyphs from Symbol // have been mapped to ones in OpenSymbol, don't warn // that Symbol is missing. (x.mOriginalFont == "Symbol" && j.startsWith("OpenSymbol/"))) { return true; } return false; }), aFontMappingUseData.end()); if (aFontMappingUseData.size() > 0) { SAL_INFO("lok.fontsubst", "================ Pruned substitutions:"); for (const auto &i : aFontMappingUseData) { SAL_INFO("lok.fontsubst", i.mOriginalFont); for (const auto &j : i.mUsedFonts) SAL_INFO("lok.fontsubst", " " << j); } } for (std::size_t i = 0; i < aFontMappingUseData.size(); ++i) { pDocument->maFontsMissing.insert(aFontMappingUseData[i].mOriginalFont); } return pDocument; } catch (const uno::Exception& exception) { pLib->maLastExceptionMsg = exception.Message; TOOLS_INFO_EXCEPTION("lok", "Document can't be loaded"); } return nullptr; } static int lo_runMacro(LibreOfficeKit* pThis, const char *pURL) { comphelper::ProfileZone aZone("lo_runMacro"); SolarMutexGuard aGuard; LibLibreOffice_Impl* pLib = static_cast(pThis); pLib->maLastExceptionMsg.clear(); OUString sURL( pURL, strlen(pURL), RTL_TEXTENCODING_UTF8 ); if (sURL.isEmpty()) { pLib->maLastExceptionMsg = "Macro to run was not provided."; SAL_INFO("lok", "Macro URL is empty"); return false; } if (!sURL.startsWith("macro://")) { pLib->maLastExceptionMsg = "This doesn't look like macro URL"; SAL_INFO("lok", "Macro URL is invalid"); return false; } pLib->maLastExceptionMsg.clear(); if (!xContext.is()) { pLib->maLastExceptionMsg = "ComponentContext is not available"; SAL_INFO("lok", "ComponentContext is not available"); return false; } util::URL aURL; aURL.Complete = sURL; uno::Reference < util::XURLTransformer > xParser( util::URLTransformer::create( xContext ) ); if( xParser.is() ) xParser->parseStrict( aURL ); uno::Reference xComponentLoader = frame::Desktop::create(xContext); if (!xComponentLoader.is()) { pLib->maLastExceptionMsg = "ComponentLoader is not available"; SAL_INFO("lok", "ComponentLoader is not available"); return false; } xFactory = xContext->getServiceManager(); if (!xFactory) return false; uno::Reference xDP; xSFactory.set(xFactory, uno::UNO_QUERY_THROW); xDP.set( xSFactory->createInstance("com.sun.star.comp.sfx2.SfxMacroLoader"), uno::UNO_QUERY ); uno::Reference xD = xDP->queryDispatch( aURL, OUString(), 0); if (!xD.is()) { pLib->maLastExceptionMsg = "Macro loader is not available"; SAL_INFO("lok", "Macro loader is not available"); return false; } uno::Reference < frame::XSynchronousDispatch > xSyncDisp( xD, uno::UNO_QUERY_THROW ); uno::Sequence aEmpty; css::beans::PropertyValue aErr; uno::Any aRet = xSyncDisp->dispatchWithReturnValue( aURL, aEmpty ); aRet >>= aErr; if (aErr.Name == "ErrorCode") { sal_uInt32 nErrCode = 0; // ERRCODE_NONE aErr.Value >>= nErrCode; pLib->maLastExceptionMsg = "An error occurred running macro (error code: " + OUString::number( nErrCode ) + ")"; SAL_INFO("lok", "Macro execution terminated with error code " << nErrCode); return false; } return true; } static bool lo_signDocument(LibreOfficeKit* /*pThis*/, const char* pURL, const unsigned char* pCertificateBinary, const int nCertificateBinarySize, const unsigned char* pPrivateKeyBinary, const int nPrivateKeyBinarySize) { comphelper::ProfileZone aZone("lo_signDocument"); OUString aURL(getAbsoluteURL(pURL)); if (aURL.isEmpty()) return false; if (!xContext.is()) return false; uno::Sequence aCertificateSequence; std::string aCertificateString(reinterpret_cast(pCertificateBinary), nCertificateBinarySize); std::string aCertificateBase64String = extractCertificate(aCertificateString); if (!aCertificateBase64String.empty()) { OUString aBase64OUString = OUString::createFromAscii(aCertificateBase64String.c_str()); comphelper::Base64::decode(aCertificateSequence, aBase64OUString); } else { aCertificateSequence.realloc(nCertificateBinarySize); std::copy(pCertificateBinary, pCertificateBinary + nCertificateBinarySize, aCertificateSequence.getArray()); } uno::Sequence aPrivateKeySequence; std::string aPrivateKeyString(reinterpret_cast(pPrivateKeyBinary), nPrivateKeyBinarySize); std::string aPrivateKeyBase64String = extractPrivateKey(aPrivateKeyString); if (!aPrivateKeyBase64String.empty()) { OUString aBase64OUString = OUString::createFromAscii(aPrivateKeyBase64String.c_str()); comphelper::Base64::decode(aPrivateKeySequence, aBase64OUString); } else { aPrivateKeySequence.realloc(nPrivateKeyBinarySize); std::copy(pPrivateKeyBinary, pPrivateKeyBinary + nPrivateKeyBinarySize, aPrivateKeySequence.getArray()); } uno::Reference xSEInitializer = xml::crypto::SEInitializer::create(xContext); uno::Reference xSecurityContext = xSEInitializer->createSecurityContext(OUString()); if (!xSecurityContext.is()) return false; uno::Reference xSecurityEnvironment = xSecurityContext->getSecurityEnvironment(); uno::Reference xCertificateCreator(xSecurityEnvironment, uno::UNO_QUERY); if (!xCertificateCreator.is()) return false; uno::Reference xCertificate = xCertificateCreator->createDERCertificateWithPrivateKey(aCertificateSequence, aPrivateKeySequence); if (!xCertificate.is()) return false; sfx2::DocumentSigner aDocumentSigner(aURL); if (!aDocumentSigner.signDocument(xCertificate)) return false; return true; } static char* lo_extractRequest(LibreOfficeKit* /*pThis*/, const char* pFilePath) { uno::Reference xComponentLoader = frame::Desktop::create(xContext); uno::Reference< css::lang::XComponent > xComp; OUString aURL(getAbsoluteURL(pFilePath)); OUString result; if (!aURL.isEmpty()) { if (xComponentLoader.is()) { try { uno::Sequence aFilterOptions(comphelper::InitPropertySequence( { {"Hidden", css::uno::Any(true)}, {"ReadOnly", css::uno::Any(true)} })); xComp = xComponentLoader->loadComponentFromURL( aURL, "_blank", 0, aFilterOptions ); } catch ( const lang::IllegalArgumentException& ex ) { SAL_WARN("lok", "lo_extractRequest: IllegalArgumentException: " << ex.Message); result = "{ }"; return convertOUString(result); } catch (...) { SAL_WARN("lok", "lo_extractRequest: Exception on loadComponentFromURL, url= " << aURL); result = "{ }"; return convertOUString(result); } if (xComp.is()) { uno::Reference< document::XLinkTargetSupplier > xLTS( xComp, uno::UNO_QUERY ); if( xLTS.is() ) { OUStringBuffer jsonText("{ \"Targets\": { "); bool lastParentheses = extractLinks(xLTS->getLinks(), false, jsonText); jsonText.append("} }"); if (!lastParentheses) jsonText.append(" }"); OUString res(jsonText.makeStringAndClear()); return convertOUString(res); } xComp->dispose(); } else { result = "{ }"; return convertOUString(result); } } } result = "{ }"; return convertOUString(result); } static void lo_trimMemory(LibreOfficeKit* /* pThis */, int nTarget) { vcl::lok::trimMemory(nTarget); } static void lo_registerCallback (LibreOfficeKit* pThis, LibreOfficeKitCallback pCallback, void* pData) { SolarMutexGuard aGuard; Application* pApp = GetpApp(); assert(pApp); LibLibreOffice_Impl* pLib = static_cast(pThis); pLib->maLastExceptionMsg.clear(); pApp->m_pCallback = pLib->mpCallback = pCallback; pApp->m_pCallbackData = pLib->mpCallbackData = pData; } static int doc_saveAs(LibreOfficeKitDocument* pThis, const char* sUrl, const char* pFormat, const char* pFilterOptions) { comphelper::ProfileZone aZone("doc_saveAs"); SolarMutexGuard aGuard; SetLastExceptionMsg(); LibLODocument_Impl* pDocument = static_cast(pThis); OUString sFormat = getUString(pFormat); OUString aURL(getAbsoluteURL(sUrl)); uno::Reference xStorable(pDocument->mxComponent, uno::UNO_QUERY_THROW); if (aURL.isEmpty()) { SetLastExceptionMsg("Filename to save to was not provided."); SAL_INFO("lok", "URL for save is empty"); return false; } try { const ExtensionMap* pMap; switch (doc_getDocumentType(pThis)) { case LOK_DOCTYPE_SPREADSHEET: pMap = aCalcExtensionMap; break; case LOK_DOCTYPE_PRESENTATION: pMap = aImpressExtensionMap; break; case LOK_DOCTYPE_DRAWING: pMap = aDrawExtensionMap; break; case LOK_DOCTYPE_TEXT: pMap = aWriterExtensionMap; break; case LOK_DOCTYPE_OTHER: default: SAL_INFO("lok", "Can't save document - unsupported document type."); return false; } if (pFormat == nullptr) { // sniff from the extension sal_Int32 idx = aURL.lastIndexOf("."); if( idx > 0 ) { sFormat = aURL.copy( idx + 1 ); } else { SetLastExceptionMsg("input URL '" + aURL + "' lacks a suffix"); return false; } } OUString aFilterName; for (sal_Int32 i = 0; pMap[i].extn; ++i) { if (sFormat.equalsIgnoreAsciiCaseAscii(pMap[i].extn)) { aFilterName = getUString(pMap[i].filterName); break; } } if (aFilterName.isEmpty()) { SetLastExceptionMsg("no output filter found for provided suffix"); return false; } OUString aFilterOptions = getUString(pFilterOptions); // Check if watermark for pdf is passed by filteroptions... // It is not a real filter option so it must be filtered out. OUString watermarkText; std::u16string_view sFullSheetPreview; int aIndex = -1; if ((aIndex = aFilterOptions.indexOf(",Watermark=")) >= 0) { int bIndex = aFilterOptions.indexOf("WATERMARKEND"); watermarkText = aFilterOptions.subView(aIndex+11, bIndex-(aIndex+11)); aFilterOptions = OUString::Concat(aFilterOptions.subView(0, aIndex)) + aFilterOptions.subView(bIndex+12); } if ((aIndex = aFilterOptions.indexOf(",FullSheetPreview=")) >= 0) { int bIndex = aFilterOptions.indexOf("FULLSHEETPREVEND"); sFullSheetPreview = aFilterOptions.subView(aIndex+18, bIndex-(aIndex+18)); aFilterOptions = OUString::Concat(aFilterOptions.subView(0, aIndex)) + aFilterOptions.subView(bIndex+16); } bool bFullSheetPreview = sFullSheetPreview == u"true"; // Select a pdf version if specified a valid one. If not specified then ignore. // If invalid then fail. sal_Int32 pdfVer = 0; if ((aIndex = aFilterOptions.indexOf(",PDFVer=")) >= 0) { int bIndex = aFilterOptions.indexOf("PDFVEREND"); std::u16string_view sPdfVer = aFilterOptions.subView(aIndex+8, bIndex-(aIndex+8)); aFilterOptions = OUString::Concat(aFilterOptions.subView(0, aIndex)) + aFilterOptions.subView(bIndex+9); if (o3tl::equalsIgnoreAsciiCase(sPdfVer, u"PDF/A-1b")) pdfVer = 1; else if (o3tl::equalsIgnoreAsciiCase(sPdfVer, u"PDF/A-2b")) pdfVer = 2; else if (o3tl::equalsIgnoreAsciiCase(sPdfVer, u"PDF/A-3b")) pdfVer = 3; else if (o3tl::equalsIgnoreAsciiCase(sPdfVer, u"PDF-1.5")) pdfVer = 15; else if (o3tl::equalsIgnoreAsciiCase(sPdfVer, u"PDF-1.6")) pdfVer = 16; else { SetLastExceptionMsg("wrong PDF version"); return false; } } // 'TakeOwnership' == this is a 'real' SaveAs (that is, the document // gets a new name). When this is not provided, the meaning of // saveAs() is more like save-a-copy, which allows saving to any // random format like PDF or PNG. // It is not a real filter option, so we have to filter it out. const uno::Sequence aOptionSeq = comphelper::string::convertCommaSeparated(aFilterOptions); std::vector aFilteredOptionVec; bool bTakeOwnership = false; MediaDescriptor aSaveMediaDescriptor; for (const auto& rOption : aOptionSeq) { if (rOption == "TakeOwnership") bTakeOwnership = true; else if (rOption == "NoFileSync") aSaveMediaDescriptor["NoFileSync"] <<= true; else aFilteredOptionVec.push_back(rOption); } aSaveMediaDescriptor["Overwrite"] <<= true; aSaveMediaDescriptor["FilterName"] <<= aFilterName; auto aFilteredOptionSeq = comphelper::containerToSequence(aFilteredOptionVec); aFilterOptions = comphelper::string::convertCommaSeparated(aFilteredOptionSeq); aSaveMediaDescriptor[MediaDescriptor::PROP_FILTEROPTIONS] <<= aFilterOptions; comphelper::SequenceAsHashMap aFilterDataMap; // If filter options is JSON string, then make sure aFilterDataMap stays empty, otherwise we // would ignore the filter options. if (!aFilterOptions.startsWith("{")) { setFormatSpecificFilterData(sFormat, aFilterDataMap); } if (!watermarkText.isEmpty()) aFilterDataMap["TiledWatermark"] <<= watermarkText; if (bFullSheetPreview) aFilterDataMap["SinglePageSheets"] <<= true; if (pdfVer) aFilterDataMap["SelectPdfVersion"] <<= pdfVer; if (!aFilterDataMap.empty()) { aSaveMediaDescriptor["FilterData"] <<= aFilterDataMap.getAsConstPropertyValueList(); } // add interaction handler too if (gImpl) { // gImpl does not have to exist when running from a unit test rtl::Reference const pInteraction( new LOKInteractionHandler("saveas", gImpl, pDocument)); uno::Reference const xInteraction(pInteraction); aSaveMediaDescriptor[MediaDescriptor::PROP_INTERACTIONHANDLER] <<= xInteraction; } if (bTakeOwnership) xStorable->storeAsURL(aURL, aSaveMediaDescriptor.getAsConstPropertyValueList()); else xStorable->storeToURL(aURL, aSaveMediaDescriptor.getAsConstPropertyValueList()); return true; } catch (const uno::Exception& exception) { SetLastExceptionMsg("exception: " + exception.Message); } return false; } /** * Initialize UNO commands, in the sense that from now on, the LOK client gets updates for status * changes of these commands. This is necessary, because (unlike in the desktop case) there are no * toolbars hosting widgets these UNO commands, so no such status updates would be sent to the * headless LOK clients out of the box. */ static void doc_iniUnoCommands () { SolarMutexGuard aGuard; SetLastExceptionMsg(); OUString sUnoCommands[] = { OUString(".uno:AlignLeft"), OUString(".uno:AlignHorizontalCenter"), OUString(".uno:AlignRight"), OUString(".uno:BackColor"), OUString(".uno:BackgroundColor"), OUString(".uno:TableCellBackgroundColor"), OUString(".uno:Bold"), OUString(".uno:CenterPara"), OUString(".uno:CharBackColor"), OUString(".uno:CharBackgroundExt"), OUString(".uno:CharFontName"), OUString(".uno:Color"), OUString(".uno:ControlCodes"), OUString(".uno:DecrementIndent"), OUString(".uno:DefaultBullet"), OUString(".uno:DefaultNumbering"), OUString(".uno:FontColor"), OUString(".uno:FontHeight"), OUString(".uno:IncrementIndent"), OUString(".uno:Italic"), OUString(".uno:JustifyPara"), OUString(".uno:JumpToMark"), OUString(".uno:OutlineFont"), OUString(".uno:LeftPara"), OUString(".uno:LanguageStatus"), OUString(".uno:RightPara"), OUString(".uno:Shadowed"), OUString(".uno:SubScript"), OUString(".uno:SuperScript"), OUString(".uno:Strikeout"), OUString(".uno:StyleApply"), OUString(".uno:Underline"), OUString(".uno:ModifiedStatus"), OUString(".uno:Undo"), OUString(".uno:Redo"), OUString(".uno:InsertPage"), OUString(".uno:DeletePage"), OUString(".uno:DuplicatePage"), OUString(".uno:InsertSlide"), OUString(".uno:DeleteSlide"), OUString(".uno:DuplicateSlide"), OUString(".uno:ChangeTheme"), OUString(".uno:Cut"), OUString(".uno:Copy"), OUString(".uno:Paste"), OUString(".uno:SelectAll"), OUString(".uno:ReplyComment"), OUString(".uno:ResolveComment"), OUString(".uno:ResolveCommentThread"), OUString(".uno:InsertRowsBefore"), OUString(".uno:InsertRowsAfter"), OUString(".uno:InsertColumnsBefore"), OUString(".uno:InsertColumnsAfter"), OUString(".uno:DeleteRows"), OUString(".uno:DeleteColumns"), OUString(".uno:DeleteTable"), OUString(".uno:SelectTable"), OUString(".uno:EntireRow"), OUString(".uno:EntireColumn"), OUString(".uno:EntireCell"), OUString(".uno:AssignLayout"), OUString(".uno:StatusDocPos"), OUString(".uno:RowColSelCount"), OUString(".uno:StatusPageStyle"), OUString(".uno:InsertMode"), OUString(".uno:SpellOnline"), OUString(".uno:StatusSelectionMode"), OUString(".uno:StateTableCell"), OUString(".uno:StatusBarFunc"), OUString(".uno:StatePageNumber"), OUString(".uno:StateWordCount"), OUString(".uno:SelectionMode"), OUString(".uno:PageStatus"), OUString(".uno:LayoutStatus"), OUString(".uno:Scale"), OUString(".uno:Context"), OUString(".uno:WrapText"), OUString(".uno:ToggleMergeCells"), OUString(".uno:NumberFormatCurrency"), OUString(".uno:NumberFormatPercent"), OUString(".uno:NumberFormatDecimal"), OUString(".uno:NumberFormatDate"), OUString(".uno:EditHeaderAndFooter"), OUString(".uno:FrameLineColor"), OUString(".uno:SortAscending"), OUString(".uno:SortDescending"), OUString(".uno:TrackChanges"), OUString(".uno:ShowTrackedChanges"), OUString(".uno:NextTrackedChange"), OUString(".uno:PreviousTrackedChange"), OUString(".uno:AcceptAllTrackedChanges"), OUString(".uno:RejectAllTrackedChanges"), OUString(".uno:TableDialog"), OUString(".uno:FormatCellDialog"), OUString(".uno:FontDialog"), OUString(".uno:ParagraphDialog"), OUString(".uno:OutlineBullet"), OUString(".uno:InsertIndexesEntry"), OUString(".uno:DocumentRepair"), OUString(".uno:TransformDialog"), OUString(".uno:InsertPageHeader"), OUString(".uno:InsertPageFooter"), OUString(".uno:OnlineAutoFormat"), OUString(".uno:InsertObjectChart"), OUString(".uno:InsertSection"), OUString(".uno:InsertAnnotation"), OUString(".uno:DeleteAnnotation"), OUString(".uno:InsertPagebreak"), OUString(".uno:InsertColumnBreak"), OUString(".uno:HyperlinkDialog"), OUString(".uno:InsertSymbol"), OUString(".uno:EditRegion"), OUString(".uno:ThesaurusDialog"), OUString(".uno:FormatArea"), OUString(".uno:FormatLine"), OUString(".uno:FormatColumns"), OUString(".uno:Watermark"), OUString(".uno:ResetAttributes"), OUString(".uno:Orientation"), OUString(".uno:ObjectAlignLeft"), OUString(".uno:ObjectAlignRight"), OUString(".uno:AlignCenter"), OUString(".uno:TransformPosX"), OUString(".uno:TransformPosY"), OUString(".uno:TransformWidth"), OUString(".uno:TransformHeight"), OUString(".uno:ObjectBackOne"), OUString(".uno:SendToBack"), OUString(".uno:ObjectForwardOne"), OUString(".uno:BringToFront"), OUString(".uno:WrapRight"), OUString(".uno:WrapThrough"), OUString(".uno:WrapLeft"), OUString(".uno:WrapIdeal"), OUString(".uno:WrapOn"), OUString(".uno:WrapOff"), OUString(".uno:UpdateCurIndex"), OUString(".uno:InsertCaptionDialog"), OUString(".uno:FormatGroup"), OUString(".uno:SplitTable"), OUString(".uno:SplitCell"), OUString(".uno:MergeCells"), OUString(".uno:DeleteNote"), OUString(".uno:AcceptChanges"), OUString(".uno:FormatPaintbrush"), OUString(".uno:SetDefault"), OUString(".uno:ParaLeftToRight"), OUString(".uno:ParaRightToLeft"), OUString(".uno:ParaspaceIncrease"), OUString(".uno:ParaspaceDecrease"), OUString(".uno:AcceptTrackedChange"), OUString(".uno:RejectTrackedChange"), OUString(".uno:ShowResolvedAnnotations"), OUString(".uno:InsertBreak"), OUString(".uno:InsertEndnote"), OUString(".uno:InsertFootnote"), OUString(".uno:InsertReferenceField"), OUString(".uno:InsertBookmark"), OUString(".uno:InsertAuthoritiesEntry"), OUString(".uno:InsertMultiIndex"), OUString(".uno:InsertField"), OUString(".uno:PageNumberWizard"), OUString(".uno:InsertPageNumberField"), OUString(".uno:InsertPageCountField"), OUString(".uno:InsertDateField"), OUString(".uno:InsertTitleField"), OUString(".uno:InsertFieldCtrl"), OUString(".uno:CharmapControl"), OUString(".uno:EnterGroup"), OUString(".uno:LeaveGroup"), OUString(".uno:AlignUp"), OUString(".uno:AlignMiddle"), OUString(".uno:AlignDown"), OUString(".uno:TraceChangeMode"), OUString(".uno:Combine"), OUString(".uno:Merge"), OUString(".uno:Dismantle"), OUString(".uno:Substract"), OUString(".uno:DistributeSelection"), OUString(".uno:Intersect"), OUString(".uno:BorderInner"), OUString(".uno:BorderOuter"), OUString(".uno:FreezePanes"), OUString(".uno:FreezePanesColumn"), OUString(".uno:FreezePanesRow"), OUString(".uno:Sidebar"), OUString(".uno:SheetRightToLeft"), OUString(".uno:RunMacro"), OUString(".uno:SpacePara1"), OUString(".uno:SpacePara15"), OUString(".uno:SpacePara2"), OUString(".uno:InsertSparkline"), OUString(".uno:DeleteSparkline"), OUString(".uno:DeleteSparklineGroup"), OUString(".uno:EditSparklineGroup"), OUString(".uno:EditSparkline"), OUString(".uno:GroupSparklines"), OUString(".uno:UngroupSparklines"), OUString(".uno:FormatSparklineMenu"), OUString(".uno:Protect"), OUString(".uno:UnsetCellsReadOnly"), OUString(".uno:ContentControlProperties"), OUString(".uno:InsertCheckboxContentControl"), OUString(".uno:InsertContentControl"), OUString(".uno:InsertDateContentControl"), OUString(".uno:InsertDropdownContentControl"), OUString(".uno:InsertPlainTextContentControl"), OUString(".uno:InsertPictureContentControl") }; util::URL aCommandURL; SfxViewShell* pViewShell = SfxViewShell::Current(); SfxViewFrame* pViewFrame = pViewShell ? &pViewShell->GetViewFrame() : nullptr; // check if Frame-Controller were created. if (!pViewFrame) { SAL_WARN("lok", "iniUnoCommands: No Frame-Controller created."); return; } if (!xContext.is()) xContext = comphelper::getProcessComponentContext(); if (!xContext.is()) { SAL_WARN("lok", "iniUnoCommands: Component context is not available"); return; } #if !defined IOS && !defined ANDROID && !defined __EMSCRIPTEN__ uno::Reference xSEInitializer = xml::crypto::SEInitializer::create(xContext); if (!xSEInitializer.is()) { SAL_WARN("lok", "iniUnoCommands: XSEInitializer is not available"); return; } uno::Reference xSecurityContext = xSEInitializer->createSecurityContext(OUString()); if (!xSecurityContext.is()) { SAL_WARN("lok", "iniUnoCommands: failed to create security context"); } #endif SfxSlotPool& rSlotPool = SfxSlotPool::GetSlotPool(pViewFrame); uno::Reference xParser(util::URLTransformer::create(xContext)); for (const auto & sUnoCommand : sUnoCommands) { aCommandURL.Complete = sUnoCommand; xParser->parseStrict(aCommandURL); // when null, this command is not supported by the given component // (like eg. Calc does not have ".uno:DefaultBullet" etc.) if (const SfxSlot* pSlot = rSlotPool.GetUnoSlot(aCommandURL.Path)) { // Initialize slot to dispatch .uno: Command. pViewFrame->GetBindings().GetDispatch(pSlot, aCommandURL, false); } } } static int doc_getDocumentType (LibreOfficeKitDocument* pThis) { comphelper::ProfileZone aZone("doc_getDocumentType"); SolarMutexGuard aGuard; SetLastExceptionMsg(); LibLODocument_Impl* pDocument = static_cast(pThis); try { uno::Reference xDocument(pDocument->mxComponent, uno::UNO_QUERY_THROW); if (xDocument->supportsService("com.sun.star.sheet.SpreadsheetDocument")) { return LOK_DOCTYPE_SPREADSHEET; } else if (xDocument->supportsService("com.sun.star.presentation.PresentationDocument")) { return LOK_DOCTYPE_PRESENTATION; } else if (xDocument->supportsService("com.sun.star.drawing.DrawingDocument")) { return LOK_DOCTYPE_DRAWING; } else if (xDocument->supportsService("com.sun.star.text.TextDocument") || xDocument->supportsService("com.sun.star.text.WebDocument")) { return LOK_DOCTYPE_TEXT; } else { SetLastExceptionMsg("unknown document type"); } } catch (const uno::Exception& exception) { SetLastExceptionMsg("exception: " + exception.Message); } return LOK_DOCTYPE_OTHER; } static int doc_getParts (LibreOfficeKitDocument* pThis) { comphelper::ProfileZone aZone("doc_getParts"); SolarMutexGuard aGuard; ITiledRenderable* pDoc = getTiledRenderable(pThis); if (!pDoc) { SetLastExceptionMsg("Document doesn't support tiled rendering"); return 0; } return pDoc->getParts(); } static int doc_getPart (LibreOfficeKitDocument* pThis) { comphelper::ProfileZone aZone("doc_getPart"); SolarMutexGuard aGuard; SetLastExceptionMsg(); ITiledRenderable* pDoc = getTiledRenderable(pThis); if (!pDoc) { SetLastExceptionMsg("Document doesn't support tiled rendering"); return 0; } return pDoc->getPart(); } static void doc_setPartImpl(LibreOfficeKitDocument* pThis, int nPart, bool bAllowChangeFocus = true) { comphelper::ProfileZone aZone("doc_setPart"); SolarMutexGuard aGuard; SetLastExceptionMsg(); ITiledRenderable* pDoc = getTiledRenderable(pThis); if (!pDoc) { SetLastExceptionMsg("Document doesn't support tiled rendering"); return; } pDoc->setPart( nPart, bAllowChangeFocus ); } static void doc_setPart(LibreOfficeKitDocument* pThis, int nPart) { doc_setPartImpl(pThis, nPart, true); } static char* doc_getPartInfo(LibreOfficeKitDocument* pThis, int nPart) { comphelper::ProfileZone aZone("doc_getPartInfo"); SolarMutexGuard aGuard; ITiledRenderable* pDoc = getTiledRenderable(pThis); if (!pDoc) { SetLastExceptionMsg("Document doesn't support tiled rendering"); return nullptr; } return convertOUString(pDoc->getPartInfo(nPart)); } static void doc_selectPart(LibreOfficeKitDocument* pThis, int nPart, int nSelect) { SolarMutexGuard aGuard; if (gImpl) gImpl->maLastExceptionMsg.clear(); ITiledRenderable* pDoc = getTiledRenderable(pThis); if (!pDoc) { gImpl->maLastExceptionMsg = "Document doesn't support tiled rendering"; return; } pDoc->selectPart( nPart, nSelect ); } static void doc_moveSelectedParts(LibreOfficeKitDocument* pThis, int nPosition, bool bDuplicate) { SolarMutexGuard aGuard; if (gImpl) gImpl->maLastExceptionMsg.clear(); ITiledRenderable* pDoc = getTiledRenderable(pThis); if (!pDoc) { gImpl->maLastExceptionMsg = "Document doesn't support tiled rendering"; return; } pDoc->moveSelectedParts(nPosition, bDuplicate); } static char* doc_getPartPageRectangles(LibreOfficeKitDocument* pThis) { comphelper::ProfileZone aZone("doc_getPartPageRectangles"); SolarMutexGuard aGuard; SetLastExceptionMsg(); ITiledRenderable* pDoc = getTiledRenderable(pThis); if (!pDoc) { SetLastExceptionMsg("Document doesn't support tiled rendering"); return nullptr; } return convertOUString(pDoc->getPartPageRectangles()); } static char* doc_getPartName(LibreOfficeKitDocument* pThis, int nPart) { comphelper::ProfileZone aZone("doc_getPartName"); SolarMutexGuard aGuard; SetLastExceptionMsg(); ITiledRenderable* pDoc = getTiledRenderable(pThis); if (!pDoc) { SetLastExceptionMsg("Document doesn't support tiled rendering"); return nullptr; } return convertOUString(pDoc->getPartName(nPart)); } static char* doc_getPartHash(LibreOfficeKitDocument* pThis, int nPart) { comphelper::ProfileZone aZone("doc_getPartHash"); SolarMutexGuard aGuard; SetLastExceptionMsg(); ITiledRenderable* pDoc = getTiledRenderable(pThis); if (!pDoc) { SetLastExceptionMsg("Document doesn't support tiled rendering"); return nullptr; } return convertOUString(pDoc->getPartHash(nPart)); } static void doc_setPartMode(LibreOfficeKitDocument* pThis, int nPartMode) { comphelper::ProfileZone aZone("doc_setPartMode"); SolarMutexGuard aGuard; SetLastExceptionMsg(); ITiledRenderable* pDoc = getTiledRenderable(pThis); if (!pDoc) { SetLastExceptionMsg("Document doesn't support tiled rendering"); return; } int nCurrentPart = pDoc->getPart(); pDoc->setPartMode(nPartMode); // We need to make sure the internal state is updated, just changing the mode // might not update the relevant shells (i.e. impress will keep rendering the // previous mode unless we do this). // TODO: we might want to do this within the relevant components rather than // here, but that's also dependent on how we implement embedded object // rendering I guess? // TODO: we could be clever and e.g. set to 0 when we change to/from // embedded object mode, and not when changing between slide/notes/combined // modes? if ( nCurrentPart < pDoc->getParts() ) { pDoc->setPart( nCurrentPart ); } else { pDoc->setPart( 0 ); } } static int doc_getEditMode(LibreOfficeKitDocument* pThis) { comphelper::ProfileZone aZone("doc_getEditMode"); SolarMutexGuard aGuard; SetLastExceptionMsg(); ITiledRenderable* pDoc = getTiledRenderable(pThis); if (!pDoc) { SetLastExceptionMsg("Document doesn't support tiled rendering"); return 0; } return pDoc->getEditMode(); } static void doc_paintTile(LibreOfficeKitDocument* pThis, unsigned char* pBuffer, const int nCanvasWidth, const int nCanvasHeight, const int nTilePosX, const int nTilePosY, const int nTileWidth, const int nTileHeight) { comphelper::ProfileZone aZone("doc_paintTile"); SolarMutexGuard aGuard; SetLastExceptionMsg(); SAL_INFO( "lok.tiledrendering", "paintTile: painting [" << nTileWidth << "x" << nTileHeight << "]@(" << nTilePosX << ", " << nTilePosY << ") to [" << nCanvasWidth << "x" << nCanvasHeight << "]px" ); ITiledRenderable* pDoc = getTiledRenderable(pThis); if (!pDoc) { SetLastExceptionMsg("Document doesn't support tiled rendering"); return; } #if defined(UNX) && !defined(MACOSX) || defined(_WIN32) // Painting of zoomed or HiDPI spreadsheets is special, we actually draw everything at 100%, // and only set cairo's (or CoreGraphic's, in the iOS case) scale factor accordingly, so that // everything is painted bigger or smaller. This is different to what Calc's internal scaling // would do - because that one is trying to fit the lines between cells to integer multiples of // pixels. comphelper::ScopeGuard dpiScaleGuard([]() { comphelper::LibreOfficeKit::setDPIScale(1.0); }); #if defined(IOS) double fDPIScaleX = 1.0; paintTileIOS(pThis, pBuffer, nCanvasWidth, nCanvasHeight, fDPIScaleX, nTilePosX, nTilePosY, nTileWidth, nTileHeight); #else ScopedVclPtrInstance< VirtualDevice > pDevice(DeviceFormat::WITHOUT_ALPHA); // Set background to transparent by default. pDevice->SetBackground(Wallpaper(COL_TRANSPARENT)); pDevice->SetOutputSizePixelScaleOffsetAndLOKBuffer( Size(nCanvasWidth, nCanvasHeight), Fraction(1.0), Point(), pBuffer); pDoc->paintTile(*pDevice, nCanvasWidth, nCanvasHeight, nTilePosX, nTilePosY, nTileWidth, nTileHeight); static bool bDebug = getenv("LOK_DEBUG_TILES") != nullptr; if (bDebug) { // Draw a small red rectangle in the top left corner so that it's easy to see where a new tile begins. tools::Rectangle aRect(0, 0, 5, 5); aRect = pDevice->PixelToLogic(aRect); pDevice->Push(PushFlags::FILLCOLOR | PushFlags::LINECOLOR); pDevice->SetFillColor(COL_LIGHTRED); pDevice->SetLineColor(); pDevice->DrawRect(aRect); pDevice->Pop(); } #ifdef _WIN32 // pBuffer was not used there pDevice->EnableMapMode(false); BitmapEx aBmpEx = pDevice->GetBitmapEx({ 0, 0 }, { nCanvasWidth, nCanvasHeight }); Bitmap aBmp = aBmpEx.GetBitmap(); Bitmap aAlpha = aBmpEx.GetAlphaMask(); Bitmap::ScopedReadAccess sraBmp(aBmp); Bitmap::ScopedReadAccess sraAlpha(aAlpha); assert(sraBmp->Height() == nCanvasHeight); assert(sraBmp->Width() == nCanvasWidth); assert(!sraAlpha || sraBmp->Height() == sraAlpha->Height()); assert(!sraAlpha || sraBmp->Width() == sraAlpha->Width()); auto p = pBuffer; for (tools::Long y = 0; y < sraBmp->Height(); ++y) { Scanline dataBmp = sraBmp->GetScanline(y); Scanline dataAlpha = sraAlpha ? sraAlpha->GetScanline(y) : nullptr; for (tools::Long x = 0; x < sraBmp->Width(); ++x) { BitmapColor color = sraBmp->GetPixelFromData(dataBmp, x); sal_uInt8 alpha = dataAlpha ? sraAlpha->GetPixelFromData(dataAlpha, x).GetBlue() : 255; *p++ = color.GetBlue(); *p++ = color.GetGreen(); *p++ = color.GetRed(); *p++ = alpha; } } #endif #endif #else (void) pBuffer; #endif } #ifdef IOS // This function is separate only to be used by LibreOfficeLight. If that app can be retired, this // function's code can be inlined. static void doc_paintTileToCGContext(LibreOfficeKitDocument* pThis, void* rCGContext, const int nCanvasWidth, const int nCanvasHeight, const int nTilePosX, const int nTilePosY, const int nTileWidth, const int nTileHeight) { SolarMutexGuard aGuard; SetLastExceptionMsg(); SAL_INFO( "lok.tiledrendering", "paintTileToCGContext: painting [" << nTileWidth << "x" << nTileHeight << "]@(" << nTilePosX << ", " << nTilePosY << ") to [" << nCanvasWidth << "x" << nCanvasHeight << "]px" ); ITiledRenderable* pDoc = getTiledRenderable(pThis); if (!pDoc) { SetLastExceptionMsg("Document doesn't support tiled rendering"); return; } Size aCanvasSize(nCanvasWidth, nCanvasHeight); paintTileToCGContext(pDoc, rCGContext, aCanvasSize, nTilePosX, nTilePosY, nTileWidth, nTileHeight); } #endif static void doc_paintPartTile(LibreOfficeKitDocument* pThis, unsigned char* pBuffer, const int nPart, const int nMode, const int nCanvasWidth, const int nCanvasHeight, const int nTilePosX, const int nTilePosY, const int nTileWidth, const int nTileHeight) { comphelper::ProfileZone aZone("doc_paintPartTile"); SolarMutexGuard aGuard; SetLastExceptionMsg(); SAL_INFO( "lok.tiledrendering", "paintPartTile: painting @ " << nPart << " : " << nMode << " [" << nTileWidth << "x" << nTileHeight << "]@(" << nTilePosX << ", " << nTilePosY << ") to [" << nCanvasWidth << "x" << nCanvasHeight << "]px" ); LibLODocument_Impl* pDocument = static_cast(pThis); int nOrigViewId = doc_getView(pThis); ITiledRenderable* pDoc = getTiledRenderable(pThis); if (!pDoc) { SetLastExceptionMsg("Document doesn't support tiled rendering"); return; } if (nOrigViewId < 0) { // tile painting always needs a SfxViewShell::Current(), but actually // it does not really matter which one - all of them should paint the // same thing. It's important to get a view for the correct document, // though. // doc_getViewsCount() returns the count of views for the document in the current view. int viewCount = doc_getViewsCount(pThis); if (viewCount == 0) return; std::vector viewIds(viewCount); doc_getViewIds(pThis, viewIds.data(), viewCount); nOrigViewId = viewIds[0]; doc_setView(pThis, nOrigViewId); } // Disable callbacks while we are painting. if (nOrigViewId >= 0) { const auto handlerIt = pDocument->mpCallbackFlushHandlers.find(nOrigViewId); if (handlerIt != pDocument->mpCallbackFlushHandlers.end()) handlerIt->second->disableCallbacks(); } try { // Text documents have a single coordinate system; don't change part. int nOrigPart = 0; const int aType = doc_getDocumentType(pThis); const bool isText = (aType == LOK_DOCTYPE_TEXT); const bool isCalc = (aType == LOK_DOCTYPE_SPREADSHEET); int nOrigEditMode = 0; bool bPaintTextEdit = true; int nViewId = nOrigViewId; int nLastNonEditorView = -1; int nViewMatchingMode = -1; if (!isText) { // Check if just switching to another view is enough, that has // less side-effects. if (nPart != doc_getPart(pThis) || nMode != pDoc->getEditMode()) { SfxViewShell* pViewShell = SfxViewShell::GetFirst(); while (pViewShell) { bool bIsInEdit = pViewShell->GetDrawView() && pViewShell->GetDrawView()->GetTextEditOutliner(); if (!bIsInEdit) nLastNonEditorView = pViewShell->GetViewShellId().get(); if (pViewShell->getPart() == nPart && pViewShell->getEditMode() == nMode && !bIsInEdit) { nViewId = pViewShell->GetViewShellId().get(); nViewMatchingMode = nViewId; nLastNonEditorView = nViewId; doc_setView(pThis, nViewId); break; } else if (pViewShell->getEditMode() == nMode && !bIsInEdit) { nViewMatchingMode = pViewShell->GetViewShellId().get(); } pViewShell = SfxViewShell::GetNext(*pViewShell); } } // if not found view with correct part // - at least avoid rendering active textbox, This is for Impress. // - prefer view with the same mode SfxViewShell* pCurrentViewShell = SfxViewShell::Current(); if (nViewMatchingMode >= 0 && nViewMatchingMode != nViewId) { nViewId = nViewMatchingMode; doc_setView(pThis, nViewId); } else if (!isCalc && nLastNonEditorView >= 0 && nLastNonEditorView != nViewId && pCurrentViewShell && pCurrentViewShell->GetDrawView() && pCurrentViewShell->GetDrawView()->GetTextEditOutliner()) { nViewId = nLastNonEditorView; doc_setView(pThis, nViewId); } // Disable callbacks while we are painting - after setting the view if (nViewId != nOrigViewId && nViewId >= 0) { const auto handlerIt = pDocument->mpCallbackFlushHandlers.find(nViewId); if (handlerIt != pDocument->mpCallbackFlushHandlers.end()) handlerIt->second->disableCallbacks(); } nOrigPart = doc_getPart(pThis); if (nPart != nOrigPart) { doc_setPartImpl(pThis, nPart, false); } nOrigEditMode = pDoc->getEditMode(); if (nOrigEditMode != nMode) { SfxLokHelper::setEditMode(nMode, pDoc); } bPaintTextEdit = (nPart == nOrigPart && nMode == nOrigEditMode); pDoc->setPaintTextEdit(bPaintTextEdit); } doc_paintTile(pThis, pBuffer, nCanvasWidth, nCanvasHeight, nTilePosX, nTilePosY, nTileWidth, nTileHeight); if (!isText) { pDoc->setPaintTextEdit(true); if (nMode != nOrigEditMode) { SfxLokHelper::setEditMode(nOrigEditMode, pDoc); } if (nPart != nOrigPart) { doc_setPartImpl(pThis, nOrigPart, false); } if (nViewId != nOrigViewId) { if (nViewId >= 0) { const auto handlerIt = pDocument->mpCallbackFlushHandlers.find(nViewId); if (handlerIt != pDocument->mpCallbackFlushHandlers.end()) handlerIt->second->enableCallbacks(); } doc_setView(pThis, nOrigViewId); } } } catch (const std::exception&) { // Nothing to do but restore the PartTilePainting flag. } if (nOrigViewId >= 0) { const auto handlerIt = pDocument->mpCallbackFlushHandlers.find(nOrigViewId); if (handlerIt != pDocument->mpCallbackFlushHandlers.end()) handlerIt->second->enableCallbacks(); } } static int doc_getTileMode(SAL_UNUSED_PARAMETER LibreOfficeKitDocument* /*pThis*/) { SetLastExceptionMsg(); return LOK_TILEMODE_BGRA; } static void doc_getDocumentSize(LibreOfficeKitDocument* pThis, long* pWidth, long* pHeight) { comphelper::ProfileZone aZone("doc_getDocumentSize"); SolarMutexGuard aGuard; SetLastExceptionMsg(); ITiledRenderable* pDoc = getTiledRenderable(pThis); if (pDoc) { Size aDocumentSize = pDoc->getDocumentSize(); *pWidth = aDocumentSize.Width(); *pHeight = aDocumentSize.Height(); } else { SetLastExceptionMsg("Document doesn't support tiled rendering"); } } static void doc_getDataArea(LibreOfficeKitDocument* pThis, long nTab, long* pCol, long* pRow) { comphelper::ProfileZone aZone("doc_getDataArea"); SolarMutexGuard aGuard; SetLastExceptionMsg(); ITiledRenderable* pDoc = getTiledRenderable(pThis); if (pDoc) { Size aDocumentSize = pDoc->getDataArea(nTab); *pCol = aDocumentSize.Width(); *pRow = aDocumentSize.Height(); } else { SetLastExceptionMsg("Document doesn't support tiled rendering"); } } static void doc_initializeForRendering(LibreOfficeKitDocument* pThis, const char* pArguments) { comphelper::ProfileZone aZone("doc_initializeForRendering"); SolarMutexGuard aGuard; SetLastExceptionMsg(); ITiledRenderable* pDoc = getTiledRenderable(pThis); if (pDoc) { doc_iniUnoCommands(); pDoc->initializeForTiledRendering( comphelper::containerToSequence(jsonToPropertyValuesVector(pArguments))); } } static void doc_registerCallback(LibreOfficeKitDocument* pThis, LibreOfficeKitCallback pCallback, void* pData) { SolarMutexGuard aGuard; SetLastExceptionMsg(); LibLODocument_Impl* pDocument = static_cast(pThis); const int nView = SfxLokHelper::getView(); if (nView < 0) return; const size_t nId = nView; if (pCallback != nullptr) { for (auto& pair : pDocument->mpCallbackFlushHandlers) { if (pair.first == nId) continue; pair.second->addViewStates(nView); } } else { for (auto& pair : pDocument->mpCallbackFlushHandlers) { if (pair.first == nId) continue; pair.second->removeViewStates(nView); } } pDocument->mpCallbackFlushHandlers[nView] = std::make_shared(pThis, pCallback, pData); if (pCallback != nullptr) { for (const auto& pair : pDocument->mpCallbackFlushHandlers) { if (pair.first == nId) continue; pDocument->mpCallbackFlushHandlers[nView]->addViewStates(pair.first); } if (SfxViewShell* pViewShell = SfxViewShell::Current()) { pDocument->mpCallbackFlushHandlers[nView]->setViewId(pViewShell->GetViewShellId().get()); pViewShell->setLibreOfficeKitViewCallback(pDocument->mpCallbackFlushHandlers[nView].get()); } if (pDocument->maFontsMissing.size() != 0) { std::string sPayload = "{ \"fontsmissing\": [ "; bool bFirst = true; for (const auto &f : pDocument->maFontsMissing) { if (bFirst) bFirst = false; else sPayload += ", "; sPayload += "\"" + std::string(f.toUtf8().getStr()) + "\""; } sPayload += " ] }"; pCallback(LOK_CALLBACK_FONTS_MISSING, sPayload.c_str(), pData); pDocument->maFontsMissing.clear(); } } else { if (SfxViewShell* pViewShell = SfxViewShell::Current()) { pViewShell->setLibreOfficeKitViewCallback(nullptr); pDocument->mpCallbackFlushHandlers[nView]->setViewId(-1); } } } /// Returns the JSON representation of all the comments in the document static char* getPostIts(LibreOfficeKitDocument* pThis) { SetLastExceptionMsg(); ITiledRenderable* pDoc = getTiledRenderable(pThis); if (!pDoc) { SetLastExceptionMsg("Document doesn't support tiled rendering"); return nullptr; } tools::JsonWriter aJsonWriter; pDoc->getPostIts(aJsonWriter); return strdup(aJsonWriter.finishAndGetAsOString().getStr()); } /// Returns the JSON representation of the positions of all the comments in the document static char* getPostItsPos(LibreOfficeKitDocument* pThis) { SetLastExceptionMsg(); ITiledRenderable* pDoc = getTiledRenderable(pThis); if (!pDoc) { SetLastExceptionMsg("Document doesn't support tiled rendering"); return nullptr; } tools::JsonWriter aJsonWriter; pDoc->getPostItsPos(aJsonWriter); return strdup(aJsonWriter.finishAndGetAsOString().getStr()); } static char* getRulerState(LibreOfficeKitDocument* pThis) { SetLastExceptionMsg(); ITiledRenderable* pDoc = getTiledRenderable(pThis); if (!pDoc) { SetLastExceptionMsg("Document doesn't support tiled rendering"); return nullptr; } tools::JsonWriter aJsonWriter; pDoc->getRulerState(aJsonWriter); return strdup(aJsonWriter.finishAndGetAsOString().getStr()); } static void doc_postKeyEvent(LibreOfficeKitDocument* pThis, int nType, int nCharCode, int nKeyCode) { comphelper::ProfileZone aZone("doc_postKeyEvent"); SolarMutexGuard aGuard; SetLastExceptionMsg(); ITiledRenderable* pDoc = getTiledRenderable(pThis); if (!pDoc) { SetLastExceptionMsg("Document doesn't support tiled rendering"); return; } try { pDoc->postKeyEvent(nType, nCharCode, nKeyCode); } catch (const uno::Exception& exception) { SetLastExceptionMsg(exception.Message); SAL_INFO("lok", "Failed to postKeyEvent " << exception.Message); } } static void doc_setBlockedCommandList(LibreOfficeKitDocument* /*pThis*/, int nViewId, const char* blockedCommandList) { SolarMutexGuard aGuard; SfxLokHelper::setBlockedCommandList(nViewId, blockedCommandList); } static void doc_postWindowExtTextInputEvent(LibreOfficeKitDocument* pThis, unsigned nWindowId, int nType, const char* pText) { comphelper::ProfileZone aZone("doc_postWindowExtTextInputEvent"); SolarMutexGuard aGuard; VclPtr pWindow; if (nWindowId == 0) { ITiledRenderable* pDoc = getTiledRenderable(pThis); if (!pDoc) { SetLastExceptionMsg("Document doesn't support tiled rendering"); return; } pWindow = pDoc->getDocWindow(); } else { pWindow = vcl::Window::FindLOKWindow(nWindowId); } if (!pWindow) { SetLastExceptionMsg("No window found for window id: " + OUString::number(nWindowId)); return; } SfxLokHelper::postExtTextEventAsync(pWindow, nType, OUString::fromUtf8(std::string_view(pText, strlen(pText)))); } static void doc_removeTextContext(LibreOfficeKitDocument* pThis, unsigned nLOKWindowId, int nCharBefore, int nCharAfter) { SolarMutexGuard aGuard; VclPtr pWindow; if (nLOKWindowId == 0) { ITiledRenderable* pDoc = getTiledRenderable(pThis); if (!pDoc) { gImpl->maLastExceptionMsg = "Document doesn't support tiled rendering"; return; } pWindow = pDoc->getDocWindow(); } else { pWindow = vcl::Window::FindLOKWindow(nLOKWindowId); } if (!pWindow) { gImpl->maLastExceptionMsg = "No window found for window id: " + OUString::number(nLOKWindowId); return; } // Annoyingly - backspace and delete are handled in the apps via an accelerator // which are PostMessage'd by SfxViewShell::ExecKey_Impl so to stay in the same // order we do this synchronously here, unless we're in a dialog. if (nCharBefore > 0) { // backspace if (nLOKWindowId == 0) { KeyEvent aEvt(8, 1283); for (int i = 0; i < nCharBefore; ++i) pWindow->KeyInput(aEvt); } else SfxLokHelper::postKeyEventAsync(pWindow, LOK_KEYEVENT_KEYINPUT, 8, 1283, nCharBefore - 1); } if (nCharAfter > 0) { // delete (forward) if (nLOKWindowId == 0) { KeyEvent aEvt(46, 1286); for (int i = 0; i < nCharAfter; ++i) pWindow->KeyInput(aEvt); } else SfxLokHelper::postKeyEventAsync(pWindow, LOK_KEYEVENT_KEYINPUT, 46, 1286, nCharAfter - 1); } } static void doc_postWindowKeyEvent(LibreOfficeKitDocument* /*pThis*/, unsigned nLOKWindowId, int nType, int nCharCode, int nKeyCode) { comphelper::ProfileZone aZone("doc_postWindowKeyEvent"); SolarMutexGuard aGuard; SetLastExceptionMsg(); VclPtr pWindow = vcl::Window::FindLOKWindow(nLOKWindowId); if (!pWindow) { SetLastExceptionMsg("Document doesn't support dialog rendering, or window not found."); return; } KeyEvent aEvent(nCharCode, nKeyCode, 0); switch (nType) { case LOK_KEYEVENT_KEYINPUT: Application::PostKeyEvent(VclEventId::WindowKeyInput, pWindow, &aEvent); break; case LOK_KEYEVENT_KEYUP: Application::PostKeyEvent(VclEventId::WindowKeyUp, pWindow, &aEvent); break; default: assert(false); break; } } static size_t doc_renderShapeSelection(LibreOfficeKitDocument* pThis, char** pOutput) { comphelper::ProfileZone aZone("doc_renderShapeSelection"); SolarMutexGuard aGuard; SetLastExceptionMsg(); LokChartHelper aChartHelper(SfxViewShell::Current()); if (aChartHelper.GetWindow()) return 0; try { LibLODocument_Impl* pDocument = static_cast(pThis); uno::Reference xStorable(pDocument->mxComponent, uno::UNO_QUERY_THROW); SvMemoryStream aOutStream; uno::Reference xOut = new utl::OOutputStreamWrapper(aOutStream); utl::MediaDescriptor aMediaDescriptor; switch (doc_getDocumentType(pThis)) { case LOK_DOCTYPE_PRESENTATION: aMediaDescriptor["FilterName"] <<= OUString("impress_svg_Export"); break; case LOK_DOCTYPE_DRAWING: aMediaDescriptor["FilterName"] <<= OUString("draw_svg_Export"); break; case LOK_DOCTYPE_TEXT: aMediaDescriptor["FilterName"] <<= OUString("writer_svg_Export"); break; case LOK_DOCTYPE_SPREADSHEET: aMediaDescriptor["FilterName"] <<= OUString("calc_svg_Export"); break; default: SAL_WARN("lok", "Failed to render shape selection: Document type is not supported"); } aMediaDescriptor["SelectionOnly"] <<= true; aMediaDescriptor["OutputStream"] <<= xOut; aMediaDescriptor["IsPreview"] <<= true; // will down-scale graphics xStorable->storeToURL("private:stream", aMediaDescriptor.getAsConstPropertyValueList()); if (pOutput) { const size_t nOutputSize = aOutStream.GetEndOfData(); *pOutput = static_cast(malloc(nOutputSize)); if (*pOutput) { std::memcpy(*pOutput, aOutStream.GetData(), nOutputSize); return nOutputSize; } } } catch (const uno::Exception& exception) { css::uno::Any exAny( cppu::getCaughtException() ); SetLastExceptionMsg(exception.Message); SAL_WARN("lok", "Failed to render shape selection: " << exceptionToString(exAny)); } return 0; } namespace { /** Class to react on finishing of a dispatched command. This will call a LOK_COMMAND_FINISHED callback when postUnoCommand was called with the parameter requesting the notification. @see LibreOfficeKitCallbackType::LOK_CALLBACK_UNO_COMMAND_RESULT. */ class DispatchResultListener : public cppu::WeakImplHelper { OString maCommand; ///< Command for which this is the result. std::shared_ptr mpCallback; ///< Callback to call. public: DispatchResultListener(const char* pCommand, std::shared_ptr pCallback) : maCommand(pCommand) , mpCallback(std::move(pCallback)) { assert(mpCallback); } virtual void SAL_CALL dispatchFinished(const css::frame::DispatchResultEvent& rEvent) override { tools::JsonWriter aJson; aJson.put("commandName", maCommand); if (rEvent.State != frame::DispatchResultState::DONTKNOW) { bool bSuccess = (rEvent.State == frame::DispatchResultState::SUCCESS); aJson.put("success", bSuccess); } unoAnyToJson(aJson, "result", rEvent.Result); mpCallback->queue(LOK_CALLBACK_UNO_COMMAND_RESULT, aJson.finishAndGetAsOString()); } virtual void SAL_CALL disposing(const css::lang::EventObject&) override {} }; } // anonymous namespace static void lcl_sendDialogEvent(unsigned long long int nWindowId, const char* pArguments) { SolarMutexGuard aGuard; StringMap aMap(jsdialog::jsonToStringMap(pArguments)); if (aMap.find("id") == aMap.end()) return; sal_uInt64 nCurrentShellId = reinterpret_cast(SfxViewShell::Current()); try { OUString sControlId = aMap["id"]; // dialogs send own id but notebookbar and sidebar controls are remembered by SfxViewShell id if (jsdialog::ExecuteAction(OUString::number(nWindowId), sControlId, aMap)) return; auto sCurrentShellId = OUString::number(nCurrentShellId); if (jsdialog::ExecuteAction(sCurrentShellId + "sidebar", sControlId, aMap)) return; if (jsdialog::ExecuteAction(sCurrentShellId + "notebookbar", sControlId, aMap)) return; if (jsdialog::ExecuteAction(sCurrentShellId + "formulabar", sControlId, aMap)) return; // this is needed for dialogs shown before document is loaded: MacroWarning dialog, etc... // these dialogs are created with WindowId "0" if (!SfxViewShell::Current() && jsdialog::ExecuteAction("0", sControlId, aMap)) return; // force resend - used in mobile-wizard jsdialog::SendFullUpdate(sCurrentShellId + "sidebar", "Panel"); } catch(...) {} } static void doc_sendDialogEvent(LibreOfficeKitDocument* /*pThis*/, unsigned long long int nWindowId, const char* pArguments) { lcl_sendDialogEvent(nWindowId, pArguments); } static void lo_sendDialogEvent(LibreOfficeKit* /*pThis*/, unsigned long long int nWindowId, const char* pArguments) { lcl_sendDialogEvent(nWindowId, pArguments); } static void lo_setOption(LibreOfficeKit* /*pThis*/, const char *pOption, const char* pValue) { static char* pCurrentSalLogOverride = nullptr; if (strcmp(pOption, "traceeventrecording") == 0) { if (strcmp(pValue, "start") == 0) { comphelper::TraceEvent::setBufferSizeAndCallback(100, TraceEventDumper::flushRecordings); comphelper::TraceEvent::startRecording(); if (traceEventDumper == nullptr) traceEventDumper = new TraceEventDumper(); } else if (strcmp(pValue, "stop") == 0) comphelper::TraceEvent::stopRecording(); } else if (strcmp(pOption, "sallogoverride") == 0) { if (pCurrentSalLogOverride != nullptr) free(pCurrentSalLogOverride); if (pValue == nullptr) pCurrentSalLogOverride = nullptr; else pCurrentSalLogOverride = strdup(pValue); if (pCurrentSalLogOverride == nullptr || pCurrentSalLogOverride[0] == '\0') sal_detail_set_log_selector(nullptr); else sal_detail_set_log_selector(pCurrentSalLogOverride); } #ifdef LINUX else if (strcmp(pOption, "addfont") == 0) { if (memcmp(pValue, "file://", 7) == 0) pValue += 7; int fd = open(pValue, O_RDONLY); if (fd == -1) { std::cerr << "Could not open font file '" << pValue << "': " << strerror(errno) << std::endl; return; } OUString sMagicFileName = "file:///:FD:/" + OUString::number(fd); OutputDevice *pDevice = Application::GetDefaultDevice(); OutputDevice::ImplClearAllFontData(false); pDevice->AddTempDevFont(sMagicFileName, ""); OutputDevice::ImplRefreshAllFontData(false); } #endif } static void lo_dumpState (LibreOfficeKit* pThis, const char* /* pOptions */, char** pState) { if (!pState) return; // NB. no SolarMutexGuard since this may be caused in some extremis / deadlock SetLastExceptionMsg(); *pState = nullptr; OStringBuffer aState(4096*256); LibLibreOffice_Impl* pLib = static_cast(pThis); pLib->dumpState(aState); OString aStr = aState.makeStringAndClear(); *pState = strdup(aStr.getStr()); } void LibLibreOffice_Impl::dumpState(rtl::OStringBuffer &rState) { rState.append("LibreOfficeKit state:"); rState.append("\n\tLastExceptionMsg:\t"); rState.append(rtl::OUStringToOString(maLastExceptionMsg, RTL_TEXTENCODING_UTF8)); rState.append("\n\tUnipoll:\t"); rState.append(vcl::lok::isUnipoll() ? "yes" : "no: events on thread"); rState.append("\n\tOptionalFeatures:\t0x"); rState.append(static_cast(mOptionalFeatures), 16); rState.append("\n\tCallbackData:\t0x"); rState.append(reinterpret_cast(mpCallback), 16); // TODO: dump mInteractionMap SfxLokHelper::dumpState(rState); vcl::lok::dumpState(rState); } static void doc_postUnoCommand(LibreOfficeKitDocument* pThis, const char* pCommand, const char* pArguments, bool bNotifyWhenFinished) { comphelper::ProfileZone aZone("doc_postUnoCommand"); SolarMutexGuard aGuard; SetLastExceptionMsg(); SfxObjectShell* pDocSh = SfxObjectShell::Current(); OUString aCommand(pCommand, strlen(pCommand), RTL_TEXTENCODING_UTF8); LibLODocument_Impl* pDocument = static_cast(pThis); std::vector aPropertyValuesVector(jsonToPropertyValuesVector(pArguments)); if (!vcl::lok::isUnipoll()) { beans::PropertyValue aSynchronMode; aSynchronMode.Name = "SynchronMode"; aSynchronMode.Value <<= false; aPropertyValuesVector.push_back(aSynchronMode); } int nView = SfxLokHelper::getView(); if (nView < 0) return; if (gImpl && aCommand == ".uno:ToggleOrientation") { ExecuteOrientationChange(); return; } // handle potential interaction if (gImpl && aCommand == ".uno:Save") { // Check if saving a PDF file OUString aMimeType = lcl_getCurrentDocumentMimeType(pDocument); if (pDocSh && pDocSh->IsModified() && aMimeType == "application/pdf") { // If we have a PDF file (for saving annotations for example), we need // to run save-as to the same file as the opened document. Plain save // doesn't work as the PDF is not a "native" format. uno::Reference xStorable(pDocument->mxComponent, uno::UNO_QUERY_THROW); OUString aURL = xStorable->getLocation(); OString aURLUtf8 = OUStringToOString(aURL, RTL_TEXTENCODING_UTF8); bool bResult = doc_saveAs(pThis, aURLUtf8.getStr(), "pdf", nullptr); // Send the result of save tools::JsonWriter aJson; aJson.put("commandName", pCommand); aJson.put("success", bResult); pDocument->mpCallbackFlushHandlers[nView]->queue(LOK_CALLBACK_UNO_COMMAND_RESULT, aJson.finishAndGetAsOString()); return; } rtl::Reference const pInteraction( new LOKInteractionHandler("save", gImpl, pDocument)); uno::Reference const xInteraction(pInteraction); beans::PropertyValue aValue; aValue.Name = "InteractionHandler"; aValue.Value <<= xInteraction; aPropertyValuesVector.push_back(aValue); bool bDontSaveIfUnmodified = false; aPropertyValuesVector.erase(std::remove_if(aPropertyValuesVector.begin(), aPropertyValuesVector.end(), [&bDontSaveIfUnmodified](const beans::PropertyValue& aItem){ if (aItem.Name == "DontSaveIfUnmodified") { bDontSaveIfUnmodified = aItem.Value.get(); return true; } return false; }), aPropertyValuesVector.end()); // skip saving and tell the result via UNO_COMMAND_RESULT if (bDontSaveIfUnmodified && (!pDocSh || !pDocSh->IsModified())) { tools::JsonWriter aJson; aJson.put("commandName", pCommand); aJson.put("success", false); // Add the reason for not saving { auto resultNode = aJson.startNode("result"); aJson.put("type", "string"); aJson.put("value", "unmodified"); } pDocument->mpCallbackFlushHandlers[nView]->queue(LOK_CALLBACK_UNO_COMMAND_RESULT, aJson.finishAndGetAsOString()); return; } } else if (gImpl && aCommand == ".uno:TransformDialog") { bool bNeedConversion = false; SfxViewShell* pViewShell = SfxViewShell::Current(); LokChartHelper aChartHelper(pViewShell); if (aChartHelper.GetWindow() ) { bNeedConversion = true; } else if (const SdrView* pView = pViewShell->GetDrawView()) { if (OutputDevice* pOutputDevice = pView->GetFirstOutputDevice()) { bNeedConversion = (pOutputDevice->GetMapMode().GetMapUnit() == MapUnit::Map100thMM); } } if (bNeedConversion) { sal_Int32 value; for (beans::PropertyValue& rPropValue: aPropertyValuesVector) { if (rPropValue.Name == "TransformPosX" || rPropValue.Name == "TransformPosY" || rPropValue.Name == "TransformWidth" || rPropValue.Name == "TransformHeight" || rPropValue.Name == "TransformRotationX" || rPropValue.Name == "TransformRotationY") { rPropValue.Value >>= value; value = o3tl::convert(value, o3tl::Length::twip, o3tl::Length::mm100); rPropValue.Value <<= value; } } } if (aChartHelper.GetWindow() && aPropertyValuesVector.size() > 0) { if (aPropertyValuesVector[0].Name != "Action") { tools::Rectangle aChartBB = aChartHelper.GetChartBoundingBox(); int nLeft = o3tl::convert(aChartBB.Left(), o3tl::Length::twip, o3tl::Length::mm100); int nTop = o3tl::convert(aChartBB.Top(), o3tl::Length::twip, o3tl::Length::mm100); for (beans::PropertyValue& rPropValue: aPropertyValuesVector) { if (rPropValue.Name == "TransformPosX" || rPropValue.Name == "TransformRotationX") { auto const value = *o3tl::doAccess(rPropValue.Value); rPropValue.Value <<= value - nLeft; } else if (rPropValue.Name == "TransformPosY" || rPropValue.Name == "TransformRotationY") { auto const value = *o3tl::doAccess(rPropValue.Value); rPropValue.Value <<= value - nTop; } } } util::URL aCommandURL; aCommandURL.Path = "LOKTransform"; css::uno::Reference& aChartDispatcher = aChartHelper.GetXDispatcher(); aChartDispatcher->dispatch(aCommandURL, comphelper::containerToSequence(aPropertyValuesVector)); return; } } else if (gImpl && aCommand == ".uno:LOKSidebarWriterPage") { setupSidebar(u"WriterPageDeck"); return; } else if (gImpl && aCommand == ".uno:SidebarShow") { setupSidebar(); return; } else if (gImpl && aCommand == ".uno:SidebarHide") { hideSidebar(); return; } bool bResult = false; LokChartHelper aChartHelper(SfxViewShell::Current()); if (aChartHelper.GetWindow() && aCommand != ".uno:Save" ) { util::URL aCommandURL; aCommandURL.Path = aCommand.copy(5); css::uno::Reference& aChartDispatcher = aChartHelper.GetXDispatcher(); aChartDispatcher->dispatch(aCommandURL, comphelper::containerToSequence(aPropertyValuesVector)); return; } if (LokStarMathHelper aMathHelper(SfxViewShell::Current()); aMathHelper.GetGraphicWindow() && aCommand != ".uno:Save") { aMathHelper.Dispatch(aCommand, comphelper::containerToSequence(aPropertyValuesVector)); return; } if (bNotifyWhenFinished && pDocument->mpCallbackFlushHandlers.count(nView)) { bResult = comphelper::dispatchCommand(aCommand, comphelper::containerToSequence(aPropertyValuesVector), new DispatchResultListener(pCommand, pDocument->mpCallbackFlushHandlers[nView])); } else bResult = comphelper::dispatchCommand(aCommand, comphelper::containerToSequence(aPropertyValuesVector)); if (!bResult) { SetLastExceptionMsg("Failed to dispatch " + aCommand); } } static void doc_postMouseEvent(LibreOfficeKitDocument* pThis, int nType, int nX, int nY, int nCount, int nButtons, int nModifier) { comphelper::ProfileZone aZone("doc_postMouseEvent"); SolarMutexGuard aGuard; SetLastExceptionMsg(); ITiledRenderable* pDoc = getTiledRenderable(pThis); if (!pDoc) { SetLastExceptionMsg("Document doesn't support tiled rendering"); return; } try { pDoc->postMouseEvent(nType, nX, nY, nCount, nButtons, nModifier); } catch (const uno::Exception& exception) { SetLastExceptionMsg(exception.Message); SAL_INFO("lok", "Failed to postMouseEvent " << exception.Message); } } static void doc_postWindowMouseEvent(LibreOfficeKitDocument* /*pThis*/, unsigned nLOKWindowId, int nType, int nX, int nY, int nCount, int nButtons, int nModifier) { comphelper::ProfileZone aZone("doc_postWindowMouseEvent"); SolarMutexGuard aGuard; SetLastExceptionMsg(); VclPtr pWindow = vcl::Window::FindLOKWindow(nLOKWindowId); if (!pWindow) { SetLastExceptionMsg("Document doesn't support dialog rendering, or window not found."); return; } const Point aPos(nX, nY); MouseEvent aEvent(aPos, nCount, MouseEventModifiers::SIMPLECLICK, nButtons, nModifier); vcl::EnableDialogInput(pWindow); switch (nType) { case LOK_MOUSEEVENT_MOUSEBUTTONDOWN: Application::PostMouseEvent(VclEventId::WindowMouseButtonDown, pWindow, &aEvent); break; case LOK_MOUSEEVENT_MOUSEBUTTONUP: Application::PostMouseEvent(VclEventId::WindowMouseButtonUp, pWindow, &aEvent); break; case LOK_MOUSEEVENT_MOUSEMOVE: Application::PostMouseEvent(VclEventId::WindowMouseMove, pWindow, &aEvent); break; default: assert(false); break; } } static void doc_postWindowGestureEvent(LibreOfficeKitDocument* /*pThis*/, unsigned nLOKWindowId, const char* pType, int nX, int nY, int nOffset) { comphelper::ProfileZone aZone("doc_postWindowGestureEvent"); SolarMutexGuard aGuard; SetLastExceptionMsg(); VclPtr pWindow = vcl::Window::FindLOKWindow(nLOKWindowId); if (!pWindow) { SetLastExceptionMsg("Document doesn't support dialog rendering, or window not found."); return; } OString aType(pType); GestureEventPanType eEventType = GestureEventPanType::Update; if (aType == "panBegin") eEventType = GestureEventPanType::Begin; else if (aType == "panEnd") eEventType = GestureEventPanType::End; GestureEventPan aEvent { sal_Int32(nX), sal_Int32(nY), eEventType, sal_Int32(nOffset), PanningOrientation::Vertical, }; vcl::EnableDialogInput(pWindow); Application::PostGestureEvent(VclEventId::WindowGestureEvent, pWindow, &aEvent); } static void doc_setTextSelection(LibreOfficeKitDocument* pThis, int nType, int nX, int nY) { comphelper::ProfileZone aZone("doc_setTextSelection"); SolarMutexGuard aGuard; SetLastExceptionMsg(); ITiledRenderable* pDoc = getTiledRenderable(pThis); if (!pDoc) { SetLastExceptionMsg("Document doesn't support tiled rendering"); return; } pDoc->setTextSelection(nType, nX, nY); } static void doc_setWindowTextSelection(LibreOfficeKitDocument* /*pThis*/, unsigned nLOKWindowId, bool swap, int nX, int nY) { comphelper::ProfileZone aZone("doc_setWindowTextSelection"); SolarMutexGuard aGuard; SetLastExceptionMsg(); VclPtr pWindow = vcl::Window::FindLOKWindow(nLOKWindowId); if (!pWindow) { SetLastExceptionMsg("Document doesn't support dialog rendering, or window not found."); return; } Size aOffset(pWindow->GetOutOffXPixel(), pWindow->GetOutOffYPixel()); Point aCursorPos(nX, nY); aCursorPos.Move(aOffset); sal_uInt16 nModifier = swap ? KEY_MOD1 + KEY_MOD2 : KEY_SHIFT; MouseEvent aCursorEvent(aCursorPos, 1, MouseEventModifiers::SIMPLECLICK, 0, nModifier); Application::PostMouseEvent(VclEventId::WindowMouseButtonDown, pWindow, &aCursorEvent); Application::PostMouseEvent(VclEventId::WindowMouseButtonUp, pWindow, &aCursorEvent); } static bool getFromTransferable( const css::uno::Reference &xTransferable, const OString &aInMimeType, OString &aRet); static bool encodeImageAsHTML( const css::uno::Reference &xTransferable, const OString &aMimeType, OString &aRet) { if (!getFromTransferable(xTransferable, aMimeType, aRet)) return false; // Encode in base64. auto aSeq = Sequence(reinterpret_cast(aRet.getStr()), aRet.getLength()); OStringBuffer aBase64Data; comphelper::Base64::encode(aBase64Data, aSeq); // Embed in HTML. aRet = "\n" "" "" "

"; return true; } static bool encodeTextAsHTML( const css::uno::Reference &xTransferable, const OString &aMimeType, OString &aRet) { if (!getFromTransferable(xTransferable, aMimeType, aRet)) return false; // Embed in HTML - FIXME: needs some escaping. aRet = "\n" "" "

" + aRet + "

"; return true; } static bool getFromTransferable( const css::uno::Reference &xTransferable, const OString &aInMimeType, OString &aRet) { OString aMimeType(aInMimeType); // Take care of UTF-8 text here. bool bConvert = false; sal_Int32 nIndex = 0; if (o3tl::getToken(aMimeType, 0, ';', nIndex) == "text/plain") { if (o3tl::getToken(aMimeType, 0, ';', nIndex) == "charset=utf-8") { aMimeType = "text/plain;charset=utf-16"; bConvert = true; } } datatransfer::DataFlavor aFlavor; aFlavor.MimeType = OUString::fromUtf8(aMimeType.getStr()); if (aMimeType == "text/plain;charset=utf-16") aFlavor.DataType = cppu::UnoType::get(); else aFlavor.DataType = cppu::UnoType< uno::Sequence >::get(); if (!xTransferable->isDataFlavorSupported(aFlavor)) { // Try harder for HTML it is our copy/paste meta-file format if (aInMimeType == "text/html") { // Desperate measures - convert text to HTML instead. if (encodeTextAsHTML(xTransferable, "text/plain;charset=utf-8", aRet)) return true; // If html is not supported, might be a graphic-selection, if (encodeImageAsHTML(xTransferable, "image/png", aRet)) return true; } SetLastExceptionMsg("Flavor " + aFlavor.MimeType + " is not supported"); return false; } uno::Any aAny; try { aAny = xTransferable->getTransferData(aFlavor); } catch (const css::datatransfer::UnsupportedFlavorException& e) { SetLastExceptionMsg("Unsupported flavor " + aFlavor.MimeType + " exception " + e.Message); return false; } catch (const css::uno::Exception& e) { SetLastExceptionMsg("Exception getting " + aFlavor.MimeType + " exception " + e.Message); return false; } if (aFlavor.DataType == cppu::UnoType::get()) { OUString aString; aAny >>= aString; if (bConvert) aRet = OUStringToOString(aString, RTL_TEXTENCODING_UTF8); else aRet = OString(reinterpret_cast(aString.getStr()), aString.getLength() * sizeof(sal_Unicode)); } else { uno::Sequence aSequence; aAny >>= aSequence; aRet = OString(reinterpret_cast(aSequence.getConstArray()), aSequence.getLength()); } return true; } static char* doc_getTextSelection(LibreOfficeKitDocument* pThis, const char* pMimeType, char** pUsedMimeType) { comphelper::ProfileZone aZone("doc_getTextSelection"); SolarMutexGuard aGuard; SetLastExceptionMsg(); ITiledRenderable* pDoc = getTiledRenderable(pThis); if (!pDoc) { SetLastExceptionMsg("Document doesn't support tiled rendering"); return nullptr; } css::uno::Reference xTransferable = pDoc->getSelection(); if (!xTransferable) { SetLastExceptionMsg("No selection available"); return nullptr; } const char *pType = pMimeType; if (!pType || pType[0] == '\0') pType = "text/plain;charset=utf-8"; OString aRet; bool bSuccess = getFromTransferable(xTransferable, OString(pType), aRet); if (!bSuccess) return nullptr; if (pUsedMimeType) // legacy { if (pMimeType) *pUsedMimeType = strdup(pMimeType); else *pUsedMimeType = nullptr; } return convertOString(aRet); } static int doc_getSelectionType(LibreOfficeKitDocument* pThis) { comphelper::ProfileZone aZone("doc_getSelectionType"); SolarMutexGuard aGuard; SetLastExceptionMsg(); ITiledRenderable* pDoc = getTiledRenderable(pThis); if (!pDoc) { SetLastExceptionMsg("Document doesn't support tiled rendering"); return LOK_SELTYPE_NONE; } css::uno::Reference xTransferable = pDoc->getSelection(); if (!xTransferable) { SetLastExceptionMsg("No selection available"); return LOK_SELTYPE_NONE; } css::uno::Reference xTransferable2(xTransferable, css::uno::UNO_QUERY); if (xTransferable2.is() && xTransferable2->isComplex()) return LOK_SELTYPE_COMPLEX; OString aRet; bool bSuccess = getFromTransferable(xTransferable, "text/plain;charset=utf-8", aRet); if (!bSuccess) return LOK_SELTYPE_NONE; if (aRet.getLength() > 10000) return LOK_SELTYPE_COMPLEX; return !aRet.isEmpty() ? LOK_SELTYPE_TEXT : LOK_SELTYPE_NONE; } static int doc_getSelectionTypeAndText(LibreOfficeKitDocument* pThis, const char* pMimeType, char** pText, char** pUsedMimeType) { // The purpose of this function is to avoid double call to pDoc->getSelection(), // which may be expensive. comphelper::ProfileZone aZone("doc_getSelectionTypeAndText"); SolarMutexGuard aGuard; SetLastExceptionMsg(); ITiledRenderable* pDoc = getTiledRenderable(pThis); if (!pDoc) { SetLastExceptionMsg("Document doesn't support tiled rendering"); return LOK_SELTYPE_NONE; } css::uno::Reference xTransferable = pDoc->getSelection(); if (!xTransferable) { SetLastExceptionMsg("No selection available"); return LOK_SELTYPE_NONE; } css::uno::Reference xTransferable2(xTransferable, css::uno::UNO_QUERY); if (xTransferable2.is() && xTransferable2->isComplex()) return LOK_SELTYPE_COMPLEX; const char *pType = pMimeType; if (!pType || pType[0] == '\0') pType = "text/plain;charset=utf-8"; OString aRet; bool bSuccess = getFromTransferable(xTransferable, OString(pType), aRet); if (!bSuccess) return LOK_SELTYPE_NONE; if (aRet.getLength() > 10000) return LOK_SELTYPE_COMPLEX; if (aRet.isEmpty()) return LOK_SELTYPE_NONE; if (pText) *pText = convertOString(aRet); if (pUsedMimeType) // legacy { if (pMimeType) *pUsedMimeType = strdup(pMimeType); else *pUsedMimeType = nullptr; } return LOK_SELTYPE_TEXT; } static int doc_getClipboard(LibreOfficeKitDocument* pThis, const char **pMimeTypes, size_t *pOutCount, char ***pOutMimeTypes, size_t **pOutSizes, char ***pOutStreams) { #ifdef IOS (void) pThis; (void) pMimeTypes; (void) pOutCount; (void) pOutMimeTypes; (void) pOutSizes; (void) pOutStreams; assert(!"doc_getClipboard should not be called on iOS"); return 0; #else comphelper::ProfileZone aZone("doc_getClipboard"); SolarMutexGuard aGuard; SetLastExceptionMsg(); assert (pOutCount); assert (pOutMimeTypes); assert (pOutSizes); assert (pOutStreams); *pOutCount = 0; *pOutMimeTypes = nullptr; *pOutSizes = nullptr; *pOutStreams = nullptr; ITiledRenderable* pDoc = getTiledRenderable(pThis); if (!pDoc) { SetLastExceptionMsg("Document doesn't support tiled rendering"); return 0; } rtl::Reference xClip(LOKClipboardFactory::getClipboardForCurView()); css::uno::Reference xTransferable = xClip->getContents(); SAL_INFO("lok", "Got from clip: " << xClip.get() << " transferable: " << xTransferable); if (!xTransferable) { SetLastExceptionMsg("No clipboard content available"); return 0; } std::vector aMimeTypes; if (!pMimeTypes) // everything { const uno::Sequence< css::datatransfer::DataFlavor > flavors = xTransferable->getTransferDataFlavors(); if (!flavors.getLength()) { SetLastExceptionMsg("Flavourless selection"); return 0; } for (const auto &it : flavors) aMimeTypes.push_back(OUStringToOString(it.MimeType, RTL_TEXTENCODING_UTF8)); } else { for (size_t i = 0; pMimeTypes[i]; ++i) aMimeTypes.push_back(OString(pMimeTypes[i])); } *pOutCount = aMimeTypes.size(); *pOutSizes = static_cast(malloc(*pOutCount * sizeof(size_t))); *pOutMimeTypes = static_cast(malloc(*pOutCount * sizeof(char *))); *pOutStreams = static_cast(malloc(*pOutCount * sizeof(char *))); for (size_t i = 0; i < aMimeTypes.size(); ++i) { if (aMimeTypes[i] == "text/plain;charset=utf-16") (*pOutMimeTypes)[i] = strdup("text/plain;charset=utf-8"); else (*pOutMimeTypes)[i] = strdup(aMimeTypes[i].getStr()); OString aRet; bool bSuccess = getFromTransferable(xTransferable, (*pOutMimeTypes)[i], aRet); if (!bSuccess || aRet.getLength() < 1) { (*pOutSizes)[i] = 0; (*pOutStreams)[i] = nullptr; } else { (*pOutSizes)[i] = aRet.getLength(); (*pOutStreams)[i] = convertOString(aRet); } } return 1; #endif } static int doc_setClipboard(LibreOfficeKitDocument* pThis, const size_t nInCount, const char **pInMimeTypes, const size_t *pInSizes, const char **pInStreams) { #ifdef IOS (void) pThis; (void) nInCount; (void) pInMimeTypes; (void) pInSizes; (void) pInStreams; #else comphelper::ProfileZone aZone("doc_setClipboard"); SolarMutexGuard aGuard; SetLastExceptionMsg(); ITiledRenderable* pDoc = getTiledRenderable(pThis); if (!pDoc) { SetLastExceptionMsg("Document doesn't support tiled rendering"); return false; } uno::Reference xTransferable(new LOKTransferable(nInCount, pInMimeTypes, pInSizes, pInStreams)); auto xClip = forceSetClipboardForCurrentView(pThis); xClip->setContents(xTransferable, uno::Reference()); SAL_INFO("lok", "Set clip: " << xClip.get() << " to: " << xTransferable); if (!pDoc->isMimeTypeSupported()) { SetLastExceptionMsg("Document doesn't support this mime type"); return false; } #endif return true; } static bool doc_paste(LibreOfficeKitDocument* pThis, const char* pMimeType, const char* pData, size_t nSize) { comphelper::ProfileZone aZone("doc_paste"); SolarMutexGuard aGuard; const char *pInMimeTypes[1]; const char *pInStreams[1]; size_t pInSizes[1]; pInMimeTypes[0] = pMimeType; pInSizes[0] = nSize; pInStreams[0] = pData; if (!doc_setClipboard(pThis, 1, pInMimeTypes, pInSizes, pInStreams)) return false; uno::Sequence aPropertyValues(comphelper::InitPropertySequence( { {"AnchorType", uno::Any(static_cast(css::text::TextContentAnchorType_AS_CHARACTER))}, {"IgnoreComments", uno::Any(true)}, })); if (!comphelper::dispatchCommand(".uno:Paste", aPropertyValues)) { SetLastExceptionMsg("Failed to dispatch the .uno: command"); return false; } return true; } static void doc_setGraphicSelection(LibreOfficeKitDocument* pThis, int nType, int nX, int nY) { comphelper::ProfileZone aZone("doc_setGraphicSelection"); SolarMutexGuard aGuard; SetLastExceptionMsg(); ITiledRenderable* pDoc = getTiledRenderable(pThis); if (!pDoc) { SetLastExceptionMsg("Document doesn't support tiled rendering"); return; } pDoc->setGraphicSelection(nType, nX, nY); } static void getDocLanguages(LibreOfficeKitDocument* pThis, uno::Sequence& rSeq) { SfxViewFrame* pViewFrame = SfxViewFrame::Current(); if (!pViewFrame) return; SfxDispatcher* pDispatcher = pViewFrame->GetBindings().GetDispatcher(); if (!pDispatcher) return; css::uno::Any aLangStatus; pDispatcher->QueryState(SID_LANGUAGE_STATUS, aLangStatus); OUString sCurrent; OUString sKeyboard; OUString sGuessText; SvtScriptType eScriptType = SvtScriptType::LATIN | SvtScriptType::ASIAN | SvtScriptType::COMPLEX; Sequence aSeqLang; if (aLangStatus >>= aSeqLang) { if (aSeqLang.getLength() == 4) { sCurrent = aSeqLang[0]; eScriptType = static_cast(aSeqLang[1].toInt32()); sKeyboard = aSeqLang[1]; sGuessText = aSeqLang[2]; } } else { aLangStatus >>= sCurrent; } LanguageType nLangType; std::set aLangItems; if (!sCurrent.isEmpty()) { nLangType = SvtLanguageTable::GetLanguageType(sCurrent); if (nLangType != LANGUAGE_DONTKNOW) { aLangItems.insert(nLangType); } } const AllSettings& rAllSettings = Application::GetSettings(); nLangType = rAllSettings.GetLanguageTag().getLanguageType(); if (nLangType != LANGUAGE_DONTKNOW && (eScriptType & SvtLanguageOptions::GetScriptTypeOfLanguage(nLangType))) { aLangItems.insert(nLangType); } nLangType = rAllSettings.GetUILanguageTag().getLanguageType(); if (nLangType != LANGUAGE_DONTKNOW && (eScriptType & SvtLanguageOptions::GetScriptTypeOfLanguage(nLangType))) { aLangItems.insert(nLangType); } if (!sKeyboard.isEmpty()) { nLangType = SvtLanguageTable::GetLanguageType(sKeyboard); if (nLangType != LANGUAGE_DONTKNOW && (eScriptType & SvtLanguageOptions::GetScriptTypeOfLanguage(nLangType))) { aLangItems.insert(nLangType); } } if (!sGuessText.isEmpty()) { Reference xLangGuesser; try { xLangGuesser = linguistic2::LanguageGuessing::create(xContext); } catch(...) { } if (xLangGuesser.is()) { lang::Locale aLocale = xLangGuesser->guessPrimaryLanguage(sGuessText, 0, sGuessText.getLength()); LanguageTag aLanguageTag(aLocale); nLangType = aLanguageTag.getLanguageType(false); if (nLangType != LANGUAGE_DONTKNOW && (eScriptType & SvtLanguageOptions::GetScriptTypeOfLanguage(nLangType))) { aLangItems.insert(nLangType); } } } LibLODocument_Impl* pDocument = static_cast(pThis); Reference xDocumentLanguages(pDocument->mxComponent, UNO_QUERY); if (xDocumentLanguages.is()) { const Sequence aLocales(xDocumentLanguages->getDocumentLanguages( static_cast(eScriptType), 64)); for (const lang::Locale& aLocale : aLocales) { nLangType = SvtLanguageTable::GetLanguageType(aLocale.Language); if (nLangType != LANGUAGE_DONTKNOW && (eScriptType & SvtLanguageOptions::GetScriptTypeOfLanguage(nLangType))) { aLangItems.insert(nLangType); } } } int nLocale = 0; Sequence aLocales(aLangItems.size()); auto pLocales = aLocales.getArray(); for (const LanguageType& itLang : aLangItems) { pLocales[nLocale++] = LanguageTag::convertToLocale(itLang); } rSeq = aLocales; } static void doc_resetSelection(LibreOfficeKitDocument* pThis) { comphelper::ProfileZone aZone("doc_resetSelection"); SolarMutexGuard aGuard; SetLastExceptionMsg(); ITiledRenderable* pDoc = getTiledRenderable(pThis); if (!pDoc) { SetLastExceptionMsg("Document doesn't support tiled rendering"); return; } pDoc->resetSelection(); } static char* getLanguages(LibreOfficeKitDocument* pThis, const char* pCommand) { css::uno::Sequence< css::lang::Locale > aLocales; if (xContext.is()) { css::uno::Reference xLangSrv = css::linguistic2::LinguServiceManager::create(xContext); if (xLangSrv.is()) { css::uno::Reference xSpell = xLangSrv->getSpellChecker(); if (xSpell.is()) aLocales = xSpell->getLocales(); } /* FIXME: To obtain the document languages the spell checker can be disabled, so a future re-work of the getLanguages function is needed in favor to use getDocLanguages */ if (!aLocales.hasElements()) { uno::Sequence< css::lang::Locale > aSeq; getDocLanguages(pThis, aSeq); aLocales = aSeq; } } boost::property_tree::ptree aTree; aTree.put("commandName", pCommand); boost::property_tree::ptree aValues; boost::property_tree::ptree aChild; OUString sLanguage; for ( css::lang::Locale const & locale : std::as_const(aLocales) ) { const LanguageTag aLanguageTag( locale ); sLanguage = SvtLanguageTable::GetLanguageString(aLanguageTag.getLanguageType()); if (sLanguage.startsWith("{") && sLanguage.endsWith("}")) continue; sLanguage += ";" + aLanguageTag.getBcp47(false); aChild.put("", sLanguage.toUtf8()); aValues.push_back(std::make_pair("", aChild)); } aTree.add_child("commandValues", aValues); std::stringstream aStream; boost::property_tree::write_json(aStream, aTree); char* pJson = static_cast(malloc(aStream.str().size() + 1)); assert(pJson); // Don't handle OOM conditions strcpy(pJson, aStream.str().c_str()); pJson[aStream.str().size()] = '\0'; return pJson; } static char* getFonts (const char* pCommand) { SfxObjectShell* pDocSh = SfxObjectShell::Current(); if (!pDocSh) return nullptr; const SvxFontListItem* pFonts = static_cast( pDocSh->GetItem(SID_ATTR_CHAR_FONTLIST)); const FontList* pList = pFonts ? pFonts->GetFontList() : nullptr; boost::property_tree::ptree aTree; aTree.put("commandName", pCommand); boost::property_tree::ptree aValues; if ( pList ) { sal_uInt16 nFontCount = pList->GetFontNameCount(); for (sal_uInt16 i = 0; i < nFontCount; ++i) { boost::property_tree::ptree aChildren; const FontMetric& rFontMetric = pList->GetFontName(i); const int* pAry = FontList::GetStdSizeAry(); sal_uInt16 nSizeCount = 0; while (pAry[nSizeCount]) { boost::property_tree::ptree aChild; aChild.put("", static_cast(pAry[nSizeCount]) / 10); aChildren.push_back(std::make_pair("", aChild)); nSizeCount++; } aValues.add_child(rFontMetric.GetFamilyName().toUtf8().getStr(), aChildren); } } aTree.add_child("commandValues", aValues); std::stringstream aStream; boost::property_tree::write_json(aStream, aTree); char* pJson = static_cast(malloc(aStream.str().size() + 1)); assert(pJson); // Don't handle OOM conditions strcpy(pJson, aStream.str().c_str()); pJson[aStream.str().size()] = '\0'; return pJson; } static char* getFontSubset (std::string_view aFontName) { OUString aFoundFont(::rtl::Uri::decode(OStringToOUString(aFontName, RTL_TEXTENCODING_UTF8), rtl_UriDecodeStrict, RTL_TEXTENCODING_UTF8)); boost::property_tree::ptree aTree; aTree.put("commandName", ".uno:FontSubset"); boost::property_tree::ptree aValues; if (const vcl::Font* pFont = FindFont(aFoundFont)) { FontCharMapRef xFontCharMap (new FontCharMap()); auto aDevice(VclPtr::Create(DeviceFormat::WITHOUT_ALPHA)); aDevice->SetFont(*pFont); aDevice->GetFontCharMap(xFontCharMap); SubsetMap aSubMap(xFontCharMap); for (auto const& subset : aSubMap.GetSubsetMap()) { boost::property_tree::ptree aChild; aChild.put("", static_cast(ublock_getCode(subset.GetRangeMin()))); aValues.push_back(std::make_pair("", aChild)); } } aTree.add_child("commandValues", aValues); std::stringstream aStream; boost::property_tree::write_json(aStream, aTree); char* pJson = static_cast(malloc(aStream.str().size() + 1)); assert(pJson); // Don't handle OOM conditions strcpy(pJson, aStream.str().c_str()); pJson[aStream.str().size()] = '\0'; return pJson; } static char* getStyles(LibreOfficeKitDocument* pThis, const char* pCommand) { LibLODocument_Impl* pDocument = static_cast(pThis); boost::property_tree::ptree aTree; aTree.put("commandName", pCommand); uno::Reference xStyleFamiliesSupplier(pDocument->mxComponent, uno::UNO_QUERY); const uno::Reference xStyleFamilies = xStyleFamiliesSupplier->getStyleFamilies(); const uno::Sequence aStyleFamilies = xStyleFamilies->getElementNames(); static const std::vector aWriterStyles = { "Text body", "Quotations", "Title", "Subtitle", "Heading 1", "Heading 2", "Heading 3" }; // We need to keep a list of the default style names // in order to filter these out later when processing // the full list of styles. std::set aDefaultStyleNames; boost::property_tree::ptree aValues; for (OUString const & sStyleFam : aStyleFamilies) { boost::property_tree::ptree aChildren; uno::Reference xStyleFamily(xStyleFamilies->getByName(sStyleFam), uno::UNO_QUERY); // Writer provides a huge number of styles, we have a list of 7 "default" styles which // should be shown in the normal dropdown, which we should add to the start of the list // to simplify their selection. if (sStyleFam == "ParagraphStyles" && doc_getDocumentType(pThis) == LOK_DOCTYPE_TEXT) { for (const OUString& rStyle: aWriterStyles) { aDefaultStyleNames.insert( rStyle ); boost::property_tree::ptree aChild; aChild.put("", rStyle.toUtf8()); aChildren.push_back(std::make_pair("", aChild)); } } const uno::Sequence aStyles = xStyleFamily->getElementNames(); for (const OUString& rStyle: aStyles ) { // Filter out the default styles - they are already at the top // of the list if (aDefaultStyleNames.find(rStyle) == aDefaultStyleNames.end() || (sStyleFam != "ParagraphStyles" || doc_getDocumentType(pThis) != LOK_DOCTYPE_TEXT) ) { boost::property_tree::ptree aChild; aChild.put("", rStyle.toUtf8()); aChildren.push_back(std::make_pair("", aChild)); } } aValues.add_child(sStyleFam.toUtf8().getStr(), aChildren); } // Header & Footer Styles { boost::property_tree::ptree aChild; boost::property_tree::ptree aChildren; static const OUStringLiteral sPageStyles(u"PageStyles"); uno::Reference xProperty; uno::Reference xContainer; if (xStyleFamilies->hasByName(sPageStyles) && (xStyleFamilies->getByName(sPageStyles) >>= xContainer)) { const uno::Sequence aSeqNames = xContainer->getElementNames(); for (OUString const & sName : aSeqNames) { bool bIsPhysical; xProperty.set(xContainer->getByName(sName), uno::UNO_QUERY); if (xProperty.is() && (xProperty->getPropertyValue("IsPhysical") >>= bIsPhysical) && bIsPhysical) { OUString displayName; xProperty->getPropertyValue("DisplayName") >>= displayName; aChild.put("", displayName.toUtf8()); aChildren.push_back(std::make_pair("", aChild)); } } aValues.add_child("HeaderFooter", aChildren); } } { boost::property_tree::ptree aCommandList; { boost::property_tree::ptree aChild; OUString sClearFormat = SvxResId(RID_SVXSTR_CLEARFORM); boost::property_tree::ptree aName; aName.put("", sClearFormat.toUtf8()); aChild.push_back(std::make_pair("text", aName)); boost::property_tree::ptree aCommand; aCommand.put("", ".uno:ResetAttributes"); aChild.push_back(std::make_pair("id", aCommand)); aCommandList.push_back(std::make_pair("", aChild)); } aValues.add_child("Commands", aCommandList); } aTree.add_child("commandValues", aValues); std::stringstream aStream; boost::property_tree::write_json(aStream, aTree); char* pJson = static_cast(malloc(aStream.str().size() + 1)); assert(pJson); // Don't handle OOM conditions strcpy(pJson, aStream.str().c_str()); pJson[aStream.str().size()] = '\0'; return pJson; } namespace { enum class UndoOrRedo { UNDO, REDO }; } /// Returns the JSON representation of either an undo or a redo stack. static char* getUndoOrRedo(LibreOfficeKitDocument* pThis, UndoOrRedo eCommand) { LibLODocument_Impl* pDocument = static_cast(pThis); auto pBaseModel = dynamic_cast(pDocument->mxComponent.get()); if (!pBaseModel) return nullptr; SfxObjectShell* pObjectShell = pBaseModel->GetObjectShell(); if (!pObjectShell) return nullptr; SfxUndoManager* pUndoManager = pObjectShell->GetUndoManager(); if (!pUndoManager) return nullptr; OUString aString; if (eCommand == UndoOrRedo::UNDO) aString = pUndoManager->GetUndoActionsInfo(); else aString = pUndoManager->GetRedoActionsInfo(); char* pJson = strdup(aString.toUtf8().getStr()); return pJson; } /// Returns the JSON representation of the redline stack. static char* getTrackedChanges(LibreOfficeKitDocument* pThis) { LibLODocument_Impl* pDocument = static_cast(pThis); uno::Reference xRedlinesSupplier(pDocument->mxComponent, uno::UNO_QUERY); tools::JsonWriter aJson; // We want positions of the track changes also which is not possible from // UNO. Enable positioning information for text documents only for now, so // construct the tracked changes JSON from inside the sw/, not here using UNO if (doc_getDocumentType(pThis) != LOK_DOCTYPE_TEXT && xRedlinesSupplier.is()) { auto redlinesNode = aJson.startArray("redlines"); uno::Reference xRedlines = xRedlinesSupplier->getRedlines()->createEnumeration(); for (size_t nIndex = 0; xRedlines->hasMoreElements(); ++nIndex) { uno::Reference xRedline(xRedlines->nextElement(), uno::UNO_QUERY); auto redlineNode = aJson.startStruct(); aJson.put("index", static_cast(nIndex)); OUString sAuthor; xRedline->getPropertyValue("RedlineAuthor") >>= sAuthor; aJson.put("author", sAuthor); OUString sType; xRedline->getPropertyValue("RedlineType") >>= sType; aJson.put("type", sType); OUString sComment; xRedline->getPropertyValue("RedlineComment") >>= sComment; aJson.put("comment", sComment); OUString sDescription; xRedline->getPropertyValue("RedlineDescription") >>= sDescription; aJson.put("description", sDescription); util::DateTime aDateTime; xRedline->getPropertyValue("RedlineDateTime") >>= aDateTime; OUString sDateTime = utl::toISO8601(aDateTime); aJson.put("dateTime", sDateTime); } } else { ITiledRenderable* pDoc = getTiledRenderable(pThis); if (!pDoc) { SetLastExceptionMsg("Document doesn't support tiled rendering"); return nullptr; } pDoc->getTrackedChanges(aJson); } return strdup(aJson.finishAndGetAsOString().getStr()); } /// Returns the JSON representation of the redline author table. static char* getTrackedChangeAuthors(LibreOfficeKitDocument* pThis) { ITiledRenderable* pDoc = getTiledRenderable(pThis); if (!pDoc) { SetLastExceptionMsg("Document doesn't support tiled rendering"); return nullptr; } tools::JsonWriter aJsonWriter; pDoc->getTrackedChangeAuthors(aJsonWriter); return strdup(aJsonWriter.finishAndGetAsOString().getStr()); } static char* doc_getCommandValues(LibreOfficeKitDocument* pThis, const char* pCommand) { comphelper::ProfileZone aZone("doc_getCommandValues"); SolarMutexGuard aGuard; SetLastExceptionMsg(); const std::string_view aCommand(pCommand); static constexpr OStringLiteral aViewRowColumnHeaders(".uno:ViewRowColumnHeaders"); static constexpr OStringLiteral aSheetGeometryData(".uno:SheetGeometryData"); static constexpr OStringLiteral aCellCursor(".uno:CellCursor"); static constexpr OStringLiteral aFontSubset(".uno:FontSubset&name="); ITiledRenderable* pDoc = getTiledRenderable(pThis); if (!pDoc) { SetLastExceptionMsg("Document doesn't support tiled rendering"); return nullptr; } if (!strcmp(pCommand, ".uno:LanguageStatus")) { return getLanguages(pThis, pCommand); } else if (!strcmp(pCommand, ".uno:CharFontName")) { return getFonts(pCommand); } else if (!strcmp(pCommand, ".uno:StyleApply")) { return getStyles(pThis, pCommand); } else if (aCommand == ".uno:Undo") { return getUndoOrRedo(pThis, UndoOrRedo::UNDO); } else if (aCommand == ".uno:Redo") { return getUndoOrRedo(pThis, UndoOrRedo::REDO); } else if (aCommand == ".uno:AcceptTrackedChanges") { return getTrackedChanges(pThis); } else if (aCommand == ".uno:TrackedChangeAuthors") { return getTrackedChangeAuthors(pThis); } else if (aCommand == ".uno:ViewAnnotations") { return getPostIts(pThis); } else if (aCommand == ".uno:ViewAnnotationsPosition") { return getPostItsPos(pThis); } else if (aCommand == ".uno:RulerState") { return getRulerState(pThis); } else if (o3tl::starts_with(aCommand, aViewRowColumnHeaders)) { tools::Rectangle aRectangle; if (aCommand.size() > o3tl::make_unsigned(aViewRowColumnHeaders.getLength())) { // Command has parameters. int nX = 0; int nY = 0; int nWidth = 0; int nHeight = 0; std::string_view aArguments = aCommand.substr(aViewRowColumnHeaders.getLength() + 1); sal_Int32 nParamIndex = 0; do { std::string_view aParamToken = o3tl::getToken(aArguments, 0, '&', nParamIndex); sal_Int32 nIndex = 0; std::string_view aKey; std::string_view aValue; do { std::string_view aToken = o3tl::getToken(aParamToken, 0, '=', nIndex); if (aKey.empty()) aKey = aToken; else aValue = aToken; } while (nIndex >= 0); if (aKey == "x") nX = o3tl::toInt32(aValue); else if (aKey == "y") nY = o3tl::toInt32(aValue); else if (aKey == "width") nWidth = o3tl::toInt32(aValue); else if (aKey == "height") nHeight = o3tl::toInt32(aValue); } while (nParamIndex >= 0); aRectangle = tools::Rectangle(nX, nY, nX + nWidth, nY + nHeight); } tools::JsonWriter aJsonWriter; pDoc->getRowColumnHeaders(aRectangle, aJsonWriter); return strdup(aJsonWriter.finishAndGetAsOString().getStr()); } else if (o3tl::starts_with(aCommand, aSheetGeometryData)) { bool bColumns = true; bool bRows = true; bool bSizes = true; bool bHidden = true; bool bFiltered = true; bool bGroups = true; if (aCommand.size() > o3tl::make_unsigned(aSheetGeometryData.getLength())) { bColumns = bRows = bSizes = bHidden = bFiltered = bGroups = false; std::string_view aArguments = aCommand.substr(aSheetGeometryData.getLength() + 1); sal_Int32 nParamIndex = 0; do { std::string_view aParamToken = o3tl::getToken(aArguments, 0, '&', nParamIndex); sal_Int32 nIndex = 0; std::string_view aKey; std::string_view aValue; do { std::string_view aToken = o3tl::getToken(aParamToken, 0, '=', nIndex); if (aKey.empty()) aKey = aToken; else aValue = aToken; } while (nIndex >= 0); bool bEnableFlag = aValue.empty() || o3tl::equalsIgnoreAsciiCase(aValue, "true") || o3tl::toInt32(aValue) > 0; if (!bEnableFlag) continue; if (aKey == "columns") bColumns = true; else if (aKey == "rows") bRows = true; else if (aKey == "sizes") bSizes = true; else if (aKey == "hidden") bHidden = true; else if (aKey == "filtered") bFiltered = true; else if (aKey == "groups") bGroups = true; } while (nParamIndex >= 0); } OString aGeomDataStr = pDoc->getSheetGeometryData(bColumns, bRows, bSizes, bHidden, bFiltered, bGroups); if (aGeomDataStr.isEmpty()) return nullptr; return convertOString(aGeomDataStr); } else if (o3tl::starts_with(aCommand, aCellCursor)) { // Ignore command's deprecated parameters. tools::JsonWriter aJsonWriter; pDoc->getCellCursor(aJsonWriter); return strdup(aJsonWriter.finishAndGetAsOString().getStr()); } else if (o3tl::starts_with(aCommand, aFontSubset)) { return getFontSubset(aCommand.substr(aFontSubset.getLength())); } else if (pDoc->supportsCommand(INetURLObject(OUString::fromUtf8(aCommand)).GetURLPath())) { tools::JsonWriter aJsonWriter; pDoc->getCommandValues(aJsonWriter, aCommand); return strdup(aJsonWriter.finishAndGetAsOString().getStr()); } else { SetLastExceptionMsg("Unknown command, no values returned"); return nullptr; } } static void doc_setClientZoom(LibreOfficeKitDocument* pThis, int nTilePixelWidth, int nTilePixelHeight, int nTileTwipWidth, int nTileTwipHeight) { comphelper::ProfileZone aZone("doc_setClientZoom"); SolarMutexGuard aGuard; SetLastExceptionMsg(); ITiledRenderable* pDoc = getTiledRenderable(pThis); if (!pDoc) { SetLastExceptionMsg("Document doesn't support tiled rendering"); return; } pDoc->setClientZoom(nTilePixelWidth, nTilePixelHeight, nTileTwipWidth, nTileTwipHeight); } static void doc_setClientVisibleArea(LibreOfficeKitDocument* pThis, int nX, int nY, int nWidth, int nHeight) { comphelper::ProfileZone aZone("doc_setClientVisibleArea"); SolarMutexGuard aGuard; SetLastExceptionMsg(); ITiledRenderable* pDoc = getTiledRenderable(pThis); if (!pDoc) { SetLastExceptionMsg("Document doesn't support tiled rendering"); return; } tools::Rectangle aRectangle(Point(nX, nY), Size(nWidth, nHeight)); pDoc->setClientVisibleArea(aRectangle); } static void doc_setOutlineState(LibreOfficeKitDocument* pThis, bool bColumn, int nLevel, int nIndex, bool bHidden) { comphelper::ProfileZone aZone("doc_setOutlineState"); SolarMutexGuard aGuard; SetLastExceptionMsg(); ITiledRenderable* pDoc = getTiledRenderable(pThis); if (!pDoc) { SetLastExceptionMsg("Document doesn't support tiled rendering"); return; } pDoc->setOutlineState(bColumn, nLevel, nIndex, bHidden); } static int doc_createViewWithOptions(LibreOfficeKitDocument* pThis, const char* pOptions) { comphelper::ProfileZone aZone("doc_createView"); SolarMutexGuard aGuard; SetLastExceptionMsg(); OUString aOptions = getUString(pOptions); const OUString aLanguage = extractParameter(aOptions, u"Language"); if (!aLanguage.isEmpty()) { // Set the LOK language tag, used for dialog tunneling. comphelper::LibreOfficeKit::setLanguageTag(LanguageTag(aLanguage)); comphelper::LibreOfficeKit::setLocale(LanguageTag(aLanguage)); } const OUString aDeviceFormFactor = extractParameter(aOptions, u"DeviceFormFactor"); SfxLokHelper::setDeviceFormFactor(aDeviceFormFactor); LibLODocument_Impl* pDocument = static_cast(pThis); const int nId = SfxLokHelper::createView(pDocument->mnDocumentId); vcl::lok::numberOfViewsChanged(SfxLokHelper::getViewsCount(pDocument->mnDocumentId)); #ifdef IOS (void) pThis; #else forceSetClipboardForCurrentView(pThis); #endif return nId; } static int doc_createView(LibreOfficeKitDocument* pThis) { return doc_createViewWithOptions(pThis, nullptr); // No options. } static void doc_destroyView(SAL_UNUSED_PARAMETER LibreOfficeKitDocument* pThis, int nId) { comphelper::ProfileZone aZone("doc_destroyView"); SolarMutexGuard aGuard; SetLastExceptionMsg(); #ifndef IOS LOKClipboardFactory::releaseClipboardForView(nId); #endif SfxLokHelper::destroyView(nId); LibLODocument_Impl* pDocument = static_cast(pThis); vcl::lok::numberOfViewsChanged(SfxLokHelper::getViewsCount(pDocument->mnDocumentId)); } static void doc_setView(SAL_UNUSED_PARAMETER LibreOfficeKitDocument* /*pThis*/, int nId) { comphelper::ProfileZone aZone("doc_setView"); SolarMutexGuard aGuard; SetLastExceptionMsg(); SfxLokHelper::setView(nId); } static int doc_getView(SAL_UNUSED_PARAMETER LibreOfficeKitDocument* /*pThis*/) { comphelper::ProfileZone aZone("doc_getView"); SolarMutexGuard aGuard; SetLastExceptionMsg(); return SfxLokHelper::getView(); } static int doc_getViewsCount(SAL_UNUSED_PARAMETER LibreOfficeKitDocument* pThis) { comphelper::ProfileZone aZone("doc_getViewsCount"); SolarMutexGuard aGuard; SetLastExceptionMsg(); LibLODocument_Impl* pDocument = static_cast(pThis); return SfxLokHelper::getViewsCount(pDocument->mnDocumentId); } static bool doc_getViewIds(SAL_UNUSED_PARAMETER LibreOfficeKitDocument* pThis, int* pArray, size_t nSize) { comphelper::ProfileZone aZone("doc_getViewsIds"); SolarMutexGuard aGuard; SetLastExceptionMsg(); LibLODocument_Impl* pDocument = static_cast(pThis); return SfxLokHelper::getViewIds(pDocument->mnDocumentId, pArray, nSize); } static void doc_setViewLanguage(SAL_UNUSED_PARAMETER LibreOfficeKitDocument* /*pThis*/, int nId, const char* language) { comphelper::ProfileZone aZone("doc_setViewLanguage"); SolarMutexGuard aGuard; SetLastExceptionMsg(); OUString sLanguage = OStringToOUString(language, RTL_TEXTENCODING_UTF8); SfxLokHelper::setViewLanguage(nId, sLanguage); SfxLokHelper::setViewLocale(nId, sLanguage); } unsigned char* doc_renderFont(LibreOfficeKitDocument* pThis, const char* pFontName, const char* pChar, int* pFontWidth, int* pFontHeight) { return doc_renderFontOrientation(pThis, pFontName, pChar, pFontWidth, pFontHeight, 0); } unsigned char* doc_renderFontOrientation(SAL_UNUSED_PARAMETER LibreOfficeKitDocument* /*pThis*/, const char* pFontName, const char* pChar, int* pFontWidth, int* pFontHeight, int pOrientation) { comphelper::ProfileZone aZone("doc_renderFont"); SolarMutexGuard aGuard; SetLastExceptionMsg(); const int nDefaultFontSize = 25; auto aFont = FindFont_FallbackToDefault(OStringToOUString(pFontName, RTL_TEXTENCODING_UTF8)); OUString aText(OStringToOUString(pChar, RTL_TEXTENCODING_UTF8)); if (aText.isEmpty()) aText = aFont.GetFamilyName(); auto aDevice(VclPtr::Create(DeviceFormat::WITHOUT_ALPHA)); ::tools::Rectangle aRect; aFont.SetFontSize(Size(0, nDefaultFontSize)); aFont.SetOrientation(Degree10(pOrientation)); aDevice->SetFont(aFont); aDevice->GetTextBoundRect(aRect, aText); if (aRect.IsEmpty()) return nullptr; int nFontWidth = aRect.Right() + 1; int nFontHeight = aRect.Bottom() + 1; if (nFontWidth <= 0 || nFontHeight <= 0) return nullptr; if (*pFontWidth > 0 && *pFontHeight > 0) { double fScaleX = *pFontWidth / static_cast(nFontWidth) / 1.5; double fScaleY = *pFontHeight / static_cast(nFontHeight) / 1.5; double fScale = std::min(fScaleX, fScaleY); if (fScale >= 1.0) { int nFontSize = fScale * nDefaultFontSize; aFont.SetFontSize(Size(0, nFontSize)); aDevice->SetFont(aFont); } aRect = tools::Rectangle(0, 0, *pFontWidth, *pFontHeight); nFontWidth = *pFontWidth; nFontHeight = *pFontHeight; } unsigned char* pBuffer = static_cast(malloc(4 * nFontWidth * nFontHeight)); if (!pBuffer) return nullptr; memset(pBuffer, 0, nFontWidth * nFontHeight * 4); aDevice->SetBackground(Wallpaper(COL_TRANSPARENT)); aDevice->SetOutputSizePixelScaleOffsetAndLOKBuffer( Size(nFontWidth, nFontHeight), Fraction(1.0), Point(), pBuffer); if (*pFontWidth > 0 && *pFontHeight > 0) { DrawTextFlags const nStyle = DrawTextFlags::Center | DrawTextFlags::VCenter | DrawTextFlags::MultiLine | DrawTextFlags::WordBreak;// | DrawTextFlags::WordBreakHyphenation ; aDevice->DrawText(aRect, aText, nStyle); } else { *pFontWidth = nFontWidth; *pFontHeight = nFontHeight; aDevice->DrawText(Point(0,0), aText); } return pBuffer; } static void doc_paintWindow(LibreOfficeKitDocument* pThis, unsigned nLOKWindowId, unsigned char* pBuffer, const int nX, const int nY, const int nWidth, const int nHeight) { doc_paintWindowDPI(pThis, nLOKWindowId, pBuffer, nX, nY, nWidth, nHeight, 1.0); } static void doc_paintWindowDPI(LibreOfficeKitDocument* pThis, unsigned nLOKWindowId, unsigned char* pBuffer, const int nX, const int nY, const int nWidth, const int nHeight, const double fDPIScale) { doc_paintWindowForView(pThis, nLOKWindowId, pBuffer, nX, nY, nWidth, nHeight, fDPIScale, -1); } static void doc_paintWindowForView(LibreOfficeKitDocument* pThis, unsigned nLOKWindowId, unsigned char* pBuffer, const int nX, const int nY, const int nWidth, const int nHeight, const double fDPIScale, int viewId) { comphelper::ProfileZone aZone("doc_paintWindowDPI"); SolarMutexGuard aGuard; SetLastExceptionMsg(); VclPtr pWindow = vcl::Window::FindLOKWindow(nLOKWindowId); if (!pWindow) { SetLastExceptionMsg("Document doesn't support dialog rendering, or window not found."); return; } // Used to avoid work in setView if set. comphelper::LibreOfficeKit::setDialogPainting(true); if (viewId >= 0) doc_setView(pThis, viewId); // Setup cairo (or CoreGraphics, in the iOS case) to draw with the changed DPI scale (and return // back to 1.0 when the painting finishes) comphelper::ScopeGuard dpiScaleGuard([]() { comphelper::LibreOfficeKit::setDPIScale(1.0); }); comphelper::LibreOfficeKit::setDPIScale(fDPIScale); #if defined(IOS) CGContextRef cgc = CGBitmapContextCreate(pBuffer, nWidth, nHeight, 8, nWidth*4, CGColorSpaceCreateDeviceRGB(), kCGImageAlphaNoneSkipFirst | kCGImageByteOrder32Little); CGContextTranslateCTM(cgc, 0, nHeight); CGContextScaleCTM(cgc, fDPIScale, -fDPIScale); SystemGraphicsData aData; aData.rCGContext = cgc; ScopedVclPtrInstance pDevice(aData, Size(1, 1), DeviceFormat::WITHOUT_ALPHA); pDevice->SetBackground(Wallpaper(COL_TRANSPARENT)); pDevice->SetOutputSizePixel(Size(nWidth, nHeight)); MapMode aMapMode(pDevice->GetMapMode()); aMapMode.SetOrigin(Point(-(nX / fDPIScale), -(nY / fDPIScale))); pDevice->SetMapMode(aMapMode); pWindow->PaintToDevice(pDevice.get(), Point(0, 0)); CGContextRelease(cgc); #else ScopedVclPtrInstance pDevice(DeviceFormat::WITHOUT_ALPHA); pDevice->SetBackground(Wallpaper(COL_TRANSPARENT)); pDevice->SetOutputSizePixelScaleOffsetAndLOKBuffer(Size(nWidth, nHeight), Fraction(1.0), Point(), pBuffer); MapMode aMapMode(pDevice->GetMapMode()); aMapMode.SetOrigin(Point(-(nX / fDPIScale), -(nY / fDPIScale))); pDevice->SetMapMode(aMapMode); pWindow->PaintToDevice(pDevice.get(), Point(0, 0)); #endif comphelper::LibreOfficeKit::setDialogPainting(false); } static void doc_postWindow(LibreOfficeKitDocument* /*pThis*/, unsigned nLOKWindowId, int nAction, const char* pData) { comphelper::ProfileZone aZone("doc_postWindow"); SolarMutexGuard aGuard; SetLastExceptionMsg(); VclPtr pWindow = vcl::Window::FindLOKWindow(nLOKWindowId); if (!pWindow) { SetLastExceptionMsg("Document doesn't support dialog rendering, or window not found."); return; } if (nAction == LOK_WINDOW_CLOSE) { vcl::CloseTopLevel(pWindow); } else if (nAction == LOK_WINDOW_PASTE) { #ifndef IOS OUString aMimeType; css::uno::Sequence aData; std::vector aArgs(jsonToPropertyValuesVector(pData)); { aArgs.size() == 2 && aArgs[0].Name == "MimeType" && (aArgs[0].Value >>= aMimeType) && aArgs[1].Name == "Data" && (aArgs[1].Value >>= aData); } if (!aMimeType.isEmpty() && aData.hasElements()) { uno::Reference xTransferable(new LOKTransferable(aMimeType, aData)); uno::Reference xClipboard(new LOKClipboard); xClipboard->setContents(xTransferable, uno::Reference()); pWindow->SetClipboard(xClipboard); KeyEvent aEvent(0, KEY_PASTE, 0); Application::PostKeyEvent(VclEventId::WindowKeyInput, pWindow, &aEvent); } else SetLastExceptionMsg("Window command 'paste': wrong parameters."); #else (void) pData; assert(!"doc_postWindow() with LOK_WINDOW_PASTE should not be called on iOS"); #endif } } // CERTIFICATE AND DOCUMENT SIGNING static bool doc_insertCertificate(LibreOfficeKitDocument* pThis, const unsigned char* pCertificateBinary, const int nCertificateBinarySize, const unsigned char* pPrivateKeyBinary, const int nPrivateKeySize) { comphelper::ProfileZone aZone("doc_insertCertificate"); if (!xContext.is()) return false; LibLODocument_Impl* pDocument = static_cast(pThis); if (!pDocument->mxComponent.is()) return false; SfxBaseModel* pBaseModel = dynamic_cast(pDocument->mxComponent.get()); if (!pBaseModel) return false; SfxObjectShell* pObjectShell = pBaseModel->GetObjectShell(); if (!pObjectShell) return false; uno::Reference xSEInitializer = xml::crypto::SEInitializer::create(xContext); uno::Reference xSecurityContext = xSEInitializer->createSecurityContext(OUString()); if (!xSecurityContext.is()) return false; uno::Reference xSecurityEnvironment = xSecurityContext->getSecurityEnvironment(); uno::Reference xCertificateCreator(xSecurityEnvironment, uno::UNO_QUERY); if (!xCertificateCreator.is()) return false; uno::Sequence aCertificateSequence; std::string aCertificateString(reinterpret_cast(pCertificateBinary), nCertificateBinarySize); std::string aCertificateBase64String = extractCertificate(aCertificateString); if (!aCertificateBase64String.empty()) { OUString aBase64OUString = OUString::createFromAscii(aCertificateBase64String.c_str()); comphelper::Base64::decode(aCertificateSequence, aBase64OUString); } else { aCertificateSequence.realloc(nCertificateBinarySize); std::copy(pCertificateBinary, pCertificateBinary + nCertificateBinarySize, aCertificateSequence.getArray()); } uno::Sequence aPrivateKeySequence; std::string aPrivateKeyString(reinterpret_cast(pPrivateKeyBinary), nPrivateKeySize); std::string aPrivateKeyBase64String = extractPrivateKey(aPrivateKeyString); if (!aPrivateKeyBase64String.empty()) { OUString aBase64OUString = OUString::createFromAscii(aPrivateKeyBase64String.c_str()); comphelper::Base64::decode(aPrivateKeySequence, aBase64OUString); } else { aPrivateKeySequence.realloc(nPrivateKeySize); std::copy(pPrivateKeyBinary, pPrivateKeyBinary + nPrivateKeySize, aPrivateKeySequence.getArray()); } uno::Reference xCertificate = xCertificateCreator->createDERCertificateWithPrivateKey(aCertificateSequence, aPrivateKeySequence); if (!xCertificate.is()) return false; SolarMutexGuard aGuard; return pObjectShell->SignDocumentContentUsingCertificate(xCertificate); } static bool doc_addCertificate(LibreOfficeKitDocument* pThis, const unsigned char* pCertificateBinary, const int nCertificateBinarySize) { comphelper::ProfileZone aZone("doc_addCertificate"); if (!xContext.is()) return false; LibLODocument_Impl* pDocument = static_cast(pThis); if (!pDocument->mxComponent.is()) return false; SfxBaseModel* pBaseModel = dynamic_cast(pDocument->mxComponent.get()); if (!pBaseModel) return false; SfxObjectShell* pObjectShell = pBaseModel->GetObjectShell(); if (!pObjectShell) return false; uno::Reference xSEInitializer = xml::crypto::SEInitializer::create(xContext); uno::Reference xSecurityContext = xSEInitializer->createSecurityContext(OUString()); if (!xSecurityContext.is()) return false; uno::Reference xSecurityEnvironment = xSecurityContext->getSecurityEnvironment(); uno::Reference