/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ /* * This file is part of the LibreOffice project. * * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ #include #include #include #include #include #include #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 "../app/cmdlineargs.hxx" // We also need to hackily be able to start the main libreoffice thread: #include "../app/sofficemain.h" #include "../app/officeipcthread.hxx" #include #include "lokinteractionhandler.hxx" #include using namespace css; using namespace vcl; using namespace desktop; using namespace utl; static LibLibreOffice_Impl *gImpl = nullptr; static std::weak_ptr< LibreOfficeKitClass > gOfficeClass; static std::weak_ptr< LibreOfficeKitDocumentClass > gDocumentClass; typedef struct { const char *extn; const char *filterName; } ExtensionMap; static const ExtensionMap aWriterExtensionMap[] = { { "doc", "MS Word 97" }, { "docx", "MS Word 2007 XML" }, { "fodt", "OpenDocument Text Flat XML" }, { "html", "HTML (StarWriter)" }, { "odt", "writer8" }, { "ott", "writer8_template" }, { "pdf", "writer_pdf_Export" }, { "txt", "Text" }, { "xhtml", "XHTML Writer File" }, { "png", "writer_png_Export" }, { nullptr, nullptr } }; static const ExtensionMap aCalcExtensionMap[] = { { "csv", "Text - txt - csv (StarCalc)" }, { "fods", "OpenDocument Spreadsheet Flat XML" }, { "html", "HTML (StarCalc)" }, { "ods", "calc8" }, { "ots", "calc8_template" }, { "pdf", "calc_pdf_Export" }, { "xhtml", "XHTML Calc File" }, { "xls", "MS Excel 97" }, { "xlsx", "Calc MS Excel 2007 XML" }, { "png", "calc_png_Export" }, { nullptr, nullptr } }; static const ExtensionMap aImpressExtensionMap[] = { { "fodp", "OpenDocument Presentation Flat XML" }, { "html", "impress_html_Export" }, { "odg", "impress8_draw" }, { "odp", "impress8" }, { "otp", "impress8_template" }, { "pdf", "impress_pdf_Export" }, { "potm", "Impress MS PowerPoint 2007 XML Template" }, { "pot", "MS PowerPoint 97 Vorlage" }, { "pptx", "Impress MS PowerPoint 2007 XML" }, { "pps", "MS PowerPoint 97 Autoplay" }, { "ppt", "MS PowerPoint 97" }, { "svg", "impress_svg_Export" }, { "swf", "impress_flash_Export" }, { "xhtml", "XHTML Impress File" }, { "png", "impress_png_Export"}, { nullptr, nullptr } }; static const ExtensionMap aDrawExtensionMap[] = { { "fodg", "draw_ODG_FlatXML" }, { "html", "draw_html_Export" }, { "odg", "draw8" }, { "pdf", "draw_pdf_Export" }, { "svg", "draw_svg_Export" }, { "swf", "draw_flash_Export" }, { "xhtml", "XHTML Draw File" }, { "png", "draw_png_Export"}, { nullptr, nullptr } }; /* * Map directly to css cursor styles to avoid further mapping in the client. * Gtk (via gdk_cursor_new_from_name) also supports the same css cursor styles. * * This was created partially with help of the mappings in gtkdata.cxx. * The list is incomplete as some cursor style simply aren't supported * by css, it might turn out to be worth mapping some of these missing cursors * to available cursors? */ #ifdef _MSC_VER #pragma warning(push) #pragma warning( disable : 4592) #endif static const std::map aPointerMap { { PointerStyle::Arrow, "default" }, // PointerStyle::Null ? { PointerStyle::Wait, "wait" }, { PointerStyle::Text, "text" }, { PointerStyle::Help, "help" }, { PointerStyle::Cross, "crosshair" }, { PointerStyle::Fill, "fill" }, { PointerStyle::Move, "move" }, { PointerStyle::NSize, "n-resize" }, { PointerStyle::SSize, "s-resize" }, { PointerStyle::WSize, "w-resize" }, { PointerStyle::ESize, "e-resize" }, { PointerStyle::NWSize, "ne-resize" }, { PointerStyle::NESize, "ne-resize" }, { PointerStyle::SWSize, "sw-resize" }, { PointerStyle::SESize, "se-resize" }, // WindowNSize through WindowSESize { PointerStyle::HSplit, "col-resize" }, { PointerStyle::VSplit, "row-resize" }, { PointerStyle::HSizeBar, "col-resize" }, { PointerStyle::VSizeBar, "row-resize" }, { PointerStyle::Hand, "grab" }, { PointerStyle::RefHand, "grabbing" }, // Pen, Magnify, Fill, Rotate // HShear, VShear // Mirror, Crook, Crop, MovePoint, MoveBezierWeight // MoveData { PointerStyle::CopyData, "copy" }, { PointerStyle::LinkData, "alias" }, // MoveDataLink, CopyDataLink //MoveFile, CopyFile, LinkFile // MoveFileLink, CopyFileLink, MoveFiless, CopyFiles { PointerStyle::NotAllowed, "not-allowed" }, // DrawLine through DrawCaption // Chart, Detective, PivotCol, PivotRow, PivotField, Chain, ChainNotAllowed // TimeEventMove, TimeEventSize // AutoScrollN through AutoScrollNSWE // Airbrush { PointerStyle::TextVertical, "vertical-text" } // Pivot Delete, TabSelectS through TabSelectSW // PaintBrush, HideWhiteSpace, ShowWhiteSpace }; #ifdef _MSC_VER #pragma warning(pop) #endif static OUString getUString(const char* pString) { if (pString == nullptr) return OUString(); OString sString(pString, strlen(pString)); return OStringToOUString(sString, RTL_TEXTENCODING_UTF8); } /// Try to convert a relative URL to an absolute one, unless it already looks like an URL. static OUString getAbsoluteURL(const char* pURL) { OUString aURL(getUString(pURL)); if (aURL.isEmpty()) return aURL; // convert relative paths to absolute ones OUString aWorkingDir; osl_getProcessWorkingDir(&aWorkingDir.pData); if (!aWorkingDir.endsWith("/")) aWorkingDir += "/"; try { return rtl::Uri::convertRelToAbs(aWorkingDir, aURL); } catch (const rtl::MalformedUriException &) { } return OUString(); } static std::vector jsonToPropertyValuesVector(const char* pJSON) { std::vector aArguments; if (pJSON && pJSON[0] != '\0') { boost::property_tree::ptree aTree; std::stringstream aStream(pJSON); boost::property_tree::read_json(aStream, aTree); for (const auto& rPair : aTree) { const std::string& rType = rPair.second.get("type"); const std::string& rValue = rPair.second.get("value"); beans::PropertyValue aValue; aValue.Name = OUString::fromUtf8(rPair.first.c_str()); if (rType == "string") aValue.Value <<= OUString::fromUtf8(rValue.c_str()); else if (rType == "boolean") aValue.Value <<= OString(rValue.c_str()).toBoolean(); else if (rType == "float") aValue.Value <<= OString(rValue.c_str()).toFloat(); else if (rType == "long") aValue.Value <<= OString(rValue.c_str()).toInt32(); else if (rType == "unsigned short") aValue.Value <<= static_cast(OString(rValue.c_str()).toUInt32()); else SAL_WARN("desktop.lib", "jsonToPropertyValuesVector: unhandled type '"<().toUtf8().getStr()); // TODO: Add more as required return aTree; } extern "C" { static void doc_destroy(LibreOfficeKitDocument* pThis); static int doc_saveAs(LibreOfficeKitDocument* pThis, const char* pUrl, const char* pFormat, const char* pFilterOptions); static int doc_getDocumentType(LibreOfficeKitDocument* pThis); static int doc_getParts(LibreOfficeKitDocument* pThis); static char* doc_getPartPageRectangles(LibreOfficeKitDocument* pThis); static int doc_getPart(LibreOfficeKitDocument* pThis); static void doc_setPart(LibreOfficeKitDocument* pThis, int nPart); static char* doc_getPartName(LibreOfficeKitDocument* pThis, int nPart); static void doc_setPartMode(LibreOfficeKitDocument* pThis, int nPartMode); void doc_paintTile(LibreOfficeKitDocument* pThis, unsigned char* pBuffer, const int nCanvasWidth, const int nCanvasHeight, const int nTilePosX, const int nTilePosY, const int nTileWidth, const int nTileHeight); void doc_paintPartTile(LibreOfficeKitDocument* pThis, unsigned char* pBuffer, const int nPart, const int nCanvasWidth, const int nCanvasHeight, const int nTilePosX, const int nTilePosY, const int nTileWidth, const int nTileHeight); static int doc_getTileMode(LibreOfficeKitDocument* pThis); static void doc_getDocumentSize(LibreOfficeKitDocument* pThis, long* pWidth, long* pHeight); static void doc_initializeForRendering(LibreOfficeKitDocument* pThis, const char* pArguments); static void doc_registerCallback(LibreOfficeKitDocument* pThis, LibreOfficeKitCallback pCallback, void* pData); static void doc_postKeyEvent(LibreOfficeKitDocument* pThis, int nType, int nCharCode, int nKeyCode); static void doc_postMouseEvent (LibreOfficeKitDocument* pThis, int nType, int nX, int nY, int nCount, int nButtons, int nModifier); static void doc_postUnoCommand(LibreOfficeKitDocument* pThis, const char* pCommand, const char* pArguments, bool bNotifyWhenFinished); static void doc_setTextSelection (LibreOfficeKitDocument* pThis, int nType, int nX, int nY); static char* doc_getTextSelection(LibreOfficeKitDocument* pThis, const char* pMimeType, char** pUsedMimeType); static bool doc_paste(LibreOfficeKitDocument* pThis, const char* pMimeType, const char* pData, size_t nSize); static void doc_setGraphicSelection (LibreOfficeKitDocument* pThis, int nType, int nX, int nY); static void doc_resetSelection (LibreOfficeKitDocument* pThis); static char* doc_getCommandValues(LibreOfficeKitDocument* pThis, const char* pCommand); static void doc_setClientZoom(LibreOfficeKitDocument* pThis, int nTilePixelWidth, int nTilePixelHeight, int nTileTwipWidth, int nTileTwipHeight); static void doc_setClientVisibleArea(LibreOfficeKitDocument* pThis, int nX, int nY, int nWidth, int nHeight); static int doc_createView(LibreOfficeKitDocument* pThis); static void doc_destroyView(LibreOfficeKitDocument* pThis, int nId); static void doc_setView(LibreOfficeKitDocument* pThis, int nId); static int doc_getView(LibreOfficeKitDocument* pThis); static int doc_getViews(LibreOfficeKitDocument* pThis); static unsigned char* doc_renderFont(LibreOfficeKitDocument* pThis, const char *pFontName, int* pFontWidth, int* pFontHeight); static char* doc_getPartHash(LibreOfficeKitDocument* pThis, int nPart); LibLODocument_Impl::LibLODocument_Impl(const uno::Reference &xComponent) : mxComponent(xComponent) { if (!(m_pDocumentClass = gDocumentClass.lock())) { m_pDocumentClass.reset(new LibreOfficeKitDocumentClass); m_pDocumentClass->nSize = sizeof(LibreOfficeKitDocument); 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->getPartName = doc_getPartName; m_pDocumentClass->setPartMode = doc_setPartMode; m_pDocumentClass->paintTile = doc_paintTile; m_pDocumentClass->paintPartTile = doc_paintPartTile; m_pDocumentClass->getTileMode = doc_getTileMode; m_pDocumentClass->getDocumentSize = doc_getDocumentSize; m_pDocumentClass->initializeForRendering = doc_initializeForRendering; m_pDocumentClass->registerCallback = doc_registerCallback; m_pDocumentClass->postKeyEvent = doc_postKeyEvent; m_pDocumentClass->postMouseEvent = doc_postMouseEvent; m_pDocumentClass->postUnoCommand = doc_postUnoCommand; m_pDocumentClass->setTextSelection = doc_setTextSelection; m_pDocumentClass->getTextSelection = doc_getTextSelection; m_pDocumentClass->paste = doc_paste; m_pDocumentClass->setGraphicSelection = doc_setGraphicSelection; m_pDocumentClass->resetSelection = doc_resetSelection; m_pDocumentClass->getCommandValues = doc_getCommandValues; m_pDocumentClass->setClientZoom = doc_setClientZoom; m_pDocumentClass->setClientVisibleArea = doc_setClientVisibleArea; m_pDocumentClass->createView = doc_createView; m_pDocumentClass->destroyView = doc_destroyView; m_pDocumentClass->setView = doc_setView; m_pDocumentClass->getView = doc_getView; m_pDocumentClass->getViews = doc_getViews; m_pDocumentClass->renderFont = doc_renderFont; m_pDocumentClass->getPartHash = doc_getPartHash; gDocumentClass = m_pDocumentClass; } pClass = m_pDocumentClass.get(); } LibLODocument_Impl::~LibLODocument_Impl() { mxComponent->dispose(); } CallbackFlushHandler::CallbackFlushHandler(LibreOfficeKitDocument* pDocument, LibreOfficeKitCallback pCallback, void* pData) : Idle( "lokit timer callback" ), m_pDocument(pDocument), m_pCallback(pCallback), m_pData(pData), m_bPartTilePainting(false) { SetPriority(SchedulerPriority::POST_PAINT); // Add the states that are safe to skip duplicates on, // even when not consequent. m_states.emplace(LOK_CALLBACK_TEXT_SELECTION_START, "NIL"); m_states.emplace(LOK_CALLBACK_TEXT_SELECTION_END, "NIL"); m_states.emplace(LOK_CALLBACK_TEXT_SELECTION, "NIL"); m_states.emplace(LOK_CALLBACK_GRAPHIC_SELECTION, "NIL"); m_states.emplace(LOK_CALLBACK_GRAPHIC_VIEW_SELECTION, "NIL"); m_states.emplace(LOK_CALLBACK_INVALIDATE_VISIBLE_CURSOR, "NIL"); m_states.emplace(LOK_CALLBACK_INVALIDATE_VIEW_CURSOR , "NIL"); m_states.emplace(LOK_CALLBACK_STATE_CHANGED, "NIL"); m_states.emplace(LOK_CALLBACK_MOUSE_POINTER, "NIL"); m_states.emplace(LOK_CALLBACK_CELL_CURSOR, "NIL"); m_states.emplace(LOK_CALLBACK_CELL_VIEW_CURSOR, "NIL"); m_states.emplace(LOK_CALLBACK_CELL_FORMULA, "NIL"); m_states.emplace(LOK_CALLBACK_CURSOR_VISIBLE, "NIL"); m_states.emplace(LOK_CALLBACK_VIEW_CURSOR_VISIBLE, "NIL"); m_states.emplace(LOK_CALLBACK_SET_PART, "NIL"); Start(); } CallbackFlushHandler::~CallbackFlushHandler() { Stop(); // We might have important notification (.uno:save?). flush(); } void CallbackFlushHandler::Invoke() { flush(); } void CallbackFlushHandler::callback(const int type, const char* payload, void* data) { CallbackFlushHandler* self = static_cast(data); if (self) { self->queue(type, payload); } } void CallbackFlushHandler::queue(const int type, const char* data) { const std::string payload(data ? data : "(nil)"); if (m_bPartTilePainting) { // We drop notifications when this is set, except for important ones. // When we issue a complex command (such as .uno:InsertAnnotation) // there will be multiple notifications. On the first invalidation // we will start painting, but other events will get fired // while the complex command in question executes. // We don't want to suppress everything here on the wrong assumption // that no new events are fired during painting. if (type != LOK_CALLBACK_STATE_CHANGED && type != LOK_CALLBACK_INVALIDATE_TILES && type != LOK_CALLBACK_INVALIDATE_VISIBLE_CURSOR && type != LOK_CALLBACK_CURSOR_VISIBLE && type != LOK_CALLBACK_VIEW_CURSOR_VISIBLE && type != LOK_CALLBACK_TEXT_SELECTION) { //SAL_WARN("lokevt", "Skipping while painting [" + std::to_string(type) + "]: [" + payload + "]."); return; } // In Writer we drop all notifications during painting. if (doc_getDocumentType(m_pDocument) == LOK_DOCTYPE_TEXT) return; } // Supress invalid payloads. if (type == LOK_CALLBACK_INVALIDATE_VISIBLE_CURSOR && payload.find(", 0, 0, ") != std::string::npos) { // The cursor position is often the relative coordinates of the widget // issueing 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_WARN("lokevt", "Skipping invalid event [" + std::to_string(type) + "]: [" + payload + "]."); return; } std::unique_lock lock(m_mutex); 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_WARN("lokevt", "Skipping duplicate [" + std::to_string(type) + "]: [" + payload + "]."); return; } stateIt->second = payload; } if (type == LOK_CALLBACK_TEXT_SELECTION && payload.empty()) { // Removing text selection invalidates the start and end as well. m_states[LOK_CALLBACK_TEXT_SELECTION_START] = ""; m_states[LOK_CALLBACK_TEXT_SELECTION_END] = ""; } m_queue.emplace_back(type, payload); // These are safe to use the latest state and ignore previous // ones (if any) since the last overrides previous ones. switch (type) { case LOK_CALLBACK_TEXT_SELECTION_START: case LOK_CALLBACK_TEXT_SELECTION_END: case LOK_CALLBACK_TEXT_SELECTION: case LOK_CALLBACK_GRAPHIC_SELECTION: case LOK_CALLBACK_GRAPHIC_VIEW_SELECTION: case LOK_CALLBACK_MOUSE_POINTER: case LOK_CALLBACK_CELL_CURSOR: case LOK_CALLBACK_CELL_VIEW_CURSOR: case LOK_CALLBACK_CELL_FORMULA: case LOK_CALLBACK_CURSOR_VISIBLE: case LOK_CALLBACK_VIEW_CURSOR_VISIBLE: case LOK_CALLBACK_SET_PART: case LOK_CALLBACK_STATUS_INDICATOR_SET_VALUE: removeAllButLast(type, false); break; // These come with rects, so drop earlier // only when the latter includes former ones. case LOK_CALLBACK_INVALIDATE_VISIBLE_CURSOR: case LOK_CALLBACK_INVALIDATE_VIEW_CURSOR: case LOK_CALLBACK_INVALIDATE_TILES: if (payload.empty()) { // Invalidating everything means previously // invalidated tiles can be dropped. removeAllButLast(type, false); } else { removeAllButLast(type, true); } break; } lock.unlock(); if (!IsActive()) { Start(); } } void CallbackFlushHandler::setPartTilePainting(const bool bPartPainting) { m_bPartTilePainting = bPartPainting; } bool CallbackFlushHandler::isPartTilePainting() const { return m_bPartTilePainting; } void CallbackFlushHandler::flush() { if (m_pCallback) { std::unique_lock lock(m_mutex); for (auto& pair : m_queue) { m_pCallback(pair.first, pair.second.c_str(), m_pData); } m_queue.clear(); } } void CallbackFlushHandler::removeAllButLast(const int type, const bool identical) { int i = m_queue.size() - 1; std::string payload; for (; i >= 0; --i) { if (m_queue[i].first == type) { payload = m_queue[i].second; //SAL_WARN("lokevt", "Found [" + std::to_string(type) + "] at " + std::to_string(i) + ": [" + payload + "]."); break; } } for (--i; i >= 0; --i) { if (m_queue[i].first == type && (!identical || m_queue[i].second == payload)) { //SAL_WARN("lokevt", "Removing [" + std::to_string(type) + "] at " + std::to_string(i) + ": " + m_queue[i].second + "]."); m_queue.erase(m_queue.begin() + i); } } } static void doc_destroy(LibreOfficeKitDocument *pThis) { LibLODocument_Impl *pDocument = static_cast(pThis); delete pDocument; } static void lo_destroy (LibreOfficeKit* pThis); static int lo_initialize (LibreOfficeKit* pThis, const char* pInstallPath, const char* pUserProfilePath); static LibreOfficeKitDocument* lo_documentLoad (LibreOfficeKit* pThis, const char* pURL); static char * lo_getError (LibreOfficeKit* pThis); static void lo_freeError (char* pFree); static LibreOfficeKitDocument* lo_documentLoadWithOptions (LibreOfficeKit* pThis, const char* pURL, const char* pOptions); static void lo_registerCallback (LibreOfficeKit* pThis, LibreOfficeKitCallback pCallback, void* pData); static char* lo_getFilterTypes(LibreOfficeKit* pThis); static void lo_setOptionalFeatures(LibreOfficeKit* pThis, uint64_t features); static void lo_setDocumentPassword(LibreOfficeKit* pThis, const char* pURL, const char* pPassword); static char* lo_getVersionInfo(LibreOfficeKit* pThis); LibLibreOffice_Impl::LibLibreOffice_Impl() : m_pOfficeClass( gOfficeClass.lock() ) , maThread(nullptr) , mpCallback(nullptr) , mpCallbackData(nullptr) , mOptionalFeatures(0) { if(!m_pOfficeClass) { m_pOfficeClass.reset(new LibreOfficeKitClass); m_pOfficeClass->nSize = sizeof(LibreOfficeKitClass); m_pOfficeClass->destroy = lo_destroy; m_pOfficeClass->documentLoad = lo_documentLoad; m_pOfficeClass->getError = lo_getError; m_pOfficeClass->freeError = lo_freeError; m_pOfficeClass->documentLoadWithOptions = lo_documentLoadWithOptions; m_pOfficeClass->registerCallback = lo_registerCallback; m_pOfficeClass->getFilterTypes = lo_getFilterTypes; m_pOfficeClass->setOptionalFeatures = lo_setOptionalFeatures; m_pOfficeClass->setDocumentPassword = lo_setDocumentPassword; m_pOfficeClass->getVersionInfo = lo_getVersionInfo; gOfficeClass = m_pOfficeClass; } pClass = m_pOfficeClass.get(); } LibLibreOffice_Impl::~LibLibreOffice_Impl() { } namespace { ITiledRenderable* getTiledRenderable(LibreOfficeKitDocument* pThis) { LibLODocument_Impl* pDocument = static_cast(pThis); return dynamic_cast(pDocument->mxComponent.get()); } } // anonymous namespace // Wonder global state ... static uno::Reference xContext; static uno::Reference xSFactory; static uno::Reference xFactory; static LibreOfficeKitDocument* lo_documentLoad(LibreOfficeKit* pThis, const char* pURL) { return lo_documentLoadWithOptions(pThis, pURL, nullptr); } static LibreOfficeKitDocument* lo_documentLoadWithOptions(LibreOfficeKit* pThis, const char* pURL, const char* pOptions) { LibLibreOffice_Impl* pLib = static_cast(pThis); SolarMutexGuard aGuard; OUString aURL(getAbsoluteURL(pURL)); if (aURL.isEmpty()) { pLib->maLastExceptionMsg = "Filename to load was not provided."; SAL_INFO("lok", "URL for load is empty"); return nullptr; } pLib->maLastExceptionMsg.clear(); if (!xContext.is()) { pLib->maLastExceptionMsg = "ComponentContext is not available"; SAL_INFO("lok", "ComponentContext is not available"); return nullptr; } uno::Reference xComponentLoader = frame::Desktop::create(xContext); if (!xComponentLoader.is()) { pLib->maLastExceptionMsg = "ComponentLoader is not available"; SAL_INFO("lok", "ComponentLoader is not available"); return nullptr; } try { uno::Sequence aFilterOptions(2); aFilterOptions[0] = css::beans::PropertyValue( OUString("FilterOptions"), 0, uno::makeAny(OUString::createFromAscii(pOptions)), beans::PropertyState_DIRECT_VALUE); rtl::Reference const pInteraction( new LOKInteractionHandler(::comphelper::getProcessComponentContext(), "load", pLib)); auto const pair(pLib->mInteractionMap.insert(std::make_pair(aURL.toUtf8(), pInteraction))); comphelper::ScopeGuard const g([&] () { if (pair.second) { pLib->mInteractionMap.erase(aURL.toUtf8()); } }); uno::Reference const xInteraction(pInteraction.get()); aFilterOptions[1].Name = "InteractionHandler"; aFilterOptions[1].Value <<= xInteraction; /* TODO sal_Int16 nMacroExecMode = document::MacroExecMode::USE_CONFIG; aFilterOptions[2].Name = "MacroExecutionMode"; aFilterOptions[2].Value <<= nMacroExecMode; sal_Int16 nUpdateDoc = document::UpdateDocMode::ACCORDING_TO_CONFIG; aFilterOptions[3].Name = "UpdateDocMode"; aFilterOptions[3].Value <<= nUpdateDoc; */ uno::Reference xComponent; xComponent = xComponentLoader->loadComponentFromURL( aURL, "_blank", 0, aFilterOptions); assert(!xComponent.is() || pair.second); // concurrent loading of same URL ought to fail if (!xComponent.is()) { pLib->maLastExceptionMsg = "loadComponentFromURL returned an empty reference"; SAL_INFO("lok", "Document can't be loaded - " << pLib->maLastExceptionMsg); return nullptr; } return new LibLODocument_Impl(xComponent); } catch (const uno::Exception& exception) { pLib->maLastExceptionMsg = exception.Message; SAL_INFO("lok", "Document can't be loaded - exception: " << exception.Message); } return nullptr; } static void lo_registerCallback (LibreOfficeKit* pThis, LibreOfficeKitCallback pCallback, void* pData) { LibLibreOffice_Impl* pLib = static_cast(pThis); pLib->mpCallback = pCallback; pLib->mpCallbackData = pData; } static int doc_saveAs(LibreOfficeKitDocument* pThis, const char* sUrl, const char* pFormat, const char* pFilterOptions) { LibLODocument_Impl* pDocument = static_cast(pThis); OUString sFormat = getUString(pFormat); OUString aURL(getAbsoluteURL(sUrl)); if (aURL.isEmpty()) { gImpl->maLastExceptionMsg = "Filename to save to was not provided."; SAL_INFO("lok", "URL for save is empty"); return false; } try { const ExtensionMap* pMap; switch (doc_getDocumentType(pThis)) { case LOK_DOCTYPE_SPREADSHEET: pMap = aCalcExtensionMap; break; case LOK_DOCTYPE_PRESENTATION: pMap = aImpressExtensionMap; break; case LOK_DOCTYPE_DRAWING: pMap = aDrawExtensionMap; break; case LOK_DOCTYPE_TEXT: pMap = aWriterExtensionMap; break; case LOK_DOCTYPE_OTHER: default: SAL_INFO("lok", "Can't save document - unsopported 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 { gImpl->maLastExceptionMsg = "input filename without a suffix"; return false; } } OUString aFilterName; for (sal_Int32 i = 0; pMap[i].extn; ++i) { if (sFormat.equalsIgnoreAsciiCaseAscii(pMap[i].extn)) { aFilterName = getUString(pMap[i].filterName); break; } } if (aFilterName.isEmpty()) { gImpl->maLastExceptionMsg = "no output filter found for provided suffix"; return false; } OUString aFilterOptions = getUString(pFilterOptions); // '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. bool bTakeOwnership = false; int nIndex = -1; if (aFilterOptions == "TakeOwnership") { bTakeOwnership = true; aFilterOptions.clear(); } else if ((nIndex = aFilterOptions.indexOf(",TakeOwnership")) >= 0 || (nIndex = aFilterOptions.indexOf("TakeOwnership,")) >= 0) { OUString aFiltered; if (nIndex > 0) aFiltered = aFilterOptions.copy(0, nIndex); if (nIndex + 14 < aFilterOptions.getLength()) aFiltered = aFiltered + aFilterOptions.copy(nIndex + 14); bTakeOwnership = true; aFilterOptions = aFiltered; } MediaDescriptor aSaveMediaDescriptor; aSaveMediaDescriptor["Overwrite"] <<= true; aSaveMediaDescriptor["FilterName"] <<= aFilterName; aSaveMediaDescriptor[MediaDescriptor::PROP_FILTEROPTIONS()] <<= aFilterOptions; // add interaction handler too if (gImpl) { // gImpl does not have to exist when running from a unit test rtl::Reference const pInteraction( new LOKInteractionHandler(::comphelper::getProcessComponentContext(), "saveas", gImpl, pDocument)); uno::Reference const xInteraction(pInteraction.get()); aSaveMediaDescriptor[MediaDescriptor::PROP_INTERACTIONHANDLER()] <<= xInteraction; } uno::Reference xStorable(pDocument->mxComponent, uno::UNO_QUERY_THROW); if (bTakeOwnership) xStorable->storeAsURL(aURL, aSaveMediaDescriptor.getAsConstPropertyValueList()); else xStorable->storeToURL(aURL, aSaveMediaDescriptor.getAsConstPropertyValueList()); return true; } catch (const uno::Exception& exception) { gImpl->maLastExceptionMsg = "exception: " + exception.Message; } return false; } static void doc_iniUnoCommands () { OUString sUnoCommands[] = { OUString(".uno:BackColor"), OUString(".uno:BackgroundColor"), OUString(".uno:Bold"), OUString(".uno:CenterPara"), OUString(".uno:CharBackColor"), OUString(".uno:CharBackgroundExt"), OUString(".uno:CharFontName"), OUString(".uno:Color"), OUString(".uno:DecrementIndent"), OUString(".uno:DefaultBullet"), OUString(".uno:DefaultNumbering"), OUString(".uno:FontColor"), OUString(".uno:FontHeight"), OUString(".uno:IncrementIndent"), OUString(".uno:Italic"), OUString(".uno:JustifyPara"), OUString(".uno:OutlineFont"), OUString(".uno:LeftPara"), OUString(".uno:RightPara"), OUString(".uno:Shadowed"), OUString(".uno:SubScript"), OUString(".uno:SuperScript"), OUString(".uno:Strikeout"), OUString(".uno:StyleApply"), OUString(".uno:Underline"), OUString(".uno:ModifiedStatus"), OUString(".uno:Undo"), OUString(".uno:Redo"), OUString(".uno:InsertPage"), OUString(".uno:DeletePage"), OUString(".uno:DuplicatePage"), OUString(".uno:Cut"), OUString(".uno:Copy"), OUString(".uno:Paste"), OUString(".uno:SelectAll"), OUString(".uno:InsertAnnotation"), OUString(".uno:InsertRowsBefore"), OUString(".uno:InsertRowsAfter"), OUString(".uno:InsertColumnsBefore"), OUString(".uno:InsertColumnsAfter"), OUString(".uno:DeleteRows"), OUString(".uno:DeleteColumns"), OUString(".uno:DeleteTable"), OUString(".uno:SelectTable"), OUString(".uno:EntireRow"), OUString(".uno:EntireColumn"), OUString(".uno:EntireCell"), OUString(".uno:MergeCells"), OUString(".uno:AssignLayout"), OUString(".uno:StatusDocPos"), OUString(".uno:RowColSelCount"), OUString(".uno:StatusPageStyle"), OUString(".uno:InsertMode"), OUString(".uno:StatusSelectionMode"), OUString(".uno:StateTableCell"), OUString(".uno:StatusBarFunc"), OUString(".uno:StatePageNumber"), OUString(".uno:StateWordCount"), OUString(".uno:SelectionMode"), OUString(".uno:PageStatus"), OUString(".uno:LayoutStatus"), OUString(".uno:Context"), OUString(".uno:WrapText"), OUString(".uno:ToggleMergeCells"), OUString(".uno:NumberFormatCurrency"), OUString(".uno:NumberFormatPercent"), OUString(".uno:NumberFormatDate"), OUString(".uno:SortAscending"), OUString(".uno:SortDescending"), OUString(".uno:TrackChanges"), }; util::URL aCommandURL; SfxViewShell* pViewShell = SfxViewShell::Current(); SfxViewFrame* pViewFrame = pViewShell? pViewShell->GetViewFrame(): nullptr; // check if Frame-Controller were created. if (!pViewShell && !pViewFrame) { SAL_WARN("lok", "iniUnoCommands: No Frame-Controller created."); return; } if (!xContext.is()) xContext = comphelper::getProcessComponentContext(); if (!xContext.is()) { SAL_WARN("lok", "iniUnoCommands: Component context is not available"); return; } SfxSlotPool& rSlotPool = SfxSlotPool::GetSlotPool(pViewFrame); uno::Reference xParser(util::URLTransformer::create(xContext)); for (const auto & sUnoCommand : sUnoCommands) { const SfxSlot* pSlot = nullptr; aCommandURL.Complete = sUnoCommand; xParser->parseStrict(aCommandURL); pSlot = rSlotPool.GetUnoSlot(aCommandURL.Path); // when null, this command is not supported by the given component // (like eg. Calc does not have ".uno:DefaultBullet" etc.) if (pSlot) { // Initialize slot to dispatch .uno: Command. pViewFrame->GetBindings().GetDispatch(pSlot, aCommandURL, false); } } } static int doc_getDocumentType (LibreOfficeKitDocument* pThis) { LibLODocument_Impl* pDocument = static_cast(pThis); try { uno::Reference xDocument(pDocument->mxComponent, uno::UNO_QUERY_THROW); if (xDocument->supportsService("com.sun.star.sheet.SpreadsheetDocument")) { return LOK_DOCTYPE_SPREADSHEET; } else if (xDocument->supportsService("com.sun.star.presentation.PresentationDocument")) { return LOK_DOCTYPE_PRESENTATION; } else if (xDocument->supportsService("com.sun.star.drawing.DrawingDocument")) { return LOK_DOCTYPE_DRAWING; } else if (xDocument->supportsService("com.sun.star.text.TextDocument") || xDocument->supportsService("com.sun.star.text.WebDocument")) { return LOK_DOCTYPE_TEXT; } else { gImpl->maLastExceptionMsg = "unknown document type"; } } catch (const uno::Exception& exception) { gImpl->maLastExceptionMsg = "exception: " + exception.Message; } return LOK_DOCTYPE_OTHER; } static int doc_getParts (LibreOfficeKitDocument* pThis) { ITiledRenderable* pDoc = getTiledRenderable(pThis); if (!pDoc) { gImpl->maLastExceptionMsg = "Document doesn't support tiled rendering"; return 0; } return pDoc->getParts(); } static int doc_getPart (LibreOfficeKitDocument* pThis) { ITiledRenderable* pDoc = getTiledRenderable(pThis); if (!pDoc) { gImpl->maLastExceptionMsg = "Document doesn't support tiled rendering"; return 0; } return pDoc->getPart(); } static void doc_setPart(LibreOfficeKitDocument* pThis, int nPart) { ITiledRenderable* pDoc = getTiledRenderable(pThis); if (!pDoc) { gImpl->maLastExceptionMsg = "Document doesn't support tiled rendering"; return; } SolarMutexGuard aGuard; pDoc->setPart( nPart ); } static char* doc_getPartPageRectangles(LibreOfficeKitDocument* pThis) { ITiledRenderable* pDoc = getTiledRenderable(pThis); if (!pDoc) { gImpl->maLastExceptionMsg = "Document doesn't support tiled rendering"; return nullptr; } OUString sRectangles = pDoc->getPartPageRectangles(); OString aString = OUStringToOString(sRectangles, RTL_TEXTENCODING_UTF8); char* pMemory = static_cast(malloc(aString.getLength() + 1)); strcpy(pMemory, aString.getStr()); return pMemory; } static char* doc_getPartName(LibreOfficeKitDocument* pThis, int nPart) { ITiledRenderable* pDoc = getTiledRenderable(pThis); if (!pDoc) { gImpl->maLastExceptionMsg = "Document doesn't support tiled rendering"; return nullptr; } OUString sName = pDoc->getPartName( nPart ); OString aString = OUStringToOString(sName, RTL_TEXTENCODING_UTF8); char* pMemory = static_cast(malloc(aString.getLength() + 1)); strcpy(pMemory, aString.getStr()); return pMemory; } static char* doc_getPartHash(LibreOfficeKitDocument* pThis, int nPart) { ITiledRenderable* pDoc = getTiledRenderable(pThis); if (!pDoc) { gImpl->maLastExceptionMsg = "Document doesn't support tiled rendering"; return nullptr; } OUString sHash = pDoc->getPartHash(nPart); OString aString = OUStringToOString(sHash, RTL_TEXTENCODING_UTF8); char* pMemory = static_cast(malloc(aString.getLength() + 1)); strcpy(pMemory, aString.getStr()); return pMemory; } static void doc_setPartMode(LibreOfficeKitDocument* pThis, int nPartMode) { ITiledRenderable* pDoc = getTiledRenderable(pThis); if (!pDoc) { gImpl->maLastExceptionMsg = "Document doesn't support tiled rendering"; return; } SolarMutexGuard aGuard; int nCurrentPart = pDoc->getPart(); pDoc->setPartMode(nPartMode); // We need to make sure the internal state is updated, just changing the mode // might not update the relevant shells (i.e. impress will keep rendering the // previous mode unless we do this). // TODO: we might want to do this within the relevant components rather than // here, but that's also dependent on how we implement embedded object // rendering I guess? // TODO: we could be clever and e.g. set to 0 when we change to/from // embedded object mode, and not when changing between slide/notes/combined // modes? if ( nCurrentPart < pDoc->getParts() ) { pDoc->setPart( nCurrentPart ); } else { pDoc->setPart( 0 ); } } void doc_paintTile(LibreOfficeKitDocument* pThis, unsigned char* pBuffer, const int nCanvasWidth, const int nCanvasHeight, const int nTilePosX, const int nTilePosY, const int nTileWidth, const int nTileHeight) { SAL_INFO( "lok.tiledrendering", "paintTile: painting [" << nTileWidth << "x" << nTileHeight << "]@(" << nTilePosX << ", " << nTilePosY << ") to [" << nCanvasWidth << "x" << nCanvasHeight << "]px" ); ITiledRenderable* pDoc = getTiledRenderable(pThis); if (!pDoc) { gImpl->maLastExceptionMsg = "Document doesn't support tiled rendering"; return; } SolarMutexGuard aGuard; #if defined(UNX) && !defined(MACOSX) && !defined(ENABLE_HEADLESS) #if defined(IOS) SystemGraphicsData aData; aData.rCGContext = reinterpret_cast(pBuffer); // the Size argument is irrelevant, I hope ScopedVclPtrInstance pDevice(&aData, Size(1, 1), DeviceFormat::DEFAULT); pDoc->paintTile(*pDevice.get(), nCanvasWidth, nCanvasHeight, nTilePosX, nTilePosY, nTileWidth, nTileHeight); #else ScopedVclPtrInstance< VirtualDevice > pDevice(nullptr, Size(1, 1), DeviceFormat::DEFAULT) ; #if !defined(ANDROID) // Set background to transparent by default. pDevice->SetBackground(Wallpaper(Color(COL_TRANSPARENT))); #endif pDevice->SetOutputSizePixelScaleOffsetAndBuffer( Size(nCanvasWidth, nCanvasHeight), Fraction(1.0), Point(), pBuffer); pDoc->paintTile(*pDevice.get(), nCanvasWidth, nCanvasHeight, nTilePosX, nTilePosY, nTileWidth, nTileHeight); static bool bDebug = getenv("LOK_DEBUG") != 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. Rectangle aRect(0, 0, 5, 5); aRect = pDevice->PixelToLogic(aRect); pDevice->Push(PushFlags::FILLCOLOR | PushFlags::LINECOLOR); pDevice->SetFillColor(COL_LIGHTRED); pDevice->SetLineColor(); pDevice->DrawRect(aRect); pDevice->Pop(); } #endif #else (void) pBuffer; (void) nCanvasWidth; (void) nCanvasHeight; (void) nTilePosX; (void) nTilePosY; (void) nTileWidth; (void) nTileHeight; #endif } void doc_paintPartTile(LibreOfficeKitDocument* pThis, unsigned char* pBuffer, const int nPart, const int nCanvasWidth, const int nCanvasHeight, const int nTilePosX, const int nTilePosY, const int nTileWidth, const int nTileHeight) { SAL_INFO( "lok.tiledrendering", "paintPartTile: painting @ " << nPart << " [" << nTileWidth << "x" << nTileHeight << "]@(" << nTilePosX << ", " << nTilePosY << ") to [" << nCanvasWidth << "x" << nCanvasHeight << "]px" ); // Disable callbacks while we are painting. LibLODocument_Impl* pDocument = static_cast(pThis); std::size_t nView = SfxLokHelper::getView(); pDocument->mpCallbackFlushHandlers[nView]->setPartTilePainting(true); try { // Text documents have a single coordinate system; don't change part. int nOrigPart = 0; const bool isText = (doc_getDocumentType(pThis) == LOK_DOCTYPE_TEXT); if (!isText) { nOrigPart = doc_getPart(pThis); if (nPart != nOrigPart) { doc_setPart(pThis, nPart); } } doc_paintTile(pThis, pBuffer, nCanvasWidth, nCanvasHeight, nTilePosX, nTilePosY, nTileWidth, nTileHeight); if (!isText && nPart != nOrigPart) { doc_setPart(pThis, nOrigPart); } } catch (const std::exception&) { // Nothing to do but restore the PartTilePainting flag. } pDocument->mpCallbackFlushHandlers[nView]->setPartTilePainting(false); } static int doc_getTileMode(LibreOfficeKitDocument* /*pThis*/) { return LOK_TILEMODE_BGRA; } static void doc_getDocumentSize(LibreOfficeKitDocument* pThis, long* pWidth, long* pHeight) { ITiledRenderable* pDoc = getTiledRenderable(pThis); if (pDoc) { Size aDocumentSize = pDoc->getDocumentSize(); *pWidth = aDocumentSize.Width(); *pHeight = aDocumentSize.Height(); } else { gImpl->maLastExceptionMsg = "Document doesn't support tiled rendering"; } } static void doc_initializeForRendering(LibreOfficeKitDocument* pThis, const char* pArguments) { ITiledRenderable* pDoc = getTiledRenderable(pThis); if (pDoc) { doc_iniUnoCommands(); pDoc->initializeForTiledRendering( comphelper::containerToSequence(jsonToPropertyValuesVector(pArguments))); } } static void doc_registerCallback(LibreOfficeKitDocument* pThis, LibreOfficeKitCallback pCallback, void* pData) { SolarMutexGuard aGuard; LibLODocument_Impl* pDocument = static_cast(pThis); std::size_t nView = SfxLokHelper::getView(); pDocument->mpCallbackFlushHandlers[nView].reset(new CallbackFlushHandler(pThis, pCallback, pData)); if (SfxViewShell* pViewShell = SfxViewFrame::Current()->GetViewShell()) pViewShell->registerLibreOfficeKitViewCallback(CallbackFlushHandler::callback, pDocument->mpCallbackFlushHandlers[nView].get()); } static void doc_postKeyEvent(LibreOfficeKitDocument* pThis, int nType, int nCharCode, int nKeyCode) { ITiledRenderable* pDoc = getTiledRenderable(pThis); if (!pDoc) { gImpl->maLastExceptionMsg = "Document doesn't support tiled rendering"; return; } pDoc->postKeyEvent(nType, nCharCode, nKeyCode); } /** Class to react on finishing of a dispatched command. This will call a LOK_COMMAND_FINISHED callback when postUnoCommand was called with the parameter requesting the notification. @see LibreOfficeKitCallbackType::LOK_CALLBACK_UNO_COMMAND_RESULT. */ class DispatchResultListener : public cppu::WeakImplHelper { OString maCommand; ///< Command for which this is the result. std::shared_ptr mpCallback; ///< Callback to call. public: DispatchResultListener(const char* pCommand, std::shared_ptr& pCallback) : maCommand(pCommand) , mpCallback(pCallback) { assert(mpCallback); } virtual void SAL_CALL dispatchFinished(const css::frame::DispatchResultEvent& rEvent) throw(css::uno::RuntimeException, std::exception) override { boost::property_tree::ptree aTree; aTree.put("commandName", maCommand.getStr()); if (rEvent.State != frame::DispatchResultState::DONTKNOW) { bool bSuccess = (rEvent.State == frame::DispatchResultState::SUCCESS); aTree.put("success", bSuccess); } // TODO UNO Any rEvent.Result -> JSON // aTree.put("result": "..."); std::stringstream aStream; boost::property_tree::write_json(aStream, aTree); OString aPayload = aStream.str().c_str(); mpCallback->queue(LOK_CALLBACK_UNO_COMMAND_RESULT, aPayload.getStr()); } virtual void SAL_CALL disposing(const css::lang::EventObject&) throw (css::uno::RuntimeException, std::exception) override {} }; static void doc_postUnoCommand(LibreOfficeKitDocument* pThis, const char* pCommand, const char* pArguments, bool bNotifyWhenFinished) { SfxObjectShell* pDocSh = SfxObjectShell::Current(); OUString aCommand(pCommand, strlen(pCommand), RTL_TEXTENCODING_UTF8); LibLODocument_Impl* pDocument = static_cast(pThis); std::vector aPropertyValuesVector(jsonToPropertyValuesVector(pArguments)); std::size_t nView = SfxLokHelper::getView(); // handle potential interaction if (gImpl && aCommand == ".uno:Save") { rtl::Reference const pInteraction( new LOKInteractionHandler(::comphelper::getProcessComponentContext(), "save", gImpl, pDocument)); uno::Reference const xInteraction(pInteraction.get()); beans::PropertyValue aValue; aValue.Name = "InteractionHandler"; aValue.Value <<= xInteraction; aPropertyValuesVector.push_back(aValue); // Check if DontSaveIfUnmodified is specified bool bDontSaveIfUnmodified = false; auto it = aPropertyValuesVector.begin(); while (it != aPropertyValuesVector.end()) { if (it->Name == "DontSaveIfUnmodified") { bDontSaveIfUnmodified = it->Value.get(); // Also remove this param before handling to core it = aPropertyValuesVector.erase(it); } else it++; } // skip saving and tell the result via UNO_COMMAND_RESULT if (bDontSaveIfUnmodified && !pDocSh->IsModified()) { boost::property_tree::ptree aTree; aTree.put("commandName", pCommand); aTree.put("success", false); // Add the reason for not saving const uno::Any aResultValue = uno::makeAny(OUString("unmodified")); aTree.add_child("result", unoAnyToPropertyTree(aResultValue)); std::stringstream aStream; boost::property_tree::write_json(aStream, aTree); pDocument->mpCallbackFlushHandlers[nView]->queue(LOK_CALLBACK_UNO_COMMAND_RESULT, strdup(aStream.str().c_str())); return; } } bool bResult = false; if (bNotifyWhenFinished && pDocument->mpCallbackFlushHandlers[nView]) { bResult = comphelper::dispatchCommand(aCommand, comphelper::containerToSequence(aPropertyValuesVector), new DispatchResultListener(pCommand, pDocument->mpCallbackFlushHandlers[nView])); } else bResult = comphelper::dispatchCommand(aCommand, comphelper::containerToSequence(aPropertyValuesVector)); if (!bResult) { gImpl->maLastExceptionMsg = "Failed to dispatch the .uno: command"; } } static void doc_postMouseEvent(LibreOfficeKitDocument* pThis, int nType, int nX, int nY, int nCount, int nButtons, int nModifier) { ITiledRenderable* pDoc = getTiledRenderable(pThis); if (!pDoc) { gImpl->maLastExceptionMsg = "Document doesn't support tiled rendering"; return; } pDoc->postMouseEvent(nType, nX, nY, nCount, nButtons, nModifier); Pointer aPointer = pDoc->getPointer(); // We don't map all possible pointers hence we need a default OString aPointerString = "default"; auto aIt = aPointerMap.find(aPointer.GetStyle()); if (aIt != aPointerMap.end()) { aPointerString = aIt->second; } LibLODocument_Impl* pLib = static_cast(pThis); std::size_t nView = SfxLokHelper::getView(); if (pLib->mpCallbackFlushHandlers[nView]) { pLib->mpCallbackFlushHandlers[nView]->queue(LOK_CALLBACK_MOUSE_POINTER, aPointerString.getStr()); } } static void doc_setTextSelection(LibreOfficeKitDocument* pThis, int nType, int nX, int nY) { ITiledRenderable* pDoc = getTiledRenderable(pThis); if (!pDoc) { gImpl->maLastExceptionMsg = "Document doesn't support tiled rendering"; return; } pDoc->setTextSelection(nType, nX, nY); } static char* doc_getTextSelection(LibreOfficeKitDocument* pThis, const char* pMimeType, char** pUsedMimeType) { ITiledRenderable* pDoc = getTiledRenderable(pThis); if (!pDoc) { gImpl->maLastExceptionMsg = "Document doesn't support tiled rendering"; return nullptr; } OString aUsedMimeType; OString aRet = pDoc->getTextSelection(pMimeType, aUsedMimeType); if (aUsedMimeType.isEmpty()) aRet = pDoc->getTextSelection("text/plain;charset=utf-8", aUsedMimeType); char* pMemory = static_cast(malloc(aRet.getLength() + 1)); strcpy(pMemory, aRet.getStr()); if (pUsedMimeType) { *pUsedMimeType = static_cast(malloc(aUsedMimeType.getLength() + 1)); strcpy(*pUsedMimeType, aUsedMimeType.getStr()); } return pMemory; } static bool doc_paste(LibreOfficeKitDocument* pThis, const char* pMimeType, const char* pData, size_t nSize) { ITiledRenderable* pDoc = getTiledRenderable(pThis); if (!pDoc) { gImpl->maLastExceptionMsg = "Document doesn't support tiled rendering"; return false; } uno::Reference xTransferable(new LOKTransferable(pMimeType, pData, nSize)); uno::Reference xClipboard(new LOKClipboard()); xClipboard->setContents(xTransferable, uno::Reference()); pDoc->setClipboard(xClipboard); if (!pDoc->isMimeTypeSupported()) { if (gImpl) gImpl->maLastExceptionMsg = "Document doesn't support this mime type"; return false; } uno::Sequence aPropertyValues(comphelper::InitPropertySequence( { {"AnchorType", uno::makeAny(static_cast(text::TextContentAnchorType_AS_CHARACTER))}, })); if (!comphelper::dispatchCommand(".uno:Paste", aPropertyValues)) { gImpl->maLastExceptionMsg = "Failed to dispatch the .uno: command"; return false; } return true; } static void doc_setGraphicSelection(LibreOfficeKitDocument* pThis, int nType, int nX, int nY) { ITiledRenderable* pDoc = getTiledRenderable(pThis); if (!pDoc) { gImpl->maLastExceptionMsg = "Document doesn't support tiled rendering"; return; } pDoc->setGraphicSelection(nType, nX, nY); } static void doc_resetSelection(LibreOfficeKitDocument* pThis) { ITiledRenderable* pDoc = getTiledRenderable(pThis); if (!pDoc) { gImpl->maLastExceptionMsg = "Document doesn't support tiled rendering"; return; } pDoc->resetSelection(); } static char* getFonts (const char* pCommand) { SfxObjectShell* pDocSh = SfxObjectShell::Current(); const SvxFontListItem* pFonts = static_cast( pDocSh->GetItem(SID_ATTR_CHAR_FONTLIST)); const FontList* pList = pFonts ? pFonts->GetFontList() : nullptr; boost::property_tree::ptree aTree; aTree.put("commandName", pCommand); boost::property_tree::ptree aValues; if ( pList ) { sal_uInt16 nFontCount = pList->GetFontNameCount(); for (sal_uInt16 i = 0; i < nFontCount; ++i) { boost::property_tree::ptree aChildren; const FontMetric& rFontMetric = pList->GetFontName(i); const sal_IntPtr* pAry = pList->GetSizeAry(rFontMetric); sal_uInt16 nSizeCount = 0; while (pAry[nSizeCount]) { boost::property_tree::ptree aChild; aChild.put("", (float)pAry[nSizeCount] / 10); aChildren.push_back(std::make_pair("", aChild)); nSizeCount++; } aValues.add_child(rFontMetric.GetFamilyName().toUtf8().getStr(), aChildren); } } aTree.add_child("commandValues", aValues); std::stringstream aStream; boost::property_tree::write_json(aStream, aTree); char* pJson = static_cast(malloc(aStream.str().size() + 1)); strcpy(pJson, aStream.str().c_str()); pJson[aStream.str().size()] = '\0'; return pJson; } static char* getStyles(LibreOfficeKitDocument* pThis, const char* pCommand) { LibLODocument_Impl* pDocument = static_cast(pThis); boost::property_tree::ptree aTree; aTree.put("commandName", pCommand); uno::Reference xStyleFamiliesSupplier(pDocument->mxComponent, uno::UNO_QUERY); uno::Reference xStyleFamilies(xStyleFamiliesSupplier->getStyleFamilies(), uno::UNO_QUERY); uno::Sequence aStyleFamilies = xStyleFamilies->getElementNames(); static const std::vector aWriterStyles = { "Text body", "Quotations", "Title", "Subtitle", "Heading 1", "Heading 2", "Heading 3" }; // We need to keep a list of the default style names // in order to filter these out later when processing // the full list of styles. std::set aDefaultStyleNames; boost::property_tree::ptree aValues; for (sal_Int32 nStyleFam = 0; nStyleFam < aStyleFamilies.getLength(); ++nStyleFam) { boost::property_tree::ptree aChildren; OUString sStyleFam = aStyleFamilies[nStyleFam]; uno::Reference xStyleFamily(xStyleFamilies->getByName(sStyleFam), uno::UNO_QUERY); // Writer provides a huge number of styles, we have a list of 7 "default" styles which // should be shown in the normal dropdown, which we should add to the start of the list // to simplify their selection. if (sStyleFam == "ParagraphStyles" && doc_getDocumentType(pThis) == LOK_DOCTYPE_TEXT) { for (const OUString& rStyle: aWriterStyles) { aDefaultStyleNames.insert( rStyle ); boost::property_tree::ptree aChild; aChild.put("", rStyle.toUtf8()); aChildren.push_back(std::make_pair("", aChild)); } } uno::Sequence aStyles = xStyleFamily->getElementNames(); for (const OUString& rStyle: aStyles ) { // Filter out the default styles - they are already at the top // of the list if (aDefaultStyleNames.find(rStyle) == aDefaultStyleNames.end() || (sStyleFam != "ParagraphStyles" || doc_getDocumentType(pThis) != LOK_DOCTYPE_TEXT) ) { boost::property_tree::ptree aChild; aChild.put("", rStyle.toUtf8()); aChildren.push_back(std::make_pair("", aChild)); } } aValues.add_child(sStyleFam.toUtf8().getStr(), aChildren); } { boost::property_tree::ptree aCommandList; { boost::property_tree::ptree aChild; OUString sClearFormat = SVX_RESSTR( RID_SVXSTR_CLEARFORM ); boost::property_tree::ptree aName; aName.put("", sClearFormat.toUtf8()); aChild.push_back(std::make_pair("text", aName)); boost::property_tree::ptree aCommand; aCommand.put("", ".uno:ResetAttributes"); aChild.push_back(std::make_pair("id", aCommand)); aCommandList.push_back(std::make_pair("", aChild)); } aValues.add_child("Commands", aCommandList); } aTree.add_child("commandValues", aValues); std::stringstream aStream; boost::property_tree::write_json(aStream, aTree); char* pJson = static_cast(malloc(aStream.str().size() + 1)); strcpy(pJson, aStream.str().c_str()); pJson[aStream.str().size()] = '\0'; return pJson; } enum class UndoOrRedo { UNDO, REDO }; /// Returns the JSON representation of either an undo or a redo stack. static char* getUndoOrRedo(LibreOfficeKitDocument* pThis, UndoOrRedo eCommand) { LibLODocument_Impl* pDocument = static_cast(pThis); auto pBaseModel = dynamic_cast(pDocument->mxComponent.get()); if (!pBaseModel) return nullptr; SfxObjectShell* pObjectShell = pBaseModel->GetObjectShell(); if (!pObjectShell) return nullptr; svl::IUndoManager* pUndoManager = pObjectShell->GetUndoManager(); if (!pUndoManager) return nullptr; OUString aString; if (eCommand == UndoOrRedo::UNDO) aString = pUndoManager->GetUndoActionsInfo(); else aString = pUndoManager->GetRedoActionsInfo(); char* pJson = strdup(aString.toUtf8().getStr()); return pJson; } /// Returns the JSON representation of the redline stack. static char* getTrackedChanges(LibreOfficeKitDocument* pThis) { LibLODocument_Impl* pDocument = static_cast(pThis); uno::Reference xRedlinesSupplier(pDocument->mxComponent, uno::UNO_QUERY); if (!xRedlinesSupplier.is()) return nullptr; uno::Reference xRedlines = xRedlinesSupplier->getRedlines()->createEnumeration(); boost::property_tree::ptree aRedlines; for (size_t nIndex = 0; xRedlines->hasMoreElements(); ++nIndex) { uno::Reference xRedline(xRedlines->nextElement(), uno::UNO_QUERY); boost::property_tree::ptree aRedline; aRedline.put("index", nIndex); OUString sAuthor; xRedline->getPropertyValue("RedlineAuthor") >>= sAuthor; aRedline.put("author", sAuthor.toUtf8().getStr()); OUString sType; xRedline->getPropertyValue("RedlineType") >>= sType; aRedline.put("type", sType.toUtf8().getStr()); OUString sComment; xRedline->getPropertyValue("RedlineComment") >>= sComment; aRedline.put("comment", sComment.toUtf8().getStr()); util::DateTime aDateTime; xRedline->getPropertyValue("RedlineDateTime") >>= aDateTime; OUString sDateTime = utl::toISO8601(aDateTime); aRedline.put("dateTime", sDateTime.toUtf8().getStr()); aRedlines.push_back(std::make_pair("", aRedline)); } boost::property_tree::ptree aTree; aTree.add_child("redlines", aRedlines); std::stringstream aStream; boost::property_tree::write_json(aStream, aTree); char* pJson = strdup(aStream.str().c_str()); return pJson; } static char* doc_getCommandValues(LibreOfficeKitDocument* pThis, const char* pCommand) { SolarMutexGuard aGuard; OString aCommand(pCommand); static const OString aViewRowColumnHeaders(".uno:ViewRowColumnHeaders"); static const OString aCellCursor(".uno:CellCursor"); if (!strcmp(pCommand, ".uno:CharFontName")) { return getFonts(pCommand); } else if (!strcmp(pCommand, ".uno:StyleApply")) { return getStyles(pThis, pCommand); } else if (aCommand == ".uno:Undo") { return getUndoOrRedo(pThis, UndoOrRedo::UNDO); } else if (aCommand == ".uno:Redo") { return getUndoOrRedo(pThis, UndoOrRedo::REDO); } else if (aCommand == ".uno:AcceptTrackedChanges") { return getTrackedChanges(pThis); } else if (aCommand.startsWith(aViewRowColumnHeaders)) { ITiledRenderable* pDoc = getTiledRenderable(pThis); if (!pDoc) { gImpl->maLastExceptionMsg = "Document doesn't support tiled rendering"; return nullptr; } Rectangle aRectangle; if (aCommand.getLength() > aViewRowColumnHeaders.getLength()) { // Command has parameters. int nX = 0; int nY = 0; int nWidth = 0; int nHeight = 0; OString aArguments = aCommand.copy(aViewRowColumnHeaders.getLength() + 1); sal_Int32 nParamIndex = 0; do { OString aParamToken = aArguments.getToken(0, '&', nParamIndex); sal_Int32 nIndex = 0; OString aKey; OString aValue; do { OString aToken = aParamToken.getToken(0, '=', nIndex); if (!aKey.getLength()) aKey = aToken; else aValue = aToken; } while (nIndex >= 0); if (aKey == "x") nX = aValue.toInt32(); else if (aKey == "y") nY = aValue.toInt32(); else if (aKey == "width") nWidth = aValue.toInt32(); else if (aKey == "height") nHeight = aValue.toInt32(); } while (nParamIndex >= 0); aRectangle = Rectangle(nX, nY, nX + nWidth, nY + nHeight); } OUString aHeaders = pDoc->getRowColumnHeaders(aRectangle); OString aString = OUStringToOString(aHeaders, RTL_TEXTENCODING_UTF8); char* pMemory = static_cast(malloc(aString.getLength() + 1)); strcpy(pMemory, aString.getStr()); return pMemory; } else if (aCommand.startsWith(aCellCursor)) { ITiledRenderable* pDoc = getTiledRenderable(pThis); if (!pDoc) { gImpl->maLastExceptionMsg = "Document doesn't support tiled rendering"; return nullptr; } // Command has parameters. int nOutputWidth = 0; int nOutputHeight = 0; long nTileWidth = 0; long nTileHeight = 0; if (aCommand.getLength() > aCellCursor.getLength()) { OString aArguments = aCommand.copy(aCellCursor.getLength() + 1); sal_Int32 nParamIndex = 0; do { OString aParamToken = aArguments.getToken(0, '&', nParamIndex); sal_Int32 nIndex = 0; OString aKey; OString aValue; do { OString aToken = aParamToken.getToken(0, '=', nIndex); if (!aKey.getLength()) aKey = aToken; else aValue = aToken; } while (nIndex >= 0); if (aKey == "outputWidth") nOutputWidth = aValue.toInt32(); else if (aKey == "outputHeight") nOutputHeight = aValue.toInt32(); else if (aKey == "tileWidth") nTileWidth = aValue.toInt64(); else if (aKey == "tileHeight") nTileHeight = aValue.toInt64(); } while (nParamIndex >= 0); } OString aString = pDoc->getCellCursor(nOutputWidth, nOutputHeight, nTileWidth, nTileHeight); char* pMemory = static_cast(malloc(aString.getLength() + 1)); strcpy(pMemory, aString.getStr()); return pMemory; } else { gImpl->maLastExceptionMsg = "Unknown command, no values returned"; return nullptr; } } static void doc_setClientZoom(LibreOfficeKitDocument* pThis, int nTilePixelWidth, int nTilePixelHeight, int nTileTwipWidth, int nTileTwipHeight) { ITiledRenderable* pDoc = getTiledRenderable(pThis); if (!pDoc) { gImpl->maLastExceptionMsg = "Document doesn't support tiled rendering"; return; } pDoc->setClientZoom(nTilePixelWidth, nTilePixelHeight, nTileTwipWidth, nTileTwipHeight); } static void doc_setClientVisibleArea(LibreOfficeKitDocument* pThis, int nX, int nY, int nWidth, int nHeight) { ITiledRenderable* pDoc = getTiledRenderable(pThis); if (!pDoc) { gImpl->maLastExceptionMsg = "Document doesn't support tiled rendering"; return; } Rectangle aRectangle(Point(nX, nY), Size(nWidth, nHeight)); pDoc->setClientVisibleArea(aRectangle); } static int doc_createView(LibreOfficeKitDocument* /*pThis*/) { SolarMutexGuard aGuard; return SfxLokHelper::createView(); } static void doc_destroyView(LibreOfficeKitDocument* /*pThis*/, int nId) { SolarMutexGuard aGuard; SfxLokHelper::destroyView(nId); } static void doc_setView(LibreOfficeKitDocument* /*pThis*/, int nId) { SolarMutexGuard aGuard; SfxLokHelper::setView(nId); } static int doc_getView(LibreOfficeKitDocument* /*pThis*/) { SolarMutexGuard aGuard; return SfxLokHelper::getView(); } static int doc_getViews(LibreOfficeKitDocument* /*pThis*/) { SolarMutexGuard aGuard; return SfxLokHelper::getViews(); } unsigned char* doc_renderFont(LibreOfficeKitDocument* /*pThis*/, const char* pFontName, int* pFontWidth, int* pFontHeight) { OString aSearchedFontName(pFontName); SfxObjectShell* pDocSh = SfxObjectShell::Current(); const SvxFontListItem* pFonts = static_cast( pDocSh->GetItem(SID_ATTR_CHAR_FONTLIST)); const FontList* pList = pFonts ? pFonts->GetFontList() : nullptr; if ( pList ) { sal_uInt16 nFontCount = pList->GetFontNameCount(); for (sal_uInt16 i = 0; i < nFontCount; ++i) { const FontMetric& rFontMetric = pList->GetFontName(i); const OUString& aFontName = rFontMetric.GetFamilyName(); if (!aSearchedFontName.equals(aFontName.toUtf8().getStr())) continue; auto aDevice( VclPtr::Create( nullptr, Size(1, 1), DeviceFormat::DEFAULT)); ::Rectangle aRect; vcl::Font aFont(rFontMetric); aFont.SetFontSize(Size(0, 25)); aDevice->SetFont(aFont); aDevice->GetTextBoundRect(aRect, aFontName); int nFontWidth = aRect.BottomRight().X() + 1; *pFontWidth = nFontWidth; int nFontHeight = aRect.BottomRight().Y() + 1; *pFontHeight = nFontHeight; unsigned char* pBuffer = static_cast(malloc(4 * nFontWidth * nFontHeight)); memset(pBuffer, 0, nFontWidth * nFontHeight * 4); aDevice->SetBackground(Wallpaper(COL_TRANSPARENT)); aDevice->SetOutputSizePixelScaleOffsetAndBuffer( Size(nFontWidth, nFontHeight), Fraction(1.0), Point(), pBuffer); aDevice->DrawText(Point(0,0), aFontName); return pBuffer; } } return nullptr; } static char* lo_getError (LibreOfficeKit *pThis) { LibLibreOffice_Impl* pLib = static_cast(pThis); OString aString = OUStringToOString(pLib->maLastExceptionMsg, RTL_TEXTENCODING_UTF8); char* pMemory = static_cast(malloc(aString.getLength() + 1)); strcpy(pMemory, aString.getStr()); return pMemory; } static void lo_freeError(char* pFree) { free(pFree); } static char* lo_getFilterTypes(LibreOfficeKit* pThis) { LibLibreOffice_Impl* pImpl = static_cast(pThis); if (!xSFactory.is()) xSFactory = comphelper::getProcessServiceFactory(); if (!xSFactory.is()) { pImpl->maLastExceptionMsg = "Service factory is not available"; return nullptr; } uno::Reference xTypeDetection(xSFactory->createInstance("com.sun.star.document.TypeDetection"), uno::UNO_QUERY); uno::Sequence aTypes = xTypeDetection->getElementNames(); boost::property_tree::ptree aTree; for (const OUString& rType : aTypes) { uno::Sequence aValues; if (xTypeDetection->getByName(rType) >>= aValues) { auto it = std::find_if(aValues.begin(), aValues.end(), [](const beans::PropertyValue& rValue) { return rValue.Name == "MediaType"; }); OUString aValue; if (it != aValues.end() && (it->Value >>= aValue) && !aValue.isEmpty()) { boost::property_tree::ptree aChild; aChild.put("MediaType", aValue.toUtf8()); aTree.add_child(rType.toUtf8().getStr(), aChild); } } } std::stringstream aStream; boost::property_tree::write_json(aStream, aTree); return strdup(aStream.str().c_str()); } static void lo_setOptionalFeatures(LibreOfficeKit* pThis, uint64_t const features) { LibLibreOffice_Impl *const pLib = static_cast(pThis); pLib->mOptionalFeatures = features; } static void lo_setDocumentPassword(LibreOfficeKit* pThis, const char* pURL, const char* pPassword) { assert(pThis); assert(pURL); LibLibreOffice_Impl *const pLib = static_cast(pThis); assert(pLib->mInteractionMap.find(OString(pURL)) != pLib->mInteractionMap.end()); pLib->mInteractionMap.find(OString(pURL))->second->SetPassword(pPassword); } static char* lo_getVersionInfo(LibreOfficeKit* /*pThis*/) { const OUString sVersionStrTemplate( "{ " "\"ProductName\": \"%PRODUCTNAME\", " "\"ProductVersion\": \"%PRODUCTVERSION\", " "\"ProductExtension\": \"%PRODUCTEXTENSION\", " "\"BuildId\": \"%BUILDID\" " "}" ); const OString sVersionStr = OUStringToOString(ReplaceStringHookProc(sVersionStrTemplate), RTL_TEXTENCODING_UTF8); char* pVersion = static_cast(malloc(sVersionStr.getLength() + 1)); strcpy(pVersion, sVersionStr.getStr()); return pVersion; } static void force_c_locale() { // force locale (and resource files loaded) to en-US OUString aLangISO("en-US"); LanguageTag aLocale(aLangISO); ResMgr::SetDefaultLocale(aLocale); SvtSysLocaleOptions aLocalOptions; aLocalOptions.SetLocaleConfigString(aLangISO); aLocalOptions.SetUILocaleConfigString(aLangISO); } static void aBasicErrorFunc(const OUString& rError, const OUString& rAction) { OStringBuffer aBuffer("Unexpected dialog: "); aBuffer.append(OUStringToOString(rAction, RTL_TEXTENCODING_ASCII_US)); aBuffer.append(" Error: "); aBuffer.append(OUStringToOString(rError, RTL_TEXTENCODING_ASCII_US)); fprintf(stderr, "Unexpected basic error dialog '%s'\n", aBuffer.getStr()); } static bool initialize_uno(const OUString& aAppProgramURL) { #ifdef IOS // For iOS we already hardcode the inifile as "rc" in the .app directory. (void) aAppProgramURL; #elif defined MACOSX rtl::Bootstrap::setIniFilename(aAppProgramURL + "/../Resources/" SAL_CONFIGFILE("soffice")); #else rtl::Bootstrap::setIniFilename(aAppProgramURL + "/" SAL_CONFIGFILE("soffice")); #endif xContext = cppu::defaultBootstrap_InitialComponentContext(); if (!xContext.is()) { gImpl->maLastExceptionMsg = "XComponentContext could not be created"; SAL_INFO("lok", "XComponentContext could not be created"); return false; } xFactory = xContext->getServiceManager(); if (!xFactory.is()) { gImpl->maLastExceptionMsg = "XMultiComponentFactory could not be created"; SAL_INFO("lok", "XMultiComponentFactory could not be created"); return false; } xSFactory.set(xFactory, uno::UNO_QUERY_THROW); comphelper::setProcessServiceFactory(xSFactory); SAL_INFO("lok", "Uno initialized - " << xContext.is()); // set UserInstallation to user profile dir in test/user-template // rtl::Bootstrap aDefaultVars; // aDefaultVars.set(OUString("UserInstallation"), aAppProgramURL + "../registry" ); // configmgr setup ? return true; } static void lo_startmain(void*) { osl_setThreadName("lo_startmain"); if (GetpApp()) Application::GetSolarMutex().tryToAcquire(); soffice_main(); } static bool bInitialized = false; static void lo_status_indicator_callback(void *data, comphelper::LibreOfficeKit::statusIndicatorCallbackType type, int percent) { LibLibreOffice_Impl* pLib = static_cast(data); if (!pLib->mpCallback) return; switch (type) { case comphelper::LibreOfficeKit::statusIndicatorCallbackType::Start: pLib->mpCallback(LOK_CALLBACK_STATUS_INDICATOR_START, nullptr, pLib->mpCallbackData); break; case comphelper::LibreOfficeKit::statusIndicatorCallbackType::SetValue: pLib->mpCallback(LOK_CALLBACK_STATUS_INDICATOR_SET_VALUE, OUString::number(percent).toUtf8().getStr(), pLib->mpCallbackData); break; case comphelper::LibreOfficeKit::statusIndicatorCallbackType::Finish: pLib->mpCallback(LOK_CALLBACK_STATUS_INDICATOR_FINISH, nullptr, pLib->mpCallbackData); break; } } static int lo_initialize(LibreOfficeKit* pThis, const char* pAppPath, const char* pUserProfileUrl) { enum { PRE_INIT, // setup shared data in master process SECOND_INIT, // complete init. after fork FULL_INIT // do a standard complete init. } eStage; // Did we do a pre-initialize static bool bPreInited = false; // What stage are we at ? if (pThis == nullptr) eStage = PRE_INIT; else if (bPreInited) eStage = SECOND_INIT; else eStage = FULL_INIT; LibLibreOffice_Impl* pLib = static_cast(pThis); if (bInitialized) return 1; if (eStage != SECOND_INIT) comphelper::LibreOfficeKit::setActive(); if (eStage != PRE_INIT) comphelper::LibreOfficeKit::setStatusIndicatorCallback(lo_status_indicator_callback, pLib); if (pUserProfileUrl) { OUString url( pUserProfileUrl, strlen(pUserProfileUrl), RTL_TEXTENCODING_UTF8); OUString path; if (url.startsWithIgnoreAsciiCase("vnd.sun.star.pathname:", &path)) { OUString url2; osl::FileBase::RC e = osl::FileBase::getFileURLFromSystemPath( path, url2); if (e == osl::FileBase::E_None) url = url2; else SAL_WARN("lok", "resolving <" << url << "> failed with " << +e); } rtl::Bootstrap::set("UserInstallation", url); if (eStage == SECOND_INIT) utl::Bootstrap::reloadData(); } OUString aAppPath; if (pAppPath) { aAppPath = OUString(pAppPath, strlen(pAppPath), RTL_TEXTENCODING_UTF8); } else { // Fun conversion dance back and forth between URLs and system paths... OUString aAppURL; ::osl::Module::getUrlFromAddress( reinterpret_cast< oslGenericFunction >(lo_initialize), aAppURL); osl::FileBase::getSystemPathFromFileURL( aAppURL, aAppPath ); } OUString aAppURL; if (osl::FileBase::getFileURLFromSystemPath(aAppPath, aAppURL) != osl::FileBase::E_None) return 0; try { if (eStage != SECOND_INIT) { SAL_INFO("lok", "Attempting to initialize UNO"); if (!initialize_uno(aAppURL)) return false; // Force headless -- this is only for bitmap rendering. rtl::Bootstrap::set("SAL_USE_VCLPLUGIN", "svp"); // We specifically need to make sure we have the "headless" // command arg set (various code specifically checks via // CommandLineArgs): desktop::Desktop::GetCommandLineArgs().setHeadless(); Application::EnableHeadlessMode(true); if (eStage == PRE_INIT) { InitVCL(); // pre-load all component libraries. if (!xContext.is()) throw css::uno::DeploymentException("preInit: XComponentContext is not created"); css::uno::Reference< css::uno::XInterface > xService; xContext->getValueByName("/singletons/com.sun.star.lang.theServiceManager") >>= xService; if (!xService.is()) throw css::uno::DeploymentException("preInit: XMultiComponentFactory is not created"); css::uno::Reference aService( xService, css::uno::UNO_QUERY_THROW); // pre-requisites: // In order to load implementations and invoke // component factory it is required: // 1) defaultBootstrap_InitialComponentContext() // 2) comphelper::setProcessServiceFactory(xSFactory); // 3) InitVCL() aService->initialize({css::uno::makeAny("preload")}); // Release Solar Mutex, lo_startmain thread should acquire it. Application::ReleaseSolarMutex(); } force_c_locale(); } // We could use InitVCL() here -- and used to before using soffice_main, // however that now deals with the initialisation for us (and it's not // possible to try to set up VCL twice. // Instead VCL init is done for us by soffice_main in a separate thread, // however we specifically can't proceed until this setup is complete // (or you get segfaults trying to use VCL and/or deadlocks due to other // setup within soffice_main). Specifically the various Application:: // functions depend on VCL being ready -- the deadlocks would happen // if you try to use loadDocument too early. // The RequestHandler is specifically set to be ready when all the other // init in Desktop::Main (run from soffice_main) is done. We can enable // the RequestHandler here (without starting any IPC thread; // shortcutting the invocation in Desktop::Main that would start the IPC // thread), and can then use it to wait until we're definitely ready to // continue. if (eStage != PRE_INIT) { SAL_INFO("lok", "Enabling RequestHandler"); RequestHandler::Enable(false); SAL_INFO("lok", "Starting soffice_main"); pLib->maThread = osl_createThread(lo_startmain, nullptr); SAL_INFO("lok", "Waiting for RequestHandler"); RequestHandler::WaitForReady(); SAL_INFO("lok", "RequestHandler ready -- continuing"); } if (eStage != SECOND_INIT) ErrorHandler::RegisterDisplay(aBasicErrorFunc); SAL_INFO("lok", "LOK Initialized"); if (eStage == PRE_INIT) bPreInited = true; else bInitialized = true; } catch (css::uno::Exception& exception) { fprintf(stderr, "Bootstrapping exception '%s'\n", OUStringToOString(exception.Message, RTL_TEXTENCODING_UTF8).getStr()); } return bInitialized; } // Undo our clever trick of having SAL_DLLPUBLIC_EXPORT actually not // meaning what is says in for the DISABLE_DYNLOADING case. See // . Normally, when building just one big dylib (Android) // or executable (iOS), most of our "public" symbols don't need to be // visible outside that resulting dylib/executable. But // libreofficekit_hook must be exported for dlsym() to find it, // though, at least on iOS. #if defined(__GNUC__) && defined(HAVE_GCC_VISIBILITY_FEATURE) && defined(DISABLE_DYNLOADING) __attribute__ ((visibility("default"))) #else SAL_DLLPUBLIC_EXPORT #endif LibreOfficeKit *libreofficekit_hook_2(const char* install_path, const char* user_profile_path) { if (!gImpl) { SAL_INFO("lok", "Create libreoffice object"); gImpl = new LibLibreOffice_Impl(); if (!lo_initialize(gImpl, install_path, user_profile_path)) { lo_destroy(gImpl); } } return static_cast(gImpl); } #if defined(__GNUC__) && defined(HAVE_GCC_VISIBILITY_FEATURE) && defined(DISABLE_DYNLOADING) __attribute__ ((visibility("default"))) #else SAL_DLLPUBLIC_EXPORT #endif LibreOfficeKit *libreofficekit_hook(const char* install_path) { return libreofficekit_hook_2(install_path, nullptr); } SAL_JNI_EXPORT int lok_preinit(const char* install_path, const char* user_profile_path) { return lo_initialize(nullptr, install_path, user_profile_path); } static void lo_destroy(LibreOfficeKit* pThis) { bool bSuccess = false; LibLibreOffice_Impl* pLib = static_cast(pThis); gImpl = nullptr; SAL_INFO("lok", "LO Destroy"); comphelper::LibreOfficeKit::setStatusIndicatorCallback(nullptr, nullptr); uno::Reference xDesktop = frame::Desktop::create ( ::comphelper::getProcessComponentContext() ); bSuccess = xDesktop.is() && xDesktop->terminate(); if (!bSuccess) { bSuccess = GetpApp() && GetpApp()->QueryExit(); } if (!bSuccess) { Application::Quit(); } osl_joinWithThread(pLib->maThread); osl_destroyThread(pLib->maThread); delete pLib; bInitialized = false; SAL_INFO("lok", "LO Destroy Done"); } } /* vim:set shiftwidth=4 softtabstop=4 expandtab: */