1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
|
/* -*- 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/.
*/
#ifndef INCLUDED_LIBREOFFICEKIT_LIBREOFFICEKIT_HXX
#define INCLUDED_LIBREOFFICEKIT_LIBREOFFICEKIT_HXX
#include "LibreOfficeKit.h"
/*
* The reasons this C++ code is not as pretty as it could be are:
* a) provide a pure C API - that's useful for some people
* b) allow ABI stability - C++ vtables are not good for that.
* c) avoid C++ types as part of the API.
*/
namespace lok
{
/// The lok::Document class represents one loaded document instance.
class Document
{
private:
LibreOfficeKitDocument* mpDoc;
public:
/// A lok::Document is typically created by the lok::Office::documentLoad() method.
inline Document(LibreOfficeKitDocument* pDoc) :
mpDoc(pDoc)
{}
inline ~Document()
{
mpDoc->pClass->destroy(mpDoc);
}
/**
* Stores the document's persistent data to a URL and
* continues to be a representation of the old URL.
*
* @param pUrl the location where to store the document
* @param pFormat the format to use while exporting, when omitted, then deducted from pURL's extension
* @param pFilterOptions options for the export filter, e.g. SkipImages.
*/
inline bool saveAs(const char* pUrl, const char* pFormat = NULL, const char* pFilterOptions = NULL)
{
return mpDoc->pClass->saveAs(mpDoc, pUrl, pFormat, pFilterOptions) != 0;
}
/// Gives access to the underlying C pointer.
inline LibreOfficeKitDocument *get() { return mpDoc; }
#ifdef LOK_USE_UNSTABLE_API
/**
* Get document type.
*
* @return an element of the LibreOfficeKitDocumentType enum.
*/
inline int getDocumentType()
{
return mpDoc->pClass->getDocumentType(mpDoc);
}
/**
* Get number of part that the document contains.
*
* Part refers to either indivual sheets in a Calc, or slides in Impress,
* and has no relevance for Writer.
*/
inline int getParts()
{
return mpDoc->pClass->getParts(mpDoc);
}
/// Get the current part of the document.
inline int getPart()
{
return mpDoc->pClass->getPart(mpDoc);
}
/// Set the current part of the document.
inline void setPart(int nPart)
{
mpDoc->pClass->setPart(mpDoc, nPart);
}
/// Get the current part's name.
inline char* getPartName(int nPart)
{
return mpDoc->pClass->getPartName(mpDoc, nPart);
}
inline void setPartMode(int nMode)
{
mpDoc->pClass->setPartMode(mpDoc, nMode);
}
/**
* Renders a subset of the document to a pre-allocated buffer.
*
* Note that the buffer size and the tile size implicitly supports
* rendering at different zoom levels, as the number of rendered pixels and
* the rendered rectangle of the document are independent.
*
* @param pBuffer pointer to the buffer, its size is determined by nCanvasWidth and nCanvasHeight.
* @param nCanvasWidth number of pixels in a row of pBuffer.
* @param nCanvasHeight number of pixels in a column of pBuffer.
* @param nTilePosX logical X position of the top left corner of the rendered rectangle, in TWIPs.
* @param nTilePosY logical Y position of the top left corner of the rendered rectangle, in TWIPs.
* @param nTileWidth logical width of the rendered rectangle, in TWIPs.
* @param nTileHeight logical height of the rendered rectangle, in TWIPs.
*/
inline void paintTile(
unsigned char* pBuffer,
const int nCanvasWidth,
const int nCanvasHeight,
const int nTilePosX,
const int nTilePosY,
const int nTileWidth,
const int nTileHeight)
{
return mpDoc->pClass->paintTile(mpDoc, pBuffer, nCanvasWidth, nCanvasHeight,
nTilePosX, nTilePosY, nTileWidth, nTileHeight);
}
/// Get the document sizes in TWIPs.
inline void getDocumentSize(long* pWidth, long* pHeight)
{
mpDoc->pClass->getDocumentSize(mpDoc, pWidth, pHeight);
}
/**
* Initialize document for rendering.
*
* Sets the rendering and document parameters to default values that are
* needed to render the document correctly using tiled rendering. This
* method has to be called right after documentLoad() in case any of the
* tiled rendering methods are to be used later.
*/
inline void initializeForRendering()
{
mpDoc->pClass->initializeForRendering(mpDoc);
}
/**
* Registers a callback. LOK will invoke this function when it wants to
* inform the client about events.
*
* @param pCallback the callback to invoke
* @param pData the user data, will be passed to the callback on invocation
*/
inline void registerCallback(LibreOfficeKitCallback pCallback, void* pData)
{
mpDoc->pClass->registerCallback(mpDoc, pCallback, pData);
}
/**
* Posts a keyboard event to the focused frame.
*
* @param nType Event type, like press or release.
* @param nCharCode contains the Unicode character generated by this event or 0
* @param nKeyCode contains the integer code representing the key of the event (non-zero for control keys)
*/
inline void postKeyEvent(int nType, int nCharCode, int nKeyCode)
{
mpDoc->pClass->postKeyEvent(mpDoc, nType, nCharCode, nKeyCode);
}
/**
* Posts a mouse event to the document.
*
* @param nType Event type, like down, move or up.
* @param nX horizontal position in document coordinates
* @param nY vertical position in document coordinates
* @param nCount number of clicks: 1 for single click, 2 for double click
*/
inline void postMouseEvent(int nType, int nX, int nY, int nCount)
{
mpDoc->pClass->postMouseEvent(mpDoc, nType, nX, nY, nCount);
}
/**
* Posts an UNO command to the document.
*
* Example argument string:
*
* {
* "SearchItem.SearchString":
* {
* "type": "string",
* "value": "foobar"
* },
* "SearchItem.Backward":
* {
* "type": "boolean",
* "value": "false"
* }
* }
*
* @param pCommand uno command to be posted to the document, like ".uno:Bold"
* @param pArguments arguments of the uno command.
*/
inline void postUnoCommand(const char* pCommand, const char* pArguments = 0)
{
mpDoc->pClass->postUnoCommand(mpDoc, pCommand, pArguments);
}
/**
* Sets the start or end of a text selection.
*
* @param nType @see LibreOfficeKitSetTextSelectionType
* @param nX horizontal position in document coordinates
* @param nY vertical position in document coordinates
*/
inline void setTextSelection(int nType, int nX, int nY)
{
mpDoc->pClass->setTextSelection(mpDoc, nType, nX, nY);
}
/**
* Gets the currently selected text.
*
* @param pMimeType suggests the return format, for example text/plain;charset=utf-8.
* @param pUsedMimeType output parameter to inform about the determined format (suggested one or plain text).
*/
inline char* getTextSelection(const char* pMimeType, char** pUsedMimeType = 0)
{
return mpDoc->pClass->getTextSelection(mpDoc, pMimeType, pUsedMimeType);
}
/**
* Adjusts the graphic selection.
*
* @param nType @see LibreOfficeKitSetGraphicSelectionType
* @param nX horizontal position in document coordinates
* @param nY vertical position in document coordinates
*/
inline void setGraphicSelection(int nType, int nX, int nY)
{
mpDoc->pClass->setGraphicSelection(mpDoc, nType, nX, nY);
}
/**
* Gets rid of any text or graphic selection.
*/
inline void resetSelection()
{
mpDoc->pClass->resetSelection(mpDoc);
}
/**
* Returns a json mapping of the possible values for the given command
* e.g. {commandName: ".uno:StyleApply", commandValues: {"familyName1" : ["list of style names in the family1"], etc.}}
* @param pCommand a uno command for which the possible values are requested
* @return {commandName: unoCmd, commandValues: {possible_values}}
*/
inline char* getCommandValues(const char* pCommand)
{
return mpDoc->pClass->getCommandValues(mpDoc, pCommand);
}
/**
* Create a new view for an existing document.
* By default a loaded document has 1 view.
* @return the ID of the new view.
*/
int createView()
{
return mpDoc->pClass->createView(mpDoc);
}
/**
* Destroy a view of an existing document.
* @param nId a view ID, returned by createView().
*/
void destroyView(int nId)
{
mpDoc->pClass->destroyView(mpDoc, nId);
}
/**
* Set an existing view of an existing document as current.
* @param nId a view ID, returned by createView().
*/
void setView(int nId)
{
mpDoc->pClass->setView(mpDoc, nId);
}
/**
* Get the current view.
* @return a view ID, previously returned by createView().
*/
int getView()
{
return mpDoc->pClass->getView(mpDoc);
}
/**
* Get number of views of this document.
*/
inline int getViews()
{
return mpDoc->pClass->getViews(mpDoc);
}
#endif // LOK_USE_UNSTABLE_API
};
/// The lok::Office class represents one started LibreOfficeKit instance.
class Office
{
private:
LibreOfficeKit* mpThis;
public:
/// A lok::Office is typically created by the lok_cpp_init() function.
inline Office(LibreOfficeKit* pThis) :
mpThis(pThis)
{}
inline ~Office()
{
mpThis->pClass->destroy(mpThis);
}
/**
* Loads a document from an URL.
*
* @param pUrl the URL of the document to load
* @param pFilterOptions options for the import filter, e.g. SkipImages.
*/
inline Document* documentLoad(const char* pUrl, const char* pFilterOptions = NULL)
{
LibreOfficeKitDocument* pDoc = NULL;
if (LIBREOFFICEKIT_HAS(mpThis, documentLoadWithOptions))
pDoc = mpThis->pClass->documentLoadWithOptions(mpThis, pUrl, pFilterOptions);
else
pDoc = mpThis->pClass->documentLoad(mpThis, pUrl);
if (pDoc == NULL)
return NULL;
return new Document(pDoc);
}
/// Returns the last error as a string, the returned pointer has to be freed by the caller.
inline char* getError()
{
return mpThis->pClass->getError(mpThis);
}
};
/// Factory method to create a lok::Office instance.
inline Office* lok_cpp_init(const char* pInstallPath, const char* pUserProfilePath = NULL)
{
LibreOfficeKit* pThis = lok_init_2(pInstallPath, pUserProfilePath);
if (pThis == NULL || pThis->pClass->nSize == 0)
return NULL;
return new ::lok::Office(pThis);
}
}
#endif // INCLUDED_LIBREOFFICEKIT_LIBREOFFICEKIT_HXX
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|