gtkmm-documentation master - en to pt_BR translation catalogue (482 entries)

en: Programming with <application>gtkmm</application> 3
pt_BR: Programando com <application>gtkmm</application> 3

en: Chapter on "Timeouts".
pt_BR: Capítulo sobre "Tempo limite".

en: Chapter on "Drawing with Cairo".
pt_BR: Capítulo sobre "Desenhando com cairo".

en: Chapter on "Working with gtkmm's Source Code".
pt_BR: Capítulo sobre "Trabalhando com o código fonte do gtkmm".

en: Chapter on "Recent Files".
pt_BR: Capítulo sobre "Arquivos recentes".

en: Parts of chapter on "Internationalization".
pt_BR: Partes do capítulo sobre "Internacionalização".

en: Chapter on "Printing".
pt_BR: Capítulo sobre "Impressão".

en: Section "Build Structure" of chapter on "Wrapping C Libraries with gmmproc".
pt_BR: Seção "Construir a estrutura" do capítulo sobre "Envolvendo bibliotecas C com gmmproc".

en: Chapter on "Multi-threaded programs".
pt_BR: Capítulo sobre "Programas com várias linhas de processamento".

en: Section on Gtk::Grid.
pt_BR: Seção sobre Gtk::Grid.

en: Chapter on Keyboard Events.
pt_BR: Capítulo sobre eventos de teclado.

en: Parts of the update from gtkmm 2 to gtkmm 3.
pt_BR: Partes da atualização da gtkmm 2 a gtkmm 3.

note: This text is copied from the introduction.
en: This book explains key concepts of the <application>gtkmm</application> C++ API for creating user interfaces. It also introduces the main user interface elements ("widgets").
pt_BR: Este livro explica os conceitos-chave da API C++ <application>gtkmm</application> para a criação de interfaces com o usuário. Ele também apresenta os principais elementos de interfaceamento ("widgets").

en: Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.2 or any later version published by the Free Software Foundation; with no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts. You may obtain a copy of the GNU Free Documentation License from the Free Software Foundation by visiting their Web site or by writing to: Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
pt_BR: Permissão concedida para copiar, distribuir e/ou modificar este documento sob os termos da Licença de Documentação Livre GNU (GNU Free Documentation License), Versão 1.2 ou qualquer versão mais recente publicada pela Free Software Foundation; sem Seções Invariantes, Textos de Capa Frontal, e sem Textos de Contracapa. Você pode encontrar uma cópia da licença GNU Free Documentation License da Free Software Foundation ao visitar seu web site ou escrevendo para: Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

en: Introduction
pt_BR: Introdução

en: This book
pt_BR: Este livro

en: This book explains key concepts of the <application>gtkmm</application> C++ API for creating user interfaces. It also introduces the main user interface elements ("widgets"). Although it mentions classes, constructors, and methods, it does not go into great detail. Therefore, for full API information you should follow the links into the reference documentation.
pt_BR: Este livro explica os conceitos-chave da API C++ <application>gtkmm</application> para a criação de interfaces com o usuário. Ele também apresenta os principais elementos de interfaceamento ("widgets"). Embora ele mencione classes, construtores e métodos, ele não entra em maiores detalhes. Portanto, para uma informação mais completa da API, você deveria seguir os links na documentação de referência.

en: This book assumes a good understanding of C++, and how to create C++ programs.
pt_BR: Este livro presume que tenha um bom conhecimento de C++ e de como criar programas em C++.

en: We would very much like to hear of any problems you have learning <application>gtkmm</application> with this document, and would appreciate input regarding improvements. Please see the <link linkend="chapter-contributing">Contributing</link> section for further information.
pt_BR: Gostaríamos muito de ouvir sobre quaisquer problemas que tenha em aprender sobre <application>gtkmm</application> com este documento, e agradeceríamos informações sobre melhorias. Por favor, veja a seção <link linkend="chapter-contributing">Contribuindo</link> para maiores informações.

en: <application>gtkmm</application> is a C++ wrapper for <ulink url="http://www.gtk.org/">GTK+</ulink>, a library used to create graphical user interfaces. It is licensed using the LGPL license, so you can develop open software, free software, or even commercial non-free software using <application>gtkmm</application> without purchasing licenses.
pt_BR: <application>gtkmm</application> é um wrapper em C++ para <ulink url="http://www.gtk.org/">GTK+</ulink>, uma biblioteca usada para criar interfaces gráficas para usuário. Sua licença é a LGPL, então você pode desenvolver software aberto, software livre ou mesmo softwares comerciais não livres usando <application>gtkmm</application> sem comprar licenças.

en: <application>gtkmm</application> was originally named gtk-- because GTK+ already has a + in the name. However, as -- is not easily indexed by search engines the package generally went by the name <application>gtkmm</application>, and that's what we stuck with.
pt_BR: <application>gtkmm</application> foi originalmente denominado como gtk-- porque GTK+ já tem um sinal + no nome. Entretanto, como -- não é facilmente indexado por mecanismos de busca, o pacote geralmente ficava com o nome <application>gtkmm</application>, e é por isso que o adotamos por fim.

en: Why use <application>gtkmm</application> instead of GTK+?
pt_BR: Por que usar <application>gtkmm</application> em vez de GTK+?

en: <application>gtkmm</application> allows you to write code using normal C++ techniques such as encapsulation, derivation, and polymorphism. As a C++ programmer you probably already realise that this leads to clearer and better organized code.
pt_BR: <application>gtkmm</application> permite escrever código usando as técnicas normais de C++ como encapsulamento, derivação e polimorfismo. Como um programador de C++, você já deve perceber que isso leva a um código mais limpo e melhor organizado.

en: <application>gtkmm</application> is more type-safe, so the compiler can detect errors that would only be detected at run time when using C. This use of specific types also makes the API clearer because you can see what types should be used just by looking at a method's declaration.
pt_BR: O <application>gtkmm</application> tem melhor segurança quanto à tipagem, assim o compilador pode detectar erros que só seriam percebidos em tempo de execução ao usar C. Esse uso de tipos específicos também torna a API mais clara, porque você pode ver que tipos deveriam ser usados apenas olhando a declaração de um método.

en: Inheritance can be used to derive new widgets. The derivation of new widgets in GTK+ C code is so complicated and error prone that almost no C coders do it. As a C++ developer you know that derivation is an essential Object Orientated technique.
pt_BR: Herança pode ser usada para derivar novos widgets. A derivação de novos widgets em código GTK+ em C é tão complicada e propensa a erros que quase nenhum programador C a faz. Sendo um desenvolvedor C++, você sabe que derivação é uma técnica essencial em orientação a objetos.

en: Member instances can be used, simplifying memory management. All GTK+ C widgets are dealt with by use of pointers. As a C++ coder you know that pointers should be avoided where possible.
pt_BR: Instâncias membros podem ser usadas, simplificando o gerenciamento de memória. Todos widgets GTK+ C são tratados pelo uso de ponteiros. Como um programador em C++ você sabe que os ponteiros devem ser evitados sempre que possível.

en: <application>gtkmm</application> involves less code compared to GTK+, which uses prefixed function names and lots of cast macros.
pt_BR: <application>gtkmm</application> envolve menos código comparado ao GTK+, que usa nomes de funções com prefixos e muitas macros de conversão.

en: <application>gtkmm</application> compared to Qt
pt_BR: <application>gtkmm</application> comparado ao Qt

en: Trolltech's Qt is the closest competition to <application>gtkmm</application>, so it deserves discussion.
pt_BR: O Qt da Trolltech é o competidor mais próximo do <application>gtkmm</application>, então merece uma discussão.

en: <application>gtkmm</application> developers tend to prefer <application>gtkmm</application> to Qt because <application>gtkmm</application> does things in a more C++ way. Qt originates from a time when C++ and the standard library were not standardised or well supported by compilers. It therefore duplicates a lot of stuff that is now in the standard library, such as containers and type information. Most significantly, Trolltech modified the C++ language to provide signals, so that Qt classes cannot be used easily with non-Qt classes. <application>gtkmm</application> was able to use standard C++ to provide signals without changing the C++ language. See the FAQ for more detailed differences.
pt_BR: Desenvolvedores de <application>gtkmm</application> tendem a preferi-lo a Qt porque <application>gtkmm</application> faz as coisas de uma maneira mais à la C++. Qt vem de uma época quando C++ e a biblioteca padrão não eram padronizados ou com um bom suporte por compiladores. Assim, ele duplica muita coisa faz agora parte da biblioteca padrão, tais como contêineres e informações de tipo. E mais significativo: Trolltech modificou a linguagem C++ para prover os sinais, de forma que classes Qt não podem ser usadas facilmente com classes não-Qt. O <application>gtkmm</application> conseguiu usar o C++ padrão para prover sinais sem alterá-lo. Veja o Perguntas frequentes para maiores detalhes nas diferenças.

en: <application>gtkmm</application> is a wrapper
pt_BR: <application>gtkmm</application> é um wrapper

en: <application>gtkmm</application> is not a native C++ toolkit, but a C++ wrapper of a C toolkit. This separation of interface and implementation has advantages. The <application>gtkmm</application> developers spend most of their time talking about how <application>gtkmm</application> can present the clearest API, without awkward compromises due to obscure technical details. We contribute a little to the underlying GTK+ code base, but so do the C coders, and the Perl coders and the Python coders, etc. Therefore GTK+ benefits from a broader user base than language-specific toolkits - there are more implementers, more developers, more testers, and more users.
pt_BR: <application>gtkmm</application> não é uma ferramenta nativamente em C++, mas um wrapper em C++ para uma ferramenta em C. Essa separação entre interface e implementação tem vantagens. Os desenvolvedores do <application>gtkmm</application> gastam a maior parte do tempo conversando sobre como o <application>gtkmm</application> pode apresentar uma API mais clara, sem se bagunçar devido a detalhes técnicos obscuros. Nós contribuímos um pouco na base do código do GTK+, mas também contribuem os programadores em C, em Perl, em Python, etc. Portanto, o GTK+ se beneficia de uma base de usuários mais ampla do que as de kits de ferramentas de uma linguagem em específico - há mais pessoas que implementam, mais desenvolvedores, mais testadores e mais usuários.

en: Installation
pt_BR: Instalação

en: Dependencies
pt_BR: Dependências

en: Before attempting to install <application>gtkmm</application> 3.0, you might first need to install these other packages.
pt_BR: Antes de tentar instalar o <application>gtkmm</application> 3.0, você pode primeiro precisar instalar estes outros pacotes.

en: These dependencies have their own dependencies, including the following applications and libraries:
pt_BR: Essas dependências têm suas próprias dependências, incluindo os seguintes aplicativos e bibliotecas:

en: Unix and Linux
pt_BR: Unix e Linux

en: Prebuilt Packages
pt_BR: Pacotes pré-compilados

en: Recent versions of <application>gtkmm</application> are packaged by nearly every major Linux distribution these days. So, if you use Linux, you can probably get started with <application>gtkmm</application> by installing the package from the official repository for your distribution. Distributions that include <application>gtkmm</application> in their repositories include Debian, Ubuntu, Red Hat, Fedora, Mandriva, Suse, and many others.
pt_BR: Versões recentes do <application>gtkmm</application> hoje são empacotadas por quase todas as grandes distribuições Linux. Assim, se você usa Linux, é bem possível que possa começar com o <application>gtkmm</application> instalando o pacote do repositório oficial da sua distribuição. Algumas que incluem <application>gtkmm</application> em seus repositórios são Debian, Ubuntu, Red Hat, Fedora, Mandriva, Suse e muitas outras.

en: The names of the <application>gtkmm</application> packages vary from distribution to distribution (e.g. <application>libgtkmm3.0-dev</application> on Debian and Ubuntu or <application>gtkmm30-devel</application> on Red Hat Fedora), so check with your distribution's package management program for the correct package name and install it like you would any other package.
pt_BR: Os nomes dos pacotes <application>gtkmm</application> variam de distribuição para distribuição (exemplo: <application>libgtkmm3.0-dev</application> no Debian e Ubuntu ou <application>gtkmm30-devel</application> no Red Hat Fedora), então verifique com o programa de gerenciamento de pacotes da sua distribuição pelo nome correto do pacote e instale-o como faria com qualquer outro.

