Clipboard: what changed

Revision 1 to 2. Removed lines have a minus sign; added lines have a plus sign.

Old	New		Line
1		-	\
2		-	\
3		-
4	1		## Predefined types
5	2
6	3		\| TPredefinedClipboardFormat \| MIME type \|
7	4		\|----------------------------\|----------------------------\|
8	5		\| pcfText \| text/plain \|
9	6		\| pcfBitmap \| image/bmp \|
10	7		\| pcfPixmap \| image/xpm \|
11	8		\| pcfIcon \| image/lcl.icon \|
12	9		\| pcfPicture \| image/lcl.picture \|
13	10		\| pcfMetaFilePict \| image/lcl.metafilepict \|
14	11		\| pcfObject \| application/lcl.object \|
15	12		\| pcfComponent \| application/lcl.component \|
16	13		\| pcfCustomData \| application/lcl.customdata \|
17	14		\| \| \|
18	15
19	16		## Text
20	17
21	18		For use of simple text Clipboard offer property AsText which can be used for reading an writing plain text.
22	19
23	20		Writing text:
24	21
25	22		``` pascal
26	23		Clipboard.AsText := 'Hello clipboard!';
27	24		```
28	25
29	26		Reading text:
30	27
31	28		``` pascal
32	29		ShowMessage('Clipboard content: ' + Clipboard.AsText);
33	30		```
34	31
35	32		Clipboard is a TClipboard variable and the Clipbrd unit should be added in the uses clause in order to use the variable:
36	33
37	34		``` pascal
38	35		uses
39	36		..., Clipbrd;
40	37		```
41	38
42	39		## Text oriented components
43	40
44	41		Some visual components like [[TEdit]], [[TMemo]], [[TStringGrid]], [[TLabeledEdit]], [[TMaskEdit]], [[TSpinEdit]] and [[TFloatSpinEdit]] have ability to select a part of contained text and offer additional functionality for handling clipboard operations on selected text.
45	42
46	43		``` pascal
47	44
48	45		procedure CopyToClipboard;
49	46		procedure CutToClipboard;
50	47		procedure PasteFromClipboard;
51	48		```
52	49
53	50		## HTML source
54	51
55	52		The ClipBoard supports reading and writing of [[HTML]].
56	53
57	54		Example of reading from and writing HTML source to clipboard:
58	55
59	56		``` pascal
60	57		uses
61	58		Clipbrd, ...;
62	59		var
63	60		Html, PlainText: String;
64	61		...
65	62		begin
66	63		Html := ClipBoard.GetAsHtml;
67	64		...
68	65		Html := '<b>Formatted</b> text';
69	66		PlainText := 'Simple Text';
70	67		ClipBoard.SetAsHtml(Html, PlainText);
71	68		end.
72	69		```
73	70
74	71		### Windows
75	72
76	73		Handling Html content on the clipboard in Windows requires fidling with headers on Windows.\
77	74		While in the past users had to do this manually, this now is handled transparently by the ClipBrd unit.\
78	75
79	76		## Image
80	77
81	78		### Load from clipboard
82	79
83	80		``` pascal
84	81		uses
85	82		Clipbrd, LCLIntf, LCLType, ...;
86	83
87	84		procedure LoadBitmapFromClipboard(Bitmap: TBitmap);
88	85		begin
89	86		if Clipboard.HasFormat(PredefinedClipboardFormat(pcfDelphiBitmap)) then
90	87		Bitmap.LoadFromClipboardFormat(PredefinedClipboardFormat(pcfDelphiBitmap));
91	88		if Clipboard.HasFormat(PredefinedClipboardFormat(pcfBitmap)) then
92	89		Bitmap.LoadFromClipboardFormat(PredefinedClipboardFormat(pcfBitmap));
93	90		end;
94	91		```
95	92
96	93		### Save to clipboard
97	94
98	95		``` pascal
99	96		uses
100	97		Clipbrd, ...;
101	98
102	99		procedure SaveBitmapToClipboard(Bitmap: TBitmap);
103	100		begin
104	101		Clipboard.Assign(Bitmap);
105	102		end;
106	103		```
107	104
108	105		## Custom format
109	106
110	107		## Multiple objects
111	108
112	109		## Getting notified of changes
113	110
114	111		The LCL does not pass on Windows messages. It only passes on messages \> WM_USER. This means you have to write your own message handler. [Processing non - user messages in your window](http://wiki.lazarus.freepascal.org/Win32/64_Interface#Processing_non-user_messages_in_your_window)
115	112
116	113		Sample code to implement message handler:
117	114
118	115		``` pascal
119	116		unit Unit1;
120	117
121	118		{$mode delphi}{$H+}
122	119
123	120		interface
124	121
125	122		uses
126	123		Classes, SysUtils, FileUtil, Forms, Controls, Graphics, Dialogs,
127	124		Clipbrd, StdCtrls, Windows, Messages;
128	125
129	126		type
130	127		TForm1 = class(TForm)
131	128		Button1: TButton;
132	129		procedure FormCreate(Sender: TObject);
133	130		procedure FormDestroy(Sender: TObject);
134	131		private
135	132		FNextClipboardOwner: HWnd; // handle to the next viewer
136	133		// Here are the clipboard event handlers
137	134		function WMChangeCBChain(AwParam: WParam; AlParam: LParam):LRESULT;
138	135		function WMDrawClipboard(AwParam: WParam; AlParam: LParam):LRESULT;
139	136		public
140	137		end;
141	138
142	139		var
143	140		Form1: TForm1;
144	141
145	142		implementation
146	143
147	144		{$R *.lfm}
148	145		var
149	146		PrevWndProc:windows.WNDPROC;
150	147
151	148		function WndCallback(Ahwnd: HWND; uMsg: UINT; wParam: WParam;
152	149		lParam: LParam): LRESULT; stdcall;
153	150		begin
154	151		if uMsg = WM_CHANGECBCHAIN then begin
155	152		Result := Form1.WMChangeCBChain(wParam, lParam);
156	153		Exit;
157	154		end
158	155		else if uMsg=WM_DRAWCLIPBOARD then begin
159	156		Result := Form1.WMDrawClipboard(wParam, lParam);
160	157		Exit;
161	158		end;
162	159		Result := CallWindowProc(PrevWndProc, Ahwnd, uMsg, WParam, LParam);
163	160		end;
164	161
165	162		{ TForm1 }
166	163
167	164		{Don't forget to assign to the OnCreate event.}
168	165		procedure TForm1.FormCreate(Sender: TObject);
169	166		begin
170	167		PrevWndProc := Windows.WNDPROC(SetWindowLongPtr(Self.Handle, GWL_WNDPROC, PtrUInt(@WndCallback)));
171	168		FNextClipboardOwner := SetClipboardViewer(Self.Handle);
172	169		end;
173	170
174	171		{Don't forget to assign to the OnDestroy event.}
175	172		procedure TForm1.FormDestroy(Sender: TObject);
176	173		begin
177	174		ChangeClipboardChain(Handle, FNextClipboardOwner);
178	175		end;
179	176
180	177		function TForm1.WMChangeCBChain(AwParam: WParam; AlParam: LParam): LRESULT;
181	178		var
182	179		Remove, Next: THandle;
183	180		begin
184	181		Remove := AwParam;
185	182		Next := AlParam;
186	183		if FNextClipboardOwner = Remove then FNextClipboardOwner := Next
187	184		else if FNextClipboardOwner <> 0 then
188	185		SendMessage(FNextClipboardOwner, WM_ChangeCBChain, Remove, Next)
189	186		Result := 0;
190	187		end;
191	188
192	189		function TForm1.WMDrawClipboard(AwParam: WParam; AlParam: LParam): LRESULT;
193	190		begin
194	191		if Clipboard.HasFormat(CF_TEXT) Then Begin
195	192		ShowMessage(Clipboard.AsText);
196	193		end;
197	194		SendMessage(FNextClipboardOwner, WM_DRAWCLIPBOARD, 0, 0); // VERY IMPORTANT
198	195		Result := 0;
199	196		end;
200	197
201	198		end.
202	199		```
203	200
204	201		## View the clipboard contents
205	202
206	203		Sometimes its useful to see whats actually in the clipboard at any one time. Here are a couple of methods I use, on a form with a TMemo and a one second timer to do just that -
207	204
208	205		``` pascal
209	206		procedure TForm1.CheckClipboard();
210	207		var
211	208		I : integer;
212	209		List : TStringList;
213	210		begin
214	211		memo1.clear;
215	212		Memo1.Append('[' + Clipboard.AsText + ']');
216	213		List := TStringList.Create;
217	214		try
218	215		ClipBoard.SupportedFormats(List);
219	216		for i := 0 to List.Count-1 do begin
220	217		//Memo1.Append(List.Strings[i]); // uncomment to see all available formats
221	218		case List.Strings[i] of // show these specific ones
222	219		'Rich Text Format', 'text/plain', 'UTF8_STRING' :
223	220		ReadClip(List.Strings[i]);
224	221		end;
225	222		end;
226	223		finally
227	224		List.Free;
228	225		end;
229	226		end;
230	227
231	228		function TForm1.ReadClip(TheFormat : ANSIString) : ANSIString;
232	229		var
233	230		Stream: TMemoryStream;
234	231		Fmt : TClipboardFormat;
235	232		List : TStringList;
236	233		begin
237	234		if TheFormat = '' then exit;
238	235		Stream := TMemoryStream.Create;
239	236		List := TStringList.Create;
240	237		try
241	238		if Clipboard.HasFormatName(TheFormat) then begin
242	239		Memo1.Append(#10+TheFormat);
243	240		Fmt := ClipBoard.FindFormatID(TheFormat);
244	241		ClipBoard.GetFormat(Fmt, Stream);
245	242		if Stream.Size > 0 then begin
246	243		Stream.Seek(0, soFromBeginning);
247	244		List.LoadFromStream(Stream);
248	245		Memo1.Lines.AddStrings(List, False);
249	246		end;
250	247		end;
251	248		finally
252	249		List.Free;
253	250		Stream.Free;
254	251		end;
255	252		end;
256	253		```
257	254
258	255		## How to fix empty GTK2 clipboard on exit
259	256
260	257		Usually when your GTK2 app exits, it's clipboard becomes empty. Bad for usual user. This unit is a dirty fix, add it to "uses" somewhere.
261	258
262	259		``` pascal
263	260		unit fix_gtk_clipboard;
264	261
265	262		{$mode objfpc}{$H+}
266	263
267	264		interface
268	265
269	266		uses
270	267		gtk2, gdk2, Clipbrd;
271	268
272	269		implementation
273	270
274	271		var
275	272		c: PGtkClipboard;
276	273		t: string;
277	274
278	275		finalization
279	276		c := gtk_clipboard_get(GDK_SELECTION_CLIPBOARD);
280	277		t := Clipboard.AsText;
281	278		gtk_clipboard_set_text(c, PChar(t), Length(t));
282	279		gtk_clipboard_store(c);
283	280		end.
284	281		```
285	282
286	283		In May 2018 I (dbannon) found that putting this bit of code in a finalization section did fix the problem when the clipboard contents had come from the application itself but if it was there before the application started, that is, the application did not write to the clipboard, it introduces another, similar problem. Clipboard contents are, again, cleared in that case. And appears to happen because by time the finalization clause is executed, the clipboard has already been cleared.
287	284
288	285		An easy solution is to put that same code into the main form's onClose event. Its early enough that the contents, from either source are still there and late enough not to be subsequently cleared.
289	286
290	287		``` pascal
291	288		uses .... {$ifdef LINUX}gtk2, gdk2, Clipbrd{$endif};
292	289		.....
293	290		procedure TMainForm.FormClose(Sender: TObject; var CloseAction: TCloseAction);
294	291		var
295	292		c: PGtkClipboard;
296	293		t: string;
297	294		begin
298	295		{$ifdef LINUX}
299	296		c := gtk_clipboard_get(GDK_SELECTION_CLIPBOARD);
300	297		t := Clipboard.AsText;
301	298		gtk_clipboard_set_text(c, PChar(t), Length(t));
302	299		gtk_clipboard_store(c);
303	300		{$endif}
304	301		end;
305	302		```
306	303
307	304		## External links
308	305
309	306		- [Basic Clipboard Operations (Cut/Copy/Paste) using the TClipboard object](http://delphi.about.com/od/vclusing/a/tclipboard.htm)
310	307
311	308		---
312	309		From the Free Pascal wiki, page "Clipboard", as it stood on 2020-05-10 after a change by Kegge13, out of the wiki's dump of 2024-05-26. Copyright stays with the author who wrote it, according to the old wiki's [[Licensing]] page. If you have concerns about this material, [message the admin](/wiki-contact).

Back to history