Guía de inicio rápido FireMonkey - IntroducciónBienvenido a FireMonkey, la primera CPU y plataforma nativa aplicación GPU-powered para la construcción de aplicaciones de negocios ricos.

Esta Guía de inicio rápido le guiará por los pasos de desarrollo básicas necesarias para crear su primera aplicación de FireMonkey y está diseñado para dar un conocimiento básico de la plataforma de aplicaciones FireMonkey. La guía también incluye enlaces a tutoriales detallados en cada paso del proceso de desarrollo para ayudarle a adquirir un profundo conocimiento de la plataforma de aplicaciones FireMonkey.

El entorno de desarrollo integrado (IDE)Al iniciar RAD Studio, el entorno de desarrollo integrado (IDE) de lanzamientos y exhibiciones varias herramientas y menús. El IDE ayuda a diseñar visualmente interfaces de usuario, establecer las propiedades del objeto, escribir código, y ver y administrar su aplicación en diversas formas.

Delphi y C + + Lenguajes de programaciónPuede desarrollar sus aplicaciones FireMonkey en cualquiera "RAD" C + + o Delphi, dos fáciles de aprender lenguajes de programación orientados a objetos componentes a base de que son utilizados por millones de desarrolladores en todo el mundo.

Delphi es un lenguaje orientado a objetos elegante y fácil de aprender. Basado en Object Pascal, sus beneficios incluyen código fácil de leer, compilación rápida, y el uso de múltiples archivos de unidades para la programación modular. Delphi tiene características especiales que apoyan el marco de componentes RAD Studio y el medio ambiente.

Un pedazo de código fuente escrito en lenguaje Delphi

También puede desarrollar aplicaciones FireMonkey en C + +, un lenguaje de programación orientado a objetos ampliamente adoptada.

Un pedazo de código fuente escrito en lenguaje C + +

Diseño de interfaz de usuarioFireMonkey incluye un completo conjunto de controles de interfaz de usuario de arrastrar y soltar. Seleccione de botones, menús, HUD, texto, cuadros combinados, cuadros, fichas, paneles y más para el diseño de su interfaz de usuario. Los controles son totalmente personalizables y pueden ser de estilo a su gusto utilizando estilos FireMonkey HD.

Estilos FireMonkey HD permiten controlar totalmente la apariencia de las interfaces de usuario de alta definición sin necesidad de programación o de convertirse en un experto en lenguajes de marcas esotéricas. Los estilos pueden ser creados o modificados por programadores o diseñadores. Elija entre una biblioteca de estilos existentes, crear interfaces de usuario personalizadas para las aplicaciones o si lo que busca es un aspecto nativo del sistema operativo más tradicional, FireMonkey le da la opción de seguir con Windows 7, Windows 8, Mac OS X, iOS y Android UIs .

Conexión a los datosCasi todas las aplicaciones de negocio funciona con datos. FireMonkey incluye componente integrado basado, acceso nativo de alto rendimiento de MS SQL Server, Oracle, IBM DB2, MySQL, Sybase, Informix, InterBase y Firebird.

Visualizar datos en tiempo real utilizando LiveBindings en sus aplicaciones FireMonkey. LiveBindings le permiten conectar cualquier tipo de fuente de datos a cualquier interfaz de usuario o los objetos gráficos en HD o 3D. FireMonkey te da una libertad sin precedentes para expresar, comunicar e interactuar con los datos en poderosas nuevas formas sólo limitadas por su imaginación.

Mi Primera Aplicación FireMonkeyVamos a crear su primera aplicación de FireMonkey.

Estos tutoriales están diseñados para darle un conocimiento básico del flujo de trabajo de desarrollo con la plataforma de aplicaciones FireMonkey. El primer tutorial es un "Hello World" tutorial aplicación fácil de seguir, que muestra los pasos esenciales para la creación de su primera aplicación FireMonkey para plataformas de escritorio (Windows, Mac OS X). Los pasos básicos de desarrollo son los mismos para Windows y Mac.

Crear su primera aplicación para plataformas de escritorio FireMonkey En este tutorial, creará una aplicación FireMonkey que funciona en diferentes plataformas (Windows y Mac OS X) y utiliza los siguientes elementos de la interfaz de usuario:

Un campo de texto para introducir un nombre. Un botón para hacer clic a decir "Hola". Una etiqueta para mostrar el mensaje "Hola name> + <su!".

Su primera aplicación FireMonkey aparecerá como en las capturas de pantalla de abajo, para Windows y Mac OS X:

Paso 1: Crear una nueva aplicación de FireMonkey HD El menú Archivo de la RAD Studio IDE le permite crear una nueva aplicación FireMonkey. Para crear una nueva aplicación FireMonkey HD, seleccione:

Archivo> Nuevo> Otros> C + + Builder Proyectos> FireMonkey aplicación de escritorio Archivo> Nuevo> Otros> Proyectos Delphi> FireMonkey aplicación de escritorio

A continuación, seleccione HD FireMonkey aplicación y haga clic en Aceptar.

Nota: Si usted no es dueño de RAD Studio, pero poseen la versión individual de Delphi o C + + Builder en su lugar, el comando Archivo> siguen aplicando nuevas medidas de menú de aplicaciones descritas anteriormente.

A continuación se muestra una captura de pantalla del IDE que muestra los 5 paneles diferentes que se pueden acoplar, desacoplar, o cerca a su gusto.

Los 5 paneles son:

Diseñador de formularios Estructura Ver Inspector de Objetos Gerente de Proyectos Paleta de herramientas

Paso 2: Coloque los componentes en el Formulario de HD FireMonkey El primer paso para crear una aplicación de FireMonkey está diseñando la interfaz de usuario. Hay cientos de componentes reutilizables disponibles en el IDE para la creación de interfaces de usuario. Mueva el cursor sobre la paleta de herramientas y expanda la categoría estándar haciendo clic en el icono de signo más (+). A continuación, seleccione el componente TEdit y suéltala en el Diseñador de formularios. Una instancia del componente TEdit se mostrará en el formulario.

Repita estos pasos para agregar los componentes TLabel y TButton al formulario. Ahora debería ver tres componentes en el Diseñador de formularios.

Utilice su ratón para reorganizar los componentes en el Diseñador de formularios como quieras.

Puede ver y cambiar las propiedades de un componente utilizando el Inspector de objetos después de seleccionar el componente en el formulario.

A continuación, cambiar visualmente el título del botón para el componente TButton. Vamos a cambiar las propiedades TEdit y TLabel mediante programación mediante la introducción de un código, como se describe en el paso 3.

Para cambiar la propiedad TButton como se muestra en la captura de pantalla anterior, seleccione el componente TButton en el formulario y cambie la propiedad Text en el Inspector de Objetos para "Say Hello" y, a continuación, pulse Intro para aplicar el cambio.

Paso 3: Escribe una Respuesta en Delphi Code Cuando un usuario hace clic en un botón Para aplicaciones GUI, la mayoría de las respuestas a las acciones de los usuarios como los clics de los botones y entradas de campos de texto pueden ser implementadas como respuesta a un evento. En RAD Studio, este tipo de respuestas se denominan controladores de eventos.

Para el componente de TButton, el evento más típico es un clic de botón. Al hacer doble clic en el botón en el Diseñador de formularios, RAD Studio crea código esqueleto para implementar un controlador de eventos para el evento clic de botón.

Ahora usted puede poner en práctica las respuestas entre los 'begin' y las declaraciones de 'fin' del método Button1Click. Vamos a poner en práctica una respuesta a mostrar un pequeño diálogo que dice "Hello + <nombre entró en la edición box>".

.. Label1 Texto: '!' = 'Hola' + Edit1 Texto +;

En Delphi, las comillas que debe rodear los literales de cadena son ''. También puede utilizar el signo más (+) para concatenar cadenas.

Mientras que usted está escribiendo código, aparecerán algunas pistas que indican el tipo de parámetro es necesario especificar. Además, ofrecemos algunos consejos de indicar los tipos de miembros que se admiten en una clase dada.

Paso 4: Ejecutar la aplicación La implementación de esta aplicación está terminada, para que pueda ejecutarlo. Puede hacer clic en el botón Ejecutar en el IDE, pulse F9 o seleccione Ejecutar> Ejecutar en el menú principal del RAD Studio.

Una vez que haya ejecutado la aplicación, se mostrará un formulario con un cuadro de edición y un botón. Introduzca texto en el cuadro de edición y haga clic en el botón Say Hello.

Paso 5: Apoyo a las versiones de 64 bits de Windows De forma predeterminada, RAD Studio crea aplicaciones destinadas a las versiones de 32 bits del sistema operativo Windows. Para agregar las versiones x64 de Windows como una plataforma de destino, seleccione el nodo Plataformas de destino en el Project Manager y seleccione Agregar Plataforma> Windows de 64 bits. Ahora su proyecto puede ser construido tanto para Win32 y Win64 plataformas. También, usted puede pulsar F9 para ejecutar la aplicación Win64.

Nota: Si la instalación de RAD Studio se ejecuta en un x86 (Win32) edición de Windows, todavía puede crear aplicaciones destinadas a Windows de 64 bits. Sin embargo, no se puede ejecutar en el escritorio, porque la versión de Windows sólo es compatible con aplicaciones de 32 bits. Puede desplegar sus aplicaciones a otro sistema de 64 bits, y depurarlos en su IDE en Windows de 32 bits que utilizan PAServer (depuración remota).

Paso 6: Agregar Mac OS X como Target Puede añadir Max OS X como plataforma de destino de la misma manera que ha agregado Windows de 64 bits. Para agregar Mac OS X como plataforma de destino, haga clic en el nodo Plataformas de destino en el Project Manager y seleccione Agregar Plataforma> OS X.

Nota: El entorno de desarrollo es en Windows. Esto significa que no se puede ejecutar aplicaciones nativas de OS X en su máquina Windows. Tendrá que conectar el IDE a una máquina X Mac OS.

Para implementar la aplicación para Mac OS X y establecer sesiones de depuración remotos automáticamente, RAD Studio proporciona una herramienta llamada Plataforma Assistant (PAServer).

Tutorial: Instalar PAServer describe los pasos para instalar PAServer en tu Mac OS X.

Definir un perfil de conexión

Después de instalar PAServer en su máquina Mac OS X, se puede conectar el IDE con el Mac, como sigue:

1. Haga clic en el nodo X OS bajo Plataformas de destino en el Administrador de proyectos, y seleccione Propiedades.

2. Seleccione Agregar Nuevo ... en el menú desplegable Perfil en el cuadro de diálogo Propiedades de la plataforma.

3. Escriba un nombre para el perfil.

4. Especifique el nombre de tu Mac (o dirección IP).

Paso 7: Ejecute la aplicación en Mac OS X Ahora el IDE está conectado a su Mac. Presione F9 para ejecutar la aplicación en tu Mac. Su solicitud debe ser similar al que se muestra en la siguiente imagen.

http://docwiki.embarcadero.com/RADStudio/XE5/en/File:My_first_FireMonkey_application_running_on_Mac.png

Tutorial móvil: Crear una aplicación móvil FireMonkey (iOS y Android) Este tema describe cómo crear un "Hello World" FireMonkey aplicación móvil (C + + o Delphi), ya sea para el iOS o Android plataforma de destino .

Antes de empezar Para desarrollar aplicaciones móviles (iOS y Android) utilizando RAD Studio, debe completar algunos pasos de configuración importantes. Este tutorial asume que usted ha completado todos los pasos de configuración necesarios.

Paso 1: Crear una nueva aplicación de FireMonkey para Android o iOS

1. Seleccione: o Archivo> Nuevo> Aplicación FireMonkey Mobile - Delphi o Archivo> Nuevo> FireMonkey de aplicaciones móviles - C + + Builder

El FireMonkey Aplicación móvil aparece asistente:

2. Seleccione Aplicación en blanco. El Diseñador FireMonkey Formulario Mobile muestra un nuevo formulario para la plataforma móvil de forma predeterminada, Android:

3. Android: Si desea crear una aplicación para Android que se ejecuta en el emulador de Android por defecto, puede utilizar la plataforma de destino preseleccionado.

Para utilizar un dispositivo Android, consulte Configurar su sistema para detectar su dispositivo Android .

4. iOS: Si desea crear una aplicación para iOS, abra el nodo Plataforma de destino en el Project Manager y haga doble clic en simulador de iOS (sólo para Delphi) o un dispositivo iOS conectado (tanto para Delphi o C + +):

Paso 2: Coloque los componentes en el Formulario de Mobile FireMonkey

El primer paso para crear una aplicación móvil FireMonkey está diseñando la interfaz de usuario, lo que es también el primer paso cuando se dirigen a las plataformas de escritorio. Hay muchos componentes reutilizables disponibles en el IDE para la creación de interfaces de usuario.

1. Mueva el puntero del ratón sobre la paleta de herramientas , y ampliar la categoría Estándar, haga clic en el signo más (+) junto al nombre de la categoría.

2. Seleccione la TEdit componente y, o bien haga doble clic en TEdit o colóquelo en el Diseñador de formularios FireMonkey móvil .

Una instancia de la TEdit aparece componente en el formulario. Aquí es una aplicación para Android:

