Read the rest of this entry »

Read the rest of this entry »

How To Create A Game Like Tiny Wings with Cocos2D 2.X Part 1 is a post from: Ray Wenderlich

WebIS highlights “Rich Notes” as major new feature of the new version.

Rich Notes - we now have a full featured Rich Text editor for notes. We’ve got a lot more coming here, but today you can set styles, fonts, typefaces, lists, and more.

WebIS has been a key sponsor of the component helping us to enhance the feature set and API of the component with support for lists. This had long been on our roadmap, but without WebIS’ sponsorship we could not have brought it to fruition.

WebIS integrated the cutting edge version 1.5 of DTRichTextEditor to enable this feature. Kac had this to say when asked for a testimonial:

“Working with Oliver has been a tremendous joy. We simply could not have shipped on-time and with the quality of rich text support as we did without him. The DTRichTextEditor is a fabulous control with lots of great tools, utilities that we were able to use such as DTHTMLWriter and other classes. I heartily recommend both the control and Oliver.”

The Pro Version of Pocket Informant will be released on Tuesday May 21st as a free update to existing 2.x customers. WebIS also offers a free Go! version which will be receiving the 3.0 treatment in the near future.

If you buy a license to DTRichTextEditor you receive full access to all source code residing on our private git server. To celebrate the launch of Pocket Informant please mention keyword PI10 for 10% discount when you buy a license until May 31st.

Your vendor identifier is an 8-digit number beginning with an 8. Usually you have only one, but if you – for example – move from an Individual to a Company Apple developer account, then your old ID is retired and you get a new one. There might be also other scenarios for people having multiple, now AutoIngest for Mac supports that.

Changes

• ADDED: Support for multiple vendor identifiers

For the validation I implemented an NSTokenField, the learnings from that I summarized in a separate article.

I hope you are enjoying this new version AutoIngest for Mac! It is available via auto-update, direct download as well as full source on GitHub. The binary builds have Sparkle for OTA updating and are signed with Developer ID.

How To Create Dynamic Textures with CCRenderTexture in Cocos2D 2.X is a post from: Ray Wenderlich

Now for this week’s update to AutoIngest for Mac I wanted to turn the plain text Vendor ID field into a token field like the Mac mail app has. Fortunately NSTokenField exists on Mac since 10.4 and today we shall explore its use.

Googling for a tutorial did not yield any immediate result, but I found a sample from Apple themselves which I am using for pointers.

First step is to go into the preferences controller’s XIB and replace the NSTextField with an NSTokenField.

Connect the token field’s delegate, also we add an outlet to our file’s owner so that we interact with it. I set the Layout to “Scrolls” and checked “Uses Single Line Mode” to have the token field a single line and scrolling horizontally if there are more than two tokens.

Even without any additional delegate methods implemented we already get some basic behavior. You can enter text and as soon as you type a comma, the text turns into a token. Now you know why they call it the “blue pill”.

The token field continuously check its contents and separates tokens by the set tokenizingCharacterSet. The best place for additional setup is the -awakeFromNib.

// any non-number is a seperator
NSMutableCharacterSet *characterSet = [NSMutableCharacterSet alphanumericCharacterSet];
[characterSet formUnionWithCharacterSet:[NSCharacterSet whitespaceAndNewlineCharacterSet]];
[characterSet formUnionWithCharacterSet:[NSCharacterSet punctuationCharacterSet]];
[characterSet removeCharactersInString:@"1234567890"];
 
self.vendorTokenField.tokenizingCharacterSet = characterSet;

NSTokenField has a class method defaultTokenizingCharacterSet, which you can overwrite in a subclass if you want to keep your token code in a reusable sub-class of NSTokenField.

There are several methods in the NSTokenFieldDelegate protocol which allows us to a few customizations.

Token Styles

You can think of a token field as an array where all elements are tokens. A token can either be a text string or the above mentioned “blue pill”. So if you want to have tokens inside some normal plain text, then the normal text would be represented by NSPlainTextTokenStyle whereas the actual tokens would be using the NSRoundedTokenStyle.

In its simplest form you would be using NSString instances for the individual tokens. To achieve the differentiation between plain text and rounded token styles you would employ a delegate method:

- (NSTokenStyle)tokenField:(NSTokenField *)tokenField styleForRepresentedObject:(id)representedObject
{
	// make valid vendor ids "blue pill", everything else plain text
	if ([representedObject isValidVendorIdentifier])
	{
		return NSRoundedTokenStyle;
	}
 
	return NSPlainTextTokenStyle;
}

