FireMonkey Info Blog

Video: Rotate an Image in a Delphi iOS App with FireMonkey

2013-05-01T15:54:00.002-07:00

This video demonstrates a code snippet for rotating an image on an iOS device.

Get the source code for this app and see more code snippets and videos at http://embt.co/iOSsnippets

Video: What's new in Delphi XE4 and RAD Studio XE4

2013-04-30T18:03:00.002-07:00

See what's new in FireMonkey FM3 for iOS development in this video about Delphi XE4 and RAD Studio XE4.

Embarcadero® RAD Studio XE4 is the multi-device, true native app development suite for companies that need to create apps for PCs, tablets, and smartphones, and get them to markets and users fast. Manage one codebase, one team, and one schedule to get apps that deliver great performance, tighter security, and a better user experience.

Learn more at: http://embt.co/FM-new

FireMonkey iOS Tutorial: Set Up Your Development Environment on the Mac

2013-04-27T12:26:00.003-07:00

See more tutorials on the Embarcadero Documentation Wiki

A FireMonkey application destined for the iOS target platform is tested initially on the iOS Simulator available on the Mac. The second half of the testing process uses the iOS Device target platform and requires a test iOS device connected to the Mac.

The first half of this tutorial describes the steps that you need to perform in order to run your iOS application on the iOS Simulator on the Mac.
The second half of this tutorial describes additional steps required in order to run your iOS Application on your iOS Device.

Requirements on the Mac

OS X 10.7 Lion or 10.8 Mountain Lion
(Neither OS is supported on legacy PowerPC- and 680x0-based Macintosh systems. All Macs since 2007 are Intel-based; all since 2008 are 64-bit, which Lion requires.)
iOS 5.1 and above
Latest version of Xcode and the iOS SDK installed, and the Xcode command line tools installed
- Requires membership in one of several Apple Developer Programs, which are described in this topic underSign up for a Developer account.
An iOS device connected to the Mac by USB port (required for testing or running your iOS app on the device)

Steps to Configure Your Mac to Run Your iOS Application on the iOS Simulator

To deploy an iOS application to the iOS Simulator on the Mac, you need to install the following tools on your Mac:

Platform Assistant (PAServer)
For debugging purposes, RAD Studio uses the Platform Assistant, an application that you must install and run on the Mac.
Xcode
Xcode is the development and debug environment on the Mac, and provides the required development files for Mac OS X and iOS applications.

Step 1: Install the Platform Assistant

As discussed, the Platform Assistant must be running on the Mac when you deploy an iOS app from your PC to either the iOS simulator or an iOS device.

The Mac OS X installer for the Platform Assistant is named RADPAServerXE4.pkg, and it is available in two places:

In the PAServer folder inside the RAD Studio installation directory.
For example, C:\Program Files\Embarcadero\RAD Studio\n.n\PAServer\RADPAServerXE4.pkg.
On the Web, for download to the Mac:
http://installers.codegear.com/release/radstudio/11.0/PAServer/RADPAServerXE4.pkg

For further details, see Installing the Platform Assistant on a Mac.

Step 2: Run the Platform Assistant

In the Finder on the Mac, activate the .app file (RAD PAServer XE4.app) as follows:

Navigate to the top-level Applications folder.
Double-click RAD PAServer XE4.app to start the Platform Assistant:
The Terminal window appears, displaying the Platform Assistant banner and the password prompt:

Connection Profile password <press Enter for no password>

Either press Return, or enter a password for PAServer and then press Return.
Next you are prompted to enter your Mac user password to allow the Platform Assistant to debug (take control of another process) your application. Enter your password, and select Take Control:

For more details about running the Platform Assistant, see Running the Platform Assistant on a Mac.

Step 3: Install Xcode on the Mac

Xcode is the development and debug environment on the Mac, and provides the required development files for Mac OS X and iOS applications.

You can install Xcode from any of the following sources:

On your "Mac OS X Install" DVD, under Optional Installs, double-click Xcode.mpkg to install Xcode on your system.
At the Mac App Store, download Xcode for free.
As a registered Apple Developer, you can download the latest version of Xcode as a bundle (.dmg). To register and then download Xcode:
1. Register (free of charge) as an Apple Developer at http://developer.apple.com/programs/register/.
2. Download Xcode as a bundle from https://developer.apple.com/downloads.

Next Steps

You have configured your Mac to run an iOS Application on the iOS Simulator.

To run an iOS Application now on the iOS Simulator, see iOS Tutorial: Set Up Your Development Environment on Windows PC to complete the configuration of your RAD Studio IDE.

To run your iOS Application on your iOS Device, please use the following steps on this page to complete the configuration of your Mac. Note that you can perform these steps after you test an application on the iOS Simulator.

Additional Steps to Configure Your Mac to Run Your iOS Application on Your iOS Device

The following additional steps enable you to run your iOS Application on your iOS Device.

Step 1: Install the Xcode Command Line Tools on a Mac

To install the necessary Xcode tools using Xcode on the Mac:

Start Xcode on the Mac.
Choose Preferences from the Xcode menu.
In the General panel, click Downloads.
On the Downloads window, choose the Components tab.
Click the Install button next to Command Line Tools.
You are asked for your Apple Developer login during the install process.

For more details, see Installing the Xcode Command Line Tools on a Mac.

Step 2: Sign Up for a Developer Account

Membership in one of the iOS developer programs is a requirement for building, running, debugging, and deploying applications for iOS.

You can join a developer program in either of the following ways:

As an individual developer.
As a member (or leader) of a team in an enterprise (business) program or university program.