3. Repita estos pasos, pero ahora agregar un TLabel y una TButton componente al formulario. 4. Seleccione el cuadro de edición y establezca la propiedad KillFocusByReturn en el Inspector de Objetos

para True . 5. Seleccione el botón y cambie la propiedad Text en el Inspector de Objetos para "Say Hello". 6. Ahora debería ver tres componentes en el Diseñador de formularios FireMonkey móvil . Aquí es una

aplicación para iOS:

7. Después de colocar estos componentes en el Diseñador de formularios FireMonkey móvil , el IDE establece automáticamente los nombres de los componentes.

Para ver o cambiar el nombre de un componente, haga clic en el componente en el Diseñador FireMonkey Formulario móvil , y luego encontrar su Nombre de la propiedad en el inspector de objetos y de la vista de estructura :

Para una TButton componente, el nombre del componente está configurado por defecto para Button1 (o Button2 Button3, dependiendo del número de TButtons que haya creado en esta solicitud).

8. La forma en la que se encuentran estos componentes también tiene un nombre. Seleccione el fondo del Diseñador de formularios FireMonkey móvil , y seleccione la propiedad Name en el Inspector de Objetos. Se muestra el nombre del formulario Form1 (o Form2, Form3, ...). También puede localizar el nombre del formulario en la vista de estructura :

9. Usted puede cambiar fácilmente al código fuente seleccionando el código (para Delphi) o <Unidad: name>. Pestaña cpp / <Unidad: name>. H (para C + +) en la parte inferior del Diseñador de formularios. También puede presionar la tecla F12 para cambiar entre el Diseñador de formularios FireMonkey móvil y el Editor de código :

Delphi C + +

El Editor de código muestra el código fuente que el IDE ha generado. Usted debe encontrar tres componentes definidos (EDIT1, Label1, y Button1):

Delphi C + +

Nota: Al guardar o ejecutar el proyecto, la Utilización e incluir cláusulas se actualizan (añadir FMX.StdCtrls para TLabel y FMX.Edit para TEdit ).

Paso 3: Escribe un controlador de eventos para el clic de un botón por el Usuario

El siguiente paso es definir un controlador de eventos para el TButton componente. Puede definir controladores de eventos para su aplicación móvil FireMonkey de la misma manera a definir controladores de eventos para aplicaciones de escritorio. Para el TButton componente, el evento más típico es un clic de botón.

Haga doble clic en el botón en el Diseñador de formularios, y RAD Studio crea código esqueleto que puede utilizar para implementar un controlador de eventos para el evento click del botón:

Delphi C + +

Ahora usted puede poner en práctica respuestas dentro del método Button1Click.

Los siguientes fragmentos de código (Delphi y C + +) implementan una respuesta que muestra un pequeño cuadro de diálogo que dice "Hello + <nombre entró en la edición box>":

Código de Delphi:

.. Label1 Texto: '!' = 'Hola' + Edit1 Texto +;

Código C + +:

"!" Label1 - -> Text = "Hola" + Edit1> Texto +;

En Delphi, las comillas que rodean literales de cadena deben estar entre comillas simples rectas (es decir, 'string' ). Usted puede utilizar el signo más ( + ) firmar para concatenar cadenas. Si usted necesita una comilla dentro de una cadena, puede utilizar dos comillas simples consecutivas dentro de una cadena, que produce una única cotización.

Mientras que usted está escribiendo código, algunos consejos sobre herramientas aparecen, indicando el tipo de parámetro es necesario especificar. Los consejos tooltip también muestran los tipos de miembros que se admiten en una clase determinada:

Delphi C + +

Paso 4: Evalúe su aplicación móvil

La implementación de esta aplicación está terminada, por lo que ahora se puede ejecutar la aplicación.

Puede hacer clic en el botón Ejecutar ( ) En el IDE, pulse F9 o seleccione Ejecutar> Ejecutar en el menú principal de RAD Studio:

Delphi C + +

Probar la aplicación para Android

Las pruebas en el emulador de Android

Por defecto, las aplicaciones de Android se ejecutan en el emulador de Android por defecto proporciona en RAD Studio. Antes de ejecutar su aplicación para Android, confirme la plataforma de destino en el Project Manager :

Las pruebas en el dispositivo Android

Si completa los pasos descritos en Mobile Tutorial: Configurar el entorno de desarrollo en Windows PC (Android) antes de la creación de su nuevo proyecto, ahora puede ejecutar su aplicación Android en un dispositivo Android conectado a su PC mediante el cable USB.

Pruebe su aplicación iOS

Las pruebas en el Mac (simulador de iOS)

Por defecto, las aplicaciones FireMonkey Delphi iOS se ejecutan en la plataforma de destino simulador de iOS. Usted puede confirmar la plataforma de destino en el Project Manager :

Cuando se ejecuta la aplicación, se implementa en el Mac y luego al simulador de iOS en el MAC. Para nuestra aplicación, se mostrará un formulario con un cuadro de edición y un botón. Introduzca texto en el cuadro de edición y haga clic en el botón Say Hello:

Nota: En los simuladores de iOS, puede probar sólo sus aplicaciones Delphi.

Las pruebas en un dispositivo iOS conectado

Si completa los pasos descritos en Mobile Tutorial: Configurar el entorno de desarrollo en el Mac (iOS) y Mobile Tutorial: Configurar el entorno de desarrollo en Windows PC (iOS) antes de la creación de su nuevo proyecto, ahora puede ejecutar su aplicación para iOS en un dispositivo iOS conectado a su Mac mediante el cable USB.

Para ejecutar la aplicación de iOS en un dispositivo iOS conectado, primero seleccionar la plataforma de destino de dispositivos iOS para que el Ayudante Plataforma despliega la aplicación en el dispositivo iOS conectado:

Después de seleccionar la plataforma de destino de dispositivos iOS, ejecute su aplicación para iOS haciendo clic en el botón Ejecutar en el IDE, presionando F9 o seleccionando Ejecutar> Ejecutar.

En el Mac, es posible que vea un cuadro de diálogo pidiendo su permiso para firmar el código de aplicaciones iOS. Seleccione "Permitir siempre" o "Permitir" para firmar su aplicación.

A continuación, vaya a su dispositivo iOS y espere a que aparezca su aplicación FireMonkey iOS. Esté atento a la imagen del lanzamiento FireMonkey (el icono está disponible en $ (BDS) \ bin \ ilustraciones \ iOS, y se puede establecer la imagen de lanzamiento en Opciones de la aplicación ):

Tutorial móvil: Configurar el entorno de desarrollo en Windows PC (Android) Una aplicación FireMonkey con destino a la plataforma de destino Android opcionalmente puede ser probado inicialmente en un emulador de Android que se ejecuta en la plataforma de desarrollo de Windows. La mayor parte del proceso de prueba utiliza la plataforma de destino de dispositivos Android y requiere un dispositivo Android de prueba conectada mediante un cable USB a su sistema de desarrollo. No es necesario utilizar el Asistente de Plataforma en el desarrollo de aplicaciones para la plataforma de destino Android. (PAServer es, sin embargo, necesaria para el desarrollo de aplicaciones de iOS y Mac OS X).

Nota: Si instala las herramientas de desarrollo de Android durante la instalación de RAD Studio, de instalar el controlador USB para su dispositivo Android es el único paso de configuración se describe aquí que necesita realizar en su PC.

Después de completar este tutorial, ya sea o el necesario paso , los pasos a seguir son los siguientes:

Habilitar la depuración USB en su dispositivo Android Configure su sistema para detectar su dispositivo Android

Configuración de la RAD Studio Ambiente

Las siguientes herramientas de desarrollo de Android están instalados en su sistema de desarrollo durante la instalación RAD Studio:

Java Development Kit (JDK) Kit de desarrollo de software de Android (SDK) Android Development Kit Nativo (NDK)

Android Development Tools se instalan con RAD Studio

Le recomendamos que instale las herramientas de desarrollo de Android utilizar nuestro instalador producto. Sin embargo, si usted ya tiene las herramientas de desarrollo de Android instalado en su sistema, o si desea instalar las herramientas usted mismo, usted puede optar por omitir este paso en el instalador. Para obtener instrucciones específicas sobre la instalación de las herramientas de desarrollo de Android sí mismo, consulte Instalación de las herramientas de desarrollo de Android .

Instalado por defecto Localización de las herramientas de desarrollo de Android

Java Development Kit (JDK)

C:\Program Files\Java\jdk1.7.0_25

Kit de desarrollo de software de Android (SDK)

C:\Users\Public\Documents\RAD Studio\12.0\PlatformSDKs\adt-bundle-windows-x86-20130522\sdk

Android Development Kit Nativo (NDK)

C:\Users\Public\Documents\RAD Studio\12.0\PlatformSDKs\android-ndk-r8e

Adición del SDK de Android en Herramientas Opciones> Gestor de SDK Importante:

Si el SDK y NDK Android se instalan durante la instalación de RAD Studio, el SDK de Android se debe descubrir de forma automática por el RAD Studio SDK Manager , y no es necesario realizar este paso, proceda con el paso siguiente:. Instalación del controlador USB para su dispositivo Android .

Si ha instalado el SDK y NDK Android ti mismo, es necesario realizar este paso para que RAD Studio puede crear aplicaciones que se dirigen a los dispositivos Android.

1. Seleccione Herramientas> Opciones> Opciones de entorno> Manager SDK .

Aquí está el SDK Manager cuando está completamente llena con el SDK de Android recomendadas:

Nota:

o Los SDK Administrador de campos están en blanco si el SDK Manager no puede detectar el defecto instalado SDK de Android y que aún no ha añadido un SDK de Android para el Administrador de SDK.

o Los campos marcados con no tienen el camino correcto. Haga clic en el [...] en ese campo y vaya a la ubicación de instalación de los archivos de la biblioteca.

2. Haga clic en Agregar. 3. En el cuadro de diálogo Agregar nuevo SDK, haga clic en la flecha hacia abajo en el campo Seleccione una

versión del SDK y seleccione Agregar nuevo ... en la lista desplegable:

Nota: Si la instalación del SDK de Android aparece en la lista Seleccione una versión del SDK, seleccione su SDK de Android.

4. El Cree aparece un nuevo asistente de Android SDK. o Complete los dos primeros campos de este asistente: Camino Android SDK Base y Camino en

Android NDK Base (sus ubicaciones de instalación). O introducir las trayectorias de las ubicaciones de instalación o haga clic en los puntos suspensivos [...] y vaya a los lugares instalados.

o La símbolo indica que el corrido de bases se pierden, y el botón Siguiente se activa sólo después de estos campos se llenan.

o Aquí está el asistente cuando no se han agregado los SDK y los campos de ruta de la base están vacías:

Este asistente verifica el corrido de bases que se especifican a continuación, automáticamente llena las rutas de acceso a las diversas otras bibliotecas (es decir, las herramientas en la página 2 del asistente). Por lo tanto, es posible que tenga que introducir sólo las rutas de base para el NDK y SDK, en la página 1 del asistente. A continuación, la segunda página se rellenará automáticamente, si se les da un poco de tiempo. O usted puede ser que necesite para verificar las direcciones de auto-pobladas (si están presentes).

o He aquí la primera página del asistente después explora (o entrar) las rutas de acceso al SDK y NDK Android. No existen iconos, porque las rutas se han verificado.

5. Haga clic en Siguiente para ir a la siguiente página del asistente, en el que el asistente intentará rellenar previamente los campos de descubrimiento.

o Esta es la segunda página del asistente, con todos sus campos precargadas:

o Para los campos que no prellenado, haga clic en el botón de puntos suspensivos [...] y vaya a la ubicación de instalación.

6. Haga clic en Finalizar para cerrar el asistente.

Puede ver y administrar sus SDKs para Android instalados, abra el Administrador de SDK .

Instalación del controlador USB para su dispositivo Android (Obligatorio)

Las instrucciones y los sitios de descarga están disponibles para varios dispositivos Android aquí:

http://developer.android.com/sdk/win-usb.html (Drivers Google USB) https://developer.amazon.com/sdk/fire/connect-adb.html (controladores USB Kindle Fire) http://developer.android.com/tools/extras/oem-usb.html (controladores USB OEM)

Por ejemplo, para un Nexus 7 o Nexus 10 tabletas, de instalar el controlador USB Google utilizando el Administrador de SDK de Android, de la siguiente manera:

1. Inicie el SDK Manager.exe seleccionando Inicio | Todos los programas | Embarcadero RAD Studio | SDKs para Android | Herramientas Android:

Consejo: Si el Administrador de SDK de Android no se inicia, ejecute android.bat desde el directorio \ tools dentro de su directorio SDK instalado.

2. En el Administrador de Android SDK, instalar el controlador USB para su Nexus 7 o Nexus 10:

Seleccionar Google USB Driver, desactive todas las casillas de verificación de otros, y haga clic en Instalar 1 Paquete:

1. La potencia de su dispositivo Android y conectarlo mediante un cable USB a su sistema de desarrollo. 2. En el Administrador de dispositivos Panel de control del sistema de desarrollo, haga clic con el Nexus 7 o

Nexus 10 y seleccione Actualizar software de controlador. 3. En el cuadro de diálogo del software de actualización del controlador, vaya a la carpeta \ extras en el

