xref: /trunk/main/dtrans/source/os2/dnd/OTransferable.cxx (revision cc13e73e)

/**************************************************************
*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements.  See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership.  The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License.  You may obtain a copy of the License at
*
*   http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied.  See the License for the
* specific language governing permissions and limitations
* under the License.
*
*************************************************************/


// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_dtrans.hxx"

#define INCL_DOSERRORS

#include <stdio.h>
#include <string.h>
#include <unistd.h>

#include <rtl/string.hxx>

#include "OTransferable.hxx"
#include "globals.hxx"


OTransferable::OTransferable( HWND hwndTarget, PDRAGINFO dragInfo)
    : m_aFlavorList( 1),
      mHwndTarget( hwndTarget),
      mDragInfo( dragInfo),
      removeOnExit( false),
      pDTShare( NULL),
      renderDRM( DRM_NULL),
      mimeType( MIMETYPE_NULL)
{
    USHORT cItems;
    PDRAGITEM dragItem;
    PSZ pNativeRMF;

    strcpy( fullpath, "");

    cItems = DrgQueryDragitemCount(dragInfo);
    if (cItems > 1) {
        debug_printf("OTransferable::OTransferable multiple drop not supported");
        return;
    }

    ULONG ulLength;
    PSZ pBuffer;

    // get 1st item
    dragItem = DrgQueryDragitemPtr(dragInfo, 0);

    // dump true type
    ulLength = DrgQueryTrueTypeLen( dragItem) + 1;
    pBuffer = (PSZ) malloc( ulLength);
    DrgQueryTrueType( dragItem, ulLength, pBuffer);
    debug_printf("DrgQueryTrueType %s", pBuffer);
    free( pBuffer);

    // get native RMF format
    ulLength = DrgQueryNativeRMFLen( dragItem) + 1;
    pNativeRMF = (PSZ) malloc( ulLength);
    DrgQueryNativeRMF( dragItem, ulLength, pNativeRMF);
    debug_printf("OTransferable::OTransferable DrgQueryNativeRMF %s", pNativeRMF);

    debug_printf("OTransferable::OTransferable DrgVerifyRMF DRM_ATOM %d", DrgVerifyRMF( dragItem, "DRM_ATOM", NULL));
    debug_printf("OTransferable::OTransferable DrgVerifyRMF DRM_OS2FILE %d", DrgVerifyRMF( dragItem, "DRM_OS2FILE", NULL));
    debug_printf("OTransferable::OTransferable DrgVerifyRMF DRM_PRINTOBJECT %d", DrgVerifyRMF( dragItem, "DRM_PRINTOBJECT", NULL));
    debug_printf("OTransferable::OTransferable DrgVerifyRMF DRM_SHAREDMEM %d", DrgVerifyRMF( dragItem, "DRM_SHAREDMEM", NULL));
    debug_printf("OTransferable::OTransferable DrgVerifyRMF DRM_DTSHARE %d", DrgVerifyRMF( dragItem, "DRM_DTSHARE", NULL));

    DataFlavor df;

    if (strstr( pNativeRMF, "<DRM_ATOM") != 0
            || strstr( pNativeRMF, "<DRM_DTSHARE") != 0
            || strstr( pNativeRMF, "<DRM_SHAREDMEM") != 0) {

        df.MimeType = OUString::createFromAscii( "text/plain;charset=utf-16" );
        df.DataType = getCppuType( static_cast<rtl::OUString*>(0));
        m_aFlavorList[0] = df;
        mimeType = MIMETYPE_TEXT;

    } else if (strstr( pNativeRMF, "<DRM_OS2FILE") != 0) {

        df.MimeType = OUString::createFromAscii(
                    "application/x-openoffice-file;windows_formatname=\"FileName\"");
        df.DataType = getCppuType( static_cast<OUString*>(0));
        m_aFlavorList[0] = df;
        mimeType = MIMETYPE_FILE;

    } else {

        mimeType = MIMETYPE_NULL;
        debug_printf("OTransferable::OTransferable UNKNOWN native RMF");

    }

    free( pNativeRMF);

}

