6.1.2 Brings iOS 7 Support

The latest stable release offers over 30 enhancements as well as the awaited iOS 7 support

We are pleased to announce the release of LiveCode 6.1.2. This is a stable release containing more than 30 bug fixes and support for xCode 5.0 and iOS 7. We would recommend all 6.1 users upgrade to this release. It is available for both Community and Commercial users. If you have a Commercial 6.x license this release will have automatically become available in your LiveCode account.

The principle reason for existence for this minor point release is to add support for the latest iOS, however as usual we have taken the opportunity to fix various issues and squeeze in a number of enhancements for your delight. Here’s what 6.1.2 has for you.

Engine Changes

iOS 7/Xcode 5 Support
Support has been added to the engine and IDE to allow for iOS builds using Xcode 5.0. This means that OS 10.8 users (required by Xcode 5.0) will need to have Xcode 5.0 installed and set up in LiveCode’s preferences in order to produce Arm v7 builds. Arm v6 builds will still be produced using Xcode 4.4 (the last version to support Arm v6).

The table below details the versions of Xcode LiveCode requires on each platform to produce the given build type. In order to produce universal builds both the Arm v6 and Arm v7 Xcode SDKs will be required.

In addition to the above, the new iOS 7 icon sizes can be specified in the standalone builder. They are sized as follows:

• Retina iPhone: 120×120
• iPad: 76×76
• Retina iPad: 152×152

Better Quality Printing on Mac
When printing on Mac, two things have been improved. The first is that semi-transparent groups (with default ink – copy / srcOver) will render directly rather than being rasterized first. The second is that PNG and JPEG images will pass their data directly through to the printer driver. The end result is that scaled images will print at higher resolution than they did before in many more cases.