For more details, see Joining an iOS Developer Program.

Step 3: Request, Download and Install Your Development Certificate

Applications that are deployed on the device (or on the iOS Simulator) need to be cryptographically signed before they run. The Development certificate contains information that is needed for signing the applications. Each individual (an individual developer or a team member) must have a unique development certificate, which can be used for multiple applications.

For development teams, development certificates must be requested by each team member, and these requests must be approved by a team admin.

Request, Download and Install Your Certificate

In the Keychain Access application on your Mac, select from the Keychain Access menu: Certificate Assistant > Request a Certificate From a Certificate Authority:
Save the certificate request as a file, and then send it to your Certificate Authority by uploading it in the Apple iOS provisioning portal.
- If you are a development team member for a corporate/organization program, your team administrator needs to approve your request. After your team administrator approves it, you can download the certificate.
- If you are an individual developer, you should see a download option for your certificate shortly after you request it. See Apple documentation at: Creating signing certificates for details.
Go to iOS Provisioning Portal. You can download the Development certificate after the status changes from Submitted to Issued:
Launch the Development Certificate by double-clicking it. It automatically loads in the Keychain Access application.

Step 4: Register Your Device for Deployment

Before a device can run user applications, it must be registered in the Apple Provisioning Portal. Devices are registered by their Unique Device ID (UDID). The UDID can be determined using Xcode, as follows:

Make sure your iOS device is connected to your Mac machine.
Open Xcode and go to Organizer (Window > Organizer).
In the Devices tab, click on your device.
Next to the Identifier label is a string of characters:
The Identifier string represents your device's UDID.
- If you are an individual developer, register your device by adding the UDID in the Devices tab of the Apple Provisioning Portal.
- If you are part of a company/organization, ask your team admin to register your device.

Step 5: Create and Install a Provisioning Profile

Provisioning profiles are used for linking a developer and devices to a development team. This provisioning profile is required for running applications on an iOS device.

If you are an individual developer, you must create a provisioning profile. For specific information, see: Creating and Downloading a Distribution Provisioning Profile.
If you are part of a company/organization, your team admins must create a provisioning profile that you can use.

After your provisioning profile is created, you must install it into Xcode, as follows:

Open Xcode on the Mac and go to the Organizer (Window > Organizer).
In the Library section, select Provisioning Profiles and click Refresh.
Xcode asks you to sign in with your Apple ID. Enter your credentials and select Log in.
The provisioning profiles available to you are installed into your Xcode:
Select a valid iOS provisioning profile and drag-and-drop it into the Provisioning profiles of your test device.

You have configured your Mac to run your iOS Application on your iOS Device.

To run your iOS Application, please see iOS Tutorial: Set Up Your Development Environment on Windows PC and complete the configuration of your RAD Studio IDE. (If you have configured your PC as part of running your application on the iOS Simulator, you can skip this step.)

Introducing FireMonkey FM3

2013-04-27T12:21:00.000-07:00

FireMonkey FM³

The multi-device, true native app platform

FireMonkey FM³ is the next generation platform for building multi-device, true native apps for iOS, Windows and Mac, using a single codebase. Deliver apps, including client/server and multi-tier, up to 5x faster and more cost effectively than with OS vendor tools.

Click here to learn more about FireMonkey FM3

Create Windows and Mac OS X applications using a single codebase with FireMonkey

2012-10-06T13:55:00.000-07:00

Create Windows and Mac OS X applications using a single codebase

Not only can you get your app to Windows 8 faster, but you can deploy it to Mac OS X using the same codebase. Per AppleInsider, Mac OS X business sales grew a massive 51% at the end of 2011. You'll love how quickly you'll get your Delphi and C++ applications on Mac OS X with FireMonkey FM².

Learn more.

FireMonkey ISV to Enterprise on Multiple Platforms

2012-10-04T06:00:00.000-07:00

ISV to Enterprise on multiple platforms

FireMonkey FM²'s flexible built-in database, cloud and middleware connectivity make it easy to build scalable enterprise-class applications or packaged desktop software for Windows and Mac clients. Integrated support for all popular RDBMS servers and n-tier middleware is available in Delphi, C++Builder and RAD Studio Enterprise editions. Industrial strength embedded database support for Windows and Mac enable you to easily build packaged "turn-key" applications that ship with lightweight to enterprise-class embedded databases. Integrated cloud connectivity makes it easy to leverage Amazon and Azure cloud services in your applications.

Learn more.

FireMonkey Case Study - Erply

2012-10-02T11:00:00.000-07:00

Erply

Erply is a provider of Software as a Service for the retail industry. It helps manage all data across stores, web shops and warehouses with an easy to use POS e-commerce solution. In 2010 Erply was selected by Wall Street Journal as one of the top ten European Startups and TechCrunch called it the "Skype of business software".

Learn More

Check it out

Embarcadero Developer Tools Pave the Way to Windows 8

2012-10-01T10:57:00.000-07:00

Embarcadero Developer Tools Pave the Way to Windows 8

Software Vendors, Such as ERPLY, Move Early for Competitive Advantage

SAN FRANCISCO — Oct. 1, 2012 — Embarcadero Technologies' customers worldwide are gaining a competitive advantage by leveraging the latest version of RAD Studio to quickly migrate existing applications to the Windows 8 user experience. ERPLY, a RAD Studio customer and a software vendor with offices in New York, London and Tallinn, provides Software as a Service for commercial retail inventory and e-commerce, handling data across physical shops, online stores and warehouses.

