2023-01-29 12:20:13 -05:00
using NUnit.Framework ;
2023-02-02 22:26:53 -05:00
using System.Diagnostics ;
2023-01-05 12:28:15 -05:00
using System.IO ;
2020-07-26 15:54:57 -04:00
using System.Linq ;
2023-01-05 12:28:15 -05:00
using System.Runtime.InteropServices.ComTypes ;
2022-12-20 17:06:37 -05:00
using System.Threading ;
2020-07-26 15:54:57 -04:00
using System.Windows.Forms ;
using Vanara.PInvoke ;
2022-12-20 17:06:37 -05:00
using Vanara.PInvoke.Tests ;
2020-07-26 15:54:57 -04:00
using static Vanara . PInvoke . Shell32 ;
using Clipboard = Vanara . Windows . Shell . NativeClipboard ;
using WFClipboard = System . Windows . Forms . Clipboard ;
2023-03-31 11:47:53 -04:00
namespace Vanara.Windows.Shell.Tests ;
[TestFixture, SingleThreaded]
public class ClipboardTests
2020-07-26 15:54:57 -04:00
{
2023-03-31 11:47:53 -04:00
private const string html = "<pre style=\"font-family:Consolas;font-size:13px;color:#dadada;\"><span style=\"color:#dcdcaa;\">“We’ ve been here”</span></pre>" ;
readonly string [ ] files = { TestCaseSources . SmallFile , TestCaseSources . ImageFile , TestCaseSources . LogFile } ;
const string txt = @"“0’ 0©0è0”" ;
const string ptxt = "ABC123" ;
private const string url = "https://microsoft.com" ;
[Test]
public void zhuxbTest ( )
2020-07-26 15:54:57 -04:00
{
2023-03-31 11:47:53 -04:00
Thread STA = new ( ( ) = >
2023-02-02 22:26:53 -05:00
{
2023-03-31 11:47:53 -04:00
Ole32 . OleInitialize ( ) ;
2023-02-02 22:26:53 -05:00
2023-03-31 11:47:53 -04:00
try
{
2023-08-04 12:24:49 -04:00
Clipboard . Clear ( ) ;
2023-02-02 22:26:53 -05:00
2023-03-31 11:47:53 -04:00
ShellItemArray ShellItemList = new ( files . Select ( fn = > new ShellItem ( fn ) ) ) ;
2023-02-02 22:26:53 -05:00
2023-08-04 12:24:49 -04:00
var Data = Clipboard . CreateEmptyDataObject ( ) ;
2023-02-02 22:26:53 -05:00
2023-08-04 12:24:49 -04:00
Data . SetData ( ShellClipboardFormat . CFSTR_FILEDESCRIPTORW , new FILEGROUPDESCRIPTOR
2023-03-31 11:47:53 -04:00
{
cItems = ( uint ) ShellItemList . Count ,
fgd = ShellItemList . Select ( ( Item ) = >
2023-02-02 22:26:53 -05:00
{
2023-08-21 13:20:32 -04:00
ShellFileInfo FileInfo = Item . FileInfo ! ;
2023-08-04 12:24:49 -04:00
FD_FLAGS Flags = FD_FLAGS . FD_ATTRIBUTES
| FD_FLAGS . FD_CREATETIME
| FD_FLAGS . FD_ACCESSTIME
| FD_FLAGS . FD_WRITESTIME
| FD_FLAGS . FD_UNICODE ;
2023-02-02 22:26:53 -05:00
if ( ! Item . IsFolder )
{
2023-08-04 12:24:49 -04:00
Flags | = FD_FLAGS . FD_FILESIZE ;
2023-02-02 22:26:53 -05:00
}
2023-08-04 12:24:49 -04:00
return new FILEDESCRIPTOR
2023-03-31 11:47:53 -04:00
{
2023-08-21 13:20:32 -04:00
cFileName = Item . Name ! ,
2023-03-31 11:47:53 -04:00
dwFlags = Flags ,
dwFileAttributes = ( FileFlagsAndAttributes ) FileInfo . Attributes ,
nFileSize = ( ulong ) FileInfo . Length ,
ftCreationTime = FileInfo . CreationTime . ToFileTimeStruct ( ) ,
ftLastAccessTime = FileInfo . LastAccessTime . ToFileTimeStruct ( ) ,
ftLastWriteTime = FileInfo . LastWriteTime . ToFileTimeStruct ( )
} ;
} ) . ToArray ( )
} ) ;
for ( int Index = 0 ; Index < ShellItemList . Count ; Index + + )
{
ShellItem Item = ShellItemList [ Index ] ;
2023-02-02 22:26:53 -05:00
2023-03-31 11:47:53 -04:00
if ( ! Item . IsFolder )
2023-02-02 22:26:53 -05:00
{
2023-08-04 12:24:49 -04:00
Data . SetData ( ShellClipboardFormat . CFSTR_FILECONTENTS , Item . GetHandler < IStream > ( ShellUtil . CreateBindCtx ( STGM . STGM_READWRITE | STGM . STGM_SHARE_DENY_WRITE ) ) , DVASPECT . DVASPECT_CONTENT , Index ) ;
2023-02-02 22:26:53 -05:00
}
2023-03-31 11:47:53 -04:00
}
2023-08-04 12:24:49 -04:00
Clipboard . SetDataObject ( Data ) ;
2023-03-31 11:47:53 -04:00
2023-08-04 12:24:49 -04:00
foreach ( uint FormatId in Clipboard . CurrentlySupportedFormats )
2023-03-31 11:47:53 -04:00
{
2023-08-04 12:24:49 -04:00
Debug . WriteLine ( $"Available format: {Clipboard.GetFormatName(FormatId)}" ) ;
2023-03-31 11:47:53 -04:00
}
2023-08-04 12:24:49 -04:00
if ( ( Clipboard . IsFormatAvailable ( ShellClipboardFormat . CFSTR_FILEDESCRIPTORA ) | | Clipboard . IsFormatAvailable ( ShellClipboardFormat . CFSTR_FILEDESCRIPTORW ) ) & & Clipboard . IsFormatAvailable ( ShellClipboardFormat . CFSTR_FILECONTENTS ) )
2023-03-31 11:47:53 -04:00
{
2023-08-04 12:24:49 -04:00
FILEGROUPDESCRIPTOR FileGroupDescriptor = Clipboard . IsFormatAvailable ( ShellClipboardFormat . CFSTR_FILEDESCRIPTORA )
? Clipboard . CurrentDataObject . GetData < FILEGROUPDESCRIPTOR > ( ShellClipboardFormat . CFSTR_FILEDESCRIPTORA )
: Clipboard . CurrentDataObject . GetData < FILEGROUPDESCRIPTOR > ( ShellClipboardFormat . CFSTR_FILEDESCRIPTORW ) ;
2023-02-02 22:26:53 -05:00
2023-03-31 11:47:53 -04:00
for ( int Index = 0 ; Index < FileGroupDescriptor . cItems ; Index + + )
2023-02-02 22:26:53 -05:00
{
2023-08-04 12:24:49 -04:00
FILEDESCRIPTOR FileDescriptor = FileGroupDescriptor . fgd [ Index ] ;
2023-03-31 11:47:53 -04:00
ulong Size = 0 ;
FileAttributes Attributes = default ;
DateTimeOffset CreateTime = default ;
DateTimeOffset LastAccessTime = default ;
DateTimeOffset LastWriteTime = default ;
2023-08-04 12:24:49 -04:00
if ( FileDescriptor . dwFlags . HasFlag ( FD_FLAGS . FD_ATTRIBUTES ) )
2023-03-31 11:47:53 -04:00
{
Attributes = ( FileAttributes ) FileDescriptor . dwFileAttributes ;
}
2023-08-04 12:24:49 -04:00
if ( FileDescriptor . dwFlags . HasFlag ( FD_FLAGS . FD_FILESIZE ) )
2023-03-31 11:47:53 -04:00
{
Size = FileDescriptor . nFileSize ;
}
2023-08-04 12:24:49 -04:00
if ( FileDescriptor . dwFlags . HasFlag ( FD_FLAGS . FD_CREATETIME ) )
2023-03-31 11:47:53 -04:00
{
CreateTime = FileDescriptor . ftCreationTime . ToDateTime ( ) ;
}
2023-08-04 12:24:49 -04:00
if ( FileDescriptor . dwFlags . HasFlag ( FD_FLAGS . FD_ACCESSTIME ) )
2023-03-31 11:47:53 -04:00
{
LastAccessTime = FileDescriptor . ftLastAccessTime . ToDateTime ( ) ;
}
2023-02-02 22:26:53 -05:00
2023-08-04 12:24:49 -04:00
if ( FileDescriptor . dwFlags . HasFlag ( FD_FLAGS . FD_WRITESTIME ) )
2023-02-02 22:26:53 -05:00
{
2023-03-31 11:47:53 -04:00
LastWriteTime = FileDescriptor . ftLastWriteTime . ToDateTime ( ) ;
2023-02-02 22:26:53 -05:00
}
2023-03-31 11:47:53 -04:00
//Throw Invalid FORMATETC structure
2023-08-04 12:24:49 -04:00
var result = Clipboard . CurrentDataObject . GetData ( ShellClipboardFormat . CFSTR_FILECONTENTS , index : Index ) ;
2023-02-02 22:26:53 -05:00
}
}
2023-03-31 11:47:53 -04:00
}
finally
{
Ole32 . OleUninitialize ( ) ;
}
} ) ;
STA . SetApartmentState ( ApartmentState . STA ) ;
STA . Start ( ) ;
STA . Join ( ) ;
}
2023-02-02 22:26:53 -05:00
2023-03-31 11:47:53 -04:00
[Test]
public void DumpWFClipboardTest ( )
{
TestContext . WriteLine ( $"ContainsAudio: {WFClipboard.ContainsAudio()}" ) ;
TestContext . WriteLine ( $"ContainsData: {WFClipboard.ContainsData(DataFormats.StringFormat)}" ) ;
TestContext . WriteLine ( $"ContainsFileDropList: {WFClipboard.ContainsFileDropList()}" ) ;
TestContext . WriteLine ( $"ContainsImage: {WFClipboard.ContainsImage()}" ) ;
TestContext . WriteLine ( $"ContainsText: {WFClipboard.ContainsText()}" ) ;
TestContext . WriteLine ( $"GetAudioStream: {WFClipboard.GetAudioStream()}" ) ;
TestContext . WriteLine ( $"GetData: {WFClipboard.GetData(DataFormats.StringFormat)}" ) ;
TestContext . WriteLine ( $"GetDataObject: {WFClipboard.GetDataObject()}" ) ;
TestContext . WriteLine ( $"GetFileDropList: {string.Join(" \ n ", WFClipboard.GetFileDropList().Cast<string>())}" ) ;
TestContext . WriteLine ( $"GetImage: {WFClipboard.GetImage()}" ) ;
TestContext . WriteLine ( $"GetText: {WFClipboard.GetText()}" ) ;
}
2020-07-26 15:54:57 -04:00
2023-03-31 11:47:53 -04:00
[Test]
public void EnumFormatsTest ( )
{
SHCreateDataObject ( ppv : out var ido ) . ThrowIfFailed ( ) ;
ido . SetData ( CLIPFORMAT . CF_UNICODETEXT , "Test" ) ;
2023-01-05 12:28:15 -05:00
2023-03-31 11:47:53 -04:00
var fmts = ido . EnumFormats ( ) . ToArray ( ) ;
Assert . That ( fmts , Is . Not . Empty ) ;
TestContext . Write ( string . Join ( ", " , fmts . Select ( f = > Clipboard . GetFormatName ( ( uint ) f . cfFormat ) ) ) ) ;
2020-07-26 15:54:57 -04:00
2023-03-31 11:47:53 -04:00
var fmt = fmts . First ( ) ;
Assert . IsTrue ( ido . IsFormatAvailable ( ( uint ) fmt . cfFormat ) ) ;
}
2020-07-26 15:54:57 -04:00
2023-03-31 11:47:53 -04:00
[Test]
public void GetPriorityFormatTest ( )
{
var fmts = Clipboard . CurrentlySupportedFormats . ToArray ( ) ;
Assert . That ( Clipboard . GetFirstFormatAvailable ( fmts ) , Is . GreaterThan ( 0 ) ) ;
}
2020-07-26 15:54:57 -04:00
2023-03-31 11:47:53 -04:00
[Test]
public void GetSetShellItems1 ( )
{
ShellItemArray items = new ( Array . ConvertAll ( files , f = > new ShellItem ( f ) ) ) ;
2023-08-21 13:20:32 -04:00
var ido = items . ToDataObject ( ) ! ;
2023-03-31 11:47:53 -04:00
var shArray = ShellItemArray . FromDataObject ( ido ) ;
2023-08-21 13:20:32 -04:00
Assert . That ( shArray ! . Count , Is . GreaterThan ( 0 ) ) ;
2023-03-31 11:47:53 -04:00
CollectionAssert . AreEquivalent ( files , shArray . Select ( s = > s . FileSystemPath ) ) ;
}
2022-12-27 11:34:36 -05:00
2023-03-31 11:47:53 -04:00
[Test]
public void GetSetShellItems2 ( )
{
ShellItem [ ] items = Array . ConvertAll ( files , f = > new ShellItem ( f ) ) ;
Clipboard . SetDataObject ( Clipboard . CreateDataObjectFromShellItems ( items ) ) ;
2023-08-21 13:20:32 -04:00
var shArray = ShellItemArray . FromDataObject ( Clipboard . CurrentDataObject ) ! ;
2023-03-31 11:47:53 -04:00
Assert . That ( shArray . Count , Is . EqualTo ( items . Length ) ) ;
CollectionAssert . AreEquivalent ( files , shArray . Select ( s = > s . FileSystemPath ) ) ;
}
2022-12-20 17:06:37 -05:00
2023-03-31 11:47:53 -04:00
[Test]
public void GetSetDataTest ( )
{
2023-08-21 13:20:32 -04:00
SHCreateDataObject ( ppv : out System . Runtime . InteropServices . ComTypes . IDataObject ido ) . ThrowIfFailed ( ) ;
2023-01-05 12:28:15 -05:00
2023-03-31 11:47:53 -04:00
//using var hPal = Gdi32.CreatePalette(new LOGPALETTE() { palNumEntries = 256, palVersion = 0x0300, palPalEntry = new PALETTEENTRY[256] });
//ido.SetData(CLIPFORMAT.CF_PALETTE, hPal);
//Assert.That((HPALETTE)ido.GetData(CLIPFORMAT.CF_PALETTE), Is.EqualTo((HPALETTE)hPal));
2023-01-05 12:28:15 -05:00
2023-03-31 11:47:53 -04:00
using System.Drawing.Bitmap bmp = new ( TestCaseSources . BmpFile ) ;
using Gdi32.SafeHBITMAP hBmp = new ( bmp . GetHbitmap ( ) ) ;
ido . SetData ( CLIPFORMAT . CF_BITMAP , hBmp ) ;
2023-08-21 13:20:32 -04:00
Assert . AreEqual ( ( HBITMAP ) ( ido . GetData ( CLIPFORMAT . CF_BITMAP ) ? ? throw new InvalidOperationException ( ) ) , ( HBITMAP ) hBmp ) ;
2023-01-05 12:28:15 -05:00
2023-03-31 11:47:53 -04:00
//using System.Drawing.Imaging.Metafile enhMeta = new System.Drawing.Imaging.Metafile(TestCaseSources.TempChildDirWhack + "test.wmf");
//using Gdi32.SafeHENHMETAFILE hEnh = new(enhMeta.GetHenhmetafile());
//ido.SetData(CLIPFORMAT.CF_ENHMETAFILE, hEnh);
//Assert.That((HENHMETAFILE)ido.GetData(CLIPFORMAT.CF_ENHMETAFILE), Is.EqualTo((HENHMETAFILE)hEnh));
2023-01-05 12:28:15 -05:00
2023-03-31 11:47:53 -04:00
ido . SetData ( CLIPFORMAT . CF_HDROP , files ) ;
ido . SetData ( ShellClipboardFormat . CFSTR_FILENAMEMAPA , files ) ;
ido . SetData ( ShellClipboardFormat . CFSTR_FILENAMEMAPW , files ) ;
2023-08-21 13:20:32 -04:00
CollectionAssert . AreEquivalent ( files , ( string [ ] ) ido . GetData ( CLIPFORMAT . CF_HDROP ) ! ) ;
CollectionAssert . AreEquivalent ( files , ( string [ ] ) ido . GetData ( ShellClipboardFormat . CFSTR_FILENAMEMAPA ) ! ) ;
CollectionAssert . AreEquivalent ( files , ( string [ ] ) ido . GetData ( ShellClipboardFormat . CFSTR_FILENAMEMAPW ) ! ) ;
2023-01-05 12:28:15 -05:00
2023-03-31 11:47:53 -04:00
ido . SetData ( CLIPFORMAT . CF_OEMTEXT , ptxt ) ;
Assert . AreEqual ( ido . GetData ( CLIPFORMAT . CF_OEMTEXT ) , ptxt ) ;
2023-01-05 12:28:15 -05:00
2023-03-31 11:47:53 -04:00
ido . SetData ( CLIPFORMAT . CF_TEXT , txt ) ;
Assert . AreEqual ( ido . GetData ( CLIPFORMAT . CF_TEXT ) , txt ) ;
2023-01-05 12:28:15 -05:00
2023-03-31 11:47:53 -04:00
ido . SetData ( CLIPFORMAT . CF_UNICODETEXT , txt ) ;
Assert . AreEqual ( ido . GetData ( CLIPFORMAT . CF_UNICODETEXT ) , txt ) ;
2023-01-05 12:28:15 -05:00
2023-03-31 11:47:53 -04:00
var r = new RECT ( 0 , 8 , 16 , 32 ) ;
ido . SetData ( "RECT" , r ) ;
Assert . AreEqual ( ido . GetData < RECT > ( "RECT" ) , r ) ;
2023-01-05 12:28:15 -05:00
2023-03-31 11:47:53 -04:00
var lcid = Kernel32 . GetUserDefaultLCID ( ) ;
ido . SetData ( CLIPFORMAT . CF_LOCALE , lcid ) ;
//Assert.AreEqual(ido.GetData<LCID>(CLIPFORMAT.CF_LOCALE), lcid);
//Assert.That(ido.GetData(CLIPFORMAT.CF_LOCALE), lcid);
2023-01-05 12:28:15 -05:00
2023-03-31 11:47:53 -04:00
const string csv = "a,b,c,d\n1,2,3,4" ;
ido . SetData ( ShellClipboardFormat . CF_CSV , csv ) ;
Assert . AreEqual ( ido . GetData ( ShellClipboardFormat . CF_CSV ) , csv ) ;
2023-01-05 12:28:15 -05:00
2023-03-31 11:47:53 -04:00
ido . SetData ( ShellClipboardFormat . CF_HTML , html ) ;
Assert . AreEqual ( ido . GetData ( ShellClipboardFormat . CF_HTML ) , html ) ;
2023-01-05 12:28:15 -05:00
2023-08-04 12:24:49 -04:00
var rtf = File . ReadAllText ( TestCaseSources . TempDirWhack + "Test.rtf" ) ;
2023-03-31 11:47:53 -04:00
ido . SetData ( ShellClipboardFormat . CF_RTF , rtf ) ;
Assert . AreEqual ( ido . GetData ( ShellClipboardFormat . CF_RTF ) , rtf ) ;
2023-01-05 12:28:15 -05:00
2023-03-31 11:47:53 -04:00
ido . SetData ( ShellClipboardFormat . CF_RTFNOOBJS , rtf ) ;
Assert . AreEqual ( ido . GetData ( ShellClipboardFormat . CF_RTFNOOBJS ) , rtf ) ;
2023-01-05 12:28:15 -05:00
2023-03-31 11:47:53 -04:00
DROPDESCRIPTION dropDesc = new ( ) { type = DROPIMAGETYPE . DROPIMAGE_COPY , szMessage = "Move this" } ;
ido . SetData ( ShellClipboardFormat . CFSTR_DROPDESCRIPTION , dropDesc ) ;
2023-08-21 13:20:32 -04:00
Assert . AreEqual ( ( ( DROPDESCRIPTION ) ido . GetData ( ShellClipboardFormat . CFSTR_DROPDESCRIPTION ) ! ) . szMessage , dropDesc . szMessage ) ;
2023-01-05 12:28:15 -05:00
2023-03-31 11:47:53 -04:00
FILE_ATTRIBUTES_ARRAY faa = new ( ) { cItems = 1 , rgdwFileAttributes = new [ ] { 4 U } } ;
ido . SetData ( ShellClipboardFormat . CFSTR_FILE_ATTRIBUTES_ARRAY , faa ) ;
2023-08-21 13:20:32 -04:00
Assert . AreEqual ( ( ( FILE_ATTRIBUTES_ARRAY ) ido . GetData ( ShellClipboardFormat . CFSTR_FILE_ATTRIBUTES_ARRAY ) ! ) . cItems , faa . cItems ) ;
2023-01-05 12:28:15 -05:00
2023-03-31 11:47:53 -04:00
FILEGROUPDESCRIPTOR fgd = new ( ) { cItems = ( uint ) files . Length , fgd = new FILEDESCRIPTOR [ files . Length ] } ;
for ( int i = 0 ; i < files . Length ; i + + )
{
if ( i = = 0 ) { ido . SetData ( ShellClipboardFormat . CFSTR_FILENAMEA , files [ i ] ) ; ido . SetData ( ShellClipboardFormat . CFSTR_FILENAMEW , files [ i ] ) ; }
fgd . fgd [ i ] = new FileInfo ( files [ i ] ) ;
ShlwApi . SHCreateStreamOnFileEx ( fgd . fgd [ i ] . cFileName , STGM . STGM_READ | STGM . STGM_SHARE_DENY_WRITE , 0 , false , null , out IStream istream ) . ThrowIfFailed ( ) ;
ido . SetData ( ShellClipboardFormat . CFSTR_FILECONTENTS , istream , DVASPECT . DVASPECT_CONTENT , i ) ;
}
ido . SetData ( ShellClipboardFormat . CFSTR_FILEDESCRIPTORW , fgd ) ;
2023-08-21 13:20:32 -04:00
Assert . AreEqual ( ( ( FILEGROUPDESCRIPTOR ) ido . GetData ( ShellClipboardFormat . CFSTR_FILEDESCRIPTORW ) ! ) . cItems , fgd . cItems ) ;
Assert . That ( ( ) = > { var ist = ( Ole32 . IStreamV ) ido . GetData ( ShellClipboardFormat . CFSTR_FILECONTENTS , index : 1 ) ! ; ist . Seek ( 0 , Ole32 . STREAM_SEEK . STREAM_SEEK_SET , out _ ) . ThrowIfFailed ( ) ; } , Throws . Nothing ) ;
2023-03-31 11:47:53 -04:00
Assert . That ( ido . GetData ( ShellClipboardFormat . CFSTR_FILENAMEA ) , Is . TypeOf < string > ( ) . And . Not . Null ) ;
Assert . That ( ido . GetData ( ShellClipboardFormat . CFSTR_FILENAMEW ) , Is . TypeOf < string > ( ) . And . Not . Null ) ;
2023-01-05 12:28:15 -05:00
2023-03-31 11:47:53 -04:00
ido . SetUrl ( url , "Microsoft" ) ;
Assert . That ( ido . GetData ( ShellClipboardFormat . CFSTR_INETURLA ) , Does . StartWith ( url ) ) ;
Assert . That ( ido . GetData ( ShellClipboardFormat . CFSTR_INETURLW ) , Does . StartWith ( url ) ) ;
2023-01-05 12:28:15 -05:00
2023-03-31 11:47:53 -04:00
ido . SetData ( ShellClipboardFormat . CFSTR_INDRAGLOOP , true ) ;
2023-08-21 13:20:32 -04:00
Assert . AreEqual ( ( BOOL ) ido . GetData ( ShellClipboardFormat . CFSTR_INDRAGLOOP ) ! , true ) ;
2023-01-05 12:28:15 -05:00
2023-03-31 11:47:53 -04:00
ido . SetData ( ShellClipboardFormat . CFSTR_INVOKECOMMAND_DROPPARAM , ptxt ) ;
Assert . AreEqual ( ido . GetData ( ShellClipboardFormat . CFSTR_INVOKECOMMAND_DROPPARAM ) , ptxt ) ;
2023-01-05 12:28:15 -05:00
2023-03-31 11:47:53 -04:00
ido . SetData ( ShellClipboardFormat . CFSTR_LOGICALPERFORMEDDROPEFFECT , Ole32 . DROPEFFECT . DROPEFFECT_COPY ) ;
Assert . AreEqual ( ido . GetData ( ShellClipboardFormat . CFSTR_LOGICALPERFORMEDDROPEFFECT ) , Ole32 . DROPEFFECT . DROPEFFECT_COPY ) ;
2023-01-05 12:28:15 -05:00
2023-03-31 11:47:53 -04:00
ido . SetData ( ShellClipboardFormat . CFSTR_MOUNTEDVOLUME , ptxt ) ;
Assert . AreEqual ( ido . GetData ( ShellClipboardFormat . CFSTR_MOUNTEDVOLUME ) , ptxt ) ;
2023-01-05 12:28:15 -05:00
2023-03-31 11:47:53 -04:00
SafeLPTSTR remName = new ( "WINSTATION" ) ;
NRESARRAY nres = new ( ) { cItems = 1 , nr = new NETRESOURCE [ ] { new ( ) { lpRemoteName = remName } } } ;
ido . SetData ( ShellClipboardFormat . CFSTR_NETRESOURCES , nres ) ;
2023-08-21 13:20:32 -04:00
Assert . AreEqual ( ( ( NRESARRAY ) ido . GetData ( ShellClipboardFormat . CFSTR_NETRESOURCES ) ! ) . cItems , nres . cItems ) ;
2023-01-05 12:28:15 -05:00
2023-03-31 11:47:53 -04:00
ido . SetData ( ShellClipboardFormat . CFSTR_PASTESUCCEEDED , Ole32 . DROPEFFECT . DROPEFFECT_COPY ) ;
Assert . AreEqual ( ido . GetData ( ShellClipboardFormat . CFSTR_PASTESUCCEEDED ) , Ole32 . DROPEFFECT . DROPEFFECT_COPY ) ;
2023-01-05 12:28:15 -05:00
2023-03-31 11:47:53 -04:00
ido . SetData ( ShellClipboardFormat . CFSTR_PERFORMEDDROPEFFECT , Ole32 . DROPEFFECT . DROPEFFECT_COPY ) ;
Assert . AreEqual ( ido . GetData ( ShellClipboardFormat . CFSTR_PERFORMEDDROPEFFECT ) , Ole32 . DROPEFFECT . DROPEFFECT_COPY ) ;
2023-01-05 12:28:15 -05:00
2023-03-31 11:47:53 -04:00
ido . SetData ( ShellClipboardFormat . CFSTR_PREFERREDDROPEFFECT , Ole32 . DROPEFFECT . DROPEFFECT_COPY ) ;
Assert . AreEqual ( ido . GetData ( ShellClipboardFormat . CFSTR_PREFERREDDROPEFFECT ) , Ole32 . DROPEFFECT . DROPEFFECT_COPY ) ;
2023-01-05 12:28:15 -05:00
2023-03-31 11:47:53 -04:00
ido . SetData ( ShellClipboardFormat . CFSTR_PRINTERGROUP , ptxt ) ;
Assert . AreEqual ( ido . GetData ( ShellClipboardFormat . CFSTR_PRINTERGROUP ) , ptxt ) ;
2023-01-05 12:28:15 -05:00
2023-03-31 11:47:53 -04:00
var guid = Guid . NewGuid ( ) ;
ido . SetData ( ShellClipboardFormat . CFSTR_SHELLDROPHANDLER , guid ) ;
Assert . AreEqual ( ido . GetData ( ShellClipboardFormat . CFSTR_SHELLDROPHANDLER ) , guid ) ;
2023-01-05 12:28:15 -05:00
2023-03-31 11:47:53 -04:00
ido . SetData ( ShellClipboardFormat . CFSTR_TARGETCLSID , guid ) ;
Assert . AreEqual ( ido . GetData ( ShellClipboardFormat . CFSTR_TARGETCLSID ) , guid ) ;
2023-01-05 12:28:15 -05:00
2023-03-31 11:47:53 -04:00
ido . SetData ( ShellClipboardFormat . CFSTR_UNTRUSTEDDRAGDROP , 16 U ) ;
Assert . AreEqual ( ido . GetData ( ShellClipboardFormat . CFSTR_UNTRUSTEDDRAGDROP ) , 16 U ) ;
2023-01-05 12:28:15 -05:00
2023-08-04 12:24:49 -04:00
ido . SetData ( "ByteArray" , new byte [ ] { 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 } ) ;
2023-08-21 13:20:32 -04:00
Assert . AreEqual ( ( ( byte [ ] ) ido . GetData ( "ByteArray" ) ! ) . Length , 8 ) ;
2023-01-05 12:28:15 -05:00
2023-03-31 11:47:53 -04:00
//using var fs = File.OpenRead(files[0]);
//ido.SetData("Stream", fs);
//Assert.That(ido.GetData("Stream"), Is.TypeOf<IStream>());
2023-01-05 12:28:15 -05:00
2023-03-31 11:47:53 -04:00
//ido.SetData("StringArray", files);
//CollectionAssert.AreEquivalent(files, ido.GetData<string[]>("StringArray"));
2023-01-05 12:28:15 -05:00
2023-03-31 11:47:53 -04:00
// CFSTR_SHELLIDLIST
2023-01-05 12:28:15 -05:00
2023-03-31 11:47:53 -04:00
ShlwApi . SHCreateStreamOnFileEx ( files [ 0 ] , STGM . STGM_READ | STGM . STGM_SHARE_DENY_WRITE , 0 , false , null , out var istream2 ) . ThrowIfFailed ( ) ;
ido . SetData ( "IStream" , istream2 ) ;
Assert . That ( ido . GetData ( "IStream" ) as IStream , Is . Not . Null ) ;
2023-01-05 12:28:15 -05:00
2023-03-31 11:47:53 -04:00
// IStorage
2023-01-05 12:28:15 -05:00
2023-03-31 11:47:53 -04:00
//var fi = new FileInfo(files[0]);
//ido.SetData("File", fi);
//Assert.AreEqual(ido.GetData("File"), files[0]);
2023-01-05 12:28:15 -05:00
2023-03-31 11:47:53 -04:00
// ISerializable
ido . SetData ( "NetBmp" , bmp ) ;
Assert . That ( ido . GetData ( "NetBmp" ) , Is . TypeOf < System . Drawing . Bitmap > ( ) ) ;
2023-01-05 12:28:15 -05:00
2023-03-31 11:47:53 -04:00
// SafeAllocated
//SafeCoTaskMemHandle h = SafeCoTaskMemHandle.CreateFromStringList(files);
//ido.SetData("hMem", h);
//Assert.AreEqual(ido.GetData("hMem") as byte[], h.GetBytes());
}
2023-01-05 12:28:15 -05:00
2023-03-31 11:47:53 -04:00
[Test]
public void SetNativeTextHtmlTest ( )
{
SHCreateDataObject ( ppv : out var ido ) . ThrowIfFailed ( ) ;
ido . SetData ( ShellClipboardFormat . CF_HTML , html ) ;
var outVal = ido . GetData ( ShellClipboardFormat . CF_HTML ) ;
Assert . That ( outVal , Is . EqualTo ( html ) ) ;
}
2020-07-26 15:54:57 -04:00
2023-03-31 11:47:53 -04:00
[Test]
public void SetNativeTextMultTest ( )
{
const string stxt = "112233" ;
var ido = Clipboard . CreateEmptyDataObject ( ) ;
ido . SetData ( CLIPFORMAT . CF_UNICODETEXT , stxt ) ;
Clipboard . SetDataObject ( ido ) ;
Assert . That ( Clipboard . CurrentDataObject . GetData ( CLIPFORMAT . CF_UNICODETEXT ) , Is . EqualTo ( stxt ) ) ;
ido = Clipboard . CreateEmptyDataObject ( ) ;
ido . SetText ( txt , txt ) ;
Clipboard . SetDataObject ( ido ) ;
Assert . That ( Clipboard . CurrentDataObject . GetText ( CLIPFORMAT . CF_TEXT ) , Is . EqualTo ( txt ) ) ;
Assert . That ( Clipboard . CurrentDataObject . GetText ( CLIPFORMAT . CF_UNICODETEXT ) , Is . EqualTo ( txt ) ) ;
Assert . That ( Clipboard . CurrentDataObject . GetText ( ShellClipboardFormat . CF_HTML ) , Is . EqualTo ( txt ) ) ;
TestContext . WriteLine ( Clipboard . CurrentDataObject . GetText ( ShellClipboardFormat . CF_HTML ) ) ;
}
2021-08-26 19:28:15 -04:00
2023-03-31 11:47:53 -04:00
[Test]
public void SetNativeTextUnicodeTest ( )
{
const string txt = @"“0’ 0©0è0”" ;
var ido = Clipboard . CreateEmptyDataObject ( ) ;
ido . SetData ( CLIPFORMAT . CF_UNICODETEXT , txt ) ;
Clipboard . SetDataObject ( ido ) ;
2023-01-29 12:20:13 -05:00
2023-03-31 11:47:53 -04:00
Assert . That ( Clipboard . CurrentDataObject . GetText ( CLIPFORMAT . CF_UNICODETEXT ) , Is . EqualTo ( txt ) ) ;
}
2022-12-25 19:05:38 -05:00
2023-03-31 11:47:53 -04:00
//[Test]
public void ChangeEventTest ( )
{
var sawChange = new ManualResetEvent ( false ) ;
Clipboard . ClipboardUpdate + = OnUpdate ;
Thread . SpinWait ( 1000 ) ;
WFClipboard . SetText ( "Hello" ) ;
//using var Clipboard = new Clipboard();
//Clipboard.SetText("Hello");
Assert . IsTrue ( sawChange . WaitOne ( 5000 ) ) ;
Clipboard . ClipboardUpdate - = OnUpdate ;
2023-08-21 13:20:32 -04:00
void OnUpdate ( object? sender , EventArgs e ) = > sawChange . Set ( ) ;
2020-07-26 15:54:57 -04:00
}
}