Överföring av Shell-objekt med dra och släpp och Urklipp

Många program gör det möjligt för användare att överföra data till ett annat program genom att dra och släppa data med musen, eller genom att använda Urklipp. Bland de många typer av data som kan överföras finns Shell-objekt som filer eller mappar. Shell-dataöverföring kan ske mellan två program, men användarna kan också överföra Shell-data till eller från skrivbordet eller Windows Explorer.

Även om filer är det vanligaste överförda Shell-objektet kan Shell-dataöverföring omfatta alla de olika objekt som finns i Shell-namnområdet. Ditt program kan till exempel behöva överföra en fil till en virtuell mapp, till exempel papperskorgen, eller acceptera ett objekt från ett namnområdestillägg som inte kommer från Microsoft. Om du implementerar ett namnområdestillägg måste det kunna fungera korrekt som en dragkälla och ett släppmål.

I det här dokumentet beskrivs hur program kan implementera dataöverföringar med Shell-objekt för dra och släpp och Clipboard.

Så här fungerar dra och släpp med Shell-objekt

Program behöver ofta ge användarna ett sätt att överföra Shell-data. Några exempel är:

  • Dra en fil från Windows Explorer eller skrivbordet och släpp den i ett program.
  • Kopiera en fil till Urklipp i Windows Explorer och klistra in den i ett program.
  • Dra en fil från ett program till papperskorgen.

En detaljerad beskrivning av hur du hanterar dessa och andra scenarier finns i Handling Shell Data Transfer Scenarios. Det här dokumentet fokuserar på de allmänna principerna bakom Shell-dataöverföring.

Windows tillhandahåller två standardsätt för program att överföra Shell-data:

  • En användare klipper ut eller kopierar Shell-data, till exempel en eller flera filer, till urklippet. Det andra programmet hämtar data från Urklipp.
  • En användare drar en ikon som representerar data från källprogrammet och släpper ikonen i ett fönster som ägs av målprogrammet.

I båda fallen är de överförda uppgifterna inneslutna i ett dataobjekt. Dataobjekt är COM-objekt (Component Object Model) som exponerar IDataObject-gränssnittet . Schematiskt sett finns det tre viktiga steg som alla Shell-dataöverföringar måste följa:

  1. Källan skapar ett dataobjekt som representerar de data som ska överföras.
  2. Målet tar emot en pekare till dataobjektets IDataObject-gränssnitt .
  3. Målobjektet anropar IDataObject-gränssnittet för att extrahera data från det.

Skillnaden mellan Urklipp och dra och släpp-dataöverföringar ligger främst i hur pekaren IDataObject överförs från källan till målet.

Dataöverföringar via urklipp

Urklipp är det enklaste sättet att överföra Shell-data. Den grundläggande proceduren liknar standardöverföringar av data på Urklipp. Men eftersom du överför en pekare till ett dataobjekt, inte själva data, måste du använda OLE Urklipps-API:et i stället för standard-API:et för Urklipp. Följande procedur beskriver hur du använder OLE Urklipps-API:et för att överföra Shell-data med Urklipp:

  1. Datakällan skapar ett dataobjekt som innehåller data.
  2. Datakällan anropar OleSetClipboard, som placerar en pekare till dataobjektets IDataObject-gränssnitt i Urklipp.
  3. Målobjektet anropar OleGetClipboard för att hämta pekaren till dataobjektets IDataObject-gränssnitt.
  4. Målet extraherar data genom att anropa metoden IDataObject::GetData .
  5. Med vissa Shell-dataöverföringar kan målet också behöva anropa dataobjektets IDataObject::SetData-metod för att ge feedback till dataobjektet om resultatet av dataöverföringen. Ett exempel på den här typen av åtgärd finns i Hantering av optimerade flyttåtgärder.

Dataöverföringar med dra och släpp

Även om det är något mer komplext att implementera, har dra och släpp-dataöverföring några betydande fördelar jämfört med urklipp:

  • Överföringar med dra och släpp kan göras med en enkel musrörelse, vilket gör åtgärden mer flexibel och intuitiv att använda än Urklipp.
  • Dra och släpp ger användaren en visuell representation av åtgärden. Användaren kan följa ikonen när den rör sig från källa till mål.
  • Dra och släppa meddelar målet när data är tillgängliga.