"We see a clear competitive advantage to early implementation of the Windows 8 user experience," said Kris Hiiemaa, chief executive officer of ERPLY. "We have already migrated our Embarcadero Delphi-based point-of-sale application to Windows 8. We are now using the newest Embarcadero release and are excited with the roadmap to iOS/Android."

Windows 8 provides a very distinctive user interface with support for touch, gestures, and live tiles across desktops, tablets and mobile devices. Thousands of apps are already available, and as Windows 8 achieves its official GA, expected October 26th, Windows 8 adoption will quickly increase as it will become the primary operating system installed on new PCs beginning this fall.

The new Embarcadero development products RAD Studio XE3, Delphi XE3 and C++Builder XE3, released in September, include Metropolis, the fastest path to the Windows 8 user experience. With Metropolis, the Windows 8 user experience does not require rewriting or developing new applications in Windows RT. Metropolis applications also have the distinct advantage of supporting the Windows 8 style across multiple Windows versions enabling developers to cover the widest population of PCs with the new Windows UI style. Additional benefits include:

Existing Windows desktop apps can be quickly updated to the Windows 8 user experience
New Windows 8 apps are rapidly and visually developed in C++ or Delphi with the new Windows 8 Metropolis UI and integrated touch support
Software developers can deliver a single application with Windows 8 style that runs across multiple versions of Windows including Windows 8, Windows 7, Windows Vista, and Windows XP
Developers starting with Metropolis today can have new and existing applications ready for the Windows 8 fall launch kicking off October 26th

"Windows 8 is a major release with significant backing by Microsoft," said Michael Swindell, senior vice president of marketing and product management at Embarcadero. "Though all major Windows upgrades have an adoption curve, software purchasing decisions in the $160b packaged software market are immediately influenced by and biased toward support for the latest Windows versions. Software vendors that support Windows 8 and the new Windows UI style early will benefit from the market momentum and will enjoy an early mover competitive advantage. Embarcadero developer tools make Windows 8 a fast, easy and low-risk move."

For more information on Embarcadero development tools, see http://www.embarcadero.com/products/rad-studio.

About Embarcadero Technologies

Embarcadero Technologies, Inc. is a leading provider of award-winning tools for application developers and database professionals so they can design systems right, build them faster and run them better, regardless of their platform or programming language. Ninety of the Fortune 100 and an active community of more than three million users worldwide rely on Embarcadero products to increase productivity, reduce costs, simplify change management and compliance, and accelerate innovation. Founded in 1993, Embarcadero is headquartered in San Francisco, with offices located around the world.www.embarcadero.com.

Press Contact:

Kristina Lanpheir
Kulesa Faul for Embarcadero Technologies
650-340-1992
Kristina@kulesafaul.com

Develop once with FireMonkey FM2 - Compile to Windows, Compile to Mac

2012-10-01T10:00:00.000-07:00

Fastest path to Windows 8 and Mac OS X Mountain Lion

With FireMonkey FM²you can now quickly give your applications the Windows 8 UI style and user experience yet still deploy to older Windows versions and Retina ready Mac OS X with native UI fidelity. Your applications will run great on Windows 8 PCs and x86 based tablets including Microsoft's Surface Pro and you can take advantage of Windows 8 capabilities such as gestures, live tile support, full screen behavior, sensor components and deploying natively to Mac OS X with a native user experience.

Learn more about developing applications for Windows 8 with FireMonkey FM2 >

Create applications for multiple platforms from a single codebase with FireMonkey FM2

2012-09-30T09:00:00.000-07:00

Create applications for multiple platforms that standout from the crowd

Increasingly enterprises and consumers alike make application purchasing decisions based on support for both Windows and Mac. Additionally, end users are drawn to visually engaging user experiences. With FireMonkey FM²you can create native or custom user experiences that provide a distinct competitive advantage in the market. Support for both Windows and Mac gives you a wider addressable market and a competitive edge. You'll get pixel perfect user interfaces with beautifully designed styles, built-in access to common gestures with multi-touch support and GPU-powered vector based HD UI and graphics with fully programmable animations and effects and more, so your applications can stand out from the crowd.

Learn more about creating visually stunning applications with FireMonkey FM2

Introducing FireMonkey FM2

2012-09-29T08:30:00.000-07:00

FireMonkey FM²

The growing mix of operating systems and form factors in today's enterprise and consumer markets presents an unprecedented opportunity for developers who are able to deliver their application to multiple platforms. The problem facing developers is the time and resources needed to deliver rich, modern applications with native UX fidelity and performance across different operating systems and versions. Enter FireMonkey FM²- the business application platform for building visually stunning enterprise class and ISV packaged applications for Windows 8 and Mac OS X Mountain Lion using a single codebase.

Learn more about FireMonkey at http://www.embarcadero.com/firemonkey

What is FireMonkey FM2?

2012-09-28T13:44:00.000-07:00

FireMonkey in Delphi XE3, C++Builder XE3 and RAD Studio XE3 has a new name - FireMonkey FM².

FM2 is an abbreviation for FireMonkey 2.0 because it's the 2nd major version of FireMonkey.

FireMonkey FM2 also has a new logo.

Video: Migrating a FireMonkey Application to Windows 8 Style Metropolis UI

2012-09-20T10:39:00.001-07:00

In this video you will see how easy it is to take an existing application and convert it to the Windows 8 style through the Metropolis UI feature set of RAD Studio, Delphi and C++Builder. Learn more about RAD Studio or download a free RAD Studio trial to try it for yourself.

Delphi Contest: Absolutely Insane Firemonkey Demo

2012-07-16T09:57:00.001-07:00

Check out this FireMonkey application development contest on the Helpinator blog.