en: The package names will not change when new API/ABI-compatible versions of <application>gtkmm</application> are released. Otherwise they would not be API/ABI-compatible. So don't be surprised, for instance, to find <application>gtkmm</application> 3.2 supplied by Debian's <application>libgtkmm3.0-dev</application> package.
pt_BR: Os nomes dos pacotes não irão mudar quando novas versões com API/ABI compatíveis do <application>gtkmm</application> forem liberadas. Senão, não seriam compatíveis em ABI/API. Então não se surpreenda, por exemplo, se encontrar o <application>gtkmm</application> 3.2 sendo fornecido pelo pacote <application>libgtkmm3.0-dev</application> do Debian.

en: Installing From Source
pt_BR: Instalando pelo código fonte

en: If your distribution does not provide a pre-built <application>gtkmm</application> package, or if you want to install a different version than the one provided by your distribution, you can also install <application>gtkmm</application> from source. The source code for <application>gtkmm</application> can be downloaded from <ulink url="http://www.gtkmm.org/"/>.
pt_BR: Se sua distribuição não fornece um pacote do <application>gtkmm</application> pré-compilado, ou se quer instalar uma versão diferente da oferecida pela sua distribuição, você também pode instalar o <application>gtkmm</application> a partir do código-fonte. Ele pode ser baixado em <ulink url="http://www.gtkmm.org/"/>.

en: After you've installed all of the dependencies, download the <application>gtkmm</application> source code, unpack it, and change to the newly created directory. <application>gtkmm</application> can be built and installed with the following sequence of commands:
pt_BR: Depois que instalar todas as dependências, baixe o código-fonte do <application>gtkmm</application>, descompacte-o e entre no diretório recém-criado. O <application>gtkmm</application> pode ser compilado e instalado com a seguinte sequência de comandos:

en: Remember that on a Unix or Linux operating system, you will probably need to be <literal>root</literal> to install software. The <command>su</command> command will allow you to enter the <literal>root</literal> password and have <literal>root</literal> status temporarily.
pt_BR: Lembre que, nos sistemas operacionais Unix ou Linux, é provável que você precise ser <literal>root</literal> para instalar programas. O comando <command>su</command> lhe permite informar a senha de <literal>root</literal> e ter temporariamente o status de <literal>root</literal>.

en: The <filename>configure</filename> script will check to make sure all of the required dependencies are already installed. If you are missing any dependencies, it will exit and display an error.
pt_BR: O script <filename>configure</filename> irá assegurar que todas as dependências exigidas já estão instaladas. Se você estiver sem alguma dependência, ele sairá e mostrará um erro.

en: By default, <application>gtkmm</application> will be installed under the <filename>/usr/local</filename> directory. On some systems you may need to install to a different location. For instance, on Red Hat Linux systems you might use the <literal>--prefix</literal> option with configure, like so: <screen>
    # ./configure --prefix=/usr
    </screen>
pt_BR: Por padrão, o <application>gtkmm</application> será instalado dentro do diretório <filename>/usr/local</filename>. Em alguns sistemas, você talvez precise instalar em um local diferente. Por exemplo, em sistemas Red Hat Linux, você pode usar a opção <literal>--prefix</literal> no configure assim: <screen>
    # ./configure --prefix=/usr
    </screen>

en: You should be very careful when installing to standard system prefixes such as <filename>/usr</filename>. Linux distributions install software packages to <filename>/usr</filename>, so installing a source package to this prefix could corrupt or conflict with software installed using your distribution's package-management system. Ideally, you should use a separate prefix for all software you install from source.
pt_BR: Tenha muito cuidado ao instalar em prefixo padrões do sistema como <filename>/usr</filename>. As distribuições Linux instalam pacotes de programas em <filename>/usr</filename>, então instalar um pacote fonte neste prefixo poderia corromper ou conflitar com os programas instalados usando o sistema de gerenciamento de pacotes da sua distribuição. Idealmente, você deveria usar um prefixo separado para todos os softwares que você instalar a partir do código-fonte.

en: If you want to help develop <application>gtkmm</application> or experiment with new features, you can also install <application>gtkmm</application> from git. Most users will never need to do this, but if you're interested in helping with <application>gtkmm</application> development, see the <link linkend="chapter-working-with-source">Working with gtkmm's Source Code</link> appendix.
pt_BR: Se você quiser ajudar a desenvolver o <application>gtkmm</application> ou experimentar novos recursos, você pode instalar o <application>gtkmm</application> a partir do git. A maioria dos usuários nunca precisarão fazer isso, mas se estiver interessado em ajudar no desenvolvimento do <application>gtkmm</application> , veja o apêndice <link linkend="chapter-working-with-source">Trabalhando com o código-fonte do gtkmm</link>.

en: GTK+ and <application>gtkmm</application> were designed to work well with Microsoft Windows, and the developers encourage its use on the win32 platform. However, Windows has no standard installation system for development libraries. Please see the <ulink url="http://live.gnome.org/gtkmm/MSWindows">Windows Installation</ulink> page for Windows-specific installation instructions and notes.
pt_BR: GTK+ e <application>gtkmm</application> são desenhado para funcionarem bem no Microsoft Windows, e os desenvolvedores encorajam seu uso na plataforma win32. Entretanto, Windows não tem um sistema de instalação padrão para bibliotecas de desenvolvimento. Por favor, veja a página <ulink url="http://live.gnome.org/gtkmm/MSWindows">Instalação no Windows</ulink> para instruções e notas específicas sobre instalação no Windows.

en: Basics
pt_BR: Básico

en: This chapter will introduce some of the most important aspects of <application>gtkmm</application> coding. These will be demonstrated with simple working example code. However, this is just a taster, so you need to look at the other chapters for more substantial information.
pt_BR: Este capítulo irá introduzir alguns dos aspectos mais importantes de um código com <application>gtkmm</application>. Isso será demonstrado com um código de exemplo simples e funcional. Mas isso é só um aperitivo, então você precisará olhar os outros capítulos para informações mais substanciais.

en: Your existing knowledge of C++ will help you with <application>gtkmm</application> as it would with any library. Unless we state otherwise, you can expect <application>gtkmm</application> classes to behave like any other C++ class, and you can expect to use your existing C++ techniques with <application>gtkmm</application> classes.
pt_BR: Seu conhecimento prévio de C++ lhe ajudará no <application>gtkmm</application> assim como o faria com qualquer biblioteca. A menos que declaremos o contrário, você pode considerar que as classes do <application>gtkmm</application> se comportam como qualquer outra classe C++, e pode contar com o uso de técnicas de C++ que você conhece com as bibliotecas do <application>gtkmm</application>.

en: Simple Example
pt_BR: Exemplo simples

en: To begin our introduction to <application>gtkmm</application>, we'll start with the simplest program possible. This program will create an empty 200 x 200 pixel window.
pt_BR: Para iniciar a introdução ao <application>gtkmm</application>, comecemos com o programa mais simples possível. Este programa cria uma janela vazia com 200 x 200 pixels.

en: Source Code
pt_BR: Código-fonte

en: We will now explain each line of the example
pt_BR: Explicaremos agora cada linha do exemplo

en: All <application>gtkmm</application> programs must include certain <application>gtkmm</application> headers; <literal>gtkmm.h</literal> includes the entire <application>gtkmm</application> kit. This is usually not a good idea, because it includes a megabyte or so of headers, but for simple programs, it suffices.
pt_BR: Todos os programas <application>gtkmm</application> devem incluir certos cabeçalhos do <application>gtkmm</application>; <literal>gtkmm.h</literal> inclui todo o kit <application>gtkmm</application>. Isso normalmente não é uma boa ideia, porque inclui um megabyte ou mais de cabeçalhos, mas, para programas simples, é o suficiente.

en: The next two lines of code create a window and set its default (initial) size:
pt_BR: As próximas duas linhas de código criam uma janela e define seu tamanho padrão (inicial):

en: Headers and Linking
pt_BR: Cabeçalhos e vinculação

en: Although we have shown the compilation command for the simple example, you really should use the automake and autoconf tools, as described in "Autoconf, Automake, Libtool", by G. V. Vaughan et al. The examples used in this book are included in the <application>gtkmm</application> package, with appropriate build files, so we won't show the build commands in future. You'll just need to find the appropriate directory and type <literal>make</literal>.
pt_BR: Embora tenhamos mostrado o comando de compilação para o exemplo simples, você deveria, na verdade, usar as ferramentas automake e autoconf, como descritas no Autoconf, Automake, Libtool", de G. V. Vaughan et al. Os exemplos usados neste livro estão inclusos no pacote <application>gtkmm</application>, como os arquivos de compilação apropriados, então não mostraremos mais esses comandos. Você só precisará achar o diretório correto e digitar <literal>make</literal>.

en: To simplify compilation, we use <literal>pkg-config</literal>, which is present in all (properly installed) <application>gtkmm</application> installations. This program 'knows' what compiler switches are needed to compile programs that use <application>gtkmm</application>. The <literal>--cflags</literal> option causes <literal>pkg-config</literal> to output a list of include directories for the compiler to look in; the <literal>--libs</literal> option requests the list of libraries for the compiler to link with and the directories to find them in. Try running it from your shell-prompt to see the results on your system.
pt_BR: Para simplificar a compilação, usaremos o <literal>pkg-config</literal>, que está presente em todas as instalações do <application>gtkmm</application> (se instaladas apropriadamente). Esse programa "sabe" quais opções de compilador são necessárias para compilar os programa que usam <application>gtkmm</application>. A opção <literal>--cflags</literal> faz com que o <literal>pkg-config</literal> emita uma lista de diretórios de inclusão para o compilador buscar; a opção <literal>--libs</literal> solicita a lista de bibliotecas às quais o compilador deve vincular e os diretórios onde achá-los. Experimente executá-lo no seu prompt do shell para ver os resultados no seu sistema.

en: PKG_CHECK_MODULES([MYAPP], [gtkmm-3.0 &gt;= 3.0.0])
pt_BR: PKG_CHECK_MODULES([MEUAPLICATIVO], [gtkmm-3.0 &gt;= 3.0.0])

en: However, this is even simpler when using the <function>PKG_CHECK_MODULES()</function> macro in a standard configure.ac file with autoconf and automake. For instance: <placeholder-1/> This checks for the presence of gtkmm and defines MYAPP_LIBS and MYAPP_CFLAGS for use in your Makefile.am files.
pt_BR: Entretanto, isso é ainda mais simples quando se usa a macro <function>PKG_CHECK_MODULES()</function> em um arquivo configure.ac padrão com autoconf e automake. Por exemplo: <placeholder-1/> Isso confere a presença de gtkmm e define MEUAPLICATIVO_LIBS e MEUAPLICATIVO_CFLAGS para usar em seus arquivos Makefile.am.

en: gtkmm-3.0 is the name of the current stable API. There was an older API called gtkmm-2-4 which installs in parallel when it is available. There were several versions of gtkmm-2.4, such as gtkmm 2.10 and there will be several versions of the gtkmm-3.0 API. Note that the API name does not change for every version because that would be an incompatible API and ABI break. Theoretically, there might be a future gtkmm-4.0 API which would install in parallel with gtkmm-3.0 without affecting existing applications.
pt_BR: gtkmm-3.0 é o nome da API estável atual. Existiu uma antiga chamada gtkmm-2.4 que instala em paralelo quando disponível. Existem muitas versões do gtkmm-2.4, como gtkmm 2.10, e existem várias versões da API gtkmm-3.0 No que o nome da API não se altera a cada versão, por que isso seria uma quebra de compatibilidade de API e ABI. Teoricamente, pode existir uma futura API gtkmm-4.0, que se instalaria em paralelo com o gtkmm-3.0 sem afetar os aplicativos existentes.

en: Note that if you mention extra modules in addition to gtkmm-3.0, they should be separated by spaces, not commas.
pt_BR: Note que se você mencionar módulos além do gtkmm-3.0, eles seriam separados por espaços, e não por vírgulas.

en: Openismus has more <ulink url="http://www.openismus.com/documents/linux/automake/automake.shtml">basic help with automake and autoconf</ulink>.
pt_BR: Openismus tem mais <ulink url="http://www.openismus.com/documents/linux/automake/automake.shtml">ajuda básica sobre automake e autoconf</ulink>.