directorio SDK de Android, y seleccione la carpeta que corresponda a su Nexus 7 o Nexus 10. (Seleccione google para el Nexus 7 o Nexus 10.)

4. Haga clic en Aceptar.

Creación de un emulador de Android (Opcional)

Si instala el SDK y NDK durante la instalación de RAD Studio, se crea un emulador de Android para ti, así que no es necesario para crear un emulador de ti mismo.

Un emulador de Android le permite ejecutar una aplicación Android en su sistema de desarrollo en lugar de en un dispositivo Android en vivo. Un emulador puede ser útil durante los ciclos de desarrollo, pero por lo general tiene problemas importantes de rendimiento que no se ve en los dispositivos Android en vivo.

Creación de un emulador de Android Ir hasta el desarrollo de aplicaciones para Android Mobile

Un emulador de Android es un dispositivo virtual de Android (AVD), que representa un dispositivo Android específica. Se puede usar un emulador de Android como plataforma de destino para ejecutar y probar sus aplicaciones Android en el PC.

Un emulador de Android se instala por defecto durante la instalación de RAD Studio. Le recomendamos que usted permite que este emulador se instala durante la instalación del producto. Este emulador se utiliza como el destino predeterminado de una aplicación para Android, por lo que puede crear y ejecutar una aplicación Android en su sistema de desarrollo sin un dispositivo Android conectado.

El emulador de Android instalado es nombrado rsxe5_android, que utiliza la piel WVGA800 y Android 4.2.2.

Requisitos mínimos para un emulador de Android

Para crear un emulador de Android (disponible por Google como parte del SDK de Android), se recomienda utilizar al menos lo siguiente:

Intel Core i5 CPU 4 GB de RAM Emulación GPU debe aparecer en la lista de hardware de la imagen emulador, como se explica en el

funcionamiento de su aplicación Android en un emulador de Android .

No se recomienda el uso de un emulador de Android en una máquina virtual (VM), porque el apoyo de la GPU para el emulador por lo general no está disponible en las máquinas virtuales. Sin embargo, si está ejecutando Delphi en una máquina virtual en un ordenador Mac OS X, se puede considerar el uso de un emulador de distancia en el Mac, ya que el emulador no funciona en máquinas virtuales. Para obtener más información, consulte http://delphi.org/2013/09/debugging-against-a-remote-android-emulator/ .

Delphi XE5 soporta el emulador para las versiones de Android 4.x. No apoyamos emuladores para la versión 2.x (Gingerbread) porque emuladores para las versiones de Android 2.x dirigen una CPU ARMv6, que Delphi no soporta.

Los emuladores de Android requieren una GPU independiente

Emuladores de Android son en gran medida depende del hardware, y esto incluye el hardware está emulando así como el hardware en el que se ejecuta el emulador.

Por esta razón, le recomendamos que verifique la presencia de una tarjeta gráfica adecuada en su sistema de desarrollo.

1. Abra el Panel de control \ Apariencia y personalización \ Resolución de la pantalla \ Screen. 2. Haga clic en Opciones avanzadas. 3. Echa un vistazo a las propiedades que se muestran de la tarjeta gráfica.

o Si usted no tiene una GPU adecuada, probablemente no es digno de su tiempo para crear y tratar de ejecutar un emulador de Android. Encuentra otro sistema de desarrollo que tiene un GPU adecuada.

o No se recomienda Intel GPU. o Si recibe mensajes de error sobre OpenGL ES cuando intenta ejecutar el emulador de Android, esto

significa que su GPU probablemente no es adecuado.

Creación de un emulador de Android es opcional

Si decide crear su propio emulador de Android, considerar la creación de un emulador para cada dispositivo Android que desea apoyar. Tenga en cuenta que los emuladores de Android funcionan a menudo tan lento que algunas personas consideran inutilizables.

RAD Studio es compatible con los siguientes objetivos:

Emuladores de Android que son versión 4.0 o más reciente Los dispositivos Android que son la versión ARM 7 o superior

Emuladores de Android no se pueden ejecutar en una máquina virtual (VM). Aunque un emulador podría ejecutarse en una máquina virtual, el emulador no realmente ejecutar una aplicación.

Nota: Se trata de un problema de rendimiento bien conocido que los emuladores de Android son extremadamente lentos.

Instalación de una imagen del sistema Android (Obligatorio)

Antes de crear un emulador de Android, es necesario instalar una imagen del sistema Android que sus emuladores pueden utilizar.

Nota: Si ha instalado el SDK y NDK Android durante la instalación RAD Studio, una imagen del sistema Android válida (como Android 4.2.2 API 17) ya debería aparecer como instalado en el Administrador de Android SDK. En este caso, no es necesario instalar otra imagen del sistema Android.

Siga estos pasos:

1. Inicie el Manager SDK de Android (seleccione Inicio | Todos los programas | Embarcadero RAD Studio | Android Tools).

2. En el árbol de paquetes, localizar y comprobar el nodo System Image v7a EABI ARM dentro del primer nodo de Android en la lista.

Por ejemplo: Android 4.2.2 (API 17) o Android 4.3 (API 18)

3. Haga clic en Instalar 1 paquete. (Claro de ninguna casilla que fueron seleccionados automáticamente.) 4. En la página Elegir los paquetes a instalar, haga clic en Aceptar licencia y, a continuación, haga clic en

Instalar para instalar la imagen del sistema.

Creación de un emulador de Android - Los campos clave

Creación de un emulador de Android Usando el Administrador de dispositivos Android Virtual

Para crear un emulador de Android en su sistema, siga estos pasos:

1. Inicie el Manager SDK de Android (seleccione Inicio | Todos los programas | Embarcadero RAD Studio | SDK Android | Gerente Android AVD).

2. En el Administrador de dispositivos Android Virtual, haga clic en el botón Nuevo para crear un nuevo dispositivo virtual.

3. En el nuevo cuadro de diálogo Crear dispositivo virtual Android (AVD), seleccione un dispositivo Android para emular, e introduzca los datos que describen el dispositivo Android que desea emular. Con el fin de ejecutar una aplicación móvil FireMonkey , el emulador de Android debe cumplir los siguientes requisitos:

1. En Destino, seleccione un SDK de Android con un nivel de API que es de 17 o superior. La lista desplegable contiene las versiones instaladas de la SDK de Android.

2. En Opciones de Emulación, seleccione Usar Host GPU. 3. En Dispositivo, seleccione el dispositivo Android para emular.

Consejo: Emulando a un dispositivo Android más viejos como el Nexus S podría ser más rápido que la emulación de un dispositivo más grande más nuevo como el Nexus 10.

4. Haga clic en Aceptar dos veces para crear su nuevo emulador de Android. 5. Ahora puede ver el emulador en el Administrador de dispositivos Android Virtual.

RAD Studio muestra sus emuladores de Android en el Gerente del Proyecto , en el nodo de destino del nodo plataforma de destino Android. Consulte Uso del nodo de destino .

Nota: Como referencia, aquí está el defecto ubicaciones de las herramientas de desarrollo de Android instalado como instalado por el instalador RAD Studio:

Si usted necesita para comenzar el Manager SDK Android directamente, aquí es su ubicación:

C:\Users\Public\Documents\RAD Studio\12.0\PlatformSDKs\adt-bundle-windows-x86-20130522 .

Si SDK Manager.exe no se inicia, use Android.bat, que se encuentra aquí:

C:\Users\Public\Documents\RAD Studio\12.0\PlatformSDKs\adt-bundle-windows-x86-20130522\sdk

Creación de un emulador de Android mediante la línea de comandos

Puede crear un emulador de Android en la ventana de comandos escribiendo un comando como este:

eco no | crear android-s avd-n my_android-t 1

Para la piel, es posible que desee agregar esta opción:

- Piel WXGA800-7 pulgadas

Para obtener más información, consulte la documentación de Android .

Inicio de un emulador de Android

Cuando el emulador es la plataforma de destino actual, usted no tiene que iniciar el emulador antes de ejecutar la aplicación Android en el emulador. Sin embargo, se recomienda que usted comienza su emulador de Android por separado, tal vez antes de empezar a RAD Studio. Los emuladores son notoriamente lentos para iniciar y ejecutar, de manera de iniciar el emulador de antemano significa que su aplicación puede llegar a el emulador más rápido.

La forma recomendada para iniciar un emulador de Android es mediante el Administrador de dispositivos virtuales de Android, que se puede iniciar desde el Administrador de Android SDK.

Para iniciar un emulador de Android, como el emulador por defecto instalado en RAD Studio:

1. Inicie el Administrador de dispositivos virtuales de Android (seleccione Inicio | Todos los programas | Embarcadero RAD Studio | SDK Android | Gerente Android AVD).

2. Seleccione el emulador y haga clic en Iniciar.

3. Luego haga clic en Iniciar en el cuadro de diálogo Opciones de lanzamiento.

4. Su emulador debe ahora comenzar (esto puede tardar cinco o diez minutos):

En el Administrador de proyectos, el emulador debe aparecer en el nodo de destino de la plataforma de destino Android, con su puerto asignado (por ejemplo, (5554)):

Consejo: Si el Jefe de proyecto no muestra su funcionamiento emulador de Android como correr, con el mismo icono que en la imagen anterior, consulte Utilizar el nodo de destino .

Su próximo paso es ejecutar una aplicación para Android en el emulador . En Project Manager, asegúrese de que el nombre del emulador está en negrita y el número de puerto se indica entre paréntesis (como por ejemplo (5554)), lo que indica que el emulador está en marcha y es la plataforma de destino seleccionado actualmente.

Para obtener más información, consulte http://developer.android.com/tools/devices/managing-avds.html .

Ejecutar la aplicación Android en un emulador de Android Ir hasta el desarrollo de aplicaciones para Android Mobile

Contenido [hide]

1 Para agregar emulación GPU para el emulador por defecto 2 Para iniciar su Android Emulador 3 Para ejecutar la aplicación en tu Android Emulador 4 Vea también

RAD Studio proporciona un emulador de Android por defecto para su uso. El emulador se llama rsxe5_android.exe, y se encuentra en C:\Users\<username>\.android\avd\ . Usted puede utilizar el rsxe5_android emulador por defecto o crear un emulador de Android sí mismo .

El emulador de Android por defecto se crea un script que no se puede agregar una propiedad crítica - Emulación de GPU. Usted debe agregar este inmueble a el emulador rsxe5_android.exe, tal como se describe a continuación en # para añadir emulación GPU para el emulador por defecto .

Antes de ejecutar la aplicación en el emulador de Android, inicie el emulador de Android, como se describe a continuación en # iniciar su emulador de Android , con el fin de reducir el tiempo de inicio al ejecutar la aplicación para Android desde el IDE.

Administrador de dispositivos Android con defecto RAD Studio Android Emulador, rsxe5_android

La ubicación de instalación por defecto de las herramientas de desarrollo de Android es:

C:\Users\Public\Documents\RAD Studio\12.0\PlatformSDKs\adt-bundle-windows-x86-20130522\sdk\tools

Para agregar emulación GPU para el emulador por defecto

El emulador por defecto (rsxe5_android) no tiene el uso de la GPU propiedad Host establecida por defecto. Usted puede encontrar que el emulador se ejecuta más rápido si se habilita la emulación GPU, de la siguiente manera:

1. Abra el Android Virtual Device Manager: Seleccione Inicio> Todos los programas> Embarcadero RAD Studio> SDK de Android> Administrador Android AVD:

2. Seleccione el emulador rsxe5_android y haga clic en el botón Editar.

Nota: Si el emulador rsxe5_android no está presente, puede crear su propio emulador de Android. Consulte Creación de un emulador de Android .

3. En el cuadro de diálogo Editar Android Virtual Device (AVD), haga clic en Nuevo en el campo del hardware.

4. Añadir (seleccione) la propiedad de emulación GPU en la lista de propiedades del emulador, y haga clic en Aceptar:

5. Establecer el valor de la propiedad de emulación GPU para sí:

6. Haga clic en Editar AVD para guardar los cambios.

Para iniciar su Android Emulador

1. Inicie el Android Virtual Device Manager: Seleccione Inicio> Todos los programas> Embarcadero RAD Studio> SDK de Android> Administrador Android AVD.

2. En el Administrador de dispositivos Android Virtual, seleccione el emulador de Android en la lista y haga clic en Iniciar.

3. En el cuadro de diálogo de opciones de inicio, haga clic lanzamiento:

Para ejecutar la aplicación en tu Android Emulador

1. Abra la aplicación de Android en RAD Studio. 2. En el Project Manager , permitir que el emulador como la plataforma de destino.

Si es necesario, expanda el nodo Plataformas de destino y haga doble clic en la plataforma de destino Android. (Se muestra la plataforma de destino activo utilizando un tipo de letra negrita.)

1. Expanda el nodo de Android en el Administrador de proyectos. 2. Expanda el nodo de destino del niño. 3. Haga doble clic en el objetivo emulador de Android para activarlo. (Se muestra el emulador activo

utilizando un tipo de letra negrita.)

Nota: Si no se muestra el emulador, haga clic en el nodo de destino y seleccione Actualizar. Si el emulador sigue sin aparecer, consulte Utilizar el nodo de destino . En la siguiente imagen se puede ver el emulador rsxe5_android defecto correr, y la plataforma de destino ajuste activado en el Administrador del proyecto:

3. En el selector de dispositivo en el Diseñador de formularios FireMonkey Mobile , seleccione el dispositivo que coincide con el emulador que está utilizando. Por ejemplo:

o Si está utilizando el rsxe5_android emulador por defecto con su base de piel, seleccione WXGA800. o Si el emulador utiliza el dispositivo WQVGA400, seleccione 3.3 "WQVGA teléfono Android (240dp

x 400 dp) 4. Ejecute la aplicación:

o Corre con la depuración (Ejecutar> Ejecutar o F9 ) o Ejecutar sin depuración (Ejecutar> Ejecutar sin depuración o Shift+Ctrl+F9 )

5. Compilar y desplegar los mensajes deberán aparecer en el IDE. 6. Si el emulador no se está ejecutando, el IDE muestra: ". El emulador seleccionado no está funcionando

¿Quieres empezar?" Haga clic en Sí. Se muestra un mensaje de "emulador de lanzamiento". 7. Abra la pantalla del emulador y velar por la aplicación a aparecer.

En la siguiente imagen se puede ver un Nexus encargo 4 emulador se ejecuta una sencilla aplicación Hello World:

RAD Studio genera la aplicación para Android y se ejecuta la aplicación en el emulador de Android seleccionada. Si el emulador de Android activo no se está ejecutando, RAD Studio muestra un cuadro de diálogo que le da la opción para iniciar el emulador de Android. Si la pantalla del emulador de Android está bloqueado, desbloquea para acceder a su solicitud.

Emuladores de Android ir mucho más lento que los dispositivos reales debido a la plataforma de emulación ARM en la parte superior de un sistema no-ARM, si el rendimiento no le permite usar un emulador de Android lado a lado con RAD Studio, vea Ejecutar y Depurar la aplicación de Android de forma remota . Por razones obvias, los emuladores también carecen de algunas de las características que los dispositivos reales proporcionan, aunque se puede emular algunas de estas características , como la ubicación geográfica .

Correr y Depuración de la aplicación Android de forma remota Ir hasta el desarrollo de aplicaciones para Android Mobile

Contenido [hide]

1 Prepare el equipo remoto 2 Configure su PC Desarrollo 3 Vea también

Emuladores de Android requieren una gran cantidad de recursos de la máquina, sobre todo de la CPU. Ejecución de un emulador de Android y de lado a lado RAD Studio en la misma PC podría no ser deseable, en función de los recursos de su PC de desarrollo. Esto es particularmente cierto cuando se ejecuta RAD Studio en una máquina virtual (VM).

Si usted necesita para ejecutar un emulador de Android, pero utilizando el PC de desarrollo no es una opción, puede ejecutar opcionalmente el emulador de Android en una segunda máquina, y que su PC de desarrollo conectado a esta segunda máquina mediante SSH, por lo que RAD Studio puede detectar y utilizar cualquier emulador de Android que se ejecuta en esa segunda máquina.

Nota: Este método no se limita a los emuladores de Android, se puede utilizar este método con los dispositivos Android conectados a la segunda máquina también.

Véase también: Instrucciones de Vídeo

Prepare a su equipo remoto

La máquina en la que se ejecuta un emulador de Android puede ser cualquier sistema admitido por el SDK de Android: Windows, Mac OS X o Linux. Se recomienda que este equipo está en la misma red que el PC de desarrollo, por razones de rendimiento y configuración, pero puede ser que sea posible utilizar cualquier máquina si los cortafuegos y enrutamiento están configurados correctamente.

En el equipo remoto:

1. Instalar y habilitar una solución de servidor de SSH. Ver: o De Windows carece de soporte integrado SSH, compruebe aquí para una lista de soluciones de

servidor SSH que puede instalar en su máquina remota. FreeSSHd se ha encontrado para trabajar.

o En Mac OS X vaya a Preferencias del sistema -> Compartir y activar la opción "Remote Login". Ver también: Cómo habilitar SSH en Mac OS X .

2. Instalar el SDK de Android .

Si el equipo remoto ejecuta Windows, consulte Instalación del JDK / SDK / NDK (sólo se requiere el JDK y SDK). Para otros sistemas operativos, siga las indicaciones hacia el JDK y luego extraer el SDK en una carpeta conveniente.

3. Crear y activar un emulador de Android para su uso.

Si la máquina remota se ejecuta en Windows, consulte Creación de un emulador de Android . En otros sistemas operativos que necesita para ejecutar Android, que se encuentra en la carpeta sdk / / Herramientas de donde extrajo el SDK de Android. Desde allí se puede acceder al Administrador de AVD de Herramientas.

4. Matar el servidor ADB:

1. Abra una ventana de terminal y vaya a la carpeta SDK de Android que contiene el ejecutable ADB (directorio sdk \ Platform-tools).

2. Intro: adb.exe kill-server (Windows) o ./adb kill-server (Mac OS X, Linux).

Configure su PC Desarrollo

En el PC de desarrollo:

1. Instale el PuTTY cliente SSH. 2. Abra PuTTY y crear una conexión con el equipo remoto. 3. Seleccione Conexión> SSH> Tunnels y añada a / reenvío de puertos auto local para:

o 5555 a localhost: 5555 o 5554 a localhost: 5554

4. Guarde su conexión y abrirlo. 5. Introduzca las credenciales de inicio de sesión SSH para su máquina remota. 6. Mantenga esta ventana de terminal abierta, ya que mantiene la conexión con el equipo remoto. Usted

puede minimizarlo.

Una vez que has iniciado sesión, es necesario reiniciar el servidor ADB se ejecutan en su PC de desarrollo:

1. Abra una ventana de terminal y vaya a la carpeta SDK de Android que contiene el ejecutable ADB (directorio sdk \ Platform-tools).

2. Intro: adb.exe kill-server&adb start-server

Su emulador de Android que se ejecuta en la máquina remota debe aparecer en el Administrador de proyectos .

Nota: Los emuladores de Android instalado en su máquina remota, pero no en ejecución no se pueden mostrar en el Administrador de proyectos, se muestran sólo los emuladores en ejecución.

Agregar un SDK de Android Ir hasta Pasos para crear aplicaciones multiplataforma

Ir hasta el desarrollo de aplicaciones para Android Mobile

Un kit de desarrollo de software (SDK) proporciona un conjunto de archivos que se usa para crear aplicaciones para una plataforma de destino. Al desarrollar aplicaciones para Android, el SDK de Android y Android NDK son necesarios en su sistema de desarrollo, y ambos deben ser conocidos por el Administrador de SDK .

Al instalar RAD Studio, el programa de instalación le da la opción de instalar las versiones recomendadas del SDK y el NDK Android. Si se instalan estas versiones recomendadas durante la instalación del producto, el SDK Manager detecta su presencia y establece las rutas y ubicaciones predeterminadas para usted, como se muestra en esta captura de pantalla:

En este caso, cuando las versiones recomendadas del SDK y el NDK Android se instalan por defecto, usted no necesita agregar un SDK de Android, ya que la ubicación predeterminada es conocido en el SDK Manager , por lo que las bibliotecas son detectadas automáticamente.

Si desea instalar el SDK y NDK Android ti mismo, incluso en ubicaciones alternativas, o si desea utilizar una instalación existente del SDK y el NDK Android, debe agregar el SDK de Android para el RAD Studio SDK Manager . Consulte Instalación de las herramientas de desarrollo de Android , si usted no tiene el SDK de Android NDK o instalados con todo y que desea instalar usted mismo.

Precaución: Las versiones de las bibliotecas del SDK y el NDK Android que difieren de las que se instalan con RAD Studio no funcionen como se esperaba.

Para agregar un SDK de Android para RAD Studio:

1. Seleccione Herramientas> Opciones> Opciones de entorno> Manager SDK . 2. Haga clic en el botón Agregar. 3. En el Agregar un nuevo SDK cuadro de diálogo, seleccione Android de la lista desplegable

Seleccionar plataforma.

RAD Studio detecta los SDK de Android instalado en su sistema y se rellena el cuadro Seleccione una lista desplegable versión SDK para usted.

4. Seleccionar un SDK desde la lista Seleccionar un desplegable versión SDK. Para obtener más información y solución de problemas, consulte Manager SDK .

5. Compruebe Hacer el SDK seleccionada activa si desea que el nuevo SDK para ser el SDK defecto para Android.

6. Haga clic en Aceptar para continuar. La Creación de un nuevo SDK de Android asistente abre. 7. En el campo Ruta del Android NDK Base en la primera página del asistente, escriba la ruta a la

carpeta de NDK instalado, y haga clic en Siguiente. 8. En la página siguiente, espere RAD Studio para detectar automáticamente las trayectorias de las

herramientas necesarias y, a continuación, haga clic en Finalizar.

Su versión del SDK de Android aparece ahora en el Administrador de SDK :

La versión de Android SDK ahora debe ser incluido en la plataforma de destino Android en el Project Manager:

Creación de una aplicación para Android Ir hasta FireMonkey Guía de aplicaciones

Ir hasta el desarrollo de aplicaciones para Android Mobile

Contenido [hide]

1 Formas Android 2 Restricciones de equipo para los FireMonkey Aplicaciones Android 3 Uso de marcos en Aplicaciones Android

o 3.1 FireMonkey o 3.2 VCL (no disponible para Android) o 3.3 RTL o 3.4 API de Android

4 Android Core Lib Los nombres no se pueden utilizar como nombres de la aplicación 5 Recomendaciones de alineación para Barras de herramientas móviles y otros componentes FireMonkey 6 Uso de Fuentes personalizadas en Aplicaciones Android 7 Uso de Cuadros de diálogo modales en Aplicaciones Móviles 8 Ajuste del necesario usos Permisos para sus aplicaciones Android 9 Uso del botón Atrás del dispositivo Android 10 Cómo hacer que su aplicación se ejecute en modo Pantalla completa 11 Ajustes de teclado, TEdit y TMemo 12 El uso de iconos e imágenes en múltiples resoluciones 13 Carga y Despliegue de Archivos 14 Vea también

Para crear su aplicación Android:

Archivo> Nuevo> Aplicación FireMonkey Mobile - Delphi

Nota: Esta página le ayuda a desarrollar aplicaciones FireMonkey que se dirigen a la plataforma Android. Véase Android Desarrollo de aplicaciones móviles para temas que no son específicos de la fase de desarrollo, tales como la configuración de su PC y los dispositivos Android para trabajar con RAD Studio.

Formas Android

Utilizando el formulario Mobile FireMonkey , puede agregar formas adicionales de la misma manera que se hace con las aplicaciones de escritorio.

El formulario de Android tiene propiedades dependientes del hardware específicos. Por ejemplo, la forma androide tiene una forma o huella diferente de una forma FireMonkey de escritorio estándar, como sigue:

Para una aplicación FireMonkey Android, el formulario predeterminado es una forma vertical: o ClientHeight = 480 píxeles o ClientWidth = 320 píxeles

Estas son las mismas dimensiones predeterminadas utilizadas para una aplicación para iOS.

Para una aplicación de escritorio FireMonkey, la forma es una forma horizontal: o ClientHeight = 480 píxeles o ClientWidth = 600 píxeles

Restricciones de equipo para los FireMonkey Aplicaciones Android

Mientras que usted está diseñando su aplicación Android en RAD Studio, sólo puede utilizar los componentes que se admiten en los dispositivos Android. Sin embargo, tenga en cuenta que la paleta de

herramientas puede contener algunos componentes que son sólo para Windows o de otra manera no son compatibles con Android.

El uso de marcos en Aplicaciones Android

FireMonkey

El marco FireMonkey es ideal para la plataforma de destino Android, y es compatible con muchas otras plataformas también .

VCL (no disponible para Android)

La VCL sólo está disponible en Windows (32-bit o 64-bit).

RTL

Algunas unidades de reeducación por el trabajo que proporcionan funcionalidades básicas son comunes para todas las plataformas soportadas objetivo (incluyendo Android), como System.pas o System.SysUtils.pas.

Un número de unidades de RTL son sólo Android (ver API de Android ). Estas unidades tienen el prefijo del Androidapi alcance unidad .

API Android

La RTL contiene un número de unidades que proporcionan interfaces de Delphi a la API nativa de Android. Estas unidades están en el ámbito de Androidapi y por lo general se encuentran en el source\rtl\android\ directorio de su instalación de RAD Studio. El marco FireMonkey se basa en algunas de estas unidades, pero no utiliza directamente.

Android Core Lib Los nombres no se pueden utilizar como nombres de la aplicación

No se puede asignar un nombre a su proyecto si los conflictos de nombres con el nombre de un archivo de objeto base de la biblioteca compartida, como <nombre biblioteca>. Así.

Por ejemplo, no se puede utilizar cualquiera de los siguientes como los nombres de proyecto:

c (conflictos con libc.so) m (conflictos con libm.so) z (conflictos con libz.so) ssl (conflictos con libssl.so) ui (conflictos con libui.so) gui (conflictos con libgui.so) camera_client (conflictos con camera_client.so)

Y así sucesivamente.

Recomendaciones de alineación para Barras de herramientas móviles y otros componentes FireMonkey

