IAPHelper simply wraps the API of Apple’s In-App Purchase using Swift. Very lightweight and easy to use.

IAPHelper opens source and welcome to improve it.

IAPHelper Usage

Request Product List

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

var productIdentifiers = Set<ProductIdentifier>()
productIdentifiers.insert("product_id_1")
productIdentifiers.insert("product_id_2")
IAP.requestProducts(productIdentifiers) { (response, error) in
	if let products = response?.products where !products.isEmpty {
		// Get the valid products
	   
	} else if let invalidProductIdentifiers = response?.invalidProductIdentifiers {
		// Some products id are invalid
	   
	} else if error?.code == SKErrorPaymentCancelled {
		// User cancelled
	   
	} else {
		// Some error happened
	}
}

Purchase Product

1
2
3
4
5
6
7
8
9
10
11

 IAP.purchaseProduct(productIdentifier, handler: { (productIdentifier, error) in
	if let identifier = productIdentifier {
		// The product of 'productIdentifier' purchased.
	     
	} else if error?.code == SKErrorPaymentCancelled {
		// User cancelled
	     
	} else {
		// Some error happened
	}
})

Restore

1
2
3
4
5
6
7
8
9
10
11
12
13
14

 IAP.restorePurchases { (productIdentifiers, error) in
	 if !productIdentifiers.isEmpty {
	 	// Products restored
	   
	 } else if error?.code == SKErrorUnknown {
	 	// NOTE: if no product ever purchased, will return this error.
	   
	 } else if error?.code == SKErrorPaymentCancelled {
	 	// User cancelled
	   
	 } else {
	 	// Some error happened
	 }
}

Validate Receipt

1
2
3
4
5
6
7

IAP.validateReceipt(Constants.IAPSharedSecret) { (statusCode, products) in
	if statusCode == ReceiptStatus.NoRecipt.rawValue {
		// No Receipt in main bundle
	} else {
		// Get products with their expire date.
	}
})

Note: IAPHelper directly validate with Apple’s server. It’s simple, but has risk. You decide use your own server or not as Apple suggested:

Use a trusted server to communicate with the App Store. Using your own server lets you design your app to recognize and trust only your server, and lets you ensure that your server connects with the App Store server. It is not possible to build a trusted connection between a user’s device and the App Store directly because you don’t control either end of that connection.

Integrate IAPHelper in Your Project

Just copy IAPHelper.swift to your project, and use it as the demo shows.

IAPHelper Demo

NOTE: You need to change the app bundle id and product id to your own. And also set your shared secret in Constants.swift.

Note

This library can’t help you understand the basic concepts for IAP. For it, please refer to these documents.

• In-App Purchase Programming Guide
• In-App Purchase Configuration Guide for iTunes Connect
• In-App Purchase Best Practices
• Receipt Validation Programming Guide
• Adding In-App Purchase to your iOS and macOS Applications

What’s Test

It’s mainly test on macOS 10.10 with auto-renew subscription. Now it’s used by my app of iPic.

iptables works by matching each packet that crosses the networking interface against a set of rules (grouped by chains) to decide what to do (called target).

rules

The iptables firewall operates by comparing network traffic against a set of rules. The rules define the characteristics that a packet must have to match the rule, and the action that should be taken for matching packets.

chains

These rules are organized into groups called chains. A chain is a set of rules that a packet is checked against sequentially. When the packet matches one of the rules, it executes the associated action and is not checked against the remaining rules in the chain.
A user can create chains as needed. There are three chains defined by default. They are:
· INPUT: This chain handles all packets that are addressed to your server.
· OUTPUT: This chain contains rules for traffic created by your server.
· FORWARD: This chain is used to deal with traffic destined for other servers that are not created on your server.

policy

Each chain can contain zero or more rules, and has a default policy. The policy determines what happens when a packet does not match any rule. So policy could also be treated as the last rule in chain.

target

When the defined pattern matches, the action that takes place is called a target.

• A target can be a final policy decision for the packet, such as accept, or drop.
• It can also be move the packet to a different chain for processing, or simply log the encounter.
• There are many options.

IPv4 Versus IPv6

The netfilter firewall that is included in the Linux kernel keeps IPv4 and IPv6 traffic completely separate. For IPv6 traffic, a companion command called ip6tables is used.

Things to Keep in Mind

• First, we need to make sure that we have rules to keep current connections active if we implement a default drop policy. This is especially important if you are connected to your server through SSH.
• Another thing to keep in mind is that the order of the rules in each chain matter.
  • Rules near the top of a chain should have a higher level of specificity than rules at the bottom.
  • You should match specific cases first, and then provide more general rules to match broader patterns.
  • If a packet falls through the entire chain (doesn’t match any rules), it will hit the most general rule, the default policy.
  • For this reason, a chain’s default policy very strongly dictates the types of rules that will be included in the chain. A chain with the default policy of ACCEPT will contain rules that explicitly drop packets. A chain that defaults to DROP will contain exceptions for packets that should be specifically accepted.

List Rules

1

sudo iptables -S

Demo output:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

-P INPUT DROP
-P FORWARD DROP
-P OUTPUT ACCEPT
-N ICMP
-N TCP
-N UDP
-A INPUT -m conntrack --ctstate RELATED,ESTABLISHED -j ACCEPT
-A INPUT -i lo -j ACCEPT
-A INPUT -m conntrack --ctstate INVALID -j DROP
-A INPUT -p udp -m conntrack --ctstate NEW -j UDP
-A INPUT -p tcp -m tcp --tcp-flags FIN,SYN,RST,ACK SYN -m conntrack --ctstate NEW -j TCP
-A INPUT -p icmp -m conntrack --ctstate NEW -j ICMP
-A INPUT -p udp -j REJECT --reject-with icmp-port-unreachable
-A INPUT -p tcp -j REJECT --reject-with tcp-reset
-A INPUT -j REJECT --reject-with icmp-proto-unreachable
-A TCP -p tcp -m tcp --dport 22 -j ACCEPT

List Specific Chain

Specify the chain name directly after the -S option.

1

sudo iptables -S INPUT

Demo output:

1
2
3
4
5
6
7

-P INPUT ACCEPT
-A INPUT -s 39.187.179.166/32 -j DROP
-A INPUT -i lo -j ACCEPT
-A INPUT -m state --state RELATED,ESTABLISHED -j ACCEPT
-A INPUT -p tcp -m tcp --dport 22 -j ACCEPT
-A INPUT -p tcp -m tcp --dport 80 -j ACCEPT
-A INPUT -p icmp -m icmp --icmp-type 8 -j ACCEPT