Dra-och-släpp-åtgärder använder också dataobjekt för att överföra data. Släppkällan måste dock tillhandahålla funktioner utöver vad som krävs för Clipboard-överföringar:

  • Släppkällan måste också skapa ett objekt som exponerar ett IDropSource-gränssnitt . Systemet använder IDropSource för att kommunicera med källan medan åtgärden pågår.
  • Dataobjektet för dra och släpp ansvarar för att spåra markörens rörelse och visa en ikon som representerar dataobjektet.

släppmål måste också ge fler funktioner än vad som krävs för att hantera urklippsöverföringar:

  • Släppmålet måste exponera ett IDropTarget-gränssnitt . När markören är över ett målfönster använder systemet IDropTarget för att ge målet information, till exempel markörens position, och för att meddela det när data släpps.
  • Släppmålet måste registrera sig med systemet genom att anropa RegisterDragDrop. Den här funktionen ger systemet handtaget till ett målfönster och en pekare till målprogrammets IDropTarget-gränssnitt .

Note

För dra och släpp-åtgärder måste programmet initiera COM med OleInitialize, inte CoInitialize.

 

Följande procedur beskriver de viktigaste stegen som vanligtvis används för att överföra Shell-data med dra och släpp:

  1. Släppmålet anropar RegisterDragDrop för att ge systemet en pekare till dess IDropTarget-gränssnitt och registrera ett fönster som ett släppmål.
  2. När användaren startar en dra och släpp-åtgärd skapar källan ett dataobjekt och initierar en dra-loop genom att anropa DoDragDrop.
  3. När markören är över målfönstret meddelar systemet målet genom att anropa en av målets IDropTarget-metoder . Systemet anropar IDropTarget::DragEnter när markören går in i målfönstret och IDropTarget::DragOver när markören passerar över målfönstret. Båda metoderna ger släppmålet den aktuella markörens position och tillståndet för tangentbordsmodifierare, till exempel CTRL eller ALT. När markören lämnar målfönstret meddelar systemet målet genom att anropa IDropTarget::DragLeave. När någon av dessa metoder returnerar anropar systemet IDropSource-gränssnittet för att skicka returvärdet till källan.
  4. När användaren släpper musknappen för att släppa data anropar systemet målets IDropTarget::Drop-metod. Bland metodens parametrar finns en pekare till dataobjektets IDataObject-gränssnitt .
  5. målet anropar dataobjektets IDataObject::GetData-metod för att extrahera data.
  6. Med vissa Shell-dataöverföringar kan målet också behöva anropa dataobjektets IDataObject::SetData-metod för att ge feedback till källan om resultatet av dataöverföringen.
  7. När målet är klart med dataobjektet returnerar det från IDropTarget::Drop. Systemet returnerar källans DoDragDrop-anrop för att meddela källan att dataöverföringen är klar.
  8. Beroende på det specifika dataöverföringsscenariot kan källan behöva vidta ytterligare åtgärder baserat på värdet som returneras av DoDragDrop och de värden som skickas till dataobjektet av målet. När en fil till exempel flyttas måste källan kontrollera dessa värden för att avgöra om den måste ta bort den ursprungliga filen.
  9. Källan släpper dataobjektet.

De procedurer som beskrivs ovan ger en bra allmän modell för Shell-dataöverföring, men det finns många olika typer av data som kan ingå i ett Shell-dataobjekt. Det finns också ett antal olika dataöverföringsscenarier som ditt program kan behöva hantera. Varje datatyp och scenario kräver en något annorlunda metod för tre viktiga steg i proceduren:

  • Hur en källa konstruerar ett dataobjekt som ska innehålla Shell-data.
  • Hur en target extraherar Shell-data från dataobjektet.
  • Hur källan slutför dataöverföringsåtgärden.

Shell-dataobjektet ger en allmän genomgång av hur en källa konstruerar ett Shell-dataobjekt och hur dataobjektet kan hanteras av målapplikationen. Hantering av Shell-dataöverföringsscenarier beskrivs i detalj hur du hanterar ett antal vanliga scenarier för shell-dataöverföring.

 

 

  • Uppdaterades senast