The representedObject – as often used on AppKit – can be any object that should represent the tokens. The default implementation is to use the NSString values you enter, but you can easily provide your own backing objects.

Represented Objects

If you use represented objects instead of the default strings, then you have to implement several delegate methods because the token field needs to convert between the object and what it should write on the token and what the editing value should be. From the NSTokenField.h header:

// If you return nil or don't implement these delegate methods, we will assume
// editing string = display string = represented object
- (NSString *)tokenField:(NSTokenField *)tokenField displayStringForRepresentedObject:(id)representedObject;
- (NSString *)tokenField:(NSTokenField *)tokenField editingStringForRepresentedObject:(id)representedObject;
- (id)tokenField:(NSTokenField *)tokenField representedObjectForEditingString: (NSString *)editingString;

You provide backing object for a given editing string. Conversely if the user double-clicks on a token this turns into editable text. Finally the display string is the inscription on the blue pills.

For example if you have the token represent an email address, then the editing string could be “Oliver Drobnik <oliver@cocoanetics.com>” and the display string be just “Oliver Drobnik”. In that case you could have a token object class with a displayName and an email string.

Autocompletion

NSTokenField also supports showing suggestions to the user depending on some initially typed characters. Those are shown after the completionDelay which you can customize. In the case of e-mail addresses you could show the most likely completions entered so far and set the index of the most likely candidate. The defaultCompletionDelay – also a class method you can override via sub-class – is 0. When trying out different values I couldn’t notice any difference however.

Autocompletion values are provided with this delegate method.

- (NSArray *)tokenField:(NSTokenField *)tokenField completionsForSubstring:(NSString *)substring indexOfToken:(NSInteger)tokenIndex indexOfSelectedItem:(NSInteger *)selectedIndex
{
	*selectedIndex = 1;
	return @[@"8xxxxxxxx", @"81234567"];
}

If you also change the by-ref selectedIndex then the selection at this index will already be put into the text field. To avoid this you have to return -1. Then you only see the suggestions dangling below the field waiting for the user to pick one. Not setting the value is the same as returning 0.

I very briefly considered storing valid vendor IDs in the user defaults and then presenting these to the user for auto-completion, but decided against that.

Pasteboard

You might remember from the mail.app that you can drag around the e-mail tokens or even drag them into other apps. To support interaction with the Mac pasteboard you have to implement two methods.

The first method gets an array of represented token objects and lets you add some useful representation(s) to the dragging pasteboard. The objects you set there need to be able to implement the NSPasteboardWriting protocol. Alternatively you can create a property list representation for them  and set this instead of an array of objects.

- (BOOL)tokenField:(NSTokenField *)tokenField writeRepresentedObjects:(NSArray *)objects toPasteboard:(NSPasteboard *)pboard
{
	[pboard writeObjects:objects];
	return YES;
}

If you don’t implement this method then it still works, the default representation is to concatenate all tokens into a single comma-separated string. Since we are only using NSStrings as token objects we don’t have to do anything special since NSStrings know how to represent themselves on the pasteboard. This implementation causes the tokens to be staying individual values. If you drag&drop them for example into Notepad they come out as one per line.

Context Menu

Apple’s sample also shows how to add individual context menus to the tokens. This is achieved via the following two delegate methods.

// By default the tokens have no menu.
- (NSMenu *)tokenField:(NSTokenField *)tokenField menuForRepresentedObject:(id)representedObject;
- (BOOL)tokenField:(NSTokenField *)tokenField hasMenuForRepresentedObject:(id)representedObject;

This context menu is possible in addition to auto-completion and is available in the tokenized form. It’s basically a drop down menu with a down arrow to open it. The sample shows a nice trick how to force a token back into editing mode. This action is tied to an Edit… menu option.

- (IBAction)editCellAction:(id)sender
{
	NSText *fieldEditor = [self.tokensField currentEditor];
	NSRange textRange = [fieldEditor selectedRange];
 
	NSString *replacedString = [NSString stringWithString:menuToken.name];
	[fieldEditor replaceCharactersInRange:textRange withString:replacedString];
	[fieldEditor setSelectedRange:NSMakeRange(textRange.location, [replacedString length])];
}

Though I fail to see the practical use of this trick, since you can always go into edit mode by double-clicking on a blue pill token.

Validation