URL Operations Sometimes Fail on Android
There is a bug in the Android Java HTTP layer which can cause URL operations to fail (https://code.google.com/p/google-http-java-client/issues/detail?id=116). This problem seems to be related to keep-alive connections, thus until this bug is addressed in Android the engine will now turn off keep-alive on startup.

Support for Arm V6 iOS Builds Dropped
The earliest version of iOS supported by LiveCode is 4.3. Since iOS 4.3 only runs on Arm v7 (and newer) devices, support for Arm v6 (and subsequently universal builds) has been dropped. This has in turn simplified the versions of Xcode a user needs to have installed in order to perform iOS device builds:

Applescript Now Works on LiveCode IDE
This issue has been fixed. It was caused by incorrect naming of the rsrc file – it was LiveCode.rsrc rather than LiveCode-Community.rsrc or LiveCode-Commercial.rsrc. (The name of the rsrc file has to match the name of the executable file within the bundle).

Key Code Parameter to RawKey Messages No Longer Always Zero on Mobile
The rawKey messages will now give pass the ASCII code of ASCII characters to rawKeyDown/Up when pressed. This is consistent with the Desktop’s handling of the rawKey messages.

Spaces No Longer Required in Date Formatting
Date format string parsing has been made less strict in its processing, now collapsing one or more spaces together to allow a ‘ ‘ in a format string to match one or more input spaces. Additionally, spaces in the input after a formatting specifier was successfully matched are ignored. With these changes, both “10:41 PM” and “10:41PM” are accepted as valid times; previously, only the former was acceptable.

Caseless Comparison Now Working Correctly on Linux
For Linux distributions having their locale set to something other than ISO8859-1, caseless comparison was not working correctly. This has been fixed.

Ensure Caseless Comparison Works on Linux Server
This problem was fixed on the Desktop as Bug 11160 and has now been iterated to the Server build.

Offline Activation Now Working in Ubuntu
The installer now does not offer to launch LiveCode after installation as root (e.g. via su or sudo) on Linux in order to prevent the product from creating its activation files with the wrong permissions. Instead, LiveCode should be launched in the normal way after installation and activation occurs then.

A full fix list and more details can be found in the release notes for this edition, here

Community Contributions

There are a number of exciting things about 6.1. Perhaps the most interesting and positive aspect of this release is that you, the community, have got involved. 7 features and 2 fixes incorporated in 6.1 were provided by dedicated community members working on the open source engine. Not perhaps earthshaking features in themselves, but handy if you need them, and a great omen for times to come. Just to pick out a couple, Monte Goulding among other items contributed Locking Group Updates, a featuer which speeds up custom controls composed of many objects, as well as the “effective visible”, allowing you to determine which objects are genuinely visible on-screen at any given time. Jan Schenkel gave us “Getting the Page Ranges of a Field” as well as some additional statistical functions, and Mark Wieder fixed a bug with “is a color”. We’re very grateful to all of you!

If you want to get involved, there is a comprehensive guide here, and don’t forget to drop by the forums, here.

Chained Behaviors

Perhaps the biggest new feature in 6.1 is chained behaviors. I’m going to let Ben Beaumont explain to you why you should care about this in your apps.

We introduced behaviors to allow objects to share code. Take for example a platform game where you collect coins. Each of these coins requires the same script in order to function. You can define a ‘behavior script’ and all instances of the coin can use it. Making a change to the behavior script affects every coin.

Behaviors help developers to put more structure into their code and avoid repetition. Repetition is bad because if you need to change some code that is repeated throughout your project, you have to apply that change in many places. Imagine having 100 coins all with the same script. Changing the script means going through and updating the script for all 100 coins!

Chained behaviours takes this code structuring one step further. A behaviour script can now have a behavior of its own which in turn can have a behavior of its own and so on. Lets return to our game example. This time imagine your game involves collecting coins, stars and fruit while trying not to collect poison.

Each of these objects has lots in common:

• When a user interacts with the object it should be removed from the screen
• When a user collects the object their score should change
• When a user collects the object a sound should play

However, these objects also contain differences:

• Each object may move / animate in a different way
• Each object may have a different score associated to it, adding or subtracting
• Each object may have a different sound associated with it

Using chained behaviours you could structure your app as follows which would ensure that no code is repeated in more than one place.

LiveCode Community Activation Removed
In LiveCode 6.1 Community Edition, you no longer need to activate the program after downloading and installing it. This makes it more accessible, faster to install, and removes a barrier to users adopting it. You are still offered the opportunity to create an account if you wish to, but it is not required. Students can easily install in a school environment, making getting LiveCode into more and more of the educational establishment even easier.

You can get the full release notes for 6.1 here, with all the new features and fixes that have been added.

Faster apps

We’ve really gone to town on optimising image performance in this release. Why? Because better image performance means faster apps, especially on mobile. If you have a lot of images in your app, you need them to load fast for the perfect user experience. We’ve worked on optimising images themselves and on image caching so you experience smooth fast app performance.

The engine now has an image cache which is used to cache all decompressed image data. The size of the cache can be set using the global ‘imageCacheLimit’ property, and the amount of data in the cache is returned by the global ‘imageCacheUsage’ property.

The image cache operates in a least-recently-used manner – if an image needs to be decompressed and there is not enough room, the images that were used longest ago are discarded from cache until there is enough room.

If an image has ‘alwaysBuffer’ set to true, then it will be decompressed into the cache on card open. Images are processed from lowest layer to highest, so if too many images have alwaysBuffer on a card, images on lower layers will have their data discarded from the cache before ones higher up.

An image can be forced to be cached by using the new form of prepare:

prepare image <name> [ of … ]
prepare image file <filename>

The image cache is keyed on absolute filename of image thus it is now highly efficient to use image objects referencing the same filename, rather than buttons referencing icons. In particular, there will only ever be one decompressed set of image data for a given (absolute) filename in the cache at any one time.

Better Workflow

We’ve added autocomplete to the message box. Now when you type in a command into LiveCode’s "command line" it will start making suggestions for you to really speed up your workflow and cut down on typing errors. Also, if you use "put" statements a lot, you’ll love the new "Source" feature we’ve added, allowing you to go straight to the statement that generated the output.

Auto-complete

This feature allows you quick access to previous lines of code executed in the message box. Start typing to start the auto-complete feature.

Type – Starts auto-complete
Right Arrow Key – Accept suggested auto-complete
Up Arrow Key – Look forwards through auto-complete suggestions Down Arrow Key – Loop backwards through auto-complete suggestions

Source

The put command in LiveCode outputs content to the message box. The source button loads the script editor and selects the line of code that output the content.

Click – Opens script editor

More Productivity

The new project browser is a big step forward in productivity. You can now quickly find all the elements in your project, and apply common actions to them directly. No more issues with locating invisible buttons, or objects hiding behind backgrounds. Quickly name or rename objects, use the search filter to find items, and generally work with your project efficiently and transparently.

Script of Object
Shows the number of lines of the script of the object.

Click – Opens the script in the script editor

Behavior Script of Object
Shows the number of lines of the behavior script of the object if one is set.

Click – Opens the behavior script of the object

Selected Object
The selected object is highlighted with a change in background color

Click – Deselects currently selected object(s) and selects the target object
Click + Drag – Relayers the object to the drop location
Click + Drag to actions – Performs action on dragged items (ie, new, group, clone, delete)
Shift + Click – Selects all the objects between the currently selected object and the target object Cmd / Ctrl + Click – Selects the target object

Action Bar
The action bar contains a series of buttons that can be clicked on and dragged onto in order to perform the action of the highlighted or dragged object(s).

New – Create a new object of the same type as the highlighted object Group – Group the object(s)
Clone – Clone the object(s)
Delete – Delete the object(s)

Name
The type and name of the object are shown for each object.

Double Click – Makes the name editable

Lock from Selection
Prevents / enables the selection of the object by the mouse pointer in the canvas area.

Click – Toggles the setting

Show / Hide
Shows / hides the object.

Click – Toggles the setting

Expand / Collapse
Expands and collapses the stack, sub-stack, card or group showing / hiding the contents

Click – Toggles the setting

Filtering
You can now filter the controls shown in the Project Browser.

There are a number of way you can do this:

Just typing the the filter field will filter the controls by name.

Alternatively you can specify what you want to filter by, one of name, type, script lines. Name and type use "contains" to match the filter string.

name: <filter string> e.g. name: back

type: <filter string> will filter by type e.g. type: button

script [<|>|=] <integer> e.g. script > 1

The matching controls are shown, along with the groups, cards, and stacks they belong to.

Settings
A new setting icon has been added to the project browser allowing easy access to the preferences.

Take a tour of the Project Browser here.

Better Behaved Behaviors

We’ve introduced "Before" and "After" handlers for behaviors. Why should you care? In a nutshell, it prevents user actions from interfering with your carefully crafted behaviors, causing them to act in unexpected ways when the message they were expecting never arrived. Here’s how it works:

Two new handler types have been added, before and after. Before and after handlers are exclusive to behavior scripts and are sent to the behavior script before and after all messages.

For example, consider a mouseDown message moving through the message path. It gets to an object with a behavior script:

1. The engine looks at the behavior script of the target object – If a before mouseDown handler is present, it executes it.
2. The engine next looks at the object script – If an on mouseDown handler is present, it executes it.
3. The engine now looks at the behavior script – If an after mouseDown handler is present, it executes it.
4. The engine finally looks at the object script – if a pass mouseDown or no mouseDown handler was present, it moves on to the parent object.

Before and after handlers allow developers to produce behavior scripts which can handle messages sent to a control without having any effect on the message path (unlike front and back scripts).

Layers that Relayer

We’ve introduced a "Relayer" command, which means that projects with many layered objects are much more manageable. If you discover halfway through a project that item A should really be underneath item B, but on top of item J which is located in another group of objects, you can now move it around readily and without unexpected consequences. Here’s how it works:

relayer control ( before | after ) layer index
relayer control ( before | after ) control target
relayer control ( before | after ) owner
relayer control to ( front | back ) of layer index
relayer control to ( front | back ) of control target
relayer control to ( front | back ) of owner

All forms work in a regular way – a control is moved relative to a target in one of four ways:

• before – the control’s owner becomes the target’s owner and is inserted before the target; the layer of the control becomes the layer of the target and the target and all subsequent controls shift up one).