OTransferable::~OTransferable()
{
    if (removeOnExit) {
        int rc;
        rc = unlink( fullpath);
        debug_printf( "OTransferable::~OTransferable unlink rc=%d", rc);
    }
}


//
// a generic request dispatcher
//
bool OTransferable::RequestFileRendering( PDRAGITEM pditem, HWND hwnd,
                                          PCSZ pRMF, PCSZ pName)
{
    PDRAGTRANSFER pdxfer;

    pdxfer = DrgAllocDragtransfer( 1);
    if (!pdxfer)
        return true;

    pdxfer->cb = sizeof(DRAGTRANSFER);
    pdxfer->hwndClient = hwnd;
    pdxfer->pditem = pditem;
    pdxfer->hstrSelectedRMF = DrgAddStrHandle( pRMF);
    pdxfer->hstrRenderToName = 0;
    pdxfer->ulTargetInfo = pditem->ulItemID;
    pdxfer->usOperation = (USHORT)DO_COPY;
    pdxfer->fsReply = 0;

    // send the msg before setting a render-to name
    if (pditem->fsControl & DC_PREPAREITEM)
        DrgSendTransferMsg( pditem->hwndItem, DM_RENDERPREPARE, (MPARAM)pdxfer, 0);

    if (pName)
        pdxfer->hstrRenderToName = DrgAddStrHandle( pName);
    else
        pdxfer->hstrRenderToName = 0;

    // send the msg after setting a render-to name
    if ((pditem->fsControl & (DC_PREPARE | DC_PREPAREITEM)) == DC_PREPARE)
        DrgSendTransferMsg( pditem->hwndItem, DM_RENDERPREPARE, (MPARAM)pdxfer, 0);

    // ask the source to render the selected item
    if (!DrgSendTransferMsg( pditem->hwndItem, DM_RENDER, (MPARAM)pdxfer, 0))
        return true;

    return false;
}

// currently, the same filename is used for every render request;
// it is deleted when the drag session ends
//
bool OTransferable::RenderToOS2File( PDRAGITEM pditem, HWND hwnd)
{
    bool rv = true;

    const char * pszRMF;
    if (DrgVerifyRMF(pditem, "DRM_OS2FILE", "DRF_TEXT"))
        pszRMF = OS2FILE_TXTRMF;
    else
        pszRMF = OS2FILE_UNKRMF;

    // create temp name
    strcpy( fullpath, tempnam( NULL, "AOO"));
    debug_printf("OTransferable::RenderToOS2File to %s", fullpath);

    rv = RequestFileRendering( pditem, hwnd, pszRMF, fullpath);

    return rv;
}

// DTShare uses 1mb of uncommitted named-shared memory
// (next time I'll do it differently - rw)
//
bool OTransferable::RenderToDTShare( PDRAGITEM pditem, HWND hwnd)
{
    bool rv;

    APIRET rc = DosAllocSharedMem( &pDTShare, DTSHARE_NAME, 0x100000,
                                   PAG_WRITE | PAG_READ | OBJ_ANY);
    if (rc != NO_ERROR &&
            rc != ERROR_ALREADY_EXISTS) { // Did the kernel handle OBJ_ANY?
        // Try again without OBJ_ANY and if the first failure was not caused
        // by OBJ_ANY then we will get the same failure, else we have taken
        // care of pre-FP13 systems where the kernel couldn't handle it.
        rc = DosAllocSharedMem( &pDTShare, DTSHARE_NAME, 0x100000,
                                PAG_WRITE | PAG_READ);
    }

    if (rc == ERROR_ALREADY_EXISTS)
        rc = DosGetNamedSharedMem( &pDTShare, DTSHARE_NAME,
                                   PAG_WRITE | PAG_READ);
    if (rc)
        rv = true; // error
    else
        rv = RequestFileRendering( pditem, hwnd, DTSHARE_RMF, DTSHARE_NAME);

    return rv;
}

// SharedMem rendering, memory is allocated by source window
//
bool OTransferable::RenderToSharedMem( PDRAGITEM pditem, HWND hwnd)
{
    bool rv;

    rv = RequestFileRendering( pditem, hwnd, SHAREDMEM_RMF, NULL);

    return rv;
}