en: <application>gtkmm</application> applications consist of windows containing widgets, such as buttons and text boxes. In some other systems, widgets are called "controls". For each widget in your application's windows, there is a C++ object in your application's code. So you just need to call a method of the widget's class to affect the visible widget.
pt_BR: Os aplicativos <application>gtkmm</application> consistem de janelas contendo widgets (componentes), como botões e caixas de texto. Em alguns outros sistemas, widgets são chamados de "controles". Para cada widget em janelas do seu aplicativo, há um objeto C++ em seu código. Então você precisa chamar um método da classe do widget para afetar o widget visível.

en: m_box.pack_start(m_Button1);
    m_box.pack_start(m_Button2);
pt_BR: m_caixa.pack_start(m_Botao1);
    m_caixa.pack_start(m_Botao2);

en: m_frame.add(m_box);
pt_BR: m_moldura.add(m_caixa);

en: Most of the chapters in this book deal with specific widgets. See the <link linkend="chapter-container-widgets">Container Widgets</link> section for more details about adding widgets to container widgets.
pt_BR: A maioria dos capítulos deste livro trata de widgets específicos. Veja a seção <link linkend="chapter-container-widgets">Widgets contêineres</link> para mais detalhes sobre a adição de widgets a widgets contêineres.

en: Although you can specify the layout and appearance of windows and widgets with C++ code, you will probably find it more convenient to design your user interfaces with <literal>Glade</literal> and load them at runtime with <literal>Gtk::Builder</literal>. See the <link linkend="chapter-builder">Glade and Gtk::Builder</link> chapter.
pt_BR: Embora você possa especificar a disposição e a aparência das janelas e widgets com o código C++, você provavelmente achará mais conveniente projetar suas interfaces com o usuário com <literal>Glade</literal> e carregá-las em tempo de execução com o <literal>Gtk::Builder</literal>. Veja o capítulo <link linkend="chapter-builder">Glade e Gtk::Builder</link>.

en: Although <application>gtkmm</application> widget instances have lifetimes and scopes just like those of other C++ classes, <application>gtkmm</application> has an optional time-saving feature that you will see in some of the examples. <function>Gtk::manage()</function> allows you to say that a child widget is owned by the container into which you place it. This allows you to <function>new</function> the widget, add it to the container and forget about deleting it. You can learn more about <application>gtkmm</application> memory management techniques in the <link linkend="chapter-memory">Memory Management chapter</link>.
pt_BR: Embora as instâncias de widgets <application>gtkmm</application> tenham tempo de vida e escopo como qualquer outra classe C++, o <application>gtkmm</application> tem um recurso poupador de tempo opcional que você verá em alguns exemplos. <function>Gtk::manage()</function> permite que você diga que um widget filho pertence ao contêiner em que você o colocou. Isso permite que você crie um novo (<function>new</function>) widget, adicione-o ao contêiner e esqueça sobre sua exclusão. Você pode aprender mais sobre as técnicas de gerenciamento de memória do <application>gtkmm</application> no <link linkend="chapter-memory">capítulo de Gerenciamento de memória</link>.

en: Signals
pt_BR: Sinais

en: <application>gtkmm</application>, like most GUI toolkits, is <emphasis>event-driven</emphasis>. When an event occurs, such as the press of a mouse button, the appropriate signal will be <emphasis>emitted</emphasis> by the Widget that was pressed. Each Widget has a different set of signals that it can emit. To make a button click result in an action, we set up a <emphasis>signal handler</emphasis> to catch the button's "clicked" signal.
pt_BR: O <application>gtkmm</application>, como a maioria dos kits de ferramentas para GUI, é <emphasis>orientado a eventos</emphasis>. Quando um evento ocorre, como o pressionar de botão do mouse, o sinal apropriado será <emphasis>emitido</emphasis> pelo widget que foi pressionado. Cada widget tem um conjunto de sinais diferente que pode emitir. Para fazer um clique de botão resultar em uma ação, nós configuramos um <emphasis>manipulador de sinais</emphasis> para capturar o sinal "clicked" do botão.

en: m_button1.signal_clicked().connect( sigc::mem_fun(*this,
      &amp;HelloWorld::on_button_clicked) );
pt_BR: m_botao1.signal_clicked().connect( sigc::mem_fun(*this,
      &amp;OlaMundo::ao_clicar_botao) );

en: <application>gtkmm</application> uses the libsigc++ library to implement signals. Here is an example line of code that connects a Gtk::Button's "clicked" signal with a signal handler called "on_button_clicked": <placeholder-1/>
pt_BR: O <application>gtkmm</application> usa a biblioteca libsigc++ para implementar sinais. Aqui está uma linha de código de exemplo que conecta um sinal "clicked" de um Gtk::Button com um manipulador de eventos chamado "ao_clicar_botao": <placeholder-1/>

en: For more detailed information about signals, see the <link linkend="chapter-signals">appendix</link>.
pt_BR: Para informações mais detalhadas sobre sinais, veja o <link linkend="chapter-signals">apêndice</link>.

en: For information about implementing your own signals rather than just connecting to the existing <application>gtkmm</application> signals, see the <link linkend="chapter-custom-signals">appendix</link>.
pt_BR: Para informações sobre como implementar seus próprios sinais em vez de apenas conectar os sinais <application>gtkmm</application> existentes, veja o <link linkend="chapter-custom-signals">apêndice</link>.

en: You might be surprised to learn that <application>gtkmm</application> doesn't use <classname>std::string</classname> in it its interfaces. Instead it uses <classname>Glib::ustring</classname>, which is so similar and unobtrusive that you could actually pretend that each Glib::ustring is a <classname>std::string</classname> and ignore the rest of this section. But read on if you want to use languages other than English in your application.
pt_BR: Você talvez fique surpreso ao aprender que <application>gtkmm</application> não usa <classname>std::string</classname> em suas interfaces. Em vez disso, utiliza <classname>Glib::ustring</classname>, que é bem similar e não obstrusivo que você poderia fingir que cada <classname>Glib::ustring</classname> é uma <classname>std::string</classname> e ignorar o resto desta seção. Mas continue lendo se quiser usar idiomas que não seja o inglês no seu aplicativo.

en: One of the benefits of UTF-8 is that you don't need to use it unless you want to, so you don't need to retrofit all of your code at once. <classname>std::string</classname> will still work for 7-bit ASCII strings. But when you try to localize your application for languages like Chinese, for instance, you will start to see strange errors, and possible crashes. Then all you need to do is start using <classname>Glib::ustring</classname> instead.
pt_BR: Um dos benefícios do UTF-8 é que você não precisa usá-lo a menos que queira, então não precisa mexer no seu código todo de uma vez. <classname>std::string</classname> funcionará também com textos ASCII 7 bits. Porém, quando você tentar fazer a localização do seu aplicativo para idiomas como chinês, por exemplo, você comerçará a ver uns erros estranhos, e possivelmente uns travamentos. Então, tudo que você precisa fazer é começar a usar <classname>Glib::ustring</classname> no lugar.

en: Note that UTF-8 isn't compatible with 8-bit encodings like ISO-8859-1. For instance, German umlauts are not in the ASCII range and need more than 1 byte in the UTF-8 encoding. If your code contains 8-bit string literals, you have to convert them to UTF-8 (e.g. the Bavarian greeting "Grüß Gott" would be "Gr\xC3\xBC\xC3\x9F Gott").
pt_BR: Note que UTF-8 não é compatível com codificações de 8 bits como ISO-8859-1. Por exemplo, os tremas alemães (umlaut) não estão na faixa ASCII e precisam de mais que 1 byte na codificação UTF-8. Se seu código contém textos constantes em 8 bits, você tem que convertê-los para UTF-8 (exemplo: o cumprimento da Bavária "Grüß Gott" seria "Gr\xC3\xBC\xC3\x9F Gott").

en: You should avoid C-style pointer arithmetic, and functions such as strlen(). In UTF-8, each character might need anywhere from 1 to 6 bytes, so it's not possible to assume that the next byte is another character. <classname>Glib::ustring</classname> worries about the details of this for you so you can use methods such as Glib::ustring::substr() while still thinking in terms of characters instead of bytes.
pt_BR: Você deveria evitar aritmética de ponteiros no estilo C e funções como strlen(). Em UTF-8, cada caractere pode precisar em algum lugar de 1 a 6 bytes, então não é possível assumir que o próximo byte é outro caractere. <classname>Glib::ustring</classname> se preocupa com esses detalhes para você para que possa usar métodos tais como Glib::ustring::substr() enquanto ainda raciocina em termos de caracteres em vez de bytes.

en: Unlike the Windows UCS-2 Unicode solution, this does not require any special compiler options to process string literals, and it does not result in Unicode executables and libraries which are incompatible with ASCII ones.
pt_BR: Ao contrário da solução Unicode UCS-2 do Windows, ele não exige quaisquer opções especiais do compilador para processar textos contantes, além de não gerar executáveis e biblioteca Unicode que sejam incompatíveis com os em ASCII.

en: Reference
pt_BR: Referência

en: See the <link linkend="chapter-internationalization">Internationalization</link> section for information about providing the UTF-8 string literals.
pt_BR: Veja a seção <link linkend="chapter-internationalization">Internacionalização</link> para informações sobre como fornecer textos constantes em UTF-8.

en: Intermediate types
pt_BR: Tipos intermediários

en: Some API related to gtkmm uses intermediate data containers, such as <classname>Glib::StringArrayHandle</classname>, instead of a specific Standard C++ container such as <classname>std::vector</classname> or <classname>std::list</classname>, though <application>gtkmm</application> itself now uses just <classname>std::vector</classname> since <application>gtkmm</application> 3.0.
pt_BR: Algumas API relacionadas ao gtkmm usam contêneires de dados intermediários, como a <classname>Glib::StringArrayHandle</classname>, em vez de usar um contêiner especificamente no padrão C++ como <classname>std::vector</classname> or <classname>std::list</classname>, embora o próprio <application>gtkmm</application> agora use apenas <classname>std::vector</classname> desde a versão <application>gtkmm</application> 3.0.

en: <classname>Glib::StringArrayHandle</classname> or <classname>Glib::ArrayHandle&lt;Glib::ustring&gt;</classname>: Use <classname>std::vector&lt;Glib::ustring&gt;</classname>, <classname>std::list&lt;Glib::ustring&gt;</classname>, <type>const char*[]</type>, etc.
pt_BR: <classname>Glib::StringArrayHandle</classname> ou <classname>Glib::ArrayHandle&lt;Glib::ustring&gt;</classname>: Use <classname>std::vector&lt;Glib::ustring&gt;</classname>, <classname>std::list&lt;Glib::ustring&gt;</classname>, <type>const char*[]</type>, etc.

en: You should not declare these types yourself. You should instead use whatever Standard C++ container you prefer. glibmm will do the conversion for you. Here are some of these intermediate types: <placeholder-1/>
pt_BR: Você não deveria declarar esses tipos. Em vez disso, use qualquer contêiner do C++ padrão que preferir. glibmm fará a conversão para você. Aqui estão alguns desses tipos intermediários: <placeholder-1/>

en: Mixing C and C++ APIs
pt_BR: Misturando APIs C e C++

en: You can use C APIs which do not yet have convenient C++ interfaces. It is generally not a problem to use C APIs from C++, and <application>gtkmm</application> helps by providing access to the underlying C object, and providing an easy way to create a C++ wrapper object from a C object, provided that the C API is also based on the GObject system.
pt_BR: Você pode usar APIs C que ainda não tenham interfaces C++ convenientes. Geralmente não há problema usar APIs C no C++, e o <application>gtkmm</application> ajuda a prover acesso ao objeto C que está por trás, e a prover uma maneira fácil de criar um objeto C++ de wrap para um objeto C, desde que a API C também seja baseada no sistema GObject.

en: To use a <application>gtkmm</application> instance with a C function that requires a C GObject instance, use the <function>gobj()</function> function to obtain a pointer to the underlying GObject instance. For instance
pt_BR: Para passar um objeto <application>gtkmm</application> para uma função C que exija um objeto GObject C, use a função <function>gobj()</function> para obter um ponteiro para o objeto GObject escondido. Por exemplo,

en: 
    Gtk::Button* button = new Gtk::Button("example");
    gtk_button_do_something_new(button-&gt;gobj());