• after – the control’s owner becomes the target’s owner and is inserted after the target; the layer of the control becomes one greater than the layer of the last child of the target and all subsequent controls shift up one.

• front – the control’s owner becomes the target’s owner and is inserted after the last child of the target (only valid if target is a container).

• back – the control’s owner becomes the target’s owner and is inserted before the first child of the target (only valid if target is a container).

The target is resolved in one of three ways:

• The engine looks at the behavior script of the target object – If a before mouseDown handler is present, it executes it.

• The engine next looks at the object script – If an on mouseDown handler is present, it executes it.

• The engine now looks at the behavior script – If an after mouseDown handler is present, it executes it.

• The engine finally looks at the object script – if a pass mouseDown or no mouseDown handler was present, it moves on to the parent object.

Before and after handlers allow developers to produce behavior scripts which can handle messages sent to a control without having any effect on the message path (unlike front and back scripts).

• layer – the target control is taken to be the control with layer index.

• control – the target control is taken to be the given control.

• owner – the target control is taken to be the owner of the control.

The control parameter determines the control that is to be moved.
Note that the relayer command can only be used to move controls within a card – attempts to relayer controls from one card (or another stack) to another will throw an error. The relayer command can throw a number of errors:

• ‘relayer: couldn’t resolve target object’ – the target chunk is an invalid control or card