bool OTransferable::requestRendering( void)
{
    char path[CCHMAXPATH];
    char file[CCHMAXPATH];
    PDRAGITEM dragItem;

    // unknown rendering
    renderDRM = DRM_NULL;

    // only 1st item supported
    dragItem = DrgQueryDragitemPtr( mDragInfo, 0);

    // check if we already have all necessary fields or a rendering
    // request must be sent to source window

    switch( mimeType) {
    case MIMETYPE_NULL:
        debug_printf("OTransferable::requestRendering INTERNAL ERROR, mimetype undef");
        break;

    case MIMETYPE_FILE:
        if (DrgVerifyRMF( dragItem, "DRM_OS2FILE", NULL)
                && dragItem->hstrSourceName == NULLHANDLE) {

            // if hstrSourceName is NULL we need to ask source for rendering
            bool rv;
            debug_printf("OTransferable::requestRendering request rendering");
            rv = RenderToOS2File( dragItem, mHwndTarget);
            debug_printf("OTransferable::requestRendering requested rendering rv=%d", rv);
            renderDRM = DRM_OS2FILE;

            // notify rendering request ongoing
            return true;

        } else if (DrgVerifyRMF( dragItem, "DRM_OS2FILE", NULL)) {

            // we have hstrSourceName, no need for rendering,
            // we already have enough data for rendering path now

            // get full path
            DrgQueryStrName(dragItem->hstrContainerName, sizeof(path), path);
            debug_printf("OTransferable::getTransferData hstrSourceName %x", dragItem->hstrSourceName);
            debug_printf("OTransferable::getTransferData hstrTargetName %x", dragItem->hstrTargetName);
            DrgQueryStrName(dragItem->hstrSourceName, sizeof(file), file);
            sprintf( fullpath, "%s%s", path, file);
            debug_printf("OTransferable::getTransferData fullpath %s", fullpath);
            renderDRM = DRM_OS2FILE;

        } else {
            debug_printf("OTransferable::requestRendering UNKNOWN request for FILE mimetype");
        }
        break;

    case MIMETYPE_TEXT:
        if (DrgVerifyRMF( dragItem, "DRM_ATOM", NULL)) {

            DrgQueryStrName(dragItem->ulItemID, sizeof(fullpath), fullpath);
            debug_printf("OTransferable::requestRendering DRM_ATOM '%s'", fullpath);
            renderDRM = DRM_ATOM;

            // no request rendering necessary
            return false;

        } else if (DrgVerifyRMF( dragItem, "DRM_DTSHARE", NULL)) {

            bool rv;
            debug_printf("OTransferable::requestRendering request DRM_DTSHARE rendering");
            rv = RenderToDTShare( dragItem, mHwndTarget);
            debug_printf("OTransferable::requestRendering requested DRM_DTSHARE rendering rv=%d", rv);
            renderDRM = DRM_DTSHARE;

            // notify rendering request ongoing
            return true;

        } else if (DrgVerifyRMF( dragItem, "DRM_SHAREDMEM", NULL)) {

            bool rv;
            debug_printf("OTransferable::requestRendering request DRM_SHAREDMEM rendering");
            rv = RenderToSharedMem( dragItem, mHwndTarget);
            debug_printf("OTransferable::requestRendering requested DRM_SHAREDMEM rendering rv=%d", rv);
            renderDRM = DRM_SHAREDMEM;

            // notify rendering request ongoing
            return true;

        } else {
            debug_printf("OTransferable::requestRendering UNKNOWN request for TEXT mimetype");
        }
        break;
    }

    // request rendering not necessary
    return false;

}