Para asegurarse de que la barra de herramientas en su aplicación móvil se comporta y se ve igual en las plataformas iOS y Android, debe establecer las propiedades específicas de alineación en el Inspector de objetos , de la siguiente manera:

Establezca la propiedad Align para todos los controles que son hijos de un TToolBar . Por ejemplo, los siguientes son los valores de propiedad Align:

(AlLeft, bien, alCenter, alContents)

Para mantener el espacio entre los controles, o para mantener el espacio entre los bordes izquierdo y derecho de las barras de herramientas, establezca las siguientes propiedades:

o Márgenes : (izquierda, derecha) o Relleno : (izquierda, derecha)

Por ejemplo, suponga que tiene una barra de herramientas con un niño TLabel como el título, y dos speedbuttons alineados a la izquierda con un espacio entre cada botón:

3. Por TToolBar , establezca: Align = alTop

4. En el niño TLabel , establezca: Align = alContents

5. Envíe el TLabel a la parte posterior mediante el menú contextual . 6. En los dos niños TSpeedButtons , establezca:

Align = alLeft, bien, alCenter, alContents, alVertCenter

Para obtener una descripción de estas propiedades, consulte FMX.Types.TAlignLayout .

Márgenes izquierdo = 5

Para dar formato a un control segmentado (TSpeedButtons decoradas con un nombre de grupo compartida) de manera que se centra en la barra de herramientas:

1. Añadir una TLayout control al TToolBar. 2. Establecer TLayout.Align a alCenter. 3. Añadir botones a la TLayout y establecer las propiedades de alineación y los márgenes para cada

botón (es decir, Align = alLeft, Márgenes = Izquierda, Márgenes = Derecha, y así sucesivamente). Para un ejemplo, vea Tutorial móvil: El uso de un componente Button con diferentes

estilos (iOS y Android) . Para utilizar TLabel, debe establecer TLabel.AutoSize = False y establezca la propiedad Align.

o Para centrar la etiqueta en una barra de herramientas que ya tiene botones, debe establecer TLabel.Align = alContents y seleccione Enviar al fondo en el menú contextual.

Reglas de alineación similares se refieren a otros controles. Por ejemplo, suponga que ha añadido un TSwitch a un ListBox artículo; para que la conmutación alineado a la derecha y centrada verticalmente, establezca las siguientes propiedades para TSwitch:

Align = Alright Márgenes Derecha = 5

El uso de fuentes personalizadas en Aplicaciones Android

Usted puede instalar sus propias fuentes personalizadas en su biblioteca de fuentes en su sistema de desarrollo. Luego de que la fuente debe estar disponible en el IDE para que usted seleccione en tiempo de diseño. Sin embargo, al implementar la aplicación para el dispositivo de destino (iOS o Android), las fuentes de la aplicación se representan utilizando las fuentes instaladas en el dispositivo. Las fuentes que se muestran en tiempo de diseño en el IDE no se copian en el dispositivo, lo que es el comportamiento esperado.

Para saber si una fuente puede estar disponible en tiempo de ejecución en un dispositivo móvil específico, es necesario comprobar si la fuente que está utilizando en tiempo de diseño se admite en los dispositivos de destino:

Fuentes sobre Android: http://developer.android.com/design/style/typography.html Las fuentes instaladas con iOS 6: http://support.apple.com/kb/ht5484 Las fuentes instaladas con iOS 5: http://support.apple.com/kb/HT4980

El uso de Cuadros de diálogo modales en Aplicaciones Móviles

Cuadros de diálogo modales, que monopolizan la entrada del usuario, no son compatibles directamente en aplicaciones RAD Studio Android. En Android, cuadros de diálogo son esencialmente las ventanas emergentes; para información general sobre cuadros de diálogo en Android, consulte http://developer.android.com/guide/topics/ui/dialogs.html

Usted puede utilizar ShowModal en Android si llama ShowModal como un método anónimo, como se describe en ShowModal Diálogos en FireMonkey Aplicaciones para móviles . Llamando ShowModal como se hace normalmente para Windows o Mac OS X podría dar resultados inesperados.

Otra estrategia es llamar a Mostrar , y tienen la forma de devolución y llame a su evento.

Ajuste del necesario usos Permisos para sus aplicaciones Android

Algunos permisos Android básicos son pre-establecidos para todas las aplicaciones FireMonkey Android. Se debe comprobar que los permisos de acceso específicos están habilitados para su dispositivo Android en la utiliza permisos página en Opciones de proyecto.

Por ejemplo:

Para utilizar la cámara del dispositivo Android, asegúrese de que los siguientes permisos están habilitados: o Cámara o Lectura / escritura de almacenamiento externo

Para utilizar la ubicación GPS en el dispositivo Android, asegúrese de que uno o más de los permisos de acceso están habilitadas Ubicación:

o Ubicación aproximada Acceso o Acceso buena ubicación o Comandos adicionales localización Acceso

Para grabar audio en el dispositivo Android, asegúrese de que el siguiente permiso está habilitada: o Grabación de audio

Usando el botón Atrás del dispositivo Android

Para continuar con su contexto de aplicación cuando los usuarios pulsan el botón Atrás de su dispositivo Android, agregue un controlador de eventos a su formulario para OnKeyUp , y utilice el siguiente código en el controlador de eventos:

En Delphi:

si Clave = vkHardwareBack entonces comenzar / / Haga lo que usted quiere hacer aquí Clave: = 0; / / Establecer clave = 0 si desea evitar que la acción predeterminada terminar;

Consejo: El pestañas con navegación plantilla móvil implementa este control de eventos.

Cómo hacer que su aplicación se ejecute en modo Pantalla completa

Por defecto, las aplicaciones de Android muestran la barra de barra de estado / título Android.

Si desea que la aplicación se ejecute en modo de pantalla completa y ocultar la barra de estado de Android / título, seleccione Proyecto> Opciones> Información de la versión y cambiar el valor de la clave para el tema No TitleBar.

Para obtener más información, consulte la Información de la versión .

Ajustes para teclado, TEdit y TMemo

Teclado

Ajuste el vkAutoShowMode propiedad a vkasDefinedBySystem, vkasNever o vkasAlways.

TEdit y TMemo

Establecer KillFocusByReturn (habilita la tecla de retorno para quitar el foco del control)

El uso de iconos e imágenes en múltiples resoluciones

En Android, las resoluciones siguientes son compatibles:

1x, 1.5x, 2x, 3x (pequeño, normal, grande, extra grande)

En iOS, las resoluciones siguientes son compatibles:

1x y 2x (Non-Retina y Retina)

Múltiples resoluciones pueden ser apoyadas por la creación de un MultiResBitmap utilizando el nuevo editor MultiResBitmap . Para obtener más información, consulte Uso de Multi-Resolution mapas de bits .

MultiResBitmap soporta las siguientes resoluciones sobre Android: 1x, 1.5x, 2.5x

(IOS soporta 1x y 2x)

La carga y la distribución de archivos

Al implementar la aplicación para la plataforma de destino Android, si va a proporcionar archivos junto con su aplicación para cargar los archivos en tiempo de ejecución, primero debe decidir si usted quiere tener ellos en la memoria interna del dispositivo o en una memoria externa ( por ejemplo, una tarjeta SD). Después de decidir, utilice el Gestor de despliegue de poner los archivos en los assets\internal (interno) o assets carpeta (externa) durante la implementación.

Utilice el código siguiente para localizar los archivos en tiempo de ejecución:

En Delphi:

TPath. Combine (TPath. GetDocumentsPath, 'nombre de archivo') {} Interna TPath. Combine (TPath. GetSharedDocumentsPath, 'nombre de archivo') {externo}

Aquí filename es el nombre del archivo, como 'dbdemos.gdb' en la imagen anterior. El TPath registro se declara en la unidad System.IOUtils, por lo que necesita para añadir System.IOUtils en la cláusula uses.

Tutorial: Uso LiveBinding Para crear una aplicación FireMonkey Sin CódigoLiveBindings es una tecnología de enlace de datos introducidos en la versión XE2 que le ayuda a desarrollar la base de datos de aplicaciones. En este tutorial se muestra cómo crear una pequeña aplicación de base de datos potente usando LiveBinding. Usted puede hacer casi todo lo de aquí con unos pocos clics del ratón, no se requiere codificación.

Este tutorial utiliza la base de datos biolife.cds, normalmente instalado en el directorio Samples en Inicio | Programas | Embarcadero RAD Studio | Muestras y también está disponible con las muestras en SourceForge en: RAD Studio Código demo . Un ejemplo de código que utiliza una base de datos similar (DBDEMOS) está situado en FishFact (Delphi) ejemplo .

Siga estos pasos para crear una aplicación de base de datos utilizando LiveBinding:

1. Crear un nuevo proyecto. Elija una aplicación FireMonkey HD para este ejemplo. 2. Arrastre y suelte un ClientDataSet componente en el Diseñador de formularios. 3. Agregue los siguientes controles al formulario: una etiqueta , un cuadro de edición , un memo , y un control

de la imagen de los componentes. Para ser capaz de desplazarse a través de los registros de la base de datos que eligió para abrir, necesita un adicional TBindNavigator control. Opcionalmente, se puede añadir un Primer botón .

En este punto, su solicitud debe ser similar a la siguiente imagen.

4. Antes de utilizar LiveBinding, es necesario especificar un archivo de base de datos para el ClientDataSet componente. Utilice el NombreArchivo propiedad para especificar un archivo ClientDataSet (*. cds), y seleccione el archivo biolife.cds.

5. Ajuste el activo propiedad en True. 6. Ahora sólo tiene que enlazar cada control gráfico en el formulario para su campo apropiado en la base de

datos. 1. Seleccione el componente de etiqueta y haga clic en él. A continuación, seleccione el Asistente

LiveBindings ... propiedades en el menú contextual.

2. En el Asistente para LiveBindings , seleccione Vincular una propiedad del componente "Label1" con un campo.

3. Seleccione el componente Label1 y la propiedad Text.

4. Seleccione el componente ClientDataSet1.

5. Seleccione el campo Nombre de la especie y haga clic en Finalizar para completar la LiveBinding.

7. Repita los pasos anteriores para conectar el resto de los controles en los formularios de la siguiente manera:

1. Enlace el componente de cuadro de edición para el campo Categoría. 2. Enlace el componente del memorándum para el campo Notas. 3. Enlace el componente de imagen en el campo gráfico.

8. Por último, vincular el navegador se unen al origen de enlace mediante la asignación de la propiedad BindSource a BindSourceDB1.

9. Se puede ver que dos nuevos componentes, BindSourceDB1 y BindingsList1, se han añadido a la forma. Estos componentes no son visuales y son parte del motor LiveBinding. (Para modificar manualmente los enlaces en el componente BindingsList1, haga doble clic en él, pero ese no es el propósito de este tutorial.)

Ahora su aplicación debe ser similar a la siguiente imagen.

10. En este punto, puede ejecutar la aplicación (ya sea seleccione Ejecutar> Ejecutar o presione F9 ). 11. Después de la aplicación se está ejecutando, puede desplazarse a través de los registros de base de datos,

añadir un registro, eliminar un registro, o actualizar la base de datos.

La aplicación que se ejecuta completado:

Creación de una aplicación 3D

Formas FireMonkey 3D proporcionan una superficie completa de GPU con motor 3D con iluminación, texturas y animación de interfaces de usuario altamente interactivas.

Controles 3D, los objetos y las mallas se pueden importar de paquetes de diseño 3D más populares, con soporte para los formatos de archivo como Collada, OBJ y más.

Creación de la interfaz de usuario (FireMonkey Tutorial 3D)Crear una aplicación FireMonkey 3D

1. Seleccione Archivo> Nueva Aplicación> FireMonkey escritorio - Delphi> Desde el asistente FireMonkey aplicación de escritorio, elija 3D Aplicación FireMonkey y pulse el botón OK.

2. Aparecerá el Diseñador de formularios FireMonkey, mostrando una FMX.Forms.TForm3D .

Adición y ajuste de los componentes

1. Desde la paleta de herramientas, agregue los siguientes componentes FireMonkey 3D (introduciendo el nombre del componente en el campo de búsqueda y pulsando Return):

o A TLight o Dos TCube

2. En el Diseñador de formularios FireMonkey, ajustar la posición y el tamaño de los componentes FireMonkey 3D para satisfacer sus necesidades:

o Para mover un objeto, basta con arrastrar y soltar. o Para girar un componente 3D, utilice las tres asas azules que aparecen al hacer clic en el

componente. Cada mango gira el componente en el plano asociado en el espacio (es decir, X, Y, o Z vértice). Al hacer clic en un identificador, se convierte en rojo para indicar que es el mango activo. Nota: También puede utilizar las propiedades RotationAngle en el Inspector de Objetos (x, y, z).

o Para cambiar el tamaño de un componente, utilice el control para cambiar el tamaño, que es un pequeño cubo azul que se encuentra en una esquina de la pieza. El Resizer trabaja en una dimensión a la vez, el resizer es de color rojo en el lado del cubo que es la dimensión (activo) seleccionado Nota: También puede utilizar las propiedades del archivo. Inspector de objetos (por TCube , las propiedades relacionadas con el tamaño son la profundidad , anchura y altura ).