pt_BR: 
    Gtk::Button* botao = new Gtk::Button("exemplo");
    gtk_button_faca_algo_novo(botao-&gt;gobj());

en: To obtain a <application>gtkmm</application> instance from a C GObject instance, use the Glib::wrap() function. For instance
pt_BR: Para obter um objeto <application>gtkmm</application> a partir de um GObject C, use a função Glib::wrap(). Por exemplo,

en: 
    GtkButton* cbutton = get_a_button();
    Gtk::Button* button = Glib::wrap(cbutton);
pt_BR: 
    GtkButton* botao_c = pegar_um_botao();
    Gtk::Button* botao = Glib::wrap(botao_c);

en: Hello World in <application>gtkmm</application>
pt_BR: Olá mundo em <application>gtkmm</application>

en: We've now learned enough to look at a real example. In accordance with an ancient tradition of computer science, we now introduce Hello World, a la <application>gtkmm</application>:
pt_BR: Agora já aprendemos o suficiente para dar uma olhada em um exemplo real. Conforme uma antiga tradição da ciência da computação, apresentaremos um Olá, mundo, à la <application>gtkmm</application>:

en: Try to compile and run it before going on. You should see something like this:
pt_BR: Tente compilá-lo e executá-lo antes de continuar. Você deveria ver algo assim:

en: Hello World
pt_BR: Olá, Mundo

en: Pretty thrilling, eh? Let's examine the code. First, the <classname>HelloWorld</classname> class:
pt_BR: Bem empolgante, hein? Vamos examinar o código. Primeiro, a classe <classname>HelloWorld</classname>:

en: This class implements the "Hello World" window. It's derived from <classname>Gtk::Window</classname>, and has a single <classname>Gtk::Button</classname> as a member. We've chosen to use the constructor to do all of the initialisation work for the window, including setting up the signals. Here it is, with the comments omitted:
pt_BR: Esta classe implementa a janela "Hello World". Ela é derivada de <classname>Gtk::Window</classname> e tem um único <classname>Gtk::Button</classname> como membro. Optamos por usar o construtor para fazer todo o trabalho de iniciação para a janela, incluindo a configuração dos sinais. Aqui está, com os comentários omitidos:

en: Notice that we've used an initialiser statement to give the <literal>m_button</literal> object the label "Hello World".
pt_BR: Note que usamos uma declaração iniciadora para dar ao objeto <literal>m_button</literal> o rótulo "Hello World".

en: Next we call the Window's <methodname>set_border_width()</methodname> method. This sets the amount of space between the sides of the window and the widget it contains.
pt_BR: Em seguida, chamamos o método <methodname>set_border_width()</methodname> da janela. Isso define a quantidade de espaço entre as laterais da janela e o widget que ela contém.

en: We then hook up a signal handler to <literal>m_button</literal>'s <literal>clicked</literal> signal. This prints our friendly greeting to <literal>stdout</literal>.
pt_BR: Depois, associamos um manipulador para o sinal <literal>clicked</literal> de <literal>m_button</literal>. Ele emitirá nosso cumprimento amistoso para <literal>stdout</literal>.

en: Next, we use the Window's <methodname>add()</methodname> method to put <literal>m_button</literal> in the Window. (<methodname>add()</methodname> comes from <classname>Gtk::Container</classname>, which is described in the chapter on container widgets.) The <methodname>add()</methodname> method places the Widget in the Window, but it doesn't display the widget. <application>gtkmm</application> widgets are always invisible when you create them - to display them, you must call their <methodname>show()</methodname> method, which is what we do in the next line.
pt_BR: Em seguida, usamos o método <methodname>add()</methodname> da janela para colocar o <literal>m_button</literal> nela (<methodname>add()</methodname> vem de um <classname>Gtk::Container</classname>, que é descrito no capítulo sobre widgets contêineres). O método <methodname>add()</methodname> põe o widget na janela, mas não o exibe. Os widgets <application>gtkmm</application> são sempre invisíveis ao serem criados: para exibi-los, você tem que chamar o método <methodname>show()</methodname>, que é o que fazemos na linha seguinte.

en: Now let's look at our program's <function>main()</function> function. Here it is, without comments:
pt_BR: Agora vamos olhar para a função <function>main()</function> do nosso programa. Aqui está, sem os comentários:

en: Changes in <application>gtkmm</application> 3
pt_BR: Mudanças na <application>gtkmm</application> 3

en: <application>gtkmm</application>-3.0 is a new version of the <application>gtkmm</application> API that installs in parallel with the older <application>gtkmm</application>-2.4 API. The last version of the <application>gtkmm</application>-2.4 API was <application>gtkmm</application> 2.24. <application>gtkmm</application> 3 has no major fundamental differences to <application>gtkmm</application> 2 but does make several small changes that were not possible while maintaining binary compatibility. If you never used the <application>gtkmm</application>-2.4 API then you can safely ignore this chapter.
pt_BR: <application>gtkmm</application>-3.0 é a nova versão da API <application>gtkmm</application> que se instala em paralelo com a antiga API <application>gtkmm</application>-2.4. A última versão da API <application>gtkmm</application>-2.4 foi a <application>gtkmm</application> 2.24. <application>gtkmm</application> 3 não tem grandes diferenças fundamentais com a API <application>gtkmm</application>-2.4 então você pode ignorar este capítulo.

en: <application>gtkmm</application> 3's library is called <literal>libgtkmm-3.0</literal> rather than <literal>libgtkmm-2.4</literal> and installs its headers in a similarly-versioned directory, so your pkg-config check should ask for <literal>gtkmm-3.0</literal> rather than <literal>gtkmm-2.4</literal>.
pt_BR: A biblioteca <application>gtkmm</application> 3 é chamada <literal>libgtkmm-3.0</literal> em vez de <literal>libgtkmm-2.4</literal> e instala seus cabeçalhos em um diretório com a mesma versão, assim sua verificação pkg-config, deve pedir por <literal>gtkmm-3.0</literal> em vez de <literal>gtkmm-2.4</literal>.

en: <application>gtkmm</application> 3 added some new classes:
pt_BR: <application>gtkmm</application> 3 adicionou algumas novas classes:

en: <classname>Gtk::AppChooser</classname>, <classname>Gtk::AppChooserButton</classname>, <classname>Gtk::AppChooserDialog</classname> allow the user to select an installed application to open a particular type of content.
pt_BR: <classname>Gtk::AppChooser</classname>, <classname>Gtk::AppChooserButton</classname>, <classname>Gtk::AppChooserDialog</classname> permite ao usuário selecionar uma aplicação instalada para abrir um determinado tipo de conteúdo.

en: <classname>Gtk::Grid</classname> is a new container widget that will eventually replace <classname>Gtk::Box</classname>. It arranges its children according to properties of those children rather than its own layout details.
pt_BR: <classname>Gtk::Grid</classname> é um novo widget contêiner que irá substituir <classname>Gtk::Box</classname>. Ele organiza seus filhos de acordo com as propriedades desses filhos, em vez dos seus próprios detalhes de layout.

en: <classname>Gtk::Switch</classname> displays On/Off states more explictly than <classname>Gtk::CheckBox</classname>. It may be useful, for instance, when allowing users to activate hardware.
pt_BR: <classname>Gtk::Switch</classname> exibe os estados ligado/desligado mais explicitamente do que <classname>Gtk::CheckBox</classname>. Ele pode ser útil, por exemplo, ao permitir que os utilizadores possam ativar o hardware.

en: <application>gtkmm</application> 3 also made several small changes to the API, which you will probably encounter when porting code that used <application>gtkmm</application>-2.4. Here is a short list:
pt_BR: <application>gtkmm</application> 3 também fez várias pequenas mudanças na API, que provavelmente você encontrará quando portar o código usado na <application>gtkmm</application>-2.4. Aqui está uma pequena lista:

en: <classname>Gtk::CellLayout</classname>, used by <classname>Gtk::IconView</classname>, <classname>Gtk::TreeView::Column</classname> and <classname>Gtk::ComboBox</classname>, now has a <classname>Gtk::CellArea</classname> which can be used to specify more details of how the <classname>CellRenderer</classname>s are arranged and aligned.
pt_BR: <classname>Gtk::CellLayout</classname>, utilizado pela <classname>Gtk::IconView</classname>, <classname>Gtk::TreeView::Column</classname> e <classname>Gtk::ComboBox</classname>, agora tem uma <classname>Gtk::CellArea</classname> que pode ser usado para especificar mais detalhes sobre como a <classname>CellRenderer</classname> são dispostos e alinhados.

en: Gtk::ComboBox now derives from CellLayout, allowing easier layout and alignment of its <classname>Gtk::CellRenderer</classname>s.
pt_BR: Gtk::ComboBox agora deriva de CellLayout, permitindo uma fácil distribuição e alinhamento das suas <classname>Gtk::CellRenderer</classname>.

en: <classname>Gtk::Adjustment</classname> and <classname>IconSet</classname> and <classname>Gdk::Cursor</classname> are now used via <classname>Glib::RefPtr</classname>.
pt_BR: <classname>Gtk::Adjustment</classname>, <classname>IconSet</classname> e <classname>Gdk::Cursor</classname> agora são usados através de <classname>Glib::RefPtr</classname>.

en: <classname>Gtk::Box</classname>, <classname>Gtk::ButtonBox</classname>, <classname>Gtk::IconView</classname>, <classname>Gtk::Paned</classname>, <classname>Gtk::ProgressBar</classname>, <classname>Gtk::ScaleButton</classname>, <classname>Gtk::Scrollbar</classname> and <classname>Gtk::Separator</classname> now derive from <classname>Gtk::Orientable</classname>, allowing their orientation (vertical or horizontal) to be specified without requiring the use of a derived class such as <classname>Gtk::HBox</classname>.
pt_BR: <classname>Gtk::Box</classname>, <classname>Gtk::ButtonBox</classname>, <classname>Gtk::IconView</classname>, <classname>Gtk::Paned</classname>, <classname>Gtk::ProgressBar</classname>, <classname>Gtk::ScaleButton</classname>, <classname>Gtk::Scrollbar</classname> e <classname>Gtk::Separator</classname> agora derivam de <classname>Gtk::Orientable</classname>, permitindo que sua orientação (vertical ou horizontal) seja especificado sem exigir o uso de uma classe derivada, tal como <classname>Gtk::HBox</classname>.

en: <classname>Gtk::IconView</classname>, <classname>Gtk::TextView</classname>, <classname>Gtk::TreeView</classname> and other widgets derive from Scrollable instead of having their own methods such as <methodname>get_vadjustment()</methodname> and instead of having their own set_scroll_adjustments signal.
pt_BR: <classname>Gtk::IconView</classname>, <classname>Gtk::TextView</classname>, <classname>Gtk::TreeView</classname> e outros widgets derivam de Scrollable em vez de ter seus próprios métodos, como <methodname>get_vadjustment()</methodname> e ao invés de ter seu próprio sinal set_scroll_adjustments.

en: <classname>Gtk::Style</classname> and <classname>Gtk::Rc</classname> were removed, replaced by <classname>Gtk::StyleContext</classname>, and <classname>Gtk::StyleProvider</classname>s, such as <classname>Gtk::CssProvider</classname>.
pt_BR: <classname>Gtk::Style</classname> e <classname>Gtk::Rc</classname> foram removidos, substituídos por <classname>Gtk::StyleContext</classname>, e <classname>Gtk::StyleProvider</classname>, tal como <classname>Gtk::CssProvider</classname>.

en: Widget::on_expose_event() was replaced by Widget::on_draw(), which assumes that cairomm is used for drawing, via the provided <classname>Cairo::Context</classname> and does not require you to call <methodname>Cairo::Context::clip()</methodname>.
pt_BR: Widget::on_expose_event() foi substituido por Widget::on_draw(), que assume que cairomm é utilizado para desenho, por meio do <classname>Cairo::Context</classname> e não requer que você chame <methodname>Cairo::Context::clip()</methodname>.

en: <classname>Gdk::RGBA</classname> replaces <classname>Color</classname>, adding an alpha component for opacity. <classname>Colormap</classname> was removed, along with its awkward use to allocate colors.
pt_BR: <classname>Gdk::RGBA</classname> substitui <classname>Color</classname>, adicionando um componente alfa para a opacidade. <classname>Colormap</classname> foi removido, juntamente com o seu uso difícil de alocar cores.

