Lazarus Faq/pt: what changed

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

Old	New		Line
1	1		## Geral
2	2
3	3		### Onde eu posso encontar mais FAQ?
4	4
5	5		Veja o [website oficial](http://www.lazarus.freepascal.org). Há um outro FAQ também.
6	6
7	7		### Por que os binários gerados são tão grandes?
8	8
9	9		Os binários são grandes porque eles incluem uma série de informações de depuração necessárias para usar o gdb (GNU Debugger).
10	10
11	11		O compilador tem uma opção para remover a informação de depuração do executável (-Xs), mas devido ao um bug no compilador (versão 2.0.2 ou anterior), isso não funciona corretamente. Isso foi arrumado na versão de desenvolvimento do compilador.
12	12
13	13		Você pode usar um programa chamado "strip" para remover os símbolos de depuração do arquivo executável. Ele está localizado no diretório lazarus\pp\bin\i386-win32\\.
14	14
15	15		Simplesmente digite "strip --strip-all \<seu arquivo executável com o caminho\>" na linha de comando.
16	16
17	17		Se você deseja deixar seu programa ainda menor, você deve tentar também o UPX ([1](http://upx.sourceforge.net/)). O UPX é um ótimo compressor de executável. Ele não inclui memória DUPLA overhead no lugar da descompressão. Ele também tem uma rápida descompressão (~10 MB/sec em um Pentium 133).
18	18
19	19		Para usar upx simplesmente digite "upx \<seu arquivo executável com o caminho\>" na linha de comando.
20	20
21	21		após usar ambos strip e upx um simples programa Lazarus GUI terá:
22	22
23	23		- ~ 700kb no Linux
24	24		- ~ 420kb no Windows
25	25
26	26		Uma resposta mais detalhada está dada em [[Size Matters]].
27	27
28	28		Também é importante notar que um programa hello world no lazarus já inclui uma imensa quantia de recursos. Isso inclui:
29	29
30	30		- Biblioteca de manipulação de XML
31	31		- Biblioteca de manipulação de Imagem para arquivos png, xpm, bmp e ico
32	32		- Aproximadamente todos os widgets da Biblioteca de Componentes Lazarus
33	33		- Toda a Biblioteca de RunTime do Free Pascal
34	34
35	35		Portanto ele é muito grande, mas ele já inclui uma quantia de aproximadamente tudo que uma aplicação real não-trivial precisará.
36	36
37	37		O tamanho do executável do Lazarus inicia grande, mas cresce muito devagar, por causa do compilador Free Pascal e a forma que os formulário lazarus operam. Um projeto c++ (veja um exemplo, mas aplique para outras linguagens / ferramentas também) inicia muito pequeno no hello world, mas rapidamente aumenta exponencialmente quando você precisa de recursos para escrever uma aplicação não-trivial.
38	38
39	39		![](/wiki-images/d/de/Lazarus_vs_cpp.png)
40	40
41	41		### Porque a vinculação é lenta no Windows?
42	42
43	43		Falando de modo geral, a compilação no Windows leva mais tempo que em outras plataformas porque o GNU Linker utilizado pelo Free Pascal é lento neste plataforma. Este problema afeta apenas o Windows, e é somente mau em computadores relativamentes velhos (com menos de 1Ghz) e computadores com pouca RAM (128MB ou menos).
44	44
45	45		Também, se você usar vinculação inteligente (smartlink) na LCL a vinculação será mais lenta. Um estudo sobre isso está localizado aqui: [[File size and smartlinking]]
46	46
47	47		Um vinculador interno foi desenvolvido, e está pronto, mas somente estará disponível quando Free Pascal 2.2 for lançado (naturalmente ele já está disponível via subversion). Ele diminuirá o tempo de vinculação drasticamente.
48	48
49	49		### Eu preciso de pc386.cfg ou fpc.cfg?
50	50
51	51		Você precisa somente de fpc.cfg. Nesse caminho o compilador sabe onde procurar as bibliotecas.
52	52
53	53		### Como eu compilo o Lazarus?
54	54
55	55		Faça algo como:
56	56
57		-	~~`$ cd lazarus`\~~
58		-	~~`$ make`~~
	57	+	```text
	58	+	$ cd lazarus
	59	+	$ make
	60	+	```
59	61
60	62		### Como eu crio outros projetos baseados na LCL
61	63
62	64		Se você não pode usar o IDE para criar suas aplicações, use lazbuild. Ele é uma versão por linha de comanda do IDE para criar projetos e pacotes lazarus. Se você deseja criar aplicações LCL sem o IDE e sem o lazbuild, adicione as seguintes linhas para o final do seu fpc.cfg
63	65
64		-	~~` # caminho de busca para outros toolkits (Linux)`\~~
65		-	~~` -Fu/usr/lib/fpc/$fpcversion/units/$fpctarget/{SeuToolKit}`~~
	66	+	```text
	67	+	# caminho de busca para outros toolkits (Linux)
	68	+	-Fu/usr/lib/fpc/$fpcversion/units/$fpctarget/{SeuToolKit}
	69	+	```
66	70
67		-	~~` # caminho de busca para outros toolkits (Windows)`\~~
68		-	~~` -Fu/{SeusDiretorioLazarus}/components/units/{SeuToolKit}`~~
	71	+	```text
	72	+	# caminho de busca para outros toolkits (Windows)
	73	+	-Fu/{SeusDiretorioLazarus}/components/units/{SeuToolKit}
	74	+	```
69	75
70	76
71	77		Onde {SeuToolKit} pode ser gtk2, gnome, qt ou win32 e execute:
72	78
73	79
74	80		ppc386 seu.projeto.pp
75	81
76	82		Dica: Não esqueça de instalar os pacotes de desenvolvimento para seu toolkit, caso contrário você poderá receber algo como [[Linker message: cannot find -l]].
77	83
78	84		### Qual versão do FPC é requerida?
79	85
80	86		2.0.4 para MacOSX e 2.2.0 para todos os outros sistemas. Aviso: A versão 2.2.0 tem um bug no MacOSX com nomes de arquivos sensíveis a maiuscúlas-minúsculas. Você pode também usar a versão svn do fpc 2.2.1 e 2.3.x.
81	87
82	88		### Eu não consigo compilar Lazarus
83	89
84	90		1. Verifique se o seu compilador tem a versão correta.
85	91		2. Verifique se as bibliotecas fpc são de versão idêntica.
86	92		3. Verifique se você tem um fpc.cfg e não um antigo ppc386.cfg
87	93		4. Verifique também o "FAQs dependentes de SO"
88	94
89	95		### Quando eu tento compilar um projeto, eu tenho um erro
90	96
91	97		#### "Cannot find Unit interfaces". Como resolver isso?
92	98
93	99		Esta unit compilada pode ser encontrada em {LazarusDir}\lcl\units\\{TargetCPU}\\{TargetOS}\\{LCLWidgetSet}\interfaces.ppu.
94	100
95	101		Se você selecionar um widgetset diferente do que o que você utilizou para criar lazarus, você precisa criar a LCL para este widgetset.
96	102
97	103		Se ele estiver lá, você vai receber este erro, você esta usando um compilador diferente / rtl para compilar seu projeto do que o utilizado para compilar seu Lazarus IDE. Você pode fazer uma das seguintes opções:
98	104
99	105		- Recriar a LCL (ou o Lazarus completamente) com o compilador selecionado no Environmnent Options. Você pode isso
100	106
101	107		com Tools -\> Build Lazarus. Antes de fazer isso, verifique as configurações atuais em Tools -\> Configure Build Lazarus.
102	108
103	109		- Mude o compilador em Environment Options para o utilizado por você para compilar Lazarus.
104	110
105	111		Veja atentamente também em Environment Options para ver se você esta usando os caminhos corretos para o diretório Lazarus e o diretório dos fontes FPC. Verifique que este este representa somente uma versão no arquivo de configuração do compilador fpc.cfg - ele deve residir em /etc/ para sistemas Linux/Unix ou no mesmo diretório que o do compilador fpc para sistemas Windows. Se fez update do seu compilador algumas modificações vão ser encontradas para uma versão nova; podem ser encontradas no diretorio do software montou seu novo compilador.
106	112
107	113		### Quando eu tento compilar projetos Delphi em Lazarus, eu tenho erro
108	114
109	115		#### na linha :{\$R *.DFM} Como eu posso resolver este problema ?
110	116
111	117		Lazarus (ou melhor, Linux) não entende de recursos), Deste modo você não pode usá-los no caminho Delphi/win32 executado. De qualquer modo Lazarus usa um metódo considerável compátivel com esse. Você pode entretanto usar seus layouts Delphi (arquivos .dfm) se você usar as seguintes etapas:
112	118
113	119		- Você precisa de uma versão textual dos arquivos .dfm. D5 e maior são feitos com um padrão. Se você tem arquivos antigos: ALT-F12 para ver o layout como texto e colar/copiar. Quando você tem um arquivo de texto .dfm, copia corretamente ele para um arquivo .lfm.
114	120		- Criar um arquivo lazres (em lazarus/tools) lazres seuform.lrs seuform.lfm
115	121		- Adicionar a seguinte seçao de inicialização
116	122
117		-	~~` initialization`\~~
118		-	~~` {$I yourform.lrs}`~~
	123	+	```text
	124	+	initialization
	125	+	{$I yourform.lrs}
	126	+	```
119	127
120	128		Por favor tenha em mente que nem todas as propriedades do dfm são suportadas ainda por lazarus, deste modo seu poder pode "dar pau".
121	129
122	130		#### 'Identifier not found LazarusResources'.
123	131
124	132		Quando cria um formulário o Lazarus automaticamente adiciona alguns units extra para seção uses da unit do seu formulário. Durante a conversão de uma unit delphi para uma unit Lazarus isto não ocorre. Assim você precisa adicionar LResources para a seção uses da unit do seu form.
125	133
126	134		### Quando acesso os eventos de objetos (ex: o evento onclick de um botão) recebo a seguinte mensagem de erro: ERROR unit not found: stdCtrls
127	135
128	136		Certifique, em Project -\> Project Inspector, que o seu projeto depende no pacote 'LCL' e que você tem instalado o fontes do FPC.
129	137
130	138		Lazarus é uma IDE e biblioteca de componentes visuais LCL. Todo outro material, como IO, Database, FCL e RTL são fornecidos por FPC. A IDE precisa dos caminhos para todos os fontes.
131	139
132	140		O caminho do fonte FPC pode ser ajustado via: Environment -\> General Options -\> Files -\> FPC source path
133	141
134	142		### Como adicionar um pequeno arquivo no executável, sem necessitar de um arquivo separado. Como adicionar um ressource?
135	143
136	144		Por exemplo:
137	145
138		-	~~`/your/lazarus/path/tools/lazres sound.lrs sound1.wav sound2.wav ...`~~
	146	+	```text
	147	+	/your/lazarus/path/tools/lazres sound.lrs sound1.wav sound2.wav ...
	148	+	```
139	149
140	150		criará um soundlrs do sound1.wav e sound2.wav.
141	151
142	152		Então inclua antes do arquivo de formulário lrs:
143	153
144		-	~~`...`\~~
145		-	~~`initialization`\~~
146		-	~~`{$i unit1.lrs} // este é o arquivo de recurso principal (primeiro)`\~~
147		-	~~`{$i sound.lrs} // arquivo de recurso definido pelo usuário`\~~
	154	+	``` pascal
	155	+	...
	156	+	initialization
	157	+	{$i unit1.lrs} // este é o arquivo de recurso principal (primeiro)
	158	+	{$i sound.lrs} // arquivo de recurso definido pelo usuário
148	159
149		-	~~`end.`~~
	160	+	end.
	161	+	```
150	162
151	163		Em seu programa você pode usar então:
152	164
153		-	~~`Sound1AsString:=LazarusResources.Find('sound1').Value;`~~
	165	+	``` pascal
	166	+	Sound1AsString:=LazarusResources.Find('sound1').Value;
	167	+	```
154	168
155	169		### Qual o significado das várias extensões de arquivos usadas pelo Lazarus?
156	170
157	171		O Tutorial [Os "Arquivos do Lazarus"](http://wiki.lazarus.freepascal.org/index.php/Lazarus_Tutorial/pt#Os_arquivos_do_Lazarus) explica algumas extensões em um exemplo. Aqui uma breve lista:
158	172
159	173		`*.lpi`
160	174		Arquivo de Informação de Projeto Lazarus (armazenado em XML; Contém configurações especificas do projeto)
161	175
162	176		`*.lpr`
163	177		Arquivo de Projeto do Lazarus; contém o fonte Pascal do programa principal
164	178
165	179		`*.lfm`
166	180		Arquivo de Formulário Lazarus; contém informação de configuração de todos os objetos em um formulário (armazenados em um formato especifico do Lazarus; as ações são descritas pelo código-fonte Pascal em um arquivo `*.pas` correspondente)
167	181
168	182		`.pas` ou `.pp`
169	183		Unit com o Código Pascal (normalmente para um formulário, armazenado em um arquivo `*.lfm` correspondente)
170	184
171	185		`*.lrs`
172	186		Arquivo de Recurso do lazarus (este é um arquivo gerado; não confunda com um arquivo de recurso do Windows).
173	187
174	188		Este arquivo pode ser criado com a ferramenta lazres (no diretório Lazarus/Tools) usando a linha de comando: lazres myfile.lrs myfilres.lfm
175	189
176	190		`*.ppu`
177	191		Unit Compilada
178	192
179	193		`*.lpk`
180	194		Arquivo de Informação de Pacote Lazarus. (armazenado em XML; contém as configurações do pacote especificado)
181	195
182	196		### Como posso ver o resultado ou saida da depuração?
183	197
184	198		A LCL tem na procedure LCLProc o envio de saida de debug:
185	199
186	200		- DebugLn: funciona como writeLn, mas só aceita strings.
187	201		- DbgOut: funciona como o Write, mas só aceita strings.
188	202
189	203		Em circunstancias normais o resultado é mostrado no stdout. se o stdout estiver fechado, (por exemplo quando a aplicação é {\$AppType Gui} ou compilada com -WG em windows), nenhum resultado é visivel.
190	204
191	205		O Resultado do debug pode tambem ser impresso em arquivo. A unit LCLProc verifica na sua inicialização os parametros da linha de comando '--debug-log=\<file\>' se achar, ele envia o resultado para \<file\>.
192	206
193	207		Se não encontrar um paramêtro de linha de comando --debug-log, ele verifica se uma variável de ambiente xxx_debullog existe, onde xxx é o programa sem a extensão. Para lazarus isto será lazarus_debuglog. Se esta variável de ambiente existe usa esse tipo de arquivo, Exemplo, se você fizer:
194	208
195		-	~~`set lazarus_debuglog=c:\lazarus\debug.txt`~~
	209	+	```text
	210	+	set lazarus_debuglog=c:\lazarus\debug.txt
	211	+	```
196	212
197	213		saída do debug será escrita em c:\lazarus\debug.txt.
198	214
199	215		Como isto está implementado em lclproc, toda aplicação usando lclproc, podera usar esta facilidade de saida de log.
200	216
201	217		Debuging Lazarus
202	218		Mais aproveitável para windows:
203	219
204	220		Se você precisa de resultado em um console, adicione {\$APPTYPE console} em lazarus.pp ; Então recrie o Lazarus.
205	221
206	222		### Eu arrumei/implementei algo no lazarus. Como eu posso adicionar minhas mudanças para o fonte original do lazarus?
207	223
208	224		Crie um patch e envie para os desenvolvedores. Para detalhes veja [[Creating A Patch/pt]].
209	225
210	226		## Onde esta ... definido
211	227
212	228		### Constantes de Teclas Virtuais
213	229
214	230		Constantes de Teclas Virtuais são definidas em LCLType. Adicione LCLtype em sua uses.
215	231
216	232		## Usando a IDE
217	233
218	234		### Como eu posso usar "Completador de identificador"?
219	235
220	236		Você pode invocar o "Completador de identificador" pressionando \[ctrl\]\[space\]. Sob o item de menu Environment -\> Editor Options -\> Code Tools -\> Automatic Features você pode ajustar com que velocidade isso deve acontecer automaticamente
221	237
222	238		## Linux
223	239
224	240		### Como eu posso depurar no Linux sem a IDE?
225	241
226	242		Primeiro de tudo você precisa de um depurador. gdb é o depurador padrão no linux e este é um GUI-frontends disponível. Um comum frontend é ddd, que é uma parte da maioria das distribuições comuns. Para compilar lazarus/lcl com depuração-informação você deve então usar um dos seguinte comandos para iniciar a seção de depuração:
227	243
228		-	~~` $ make clean; make OPT=-dDEBUG`\~~
229		-	~~` $ ddd lazarus`~~
	244	+	```text
	245	+	$ make clean; make OPT=-dDEBUG
	246	+	$ ddd lazarus
	247	+	```
230	248
231	249		É avisado que ddd não é aceitável como por exemplo o depurador Lazarus. Especialmente se ele vier para vizualizar o conteúdo de uma variável você tem que levar em conta que ddd/gdb são case-sensitive uma vez que Pascal é case-insensitive. Portanto você tem que tipificar todas os nomes de variáveis em maiúsculas para ver o conteúdo delas. Para mais informação dê uma olhada nos manuais fpc.
232	250
233	251		### Eu posso depurar agora, mas ddd não procura meus fontes ou reivindicações que eles contém no código. O que fazer?
234	252
235	253		Este é um problema de caminho associado com qualquer gdb ou ddd. Você pode evitar por isso
236	254
237	255		- Use o comando "Change directory" (Mudança de Diretório) do menu ddd e escolha o diretório onde os sources estão localizados. A desvantagem deste método é que você agora não pode usar o source do programa iniciado com (ex: Lazarus). Deste modo ele pode ser necessário para mudar o diretório em múltiplas horas.
238	256		- Em ddd vá \[Edit\] \[gdb-settings\] e determine o search-path
239	257		- Crie um arquivo \$(HOME)/.gdbinit como:
240	258
241		-	~~` directory /your/path/to/lazarus`\~~
242		-	~~` directory /your/path/to/lazarus/lcl`\~~
243		-	~~` directory /your/path/to/lazarus/lcl/include`~~
	259	+	```text
	260	+	directory /your/path/to/lazarus
	261	+	directory /your/path/to/lazarus/lcl
	262	+	directory /your/path/to/lazarus/lcl/include
	263	+	```
244	264
245	265		### Eu recebo um erro durante a vinculação que states /usr/bin/ld can\\'t find -l
246	266
247	267		Distribuições Baseadas em Pacotes
248	268		Você precisa instalar o pacote que fornece os arquivos lib\<somelib\>.so ou lib\<somelib\>.a. Bibliotecas dinâmicas do Linux tem extensão .so, enquanto bibliotecas estáticas tem extensão .a. Em algumas distros Linux você tem instalado o pacote (rpm, deb) \<nomedopacote\> que fornece \<some lib\>, mas você também precisa do pacote de desenvolvimento (rpm, deb), normalmente chamado \<nomedopacote\>-dev, que contém a .a (biblioteca estática) e/ou o .so (biblioteca dinâmica).
249	269
250	270		Distribuições e Manuais de Compilação Baseados em Fonte (LFS)
251	271		Assegure-se que ali esta uma lib\<somelib\>.a no caminho, e que ela contém a versão correta. para deixar o vinculadores procurar a biblioteca dinâmica (dynamic library), crie um symlink chamado lib\<some lib\>.so para lib\<some lib\>\<version\>-x,y.so se necessário(e/ou para biblioteca estática; lib\<some lib\>.a para lib\<some lib\>\<version\>-x,y.a).
252	272
253	273		FreeBSD
254	274		Como distros baseadas em fonte, também assegure-se que você tem -Fl/usr/local/lib no seu fpc.cfg e/ou caminho de biblioteca do Lazarus. Mantenha em mente que GTK1.2 tem "gtk12" como nome de pacote em FreeBSD. (igualmente para glib)
255	275
256	276		NetBSD
257	277		Como distros baseadas em fonte,
258	278
259	279		também assegure-se que você tem -Fl/usr/pkg/lib no seu fpc.cfg e/ou caminho de biblioteca do Lazarus.
260	280
261	281		### Como eu converto um projeto Kylix 2 em um Projeto Lazarus?
262	282
263	283		Aproximadamente o mesmo caminho como convertendo um projeto Kylix em um projeto Delphi/VCL.
264	284
265	285		A LCL (Biblioteca de Componentes Lazarus) prova compatibilidade com VCL. Kylix CLX prova compatibilidade com QT. Aqui estão umas dicas gerais:
266	286
267	287		- renomeie todas as CLX Q-units usadas como QForms, QControls, QGraphics, ... em contra-parte em sua VCL: Forms, Controls, Graphics, ...
268	288		- Adicione LResources na seção uses de todos dos fontes de todos os formulários
269	289		- renomeie ou copie todos .xfm arquivos como arquivos .lfm.
270	290		- renomeie ou copie arquivo .dpr para arquivo .lpr.
271	291		- remova a diretiva {\$R *.xfm}
272	292		- remova a diretiva {\$R *.xfm}
273	293		- adicione a diretiva {\$mode objfpc}{\$H+} ou {\$mode delphi}{\$H+} para arquivos .pas e .lpr
274	294		- adicione uma seção initialization em cada fonte de formulário e adicione uma diretiva include para o arquivo .lrs (arquivo de recurso lazarus):
275	295
276		-	~~` initialization`\~~
277		-	~~` {$I unit1.lrs}`~~
	296	+	```text
	297	+	initialization
	298	+	{$I unit1.lrs}
	299	+	```
278	300
279	301
280	302		Os arquivos .lrs podem ser criados via a ferramenta lazres em: (lazarusdir)/tools/lazres.
281	303
282	304		Por exemplo: ./lazres unit1.lrs unit1.lfm
283	305
284	306		- Estabeleça diferenças. A LCL ainda não suporta todas propriedades da VCL e a CLX não é completamente compatível com a VCL.
285	307
286	308		### Quando compilo Lazarus o compilador não encontra uma unit. e.g.: gtkint.pp(17,16) Fatal: Can\\'t find unit GLIB
287	309
288	310		1\. Verifique uma limpeza de reconstrução: execute um 'make clean all'
289	311
290	312		2\. Verifique se o compilador tem a versão correta (1.0.10 ou 1.1)
291	313
292	314		3\. Verifique se o compilador está utilizando o arquivo de configuração certo. A instalação normal cria /etc/fpc.cfg. Mas fpc também procura por ~/.ppc386.cfg, ~/.fpc.cfg, /etc/ppc386.cfg e ele utiliza somente o primeiro encontrado.
293	315
294	316
295	317		Dica: Você pode ver qual arquivo de configuração é usado com 'ppc386 -vt bogus''
296	318
297	319		4\. Verifique se o arquivo de configuração (/etc/fpc.cfg) contém os paths certo para seus fpc libs (bibliotecas fpc). Ali é necessário estar três linhas como essas:
298	320
299		-	~~` -Fu/usr/lib/fpc/$version/units/$target`\~~
300		-	~~` -Fu/usr/lib/fpc/$version/units/$target/*`\~~
301		-	~~` -Fu/usr/lib/fpc/$version/units/$target/rtl`~~
	321	+	```text
	322	+	-Fu/usr/lib/fpc/$version/units/$target
	323	+	-Fu/usr/lib/fpc/$version/units/$target/*
	324	+	-Fu/usr/lib/fpc/$version/units/$target/rtl
	325	+	```
302	326
303	327
304	328		A primeira parte destes caminhos (/usr/lib/fpc) depende do seu sistema. Em alguns sistemas essa pode ser por exemplo /usr/local/lib/fpc/... .
305	329
306	330		Dica: Você pode ver os seus searchpaths com 'ppc386 -vt bogus'
307	331
308	332		5\. Verifique que o arquivo de configuração (/etc/fpc.cfg) não contém os search paths para os arquivos fontes lcl (.pp, .pas):
309	333
310		-	~~` forbidden: -Fu(lazarus_source_directory)/lcl`\~~
311		-	~~` forbidden: -Fu(lazarus_source_directory)/lcl/interfaces/gtk`~~
	334	+	```text
	335	+	forbidden: -Fu(lazarus_source_directory)/lcl
	336	+	forbidden: -Fu(lazarus_source_directory)/lcl/interfaces/gtk
	337	+	```
312	338
313	339
314	340		Se você necessita adicionar a lcl em todos os seus projetos fpc, certifique-se que os dois paths parecem como seguinte e estão atrás do, acima descrito, caminho das bibliotecas fpc:
315	341
316		-	~~` -Fu(lazarus_source_directory)/lcl/units`\~~
317		-	~~` -Fu(lazarus_source_directory)/lcl/units/gtk`~~
	342	+	```text
	343	+	-Fu(lazarus_source_directory)/lcl/units
	344	+	-Fu(lazarus_source_directory)/lcl/units/gtk
	345	+	```
318	346
319	347		6\. Verifique se a unit que falta (glib.ppu) existe em seu diretório de bibliotecas fpc. Por exemplo o gtk.ppu pode ser encontrado em /usr/lib/fpc/\$version/units/linux/gtk/. Se ele não existir, a biblioteca fpc está corrompido e deve ser reinstalada.
320	348
321	349		7\. Verifique se os fontes estão em um diretório NFS montado. Em alguns casos as atualizações NFS criam arquivos incorretamente. Plz tente mover os fontes em um não-diretório NFS e compile ali.
322	350
323	351		### Eu tenho instalada a versão binária, mas quando compilo um simples projeto Lazarus dá: Fatal: Can\\'t find unit CONTROLS
324	352
325	353		Provavelmente você está usando um antigo pacote fpc, do que aquele usado para construção dos binários do lazarus. A melhor solução é baixar os fontes e compilar lazarus manualmente Você pode baixar os fontes instantaneamente ou pegar o fonte via cvs:
326	354
327		-	~~` $ bash`\~~
328		-	~~` $ export CVSROOT=:pserver:cvs@cvs.freepascal.org:/FPC/CVS`\~~
329		-	~~` $ cvs login`\~~
330		-	~~` Dica: A senha é `*`cvs`*` (minúscula).`\~~
331		-	~~` $ cvs -z3 checkout lazarus`\~~
332		-	~~` $ cd lazarus`\~~
333		-	~~` $ make`~~
	355	+	```text
	356	+	$ bash
	357	+	$ export CVSROOT=:pserver:cvs@cvs.freepascal.org:/FPC/CVS
	358	+	$ cvs login
	359	+	Dica: A senha é cvs (minúscula).
	360	+	$ cvs -z3 checkout lazarus
	361	+	$ cd lazarus
	362	+	$ make
	363	+	```
334	364
335	365		Certifique-se que lazarus cria um novo diretório fonte: Environment-\>General Options-\>Files-\>Lazarus Directory Top
336	366
337	367		### Lazarus compila, mas ao vincular falha com: libgdk-pixbuf not found
338	368
339	369		Instale a biblioteca gdk-pixbuf para gtk1.x ou então desative o uso:
340	370
341	371		Procure a biblioteca gdk-pixbuf em:
342	372
343	373		RPMs: <http://rpmfind.net/linux/rpm2html/search.php?query=gdk-pixbuf&submit=Search+>...&system=&arch=
344	374
345	375		Pacotes Debian: libgdk-pixbuf-dev
346	376
347	377		Fontes: <ftp://ftp.gnome.org/pub/gnome/unstable/sources/gdk-pixbuf/>
348	378
349	379		Para desativar o uso em Lazarus: Em Tools-\>Configure "Build Lazarus" adicione a opção '-dNoGdkPixBufLib' ou uma linha de comando: "make clean all OPT=-dNoGdkPixBufLib".
350	380
351	381		### Eu tenho SuSE e eu recebo /usr/bin/ld: cannot find -lgtk Error: Error while linking
352	382
353	383		Suse instala os gtk devel libs em /opt/gnome/lib, que não esta no diretorio comum dos arquivos .lib. simplesmente adicione no /etc/fpc.cfg.
354	384
355		-	~~`(-Fl/opt/gnome/lib).`~~
	385	+	```text
	386	+	(-Fl/opt/gnome/lib).
	387	+	```
356	388
357	389		### Lazarus quebra com erro de runtime 211 após eu instalar um componente
358	390
359	391		Após eu ter instalado um componente, Lazarus quebra com a seguinte mensagem:
360	392
361		-	~~`Threading has been used before cthreads was initialized.`\~~
362		-	~~`Make cthreads one of the first units in your uses clause.`\~~
363		-	~~`Runtime error 211 at $0066E188`~~
	393	+	``` pascal
	394	+	Threading has been used before cthreads was initialized.
	395	+	Make cthreads one of the first units in your uses clause.
	396	+	Runtime error 211 at $0066E188
	397	+	```
364	398
365	399		Como eu posso arrumar isso?
366	400
367	401		Seu récem-instalado componente esta usando threads. Fpc em *nix não inclui automaticamente suporte à threading, mas ele pode ser inicializado. Esta inicialização se completa na unit cthreads. Todas as aplicações que usam o componente precisam adicionar esta unit para a clausula uses do programa principal. Seu Lazarus não é uma excessão. Isto pode ser feito de duas formas:
368	402
369	403		1\) Modifique o fonte da ide/lazarus.pp: adicione a unit cthreads para a clausula uses, assim ele fica parecida com:
370	404
371		-	~~`uses`\~~
372		-	~~` //cmem,`\~~
373		-	~~` cthreads, `\~~
374		-	~~` {$IFDEF IDE_MEM_CHECK}`\~~
375		-	~~`...`~~
	405	+	``` pascal
	406	+	uses
	407	+	//cmem,
	408	+	cthreads,
	409	+	{$IFDEF IDE_MEM_CHECK}
	410	+	...
	411	+	```
376	412
377	413		e recrie lazarus.
378	414
379	415		2\) Afim de evitar modificar o arquivo lazarus.pp, um opção no compilador fpc pode ser usada. Desde In order to avoid modifying lazarus.pp file, a fpc compiler option could be used. Uma vez que o pacote que usa threads for compilado, abra o menu Tools-\>Configure "build Lazarus". O diálogo Configure "build Lazarus" deverá ser mostrado, no campo "Options:" digite -Facthreads e então pressione o botão "OK". A próxima etapa é instalar o pacote. Lazarus deverá ser criado com a opção -Facthreads a qual agirá no programa principal como se a unit cthreads fosse a primeira na clausula uses.
380	416
381	417		Dica: Talvez seu antigo (não-quebrado) executável lazarus é armazenado em lazarus.old no mesmo diretório que o executável quebrado.
382	418
383	419		### Quando eu executo um program com threads eu recebeo um erro de runtime 232
384	420
385	421		A mensagem de erro completa é:
386	422
387		-	~~`This binary has no thread support compiled in.`\~~
388		-	~~`Recompile the application with a thread-driver in the program uses`\~~
389		-	~~`clause before other units using thread.`\~~
390		-	~~`Runtime error 232`~~
	423	+	``` pascal
	424	+	This binary has no thread support compiled in.
	425	+	Recompile the application with a thread-driver in the program uses
	426	+	clause before other units using thread.
	427	+	Runtime error 232
	428	+	```
391	429
392	430		Solução: Adicione cthreads como primeira unit para a sua clausula uses do seu programa principal, normalmente o arquivo .lpr.
393	431
394	432		### Eu tenho Ubuntu Breezy e meus fontes em Lazarus IDE parecem muito grande
395	433
396	434		Se Lazarus é compilado com Gtk1.2, as configurações em Gnome Preferences/Font não tem nenhum efeito como eles são relatados por Gtk2. Você pode tentar essa solução Crie um arquivo nomeado .gtkrc.mine em seu diretório home (se ele já não existir ali) e adicione essas linhas para ele:
397	435
398	436		style "default-text" {
399	437		fontset = "--arial-medium-r-normal---100-----iso8859-1,\
400	438		--helvetica-medium-r-normal---100------"
401	439		}
402	440
403	441		class "GtkWidget" style "default-text"
404	442
405	443		### Como eu posso compilar um programa para Gtk2?
406	444
407	445		Até o momento, a ide compilada em Gtk2 é um pouco instável, mas você pode compilar programas para Gtk2 usando a IDE Gtk1.
408	446
409	447		Para começar, recompile LCL para Gtk2. Vá até o menu "Tools"-\>"Configure Build Lazarus" e ajuste a LCL para clean+build e todo o resto tudo como none.
410	448
411	449		Agora click em Ok e vá até o menu "Tools"-\>"Build Lazarus"
412	450
413	451		Agora você pode compilar seu programa com Gtk2 indo em Opções de Compilação e mudando o widgetset para Gtk2.
414	452
415	453		## Windows
416	454
417	455		### Quando eu repito a compilação, eu recebo: The name specified is not recognized as an internal or external command, operable program or batch file.\>& was unexpected at this time.
418	456
419	457		No diretório do compilador existe um arquivo de script OS2 nomeado make.cmd. NT vê isto tambem como um arquivo de script, então remova porque em NT ele não é necessario.
420	458
421	459		### Quando eu repito a compilação, eu recebo: make\[3\]: ./ppc1.exe: Command not found
422	460
423	461		Eu não sei porque mas de alguma forma make tem perdido este caminho. Tente repetir com um diretório base determinado como: make cycle BASEDIR=your_fpc_source_dir_herecompiler
424	462
425	463		### Quando eu tento criar(make) Lazarus eu recebo:
426	464
427	465		#### make.exe: * * * interfaces: No such file or directory (ENOENT). Stop.make.exe: * * * \[interfaces_all\] Error 2
428	466
429	467		Você precisa atualizar o seu make..
430	468
431	469		#### makefile:27: *** You need the GNU utils package to use this Makefile. Stop.
432	470
433	471		Verifique se você não instalou o FPC em um caminho com espaços no nome. O Makefile não suporta isso.
434	472
435	473		### Como eu posso dar a meu programa um aspecto XP como lazarus tem?
436	474
437	475		Se você tem um myprogram.exe então crie um arquivo chamado myprogram.exe.manifest e copie-cole para o arquivo isto:
438	476
439		-	~~`<?xml version="1.0" encoding="UTF-8" standalone="yes"?>`\~~
440		-	~~`<assembly xmlns="`[`urn:schemas-microsoft-com:asm.v1`](urn:schemas-microsoft-com:asm.v1)`" manifestVersion="1.0">`\~~
441		-	~~`<assemblyIdentity processorArchitecture="*" version="1.0.0.0" type="win32" name="myprogram"/>`\~~
442		-	~~`<description>programom</description>`\~~
443		-	~~`<dependency>`\~~
444		-	~~` <dependentAssembly>`\~~
445		-	~~` <assemblyIdentity`\~~
446		-	~~` type="win32"`\~~
447		-	~~` name="Microsoft.Windows.Common-Controls"`\~~
448		-	~~` version="6.0.0.0"`\~~
449		-	~~` publicKeyToken="6595b64144ccf1df"`\~~
450		-	~~` language="*"`\~~
451		-	~~` processorArchitecture="*" />`\~~
452		-	~~` </dependentAssembly>`\~~
453		-	~~` </dependency>`\~~
454		-	~~`</assembly>`~~
	477	+	``` pascal
	478	+	<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
	479	+	<assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0">
	480	+	<assemblyIdentity processorArchitecture="*" version="1.0.0.0" type="win32" name="myprogram"/>
	481	+	<description>programom</description>
	482	+	<dependency>
	483	+	<dependentAssembly>
	484	+	<assemblyIdentity
	485	+	type="win32"
	486	+	name="Microsoft.Windows.Common-Controls"
	487	+	version="6.0.0.0"
	488	+	publicKeyToken="6595b64144ccf1df"
	489	+	language="*"
	490	+	processorArchitecture="*" />
	491	+	</dependentAssembly>
	492	+	</dependency>
	493	+	</assembly>
	494	+	```
455	495
456	496		Voila! XP looks.
457	497
458	498		### Quando eu executo um programa Windows criado em Lazarus ele inicia uma janela DOS
459	499
460	500		Especifique o argumento -WG (Windows GUI) na linha de comando do compilador ou no Lazarus IDE verifique a checkbox Windows GUI na caixa de dialogo compiler options (menu Project -\> Compiler Options -\> Linking -\> target OS Specific options.
461	501
462	502		## Mac OS X
463	503
464	504		### Por que ao compilar um projeto falha com 'unknown section attribute: no_dead_strip'?
465	505
466	506		Inativo 'code stripping' não é suportado pelo assembler e pelo linker antes do Mac OS X 10.4.0. Desativa as opções de compilador
467	507
468	508		- Code \> Unit style \> Smart linkable (-CX)
469	509		- and Linking \> Link Style \> Link smart (-XX)
470	510
471	511		## Licenciando
472	512
473	513		### Eu posso criar aplicações comerciais com o Lazarus ?
474	514
475	515		Sim, a LCL é licenciada sob LGPL com uma exceção, que permite a você linká-la estaticamente sem lançar o fonte de sua aplicação. Modificações e otimização da LCL devem ser distribuidos com o fonte. Lazarus, o IDE, é licenciado sob a GPL.
476	516
477	517		### Por que alguns componentes tem seu uso restringido em aplicações comerciais ?
478	518
479	519		Lazarus vem com componentes adiconais, que são desenvolvidos por terceiros. Esses componentes tem licenças variadas. Se você pretende usar esses componentes é preciso ver a licença nos arquivos fontes desses pacotes. Muitos desses componentes de terceiros estão no diretório "components".
480	520
481	521		### Como eu sei se um Componente é parte da LCL ?
482	522
483	523		TODAS as unidades LCL estão no diretório "lcl". Uma lista de unidades pertencentes à LCL podem ser encontradas em [2](http://lazarus-ccr.sourceforge.net/docs/lcl/). Se seu código utilizar unidades não relacionadas nessa página, você pode estar usando um componente que não é parte da LCL.
484	524
485	525		### Eu posso criar plug-ins comerciais com o Lazarus ?
486	526
487	527		Sim, o parte IDEIntf do IDE é licenciado sob a LGPL com a mesma excessão, de modo que as estruturas de dados compartilhados nesta parte, não obriguem a licença do seu plug - in ou pacote para tempo-de-design estar sob a GPL. Você é livre para escolher um plug - in de qualquer licença; não queremos limitar a sua escolha. Portanto plug-ins não-GPL compatíveis são permitidas. Note que não é permitida a distribuição de uma versão pré-compilada do Lazarus com estes plug-ins não-GPL compatível incluído estaticamente; no entanto, não vemos isso como uma grave limitação, visto que recompilar o Lazarus é fácil.
488	528
489	529		## Colaboradores e Comentários
490	530
491	531		Está página foi convertida do epikwiki [version](http://lazarus-ccr.sourceforge.net/index.php?wiki=LazarusFaq).
492	532
493	533		---
494	534		From the Free Pascal wiki, page "Lazarus Faq/pt", as it stood on 2015-06-06 after a change by FTurtle, 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).
495	535		Category: FAQs/pt
496	536		Category: Lazarus/pt
497	537		Category: Português

Back to history