copynpaste.cpp

Go to the documentation of this file.

/*
 *  The ManaPlus Client
 *  Copyright (C) 2001-2010  Wormux Team
 *  Copyright (C) 2011-2019  The ManaPlus Developers
 *  Copyright (C) 2019-2021  Andrei Karas
 *
 *  This file is part of The ManaPlus Client.
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  any later version.
 *
 *  This program 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 General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
/*
 *  IMPORTANT!
 *
 *  This code was taken from Wormux svn trunk at Feb 25 2010. Please don't
 *  make any unnecessary modifications, and try to sync up modifications
 *  when possible.
 */
 
#ifdef _MSC_VER
# include "msvc/config.h"
#elif defined(HAVE_CONFIG_H)
#include "config.h"
#endif  // _MSC_VER
 
#include "utils/copynpaste.h"
 
#include "debug.h"
 
#ifdef USE_SDL2
PRAGMA48(GCC diagnostic push)
PRAGMA48(GCC diagnostic ignored "-Wshadow")
#include <SDL_clipboard.h>
PRAGMA48(GCC diagnostic pop)
 
#else  // USE_SDL2
 
#if defined(__APPLE__)
#ifdef Status
#undef Status
#endif  // Status
#include <Carbon/Carbon.h>
#elif defined USE_X11
#include "render/graphics.h"
 
#include "utils/sdlhelper.h"
 
PRAGMA48(GCC diagnostic push)
PRAGMA48(GCC diagnostic ignored "-Wshadow")
#include <SDL_syswm.h>
PRAGMA48(GCC diagnostic pop)
#include <unistd.h>
#elif defined __native_client__
#include "utils/naclmessages.h"
#elif defined WIN32
#include "utils/cast.h"
PRAGMA48(GCC diagnostic push)
PRAGMA48(GCC diagnostic ignored "-Wshadow")
#include <SDL_syswm.h>
PRAGMA48(GCC diagnostic pop)
#endif  // defined(__APPLE__)
 
#endif  // USE_SDL2
 
#ifdef USE_SDL2
bool retrieveBuffer(std::string& text, size_t& pos)
{
    char *buf = SDL_GetClipboardText();
    if (buf)
    {
        text.insert(pos, buf);
        pos += strlen(buf);
        SDL_free(buf);
        return true;
    }
    return false;
}
 
bool sendBuffer(const std::string &restrict text)
{
    return !SDL_SetClipboardText(text.c_str());
}
 
#else  //  USE_SDL2
 
#ifdef WIN32
bool retrieveBuffer(std::string& text, size_t& pos)
{
    bool ret = false;
 
    if (!OpenClipboard(nullptr))
        return false;
 
    HANDLE h = GetClipboardData(CF_UNICODETEXT);
    if (h)
    {
        LPCWSTR data = static_cast<LPCWSTR>(GlobalLock(h));
 
        if (data)
        {
            const size_t len = WideCharToMultiByte(CP_UTF8, 0, data, -1,
                nullptr, 0, nullptr, nullptr);
            if (len > 0)
            {
                // Convert from UTF-16 to UTF-8
                void *temp = calloc(len, 1);
                if (WideCharToMultiByte(CP_UTF8, 0, data, -1,
                    static_cast<LPSTR>(temp), len, nullptr, nullptr))
                {
                    text.insert(pos, static_cast<char*>(temp));
                    pos += len - 1;
                }
                free(temp);
                ret = true;
            }
        }
        GlobalUnlock(h);
    }
    else
    {
        h = GetClipboardData(CF_TEXT);
 
        if (h)
        {
            const char *const data = static_cast<char*>(GlobalLock(h));
            if (data)
            {
                text.insert(pos, data);
                pos += strlen(data);
                ret = true;
            }
            GlobalUnlock(h);
        }
    }
 
    CloseClipboard();
    return ret;
}
 
bool sendBuffer(const std::string &restrict text)
{
    const int wCharsLen = MultiByteToWideChar(CP_UTF8,
        0, text.c_str(), -1, nullptr, 0);
    if (!wCharsLen)
        return false;
 
    HANDLE h = GlobalAlloc(GMEM_MOVEABLE | GMEM_DDESHARE,
        CAST_SIZE(wCharsLen) * sizeof(WCHAR));
    WCHAR *const out = static_cast<WCHAR*>(GlobalLock(h));
 
    MultiByteToWideChar(CP_UTF8, 0, text.c_str(), -1, out, wCharsLen);
 
    if (!OpenClipboard(nullptr))
    {
        GlobalUnlock(h);
        GlobalFree(h);
        return false;
    }
    GlobalUnlock(h);
    EmptyClipboard();
    if (!SetClipboardData(CF_UNICODETEXT, out))
    {
        GlobalFree(h);
        CloseClipboard();
        return false;
    }
    GlobalFree(h);
    CloseClipboard();
 
    return true;
}
 
