/*
* Copyright (C) 2022 Linux Studio Plugins Project
* (C) 2022 Vladimir Sadovnikov
*
* This file is part of lsp-ws-lib
* Created on: 19 июл. 2022 г.
*
* lsp-ws-lib is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* any later version.
*
* lsp-ws-lib is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with lsp-ws-lib. If not, see .
*/
#include
#include
#include
#include
#include
#include
namespace
{
static const char * const mimes[] =
{
"UTF8_STRING",
"text/plain;charset=utf-8",
"text/plain;charset=UTF-16LE",
"text/plain;charset=UTF-16BE",
"text/plain;charset=US-ASCII",
"text/plain",
NULL
};
static const char *characters =
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
}
MTEST_BEGIN("ws.display", clipboard)
// Clipboard data source
class CbDataSource: public ws::IDataSource
{
private:
LSPString sText;
test_type_t *pTest;
public:
explicit CbDataSource(test_type_t *test, const LSPString &text) : ws::IDataSource(mimes)
{
pTest = test;
sText.set(&text);
}
virtual ~CbDataSource()
{
}
public:
virtual io::IInStream *open(const char *mime) override
{
// Scan supported MIME types
ssize_t idx = -1, i=0;
for (const char *const *p = mimes; *p != NULL; ++p, ++i)
{
if (!::strcasecmp(mimes[i], mime))
{
idx = i;
break;
}
}
// Analyze found MIME type
void *data = NULL;
size_t bytes = 0;
switch (idx)
{
case 0: // UTF8_STRING
case 1: // text/plain;charset=utf-8
data = sText.clone_utf8(&bytes);
bytes -= sizeof(char); // 1 extra byte for zero character
break;
case 2: // text/plain;charset=UTF-16LE
data = __IF_LEBE(
sText.clone_utf16(&bytes),
sText.clone_native(&bytes, "UTF16-LE")
);
bytes -= sizeof(lsp_utf16_t); // 2 extra bytes for zero character
break;
case 3: // text/plain;charset=UTF-16BE
data = __IF_LEBE(
sText.clone_native(&bytes, "UTF16-BE"),
sText.clone_utf16(&bytes)
);
bytes -= sizeof(lsp_utf16_t); // 2 extra bytes for zero character
break;
case 4:
data = sText.clone_ascii(&bytes);
bytes -= sizeof(char); // 1 extra byte for zero character
break;
case 5:
data = sText.clone_native(&bytes);
bytes -= sizeof(char); // 4 extra byte for zero character
break;
default:
break;
}
// Format not supported?
if (data == NULL)
return NULL;
// Allocate memory stream;
io::InMemoryStream *stream = new io::InMemoryStream(data, bytes, MEMDROP_FREE);
if (stream == NULL)
{
::free(data);
return NULL;
}
return stream;
}
};
// Clipboard data sink
class CbDataSink: public ws::IDataSink
{
protected:
test_type_t *pTest;
io::OutMemoryStream sOS;
ssize_t nMime;
const char *pMime;
public:
explicit CbDataSink(test_type_t *test)
{
pTest = test;
nMime = -1;
pMime = NULL;
}
virtual ~CbDataSink()
{
clear();
}
public:
inline const char *mime() const { return pMime; }
public:
void clear()
{
sOS.drop();
nMime = -1;
pMime = NULL;
}
virtual ssize_t open(const char * const *mime_types) override
{
ssize_t self_idx = 0, found = -1;
for (const char *const *p = mimes; (*p != NULL) && (found < 0); ++p, ++self_idx)
{
ssize_t src_idx = 0;
for (const char *const *v = mime_types; (*v != NULL) && (found < 0); ++v, ++src_idx)
{
if (!::strcasecmp(*p, *v))
{
found = src_idx;
nMime = self_idx;
pMime = *p;
break;
}
}
}
if (found < 0)
return -STATUS_UNSUPPORTED_FORMAT;
pTest->printf("Selected mime type: %s, index=%d\n", pMime, found);
return found;
}
virtual status_t write(const void *buf, size_t count) override
{
if (pMime == NULL)
return STATUS_CLOSED;
ssize_t written = sOS.write(buf, count);
return (written >= ssize_t(count)) ? STATUS_OK : STATUS_UNKNOWN_ERR;
}
virtual status_t close(status_t code) override
{
if (pMime == NULL)
{
clear();
return STATUS_OK;
}
// Commit data
LSPString tmp;
if (code == STATUS_OK)
{
bool ok = false;
code = STATUS_NO_MEM;
switch (nMime)
{
case 0: // text/plain;charset=utf-8
case 1: // UTF8_STRING
ok = tmp.set_utf8(reinterpret_cast(sOS.data()), sOS.size());
break;
case 2: // text/plain;charset=UTF-16LE
ok =
__IF_LEBE(
tmp.set_utf16(reinterpret_cast(sOS.data())),
tmp.set_native(reinterpret_cast(sOS.data()), "UTF16-LE")
);
break;
case 3: // text/plain;charset=UTF-16BE
ok =
__IF_LEBE(
tmp.set_native(reinterpret_cast(sOS.data()), "UTF16-BE"),
tmp.set_utf16(reinterpret_cast(sOS.data()))
);
break;
case 4: // text/plain;charset=US-ASCII
ok = tmp.set_ascii(reinterpret_cast(sOS.data()));
break;
case 5: // text/plain
ok = tmp.set_native(reinterpret_cast(sOS.data()), sOS.size());
break;
default:
code = STATUS_UNSUPPORTED_FORMAT;
break;
}
// Successful set?
if (ok)
code = STATUS_OK;
}
// Drop data
clear();
// Submit fetched data to callback method
if (code == 0)
pTest->printf("Received clipboard data:\n%s\n", tmp.get_native());
else
pTest->printf("Failed to receive clipboard data: error=%d\n", int(code));
return code;
}
};
class Handler: public ws::IEventHandler
{
private:
test_type_t *pTest;
ws::IWindow *pWnd;
public:
inline Handler(test_type_t *test, ws::IWindow *wnd)
{
pTest = test;
pWnd = wnd;
}
void copy_to_clipboard(size_t id)
{
// Generate some random string
LSPString tmp;
size_t n = strlen(characters);
for (size_t r=0; r<8; ++r)
{
for (size_t c=0; c<64; ++c)
tmp.append(characters[rand() % n]);
tmp.append('\n');
}
// Create clpboard data source
CbDataSource *ds = new CbDataSource(pTest, tmp);
if (ds == NULL)
return;
ds->acquire();
lsp_finally{ ds->release(); };
// Commit data source to clipboard
pWnd->display()->set_clipboard(id, ds);
// Output message to console
pTest->printf("Submitted clipboard data:\n%s\n", tmp.get_native());
}
void paste_from_clipboard(size_t id)
{
CbDataSink *ds = new CbDataSink(pTest);
if (ds == NULL)
return;
ds->acquire();
lsp_finally{ ds->release(); };
pWnd->display()->get_clipboard(id, ds);
}
virtual status_t handle_event(const ws::event_t *ev) override
{
switch (ev->nType)
{
case ws::UIE_MOUSE_CLICK:
{
if (ev->nState & ws::MCF_CONTROL)
{
if (ev->nCode == ws::MCB_LEFT)
copy_to_clipboard(ws::CBUF_PRIMARY);
else if (ev->nCode == ws::MCB_RIGHT)
copy_to_clipboard(ws::CBUF_CLIPBOARD);
}
else if (ev->nState & ws::MCF_SHIFT)
{
if (ev->nCode == ws::MCB_LEFT)
paste_from_clipboard(ws::CBUF_PRIMARY);
else if (ev->nCode == ws::MCB_RIGHT)
paste_from_clipboard(ws::CBUF_CLIPBOARD);
}
return STATUS_OK;
}
// Redraw event
case ws::UIE_REDRAW:
{
Color c;
c.set_rgb24(0x0088cc);
ws::ISurface *s = pWnd->get_surface();
if (s == NULL)
return STATUS_OK;
// Perform drawing
s->begin();
s->clear(c);
s->end();
return STATUS_OK;
}
case ws::UIE_CLOSE:
{
pTest->printf("CLOSE\n");
pWnd->hide();
pWnd->display()->quit_main();
break;
}
default:
return IEventHandler::handle_event(ev);
}
return STATUS_OK;
}
};
MTEST_MAIN
{
ws::IDisplay *dpy = ws::create_display(0, NULL);
MTEST_ASSERT(dpy != NULL);
lsp_finally { ws::free_display(dpy); };
ws::IWindow *wnd = dpy->create_window();
MTEST_ASSERT(wnd != NULL);
lsp_finally {
wnd->destroy();
delete wnd;
};
MTEST_ASSERT(wnd->init() == STATUS_OK);
MTEST_ASSERT(wnd->set_caption("Test clipboard") == STATUS_OK);
MTEST_ASSERT(wnd->resize(320, 200) == STATUS_OK);
MTEST_ASSERT(wnd->set_window_actions(ws::WA_ALL) == STATUS_OK);
MTEST_ASSERT(wnd->set_size_constraints(160, 100, 640, 400) == STATUS_OK);
Handler h(this, wnd);
wnd->set_handler(&h);
MTEST_ASSERT(wnd->show() == STATUS_OK);
MTEST_ASSERT(dpy->main() == STATUS_OK);
}
MTEST_END