We already have a bit of validation going by only turning valid vendor IDs into pills. But there is yet another delegate method which would also allow us to completely reject invalid tokens.

The following only accepts valid tokens. This also removes invalid tokens if you enter a separator or tab out of the field.

- (NSArray *)tokenField:(NSTokenField *)tokenField shouldAddObjects:(NSArray *)tokens atIndex:(NSUInteger)index
{
	NSMutableArray *validTokens = [NSMutableArray array];
 
	for (NSString *oneToken in tokens)
	{
		if ([oneToken isValidVendorIdentifier])
		{
			[validTokens addObject:oneToken];
		}
	}
 
	return validTokens;
}

Depending on your use case you might not want to have invalid tokens simply disappear. If you want to keep them, but just have them be text, then you just forego implementing this delegate method.

A second method to only get validated values into the array of vendor IDs is to have an NSValueTransformer which gets the array of tokens, filters for valid and sorts uniquely.

@implementation ValidVendorValueTransformer
 
+ (Class)transformedValueClass
{
	return [NSArray class];
}
 
- (id)transformedValue:(id)value
{
	NSArray *array = nil;
 
	if ([value isKindOfClass:[NSArray class]])
	{
		array = value;
	}
	else if ([value isKindOfClass:[NSString class]])
	{
		array = @[value];
	}
 
	NSAssert(array, @"Invalid class for transformer");
 
	// make unique in set
	NSMutableSet *validTokens = [NSMutableSet set];
 
	for (NSString *oneToken in array)
	{
		if ([oneToken isValidVendorIdentifier])
		{
			[validTokens addObject:oneToken];
		}
	}
 
	NSSortDescriptor *sort = [NSSortDescriptor sortDescriptorWithKey:nil
                                  ascending:YES
                                  selector:@selector(compare:)];
	return [validTokens sortedArrayUsingDescriptors:@[sort]];
}
 
@end

This also has a provision for the vendor ID value previously being a string. With this it automatically migrates the value next time you enter the preferences. You install the value transformer in the data bindings inspector for the token field.

Also note the “Continuosly Updates Value” which I set so that whenever the contents changes the user default gets updated.

Conclusion

I wanted to achieve the effect of a valid vendor identifier automatically turning into a rounded token, but failed. I was able to see that the token field would turn valid IDs into my own VendorIdentifier represented objects, but it didn’t update the display. Only when I entered a separator character or tabbed out of the token field would I see the refresh occur.

There are no other visual customization options – that I could find – on NSTokenField so you have to be content with the “blue pill” style. But once you wrapped your head around the basic concepts and accepted the limitations of the API you can quickly use token fields to add them to your apps.

They work nicely intermixed with normal text or as “token only” fields which you can data-bind to an NSArray.

I get a great deal of pleasure from reading responses to my articles, most of which are via my Twitter account. I was reading the stream of tweets referencing the article via Topsy recently, as I do for all my pieces, and I was once again fascinated by the extracts and quotes people choose to use.

In the majority of cases, the sections people quote from my articles agree with my own impression of what the important points were. I’d love to attribute this to careful writing and well-formed arguments, but of course it’s more due to the reader paying attention.

In some cases, though, people choose to refer to articles (and thus, in a sense, summarise them) using what I feel are either secondary points, or even actual mischaracterisations of misinterpretations of what I’ve said. The fault for that will be mine in some cases, and in others it’ll be the reader’s.

I had a spirited discussion on Twitter earlier today about a vague idea for offering some extra insight regarding my own view of an article’s salient points.

There were a few standard suggestions, which I’d already dismissed as not quite appropriate. Emphasis, for example, is more of a linguistic tool (to indicate or be analogous to verbal emphasis) than something to be used at the logical level. I also think that emphasis is ugly and diluted when used for more than a single clause or so.

The next suggestion (and probably most popular overall) was pull-quotes. I’ve used those perhaps twice in total on this blog before, and each time I felt self-conscious about it. Pull-quotes can make you seem arrogant, in my opinion. There’s something crass about them.

Since this discussion took place on the internet, a few people even deigned to give me a high school writing lesson, saying that no additional means of highlighting passages should be needed if I just make my point properly. Thanks for that.

Abstracts were mentioned (I think that arguments should be allowed to build; I’m not writing academic papers), as were sub-headings (similar objection to abstracts), and unacceptably ugly inline styling like boldface or underlining.