##List Rules as Tables
Listing the iptables rules in the table view can be useful for comparing different rules against each other.

1

sudo iptables -L

This will output all of current rules sorted by chain.

1

sudo iptables -L INPUT --line-numbers

Demo output:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

Chain INPUT (policy ACCEPT)
num  target     prot opt source               destination         
1    f2b-shadowsocks  tcp  --  anywhere             anywhere             multiport dports 6000:6100
2    f2b-mysqld-auth  tcp  --  anywhere             anywhere             multiport dports mysql
3    f2b-php-url-fopen  tcp  --  anywhere             anywhere             multiport dports http,https
4    f2b-nginx-botsearch  tcp  --  anywhere             anywhere             multiport dports http,https
5    f2b-nginx-http-auth  tcp  --  anywhere             anywhere             multiport dports http,https
6    f2b-sshd-ddos  tcp  --  anywhere             anywhere             multiport dports 7022
7    f2b-sshd   tcp  --  anywhere             anywhere             multiport dports 7022
8    DROP       all  --  39.187.179.166       anywhere            
9    ACCEPT     all  --  anywhere             anywhere            
10   ACCEPT     all  --  anywhere             anywhere             state RELATED,ESTABLISHED
11   ACCEPT     tcp  --  anywhere             anywhere             tcp dpt:ssh
12   ACCEPT     tcp  --  anywhere             anywhere             tcp dpt:http
13   DROP       tcp  --  anywhere             anywhere             tcp dpt:mysql
14   ACCEPT     icmp --  anywhere             anywhere             icmp echo-request

The first line of output indicates the chain name (INPUT, in this case), followed by its default policy (DROP). The next line consists of the headers of each column in the table, and is followed by the chain’s rules.

• target: If a packet matches the rule, the target specifies what should be done with it. For example, a packet can be accepted, dropped, logged, or sent to another chain to be compared against more rules
• prot: The protocol, such as tcp, udp, icmp, or all
• opt: Rarely used, this column indicates IP options
• source: The source IP address or subnet of the traffic, or anywhere
• destination: The destination IP address or subnet of the traffic, or anywhere

The last column, which is not labeled, indicates the options of a rule.

Add Rules

Accept connection on port 22 for ssh:

1

sudo iptables -A INPUT -p tcp --dport 22 -j ACCEPT

• -A INPUT: The -A flag appends a rule to the end of a chain (here the chain is INPUT). In another side -I INPUT 2 means insert to the 2nd rule of INPUT chain.
• -p tcp: This option matches packets if the protocol being used is TCP.
• --dport: This option is available if the -p tcp flag is given. It gives a further requirement of matching the destination port for the matching packet.
• -j ACCEPT: This specifies the target of matching packets.

Delete Rules

Delete Rule by Specification

For example, if you want to delete the rule that drops invalid incoming packets (-A INPUT -m conntrack –ctstate INVALID -j DROP), you could run this command:

1

sudo iptables -D INPUT -m conntrack --ctstate INVALID -j DROP

Note that the -A option, which is used to indicate the rule position at creation time, should be excluded here.

Delete Rule by Chain and Number

To determine a rule’s line number, list the rules in the table format and add the –line-numbers option:

1

sudo iptables -L --line-numbers

Then run theiptables -D command followed by the chain and rule number.

1

sudo iptables -D INPUT 3

Drop Rules

There’re 2 ways for drop:

• Set the default policy for chain as ACCEPT. Then if a connection doesn’t march any rules in the chain, it will be accepted.
  • If using this way, need to set drop rule one by one. If missed on, it will be security hole.
• Set the default policy for chain as DROP. Then if a connection doesn’t march any rules in the chain, it will be dropped.
  • If using this way, only need to set accept rules. All others will be dropped by default. It’s strict but safe.

Set policy of chain to ACCEPT or DROP:

1
2

sudo iptables -P INPUT ACCEPT
sudo iptables -P INPUT DROP

Add a DROP rule in INPUT chain:

1

sudo iptables -A INPUT -j DROP

Block an IP Address

To block network connections that originate from a specific IP address, 15.15.15.51 for example, run this command:

1

sudo iptables -A INPUT -s 15.15.15.51 -j DROP

If you want to reject the connection instead, which will respond to the connection request with a “connection refused” error, replace “DROP” with “REJECT” like this:

1

sudo iptables -A INPUT -s 15.15.15.51 -j REJECT

Show Packet Counts and Aggregate Size

This is often useful when trying to get a rough idea of which rules are matching against packets. For example, let’s look at the INPUT chain again, with the -v option:

1

sudo iptables -L INPUT -v

Example: Verbose Listing

1
2
3
4
5
6
7
8
9
10
11

Chain INPUT (policy DROP 0 packets, 0 bytes)
 pkts bytes target     prot opt in     out     source               destination
 284K   42M ACCEPT     all  --  any    any     anywhere             anywhere             ctstate RELATED,ESTABLISHED
    0     0 ACCEPT     all  --  lo     any     anywhere             anywhere
    0     0 DROP       all  --  any    any     anywhere             anywhere             ctstate INVALID
  396 63275 UDP        udp  --  any    any     anywhere             anywhere             ctstate NEW
17067 1005K TCP        tcp  --  any    any     anywhere             anywhere             tcp flags:FIN,SYN,RST,ACK/SYN ctstate NEW
 2410  154K ICMP       icmp --  any    any     anywhere             anywhere             ctstate NEW
  396 63275 REJECT     udp  --  any    any     anywhere             anywhere             reject-with icmp-port-unreachable
 2916  179K REJECT     all  --  any    any     anywhere             anywhere             reject-with icmp-proto-unreachable
    0     0 ACCEPT     tcp  --  any    any     anywhere             anywhere             tcp dpt:ssh ctstate NEW,ESTABLISHED

Reset Packet Counts and Aggregate Size

They also reset if a reboot occurs. This is useful if you want to see if your server is receiving new traffic that matches your existing rules.

To clear the counters for all chains and rules, use the -Z option by itself:

1
2
3

sudo iptables -Z
sudo iptables -Z INPUT
sudo iptables -Z INPUT 1

Save iptables Configuration

By default, the rules that you add to iptables are ephemeral. This means that when you restart your server, your iptables rules will be gone. The easiest way to save is with the iptables-persistent package.

1
2

sudo apt-get update
sudo apt-get install iptables-persistent

Once the installation is complete, you will have a new service called iptables-persistent that is configured to run at boot. This service will load in your rules and apply them when the server is started.

