307 lines
8.9 KiB
C++
307 lines
8.9 KiB
C++
/* -*- 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 <cstring>
|
|
#include <fstream>
|
|
#include <iostream>
|
|
#include <memory>
|
|
|
|
#include <png.h>
|
|
|
|
#include <Poco/Util/Application.h>
|
|
#include <Poco/String.h>
|
|
#include <Poco/StringTokenizer.h>
|
|
|
|
#include "LOOLSession.hpp"
|
|
#include "TileCache.hpp"
|
|
|
|
using Poco::Net::WebSocket;
|
|
using Poco::Util::Application;
|
|
using Poco::StringTokenizer;
|
|
|
|
LOOLSession::LOOLSession(WebSocket& ws, LibreOfficeKit *loKit) :
|
|
_haveSeparateProcess(false),
|
|
_ws(ws),
|
|
_loKit(loKit),
|
|
_loKitDocument(NULL)
|
|
{
|
|
}
|
|
|
|
LOOLSession::~LOOLSession()
|
|
{
|
|
_ws.shutdown();
|
|
if (_loKitDocument)
|
|
_loKitDocument->pClass->destroy(_loKitDocument);
|
|
}
|
|
|
|
bool LOOLSession::handleInput(char *buffer, int length)
|
|
{
|
|
Application& app = Application::instance();
|
|
|
|
char *endl = (char *) memchr(buffer, '\n', length);
|
|
std::string commandline;
|
|
if (endl == NULL)
|
|
commandline = std::string(buffer, length);
|
|
else
|
|
commandline = std::string(buffer, endl-buffer);
|
|
|
|
app.logger().information("Command: " + commandline);
|
|
|
|
StringTokenizer tokens(commandline, " ", StringTokenizer::TOK_IGNORE_EMPTY | StringTokenizer::TOK_TRIM);
|
|
|
|
if (tokens[0] == "load")
|
|
{
|
|
if (_loKitDocument)
|
|
{
|
|
app.logger().error("A document is already loaded");
|
|
return false;
|
|
}
|
|
loadDocument(tokens);
|
|
}
|
|
else if (!_loKitDocument)
|
|
{
|
|
sendTextFrame("No document loaded");
|
|
return false;
|
|
}
|
|
else if (tokens[0] == "status")
|
|
{
|
|
sendTextFrame(getStatus());
|
|
}
|
|
else if (tokens[0] == "tile")
|
|
{
|
|
sendTile(tokens);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool LOOLSession::haveSeparateProcess() const
|
|
{
|
|
return _haveSeparateProcess;
|
|
}
|
|
|
|
void LOOLSession::sendTextFrame(std::string text)
|
|
{
|
|
_ws.sendFrame(text.data(), text.size());
|
|
}
|
|
|
|
void LOOLSession::sendBinaryFrame(const char *buffer, int length)
|
|
{
|
|
_ws.sendFrame(buffer, length, WebSocket::FRAME_BINARY);
|
|
}
|
|
|
|
extern "C"
|
|
{
|
|
static void myCallback(int nType, const char* pPayload, void* pData)
|
|
{
|
|
LOOLSession *srv = (LOOLSession *) pData;
|
|
|
|
switch ((LibreOfficeKitCallbackType) nType)
|
|
{
|
|
case LOK_CALLBACK_INVALIDATE_TILES:
|
|
srv->sendTextFrame("invalidatetiles: " + std::string(pPayload));
|
|
break;
|
|
case LOK_CALLBACK_INVALIDATE_VISIBLE_CURSOR:
|
|
srv->sendTextFrame("invalidatecursor:");
|
|
break;
|
|
case LOK_CALLBACK_TEXT_SELECTION:
|
|
srv->sendTextFrame("textselection: " + std::string(pPayload));
|
|
break;
|
|
case LOK_CALLBACK_TEXT_SELECTION_START:
|
|
srv->sendTextFrame("textselectionstart: " + std::string(pPayload));
|
|
break;
|
|
case LOK_CALLBACK_TEXT_SELECTION_END:
|
|
srv->sendTextFrame("textselectionend: " + std::string(pPayload));
|
|
break;
|
|
case LOK_CALLBACK_CURSOR_VISIBLE:
|
|
srv->sendTextFrame("cursorvisible: " + std::string(pPayload));
|
|
break;
|
|
case LOK_CALLBACK_GRAPHIC_SELECTION:
|
|
srv->sendTextFrame("graphicselection: " + std::string(pPayload));
|
|
break;
|
|
case LOK_CALLBACK_HYPERLINK_CLICKED:
|
|
srv->sendTextFrame("hyperlinkclicked: " + std::string(pPayload));
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void LOOLSession::loadDocument(StringTokenizer& tokens)
|
|
{
|
|
if (tokens.count() != 2)
|
|
{
|
|
sendTextFrame("error: cmd=load kind=syntax");
|
|
return;
|
|
}
|
|
|
|
_docURL = tokens[1];
|
|
_tileCache.reset(new TileCache(_docURL));
|
|
|
|
if ((_loKitDocument = _loKit->pClass->documentLoad(_loKit, _docURL.c_str())) != NULL)
|
|
{
|
|
sendTextFrame(getStatus());
|
|
_loKitDocument->pClass->registerCallback(_loKitDocument, myCallback, this);
|
|
}
|
|
}
|
|
|
|
std::string LOOLSession::getStatus()
|
|
{
|
|
LibreOfficeKitDocumentType type = (LibreOfficeKitDocumentType) _loKitDocument->pClass->getDocumentType(_loKitDocument);
|
|
std::string typeString;
|
|
switch (type)
|
|
{
|
|
case LOK_DOCTYPE_TEXT:
|
|
typeString = "text";
|
|
break;
|
|
case LOK_DOCTYPE_SPREADSHEET:
|
|
typeString = "spreadsheet";
|
|
break;
|
|
case LOK_DOCTYPE_PRESENTATION:
|
|
typeString = "presentation";
|
|
break;
|
|
case LOK_DOCTYPE_DRAWING:
|
|
typeString = "drawing";
|
|
break;
|
|
default:
|
|
typeString = "other";
|
|
break;
|
|
}
|
|
long width, height;
|
|
_loKitDocument->pClass->getDocumentSize(_loKitDocument, &width, &height);
|
|
return ("status: type=" + typeString + " "
|
|
"parts=" + std::to_string(_loKitDocument->pClass->getParts(_loKitDocument)) + " "
|
|
"current=" + std::to_string(_loKitDocument->pClass->getPart(_loKitDocument)) + " "
|
|
"width=" + std::to_string(width) + " "
|
|
"height=" + std::to_string(height));
|
|
}
|
|
|
|
namespace {
|
|
bool getTokenInteger(const std::string& token, const std::string& name, int *value)
|
|
{
|
|
size_t nextIdx;
|
|
try
|
|
{
|
|
if (token.size() < name.size() + 2 ||
|
|
token.substr(0, name.size()) != name ||
|
|
token[name.size()] != '=' ||
|
|
(*value = std::stoi(token.substr(name.size() + 1), &nextIdx), false) ||
|
|
nextIdx != token.size() - name.size() - 1)
|
|
{
|
|
throw std::invalid_argument("bah");
|
|
}
|
|
}
|
|
catch (std::invalid_argument&)
|
|
{
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
|
|
// Callback functions for libpng
|
|
|
|
extern "C"
|
|
{
|
|
static void user_write_status_fn(png_structp, png_uint_32, int)
|
|
{
|
|
}
|
|
|
|
static void user_write_fn(png_structp png_ptr, png_bytep data, png_size_t length)
|
|
{
|
|
std::vector<char> *outputp = (std::vector<char> *) png_get_io_ptr(png_ptr);
|
|
size_t oldsize = outputp->size();
|
|
outputp->resize(oldsize + length);
|
|
memcpy(outputp->data() + oldsize, data, length);
|
|
}
|
|
|
|
static void user_flush_fn(png_structp)
|
|
{
|
|
}
|
|
}
|
|
|
|
void LOOLSession::sendTile(StringTokenizer& tokens)
|
|
{
|
|
int width, height, tilePosX, tilePosY, tileWidth, tileHeight;
|
|
|
|
if (tokens.count() != 7 ||
|
|
!getTokenInteger(tokens[1], "width", &width) ||
|
|
!getTokenInteger(tokens[2], "height", &height) ||
|
|
!getTokenInteger(tokens[3], "tileposx", &tilePosX) ||
|
|
!getTokenInteger(tokens[4], "tileposy", &tilePosY) ||
|
|
!getTokenInteger(tokens[5], "tilewidth", &tileWidth) ||
|
|
!getTokenInteger(tokens[6], "tileheight", &tileHeight))
|
|
{
|
|
sendTextFrame("error: cmd=tile kind=syntax");
|
|
return;
|
|
}
|
|
|
|
std::string response = "tile: " + Poco::cat(std::string(" "), tokens.begin() + 1, tokens.end()) + "\n";
|
|
|
|
std::vector<char> output;
|
|
output.reserve(4 * width * height);
|
|
output.resize(response.size());
|
|
memcpy(output.data(), response.data(), response.size());
|
|
|
|
std::unique_ptr<std::fstream> cachedTile = _tileCache->lookup(width, height, tilePosX, tilePosY, tileWidth, tileHeight);
|
|
if (cachedTile && cachedTile->is_open())
|
|
{
|
|
std::cout << "Found in cache!" << std::endl;
|
|
cachedTile->seekg(0, std::ios_base::end);
|
|
size_t pos = output.size();
|
|
std::streamsize size = cachedTile->tellg();
|
|
output.resize(pos + size);
|
|
cachedTile->seekg(0, std::ios_base::beg);
|
|
cachedTile->read(output.data() + pos, size);
|
|
cachedTile->close();
|
|
|
|
sendBinaryFrame(output.data(), output.size());
|
|
|
|
return;
|
|
}
|
|
|
|
unsigned char *buffer = new unsigned char[4 * width * height];
|
|
int rowStride;
|
|
_loKitDocument->pClass->paintTile(_loKitDocument, buffer, width, height, &rowStride, tilePosX, tilePosY, tileWidth, tileHeight);
|
|
|
|
png_structp png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
|
|
|
|
png_infop info_ptr = png_create_info_struct(png_ptr);
|
|
|
|
if (setjmp(png_jmpbuf(png_ptr)))
|
|
{
|
|
png_destroy_write_struct(&png_ptr, NULL);
|
|
sendTextFrame("error: cmd=tile kind=failure");
|
|
return;
|
|
}
|
|
|
|
png_set_IHDR(png_ptr, info_ptr, width, height, 8, PNG_COLOR_TYPE_RGB_ALPHA, PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
|
|
|
|
png_set_write_fn(png_ptr, &output, user_write_fn, user_flush_fn);
|
|
png_set_write_status_fn(png_ptr, user_write_status_fn);
|
|
|
|
png_write_info(png_ptr, info_ptr);
|
|
|
|
for (int y = 0; y < height; ++y)
|
|
png_write_row(png_ptr, buffer + y * width * 4);
|
|
|
|
png_write_end(png_ptr, info_ptr);
|
|
|
|
png_destroy_write_struct(&png_ptr, NULL);
|
|
|
|
delete[] buffer;
|
|
|
|
_tileCache->save(width, height, tilePosX, tilePosY, tileWidth, tileHeight, output.data() + response.size(), output.size() - response.size());
|
|
|
|
sendBinaryFrame(output.data(), output.size());
|
|
}
|
|
|
|
void LOOLSession::forkOff()
|
|
{
|
|
}
|
|
|
|
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|