3. Para cambiar el material de los dos cubos:

1. Añadir una TTextureMaterialSource al formulario. En el Inspector de objetos , utilizando TTextureMaterialSource , ajuste la textura de la

propiedad haciendo clic en los puntos suspensivos [...]> Editar. El Bitmap Editor abre asistente. Haga clic en el botón Cargar del Editor de mapa de bits para cargar la textura deseada. Después de cargar la textura, haga clic en el botón Aceptar en el Editor de mapa de bits.

En el Inspector de objetos , con el primer cubo de enfoque, ajuste el MaterialSource propiedad haciendo clic en los puntos suspensivos [...]> y elegir el añadido TTextureMaterialSource de la lista.

TTextureMaterialSource sólo añade textura al cubo.

2. Añadir una TLightMaterialSource al formulario. Para especificar el color y la textura del material, utilice los TLightMaterialSource

propiedades. En el Inspector de objetos , utilizando TLightMaterialSource :

Ajuste la textura de la propiedad haciendo clic en los puntos suspensivos [...]> Editar. El Bitmap Editor abre asistente. Haga clic en el botón Cargar en el Editor de mapa de bits para cargar la textura deseada. Después de cargar la textura, haga clic en el botón Aceptar en el Editor de mapa de bits.

Ambiente , difuso , emisivo y especular se establece de forma predeterminada como en la imagen siguiente.

4. El resultado en tiempo de diseño se muestra en la siguiente imagen.

5. En este punto, puede hacer clic F9 para compilar, construir y ejecutar su primera aplicación FireMonkey 3D.

Creación de una interfaz 2D en una aplicación 3D (FireMonkey Tutorial 3D) Ir hasta Tutorial: Crear una aplicación FireMonkey 3D

Una aplicación de 3D no se puede utilizar directamente los componentes 2D como botones o listas. Si un componente 2D se arrastra y coloca en un recipiente de 3D, el componente no se rindió, sino que aparecerá en la vista de estructura como un control secundario. Sin embargo, hay una forma sencilla de hacer frente a este problema, mediante la creación de un puente entre las escenas 3D y 2D. FireMonkey proporciona la FMX.Layers3D.TLayer3D componente para este propósito.

Contenido [hide]

1 Adición y ajuste de una superficie 2D (TLayer3D) y un TButton 2 Agregar y Organizar Componentes 2D 3 Agregar eventos y controladores de eventos 4 Anterior 5 Vea también

Adición y ajuste de una superficie 2D (TLayer3D) y un TButton

1. Con el formulario en el tutorial anterior seleccionado en el Inspector de objetos o la vista de estructura , haga doble clic TLayer3D en la paleta de herramientas .

2. Ahora usted puede utilizar la TLayer3D componente como la superficie de los componentes FireMonkey 2D.

Con TLayer3D seleccionado en la vista de estructura o Inspector de Objetos , agregue un TButton . En la vista de estructura , asegúrese de que el botón es el hijo de la capa, no un hijo de la forma (si usted necesita para corregir la jerarquía, arrastre el TButton y colóquelo en la capa).

3. Para simular una superficie 2D, cambiar la Proyección tipo de la TLayer3D componente. En el Inspector de objetos , establezca la propiedad siguiente de la capa:

Proyección = pjScreen Una pantalla de proyección es un plano de la pantalla de proyección de píxel a píxel con un (invisible) de la cámara fija, y el plano frontal de la 3d-truncado es ahora un plano de la pantalla. Cada objeto es todavía 3D, pero puede ser manipulado como si 2D.

Su aplicación 3D debería ser similar a la siguiente figura:

4. Como se puede ver, el TLayer3D componente ha eclipsado la escena, por decir lo menos. En el inspector de objetos , con TLayer3D en el foco, establezca las siguientes propiedades:

o Alinear a alMostRight (o cualquier otra alineación que elija) o Ancho de 150 (o cualquier otro ancho que elija, especifique en píxeles)

Por ejemplo:

Adición y Arreglar Componentes 2D

Ahora elimine el botón añadido, añadir otros componentes a través de los cuales se rotan los objetos 3D en el formulario, mover o cambiar de tamaño.

1. Con TLayer3D en foco, añadir cinco TGroupBoxes . 1. Seleccione todos los cuadros de grupo en la vista de estructura presionando CTRL y haciendo clic en

el ratón, y en el inspector de objetos , establezca Alinear a alTop . 2. Seleccione los tres primeros cuadros de grupo desde la parte superior, y en el Inspector de

Objetos , ajuste de altura de 70 (o cualquier otro valor que se consideran para ajustarse mejor a la disposición final).

3. Seleccione cada TGroupBox y ajuste: El texto de anchura, altura, profundidad, Mover y Rotar El Nombre de WidthGroupBox, HeightGroupBox, DepthGroupBox, MoveGroupBox y

RotateGroupBox. Asegúrese de que el nombre y el texto están relacionados. El Habilitado propiedad en False.

4. Añadir pares de dos botones a los tres primeros TGroupBox . Un botón se utiliza para aumentar y uno, para disminuir la anchura, altura y profundidad.

Cambie los nombres de los pares del botón de la siguiente manera:

IncreaseWidthButton y DecreaseWidthButton IncreaseHeightButton y DecreaseHeightButton IncreaseDepthButton y DecreaseDepthButton

Cambiar texto en concordancia con el nombre del botón.

5. Añadir tres conjuntos de dos botones pares para los cuadros de grupo Move.

Cambie los nombres de los pares del botón de la siguiente manera:

MoveRightButton y MoveLeftButton MoveDownButton y MoveUpButton MoveBackButton y MoveFrontButton

Cambiar texto en concordancia con el nombre del botón.

6. Agregue tres TTrackBar componentes, utilizados para girar el objeto 3D en cada eje, a la caja de grupo Rotar.

7. Cambie los nombres de los TTrackBar a RotateXTrackBar, RotateYTrackBar y RotateZTrackBar. 8. En el Inspector de Objetos establecido, para cada barra de la pista, la mínima propiedad a -360 y el

máximo de la propiedad a 360 . 2. Añadir otra TLayer3D al formulario.

1. Con el nuevo TLayer3D en el foco, en el inspector de objetos , establezca la Proyección propiedad a pjScreen y el Align propiedad a alTop .

2. Añadir dos TGroupBox componentes al nuevo TLayer3D . 3. Seleccione cada TGroupBox y ajuste:

El texto del artículo a ser manipulado, y la Luz de encendido / apagado. El Nombre de ManipulateItemGroupBox y LightGroupBox. Asegúrese de que el nombre y

el texto están relacionados. 4. Añadir tres TRadioButtons a la ManipulateItemGroupBox, uno para cada objeto en 3D en la

escena. 5. Seleccione cada TRadioButton y ajuste:

El texto de Cube1, Cube2, y la Luz. El Nombre de Cube1RadioButton, Cube2RadioButton y LigthRadioButton. Asegúrese de

que el nombre y el texto están relacionados. 6. Añadir una TButton al LightGroupBox. 7. Seleccione el botón y ajuste:

El texto en OFF. El Nombre de LightOnOffButton.

El diseño final debe ser similar a esto:

Agregar eventos y controladores de eventos

Ahora tiene una simple escena 3D en el que puede asignar fácilmente los eventos a los objetos.

1. Para conseguir lo que es objeto 3D para ser manipulado, declare una variable de cadena global de mantener el nombre del objeto.

La barra de la pista ofrece la posibilidad de rotar el objeto en foco en el OnChange evento. Para evitar la actualización de los ángulos de giro para el objeto anterior, cuando se selecciona otro objeto, agregar una variable booleana RotateFlag. Si se establece en False, el código en el OnChange no ocurrirá controlador de eventos.

/ Declaración / Delphi var Form1: TForm1; ManipulatedItem: String; RotateFlag: boolean; / / C + + declaración TForm3D1 * Form3D1; System :: UnicodeString ManipulatedItem; bool RotateFlag;

2. Añadir OnChange controladores de eventos para los botones de opción haciendo doble clic en cada uno de ellos. A continuación se muestra el Delphi y C + + código de Cube1RadioButton. El código para Cube2RadioButton es el mismo, sólo que Cube2 se utiliza en lugar de Cube1.

/ / La aplicación Delphi para el evento OnChange botón de radio . procedimiento TForm1 Cube1RadioButtonChange (Sender: TObject); comenzar / / Permite a los cuadros de grupo para manipular Cube1 . WidthGroupBox Enabled: = True; . HeightGroupBox Enabled: = True; . DepthGroupBox Enabled: = True; . MoveGroupBox Enabled: = True; . RotateGroupBox Enabled: = True; / / Actualiza los valores de las barras de la pista para mostrar el valor actual de la Cube1.RotationAngle RotateFlag: = false; . RotateXTrackBar Valor:.. = Cube1 RotationAngle X; ... RotateYTrackBar Valor: = Cube1 RotationAngle Y; ... RotateZTrackBar Valor: = Cube1 RotationAngle Z; RotateFlag: = True; / / Guarda el nombre del objeto en 3D para ser manipulado ManipulatedItem:. = Cube1 Nombre; terminar; / / La aplicación de C + + para el botón de radio evento OnChange void __ fastcall TForm3D1 :: Cube1RadioButtonChange (TObject * Remitente) { / / Permite a los cuadros de grupo para manipular Cube1 WidthGroupBox -> Enabled = true; HeightGroupBox -> Enabled = true; DepthGroupBox -> Enabled = true;

MoveGroupBox -> Enabled = true; RotateGroupBox -> Enabled = true; / / Actualiza los valores de las barras de la pista para mostrar el valor actual de la Cube1.RotationAngle RotateFlag = false; RotateXTrackBar -> Valor = Cube1 -> RotationAngle -> X; RotateYTrackBar -> Valor = Cube1 -> RotationAngle -> Y; RotateZTrackBar -> Valor = Cube1 -> RotationAngle -> Z; RotateFlag = true; / / Guarda el nombre del objeto en 3D para ser manipulado ManipulatedItem = Cube1 -> Nombre;

}

Para LightRadioButton, el código no permite que todos los cuadros de grupo de manipulación. Mover y cambiar el tamaño de la TLight tiene ahora efectos visuales más la escena. La implementación de LightRadioButton es:

/ / La aplicación Delphi para el evento OnChange botón de radio . procedimiento TForm1 LightRadioButtonChange (Sender: TObject); comenzar / / Desactiva los cuadros de grupo que se mueven y redimensionan la luz . WidthGroupBox Enabled: = False; . HeightGroupBox Enabled: = False; . DepthGroupBox Enabled: = False; . MoveGroupBox Enabled: = False; / / La luz se manipula sólo si está en if (Light1. Enabled = True), entonces comenzar . RotateGroupBox Enabled: = True; / / Actualiza los valores de las barras de la pista para mostrar el valor actual de la Light1.RotationAngle RotateFlag: = false; . RotateXTrackBar Valor:.. = Light1 RotationAngle X; . RotateYTrackBar Valor:.. = Light1 RotationAngle Y; ... RotateZTrackBar Valor: = Light1 RotationAngle Z; RotateFlag: = True; / / Guarda el nombre del objeto en 3D para ser manipulado ManipulatedItem:. = Cube1 Nombre; final más . RotateGroupBox Enabled: = false; terminar; terminar; / / La aplicación de C + + para el botón de radio evento OnChange void __ fastcall TForm3D1 :: LightRadioButtonChange (TObject * Remitente) { / / Desactiva los cuadros de grupo que se mueven y redimensionan la luz WidthGroupBox -> Enabled = false; HeightGroupBox -> Enabled = false; DepthGroupBox -> Enabled = false; MoveGroupBox -> Enabled = false; / / La luz se manipula sólo si está en if (Light1 -> == Enabled true) { RotateGroupBox -> Enabled = true; / / Actualiza los valores de las barras de la pista para mostrar el valor actual de la Light1.RotationAngle RotateFlag = false; RotateXTrackBar -> Valor = Light1 -> RotationAngle -> X; RotateYTrackBar -> Valor = Light1 -> RotationAngle -> Y; RotateZTrackBar -> Valor = Light1 -> RotationAngle -> Z; RotateFlag = true; / / Guarda el nombre del objeto en 3D para ser manipulado ManipulatedItem = Cube1 -> Nombre; } más RotateGroupBox -> Enabled = false; }

3. Aplicación del botón LightOnOffButton:

. procedimiento TForm1 LightOnOffButtonClick (Sender: TObject); comenzar si Light1. Enabled = True entonces comenzar . Light1 Enabled: = False; . LightOnOffButton texto: = "ON";

si (LightRadioButton. IsChecked) a continuación . RotateGroupBox Enabled: = False; final más comenzar . Light1 Enabled: = True; . LightOnOffButton texto: = "OFF"; si (LightRadioButton. IsChecked) a continuación . RotateGroupBox Enabled: = True; terminar; terminar; void __ fastcall TForm3D1 :: LightOnOffButtonClick (TObject * Remitente) { if (Light1 -> == Enabled true) { Light1 -> Enabled = false; LightOnOffButton -> Text = "ON"; if (LightRadioButton -> IsChecked) RotateGroupBox -> Enabled = false; } más { Light1 -> Enabled = true; LightOnOffButton -> Text = "OFF"; if (LightRadioButton -> IsChecked) RotateGroupBox -> Enabled = true; } }