If you ever update your firewall and want to preserve the changes, you must save your iptables rules for them to be persistent.

1

sudo service netfilter-persistent save

This will overwrite your /etc/iptables/rules.v4 and /etc/iptables/rules.v6 files with the policies you crafted on the command line.

1
2
3

/etc/iptables.rules 
/etc/iptables/rules.v4
/etc/iptables/rules.v6

Create Your Own Firewall by iptables

Pre-condititions:

• Backup existing iptables. Could just copy output of sudo iptables -S, or copy rules saved by iptables-persistent as mentioned above.
• If you lock yourself from accessing using ssh, make sure you have other ways to access it.

Create Protocol-Specific Chains

1
2
3

sudo iptables -N UDP
sudo iptables -N TCP
sudo iptables -N ICMP

Enable ssh, http, https:

1
2

sudo iptables -A TCP -p tcp --dport 22 -j ACCEPT
sudo iptables -A TCP -p tcp --dport 80,443 -j ACCEPT

Enable other custom service:

1
2

sudo iptables -A TCP -p tcp --dport 8000:8010 -j ACCEPT
sudo iptables -A UDP -p udp --dport 8000:8010 -j ACCEPT

Create General Purpose Accept and Deny Rules

First, we will create an exception to accept all traffic that is part of an established connection or is related to an established connection:

1

sudo iptables -A INPUT -m conntrack --ctstate ESTABLISHED,RELATED -j ACCEPT

Allow all traffic originating on the local loopback interface.

1

sudo iptables -A INPUT -i lo -j ACCEPT

Finally, we want to deny all invalid packets.

1

sudo iptables -A INPUT -m conntrack --ctstate INVALID -j DROP

Creating the Jump Rules to the Protocol-Specific Chains

Direct traffic in the INPUT chain into the appropriate protocol-specific chains.

1
2
3

sudo iptables -A INPUT -p udp -m conntrack --ctstate NEW -j UDP
sudo iptables -A INPUT -p tcp --syn -m conntrack --ctstate NEW -j TCP
sudo iptables -A INPUT -p icmp -m conntrack --ctstate NEW -j ICMP

Reject All Remaining Traffic

If a packet that was passed to a protocol-specific chain did not match any of the rules within, control will be passed back to the INPUT chain. Anything that reaches this point should not be allowed by our firewall. We will deny the traffic using the REJECT target, which sends a response message to the client.

Attempting to reach a closed UDP port will result in an ICMP “port unreachable” message.

1

sudo iptables -A INPUT -p udp -j REJECT --reject-with icmp-port-unreachable

Attempting to establish a TCP connection on a closed port results in a TCP RST response:

1

sudo iptables -A INPUT -p tcp -j REJECT --reject-with tcp-reset

For all other packets, we can send an ICMP “protocol unreachable” message to indicate that the server doesn’t respond to packets of that type:

1

sudo iptables -A INPUT -j REJECT --reject-with icmp-proto-unreachable

Adjusting Default Policies

Set the default policy to DROP as a precaution.

1
2
3

sudo iptables -P INPUT DROP
sudo iptables -P FORWARD DROP
sudo iptables -P OUTPUT ACCEPT

Saving iptables Rules

1
2
3

sudo service netfilter-persistent save
or 
sudo /etc/init.d/iptables-persistent save

This will overwrite your /etc/iptables/rules.v4 and /etc/iptables/rules.v6 files with the policies you crafted on the command line.

Test your Firewall Configuration with Nmap and Tcpdump

https://www.digitalocean.com/community/tutorials/how-to-test-your-firewall-configuration-with-nmap-and-tcpdump

Preconditions:

• Install tcpdump build-essential libssl-dev, nmap

Scan your Target for Open TCP Ports

Setting Up the Packet Capture

1

sudo tcpdump host target_ip_addr -w ~/scan_results/syn_scan/packets

With tcpdump recording our traffic to the target machine, we are ready to run the SYN scan using nmap.

1

sudo nmap -sS -Pn -p- -T4 -vv --reason -oN ~/scan_results/syn_scan/nmap.results target_ip_addr

The results are saved in ~/scan_results/syn_scan/nmap.results.

Scan your Target for Open UDP Ports

Setting Up the Packet Capture

1

sudo tcpdump host target_ip_addr -w ~/scan_results/udp_scan/packets

Run the UDP Scan

1

sudo nmap -sU -Pn -p- -T4 -vv --reason -oN ~/scan_results/udp_scan/nmap.results target_ip_addr

The results are saved in ~/scan_results/syn_scan/nmap.results.

Host and Service Discovery

Discovering the Versions of Services on the Server

1

sudo nmap -sV -Pn -p 22,80 -vv --reason -oN ~/scan_results/versions/service_versions.nmap target_ip_addr

Discovering the Host Operating System

1

sudo nmap -O -Pn -vv --reason -oN ~/scan_results/versions/os_version.nmap target_ip_addr

References

• https://www.digitalocean.com/community/tutorials/how-the-iptables-firewall-works
• https://www.digitalocean.com/community/tutorials/how-to-set-up-a-firewall-using-iptables-on-ubuntu-14-04
• https://www.digitalocean.com/community/tutorials/how-to-list-and-delete-iptables-firewall-rules

MacGoogleAnalytics is an open source library to use Google Analytics on Mac OS X.

Introduction

As we know, Google Analytics is perfect for user data collection and analytics. But unfortunately, there’s no official SDK for Mac OS X.

But still, there’re several ways to use Google Analytics on Mac OS X. MacGoogleAnalytics may be what you found.

Overall, there’re 2 parts work together to use Google Analytics.

• HTML File

  • This is the real place to send data to Google Analytics server. It uses Google Analytics’s standard JavaScript API.

• Mac OS X Part

  • In Mac OS X side, it loads the html file just mentioned. Send data like event to the html file as parameters. And then these data will be send in the html file through the JavaScript API.

HTML File

You can find the html file in source > html > gapp.html.

Parameter of HTML File

The parameter of the html file is exactly the same with normal html file.

1

/gapp.html?param1=paramValue1&param2=paramValue2&...

Demo of the html file with full parameters:

1

/gapp.html?id=UA-12345678-1&name=ihosts&version=1.1.0&ca=menu&ev=click&la=rate

Here are the supported parameter list.

• id
  • The Google Analytics id, e.g., ‘UA-12345678-1’.
  • Note: When you create a Google Analytics id, use the ‘Mobile app‘, but not ‘Website’.

• name
  • The product name, e.g., ‘ihosts’ for iHosts. You can track different products using same Google Analytics id, even I don’t suggest you do that.