en: <classname>Gdk::Pixmap</classname> and <classname>Gdk::Bitmap</classname> were removed in favour of <classname>Gdk::Pixbuf</classname>.
pt_BR: <classname>Gdk::Pixmap</classname> e <classname>Gdk::Bitmap</classname> foram removidos em favor de <classname>Gdk::Pixbuf</classname>.

en: <classname>Gdk::Drawable</classname> was removed, with its methods moving into <classname>Gdk::Window</classname>.
pt_BR: <classname>Gdk::Drawable</classname> foi removido, com seus método movidos para <classname>Gdk::Window</classname>.

en: We now use std::vector in several methods instead of the intermediate *Handle types to make the API clearer.
pt_BR: Agora usamos std::vector em vários métodos, em vez do tipo intermediário *Handle para fazer a API mais clara.

en: All deprecated API was removed in <application>gtkmm</application> 3.0, though there will be new deprecations in future versions.
pt_BR: Toda API obsoleta foi removida na <application>gtkmm</application> 3.0, que haverá novas depreciações em versões futuras.

en: As a first step to porting your source code to <application>gtkmm</application>-3.0; you should probably ensure that your application builds with the deprecated <application>gtkmm</application>-2.4; API disabled, by defining macro such as GTK_DISABLE_DEPRECATED. There are some autotools macros that can help with this by defining them optionally at build time. See the <ulink url="https://live.gnome.org/gtkmm/PortingToGtkmm3">gtkmm 3 porting wiki page</ulink> for more details.
pt_BR: Como um primeiro passo para portar seu código fonte para <application>gtkmm</application>-3.0; você provavelmente deve garantir que seu aplicativo funcione com a obsoleta <application>gtkmm</application>-2.4; Desativar a API, definindo a macro tal como GTK_DISABLE_DEPRECATED. Há algumas macros autotools que podem ajudar com isso, definindo-os opcionalmente em tempo de compilação. Consulte <ulink url="https://live.gnome.org/gtkmm/PortingToGtkmm3">gtkmm 3 portabilidade na página wiki</ulink> para mais detalhes.

en: Buttons
pt_BR: Botões

en: <application>gtkmm</application> provides four basic types of buttons:
pt_BR: <application>gtkmm</application> provẽ quatro tipos básicos de botões:

en: Push-Buttons
pt_BR: Botões de pressão

en: <ulink url="http://developer.gnome.org/gtkmm/unstable/classGtk_1_1Button.html"><classname>Gtk::Button</classname></ulink>. Standard buttons, usually marked with a label or picture. Pushing one triggers an action. See the <link linkend="sec-pushbuttons">Button</link> section.
pt_BR: <ulink url="http://developer.gnome.org/gtkmm/unstable/classGtk_1_1Button.html"><classname>Gtk::Button</classname></ulink>. Os botões padrões, normalmente marcados com um rótulo ou imagem. Pressioná-los dispara uma ação. Veja a seção <link linkend="sec-pushbuttons">Botão</link>.

en: Toggle buttons
pt_BR: Botões de alternância

en: <ulink url="http://developer.gnome.org/gtkmm/unstable/classGtk_1_1ToggleButton.html"><classname>Gtk::ToggleButton</classname></ulink>. Unlike a normal Button, which springs back up, a ToggleButton stays down until you press it again. It might be useful as an on/off switch. See the <link linkend="sec-toggle-buttons">ToggleButton</link> section.
pt_BR: <ulink url="http://developer.gnome.org/gtkmm/unstable/classGtk_1_1ToggleButton.html"><classname>Gtk::ToggleButton</classname></ulink>. Ao contrário de um botão normal, que volta à sua posição para cima, um botão de alternância fica pressionado para baixo até que você o pressione novamente. Isso pode ser útil como um interruptor liga/desliga. Veja a seção <link linkend="sec-toggle-buttons">Botão de alternância</link>.

en: Checkboxes
pt_BR: Botão de seleção

en: <ulink url="http://developer.gnome.org/gtkmm/unstable/classGtk_1_1CheckButton.html"><classname>Gtk::CheckButton</classname></ulink>. These act like ToggleButtons, but show their state in small squares, with their label at the side. They should be used in most situations which require an on/off setting. See the <link linkend="sec-checkboxes">CheckBox</link> section.
pt_BR: <ulink url="http://developer.gnome.org/gtkmm/unstable/classGtk_1_1CheckButton.html"><classname>Gtk::CheckButton</classname></ulink>. Este agem como botões de alternância, mas eles mostram seu estado em quadrados pequenos, com seus rótulos ao lado. Eles deveriam ser usado na maioria das situações que exigem uma configuração liga/desliga. Veja a seção <link linkend="sec-checkboxes">Botão de seleção</link>.

en: Radio buttons
pt_BR: Botões de opção

en: <ulink url="http://developer.gnome.org/gtkmm/unstable/classGtk_1_1RadioButton.html"><classname>Gtk::RadioButton</classname></ulink>. Named after the station selectors on old car radios, these buttons are used in groups for options which are mutually exclusive. Pressing one causes all the others in its group to turn off. They are similar to CheckBoxes (a small widget with a label at the side), but usually look different. See the <link linkend="sec-radio-buttons">RadioButton</link> section.
pt_BR: <ulink url="http://developer.gnome.org/gtkmm/unstable/classGtk_1_1RadioButton.html"><classname>Gtk::RadioButton</classname></ulink>. Com o seu nome baseado nos seletores de estação em aparelhos antigos de carro, estes botões são usados em grupos para opções que sejam mutuamente exclusivas. Pressinar um deles faz com que todos os outros do seu grupo sejam desativados. Eles são similares aos botões de seleção (um pequeno widget com um rótulo ao lado), mas normalmente tem uma aparência distinta. Veja a seção <link linkend="sec-radio-buttons">Botão de opção</link>.

en: Note that, due to GTK+'s theming system, the appearance of these widgets will vary. In the case of checkboxes and radio buttons, they may vary considerably.
pt_BR: Note que, devido ao sistema de temas do GTK+, a aparência desses widgets irá variar. No caso dos botões de seleção e de opção, eles podem variar consideravelmente.

en: Button
pt_BR: Botão

en: Constructors
pt_BR: Construtores

en: There are two ways to create a Button. You can specify a label string in the <classname>Gtk::Button</classname> constructor, or set it later with <methodname>set_label()</methodname>.
pt_BR: Existem duas formas de criar um Botão. Você pode especificar um texto de rótulo no construtor <classname>Gtk::Button</classname> ou defini-lo mais tarde com <methodname>set_label()</methodname>.

en: To define an accelerator key for keyboard navigation, place an underscore before one of the label's characters and specify <literal>true</literal> for the optional <literal>mnemonic</literal> parameter. For instance:
pt_BR: Para definir uma tecla aceleradora para navegação por teclado, coloque uma sublinha antes de um dos caracteres do rótulo e especifique <literal>true</literal> para o parâmetro opcional <literal>mnemonic</literal>. Por exemplo:

en: Gtk::Button* pButton = new Gtk::Button("_Something", true);
pt_BR: Gtk::Button* pButton = new Gtk::Button("_Algo", true);

en: Wherever possible you should use Stock items, to ensure consistency with other applications, and to improve the appearance of your applications by using icons. For instance, <placeholder-1/> This will use standard text, in all languages, with standard keyboard accelerators, with a standard icon.
pt_BR: Sempre que possível, você deveria usar itens predefinidos, para garantir consistência com outros aplicativos e para melhorar a aparência dos seus usando ícones. Por exemplo, <placeholder-1/> nesse caso, ele usará o texto padrão, em todos os idiomas, com os aceleradores padrões, com um ícone padrão.

en: <classname>Gtk::Button</classname> is also a container so you could put any other widget, such as a <classname>Gtk::Image</classname> into it.
pt_BR: <classname>Gtk::Button</classname> é também um contêiner, então você pode colocar qualquer outro widget nele, como um <classname>Gtk::Image</classname>.

en: Example
pt_BR: Exemplo

en: This example creates a button with a picture and a label.
pt_BR: Este exemplo cria um botão com uma figura e um rótulo.

en: buttons example
pt_BR: exemplo de botões

en: The <classname>Gtk::Button</classname> widget has the following signals, but most of the time you will just handle the <literal>clicked</literal> signal:
pt_BR: O widget <classname>Gtk::Button</classname> tem os seguintes sinais, mas a maioria das vezes você só precisará manipular o sinal <literal>clicked</literal>:

en: Emitted when the button is pressed.
pt_BR: Emitido quando o botão é pressionado.

en: Emitted when the button is released.
pt_BR: Emitido quando o botão é solto.

en: Emitted when the button is pressed and released.
pt_BR: Emitido quando o botão é pressionado e depois liberado.

en: Emitted when the mouse pointer moves over the button's window.
pt_BR: Emitido quando o ponteiro do mouse se move sobre a janela do botão.

en: Emitted when the mouse pointer leaves the button's window.
pt_BR: Emitido quando o ponteiro do mouse sai da janela do botão.

en: ToggleButton
pt_BR: Botão de alternância

en: <classname>ToggleButton</classname>s are like normal <classname>Button</classname>s, but when clicked they remain activated, or pressed, until clicked again.
pt_BR: Um <classname>ToggleButton</classname> é como um <classname>Button</classname> normal, só que uma vez clicados, eles permanecem ativados, ou pressionados, até que sejam clicados de novo.

en: To retrieve the state of the <classname>ToggleButton</classname>, you can use the <methodname>get_active()</methodname> method. This returns <literal>true</literal> if the button is "down". You can also set the toggle button's state, with <methodname>set_active()</methodname>. Note that, if you do this, and the state actually changes, it causes the "clicked" signal to be emitted. This is usually what you want.
pt_BR: para obter o estado do <classname>ToggleButton</classname>, você pode usar o método <methodname>get_active()</methodname>. Ele retorna <literal>true</literal> se o botão está "para baixo". Você também pode definir o estado do botão de alternância, para isso use <methodname>set_active()</methodname>. Note que, se você fizer isso e o estado mudar de fato, isso faz com que o sinal <literal>clicked</literal> seja emitido. Isso é o que você quer normalmente.

en: You can use the <methodname>toggled()</methodname> method to toggle the button, rather than forcing it to be up or down: This switches the button's state, and causes the <literal>toggled</literal> signal to be emitted.
pt_BR: Você pode usar o método <methodname>toggled()</methodname> para alternar o botão, em vez de forçá-lo para cima ou para baixo: isso troca o estado do botão e faz com que o sinal <literal>toggled</literal> seja emitido.

en: <classname>Gtk::ToggleButton</classname> is most useful as a base class for the <classname>Gtk::CheckButton</classname> and <classname>Gtk::RadioButton</classname> classes.
pt_BR: <classname>Gtk::ToggleButton</classname> é mais útil como uma base para as classes <classname>Gtk::CheckButton</classname> e <classname>Gtk::RadioButton</classname>.

en: CheckButton
pt_BR: Botão de seleção

en: <classname>Gtk::CheckButton</classname> inherits from <classname>Gtk::ToggleButton</classname>. The only real difference between the two is <classname>Gtk::CheckButton</classname>'s appearance. You can check, set, and toggle a checkbox using the same member methods as for <classname>Gtk::ToggleButton</classname>.
pt_BR: <classname>Gtk::CheckButton</classname> é derivado de <classname>Gtk::ToggleButton</classname>. A única diferença real entre os dois é a aparência de <classname>Gtk::CheckButton</classname>. Você pode selecionar, definir e alternar um botão de seleção usando os mesmos métodos membros de um <classname>Gtk::ToggleButton</classname>.

en: RadioButton
pt_BR: Botão de opção

en: Like checkboxes, radio buttons also inherit from <classname>Gtk::ToggleButton</classname>, but these work in groups, and only one RadioButton in a group can be selected at any one time.
pt_BR: Como os de seleção, botões de opção também é uma classe filho de <classname>Gtk::ToggleButton</classname>, mas eles trabalham em grupos, e só um botão de opção em um grupo pode estar selecionado por vez.

en: Groups
pt_BR: Grupos