Delphi Contest: Absolutely Insane Firemonkey Demo

Free Mida to FireMonkey Migration Tool

2012-07-12T11:28:00.001-07:00

Register for this webinar and you can download the Mida converter tool for Delphi XE2, C++Builder XE2 and RAD Studio XE2 free!

Custom FireMonkey "TSimpleTriangle" component - Blog Post Share

2012-06-27T13:28:00.000-07:00

Custom FireMonkey "TSimpleTriangle" component

Have you ever written a component in Delphi? Reusable components are the corner-stone of rapid application development and important part of Delphi success on the market. Being able to manipulate an instance of a class at design-time is where Delphi shines!

In his post, Pawel Glowacki describes step-by-step the process of creating a custom FireMonkey "TSimpleTriangle" component for displaying a triangle on a FireMonkey HD form.

Read the blog post at: http://blogs.embarcadero.com/pawelglowacki/2012/06/26/39692/

Blog share: Getting to grips with using FireMonkey Grids

2012-06-26T13:26:00.000-07:00

Check out this blog post from Stephen Ball:

Getting to grips with using FireMonkey Grids

It describes some of the differences between VCL and FireMonkey grids for Delphi and C++Builder users and includes a downloadable FireMonkey grid code sample example.

See the blog post at http://blogs.embarcadero.com/stephenball/2012/05/29/getting-to-grips-with-using-firemonkey-grids/

C++Builder with FireMonkey in The Code Project Members's Choice Awards

2012-06-20T14:46:00.000-07:00

Congratulations to Embarcadero C++Builder with FireMonkey for receiving honorable mention recognition in the 2012 Code Project Member's Choice Awards.

See the press release: http://www.pressreleasepoint.com/code-project%C2%AE-announces-fourth-annual-members-choice-award-winners

Embarcadero C++Builder® XE2, now with FireMonkey™, is the only true visual C++ development environment - designed for ultra-fast, component-based creation of highly-maintainable, visually stunning GUI applications for Windows and Mac OS X. C++Builder's fully visual two-way RAD IDE and thousands of available components speed and simplify building visually-rich and data-intensive end-user applications.

Gartner: Macs Invading the Enterprise

2012-06-07T10:20:00.000-07:00

Interesting article in Macworld and Network World on how Macs are invading the enterprise.

This shows the great opportunity for Windows software developers to create Mac apps with the FireMonkey application platform in Delphi, C++Builder and Embarcadero RAD Studio.

Here's an excerpt:

The enterprise is still a Windows PC-dominated universe, he said. But Windows is not only being challenged by newer tablet technologies, a subtle shift is also happening that sees users demanding Macs. IT managers can no longer turn that request down so easily—and probably shouldn't anyway, he said.

"[The desktop] is still 90-something percent Windows," said Silver, adding that "thin clients will have 4 percent or so by the end of the year." At most, there might be a 5 percent installed base of Macs, which IT managers traditionally regarded as an additional management burden over the Windows PCs they must carefully tend for updates and patch management.

But as the consumerization of IT has its impact, and as more companies find themselves not automatically saying "no" to new devices—especially when the company sales stars or the young new hires demand them as part of the job—the IT department can no longer wish the Mac away. A Gartner survey found 60 percent of enterprises still "limit" Macs, but more and more are "embracing" them. And 64 percent said they will likely allow more Macs into their businesses over the next few years.

Read the full article at: http://www.macworld.com/article/1167122/gartner_macs_invading_the_enterprise.html

Visual C++ to Mac using FireMonkey and C++Builder

2012-06-04T15:16:00.001-07:00

Check out this new video from Embarcadero on Visual C++ to Mac using C++Builder

Learn how you can take your existing C++ code from other development environments such as Visual Studio and use it in projects and applications that run natively on both Windows and Mac using the FireMonkey application framework.

Learn more at: http://embt.co/VisualCtoMac

Great deal on FireMonkey through June 29, 2012

2012-06-01T12:00:00.000-07:00

If you're looking for a great deal on FireMonkey, Embarcadero has a special offer running June 1 through June 29, 2012.

Buy or upgrade to Delphi XE2 or C++Builder XE2 and you get RAD Studio XE2 free!

With RAD Studio XE2, you get:

FireMonkey in Delphi XE2 to target Windows, Mac and iOS with the Object Pascal programming language
FireMonkey in C++Builder XE2 to target Windows and Mac with the C++ language

You also get two other IDEs - RadPHP for web and mobile development and Embarcadero Prism for .NET development and early support for Windows 8 Metro development.

You can learn more about this special offer on the Embarcadero web site.

How do I use the FireMonkey TBitmap StartLine Property in C++?

2012-05-28T12:45:00.000-07:00

FMXTBitmapStartLine (C++)

Language:

Versions:

Description

This example shows how to use the TBitmap.StartLine property. This example rotates the RGB channel color of every pixel of an image.

To build and test this example, create a FireMonkey HD Application - C++, then add the next objects to the form:

A TImage to display the initial TBitmap.
A TImage to display the result.
Two TLabel, one for each TImage.
A TButton to draw on the initial image.
A TOpenDialog and a TButton to load the image to be customized.

Add the following code to the OnClick event handlers of the load button.

Code

void __fastcall TForm1::Button2Click(TObject *Sender) {
 if (OpenDialog1->Execute()) {
  Image1->Bitmap->LoadFromFile(OpenDialog1->FileName);
 }
}

Add the following code to the OnClick event handlers of the other button.

Code