• version
  • The app’s version, e.g., ‘1.2.1’.
• ca (optional)
  • The Google Analytics event category name.
• ev (optional)
  • The Google Analytics event action name.
• la (optional)
  • The Google Analytics event label value.

Note: The full url include the parameters will be encoded. So no need to worry about the characters are valid or not. They will all be valid.

Deploy the HTML File

The html file should be deployed to a domain before it can be accessed. I deployed it at GitHub with my domain, you can feel free to use it.

1

http://atjason.com/MacGoogleAnalytics/gapp.html

You can also deploy it to your server with your domain.

Tip: you may want to reduce the html file size by compressing the JavaScript code in it. Thus it will be faster to download.

Mac OS X Part

There’s only 2 files needed for Mac OS X part: GoogleAnalytics.swift and GoogleAnalytics.swift.

GoogleAnalytics.swift

Good news is, you even don’t need to touch this file.

This is the key file to integrate with Google Analytics. If you read the code, you will find it in fact loads the html file in a WebView, and combine the data as parameters for the html.

GoogleAnalyticsHelper.swift

This class help you easily use Google Analytics.

Don’t worry, you only need to update these properties:

• GAID
  • The Google Analytics id, e.g., ‘UA-12345678-1’. This is the ‘id’ used as parameter of html file.
• GAName
  • The product name, e.g., ‘ihosts’ for TODO iHosts Link. This is the ‘name’ used as parameter of html file.
• PingURL
  • The full url of gapp.html, e.g., ‘http://atjason.com/MacGoogleAnalytics/gapp.html‘ mentioned above, or the url you deployed.
• PingTimeInterval
  • By default it’s 6h. It means telling Google Analytics every 6h that ‘hey, I’m alive’. This will help Google Analytics to calculate the active users.

Demo Project Using Swift

How to integrate MacGoogleAnalytics in your project? Just put the GoogleAnalytics.swift and GoogleAnalyticsHelper.swift in your project.

Then, you need to start Google Analytics when app finished launching, stop it when app will terminate.

1
2
3
4
5
6
7

func applicationDidFinishLaunching(aNotification: NSNotification) {    
  GAHelper.startGoogleAnalytics()
}
  
func applicationWillTerminate(notification: NSNotification) {
  GAHelper.stopGoogleAnalytics()
}

The main usage of Google Analytics is to send event. How to send the event? Just as simple as following code.

1

GA.sendEvent("menu", event: "click", label: "rate")

That’s all.

Work With HTTP

When run your project with MacGoogleAnalytics, you may meet this error:

App Transport Security has blocked a cleartext HTTP (http://) resource load since it is insecure. Temporary exceptions can be configured via your app’s Info.plist file.

Apple disable http access by default for security reason. If you really need to use http, could manually allow it. Open Info.plist, and add the following lines:

1
2
3
4
5

<key>NSAppTransportSecurity</key>
<dict>
<key>NSAllowsArbitraryLoads</key>
<true/>
</dict>

Please keep in mind that this solution should be your last resort. You’d ideally want to enable HTTPS on your service, or next, whitelist domains on which you want HTTP and if none of this is possible, then use this approach.

Demo Project Using Objective C

TODO

View Data in Google Analytics Site

After data are collected, you can view them in Google Analytics as normal: https://analytics.google.com/analytics/web/. During debug, you can also check whether it works or not in ‘Real-Time’.

Just give a tip for OS X version. In the demo app using swift, it collect event of options > option_a > yes or no. You may want to know, how many users enable this option in OS X 10.10 and how many for 10.11. How to do it?

Open the Behavior > Events > Top Events, select options > option_a. Here you should be able to see all the events. Then add a new custom Segment, in Technology > Operating System Version, add contains ‘10.10’, save it as ‘OS X 10.10’. Add another Segment for ‘OS X 10.11’.

And then, apply the Segments, it could distinguish the data of OS X 10.10 or 10.11.

Release on Mac App Store

Yes, this way could be released on Mac App Store. In fact, these of my apps have already released on Mac App Store.

• iHosts
• Daily Clipboard
• Attention Timer

Show Your Product

If your product using MacGoogleAnalytics and you’d like to share it here, pull requests welcome :)

Donate

If you think Mac Google Analytics is helpful for you, welcome to donate :)

1
2
3

@IBAction func textFieldAction(sender: NSTextField) {
    print(sender.stringValue)
}

Connect NSTextField’s Action to Delegate’s One

Set NSTextField’s Action Type

• Open ‘Build Settings’ for Project (not target)
• Search ‘Swift Compiler - Custom Flags‘. Add a -D DEBUG entry in Other Swift Flags

Use Debug Flag in Swift

1
2
3
4
5

#if DEBUG
    print("I'm running in DEBUG mode")
#else
    print("I'm running in a non-DEBUG mode")
#endif

Development environment:

• OS X: 10.11.4
• XCode: 7.3
• Swift: 2.2

Auto Layout and Double-Length Pseudolanguage

For localized app, typically you need to set the UI to ‘Auto Layout‘. As the same string in different languages may have very different length, the ‘auto layout’ could let each language corecttly display.

How to test the auto layout correclty work or not? Beside really test the app with different language, you can also use ‘Double-Length Pseudolanguage‘. This localization simply takes the text of your development language, and doubles it. So, for example, “Tell the World” becomes “Tell the World Tell the World.” While many pieces of text won’t actually double in length when translated to another langauge, it serves as a great way to test to see whether your interface can handle the wide variation in length.

Steps to preview a localization in Interface Builder:

• In project navigator, select the .storyboard or .xib file you want to preview.
• Choose View > Assistant Editor > Show Assistant Editor.
• In the assistant editor jump bar, open the Assistant pop-up menu, scroll to and choose the Preview item, and choose the .storyboard or .xib file from the submenu.
  If a preview of the app’s user interface doesn’t appear in the assistant editor, select the window or view you want to preview in the icon or outline view.

• In the assistant editor, choose the localization you want to preview from the language pop-up menu in the lower-right corner.

Now, a preview of the localization appears in the assistant editor. If you choose a real language, strings that do not need to be localized or need to be localized, but currently are not, appear in uppercase.

Use Localized String in Code

The key is to use NSLocalizedString function. It could load localized text from the localized string file.

To explicit ordering of tokens in format strings, could use %1$@, %2$@, etc.

The related code is:

1
2
3
4
5
6
7
8
9