//
// AOO window received DM_RENDERCOMPLETE message
//
bool OTransferable::renderComplete( PDRAGTRANSFER pdxfer)
{
    switch( renderDRM) {
    case DRM_NULL:
        // already handled in requestRendering()
        break;
    case DRM_ATOM:
        // set full path from source rendered name string
        DrgQueryStrName( pdxfer->hstrRenderToName, sizeof(fullpath), fullpath);
        debug_printf("OTransferable::setDragTransfer fullpath %s", fullpath);
        break;
    case DRM_DTSHARE:
        // handled in getTransferData()
        break;
    case DRM_SHAREDMEM:
        // save pointer
        pSharedMem = (char *) pdxfer->hstrRenderToName;
        // extraction handled in getTransferData()
        break;
    case DRM_OS2FILE:
        // we already know the path, no need to use hstrRenderToName
        debug_printf("OTransferable::setDragTransfer fullpath %s", fullpath);
        // remove tmp file on destruction
        removeOnExit = true;
        break;
    }

    // send success to source window
    DrgSendTransferMsg( pdxfer->hwndClient, DM_ENDCONVERSATION,
                        (MPARAM) pdxfer->ulTargetInfo,
                        (MPARAM) DMFL_TARGETSUCCESSFUL);

    // free resources
    DrgDeleteStrHandle( pdxfer->hstrSelectedRMF);
    DrgDeleteStrHandle( pdxfer->hstrRenderToName);
    DrgFreeDragtransfer( pdxfer);

    return false;
}

Any SAL_CALL OTransferable::getTransferData( const DataFlavor& df)
throw(UnsupportedFlavorException, IOException, RuntimeException)
{
    OUString m_aData;
    char * pszText = 0;
    int pszLen;
    ULONG size = ~0;
    ULONG flags = 0;
    APIRET rc;
    bool renderOk = false;

    debug_printf("OTransferable::getTransferData MimeType %s",
                 ::rtl::OUStringToOString( df.MimeType, RTL_TEXTENCODING_UTF8 ).getStr());

    // handle shared memory cases
    switch( renderDRM) {
    case DRM_DTSHARE:

        pszLen = ((ULONG*)pDTShare)[0];
        pszText = (char*) malloc( pszLen + 1);
        if (pszText) {
            strcpy(pszText, &((char*)pDTShare)[sizeof(ULONG)] );
        }
        // using DosGetNamedSharedMem() on memory we allocated appears
        // to increment its usage ctr, so we have to free it 2x
        DosFreeMem(pDTShare);
        DosFreeMem(pDTShare);
        // reset pointer
        pDTShare = NULL;

        // prepare data for AOO
        m_aData = OUString( pszText, pszLen, RTL_TEXTENCODING_UTF8);
        break;

    case DRM_SHAREDMEM:
        rc = DosQueryMem((PVOID) pSharedMem, &size, &flags);
        renderOk = rc == 0;
        if (renderOk) {
            renderOk = (flags & (PAG_COMMIT | PAG_READ | PAG_BASE)) ==
                       (PAG_COMMIT | PAG_READ | PAG_BASE);
        }
        if (renderOk) {
            ULONG realSize = *(ULONG *) pSharedMem;
            renderOk = realSize <= size;
            if (renderOk) {
                // prepare data for AOO
                m_aData = OUString( pSharedMem + sizeof(ULONG), realSize, RTL_TEXTENCODING_UTF8);
            }
        }
        // free memory only if it is given by another process,
        // otherwise DefaultDragWorker will free it
        if (flags & PAG_SHARED)
            DosFreeMem((PVOID) pSharedMem);
        break;

    case DRM_ATOM:
    case DRM_OS2FILE:
        // data is in fullpath string
        // prepare data for AOO
        m_aData = OUString( fullpath, strlen(fullpath), RTL_TEXTENCODING_UTF8);
        break;

    default:
        debug_printf( "OTransferable::getTransferData unsupported DRM_* type %d",
                      renderDRM);
        break;
    }

    // return data
    return makeAny( m_aData );
}

// -----------------------------------------------------------------------

Sequence< DataFlavor > SAL_CALL OTransferable::getTransferDataFlavors(  )
throw(RuntimeException)
{
    return m_aFlavorList;
}

// -----------------------------------------------------------------------

sal_Bool SAL_CALL OTransferable::isDataFlavorSupported( const DataFlavor& )
throw(RuntimeException)
{
    return sal_True;
}