en: There are two ways to set up a group of radio buttons. The first way is to create the buttons, and set up their groups afterwards. Only the first two constructors are used. In the following example, we make a new window class called <classname>RadioButtons</classname>, and then put three radio buttons in it:
pt_BR: Existem duas maneiras de definir um grupo de botões de opção. A primeira é criar os botões e configurar os seus grupos em seguida. Somente os dois primeiros construtores são usados. No exemplo a seguir, fazemos uma nova classe janela chamada <classname>RadioButtons</classname>, e então colocamos três botões nela:

en: class RadioButtons : public Gtk::Window
    {
    public:
        RadioButtons();
    
    protected:
        Gtk::RadioButton m_rb1, m_rb2, m_rb3;
    };
    
    RadioButtons::RadioButtons()
      : m_rb1("button1"),
        m_rb2("button2"),
        m_rb3("button3")
    {
        Gtk::RadioButton::Group group = m_rb1.get_group();
        m_rb2.set_group(group);
        m_rb3.set_group(group);
    }
pt_BR: class RadioButtons : public Gtk::Window
    {
    public:
        RadioButtons();
    
    protected:
        Gtk::RadioButton m_rb1, m_rb2, m_rb3;
    };
    
    RadioButtons::RadioButtons()
      : m_rb1("botão1"),
        m_rb2("botão2"),
        m_rb3("botão3")
    {
        Gtk::RadioButton::Group grupo = m_rb1.get_group();
        m_rb2.set_group(grupo);
        m_rb3.set_group(grupo);
    }

en: We told <application>gtkmm</application> to put all three <classname>RadioButton</classname>s in the same group by obtaining the group with <methodname>get_group()</methodname> and using <methodname>set_group()</methodname> to tell the other <classname>RadioButton</classname>s to share that group.
pt_BR: Dissemos a <application>gtkmm</application> para colocar os três <classname>RadioButton</classname>s no mesmo grupo obtendo o grupo com  <methodname>get_group()</methodname> e usando <methodname>set_group()</methodname> para dizer ao outro <classname>RadioButton</classname> compartilhar esse grupo.

en: m_rb2.set_group(m_rb1.get_group()); //doesn't work
pt_BR: m_rb2.set_group(m_rb1.get_group()); //não funciona

en: Note that you can't just do <placeholder-1/> because the group is modified by <methodname>set_group()</methodname> and therefore non-const.
pt_BR: Note que você não pode simplesmente fazer <placeholder-1/> porque o grupo é modificado por <methodname>set_group()</methodname> e portanto não é const.

en: The second way to set up radio buttons is to make a group first, and then add radio buttons to it. Here's an example:
pt_BR: A segunda maneira de configurar os botões de opção é criar um grupo primeiro, e depois adicionar botões de opção a ele. Aqui está um exemplo:

en: class RadioButtons : public Gtk::Window
    {
    public:
        RadioButtons();
    };
    
    RadioButtons::RadioButtons()
    {
        Gtk::RadioButton::Group group;
        Gtk::RadioButton *m_rb1 = Gtk::manage(
          new Gtk::RadioButton(group,"button1"));
        Gtk::RadioButton *m_rb2 = manage(
          new Gtk::RadioButton(group,"button2"));
          Gtk::RadioButton *m_rb3 = manage(
            new Gtk::RadioButton(group,"button3"));
    }
pt_BR: class RadioButtons : public Gtk::Window
    {
    public:
        RadioButtons();
    };
    
    RadioButtons::RadioButtons()
    {
        Gtk::RadioButton::Group group;
        Gtk::RadioButton *m_rb1 = Gtk::manage(
          new Gtk::RadioButton(group,"botão 1"));
        Gtk::RadioButton *m_rb2 = manage(
          new Gtk::RadioButton(group,"botão 2"));
          Gtk::RadioButton *m_rb3 = manage(
            new Gtk::RadioButton(group,"botão 3"));
    }

en: We made a new group by simply declaring a variable, <literal>group</literal>, of type <classname>Gtk::RadioButton::Group</classname>. Then we made three radio buttons, using a constructor to make each of them part of <literal>group</literal>.
pt_BR: Criar um novo grupo, simplesmente declarando uma variável <literal>group</literal>, do tipo <classname>Gtk::RadioButton::Group</classname>. Depois criamos três botões de opção, usando um construtor para fazer cada um parte de <literal>group</literal>.

en: Methods
pt_BR: Métodos

en: <classname>RadioButtons</classname> are "off" when created; this means that when you first make a group of them, they will all be off. Don't forget to turn one of them on using <methodname>set_active()</methodname>:
pt_BR: <classname>RadioButtons</classname> são "desligado" quando criado; o que significa que quando você faz um grupo deles, todos eles irão estar desligado. Não esqueça de ativar um deles na utilização com <methodname>set_active()</methodname>:

en: The following example demonstrates the use of <classname>RadioButton</classname>s:
pt_BR: O exemplo seguinte demonstra o uso de <classname>RadioButton</classname>s:

en: Range Widgets
pt_BR: Widgets de intervalos

en: <classname>Gtk::Scale</classname> and <classname>Gtk::Scrollbar</classname> both inherit from <classname>Gtk::Range</classname> and share much functionality. They contain a "trough" and a "slider" (sometimes called a "thumbwheel" in other GUI environments). Dragging the slider with the pointer moves it within the trough, while clicking in the trough advances the slider towards the location of the click, either completely, or by a designated amount, depending on which mouse button is used. This should be familiar scrollbar behaviour.
pt_BR: <classname>Gtk::Scale</classname> e <classname>Gtk::Scrollbar</classname> ambos herdam de <classname>Gtk::Range</classname> e compartilham muitas funcionalidades. Eles contêm uma "calha" e um "deslizante" (às vezes chamado "botão deslizante" em outros ambientes GUI). Arrastando o controle deslizante com o ponteiro movendo dentro da calha, enquanto clica nos avanços da calha o controle desliza para a localização do clique, quer inteiramente, quer por um valor designado, dependendo de qual botão do mouse é usado. Este deve ser um comportamento de rolagem familiar.

en: Scrollbar Widgets
pt_BR: Widgets de barra de rolagem

en: The orientation of a <classname>Gtk::Scrollbar</classname> can be either horizontal or vertical.
pt_BR: A orientação de um <classname>Gtk::Scrollbar</classname> pode ser horizontal ou vertical.

en: Scale Widgets
pt_BR: Widgets de escala

en: Useful methods
pt_BR: Métodos úteis

en: <classname>Scale</classname> widgets can display their current value as a number next to the trough. By default they show the value, but you can change this with the <methodname>set_draw_value()</methodname> method.
pt_BR: Widgets de <classname>Scala</classname> pode exibir seu valor atual com um número próximo à calha. Por padrão, eles mostram o valor, você pode mudar isso com o método <methodname>set_draw_value()</methodname>.

en: Also, the value can be drawn in different positions relative to the trough, specified by the <methodname>set_value_pos()</methodname> method.
pt_BR: Além disso, o valor pode ser desenhado em diferentes posições em relação à calha, especificado pelo método <methodname>set_value_pos()</methodname>.

en: Update Policies
pt_BR: Política de atualização

en: <literal>Gtk::UPDATE_DELAYED</literal> - The <literal>value_changed</literal> signal is emitted when the user releases the mouse button, or if the slider stops moving for a short period of time.
pt_BR: <literal>Gtk::UPDATE_DELAYED</literal> - O sinal <literal>value_changed</literal>é emitido quando o usuário libera o botão do mouse, ou se o cursor para de se mover por um curto período de tempo.

en: Miscellaneous Widgets
pt_BR: Diversos widgets

en: Label
pt_BR: Rótulo

en: Entry
pt_BR: Entrada

en: Simple Use
pt_BR: Uso simples

en: Entry widgets allow the user to enter text. You can change the contents with the <methodname>set_text()</methodname> method, and read the current contents with the <methodname>get_text()</methodname> method.
pt_BR: Campos de entrada permite o usuário digitar texto. Você pode alterar o conteúdo com o método <methodname>set_text()</methodname>, e ler o conteúdo atual com o método <methodname>get_text()</methodname>.

en: For the input of passwords, passphrases and other information you don't want echoed on the screen, calling <methodname>set_visibility()</methodname> with <literal>false</literal> will cause the text to be hidden.
pt_BR: Para entrada de senhas, frases e outras informações que você não deseja mostrar na tela, chamando <methodname>set_visibility()</methodname> com <literal>false</literal> irá fazer com que o texto seja escondido.

en: Simple Entry Example
pt_BR: Exemplo de entrada simples

en: Entry Completion
pt_BR: Entrada com auto completar

en: Entry Completion Example
pt_BR: Exemplo de entrada com auto completar

en: Entry Icons
pt_BR: Entrada com ícones

en: Entry Icon Example
pt_BR: Exemplo de entrada com ícones

en: Entry with Icon
pt_BR: Entrada com ícone

en: Entry Progress
pt_BR: Entrada com barra de progresso

en: Entry Progress Example
pt_BR: Exemplo de entrada com barra de progresso

en: Entry with Progress Bar
pt_BR: Entrada com barra de progresso

en: <literal>value</literal>: value for the Spin Button
pt_BR: <literal>value</literal>: valor para o seletor numérico

en: <literal>lower</literal>: lower range value
pt_BR: <literal>lower</literal>: valor mínimo do intervalo

en: <literal>upper</literal>: upper range value
pt_BR: <literal>upper</literal>: valor máximo do intervalo

en: <literal>step_increment</literal>: value to increment/decrement when pressing mouse button 1 on a button
pt_BR: <literal>step_increment</literal>: valor para aumentar/diminuir quando pressiona o botão 1 do mouse em um botão

en: <literal>page_increment</literal>: value to increment/decrement when pressing mouse button 2 on a button
pt_BR: <literal>page_increment</literal>: valor para aumentar/diminuir quando pressiona o botão 2 do mouse em um botão

en: <literal>page_size</literal>: unused
pt_BR: <literal>page_size</literal>: não usado

en: Additionally, mouse button 3 can be used to jump directly to the <literal>upper</literal> or <literal>lower</literal> values.
pt_BR: Além disso, o botão 3 do mouse pode ser usado para ir diretamente aos valores <literal>upper</literal> ou <literal>lower</literal>.

en: Activity Mode
pt_BR: Modo de atividade

en: Tooltips
pt_BR: Dicas

en: Widget Reference
pt_BR: Widgets de referência

en: Tooltip Reference
pt_BR: Dicas de referência

en: Tooltip
pt_BR: Dica de Ferramenta

en: Container Widgets
pt_BR: Widgets de empacotamento

en: Single-item Containers
pt_BR: Empacotamento de item único

en: Frame
pt_BR: Moldura

en: Paned
pt_BR: Painel

en: Alignment
pt_BR: Alinhamento

en: Multiple-item widgets
pt_BR: Widgets de múltiplos itens

en: An improved Hello World
pt_BR: Um olá mundo melhorado

en: Hello World 2
pt_BR: Olá, mundo 2

en: Boxes
pt_BR: Caixas

en: Adding widgets
pt_BR: Adicionando widgets

en: Per-child packing options
pt_BR: Opções de empacotamento por filhos

en: Per-container packing options
pt_BR: Opções de empacotamento por recipiente

en: Box Packing 2
pt_BR: Caixa de embalagem 2

en: Gtk::Application and command-line options
pt_BR: Gtk::Application e opções de linha de comando

en: The following example program requires a command-line option. The source code shows two ways of handling command-line options in combination with <classname>Gtk::Application</classname>.
pt_BR: O programa de exemplo a seguir exige uma opção de linha de comando. O código fonte mostra duas maneiras de lidar com linhas de comando em combinação com <classname>Gtk::Application</classname>.

en: Here is the source code for the example that produced the screenshots above. When you run this example, provide a number between 1 and 3 as a command-line option, to see different packing options in use.
pt_BR: Aqui está o código fonte para o exemplo que produziu as imagens acima. Quando você executar esse exemplo, fornecer um número entre 1 e 3 como uma opção de linha de comando, para ver diferentes opções de empacotamento em uso.

en: ButtonBoxes
pt_BR: Caixa de botões

en: Button boxes are a convenient way to quickly arrange a group of buttons. Their orientation can be either horizontal or vertical.
pt_BR: Caixas de botões são uma forma conveniente de arranjar rapidamente um grupo de botões. Sua orientação pode ser horizontal ou vertical.