func setLabelStrings() {
  let dateFormatter = NSDateFormatter()
  dateFormatter.dateStyle = .NoStyle
  dateFormatter.timeStyle = .ShortStyle
  let dateString = dateFormatter.stringFromDate(NSDate())
  
  question = NSLocalizedString("Q: What's the time now?", comment: "Question")
  answer = String(format: NSLocalizedString("A: It's %@.", comment: "Answer"), dateString)
}

Add Localization Language for Project

Add a new localization to the project could make Xcode aware that you want to start translating files into that language, which means you can do things like select that language in the Preview assistant.

• Select the project in the project navigator.
  Note: It’s PROJECT, but not targets.
• Add the new localization.
  Scroll down to the Localizations section. Click the + button, and select ‘Chinese (Simplified)’ from the menu that appears

• Select the files you want to localize.
  Xcode will ask you which files you want to translate into the new language. At this stage, there will only be a single file: the app’s interface, stored in MainMenu.xib. It’s selected by default, so click Finish.
  Note: select “Locializable Strings”, but not ‘Interface Builder Story’.

• A new file will be created: a strings file for the storyboard file. It’ll appear as an item inside the storyboard file, in the project navigator.

Add Localizations Files

To well organize the localized strings, it’s better we manually add 2 string files here: ‘Localizable.strings‘ and ‘InfoPlist.strings‘. ‘Localizable.strings’ will store the strings in app. For ‘InfoPlist.strings’, please check the following introduction.

Localizing Property List Values

The values for many keys in an information property list file are human-readable strings that are displayed to the user by the Finder or your own app. When you localize your app, you should be sure to localize the values for these strings in addition to the rest of your app’s content.

Localized values are not stored in the Info.plist file itself. Instead, you store the values for a particular localization in a strings file with the name ‘InfoPlist.strings‘. You place this file in the same language-specific project directory that you use to store other resources for the same localization. The contents of the InfoPlist.strings file are the individual keys you want localized and the appropriately translated value. The routines that look up key values in the Info.plist file take the user’s language preferences into account and return the localized version of the key (from the appropriate InfoPlist.strings file) when one exists. If a localized version of a key does not exist, the routines return the value stored in the Info.plist file.

Add ‘Localizable.strings’ and ‘InfoPlist.strings’

Before add the strings files, it’s better to add a ‘Localizations’ group in project. And it’s also better to create the corresponding folder in Finder.

Now it’s time really add the string files.

• Create a new file in the project: a strings file. You’ll find this in the Resource section of the file templates. Name the file as ‘Localizable.strings’, save in the ‘Localizations’ folder.

• Select the ‘Localizable.strings’ file. Open the ‘File Inspector’ and scroll down to Localizations.
  Click the Localize button. A menu will appear; choose Base and click Localize.

Now the localization option has changed, with three small checkboxes, one for Base, one for English, and the last for Chinese Simplified. Select Base and Chinese Simplified. In fact the Base is just English as we choose English as development language.

Now create ‘InfoPlist.strings’ and did same settings as ‘Localizable.strings’. The difference is, save the ‘InfoPlist.strings’ in same level of ‘Localizations’ in Finder, but still in the ‘Localizations’ group in project. After set it as localization, it will auto matically be moved to ‘Base.lproj’ and ‘zh-Hans.lproj’ in Finder.

How to localize the app’s name displayed with app icon in Finder? Add this string in Base version of ‘InfoPlist.strings’:

1
2

/* App Name */
"CFBundleDisplayName" ="Localization Demo";

And add this for the Chinese Simplified version:

1
2

/* App Name */
"CFBundleDisplayName" ="本地化示例";

NOTE
It’s important to use the file names of ‘InfoPlist.strings’ and ‘Localizable.strings’, as the app will look for the files with these names.

After added, the files in Finder will looks like:

Edit Localization Files

There’re 2 ways to edit the localization files: Direclty Edit and Using .xliff Files. Now let’s introduce the .xliff files.

Normally, you don’t translate the app by yourself, but let some others who are expert for the language to do it. How to cooperate with them? Use .xliff file.

Export .xliff Files

• Select the root of the project.
• Select ‘Editor’ menu > ‘Export for localization…’. In the popup dialog, select where to store the files. Need to select ‘Chinese (Simplied)’ in languages. This means export the .xliff file for the languages selected. Click ‘Save’.
  
• Open the ‘zh-Hans.xliff’ you just saved. You can see it’s like a xml file.

Edit parts for ‘Localizable.strings’. Find the following part, add <target>...</target> under the <source>A: It's %@.</source>. This is just the core of ‘localization’.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

<file original="LocalizationDemo/Localizable.strings" source-language="en" datatype="plaintext" target-language="zh-Hans">
  <header>
    <tool tool-id="com.apple.dt.xcode" tool-name="Xcode" tool-version="7.3" build-num="7D175"/>
  </header>
  <body>
    <trans-unit id="A: It's %@.">
      <source>A: It's %@.</source>
      <target>答：现在是 %@。</target>
      <note>Answer</note>
    </trans-unit>
    <trans-unit id="Q: What's the time now?">
      <source>Q: What's the time now?</source>
      <target>问：现在几点了？</target>
      <note>Question</note>
    </trans-unit>
  </body>
</file>

Import .xliff Files

• Select the root of the project.
• Select ‘Editor’ menu > ‘Import localization…’. In the popup dialog, select the ‘zh-Hans.xliff’ you just modified. It should pop up a dialog to show the difference between the files in project and the one you just modified. Click ‘Import’ if it’s fine.

After it’s done, open the ‘InfoPlist.strings’ or ‘Localizable.strings’, you should be able to say the new translated strings. Did you remember I just said there’re 2 ways to edit the string files, and another one is directly edit it? Here it is, you can directly edit the files and add the strings like you added through .xliff.

Special Tips
Seems XCode has issue. If you project has test or other target, if you import the modified strings for the first, the XCode may crash.
The solution is, export strings, don’t change it and import again.
I guess this mainly let the test or other project be localized. Even you don’t need to localize them, but have to do it to walk around XCode’s issue (again, it’s what I guess).

Test Localization

There’re 2 ways to test the localization.

1. Change System’s Language

Open ‘System Preferences’ > ‘Language & Region’, you can drag Chinese Simplied to top of the list to activate it. You can also change the ragion.

The disadvantage of this way is, you need to reboot to let the change work. And the entire system’s language will be changed. How only change the language for the app? Check the following way.

2. Use XCode’s Scheme

You can make Xcode launch the application using the special langauge or region.
To do this, you can duplicate current scheme, name it as ‘Chinese (Simplified)’. Open the Options panel. Change the Application Language from System Language to ‘Chinese (Simplified)’.

