Multiplatform Programming Guide/zh CN: what changed

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

Old	New		Line
1	1		大多数 [[Lazarus Documentation/zh CN\|LCL]] 可以跨平台使用，几乎不需要做修改。
2	2
3	3		这是在 Lazarus 和 Free Pascal 上编写跨平台应用程序的教程。涵盖了必要的注意事项，从准备到[[Deploying Your Application\|部署]]的相关帮助。
4	4
5	5		## 跨平台编程简介
6	6
7	7		### 你需要跨平台吗？
8	8
9	9		要回答这个问题，你需要先确定哪些用户使用你的应用程序，以便在那里部署。
10	10
11	11		在 2014 年，如果你正在开发通用桌面软件，微软的 Windows 可能是重要的平台。需要注意的是，Mac OS X 或 Linux 正变得流行，他们或许会成为你开发应用的另一个平台。
12	12
13	13		不同的国家流行不同的桌面操作系统，按使用软件类型、人员，没有通用规则，像 Mac OS X在美国和西欧相当受欢迎，而在南美 Mac 大多用于视频和音频工作。
14	14
15	15		在许多签约项目里，只与一个平台相关。Free Pascal 和 Lazarus 完全有能力针对特定平台编写软件。如，访问完整 Windows API 写一个 Windows 程序。
16	16
17	17		If you're developing software that will run on a Web server, a Unix platform in one of its various flavors is commonly used. In this case, perhaps only Linux, Solaris, BSD and other Unixes make sense as your target platforms, although you may want to add support for Windows for completeness. （~~如果你开发的软件运行在 Web 服务器上，在 Unix 平台，你可以将 Linux、Solaris、BSD 和其他 Unix 作为目标平台，但你也想增加对 Windows 的完整支持。~~）
18	18
19	19		一旦你解决了跨平台的问题，你可以在很大程度上忽略了其他平台，就像在一个平台开发。然而，在某些时候你需要测试部署在其他平台上的程序；像这样，你不想使用多个物理计算机，可以使用双引导、虚拟机VMware或类似的解决方案。这将有助于不受限制地访问目标操作系统。
20	20
21	21		## 跨平台编程
22	22
23	23		### 处理文件和文件夹
24	24
25	25		在处理文件和文件夹时，使用于非特定平台的路径分隔符和[[End of Line\|行结束]]符很重要。这个列表定义了 Lazarus 处理文件或文件夹时的[[Constant/zh CN\|常量]]列表。
26	26
27	27		- PathSep, PathSeparator: 多路径分隔符 (';', ...)
28	28		- PathDelim, DirectorySeparator: 各平台路径分隔符 ('/', '\\', ...)
29	29		- LineEnding: 行结束符 (#13#10 - CRLF, \#10 - [[Line feed\|LF]], ...)
30	30
31	31		要特别注意的是文件系统问题。
32	32
33	33		在 Windows 中，文件名通常不区分大小写，但在 Linux 和 BSD 平台将区分。但，如果一个EXT2、EXT3等系统文件挂载到 Windows 中，这仍将区分大小写。Linux 挂载 FAT 文件系统却不区分大小写。
34	34
35	35		It shall be paid special attention, that NTFS is non-case sensitive when used in Windows, but it is case sensitive when mounted by POSIX OSes. This could cause various problems, including loss of files if files with same filenames in different cases exist on a NTFS partition, mounted in Windows. Using custom functions for checking and preventing creation of several files with the same names on NTFS should be considered by the developers.(~~特别注意的是，Windows 中的 NTFS 文件系统不区分大小写，但通过安装 POSIX 系统时是区分大小写的。这将会导致各种问题，其中包括文件丢失。~~)
36	36
37	37		Mac OS X 默认不区分文件名大小写，这可能是恼人错误的原因，所以任何便携式应用程序都应该坚持文件名大小写统一。
38	38
39	39		The RTL file functions use the system encoding for file names. Under Windows this is one of the windows code pages, while Linux, BSD and Mac OS X usually use UTF-8. The unit FileUtil of the LCL provides file functions which takes UTF-8 strings like the rest of the LCL.
40	40
41	41		(~~RTL（Free Pascal 运行库）文件使用系统编码。在 Windows 中是一代码页，在 Linux, BSD 和 Mac OS X 使用 UTF-8，LCL（Lazarus 组件库）中的 FileUtil单元，提供了文件操作的相关功能。~~)
42	42
43	43		``` pascal
44	44		// AnsiToUTF8 and UTF8ToAnsi need a widestring manager under Linux, BSD, MacOSX
45	45		// but normally these OS use UTF-8 as system encoding so the widestringmanager
46	46		// 是不需要的。
47	47		function NeedRTLAnsi: boolean;// 为真，则系统编码不是 UTF-8
48	48		procedure SetNeedRTLAnsi(NewValue: boolean);
49	49		function UTF8ToSys(const s: string): string;// 作为 AnsiToUTF8 需要独立的 widestringmanager
50	50		function SysToUTF8(const s: string): string;// 作为 AnsiToUTF8 需要独立的 widestringmanager
51	51		function UTF8ToConsole(const s: string): string;//转换 UTF8 编码字符串到控制台编码(使用 Write, WriteLn)
52	52
53	53		// 文件操作
54	54		function FileExistsUTF8(const Filename: string): boolean;
55	55		function FileAgeUTF8(const FileName: string): Longint;
56	56		function DirectoryExistsUTF8(const Directory: string): Boolean;
57	57		function ExpandFileNameUTF8(const FileName: string): string;
58	58		function ExpandUNCFileNameUTF8(const FileName: string): string;
59	59		function ExtractShortPathNameUTF8(Const FileName : String) : String;
60	60		function FindFirstUTF8(const Path: string; Attr: Longint; out Rslt: TSearchRec): Longint;
61	61		function FindNextUTF8(var Rslt: TSearchRec): Longint;
62	62		procedure FindCloseUTF8(var F: TSearchrec);
63	63		function FileSetDateUTF8(const FileName: String; Age: Longint): Longint;
64	64		function FileGetAttrUTF8(const FileName: String): Longint;
65	65		function FileSetAttrUTF8(const Filename: String; Attr: longint): Longint;
66	66		function DeleteFileUTF8(const FileName: String): Boolean;
67	67		function RenameFileUTF8(const OldName, NewName: String): Boolean;
68	68		function FileSearchUTF8(const Name, DirList : String): String;
69	69		function FileIsReadOnlyUTF8(const FileName: String): Boolean;
70	70		function GetCurrentDirUTF8: String;
71	71		function SetCurrentDirUTF8(const NewDir: String): Boolean;
72	72		function CreateDirUTF8(const NewDir: String): Boolean;
73	73		function RemoveDirUTF8(const Dir: String): Boolean;
74	74		function ForceDirectoriesUTF8(const Dir: string): Boolean;
75	75
76	76		// 环境
77	77		function ParamStrUTF8(Param: Integer): string;
78	78		function GetEnvironmentStringUTF8(Index: Integer): string;
79	79		function GetEnvironmentVariableUTF8(const EnvVar: string): String;
80	80		function GetAppConfigDirUTF8(Global: Boolean): string;
81	81
82	82		// 其他
83	83		function SysErrorMessageUTF8(ErrorCode: Integer): String;
84	84		```
85	85
86	86		### 空文件名和路径双分隔符
87	87
88	88		Windows 和 Linux/Unix/Unix 等系统在处理文件/文件夹名时有差异。
89	89
90	90		- Windows 允许空文件名。这就是为什么 FileExistsUTF8('..\\') 可以检查空文件名的父目录。
91	91		- 在 Linux/Unix/类Unix系统空文件映射到目录上将被视为文件。这意味着，FileExistsUTF8('../') 将检查父目录，这会返回真。
92	92
93	93		文件名的双路径分隔符应该区别对待：
94	94
95	95		- Windows：是 'C:\\' 不是 'C:\\\\'
96	96		- 类Unix系统：路径 '/usr//' 等同于 '/usr/'，如果 '/usr' 是目录，则，也等同于上面。
97	97
98	98		连接文件名时，要注意，如：
99	99
100	100		``` pascal
101	101		FullFilename:=FilePath+PathDelim+ShortFilename; // 这会返回 2个 PathDelims ，在 Windows和 Linux 将导致不同结果
102	102		FullFilename:=AppendPathDelim(FilePath)+ShortFilename); // 仅创建一个 PathDelim
103	103		FullFilename:=TrimFilename(FilePath+PathDelim+ShortFilename); // 仅创建 1个 PathDelim 并做些清理
104	104		```
105	105
106	106		TrimFilename 函数将替换双路径分隔符为单分隔符，并缩短 '..' 路径，如，/usr//lib/../src 将修整为 /usr/src 。
107	107
108	108		如果想判断一个目录是否可用，使用 DirectoryExistsUTF8。
109	109
110	110		使用 ExtractFilePath 可以返回文件名的路径部分，并包含路径定界符。
111	111
112	112		- 在类 Unix 系统上，可以使用 FileExistsUTF8 ，如 FileExistsUTF8('/home/user/') ，如果 /home/user 存在，将返回真。
113	113		- 在 Windows 下，你必须使用 DirectoryExistsUTF8 函数，但在此之前，你必须删除路径分隔符，如 ChompPathDelim 函数。
114	114
115	115		在类Unix系统的根目录是 '/'，使用 ChompPathDelim 将创建一个空字符串。DirPathExists 函数工作方式类同于 DirectoryExistsUTF8，将修剪给定的路径。
116	116
117	117		需要注意的是，Unix/Linux 上使用 '~' (波浪号)代表用户目录，典型的例子，'/home/jim/' 将调用 jim 用户的文件。因此 '~/myapp/myfile' 和 '/home/jim/myapp/myfile' 在命令行和脚本中相同。然则，Lazarus 不会自动扩展波浪号。这需要使用 ExpandFileNameUTF8('~/myapp/myfile') 来获取完整路径。
118	118
119	119		### 文本编码
120	120
121	121		文本文件的编码通常是当前系统的编码。在Windows下，是代码页之一，而在Linux，BSD和Mac OS X，通常是 UTF-8编码。没有 100% 的规则找出文本文件的编码。LCL 的lconvencoding 有一个函数可以获得文件编码：
122	122
123	123		``` pascal
124	124		function GuessEncoding(const s: string): string;
125	125		function GetDefaultTextEncoding: string;
126	126		```
127	127
128	128		编码转换：
129	129
130	130		``` pascal
131	131		function ConvertEncoding(const s, FromEncoding, ToEncoding: string): string;
132	132
133	133		function UTF8BOMToUTF8(const s: string): string; // UTF8 与 BOM
134	134		function ISO_8859_1ToUTF8(const s: string): string; // 中欧
135	135		function CP1250ToUTF8(const s: string): string; // 中欧
136	136		function CP1251ToUTF8(const s: string): string; // 西里尔
137	137		function CP1252ToUTF8(const s: string): string; // 拉丁语1
138	138		...
139	139		function UTF8ToUTF8BOM(const s: string): string; // UTF8 与 BOM
140	140		function UTF8ToISO_8859_1(const s: string): string; // 中欧
141	141		function UTF8ToCP1250(const s: string): string; // 中欧
142	142		function UTF8ToCP1251(const s: string): string; // 西里尔
143	143		function UTF8ToCP1252(const s: string): string; // 拉丁语1
144	144		...
145	145		```
146	146
147	147		如，加载一个文本文件并将其转换为 UTF-8 编码，你可以使用：
148	148
149	149		``` pascal
150	150		var
151	151		sl: TStringList;
152	152		OriginalText: String;
153	153		TextAsUTF8: String;
154	154		begin
155	155		sl:=TStringList.Create;
156	156		try
157	157		sl.LoadFromFile('sometext.txt'); // 注意：此更改系统行行尾
158	158		OriginalText:=sl.Text;
159	159		TextAsUTF8:=ConvertEncoding(OriginalText,GuessEncoding(OriginalText),EncodingUTF8);
160	160		...
161	161		finally
162	162		sl.Free;
163	163		end;
164	164		end;
165	165		```
166	166
167	167		保存文本文件到系统编码可以使用：
168	168
169	169		``` pascal
170	170		sl.Text:=ConvertEncoding(TextAsUTF8,EncodingUTF8,GetDefaultTextEncoding);
171	171		sl.SaveToFile('sometext.txt');
172	172		```
173	173
174	174		### 配置文件
175	175
176	176		你可以使用 SysUtils 单元的 [[doc:rtl/sysutils/getappconfigdir.html\|GetAppConfigDir]] 函数获取合适的位置存储系统配置文件。该函数有一个参数，称为全局。如果为真，则返回一个全局目录，即适用于系统上的所有用户。如果为参数为假，则为运行该程序的用户配置目录。在不支持多用户环境的系统，这两个目录是相同的。
177	177
178	178		也可以使用 [[doc:rtl/sysutils/getappconfigfile.html\|GetAppConfigFile]] 函数，将返回一个合适的配置文件名，你可以这样使用它：
179	179
180	180		ConfigFilePath := GetAppConfigFile(False) + '.conf';
181	181
182	182		以下是不同系统默认路径输出的例子：
183	183
184	184		``` pascal
185	185		program project1;
186	186
187	187		{$mode objfpc}{$H+}
188	188
189	189		uses
190	190		SysUtils;
191	191
192	192		begin
193	193		WriteLn(GetAppConfigDir(True));
194	194		WriteLn(GetAppConfigDir(False));
195	195		WriteLn(GetAppConfigFile(True));
196	196		WriteLn(GetAppConfigFile(False));
197	197		end.
198	198		```
199	199
200	200		在 GNU/Linux系统上FPC 2.2.2输出，为 TRUE 时会有问题，在 2.2.3 已经修复。
201	201
202	202		/etc/project1/
203	203		/home/user/.config/project1/
204	204		/etc/project1.cfg
205	205		/home/user/.config/project1.cfg
206	206
207	207		你可以看到，全局配置文件存储在 /etc 目录和本地配置存储在用户的主目录中隐藏文件夹。目录中，其名称以点(.)被隐藏在Linux上。你可以使用 GetAppConfigDir 返回的路径以创建目录，然后保存配置文件。
208	208
209	209		> Note: 普通用户不允许写入 /etc 目录。只有拥有超级管理员的用户才可以写入。
210	210
211	211		在 Windows XP 上的 FPC 2.2.4上输出：
212	212
213	213		C:\Documents and Settings\All Users\Application Data\project1\
214	214		C:\Documents and Settings\user\Local Settings\Application Data\project1
215	215		C:\Documents and Settings\All Users\Application Data\project1\project1.cfg
216	216		C:\Documents and Settings\user\Local Settings\Application Data\project1\project1.cfg
217	217
218	218		请注意，在 FPC 2.2.4 之前，全局配置在 Windows 目录。
219	219
220	220		在 Windows 98 上的 FPC 2.2.0上输出：
221	221
222	222		C:\Program Files\PROJECT1
223	223		C:\Windows\Local Settings\Application Data\PROJECT1
224	224		C:\Program Files\PROJECT1\PROJECT1.cfg
225	225		C:\Windows\Local Settings\Application Data\PROJECT1\PROJECT1.cfg
226	226
227	227		在 Mac OS X 上的 FPC 2.2.0上输出：
228	228
229	229		/etc
230	230		/Users/user/.config/project1
231	231		/etc/project1.cfg
232	232		/Users/user/.config/project1/project1.cfg
233	233
234	234		> Note: 使用 UPX 会干扰 GetAppConfigDir 和 GetAppConfigFile 函数。
235	235
236	236		> Note: 在 Mac OS X中，大多数情况下，配置文件是首选文件，是以 ".plist"结尾的XML文件，存放在 /Library/Preferences 或 ~/Library/Preferences中，应用程序包所用的名字来自 Info.plist 的 "Bundle identifier" 字段。使用 Carbon 调用 CFPreference... 是实现这一目标最简单的方法。.config 文件在用户目录违反的设计指导。
237	237
238	238		### 数据和资源文件
239	239
240	240		一个常见的问题是应用程序需要的数据文件在哪里存储，像图像、音乐、XML文件、数据库文件、帮助文件等等。不幸的是，它没有跨平台的功能去取得最佳位置和寻找数据文件。解决办法是，在不同平台上使用 IFDEF。
241	241
242	242		#### Windows
243	243
244	244		在Windows上，数据文件不应该存放在应用程序目录（如 C:\Program Files\\），应该在特定位置（见 [1](http://support.microsoft.com/kb/310294) 在"对应用程序数据进行分类"）。Windows Vista 或较新的将强制 (用户只有 elevation 或禁用 UAC时才可以写访问这些目录) 使用文件夹重定向机制，以适应旧的，错误的编程应用。只读不写数据，应用程序仍然可以正常工作。
245	245
246	246		查看 [[Windows Programming Tips\|获取特殊文件夹（我的文档、桌面、本地应用程序数据等）]]。
247	247
248	248		#### Unix/Linux
249	249
250	250		在大多数Unix系统（像Linux, FreeBSD, OpenBSD, Solaris），应用程序数据存储在一个固定的地方，它可以在 /usr/share/app_name 或 /opt/app_name。
251	251
252	252		写入的数据通常存储在 /var/\<programname\>，具有适当的权限。
253	253
254	254		用户特定的读/写、配置/数据文件，将存储的用户主目录下（如存储在~/.myfancyprogram）。
255	255
256	256		#### OSX
257	257
258	258		Mac OS X是一个异常在UNIX系统。部署应用程序的最佳方法是使用一个应用程序包,其中包括你的软件需要的所有文件。你所谓的资源文件应该位于包内,即便被移动,它仍可以正常工作。您需要使用CoreFoundation API调用找到包的位置。将路径映射到 MyBundle.app/Contents/Resources。
259	259
260	260		#### 示例
261	261
262	262		本节介绍了一种特定解决方案，其中
263	263
264	264		- Windows 下的数据文件与可执行文件存放在一起（或在此基础上的其他目录，像 ResourcesPath + 'data' + PathDelim + 'myfile.dat'）
265	265		- 在 Unix系统中将从配置文件中读取一个目录。如果配置文件不存在或不包含信息，将使用 ('/usr/share/myapp/')做为默认目录。
266	266
267	267		> Warning: 基于上面的解释，这段代码在 Windows 上是错误的——除非它是只读访问！
268	268
269	269		通过 GetAppConfigFile 函数来获得配置文件路径。
270	270
271	271		下面是一个完整的单元，可以在你的程序上使用。
272	272
273	273		``` pascal
274	274		unit appsettings;
275	275
276	276		interface
277	277
278	278		{$ifdef fpc}
279	279		{$mode delphi}{$H+}
280	280		{$endif}
281	281
282	282		uses
283	283		Classes, SysUtils, Forms, IniFiles, constants;
284	284
285	285		type
286	286
287	287		{ TConfigurations }
288	288
289	289		TConfigurations = class(TObject)
290	290		private
291	291		function GetResourcesPath: string;
292	292		public
293	293		{other settings as fields here}
294	294		ConfigFilePath: string;
295	295		ResourcesPath: string;
296	296		constructor Create;
297	297		destructor Destroy; override;
298	298		procedure ReadFromFile(Sender: TObject);
299	299		procedure Save(Sender: TObject);
300	300		end;
301	301
302	302		var
303	303		vConfigurations: TConfigurations;
304	304
305	305		implementation
306	306
307	307		{$IFDEF Win32}
308	308		uses
309	309		Windows;
310	310		{$ENDIF}
311	311		{$ifdef Darwin}
312	312		uses
313	313		MacOSAll;
314	314		{$endif}
315	315
316	316		const
317	317		DefaultDirectory = '/usr/share/myapp/';
318	318		BundleResourcesDirectory = '/Contents/Resources/';
319	319
320	320		SectionGeneral = 'General';
321	321		SectionUnix = 'UNIX';
322	322
323	323		IdentResourcesPath = 'ResourcesPath';
324	324
325	325		{ TConfigurations }
326	326
327	327		constructor TConfigurations.Create;
328	328		begin
329	329		{$ifdef win32}
330	330		ConfigFilePath := ExtractFilePath(Application.EXEName) + 'myapp.ini';
331	331		{$endif}
332	332		{$ifdef Unix}
333	333		ConfigFilePath := GetAppConfigFile(False) + '.conf';
334	334		{$endif}
335	335
336	336		ResourcesPath := GetResourcesPath();
337	337
338	338		ReadFromFile(nil);
339	339		end;
340	340
341	341		destructor TConfigurations.Destroy;
342	342		begin
343	343		Save(nil);
344	344
345	345		inherited Destroy;
346	346		end;
347	347
348	348		procedure TConfigurations.Save(Sender: TObject);
349	349		var
350	350		MyFile: TIniFile;
351	351		begin
352	352		MyFile := TIniFile.Create(ConfigFilePath);
353	353		try
354	354		MyFile.WriteString(SectionUnix, IdentResourcesPath, ResourcesPath);
355	355		finally
356	356		MyFile.Free;
357	357		end;
358	358		end;
359	359
360	360		procedure TConfigurations.ReadFromFile(Sender: TObject);
361	361		var
362	362		MyFile: TIniFile;
363	363		begin
364	364		MyFile := TIniFile.Create(ConfigFilePath);
365	365		try
366	366		// 在这里你可以从配置文件中读取其他信息
367	367
368	368		{$ifdef Win32}
369	369		ResourcesPath := MyFile.ReadString(SectionUnix, IdentResourcesPath,
370	370		ExtractFilePath(Application.EXEName));
371	371		{$else}
372	372		{$ifndef darwin}
373	373		ResourcesPath := MyFile.ReadString(SectionUnix, IdentResourcesPath,
374	374		DefaultDirectory);
375	375		{$endif}
376	376		{$endif}
377	377		finally
378	378		MyFile.Free;
379	379		end;
380	380		end;
381	381
382	382		function TConfigurations.GetResourcesPath(): string;
383	383		begin
384	384		{$ifdef Darwin}
385	385		var
386	386		pathRef: CFURLRef;
387	387		pathCFStr: CFStringRef;
388	388		pathStr: shortstring;
389	389		{$endif}
390	390		begin
391	391		{$ifdef UNIX}
392	392		{$ifdef Darwin}
393	393		pathRef := CFBundleCopyBundleURL(CFBundleGetMainBundle());
394	394		pathCFStr := CFURLCopyFileSystemPath(pathRef, kCFURLPOSIXPathStyle);
395	395		CFStringGetPascalString(pathCFStr, @pathStr, 255, CFStringGetSystemEncoding());
396	396		CFRelease(pathRef);
397	397		CFRelease(pathCFStr);
398	398
399	399		Result := pathStr + BundleResourcesDirectory;
400	400		{$else}
401	401		Result := DefaultDirectory;
402	402		{$endif}
403	403		{$endif}
404	404
405	405		{$ifdef Windows}
406	406		Result := ExtractFilePath(Application.EXEName);
407	407		{$endif}
408	408		end;
409	409
410	410		initialization
411	411
412	412		vConfigurations := TConfigurations.Create;
413	413
414	414		finalization
415	415
416	416		FreeAndNil(vConfigurations);
417	417
418	418		end.
419	419		```
420	420
421	421		这个代码示例，从正确的位置得到一个资源文件：
422	422
423	423		``` pascal
424	424		bmp := TBitmap.Create
425	425		try
426	426		bmp.LoadFromFile(vConfigurations.ResourcesPath + 'MyBitmap.bmp');
427	427		finally
428	428		bmp.Free;
429	429		end;
430	430		```
431	431
432	432		### 32/64 位
433	433
434	434		#### 在运行时检测位数
435	435
436	436		虽然你可以控制定义编译 32位或64位编译器，但有时你想知道程序运行在多少位操作系统上。例如，你在64位的Windows系统上运行 32位的Lazarus 程序，你想在32位程序文件目录运行外部程序，或者你想给用户提供不同的信息：我需要在我的 LazUpdater 程序中为用户提供 32位或64位编译器的选择，如果合适的话。
437	437
438	438		对于 Windows，FPC x86 编译器工作在我的 Vista x64上 —— 感谢 [Lazarus 德国论坛](http://www.lazarusforum.de/viewtopic.php?f=55&t=5287)：
439	439
440	440		``` pascal
441	441		program bitness;
442	442
443	443		{$mode objfpc}{$H+}
444	444		{$APPTYPE CONSOLE}
445	445		uses {$IFDEF UNIX} {$IFDEF UseCThreads}
446	446		cthreads, {$ENDIF} {$ENDIF}
447	447		Classes,
448	448		SysUtils,
449	449		Windows;
450	450
451	451		function IsWindows64: boolean;
452	452		{
453	453		检测如果运行在 32/64 位Windows，
454	454		独立于程序位数。
455	455		原始来源：
456	456		http://www.delphipraxis.net/118485-ermitteln-ob-32-bit-oder-64-bit-betriebssystem.html
457	457		修改自 FreePascal 的Lazarus 德国论坛：
458	458		http://www.lazarusforum.de/viewtopic.php?f=55&t=5287
459	459		}
460	460		{$ifdef WIN32} //修改 KpjComp 的64位编译模式
461	461		type
462	462		TIsWow64Process = function( // IsWow64Process API 类型
463	463		Handle: Windows.THandle; var Res: Windows.BOOL): Windows.BOOL; stdcall;
464	464		var
465	465		IsWow64Result: Windows.BOOL; // 返回 IsWow64Process
466	466		IsWow64Process: TIsWow64Process; // IsWow64Process 函数参考
467	467		begin
468	468		// 尝试从 kernel32 加载所需功能
469	469		IsWow64Process := TIsWow64Process(Windows.GetProcAddress(
470	470		Windows.GetModuleHandle('kernel32'), 'IsWow64Process'));
471	471		if Assigned(IsWow64Process) then
472	472		begin
473	473		// 功能实现：调用它
474	474		if not IsWow64Process(Windows.GetCurrentProcess, IsWow64Result) then
475	475		raise SysUtils.Exception.Create('IsWindows64: bad process handle');
476	476		// 返回函数结果
477	477		Result := IsWow64Result;
478	478		end
479	479		else
480	480		// 功能未实现：不能运行在 Wow64
481	481		Result := False;
482	482		{$else} //如果正在运行的是 64位代码，则系统必须是 64位 :)
483	483		begin
484	484		Result := True;
485	485		{$endif}
486	486		end;
487	487
488	488		begin
489	489		try
490	490		if IsWindows64 then
491	491		begin
492	492		writeln('This operating system is 64 bit.');
493	493		end
494	494		else
495	495		begin
496	496		writeln('This operating system is 32 bit.');
497	497		end;
498	498		except
499	499		on E: exception do
500	500		begin
501	501		writeln('Could not determine bitness of operating system. Error details: ' + E.ClassName+'/'+E.Message);
502	502		end;
503	503		end;
504	504		end.
505	505		```
506	506
507	507		#### 指针/整数类型转换
508	508
509	509		指针在64位上需要 8字节，而不是 32位的4字节。The 'Integer' type remains 32bit on all platforms for compatibility. This means you can not typecast pointers into integers and back.（~~'Integer'类型仍是 32位，并兼容所有平台。这意味着你不能在整型与指针间互转。~~）
510	510
511	511		FPC 为此定义了两种类型: PtrInt 和 PtrUInt。 PtrInt 在32位平台是32位有符号整数，在64位上是64位有符号整数。PtrUInt同上，不同是无符号。
512	512
513	513		工作在 Delphi 和 FPC 的代码：
514	514
515		-	~~`{$IFNDEF FPC}`\~~
516		-	~~`type`\~~
517		-	~~` PtrInt = integer;`\~~
518		-	~~` PtrUInt = cardinal;`\~~
519		-	~~`{$ENDIF}`~~
	515	+	``` pascal
	516	+	{$IFNDEF FPC}
	517	+	type
	518	+	PtrInt = integer;
	519	+	PtrUInt = cardinal;
	520	+	{$ENDIF}
	521	+	```
520	522
521	523		替换所有 integer(指针或对象) 为 PtrInt(指针或对象)。
522	524
523	525		### 字节顺序
524	526
525	527		Intel 平台是little endian（小端字节序），这意味着，首位存放低字节。像，\$1234，存储方式为 \$34 \$12在小端字节序系统中。在 big endian（大端字节序）系统，像powerpc ，\$1234 存储为 \$12 \$34。读取其他系统上的文件时，此不同处很重要。
526	528
527	529		参见：[大端、小端的区别(Big-endian or Little-endian)](http://smilejay.com/2012/01/big-endian_little-endian/)
528	530
529	531		下面代码在两种方式下工作：
530	532
531	533		``` pascal
532	534		{$IFDEF ENDIAN_BIG}
533	535		...
534	536		{$ELSE}
535	537		...
536	538		{$ENDIF}
537	539		```
538	540
539	541		此相反的是ENDIAN_LITTLE。
540	542
541	543		系统单元提供了大量字节序转换功能，像 SwapEndian, BEtoN（大端转换小端）、LEtoN（小端转大端），NtoBE（转换为大端）和 NtoLE（转换为小端）。
542	544
543	545		#### Libc和其他特殊单位
544	546
545	547		避免使用像"oldlinux" 和 "libc" 的单元，因为其在 linux/i386 以外不被支持。
546	548
547	549		#### 汇编
548	550
549	551		避免汇编。
550	552
551	553		#### 编译器定义
552	554
553	555		``` pascal
554	556		{$ifdef CPU32}
555	557		...这里写34位处理器代码
556	558		{$ENDIF}
557	559		{$ifdef CPU64}
558	560		...这里写64位处理器代码
559	561		{$ENDIF}
560	562		```
561	563
562	564		### 项目、包和搜索路径
563	565
564	566		Lazarus projects and packages are designed for multi platforms. Normally you can simply copy the project and the required packages to another machine and compile them there. You don't need to create one project per platform.
565	567
566	568		Some advice to achieve this
567	569
568	570		The compiler creates for every unit a ppu with the same name. This ppu can be used by other projects and packages. The unit source files (e.g. unit1.pas) should not be shared. Simply give the compiler a unit output directory where to create the ppu files. The IDE does that by default, so nothing to do for you here.
569	571
570	572		Every unit file must be part of one project or package. If a unit file is only used by a single project, add it to this project. Otherwise add it to a package. If you have not yet created a package for your shared units, see here: [[Lazarus Packages\|Creating a package for your common units]]
571	573
572	574		Every project and every package should have disjunct directories - they should not share directories. Otherwise you must be an expert in the art of compiler search paths. If you are not an expert or if others who may use your project/package are not experts: do not share directories between projects/packages.
573	575
574	576		#### 特定于平台的单元
575	577
576	578		For example the unit wintricks.pas should only be used under Windows. In the uses section use:
577	579
578	580		``` pascal
579	581		uses
580	582		Classes, SysUtils
581	583		{$IFDEF Windows}
582	584		,WinTricks
583	585		{$ENDIF}
584	586		;
585	587		```
586	588
587	589		If the unit is part of a package, you must also select the unit in the package editor of the package and disable the Use unit checkbox.
588	590
589	591		See also [[Lazarus Packages\|Platform specific units]]
590	592
591	593		#### 特定平台搜索路径
592	594
593	595		When you target several platforms and access the operating system directly, then you will quickly get tired of endless IFDEF constructions. One solution that is used often in the FPC and Lazarus sources is to use include files. Create one sub directory per target. For example win32, linux, bsd, darwin. Put into each directory an include file with the same name. Then use a macro in the include path. The unit can use a normal include directive. An example for one include file for each LCL widget set:
594	596
595	597		Create one file for each widget set you want to support:
596	598
597		-	~~`win32/example.inc`\~~
598		-	~~`gtk/example.inc`\~~
599		-	~~`gtk2/example.inc`\~~
600		-	~~`carbon/example.inc`~~
	599	+	```text
	600	+	win32/example.inc
	601	+	gtk/example.inc
	602	+	gtk2/example.inc
	603	+	carbon/example.inc
	604	+	```
601	605
602	606		You do not need to add the files to the package or project. Add the include search path \$(LCLWidgetType) to the compiler options of your package or project.
603	607
604	608		In your unit use the directive: {\$I example.inc}
605	609
606	610		Here are some useful macros and common values:
607	611
608	612		- LCLWidgetType: win32, gtk, gtk2, qt, carbon, fpgui, nogui
609	613		- TargetOS: linux, win32, win64, wince, freebsd, netbsd, openbsd, darwin (many more)
610	614		- TargetCPU: i386, x86_64, arm, powerpc, sparc
611	615		- SrcOS: win, unix
612	616
613	617		You can use the \$Env() macro to use environment variables.
614	618
615	619		And of course you can use combinations. For example the LCL uses:
616	620
617		-	~~`$(LazarusDir)/lcl/units/$(TargetCPU)-$(TargetOS);$(LazarusDir)/lcl/units/$(TargetCPU)-$(TargetOS)/$(LCLWidgetType)`~~
	621	+	```text
	622	+	$(LazarusDir)/lcl/units/$(TargetCPU)-$(TargetOS);$(LazarusDir)/lcl/units/$(TargetCPU)-$(TargetOS)/$(LCLWidgetType)
	623	+	```
618	624
619	625		See here the complete list of macros: [[IDE Macros in paths and filenames]]
620	626
621	627		#### 计算机/用户的特定搜索路径
622	628
623	629		For example you have two windows machines stan and oliver. On stan your units are in C:\units and on oliver your units are in D:\path. The units belong to the package SharedStuff which is C:\units\sharedstuff.lpk on stan and D:\path\sharedstuff.lpk on oliver. Once you opened the lpk in the IDE or by lazbuild, the path is automatically stored in its configuration files (packagefiles.xml). When compiling a project that requires the package SharedStuff, the IDE and lazbuild knows where it is. So no configuration is needed.
624	630
625	631		If you have want to deploy a package over many machine or for all users of a machine (e.g. a pool for students), then you can add a lpl file in the lazarus source directory. See packager/globallinks for examples.
626	632
627	633		### 区域差异
628	634
629	635		Some functions from Free Pascal, like StrToFloat behave differently depending on the current locale. For example, in the USA the decimal separator is usually ".", but in many European and South American countries it is ",". This can be a problem as sometimes it is desired to have these functions behave in a fixed way, independently from the locale. An example is a file format with decimal points that always needs to be interpreted the same way.
630	636
631	637		The next sections explain how to do that.
632	638
633	639		#### StrToFloat
634	640
635	641		A new set of format settings which set a fixed decimal separator can be created with the following code:
636	642
637	643		``` pascal
638	644		// in your .lpr project file
639	645		uses
640	646		...
641	647		{$IFDEF UNIX}
642	648		clocale
643	649		{ required on Linux/Unix for formatsettings support. Should be one fo the first (probably after cthreads?}
644	650		{$ENDIF}
645	651		```
646	652
647	653		and:
648	654
649	655		``` pascal
650	656		// in your code:
651	657		var
652	658		FPointSeparator, FCommaSeparator: TFormatSettings;
653	659		begin
654	660		// Format seetings to convert a string to a float
655	661		FPointSeparator := DefaultFormatSettings;
656	662		FPointSeparator.DecimalSeparator := '.';
657	663		FPointSeparator.ThousandSeparator := '#';// disable the thousand separator
658	664		FCommaSeparator := DefaultFormatSettings;
659	665		FCommaSeparator.DecimalSeparator := ',';
660	666		FCommaSeparator.ThousandSeparator := '#';// disable the thousand separator
661	667		```
662	668
663	669		Latter on you can use this format settings when calling StrToFloat, like this:
664	670
665	671		``` pascal
666	672		// This function works like StrToFloat, but simply tries two possible decimal separator
667	673		// This will avoid an exception when the string format doesn't match the locale
668	674		function AnSemantico.StringToFloat(AStr: string): Double;
669	675		begin
670	676		if Pos('.', AStr) > 0 then Result := StrToFloat(AStr, FPointSeparator)
671	677		else Result := StrToFloat(AStr, FCommaSeparator);
672	678		end;
673	679		```
674	680
675	681		### GTK2 和屏蔽 FPU 异常
676	682
677	683		Gtk2 library changes the default value of FPU (floating point unit) exception mask. The consequence of this is that some floating point exceptions do not get raised if Gtk2 library is used by the application. That means that, if for example you develop a LCL application on Windows with win32/64 widgetset (which is Windows default) and plan to compile for Linux (where Gtk2 is default widgetset), you should keep this incompatibilities in mind.
678	684
679	685		After [this forum topic](http://www.lazarus.freepascal.org/index.php/topic,13460.0.html) and answers on [this bug report](http://bugs.freepascal.org/view.php?id=19674) it became clear that nothing can be done about this, so we must know what actually these differences are.
680	686
681	687		Therefore, let's do a test:
682	688
683	689		``` pascal
684	690		uses
685	691		..., math,...
686	692
687	693		{...}
688	694
689	695		var
690	696		FPUException: TFPUException;
691	697		FPUExceptionMask: TFPUExceptionMask;
692	698		begin
693	699		FPUExceptionMask := GetExceptionMask;
694	700		for FPUException := Low(TFPUException) to High(TFPUException) do begin
695	701		write(FPUException, ' - ');
696	702		if not (FPUException in FPUExceptionMask) then
697	703		write('not ');
698	704
699	705		writeln('masked!');
700	706		end;
701	707		readln;
702	708		end.
703	709		```
704	710
705	711		Our simple program will get what FPC default is:
706	712
707		-	~~`exInvalidOp - not masked!`\~~
708		-	~~`exDenormalized - masked!`\~~
709		-	~~`exZeroDivide - not masked!`\~~
710		-	~~`exOverflow - not masked!`\~~
711		-	~~`exUnderflow - masked!`\~~
712		-	~~`exPrecision - masked!`\~~
	713	+	```text
	714	+	exInvalidOp - not masked!
	715	+	exDenormalized - masked!
	716	+	exZeroDivide - not masked!
	717	+	exOverflow - not masked!
	718	+	exUnderflow - masked!
	719	+	exPrecision - masked!
	720	+	```
713	721
714	722		However, with Gtk2, only exOverflow is not masked.
715	723
716	724		The consequence is that EInvalidOp and EZeroDivide exceptions do not get raised if the application links to Gtk2 library! Normally, dividing non-zero value by zero raises EZeroDivide exception and dividing zero by zero raises EInvalidOp. For example the code like this:
717	725
718	726		``` pascal
719	727		var
720	728		X, A, B: Double;
721	729		// ...
722	730
723	731		try
724	732		X := A / B;
725	733		// code block 1
726	734		except
727	735		// code block 2
728	736		end;
729	737		// ...
730	738		```
731	739
732	740		will take different direction when compiled in application with Gtk2 widgetset. On win widgetset, when B equals zero, an exception will get raised (EZeroDivide or EInvalidOp, depending on whether A is zero) and "code block 2" will be executed. On Gtk2 X becomes [Infinity](http://www.freepascal.org/docs-html/rtl/math/infinity.html), [NegInfinity](http://www.freepascal.org/docs-html/rtl/math/neginfinity.html), or [NaN](http://www.freepascal.org/docs-html/rtl/math/nan.html) and "code block 1" will be executed.
733	741
734	742		We can think of different ways to overcome this inconsistency. Most of the time you can simply test if B equals zero and don't try the dividing in that case. However, sometimes you will need some different approach. So, take a look at the following examples:
735	743
736	744		``` pascal
737	745		uses
738	746		..., math,...
739	747
740	748		//...
741	749		var
742	750		X, A, B: Double;
743	751		Ind: Boolean;
744	752		// ...
745	753		try
746	754		X := A / B;
747	755		Ind := IsInfinite(X) or IsNan(X); // with gtk2, we fall here
748	756		except
749	757		Ind := True; // in windows, we fall here when B equals zero
750	758		end;
751	759		if Ind then begin
752	760		// code block 2
753	761		end else begin
754	762		// code block 1
755	763		end;
756	764		// ...
757	765		```
758	766
759	767		Or:
760	768
761	769		``` pascal
762	770		uses
763	771		..., math,...
764	772
765	773		//...
766	774		var
767	775		X, A, B: Double;
768	776		FPUExceptionMask: TFPUExceptionMask;
769	777		// ...
770	778
771	779		try
772	780		FPUExceptionMask := GetExceptionMask;
773	781		SetExceptionMask(FPUExceptionMask - [exInvalidOp, exZeroDivide]); // unmask
774	782		try
775	783		X := A / B;
776	784		finally
777	785		SetExceptionMask(FPUExceptionMask); // return previous masking immediately, we must not let Gtk2 internals to be called without the mask
778	786		end;
779	787		// code block 1
780	788		except
781	789		// code block 2
782	790		end;
783	791		// ...
784	792		```
785	793
786	794		Be cautious, do not do something like this (call LCL with still removed mask):
787	795
788	796		``` pascal
789	797		try
790	798		FPUExceptionMask := GetExceptionMask;
791	799		SetExceptionMask(FPUExceptionMask - [exInvalidOp, exZeroDivide]);
792	800		try
793	801		Edit1.Text := FloatToStr(A / B); // NO! Setting Edit's text goes down to widgetset internals and Gtk2 API must not be called without the mask!
794	802		finally
795	803		SetExceptionMask(FPUExceptionMask);
796	804		end;
797	805		// code block 1
798	806		except
799	807		// code block 2
800	808		end;
801	809		// ...
802	810		```
803	811
804	812		But use an auxiliary variable:
805	813
806	814		``` pascal
807	815		try
808	816		FPUExceptionMask := GetExceptionMask;
809	817		SetExceptionMask(FPUExceptionMask - [exInvalidOp, exZeroDivide]);
810	818		try
811	819		X := A / B; // First, we set auxiliary variable X
812	820		finally
813	821		SetExceptionMask(FPUExceptionMask);
814	822		end;
815	823		Edit1.Text := FloatToStr(X); // Now we can set Edit's text.
816	824		// code block 1
817	825		except
818	826		// code block 2
819	827		end;
820	828		// ...
821	829		```
822	830
823	831		In all situations, when developing LCL applications, it is most important to know about this and to keep in mind that some floating point operations can go different way with different widgetsets. Then you can think of an appropriate way to workaround this, but this should not go unnoticed.
824	832
825	833		## 从 Windows 迁移到 *nix 的问题
826	834
827	835		Issues specific to Linux, OSX, Android and other Unixes are described here. Not all subjects may apply to all platforms
828	836
829	837		### 在Unix上没有“应用程序目录”
830	838
831	839		Many programmers are used to call ExtractFilePath(ParamStr(0)) or Application.ExeName to get the location of the executable, and then search for the necessary files for the program execution (Images, XML files, database files, etc) based on the location of the executable. This is wrong on unixes. The string on ParamStr(0) may contain a directory other than the one of the executable, and it also varies between different shell programs (sh, bash, etc).
832	840
833	841		Even if Application.ExeName could in fact know the directory where the executable is, that file could be a symbolic link, so you could get the directory of the link instead (depending on the Linux kernel version, you either get the directory of the link or of the program binary itself).
834	842
835	843		To avoid this read the sections about [[Multiplatform Programming Guide\|configuration files]] and [[Multiplatform Programming Guide\|data files]].
836	844
837	845		### Windows COM 没有自动化
838	846
839	847		With Windows, COM Automation is a powerful way not only of manipulating other programs remotely but also for allowing other programs to manipulate your program. With Delphi you can make your program both an COM Automation client and a COM Automation server, meaning it can both manipulate other programs and in turn be manipulated by other programs. For examples, see [Using COM Automation to interact with OpenOffice and Microsoft Office](http://wiki.lazarus.freepascal.org/Office_Automation#Using_COM_Automation_to_interact_with_OpenOffice_and_Microsoft_Office).
840	848
841	849		#### 替代 OSX
842	850
843	851		Unfortunately, COM Automation isn't available on OS X and Linux. However, you can simulate some of the functionality of COM Automation on OS X using AppleScript.
844	852
845	853		AppleScript is similar to COM Automation in some ways. For example, you can write scripts that manipulate other programs. Here's a very simple example of AppleScript that starts NeoOffice (the Mac version of OpenOffice.org):
846	854
847		-	~~` tell application "NeoOffice"`\~~
848		-	~~` launch`\~~
849		-	~~` end tell`~~
	855	+	``` pascal
	856	+	tell application "NeoOffice"
	857	+	launch
	858	+	end tell
	859	+	```
850	860
851	861		An app that is designed to be manipulated by AppleScript provides a "dictionary" of classes and commands that can be used with the app, similar to the classes of a Windows Automation server. However, even apps like NeoOffice that don't provide a dictionary will still respond to the commands "launch", "activate" and "quit". AppleScript can be run from the OS X Script Editor or Finder or even converted to an app that you can drop on the dock just like any app. You can also run AppleScript from your program, as in this example:
852	862
853		-	~~` Shell('myscript.applescript');`~~
	863	+	```text
	864	+	Shell('myscript.applescript');
	865	+	```
854	866
855	867		This assumes the script is in the indicated file. You can also run scripts on the fly from your app using the OS X OsaScript command:
856	868
857		-	~~` Shell('osascript -e '#39'tell application "NeoOffice"'#39 +`\~~
858		-	~~` ' -e '#39'launch'#39' -e '#39'end tell'#39);`\~~
859		-	~~` {Note use of #39 to single-quote the parameters}`~~
	869	+	``` pascal
	870	+	Shell('osascript -e '#39'tell application "NeoOffice"'#39 +
	871	+	' -e '#39'launch'#39' -e '#39'end tell'#39);
	872	+	{Note use of #39 to single-quote the parameters}
	873	+	```
860	874
861	875		However, these examples are just the equivalent of the following Open command:
862	876
863		-	~~` Shell('open -a NeoOffice');`~~
	877	+	```text
	878	+	Shell('open -a NeoOffice');
	879	+	```
864	880
865	881		Similarly, in OS X you can emulate the Windows shell commands to launch a web browser and launch an email client with:
866	882
867		-	~~` fpsystem('open -a safari "`[`http://gigaset.com/shc/0,1935,hq_en_0_141387_rArNrNrNrN,00.html`](http://gigaset.com/shc/0,1935,hq_en_0_141387_rArNrNrNrN,00.html)`"');`~~
	883	+	```text
	884	+	fpsystem('open -a safari "http://gigaset.com/shc/0,1935,hq_en_0_141387_rArNrNrNrN,00.html"');
	885	+	```
868	886
869	887		and
870	888
871		-	~~` fpsystem('open -a mail "`[`mailto:ss4200@invalid.org`](mailto:ss4200@invalid.org)`"');`~~
	889	+	```text
	890	+	fpsystem('open -a mail "mailto:ss4200@invalid.org"');
	891	+	```
872	892
873	893		which assumes, fairly safely, that an OS X system will have the Safari and Mail applications installed. Of course, you should never make assumptions like this, and for the two previous examples, you can in fact just rely on OS X to do the right thing and pick the user's default web browser and email client if you instead use these variations:
874	894
875		-	~~` fpsystem('open "`[`http://gigaset.com/shc/0,1935,hq_en_0_141387_rArNrNrNrN,00.html`](http://gigaset.com/shc/0,1935,hq_en_0_141387_rArNrNrNrN,00.html)`"');`~~
	895	+	```text
	896	+	fpsystem('open "http://gigaset.com/shc/0,1935,hq_en_0_141387_rArNrNrNrN,00.html"');
	897	+	```
876	898
877	899		and
878	900
879		-	~~` fpsystem('open "`[`mailto:ss4200@invalid.org`](mailto:ss4200@invalid.org)`"');`~~
	901	+	```text
	902	+	fpsystem('open "mailto:ss4200@invalid.org"');
	903	+	```
880	904
881	905		Do not forget to include the Unix unit in your uses clause if you use `fpsystem` or `shell` (interchangeable).
882	906
883	907		The real power of AppleScript is to manipulate programs remotely to create and open documents and automate other activities. How much you can do with a program depends on how extensive its AppleScript dictionary is (if it has one). For example, Microsoft's Office X programs are not very usable with AppleScript, whereas the newer Office 2004 programs have completely rewritten AppleScript dictionaries that compare in many ways with what's available via the Windows Office Automation servers.
884	908
885	909		#### Linux 替代品
886	910
887	911		While Linux shells support sophisticated command line scripting, the type of scripting is limited to what can be passed to a program on the command line. There is no single, unified way to access a program's internal classes and commands with Linux the way they are via Windows COM Automation and OS X AppleScript. However, individual desktop environments (GNOME/KDE) and application frameworks often provide such methods of interprocess communication. On GNOME see Bonobo Components. KDE has the KParts framework, DCOP. OpenOffice has a platform neutral API for controlling the office remotely (google OpenOffice SDK) - though you would probably have to write glue code in another language that has bindings (such as Python) to use it. In addition, some applications have "server modes" activated by special command-line options that allow them to be controlled from another process. It is also possible (Borland did it with Kylix document browser) to "embed" one top-level X application window into another using XReparentWindow (I think).
888	912
889	913		As with Windows, many OS X and Linux programs are made up of multiple library files (.dylib and .so extensions). Sometimes these libraries are designed so you can also use them in programs you write. While this can be a way of adding some of the functionality of an external program to your program, it's not really the same as running and manipulating the external program itself. Instead, your program is just linking to and using the external program's library similar to the way it would use any programming library.
890	914
891	915		### Windows API 函数的替代品
892	916
893	917		Many Windows programs use the Windows API extensively. In cross-platform applications Win API functions in the Windows unit should not be used, or should be enclosed by a conditional compile (e.g. {\$IFDEF MSWINDOWS} ).
894	918
895	919		Fortunately many of the commonly used Windows API functions are implemented in a multiplatform way in the unit [[lclintf]]. This can be a solution for programs which rely heavily on the Windows API, although the best solution is to replace these calls with true cross-platform components from the LCL. You can replace calls to GDI painting functions with calls to a TCanvas object's methods, for example.
896	920
897	921		### 关键代码
898	922
899	923		Fortunately, detecting key codes (e.g. on KeyUp events) is portable: see [[LCL Key Handling]].
900	924
901	925		### 安装跨平台应用
902	926
903	927		See [[Deploying Your Application]]
904	928
905	929		## 参见
906	930
907	931		- [[Writing portable code regarding the processor architecture]]
908	932		- [[Introduction to platform-sensitive development]]
909	933		- <http://www.midnightbeach.com/KylixForDelphiProgrammers.html> A guide for Windows programmers starting with Kylix. Many of concepts / code snippets apply to Lazarus.
910	934		- <http://www.stack.nl/~marcov/porting.pdf> A guide for writing portable source code, mainly between different compilers.
911	935
912	936		---
913	937		From the Free Pascal wiki, page "Multiplatform Programming Guide/zh CN", as it stood on 2020-02-20 after a change by Trev, 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