en: Buttons are added to a <classname>ButtonBox</classname> with the <methodname>add()</methodname> method.
pt_BR: Os botões são adicionados a um <classname>ButtonBox</classname> com o método <methodname>add()</methodname>.

en: Button boxes support several layout styles. The style can be retrieved and changed using <methodname>get_layout()</methodname> and <methodname>set_layout()</methodname>.
pt_BR: Caixa de botões suportam varios estilos de layout. O estilo pode ser recuperado e alterado usando <methodname>get_layout()</methodname> and <methodname>set_layout()</methodname>.

en: ButtonBox
pt_BR: Caixa de botões

en: Grid
pt_BR: Grade

en: A <classname>Grid</classname> dynamically lays out child widgets in rows and columns. The dimensions of the grid do not need to be specified in the constructor.
pt_BR: Uma <classname>Grid</classname> dinamicamente estabelece widgets filhos em linhas e colunas. As dimensões da grade não precisa ser especificado no construtor.

en: Table
pt_BR: Tabela

en: <classname>Gtk::Table</classname> allows us to place widgets in a grid, similar to <classname>Gtk::Grid</classname>.
pt_BR: <classname>Gtk::Table</classname> nos permite colocar widgets em uma grade, semelhante à <classname>Gtk::Grid</classname>.

en: <classname>Gtk::Table</classname> is deprecated from <application>gtkmm</application> version 3.4 and should not be used in newly-written code. Use <classname>Gtk::Grid</classname> instead.
pt_BR: <classname>Gtk::Table</classname> está obsoleto a partir da <application>gtkmm</application> versão 3.4 e não deve ser utilizado em códigos recentemente escritos. Ao invés use <classname>Gtk::Grid</classname>.

en: Notebook
pt_BR: Painel com abas

en: To programmatically change the selected page, use the <methodname>set_current_page()</methodname> method.
pt_BR: Para alterar programaticamente a página selecionada, use o método <methodname>set_current_page()</methodname>.

en: Assistant
pt_BR: Assistente

en: Use the <methodname>append_page()</methodname>, <methodname>prepend_page</methodname> and <methodname>insert_page()</methodname> methods to add pages to the <classname>Assistant</classname>, supplying the child widget for each page.
pt_BR: Use os métodos <methodname>append_page()</methodname>, <methodname>prepend_page</methodname> e <methodname>insert_page()</methodname> para adicionar páginas ao <classname>Assistant</classname>, fornecendo o widget filho para cada página.

en: To set the title of a page, use the <methodname>set_page_title()</methodname> method. The header and side images of a page can be set with the <methodname>set_page_header_image()</methodname> and <methodname>set_page_side_image()</methodname> methods.
pt_BR: Para definir o título de uma página, utilize o método <methodname>set_page_title()</methodname>. As imagens de cabeçalho e do lado de uma página pode ser definido com os métodos <methodname>set_page_header_image()</methodname> e <methodname>set_page_side_image()</methodname>.

en: To add widgets to the action area, use the <methodname>add_action_widget()</methodname> method. They will be packed alongside the default buttons. Use the <methodname>remove_action_widget()</methodname> method to remove widgets.
pt_BR: Para adicionar widgets para a área de ação, usar o método <methodname>add_action_widget()</methodname>. Eles serão acondicionados ao lado dos botões padrão. Usar o método <methodname>remove_action_widget()</methodname> para remover widgets.

en: The TreeView widget
pt_BR: Widget de visualização em árvore

en: The <classname>Gtk::TreeView</classname> widget can contain lists or trees of data, in columns.
pt_BR: O widget <classname>Gtk::TreeView</classname> pode conter listas ou árvores de dados, em colunas.

en: The Model
pt_BR: Modelo

en: Although you can theoretically implement your own Model, you will normally use either the <classname>ListStore</classname> or <classname>TreeStore</classname> model classes.
pt_BR: Embora você pode, teoricamente, implementar seu próprio modelo, normalmente você vai usar a classe modelo <classname>ListStore</classname> ou <classname>TreeStore</classname>.

en: TreeStore, for a hierarchy
pt_BR: TreeStore, por hierarquia

en: Model Columns
pt_BR: Modelo de colunas

en: Adding Rows
pt_BR: Adicionando linhas

en: Adding child rows
pt_BR: Adicionando linhas filhas

en: Setting values
pt_BR: Ajustando valores

en: Getting values
pt_BR: Obtenção de valores

en: "Hidden" Columns
pt_BR: "Ocultando" colunas

en: The View
pt_BR: Visualização

en: Using a Model
pt_BR: Utilizando um modelo

en: Adding View Columns
pt_BR: Adicionando visualização em colunas

en: Specifying CellRenderer details
pt_BR: Especificando detalhes do renderizador de célula

en: Editable Cells
pt_BR: Células editáveis

en: Row children
pt_BR: Linhas filhas

en: The Selection
pt_BR: Seleção

en: Single or multiple selection
pt_BR: Seleção única ou múltipla

en: The selected rows
pt_BR: As linhas selecionadas

en: The "changed" signal
pt_BR: O sinal "changed"

en: Preventing row selection
pt_BR: Impedindo a seleção de linhas

en: and then
pt_BR: e, em seguida,

en: Changing the selection
pt_BR: Alterando a seleção

en: or
pt_BR:  ou

en: Sorting
pt_BR: Classificando

en: TreeSortable Reference
pt_BR: Referência TreeSortable

en: TreeModelSort Reference
pt_BR: Referência TreeModelSort

en: Drag and Drop
pt_BR: Arrastar e soltar

en: Reorderable rows
pt_BR: Linhas reordenáveis

en: Popup Context Menu
pt_BR: Contexto de menu popup

en: TreeView - Editable Cells
pt_BR: TreeView - Células editáveis

en: TreeView - Drag And Drop
pt_BR: TreeView - Arrastar e soltar

en: TreeView - Popup Context Menu
pt_BR: TreeView - Contexto de menu popup

en: Combo Boxes
pt_BR: Caixa de combinação

en: The model
pt_BR: O modelo

en: The chosen item
pt_BR: O item escolhido

en: Responding to changes
pt_BR: Respondendo as mudanças

en: Full Example
pt_BR: Exemplo completo

en: ComboBox
pt_BR: Caixa de combinação

en: Simple Text Example
pt_BR: Exemplo de texto simples

en: ComboBox with an Entry
pt_BR: ComboBox com uma entrada

en: The text column
pt_BR: A coluna de texto

en: The entry
pt_BR: Entrada

en: ComboBox with Entry
pt_BR: Caixa de combinação com entrada

en: ComboBoxText with Entry
pt_BR: ComboBoxText com uma entrada

en: The Buffer
pt_BR: O Buffer

en: Tags and Formatting
pt_BR: Etiquetas e formatação

en: Tags
pt_BR: Etiquetas

en: Applying Tags
pt_BR: Aplicando etiquetas

en: Marks
pt_BR: Marcas

en: Default formatting
pt_BR: Formatação padrão

en: Scrolling
pt_BR: Deslocamento

en: Menus and Toolbars
pt_BR: Menus e barras de ferramentas

en: Actions
pt_BR: Ações

en: For instance:
pt_BR: Por exemplo:

en: For instance,
pt_BR: Por exemplo,

en: Popup Menus
pt_BR: Menus popup

en: Main Menu example
pt_BR: Exemplo de menu principal

en: Main Menu
pt_BR: Menu principal

en: Popup Menu example
pt_BR: Exemplo de menu popup

en: Popup Menu
pt_BR: Menu popup

en: Adjustments
pt_BR: Ajustes

en: Creating an Adjustment
pt_BR: Criando um ajuste

en: The <classname>Gtk::Adjustment</classname> constructor is as follows:
pt_BR: O construtor <classname>Gtk::Adjustment</classname> é como se segue:

en: Using Adjustments the Easy Way
pt_BR: Usando ajustes o caminho fácil

en: The adjustable widgets can be roughly divided into those which use and require specific units for these values, and those which treat them as arbitrary numbers.
pt_BR: Os widgets ajustáveis ​​podem ser grosseiramente divididos naqueles que usam e requerem unidades específicas para estes valores, e aqueles que tratá-los como números arbitrários.

en: // creates its own adjustments
    Gtk::TextView textview;
    // uses the newly-created adjustment for the scrollbar as well
    Gtk::Scrollbar vscrollbar (textview.get_vadjustment(), Gtk::ORIENTATION_VERTICAL);
pt_BR: // cria seus próprios ajustes
    Gtk::TextView textview;
    // usa o ajuste recém-criado para a barra de rolagem assim
    Gtk::Scrollbar vscrollbar (textview.get_vadjustment(), Gtk::ORIENTATION_VERTICAL);

en: Adjustment Internals
pt_BR: Ajustamento interno

en: Widgets Without X-Windows
pt_BR: Widgets sem X-Windows

en: Here is a list of some of these Widgets:
pt_BR: Aqui está uma lista de alguns desses Widgets:

en: Gtk::Alignment
    Gtk::Arrow
    Gtk::AspectFrame
    Gtk::Bin
    Gtk::Box
    Gtk::Button
    Gtk::CheckButton
    Gtk::Fixed
    Gtk::Frame
    Gtk::Grid
    Gtk::Image
    Gtk::Label
    Gtk::MenuItem
    Gtk::Notebook
    Gtk::Paned
    Gtk::RadioButton
    Gtk::Range
    Gtk::ScrolledWindow
    Gtk::Separator
    Gtk::Table (deprecated from <application>gtkmm</application> version 3.4)
    Gtk::Toolbar
pt_BR: Gtk::Alignment
    Gtk::Arrow
    Gtk::AspectFrame
    Gtk::Bin
    Gtk::Box
    Gtk::Button
    Gtk::CheckButton
    Gtk::Fixed
    Gtk::Frame
    Gtk::Grid
    Gtk::Image
    Gtk::Label
    Gtk::MenuItem
    Gtk::Notebook
    Gtk::Paned
    Gtk::RadioButton
    Gtk::Range
    Gtk::ScrolledWindow
    Gtk::Separator
    Gtk::Table (obsoleta a partir da <application>gtkmm</application> versão 3.4)
    Gtk::Toolbar

note: <para>TODO: Why don't they have X Windows - explain clipping. Also, how does this affect platform such as Windows and MacOS that don't use X. </para>
en: The constructor for <classname>Gtk::EventBox</classname> is:
pt_BR: O construtor para <classname>Gtk::EventBox</classname> é:

en: A child widget can be added to the <classname>EventBox</classname> using:
pt_BR: Um elemento filho pode ser adicionado a <classname>Caixa de Evento</classname> usando:

en: Dialogs
pt_BR: Caixas de diálogo

en: FileChooser
pt_BR: Seletor de arquivos

en: The Drawing Area Widget
pt_BR: O widget área de desenho

en: Cairo and Pango
pt_BR: Cairo e pango

en: The Cairo Drawing Model
pt_BR: Modelo de desenho com cairo

en: Drawing Straight Lines
pt_BR: Desenho de linhas retas

en: Drawing Area - Lines
pt_BR: Área de desenho - Linhas

en: Drawing with relative coordinates
pt_BR: Desenho com coordenadas relativas

en: Line styles
pt_BR: Estilos de linha

en: Drawing thin lines
pt_BR: Desenhando linhas finas

en: Drawing Curved Lines
pt_BR: Desenhando linhas curvadas

en: Drawing Area - Arcs
pt_BR: Área de desenho - Arcos

en: Drawing counter-clockwise
pt_BR: Desenhando no sentido anti-horário

en: Drawing Text
pt_BR: Desenhando texto

en: Drawing Text with Pango
pt_BR: Desenhando texto com pango

en: Drawing Area - Text
pt_BR: Área de desenho - Texto

en: Drawing Images
pt_BR: Desenhando imagens

en: Drawing Area - Image
pt_BR: Área de desenho - Imagens

en: Sources and Destinations
pt_BR: Origens e destinos

en: target: A name, such as "STRING"
pt_BR: target: Um nome, tal como "STRING"

en: Copy
pt_BR: Copiar

en: Move
pt_BR: Mover

en: The Clipboard
pt_BR: Área de transferência