Now, run the app, it should look like:

Development environment:

• OS X: 10.11.4
• XCode: 7.3
• Swift: 2.2

Enable ‘launch at login’ in Mac App Store

Beside works in sandbox mode, to enable ‘launch at login’ in Mac App Store, should mee this requirement:

2.26 Apps that are set to auto-launch or to have other code automatically run at startup or login without user consent will be rejected.

How to deal with it?
Easy, just add a checkbox in Preferences to let user choose auto launch or not. And, make sure, do NOT enable it by default. Otherwise Apple will reject it (I was ever rejected for this reason).

Steps

The precondition is, you already setup your normal project.

Add New Target of Helper

Add a new target of your project. You can name the target as “XHelper”, and “X” is your main project.
Note: to reduce app’s size, choose the Language of ‘Objective-C’. No worry, only a few code is needed.

Settings for Helper Target

Let the helper works in the background and doesn’t display a Dock icon.
Open the Info tab for the helper target.

• Under the ‘Custom OS X Application Target Properties’ section, add a new row with the Key ‘Application is background only’ and the Boolean value of ‘YES’.

Next, let the helper target skips the install when the base application also gets installed. To do this:
Open the Build Settings tab for the helper target.

• Search for ‘Skip Install’, setting this option to ‘YES’

Settings for Main Target

Open the Build Settings tab for the main target.

• Search for the item called ‘Strip Debug Symbols During Copy’, and set this item to ‘NO’.

Open the Build Phases tab for the main target

• If you don’t already have a ‘Copy Files’ phase, then add one by selecting the small + sign in the top left corner of this section.
• Expand the ‘Copy Files’ phase, and select ‘Wrapper’ from the Destination drop-down menu
• In the Subpath section, type the following path: “Contents/Library/LoginItems“
• Select the + button for the Name section, then search for and add the ‘X Helper.app’ application bundle from the source list that appears, and select it in the list. Click ‘Add’ when done.

This will ensure that the Helper target is copied into our application bundle when we compile the project.

Code for Helper Target

First, remove the menu and base window in the Helper app’s XIB file.

Open AppDelegate.m, add these code in applicationDidFinishLaunching. It will find out the path for the main application, launch it, and then terminate itself.

1
2
3
4
5
6
7

- (void)applicationDidFinishLaunching:(NSNotification *)aNotification {
  NSArray *pathComponents = [[[NSBundle mainBundle] bundlePath] pathComponents];
  pathComponents = [pathComponents subarrayWithRange:NSMakeRange(0, [pathComponents count] - 4)];
  NSString *path = [NSString pathWithComponents:pathComponents];
  [[NSWorkspace sharedWorkspace] launchApplication:path];
  [NSApp terminate:nil];
}

Code for Main Target

There’re mainly 2 parts.

Add Preferences

This is mainly to remember user’s choice to auto launch or not. For details, refer to my another project for Preferences.

Set Auto Launch

This step is in fact easy. The core is function of SMLoginItemSetEnabled. Remember to import ServiceManagement.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

import Cocoa
import ServiceManagement
class MainWindowController: NSWindowController {   
  @IBAction func set(sender: NSButton) {    
    let appBundleIdentifier = "com.atjason.swift.cocoa.AutoLaunchHelper"
    let autoLaunch = (autoLaunchCheckbox.state == NSOnState)
    if SMLoginItemSetEnabled(appBundleIdentifier, autoLaunch) {
      if autoLaunch {
        NSLog("Successfully add login item.")
      } else {
        NSLog("Successfully remove login item.")
      }
      
    } else {
      NSLog("Failed to add login item.")
    }
  }
}

Test Auto Launch

In theory, your app and helper should meet these requirements:

• Move the app in the /Applications folder.
• Both the main and Helper application are signed.
• Both the main and Helper application are sandboxed.

But in fact, when my test app meet none of the requirements above, it still can auto lauch after reboot. Not sure why, but if you plan to release your app in Mac App Store, obviously these requirements will be met.

Good luck.

Development environment:

• OS X: 10.11.4
• XCode: 7.3
• Swift: 2.2

After it’s finished, the app looks like:

NSTabViewController

The mainly used class is NSTabViewController.
An NSTabViewController object is a container view controller that manages a tab view interface, which organizes multiple pages of content but displays only one of those pages at a time. Each page of content is managed by a separate child view controller. Navigation between child view controllers is accomplished with the help of an NSTabView object, which the tab view controller manages. When the user selects a new tab, the tab view controller displays the content associated with the associated child view controller, replacing the previous content.

Storyboard

Storyboard isn’t necessary to build preferences window, but it could let the workflow be clear and simple.

Preference Manager

Typically there’re many settings in preferences. To make it easy to manage all of them, it’s better to use one singleton class to access them, e.g., register factory defaults, read, write, reset, etc.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

class PreferenceManager {
  // Single instance
  static let sharedInstance = PreferenceManager()
    
  private init() {
    registerFactoryDefaults()
  }
  
  let userDefaults = NSUserDefaults.standardUserDefaults()
  
  private let initializedKey = "Initialized"
  
  var startAtLogin: Bool {
    get {
      return userDefaults.boolForKey(startAtLoginKey)
    }
    
    set {
      userDefaults.setBool(newValue, forKey: startAtLoginKey)
    }
  }
 
  private func registerFactoryDefaults() {
    let factoryDefaults = [
      initializedKey: NSNumber(bool: false),
    ]
    
    userDefaults.registerDefaults(factoryDefaults)
  }
  
  func synchronize() {
    userDefaults.synchronize()
  }
  
  func reset() {
    userDefaults.removeObjectForKey(initializedKey)    
    synchronize()
  }
}

Bind with User Defaults

Beside using class PreferenceManager, you can also directly bind object’s value to user defaults.

Register Factory Defaults

It’s better each setting has default value. NSUserDefaults.registerDefaults works for it.
Note: The contents of the registration domain are not written to disk; you need to call this method each time your application starts. You can place a plist file in the application’s Resources directory and call registerDefaults: with the contents that you read in from that file.

Archive

To store data in user defaults, the object need to support archvie. For key based archive, the class need to conform to NSCoding. For more introduction, please refer to here.

Store Tab View’s Size

If you allow user to resize the size of each tab view, its better to store them in user defaults, and restore when user access preferences window again. But as the structure of NSSize doesn’t support archive, you need to use a class to archive it.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

class SizeArchiver: NSObject, NSCoding {
  private static let sizeKey = "Size"
  
  var size = NSSize()
  