• ‘relayer: couldn’t resolve source control’ – the source chunk is an invalid control

• ‘relayer: source not a control’ – the source chunk resolves to a non-control object

• ‘relayer: target not a container’ – the target chunk resolves to a non-container object (i.e. not a card or a group)

• ‘relayer: source and target not on the same card’ – the source control does not reside on target (if it’s a card), or target’s card

• ‘relayer: layer not an integer’ – the expression passed to the ‘layer’ form is not a valid integer

• ‘relayer: bad layer expression’ – an error was thrown while evaluating the layer expression

• ‘relayer: target not a control’ – in the before or after form, the target chunk resolves a non- control object

• ‘relayer: cannot move a control into a descendent’ – an attempt has been made to move a group into a child of itself.

• ‘relayer: required objects disappeared while processing’ – the target object and/or the source object were deleted in the process of relaying (this can happen when moving controls in and out of groups as messages might be sent to ensure focus is correct).

Other new features include:

• Field improvements –
  • support for Non-BMP unicode characters
  • hexadecimal HTML entity references
  • strong and em HTML tags
  • a new listIndex paragraph property
  • and a new metadata paragraph property
• Effective rect of stack – get and set the rectangular area of a given stack with its decorations and frame taken into account
• Import/export snapshot at size – resize your snapshot before importing it into your project
• Control at location – get the control at a given location
• Split and Combine variants – enables better handling of data in an array
• Object selection started/ended – lets you know when a user starts and finishes dragging over an object

On iOS, support for 6.1 device and simulator builds was added.

105 bugs were fixed in total. Read the full release notes here.

This release is important if you are trying to build apps for iOS. You can now build LiveCode apps for iOS 6.1, using Xcode 4.6. Armv7 device builds are now produced using the iOS 6.1 SDK and testing with the 6.1 simulators is now possible.

For Lion & Mountain Lion users to produce Armv7 device builds, you must have the iOS 6.1 SDK installed, which comes with Xcode 4.6. For Armv6 builds, the iOS 5.1 SDK is needed, which comes with Xcode 4.4. Naturally, to produce universal builds, both Xcode 4.4 and 4.6 are needed.

For Snow Leopard users, all device builds are produced using the iOS 5.1 SDK (the latest version available for Snow Leopard) which comes with Xcode 4.2.

LiveCode 5.5.4 supports the 4.3, 5.0, 5.1, 6.0 and 6.1 simulators. To use LiveCode with a given simulator version, point LiveCode to the version of Xcode the simulator comes with using the “Mobile Support” section of the LiveCode preferences. Extra simulators can be installed through the “Downloads” pane of Xcode’s preferences.

You can download the release notes for 5.5.4 here:

Desktop

iOS

Android

This version brings you the all new field, with it’s exciting new text handling abilities and Unicode improvements, and no less than 15 new features on Android, and 8 for iOS, largely bringing these two platforms into line with each other.

To help you get to grips with the new features, we’ve created a series of new lessons. Take a look at how to style paragraphs, using the “flagged” property, displaying a table, or hierarchical list support.

For mobile there is a lesson on using custom URL schemes, and you can check out local notifications in this newsletter.

For a detailed discussion of the new Field features, please see this newsletter article.

