draganddrop.cc

属性sosuo算法

#define MOZILLA_INTERNAL_API
#include "DragAndDrop.h"
#include "XPCOMUtil.h"
#include <nsICommandManager.h>
#include <gtkmozembed.h>
#include <gtkmozembed_internal.h>
#include <nsEscape.h>
#include <nsIDragService.h>
#include <nsIDragSession.h>
#include <nsIDOMEvent.h>
#include <nsIDOMEventListener.h>
#include <nsIDOMEventTarget.h>
#include <nsIDOMMouseEvent.h>
#include <nsIDOMWindow.h>
#include <nsILocalFile.h>
#include <nsIComponentRegistrar.h>
#include <nsIWebBrowser.h>
#include <nsString.h>
#include <nsIClipboardDragDropHooks.h>
#include <nsIDragSession.h>
#include <nsISupportsPrimitives.h>
#include <nsITransferable.h>
#include <nsISupportsArray.h>
#include <nsICollection.h>
#include <stdio.h>
#include <string.h>


PRInt32 stringToDragAction(const nsAString &str) {
    nsCAutoString cstr = NS_ConvertUTF16toUTF8(str);
    if(cstr.Equals("move")) return nsIDragService::DRAGDROP_ACTION_MOVE;
    if(cstr.Equals("copy")) return nsIDragService::DRAGDROP_ACTION_COPY;
    if(cstr.Equals("link")) return nsIDragService::DRAGDROP_ACTION_LINK;
    printf("WARNING: bad dragEffect string: %s\n", 
            PromiseFlatCString(cstr).get());
    return nsIDragService::DRAGDROP_ACTION_NONE;
}

nsresult makeDragData(nsIDOMElement* element, nsISupportsArray *dragArray) {
    // Create a transferable
    nsresult rv;
    nsCOMPtr<nsITransferable> trans(do_CreateInstance(
                "@mozilla.org/widget/transferable;1", &rv));
    // Add the mime-type
    nsAutoString dragSourceTypeStr = NS_ConvertUTF8toUTF16(
            nsDependentCString("dragsourcetype"));
    nsAutoString dragType;
    rv = element->GetAttribute(dragSourceTypeStr, dragType);
    nsCAutoString mimeType = NS_ConvertUTF16toUTF8(dragType);
    mimeType.Insert("application/x-democracy-", 0);
    mimeType.Append("-drag");
    trans->AddDataFlavor(PromiseFlatCString(mimeType).get());
    if(NS_FAILED(rv)) return rv;
    // Add the data
    nsAutoString dragSourceDataStr = NS_ConvertUTF8toUTF16(
            nsDependentCString("dragsourcedata"));
    nsAutoString sourceDataStr;
    rv = element->GetAttribute(dragSourceDataStr, sourceDataStr);
    nsCOMPtr<nsISupportsString> sourceData(do_CreateInstance(
                "@mozilla.org/supports-string;1", &rv));
    rv = sourceData->SetData(sourceDataStr);
    if(NS_FAILED(rv)) return rv;
    rv = trans->SetTransferData(PromiseFlatCString(mimeType).get(), sourceData,
            sourceDataStr.Length() * 2);
    if(NS_FAILED(rv)) return rv;
    // Turn that transferable into an nsISupportsArray
    nsCOMPtr<nsISupports> transSupports(do_QueryInterface(trans, &rv));
    if(NS_FAILED(rv)) return rv;
    nsCOMPtr<nsICollection> dragCollection(do_QueryInterface(dragArray, &rv));
    if(NS_FAILED(rv)) return rv;
    rv = dragCollection->AppendElement(transSupports);
    return rv;
}

nsresult startDrag(nsISupportsArray* dragArray) {
    nsresult rv;
    // Get the drag service and make sure we're not already doing a drop
    nsCOMPtr<nsIDragService> dragService(do_GetService(
                "@mozilla.org/widget/dragservice;1", &rv));
    if(NS_FAILED(rv)) return rv;
    nsCOMPtr<nsIDragSession> dragSession;
    rv = dragService->GetCurrentSession(getter_AddRefs(dragSession));
    if(NS_FAILED(rv)) return rv;
    if(dragSession != nsnull) return NS_ERROR_FAILURE;
    rv = dragService->InvokeDragSession(NULL, dragArray, NULL, 
            nsIDragService::DRAGDROP_ACTION_COPY);
    return rv;
}

nsresult isSingleDragTypeSupported(const nsAString &dragType, PRBool *supported)
{
    nsresult rv;


    nsCAutoString dragMimeType = NS_ConvertUTF16toUTF8(dragType);
    dragMimeType.Insert("application/x-democracy-", 0);
    dragMimeType.Append("-drag");
    nsCOMPtr<nsIDragService> dragService(do_GetService(
                "@mozilla.org/widget/dragservice;1", &rv));
    if(NS_FAILED(rv)) return rv;
    nsCOMPtr<nsIDragSession> dragSession;
    rv = dragService->GetCurrentSession(getter_AddRefs(dragSession));
    if(NS_FAILED(rv)) return rv;
    rv = dragSession->IsDataFlavorSupported(
            PromiseFlatCString(dragMimeType).get(), supported);
    return rv;
}