  var width: CGFloat {
    return size.width
  }
  
  var height: CGFloat {
    return size.height
  }
  
  override init() {
    super.init()
  }
  
  init(size: NSSize) {
    super.init()
    
    self.size = size
  }
  
  // MARK: - NSCoding
  
  required init?(coder aDecoder: NSCoder) {
    super.init()
    
    self.size = aDecoder.decodeSizeForKey(SizeArchiver.sizeKey)
  }
  
  func encodeWithCoder(aCoder: NSCoder) {
    aCoder.encodeSize(self.size, forKey: SizeArchiver.sizeKey)
  }
}

Development environment:

• OS X: 10.11.4
• XCode: 7.3
• Swift: 2.2

After it’s finished, the app looks like:

Storyboard introduction

With storyboards, you can combine as much (or as little) of your application as you want in one canvas, as well as visualize how the parts relate to each other.
Storyboards are organized by scenes (windows and views), which are connected to each other by segues. Segues describe the scenes’ relationships to one another. Storyboards can be used to describe a window and its popover or sheet – or a complicated graph of nested views, each with its own view controller, which previously would have necessitated programmatic construction.
Storyboards were added to OS X in 10.10 Yosemite and to iOS in version 5.

To create the relationship segue between the window controller and the split view controller, control-drag from the blue Window Controller icon in the border on top of the window controller down to the split view controller. In the pop-up Relationship Segue window that appears, select window content.

How is the Storyboard Loaded?

Just like with MainMenu.xib, the answer is in the Info.plist.
If you check the Info.plist for this project you will see that the key NSMainStoryboardFile is set to Main.

Scenes can also be loaded from storyboards programmatically. The NSStoryboard class provides this, much like NSBundle does for NIB loading. Within a storyboard, one scene can be designated as the initial controller. This is used in the application’s Main.storyboard to designate the application window to be opened at launch.

Controllers within a storyboard can also be instantiated by their identifier, which is set in the identity inspector. If you had a view controller with an identifier of Palette, you could instantiate the view controller and show it in a window using the following code:

1
2
3
4
5
6
7

if let storyboard = NSStoryboard(name: "Main", bundle: nil) {
    if let vc = storyboard.instantiateControllerWithIdentifier("Palette")
            as? NSViewController {
        paletteWindow = NSWindow(contentViewController: vc)
        paletteWindow.makeKeyAndOrderFront(nil)
    }
}

Development environment:

• OS X: 10.11.4
• XCode: 7.3
• Swift: 2.2

After it’s finished, the app looks like:

How to Run as Status Bar App?

In another word, how to make the application not show a dock icon? The key point is to modify the application’s Info.plist file and indicate that it’s an agent. “Agent” is Apple’s term for a background application that doesn’t present a dock icon.
Select the project at the top of the project navigator. Open the Info tab at the top of the main editor. Add a new entry of Application is agent (UIElement) and set the value of this entry to YES.

How to Let Status App Start?

It’s better don’t write much code in AppDelegate or other single class. To do it, I split main code in these 2 controllers:

1. StatusItemController
   This controller is mainly to ‘start’ the app, i.e., init the status bar item. And also set the menu for status bar item.

2. StatusMenuController
   This controller mainly works as the delegate of status bar item’s menu. E.g., implement the actions of menu items.

Then, how to let the app start? Steps:

• Open ‘MainMenu.xib’.
• Create Menu and sub-menus.

• Add an Object. Set its class to ‘StatusMenuController’.

• Add another Object of ‘StatusItemController’.
• Connect Menu object to StatusMenuController’s ‘menu’ outlet.

• Connect StatusMenuController to StatusItemController’s ‘menuController’ outlet.

• Open StatusItemController.swift, init the status bar item in ‘awakeFromNib’.

  1 2 3 4 5 6 7 8 9 10 11

  class StatusItemController: NSObject { var statusItem: NSStatusItem! @IBOutlet weak var menuController: StatusMenuController! override func awakeFromNib() { statusItem = NSStatusBar.systemStatusBar() .statusItemWithLength(NSVariableStatusItemLength) statusItem.title = "App" statusItem.highlightMode = true statusItem.menu = menuController.menu } }

That’s it. Now the app should be able to correctly start. As you can see, the key point is, app will init the ‘MainMenu.xib’ (as defined in Info.plist > ‘Main nib file base name’), then all the objects in ‘MainMenu.xib” will be created. So, the menu and controllers you added in ‘MainMenu.xib” will be created. Clear?

In this case, the AppDelegate could even keep empty. Cool, right?

1
2

@NSApplicationMain
class AppDelegate: NSObject, NSApplicationDelegate {}

How to Show Percent in Status Bar?

There’s class of NSProgressIndicator. The fact of it is a view. Thus the problem becomes how to add this view to status bar.

You will find, the NSStatusItem.view is nil, thus you can’t add to its subview. From the API of NSStatusItem we can found, it’s suggested to use NSStatusItem.button to customize. OK, we can add view to subviews of the button.

1
2
3

/// The button that is displayed in the status bar. This is created automatically on the creation of the StatusItem. Behavior customization for the button, such as image, target/action, tooltip, can be set with this property.
@available(OSX 10.10, *)
public var button: NSStatusBarButton? { get }

That’s not finished. Using this code could show the percent in status bar, but the size of status bar item is incorrect. How to deal with it? To be honest, I didn’t find a good way, but find a walkaround way, i.e., add an empty image to the status bar item. And then add NSProgressIndicator to the button. It’s not good, but works. The code is as following:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

  if let button = statusItem.button {
        // FIXME: it works, but obviously not good.
        let frame = NSRect(x: 6, y: 2, width: 18, height: 18)
        let progressIndicator = NSProgressIndicator(frame: frame)
        progressIndicator.style = .SpinningStyle
        progressIndicator.indeterminate = false
        progressIndicator.doubleValue = 30
        
        // Use empty image to extand the status item's size
        statusItem.image = NSImage(named: "EmptyIconImage")
        button.addSubview(progressIndicator)
  }
``` 
And the percent looks like:
![](https://farm6.staticflickr.com/5492/31332937901_69060ed428_o.jpg)
![](https://farm6.staticflickr.com/5720/31303434582_304507af58_o.jpg)
# How to Disable a Menu Item?
It sounds very easy. Just set the `NSMenuItem.enabled = false`. But the fact is not. Read the description for `NSMenuItem.autoenablesItems`:
```swift
    /* Set and get whether the menu autoenables items.  If a menu autoenables items, then calls to -[NSMenuItem setEnabled:] are ignored, and the enabled state is computed via the NSMenuValidation informal protocol below.  Autoenabling is on by default. */
    public var autoenablesItems: Bool