#elif defined(__APPLE__)
 
// Sorry for the very long code, all nicer OS X APIs are coded in
// Objective C and not C!
// Also it does very thorough error handling
bool getDataFromPasteboard(PasteboardRef inPasteboard,
                           char* flavorText /* out */,
                           const int bufSize)
{
    ItemCount itemCount;
    PasteboardSyncFlags syncFlags = PasteboardSynchronize(inPasteboard);
    OSStatus err = PasteboardGetItemCount(inPasteboard, &itemCount);
    require_noerr(err, CantGetPasteboardItemCount);
 
    for (UInt32 itemIndex = 1; itemIndex <= itemCount; itemIndex ++)
    {
        PasteboardItemID    itemID;
        CFArrayRef          flavorTypeArray;
        CFIndex             flavorCount;
 
        err = PasteboardGetItemIdentifier(inPasteboard, itemIndex, &itemID);
        require_noerr(err, CantGetPasteboardItemIdentifier);
 
        err = PasteboardCopyItemFlavors(inPasteboard,
            itemID, &flavorTypeArray);
        require_noerr(err, CantCopyPasteboardItemFlavors);
 
        flavorCount = CFArrayGetCount(flavorTypeArray);
 
        for (CFIndex flavorIndex = 0; flavorIndex < flavorCount;
             flavorIndex ++)
        {
            CFStringRef flavorType = (CFStringRef)CFArrayGetValueAtIndex(
                flavorTypeArray, flavorIndex);
 
            // we're only interested by text...
            if (UTTypeConformsTo(flavorType, CFSTR("public.utf8-plain-text")))
            {
                CFDataRef flavorData;
                err = PasteboardCopyItemFlavorData(inPasteboard, itemID,
                                                   flavorType, &flavorData);
                require_noerr(err, CantCopyFlavorData);
                CFIndex flavorDataSize = CFDataGetLength(flavorData);
                flavorDataSize = (flavorDataSize<254) ? flavorDataSize : 254;
 
                if (flavorDataSize + 2 > bufSize)
                {
                    fprintf(stderr,
                        "Cannot copy clipboard, contents is too big!\n");
                    return false;
                }
 
                for (short dataIndex = 0; dataIndex <= flavorDataSize;
                     dataIndex ++)
                {
                    signed char byte = *(CFDataGetBytePtr(
                        flavorData) + dataIndex);
                    flavorText[dataIndex] = byte;
                }
 
                flavorText[flavorDataSize] = '\0';
                flavorText[flavorDataSize + 1] = '\n';
 
                CFRelease(flavorData);
                return true;
            }
 
            continue;
CantCopyFlavorData:
            fprintf(stderr, "Cannot copy clipboard, CantCopyFlavorData!\n");
        }
 
        CFRelease(flavorTypeArray);
        continue;
 
CantCopyPasteboardItemFlavors:
        fprintf(stderr,
            "Cannot copy clipboard, CantCopyPasteboardItemFlavors!\n");
        continue;
CantGetPasteboardItemIdentifier:
        fprintf(stderr,
            "Cannot copy clipboard, CantGetPasteboardItemIdentifier!\n");
        continue;
    }
    fprintf(stderr,
        "Cannot copy clipboard, found no acceptable flavour!\n");
    return false;
 
CantGetPasteboardItemCount:
    fprintf(stderr, "Cannot copy clipboard, CantGetPasteboardItemCount!\n");
    return false;
}
 
bool getClipBoard(char* text  /* out */, const int bufSize)
{
    PasteboardRef theClipboard;
    OSStatus err = PasteboardCreate(kPasteboardClipboard, &theClipboard);
    require_noerr(err, PasteboardCreateFailed);
 
    if (!getDataFromPasteboard(theClipboard, text, bufSize))
    {
        fprintf(stderr,
            "Cannot copy clipboard, getDataFromPasteboardFailed!\n");
        return false;
    }
 
    CFRelease(theClipboard);
 
    return true;
 
    // ---- error handling
PasteboardCreateFailed:
    fprintf(stderr, "Cannot copy clipboard, PasteboardCreateFailed!\n");
    CFRelease(theClipboard);
    return false;
}
 
bool retrieveBuffer(std::string& text, size_t& pos)
{
    const int bufSize = 512;
    char buffer[bufSize + 1];
 
    if (getClipBoard(buffer, bufSize))
    {
        text = buffer;
        pos += strlen(buffer);
        return true;
    }
    else
    {
        return false;
    }
}
 
bool sendBuffer(const std::string &restrict text)
{
    return false;
}
 
#elif defined USE_X11
 
