1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
|
<?xml version="1.0" encoding="UTF-8" ?>
<chapter id="kmdr-basics">
<chapterinfo>
<title
>Fundamentos do &kommander;</title>
<authorgroup>
<author
><firstname
>Tamara</firstname
> <surname
>King</surname
> <affiliation
><address
> <email
>tik@acm.org</email>
</address
></affiliation>
</author>
<author
><firstname
>Eric</firstname
> <surname
>Laffoon</surname
> <affiliation
><address
> <email
>sequitur@kde.org</email>
</address
></affiliation>
</author>
<othercredit role="translator"
><firstname
>Marcus</firstname
><surname
>Gama</surname
><affiliation
><address
><email
>marcus_gama@uol.com.br</email
></address
></affiliation
><contrib
>Tradução</contrib
></othercredit
>
</authorgroup>
</chapterinfo>
<title
>Fundamentos do &kommander;</title>
<!-- This chapter should tell the user how to use your app. You should use as
many sections (Chapter, Sect1, Sect3, etc...) as is necessary to fully document
your application. -->
<sect1 id="concepts">
<title
>Conceitos</title>
<para
>O &kommander; foi desenhado originalmente ao redor de um conceito simples que se provou, de qualquer forma, revolucionário entre as ferramentas de desenho visual. Tipicamente, estas ferramentas permitem-lhe criar janelas e, possivelmente, algumas interfaces completas. Claro que uma interface completa corresponde à janela principal do programa que tem tipicamente menus, uma barra de estado e a área do aplicativo. As janelas de diálogo são janelas-filhas que tipicamente não possuem menus e que são assim chamadas porque o seu intuito é <quote
>estabelecer um diálogo</quote
> ou trocar informações entre você e o aplicativo principal. Os itens numa janela são chamados de <quote
>elementos gráficos</quote
> ou <quote
>widgets</quote
> e você interliga o seu programa com estes elementos. O &kommander; é diferente porque é, inerentemente, não-programático aqui. Ele usa o conceito de associar o texto com os elementos gráficos da janela. Inicialmente isto era chamado de <quote
>Texto Associado</quote
> mas agora é chamado de <quote
>Texto do &kommander;</quote
>. Os elementos gráficos nas janelas do &kommander; poderão incluir o conteúdo de outros elementos através de referências, e um elemento poderá referenciar o seu próprio conteúdo, através da utilização de um <quote
>Especial</quote
> que se parece com o seguinte, @widgetText. Os especiais são comandos que possuem um significado particular no &kommander;. Por isso, se você criou uma janela com dois campos de texto e chamou o primeiro campo <quote
>PrimeiroNome</quote
> e o segundo <quote
>UltimoNome</quote
>, você poderia criar um botão e definir o seu Texto do &kommander; como sendo <quote
>O meu nome é @PrimeiroNome @UltimoNome</quote
>. Você teria que definir o @widgetText nos elementos do primeiro e último nomes. Lembra-se? É preciso dizer ao &kommander; para referenciar o texto dentro deles. Você poderia executar isto a partir de um <application
>Konsole</application
> e ele iria mostrar o texto para você. Por isso, iria referenciar o primeiro nome da seguinte forma: @PrimeiroNome -> obtém o elemento chamado PrimeiroNome (@PrimeiroNome) -> @widgetText -> obtém o conteúdo do campo LineEdit. Por isso, neste caso, o @PrimeiroNome devolve <quote
>José</quote
>: @PrimeiroNome -> @widgetText -> <quote
>José</quote
>. </para>
<para
>Esta é a base simples do &kommander;. O que você poderá fazer com isto é o que realmente interessa. Antes de mais nada, é importante notar que, comparado com a abordagem normal de uma ferramenta baseada numa linguagem, o &kommander; não necessita de instruções de programação para definir estas operações. Isto torna o &kommander; rápido para os programadores. Para os usuários finais, é muito mais simples do que aprender as bases de uma linguagem. Para todos, isto significa que você poderá focar a sua tarefa, em vez de ter o seu material de referência eternamente à mão. Inicialmente, quando as pessoas ficam expostas a uma ferramenta como o &kommander;, a primeira pergunta é <quote
>Onde eu poderei usar esta ferramenta legal?</quote
> À medida que avança, a manipulação de texto é praticamente tudo o que precisa. </para>
<para
>Assim, o que o &kommander; pode fazer? Aqui está uma lista que extrai as operações básicas. O &kommander; pode: </para>
<orderedlist>
<listitem
><para
>Passar cadeias de caracteres ao programa invocado através do 'stdout'.</para
></listitem>
<listitem
><para
>Invocar programas executáveis.</para
></listitem>
<listitem
><para
>Usar o &DCOP; para interagir com os programas do &kde;</para
></listitem>
</orderedlist>
<para
>Se você não for um programador, você poderá querer saber o que é isso em termos mais simples. Em primeiro lugar, se você lançar o &kommander; a partir de um console, então esse console será o programa invocador. Existe uma relação pai-filho aí. O envio de uma mensagem para o console é feito através da 'saída padrão' (stdout) do programa filho, assim chamada porque existe também a 'saída de erros'. Isto é interessante porque alguns programas, como o &quantaplus;, usam a 'stdout' para receber informações dos programas que lançam. Por isso, as janelas do &kommander; podem devolver os seus textos de resultado diretamente no editor do &quantaplus; se forem chamados a partir dele. Isto significa que as janelas do &kommander; podem ser extensões úteis para os programas. </para>
<para
>O segundo caso é a invocação de um executável. Qualquer programa que rode no seu sistema é um executável. Até mesmo um 'script' é executado pelo interpretador dele, por isso também é tecnicamente um executável. O &kommander; poderá executar comandos, tal como o console, mesmo que o execute a partir do menu. Por isso, e por exemplo, se você quiser que ele abra o &GIMP;, você teria um botão do qual derivasse o texto <quote
>gimp</quote
> e o colocasse num item especial como por exemplo: @exec(gimp); nesse caso veria o &GIMP; abrindo. Você poderá também executar o <quote
>ls -l</quote
>, mas só iria ver o resultado se você o estivesse rodando a partir de um console. </para>
<para
>O terceiro caso é bastante interessante, de fato. O &DCOP; é a abreviatura do <emphasis
>D</emphasis
>esktop <emphasis
>CO</emphasis
>mmunication <emphasis
>P</emphasis
>rotocol do &kde; e é bastante poderoso. Siga em frente e rode o programa <application
>kdcop</application
> para dar uma olhada. Você irá ver rapidamente que qualquer aplicativo que seja desenvolvido segundo as normas faz as coisas acontecerem através do &DCOP; e os muito bem desenhados terão bastantes coisas lá. Com o &DCOP; você poderá obter informações de vários tipos, assim como definir os valores dos elementos gráficos, entre outras coisas. Existe uma seção sobre a utilização do &DCOP; neste manual. O &kommander; poderá enviar pedidos de &DCOP; para qualquer aplicativo do &kde;, assim como poderá também ser controlado pelo &DCOP;. De fato, você consegue invocar o &DCOP; na linha de comando para qualquer programa do &kde;. Então, o que há de tão especial? O especial é que, se quiser fazer um volume de comandos, você começa a perceber que o &DCOP; da linha de comando é adequado para comandos curtos, mas poderá provocar atrasos, por exemplo, sendo chamado num ciclo centenas vezes. É por isso que o &kommander; tem um especial @dcop, porque é aproximadamente 1 000 vezes mais rápido. Uma vez que o &kommander; pode enviar e receber pedidos de &DCOP;, o &DCOP; poderá ser usado para criar 'scripts' no &kommander;. É por isso que existe também um especial de &DCOP; local, o @ldcop, que lhe permite escrever muito menos coisas para emitir um comando. </para>
<para
>Isto é tudo sobre os conceitos fundamentais do &kommander;? Não, mas deverá ajudá-lo a perceber um pouco como ele funciona, para que o que for abordado não pareça uma língua estrangeira para você. Existem mais algumas coisas. Os 'signals' e os 'slots' são a forma como o &kommander; lida com os eventos. Um evento num programa basicamente diz que <quote
>algo aconteceu</quote
> como, por exemplo, a criação de um elemento gráfico ou a alteração do texto deste. Estas alterações <quote
>emitem 'signals'</quote
> e você poderá ligar estes 'signals' a um 'slot' receptor que irá então fazer algo quando o evento ocorrer. Um uso disto no &kommander; é o parente do Text do &kommander;, o <quote
>Texto de População</quote
>. O Texto de População irá preencher um elemento gráfico quando for chamado. Tal como o Text do &kommander;, o Texto de População poderá conter sequências de texto ou programas. </para>
<para
>Isto deverá fornecer-lhe os conceitos básicos para começar a usar o &kommander;. Nós tentaremos manter o número de Especiais baixo e usar bastante o &DCOP;. A idéia é que se pretende manter o poder do &kommander; tão consistente e intuitivo quanto possível. Você irá concluir que poderá incorporar qualquer linguagem de 'scripting' no &kommander;, onde quer que precise, e até poderá mesmo usar várias linguagens numa mesma janela. O resto da informação deste documento assume que você está familiarizado com os conceitos e termos aqui apresentados. Os exemplos e tutoriais são também bastante úteis para compreender o que poderá ser feito com o &kommander;. </para>
</sect1>
&editor; <sect1 id="executor">
<title
>O Executor</title>
<para
>O executor, chamado <application
>kmdr-executor</application
>, roda os programas do &kommander;. Ele carrega os arquivos <literal role="extension"
>.kmdr</literal
> e produz dinamicamente uma janela completamente funcional. </para>
<sect2 id="executor-for-programmers">
<title
>O Executor para os Programadores</title>
<para
>Os programadores de C++ podem usar facilmente a classe KmdrDialogInstance nos seus programas de C++ para que o recurso de execução seja incorporada no seu aplicativo, tornando obsoleta a necessidade de executar o programa externo. Para um diálogo padrão, a sobrecarga da criação do diálogo é mínima, mas a criação do aplicativo do &kde; poderá atrasar o diálogo durante cerca de um segundo. </para>
</sect2>
</sect1>
<sect1 id="create-dialog">
<title
>Criando um Diálogo</title>
<para
></para>
</sect1>
</chapter>
|