Text Messaging for iOS and Android
Text messaging has been a much requested feature we’ve now added for you. Here’s how it works:

Use the command mobileComposeTextMessage to launch the default text messaging app.

mobileComposeTextMessage recipients, [body]

The recipients is a comma separated list of phone numbers you want the message to be sent to. The optional body is the content of the message you wish to be sent. Note that once you’ve called the mobileComposeTextMessage command you have no more control over what the user does with the message – they are free to modify it and the addresses as they see fit.

Upon completion of a compose request, the result is set to one of the following:

• sent – the text was sent successfully
• cancel – the text was not sent, and the user elected not to save it for later
• failed – the text could not be sent
• false – the device does not have text messaging functionality

You can determine if the device has the text messaging client configured using the function
mobileCanComposeTextMessage(). This returns true if the client is configured.

Mobile Features Added
New features on both iOS and Android include:

• Rotation sensor
• Local notifications
• Custom URL schemes
• Text messaging
• Vibration
• Busy indicators

Features new to Android that iOS already supports include:

• Native browser control
• Modal pick wheel support
• Date picker support
• GPS
• Compass
• Multi-channel sound
• Beep
• Custom fonts
• Idle Timer configuration
• Localisation calls

Important: The file format in this release has changed to allow us to better support the new field and unicode features. This means that if you wish to retain compatiblity with older versions of LiveCode, you must save your projects by choosing “Save As… legacy format” in the File/save menu.

What’s new?
Firstly, on all platforms we have implemented improvements to the Accelerated Rendering which was introduced with LiveCode 5. No fewer than 35 bugs were squished, many on desktop/all platforms (see below). Generally, this is a fairly Android centric release in terms of features. We’ve added:

Open GL support on Android

As well as the new graphics architecture introduced across all platforms in LiveCode 5.0, you can now use the Open GL features on Android as well as iOS. Get the fastest possible performance out of your animations!

In App purchasing for Android

This important feature allowing you to earrn more money from your apps now works on Android as well as iOS, and you can find out how to use it by following our hands on lesson. Start adding powerups to your Android games to boost your user engagement 🙂

Support for the hardware “Menu” key on Android.

A simple but important feature. Use this with the following syntax:

on menuKey     answer "You pressed the menu key" with "Okay"  end menuKey  

This allows you to handle the menuKey message to perform an action when the menu key is pressed by your user.

Support for the hardware “Search” key on Android

Sent to the current card of the defaultStack when the hardware search button is pressed.

on searchKey     answer "You pressed the search key" with "Okay"  end searchKey  

Again, a very welcome addition to the Android features available to you.

Store on the SD card as well as device.

This is going to make your apps much more popular with end users – now you can store them externally, saving space on the device.

iOS gets some new features too:

Activity indicator

iOS provides a native animated activity indicator that sits above all other components and is used to indicate that an app is busy processing. Use the iphoneActivityIndicatorStart command to display a native iOS activity indicator on the top of the LiveCode stack that is running.

iphoneActivityIndicatorStart [type], [xposition, yposition]

Here, type can be one of:

• gray – default, displays a small gray spoked animation
• white – displays a small white spoked animation
• whiteLarge – displays a large white spoked animation

The xposition and yposition specify the location in pixels of the activity indicator. If a location is
not specified, then the animation is positioned in the middle of the screen. You can turn the activity indicator off by calling iphoneActivityIndicatorStop.

Media picker

You can present the user with the standard iOS media picker using:

iphonePickMedia [multiple], [type…]

Set multiple to true if you want to allow the user to pick more than one item.

You can specify the type of media item the user is to select from by passing one or more of the
following:

• music – Specifies that the user should be allowed to select music items.
• podCast – Specifies that the user should be allowed to select pod casts.
• audioBook – Specifies that the user should be allowed to select audio books.
• anyAudio – Specifies that the user should be allowed to select any audio item.

If no types are passed, all media items will be displayed. A return separated list of all the media items the user has picked will be present in the result. A media item can be played back using the play command.

We’ve also updated the play command to support playback of files in iPod
library and updated native browser control to send a new message “browserLoadRequested”.

What’s Fixed?

We’ve ironed flat no fewer than 35 bugs in this release, many on desktop, a large number on iOS and a handful on Android. To list them all here would be tedious, but some noteworthy beasties were: 