void __fastcall TForm1::Button1Click(TObject *Sender) {
 TBitmap *MyBitmap = new TBitmap(0, 0);
 int I;
 Byte T;
 PAlphaColorRecArray PixelRecs;
 try {
  if (Image1->Bitmap->IsEmpty()) {
   // Display a message when there is no image loaded
   MessageDlg("There is no image to customize:",
    TMsgDlgType::mtWarning,
   TMsgDlgButtons() << TMsgDlgBtn::mbOK, 0);
  }
  else {
   // A copy of the initial bitmap
   MyBitmap->Assign(Image1->Bitmap);
   // Cast from 32-bit colors to color record
   PixelRecs = PAlphaColorRecArray(MyBitmap->StartLine);
   // Rotate RGB of every pixel
   for (I = 0; I < MyBitmap->Width * MyBitmap->Height - 1; I++) {
    T = (*PixelRecs)[I].R; // temp
    (*PixelRecs)[I].R = (*PixelRecs)[I].G;
    (*PixelRecs)[I].G = (*PixelRecs)[I].B;
    (*PixelRecs)[I].B = T;
   }
 
   // Display the result
   Image2->Bitmap = MyBitmap;
 
  }
 }
 __finally {
  delete MyBitmap;
 }
}

The result should look like in the following image:

Uses

FMX.Types.TBitmap.StartLine ( fr | de | ja )

FMX.Types.PAlphaColorRecArray ( fr | de | ja )

FMX.Objects.TImage.Bitmap ( fr | de | ja )

New FireMonkey Grid beta available from Arcana

2012-05-26T02:00:00.000-07:00

Arcana / Sivv recently published a blog post about a beta of a new FireMonkey grid related to their Apesuite FireMonkey component set. Check out the blog post here: http://arcana.sivv.com/blog/2012/5/23/apesuite-progress-and-new-firemonkey-grid-demo.html

How do I use FireMonkey SaveCanvas and RestoreCanvas Functions with C++?

2012-05-25T12:53:00.000-07:00

FMXTCanvasSaveCanvas (C++)

Language:

Versions:

Description

This example shows how to use the SaveCanvas and RestoreCanvas functions and their results. Is also shows how to dynamically customize the drawing stroke and fill properties of the TCanvas.

To build and test this example, create a FireMonkey HD Application - C++ and add the following controls on the form:

A TImage.
Two TButton objects (a Save State button and a Restore State button) and a TMemo object to display the saved state.
A TColorComboBox object to set and display the current Stroke color.
A TColorComboBox object to set and display the current Fill color.
A TNumberBox to set and display the current StrokeThickness property value.
A TNumberBox to set and display the current Font size.
Three TComboBox objects to set and display the current StrokeCap, StrokeDah, and StrokeJoin properties.
Two TButton objects for drawing and filling an ellipse and a rectangle.
A TButton and a TEdit to set and display a text.
A TButton to clear and reset the TCanvas to the initial state.

The set of TColorComboBox, TNumberBox, and TComboBox objects display the current state of the drawing and filling TCanvasproperties. When the selected values change, the TCanvas properties are updated.

This example does the following:

Draws an ellipse, a rectangle, or displays a text with the current draw and fill properties.
Saves the state of the canvas at a moment and restores it after.

The drawing is made on the canvas of the bitmap. The bitmap is displayed on the TImage.

In the next sample image, the ellipse was drawn with the state displayed in the memo, and the rectangle was drawn with the state displayed by the set of combo boxes.

Code

Add as global variables two pointers, SaveState and InitialState, to keep the initial state of the canvas and the state saved when the SaveState button is clicked.

TForm1 *Form1;
TCanvasSaveState *SaveState, *InitialState;

Add a new procedure to the form class, named UpdateStateComboBox (do not forget to add it on the header as well), to update the set of combo boxes. This method is called when the form is created, the canvas is cleared, or a state is restored, so the combo boxes set show the current draw and fill properties.

void __fastcall TForm1::UpdateStateComboBox() {
 // updates the combo boxes with the current state of the canvas
 StrokeColorComboBox->Color = MainImage->Bitmap->Canvas->Stroke->Color;
 ThicknessNumberBox1->Value = MainImage->Bitmap->Canvas->StrokeThickness;
 StrokeCapComboBox->ItemIndex = StrokeCapComboBox->ListBox->Items->IndexOf
  (GetEnumName(__delphirtti(TStrokeCap),
  (int)(MainImage->Bitmap->Canvas->StrokeCap)));
 StrokeDashComboBox->ItemIndex = StrokeDashComboBox->ListBox->Items->IndexOf
  (GetEnumName(__delphirtti(TStrokeDash),
  (int)(MainImage->Bitmap->Canvas->StrokeDash)));
 StrokeJoinComboBox->ItemIndex = StrokeJoinComboBox->ListBox->Items->IndexOf
  (GetEnumName(__delphirtti(TStrokeJoin),
  (int)(MainImage->Bitmap->Canvas->StrokeJoin)));
 FillColorColorComboBox->Color = MainImage->Bitmap->Canvas->Fill->Color;
 TextSizeNumberBox->Value = MainImage->Bitmap->Canvas->Font->Size;
}

Add the following code to the OnCreate event handler of the form.

void __fastcall TForm1::FormCreate(TObject *Sender) {
 // initializes the initial bitmap
 MainImage->Bitmap = new TBitmap(MainImage->Width, MainImage->Height);
 // updates the combo boxes values
 UpdateStateComboBox();
 // saves the initial state of the canvas to be customized
 InitialState = MainImage->Bitmap->Canvas->SaveState();
}

Add the following lines of code to the OnClick event handlers of SaveCanvas and RestoreCanvas buttons:

void __fastcall TForm1::SaveButtonClick(TObject *Sender) {
 StateMemo->Lines->Clear();
 // saves the current state and display the current properties on the StateMemo
 SaveState = MainImage->Bitmap->Canvas->SaveState();
 RestoreButton->Enabled = true;
 // displays the saved properties on the StateMemo
 StateMemo->Lines->Add("Stroke Color: " +
  StrokeColorComboBox->ListBox->Selected->Text);
 StateMemo->Lines->Add("StrokeThickness: " + ThicknessNumberBox1->Text);
 StateMemo->Lines->Add("StrokeCap: " +
  StrokeCapComboBox->ListBox->Selected->Text);
 StateMemo->Lines->Add("StrokeDash: " +
  StrokeDashComboBox->ListBox->Selected->Text);
 StateMemo->Lines->Add("StrokeJoin: " +
  StrokeJoinComboBox->ListBox->Selected->Text);
 StateMemo->Lines->Add("Text Size: " + TextSizeNumberBox->Text);
 StateMemo->Lines->Add("Fill Color: " +
  FillColorColorComboBox->ListBox->Selected->Text);
}
// ---------------------------------------------------------------------------
 
void __fastcall TForm1::RestoreButtonClick(TObject *Sender) {
 // restores the saved properties
 MainImage->Bitmap->Canvas->RestoreState(SaveState);
 RestoreButton->Enabled = false;
 // updates the combo boxes
 UpdateStateComboBox();
 // clears the memo
 StateMemo->Lines->Clear();
}
// ---------------------------------------------------------------------------

Add the following lines of code to the OnExit event handlers of the TColorComboBox, TNumberBox, and TComboBox objects, respectively:

void __fastcall TForm1::StrokeColorComboBoxExit(TObject *Sender) {
 // sets the stroke color
 MainImage->Bitmap->Canvas->Stroke->Color = StrokeColorComboBox->Color;
}
// ---------------------------------------------------------------------------
 
void __fastcall TForm1::ThicknessNumberBox1Exit(TObject *Sender) {
 // sets the thickness of the stroke
 MainImage->Bitmap->Canvas->StrokeThickness = ThicknessNumberBox1->Value;
}
// ---------------------------------------------------------------------------
 
void __fastcall TForm1::StrokeCapComboBoxExit(TObject *Sender) {
 // sets the stroke cap
 MainImage->Bitmap->Canvas->StrokeCap =
  TStrokeCap(GetEnumValue(__delphirtti(TStrokeCap),
  StrokeCapComboBox->Selected->Text));
}
// ---------------------------------------------------------------------------
 
void __fastcall TForm1::StrokeDashComboBoxExit(TObject *Sender) {
 // sets the stroke dash
 MainImage->Bitmap->Canvas->StrokeDash =
  TStrokeDash(GetEnumValue(__delphirtti(TStrokeDash),
  StrokeDashComboBox->Selected->Text));
}
// ---------------------------------------------------------------------------
 
void __fastcall TForm1::StrokeJoinComboBoxExit(TObject *Sender) {
 // sets the stroke join
 MainImage->Bitmap->Canvas->StrokeJoin =
  TStrokeJoin(GetEnumValue(__delphirtti(TStrokeJoin),
  StrokeJoinComboBox->Selected->Text));
}
// ---------------------------------------------------------------------------
 
void __fastcall TForm1::FillColorColorComboBoxExit(TObject *Sender) {
 // sets the fill color
 MainImage->Bitmap->Canvas->Fill->Color = FillColorColorComboBox->Color;
}
// ---------------------------------------------------------------------------
 
void __fastcall TForm1::TextSizeNumberBoxExit(TObject *Sender) {
 // sets the font size
 MainImage->Bitmap->Canvas->Font->Size = TextSizeNumberBox->Value;
}
// ---------------------------------------------------------------------------

Add the following lines of code to the OnClik event handlers of the ellipse, rectangle, text, and clear TButton objects, respectively:

void __fastcall TForm1::EllipseButtonClick(TObject *Sender) {
 TRectF MyRect;
 int x1, y1, x2, y2;
 // draws and fills an ellipse on the canvas with the current state
 x1 = 20;
 y1 = 20;
 x2 = MainImage->Bitmap->Canvas->Width - 20;
 y2 = MainImage->Bitmap->Canvas->Height - 20;
 // sets the circumscribed rectangle of the ellipse
 MyRect.init(x1, y1, x2, y2);
 // draws the ellipse on the canvas+
        MainImage->Bitmap->Canvas->BeginScene();
 MainImage->Bitmap->Canvas->DrawEllipse(MyRect, 40);
 MainImage->Bitmap->Canvas->FillEllipse(MyRect, 40);
        MainImage->Bitmap->Canvas->EndScene();
 // updates the bitmap
 MainImage->Bitmap->BitmapChanged();
}
// ---------------------------------------------------------------------------
 
void __fastcall TForm1::RectangleButtonClick(TObject *Sender) {
 TRectF MyRect;
 int x1, y1, x2, y2;
 // draws and fills a rectangle on the canvas with the current state
 // the rectangle to be drawn
 x1 = 60;
 y1 = 60;
 x2 = MainImage->Bitmap->Canvas->Width - 60;
 y2 = MainImage->Bitmap->Canvas->Height - 60;
 MyRect.init(x1, y1, x2, y2);
        MainImage->Bitmap->Canvas->BeginScene();
 MainImage->Bitmap->Canvas->DrawRect(MyRect, 0, 0, AllCorners, 100);
 MainImage->Bitmap->Canvas->FillRect(MyRect, 0, 0, AllCorners, 100);
        MainImage->Bitmap->Canvas->EndScene();
 // updates the bitmap
 MainImage->Bitmap->BitmapChanged();
}
// ---------------------------------------------------------------------------
 
