/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4; fill-column: 100 -*- */ /* * This file is part of the Collabora Office 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 #include #include #include #include #include #if HAVE_FEATURE_QUICKJS #include #endif #include #ifdef IOS #include #include #include #include #include #import #import #include #endif #undef HAVE_MALLOC_TRIM #ifdef UNX # include #endif #ifdef LINUX #if defined __GLIBC__ # include # define HAVE_MALLOC_TRIM #endif #endif #ifdef ANDROID #include #endif #ifdef __EMSCRIPTEN__ #include #include #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 #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 #include #include #include #include #include #ifdef IOS #include #endif #include #include #include #include #if defined(_WIN32) && !USE_HEADLESS_CODE #include #endif #include #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 "kitinteractionhandler.hxx" #include "kitclipboard.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; using namespace bridge; using namespace uno; using namespace ::cpo::uno; using namespace lang; #ifdef UNX static int urandom = -1; extern "C" { int SAL_JNI_EXPORT kit_open_urandom() { return dup(urandom); } }; #endif using LanguageToolCfg = officecfg::Office::Linguistic::GrammarChecking::LanguageTool; static LibCO_Impl *gImpl = nullptr; static bool cok_preinit_2_called = false; static bool gUseCompactFonts = false; static std::weak_ptr< COKitClass > gOfficeClass; static std::weak_ptr< COKitDocumentClass > gDocumentClass; static void SetLastExceptionMsg(const OUString& s = OUString()) { SAL_WARN_IF(!s.isEmpty(), "kit", "kit exception '" + s + "'"); if (gImpl) gImpl->maLastExceptionMsg = s; } namespace { struct ExtensionMap { std::string_view extn; OUString 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 cpo::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(COKitCallbackType::PROFILE_FRAME, aChunk.getStr(), gImpl->mpCallbackData); } } }; TraceEventDumper *traceEventDumper = nullptr; constexpr ExtensionMap aWriterExtensionMap[] = { { "doc", u"MS Word 97"_ustr }, { "docm", u"Office Open XML Text VBA"_ustr }, { "docx", u"Office Open XML Text"_ustr }, { "fodt", u"OpenDocument Text Flat XML"_ustr }, { "html", u"HTML (StarWriter)"_ustr }, { "odt", u"writer8"_ustr }, { "ott", u"writer8_template"_ustr }, { "pdf", u"writer_pdf_Export"_ustr }, { "epub", u"EPUB"_ustr }, { "rtf", u"Rich Text Format"_ustr }, { "txt", u"Text"_ustr }, { "xhtml", u"XHTML Writer File"_ustr }, { "png", u"writer_png_Export"_ustr }, { "xml", u"writer_indexing_export"_ustr }, { "md", u"Markdown"_ustr }, }; constexpr ExtensionMap aCalcExtensionMap[] = { { "csv", u"Text - txt - csv (StarCalc)"_ustr }, { "fods", u"OpenDocument Spreadsheet Flat XML"_ustr }, { "html", u"HTML (StarCalc)"_ustr }, { "ods", u"calc8"_ustr }, { "ots", u"calc8_template"_ustr }, { "pdf", u"calc_pdf_Export"_ustr }, { "xhtml", u"XHTML Calc File"_ustr }, { "xls", u"MS Excel 97"_ustr }, { "xlsm", u"Calc Office Open XML VBA"_ustr }, { "xlsx", u"Calc Office Open XML"_ustr }, { "png", u"calc_png_Export"_ustr }, }; constexpr ExtensionMap aImpressExtensionMap[] = { { "fodp", u"OpenDocument Presentation Flat XML"_ustr }, { "html", u"impress_html_Export"_ustr }, { "odg", u"impress8_draw"_ustr }, { "odp", u"impress8"_ustr }, { "otp", u"impress8_template"_ustr }, { "pdf", u"impress_pdf_Export"_ustr }, { "potm", u"Impress MS PowerPoint 2007 XML Template"_ustr }, { "potx", u"Impress MS PowerPoint 2007 XML Template"_ustr }, { "pot", u"MS PowerPoint 97 Vorlage"_ustr }, { "pptm", u"Impress MS PowerPoint 2007 XML VBA"_ustr }, { "ppts", u"Impress MS PowerPoint 2007 XML AutoPlay"_ustr }, { "pptx", u"Impress MS PowerPoint 2007 XML"_ustr }, { "pps", u"MS PowerPoint 97 AutoPlay"_ustr }, { "ppt", u"MS PowerPoint 97"_ustr }, { "svg", u"impress_svg_Export"_ustr }, { "xhtml", u"XHTML Impress File"_ustr }, { "png", u"impress_png_Export"_ustr }, { "bmp", u"impress_bmp_Export"_ustr }, { "gif", u"impress_gif_Export"_ustr }, { "tif", u"impress_tif_Export"_ustr }, { "tiff", u"impress_tif_Export"_ustr }, // tif and tiff are the same format: see https://developer.mozilla.org/en-US/docs/Web/Media/Formats/Image_types#tiff_tagged_image_file_format }; constexpr ExtensionMap aDrawExtensionMap[] = { { "fodg", u"OpenDocument Drawing Flat XML"_ustr }, { "html", u"draw_html_Export"_ustr }, { "odg", u"draw8"_ustr }, { "pdf", u"draw_pdf_Export"_ustr }, { "svg", u"draw_svg_Export"_ustr }, { "xhtml", u"XHTML Draw File"_ustr }, { "png", u"draw_png_Export"_ustr }, }; OUString getUString(const char* pString) { if (pString == nullptr) return OUString(); return OStringToOUString(pString, RTL_TEXTENCODING_UTF8); } // Tolerate embedded \0s etc. 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; } 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. 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(); } } // unnamed namespace std::vector desktop::jsonToPropertyValuesVector(const char* pJSON) { std::vector aArguments; if (pJSON && pJSON[0] != '\0') { aArguments = comphelper::JsonToPropertyValues(pJSON); } return aArguments; } static void extractLinks(const uno::Reference< container::XNameAccess >& xLinks, bool subcontent, tools::JsonWriter& aJson) { for (const OUString& aLink : xLinks->getElementNames()) { cpo::uno::Any aAny; 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 continue; } uno::Reference< beans::XPropertySet > xTarget; if( aAny >>= xTarget ) { try { // get name to display aAny = xTarget->getPropertyValue(u"LinkDisplayName"_ustr); OUString aStrDisplayname; aAny >>= aStrDisplayname; if (subcontent) { aJson.put(aStrDisplayname, aLink); } else { uno::Reference xSI(xTarget, uno::UNO_QUERY_THROW); if (xSI->supportsService(u"com.sun.star.document.LinkTarget"_ustr)) { aJson.put(aStrDisplayname, aLink); continue; } else { auto aNode = aJson.startNode( OUStringToOString(aStrDisplayname, RTL_TEXTENCODING_UTF8)); uno::Reference< document::XLinkTargetSupplier > xLTS( xTarget, uno::UNO_QUERY ); if( xLTS.is() ) extractLinks(xLTS->getLinks(), true, aJson); } } } catch(...) { SAL_WARN("kit", "extractLinks: Exception"); } } } } static void unoAnyToJson(tools::JsonWriter& rJson, std::string_view pNodeName, const cpo::uno::Any& anyItem) { auto aNode = rJson.startNode(pNodeName); OUString aType = anyItem.getValueTypeName(); rJson.put("type", aType); if (aType == "string") rJson.put("value", anyItem.get()); else if (aType == "unsigned long") rJson.put("value", OString::number(anyItem.get())); else if (aType == "long") rJson.put("value", OString::number(anyItem.get())); else if (aType == "[]any") { cpo::uno::Sequence aSeq; if (anyItem >>= aSeq) { auto valueNode = rJson.startNode("value"); for (auto i = 0; i < aSeq.getLength(); ++i) { unoAnyToJson(rJson, OString::number(i), 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, KitHelper::MaxTwips, KitHelper::MaxTwips); if (comphelper::COKit::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 < end && *pos != ',') ++pos; if (pos < end) ++pos; assert(pos < end); tools::Long nTop = rtl_str_toInt64_WithLength(pos, 10, end - pos); while (pos < end && *pos != ',') ++pos; if (pos < end) ++pos; assert(pos < end); tools::Long nWidth = rtl_str_toInt64_WithLength(pos, 10, end - pos); while (pos < end && *pos != ',') ++pos; if (pos < end) ++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::COKit::isPartInInvalidation()) { while (pos < end && *pos != ',') ++pos; if (pos < end) ++pos; assert(pos < end); nPart = rtl_str_toInt64_WithLength(pos, 10, end - pos); while (pos < end && *pos != ',') ++pos; if (pos < end) { ++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 COKitCallbackType type) { switch (type) { case COKitCallbackType::CELL_VIEW_CURSOR: case COKitCallbackType::GRAPHIC_VIEW_SELECTION: case COKitCallbackType::INVALIDATE_VIEW_CURSOR: case COKitCallbackType::TEXT_VIEW_SELECTION: case COKitCallbackType::VIEW_CURSOR_VISIBLE: return true; default: return false; } } static bool isUpdatedType(COKitCallbackType type) { switch (type) { case COKitCallbackType::TEXT_SELECTION: case COKitCallbackType::TEXT_SELECTION_START: case COKitCallbackType::TEXT_SELECTION_END: return true; default: return false; } } static bool isUpdatedTypePerViewId(COKitCallbackType type) { switch (type) { case COKitCallbackType::INVALIDATE_VISIBLE_CURSOR: case COKitCallbackType::INVALIDATE_VIEW_CURSOR: case COKitCallbackType::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; } // Wonder global state ... static uno::Reference xContext; static uno::Reference xSFactory; static uno::Reference xFactory; namespace { OUString lcl_getCurrentDocumentMimeType(const LibLODocument_Impl* pDocument) { SfxBaseModel* pBaseModel = dynamic_cast(pDocument->mxComponent.get()); if (!pBaseModel) return u""_ustr; SfxObjectShell* pObjectShell = pBaseModel->GetObjectShell(); if (!pObjectShell) return u""_ustr; SfxMedium* pMedium = pObjectShell->GetMedium(); if (!pMedium) return u""_ustr; auto pFilter = pMedium->GetFilter(); if (!pFilter) return u""_ustr; 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* pViewSh = SfxViewShell::Current(); if (!pViewSh) return; pViewSh->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* pViewSh = SfxViewShell::Current(); if (!pViewSh) return; pViewSh->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( u""_ustr ); SfxPoolItemHolder aResult; pViewFrm->GetBindings().GetDispatcher()->QueryState(SID_ATTR_PAGE_SIZE, aResult); std::unique_ptr pPageSizeItem(static_cast(aResult.getItem())->Clone()); pViewFrm->GetBindings().GetDispatcher()->QueryState(SID_ATTR_PAGE_LRSPACE, aResult); std::unique_ptr pPageLRMarginItem(static_cast(aResult.getItem())->Clone()); pViewFrm->GetBindings().GetDispatcher()->QueryState(SID_ATTR_PAGE_ULSPACE, aResult); std::unique_ptr pPageULMarginItem(static_cast(aResult.getItem())->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* pCurrent = SfxViewShell::Current()) { pCurrent->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 hideSidebar() { SfxViewShell* pViewShell = SfxViewShell::Current(); SfxViewFrame* pViewFrame = pViewShell ? &pViewShell->GetViewFrame() : nullptr; if (pViewFrame) pViewFrame->SetChildWindow(SID_SIDEBAR, false , false ); else SetLastExceptionMsg(u"No view shell or sidebar"_ustr); } cpo::uno::Sequence setLanguageToolConfig() { cpo::uno::Sequence aLTLocales; const char* pEnabled = ::getenv("LANGUAGETOOL_ENABLED"); const char* pBaseUrlString = ::getenv("LANGUAGETOOL_BASEURL"); if (pEnabled && pBaseUrlString) { const char* pUsername = ::getenv("LANGUAGETOOL_USERNAME"); const char* pApikey = ::getenv("LANGUAGETOOL_APIKEY"); const char* pSSLVerification = ::getenv("LANGUAGETOOL_SSL_VERIFICATION"); const char* pRestProtocol = ::getenv("LANGUAGETOOL_RESTPROTOCOL"); OUString aEnabled = OStringToOUString(pEnabled, RTL_TEXTENCODING_UTF8); if (aEnabled != "true") return aLTLocales; OUString aBaseUrl = OStringToOUString(pBaseUrlString, RTL_TEXTENCODING_UTF8); try { using LanguageToolCfg = officecfg::Office::Linguistic::GrammarChecking::LanguageTool; auto batch(comphelper::ConfigurationChanges::create()); LanguageToolCfg::BaseURL::set(aBaseUrl, batch); LanguageToolCfg::IsEnabled::set(true, batch); if (pSSLVerification) { OUString aSSLVerification = OStringToOUString(pSSLVerification, RTL_TEXTENCODING_UTF8); LanguageToolCfg::SSLCertVerify::set(aSSLVerification == "true", batch); } if (pRestProtocol) { OUString aRestProtocol = OStringToOUString(pRestProtocol, RTL_TEXTENCODING_UTF8); LanguageToolCfg::RestProtocol::set(aRestProtocol, batch); } if (pUsername && pApikey) { OUString aUsername = OStringToOUString(pUsername, RTL_TEXTENCODING_UTF8); OUString aApiKey = OStringToOUString(pApikey, RTL_TEXTENCODING_UTF8); LanguageToolCfg::Username::set(aUsername, batch); LanguageToolCfg::ApiKey::set(aApiKey, batch); } batch->commit(); uno::Reference xGC( xContext->getServiceManager()->createInstanceWithContext(u"org.openoffice.lingu.LanguageToolGrammarChecker"_ustr, xContext), uno::UNO_QUERY_THROW); uno::Reference xSuppLoc(xGC, uno::UNO_QUERY_THROW); css::uno::Reference xLangSrv = css::linguistic2::LinguServiceManager::create(xContext); if (xLangSrv.is()) { css::uno::Reference xSpell = xLangSrv->getSpellChecker(); if (xSpell.is()) { Sequence aEmpty; Sequence aLocales = xSpell->getLocales(); for (int itLocale = 0; itLocale < aLocales.getLength(); itLocale++) { // turn off spell checker if LanguageTool supports the locale already if (xSuppLoc->hasLocale(aLocales[itLocale])) xLangSrv->setConfiguredServices( SN_SPELLCHECKER, aLocales[itLocale], aEmpty); } } } aLTLocales = xSuppLoc->getLocales(); } catch(uno::Exception const& rException) { SAL_WARN("kit", "Failed to set LanguageTool API settings: " << rException.Message); } } return aLTLocales; } } // 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(COKitDocument* pThis); static int doc_saveAs(COKitDocument* pThis, const char* pUrl, const char* pFormat, const char* pFilterOptions); static COKitDocumentType doc_getDocumentType(COKitDocument* pThis); static int doc_getParts(COKitDocument* pThis); static char* doc_getPartPageRectangles(COKitDocument* pThis); static int doc_getPart(COKitDocument* pThis); static void doc_setPart(COKitDocument* pThis, int nPart); static void doc_selectPart(COKitDocument* pThis, int nPart, int nSelect); static void doc_moveSelectedParts(COKitDocument* pThis, int nPosition, bool bDuplicate, int nIntoSection); static char* doc_getPartName(COKitDocument* pThis, int nPart); static void doc_setPartMode(COKitDocument* pThis, COKitPartMode ePartMode); static int doc_getEditMode(COKitDocument* pThis); static void doc_paintTile(COKitDocument* pThis, unsigned char* pBuffer, const int nCanvasWidth, const int nCanvasHeight, const int nTilePosX, const int nTilePosY, const int nTileWidth, const int nTileHeight); static void doc_paintPartTile(COKitDocument* 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 COKitTileMode doc_getTileMode(COKitDocument* pThis); static void doc_getDocumentSize(COKitDocument* pThis, long* pWidth, long* pHeight); static void doc_getDataArea(COKitDocument* pThis, long nTab, long* pCol, long* pRow); static void doc_initializeForRendering(COKitDocument* pThis, const char* pArguments); static void doc_registerCallback(COKitDocument* pThis, COKitCallback pCallback, void* pData); static void doc_postKeyEvent(COKitDocument* pThis, COKitKeyEventType eType, int nCharCode, int nKeyCode); static void doc_setBlockedCommandList(COKitDocument* pThis, int nViewId, const char* blockedCommandList); static void doc_postWindowExtTextInputEvent(COKitDocument* pThis, unsigned nWindowId, COKitExtTextInputType eType, const char* pText); static void doc_removeTextContext(COKitDocument* pThis, unsigned nKitWindowId, int nCharBefore, int nCharAfter); static void doc_sendDialogEvent(COKitDocument* pThis, unsigned long long int nKitWindowId, const char* pArguments); static void doc_postWindowKeyEvent(COKitDocument* pThis, unsigned nKitWindowId, COKitKeyEventType eType, int nCharCode, int nKeyCode); static void doc_postMouseEvent (COKitDocument* pThis, COKitMouseEventType eType, int nX, int nY, int nCount, int nButtons, int nModifier); static void doc_postWindowMouseEvent (COKitDocument* pThis, unsigned nKitWindowId, COKitMouseEventType eType, int nX, int nY, int nCount, int nButtons, int nModifier); static void doc_postWindowGestureEvent(COKitDocument* pThis, unsigned nKitWindowId, const char* pType, int nX, int nY, int nOffset); static void doc_postUnoCommand(COKitDocument* pThis, const char* pCommand, const char* pArguments, bool bNotifyWhenFinished); static void doc_setWindowTextSelection(COKitDocument* pThis, unsigned nKitWindowId, bool swap, int nX, int nY); static void doc_setTextSelection (COKitDocument* pThis, COKitSetTextSelectionType eType, int nX, int nY); static char* doc_getTextSelection(COKitDocument* pThis, const char* pMimeType, char** pUsedMimeType); static COKitSelectionType doc_getSelectionType(COKitDocument* pThis); static COKitSelectionType doc_getSelectionTypeAndText(COKitDocument* pThis, const char* pMimeType, char** pText, char** pUsedMimeType); static int doc_getClipboard (COKitDocument* pThis, const char **pMimeTypes, size_t *pOutCount, char ***pOutMimeTypes, size_t **pOutSizes, char ***pOutStreams); static int doc_setClipboard (COKitDocument* pThis, const size_t nInCount, const char **pInMimeTypes, const size_t *pInSizes, const char **pInStreams); static void doc_transferClipboardFromView(COKitDocument* pThis, int nSourceViewId); static bool doc_paste(COKitDocument* pThis, const char* pMimeType, const char* pData, size_t nSize); static void doc_flushClipboard(COKitDocument* pThis); static void doc_setGraphicSelection (COKitDocument* pThis, COKitSetGraphicSelectionType eType, int nX, int nY); static void doc_resetSelection (COKitDocument* pThis); static char* doc_getCommandValues(COKitDocument* pThis, const char* pCommand); static void doc_setClientZoom(COKitDocument* pThis, int nTilePixelWidth, int nTilePixelHeight, int nTileTwipWidth, int nTileTwipHeight); static void doc_setClientVisibleArea(COKitDocument* pThis, int nX, int nY, int nWidth, int nHeight); static void doc_setOutlineState(COKitDocument* pThis, bool bColumn, int nLevel, int nIndex, bool bHidden); static int doc_createView(COKitDocument* pThis); static int doc_createViewWithOptions(COKitDocument* pThis, const char* pOptions); static void doc_destroyView(COKitDocument* pThis, int nId); static void doc_setView(COKitDocument* pThis, int nId); static int doc_getView(COKitDocument* pThis); static int doc_getViewsCount(COKitDocument* pThis); static bool doc_getViewIds(COKitDocument* pThis, int* pArray, size_t nSize); static void doc_setViewLanguage(COKitDocument* pThis, int nId, const char* language); static unsigned char* doc_renderFontOrientation(COKitDocument* pThis, const char *pFontName, const char *pChar, int* pFontWidth, int* pFontHeight, int pOrientation); static char* doc_getPartHash(COKitDocument* pThis, int nPart); static void doc_paintWindow(COKitDocument* pThis, unsigned nKitWindowId, unsigned char* pBuffer, const int nX, const int nY, const int nWidth, const int nHeight); static void doc_paintWindowDPI(COKitDocument* pThis, unsigned nKitWindowId, unsigned char* pBuffer, const int nX, const int nY, const int nWidth, const int nHeight, const double fDPIScale); static void doc_paintWindowForView(COKitDocument* pThis, unsigned nKitWindowId, unsigned char* pBuffer, const int nX, const int nY, const int nWidth, const int nHeight, const double fDPIScale, int viewId); static void doc_postWindow(COKitDocument* pThis, unsigned nKitWindowId, COKitWindowAction eAction, const char* pData); static char* doc_getPartInfo(COKitDocument* pThis, int nPart); static unsigned long long doc_getPartUniqueId(COKitDocument* pThis, int nPart, int nMode); static int doc_getPartIndex(COKitDocument* pThis, int nPart, int nMode); static bool doc_insertCertificate(COKitDocument* pThis, const unsigned char* pCertificateBinary, const int nCertificateBinarySize, const unsigned char* pPrivateKeyBinary, const int nPrivateKeyBinarySize); static bool doc_addCertificate(COKitDocument* pThis, const unsigned char* pCertificateBinary, const int nCertificateBinarySize); static int doc_getSignatureState(COKitDocument* pThis); static size_t doc_renderShapeSelection(COKitDocument* pThis, char** pOutput); static void doc_resizeWindow(COKitDocument* pThis, unsigned nKitWindowId, const int nWidth, const int nHeight); static void doc_completeFunction(COKitDocument* pThis, const char*); static void doc_sendFormFieldEvent(COKitDocument* pThis, const char* pArguments); static bool doc_renderSearchResult(COKitDocument* pThis, const char* pSearchResult, unsigned char** pBitmapBuffer, int* pWidth, int* pHeight, size_t* pByteSize); static void doc_sendContentControlEvent(COKitDocument* pThis, const char* pArguments); static void doc_setViewTimezone(COKitDocument* pThis, int nId, const char* timezone); static void doc_setViewReadOnly(COKitDocument* pThis, int nId, const bool readonly); static void doc_setAllowChangeComments(COKitDocument* pThis, int nId, const bool allow); static void doc_setAllowManageRedlines(COKitDocument* pThis, int nId, bool allow); static void doc_setAccessibilityState(COKitDocument* pThis, int nId, bool bEnabled); static char* doc_getA11yFocusedParagraph(COKitDocument* pThis); static int doc_getA11yCaretPosition(COKitDocument* pThis); static char* doc_getPresentationInfo(COKitDocument* pThis); static bool doc_createSlideRenderer( COKitDocument* pThis, const char* pSlideHash, int nSlideNumber, unsigned* nViewWidth, unsigned* nViewHeight, bool bRenderBackground, bool bRenderMasterPage); static void doc_postSlideshowCleanup(COKitDocument* pThis); static bool doc_renderNextSlideLayer( COKitDocument* pThis, unsigned char* pBuffer, bool* bIsBitmapLayer, double* pScale, char** pJsonMsg); static void doc_setViewOption(COKitDocument* pDoc, const char* pOption, const char* pValue); static void doc_setColorPreviewState(COKitDocument* pThis, int nId, bool bEnabled); } // extern "C" namespace { ITiledRenderable* getTiledRenderable(COKitDocument* pThis) { LibLODocument_Impl* pDocument = static_cast(pThis); return dynamic_cast(pDocument->mxComponent.get()); } // Whether the boundary names this document's parts by their stable page unique ids rather than // by page-list indexes: the case for presentation and drawing documents, which always hold at // least one page. bool partsAreUniqueIds(ITiledRenderable* pDoc) { return pDoc && pDoc->getPartUniqueId(0, 0) != 0; } // The part number the boundary names the part at nIndex by: the page's stable unique id. The // mode selects the page list the index addresses. Returns -1 when no page holds that index or // the id does not fit in a part number; the ids count up from 1, one step per object the // process creates, so a real document session stays far below that limit. int partNumberFromIndex(ITiledRenderable* pDoc, int nIndex, int nMode) { if (nIndex < 0) return -1; const sal_uInt64 nUniqueId = pDoc->getPartUniqueId(nIndex, nMode); if (nUniqueId == 0 || nUniqueId > o3tl::make_unsigned(std::numeric_limits::max())) { SAL_WARN_IF(nUniqueId != 0, "kit", "The unique id " << nUniqueId << " of part " << nIndex << " does not fit in a part number"); return -1; } return static_cast(nUniqueId); } // The index the part with the given part number holds now in the given mode's page list, or -1 // when no page carries that number any more. int partIndexFromNumber(ITiledRenderable* pDoc, int nPart, int nMode) { if (nPart <= 0) return -1; // Past the last page of the mode's list the lookup returns zero. for (int nIndex = 0;; ++nIndex) { const sal_uInt64 nUniqueId = pDoc->getPartUniqueId(nIndex, nMode); if (nUniqueId == 0) return -1; if (nUniqueId == o3tl::make_unsigned(nPart)) return nIndex; } } /* * 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(COKitDocument *pThis) { ITiledRenderable* pDoc = getTiledRenderable(pThis); rtl::Reference xClip(KitClipboardFactory::getClipboardForCurView()); if (!pDoc) { return xClip; } SAL_INFO("kit", "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; } const vcl::Font* FindFont(std::u16string_view rFontName) { SfxObjectShell* pDocSh = SfxObjectShell::Current(); if (!pDocSh) return nullptr; const SvxFontListItem* pFonts = 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); } COKitDocumentType getDocumentType (COKitDocument* pThis) { SetLastExceptionMsg(); LibLODocument_Impl* pDocument = static_cast(pThis); try { uno::Reference xDocument(pDocument->mxComponent, uno::UNO_QUERY_THROW); if (xDocument->supportsService(u"com.sun.star.sheet.SpreadsheetDocument"_ustr)) { return COKitDocumentType::SPREADSHEET; } else if (xDocument->supportsService(u"com.sun.star.presentation.PresentationDocument"_ustr)) { return COKitDocumentType::PRESENTATION; } else if (xDocument->supportsService(u"com.sun.star.drawing.DrawingDocument"_ustr)) { return COKitDocumentType::DRAWING; } else if (xDocument->supportsService(u"com.sun.star.text.TextDocument"_ustr) || xDocument->supportsService(u"com.sun.star.text.WebDocument"_ustr)) { return COKitDocumentType::TEXT; } else { SetLastExceptionMsg(u"unknown document type"_ustr); } } catch (const uno::Exception& exception) { SetLastExceptionMsg("exception: " + exception.Message); } return COKitDocumentType::OTHER; } } // anonymous namespace WaitUntilIdle::WaitUntilIdle() : maIdle{"LibLODocument IdleTask"} { maIdle.SetPriority(TaskPriority::TOOLKIT_DEBUG); maIdle.SetInvokeHandler(LINK(this, WaitUntilIdle, IdleHdl)); } IMPL_LINK_NOARG(WaitUntilIdle, IdleHdl, Timer*, void) { // SfxBindings defers slot updates via an AutoTimer with // TIMEOUT_FIRST=300ms (DEFAULT_IDLE priority). The vcl::Idle // backing this handler runs at TOOLKIT_DEBUG and is ready // immediately, so without this drain we report "idle" while the // 300ms timer is still pending and a later wave of sidebar // updates arrives after the reply. Drain the bindings of every // view frame belonging to the originating view's document - using // SfxViewFrame::Current() would pick the globally active frame, // which need not be the one that armed this idle in multi-view / // multi-doc kit processes. const int nViewId = mnViewId; SfxViewShell* pOriginShell = SfxViewShell::GetFirst(false, [nViewId](const SfxViewShell& shell) { return shell.GetViewShellId().get() == nViewId; }); if (pOriginShell) { SfxObjectShell* pDocShell = pOriginShell->GetObjectShell(); for (SfxViewFrame* pFrame = SfxViewFrame::GetFirst(pDocShell); pFrame; pFrame = SfxViewFrame::GetNext(*pFrame, pDocShell)) { pFrame->GetBindings().Update(); } } tools::JsonWriter aJson; aJson.put("commandName", ".uno:ReportWhenIdle"); aJson.put("idleID", msIdleId); mpCallbackFlushHandler->queue(COKitCallbackType::UNO_COMMAND_RESULT, aJson.finishAndGetAsOString()); mpCallbackFlushHandler.reset(); msIdleId.clear(); mnViewId = -1; } 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->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; 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->transferClipboardFromView = doc_transferClipboardFromView; m_pDocumentClass->paste = doc_paste; m_pDocumentClass->flushClipboard = doc_flushClipboard; 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->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->getPartUniqueId = doc_getPartUniqueId; m_pDocumentClass->getPartIndex = doc_getPartIndex; 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; m_pDocumentClass->setAccessibilityState = doc_setAccessibilityState; m_pDocumentClass->getA11yFocusedParagraph = doc_getA11yFocusedParagraph; m_pDocumentClass->getA11yCaretPosition = doc_getA11yCaretPosition; m_pDocumentClass->setViewReadOnly = doc_setViewReadOnly; m_pDocumentClass->setAllowChangeComments = doc_setAllowChangeComments; m_pDocumentClass->setAllowManageRedlines = doc_setAllowManageRedlines; m_pDocumentClass->getPresentationInfo = doc_getPresentationInfo; m_pDocumentClass->createSlideRenderer = doc_createSlideRenderer; m_pDocumentClass->postSlideshowCleanup = doc_postSlideshowCleanup; m_pDocumentClass->renderNextSlideLayer = doc_renderNextSlideLayer; m_pDocumentClass->setViewOption = doc_setViewOption; m_pDocumentClass->setColorPreviewState = doc_setColorPreviewState; gDocumentClass = m_pDocumentClass; } pClass = m_pDocumentClass.get(); forceSetClipboardForCurrentView(this); } LibLODocument_Impl::~LibLODocument_Impl() { if (comphelper::COKit::isForkedChild()) { // Touch the least memory possible, while trying to avoid leaking files. SfxBaseModel* pBaseModel = dynamic_cast(mxComponent.get()); if (pBaseModel) { SfxObjectShell* pObjectShell = pBaseModel->GetObjectShell(); if (pObjectShell) pObjectShell->InternalCloseAndRemoveFiles(); } return; } try { mxComponent->dispose(); } catch (const css::lang::DisposedException&) { TOOLS_WARN_EXCEPTION("kit", "failed to dispose document"); } } static OUString getGenerator() { OUString sGenerator( Translate::ExpandVariables(u"%PRODUCTNAME %PRODUCTVERSION%PRODUCTEXTENSION (%1)"_ustr)); OUString os(u"$_OS"_ustr); ::rtl::Bootstrap::expandMacros(os); return sGenerator.replaceFirst("%1", os); } extern "C" { // One of these is created per view to handle events cf. doc_registerCallback CallbackFlushHandler::CallbackFlushHandler(COKitDocument* pDocument, COKitCallback pCallback, void* pData) : m_pDocument(pDocument), m_pCallback(pCallback), m_pFlushEvent(nullptr), m_pData(pData), m_nDisableCallbacks(0) { // 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(COKitCallbackType::TEXT_SELECTION, "NIL"_ostr); m_states.emplace(COKitCallbackType::GRAPHIC_SELECTION, "NIL"_ostr); m_states.emplace(COKitCallbackType::INVALIDATE_VISIBLE_CURSOR, "NIL"_ostr); m_states.emplace(COKitCallbackType::STATE_CHANGED, "NIL"_ostr); m_states.emplace(COKitCallbackType::MOUSE_POINTER, "NIL"_ostr); m_states.emplace(COKitCallbackType::CELL_CURSOR, "NIL"_ostr); m_states.emplace(COKitCallbackType::CELL_FORMULA, "NIL"_ostr); m_states.emplace(COKitCallbackType::CELL_ADDRESS, "NIL"_ostr); m_states.emplace(COKitCallbackType::CURSOR_VISIBLE, "NIL"_ostr); m_states.emplace(COKitCallbackType::SET_PART, "NIL"_ostr); m_states.emplace(COKitCallbackType::TABLE_SELECTED, "NIL"_ostr); m_states.emplace(COKitCallbackType::TAB_STOP_LIST, "NIL"_ostr); m_states.emplace(COKitCallbackType::RULER_UPDATE, "NIL"_ostr); m_states.emplace(COKitCallbackType::VERTICAL_RULER_UPDATE, "NIL"_ostr); m_states.emplace(COKitCallbackType::STATUS_INDICATOR_SET_VALUE, "NIL"_ostr); if (char* pViewRenderState = pDocument->pClass->getCommandValues(pDocument, ".uno:ViewRenderState")) { m_aViewRenderState = OString(pViewRenderState); free(pViewRenderState); } } void CallbackFlushHandler::stop() { if (m_pFlushEvent) { Application::RemoveUserEvent(m_pFlushEvent); m_pFlushEvent = nullptr; } } 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( COKitCallbackType eType, bool value ) { assert(isUpdatedType(eType)); const size_t nIndex = static_cast(eType); if( m_updatedTypes.size() <= nIndex ) m_updatedTypes.resize( nIndex + 1 ); // new are default-constructed, i.e. false m_updatedTypes[ nIndex ] = value; if(value) scheduleFlush(); } void CallbackFlushHandler::resetUpdatedType( COKitCallbackType eType ) { setUpdatedType( eType, false ); } void CallbackFlushHandler::setUpdatedTypePerViewId( COKitCallbackType eType, int nViewId, int nSourceViewId, bool value ) { assert(isUpdatedTypePerViewId(eType)); std::vector& types = m_updatedTypesPerViewId[ nViewId ]; const size_t nIndex = static_cast(eType); if( types.size() <= nIndex ) types.resize( nIndex + 1 ); // new are default-constructed, i.e. 'set' is false types[ nIndex ] = PerViewIdData{ value, nSourceViewId }; if(value) scheduleFlush(); } void CallbackFlushHandler::resetUpdatedTypePerViewId( COKitCallbackType eType, int nViewId ) { assert(isUpdatedTypePerViewId(eType)); bool allViewIds = false; // Handle specially messages that do not have viewId for backwards compatibility. if( eType == COKitCallbackType::INVALIDATE_VISIBLE_CURSOR && !comphelper::COKit::isViewIdForVisCursorInvalidation()) allViewIds = true; if( !allViewIds ) { setUpdatedTypePerViewId( eType, nViewId, -1, false ); return; } for( auto& it : m_updatedTypesPerViewId ) { std::vector& types = it.second; const size_t nIndex = static_cast(eType); if( types.size() >= nIndex ) types[ nIndex ].set = false; } } void CallbackFlushHandler::viewCallback(COKitCallbackType eType, const OString& pPayload) { // A SET_PART payload carries the page-list index of the page the view switched to, while the // boundary names parts of a presentation or drawing document by their stable page unique // ids. Translate when queueing, while the page still holds that index. if (eType == COKitCallbackType::SET_PART) { ITiledRenderable* pDoc = getTiledRenderable(m_pDocument); if (partsAreUniqueIds(pDoc)) { const int nPart = partNumberFromIndex(pDoc, pPayload.toInt32(), pDoc->getEditMode()); if (nPart < 0) { SAL_INFO("kit", "Skipping SET_PART for the gone part " << pPayload); return; } CallbackData callbackData(OString::number(nPart)); queue(eType, callbackData); return; } } CallbackData callbackData(pPayload); queue(eType, callbackData); } void CallbackFlushHandler::viewCallbackWithViewId(COKitCallbackType eType, const OString& pPayload, int nViewId) { CallbackData callbackData(pPayload, nViewId); queue(eType, callbackData); } void CallbackFlushHandler::viewVectorPartChanged(int nPart) { // Only a view that renders from vector primitives consumes deltas. if (!m_bVectorRendering || nPart < 0) return; // Repeated changes of the same part between two flushes collapse // into a single delta, computed at flush time. m_vectorDeltaParts.insert(nPart); scheduleFlush(); } void CallbackFlushHandler::flushVectorPrimitivesDeltas() { if (m_vectorDeltaParts.empty()) return; std::set aParts; aParts.swap(m_vectorDeltaParts); ITiledRenderable* pDocument = getTiledRenderable(m_pDocument); if (!pDocument) return; for (const int nPart : aParts) { // Computing the delta at delivery time reads the document after // the change that triggered the invalidation has fully landed. // The command tracks the version last pushed to this view and // returns the delta since it, so the mark advances only for a // delta that is handed to the client. const OString aCommand = ".uno:VectorPrimitives?part=" + OString::number(nPart) + "&pushdelta=1&viewid=" + OString::number(m_viewId); tools::JsonWriter aJsonWriter; pDocument->getCommandValues(aJsonWriter, std::string_view(aCommand.getStr(), aCommand.getLength())); const OString aDelta = aJsonWriter.finishAndGetAsOString(); m_pCallback(COKitCallbackType::VECTOR_PRIMITIVES_DELTA, aDelta.getStr(), m_pData); } } void CallbackFlushHandler::viewInvalidateTilesCallback(const tools::Rectangle* pRect, int nPart, int nMode) { // The invalidation carries the page-list index of the invalidated page, while the boundary // names parts of a presentation or drawing document by their stable page unique ids. // Translate when queueing, while the page still holds that index, so the queued rectangles // merge under a key that survives page renumbering. A negative part stands for every part // and passes through. if (nPart >= 0) { ITiledRenderable* pDoc = getTiledRenderable(m_pDocument); if (partsAreUniqueIds(pDoc)) { nPart = partNumberFromIndex(pDoc, nPart, nMode); if (nPart < 0) return; } } tools::Rectangle& rPaintedTiles = m_aPaintedTiles[nPart][nMode]; tools::Rectangle aRect; if (m_bVectorRendering) { // A vector-rendered view paints no bitmap tiles, so there is no // painted-tile bounding box to crop against. Forward the invalidation // as-is, or invalidate everything when the rect is null. The delta // push is not scheduled here: an invalidation only reaches views // whose paint pipeline is active, while viewVectorPartChanged is // driven from the model change and reaches every view. aRect = pRect ? *pRect : RectangleAndPart::emptyAllRectangle; } else if (rPaintedTiles.IsEmpty()) { // We have not sent any tiles: don't send invalidations. return; } else if (pRect) { // We got an invalidate: crop it against the bbox. aRect = *pRect; aRect.Intersection(rPaintedTiles); if (aRect.IsEmpty()) { return; } } else { // EMPTY invalidation: reset the bbox. rPaintedTiles = tools::Rectangle(); // nullptr pRect means: invalidate everything. aRect = RectangleAndPart::emptyAllRectangle; } // RectangleAndPart ctor doesn't store &aRect, so this is OK. CallbackData callbackData(&aRect, nPart, nMode); queue(COKitCallbackType::INVALIDATE_TILES, callbackData); } void CallbackFlushHandler::viewUpdatedCallback(COKitCallbackType eType) { assert(isUpdatedType( eType )); std::unique_lock lock(m_mutex); SAL_INFO("kit", "Updated: [" << eType << "]"); setUpdatedType(eType, true); } void CallbackFlushHandler::viewUpdatedCallbackPerViewId(COKitCallbackType eType, int nViewId, int nSourceViewId) { assert(isUpdatedTypePerViewId( eType )); std::unique_lock lock(m_mutex); SAL_INFO("kit", "Updated: [" << eType << "]"); setUpdatedTypePerViewId(eType, nViewId, nSourceViewId, true); } void CallbackFlushHandler::dumpState(rtl::OStringBuffer &rState) { // NB. no locking rState.append("\n View:\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::viewAddPendingInvalidateTiles() { // Invoke() will call flushPendingKitInvalidateTiles(), so just make sure the timer is active. scheduleFlush(); } void CallbackFlushHandler::queue(const COKitCallbackType type, const OString& data) { CallbackData callbackData(data); queue(type, callbackData); } void CallbackFlushHandler::queue(const COKitCallbackType type, CallbackData& aCallbackData) { comphelper::ProfileZone aZone("CallbackFlushHandler::queue"); SAL_INFO("kit", "Queue: [" << type << "]: [" << aCallbackData.getPayload() << "] on " << m_queue1.size() << " entries."); if (comphelper::COKit::isForkedChild()) { // In background mode - avoid any extraneous or confusing messages switch (type) { case COKitCallbackType::INVALIDATE_TILES: case COKitCallbackType::INVALIDATE_VISIBLE_CURSOR: case COKitCallbackType::TEXT_SELECTION: case COKitCallbackType::CURSOR_VISIBLE: case COKitCallbackType::GRAPHIC_SELECTION: case COKitCallbackType::TABLE_SELECTED: case COKitCallbackType::SET_PART: case COKitCallbackType::DOCUMENT_SIZE_CHANGED: case COKitCallbackType::MOUSE_POINTER: case COKitCallbackType::INVALIDATE_HEADER: case COKitCallbackType::INVALIDATE_SHEET_GEOMETRY: SAL_INFO("kit", "Elide event in background save mode"); return; default: break; } } bool bIsChartActive = false; bool bIsComment = false; if (type == COKitCallbackType::GRAPHIC_SELECTION) { KitChartHelper aChartHelper(SfxViewShell::Current()); bIsChartActive = aChartHelper.GetWindow() != nullptr; } else if (type == COKitCallbackType::COMMENT) { bIsComment = true; } else if (type == COKitCallbackType::VIEW_RENDER_STATE) { m_aViewRenderState = aCallbackData.getPayload(); } 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 != COKitCallbackType::STATE_CHANGED && type != COKitCallbackType::INVALIDATE_TILES && type != COKitCallbackType::INVALIDATE_VISIBLE_CURSOR && type != COKitCallbackType::CURSOR_VISIBLE && type != COKitCallbackType::VIEW_CURSOR_VISIBLE && type != COKitCallbackType::TEXT_SELECTION && type != COKitCallbackType::TEXT_SELECTION_START && type != COKitCallbackType::TEXT_SELECTION_END && type != COKitCallbackType::MEDIA_SHAPE && type != COKitCallbackType::REFERENCE_MARKS) { SAL_INFO("kit", "Skipping while painting [" << type << "]: [" << aCallbackData.getPayload() << "]."); return; } // In Writer we drop all notifications during painting. if (doc_getDocumentType(m_pDocument) == COKitDocumentType::TEXT) return; } // Suppress invalid payloads. if (type == COKitCallbackType::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("kit", "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("kit", "Received event with updated type [" << type << "] as normal callback"); resetUpdatedType(type); } if(isUpdatedTypePerViewId(type)) { SAL_INFO("kit", "Received event with updated type [" << type << "] as normal callback"); resetUpdatedTypePerViewId(type, aCallbackData.getViewId()); } // drop duplicate callbacks for the listed types switch (type) { case COKitCallbackType::TEXT_SELECTION_START: case COKitCallbackType::TEXT_SELECTION_END: case COKitCallbackType::TEXT_SELECTION: case COKitCallbackType::GRAPHIC_SELECTION: case COKitCallbackType::GRAPHIC_VIEW_SELECTION: case COKitCallbackType::INVALIDATE_VISIBLE_CURSOR: case COKitCallbackType::INVALIDATE_VIEW_CURSOR: case COKitCallbackType::STATE_CHANGED: case COKitCallbackType::MOUSE_POINTER: case COKitCallbackType::CELL_CURSOR: case COKitCallbackType::CELL_VIEW_CURSOR: case COKitCallbackType::CELL_FORMULA: case COKitCallbackType::CELL_ADDRESS: case COKitCallbackType::CELL_SELECTION_AREA: case COKitCallbackType::CURSOR_VISIBLE: case COKitCallbackType::VIEW_CURSOR_VISIBLE: case COKitCallbackType::SET_PART: case COKitCallbackType::TEXT_VIEW_SELECTION: case COKitCallbackType::INVALIDATE_HEADER: case COKitCallbackType::WINDOW: case COKitCallbackType::CALC_FUNCTION_LIST: case COKitCallbackType::INVALIDATE_SHEET_GEOMETRY: case COKitCallbackType::REFERENCE_MARKS: case COKitCallbackType::CELL_AUTO_FILL_AREA: case COKitCallbackType::A11Y_FOCUS_CHANGED: case COKitCallbackType::A11Y_CARET_CHANGED: case COKitCallbackType::A11Y_TEXT_SELECTION_CHANGED: case COKitCallbackType::A11Y_FOCUSED_CELL_CHANGED: case COKitCallbackType::COLOR_PALETTES: case COKitCallbackType::A11Y_EDITING_IN_SELECTION_STATE: case COKitCallbackType::A11Y_SELECTION_CHANGED: { 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("kit", "Skipping queue duplicate [" << type << + "]: [" << aCallbackData.getPayload() << "]."); return; } } break; default: break; } if (type == COKitCallbackType::TEXT_SELECTION && aCallbackData.isEmpty()) { const auto posStart = std::find(m_queue1.rbegin(), m_queue1.rend(), COKitCallbackType::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(), COKitCallbackType::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 COKitCallbackType::TEXT_SELECTION_START: case COKitCallbackType::TEXT_SELECTION_END: case COKitCallbackType::TEXT_SELECTION: case COKitCallbackType::GRAPHIC_SELECTION: case COKitCallbackType::INVALIDATE_VISIBLE_CURSOR: case COKitCallbackType::INVALIDATE_TILES: case COKitCallbackType::TOOLTIP: if (removeAll(type)) SAL_INFO("kit", "Removed dups of [" << type << "]: [" << aCallbackData.getPayload() << "]."); break; default: 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 COKitCallbackType::TEXT_SELECTION_START: case COKitCallbackType::TEXT_SELECTION_END: case COKitCallbackType::TEXT_SELECTION: case COKitCallbackType::MOUSE_POINTER: case COKitCallbackType::CELL_CURSOR: case COKitCallbackType::CELL_FORMULA: case COKitCallbackType::CELL_ADDRESS: case COKitCallbackType::CURSOR_VISIBLE: case COKitCallbackType::SET_PART: case COKitCallbackType::STATUS_INDICATOR_SET_VALUE: case COKitCallbackType::RULER_UPDATE: case COKitCallbackType::VERTICAL_RULER_UPDATE: case COKitCallbackType::A11Y_FOCUS_CHANGED: case COKitCallbackType::A11Y_CARET_CHANGED: case COKitCallbackType::A11Y_TEXT_SELECTION_CHANGED: case COKitCallbackType::A11Y_FOCUSED_CELL_CHANGED: case COKitCallbackType::COLOR_PALETTES: case COKitCallbackType::TOOLTIP: case COKitCallbackType::SHAPE_INNER_TEXT: case COKitCallbackType::SHAPE_DRAG_PREVIEW: { if (removeAll(type)) SAL_INFO("kit", "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 COKitCallbackType::INVALIDATE_VISIBLE_CURSOR: // 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 if (aCallbackData.getPayload().indexOf("\"hyperlink\":\"\"") == -1 && aCallbackData.getPayload().indexOf("\"hyperlink\": {}") == -1) break; [[fallthrough]]; case COKitCallbackType::CELL_VIEW_CURSOR: case COKitCallbackType::GRAPHIC_VIEW_SELECTION: case COKitCallbackType::INVALIDATE_VIEW_CURSOR: case COKitCallbackType::TEXT_VIEW_SELECTION: case COKitCallbackType::VIEW_CURSOR_VISIBLE: case COKitCallbackType::CALC_FUNCTION_LIST: case COKitCallbackType::FORM_FIELD_BUTTON: { const int nViewId = aCallbackData.getViewId(); removeAll(type, [nViewId] (const CallbackData& elemData) { return (nViewId == elemData.getViewId()); } ); } break; case COKitCallbackType::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 COKitCallbackType::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 COKitCallbackType::WINDOW: if (processWindowEvent(type, aCallbackData)) return; break; case COKitCallbackType::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; default: 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("kit", "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("kit", "Current Queue: " << oss.str()); assert( std::all_of( m_queue2.begin(), m_queue2.end(), [](const CallbackData& c) { return c.validate(); })); } #endif lock.unlock(); scheduleFlush(); } bool CallbackFlushHandler::processInvalidateTilesEvent(COKitCallbackType type, CallbackData& aCallbackData) { RectangleAndPart rcNew = aCallbackData.getRectangleAndPart(); if (rcNew.isEmpty()) { SAL_INFO("kit", "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(), COKitCallbackType::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("kit", "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("kit", "Skipping queue [" << type << "]: [" << aCallbackData.getPayload() << "] since overlaps existing all-parts."); return true; } } } if (rcNew.isInfinite()) { SAL_INFO("kit", "Have Empty [" << type << "]: [" << aCallbackData.getPayload() << "] so removing all with part " << rcNew.m_nPart << "."); removeAll(COKitCallbackType::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("kit", "Have [" << type << "]: [" << aCallbackData.getPayload() << "] so merging overlapping."); removeAll(COKitCallbackType::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("kit", "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("kit", "New " << rcNew.toString() << " has " << rcOld.toString() << "?"); if (rcNew.m_aRectangle.Contains(rcOld.m_aRectangle) && rcOld.m_nMode == rcNew.m_nMode) { SAL_INFO("kit", "New " << rcNew.toString() << " engulfs old " << rcOld.toString() << "."); return true; } } else if (rcOld.m_nPart == -1) { // Don't merge unless fully overlapped. SAL_INFO("kit", "Old " << rcOld.toString() << " has " << rcNew.toString() << "?"); if (rcOld.m_aRectangle.Contains(rcNew.m_aRectangle) && rcOld.m_nMode == rcNew.m_nMode) { SAL_INFO("kit", "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("kit", "Merging " << rcNew.toString() << " & " << rcOld.toString() << " => " << rcOverlap.toString() << " Overlap: " << bOverlap); if (bOverlap) { rcNew.m_aRectangle.Union(rcOld.m_aRectangle); SAL_INFO("kit", "Merged: " << rcNew.toString()); return true; } } // Keep others. return false; }); if (rcNew.m_aRectangle != rcOrig.m_aRectangle) { SAL_INFO("kit", "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("kit", "Error: merged rect smaller."); } } } aCallbackData.updateRectangleAndPart(rcNew); // Queue this one. return false; } bool CallbackFlushHandler::processWindowEvent(COKitCallbackType type, CallbackData& aCallbackData) { const OString& payload = aCallbackData.getPayload(); boost::property_tree::ptree& aTree = aCallbackData.setJson(std::string(payload)); const unsigned nKitWindowId = 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(COKitCallbackType::WINDOW,[&nKitWindowId](const CallbackData& elemData) { const boost::property_tree::ptree& aOldTree = elemData.getJson(); if (nKitWindowId == 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 != COKitCallbackType::WINDOW) continue; const boost::property_tree::ptree& aOldTree = it2->getJson(); if (nKitWindowId == 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("kit.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(COKitCallbackType::WINDOW, [&aNewRect, &nKitWindowId, ¤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 (nKitWindowId == aOldTree.get("id", 0)) { if (aNewRect == aOldRect) { SAL_INFO("kit.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("kit.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("kit.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("kit.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(COKitCallbackType::WINDOW,[&nKitWindowId](const CallbackData& elemData) { const boost::property_tree::ptree& aOldTree = elemData.getJson(); if (nKitWindowId == aOldTree.get("id", 0)) return true; return false; }); VclPtr pWindow = vcl::Window::FindKitWindow(nKitWindowId); if (!pWindow) { SetLastExceptionMsg(u"Document doesn't support dialog rendering, or window not found."_ustr); return false; } auto xClip = forceSetClipboardForCurrentView(m_pDocument); pWindow->SetClipboard(uno::Reference(xClip)); } 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(COKitCallbackType::WINDOW, [&nKitWindowId](const CallbackData& elemData) { const boost::property_tree::ptree& aOldTree = elemData.getJson(); if (nKitWindowId == 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; } ); // 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 // COKitCallbackType::TEXT_SELECTION_START and COKitCallbackType::TEXT_SELECTION_END // must always precede COKitCallbackType::TEXT_SELECTION if present. // Only these types should be present (see isUpdatedType()) and should be processed in this order. static const COKitCallbackType orderedUpdatedTypes[] = { COKitCallbackType::TEXT_SELECTION_START, COKitCallbackType::TEXT_SELECTION_END, COKitCallbackType::TEXT_SELECTION }; // Only these types should be present (see isUpdatedTypePerViewId()) and (as of now) // the order doesn't matter. static const COKitCallbackType orderedUpdatedTypesPerViewId[] = { COKitCallbackType::INVALIDATE_VISIBLE_CURSOR, COKitCallbackType::INVALIDATE_VIEW_CURSOR, COKitCallbackType::TEXT_VIEW_SELECTION }; if (viewShell) { for( COKitCallbackType type : orderedUpdatedTypes ) { const size_t nIndex = static_cast(type); if(nIndex < updatedTypes.size() && updatedTypes[ nIndex ]) { enqueueUpdatedType( type, viewShell, m_viewId ); } } } else { // View removed, probably cleaning up. SAL_INFO("kit", "View #" << m_viewId << " no longer found for updated events"); } for( const auto& it : updatedTypesPerViewId ) { int viewId = it.first; const std::vector& types = it.second; for( COKitCallbackType type : orderedUpdatedTypesPerViewId ) { const size_t nIndex = static_cast(type); if(nIndex < types.size() && types[ nIndex ].set) { SfxViewShell* sourceViewShell = viewShell; const int sourceViewId = types[ nIndex ].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("kit", "View #" << sourceViewId << " no longer found for updated event [" << type << "]"); continue; // View removed, probably cleaning up. } enqueueUpdatedType( type, sourceViewShell, viewId ); } } } } void CallbackFlushHandler::enqueueUpdatedType( COKitCallbackType type, const SfxViewShell* viewShell, int viewId ) { if (type == COKitCallbackType::INVALIDATE_VISIBLE_CURSOR) { if (const SfxViewShell* viewShell2 = KitStarMathHelper(viewShell).GetSmViewShell()) viewShell = viewShell2; } std::optional payload = viewShell->getKitPayload( type, viewId ); if(!payload) return; // No actual payload to send. CallbackData callbackData = isUpdatedTypePerViewId(type) ? CallbackData(*payload, viewId) : CallbackData(*payload); m_queue1.emplace_back(type); m_queue2.emplace_back(callbackData); SAL_INFO("kit", "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->flushPendingKitInvalidateTiles(); } std::unique_lock lock(m_mutex); // Append messages for updated types, fetch them only now. enqueueUpdatedTypes(); SAL_INFO("kit", "Flushing " << m_queue1.size() << " elements."); auto it1 = m_queue1.begin(); auto it2 = m_queue2.begin(); for (; it1 != m_queue1.end(); ++it1, ++it2) { const COKitCallbackType type = *it1; const auto& payload = it2->getPayload(); const int viewId = lcl_isViewCallbackType(type) ? it2->getViewId() : -1; SAL_INFO("kit", "processing event: [" << type << ',' << viewId << "]: [" << payload << "]."); // common code-path for events on this view: if (viewId == -1) { sal_Int32 idx; // key-value pairs if (type == COKitCallbackType::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("kit", "Skipping new state duplicate: [" << type << "]: [" << payload << "]."); continue; } SAL_INFO("kit", "Replacing a state element [" << type << "]: [" << payload << "]."); stateIt->second = value; } else { SAL_INFO("kit", "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("kit", "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("kit", "Skipping view duplicate [" << type << ',' << viewId << "]: [" << payload << "]."); continue; } SAL_INFO("kit", "Replacing an element in view states [" << type << ',' << viewId << "]: [" << payload << "]."); stateIt->second = payload; } else { SAL_INFO("kit", "Inserted a new element in view states: [" << type << ',' << viewId << "]: [" << payload << "]"); states.emplace(type, payload); } } } m_pCallback(type, payload.getStr(), m_pData); } // The deltas of the changed vector parts follow the queued // messages, so the client sees each invalidation before the delta // that answers it. flushVectorPrimitivesDeltas(); m_queue1.clear(); m_queue2.clear(); stop(); } void CallbackFlushHandler::scheduleFlush() { if (!m_pFlushEvent) m_pFlushEvent = Application::PostUserEvent(LINK(this, CallbackFlushHandler, FlushQueue)); } IMPL_LINK_NOARG(CallbackFlushHandler, FlushQueue, void*, void) { m_pFlushEvent = nullptr; invoke(); } bool CallbackFlushHandler::removeAll(COKitCallbackType 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(COKitCallbackType 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); } void CallbackFlushHandler::tilePainted(int nPart, int nMode, const tools::Rectangle& rRectangle) { // Painted a new tile: grow the bbox. tools::Rectangle& rPaintedTiles = m_aPaintedTiles[nPart][nMode]; rPaintedTiles.Union(rRectangle); } static void doc_destroy(COKitDocument *pThis) { comphelper::ProfileZone aZone("doc_destroy"); SolarMutexGuard aGuard; LibLODocument_Impl *pDocument = static_cast(pThis); #ifndef IOS KitClipboardFactory::releaseClipboardsForDocument(pDocument->mnDocumentId); #endif // Drop any original-document-URL mapping recorded for this document at load. // Clear it by the key we captured then, not via xModel->getURL(): the model // may already be disposed by the time we get here (doc_destroy runs from // ~Document()), and getURL() on a disposed model throws DisposedException, // which would escape the destructor and call std::terminate(). if (!pDocument->maOriginalDocumentUrlKey.isEmpty()) comphelper::COKit::clearOriginalDocumentUrl(pDocument->maOriginalDocumentUrlKey); delete pDocument; } static void lo_destroy (COKit* pThis); static int lo_initialize (COKit* pThis, const char* pInstallPath, const char* pUserProfilePath); static COKitDocument* lo_documentLoad (COKit* pThis, const char* pURL); static char * lo_getError (COKit* pThis); static void lo_freeError (char* pFree); static COKitDocument* lo_documentLoadWithOptions (COKit* pThis, const char* pURL, const char* pOptions); static void lo_registerCallback (COKit* pThis, COKitCallback pCallback, void* pData); static char* lo_getFilterTypes(COKit* pThis); static void lo_setOptionalFeatures(COKit* pThis, COKitOptionalFeatures features); static void lo_setDocumentPassword(COKit* pThis, const char* pURL, const char* pPassword); static char* lo_getVersionInfo(COKit* pThis); static int lo_runMacro (COKit* pThis, const char* pURL); static bool lo_signDocument(COKit* pThis, const char* pUrl, const unsigned char* pCertificateBinary, const int nCertificateBinarySize, const unsigned char* pPrivateKeyBinary, const int nPrivateKeyBinarySize); static char* lo_extractRequest(COKit* pThis, const char* pFilePath); static void lo_trimMemory(COKit* pThis, int nTarget); static void* lo_startURP(COKit* pThis, void* pReceiveURPFromLOContext, void* pSendURPToLOContext, int (*fnReceiveURPFromLO)(void* pContext, const signed char* pBuffer, int nLen), int (*fnSendURPToLO)(void* pContext, signed char* pBuffer, int nLen)); static void lo_stopURP(COKit* pThis, void* pSendURPToLOContext); static int lo_joinThreads(COKit* pThis); static void lo_startThreads(COKit* pThis); static void lo_setForkedChild(COKit* pThis, bool bIsChild); static void lo_runLoop(COKit* pThis, COKitPollCallback pPollCallback, COKitWakeCallback pWakeCallback, void* pData); static void lo_registerAnyInputCallback(COKit* pThis, COKitAnyInputCallback pAnyInputCallback, void* pData); static void lo_registerFileSaveDialogCallback(COKit* pThis, COKitFileSaveDialogCallback pFileSaveDialogCallback); static void lo_registerRevealInFileManagerCallback(COKit* pThis, COKitRevealInFileManagerCallback pRevealInFileManagerCallback); static void lo_sendDialogEvent(COKit* pThis, unsigned long long int nKitWindowId, const char* pArguments); static void lo_setOption(COKit* pThis, const char* pOption, const char* pValue); static void lo_dumpState(COKit* pThis, const char* pOptions, char** pState); static char* lo_extractDocumentStructureRequest(COKit* pThis, const char* pFilePath, const char* pFilter); static int lo_getDocsCount(COKit* pThis); static void lo_installClipboardProvider(COKit* pThis, const COKitClipboardProvider* pProvider); static int lo_getGlobalClipboard(COKit* pThis, const char** pMimeTypes, size_t* pOutCount, char*** pOutMimeTypes, size_t** pOutSizes, char*** pOutStreams); static void lo_executeScript( char const * script, char ** result, char ** error, void (*proxyCallback) (void * data, char const * payload), void * proxyCallbackData, bool * usedLegacyUnoApi); static void lo_deliverProxyResult(char const * callId, char const * jsonValue); static void lo_cancelProxyCalls(); static int lo_isExpectedReentry(); static bool lo_takeLegacyUnoApiUseFlag(); LibCO_Impl::LibCO_Impl() : m_pOfficeClass( gOfficeClass.lock() ) , maThread(nullptr) , mpCallback(nullptr) , mpCallbackData(nullptr) , mOptionalFeatures(COKitOptionalFeatures::NONE) { if(!m_pOfficeClass) { m_pOfficeClass = std::make_shared(); 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; m_pOfficeClass->startURP = lo_startURP; m_pOfficeClass->stopURP = lo_stopURP; m_pOfficeClass->joinThreads = lo_joinThreads; m_pOfficeClass->startThreads = lo_startThreads; m_pOfficeClass->setForkedChild = lo_setForkedChild; m_pOfficeClass->extractDocumentStructureRequest = lo_extractDocumentStructureRequest; m_pOfficeClass->registerAnyInputCallback = lo_registerAnyInputCallback; m_pOfficeClass->registerFileSaveDialogCallback = lo_registerFileSaveDialogCallback; m_pOfficeClass->registerRevealInFileManagerCallback = lo_registerRevealInFileManagerCallback; m_pOfficeClass->getDocsCount = lo_getDocsCount; m_pOfficeClass->executeScript = lo_executeScript; m_pOfficeClass->deliverProxyResult = lo_deliverProxyResult; m_pOfficeClass->cancelProxyCalls = lo_cancelProxyCalls; m_pOfficeClass->isExpectedReentry = lo_isExpectedReentry; m_pOfficeClass->installClipboardProvider = lo_installClipboardProvider; m_pOfficeClass->getGlobalClipboard = lo_getGlobalClipboard; m_pOfficeClass->takeLegacyUnoApiUseFlag = lo_takeLegacyUnoApiUseFlag; gOfficeClass = m_pOfficeClass; } pClass = m_pOfficeClass.get(); } LibCO_Impl::~LibCO_Impl() { } namespace { void setLanguageAndLocale(OUString const & aLangISO) { SvtSysLocaleOptions aLocalOptions; aLocalOptions.SetLocaleConfigString(aLangISO); aLocalOptions.SetUILocaleConfigString(aLangISO); aLocalOptions.Commit(); LanguageTag aTag(aLangISO); MsLangId::setConfiguredSystemUILanguage(aTag.getLanguageType(false)); LanguageTag::setConfiguredSystemLanguage(aTag.getLanguageType(false)); } void setFormatSpecificFilterData(std::u16string_view sFormat, comphelper::SequenceAsHashMap & rFilterDataMap) { if (sFormat == u"pdf") { // always export bookmarks, which is needed for annotations rFilterDataMap[u"ExportBookmarks"_ustr] <<= true; } } } // anonymous namespace static COKitDocument* lo_documentLoad(COKit* pThis, const char* pURL) { return lo_documentLoadWithOptions(pThis, pURL, nullptr); } static COKitDocument* lo_documentLoadWithOptions(COKit* pThis, const char* pURL, const char* pOptions) { comphelper::ProfileZone aZone("lo_documentLoadWithOptions"); SolarMutexGuard aGuard; static int nDocumentIdCounter = 0; LibCO_Impl* pLib = static_cast(pThis); pLib->maLastExceptionMsg.clear(); const OUString aURL(getAbsoluteURL(pURL)); if (aURL.isEmpty()) { pLib->maLastExceptionMsg = u"Filename to load was not provided."_ustr; SAL_INFO("kit", "URL for load is empty"); return nullptr; } pLib->maLastExceptionMsg.clear(); if (!xContext.is()) { pLib->maLastExceptionMsg = u"ComponentContext is not available"_ustr; SAL_INFO("kit", "ComponentContext is not available"); return nullptr; } uno::Reference xComponentLoader = frame::Desktop::create(xContext); if (!xComponentLoader.is()) { pLib->maLastExceptionMsg = u"ComponentLoader is not available"_ustr; SAL_INFO("kit", "ComponentLoader is not available"); return nullptr; } try { // 'Language=...' is an option that COKit 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"); if (!aLanguage.isEmpty() && LanguageTag::isValidBcp47(aLanguage, nullptr)) { KitHelper::setDefaultLanguage(aLanguage); // Set the COKit language tag, used for dialog tunneling. comphelper::COKit::setLanguageTag(LanguageTag(aLanguage)); comphelper::COKit::setLocale(LanguageTag(aLanguage)); comphelper::COKit::setLoadLanguageTag(LanguageTag(aLanguage)); SAL_INFO("kit", "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()) { KitHelper::setDefaultTimezone(true, aTimezone); } else { // Default to the TZ envar, if set. const char* tz = ::getenv("TZ"); if (tz) { KitHelper::setDefaultTimezone(true, OStringToOUString(tz, RTL_TEXTENCODING_UTF8)); } else { KitHelper::setDefaultTimezone(false, OUString()); } } const OUString aDeviceFormFactor = extractParameter(aOptions, u"DeviceFormFactor"); KitHelper::setDeviceFormFactor(aDeviceFormFactor); const OUString aBatch = extractParameter(aOptions, u"Batch"); if (!aBatch.isEmpty()) { Application::SetDialogCancelMode(DialogCancelMode::KitSilent); } rtl::Reference const pInteraction( new KitInteractionHandler("load"_ostr, pLib)); // Take over the interaction handler entry for this URL. A successful // load keeps its entry past the load (the scope guard is dismissed // below) so a view-to-edit reload can still get the password. Once that // document is gone the entry is stale, so a fresh load of the same URL // overwrites it instead of tripping over the leftover. const OString aInteractionKey(aURL.toUtf8()); pLib->mInteractionMap[aInteractionKey] = pInteraction; comphelper::ScopeGuard g( [&]() { // The load failed: drop our handler, unless a later load of the // same URL has already replaced it with its own. auto const it = pLib->mInteractionMap.find(aInteractionKey); if (it != pLib->mInteractionMap.end() && it->second == pInteraction) pLib->mInteractionMap.erase(it); }); 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); OUString aClientVisibleArea = extractParameter(aOptions, u"ClientVisibleArea"); if (!aClientVisibleArea.isEmpty()) { std::vector aTokens = comphelper::string::split(aClientVisibleArea, ';'); if (aTokens.size() >= 4) { awt::Rectangle aRectangle; aRectangle.X = aTokens[0].toInt32(); aRectangle.Y = aTokens[1].toInt32(); aRectangle.Width = aTokens[2].toInt32(); aRectangle.Height = aTokens[3].toInt32(); comphelper::COKit::setInitialClientVisibleArea(aRectangle); } } // The embedder may load a working copy under a different URL than the file // the user opened (the macOS app loads from a temp dir). When it tells us // the original URL, remember it against this working URL so the Properties // dialog can show and reveal the real location. The value was percent-escaped // for the comma-separated options string, so decode it back. OUString aOriginalDocumentUrlKey; OUString aOriginalDocumentUrl = extractParameter(aOptions, u"OriginalDocumentUrl"); if (!aOriginalDocumentUrl.isEmpty()) { aOriginalDocumentUrl = rtl::Uri::decode(aOriginalDocumentUrl, rtl_UriDecodeWithCharset, RTL_TEXTENCODING_UTF8); // Key by the canonical main URL, matching how the Properties dialog // looks it up (INetURLObject::GetMainURL with no decoding). Remember // the key so doc_destroy can clear the mapping without dereferencing // the (possibly already disposed) model. aOriginalDocumentUrlKey = INetURLObject(aURL).GetMainURL(INetURLObject::DecodeMechanism::NONE); comphelper::COKit::setOriginalDocumentUrl(aOriginalDocumentUrlKey, aOriginalDocumentUrl); } #if defined(ANDROID) && HAVE_FEATURE_ANDROID_KIT sal_Int16 nMacroExecMode = document::MacroExecMode::USE_CONFIG; #else const OUString aEnableMacrosExecution = extractParameter(aOptions, u"EnableMacrosExecution"); sal_Int16 nMacroExecMode; if (aEnableMacrosExecution == "true") { nMacroExecMode = document::MacroExecMode::USE_CONFIG; } else { nMacroExecMode = document::MacroExecMode::NEVER_EXECUTE; // also set the global flag so IsMacroDisabled() returns true, // blocking share-location scripts that bypass the per-document // MacroExecutionMode check. Affects this per-document process instance, // may require re-visiting when/if CODA gets macro support. std::shared_ptr xChanges = comphelper::ConfigurationChanges::create(); officecfg::Office::Common::Security::Scripting::DisableMacrosExecution::set( true, xChanges); xChanges->commit(); } #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 COKit case cpo::uno::Sequence aFilterOptions{ comphelper::makePropertyValue(u"FilterOptions"_ustr, aOptions), comphelper::makePropertyValue(u"InteractionHandler"_ustr, uno::Reference(pInteraction)), comphelper::makePropertyValue(u"MacroExecutionMode"_ustr, nMacroExecMode), comphelper::makePropertyValue(u"AsTemplate"_ustr, false), comphelper::makePropertyValue(u"Silent"_ustr, !aBatch.isEmpty()) }; /* TODO sal_Int16 nUpdateDoc = document::UpdateDocMode::ACCORDING_TO_CONFIG; aFilterOptions[3].Name = "UpdateDocMode"; aFilterOptions[3].Value <<= nUpdateDoc; */ OutputDevice::StartTrackingFontMappingUse(); if (const char* pExemptVerifyHost = ::getenv("KIT_EXEMPT_VERIFY_HOST")) HostFilter::setExemptVerifyHost(OUString(pExemptVerifyHost, strlen(pExemptVerifyHost), RTL_TEXTENCODING_UTF8)); const int nThisDocumentId = nDocumentIdCounter++; comphelper::COKit::setDocId(ViewShellDocId(nThisDocumentId)); uno::Reference xComponent = xComponentLoader->loadComponentFromURL( aURL, u"_blank"_ustr, 0, aFilterOptions); if (!xComponent.is()) { pLib->maLastExceptionMsg = u"loadComponentFromURL returned an empty reference"_ustr; SAL_INFO("kit", "Document can't be loaded - " << pLib->maLastExceptionMsg); return nullptr; } assert(comphelper::COKit::getDocId() == ViewShellDocId(nThisDocumentId) && "incorrect docid set on document"); LibLODocument_Impl* pDocument = new LibLODocument_Impl(xComponent, nThisDocumentId); pDocument->maOriginalDocumentUrlKey = aOriginalDocumentUrlKey; // After loading the document, its initial view is the "current" view. if (pLib->mpCallback) { int nState = doc_getSignatureState(pDocument); pLib->mpCallback(COKitCallbackType::SIGNATURE_STATUS, OString::number(nState).getStr(), pLib->mpCallbackData); } auto aFontMappingUseData = OutputDevice::FinishTrackingFontMappingUse(); if (aFontMappingUseData.size() > 0) { SAL_INFO("kit.fontsubst", "================ Original substitutions:"); for (const auto &i : aFontMappingUseData) { SAL_INFO("kit.fontsubst", i.mOriginalFont); for (const auto &j : i.mUsedFonts) SAL_INFO("kit.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. std::erase_if (aFontMappingUseData, [](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; }); // 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. std::erase_if (aFontMappingUseData, [](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; }); if (aFontMappingUseData.size() > 0) { SAL_INFO("kit.fontsubst", "================ Pruned substitutions:"); for (const auto &i : aFontMappingUseData) { SAL_INFO("kit.fontsubst", i.mOriginalFont); for (const auto &j : i.mUsedFonts) SAL_INFO("kit.fontsubst", " " << j); } } for (std::size_t i = 0; i < aFontMappingUseData.size(); ++i) { pDocument->maFontsMissing.insert(aFontMappingUseData[i].mOriginalFont); } SAL_INFO("kit", "lo_documentLoadWithOptions: finished @ " << osl_getGlobalTimer()); // Load succeeded: keep the interaction handler in mInteractionMap so a // later reload (view to edit) can still deliver the password. g.dismiss(); return pDocument; } catch (const uno::Exception& exception) { pLib->maLastExceptionMsg = exception.Message; TOOLS_INFO_EXCEPTION("kit", "Document can't be loaded"); } return nullptr; } static int lo_runMacro(COKit* pThis, const char *pURL) { comphelper::ProfileZone aZone("lo_runMacro"); SolarMutexGuard aGuard; LibCO_Impl* pLib = static_cast(pThis); pLib->maLastExceptionMsg.clear(); OUString sURL( pURL, strlen(pURL), RTL_TEXTENCODING_UTF8 ); if (sURL.isEmpty()) { pLib->maLastExceptionMsg = u"Macro to run was not provided."_ustr; SAL_INFO("kit", "Macro URL is empty"); return false; } if (!sURL.startsWith("macro://")) { pLib->maLastExceptionMsg = u"This doesn't look like macro URL"_ustr; SAL_INFO("kit", "Macro URL is invalid"); return false; } pLib->maLastExceptionMsg.clear(); if (!xContext.is()) { pLib->maLastExceptionMsg = u"ComponentContext is not available"_ustr; SAL_INFO("kit", "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 = u"ComponentLoader is not available"_ustr; SAL_INFO("kit", "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(u"com.sun.star.comp.sfx2.SfxMacroLoader"_ustr), uno::UNO_QUERY ); uno::Reference xD = xDP->queryDispatch( aURL, OUString(), 0); if (!xD.is()) { pLib->maLastExceptionMsg = u"Macro loader is not available"_ustr; SAL_INFO("kit", "Macro loader is not available"); return false; } uno::Reference < frame::XSynchronousDispatch > xSyncDisp( xD, uno::UNO_QUERY_THROW ); cpo::uno::Sequence aEmpty; css::beans::PropertyValue aErr; cpo::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("kit", "Macro execution terminated with error code " << nErrCode); return false; } return true; } static bool lo_signDocument(COKit* /*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; std::string_view aCertificateString(reinterpret_cast(pCertificateBinary), nCertificateBinarySize); std::string_view aPrivateKeyString(reinterpret_cast(pPrivateKeyBinary), nPrivateKeyBinarySize); uno::Reference xCertificate = KitHelper::getSigningCertificate(aCertificateString, aPrivateKeyString); if (!xCertificate.is()) return false; sfx2::DocumentSigner aDocumentSigner(aURL); if (!aDocumentSigner.signDocument(xCertificate)) return false; return true; } static char* lo_extractRequest(COKit* /*pThis*/, const char* pFilePath) { uno::Reference xComponentLoader = frame::Desktop::create(xContext); uno::Reference< css::lang::XComponent > xComp; OUString aURL(getAbsoluteURL(pFilePath)); if (!aURL.isEmpty()) { if (xComponentLoader.is()) { try { cpo::uno::Sequence aFilterOptions(comphelper::InitPropertySequence( { {u"Hidden"_ustr, cpo::uno::Any(true)}, {u"ReadOnly"_ustr, cpo::uno::Any(true)} })); xComp = xComponentLoader->loadComponentFromURL( aURL, u"_blank"_ustr, 0, aFilterOptions ); } catch ( const lang::IllegalArgumentException& ex ) { SAL_WARN("kit", "lo_extractRequest: IllegalArgumentException: " << ex.Message); } catch (...) { SAL_WARN("kit", "lo_extractRequest: Exception on loadComponentFromURL, url= " << aURL); } if (xComp.is()) { uno::Reference< document::XLinkTargetSupplier > xLTS( xComp, uno::UNO_QUERY ); if( xLTS.is() ) { tools::JsonWriter aJson; { auto aNode = aJson.startNode("Targets"); extractLinks(xLTS->getLinks(), false, aJson); } return convertOString(aJson.finishAndGetAsOString()); } xComp->dispose(); } } } return strdup("{ }"); } static char* lo_extractDocumentStructureRequest(COKit* /*pThis*/, const char* pFilePath, const char* pFilter) { SolarMutexGuard aGuard; uno::Reference xComponentLoader = frame::Desktop::create(xContext); uno::Reference< css::lang::XComponent > xComp; OUString aURL(getAbsoluteURL(pFilePath)); if (!aURL.isEmpty()) { if (xComponentLoader.is()) { try { cpo::uno::Sequence aFilterOptions(comphelper::InitPropertySequence( { {u"Hidden"_ustr, cpo::uno::Any(true)}, {u"ReadOnly"_ustr, cpo::uno::Any(true)} })); xComp = xComponentLoader->loadComponentFromURL( aURL, u"_blank"_ustr, 0, aFilterOptions ); } catch ( const lang::IllegalArgumentException& ex ) { SAL_WARN("kit", "lo_extractDocumentStructureRequest: IllegalArgumentException: " << ex.Message); } catch (...) { SAL_WARN("kit", "lo_extractDocumentStructureRequest: Exception on loadComponentFromURL, url= " << aURL); } if (xComp.is()) { ITiledRenderable* pDoc = dynamic_cast(xComp.get()); if (!pDoc) return nullptr; auto pBaseModel = dynamic_cast(xComp.get()); if (!pBaseModel) return nullptr; SfxObjectShell* pObjectShell = pBaseModel->GetObjectShell(); if (!pObjectShell) return nullptr; //if it is a writer document.. uno::Reference xDocument(xComp, uno::UNO_QUERY_THROW); if (xDocument->supportsService(u"com.sun.star.text.TextDocument"_ustr) || xDocument->supportsService(u"com.sun.star.text.WebDocument"_ustr) || xDocument->supportsService(u"com.sun.star.presentation.PresentationDocument"_ustr)) { tools::JsonWriter aJson; { OString aCommand = ".uno:ExtractDocumentStructure"_ostr; if (pFilter && pFilter[0]) { aCommand = OString::Concat(aCommand) + "?filter="_ostr + pFilter; } pDoc->getCommandValues(aJson, aCommand); } return convertOString(aJson.finishAndGetAsOString()); } xComp->dispose(); } } } return strdup("{ }"); } namespace { enum class JoinThreads { ALL, RESTARTS_ON_DEMAND }; } static int joinThreads(JoinThreads eCategory); static void flushBufferedVOCs() { SolarMutexGuard aGuard; // Flush all buffered VOC primitives from the pages. SfxViewShell* pViewShell = SfxViewShell::Current(); if (!pViewShell) return; const SdrView* pView = pViewShell->GetDrawView(); if (!pView) return; SdrPageView* pPageView = pView->GetSdrPageView(); if (!pPageView) return; SdrPage* pCurPage = pPageView->GetPage(); if (!pCurPage) return; SdrModel& sdrModel = pCurPage->getSdrModelFromSdrPage(); for (sal_uInt16 i = 0; i < sdrModel.GetPageCount(); ++i) { SdrPage* pPage = sdrModel.GetPage(i); if (pPage) pPage->GetViewContact().flushViewObjectContacts(); } } static void lo_trimMemory(COKit* /* pThis */, int nTarget) { vcl::kit::trimMemory(nTarget); if (nTarget > 2000) { flushBufferedVOCs(); // When more aggressively reclaiming memory then shutdown threads which // will restart on demand. // The SolarMutex should not be held when calling joinThreads to avoid // deadlock. joinThreads(JoinThreads::RESTARTS_ON_DEMAND); } if (nTarget > 1000) { #ifdef HAVE_MALLOC_TRIM malloc_trim(0); #endif } } namespace { class FunctionBasedURPInstanceProvider : public ::cppu::WeakImplHelper { private: css::uno::Reference m_rContext; public: FunctionBasedURPInstanceProvider( const css::uno::Reference& rxContext); // XInstanceProvider virtual css::uno::Reference getInstance(const OUString& aName) override; }; // InstanceProvider FunctionBasedURPInstanceProvider::FunctionBasedURPInstanceProvider( const Reference& rxContext) : m_rContext(rxContext) { } Reference FunctionBasedURPInstanceProvider::getInstance(const OUString& aName) { Reference rInstance; if (aName == "StarOffice.ServiceManager") { rInstance.set(m_rContext->getServiceManager()); } else if (aName == "StarOffice.ComponentContext") { rInstance = m_rContext; } else if (aName == "StarOffice.NamingService") { Reference rNamingService( m_rContext->getServiceManager()->createInstanceWithContext( u"cpo.uno.NamingService"_ustr, m_rContext), UNO_QUERY); if (rNamingService.is()) { rNamingService->registerObject(u"StarOffice.ServiceManager"_ustr, m_rContext->getServiceManager()); rNamingService->registerObject(u"StarOffice.ComponentContext"_ustr, m_rContext); rInstance = rNamingService; } } return rInstance; } class FunctionBasedURPConnection : public cppu::WeakImplHelper { public: explicit FunctionBasedURPConnection(void*, int (*)(void* pContext, const signed char* pBuffer, int nLen), void*, int (*)(void* pContext, signed char* pBuffer, int nLen)); ~FunctionBasedURPConnection(); // These overridden member functions use "read" and "write" from the point of view of LO, // i.e. the opposite to how startURP() uses them. virtual sal_Int32 read(Sequence& rReadBytes, sal_Int32 nBytesToRead) override; virtual void write(const Sequence& aData) override; virtual void flush() override; virtual void close() override; virtual OUString getDescription() override; void setBridge(const Reference&); void* getContext(); inline static int g_connectionCount = 0; private: void* m_pRecieveFromLOContext; void* m_pSendURPToLOContext; int (*m_fnReceiveURPFromLO)(void* pContext, const signed char* pBuffer, int nLen); int (*m_fnSendURPToLO)(void* pContext, signed char* pBuffer, int nLen); Reference m_URPBridge; }; FunctionBasedURPConnection::FunctionBasedURPConnection( void* pRecieveFromLOContext, int (*fnReceiveURPFromLO)(void* pContext, const signed char* pBuffer, int nLen), void* pSendURPToLOContext, int (*fnSendURPToLO)(void* pContext, signed char* pBuffer, int nLen)) : m_pRecieveFromLOContext(pRecieveFromLOContext) , m_pSendURPToLOContext(pSendURPToLOContext) , m_fnReceiveURPFromLO(fnReceiveURPFromLO) , m_fnSendURPToLO(fnSendURPToLO) { g_connectionCount++; } FunctionBasedURPConnection::~FunctionBasedURPConnection() { Reference xComp(m_URPBridge, UNO_QUERY_THROW); xComp->dispose(); // TODO: check this doesn't deadlock } void* FunctionBasedURPConnection::getContext() { return this; } sal_Int32 FunctionBasedURPConnection::read(Sequence& rReadBytes, sal_Int32 nBytesToRead) { if (nBytesToRead < 0) return 0; if (rReadBytes.getLength() != nBytesToRead) rReadBytes.realloc(nBytesToRead); // As with osl::StreamPipe, we must always read nBytesToRead... return m_fnSendURPToLO(m_pSendURPToLOContext, rReadBytes.getArray(), nBytesToRead); } void FunctionBasedURPConnection::write(const Sequence& rData) { m_fnReceiveURPFromLO(m_pRecieveFromLOContext, rData.getConstArray(), rData.getLength()); } void FunctionBasedURPConnection::flush() {} void FunctionBasedURPConnection::close() { SAL_INFO("kit.urp", "Requested to close FunctionBasedURPConnection"); } OUString FunctionBasedURPConnection::getDescription() { return u""_ustr; } void FunctionBasedURPConnection::setBridge(const Reference& xBridge) { m_URPBridge = xBridge; } } static void* lo_startURP(COKit* /* pThis */, void* pRecieveFromLOContext, void* pSendToLOContext, int (*fnReceiveURPFromLO)(void* pContext, const signed char* pBuffer, int nLen), int (*fnSendURPToLO)(void* pContext, signed char* pBuffer, int nLen)) { // Here we will roughly do what desktop LO does when one passes a command-line switch like // --accept=socket,port=nnnn;urp;StarOffice.ServiceManager. Except that no listening socket will // be created. The communication to the URP will be through the nReceiveURPFromLO and nSendURPToLO // functions. rtl::Reference connection( new FunctionBasedURPConnection(pRecieveFromLOContext, fnReceiveURPFromLO, pSendToLOContext, fnSendURPToLO)); Reference xBridgeFactory = css::bridge::BridgeFactory::create(xContext); Reference xInstanceProvider(new FunctionBasedURPInstanceProvider(xContext)); Reference xBridge(xBridgeFactory->createBridge( "functionurp" + OUString::number(FunctionBasedURPConnection::g_connectionCount), u"kit.urp"_ustr, connection, xInstanceProvider)); connection->setBridge(std::move(xBridge)); return connection->getContext(); } /** * Stop a function based URP connection that you started with lo_startURP above * * @param pSendToLOContext a pointer to the context returned by lo_startURP */ static void lo_stopURP(COKit* /* pThis */, void* pFunctionBasedURPConnection/* FunctionBasedURPConnection* */) { static_cast(pFunctionBasedURPConnection)->close(); } static int joinThreads(JoinThreads eCategory) { DBG_TESTNOTSOLARMUTEX(); comphelper::ThreadPool &pool = comphelper::ThreadPool::getSharedOptimalPool(); if (!pool.joinThreadsIfIdle()) return 0; // Grammar checker thread css::uno::Reference xLangSrv = css::linguistic2::LinguServiceManager::create(xContext); auto joinable = dynamic_cast(xLangSrv.get()); if (joinable && !joinable->joinThreads()) return 0; if (eCategory == JoinThreads::ALL) { auto ucpWebdav = xContext->getServiceManager()->createInstanceWithContext( u"com.sun.star.ucb.WebDAVManager"_ustr, xContext); joinable = dynamic_cast(ucpWebdav.get()); if (joinable && !joinable->joinThreads()) return 0; auto progressThread = xContext->getServiceManager()->createInstanceWithContext( u"com.sun.star.task.StatusIndicatorFactory"_ustr, xContext); joinable = dynamic_cast(progressThread.get()); if (joinable && !joinable->joinThreads()) return 0; } // Ensure configmgr's write thread is down css::uno::Reference< css::util::XFlushable >( css::configuration::theDefaultProvider::get( comphelper::getProcessComponentContext()), css::uno::UNO_QUERY_THROW)->flush(); drawinglayer::primitive2d::BufferedDecompositionFlusher::shutdown(); if (eCategory == JoinThreads::ALL) salhelper::Timer::joinThread(); return 1; } static int lo_joinThreads(COKit* /* pThis */) { return joinThreads(JoinThreads::ALL); } static void lo_startThreads(COKit* /* pThis */) { salhelper::Timer::startThread(); auto ucpWebdav = xContext->getServiceManager()->createInstanceWithContext( u"com.sun.star.ucb.WebDAVManager"_ustr, xContext); auto joinable = dynamic_cast(ucpWebdav.get()); if (joinable) joinable->startThreads(); auto progressThread = xContext->getServiceManager()->createInstanceWithContext( u"com.sun.star.task.StatusIndicatorFactory"_ustr, xContext); joinable = dynamic_cast(progressThread.get()); if (joinable) joinable->startThreads(); } static void lo_setForkedChild(COKit* /* pThis */, bool bIsChild) { comphelper::COKit::setForkedChild(bIsChild); if (bIsChild) Application::UpdateMainThread(); } static void lo_registerCallback (COKit* pThis, COKitCallback pCallback, void* pData) { SolarMutexGuard aGuard; Application* pApp = GetpApp(); assert(pApp); LibCO_Impl* pLib = static_cast(pThis); pLib->maLastExceptionMsg.clear(); pApp->m_pCallback = pLib->mpCallback = pCallback; pApp->m_pCallbackData = pLib->mpCallbackData = pData; } static SfxObjectShell* getSfxObjectShell(COKitDocument* pThis) { LibLODocument_Impl* pDocument = static_cast(pThis); if (!pDocument) return nullptr; SfxBaseModel* pBaseModel = dynamic_cast(pDocument->mxComponent.get()); if (!pBaseModel) return nullptr; return pBaseModel->GetObjectShell(); } static int doc_saveAs(COKitDocument* 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(u"Filename to save to was not provided."_ustr); SAL_INFO("kit", "URL for save is empty"); return false; } try { std::span pMap; switch (doc_getDocumentType(pThis)) { case COKitDocumentType::SPREADSHEET: pMap = aCalcExtensionMap; break; case COKitDocumentType::PRESENTATION: pMap = aImpressExtensionMap; break; case COKitDocumentType::DRAWING: pMap = aDrawExtensionMap; break; case COKitDocumentType::TEXT: pMap = aWriterExtensionMap; break; case COKitDocumentType::OTHER: default: SAL_INFO("kit", "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 (const auto& item : pMap) { if (sFormat.equalsIgnoreAsciiCaseAscii(item.extn)) { aFilterName = item.filterName; break; } } if (aFilterName.isEmpty()) { SetLastExceptionMsg(u"no output filter found for provided suffix"_ustr); 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"; OUString filePassword; if ((aIndex = aFilterOptions.indexOf(",Password=")) >= 0) { int bIndex = aFilterOptions.indexOf("PASSWORDEND"); filePassword = aFilterOptions.subView(aIndex + 10, bIndex - (aIndex + 10)); aFilterOptions = OUString::Concat(aFilterOptions.subView(0, aIndex)) + aFilterOptions.subView(bIndex + 11); } OUString filePasswordToModify; if ((aIndex = aFilterOptions.indexOf(",PasswordToModify=")) >= 0) { int bIndex = aFilterOptions.indexOf("PASSWORDTOMODIFYEND"); filePassword = aFilterOptions.subView(aIndex + 18, bIndex - (aIndex + 18)); aFilterOptions = OUString::Concat(aFilterOptions.subView(0, aIndex)) + aFilterOptions.subView(bIndex + 19); } // 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/A-4")) pdfVer = 4; else if (o3tl::equalsIgnoreAsciiCase(sPdfVer, u"PDF-1.5")) pdfVer = 15; else if (o3tl::equalsIgnoreAsciiCase(sPdfVer, u"PDF-1.6")) pdfVer = 16; else if (o3tl::equalsIgnoreAsciiCase(sPdfVer, u"PDF-1.7")) pdfVer = 17; else if (o3tl::equalsIgnoreAsciiCase(sPdfVer, u"PDF-2.0")) pdfVer = 20; else { SetLastExceptionMsg(u"wrong PDF version"_ustr); 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. // Preserve CSV filter options structure: don't drop empty tokens or add spaces. // Just scan for and remove special non-filter keywords. // (Using convertCommaSeparated() would drop empty tokens and add spaces, // which breaks CSV filter options where token position matters.) bool bTakeOwnership = false; bool bCreateFromTemplate = false; comphelper::SequenceAsHashMap aSaveMediaDescriptor; if (!aFilterOptions.startsWith("{")) { // Token-based filter options: scan for and remove special keywords. // JSON options pass through unchanged — no keywords expected, and // splitting on commas would needlessly mangle the JSON string. OUStringBuffer aFilteredBuf; sal_Int32 nIndex = 0; bool bFirst = true; do { const OUString aToken(o3tl::getToken(aFilterOptions, 0, ',', nIndex)); const OUString aTrimmed = aToken.trim(); if (aTrimmed == "TakeOwnership") bTakeOwnership = true; else if (aTrimmed == "NoFileSync") aSaveMediaDescriptor[u"NoFileSync"_ustr] <<= true; else if (aTrimmed == "FromTemplate") bCreateFromTemplate = true; else { if (!bFirst) aFilteredBuf.append(u','); aFilteredBuf.append(aToken); bFirst = false; } } while (nIndex >= 0); aFilterOptions = aFilteredBuf.makeStringAndClear(); } if (bCreateFromTemplate && bTakeOwnership) { if (SfxObjectShell* pObjectShell = getSfxObjectShell(pThis)) { DateTime now( ::DateTime::SYSTEM ); pObjectShell->getDocProperties()->setCreationDate(now.GetUNODateTime()); } } aSaveMediaDescriptor[u"Overwrite"_ustr] <<= true; aSaveMediaDescriptor[u"FilterName"_ustr] <<= aFilterName; 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[u"TiledWatermark"_ustr] <<= watermarkText; if (bFullSheetPreview) aFilterDataMap[u"SinglePageSheets"_ustr] <<= true; if (pdfVer) aFilterDataMap[u"SelectPdfVersion"_ustr] <<= pdfVer; if (!aFilterDataMap.empty()) { aSaveMediaDescriptor[u"FilterData"_ustr] <<= aFilterDataMap.getAsConstPropertyValueList(); } if (!filePassword.isEmpty()) aSaveMediaDescriptor[u"Password"_ustr] <<= filePassword; if (!filePasswordToModify.isEmpty()) aSaveMediaDescriptor[u"PasswordToModify"_ustr] <<= filePasswordToModify; // add interaction handler too if (gImpl) { // gImpl does not have to exist when running from a unit test rtl::Reference const pInteraction( new KitInteractionHandler("saveas"_ostr, gImpl, pDocument)); aSaveMediaDescriptor[MediaDescriptor::PROP_INTERACTIONHANDLER] <<= uno::Reference(pInteraction); } 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 COKit 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 COKit clients out of the box. */ static void doc_iniUnoCommands () { SolarMutexGuard aGuard; SetLastExceptionMsg(); util::URL aCommandURL; SfxViewShell* pViewShell = SfxViewShell::Current(); SfxViewFrame* pViewFrame = pViewShell ? &pViewShell->GetViewFrame() : nullptr; // check if Frame-Controller were created. if (!pViewFrame) { SAL_WARN("kit", "iniUnoCommands: No Frame-Controller created."); return; } if (!xContext.is()) xContext = comphelper::getProcessComponentContext(); if (!xContext.is()) { SAL_WARN("kit", "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("kit", "iniUnoCommands: XSEInitializer is not available"); return; } uno::Reference xSecurityContext = xSEInitializer->createSecurityContext(OUString()); if (!xSecurityContext.is()) { SAL_WARN("kit", "iniUnoCommands: failed to create security context"); } #endif SfxSlotPool& rSlotPool = SfxSlotPool::GetSlotPool(pViewFrame); uno::Reference xParser(util::URLTransformer::create(xContext)); const std::map& rUnoCommandList = GetKitUnoCommandList(); for (const auto& aUnoCommand : rUnoCommandList) { if (aUnoCommand.second.initializeForStatusUpdates) { aCommandURL.Complete = u".uno:"_ustr + aUnoCommand.first; 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 COKitDocumentType doc_getDocumentType (COKitDocument* pThis) { comphelper::ProfileZone aZone("doc_getDocumentType"); SolarMutexGuard aGuard; return getDocumentType(pThis); } static int doc_getParts (COKitDocument* pThis) { comphelper::ProfileZone aZone("doc_getParts"); SolarMutexGuard aGuard; ITiledRenderable* pDoc = getTiledRenderable(pThis); if (!pDoc) { SetLastExceptionMsg(u"Document doesn't support tiled rendering"_ustr); return 0; } return pDoc->getParts(); } static int doc_getPart (COKitDocument* pThis) { comphelper::ProfileZone aZone("doc_getPart"); SolarMutexGuard aGuard; SetLastExceptionMsg(); ITiledRenderable* pDoc = getTiledRenderable(pThis); if (!pDoc) { SetLastExceptionMsg(u"Document doesn't support tiled rendering"_ustr); return 0; } const int nIndex = pDoc->getPart(); // The boundary names parts of a presentation or drawing document by their stable page // unique ids. An id too wide for a part number leaves the index in place. if (partsAreUniqueIds(pDoc)) { const int nPart = partNumberFromIndex(pDoc, nIndex, pDoc->getEditMode()); if (nPart >= 0) return nPart; } return nIndex; } static void doc_setPartIndexImpl(COKitDocument* pThis, int nPartIndex, bool bAllowChangeFocus = true) { comphelper::ProfileZone aZone("doc_setPart"); SolarMutexGuard aGuard; SetLastExceptionMsg(); ITiledRenderable* pDoc = getTiledRenderable(pThis); if (!pDoc) { SetLastExceptionMsg(u"Document doesn't support tiled rendering"_ustr); return; } pDoc->setPart( nPartIndex, bAllowChangeFocus ); } static void doc_setPartImpl(COKitDocument* pThis, int nPart, bool bAllowChangeFocus = true) { SolarMutexGuard aGuard; ITiledRenderable* pDoc = getTiledRenderable(pThis); if (!pDoc) { SetLastExceptionMsg(u"Document doesn't support tiled rendering"_ustr); return; } // The boundary names parts of a presentation or drawing document by their stable page // unique ids. The part number of a page that is gone selects nothing. if (partsAreUniqueIds(pDoc)) { const int nIndex = partIndexFromNumber(pDoc, nPart, pDoc->getEditMode()); if (nIndex < 0) { SAL_INFO("kit", "setPart names the gone part " << nPart); return; } nPart = nIndex; } doc_setPartIndexImpl(pThis, nPart, bAllowChangeFocus); } static void doc_setPart(COKitDocument* pThis, int nPart) { doc_setPartImpl(pThis, nPart, true); } static char* doc_getPartInfo(COKitDocument* pThis, int nPart) { comphelper::ProfileZone aZone("doc_getPartInfo"); SolarMutexGuard aGuard; ITiledRenderable* pDoc = getTiledRenderable(pThis); if (!pDoc) { SetLastExceptionMsg(u"Document doesn't support tiled rendering"_ustr); return nullptr; } return convertOUString(pDoc->getPartInfo(nPart)); } static unsigned long long doc_getPartUniqueId(COKitDocument* pThis, int nPart, int nMode) { comphelper::ProfileZone aZone("doc_getPartUniqueId"); SolarMutexGuard aGuard; ITiledRenderable* pDoc = getTiledRenderable(pThis); if (!pDoc) { SetLastExceptionMsg(u"Document doesn't support tiled rendering"_ustr); return 0; } return pDoc->getPartUniqueId(nPart, nMode); } static int doc_getPartIndex(COKitDocument* pThis, int nPart, int nMode) { comphelper::ProfileZone aZone("doc_getPartIndex"); SolarMutexGuard aGuard; ITiledRenderable* pDoc = getTiledRenderable(pThis); if (!pDoc) { SetLastExceptionMsg(u"Document doesn't support tiled rendering"_ustr); return -1; } // A document whose part numbers are page-list indexes needs no lookup. if (!partsAreUniqueIds(pDoc)) return nPart; return partIndexFromNumber(pDoc, nPart, nMode); } static void doc_selectPart(COKitDocument* pThis, int nPart, int nSelect) { SolarMutexGuard aGuard; SetLastExceptionMsg(); ITiledRenderable* pDoc = getTiledRenderable(pThis); if (!pDoc) { SetLastExceptionMsg(u"Document doesn't support tiled rendering"_ustr); return; } // The boundary names parts of a presentation or drawing document by their stable page // unique ids. The part number of a page that is gone selects nothing. if (partsAreUniqueIds(pDoc)) { const int nIndex = partIndexFromNumber(pDoc, nPart, pDoc->getEditMode()); if (nIndex < 0) { SAL_INFO("kit", "selectPart names the gone part " << nPart); return; } nPart = nIndex; } pDoc->selectPart( nPart, nSelect ); } static void doc_moveSelectedParts(COKitDocument* pThis, int nPosition, bool bDuplicate, int nIntoSection) { SolarMutexGuard aGuard; SetLastExceptionMsg(); ITiledRenderable* pDoc = getTiledRenderable(pThis); if (!pDoc) { SetLastExceptionMsg(u"Document doesn't support tiled rendering"_ustr); return; } pDoc->moveSelectedParts(nPosition, bDuplicate, nIntoSection); } static char* doc_getPartPageRectangles(COKitDocument* pThis) { comphelper::ProfileZone aZone("doc_getPartPageRectangles"); SolarMutexGuard aGuard; SetLastExceptionMsg(); ITiledRenderable* pDoc = getTiledRenderable(pThis); if (!pDoc) { SetLastExceptionMsg(u"Document doesn't support tiled rendering"_ustr); return nullptr; } return convertOUString(pDoc->getPartPageRectangles()); } static char* doc_getA11yFocusedParagraph(COKitDocument* pThis) { SolarMutexGuard aGuard; SetLastExceptionMsg(); ITiledRenderable* pDoc = getTiledRenderable(pThis); if (!pDoc) { SetLastExceptionMsg(u"Document doesn't support tiled rendering"_ustr); return nullptr; } if (SfxViewShell* pViewShell = SfxViewShell::Current()) { return convertOUString(pViewShell->getA11yFocusedParagraph()); } return nullptr; } static int doc_getA11yCaretPosition(COKitDocument* pThis) { SolarMutexGuard aGuard; SetLastExceptionMsg(); ITiledRenderable* pDoc = getTiledRenderable(pThis); if (!pDoc) { SetLastExceptionMsg(u"Document doesn't support tiled rendering"_ustr); return -1; } if (SfxViewShell* pViewShell = SfxViewShell::Current()) { return pViewShell->getA11yCaretPosition(); } return -1; } static char* doc_getPartName(COKitDocument* pThis, int nPart) { comphelper::ProfileZone aZone("doc_getPartName"); SolarMutexGuard aGuard; SetLastExceptionMsg(); ITiledRenderable* pDoc = getTiledRenderable(pThis); if (!pDoc) { SetLastExceptionMsg(u"Document doesn't support tiled rendering"_ustr); return nullptr; } return convertOUString(pDoc->getPartName(nPart)); } static char* doc_getPartHash(COKitDocument* pThis, int nPart) { comphelper::ProfileZone aZone("doc_getPartHash"); SolarMutexGuard aGuard; SetLastExceptionMsg(); ITiledRenderable* pDoc = getTiledRenderable(pThis); if (!pDoc) { SetLastExceptionMsg(u"Document doesn't support tiled rendering"_ustr); return nullptr; } return convertOUString(pDoc->getPartHash(nPart)); } static void doc_setPartMode(COKitDocument* pThis, COKitPartMode ePartMode) { comphelper::ProfileZone aZone("doc_setPartMode"); SolarMutexGuard aGuard; SetLastExceptionMsg(); ITiledRenderable* pDoc = getTiledRenderable(pThis); if (!pDoc) { SetLastExceptionMsg(u"Document doesn't support tiled rendering"_ustr); return; } int nCurrentPart = pDoc->getPart(); pDoc->setPartMode(ePartMode); // 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? // TODO: Also now see ViewShellBase::setEditMode for a similar case if ( nCurrentPart < pDoc->getParts() ) { pDoc->setPart( nCurrentPart ); } else { pDoc->setPart( 0 ); } } static int doc_getEditMode(COKitDocument* pThis) { comphelper::ProfileZone aZone("doc_getEditMode"); SolarMutexGuard aGuard; SetLastExceptionMsg(); ITiledRenderable* pDoc = getTiledRenderable(pThis); if (!pDoc) { SetLastExceptionMsg(u"Document doesn't support tiled rendering"_ustr); return 0; } return pDoc->getEditMode(); } static void doc_paintTile(COKitDocument* 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( "kit.tiledrendering", "paintTile: painting [" << nTileWidth << "x" << nTileHeight << "]@(" << nTilePosX << ", " << nTilePosY << ") to [" << nCanvasWidth << "x" << nCanvasHeight << "]px" ); ITiledRenderable* pDoc = getTiledRenderable(pThis); if (!pDoc) { SetLastExceptionMsg(u"Document doesn't support tiled rendering"_ustr); return; } #if defined(UNX) || 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::COKit::setDPIScale(1.0); }); #if defined(IOS) double fDPIScale = 1.0; // Online uses COKitTileMode::RGBA by default so flip the normal flags // to kCGImageAlphaPremultipliedLast | kCGImageByteOrder32Big CGContextRef pCGContext = CGBitmapContextCreate(pBuffer, nCanvasWidth, nCanvasHeight, 8, nCanvasWidth * 4, CGColorSpaceCreateDeviceRGB(), kCGImageAlphaPremultipliedLast | kCGImageByteOrder32Big); CGContextTranslateCTM(pCGContext, 0, nCanvasHeight); CGContextScaleCTM(pCGContext, fDPIScale, -fDPIScale); SAL_INFO( "kit.tiledrendering", "doc_paintTile: painting [" << nTileWidth << "x" << nTileHeight << "]@(" << nTilePosX << ", " << nTilePosY << ") to [" << nCanvasWidth << "x" << nCanvasHeight << "]px" ); Size aCanvasSize(nCanvasWidth, nCanvasHeight); SystemGraphicsData aData; aData.rCGContext = reinterpret_cast(pCGContext); ScopedVclPtrInstance pDevice(aData, Size(1, 1), DeviceFormat::WITHOUT_ALPHA); pDevice->SetBackground(Wallpaper(COL_TRANSPARENT)); pDevice->SetOutputSizePixel(aCanvasSize); pDoc->paintTile(*pDevice, aCanvasSize.Width(), aCanvasSize.Height(), nTilePosX, nTilePosY, nTileWidth, nTileHeight); CGContextRelease(pCGContext); #else ScopedVclPtrInstance< VirtualDevice > pDevice(DeviceFormat::WITHOUT_ALPHA); // Set background to transparent by default. pDevice->SetBackground(Wallpaper(COL_TRANSPARENT)); pDevice->SetOutputSizePixelScaleOffsetAndKitBuffer( Size(nCanvasWidth, nCanvasHeight), 1.0, Point(), pBuffer); pDoc->paintTile(*pDevice, nCanvasWidth, nCanvasHeight, nTilePosX, nTilePosY, nTileWidth, nTileHeight); static bool bDebug = getenv("KIT_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); auto popIt = pDevice->ScopedPush(PushFlags::FILLCOLOR | PushFlags::LINECOLOR); pDevice->SetFillColor(COL_LIGHTRED); pDevice->SetLineColor(); pDevice->DrawRect(aRect); } #if defined(_WIN32) && !USE_HEADLESS_CODE // pBuffer was not used there pDevice->EnableMapMode(false); Bitmap aBmp(pDevice->GetBitmap({ 0, 0 }, { nCanvasWidth, nCanvasHeight })); vcl::bitmap::fillWithData(pBuffer, aBmp); #endif #endif #else (void) pBuffer; #endif // Inform all views with the same view render state about the paint, so they know if makes sense // to invalidate those areas later. LibLODocument_Impl* pDocument = static_cast(pThis); int nOrigViewId = doc_getView(pThis); int nPart = pDoc->getPart(); int nMode = pDoc->getEditMode(); tools::Rectangle aRectangle{Point(nTilePosX, nTilePosY), Size(nTileWidth, nTileHeight)}; pDocument->updateViewsForPaintedTile(nOrigViewId, nPart, nMode, aRectangle); } inline static ITiledRenderable* getDocumentPointer(COKitDocument* pThis) { ITiledRenderable* pDoc = getTiledRenderable(pThis); if (!pDoc) { SetLastExceptionMsg(u"Document doesn't support tiled rendering"_ustr); return nullptr; } return pDoc; } inline static void writeInfoLog(const int nPart, const int nMode, const int nTileWidth, const int nTileHeight, const int nTilePosX, const int nTilePosY, const int nCanvasWidth, const int nCanvasHeight) { SAL_INFO( "kit.tiledrendering", "paintPartTile: painting @ " << nPart << " : " << nMode << " [" << nTileWidth << "x" << nTileHeight << "]@(" << nTilePosX << ", " << nTilePosY << ") to [" << nCanvasWidth << "x" << nCanvasHeight << "]px" ); } inline static int getFirstViewIdAsFallback(COKitDocument* pThis) { // 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 -1; std::vector viewIds(viewCount); doc_getViewIds(pThis, viewIds.data(), viewCount); int result = viewIds[0]; doc_setView(pThis, result); SAL_WARN("kit.tiledrendering", "Why is this happening? A call to paint without setting a view?"); return result; } inline static void disableViewCallbacks(LibLODocument_Impl* pDocument, const int viewId) { const auto handlerIt = pDocument->mpCallbackFlushHandlers.find(viewId); if (handlerIt != pDocument->mpCallbackFlushHandlers.end()) handlerIt->second->disableCallbacks(); } inline static void enableViewCallbacks(LibLODocument_Impl* pDocument, const int viewId) { const auto handlerIt = pDocument->mpCallbackFlushHandlers.find(viewId); if (handlerIt != pDocument->mpCallbackFlushHandlers.end()) handlerIt->second->enableCallbacks(); } inline static int getAlternativeViewForPaint(COKitDocument* pThis, ITiledRenderable* pDoc, const SfxViewShell* pCurrentViewShell, const std::string_view &sCurrentViewRenderState, const int nPartIndex, const int nMode) { // The painted tile belongs to a single document. When several documents // live in one process, other documents may have a view sitting on the // requested part, so the candidate view must belong to this document. const ViewShellDocId aThisDocId(static_cast(pThis)->mnDocumentId); SfxViewShell* pViewShell = SfxViewShell::GetFirst(); while (pViewShell) { bool bIsInEdit = pViewShell->GetDrawView() && pViewShell->GetDrawView()->GetTextEditOutliner(); if (!bIsInEdit && pViewShell != pCurrentViewShell && pViewShell->GetDocId() == aThisDocId) { if (pViewShell->getPart() == nPartIndex && pViewShell->getEditMode() == nMode) { OString sNewRenderState = pDoc->getViewRenderState(pViewShell); if (sCurrentViewRenderState == sNewRenderState) { const int nViewId = pViewShell->GetViewShellId().get(); doc_setView(pThis, nViewId); return nViewId; } } } pViewShell = SfxViewShell::GetNext(*pViewShell); } return -1; } static void doc_paintPartTile(COKitDocument* 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 bool bFirst = true; if (bFirst) { bFirst = false; SAL_INFO("kit", "doc_paintPartTile: first tile @ " << osl_getGlobalTimer()); } comphelper::ProfileZone aZone("doc_paintPartTile"); SolarMutexGuard aGuard; SetLastExceptionMsg(); writeInfoLog(nPart, nMode, nTileWidth, nTileHeight, nTilePosX, nTilePosY, nCanvasWidth, nCanvasHeight); ITiledRenderable* pDoc = getDocumentPointer(pThis); if (!pDoc) return; // The boundary names parts of a presentation or drawing document by their stable page unique // ids. Resolve the requested part number to the index the page holds when it paints, so the // pixels are of the requested page even if the pages were renumbered after the request was // sent; the solar mutex is held for the whole call, so the index stays valid throughout. A // page that is gone has nothing to paint. int nPartIndex = nPart; if (partsAreUniqueIds(pDoc)) { nPartIndex = partIndexFromNumber(pDoc, nPart, nMode); if (nPartIndex < 0) { SAL_INFO("kit", "paintPartTile names the gone part " << nPart); return; } } LibLODocument_Impl* pDocument = static_cast(pThis); int nOrigViewId = doc_getView(pThis); if (nOrigViewId < 0) nOrigViewId = getFirstViewIdAsFallback(pThis); if (nOrigViewId == -1) return; // Data validity checks end here. // Disable callbacks while we are painting. disableViewCallbacks(pDocument, nOrigViewId); try { // Text documents have a single coordinate system; don't change part. int nOrigPart = 0; const COKitDocumentType aType = doc_getDocumentType(pThis); const bool isText = (aType == COKitDocumentType::TEXT); int nOrigEditMode = 0; bool bPaintTextEdit = true; int nViewId = nOrigViewId; SfxViewShell* pCurrentViewShell = SfxViewShell::Current(); const OString sCurrentViewRenderState = pDoc->getViewRenderState(pCurrentViewShell); // When rendering another part's tile we switch the view page, this // clears the current selections (marked objects). // Remember the selections here and restore it after switching back. std::vector aSavedMarkedObjects; // Check if just switching to another view is enough, that has less side-effects. // Render state is sometimes empty, don't risk it. if ((nPartIndex != pDoc->getPart() || nMode != pDoc->getEditMode()) && !sCurrentViewRenderState.isEmpty()) { nViewId = getAlternativeViewForPaint(pThis, pDoc, pCurrentViewShell, sCurrentViewRenderState, nPartIndex, nMode); if (nViewId == -1) nViewId = nOrigViewId; // Couldn't find an alternative view. // else -> We found an alternative view and already switched to that. } // Disable callbacks while we are painting - after setting the view if (nViewId != nOrigViewId) disableViewCallbacks(pDocument, nViewId); else { // If we are here, we couldn't find an alternative view. We need to check the part and mode. if (!isText) { nOrigPart = pDoc->getPart(); if (nPartIndex != nOrigPart) { if (SdrView* pSaveView = pCurrentViewShell ? pCurrentViewShell->GetDrawView() : nullptr) { const SdrMarkList& rMarks = pSaveView->GetMarkedObjectList(); for (size_t i = 0; i < rMarks.GetMarkCount(); ++i) aSavedMarkedObjects.push_back(rMarks.GetMark(i)->GetMarkedSdrObj()); } doc_setPartIndexImpl(pThis, nPartIndex, false); } } nOrigEditMode = pDoc->getEditMode(); if (nOrigEditMode != nMode) KitHelper::setEditMode(nMode, pDoc); } if (!isText) { bPaintTextEdit = (nPartIndex == nOrigPart && nMode == nOrigEditMode); pDoc->setPaintTextEdit(bPaintTextEdit); } doc_paintTile(pThis, pBuffer, nCanvasWidth, nCanvasHeight, nTilePosX, nTilePosY, nTileWidth, nTileHeight); if (!isText) { pDoc->setPaintTextEdit(true); } if (nViewId == nOrigViewId) { // We didn't find an alternative view, set the part and mode back to their initial values if needed. if (nMode != nOrigEditMode) KitHelper::setEditMode(nOrigEditMode, pDoc); if (!isText) { if (nPartIndex != nOrigPart) { doc_setPartIndexImpl(pThis, nOrigPart, false); // Re-apply the selections cleared during the view page switching. if (!aSavedMarkedObjects.empty()) { if (SdrView* pRestoreView = pCurrentViewShell ? pCurrentViewShell->GetDrawView() : nullptr) { if (SdrPageView* pPageView = pRestoreView->GetSdrPageView()) { for (SdrObject* pObj : aSavedMarkedObjects) { if (pObj) pRestoreView->MarkObj(pObj, pPageView); } } } } } } } else { // We found an alternative view and used it. Enable its callbacks again and turn back to our original view. enableViewCallbacks(pDocument, nViewId); doc_setView(pThis, nOrigViewId); } } catch (const std::exception&) { // Nothing to do but restore the PartTilePainting flag. } enableViewCallbacks(pDocument, nOrigViewId); // Inform all views with the same view render state about the paint, so they know if makes sense // to invalidate those areas later. tools::Rectangle aRectangle{Point(nTilePosX, nTilePosY), Size(nTileWidth, nTileHeight)}; pDocument->updateViewsForPaintedTile(nOrigViewId, nPart, nMode, aRectangle); } void LibLODocument_Impl::updateViewsForPaintedTile(int nOrigViewId, int nPart, int nMode, const tools::Rectangle& rRectangle) { auto it = mpCallbackFlushHandlers.find(nOrigViewId); if (it == mpCallbackFlushHandlers.end()) { return; } // Update info about painted tiles in other views that have the same CanonicalViewId. const OString& rViewRenderState = it->second->getViewRenderState(); for (const auto& rHandler : mpCallbackFlushHandlers) { if (rHandler.second->getViewRenderState() != rViewRenderState) { continue; } rHandler.second->tilePainted(nPart, nMode, rRectangle); } } static COKitTileMode doc_getTileMode(SAL_UNUSED_PARAMETER COKitDocument* /*pThis*/) { SetLastExceptionMsg(); #if ENABLE_CAIRO_RGBA || defined IOS return COKitTileMode::RGBA; #else return COKitTileMode::BGRA; #endif } static void doc_getDocumentSize(COKitDocument* 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(u"Document doesn't support tiled rendering"_ustr); } } static void doc_getDataArea(COKitDocument* 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(u"Document doesn't support tiled rendering"_ustr); } } static void doc_initializeForRendering(COKitDocument* pThis, const char* pArguments) { comphelper::ProfileZone aZone("doc_initializeForRendering"); SolarMutexGuard aGuard; SetLastExceptionMsg(); ITiledRenderable* pDoc = getTiledRenderable(pThis); if (pDoc) { doc_iniUnoCommands(); std::vector aArgs = jsonToPropertyValuesVector(pArguments); OString aSignatureCert; OString aSignatureKey; for (const auto& rArg : aArgs) { if (rArg.Name == ".uno:SignatureCert" && rArg.Value.has()) { aSignatureCert = rArg.Value.get().toUtf8(); } else if (rArg.Name == ".uno:SignatureKey" && rArg.Value.has()) { aSignatureKey = rArg.Value.get().toUtf8(); } else if (rArg.Name == ".uno:SignatureCa" && rArg.Value.has()) { OString aSignatureCa(rArg.Value.get().toUtf8()); KitHelper::addCertificates(aSignatureCa); } } if (!aSignatureCert.isEmpty() && !aSignatureKey.isEmpty()) { if (SfxViewShell* pViewShell = SfxViewShell::Current()) { svl::crypto::CertificateOrName aCertificateOrName; aCertificateOrName.m_xCertificate = KitHelper::getSigningCertificate(aSignatureCert, aSignatureKey); pViewShell->SetSigningCertificate(aCertificateOrName); } } pDoc->initializeForTiledRendering(comphelper::containerToSequence(aArgs)); } } static void doc_registerCallback(COKitDocument* pThis, COKitCallback pCallback, void* pData) { SolarMutexGuard aGuard; SetLastExceptionMsg(); LibLODocument_Impl* pDocument = static_cast(pThis); const int nView = KitHelper::getViewId(pDocument->mnDocumentId); SfxViewShell* pViewShell = KitHelper::getViewOfId(nView); if (!pViewShell) return; assert(nView == pViewShell->GetViewShellId().get() && "otherwise we couldn't have found it"); 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); } } auto pCallbackFlushHandler = std::make_shared(pThis, pCallback, pData); pDocument->mpCallbackFlushHandlers[nView] = pCallbackFlushHandler; if (pCallback != nullptr) { for (const auto& pair : pDocument->mpCallbackFlushHandlers) { if (pair.first == nId) continue; pDocument->mpCallbackFlushHandlers[nView]->addViewStates(pair.first); } pDocument->mpCallbackFlushHandlers[nView]->setViewId(nView); pViewShell->setCOKitViewCallback(pDocument->mpCallbackFlushHandlers[nView].get()); if (!pDocument->maFontsMissing.empty()) { OStringBuffer sPayload("{ \"fontsmissing\": [ "); bool bFirst = true; for (const auto &f : pDocument->maFontsMissing) { if (bFirst) bFirst = false; else sPayload.append(", "); sPayload.append("\"" + f.toUtf8() + "\""); } sPayload.append(" ] }"); pCallback(COKitCallbackType::FONTS_MISSING, sPayload.toString().getStr(), pData); pDocument->maFontsMissing.clear(); } // Try to take info about already painted tiles from another view that has the same // CanonicalViewId. const OString& rViewRenderState = pCallbackFlushHandler->getViewRenderState(); for (const auto& rHandler : pDocument->mpCallbackFlushHandlers) { if (rHandler.second->getViewRenderState() == rViewRenderState && rHandler.first != nId) { pCallbackFlushHandler->setPaintedTiles(rHandler.second->getPaintedTiles()); break; } } } else { pViewShell->setCOKitViewCallback(nullptr); pDocument->mpCallbackFlushHandlers[nView]->setViewId(-1); pDocument->mpCallbackFlushHandlers.erase(nView); } } /// Returns the JSON representation of all the comments in the document static char* getPostIts(COKitDocument* pThis) { SetLastExceptionMsg(); ITiledRenderable* pDoc = getTiledRenderable(pThis); if (!pDoc) { SetLastExceptionMsg(u"Document doesn't support tiled rendering"_ustr); return nullptr; } tools::JsonWriter aJsonWriter; pDoc->getPostIts(aJsonWriter); return convertOString(aJsonWriter.finishAndGetAsOString()); } /// Returns the JSON representation of the positions of all the comments in the document static char* getPostItsPos(COKitDocument* pThis) { SetLastExceptionMsg(); ITiledRenderable* pDoc = getTiledRenderable(pThis); if (!pDoc) { SetLastExceptionMsg(u"Document doesn't support tiled rendering"_ustr); return nullptr; } tools::JsonWriter aJsonWriter; pDoc->getPostItsPos(aJsonWriter); return convertOString(aJsonWriter.finishAndGetAsOString()); } static char* getRulerState(COKitDocument* pThis) { SetLastExceptionMsg(); ITiledRenderable* pDoc = getTiledRenderable(pThis); if (!pDoc) { SetLastExceptionMsg(u"Document doesn't support tiled rendering"_ustr); return nullptr; } tools::JsonWriter aJsonWriter; pDoc->getRulerState(aJsonWriter); return convertOString(aJsonWriter.finishAndGetAsOString()); } static char* getAllPartSize(COKitDocument* pThis) { SetLastExceptionMsg(); ITiledRenderable* pDoc = getTiledRenderable(pThis); if (!pDoc) { SetLastExceptionMsg(u"Document doesn't support tiled rendering"_ustr); return nullptr; } tools::JsonWriter aJsonWriter; pDoc->getAllPartSize(aJsonWriter); return convertOString(aJsonWriter.finishAndGetAsOString()); } static void doc_postKeyEvent(COKitDocument* pThis, COKitKeyEventType eType, int nCharCode, int nKeyCode) { comphelper::ProfileZone aZone("doc_postKeyEvent"); SolarMutexGuard aGuard; SetLastExceptionMsg(); ITiledRenderable* pDoc = getTiledRenderable(pThis); if (!pDoc) { SetLastExceptionMsg(u"Document doesn't support tiled rendering"_ustr); return; } try { pDoc->postKeyEvent(eType, nCharCode, nKeyCode); } catch (const uno::Exception& exception) { SetLastExceptionMsg(exception.Message); SAL_INFO("kit", "Failed to postKeyEvent " << exception.Message); } } static void doc_setBlockedCommandList(COKitDocument* /*pThis*/, int nViewId, const char* blockedCommandList) { SolarMutexGuard aGuard; KitHelper::setBlockedCommandList(nViewId, blockedCommandList); } static void doc_postWindowExtTextInputEvent(COKitDocument* pThis, unsigned nWindowId, COKitExtTextInputType eType, const char* pText) { comphelper::ProfileZone aZone("doc_postWindowExtTextInputEvent"); SolarMutexGuard aGuard; VclPtr pWindow; if (nWindowId == 0) { ITiledRenderable* pDoc = getTiledRenderable(pThis); if (!pDoc) { SetLastExceptionMsg(u"Document doesn't support tiled rendering"_ustr); return; } pWindow = pDoc->getDocWindow(); } else { pWindow = vcl::Window::FindKitWindow(nWindowId); } if (!pWindow) { SetLastExceptionMsg("No window found for window id: " + OUString::number(nWindowId)); return; } KitHelper::postExtTextEventAsync(pWindow, eType, OUString::fromUtf8(std::string_view(pText, strlen(pText)))); } static void doc_removeTextContext(COKitDocument* pThis, unsigned nKitWindowId, int nCharBefore, int nCharAfter) { SolarMutexGuard aGuard; if (SfxViewShell::IsCurrentKitViewReadOnly()) return; VclPtr pWindow; if (nKitWindowId == 0) { ITiledRenderable* pDoc = getTiledRenderable(pThis); if (!pDoc) { SetLastExceptionMsg(u"Document doesn't support tiled rendering"_ustr); return; } pWindow = pDoc->getDocWindow(); } else { pWindow = vcl::Window::FindKitWindow(nKitWindowId); } if (!pWindow) { SetLastExceptionMsg("No window found for window id: " + OUString::number(nKitWindowId)); 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 (nKitWindowId == 0) { KeyEvent aEvt(8, KEY_BACKSPACE); for (int i = 0; i < nCharBefore; ++i) pWindow->KeyInput(aEvt); } else KitHelper::postKeyEventAsync(pWindow, COKitKeyEventType::DOWN, 8, KEY_BACKSPACE, nCharBefore - 1); } if (nCharAfter > 0) { // delete (forward) if (nKitWindowId == 0) { KeyEvent aEvt(46, KEY_DELETE); for (int i = 0; i < nCharAfter; ++i) pWindow->KeyInput(aEvt); } else KitHelper::postKeyEventAsync(pWindow, COKitKeyEventType::DOWN, 46, KEY_DELETE, nCharAfter - 1); } } static void doc_postWindowKeyEvent(COKitDocument* /*pThis*/, unsigned nKitWindowId, COKitKeyEventType eType, int nCharCode, int nKeyCode) { comphelper::ProfileZone aZone("doc_postWindowKeyEvent"); SolarMutexGuard aGuard; SetLastExceptionMsg(); VclPtr pWindow = vcl::Window::FindKitWindow(nKitWindowId); if (!pWindow) { SetLastExceptionMsg(u"Document doesn't support dialog rendering, or window not found."_ustr); return; } KeyEvent aEvent(nCharCode, nKeyCode, 0); switch (eType) { case COKitKeyEventType::DOWN: Application::PostKeyEvent(VclEventId::WindowKeyInput, pWindow, &aEvent); break; case COKitKeyEventType::UP: Application::PostKeyEvent(VclEventId::WindowKeyUp, pWindow, &aEvent); break; default: assert(false); break; } } // To be an exportable selection, there must be something selected and that // selection can't be "ScCellObj" which doesn't can't provide a svg. // // Typically a problem arises when double clicking a shape in calc. The 1st // click selects the shape, triggering generation of a preview, but the second // shape enters into edit mode before doc_renderShapeSelection has a chance to // fire, at which point the shape is no longer selected. Rather than generate // an error just return a 0 length result if there is no shape selected, so we // continue to generate an error if a shape is selected, but could not provide // an svg. static bool doc_hasShapeSelection(const css::uno::Reference& rComponent) { uno::Reference xModel(rComponent, uno::UNO_QUERY); if (!xModel.is()) return false; uno::Reference xController(xModel->getCurrentController()); if (!xController.is()) return false; uno::Reference xSelectionSupplier(xController, uno::UNO_QUERY); if (!xSelectionSupplier.is()) return false; Any selection = xSelectionSupplier->getSelection(); uno::Reference xSelection; selection >>= xSelection; return xSelection && xSelection->getImplementationName() != "ScCellObj"; } static size_t doc_renderShapeSelection(COKitDocument* pThis, char** pOutput) { comphelper::ProfileZone aZone("doc_renderShapeSelection"); SolarMutexGuard aGuard; SetLastExceptionMsg(); // In Calc and Impress, double-clicking a shape leaves the shape in edit // mode while the parent doc's selection becomes invalid (Calc selects // the cell, Impress drops the shape selection). Bail out to avoid // rendering during that transition. Writer's chart wizard differs: it // inserts the chart and enters edit mode immediately, but the chart // frame remains selected at the Writer level as a TextEmbeddedObject, // and writer_svg_Export's embedded-object path can render the // replacement graphic even while the chart is still in edit mode. if (doc_getDocumentType(pThis) != COKitDocumentType::TEXT) { KitChartHelper aChartHelper(SfxViewShell::Current()); if (aChartHelper.GetWindow()) return 0; } try { LibLODocument_Impl* pDocument = static_cast(pThis); if (!doc_hasShapeSelection(pDocument->mxComponent)) return 0; uno::Reference xStorable(pDocument->mxComponent, uno::UNO_QUERY_THROW); SvMemoryStream aOutStream; uno::Reference xOut = new utl::OOutputStreamWrapper(aOutStream); comphelper::SequenceAsHashMap aMediaDescriptor; switch (doc_getDocumentType(pThis)) { case COKitDocumentType::PRESENTATION: aMediaDescriptor[u"FilterName"_ustr] <<= u"impress_svg_Export"_ustr; break; case COKitDocumentType::DRAWING: aMediaDescriptor[u"FilterName"_ustr] <<= u"draw_svg_Export"_ustr; break; case COKitDocumentType::TEXT: aMediaDescriptor[u"FilterName"_ustr] <<= u"writer_svg_Export"_ustr; break; case COKitDocumentType::SPREADSHEET: aMediaDescriptor[u"FilterName"_ustr] <<= u"calc_svg_Export"_ustr; break; default: SAL_WARN("kit", "Failed to render shape selection: Document type is not supported"); } aMediaDescriptor[u"SelectionOnly"_ustr] <<= true; aMediaDescriptor[u"OutputStream"_ustr] <<= xOut; aMediaDescriptor[u"IsPreview"_ustr] <<= true; // will down-scale graphics // Pin the shared draw outliner's background to the requesting // view's DOCCOLOR so automatic font colors resolve against the // user's per-view theme. Otherwise multi-user dark/light setups // produce inverse-mode auto color text in the SVG drag preview. SdrOutliner* pPinnedOutliner = nullptr; Color aSavedOutlinerBg(COL_AUTO); if (SfxViewShell* pViewShell = SfxViewShell::Current()) { if (SdrView* pDrawView = pViewShell->GetDrawView()) { pPinnedOutliner = &pDrawView->GetModel().GetDrawOutliner(); aSavedOutlinerBg = pPinnedOutliner->GetBackgroundColor(); pPinnedOutliner->SetBackgroundColor( pViewShell->GetColorConfigColor(svtools::DOCCOLOR)); } } comphelper::ScopeGuard aRestoreOutlinerBg([&]() { if (pPinnedOutliner) pPinnedOutliner->SetBackgroundColor(aSavedOutlinerBg); }); xStorable->storeToURL(u"private:stream"_ustr, 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) { cpo::uno::Any exAny( cppu::getCaughtException() ); SetLastExceptionMsg(exception.Message); SAL_WARN("kit", "Failed to render shape selection: " << exceptionToString(exAny)); } return 0; } namespace { /** Class to react on finishing of a dispatched command. This will call a KIT_COMMAND_FINISHED callback when postUnoCommand was called with the parameter requesting the notification. @see COKitCallbackType::COKitCallbackType::UNO_COMMAND_RESULT. */ class DispatchResultListener : public cppu::WeakImplHelper { const OString maCommand; ///< Command for which this is the result. const std::shared_ptr mpCallback; ///< Callback to call. const std::chrono::steady_clock::time_point mSaveTime; //< The time we started saving. const bool mbWasModified; //< Whether or not the document was modified before saving. const css::uno::Reference mxComponent; //< The document the command ran on. public: DispatchResultListener(const char* pCommand, std::shared_ptr pCallback, bool bWasModified, css::uno::Reference xComponent) : maCommand(pCommand) , mpCallback(std::move(pCallback)) , mSaveTime(std::chrono::steady_clock::now()) , mbWasModified(bWasModified) , mxComponent(std::move(xComponent)) { assert(mpCallback); } virtual void 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); } // A failed save comes back with a void result, so the reason the store gave would be lost. // The store recorded its reason on the document shell as it failed, so carry that as the // result instead. OUString aStoreError; if (SfxObjectShell* pShell = SfxObjectShell::GetShellFromComponent(mxComponent)) aStoreError = pShell->GetLastStoreErrorMessage(); if (maCommand == ".uno:Save" && rEvent.State == frame::DispatchResultState::FAILURE && !rEvent.Result.hasValue() && !aStoreError.isEmpty()) { auto resultNode = aJson.startNode("result"); aJson.put("type", "string"); aJson.put("value", aStoreError.toUtf8()); } else unoAnyToJson(aJson, "result", rEvent.Result); aJson.put("wasModified", mbWasModified); aJson.put("startUnixTimeMics", std::chrono::time_point_cast(mSaveTime) .time_since_epoch() .count()); aJson.put("saveDurationMics", std::chrono::duration_cast( std::chrono::steady_clock::now() - mSaveTime) .count()); mpCallback->queue(COKitCallbackType::UNO_COMMAND_RESULT, aJson.finishAndGetAsOString()); } virtual void disposing(const css::lang::EventObject&) override {} }; } // anonymous namespace static void lcl_sendDialogEvent(unsigned long long int nWindowId, const char* pArguments) { SolarMutexGuard aGuard; const StringMap aMap(jsdialog::jsonToStringMap(pArguments)); auto aIdIter = aMap.find(u"id"_ustr); if (aIdIter == aMap.end() || aIdIter->second.isEmpty()) { SAL_WARN("kit", "sendDialogEvent: no widget id set"); assert(false); return; } const sal_uInt64 nCurrentShellId = reinterpret_cast(SfxViewShell::Current()); try { const OUString sControlId = aIdIter->second; OUString sWindowId = OUString::number(nWindowId); const OUString sCurrentShellId = OUString::number(nCurrentShellId); // special values for window id if (nWindowId == static_cast(-1)) sWindowId = sCurrentShellId + "sidebar"; if (nWindowId == static_cast(-2)) sWindowId = sCurrentShellId + "notebookbar"; if (nWindowId == static_cast(-3)) sWindowId = sCurrentShellId + "formulabar"; if (nWindowId == static_cast(-4)) sWindowId = sCurrentShellId + "addressinputfield"; if (nWindowId == static_cast(-5)) sWindowId = sCurrentShellId + "quickfind"; // dialogs send own id but notebookbar and sidebar controls are remembered by SfxViewShell id if (jsdialog::ExecuteAction(sWindowId, sControlId, aMap)) return; if (jsdialog::ExecuteAction(sCurrentShellId + "sidebar", sControlId, aMap)) return; if (jsdialog::ExecuteAction(sCurrentShellId + "navigator", sControlId, aMap)) return; if (jsdialog::ExecuteAction(sCurrentShellId + "quickfind", sControlId, aMap)) return; if (jsdialog::ExecuteAction(sCurrentShellId + "notebookbar", sControlId, aMap)) return; if (jsdialog::ExecuteAction(sCurrentShellId + "formulabar", sControlId, aMap)) return; if (jsdialog::ExecuteAction(sCurrentShellId + "addressinputfield", 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(u"0"_ustr, sControlId, aMap)) return; SAL_WARN( "kit", "sendDialogEvent: no widget for id '" << sControlId << "' on shell " << sCurrentShellId << " or window " << sWindowId); } catch (std::out_of_range& e) { SAL_WARN("kit", "jsdialog::ExecuteAction syntax error - field not found in '" << e.what() << "'"); assert(false); } catch (...) {} } static void doc_sendDialogEvent(COKitDocument* /*pThis*/, unsigned long long int nWindowId, const char* pArguments) { lcl_sendDialogEvent(nWindowId, pArguments); } static void lo_sendDialogEvent(COKit* /*pThis*/, unsigned long long int nWindowId, const char* pArguments) { lcl_sendDialogEvent(nWindowId, pArguments); } static void reInitDictionaryList() { uno::Reference