nsresult checkForURLs(PRBool* hasURLs)
{
    nsresult rv;
    nsCOMPtr<nsIDragService> dragService(do_GetService(
                "@mozilla.org/widget/dragservice;1", &rv));
    if(NS_FAILED(rv)) return rv;
    nsCOMPtr<nsIDragSession> dragSession;
    rv = dragService->GetCurrentSession(getter_AddRefs(dragSession));
    if(NS_FAILED(rv)) return rv;
    rv = dragSession->IsDataFlavorSupported(kURLMime, hasURLs);
    if(NS_FAILED(rv)) return rv;
    return NS_OK;
}

nsresult isDragTypeSupported(const nsAString& dragAttribute, 
        PRBool *supported, nsAString* dragType = nsnull)
{
    PRInt32 start, currentColon;
    start = currentColon = 0;
    *supported = false;
    nsresult rv;

    while(start < dragAttribute.Length()) {
        currentColon = dragAttribute.FindChar(':', start);
        if(currentColon < 0) {
            const nsAString& singleDragType = Substring(dragAttribute, start, 
                    dragAttribute.Length() - start);
            rv = isSingleDragTypeSupported(singleDragType, supported);
            if(NS_FAILED(rv)) return rv;
            if(*supported && dragType) {
                dragType->Replace(0, dragType->Length(), singleDragType);
            }
            return NS_OK;
        }
        const nsAString& singleDragType = Substring(dragAttribute, start, 
                currentColon - start);
        rv = isSingleDragTypeSupported(singleDragType, supported);

        if(NS_FAILED(rv)) return rv;
        if(*supported) {
            if(dragType) {
                dragType->Replace(0, dragType->Length(), singleDragType);
            }
            return NS_OK;
        }
        start = currentColon + 1;
    }
    return NS_OK;
}

nsresult extractDragData(const char* mimeType, nsAString& output, int index=0) 
{
    nsresult rv;
    nsCOMPtr<nsIDragService> dragService(do_GetService(
                "@mozilla.org/widget/dragservice;1", &rv));
    if(NS_FAILED(rv)) return rv;
    nsCOMPtr<nsIDragSession> dragSession;
    rv = dragService->GetCurrentSession(getter_AddRefs(dragSession));
    if(NS_FAILED(rv)) return rv;
    nsCOMPtr<nsITransferable> trans(do_CreateInstance(
                "@mozilla.org/widget/transferable;1", &rv));
    if(NS_FAILED(rv)) return rv;
    trans->AddDataFlavor(mimeType);
    if(NS_FAILED(rv)) return rv;
    rv = dragSession->GetData(trans, index);
    if(NS_FAILED(rv)) return rv;
    nsCOMPtr<nsISupportsString> data;
    PRUint32 length;
    rv = trans->GetTransferData(mimeType, getter_AddRefs(data), &length);
    if(NS_FAILED(rv)) return rv;
    rv = data->GetData(output);
    return rv;
}

nsresult getDragSourceData(const nsAString &dragType, nsAString &output)
{
    nsresult rv;

    nsCAutoString dragMimeType = NS_ConvertUTF16toUTF8(dragType);
    dragMimeType.Insert("application/x-democracy-", 0);
    dragMimeType.Append("-drag");
    rv = extractDragData(PromiseFlatCString(dragMimeType).get(), output);
    if(NS_FAILED(rv)) return rv;
    return NS_OK;
}


static nsCOMPtr<nsIDOMElement> highlightedElement;
static nsAutoString currentHighlightClass;

nsresult removeCurrentHighlight() {
    if(!highlightedElement) return NS_OK;
    nsAutoString classStr = NS_ConvertUTF8toUTF16(nsDependentCString("class"));
    nsAutoString cssClass;
    nsresult rv;
    rv = highlightedElement->GetAttribute(classStr, cssClass);
    if(NS_FAILED(rv)) return rv;
    int hlLength = currentHighlightClass.Length();
    for(int i = 0; i <= cssClass.Length() - hlLength; i++) {
        if(Substring(cssClass, i, hlLength).Equals(currentHighlightClass)) {
            cssClass.Cut(i, hlLength);
            break;
        }
    }
    rv = highlightedElement->SetAttribute(classStr, cssClass);
    if(NS_FAILED(rv)) return rv;
    highlightedElement = nsnull;
    return NS_OK;
}

nsresult setNewHighlight(nsIDOMElement *element, const nsAString &dragType) {
    nsresult rv;
    if(highlightedElement) {
        rv = removeCurrentHighlight();
        if(NS_FAILED(rv)) return rv;
    }
    nsAutoString classStr = NS_ConvertUTF8toUTF16(nsDependentCString("class"));
    nsAutoString cssClass;
    rv = element->GetAttribute(classStr, cssClass);
    if(NS_FAILED(rv)) return rv;

    currentHighlightClass.Cut(0, currentHighlightClass.Length());
    if(!cssClass.IsEmpty()) {
        currentHighlightClass.Append(NS_ConvertUTF8toUTF16(
                    nsDependentCString(" ")));
    }
    currentHighlightClass.Append(NS_ConvertUTF8toUTF16(
                nsDependentCString("drag-highlight ")));
    currentHighlightClass.Append(dragType);

    cssClass.Append(currentHighlightClass);
    rv = element->SetAttribute(classStr, cssClass);
    if(NS_FAILED(rv)) return rv;
    highlightedElement = element;
    return NS_OK;
}

nsresult findDropElement(nsIDOMEvent* event, nsIDOMElement** element,
        nsString& singleDragType)
{
    nsresult rv;
    *element = nsnull;
    if(event == nsnull) return NS_OK;
    nsCOMPtr<nsIDOMEventTarget> target;