Diferencia entre la luz y apaga:

4. Cambiar el tamaño de los botones tiene una aplicación similar. A continuación se muestra la ejecución para aumentar y disminuir el ancho del objeto 3D.

/ / El aumento y la disminución de la anchura del objeto 3D . procedimiento TForm1 IncreaseWidthButtonClick (Sender: TObject); comenzar TControl3D ( FindComponent ( ManipulatedItem ) ) . Width : = TControl3D ( FindComponent ( ManipulatedItem ) ) . Width + 1 ; terminar;

. procedimiento TForm1 DecreaseWidthButtonClick (Sender: TObject); comenzar TControl3D ( FindComponent ( ManipulatedItem ) ) . Width : = TControl3D ( FindComponent ( ManipulatedItem ) ) . Width - 1 ; terminar; void __ fastcall TForm3D1 :: IncreaseWidthButtonClick (TObject * Remitente) { ( ( TControl3D * ) ( FindComponent ( ManipulatedItem ) ) ) - > Width = ( ( TControl3D * ) ( FindComponent ( ManipulatedItem ) ) ) - > Width + 1 ; } void __ fastcall TForm3D1 :: DecreaseWidthButtonClick (TObject * Remitente) {

( ( TControl3D * ) ( FindComponent ( ManipulatedItem ) ) ) - > Width = ( ( TControl3D * ) ( FindComponent ( ManipulatedItem ) ) ) - > Width - 1 ; }

5. Botones de movimiento tiene una aplicación similar. A continuación se muestra la aplicación para mover el objeto a la derecha y la izquierda en 3D.

. procedimiento TForm1 MoveRightButtonClick (Sender: TObject); comenzar TControl3D ( FindComponent ( ManipulatedItem ) ) . Position . X : = TControl3D ( FindComponent ( ManipulatedItem ) ) . Position . X + 1 ; terminar;

. procedimiento TForm1 MoveLeftButtonClick (Sender: TObject); comenzar TControl3D ( FindComponent ( ManipulatedItem ) ) . Position . X : = TControl3D ( FindComponent ( ManipulatedItem ) ) . Position . X - 1 ; terminar; void __ fastcall TForm3D1 :: MoveRightButtonClick (TObject * Remitente) { ( ( TControl3D * ) ( FindComponent ( ManipulatedItem ) ) ) - > Position - > X = ( ( TControl3D * ) ( FindComponent ( ManipulatedItem ) ) ) - > Position - > X + 1 ; } void __ fastcall TForm3D1 :: MoveLeftButtonClick (TObject * Remitente) { ( ( TControl3D * ) ( FindComponent ( ManipulatedItem ) ) ) - > Position - > X = ( ( TControl3D * ) ( FindComponent ( ManipulatedItem ) ) ) - > Position - > X - 1 ; }

6. Rotación de barras de la pista tiene una aplicación similar. A continuación se muestra la aplicación para hacer girar el objeto 3D alrededor del eje X.

. procedimiento TForm1 RotateXTrackBarChange (Sender: TObject); comenzar if (ManipulatedItem <>'') y (RotateFlag = True), entonces TControl3D (findComponent (ManipulatedItem)) RotationAngle X: = RotateXTrackBar Value;... terminar; void __ fastcall TForm3D1 :: RotateXTrackBarChange (TObject * Remitente) { if (ManipulatedItem! = "" && RotateFlag == true) ((TControl3D *) (findComponent (ManipulatedItem))) -> RotationAngle -> X = RotateXTrackBar -> Valor; }

7. Ejecute el proyecto presionando F9.

Compruebe Cube1Radiobutton. Al hacer clic en los botones de aumento / disminución, cambios en el tamaño del cubo.

Compruebe Cube1Radiobutton. Al hacer clic en los botones Izquierda / Derecha, la posición del cubo cambia.

Compruebe Cube1Radiobutton. Si se aumenta el valor de las barras de la pista, el cubo se gira hacia la derecha, y si el valor se reduce, el cubo se gira en sentido antihorario.

Compruebe LightRadiobutton. Si se aumenta el valor de las barras de la pista, la luz se gira y su efecto se puede ver más de Cube2.

3D Aplicación FireMonkeyArchivo> Nuevo> FireMonkey de aplicaciones de escritorio - Delphi> 3D Aplicación FireMonkey

Archivo> Nuevo> FireMonkey aplicación de escritorio - C + + Builder> 3D Aplicación FireMonkey

Crea el marco para una aplicación FireMonkey 3D y abre la FireMonkey Diseñador de formularios , que muestra la forma básica ( FMX.Forms3D.TForm3D ).

Para cada aplicación FireMonkey, el archivo de formulario tiene la extensión .fmx (en lugar de .dfm , la extensión utilizada para un archivo de formulario VCL, que es sólo para Windows).

Usos (Delphi)

Para una aplicación de Delphi 3D FireMonkey, el uses sección del .pas archivo contiene las siguientes unidades (incluyendo nombres de ámbito unidad):

Sistema. SysUtils, Sistema. Tipos, Sistema. UITypes, Sistema. Clases, Sistema. Variantes, FMX. Tipos, FMX, Controles FMX Forms3D, FMX Formularios, FMX Diálogos....;

Incluye (C + +)

. Para una aplicación C + + FireMonkey 3D, el h archivo incluye las siguientes unidades:

# Include <System.Classes.hpp> # Include <FMX.Controls.hpp> # Include <FMX.Forms3D.hpp>

. El cpp contiene:

# Include <fmx.h> # Pragma hdrstop

. El cpp proyecto contiene:

# Include <fmx.h> # Pragma hdrstop # Include <tchar.h>

HD FireMonkey AplicaciónArchivo> Nuevo> Otros> C + + Builder Proyectos> FireMonkey de aplicaciones de escritorio > HD FireMonkey Aplicación

Archivo> Nuevo> Otros> Proyectos Delphi> FireMonkey de aplicaciones de escritorio > HD FireMonkey Aplicación

Crea el marco para un HD FireMonkey aplicación y abre el Diseñador de formularios , que muestra la forma básica ( FMX.Forms.TForm ). Para cada aplicación FireMonkey, el archivo de formulario tiene la extensión .fmx (en lugar de .dfm , la extensión utilizada para sólo para Windows archivo de formulario VCL).

Puede establecer el plataforma de destino para una aplicación FireMonkey HD para ser cualquiera de los siguientes:

Windows de 32 bits Windows de 64 bits OS X

Usos (Delphi)

Para una aplicación de Delphi FireMonkey HD, el uses sección del .pas archivo contiene las siguientes unidades (incluyendo nombres de ámbito unidad):

.. Sistema SysUtils, Sistema de Tipos, Sistema UITypes, Sistema de Clases, Sistema Variantes, FMX Tipos, FMX Controles, FMX Formularios, FMX Diálogos.......;

Incluye (C + +)

Para una aplicación de C + + FireMonkey HD, la unidad .h archivo incluye lo siguiente:

# Ifndef UnitnameH # Define UnitnameH / / ------------------------------------------------ --------------------------- # Include <System.Classes.hpp> # Include <FMX.Controls.hpp> # Include <FMX.Forms.hpp>

El proyecto .cpp archivo contiene:

# Include <fmx.h> # Pragma hdrstop # Include <tchar.h>

La unidad .cpp archivo incluye lo siguiente:

# Include <fmx.h> # Pragma hdrstop # Include "Unitname.h"

Uso de imágenes y efectos de animaciónEl FireMonkey motor incorporado ImageFX proporciona fácil de usar la GPU de procesamiento de imágenes de sombreado con motor sin necesidad de programación compleja. El motor ImageFX se puede utilizar para la transformación de la imagen, efectos en tiempo real, efectos de interfaz de usuario, y más. Al igual que Photoshop y CoreImage, ImageFX admite varios filtros a la vez que aprovechan una tubería única instrucción GPU dinámica para un rendimiento casi en tiempo real con precisión de píxel.Todos los objetos FireMonkey HD y 3D pueden ser animados usando animación basada en la línea de tiempo para crear movimiento, transiciones, efectos. Puede conectar la animación para controles de usuario y métodos de entrada, como el ratón, el tacto y el movimiento de los controladores para las aplicaciones altamente interactivas, quioscos, y demostraciones.

El uso de efectos de imagen FireMonkeyFireMonkey ofrece muchos tipos diferentes de efectos integrados de imagen que modifican una imagen ya sea individualmente o en concierto con otros para lograr diferentes efectos visuales.

Como un efecto dominó se aplica a una imagen

En este tutorial, utilizará varios efectos de imagen básicos en una aplicación FireMonkey.

Paso 1: Aplicar un efecto a una foto En FireMonkey, aplicando un efecto de imagen a una imagen es un proceso sencillo. Basta con crear un componente que tiene una imagen y luego aplicar uno de los componentes de efecto de imagen.

1. Crear una nueva aplicación FireMonkey (Archivo> Nuevo> FireMonkey de aplicaciones de escritorio > HD FireMonkey Aplicación ).

2. Coloque un componente TImage en el formulario. Para ello, escriba "imagen" en el cuadro de búsqueda en la paleta de herramientas y haga doble clic en el componente TImage:

Selección de un componente TImage en la paleta de herramientas

La colocación de un componente TImage en el Diseñador de formularios

3. Se puede ver que el componente TImage no se coloca en el centro del Diseñador de formularios. Como se muestra en la imagen, es necesario hacer que el tamaño del área de imagen lo más grande posible. Para ello, seleccione el componente TImage en el Diseñador de formularios y, a continuación, cambie la propiedad Align para alClient en el inspector de objetos para que el tamaño del componente TImage ser el mismo que el área de cliente del formulario.

Cambio de la propiedad Align para alClient

4. Seleccione la imagen a la que desea aplicar el efecto de la imagen. El componente TImage tiene la imagen en su propiedad Bitmap. Seleccione la propiedad Bitmap en el Inspector de Objetos, y el uso de la ... menú Edición para seleccionar una imagen.

Selección de una imagen en un componente TImage

5. Ahora usted puede seleccionar una imagen Efecto de componentes. Vaya a la paleta de herramientas, tipo de "efecto" en el cuadro de búsqueda y seleccione TRippleEffect. En la paleta de herramientas se pueden encontrar muchos efectos disponibles. Usted puede leer una explicación detallada de estos efectos en nuestra referencia de la API ( FMX.Filter.Effects ).

Ahora el componente RippleEffect se visualiza en el panel de estructura.

Para aplicar un efecto, un componente de efecto tiene que ser definido como un niño de otro componente. En este caso, RippleEffect1 debe definirse como un hijo de Image1. Para ello, arrastre RippleEffect1 y soltarlo al componente Image1 sobre la Estructura Pane.

Hacer que el componente RippleEffect un niño del componente Image1

6. Ahora se puede ver que RippleEffect ya está en obras en el Diseñador de formularios.

La aplicación de un efecto dominó a un cuadro en el Diseñador de formularios

7. También puede cambiar cómo este efecto se aplica a la imagen cambiando algunas propiedades. Por ejemplo, el cambio de la propiedad de frecuencia a 20 cambia el efecto como se muestra en la siguiente imagen.

Paso 2: Aplicar un efecto de animación a una propiedad de un efecto de imagen Como se discutió en FireMonkey efectos de animación , cualquier propiedad numérica puede utilizar efectos de animación (cambiando el valor en el tiempo). En este paso, aplique uno de los típicos efectos de animación, TFloatAnimation, a esta aplicación de ejemplo.

1. Seleccione RippleEffect1 sobre la Estructura Pane. 2. Seleccione la propiedad Fase en el Inspector de Objetos, y seleccione Crear Nuevo TFloatAnimation en el

menú desplegable.

Asegúrese de que ahora FloatAnimation1 se define como un hijo de RippleEffect1.

3. Cambiar las propiedades de FloatAnimation1 de la siguiente manera:

Propiedad Valor Descripción

Duración 10 La cantidad de tiempo (en segundos) para animar desde el valor inicial hasta el valor de parada.

Activado Verdadero Inicia la animación durante la inicialización del tiempo de ejecución.Bucle Verdadero Repite la animación de forma indefinida.PropertyName Fase Especifica el nombre de la propiedad que desea animar.StopValue 20 Termina la animación de esta propiedad cuando se alcanza este valor.

4.5. Configuración de las propiedades de FloatAnimation1

6. Ejecutar la aplicación. Ahora usted puede ver cómo el efecto de onda progresa con el tiempo.

Usando FireMonkey efectos de animaciónFireMonkey ofrece muchos tipos diferentes de efectos integrados de animación que modifican el valor de la propiedad seleccionada en el tiempo.

Los ejemplos de los efectos de animación:

Tipo de Inmueble Clase de efectos de animación

Cualquier propiedad que es un entero. TIntAnimation

Cualquier propiedad que es un número real. TFloatAnimation

Ubicación de los componentes definidos por una propiedad TBounds. TRectAnimation

Cualquier cadena o propiedad de entero que contiene un color. TColorAnimation

Un gradiente (escriba TGradient) TGradientAnimation

Una imagen de mapa de bits TBitmapAnimation

En este tutorial, utilizará varios efectos de animación básicas en una aplicación FireMonkey.