static char* getSelection2(Display *const dpy, Window us, Atom selection,
                           Atom request_target)
{
    int max_events = 50;
    Window owner = XGetSelectionOwner(dpy, selection);
 
    if (owner == None)
        return nullptr;
 
    XConvertSelection(dpy, selection, request_target,
        XA_PRIMARY, us, CurrentTime);
    XFlush(dpy);
 
    while (max_events --)
    {
        XEvent e;
 
        XNextEvent(dpy, &e);
        if (e.type == SelectionNotify)
        {
            if (e.xselection.property == None)
                return nullptr;
 
            long unsigned len, left, dummy;
            int format;
            Atom type;
            unsigned char *data = nullptr;
 
            int ret = XGetWindowProperty(dpy, us, e.xselection.property, 0, 0,
                False, AnyPropertyType, &type, &format, &len, &left, &data);
            if (left < 1)
            {
                if (ret == Success)
                    XFree(data);
                return nullptr;
            }
 
            ret = XGetWindowProperty(dpy, us, e.xselection.property, 0,
                left, False, AnyPropertyType, &type, &format, &len,
                &dummy, &data);
 
            if (ret != Success)
                return nullptr;
 
            return reinterpret_cast<char*>(data);
        }
    }
    return nullptr;
}
 
static Atom requestAtom;
 
static char* getSelection(Display *const dpy, Window us, Atom selection)
{
    char *data = nullptr;
    if (requestAtom != None)
        data = getSelection2(dpy, us, selection, requestAtom);
    if (!data)
        data = getSelection2(dpy, us, selection, XA_STRING);
    return data;
}
 
bool retrieveBuffer(std::string& text, size_t& pos)
{
    SDL_SysWMinfo info;
 
    SDL_VERSION(&info.version)
    if (SDL::getWindowWMInfo(mainGraphics->getWindow(), &info))
    {
        Display *const dpy = info.info.x11.display;
        Window us = info.info.x11.window;
 
        requestAtom = XInternAtom(dpy, "UTF8_STRING", true);
        char *data = getSelection(dpy, us, XA_PRIMARY);
        if (!data)
            data = getSelection(dpy, us, XA_SECONDARY);
        if (!data)
        {
            Atom XA_CLIPBOARD = XInternAtom(dpy, "CLIPBOARD", 0);
            if (XA_CLIPBOARD != None)
                data = getSelection(dpy, us, XA_CLIPBOARD);
        }
 
        if (data)
        {
            // check cursor position
            const size_t sz = text.size();
            if (pos > sz)
                pos = sz;
 
            text.insert(pos, data);
            pos += strlen(data);
            XFree(data);
 
            return true;
        }
    }
    return false;
}
 
static bool runxsel(const std::string &text, const char *p1,
                    const char *p2 = nullptr);
 
bool sendBuffer(const std::string &restrict text)
{
    runxsel(text, "-i");
    runxsel(text, "-b", "-i");
    return true;
}
 
static bool runxsel(const std::string &text, const char *p1, const char *p2)
{
    pid_t pid;
    int fd[2];
 
    if (pipe(fd))
        return false;
 
    if ((pid = fork()) == -1)
    {   // fork error
        return false;
    }
    else if (!pid)
    {   // child
        close(fd[1]);
 
        if (fd[0] != STDIN_FILENO)
        {
            if (dup2(fd[0], STDIN_FILENO) != STDIN_FILENO)
            {
                close(fd[0]);
                _exit(1);
            }
            close(fd[0]);
        }
 
        const char *const xselPath =
#if defined __OpenBSD__ || defined __FreeBSD__ || defined __DragonFly__
            "/usr/local/bin/xsel";
#else  // defined __OpenBSD__ || defined __FreeBSD__ || defined __DragonFly__
            "/usr/bin/xsel";
#endif  // defined __OpenBSD__ || defined __FreeBSD__ || defined __DragonFly__
 
        if (p2)
        {
            execl(xselPath, "xsel", p1, p2,
                static_cast<char *>(nullptr));
        }
        else
        {
            execl(xselPath, "xsel", p1,
                static_cast<char *>(nullptr));
        }
 
        _exit(1);
    }
 
    // parent
    close(fd[0]);
    const size_t len = text.length();
    if (write(fd[1], text.c_str(), len) != static_cast<ssize_t>(len))
    {
        close(fd[1]);
        return false;
    }
    close(fd[1]);
    return true;
}
 
#elif defined __native_client__
 
bool retrieveBuffer(std::string& text, size_t& pos)
{
    NaclMessageHandle *handle = naclRegisterMessageHandler("clipboard-paste");
    naclPostMessage("clipboard-paste", "");
    std::string response = naclWaitForMessage(handle);
    text.insert(pos, response);
    pos += response.size();
    return true;
}
 
bool sendBuffer(const std::string &restrict text)
{
    naclPostMessage("clipboard-copy", text);
    return true;
}
#else  // WIN32
 
bool retrieveBuffer(std::string &text A_UNUSED, size_t &pos A_UNUSED)
{
    return false;
}
 
bool sendBuffer(const std::string &restrict text A_UNUSED)
{
    return false;
}
#endif  // WIN32
#endif  // USE_SDL2