void __fastcall TForm1::TextButtonClick(TObject *Sender) {
 TRectF MyRect;
 int x1, y1, x2, y2;
 x1 = 60;
 y1 = 60;
 x2 = MainImage->Bitmap->Canvas->Width - 60;
 y2 = MainImage->Bitmap->Canvas->Height - 60;
 MyRect.init(x1, y1, x2, y2);
 // fills and draws the text in the specified rectangle area of the canvas
        MainImage->Bitmap->Canvas->BeginScene();
 MainImage->Bitmap->Canvas->FillText(MyRect, TextEdit->Text, false, 100,
  TFillTextFlags() << TFillTextFlag::ftRightToLeft, TTextAlign::taCenter,
  TTextAlign::taCenter);
        MainImage->Bitmap->Canvas->EndScene();
 // updates the bitmap
 MainImage->Bitmap->BitmapChanged();
}
// ---------------------------------------------------------------------------
 
void __fastcall TForm1::ClearButtonClick(TObject *Sender)
{
  //clears the canvas and restores the initial state
  MainImage->Bitmap->Canvas->BeginScene();
  MainImage->Bitmap->Canvas->Clear(claNull);
  MainImage->Bitmap->BitmapChanged();
  MainImage->Bitmap->Canvas->RestoreState(InitialState);
  MainImage->Bitmap->Canvas->EndScene();
  //updates the combo boxes
  UpdateStateComboBox();
}
//---------------------------------------------------------------------------

Uses

FMX.Types.TCanvas.SaveState ( fr | de | ja )

FMX.Types.TCanvas.RestoreState ( fr | de | ja )

FMX.Types.TCanvas.Stroke ( fr | de | ja )

FMX.Types.TCanvas.StrokeThickness ( fr | de | ja )

FMX.Types.TCanvas.StrokeCap ( fr | de | ja )

FMX.Types.TCanvas.StrokeDash ( fr | de | ja )

FMX.Types.TCanvas.StrokeJoin ( fr | de | ja )

FMX.Types.TCanvas.Font ( fr | de | ja )

FMX.Types.TCanvas.Fill ( fr | de | ja )

FMX.Types.TCanvas.Clear ( fr | de | ja )

FMX.Types.TCanvas.DrawEllipse ( fr | de | ja )

FMX.Types.TCanvas.FillEllipse ( fr | de | ja )

FMX.Types.TCanvas.DrawRect ( fr | de | ja )

FMX.Types.TCanvas.FillRect ( fr | de | ja )

FMX.Types.TCanvas.FillText ( fr | de | ja )

FMX.Objects.TImage.Bitmap ( fr | de | ja )

FMX.Objects.TBitmap.Canvas ( fr | de | ja )

System.Types.TRectF ( fr | de | ja )

How do I use FireMonkey TBrush in C++ Code Sample

2012-05-22T12:50:00.000-07:00

FMXTBrush (C++)

Language:

Versions:

Description

This example is a FireMonkey HD Application that demonstrates how to use different properties of TBrush.

This example requires the following components:

A ComboBox object with three ListBoxItem objects.
An Ellipse object.
Two ColorListBox objects.
Four Label objects.
Four Image objects.

The form should look like in the following image.

Disable all the components, except the Ellipse, the ComboBox, and the Labels. Set the text to the labels as null ( ' ' ), except for the one above the ComboBox. Set its text to 'Choose a style for the Ellipse:' . Load different Bitmap files to the Bitmap property of the Imageobjects.

Code

// C++
void __fastcall TForm1::ColorListBox1Change(TObject *Sender) {
 // Verify the Style of the TBrush and use the selected color accordingly (as the color of the brush or as the first gradient color)
 if (Ellipse1->Fill->Kind == TBrushKind::bkSolid)
  Ellipse1->Fill->Color = ColorListBox1->Color;
 else
  Ellipse1->Fill->Gradient->Color = ColorListBox1->Color;
}
// ---------------------------------------------------------------------------
 
void __fastcall TForm1::ColorListBox2Change(TObject *Sender) {
 // Use the selected color as the second color of the gradient
 Ellipse1->Fill->Gradient->Color1 = ColorListBox2->Color;
}
// ---------------------------------------------------------------------------
 
void __fastcall TForm1::FormCreate(TObject *Sender) {
 Ellipse1->Fill->Kind = TBrushKind::bkNone;
}
// ---------------------------------------------------------------------------
 
void __fastcall TForm1::Image1Click(TObject *Sender) {
 // Set the Brush's pattern to be the first image
 Ellipse1->Fill->Bitmap->Bitmap = Image1->Bitmap;
 Ellipse1->Repaint();
}
// ---------------------------------------------------------------------------
 
void __fastcall TForm1::Image2Click(TObject *Sender) {
 // Set the Brush's pattern to be the second image
 Ellipse1->Fill->Bitmap->Bitmap = Image2->Bitmap;
 Ellipse1->Repaint();
}
// ---------------------------------------------------------------------------
 
void __fastcall TForm1::Image3Click(TObject *Sender) {
 // Set the Brush's pattern to be the third image
 Ellipse1->Fill->Bitmap->Bitmap = Image3->Bitmap;
 Ellipse1->Repaint();
}
// ---------------------------------------------------------------------------
 
