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
>Bases do &kommander;</title>
<authorgroup>
<author
><firstname
>Tamara</firstname
> <surname
>King</surname
> <affiliation
><address
> <email
>[email protected]</email>
</address
></affiliation>
</author>
<author
><firstname
>Eric</firstname
> <surname
>Laffoon</surname
> <affiliation
><address
> <email
>[email protected]</email>
</address
></affiliation>
</author>
<othercredit role="translator"
><firstname
>José</firstname
><surname
>Pires</surname
><affiliation
><address
><email
>[email protected]</email
></address
></affiliation
><contrib
>Tradução</contrib
></othercredit
>
</authorgroup>
</chapterinfo>
<title
>Bases 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 à volta 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 da aplicação. As janelas de diálogo são janelas-filhas que tipicamente não têm menus e que são assim chamadas porque o seu intuito é <quote
>estabelecer um diálogo</quote
> ou trocar informações entre si e a aplicação 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 é, por inerência, 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 ao seguinte, @widgetText. Os especiais são comandos que têm um significado particular no &kommander;. Por isso, se você criou uma janela com dois campos de texto e chamou ao primeiro campo <quote
>PrimeiroNome</quote
> e ao 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 de 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 si. 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
>Zé</quote
>: @PrimeiroNome -> @widgetText -> <quote
>Eric</quote
>. </para>
<para
>Este é o núcleo simples do &kommander;. O que você poderá fazer com isto é o que é realmente interessante. Primeiro que tudo, é importante notar que, comparado com a aproximação 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 utilizadores finais, é muito mais simples do que aprender as bases de uma linguagem. Para todos, isto significa que você poder-se-á focar na 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 é que eu poderei usar esta ferramenta gira?</quote
> À medida que avança, a manipulação de texto é praticamente tudo o que precisa. </para>
<para
>Por isso, o que é 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 isso trocado por miúdos. Em primeiro lugar, se você lançar o &kommander; a partir de uma consola, então essa consola será o programa invocador. Existe uma relação pai-filho aí. O envio de uma mensagem para a consola é feito através do 'standard output' (stdout) do programa filho, assim chamado porque existe também o 'error output'. Isto é interessante porque alguns programas, como o &quantaplus;, usam o 'stdout' para receber informações dos programas que lançam. Por isso, as janelas do &kommander; podem devolver os seus textos de resultado directamente 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 corra 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 a consola, 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; a abrir. Você poderá também executar o <quote
>ls -l</quote
>, mas só iria ver o resultado se você o estivesse a correr a partir de uma consola. </para>
<para
>O terceiro caso é bastante interessante, de facto. 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 corra o programa <application
>kdcop</application
> para dar uma vista de olhos. Você irá ver rapidamente que qualquer aplicação que seja desenvolvida segundo as normas tem logo a funcionar no &DCOP; e as bastante bem desenhadas 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 secção sobre a utilização do &DCOP; neste manual. O &kommander; poderá enviar pedidos de &DCOP; para qualquer aplicação do &kde;, assim como poderá também ser controlado pelo &DCOP;. De facto, você consegue invocar o &DCOP; na linha de comandos para qualquer programa do &kde;. Daí, 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 comandos é adequado para comandos curtos, mas poderá provocar atrasos, por exemplo, a ser chamado num ciclo centenas vezes. É por isso que o &kommander; tem um especial @dcop, porque é aproximadamente 1 000 vezes mais rápido. Dado 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, o qual lhe permite escrever muito menos coisas para emitir um comando. </para>
<para
>É tudo acerca dos conceitos de base do &kommander;? Não, mas deverá ajudá-lo a ter algum sentido sobre como funciona, para que o que for coberto não pareça uma língua estrangeira para si. Existe 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. Uma utilização 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á dar-lhe os conceitos básicos para começar a usar o &kommander;. Tentar-se-á manter o número de Especiais baixo e usar bastante o &DCOP;. A ideia é 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
>, corre os programas do &kommander;. Ele carrega os ficheiros <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 a funcionalidade de execução seja incorporada na sua aplicação, tornando obsoleta a necessidade de executar o programa externo. Para uma janela normal, a sobrecarga da criação da janela é mínima, mas a criação da aplicação do &kde; poderá atrasar a janela durante cerca de um segundo. </para>
</sect2>
</sect1>
<sect1 id="create-dialog">
<title
>Criar uma Janela</title>
<para
></para>
</sect1>
</chapter>
|