• Visual effects now working when transitioning from card to stack (iOS)
• Export snapshot no longer produces inverted images in landscape mode. (iOS)
• Launch image is displayed with the correct orientation (iOS).
• PDF printing now works on iOS4 (iOS).
• Date picker permits the selection of dates before 1970 (iOS).
• Updated template plists to remove deprecated entry CFBundleIcon. (iOS)
• Device builds no longer confused by externals built for 5.0 simulator (iOS)
• opaque graphics render correctly using OpenGL compositor (Android)
• No black screen when switching between OpenGL and Bitmap modes ( Android)
• Visual effects now work in OpenGL mode ( Android)
• Focus correctly revoked when object hidden using ‘hide … with visual effect’ (desktop)
• Redraw issues fixed with QT players on Mac (desktop)
• New objects redraw correctly when created (desktop)
• Toggling ‘show invisibles’ now redraws bottom-most stack (desktop)
• Focus border is included in redraw when hiding field (desktop)
• Posting to HTTPS URLs now works (desktop)
• Now able to set blendLevel of stacks with a windowShape that contains alpha (desktop)

For a full listing of fixed issues, please check the release notes for each platform.

iOS release notes

Android release notes

General release notes

LiveCode 5 now lets you create apps with hardware accelerated graphics.This means you can now create stunning multimedia rich apps and exciting games that run faster and more smoothly than ever before on mobile platforms as well as the desktop.

The rendering speed of LiveCode 5 is up to 10x faster than its predecessor.

Other Headline Features

Not only that, we’ve brought you In-App purchasing, iOS 5 compatibility, and a brand new Learning Portal. This Learning Portal is well worth a look. Elanor got such great feedback in the Academy course, that we asked her to create these six videos together with the learning materials. Below is the first one in the series, and you can check the rest out at your leisure here.

In this first lesson we take you on a tour of LiveCode and introduce basic concepts like stacks (windows), cards (screens), objects (buttons, fields etc) and how actions and information are passed between them. We’ll also show you the various panes within LiveCode and what they all do.

What else is new?

If you’ve been reading our blog or seen our new front door you’ll know all about the headline features already. What you may not appreciate yet is all the additional work that has been done, across the board, to make LiveCode 5 the best LiveCode ever. On your behalf I’ve been digging through the release notes for the various platforms, to see what else has been done by our hard working team.

Bug fixing

Not the sexiest topic, but as every programmer knows, one more bug squished is one less sleepless night for someone, somewhere. I’ve counted up 54 bugs mentioned as fixed in the release notes across desktop, iOS and Android. Here are a handful of gems:

Desktop fixes
Fixed: Building a standalone cuts off a stack
Fixed: Wrong color used to draw on Windows if new color has same red and blue when inverted as old color
… and 31 more bugs eliminated on desktop!

Android fixes
Fixed: card/stack initialized with wrong size during Android startup.
Fixed: import/export snapshot inverts colors on Android
… and 5 more specific Android bugs gone!

iOS fixes
Fixed: allowed orientations not set to plist settings on startup on iPad.
Fixed: nested controls don’t receive touch messages
… and 18 more nasty little bugs squished here!

Android Love
You might be thinking – hey, great, LiveCode iOS gets in-app purchasing and support for iOS 5, but what’s in it for Android? A quote from our user base answers this rather well:

“The new engine works great on Android and I can attest that it makes an amazing difference. Also, visual effects are now functional, stability and memory management has been markedly improved, redraw and background pattern issues have been addressed, orientation is better supported, graphic effects (shadows, etc) now work. These are all in parity with iOS.” ~ Jacque Landman-Gay

In-App purchasing is coming very shortly to Android, it just didn’t quite make the cut for 5.0. We decided to hold it back and give it a little more polish, rather than risk shipping it in a slightly experimental form.

More features
As well as the major features, LiveCode 5 brings you Pixel Perfect Intersect and the Auto-Updater on desktop. LiveCode will now inform you when there is a new release available that you might be interested in, and you can grab your update right from inside the program. Android gets support for all the standard visual effects, and even Server gets a sneaky little feature add – support for sessions has been added.