Paso 1: El uso de TFloatAnimation cambiar un flotante Valor de la propiedad En FireMonkey, cualquier propiedad que utiliza números flotantes se puede modificar mediante efectos de animación a través TFloatingAnimation. Así que, vamos a cambiar algunos valores de uso de los efectos de animación.

1. Cree una nueva aplicación FireMonkey HD. (Archivo> Nuevo> FireMonkey aplicación de escritorio > HD FireMonkey Aplicación).

2. Coloque un componente TRectangle en el Diseñador de formularios. Para ello, escriba rec en el cuadro de búsqueda en la paleta de herramientas y haga doble clic en el componente TRectangle:

Selección de un componente TRectangle en la paleta de herramientas

Componente TRectangle en el Diseñador de formularios

3. Después de colocar un componente TRectangle en el Diseñador de formularios, verá varias propiedades que tienen un icono de la película ( ) En el Inspector de Objetos. El icono de la película indica que estas propiedades de los componentes pueden ser animados.

Las siguientes son las propiedades típicas (dependiendo del componente) que se pueden cambiar a través TFloatingAnimation:

o Altura o Position.x o Position.y o RotationAngle o RotationCenter.X o RotationCenter.Y o Scale.X o Scale.Y o StrokeThickness o XRadious o YRadious o Ancho

4. Para modificar el valor de una propiedad, haga clic en el menú desplegable de la propiedad RotationAngle y, a continuación, seleccione Crear nuevo TFloatAnimation.

5. Ahora se crea el nuevo componente TFloatAnimation. Usted verá que, en el panel Estructura, FloatAnimation1 se define como un hijo de Rectangle1.

Nota: Por favor tenga en cuenta que el efecto de los componentes de la animación de efecto se aplica al componente principal.

6. El inspector de objetos se muestran las propiedades para el componente FloatAnimation1. Cambie las siguientes propiedades que se describen en la tabla:

Propiedad Valor Descripción

Duración 5La cantidad de tiempo (en segundos) para animar desde el valor inicial hasta el valor de parada.

Activado Verdadero La animación empieza cuando se inicia la aplicación.

Bucle Verdadero Repite la animación de forma indefinida.

StopValue 360 Termina la animación de esta propiedad cuando se alcanza este valor.

7.

Propiedades en FloatAnimation1 8.9. Otra propiedad importante, que se define de forma automática, es nombreDePropiedad. En este caso, esta

propiedad se establece en RotationAngle, por lo que esta animación afecta al valor de la propiedad RotationAngle de su componente principal.

10.

11. Ejecutar la aplicación. Ahora el componente rectángulo gira en el formulario:

12. Puede animar propiedades numéricas utilizando los mismos pasos.

Paso 2: Cambiar el color mediante la adición TColorAnimation Como se mencionó al principio de este tutorial, FireMonkey tiene muchos efectos integrados de animación. A continuación, se le aplicará una animación de color para cambiar el color del rectángulo, además de la rotación se describe en el Paso 1.

1. Seleccione el componente TColorAnimation desde la paleta de herramientas. Para ello, escriba anim en el cuadro de búsqueda en la paleta de herramientas y, a continuación, haga doble clic en TColorAnimation:

Componente TColorAnimation está ahora en el panel Estructura.

2. TColorAnimation1 se define como un hijo de Form4 mientras FloatAnimation1 se define como un hijo de Rectangle1 (como se explica en el Paso 1). ColorAnimation 1 de arrastrar y soltar en Rectangle1. Ahora ColorAnimation1 se define como un hijo de Rectangle1, y por lo tanto afecta ColorAnimation1 Rectangle1:

3. El inspector de objetos se muestran las propiedades para el componente TColorAnimation1. Cambie las siguientes propiedades como se describe en la tabla.

Propiedad Valor Descripción

PropertyName Fill.color Nombre de la propiedad que desea animar.

Activado Verdadero La animación empieza cuando se inicia la aplicación.

Duración 3La cantidad de tiempo (en segundos) para animar desde el valor inicial hasta el valor de parada.

Bucle Verdadero Repite la animación de forma indefinida.

AutoReverse Verdadero Anima hacia atrás después de la animación hacia adelante.

StopValue Rojo Termina la animación de esta propiedad cuando se alcanza este valor.

4.

Propiedades en ColorAnimation1

5. Ejecutar la aplicación. Ahora el componente rectángulo gira sobre la forma y ha cambiado su color a rojo:

Paso 3: Cambio de la imagen mediante el uso de TBitmapAnimation El último paso en este tutorial utiliza una animación de mapa de bits con un componente de imagen.

1. Crear una nueva aplicación FireMonkey, como en el paso 1 de este tutorial.

2. Coloque un componente TImage (Image1) en el Diseñador de formularios.

3. Coloque un componente TBitmapAnimation en el Diseñador de formularios. Uso de la vista de estructura, ajuste este componente (BitmapAnimation1) como hijo de Image1:

4. Establezca las propiedades del BitmapAnimation1 en el Inspector de Objetos de la siguiente manera:

Propiedad Valor Descripción

PropertyName Bitmap Nombre de la propiedad que desea animar.

Activado Verdadero La animación empieza cuando se inicia la aplicación.

Duración 10La cantidad de tiempo (en segundos) para animar desde el valor inicial hasta el valor de parada.

Bucle Verdadero Repite la animación de forma indefinida.

AutoReverse Verdadero Anima hacia atrás después de la animación hacia adelante.

StartValue Inicia la animación de esta propiedad de esta imagen de mapa de bits.

StopValueTermina la animación de esta propiedad cuando llega esta imagen de mapa de bits.

5.6. Establezca las propiedades StartValue y EndValue. Estas propiedades tienen la fotografía como imagen

inicial y la imagen final. Haga clic en el menú Edición y, a continuación, seleccione sus imágenes favoritas utilizando el Editor de mapa de bits .

7. Ejecutar la aplicación. Ahora bien, estas dos imágenes son animados a través del tiempo:

FireMonkey efectos de animaciónAnimaciones modifican los valores de propiedad a través del tiempo. Ellos se pueden iniciar de forma automática o manual, ambas con un retardo opcional. Después de la animación ha seguido su curso durante el periodo de tiempo definido, se puede parar, empezar de nuevo, o hacer lo mismo pero a la inversa.

Contenido [hide]

1 Tipos de Animación 2 Creación de animaciones 3 Arranque y apagado

o 3.1 Animación disparadores 4 Inversión y Looping 5 Personalizar animación 6 Vea también

Tipos de Animación

Las subclases proporcionadas de TAnimation se dividen en tres categorías:

Las interpolaciones de un valor inicial hasta un valor final: o TIntAnimation cambia cualquier propiedad que es un entero. o TFloatAnimation cambia cualquier propiedad que es un número real, al igual que la posición (X, Y, y

Z deben hacerse por separado), la rotación y opacidad. o TRectAnimation cambia la ubicación de los cuatro bordes de una TBounds propiedad. o TColorAnimation cambia cualquier cadena o propiedad de entero que contiene un color,

incluyendo los de tipo TAlphaColor (que en realidad es un número cardinal), mediante la modificación de los valores de rojo, verde, azul, y alfa del color.

o TGradientAnimation cambia un gradiente (escriba TGradient ) mediante la modificación de los colores de cada punto que define el gradiente.

o TBitmapAnimation transiciones de una imagen de mapa de bits a partir a otro por el dibujo de la imagen final (tipo TBitmap ) con el aumento de la opacidad, haciendo que se desvanezca a la vista.

La interpolación a través de una serie de valores, no sólo dos: desde la primera a la segunda, desde la segunda a la tercera, y así sucesivamente:

o TFloatKeyAnimation transiciones a través de una lista de números. o TColorKeyAnimation transiciones a través de una lista de colores. o TPathAnimation modifica 2D de un objeto de posición para seguir una ruta , opcionalmente

girándola en el camino. Pasando a través de una lista sin interpolación:

o TBitmapListAnimation funciona como una presentación por tiempo, con todas las imágenes combinadas horizontalmente en un solo mapa de bits. Con una velocidad de cuadros rápida (de corta duración y / o muchas imágenes), se ve como una película.

Creación de animaciones

Animaciones atribuyen como hijos del objeto que se está animada, al igual que cualquier otro subcomponente. A continuación, la propiedad PropertyName se establece en una ruta de acceso de propiedad de puntos, tal como se utiliza con System.TypInfo funciones como GetPropInfo ; por ejemplo, "opacidad" y "position.y".

En el Inspector de Objetos, propiedades comúnmente animadas se indican con un icono de la tira de película. La elección de crear una animación en el menú desplegable del valor de la propiedad se establecerá automáticamente el PropertyName. Animación de objetos añadidos en la paleta de componentes deben establecer el PropertyName manualmente.

TFmxObject proporciona algunos métodos de conveniencia para crear numéricos y de colores animaciones a partir de código, con el PropertyName y terminando valor como los argumentos necesarios. Estas animaciones siempre comienzan de inmediato a partir del valor actual, no se permite looping, y se liberan cuando haya terminado. Las animaciones numéricos también pueden comenzar con un retraso o esperar en el hilo principal hasta que termine.

Inicio y detención

Si de una animación Habilitado indicador se establece en True en el Diseñador de formularios, automáticamente Iniciar después de la carga. Si se establece en True en el código también se iniciará la animación; Dándole el valor false se Pare ello. Por el contrario, llama Start y Stop establecerá Activado para igualar.

En TFloatAnimation, StartFromCurrent sobrescribirá automáticamente el StartValue con el valor actual de la propiedad cuando se inicia la animación (o bien llamando al inicio o si está activado). No hay ajuste de StartValue si StartFromCurrent es True punto. Todo esto es cierto para TIntAnimation también.

Nota: Esto es especialmente relevante cuando looping o reutilización de objetos de animación de forma manual. Si la ejecución anterior utiliza StartFromCurrent, y la próxima ejecución utiliza un StartValue, entonces StartFromCurrent debe establecerse en False.

Para detener la animación:

Ajuste de Pausa en True permitirá la animación para reanudar desde ese punto, por el establecimiento de nuevo en False.

Llamando Detener saltará al final de la animación. La propiedad se establece en el valor final (StopValue si Inverse es False, StartValue si ocurre lo contrario), y OnFinish incendios.

StopAtCurrent no establece la propiedad en el valor final, pero todavía dispara OnFinish.

Los disparadores de animación

Además de iniciar automáticamente con Habilitado y llamando de inicio y parada manual, las animaciones pueden ser provocados por los cambios de propiedad. Los desencadenantes no funcionan con todas las propiedades arbitraria, pero sólo con las propiedades particulares que se comprueban durante el procesamiento de eventos interno del componente. Todos los desencadenantes incorporados comprobar propiedades booleanas, y por convención los nombres de estas propiedades comienzan con "Is".

TControl y TControl3D proporcionan cuatro disparadores para cada control y la forma:

IsMouseOver IsDragOver IsFocused IsVisible

Otros desencadenantes integrados incluyen:

IsPressed ( TCustomButton , TRadioButton , TCheckBox , TThumb ) IsChecked ( TRadioButton , TCheckBox , TMenuItem , IsChecked ) IsSelected ( TMenuItem , TTabItem , TListBoxItem , TTreeViewItem ) IsExpanded ( TExpander , TTreeView )

Nota: Se proporciona un conjunto ligeramente diferente de disparadores para otros efectos de imagen no de animación.

Las animaciones pueden ser configurado para iniciarse cuando alguna de estas propiedades cambian como resultado de código o la acción del usuario. Cuando la condición de disparo ya no se sostiene, la animación se detendrá. Condiciones de activación se limitan a comprobaciones de igualdad, y si el disparador contiene más de una condición, todos ellos deben evaluarse como true para el gatillo para disparar. Un disparador se expresa como una cadena que contiene una o más condiciones de disparo, separados por punto y coma. Cada condición de activación consiste en el nombre de la propiedad, un signo igual y el valor de disparo. Todos los desencadenantes incorporados son boolean, por lo que su valor debe ser "verdadero" o "falso". Por ejemplo:

IsMouseOver = true; IsPressed = false

Condiciones de disparo se guardan en dos propiedades, disparador y TriggerInverse. Como su nombre indica, el primero será simplemente Inicie la animación definida, mientras que el segundo será establecer el indicador inverso de la animación primero. Debido a la forma de animaciones funcionan a la inversa, y la forma en que las animaciones serán inmediatamente "parar en el acabado" cuando la condición ya no se sostiene, en lugar de una sola animación con condiciones de activación opuestas, a veces se requieren dos animaciones separadas definidas como opuestos, cada uno con uno de los detonantes opuestos.

Inversión y Looping

Inverse trabaja por "horario de marcha atrás", sino que no baje la marcha y paro valores. Por lo tanto, con tanto Inverse y StartFromCurrent Es cierto que el establecimiento se pondrá en primera saltar a StopValue, y luego animar de nuevo al valor en el momento de la animación comenzó: en efecto, "parar en la corriente" (como el StartAtCurrent boolean, no el procedimiento StopAtCurrent) .

Una animación puede Loop en repetidas ocasiones, ya sea en la misma dirección una y otra o lado a otro como un péndulo con AutoReverse .