en: Targets
pt_BR: Alvos

en: Paste
pt_BR: Colar

en: Discovering the available targets
pt_BR: Descobrindo os alvos disponíveis

en: Simple
pt_BR: Simples

en: Clipboard - Simple
pt_BR: Área de transferência - Simples

en: Clipboard - Ideal
pt_BR: Área de transferência - Ideal

en: Printing
pt_BR: Imprimindo

en: Page setup
pt_BR: Configurar página

en: For instance, <placeholder-1/>
pt_BR: Por exemplo, <placeholder-1/>

en: Rendering text
pt_BR: Processamento de texto

en: Asynchronous operations
pt_BR: Operações assíncronas

en: Export to PDF
pt_BR: Exportar para PDF

en: Extending the print dialog
pt_BR: Estendendo o diálogo de impressão

en: Preview
pt_BR: Visualização

en: Printing - Simple
pt_BR: Impressão - Simples

en: Recently Used Documents
pt_BR: Documentos usados recentemente

en: <varname>mime_type</varname>: The MIME type of the resource
pt_BR: <varname>mime_type</varname>: O tipo MIME do recurso

en: Modifying the List of Recent Files
pt_BR: Modificando a lista de arquivos recentes

en: Simple RecentChooserDialog example
pt_BR: Exemplo simples de um RecentChooserDialog

en: Filtering Recent Files
pt_BR: Filtrando arquivos recentes

en: Plugs and Sockets
pt_BR: Plugs e Sockets

en: Overview
pt_BR: Visão geral

en: Sockets
pt_BR: Soquetes

en: Plugs
pt_BR: Plugues

en: The window ID is: 69206019
pt_BR: O ID da janela é: 69206019

en: Keyboard Events
pt_BR: Eventos de teclado

en: Keyboard Events - Simple
pt_BR: Eventos de teclado - Simples

en: Event Propagation
pt_BR: Propagação de eventos

en: Keyboard Events - Event Propagation
pt_BR: Eventos de teclado - Propagação de eventos

en: Timeouts, I/O and Idle Functions
pt_BR: Tempo limite, E/S e funções ociosas

en: Timeouts
pt_BR: Tempos limites

en: Monitoring I/O
pt_BR: Monitorando E/S

en: Idle Functions
pt_BR: Funções ociosas

en: Memory management
pt_BR: Gerenciamento de memória

en: Normal C++ memory management
pt_BR: Gerenciamento de memória normal em C++

en: Managed Widgets
pt_BR: Widgets gerenciados

en: Shared resources
pt_BR: Recursos compartilhados

en: See the <link linkend="chapter-refptr">appendix</link> for detailed information about RefPtr.
pt_BR: Veja o <link linkend="chapter-refptr">apêndice</link> para obter informações detalhadas sobre RefPtr.

en: Glade and Gtk::Builder
pt_BR: Glade e Gtk::Builder

en: Less C++ code is required.
pt_BR: Menos código C++ é necessário.

en: Loading the .glade file
pt_BR: Carregando arquivos .glade

en: Accessing widgets
pt_BR: Acessando widgets

en: Using derived widgets
pt_BR: Usando widgets derivados

en: Internationalization and Localization
pt_BR: Internacionalização e localização

en: Preparing your project
pt_BR: Preparando seu projeto

en: Marking strings for translation
pt_BR: Marcando strings para tradução

en: How gettext works
pt_BR: Como funciona o gettext

en: Testing and adding translations
pt_BR: Testando e adicionando traduções

en: Resources
pt_BR: Recursos

en: Internationalizing GNOME applications
pt_BR: Internacionalização de aplicações do GNOME

en: Intltool README
pt_BR: LEIA-ME Intltool

en: gettext manual
pt_BR: Manual do gettext

en: <placeholder-1/> example package
pt_BR: <placeholder-1/> pacote de exemplo

en: Expecting UTF8
pt_BR: Esperando UTF8

en: Same strings, different semantics
pt_BR: Mesmas strings, semânticas diferentes

en: Composition of strings
pt_BR: Composição de strings

en: Unusual words
pt_BR: Palavras incomuns

en: Custom Widgets
pt_BR: Widgets personalizados

en: Custom Containers
pt_BR: Contêiners personalizados

en: Custom Container
pt_BR: Contêiner personalizado

en: <methodname>on_map()</methodname>: (optional)
pt_BR: <methodname>on_map()</methodname>: (opcional)

en: Custom Widget
pt_BR: Widget personalizado

en: Multi-threaded programs
pt_BR: Programas com várias linhas de processamento

en: The rules
pt_BR: As regras

en: Recommended Techniques
pt_BR: Técnicas recomendadas

en: Application Lifetime
pt_BR: Tempo de vida da aplicação

en: Using a <application>gtkmm</application> widget
pt_BR: Usando um widget <application>gtkmm</application>

en: Copying
pt_BR: Copiando

en: Checking for null
pt_BR: Verificação de nulo

en: Connecting signal handlers
pt_BR: Conectando manipuladores de sinais

en: Writing signal handlers
pt_BR: Escrevendo manipuladores de sinais

en: Disconnecting signal handlers
pt_BR: Desconectando manipuladores de sinais

en: Binding extra arguments
pt_BR: Ligando argumentos extras

en: X Event signals
pt_BR: Sinais de eventos X

en: Signal Handler sequence
pt_BR: Sequência de manipulador de sinal

en: Creating your own signals
pt_BR: Criando seus próprios sinais

en: <application>gtkmm</application> and Win32
pt_BR: <application>gtkmm</application> e Win32

en: Working with gtkmm's Source Code
pt_BR: Trabalhando com códigos fonte gtkmm

en: Setting up jhbuild
pt_BR: Configurando jhbuild

en: Setting a prefix
pt_BR: Definindo um prefixo

en: The build structure
pt_BR: Estrutura de construção

en: Copying the skeleton project
pt_BR: Copiando o esqueleto do projeto

en: Modifying build files
pt_BR: Modificando arquivos de construção

en: In <filename>configure.ac</filename>, <placeholder-1/>
pt_BR: Em <filename>configure.ac</filename>, <placeholder-1/>

en: Makefile.am files
pt_BR: Arquivos Makefile.am

en: The command line options passed to the C preprocessor.
pt_BR: As opções de linha de comando passados para o pré-processador C.

en: The command line options passed to the C++ compiler.
pt_BR: As opções de linha de comando passados para o compilador C++.

en: Creating .hg and .ccg files
pt_BR: Criação de arquivos .hg e .ccg

en: Generating the .defs files.
pt_BR: Gerando os arquivos .defs.

en: functions
pt_BR: funções

en: signals
pt_BR: sinais

en: properties
pt_BR: propriedades

en: Includes the other files.
pt_BR: Inclui outros arquivos.

en: Objects and functions.
pt_BR: Objetos e funções.

en: Enumerations.
pt_BR: Enumerações.

en: Signals and properties.
pt_BR: Sinais e propriedades.

en: Generating the methods .defs
pt_BR: Gerando o methods .defs

en: Generating the enums .defs
pt_BR: Gerando o enums .defs

en: Writing the vfuncs .defs
pt_BR: Escrevendo o vfuncs .defs

en: The .hg and .ccg files
pt_BR: Os arquivos .hg e .ccg

en: Add a default constructor.
pt_BR: Adiciona um construtor padrão.

en: m4 Conversions
pt_BR: Conversões m4

en: m4 Initializations
pt_BR: Inicializações m4

en: Class macros
pt_BR: Macros de classes

en: For instance, from <filename>accelgroup.hg</filename>: <placeholder-1/>
pt_BR: Por exemplo, a partir de <filename>accelgroup.hg</filename>: <placeholder-1/>

en: For instance, from <filename>button.hg</filename>: <placeholder-1/>
pt_BR: Por exemplo, a partir de <filename>button.hg</filename>: <placeholder-1/>

en: _CLASS_BOXEDTYPE_STATIC( C++ class, C class )
pt_BR: _CLASS_BOXEDTYPE_STATIC( classe C++, classe C  )

en: For instance, from <filename>stockitem.hg</filename>: <placeholder-1/>
pt_BR: Por exemplo, a partir de <filename>stockitem.hg</filename>: <placeholder-1/>

en: _CLASS_GENERIC( C++ class, C class )
pt_BR: _CLASS_GENERIC( classe C++, classe C )

en: For instance, from <filename>celleditable.hg</filename>: <placeholder-1/>
pt_BR: Por exemplo, a partir de <filename>celleditable.hg</filename>: <placeholder-1/>

en: Constructor macros
pt_BR: Contrutor de macros

en: Method macros
pt_BR: Métodos macros

en: For instance, from <filename>entry.hg</filename>: <placeholder-1/>
pt_BR: Por exemplo, a partir de <filename>entry.hg</filename>: <placeholder-1/>

en: deprecated
pt_BR: obsoleto

en: For instance, from <filename>container.hg</filename>: <placeholder-1/>
pt_BR: Por exemplo, a partir de <filename>container.hg</filename>: <placeholder-1/>

en: For instance, from <filename>buttonbox.hg</filename>: <placeholder-1/>
pt_BR: Por exemplo, a partir de <filename>buttonbox.hg</filename>: <placeholder-1/>

en: For instance, from <filename>widget.hg</filename>: <placeholder-1/>
pt_BR: Por exemplo, a partir de <filename>widget.hg</filename>: <placeholder-1/>

en: Do not generate a definition of the vfunc in the <filename>.cc</filename> file. Use this when you must generate the vfunc by hand.
pt_BR: Não gera uma definição do vfunc no arquivo <filename>.cc</filename>. Use-a quando  você deve gerar o vfunc a mão.

en: Other macros
pt_BR: Outros macros

en: This macro generates initialization code for the interface.
pt_BR: Esta macro gera o código de inicialização para a interface.

en: There is one optional extra argument: <placeholder-1/>
pt_BR: Há um argumento extra opcional: <placeholder-1/>

en: For example, from <filename>icontheme.hg</filename>: <placeholder-1/>
pt_BR: Por exemplo, a partir de <filename>icontheme.hg</filename>: <placeholder-1/>

en: For instance, from <filename>pixbuf.hg</filename>: <placeholder-1/>
pt_BR: Por exemplo, a partir de <filename>pixbuf.hg</filename>: <placeholder-1/>

en: _MEMBER_GET(C++ name, C name, C++ type, C type)
pt_BR: _MEMBER_GET(C++ nome, C nome, C++ tipo, C tipo)

en: _MEMBER_SET(C++ name, C name, C++ type, C type)
pt_BR: _MEMBER_SET(C++ nome, C nome, C++ tipo, C tipo)

en: For example, in <filename>rectangle.hg</filename>: <placeholder-1/>
pt_BR: Por exemplo, em <filename>rectangle.hg</filename>: <placeholder-1/>

en: Use these macros to automatically provide getters and setters for a data member that is a pointer type. For the getter function, it will create two methods, one const and one non-const.
pt_BR: Usa essas macros para automaticamente fornecer os método getters e setters para um dado membro que é um tipo ponteiro. Para a função getter, ele irá criar dois métodos, um const e um não-const.

en: For example, for <classname>Pango::Analysis</classname> in <filename>item.hg</filename>: <placeholder-1/>
pt_BR: Por exemplo, para <classname>Pango::Analysis</classname> em <filename>item.hg</filename>: <placeholder-1/>

en: For example, in Pangomm, <filename>layoutline.hg</filename>: <placeholder-1/>
pt_BR: Por exemplo, em Pangmm, <filename>layoutline.hg</filename>: <placeholder-1/>

en: Basic Types
pt_BR: Tipos básicos

en: Basic Type equivalents
pt_BR: Tipos básicos equivalentes

en: C type
pt_BR: Tipo C

en: C++ type
pt_BR: Tipo C++

en: <placeholder-1/> (or <placeholder-2/> for filenames)
pt_BR: <placeholder-1/> (ou <placeholder-2/> para nomes de arquivos)

en: Initialization
pt_BR: Inicialização

en: Problems in the C API.
pt_BR: Problemas na API C.

en: Lack of properties
pt_BR: Falta de propriedades

en: Documentation
pt_BR: Documentação

en: Reusing C documentation
pt_BR: Reutilizando documentação C

en: Documentation build structure
pt_BR: Documentação da estrutura de construção
