mirror of
https://github.com/ultimatepp/ultimatepp.git
synced 2026-05-17 06:06:00 -06:00
2627 lines
65 KiB
C++
2627 lines
65 KiB
C++
#include <Core/Core.h>
|
|
|
|
#ifndef PLATFORM_WIN32
|
|
#error Sorry: This platform is not supported!. Look for Automation in Bazaar Upp Forum to search for info and new news
|
|
#endif
|
|
|
|
#include <winnls.h>
|
|
|
|
#include "SysInfo/SysInfo.h"
|
|
#include "AutomationBase.h"
|
|
#include "Automation.h"
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////
|
|
VariantOle::VariantOle()
|
|
{
|
|
VariantInit(&var);
|
|
VariantClear(&var);
|
|
}
|
|
VariantOle::~VariantOle()
|
|
{
|
|
if (var.vt == VT_BSTR)
|
|
SysFreeString(var.bstrVal);
|
|
}
|
|
void VariantOle::Bool(bool val)
|
|
{
|
|
var.vt = VT_BOOL;
|
|
var.boolVal = val;
|
|
}
|
|
void VariantOle::Int(int val)
|
|
{
|
|
var.vt = VT_I4;
|
|
var.intVal = val;
|
|
}
|
|
void VariantOle::Int4(long val)
|
|
{
|
|
var.vt = VT_I4;
|
|
var.lVal = val;
|
|
}
|
|
void VariantOle::Real4(float val)
|
|
{
|
|
var.vt = VT_R4;
|
|
var.fltVal = val;
|
|
}
|
|
void VariantOle::Real8(double val)
|
|
{
|
|
var.vt = VT_R8;
|
|
var.dblVal = val;
|
|
}
|
|
void VariantOle::BString(String str)
|
|
{
|
|
WCHAR wfileName[1024*sizeof(WCHAR)];
|
|
|
|
MultiByteToWideChar(CP_UTF8, 0, str, -1, wfileName, sizeof(wfileName)/sizeof(wfileName[0]));
|
|
var.vt = VT_BSTR;
|
|
var.bstrVal = ::SysAllocString(wfileName);
|
|
}
|
|
void VariantOle::Optional()
|
|
{
|
|
var.vt = VT_ERROR;
|
|
var.scode = DISP_E_PARAMNOTFOUND;
|
|
}
|
|
void VariantOle::ObjectOle(::ObjectOle val)
|
|
{
|
|
var.vt = VT_DISPATCH;
|
|
var.pdispVal = val;
|
|
}
|
|
void VariantOle::Time(Upp::Time t)
|
|
{
|
|
var.vt = VT_DATE;
|
|
SYSTEMTIME stime;
|
|
stime.wDay = t.day;
|
|
stime.wMonth = t.month;
|
|
stime.wYear = t.year;
|
|
stime.wHour = t.hour;
|
|
stime.wMinute = t.minute;
|
|
stime.wSecond = t.second;
|
|
SystemTimeToVariantTime(&stime, &(var.date));
|
|
}
|
|
void VariantOle::ArrayDim(int sizeX)
|
|
{
|
|
var.vt = VT_ARRAY | VT_VARIANT;
|
|
SAFEARRAYBOUND sab[1]; // 1 dimension
|
|
sab[0].lLbound = 1; sab[0].cElements = sizeX;
|
|
var.parray = SafeArrayCreate(VT_VARIANT, 1, sab);
|
|
}
|
|
void VariantOle::ArrayDim(int sizeX, int sizeY)
|
|
{
|
|
var.vt = VT_ARRAY | VT_VARIANT;
|
|
SAFEARRAYBOUND sab[2]; // 2 dimension
|
|
sab[0].lLbound = 1; sab[0].cElements = sizeY;
|
|
sab[1].lLbound = 1; sab[1].cElements = sizeX;
|
|
var.parray = SafeArrayCreate(VT_VARIANT, 2, sab);
|
|
}
|
|
void VariantOle::ArraySetValue(int x, ::Value value)
|
|
{
|
|
VariantOle tmp;
|
|
tmp.Value(value);
|
|
long indices[] = {x};
|
|
SafeArrayPutElement(var.parray, indices, (void *)&tmp);
|
|
}
|
|
void VariantOle::ArraySetVariant(int x, VariantOle &value)
|
|
{
|
|
long indices[] = {x};
|
|
SafeArrayPutElement(var.parray, indices, (void *)&value);
|
|
}
|
|
void VariantOle::ArraySetValue(int x, int y, ::Value value)
|
|
{
|
|
VariantOle tmp;
|
|
tmp.Value(value);
|
|
long indices[] = {y, x};
|
|
SafeArrayPutElement(var.parray, indices, (void *)&tmp);
|
|
}
|
|
void VariantOle::ArraySetVariant(int x, int y, VariantOle &value)
|
|
{
|
|
long indices[] = {y, x};
|
|
SafeArrayPutElement(var.parray, indices, (void *)&value);
|
|
}
|
|
void VariantOle::Value(::Value value)
|
|
{
|
|
if(value.Is<bool>()) {
|
|
bool v = value;
|
|
Bool(v);
|
|
} else if(value.Is<int>()) {
|
|
int v = value;
|
|
Int(v);
|
|
} else if(value.Is<int64>()) {
|
|
int64 v = value;
|
|
Int4((long)v);
|
|
//} else if(value.Is<float>()) {
|
|
// float v = value;
|
|
// Real4(v);
|
|
} else if(value.Is<double>()) {
|
|
double v = value;
|
|
Real8(v);
|
|
} else if(value.Is<String>()) {
|
|
String v = value;
|
|
BString(v);
|
|
} else if(IsDateTime(value)) {
|
|
Upp::Time v = value;
|
|
Time(v);
|
|
} else {
|
|
String v = value;
|
|
BString(v);
|
|
}
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////
|
|
class Ole
|
|
{
|
|
public:
|
|
static bool Invoke(int autoType, VARIANT *pvResult, IDispatch *pDisp, String name, int cArgs...);
|
|
static void Init();
|
|
static bool Close();
|
|
static ObjectOle CreateObject(String application);
|
|
static ObjectOle GetObject(ObjectOle from, String what);
|
|
static ObjectOle GetObject(ObjectOle from, String which, VariantOle &value);
|
|
static ObjectOle GetObject(ObjectOle from, String which, VariantOle &value, VariantOle &value2);
|
|
static bool SetValue(ObjectOle from, String which, VariantOle &value);
|
|
static bool SetValue(ObjectOle from, String which, VariantOle &value, VariantOle &value2);
|
|
static bool SetValue(ObjectOle from, String which, VariantOle &value, VariantOle &value2, VariantOle &value3);
|
|
static Value GetValue(ObjectOle from, String which);
|
|
static Value GetValue(ObjectOle from, String which, VariantOle &value);
|
|
static Value GetValue(ObjectOle from, String which, VariantOle &value, VariantOle &value2);
|
|
static bool Method(ObjectOle from, String which);
|
|
static bool Method(ObjectOle from, String which, VariantOle &value);
|
|
static bool Method(ObjectOle from, String which, VariantOle &value, VariantOle &value2);
|
|
static bool Method(ObjectOle from, String which, VariantOle &value, VariantOle &value2, VariantOle &value3);
|
|
static bool Method(ObjectOle from, String which, VariantOle &value, VariantOle &value2, VariantOle &value3, VariantOle &value4);
|
|
static bool Method(ObjectOle from, String which, VariantOle &value, VariantOle &value2, VariantOle &value3, VariantOle &value4, VariantOle &value5);
|
|
static bool Method(ObjectOle from, String which, VariantOle &value, VariantOle &value2, VariantOle &value3, VariantOle &value4, VariantOle &value5, VariantOle &value6, VariantOle &value7, VariantOle &value8, VariantOle &value9, VariantOle &value10, VariantOle &value11);
|
|
static ObjectOle MethodGet(ObjectOle from, String which);
|
|
static ObjectOle MethodGet(ObjectOle from, String which, VariantOle &value);
|
|
static ObjectOle MethodGet(ObjectOle from, String which, VariantOle &value, VariantOle &value2);
|
|
static ObjectOle MethodGet(ObjectOle from, String which, VariantOle &value, VariantOle &value2, VariantOle &value3);
|
|
static ObjectOle MethodGet(ObjectOle from, String which, VariantOle &value, VariantOle &value2, VariantOle &value3, VariantOle &value4);
|
|
static bool IsOn() {return numOleInit > 0;};
|
|
private:
|
|
static int numOleInit;
|
|
};
|
|
|
|
int Ole::numOleInit = 0;
|
|
|
|
void Ole::Init()
|
|
{ // Initialize COM for this thread
|
|
if (numOleInit == 0) {
|
|
OleInitialize(NULL);
|
|
CoInitialize(NULL);
|
|
numOleInit++;
|
|
}
|
|
}
|
|
bool Ole::Close()
|
|
{ // Uninitialize COM for this thread
|
|
numOleInit--;
|
|
if (numOleInit == 0)
|
|
CoUninitialize();
|
|
if (numOleInit < 0) { // This is a mistake
|
|
numOleInit = 0;
|
|
return false;
|
|
} else
|
|
return true;
|
|
}
|
|
// Invoke() - Automation helper function
|
|
bool Ole::Invoke(int autoType, VARIANT *pvResult, IDispatch *pDisp, String name, int cArgs ...)
|
|
{
|
|
// Begin variable-argument lis
|
|
va_list marker;
|
|
va_start(marker, cArgs);
|
|
|
|
if(!pDisp) {
|
|
MessageBox(NULL, "NULL IDispatch passed to AutoWrap()", "Error", 0x10010);
|
|
return false;
|
|
}
|
|
// Variables used
|
|
DISPPARAMS dp = { NULL, NULL, 0, 0 };
|
|
DISPID dispidNamed = DISPID_PROPERTYPUT;
|
|
DISPID dispID;
|
|
HRESULT hr;
|
|
char buf[200];
|
|
char szName[200];
|
|
WString wname = name.ToWString();
|
|
WStringBuffer ptName(wname);
|
|
|
|
// Convert down to ANSI
|
|
WideCharToMultiByte(CP_ACP, 0, ptName, -1, szName, 256, NULL, NULL);
|
|
|
|
// Get DISPID for name passed
|
|
hr = pDisp->GetIDsOfNames(IID_NULL, (LPOLESTR *)&ptName, 1, LOCALE_USER_DEFAULT, &dispID);
|
|
if(FAILED(hr)) {
|
|
//sprintf(buf, "Command IDispatch::GetIDsOfNames(\"%s\") failed w/err 0x%08lx", szName, hr);
|
|
sprintf(buf, "Command \"%s\" not found for object or problem when running it", szName);
|
|
MessageBox(NULL, buf, "Ole error", 0x10010);
|
|
return false;
|
|
}
|
|
// Allocate memory for arguments
|
|
VARIANT *pArgs = new VARIANT[cArgs+1];
|
|
// Extract arguments
|
|
for(int i = 0; i < cArgs; i++)
|
|
pArgs[i] = va_arg(marker, VARIANT);
|
|
|
|
// Build DISPPARAMS
|
|
dp.cArgs = cArgs;
|
|
dp.rgvarg = pArgs;
|
|
|
|
// Handle special-case for property-puts!
|
|
if(autoType & DISPATCH_PROPERTYPUT) {
|
|
dp.cNamedArgs = 1;
|
|
dp.rgdispidNamedArgs = &dispidNamed;
|
|
}
|
|
// Make the call!
|
|
hr = pDisp->Invoke(dispID, IID_NULL, LOCALE_SYSTEM_DEFAULT, autoType, &dp, pvResult, NULL, NULL);
|
|
|
|
// End variable-argument section
|
|
va_end(marker);
|
|
|
|
delete [] pArgs;
|
|
|
|
if(FAILED(hr)) {
|
|
//sprintf(buf, "IDispatch::Invoke(\"%s\"=%08lx) failed w/err 0x%08lx", szName, dispID, hr);
|
|
//MessageBox(NULL, buf, "Ole::Invoke()", 0x10010);
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
ObjectOle Ole::CreateObject(String application)
|
|
{
|
|
CLSID clsid;
|
|
HRESULT hr = CLSIDFromProgID(application.ToWString(), &clsid); // Get CLSID for our server
|
|
if(FAILED(hr)) {
|
|
//::MessageBox(NULL, "CLSIDFromProgID() failed", "Error", 0x10010);
|
|
return NULL;
|
|
}
|
|
ObjectOle app;
|
|
// Start server and get IDispatch
|
|
hr = CoCreateInstance(clsid, NULL, CLSCTX_LOCAL_SERVER, IID_IDispatch, (void **)&app);
|
|
if(FAILED(hr)) {
|
|
::MessageBox(NULL, "Application not registered properly", "Error", 0x10010);
|
|
return NULL;
|
|
}
|
|
return app;
|
|
}
|
|
ObjectOle Ole::GetObject(ObjectOle from, String which)
|
|
{
|
|
VARIANT result;
|
|
VariantInit(&result);
|
|
if(!Ole::Invoke(DISPATCH_PROPERTYGET, &result, from, which, 0))
|
|
return NULL;
|
|
else
|
|
return result.pdispVal;
|
|
}
|
|
ObjectOle Ole::GetObject(ObjectOle from, String which, VariantOle &value)
|
|
{
|
|
VARIANT result;
|
|
VariantInit(&result);
|
|
if(!Ole::Invoke(DISPATCH_PROPERTYGET, &result, from, which, 1, value.var))
|
|
return NULL;
|
|
else
|
|
return result.pdispVal;
|
|
}
|
|
ObjectOle Ole::GetObject(ObjectOle from, String which, VariantOle &value, VariantOle &value2)
|
|
{
|
|
VARIANT result;
|
|
VariantInit(&result);
|
|
if(!Ole::Invoke(DISPATCH_PROPERTYGET, &result, from, which, 2, value.var, value2.var))
|
|
return NULL;
|
|
else
|
|
return result.pdispVal;
|
|
}
|
|
Value Ole::GetValue(ObjectOle from, String which)
|
|
{
|
|
VARIANT result;
|
|
VariantInit(&result);
|
|
if(!Ole::Invoke(DISPATCH_PROPERTYGET|DISPATCH_METHOD, &result, from, which, 0))
|
|
return "";
|
|
|
|
Value ret;
|
|
switch(result.vt) {
|
|
case VT_EMPTY:
|
|
case VT_NULL:
|
|
case VT_BLOB:
|
|
break;
|
|
case VT_BOOL:
|
|
ret = result.boolVal;// ? "true" : "false";
|
|
break;
|
|
case VT_I2:
|
|
ret = result.iVal;
|
|
break;
|
|
case VT_I4:
|
|
ret = (int64)result.lVal;
|
|
break;
|
|
case VT_R4:
|
|
ret = AsString(result.fltVal);
|
|
break;
|
|
case VT_R8:
|
|
ret = AsString(result.dblVal);
|
|
break;
|
|
case VT_BSTR:
|
|
{
|
|
char dbcs[1024];
|
|
char *pbstr = (char *)result.bstrVal;
|
|
int i = wcstombs(dbcs, result.bstrVal, *((DWORD *)(pbstr-4)));
|
|
dbcs[i] = 0;
|
|
ret = dbcs;
|
|
}
|
|
break;
|
|
case VT_LPSTR:
|
|
//ret = result.pszVal;
|
|
ret = "Unknown VT_LPSTR";
|
|
case VT_DATE:
|
|
SYSTEMTIME stime;
|
|
VariantTimeToSystemTime(result.date, &stime);
|
|
{
|
|
Time t;
|
|
t.day = (Upp::byte)stime.wDay;
|
|
t.month = (Upp::byte)stime.wMonth;
|
|
t.year = stime.wYear;
|
|
t.hour = (Upp::byte)stime.wHour;
|
|
t.minute = (Upp::byte)stime.wMinute;
|
|
t.second = (Upp::byte)stime.wSecond;
|
|
ret = t;
|
|
}
|
|
break;
|
|
case VT_CF:
|
|
ret = "(Clipboard format)";
|
|
break;
|
|
}
|
|
return ret;
|
|
}
|
|
bool Ole::SetValue(ObjectOle from, String which, VariantOle &value)
|
|
{
|
|
return Ole::Invoke(DISPATCH_PROPERTYPUT, NULL, from, which, 1, value.var);
|
|
}
|
|
bool Ole::SetValue(ObjectOle from, String which, VariantOle &value, VariantOle &value2)
|
|
{
|
|
return Ole::Invoke(DISPATCH_PROPERTYPUT, NULL, from, which, 2, value.var, value2.var);
|
|
}
|
|
bool Ole::SetValue(ObjectOle from, String which, VariantOle &value, VariantOle &value2, VariantOle &value3)
|
|
{
|
|
return Ole::Invoke(DISPATCH_PROPERTYPUT, NULL, from, which, 3, value.var, value2.var, value3.var);
|
|
}
|
|
// result var is not used but OpenOffice automation requires it (I do not why)
|
|
bool Ole::Method(ObjectOle from, String which)
|
|
{
|
|
VARIANT result;
|
|
VariantInit(&result);
|
|
return Ole::Invoke(DISPATCH_METHOD, &result, from, which, 0);
|
|
}
|
|
bool Ole::Method(ObjectOle from, String which, VariantOle &value)
|
|
{
|
|
VARIANT result;
|
|
VariantInit(&result);
|
|
return Ole::Invoke(DISPATCH_METHOD, &result, from, which, 1, value.var);
|
|
}
|
|
bool Ole::Method(ObjectOle from, String which, VariantOle &value, VariantOle &value2)
|
|
{
|
|
VARIANT result;
|
|
VariantInit(&result);
|
|
return Ole::Invoke(DISPATCH_METHOD, &result, from, which, 2, value.var, value2.var);
|
|
}
|
|
bool Ole::Method(ObjectOle from, String which, VariantOle &value, VariantOle &value2, VariantOle &value3)
|
|
{
|
|
VARIANT result;
|
|
VariantInit(&result);
|
|
return Ole::Invoke(DISPATCH_METHOD, &result, from, which, 3, value.var, value2.var, value3.var);
|
|
}
|
|
bool Ole::Method(ObjectOle from, String which, VariantOle &value, VariantOle &value2, VariantOle &value3, VariantOle &value4)
|
|
{
|
|
VARIANT result;
|
|
VariantInit(&result);
|
|
return Ole::Invoke(DISPATCH_METHOD, &result, from, which, 3, value.var, value2.var, value3.var, value4.var);
|
|
}
|
|
bool Ole::Method(ObjectOle from, String which, VariantOle &value, VariantOle &value2, VariantOle &value3, VariantOle &value4, VariantOle &value5)
|
|
{
|
|
VARIANT result;
|
|
VariantInit(&result);
|
|
return Ole::Invoke(DISPATCH_METHOD, &result, from, which, 3, value.var, value2.var, value3.var, value4.var, value5.var);
|
|
}
|
|
bool Ole::Method(ObjectOle from, String which, VariantOle &value, VariantOle &value2, VariantOle &value3, VariantOle &value4, VariantOle &value5, VariantOle &value6, VariantOle &value7, VariantOle &value8, VariantOle &value9, VariantOle &value10, VariantOle &value11)
|
|
{
|
|
VARIANT result;
|
|
VariantInit(&result);
|
|
return Ole::Invoke(DISPATCH_METHOD, &result, from, which, 11, value.var, value2.var, value3.var, value4.var, value5.var, value6.var, value7.var, value8.var, value9.var, value10.var, value11.var);
|
|
}
|
|
ObjectOle Ole::MethodGet(ObjectOle from, String which)
|
|
{
|
|
VARIANT result;
|
|
VariantInit(&result);
|
|
if(!Ole::Invoke(DISPATCH_METHOD, &result, from, which, 0))
|
|
return NULL;
|
|
else
|
|
return result.pdispVal;
|
|
}
|
|
ObjectOle Ole::MethodGet(ObjectOle from, String which, VariantOle &value)
|
|
{
|
|
VARIANT result;
|
|
VariantInit(&result);
|
|
if(!Ole::Invoke(DISPATCH_METHOD, &result, from, which, 1, value.var))
|
|
return NULL;
|
|
else
|
|
return result.pdispVal;
|
|
}
|
|
ObjectOle Ole::MethodGet(ObjectOle from, String which, VariantOle &value, VariantOle &value2)
|
|
{
|
|
VARIANT result;
|
|
VariantInit(&result);
|
|
if(!Ole::Invoke(DISPATCH_METHOD, &result, from, which, 2, value.var, value2.var))
|
|
return NULL;
|
|
else
|
|
return result.pdispVal;
|
|
}
|
|
ObjectOle Ole::MethodGet(ObjectOle from, String which, VariantOle &value, VariantOle &value2, VariantOle &value3)
|
|
{
|
|
VARIANT result;
|
|
VariantInit(&result);
|
|
if(!Ole::Invoke(DISPATCH_METHOD, &result, from, which, 3, value.var, value2.var, value3.var))
|
|
return NULL;
|
|
else
|
|
return result.pdispVal;
|
|
}
|
|
ObjectOle Ole::MethodGet(ObjectOle from, String which, VariantOle &value, VariantOle &value2, VariantOle &value3, VariantOle &value4)
|
|
{
|
|
VARIANT result;
|
|
VariantInit(&result);
|
|
if(!Ole::Invoke(DISPATCH_METHOD, &result, from, which, 4, value.var, value2.var, value3.var, value4.var))
|
|
return NULL;
|
|
else
|
|
return result.pdispVal;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
MSSheet::MSSheet()
|
|
{
|
|
App = Books = Book = Sheet = Range = NULL;
|
|
quit = false;
|
|
|
|
App = Ole::CreateObject("Excel.Application");
|
|
if (!(Books = Ole::GetObject(App, "Workbooks"))) {
|
|
::MessageBox(NULL, "Workbooks not loaded properly", "Error", 0x10010);
|
|
return;
|
|
}
|
|
}
|
|
MSSheet::~MSSheet()
|
|
{
|
|
if (Range)
|
|
Range->Release();
|
|
if (Sheet)
|
|
Sheet->Release();
|
|
if (Book)
|
|
Book->Release();
|
|
if (Books)
|
|
Books->Release();
|
|
if (App) {
|
|
Quit();
|
|
App->Release();
|
|
}
|
|
}
|
|
bool MSSheet::IsAvailable()
|
|
{
|
|
ObjectOle app = Ole::CreateObject("Excel.Application");
|
|
|
|
if (!app)
|
|
return false;
|
|
else {
|
|
app->Release();
|
|
return true;
|
|
}
|
|
}
|
|
bool MSSheet::SetVisible(bool visible)
|
|
{
|
|
if (!Books)
|
|
return false;
|
|
|
|
VariantOle vVisible;
|
|
vVisible.Int4(visible? 1: 0);
|
|
return Ole::SetValue(App, "Visible", vVisible);
|
|
}
|
|
bool MSSheet::SetSaved(bool saved)
|
|
{
|
|
if (!Books && !Book)
|
|
return false;
|
|
|
|
// Set .Saved property of workbook to TRUE so we aren't prompted
|
|
// to save when we tell Excel to quit...
|
|
VariantOle vSaved;
|
|
vSaved.Int4(saved? 1: 0);
|
|
return Ole::SetValue(Book, "Saved", vSaved);
|
|
}
|
|
bool MSSheet::Quit()
|
|
{
|
|
if (!quit) {
|
|
quit = true;
|
|
return Ole::Method(App, "Quit");
|
|
}
|
|
return true;
|
|
}
|
|
bool MSSheet::AddSheet(bool visible)
|
|
{
|
|
if (!Books)
|
|
return false;
|
|
|
|
if (!(Book = Ole::GetObject(Books, "Add")))
|
|
return false;
|
|
if (!(Sheet = Ole::GetObject(App, "ActiveSheet")))
|
|
return false;
|
|
|
|
SetVisible(visible);
|
|
return true;
|
|
}
|
|
bool MSSheet::OpenSheet(String fileName, bool visible)
|
|
{
|
|
if (!Books)
|
|
return false;
|
|
|
|
VariantOle vFileName;
|
|
vFileName.BString(fileName);
|
|
if (!(Book = Ole::GetObject(Books, "Open", vFileName)))
|
|
return false;
|
|
if (!(Sheet = Ole::GetObject(App, "ActiveSheet")))
|
|
return false;
|
|
|
|
SetVisible(visible);
|
|
return true;
|
|
}
|
|
bool MSSheet::Select(String range)
|
|
{
|
|
VariantOle vRange;
|
|
vRange.BString(range);
|
|
|
|
if (!(Range = Ole::GetObject(Sheet, "Range", vRange)))
|
|
return false;
|
|
return true;
|
|
}
|
|
bool MSSheet::Select(int fromX, int fromY, int toX, int toY)
|
|
{
|
|
String range = OfficeSheet::ColRowToCell(fromX, fromY) + ":" + OfficeSheet::ColRowToCell(toX, toY);
|
|
VariantOle vRange;
|
|
vRange.BString(range);
|
|
|
|
if (!(Range = Ole::GetObject(Sheet, "Range", vRange)))
|
|
return false;
|
|
return true;
|
|
}
|
|
bool MSSheet::Select()
|
|
{
|
|
if (!(Range = Ole::GetObject(Sheet, "Cells"))) // ActiveSheet.Cells.Select
|
|
return false;
|
|
return Ole::Method(Range, "Select");
|
|
}
|
|
void MSSheet::DefMatrix(int width, int height)
|
|
{
|
|
Matrix.ArrayDim(width, height);
|
|
}
|
|
void MSSheet::SetMatrixValue(int x, int y, ::Value value)
|
|
{
|
|
Matrix.ArraySetValue(x, y, value);
|
|
}
|
|
bool MSSheet::FillSelectionMatrix()
|
|
{
|
|
if (!Range)
|
|
return false;
|
|
|
|
bool ret = Ole::Invoke(DISPATCH_PROPERTYPUT, NULL, Range, "Value", 1, Matrix.var);
|
|
|
|
return ret;
|
|
}
|
|
|
|
bool MSSheet::SetValue(String cell, Value value) // cell in textual format like "B14"
|
|
{
|
|
int col, row;
|
|
|
|
OfficeSheet::CellToColRow(cell, col, row);
|
|
return MSSheet::SetValue(col, row, value);
|
|
}
|
|
bool MSSheet::SetValue(int col, int row, Value value)
|
|
{
|
|
if (!Sheet)
|
|
return false;
|
|
|
|
VariantOle x, y, val;
|
|
x.Int4(col);
|
|
y.Int4(row);
|
|
val.Value(value);
|
|
|
|
return Ole::SetValue(Sheet, "Cells", val, x, y);
|
|
}
|
|
bool MSSheet::Replace(Value search, Value replace)
|
|
{
|
|
if (!App)
|
|
return false;
|
|
|
|
ObjectOle selection; // Call Application.Selection.Replace(search, replace)
|
|
if (!(selection = Ole::GetObject(App, "Selection")))
|
|
return false;
|
|
|
|
VariantOle vSearch, vReplace;
|
|
vSearch.Value(search);
|
|
vReplace.Value(replace);
|
|
|
|
return Ole::Method(selection, "Replace", vReplace, vSearch);
|
|
}
|
|
Value MSSheet::GetValue(int col, int row)
|
|
{
|
|
if (!Sheet)
|
|
return false;
|
|
|
|
VariantOle x, y;
|
|
x.Int4(col);
|
|
y.Int4(row);
|
|
|
|
return Ole::GetValue(Ole::GetObject(Sheet, "Cells", x, y), "value");
|
|
}
|
|
Value MSSheet::GetValue(String cell)
|
|
{
|
|
int row, col;
|
|
|
|
OfficeSheet::CellToColRow(cell, col, row);
|
|
return GetValue(col, row);
|
|
}
|
|
bool MSSheet::SaveAs(String fileName, String type)
|
|
{
|
|
if (!Book)
|
|
return false;
|
|
|
|
fileName = ForceExt(fileName, "." + type);
|
|
|
|
VariantOle vFileName, vType;
|
|
|
|
vFileName.BString(fileName);
|
|
if (type == "csv")
|
|
vType.Int(6);
|
|
else if (type == "html")
|
|
vType.Int(44);
|
|
else if (type == "txt")
|
|
vType.Int(20);
|
|
else if (type == "xlsx")
|
|
vType.Int(51);
|
|
else // xls
|
|
vType.Int(-4143);
|
|
|
|
int ret = Ole::Method(Book, "SaveAs", vType, vFileName);
|
|
|
|
return (bool)ret;
|
|
}
|
|
bool MSSheet::SetBold(String cell, bool bold)
|
|
{
|
|
int col, row;
|
|
OfficeSheet::CellToColRow(cell, col, row);
|
|
return SetBold(col, row, bold);
|
|
}
|
|
bool MSSheet::SetBold(int col, int row, bool bold)
|
|
{
|
|
if (!Sheet)
|
|
return false;
|
|
|
|
VariantOle x, y;
|
|
x.Int4(col);
|
|
y.Int4(row);
|
|
|
|
VariantOle val;
|
|
val.Bool(bold);
|
|
return Ole::SetValue(Ole::GetObject(Ole::GetObject(Sheet, "Cells", x, y), "Font"), "Bold", val);
|
|
}
|
|
bool MSSheet::SetBold(bool bold)
|
|
{
|
|
if (!Range)
|
|
return false;
|
|
|
|
VariantOle val;
|
|
val.Bool(bold);
|
|
return Ole::SetValue(Ole::GetObject(Range, "Font"), "Bold", val);
|
|
}
|
|
bool MSSheet::SetFont(String cell, String name, int size)
|
|
{
|
|
int col, row;
|
|
OfficeSheet::CellToColRow(cell, col, row);
|
|
return SetFont(col, row, name, size);
|
|
}
|
|
bool MSSheet::SetFont(int col, int row, String name, int size)
|
|
{
|
|
if (!Sheet)
|
|
return false;
|
|
|
|
VariantOle x, y;
|
|
x.Int4(col);
|
|
y.Int4(row);
|
|
|
|
ObjectOle font = Ole::GetObject(Ole::GetObject(Sheet, "Cells", x, y), "Font");
|
|
if (!font)
|
|
return false;
|
|
|
|
VariantOle vName;
|
|
vName.BString(name);
|
|
if(!Ole::SetValue(font, "Name", vName))
|
|
return false;
|
|
VariantOle vSize;
|
|
vSize.Int(size);
|
|
if(!Ole::SetValue(font, "Size", vSize))
|
|
return false;
|
|
return true;
|
|
}
|
|
bool MSSheet::SetFont(String name, int size)
|
|
{
|
|
if (!Range)
|
|
return false;
|
|
|
|
ObjectOle font = Ole::GetObject(Range, "Font");
|
|
if (!font)
|
|
return false;
|
|
|
|
VariantOle vName;
|
|
vName.BString(name);
|
|
if(!Ole::SetValue(font, "Name", vName))
|
|
return false;
|
|
VariantOle vSize;
|
|
vSize.Int(size);
|
|
if(!Ole::SetValue(font, "Size", vSize))
|
|
return false;
|
|
return true;
|
|
}
|
|
bool MSSheet::Print()
|
|
{
|
|
if (!Sheet)
|
|
return false;
|
|
|
|
bool ret = Ole::Method(Sheet, "PrintOut");
|
|
|
|
return ret;
|
|
}
|
|
|
|
enum XLSheetTypes {xlWorksheet = -4167, xlChart = -4109, xlExcel4MacroSheet = 3, xlExcel4IntlMacroSheet = 4};
|
|
|
|
bool MSSheet::InsertTab(String name) // Insert tab after the last
|
|
{
|
|
if (!App)
|
|
return false;
|
|
|
|
if (!(Sheet = Ole::GetObject(Ole::GetObject(App, "Sheets"), "Add")))
|
|
return false;
|
|
VariantOle vName;
|
|
vName.BString(name);
|
|
if(!Ole::SetValue(Sheet, "Name", vName))
|
|
return false;
|
|
//return true;
|
|
|
|
VariantOle vOptional;
|
|
vOptional.Optional();
|
|
|
|
ObjectOle lastSheet;
|
|
VariantOle vId;
|
|
vId.Int(GetNumTabs());
|
|
if (!(lastSheet = Ole::GetObject(App, "Sheets", vId)))
|
|
return false;
|
|
VariantOle vAfter;
|
|
vAfter.ObjectOle(lastSheet);
|
|
|
|
return Ole::Method(Sheet, "Move", vAfter, vOptional); // Apending tab after last tab
|
|
}
|
|
bool MSSheet::ChooseTab(String name)
|
|
{
|
|
if (!App)
|
|
return false;
|
|
|
|
VariantOle vName;
|
|
vName.BString(name);
|
|
if (!(Sheet = Ole::GetObject(App, "Sheets", vName)))
|
|
return false;
|
|
|
|
return Ole::Method(Sheet, "select");
|
|
}
|
|
bool MSSheet::ChooseTab(int index)
|
|
{
|
|
if (!App)
|
|
return false;
|
|
|
|
VariantOle vId;
|
|
vId.Int(index+1);
|
|
if (!(Sheet = Ole::GetObject(App, "Sheets", vId)))
|
|
return false;
|
|
|
|
return Ole::Method(Sheet, "select");
|
|
}
|
|
bool MSSheet::RemoveTab(String name)
|
|
{
|
|
if (!App)
|
|
return false;
|
|
|
|
ObjectOle DelSheet;
|
|
VariantOle vName;
|
|
vName.BString(name);
|
|
if (!(DelSheet = Ole::GetObject(App, "Sheets", vName)))
|
|
return false;
|
|
|
|
return Ole::Method(DelSheet, "delete");
|
|
}
|
|
bool MSSheet::RemoveTab(int index)
|
|
{
|
|
if (!App)
|
|
return false;
|
|
|
|
ObjectOle DelSheet;
|
|
VariantOle vId;
|
|
vId.Int(index+1);
|
|
if (!(DelSheet = Ole::GetObject(App, "Sheets", vId)))
|
|
return false;
|
|
|
|
return Ole::Method(DelSheet, "delete");
|
|
}
|
|
int MSSheet::GetNumTabs()
|
|
{
|
|
if (!App)
|
|
return -1;
|
|
|
|
return Ole::GetValue(Ole::GetObject(App, "Sheets"), "count");
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
MSDoc::MSDoc()
|
|
{
|
|
App = Docs = Doc = Selection = NULL;
|
|
quit = false;
|
|
|
|
App = Ole::CreateObject("Word.Application");
|
|
if (!(Docs = Ole::GetObject(App, "Documents"))) {
|
|
::MessageBox(NULL, "Workbooks not loaded properly", "Error", 0x10010);
|
|
return;
|
|
}
|
|
}
|
|
MSDoc::~MSDoc()
|
|
{
|
|
if (Selection)
|
|
Selection->Release();
|
|
if (Doc)
|
|
Doc->Release();
|
|
if (Docs)
|
|
Docs->Release();
|
|
if (App) {
|
|
Quit();
|
|
App->Release();
|
|
}
|
|
Ole::Close();
|
|
}
|
|
bool MSDoc::SetVisible(bool visible)
|
|
{
|
|
if (!Docs)
|
|
return false;
|
|
|
|
VariantOle vVisible;
|
|
vVisible.Int4(visible? 1: 0);
|
|
return Ole::SetValue(App, "Visible", vVisible);
|
|
}
|
|
bool MSDoc::IsAvailable()
|
|
{
|
|
ObjectOle app = Ole::CreateObject("Word.Application");
|
|
|
|
if (!app)
|
|
return false;
|
|
else {
|
|
app->Release();
|
|
return true;
|
|
}
|
|
}
|
|
bool MSDoc::SetSaved(bool saved)
|
|
{
|
|
if (!Doc)
|
|
return false;
|
|
|
|
VariantOle vSaved;
|
|
vSaved.Int4(saved? 1: 0);
|
|
return Ole::SetValue(Doc, "Saved", vSaved);
|
|
}
|
|
bool MSDoc::Quit()
|
|
{
|
|
if (!quit) {
|
|
quit = true;
|
|
return Ole::Method(App, "Quit");
|
|
}
|
|
return true;
|
|
}
|
|
bool MSDoc::AddDoc(bool visible)
|
|
{
|
|
if (!Docs)
|
|
return false;
|
|
|
|
if (!(Doc = Ole::MethodGet(Docs, "Add")))
|
|
return false;
|
|
|
|
if(!(Selection = Ole::GetObject(App, "Selection")))
|
|
return false;
|
|
|
|
SetVisible(visible);
|
|
return true;
|
|
}
|
|
bool MSDoc::OpenDoc(String fileName, bool visible)
|
|
{
|
|
if (!Docs)
|
|
return false;
|
|
|
|
VariantOle vFileName;
|
|
vFileName.BString(fileName);
|
|
if (!(Doc = Ole::MethodGet(Docs, "Open", vFileName)))
|
|
return false;
|
|
|
|
if(!(Selection = Ole::GetObject(App, "Selection")))
|
|
return false;
|
|
|
|
SetVisible(visible);
|
|
return true;
|
|
}
|
|
bool MSDoc::SaveAs(String fileName, String type)
|
|
{
|
|
if (!Doc)
|
|
return false;
|
|
|
|
fileName = ForceExt(fileName, "." + type);
|
|
|
|
VariantOle vFileName, vType;
|
|
|
|
vFileName.BString(fileName);
|
|
if (type == "rtf")
|
|
vType.Int(6);
|
|
else if (type == "html")
|
|
vType.Int(8);
|
|
else if (type == "txt")
|
|
vType.Int(2);
|
|
else if (type == "docx")
|
|
vType.Int(13);
|
|
else // doc
|
|
vType.Int(0);
|
|
|
|
int ret = Ole::Method(Doc, "SaveAs", vType, vFileName);
|
|
|
|
return (bool)ret;
|
|
}
|
|
bool MSDoc::WriteText(String value)
|
|
{
|
|
if (!Selection)
|
|
return false;
|
|
|
|
VariantOle val;
|
|
val.BString(value);
|
|
return Ole::Method(Selection, "TypeText", val);
|
|
}
|
|
bool MSDoc::SetFont(String type, int size)
|
|
{
|
|
ObjectOle font;
|
|
|
|
if(!(font = Ole::GetObject(Selection, "Font")))
|
|
return false;
|
|
|
|
VariantOle vType;
|
|
vType.BString(type);
|
|
if(!Ole::SetValue(font, "Name", vType))
|
|
return false;
|
|
VariantOle vSize;
|
|
vSize.Int(size);
|
|
if(!Ole::SetValue(font, "Size", vSize))
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
bool MSDoc::SetBold(bool bold)
|
|
{
|
|
VariantOle vBold;
|
|
vBold.Bool(bold);
|
|
if(!Ole::SetValue(Ole::GetObject(Selection, "Font"), "Bold", vBold))
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
bool MSDoc::SetItalic(bool italic)
|
|
{
|
|
VariantOle vItalic;
|
|
vItalic.Bool(italic);
|
|
if(!Ole::SetValue(Ole::GetObject(Selection, "Font"), "Italic", vItalic))
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
bool MSDoc::Print()
|
|
{
|
|
if (!Docs && !Doc)
|
|
return false;
|
|
|
|
bool ret = Ole::Method(Doc, "PrintOut");
|
|
|
|
return ret;
|
|
}
|
|
bool MSDoc::Select()
|
|
{
|
|
return Ole::Method(Selection, "WholeStory");
|
|
}
|
|
// Some tricks as Ole Replace does not work properly texts to replace longer than about 250 chars and for some special chars
|
|
bool MSDoc::Replace(String search, String _replace)
|
|
{
|
|
String replace = CleanString(_replace);
|
|
replace = ::Replace(replace, "^", " ");
|
|
replace = ::Replace(replace, "\r", ""); // To remove squares
|
|
|
|
String replaceSubset;
|
|
while (replace.GetCount() > 200) {
|
|
replaceSubset = replace.Left(200);
|
|
replaceSubset.Cat(search);
|
|
replace = replace.Right(replace.GetCount() - 200);
|
|
|
|
replaceSubset = ::Replace(replaceSubset, "\n", "^l");
|
|
if (!ReplaceSubset(search, replaceSubset))
|
|
return false;
|
|
}
|
|
replace = ::Replace(replace, "\n", "^l");
|
|
return ReplaceSubset(search, replace);
|
|
}
|
|
String MSDoc::CleanString(String str) // Clean chars in String
|
|
{
|
|
String ret;
|
|
String valid = ">=<ºª%€&()$1234567890áéíóúÁÉÍÓÚñÑçÇ,.,:-_/¿?+*[]{}'\"!¡ \r\n";
|
|
for (int i = 0; i < str.GetCount(); ++i) {
|
|
int s = str[i];
|
|
if (IsLetter(s) || valid.Find(s) >= 0)
|
|
ret.Cat(s);
|
|
}
|
|
return ret;
|
|
}
|
|
bool MSDoc::ReplaceSubset(String search, String replace)
|
|
{
|
|
ObjectOle find;
|
|
if (!(find = Ole::GetObject(Selection, "Find")))
|
|
return false;
|
|
|
|
if(!Ole::Method(find, "ClearFormatting")) // Selection.Find.ClearFormatting
|
|
return false;
|
|
|
|
VariantOle vFindText;
|
|
vFindText.BString(search);
|
|
|
|
VariantOle vMatchCase;
|
|
vMatchCase.Bool(false);
|
|
|
|
VariantOle vMatchWholeWord;
|
|
vMatchWholeWord.Bool(false);
|
|
|
|
VariantOle vMatchWildcards;
|
|
vMatchWildcards.Bool(false);
|
|
|
|
VariantOle vMatchSoundsLike;
|
|
vMatchSoundsLike.Bool(false);
|
|
|
|
VariantOle vMatchAllWordForms;
|
|
vMatchAllWordForms.Bool(false);
|
|
|
|
VariantOle vForward;
|
|
vForward.Bool(true);
|
|
|
|
VariantOle vWrap;
|
|
vWrap.Int(wdFindContinue);
|
|
|
|
VariantOle vFormat;
|
|
vFormat.Bool(false);
|
|
|
|
VariantOle vReplaceWith;
|
|
vReplaceWith.BString(replace);
|
|
|
|
VariantOle vReplace;
|
|
vReplace.Int(wdReplaceAll);
|
|
|
|
return Ole::Method(find, "Execute", vReplace, vReplaceWith, vFormat, vWrap, vForward, vMatchAllWordForms, vMatchSoundsLike, vMatchWildcards, vMatchWholeWord, vMatchCase, vFindText);
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
class OOo
|
|
{
|
|
public:
|
|
static ObjectOle MakePropertyValue(String name, ::Value value)
|
|
{
|
|
ObjectOle ServiceManager;
|
|
if (!(ServiceManager = Ole::CreateObject("com.sun.star.ServiceManager")))
|
|
return NULL;
|
|
|
|
ObjectOle Struct;
|
|
VariantOle vstr;
|
|
vstr.BString("com.sun.star.beans.PropertyValue");
|
|
if (!(Struct = Ole::MethodGet(ServiceManager, "Bridge_GetStruct", vstr)))
|
|
return NULL;
|
|
|
|
VariantOle vname, vvalue;
|
|
vname.BString(name);
|
|
if (!Ole::SetValue(Struct, "Name", vname))
|
|
return NULL;
|
|
vvalue.Value(value);
|
|
if (!Ole::SetValue(Struct, "Value", vvalue))
|
|
return NULL;
|
|
return Struct;
|
|
}
|
|
static String ConvertToUrl(String strFile)
|
|
{
|
|
String ret;
|
|
String c;
|
|
|
|
for (int i = 0; i < strFile.GetCount(); ++i) {
|
|
if (strFile[i] >= 123)
|
|
c = "%" + Format("%x", strFile[i]);
|
|
else {
|
|
switch (strFile[i]) {
|
|
case 9: c = "%09"; break;
|
|
case 13: c = "%0d"; break;
|
|
case 10: c = "%0a"; break;
|
|
case 32: case 33: case 34: case 35: case 37: case 38: case 39: case 40: case 41: case 43:
|
|
case 44: case 59: case 60: case 61: case 62: case 63: case 91: case 93: case 94: case 96:
|
|
c = "%" + Format("%x", strFile[i]); break;
|
|
case '\\': c = "/"; break;
|
|
case ':': c = "|"; break;
|
|
default: c = strFile.Mid(i, 1);
|
|
}
|
|
}
|
|
ret.Cat(c);
|
|
}
|
|
return "file:///" + ret;
|
|
}
|
|
static ObjectOle CreateUnoService(String strServiceName)
|
|
{
|
|
ObjectOle ServiceManager;
|
|
if (!(ServiceManager = Ole::CreateObject("com.sun.star.ServiceManager")))
|
|
return NULL;
|
|
|
|
VariantOle vService;
|
|
vService.BString(strServiceName);
|
|
return Ole::MethodGet(ServiceManager, "createInstance", vService);
|
|
}
|
|
};
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
OPENSheet::OPENSheet()
|
|
{
|
|
ServiceManager = CoreReflection = Desktop = Document = Sheets = Sheet = Cell = Range = NULL;
|
|
selectedAll = false;
|
|
quit = false;
|
|
|
|
// The service manager is always the starting point
|
|
// If there is no office running then an office is started up
|
|
ObjectOle ServiceManager;
|
|
if (!(ServiceManager = Ole::CreateObject("com.sun.star.ServiceManager")))
|
|
return;
|
|
|
|
// Create the CoreReflection service that is later used to create structs
|
|
ObjectOle CoreReflection;
|
|
VariantOle vInstance;
|
|
vInstance.BString("com.sun.star.reflection.CoreReflection");
|
|
if (!(CoreReflection = Ole::MethodGet(ServiceManager, "createInstance", vInstance)))
|
|
return;
|
|
|
|
// Create the Desktop
|
|
VariantOle vDesktop;
|
|
vDesktop.BString("com.sun.star.frame.Desktop");
|
|
if (!(Desktop = Ole::MethodGet(ServiceManager, "createInstance", vDesktop)))
|
|
return;
|
|
}
|
|
|
|
OPENSheet::~OPENSheet()
|
|
{
|
|
if (Cell)
|
|
Cell->Release();
|
|
if (Range)
|
|
Range->Release();
|
|
if (Sheet)
|
|
Sheet->Release();
|
|
if (Sheets)
|
|
Sheets->Release();
|
|
if (Document)
|
|
Document->Release();
|
|
if (Desktop) {
|
|
Quit();
|
|
Desktop->Release();
|
|
}
|
|
if (CoreReflection)
|
|
CoreReflection->Release();
|
|
if (ServiceManager)
|
|
ServiceManager->Release();
|
|
}
|
|
bool OPENSheet::IsAvailable()
|
|
{
|
|
ObjectOle serviceManager;
|
|
if (!(serviceManager = Ole::CreateObject("com.sun.star.ServiceManager")))
|
|
return false;
|
|
else {
|
|
serviceManager->Release();
|
|
return true;
|
|
}
|
|
}
|
|
bool OPENSheet::SetSaved(bool saved)
|
|
{
|
|
VariantOle vval;
|
|
vval.Bool(!saved); // Modified is the opposite to saved
|
|
return Ole::Method(Document, "setModified", vval);
|
|
}
|
|
bool OPENSheet::Quit()
|
|
{
|
|
if (!quit) {
|
|
quit = true;
|
|
return Ole::Method(Desktop, "Terminate");
|
|
}
|
|
return true;
|
|
}
|
|
bool OPENSheet::InsertTab(String name)
|
|
{
|
|
if (!Sheets)
|
|
return false;
|
|
VariantOle vStr;
|
|
vStr.BString("com.sun.star.sheet.Spreadsheet");
|
|
if (!(Sheet = Ole::MethodGet(Document, "createInstance", vStr)))
|
|
return false;
|
|
|
|
vStr.BString(name);
|
|
|
|
VariantOle vsheet;
|
|
vsheet.ObjectOle(Sheet);
|
|
|
|
if (!(Ole::Method(Sheets, "insertByName", vsheet, vStr)))
|
|
return false;
|
|
|
|
// Set tab as active
|
|
ObjectOle View;
|
|
if (!(View = Ole::MethodGet(Document, "getCurrentController")))
|
|
return false;
|
|
|
|
VariantOle vSheet;
|
|
vSheet.ObjectOle(Sheet);
|
|
return Ole::SetValue(View, "ActiveSheet", vSheet);
|
|
}
|
|
bool OPENSheet::ChooseTab(String name)
|
|
{
|
|
if (!Sheets)
|
|
return false;
|
|
VariantOle vStr;
|
|
vStr.BString(name);
|
|
if (!(Sheet = Ole::MethodGet(Sheets, "getByName", vStr)))
|
|
return false;
|
|
|
|
// Set tab as active
|
|
ObjectOle View;
|
|
if (!(View = Ole::MethodGet(Document, "getCurrentController")))
|
|
return false;
|
|
|
|
VariantOle vSheet;
|
|
vSheet.ObjectOle(Sheet);
|
|
return Ole::SetValue(View, "ActiveSheet", vSheet);
|
|
}
|
|
bool OPENSheet::ChooseTab(int index)
|
|
{
|
|
if (!Sheets)
|
|
return false;
|
|
VariantOle vId;
|
|
vId.Int(index);
|
|
if (!(Sheet = Ole::MethodGet(Sheets, "getByIndex", vId)))
|
|
return false;
|
|
|
|
// Set tab as active
|
|
ObjectOle View;
|
|
if (!(View = Ole::MethodGet(Document, "getCurrentController")))
|
|
return false;
|
|
|
|
VariantOle vSheet;
|
|
vSheet.ObjectOle(Sheet);
|
|
return Ole::SetValue(View, "ActiveSheet", vSheet);
|
|
}
|
|
bool OPENSheet::RemoveTab(String name)
|
|
{
|
|
if (!Sheets)
|
|
return false;
|
|
VariantOle vStr;
|
|
vStr.BString(name);
|
|
if (!Ole::Method(Sheets, "removeByName", vStr))
|
|
return false;
|
|
return true;
|
|
}
|
|
bool OPENSheet::RemoveTab(int index)
|
|
{
|
|
if (!Sheets)
|
|
return false;
|
|
VariantOle vId;
|
|
vId.Int(index);
|
|
if (!Ole::Method(Sheets, "removeByIndex", vId))
|
|
return false;
|
|
return true;
|
|
}
|
|
int OPENSheet::GetNumTabs()
|
|
{
|
|
if (!Sheets)
|
|
return -1;
|
|
Value count;
|
|
count = Ole::GetValue(Sheets, "getCount");
|
|
return count;
|
|
}
|
|
bool OPENSheet::AddSheet(bool visible)
|
|
{
|
|
if (!Desktop)
|
|
return false;
|
|
|
|
VariantOle vArray;
|
|
vArray.ArrayDim(1);
|
|
VariantOle vobject;
|
|
vobject.ObjectOle(OOo::MakePropertyValue("Hidden", true));
|
|
vArray.ArraySetVariant(1, vobject);
|
|
|
|
VariantOle vFile;
|
|
vFile.BString("_blank");
|
|
VariantOle vSize;
|
|
vSize.Int4(0);
|
|
VariantOle vDocument;
|
|
vDocument.BString("private:factory/scalc");
|
|
if (!(Document = Ole::MethodGet(Desktop, "loadComponentFromURL", vArray, vSize, vFile, vDocument)))
|
|
return false;
|
|
|
|
if (!(Sheets = Ole::MethodGet(Document, "getSheets")))
|
|
return false;
|
|
|
|
if (!visible)
|
|
SetVisible(visible);
|
|
return true; //ChooseTab(0); // Select the first tab
|
|
}
|
|
bool OPENSheet::OpenSheet(String fileName, bool visible)
|
|
{
|
|
if (!Desktop)
|
|
return false;
|
|
|
|
VariantOle vArray;
|
|
vArray.ArrayDim(0);
|
|
|
|
VariantOle vFile;
|
|
vFile.BString("_blank");
|
|
VariantOle vSize;
|
|
vSize.Int4(0);
|
|
VariantOle vDocument;
|
|
vDocument.BString(OOo::ConvertToUrl(fileName));
|
|
if (!(Document = Ole::MethodGet(Desktop, "loadComponentFromURL", vArray, vSize, vFile, vDocument)))
|
|
return false;
|
|
|
|
if (!(Sheets = Ole::MethodGet(Document, "getSheets")))
|
|
return false;
|
|
|
|
if (!visible)
|
|
SetVisible(visible);
|
|
return ChooseTab(0); // Select the first tab
|
|
}
|
|
// Problem: It does hidden but not set visible again the window !!!
|
|
bool OPENSheet::SetVisible(bool visible)
|
|
{
|
|
if (!Document)
|
|
return false;
|
|
ObjectOle DocCtrl;
|
|
if (!(DocCtrl = Ole::MethodGet(Document, "getCurrentController")))
|
|
return false;
|
|
ObjectOle DocFrame;
|
|
if (!(DocFrame = Ole::MethodGet(DocCtrl, "getFrame")))
|
|
return false;
|
|
ObjectOle DocWindow;
|
|
if (!(DocWindow = Ole::MethodGet(DocFrame, "getContainerWindow")))
|
|
return false;
|
|
|
|
VariantOle vvisible;
|
|
vvisible.Bool(visible);
|
|
return Ole::Method(DocWindow, "setVisible", vvisible);
|
|
}
|
|
bool OPENSheet::Select(String range)
|
|
{
|
|
if (!Sheet)
|
|
return false;
|
|
VariantOle vrange;
|
|
vrange.BString(range);
|
|
if (!(Range = Ole::MethodGet(Sheet, "getCellRangeByName", vrange)))
|
|
return false;
|
|
return true;
|
|
}
|
|
bool OPENSheet::Select(int fromX, int fromY, int toX, int toY)
|
|
{
|
|
if (!Sheet)
|
|
return false;
|
|
VariantOle vX1, vY1, vX2, vY2;
|
|
vX1.Int(fromX-1); // Comienza en 0
|
|
vY1.Int(fromY-1);
|
|
vX2.Int(toX-1); // Comienza en 0
|
|
vY2.Int(toY-1);
|
|
if (!(Range = Ole::MethodGet(Sheet, "getCellRangeByPosition", vY2, vX2, vY1, vX1)))
|
|
return false;
|
|
selectedAll = false;
|
|
return true;
|
|
}
|
|
bool OPENSheet::Select()
|
|
{
|
|
if (!Sheet)
|
|
return false;
|
|
selectedAll = true;
|
|
return true;
|
|
}
|
|
/*
|
|
void OPENSheet::DefMatrix(int width, int height)
|
|
{
|
|
return;
|
|
}
|
|
void OPENSheet::SetMatrixValue(int x, int y, ::Value value)
|
|
{
|
|
return;
|
|
}
|
|
bool OPENSheet::FillSelectionMatrix()
|
|
{
|
|
return false;
|
|
}
|
|
*/
|
|
bool OPENSheet::Replace(Value search, Value replace)
|
|
{
|
|
if (!Sheet)
|
|
return false;
|
|
ObjectOle Search;
|
|
if (!(Search = Ole::MethodGet(Sheet, "createReplaceDescriptor")))
|
|
return false;
|
|
VariantOle vsearch, vreplace;
|
|
vsearch.BString(search);
|
|
Ole::Method(Search, "setSearchString", vsearch);
|
|
vreplace.BString(replace);
|
|
Ole::Method(Search, "setReplaceString", vreplace);
|
|
VariantOle vsrep;
|
|
vsrep.ObjectOle(Search);
|
|
|
|
ObjectOle *data;
|
|
if (selectedAll) {
|
|
if (!Sheet)
|
|
return false;
|
|
data = &Sheet;
|
|
} else {
|
|
if (!Range)
|
|
return false;
|
|
data = &Range;
|
|
}
|
|
if (!Ole::Method(*data, "replaceAll", vsrep))
|
|
return false;
|
|
return true;
|
|
}
|
|
Value OPENSheet::GetValue(int col, int row)
|
|
{
|
|
if (!SelCell(col, row))
|
|
return false;
|
|
return Ole::GetValue(Cell, "getFormula"); // Also valid getValue and getString
|
|
}
|
|
Value OPENSheet::GetValue(String cell)
|
|
{
|
|
int row, col;
|
|
|
|
OfficeSheet::CellToColRow(cell, col, row);
|
|
return GetValue(col, row);
|
|
}
|
|
bool OPENSheet::SaveAs(String fileName, String type)
|
|
{
|
|
if (!Document)
|
|
return false;
|
|
|
|
fileName = ForceExt(fileName, "." + type);
|
|
VariantOle vFileName;
|
|
vFileName.BString(OOo::ConvertToUrl(fileName));
|
|
|
|
String filter;
|
|
if (type == "xls")
|
|
filter = "MS Excel 97";
|
|
else if (type == "pxl")
|
|
filter = "Pocket Excel";
|
|
else if (type == "html")
|
|
filter = "HTML (StarCalc)";
|
|
else if (type == "txt")
|
|
filter = "Text - txt - csv (StarCalc)";
|
|
else if (type == "pdf")
|
|
filter = "calc_pdf_Export";
|
|
else if (type == "ods")
|
|
filter = "";
|
|
else
|
|
return false;
|
|
|
|
VariantOle vArraySave;
|
|
if (filter.IsEmpty()) {
|
|
vArraySave.ArrayDim(0);
|
|
return Ole::Method(Document, "storeToURL", vArraySave, vFileName);
|
|
} else {
|
|
VariantOle vArg;
|
|
vArg.ObjectOle(OOo::MakePropertyValue("FilterName", filter));
|
|
vArraySave.ArrayDim(1);
|
|
vArraySave.ArraySetVariant(1, vArg);
|
|
return Ole::Method(Document, "storeToURL", vArraySave, vFileName);
|
|
}
|
|
}
|
|
|
|
bool OPENSheet::SelCell(int x, int y)
|
|
{
|
|
if (!Sheet)
|
|
return false;
|
|
VariantOle vX, vY;
|
|
vX.Int(x-1); // Comienza en 0
|
|
vY.Int(y-1);
|
|
if (!(Cell = Ole::MethodGet(Sheet, "getCellByPosition", vY, vX)))
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
bool OPENSheet::SetValue(String cell, Value value) // cell in textual format like "B14"
|
|
{
|
|
int col, row;
|
|
OfficeSheet::CellToColRow(cell, col, row);
|
|
return SetValue(col, row, value);
|
|
}
|
|
bool OPENSheet::SetValue(int col, int row, Value value)
|
|
{
|
|
if (!SelCell(col, row))
|
|
return false;
|
|
VariantOle vText;
|
|
vText.Value(value);
|
|
if (value.Is<String>() || value.Is<Date>() || value.Is<Time>())
|
|
return Ole::Method(Cell, "setFormula", vText);
|
|
else
|
|
return Ole::Method(Cell, "setValue", vText);
|
|
}
|
|
bool OPENSheet::SetItalic(String cell, bool italic)
|
|
{
|
|
int col, row;
|
|
OfficeSheet::CellToColRow(cell, col, row);
|
|
return SetItalic(col, row, italic);
|
|
}
|
|
bool OPENSheet::SetItalic(int col, int row, bool italic)
|
|
{
|
|
if (!SelCell(col, row))
|
|
return false;
|
|
VariantOle vproperty, vvalue;
|
|
vproperty.BString("CharPosture");
|
|
if (italic)
|
|
vvalue.Int(2);
|
|
else
|
|
vvalue.Int(0);
|
|
return Ole::SetValue(Cell, "setPropertyValue", vvalue, vproperty);
|
|
}
|
|
bool OPENSheet::SetItalic(bool italic)
|
|
{
|
|
VariantOle vvalue;
|
|
if (italic)
|
|
vvalue.Int(2);
|
|
else
|
|
vvalue.Int(0);
|
|
return Ole::SetValue(Range, "CharPosture", vvalue);
|
|
}
|
|
bool OPENSheet::SetBold(String cell, bool bold)
|
|
{
|
|
int col, row;
|
|
OfficeSheet::CellToColRow(cell, col, row);
|
|
return SetBold(col, row, bold);
|
|
}
|
|
bool OPENSheet::SetBold(int col, int row, bool bold)
|
|
{
|
|
if (!SelCell(col, row))
|
|
return false;
|
|
VariantOle vproperty, vvalue;
|
|
vproperty.BString("CharBold");
|
|
vvalue.Bool(bold);
|
|
return Ole::SetValue(Cell, "setPropertyValue", vvalue, vproperty);
|
|
}
|
|
bool OPENSheet::SetBold(bool bold)
|
|
{
|
|
VariantOle vvalue;
|
|
if (bold)
|
|
vvalue.Int(150);
|
|
else
|
|
vvalue.Int(100);
|
|
return Ole::SetValue(Range, "CharWeight", vvalue);
|
|
}
|
|
bool OPENSheet::SetUnderline(String cell, bool underline)
|
|
{
|
|
int col, row;
|
|
OfficeSheet::CellToColRow(cell, col, row);
|
|
return SetBold(col, row, underline);
|
|
}
|
|
bool OPENSheet::SetUnderline(int col, int row, bool underline)
|
|
{
|
|
if (!SelCell(col, row))
|
|
return false;
|
|
VariantOle vproperty, vvalue;
|
|
vproperty.BString("CharUnderline");
|
|
vvalue.Bool(underline);
|
|
return Ole::SetValue(Cell, "setPropertyValue", vvalue, vproperty);
|
|
}
|
|
bool OPENSheet::SetUnderline(bool underline)
|
|
{
|
|
VariantOle vvalue;
|
|
if (underline)
|
|
vvalue.Int(1); // 2 is doble underline
|
|
else
|
|
vvalue.Int(0);
|
|
return Ole::SetValue(Range, "CharUnderline", vvalue);
|
|
}
|
|
// 2 Centered, 0 Normal, 1 left, 3 right
|
|
bool OPENSheet::SetHorizJustify(String cell, int justify)
|
|
{
|
|
int col, row;
|
|
OfficeSheet::CellToColRow(cell, col, row);
|
|
return SetHorizJustify(col, row, justify);
|
|
}
|
|
bool OPENSheet::SetHorizJustify(int col, int row, int justify)
|
|
{
|
|
if (!SelCell(col, row))
|
|
return false;
|
|
VariantOle vproperty, vvalue;
|
|
vproperty.BString("HoriJustify");
|
|
vvalue.Bool(justify);
|
|
return Ole::SetValue(Cell, "setPropertyValue", vvalue, vproperty);
|
|
}
|
|
// 2 Centered
|
|
bool OPENSheet::SetVertJustify(String cell, int justify)
|
|
{
|
|
int col, row;
|
|
OfficeSheet::CellToColRow(cell, col, row);
|
|
return SetVertJustify(col, row, justify);
|
|
}
|
|
bool OPENSheet::SetVertJustify(int col, int row, int justify)
|
|
{
|
|
if (!SelCell(col, row))
|
|
return false;
|
|
VariantOle vproperty, vvalue;
|
|
vproperty.BString("VertJustify");
|
|
vvalue.Bool(justify);
|
|
return Ole::SetValue(Cell, "setPropertyValue", vvalue, vproperty);
|
|
}
|
|
bool OPENSheet::SetFont(String cell, String name, int size)
|
|
{
|
|
int col, row;
|
|
OfficeSheet::CellToColRow(cell, col, row);
|
|
return SetFont(col, row, name, size);
|
|
}
|
|
bool OPENSheet::SetFont(int col, int row, String name, int size)
|
|
{
|
|
if (!SelCell(col, row))
|
|
return false;
|
|
VariantOle vproperty, vvalue;
|
|
vproperty.BString("CharFontName");
|
|
vvalue.BString(name);
|
|
Ole::Method(Cell, "setPropertyValue", vvalue, vproperty);
|
|
|
|
vproperty.BString("CharHeight");
|
|
vvalue.Int(size);
|
|
return Ole::Method(Cell, "setPropertyValue", vvalue, vproperty);
|
|
}
|
|
bool OPENSheet::SetFont(String name, int size)
|
|
{
|
|
VariantOle vvalue;
|
|
vvalue.BString(name);
|
|
Ole::SetValue(Range, "CharFontName", vvalue);
|
|
vvalue.Int(size);
|
|
return Ole::SetValue(Range, "CharHeight", vvalue);
|
|
}
|
|
bool OPENSheet::SetCellBackColor(String cell, Color color) // 2 Centered
|
|
{
|
|
int col, row;
|
|
OfficeSheet::CellToColRow(cell, col, row);
|
|
return SetCellBackColor(col, row, color);
|
|
}
|
|
bool OPENSheet::SetCellBackColor(int col, int row, Color color)
|
|
{
|
|
if (!SelCell(col, row))
|
|
return false;
|
|
VariantOle vproperty, vvalue;
|
|
vproperty.BString("CellBackColor");
|
|
vvalue.Int4(RGB(color.GetR(), color.GetG(), color.GetB()));
|
|
return Ole::SetValue(Cell, "setPropertyValue", vvalue, vproperty);
|
|
}
|
|
bool OPENSheet::SetFormat(String format)
|
|
{
|
|
int value;
|
|
|
|
if (format == "integer")
|
|
value = 1;
|
|
else if (format == "float")
|
|
value = 2;
|
|
else if (format == "date")
|
|
value = 37;
|
|
else if (format == "time")
|
|
value = 41;
|
|
else if (format == "datetime")
|
|
value = 51;
|
|
else
|
|
return false;
|
|
|
|
VariantOle vvalue;
|
|
vvalue.Int(value);
|
|
return Ole::SetValue(Range, "NumberFormat", vvalue);
|
|
}
|
|
bool OPENSheet::SetColWidth(int col, int width)
|
|
{
|
|
ObjectOle Columns;
|
|
if (!(Columns = Ole::MethodGet(Sheet, "getColumns")))
|
|
return false;
|
|
ObjectOle Column;
|
|
VariantOle vvalue;
|
|
vvalue.Int(col);
|
|
if (!(Column = Ole::MethodGet(Columns, "getByIndex", vvalue)))
|
|
return false;
|
|
vvalue.Int(width);
|
|
return Ole::SetValue(Column, "Width", vvalue);
|
|
}
|
|
|
|
bool OPENSheet::SetRowHeight(int row, int height)
|
|
{
|
|
ObjectOle Rows;
|
|
if (!(Rows = Ole::MethodGet(Sheet, "getRows")))
|
|
return false;
|
|
ObjectOle Row;
|
|
VariantOle vvalue;
|
|
vvalue.Int(row);
|
|
if (!(Row = Ole::MethodGet(Rows, "getByIndex", vvalue)))
|
|
return false;
|
|
vvalue.Int(height);
|
|
return Ole::SetValue(Row, "Height", vvalue);
|
|
}
|
|
bool OPENSheet::Print()
|
|
{
|
|
VariantOle vArrayPrint;
|
|
vArrayPrint.ArrayDim(1);
|
|
VariantOle vArg;
|
|
vArg.ObjectOle(OOo::MakePropertyValue("CopyCount", 1));
|
|
vArrayPrint.ArraySetVariant(1, vArg);
|
|
|
|
return Ole::Method(Document, "print", vArrayPrint);
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
OPENDoc::OPENDoc()
|
|
{
|
|
ServiceManager = CoreReflection = Desktop = Document = Text = Cursor = NULL;
|
|
quit = false;
|
|
|
|
// The service manager is always the starting point
|
|
// If there is no office running then an office is started up
|
|
ObjectOle ServiceManager;
|
|
if (!(ServiceManager = Ole::CreateObject("com.sun.star.ServiceManager")))
|
|
return;
|
|
|
|
// Create the CoreReflection service that is later used to create structs
|
|
ObjectOle CoreReflection;
|
|
VariantOle vInstance;
|
|
vInstance.BString("com.sun.star.reflection.CoreReflection");
|
|
if (!(CoreReflection = Ole::MethodGet(ServiceManager, "createInstance", vInstance)))
|
|
return;
|
|
|
|
// Create the Desktop
|
|
VariantOle vDesktop;
|
|
vDesktop.BString("com.sun.star.frame.Desktop");
|
|
if (!(Desktop = Ole::MethodGet(ServiceManager, "createInstance", vDesktop)))
|
|
return;
|
|
}
|
|
OPENDoc::~OPENDoc()
|
|
{
|
|
if (Cursor)
|
|
Cursor->Release();
|
|
if (Text)
|
|
Text->Release();
|
|
if (Document)
|
|
Document->Release();
|
|
if (Desktop) {
|
|
Quit();
|
|
Desktop->Release();
|
|
}
|
|
if (CoreReflection)
|
|
CoreReflection->Release();
|
|
if (ServiceManager)
|
|
ServiceManager->Release();
|
|
}
|
|
|
|
bool OPENDoc::IsAvailable()
|
|
{
|
|
ObjectOle serviceManager;
|
|
if (!(serviceManager = Ole::CreateObject("com.sun.star.ServiceManager")))
|
|
return false;
|
|
else {
|
|
serviceManager->Release();
|
|
return true;
|
|
}
|
|
}
|
|
bool OPENDoc::AddDoc(bool visible)
|
|
{
|
|
if (!Desktop)
|
|
return false;
|
|
|
|
VariantOle vArray;
|
|
vArray.ArrayDim(1);
|
|
VariantOle vobject;
|
|
vobject.ObjectOle(OOo::MakePropertyValue("Hidden", true));
|
|
vArray.ArraySetVariant(1, vobject);
|
|
|
|
VariantOle vFile;
|
|
vFile.BString("_blank");
|
|
VariantOle vSize;
|
|
vSize.Int4(0);
|
|
VariantOle vDocument;
|
|
vDocument.BString("private:factory/swriter");
|
|
if (!(Document = Ole::MethodGet(Desktop, "loadComponentFromURL", vArray, vSize, vFile, vDocument)))
|
|
return false;
|
|
|
|
if (!visible)
|
|
SetVisible(visible);
|
|
|
|
// Create a text object
|
|
if (!(Text = Ole::MethodGet(Document, "getText")))
|
|
return false;
|
|
|
|
// Create a cursor object
|
|
if (!(Cursor = Ole::MethodGet(Text, "createTextCursor")))
|
|
return false;
|
|
return true;
|
|
}
|
|
bool OPENDoc::OpenDoc(String fileName, bool visible)
|
|
{
|
|
if (!Desktop)
|
|
return false;
|
|
|
|
VariantOle vArray;
|
|
vArray.ArrayDim(1);
|
|
VariantOle vobject;
|
|
vobject.ObjectOle(OOo::MakePropertyValue("Hidden", true));
|
|
vArray.ArraySetVariant(1, vobject);
|
|
|
|
VariantOle vFile;
|
|
vFile.BString("_blank");
|
|
VariantOle vSize;
|
|
vSize.Int4(0);
|
|
VariantOle vDocument;
|
|
vDocument.BString(OOo::ConvertToUrl(fileName));
|
|
if (!(Document = Ole::MethodGet(Desktop, "loadComponentFromURL", vArray, vSize, vFile, vDocument)))
|
|
return false;
|
|
|
|
if (!visible)
|
|
SetVisible(visible);
|
|
|
|
// Create a text object
|
|
if (!(Text = Ole::MethodGet(Document, "getText")))
|
|
return false;
|
|
|
|
// Create a cursor object
|
|
if (!(Cursor = Ole::MethodGet(Text, "createTextCursor")))
|
|
return false;
|
|
return true;
|
|
}
|
|
bool OPENDoc::SetVisible(bool visible)
|
|
{
|
|
if (!Document)
|
|
return false;
|
|
ObjectOle DocCtrl;
|
|
if (!(DocCtrl = Ole::MethodGet(Document, "getCurrentController")))
|
|
return false;
|
|
ObjectOle DocFrame;
|
|
if (!(DocFrame = Ole::MethodGet(DocCtrl, "getFrame")))
|
|
return false;
|
|
ObjectOle DocWindow;
|
|
if (!(DocWindow = Ole::MethodGet(DocFrame, "getContainerWindow")))
|
|
return false;
|
|
|
|
VariantOle vvisible;
|
|
vvisible.Bool(visible);
|
|
return Ole::Method(DocWindow, "setVisible", vvisible);
|
|
}
|
|
bool OPENDoc::SetColor(Color col)
|
|
{
|
|
VariantOle vColor;
|
|
vColor.BString("CharColor");
|
|
VariantOle vValue;
|
|
vValue.Int4(RGB(col.GetR(), col.GetG(), col.GetB()));
|
|
return Ole::Method(Cursor, "setPropertyValue", vValue, vColor);
|
|
}
|
|
bool OPENDoc::SetFont(String font, int size)
|
|
{
|
|
VariantOle vFont;
|
|
vFont.BString("CharFontName");
|
|
VariantOle vValue;
|
|
vValue.BString(font);
|
|
Ole::Method(Cursor, "setPropertyValue", vValue, vFont);
|
|
VariantOle vHeight;
|
|
vHeight.BString("CharHeight");
|
|
vValue.Int(size);
|
|
return Ole::Method(Cursor, "setPropertyValue", vValue, vHeight);
|
|
}
|
|
bool OPENDoc::SetBold(bool bold)
|
|
{
|
|
VariantOle vvalue;
|
|
if (bold)
|
|
vvalue.Int(150);
|
|
else
|
|
vvalue.Int(100);
|
|
return Ole::SetValue(Cursor, "CharWeight", vvalue);
|
|
}
|
|
bool OPENDoc::SetItalic(bool italic)
|
|
{
|
|
VariantOle vvalue;
|
|
if (italic)
|
|
vvalue.Int(2);
|
|
else
|
|
vvalue.Int(0);
|
|
return Ole::SetValue(Cursor, "CharPosture", vvalue);
|
|
}
|
|
bool OPENDoc::WriteText(String str)
|
|
{
|
|
VariantOle vFalse;
|
|
vFalse.Bool(false);
|
|
VariantOle vText;
|
|
vText.BString(str);
|
|
VariantOle vCursor;
|
|
vCursor.ObjectOle(Cursor);
|
|
return Ole::Method(Text, "insertString", vFalse, vText, vCursor);
|
|
}
|
|
|
|
bool OPENDoc::Select() // Not used here
|
|
{
|
|
return true;
|
|
}
|
|
|
|
bool OPENDoc::Replace(String search, String replace)
|
|
{
|
|
ObjectOle Search;
|
|
if (!(Search = Ole::MethodGet(Document, "createReplaceDescriptor")))
|
|
return false;
|
|
VariantOle vsearch;
|
|
vsearch.BString(search);
|
|
Ole::Method(Search, "setSearchString", vsearch);
|
|
VariantOle vreplace;
|
|
vreplace.BString(replace);
|
|
Ole::Method(Search, "setReplaceString", vreplace);
|
|
|
|
VariantOle vsrep;
|
|
vsrep.ObjectOle(Search);
|
|
return Ole::Method(Document, "replaceAll", vsrep);
|
|
}
|
|
|
|
bool OPENDoc::Print()
|
|
{
|
|
/* Sorry. This does not run
|
|
VariantOle vArrayPrintConf;
|
|
vArrayPrintConf.ArrayDim(3);
|
|
|
|
vArg.ObjectOle(OOo::MakePropertyValue("Printer", "Default")); // Pages "1-15; 18"
|
|
vArrayPrintConf.ArraySetVariant(1, vArg);
|
|
vArg.ObjectOle(OOo::MakePropertyValue("PaperOrientation", "com.sun.star.view.PaperOrientation.PORTRAIT"));
|
|
vArrayPrintConf.ArraySetVariant(2, vArg);
|
|
vArg.ObjectOle(OOo::MakePropertyValue("PaperFormat", "com.sun.star.view.PaperFormat.A4"));
|
|
vArrayPrintConf.ArraySetVariant(3, vArg);
|
|
|
|
if (!(Ole::SetValue(Document, "SetPrinter", vArrayPrintConf)))
|
|
return false;
|
|
*/
|
|
VariantOle vArrayPrint;
|
|
vArrayPrint.ArrayDim(1);
|
|
VariantOle vArg;
|
|
vArg.ObjectOle(OOo::MakePropertyValue("CopyCount", 1));
|
|
vArrayPrint.ArraySetVariant(1, vArg);
|
|
// It runs
|
|
// vArg.ObjectOle(OOo::MakePropertyValue("Pages", "2")); // Pages "1-15; 18"
|
|
// vArrayPrint.ArraySetVariant(2, vArg);
|
|
|
|
return Ole::Method(Document, "print", vArrayPrint);
|
|
}
|
|
|
|
bool OPENDoc::SetSaved(bool saved)
|
|
{
|
|
VariantOle vval;
|
|
vval.Bool(!saved); // Modified is the opposite to saved
|
|
return Ole::Method(Document, "setModified", vval);
|
|
}
|
|
bool OPENDoc::SaveAs(String fileName, String type)
|
|
{
|
|
if (!Document)
|
|
return false;
|
|
|
|
fileName = ForceExt(fileName, "." + type);
|
|
VariantOle vFileName;
|
|
vFileName.BString(OOo::ConvertToUrl(fileName));
|
|
|
|
String filter;
|
|
if (type == "doc")
|
|
filter = "MS Word 97";
|
|
else if (type == "rtf")
|
|
filter = "Rich Text Format";
|
|
else if (type == "psw")
|
|
filter = "Pocket Word File";
|
|
else if (type == "html")
|
|
filter = "HTML (StarDoc)";
|
|
else if (type == "txt")
|
|
filter = "Text";
|
|
else if (type == "pdf")
|
|
filter = "writer_pdf_Export";
|
|
else if (type == "odt")
|
|
filter = "";
|
|
else
|
|
return false;
|
|
|
|
VariantOle vArraySave;
|
|
if (filter.IsEmpty())
|
|
vArraySave.ArrayDim(0);
|
|
else {
|
|
VariantOle vArg;
|
|
vArg.ObjectOle(OOo::MakePropertyValue("FilterName", filter));
|
|
vArraySave.ArrayDim(1);
|
|
vArraySave.ArraySetVariant(1, vArg);
|
|
}
|
|
return Ole::Method(Document, "storeToURL", vArraySave, vFileName);
|
|
}
|
|
bool OPENDoc::Quit()
|
|
{
|
|
if (!quit) {
|
|
quit = true;
|
|
return Ole::Method(Document, "Dispose");
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
OfficeSheet::OfficeSheet()
|
|
{
|
|
data = NULL;
|
|
Ole::Init();
|
|
}
|
|
OfficeSheet::~OfficeSheet()
|
|
{
|
|
if (!data)
|
|
return;
|
|
if (type == SheetOPEN)
|
|
delete (OPENSheet*)data;
|
|
else if (type == SheetMS)
|
|
delete (MSSheet*)data;
|
|
|
|
Ole::Close();
|
|
}
|
|
void OfficeSheet::CellToColRow(const char *cell, int &col, int &row)
|
|
{
|
|
String s_col;
|
|
int i;
|
|
int lenCell = strlen(cell);
|
|
for (i = 0; (i < lenCell) && (cell[i] >= 'A') && (cell[i] <= 'Z'); ++i)
|
|
s_col.Cat(cell[i]);
|
|
|
|
row = atoi(cell + i);
|
|
|
|
int num_az = 'Z' - 'A' + 1;
|
|
col = 0;
|
|
int len = s_col.GetCount();
|
|
int p = (int)pow((double)num_az, len-1);
|
|
for (int j = 0; j < s_col.GetCount(); ++j) {
|
|
col += (s_col[j] - 'A' + 1)*p;
|
|
p /= num_az;
|
|
}
|
|
}
|
|
String OfficeSheet::ColRowToCell(const int col, const int row)
|
|
{
|
|
String cell;
|
|
int num_az = 'Z' - 'A' + 1;
|
|
int firstLetter = col/num_az;
|
|
int secondLetter = col - firstLetter*num_az;
|
|
int len = firstLetter > 0 ? 2: 1;
|
|
|
|
StringBuffer bCell(len);
|
|
if (len == 2) {
|
|
bCell[0] = 'A' + firstLetter - 1;
|
|
bCell[1] = 'A' + secondLetter - 1;
|
|
} else if (len == 1)
|
|
bCell[0] = 'A' + secondLetter - 1;
|
|
else
|
|
return "Error";
|
|
bCell.Cat(AsString(row));
|
|
cell = bCell;
|
|
|
|
return cell;
|
|
}
|
|
bool OfficeSheet::IsAvailable(String strtype)
|
|
{
|
|
if (strtype == "Open")
|
|
return OPENSheet::IsAvailable();
|
|
else if (strtype == "Microsoft")
|
|
return MSSheet::IsAvailable();
|
|
else
|
|
return false;
|
|
}
|
|
bool OfficeSheet::Init(char *strtype)
|
|
{
|
|
if (data) {
|
|
if (type == SheetOPEN)
|
|
delete (OPENSheet*)data;
|
|
else if (type == SheetMS)
|
|
delete (MSSheet*)data;
|
|
}
|
|
if (strcmp(strtype, "Open") >= 0) {
|
|
type = SheetOPEN;
|
|
data = new OPENSheet();
|
|
} else if (strcmp(strtype, "Microsoft") >= 0) {
|
|
type = SheetMS;
|
|
data = new MSSheet();
|
|
} else
|
|
return false;
|
|
return true;
|
|
}
|
|
bool OfficeSheet::AddSheet(bool visible)
|
|
{
|
|
if (!data)
|
|
return false;
|
|
if (type == SheetOPEN)
|
|
return ((OPENSheet*)data)->AddSheet(visible);
|
|
else if (type == SheetMS)
|
|
return ((MSSheet*)data)->AddSheet(visible);
|
|
else
|
|
return false;
|
|
}
|
|
bool OfficeSheet::OpenSheet(String fileName, bool visible)
|
|
{
|
|
if (!data)
|
|
return false;
|
|
if (type == SheetOPEN)
|
|
return ((OPENSheet*)data)->OpenSheet(fileName, visible);
|
|
else if (type == SheetMS)
|
|
return ((MSSheet*)data)->OpenSheet(fileName, visible);
|
|
else
|
|
return false;
|
|
}
|
|
bool OfficeSheet::SetValue(int col, int row, Value value)
|
|
{
|
|
if (!data)
|
|
return false;
|
|
if (type == SheetOPEN)
|
|
return ((OPENSheet*)data)->SetValue(col, row, value);
|
|
else if (type == SheetMS)
|
|
return ((MSSheet*)data)->SetValue(col, row, value);
|
|
else
|
|
return false;
|
|
}
|
|
bool OfficeSheet::SetValue(String cell, Value value)
|
|
{
|
|
if (!data)
|
|
return false;
|
|
if (type == SheetOPEN)
|
|
return ((OPENSheet*)data)->SetValue(cell, value);
|
|
else if (type == SheetMS)
|
|
return ((MSSheet*)data)->SetValue(cell, value);
|
|
else
|
|
return false;
|
|
}
|
|
Value OfficeSheet::GetValue(String cell)
|
|
{
|
|
if (!data)
|
|
return Null;
|
|
if (type == SheetOPEN)
|
|
return ((OPENSheet*)data)->GetValue(cell);
|
|
else if (type == SheetMS)
|
|
return ((MSSheet*)data)->GetValue(cell);
|
|
else
|
|
return Null;
|
|
}
|
|
Value OfficeSheet::GetValue(int col, int row)
|
|
{
|
|
if (!data)
|
|
return Null;
|
|
if (type == SheetOPEN)
|
|
return ((OPENSheet*)data)->GetValue(col, row);
|
|
else if (type == SheetMS)
|
|
return ((MSSheet*)data)->GetValue(col, row);
|
|
else
|
|
return Null;
|
|
}
|
|
bool OfficeSheet::Replace(Value search, Value replace)
|
|
{
|
|
if (!data)
|
|
return false;
|
|
if (type == SheetOPEN)
|
|
return ((OPENSheet*)data)->Replace(search, replace);
|
|
else if (type == SheetMS)
|
|
return ((MSSheet*)data)->Replace(search, replace);
|
|
else
|
|
return false;
|
|
}
|
|
bool OfficeSheet::SetBold(int col, int row, bool bold)
|
|
{
|
|
if (!data)
|
|
return false;
|
|
if (type == SheetOPEN)
|
|
return ((OPENSheet*)data)->SetBold(col, row, bold);
|
|
else if (type == SheetMS)
|
|
return ((MSSheet*)data)->SetBold(col, row, bold);
|
|
else
|
|
return false;
|
|
}
|
|
bool OfficeSheet::SetBold(String cell, bool bold)
|
|
{
|
|
if (!data)
|
|
return false;
|
|
if (type == SheetOPEN)
|
|
return ((OPENSheet*)data)->SetBold(cell, bold);
|
|
else if (type == SheetMS)
|
|
return ((MSSheet*)data)->SetBold(cell, bold);
|
|
else
|
|
return false;
|
|
}
|
|
bool OfficeSheet::SetBold(bool bold)
|
|
{
|
|
if (!data)
|
|
return false;
|
|
if (type == SheetOPEN)
|
|
return ((OPENSheet*)data)->SetBold(bold);
|
|
else if (type == SheetMS)
|
|
return ((MSSheet*)data)->SetBold(bold);
|
|
else
|
|
return false;
|
|
}
|
|
bool OfficeSheet::SetFont(int col, int row, String name, int size)
|
|
{
|
|
if (!data)
|
|
return false;
|
|
if (type == SheetOPEN)
|
|
return ((OPENSheet*)data)->SetFont(col, row, name, size);
|
|
else if (type == SheetMS)
|
|
return ((MSSheet*)data)->SetFont(col, row, name, size);
|
|
else
|
|
return false;
|
|
}
|
|
bool OfficeSheet::SetFont(String cell, String name, int size)
|
|
{
|
|
if (!data)
|
|
return false;
|
|
if (type == SheetOPEN)
|
|
return ((OPENSheet*)data)->SetFont(cell, name, size);
|
|
else if (type == SheetMS)
|
|
return ((MSSheet*)data)->SetFont(cell, name, size);
|
|
else
|
|
return false;
|
|
}
|
|
bool OfficeSheet::SetFont(String name, int size)
|
|
{
|
|
if (!data)
|
|
return false;
|
|
if (type == SheetOPEN)
|
|
return ((OPENSheet*)data)->SetFont(name, size);
|
|
else if (type == SheetMS)
|
|
return ((MSSheet*)data)->SetFont(name, size);
|
|
else
|
|
return false;
|
|
}
|
|
bool OfficeSheet::Select(String range)
|
|
{
|
|
if (!data)
|
|
return false;
|
|
if (type == SheetOPEN)
|
|
return ((OPENSheet*)data)->Select(range);
|
|
else if (type == SheetMS)
|
|
return ((MSSheet*)data)->Select(range);
|
|
else
|
|
return false;
|
|
}
|
|
bool OfficeSheet::Select(int fromX, int fromY, int toX, int toY)
|
|
{
|
|
if (!data)
|
|
return false;
|
|
if (type == SheetOPEN)
|
|
return ((OPENSheet*)data)->Select(fromX, fromY, toX, toY);
|
|
else if (type == SheetMS)
|
|
return ((MSSheet*)data)->Select(fromX, fromY, toX, toY);
|
|
else
|
|
return false;
|
|
}
|
|
bool OfficeSheet::Select()
|
|
{
|
|
if (!data)
|
|
return false;
|
|
if (type == SheetOPEN)
|
|
return ((OPENSheet*)data)->Select();
|
|
else if (type == SheetMS)
|
|
return ((MSSheet*)data)->Select();
|
|
else
|
|
return false;
|
|
}
|
|
/*
|
|
void OfficeSheet::DefMatrix(int width, int height)
|
|
{
|
|
if (!data)
|
|
return;
|
|
if (type == SheetOPEN)
|
|
((OPENSheet*)data)->DefMatrix(width, height);
|
|
else if (type == SheetMS)
|
|
((MSSheet*)data)->DefMatrix(width, height);
|
|
else
|
|
return;
|
|
}
|
|
bool OfficeSheet::FillSelectionMatrix()
|
|
{
|
|
if (!data)
|
|
return false;
|
|
if (type == SheetOPEN)
|
|
return ((OPENSheet*)data)->FillSelectionMatrix();
|
|
else if (type == SheetMS)
|
|
return ((MSSheet*)data)->FillSelectionMatrix();
|
|
else
|
|
return false;
|
|
}
|
|
void OfficeSheet::SetMatrixValue(int i, int j, ::Value value)
|
|
{
|
|
if (!data)
|
|
return;
|
|
if (type == SheetOPEN)
|
|
((OPENSheet*)data)->SetMatrixValue(i, j, value);
|
|
else if (type == SheetMS)
|
|
((MSSheet*)data)->SetMatrixValue(i, j, value);
|
|
else
|
|
return;
|
|
}
|
|
*/
|
|
bool OfficeSheet::SaveAs(String fileName, String _type)
|
|
{
|
|
if (!data)
|
|
return false;
|
|
if (type == SheetOPEN) {
|
|
int ret;
|
|
ret = ((OPENSheet*)data)->SaveAs(fileName, _type);
|
|
((OPENSheet*)data)->SetSaved(true);
|
|
return ret;
|
|
} else if (type == SheetMS) {
|
|
((MSSheet*)data)->SetSaved(true);
|
|
return ((MSSheet*)data)->SaveAs(fileName, _type);
|
|
} else
|
|
return false;
|
|
}
|
|
|
|
bool OfficeSheet::Quit()
|
|
{
|
|
if (!data)
|
|
return false;
|
|
if (type == SheetOPEN)
|
|
return ((OPENSheet*)data)->Quit();
|
|
else if (type == SheetMS)
|
|
return ((MSSheet*)data)->Quit();
|
|
else
|
|
return false;
|
|
}
|
|
bool OfficeSheet::Print()
|
|
{
|
|
if (!data)
|
|
return false;
|
|
if (type == SheetOPEN)
|
|
return ((OPENSheet*)data)->Print();
|
|
else if (type == SheetMS)
|
|
return ((MSSheet*)data)->Print();
|
|
else
|
|
return false;
|
|
}
|
|
bool OfficeSheet::InsertTab(String name)
|
|
{
|
|
if (!data)
|
|
return false;
|
|
if (type == SheetOPEN)
|
|
return ((OPENSheet*)data)->InsertTab(name);
|
|
else if (type == SheetMS)
|
|
return ((MSSheet*)data)->InsertTab(name);
|
|
else
|
|
return false;
|
|
}
|
|
bool OfficeSheet::ChooseTab(String name)
|
|
{
|
|
if (!data)
|
|
return false;
|
|
if (type == SheetOPEN)
|
|
return ((OPENSheet*)data)->ChooseTab(name);
|
|
else if (type == SheetMS)
|
|
return ((MSSheet*)data)->ChooseTab(name);
|
|
else
|
|
return false;
|
|
}
|
|
bool OfficeSheet::ChooseTab(int index)
|
|
{
|
|
if (!data)
|
|
return false;
|
|
if (type == SheetOPEN)
|
|
return ((OPENSheet*)data)->ChooseTab(index);
|
|
else if (type == SheetMS)
|
|
return ((MSSheet*)data)->ChooseTab(index);
|
|
else
|
|
return false;
|
|
}
|
|
bool OfficeSheet::RemoveTab(String name)
|
|
{
|
|
if (!data)
|
|
return false;
|
|
if (type == SheetOPEN)
|
|
return ((OPENSheet*)data)->RemoveTab(name);
|
|
else if (type == SheetMS)
|
|
return ((MSSheet*)data)->RemoveTab(name);
|
|
else
|
|
return false;
|
|
}
|
|
bool OfficeSheet::RemoveTab(int index)
|
|
{
|
|
if (!data)
|
|
return false;
|
|
if (type == SheetOPEN)
|
|
return ((OPENSheet*)data)->RemoveTab(index);
|
|
else if (type == SheetMS)
|
|
return ((MSSheet*)data)->RemoveTab(index);
|
|
else
|
|
return false;
|
|
}
|
|
int OfficeSheet::GetNumTabs()
|
|
{
|
|
if (!data)
|
|
return false;
|
|
if (type == SheetOPEN)
|
|
return ((OPENSheet*)data)->GetNumTabs();
|
|
else if (type == SheetMS)
|
|
return ((MSSheet*)data)->GetNumTabs();
|
|
else
|
|
return false;
|
|
}
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////
|
|
OfficeDoc::OfficeDoc()
|
|
{
|
|
data = NULL;
|
|
Ole::Init();
|
|
}
|
|
OfficeDoc::~OfficeDoc()
|
|
{
|
|
if (!data)
|
|
return;
|
|
if (type == DocOPEN)
|
|
delete (OPENDoc*)data;
|
|
else if (type == DocMS)
|
|
delete (MSDoc*)data;
|
|
|
|
Ole::Close();
|
|
}
|
|
bool OfficeDoc::IsAvailable(char *strtype)
|
|
{
|
|
if (strcmp(strtype, "Open") >= 0)
|
|
return OPENDoc::IsAvailable();
|
|
else if (strcmp(strtype, "Microsoft") >= 0)
|
|
return MSDoc::IsAvailable();
|
|
else
|
|
return false;
|
|
}
|
|
bool OfficeDoc::Init(char *strtype)
|
|
{
|
|
if (data) {
|
|
if (type == DocOPEN)
|
|
delete (OPENDoc*)data;
|
|
else if (type == DocMS)
|
|
delete (MSDoc*)data;
|
|
}
|
|
if (strcmp(strtype, "Open") >= 0) {
|
|
type = DocOPEN;
|
|
data = new OPENDoc();
|
|
} else if (strcmp(strtype, "Microsoft") >= 0) {
|
|
type = DocMS;
|
|
data = new MSDoc();
|
|
} else
|
|
return false;
|
|
return true;
|
|
}
|
|
bool OfficeDoc::AddDoc(bool visible)
|
|
{
|
|
if (!data)
|
|
return false;
|
|
if (type == DocOPEN)
|
|
return ((OPENDoc*)data)->AddDoc(visible);
|
|
else if (type == DocMS)
|
|
return ((MSDoc*)data)->AddDoc(visible);
|
|
else
|
|
return false;
|
|
}
|
|
bool OfficeDoc::OpenDoc(String fileName, bool visible)
|
|
{
|
|
if (!data)
|
|
return false;
|
|
if (type == DocOPEN)
|
|
return ((OPENDoc*)data)->OpenDoc(fileName, visible);
|
|
else if (type == DocMS)
|
|
return ((MSDoc*)data)->OpenDoc(fileName, visible);
|
|
else
|
|
return false;
|
|
}
|
|
bool OfficeDoc::SetFont(String font, int size)
|
|
{
|
|
if (!data)
|
|
return false;
|
|
if (type == DocOPEN)
|
|
return ((OPENDoc*)data)->SetFont(font, size);
|
|
else if (type == DocMS)
|
|
return ((MSDoc*)data)->SetFont(font, size);
|
|
else
|
|
return false;
|
|
}
|
|
bool OfficeDoc::SetBold(bool bold)
|
|
{
|
|
if (!data)
|
|
return false;
|
|
if (type == DocOPEN)
|
|
return ((OPENDoc*)data)->SetBold(bold);
|
|
else if (type == DocMS)
|
|
return ((MSDoc*)data)->SetBold(bold);
|
|
else
|
|
return false;
|
|
}
|
|
bool OfficeDoc::SetItalic(bool italic)
|
|
{
|
|
if (!data)
|
|
return false;
|
|
if (type == DocOPEN)
|
|
return ((OPENDoc*)data)->SetItalic(italic);
|
|
else if (type == DocMS)
|
|
return ((MSDoc*)data)->SetItalic(italic);
|
|
else
|
|
return false;
|
|
}
|
|
bool OfficeDoc::WriteText(String value)
|
|
{
|
|
if (!data)
|
|
return false;
|
|
if (type == DocOPEN)
|
|
return ((OPENDoc*)data)->WriteText(value);
|
|
else if (type == DocMS)
|
|
return ((MSDoc*)data)->WriteText(value);
|
|
else
|
|
return false;
|
|
}
|
|
bool OfficeDoc::Select()
|
|
{
|
|
if (!data)
|
|
return false;
|
|
if (type == DocOPEN)
|
|
return ((OPENDoc*)data)->Select();
|
|
else if (type == DocMS)
|
|
return ((MSDoc*)data)->Select();
|
|
else
|
|
return false;
|
|
}
|
|
bool OfficeDoc::Replace(String search, String replace)
|
|
{
|
|
if (!data)
|
|
return false;
|
|
if (type == DocOPEN)
|
|
return ((OPENDoc*)data)->Replace(search, replace);
|
|
else if (type == DocMS)
|
|
return ((MSDoc*)data)->Replace(search, replace);
|
|
else
|
|
return false;
|
|
}
|
|
bool OfficeDoc::Print()
|
|
{
|
|
if (!data)
|
|
return false;
|
|
if (type == DocOPEN)
|
|
return ((OPENDoc*)data)->Print();
|
|
else if (type == DocMS)
|
|
return ((MSDoc*)data)->Print();
|
|
else
|
|
return false;
|
|
}
|
|
bool OfficeDoc::SaveAs(String fileName, String _type)
|
|
{
|
|
if (!data)
|
|
return false;
|
|
if (type == DocOPEN) {
|
|
int ret;
|
|
ret = ((OPENDoc*)data)->SaveAs(fileName, _type);
|
|
((OPENDoc*)data)->SetSaved(true);
|
|
return ret;
|
|
} else if (type == DocMS) {
|
|
((MSDoc*)data)->SetSaved(true);
|
|
return ((MSDoc*)data)->SaveAs(fileName, _type);
|
|
} else
|
|
return false;
|
|
}
|
|
|
|
bool OfficeDoc::Quit()
|
|
{
|
|
if (!data)
|
|
return false;
|
|
if (type == DocOPEN)
|
|
return ((OPENDoc*)data)->Quit();
|
|
else if (type == DocMS)
|
|
return ((MSDoc*)data)->Quit();
|
|
else
|
|
return false;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|