As you can see, NSMenuItem.autoenablesItems is enabled by default. And if it’s enabled, the set of NSMenuItem.enabled property will be ignored. Thus, if you want to manually control the NSMenuItem.enabled property, first disable the NSMenuItem.autoenablesItems property.

How to Support Dark Mode?

There’re 2 key points needed to support dark mode of OS X.

1. The icon itself should support. To be exactly, the background of the icon should be transparent.
2. Set the NSMenuItem.image?.template = true

1
2
3
4
5
6

/* The 'template' property is metadata that allows clients to be smarter about image processing.  An image should be marked as a template if it is basic glpyh-like black and white art that is intended to be processed into derived images for use on screen.
 
 NSButtonCell applies effects to images based on the state of the button.  For example, images are shaded darker when the button is pressed.  If a template image is set on a cell, the cell can apply more sophisticated effects.  For example, it may be processed into an image that looks engraved when drawn into a cell whose interiorBackgroundStyle is NSBackgroundStyleRaised, like on a textured button.
 */
public var template: Bool

The normal and dark status bar items look like:

How to Support Indentation Level?

Easy. Just set the NSMenuItem.indentationLevel.

How to Pop Over?

It’s easy to pop over status item. Check the following code:

1
2
3

if let button = statusItem.button {
  popover.showRelativeToRect(button.bounds, ofView: button, preferredEdge: .MinY)
}

But it’s hard to pop over menu item, as menu item’s view is nil by default. And then no view or bound to show popover relatively. Ever see some other app like ClipMenu could implement this feature, but hasn’t found how to do it.

Another walkaround is to use NSMenuItem.toolTip to show additional information of a menu item.

What Left?

• tag and representedObject
• action

Development environment:

• OS X: 10.11.4
• XCode: 7.3
• Swift: 2.2

Steps

Create Basic Project

Refer to commit till #40ccec2.

Add UI Controls

Refer to commit till #2853186.
After done, the UI looks like:

Add Model Class of “Node”

Refer to commit till #516acc4.

1
2
3
4
5
6
7
8
9
10
11
12

class Node: NSObject {
  var title = "Node"
  var children = [Node]()
  
  override init() {
    super.init()
  }
  init(title: String) {
    self.title = title
  }
}

Prepare Demo Nodes Data

Refer to commit till #f914811.
Node structure:
- Node
- Group
-– Node A
-– Node B

Add and Configure NSTreeController

Refer to commit till #06b01a8.
Steps

• Add NSTreeController in the .xib and select it.
• Go to “Attricutes Inspector”.
  • Set the “Key Paths > Children” to “children”.
  • Choose “Mode” Class and set “Class Name” to “OutlineWithController.Node”.
  • Select “Prepares Content”

• Go to “Binding Inspector”.
  • Bind “Content Array” to self.nodes (which was created in previous step, and it should be dynamic).

Bind NSOutlineView

Refer to commit till #f941f7b.
Steps

• Select “Outline View”.
• Go to “Binding Inspector”.
  • Bind “Content” to “Tree Controller”‘s “arrangedObjects”. Ignore the warning in “Model Key Path”.
  • Bind “Selection Index Paths” to Tree Controller’s “selectionIndexPaths”.

• Select “Table View Cell”.
• Go to “Binding Inspector”.
  • Bind “Content” to “Tree Cell View”‘s “objectValue.title”. Node: here the “objectValue” is the class Node as you defined it in the tree controller.

• Go to “Attributes Inspector”.
  • Set “Behavior” to “Editable”.

Run the app, you should see the app like:

Add Node and Remove It

Refer to commit till #d9b7197.
Steps

• Right click on the tree controller.
• Connect “add:” to “Add Node” menu item.
• Connect “addChild:” to “Add Child Node” menu item.
• Connect “remove:” to edit button.

That’s it. Run the app. You should be able to add node or remove it.

Edit Selected Node

Refer to commit till #22e2c07.
The key code is here:

1
2
3
4
5
6

@IBAction func editNode(sender: NSObject) {
  let row = outlineView.selectedRow
  if row != -1 {
    outlineView.editColumn(0, row: row, withEvent: nil, select: true)
  }
}

Disable Remove and Edit Controls if no Node Selected

Refer to commit till #eb7decd.
The key point is to bind the “Enabled” attribute to tree controller’s “canRemove” controller key.
Another point is, when app starts maybe nothing was selected. In this case, disable the Outline’s “Attributes > Selection > Empty”, and select the Tree Controller’s “Attributes > Avoid Empty Selection”.

Development environment:

• OS X: 10.11.4
• XCode: 7.3
• Swift: 2.2

Steps

Create Basic Project

Refer to commit till #fa626ee.

Add Model Class of “Node”

Refer to commit till #e302b91.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

class Node: NSObject {
  var title = "Node"
  var isGroup = false
  var children = [Node]()
  weak var parent: Node?
  
  override init() {
    super.init()
  }
  
  init(title: String) {
    self.title = title
  }
  
  func isLeaf() -> Bool {
    return children.isEmpty
  }
}

Add UI Controls

Refer to commit till #5dee8d1.
After done, the UI looks like:

Implement NSOutlineViewDataSource

Refer to commit till #c467d0b.
Notes:

• Set NSOutlineView’s dataSource to File’s Owner.
  

• Bind value “Table Cell View” to “Table Cell View” > Model Key Path: objectValue.title.
  

After done, the UI looks like:

Implement NSOutlineViewDelegate

Refer to commit till #300948e.

Notes:

• Set NSOutlineView’s delegate to File’s Owner.
  

Add Node and Group

Refer to commit till #f18c61f.

Notes:

• The logic to add node or group in correct position is very boring. That’s why binding will be a good friend.
• There’re 2 ways to insert item in outline view. One is update the data modal, then call NSOutlineView.reloadData(). But this will let UI flash. So it’s better to manually insert item in outline view (e.g., use NSOutlineView.insertItemsAtIndexes). Another benefit is could use animation during inserting.

After done, you can add node or group. The UI looks like:

Implement other UI Operations

The operations include remove, edit, move up and move down. It’s not hard. But the logic is complex and boring. Be careful.
Refer to commit till #3f7ffaa.

Notes

• Could create a dynamic property (e.g., dynamic var removeButtonEnabled = false), and then bind a control’s enable property to it. e.g.,
  

• Should set table view cell’s behavior as “Editable” to edit it.