void __fastcall TForm1::Image4Click(TObject *Sender) {
 // Set the Brush's pattern to be the fourth image
 Ellipse1->Fill->Bitmap->Bitmap = Image4->Bitmap;
 Ellipse1->Repaint();
}
// Set the style of the TBrush according to the selected option and
// enable the components needed to set the other TBrush properties
// ---------------------------------------------------------------------------
 
void __fastcall TForm1::ListBoxItem1Click(TObject *Sender) {
 Label3->Text = "Choose a color:";
 Label4->Text = "";
 Label2->Text = "";
 Ellipse1->Fill->Kind = TBrushKind::bkSolid;
 ColorListBox1->Enabled = True;
 ColorListBox2->Enabled = False;
 Image1->Enabled = False;
 Image2->Enabled = False;
 Image3->Enabled = False;
 Image4->Enabled = False;
}
// ---------------------------------------------------------------------------
 
void __fastcall TForm1::ListBoxItem2Click(TObject *Sender) {
 Label3->Text = "Choose the top color:";
 Label4->Text = "Choose the bottom color:";
 Label2->Text = "";
 Ellipse1->Fill->Kind = TBrushKind::bkGradient;
 ColorListBox1->Enabled = True;
 ColorListBox2->Enabled = True;
 Image1->Enabled = False;
 Image2->Enabled = False;
 Image3->Enabled = False;
 Image4->Enabled = False;
 
}
// ---------------------------------------------------------------------------
 
void __fastcall TForm1::ListBoxItem3Click(TObject *Sender) {
 Label2->Text = "Choose an image:";
 Label3->Text = "";
 Label4->Text = "";
 Ellipse1->Fill->Kind = TBrushKind::bkBitmap;
 ColorListBox1->Enabled = False;
 ColorListBox2->Enabled = False;
 Image1->Enabled = True;
 Image2->Enabled = True;
 Image3->Enabled = True;
 Image4->Enabled = True;
 Ellipse1->Fill->Bitmap->WrapMode = TWrapMode::wmTileStretch;
}
// ---------------------------------------------------------------------------

Uses

FMX.Types.TBrush ( fr | de | ja )
FMX.Types.TBrush.Kind ( fr | de | ja )
FMX.Types.TBrush.Bitmap ( fr | de | ja )
FMX.Types.TBrushBitmap.WrapMode ( fr | de | ja )
FMX.Types.TBrushBitmap.Bitmap ( fr | de | ja )
FMX.Types.TBrush.Gradient ( fr | de | ja )
FMX.Types.TBrush.Color ( fr | de | ja )
FMX.Objects.TEllipse.Fill ( fr | de | ja )
FMX.Types.TGradient.Color ( fr | de | ja )
FMX.Types.TGradient.Color1 ( fr | de | ja )

FireMonkey Info Blog

Video: Rotate an Image in a Delphi iOS App with FireMonkey

Video: What's new in Delphi XE4 and RAD Studio XE4

FireMonkey iOS Tutorial: Set Up Your Development Environment on the Mac

Requirements on the Mac

Steps to Configure Your Mac to Run Your iOS Application on the iOS Simulator

Step 1: Install the Platform Assistant

Step 2: Run the Platform Assistant

Step 3: Install Xcode on the Mac

Next Steps

Additional Steps to Configure Your Mac to Run Your iOS Application on Your iOS Device

Step 1: Install the Xcode Command Line Tools on a Mac

Step 2: Sign Up for a Developer Account

Step 3: Request, Download and Install Your Development Certificate

Request, Download and Install Your Certificate

Step 4: Register Your Device for Deployment

Step 5: Create and Install a Provisioning Profile

Introducing FireMonkey FM3

FireMonkey FM3

The multi-device, true native app platform

Create Windows and Mac OS X applications using a single codebase with FireMonkey

Create Windows and Mac OS X applications using a single codebase

FireMonkey ISV to Enterprise on Multiple Platforms

ISV to Enterprise on multiple platforms

FireMonkey Case Study - Erply

Embarcadero Developer Tools Pave the Way to Windows 8

Develop once with FireMonkey FM2 - Compile to Windows, Compile to Mac

Fastest path to Windows 8 and Mac OS X Mountain Lion

Create applications for multiple platforms from a single codebase with FireMonkey FM2

Create applications for multiple platforms that standout from the crowd

Introducing FireMonkey FM2

FireMonkey FM2

What is FireMonkey FM2?

Video: Migrating a FireMonkey Application to Windows 8 Style Metropolis UI

Delphi Contest: Absolutely Insane Firemonkey Demo

Free Mida to FireMonkey Migration Tool

Custom FireMonkey "TSimpleTriangle" component - Blog Post Share

Custom FireMonkey "TSimpleTriangle" component

Blog share: Getting to grips with using FireMonkey Grids

C++Builder with FireMonkey in The Code Project Members's Choice Awards

Gartner: Macs Invading the Enterprise

Visual C++ to Mac using FireMonkey and C++Builder

Great deal on FireMonkey through June 29, 2012

How do I use the FireMonkey TBitmap StartLine Property in C++?

FMXTBitmapStartLine (C++)

Language:

Versions:

Contents

Description

Code

Code

Uses

See Also

New FireMonkey Grid beta available from Arcana

How do I use FireMonkey SaveCanvas and RestoreCanvas Functions with C++?

FMXTCanvasSaveCanvas (C++)

Language:

Versions:

Contents

Description

Code

Uses

See Also

How do I use FireMonkey TBrush in C++ Code Sample

FMXTBrush (C++)

Language:

Versions:

Contents

Description

Code

Uses

See Also

FireMonkey FM³

FireMonkey FM²