Things got a bit more interesting when Branch was mentioned, which has the sort of neon-highlighter-pen concept I’d been thinking of – you can see examples here, though again I don’t like the underline; only the hover appearance. That implementation is reasonably close to what I’m after.

No matter how carefully written a piece may be, the reader is an unknown factor. Different people will interpret your words differently, and it’s not possible to completely eliminate that. Perhaps that’s even a positive state of affairs.

In any case, everyone will have different “take-home points” from a piece of writing. As I see after publishing each piece, everyone’s highlights (or summaries, or key points) are unique. The author of a piece has of course conveyed their position in the piece itself, but (except for perhaps an initial tweet, or the meta description contents of the page) we’re not often in the position of listing our own highlights.

I think that’s a shame, because there can be value in getting a sense of what the author of a piece feels is the main thrust of their own argument, or a sense of what they feel might be notable or quotable.

Accordingly, I’ve implemented a system to do that on this blog, which I hope to use in future. I’m also providing the relevant code so you reuse it yourself if you wish. I call these annotations Author Marks.

My design criteria were contradictory:

1. Don’t be visually intrusive, or imply arrogance.
2. Replicate highlighter-pens on paper.

As I thought about it a little more, I realised that Author Marks are somewhat like extras on a DVD; a little bit of additional content, which you must choose to view, giving some insight into the piece from the author’s perspective.

For simplicity, I decided to make use of the HTML5 mark tag to indicate those segments. This has the advantages of being semantically valid, portable, and readily accessible to user-specified stylesheets.

Highlighting of marks is off by default, but I’ve made a simple JavaScript which you, dear reader, can use to enable highlighting if you want to. The appropriate links are at the bottom of each article after my byline, but for the sake of demonstration I’ve also added one here:

Show Author Marks.

I’ve added some gratuitous marks in this article’s text so you can readily test the functionality. For example, this phrase has been marked. In actual usage, I’d try to limit the number of marks to a handful per article.

For those reading this in a feed reader, or with JavaScript disabled, here’s a screenshot of how it looks.

You can find the JavaScript in this github repository, complete with instructions for use.

I’ve gone back and added some marks to my Tail wagging piece as a sort of test run.

It’s my hope that this can serve as a way for me to provide a hint about my own sense of a piece’s key points, and highlight anything I think is particularly pithy. You’ll be free to either be complicit, or just amused at my own vanity or (in your opinion) misguidedness.

I’m very interested in further discussion on this topic – but do feel free to wilfully mischaracterise this article on Twitter instead.

IDC has new Worldwide statistics that show for Q1 2013 Android and iOS represented 92.3% of all smartphone OS Shipments. Android had a 75% market share, iOS 17.3%, Windows Phone 3.2% and BlackBerry 2.9%.

Related Articles:

• Android Anti-Virus Software Prone to Transformation Attacks
• App Vulnerabilities
• App Data Protection and Security
• I’ll be Speaking at the Free Make IT Mobile Event
• Accenture’s Predictions and Developer Opportunities
• Make IT Mobile

Changes in 1.5.1

• FIXED: Attributes “bleeding” into next paragraph

Changes in 1.5.2

• FIXED: Crash on parsing HTML with additional tags following HTML end tag
• FIXED: DTAttributedLabel problems being instantiated from NIB, ignoring edge insets
• FIXED: Crash on using font-family “inherit” together with font-variant “small-caps”.
• FIXED: Endless loop when using a text block that would not fully fit in a height-constrained layout frame
• FIXED: Image Attachment ignoring maximum display size if width/height are set via tag attributes
• FIXED: Invalid font-size would cause Core Text font size of 12px to be used.
• [Sponsored] CHANGED: Lists now correctly use padding and margin. If you specify too small a margin for the list prefix to fit, then the list prefix is omitted.

Contrary to how HTML browsers are displaying list prefixes (e.g. bullets) Core Text cannot draw outside of the laid out lines. This limitation became apparent if you specified a too large list indent margin to fit the prefix. Then the text would spill over the too closely set tab stops and be indented to the next standard tab stop. To prevent this from happening I implemented a check that tests to see if the margin is sufficiently wide to fit the prefix excluding white space.

The new version is tagged and available on the GitHub master branch. A new spec has been added to the CocoaPods public repository.

This release has one sponsor, as highlighted. Austrian company Antiloop is doing Ruby on Rails, iPhone and iPad development. They are big fans of DTCoreText and are using it in several apps, including:

• Ecoline for iPad
• Journal

Both apps make great use of rich text and are free downloads on the Apple App Store.