Introduction

PlistEdit Pro is a replacement for the embedded plist editor included in Xcode. While Xcode does the job, it is rather limited in its functions and it can be frustrating to work with its strictly basic functionality. PlistEdit Pro offers advanced features such as:

• A full featured find and replace bar
• The ability to directly edit the text of a property list
• Support for both Apple’s plist format as well as the commonly used JSON format
• Customizable fonts
• Data formatters, which interpret raw plist values for display and editing
• Sorting of arrays and dictionaries
• Property list browsers, which will scan a folder or app package for plist files to edit
• A special browser for viewing and editing your preferences files
• A favorites list, for easy access of frequently edited files
• Structure definitions, which define a property list’s structure and assist with editing
• A command line tool that lets you edit plist files and data from the UNIX shell
• Applescript support

About property lists

Property lists are used extensively in macOS and iOS. They can be used to store user preferences, configuration information for your system, and information in your installed applications. A property list is a hierarchical data structure made up of seven different types of data:

• Dictionary: a dictionary contains key/value pairs, with one data value associated with each key in the dictionary. Dictionaries are unordered, but can only have one instance of any given key.
• Array: an array contains any number of data values in a particular order. The values in an array are distinguished solely by their index within the array.
• String: a series of characters of any length.
• Number: a number, either integer or floating point.
• Boolean: a simple truth value, either YES or NO
• Date: a point in time which can be measured down to the second. Dates in property lists are not associated with any particular time zone.
• Data: a raw series of bytes, displayed in hexadecimal.

Property lists can be stored in files in several different formats: XML, ASCII, or binary. The most common form is XML, which is both human readable and flexible enough to represent all seven types of data that occur in property lists. The ASCII format for property lists is a little easier to read and edit, but some of the data types (boolean, date, and number) cannot be stored in this format (the ASCII format is also deprecated in macOS 10.6 and later). The binary format takes up the least space on disk and can represent all data types, but is not easily readable or editable.

More details on the use of property lists in macOS and iOS can be found on Apple’s site: Property List Programming Guide

About JSON

PlistEdit Pro also supports the editing of JSON files, a format commonly used when working with Javascript and other web technologies. You can find more detailed information about the JSON format at http://www.json.org/

The types of data that can be represented in JSON are nearly identical to those supported by plists, with the following exceptions:

• The “Date” and “Data” data types are not supported by JSON
• JSON also supports an additional “Null” type, which is not supported by regular plists

When working with JSON files in PlistEdit Pro, you can perform all the same operations that you can with regular plists, such as copy/paste, drag and drop, find/replace, and so forth. PlistEdit Pro can also be used to convert data between plist and JSON formats.

Editing property lists

Editing a property list is fairly straightforward. You can edit existing values by double clicking the text in the value column (or for boolean values, a pop-up menu is provided instead). For items contained in a dictionary, you can edit the keys by double clicking the key. You can also change the type of an existing data item by selecting an item from the pop-up menu in the Class column. When you change an item from one class to another, PlistEdit Pro will do its best to convert the old data into the new format, e.g. changing the boolean value YES to a string valued “YES”.

Adding new data items to the list can be done through the New Sibling and New Child commands, available in both the toolbar and the Operations menu. You can also move or copy items by dragging them to a different position in the list, or by copying and pasting selected items.

Editing large values

The Edit Value command, available in the Edit menu, will open a sheet with a larger text view, allowing you to edit larger values that are difficult to edit in the confines of a single row editing field. You can also select multiple items in a property list that are of the same class and use the Edit Value command to assign a single value to all the selected items at once.

Autocompletion

PlistEdit Pro provides an autocompletion feature that makes entering information easier. If you are using a structure definition when editing a plist, PlistEdit Pro will include any keys that are specified in that definition. For example, if you are editing an Info.plist file, and type “CF”, PlistEdit Pro will provide completions for all the common keys that start with CF (e.g. CFBundleName, CFBundleVersion, CFBundleDocumentTypes, etc.).

Keyboard shortcuts

PlistEdit Pro also provides several convenient keyboard shortcuts which allow you to edit anything in your property list without ever leaving the keyboard.

Find and replace

PlistEdit Pro supports finding and replacing text both within individual keys and values in a property list and in the full text version of the property list file, i.e. the raw XML or JSON. Simply click the view you want to search in (outline or text) and press command-F to bring up the find bar, where you can enter a string to search for. Clicking the small magnifying glass next to the search field will provide menu with options such as case sensitivity, wrap around, and restricting search results to the beginning or entirety of a key or value.

Sorting property list

PlistEdit Pro provide a number of different ways to sort your property lists, making it easier to browse through larger lists and find various items. Note that sorting a dictionary will not be persisted when saving the property list, since dictionaries are always saved with their keys sorted alphabetically. The order of sorted arrays will be saved though.

Sort Keys

Selecting a dictionary and selecting the “Sort Keys” command from the Operations menu will rearrange the objects in the dictionary in order by their keys. Dictionaries are sorted alphabetically by default when opening a property list, but this order can be changed when renaming items or creating new items, so this allows you to restore the sort order. Additionally, the “Sort All Keys” menu command will apply the same sorting to all dictionaries in the entire property list.

Sort Values

Similarly, the “Sort Values” command will sort items in either an array or dictionary by the “Value” column, rather than the “Key” column. If the array/dictionary contains objects of mixed types (e.g. some strings, some numbers, some dates, etc.) the items will be grouped by type, and then sorted within each type.

Sort By Subkey

The “Sort By Subkey” command can be used on an array or dictionary containing only dictionaries, and will sort those dictionaries based on a particular key that those dictionaries contain. For example, if you are editing an Info.plist file for a document based application and select the array of document types supported by the application, you can sort that list by any of the keys that appear in the document type dictionaries, e.g. “CFBundleTypeName”, “NSDocumentClass”, etc. PlistEdit Pro will reorder the dictionaries sorted based on the key you select. Any dictionaries that don’t contain a value for that key will be sorted to the end of the list. This can be combined with the “View By Subkey” command to easily browse through large lists of dictionaries based on any key contained by those dictionaries.

Sorting Options

The preferences window allows you to specify whether you want your sorting to be performed case sensitively or numerically. Case sensitive sorting will sort all capital letters before lowercase letters, and numeric sorting will sort numbers based on their numeric value, rather than treating them as alphabetic strings.

Viewing data in different formats

Property lists allow for storage of a wide variety of different data types. There are only seven basic types to work with, but data can be manipulated in many different ways to be stored as one of these seven types. However, this sometimes means transforming the data into a form that is not easily recognized or edited when viewing the property list.

Formatters

PlistEdit Pro helps alleviate this problem by providing formatters for many common types of data that have to be manipulated to be stored in a property list. To view a value using a formatter, select the row you want to view and select the data type you want to view it as using the “View As” submenu in the Edit menu (or by control-clicking and selecting from the contextual menu). Below is a list of the formatters that are included with the current version of PlistEdit Pro:

Note that not only do formatters allow you to view data as different types, they also allow you to edit the data in the same form. For example, you can type in a new hex value for a number, or type in a new path to make an alias record point to a different location.

View By Subkey

When viewing a list of dictionaries, it’s often difficult to find a particular dictionary, since the only value that’s displayed by default for each dictionary is the number of key/value pairs it contains. If you select such a list and use the “View By Subkey” menu command, you can select a key whose value will be displayed next to the dictionary. This makes it easy to find a particular dictionary in a large list without having to open each dictionary to see its contents.

Editing raw property list text

While PlistEdit Pro allows you to edit property lists without needing to fiddle with their textual representations, it does allow you to edit the raw XML/ASCII text of the property list if you want to. The text for a property list is displayed in the bottom half of the document window, and you can edit the text directly from inside the document window. If you’ve modified the text, you will need to click the “Sync Outline” button in order to update the outline view to reflect the changes you have made in the text view. If the edits you’ve performed have left the text in an unparsable state, PlistEdit Pro will inform you when you try to sync the outline view, or save the document. The error message will typically contain a line number where the error was found, in which case you can use the “Go To Line” command in the Edit menu to go to that line in the text to find and fix the error.

Similarly, the “Sync Text” button will update the textual representation to reflect any changes you’ve made in the outline view above. Checking “Automatically sync text” checkbox will regenerate the text after every single change you make in the outline view. Note however that this may cause slowdowns when working with large property lists.

Also, when working with the JSON format, you have a preference whether you want the text to display the JSON text as condensed (i.e. with all whitespace stripped out), or indented (i.e. a more easily readable format, with each data item on its own line).

Property list browsers

PlistEdit Pro allows you to easily examine many property lists at once through its property list browser. There are two ways in which you can create a new browser:

1. Select “New Property List Browser” from the Browser menu. This will open a new, empty browser.
2. Drag a folder or folders from the Finder onto the PlistEdit Pro application icon. This will open up a new browser and display the property lists found in the folder(s). Note that you can drag an application or any other bundle onto PlistEdit Pro to examine the property lists contained inside.

Once the browser is open, it will display the list of property list files you’ve added to it. To add more files to an open browser, simply drag the files or folders from the Finder into the browser’s list. To open a file shown in the list, just double click on its row in the list, or select one or more files and press the Return key.

Along with the file’s name, you can also see a number of each file’s attributes in the other columns in the table. To customize which of these columns are visible, use the pop-up menu by clicking on the small triangle in the upper right hand corner of the list. You can also sort the list by one of these properties by clicking on the header of that column (click a second time to reverse the sort order).

The following columns are available:

• Creation date: the file’s creation date
• Modification date: the file’s modification date
• Size: the size in bytes of the file on disk
• Parent: the name of the parent folder of the file. If more than one file in the last has both the same name and same parent folder name, the enclosing folders will also be shown as necessary to be able to identify the files uniquely.
• Format: the format of the property list, either binary, ASCII, or XML. Note that even though a file’s format may be identified here, it does not necessarily mean that the property list is valid.
• Valid: shows whether or not the property list is valid (well formed). To test property list validity, use the Validate command available in the Browser menu. A property list will have a question mark displayed in this column until it has been tested for validity

Multi-file searches

If you have a large number of files in a browser, you can use the browser’s search features to narrow down the list and easily find the particular file you’re looking for. Type something into the search field at the bottom of the window, and PlistEdit Pro will search the list of files for ones matching what you’ve typed. You can search in one of two ways, either by the file’s name, or by its content, chosen by clicking one of the radio buttons just below the search field.

When searching by content, the search will open up all the property list files in the list and look for the given text within the content of the property list. Clicking the “Options…” button will display several ways to customize how it performs the search:

• Search Scope: this allows you to limit the search to either the keys in the property list or the values, or you can search both at once
• Top level only: if this box is checked, the search will only check the items contained by the root of the property list; otherwise, it will search recursively down into all the items in the property list. Recursive searching can be significantly slower, especially for large property lists, so checking this box will often speed up your search times.
• Ignore case: If checked, the browser will perform a case insensitive search
• Invert found file set: If this box is checked, then instead of displaying all the files that do match the search, it will instead show the files that don’t match. This can be useful when trying to find a file that’s missing a particular key or value.
• Search kind: The pop-up menu will let you select the context to search for the text in. You can choose whether to only show files where the search text is found at the start of a key/value, at its end, anywhere inside the key/value, or only when exactly equal to it.

Clicking the “Save As Default” button will save the current search options as the default ones to be used whenever a new browser is created.

Saving browser configurations

Whenever you create a property list browser and add files or folders to it, PlistEdit Pro remembers which files and folders you dragged into that browser. You can later add or remove items by clicking the “Edit Content” button in the browser’s toolbar. After you have added or removed items, PlistEdit Pro will update the file list by rescanning all the files and folders you’ve specified.

After you’ve configured a browser, you can save that configuration so that you can later reopen that same browser and view the files contained in it. For example, if you are working on a project that uses a number of property list files, you can save a browser that is set to browse the contents of your project folder. Anytime after that, you can then reopen that browser to edit any of the property list files in your project without having to find the individual files again.

You can click the “Save Browser” button in a browser’s toolbar to save the current configuration of that browser under a name of your choice. That configuration will now show up in the submenu of the “Open Saved Browser” menu item in the “Browser” menu, and selecting it will restore the saved browser and rescan any folders it is set to browse. You can also rename and delete existing browser configurations by selecting “Organized Saved Browsers…” from the “Browser” menu.

The preferences browser

Most macOS applications store their preferences in property list files, making them easy to view and edit. PlistEdit Pro offers a special property list browser that allows you to quickly locate and edit the preferences for many applications on your system. The preferences browser works much the same as a normal property list browser, but with a few added options.

In macOS, preference files are stored for the most part in a single folder at ~/Library/Preferences. When you open up the preferences browser (available through the Window menu), PlistEdit Pro will scan your preferences folder for all the preferences that are stored as property lists and display them to you in a list. You can also see the name of the application to which a particular preferences file belongs, making it much easier to find the file you need for a particular application. To edit a preferences file, simply double click on it in the list.

In addition to the normal search capabilities of a property list browser, the preferences browser offers a couple additional ways to narrow down the list of files you’re looking at. Clicking the checkbox titled “Show only prefs for known applications” will filter out any preferences file for which the system cannot find the corresponding application. This can be useful for filtering out old preferences files for applications that are no longer on the system.

While most preferences are stored on a user by user basis, some preferences can also be shared system-wide. These preferences are stored in /Library/Preferences, and can also be viewed in the preferences browser by checking the checkbox titled “Show system-wide preferences” at the bottom of the window. The preferences browser also provides an additional column (titled “File Type”) which lets you see which preferences files are specific to the current user, and which are system-wide.

The toolbar buttons at the top of the window provide some addition useful functions that act on the preference file you currently have selected in the list:

• Launch Application: launches the application (if one exists) to which the selected preference file belongs.
• Reveal In Finder: reveals the selected preference file in the Finder.
• Reveal Application: reveals the application (if one exists) to which the selected preference file belongs.
• Refresh List: rescans the preferences folders and displays the latest state of the preference files.
• Move To Trash: moves the selected preference file to the trash.

Favorites

PlistEdit Pro offers a favorites menu to which you can add your most frequently used property list files for easy access. The Favorites menu is located in the File menu. If you have a property list file open that you want to add to your favorites, simply press Command-T, and the frontmost property list document will be added to the list. For further management of your favorites list, press Command-Shift-T, and a property list browser will open up displaying your favorites list.

Just like in any other property list browser, you can search your favorites list either by filename or by content. The favorites browser also allows you to assign a keyboard shortcut (Command-0 through Command-9) to the items in your favorites list. To change an item’s shortcut, just choose one from the Shortcut column’s pop-up menu for that item’s row. You can also add files to your favorites list by dragging them into the favorites browser, and you can remove an item by selecting it and clicking the “Remove” button in the browser window’s toolbar.

Property list structure definitions

There are many common uses of property lists in which the property list must be structured in a certain way. For example, when editing a .scriptSuite file which is necessary for a developer to add Applescript support to their application, only a small set of keys are used, and the values stored must conform to certain types. To help create and edit lists with predefined structures such as this, property list structure definitions can be greatly helpful.

Using a structure definition when editing a property list

Using a structure definition when editing your property lists provides several additional enhancements and features.

Choosing from a list of available keys

Some types of property list can involve a large number of different keys, which can be difficult to keep track of and result in digging through the documentation, trying to figure out what the exact key you need for a particular purpose is. Structure definitions document the commonly used keys in certain types of property list files, and allow you to select such a key from a list directly from the PlistEdit Pro interface, rather than having to look it up in the documentation. For example, when editing an Info.plist file, PlistEdit Pro will already know commonly used keys such as CFBundleName, NSPrincipalClass, CFBundleDocumentTypes, LSUIElement, and so forth. This functionality can be accessed in a few different ways:

• When editing a key, PlistEdit Pro will autocomplete the key as you type it, based on the entries found in the structure definition for the property list you’re editing.
• A pop-up menu is also provided next to the key when editing, which you can click to view a full list of all the known keys for the dictionary you’re currently working with.
• The “Add Sibling Key” and “Add Child Key” items in the Operations menu also list any known keys, and allow you to add a new item to the dictionary using a key that you select

Human readable keys

Structure definitions can provide plain english names for property list keys, making it easier to tell what a particular key is used for. For example, instead of seeing “NSJavaPath” displayed for that key in an Info.plist file, you’d instead see “Java classpaths”, which makes it a little more clear what exactly the purpose of that key is.

Choosing from a list of allowed values

Some property list keys only allow certain values to be entered for that key, or at least there may be some small set of values that are very commonly used for a particular key. Structure definitions can provide a list of such values and provide a pop-up list and autocompletion when editing such a key. For example, when editing the CFBundleTypeRoles key of a document type dictionary in an Info.plist file, the structure definition provides a list of commonly used values for this key, which are “Editor”, “Viewer”, “Shell”, and “None”, so that you don’t have to remember these values or look them up yourself.

Additionally, for some keys which require non-string values, the structure definition will display textual representations of these values which are much easier to choose from. For example, the “LSUIPresentationMode” key in an Info.plist file requires a number to be entered for its value. This number corresponds to the SystemUIMode typedef declared in MacApplication.h in the Carbon framework. Normally, you would need to figure out what numeric value to use for a given mode (e.g. 0 gives you the normal UI mode, 1 hides the menu bar but not the dock, 2 hides both the menu bark and the dock. etc.) and enter that yourself. Using a structure definition, you will instead see choices such as “Normal”, “Content hidden”, “All hidden”, etc., and selecting one of those choices will set the numeric value to the appropriate number behind the scenes.

Default values

Structure definitions can provide default values for particular keys and object types. When you create a new object in your property list, it will automatically be populated with a sensible default value, rather than just being blank and leaving you to guess what type of information you might need to enter. Also, newly created dictionaries will be automatically populated with keys that are either required or present by default, so you don’t accidentally forget to include a required key for that dictionary.

Display type

A structure definition can also specify that a particular item or key be displayed as a different type, using PlistEdit Pro’s formatters (the same as you can assign using the “View As” submenu in the Edit menu). For example, if a four character code is being stored in a Number object as a 32 bit integer value, the structure definition can specify that that value should be display using the OSType formatter. This will result in you seeing the actual four character code rather than a very large plain numeric value, which isn’t particularly useful. Note: this functionality is only supported by PlistEdit Pro, and not by Apple’s Property List Editor or Xcode.

Identifying keys for dictionaries

A structure definition can specify that the value stored under a particular key should be used to identify a dictionary, making it easier to browse through a list of dictionaries to find the one you’re looking for. ßFor example, when looking at the list of document types stored under the CFBundleDocumentTypes key, each dictionary in that list has a CFBundleTypeName key which specifies the name of that document type. The Info.plist structure definition specifies this key as being the identifying key for document type dictionaries. When you look at this list in PlistEdit Pro using the Info.plist structure definition, each document type’s name will be displayed in the same row as the dictionary, making it easy to find a particular document type without having to expand each dictionary looking for the one whose name matches what you’re looking for. This is similar to the functionality provide by the “View By Subkey” command, only it’s done automatically when viewing a property list when using a structure definition.

How structure definitions work

A property list structure definition is made up mainly of a list of property list classes. Each class describes a particular kind of property list object and how it should be displayed when editing. Every structure definition has a special class named “root”, which specifies what the root object of the property list should look like, what keys it supports, and so forth. The root class then determines what classes should be used for its children. The children’s classes in turn specify what class should be used for their children, and so on down the hierarchy. When using a structure definition, you’ll notice that for many items, instead of the basic types like “Array”, “Boolean”, etc., you will instead see the name of the class that has been assigned to that item by the definition

In the example above, the Info.plist structure definition’s root class specifies that the object under the “Document types” key should be assigned the “DocumentTypeArray” class. The “DocumentTypeArray” class specifies that all its children should be assigned the “DocumentTypeDict” class, and then the “DocumentTypeDict” class specifies what should be used for its various child keys.

The most important piece of information for a class is what basic type should be used for property list objects that are assigned that clas. This can be one of the seven basic property list types: Array, Boolean, Data, Date, Dictionary, Number or String, as well as a Variant Dictionary type that will be explained a little later. The “root” class is typically a dictionary, though it can sometimes be an array as well. Depending on what type of object a class represents, the class will have different attributes that specify how that type of object should be treated when viewing and editing it. Note that currently, there is no way for one class to “subclass” another and inherit its properties.

Creating a structure definition

If you wish to create your own custom structure definition, simply choose “New Definition” from the Definition menu, and a new document will be created with a single basic definition ready for you to edit. When you’ve performed your edits and wish to save, the file will be saved by default in ~/Library/Application Support/PlistEdit Pro/Structure Definitions. This way, they will automatically be loaded and usable by PlistEdit Pro at launch time.

Editing a structure definition

PlistEdit Pro offers a full, custom interface for editing property list structure definitions. The easiest way to open an installed structure definition file is to go to the Definitions tab of the preferences window and double click the definition you would like to view/edit.

The editor window can be divided up into four basic areas:

1. Toolbar. The buttons in the toolbar allow you to manage the structure definitions stored in the file. Files are stored as XML, and are actually a subset of the Xcode plugin format. Each plugin can store multiple structure definitions, though many will only store a single one. You can add new definitions to the file and delete existing definitions, as well as switching which definition you want to edit using the pop-up menu on the right. Each plugin also has its own name, bundle identifier, and version number, which can be editing using the “Plugin Info” button.
2. Definition info. Each structure definition within the file also has a name and identifier. The name is what is displayed in the menu when switching which definition you want to use when viewing a particular property list. The identifier should be in the reverse domain name style, and should be unique, so that definitions can be told apart.
3. Property list classes. This table displays the list of property list classes that make up the structure definition. The plus and minus buttons below can be used to add and delete classes from the definition, and selecting a class will display its details in the bottom half of the window.
4. Class detail. This portion of the window displays the details for the selected class. The controls displayed here will differ depending on the type of object represented by the selected element, and are described later in this help document.

If you edit and save an installed structure definition, the changes will take effect immediately in any open property list documents, so if you’re creating your own structure definition using PlistEdit Pro, you can “debug” your changes without having to close and reopen a document or quit and relaunch PlistEdit Pro.

Plain values



When selecting a class whose type is a string, number, boolean, data, or date, you will see the controls above which allow you to edit the class.

• Default Value. This allows you to specify a default value for property list objects of this type. This value will be automatically filled in for any new object created of this type.
• Placeholder. If a placeholder value is specified here, then if an object of this class in a property list has not had any value entered for it yet, the placeholder value will be displayed in gray text in the Value column for that object. This can be used to give the user a clue as to what type of information should be entered for that object, without having to assign an actual default value to that object upon creation.
• Default Display Type. Specifies that this class of object should be display using something other than the default formatter. For example, if you’re editing an element used for Number objects used to store four character codes, you can choose the OSType formatter from the pop-up menu here, and any such object will be display by default as a four character code rather than a plain number. This is equivalent to using the “View As” submenu in the Edit menu. Note that this value only affects display in PlistEdit Pro, and not in Xcode or Apple’s Property List Editor.
• Allowable Values. For objects that are only allowed to be a specific number of values, you can specify what the allowable values are for that object here. Use the plus/minus buttons to add/remove items from the list, and double click on the value/display value to edit them. PlistEdit Pro will provide a pop-up menu for the object when editing the property list. The entries you type in the Display Value column will be what shows up for the user to select from in the pop-up menu, but the entries in the Value column will be the value actually set in the property list when an item is selected.

Dictionaries



When selecting a dictionary element, you will see the controls above for editing the definition element.

• Default child class. Allows you to specify what class should be used by default when creating a new child object for a dictionary of this type. For example, if you’re editing an class for a dictionary that will contain boolean values, you can select the Boolean class from this pop-up, and any new objects created in that dictionary will be booleans by default.
• Default key name. Similarly, you can also specify what key string should be used for newly created children of the dictionary. PlistEdit Pro uses “New Item” by default when creating, but for example if you want all the keys for a dictionary to be reverse domain name style strings, you could specify “com.mycompany.mykey” as the default key name, which would give the user an idea of what form of key they should be using for this dictionary.
• Identifying key. Specifies a key of the dictionary whose value should be displayed in the Value column for the dictionary when editing a property list file. For example, specifying the “CFBundleName” key for dictionaries in the CFBundleDocumentTypes array in an Info.plist file will display each document type’s name in the row for that document type’s dictionary, making it easy to scan the list of document types to find the one you want.
• Variant key. Specifies a key to identify this element as being the one to use for a variant dictionary.
• Variant value. Specifies a value to identify this element as being the one to use for a variant dictionary.

Underneath those controls is a table that lets you specify how to handle one or more specifc keys stored in this type of dictionary. Each row has the following attributes:

• Key. This is the dictionary key that you want to define behavior for.
• Localized string. This string, if provided, will be displayed in the Key column when editing the property list instead of the actual key. This allows the definition designer to provide the user with a clearer meaning of the key’s purpose than might be discernable from the raw key value.
• Class. This specifies what class the object stored under this key in the dictionary should be. This is the main way that classes are assigned in a property list with multiple levels of hierarchy, with each dictionary defining classe for its children based on their key.
• Usage. This defines how the key is used in the dictionary and can have four values.
  • Required: the key must appear in the dictionary, and will result in a warning if the user attempts to delete that key
  • Default: though the key isn’t required, it will appear by default when a new dictionary of this class is created
  • Optional: this key has meaning in the dictionary, but is not required and will not be included in the dictionary by default
  • Deprecated: this key should no longer be used in this kind of dictionary

Arrays



When selecting an array element, you will see the controls above for editing the definition element.

• Array children class. Specifies what class each object in the array should be assigned. For example, the class for the CFBundleDocumentTypes array specifies DocumentTypeDict as the class to be used for its children. This means that each child of the CFBundleDocumentTypes array will be assigned the DocumentTypeDict class, so all the information specified by that class will be used when editing the dictionaries in that array.
• Default array entries. If you wish for newly created arrays of this type to be automatically populated with one or more objects, you can specify how many objects and what class each created object should be here.

Variant dictionaries

A variant dictionary type allows you to treate a dictionary differently based on its content. A variant dictionary type contains a list of one or more dictionary classes defined elsewhere in the structure definition. When a dictionary’s class is determined to be a variant dictionary, PlistEdit Pro will search through the variants and try to determine which variant is most applicable to the dictionary. This search is based on the “Variant key” and “Variant value” that is given for each dictionary class. To determine which variant to use, PlistEdit Pro evaluates each variant in order:

1. If the dictionary type specified by the variant has only a “Variant key” definied, then if that key is present in the dictionary being viewed, then that variant’s dictionary type is used for the dictionary being viewed.
2. If the dictionary type specified by the variant has both a “Variant key” and a “Variant value” defined, then the key must not only be present, but the value stored under that key must match the “Variant value” for the dictionary type.
3. If a variant doesn’t match the dictionary being viewed, PlistEdit Pro moves on to the next variant.
4. If none of the variants match, the dictionary is just treated as a plain dictionary.

As an example of how a variant dictionary might be used, imagine you have a list of dictionaries, and each dictionary has a key named “class” which specifies a class name for that dictionary. For each possible class, you could create a dictionary type that would define the keys and values that apply to that class. For each dictionary type, you would specify “class” as the variant key for that dictionary type, and then the class name as the variant value. Finally, you would create a variant dictionary type and add a variant for each dictionary type you had created. Then, when one of these dictionaries was assigned your variant dictionary as its type, its “class” value would determine which dictionary type was used for that particular dictionary.

Managing installed structure definitions

Structure definitions were introduced by Xcode 3.0 and are implemented as Xcode plugin files. Initially, these were plain XML files with a .xcodeplugin file extension, but then starting in Xcode 5, they changed to being full fledged code bundles with an extension of .dvtplugin. PlistEdit Pro supports both types of plugins, but can only read .dvtplugin style structure definitions, whereas it can both read and write .xcodeplugin style definitions. This means that definition files that ship with Xcode can be used by PlistEdit Pro, but not vice versa.

Xcode stores its structure definition plugins inside the Xcode.app application bundle, in Xcode.app/Contents/PlugIns, and will also read .dvtplugin style definitions stored in ~/Library/Application Support/Developer/Shared/Xcode/Plug-ins.

PlistEdit Pro ships with several of its own built-in .xcodeplugin structure definitions which are located inside its own application bundle. These structure definitions will only show up in PlistEdit Pro, and not Xcode or Property List Editor. PlistEdit Pro will also read definition files from ~/Application Support/PlistEdit Pro/Structure Definitions, which will be used as the default save location for new definition files created by you.

You can see what structure definitions you have installed by going to the Definitions tab in the preferences window of PlistEdit Pro.

 All installed structure definitions will be displayed in the Definitions table on the left. Note that a single plugin file can contain multiple definitions, such PlistEdit Pro’s built-in definitions for Applescript .scriptSuite and .scriptTerminology files, which are both stored in the same plugin file. On the right you will see the following information for the selected structure definition:

• Use for files with extensions. If you want PlistEdit Pro to automatically use a particular structure definition for files ending with a specific file extension, you can type the extensions you would like to use the selected definition into this field. For example, by default all files ending with the “.scriptSuite” extension will be opened using the AppleScript Suite definition. You do not need to include the “.” character, and you can type a comma to end one extension and start typing a new one.
• Use for files with filenames. Similarly, you can type entire filenames into this field to have files with that name use the selected structure definition by default. For example, files named “Info.plist” are automatically opened using the Info.plist definition (but other files that simply end in “.plist” are opened without a definition)
• Type. This can be one of three values, depending on where the structure definition is installed:
  • User. Indicates that this definition is installed in the Xcode plugin folder located inside your home folder
  • PlistEdit Pro Builtin. Indicates that this definition is located inside the PlistEdit Pro application bundle. You will typically not want to edit these files directly, since any changes you make will be lost if you update PlistEdit Pro to a new version. Note that these definitions will not show up for use in Xcode or Property List Editor. If you’d like to use a PlistEdit Pro definition in either program, you can make a separate copy of the definition file in your home folder that Xcode/Property List Editor will detect and use.
• Xcode Builtin. Indicates that this is one of Xcode’s built-in structure definitions. It is not recommended that you edit these files directly, since all your edits will be lost the next time you install an update to Xcode. When editing one of these definitions, you will be given the option to make a separate copy of the file in your home folder that you can edit instead. PlistEdit Pro will use whichever version of Xcode you have chosen using the xcode-select command line tool.

Note that if more than one copy of a particular structure definiton is present (based on the “identifier” field of the definition), PlistEdit Pro will only list one copy of the structure definition. Definitions installed in the user’s home folder take precedence over PlistEdit Pro built-in definitions, which in turn take precedence over Xcode built-in definitions.

Preferences

PlistEdit Pro provides several ways to customize the program to the way you work. You can access these preferences by selecting the Preferences menu item in the PlistEdit Pro menu, or by pressing command-comma.

General tab

• Default class for new objects: Selects what type of object you would like to create when adding a new child or sibling to your property list.
• Default property list format: Selects what format (XML, ASCII, binary, or JSON) you want newly created property lists to be stored in.
• Ask to revert when file changes on disk: When this option is enabled, PlistEdit Pro will watch the files you have open to see if they have changed on disk since you last opened them. When you bring PlistEdit Pro to the front, it will automatically ask you if you want to revert to the version on disk for any files that have changed.
• Automatically check for updates: Checking this box will make PlistEdit Pro check on the internet for new versions at regular intervals. Checking the “Check at startup” You can also check for updates manually using the “Check For Updates” menu item.
• Remember formatter type by key: When enabled, if you use the “View As” menu to view an item under a particular key of a dictionary as a different type, PlistEdit Pro will remember the type you chose for that key and automatically display any items under that key as that same type. For example, if you choose to view a data object under the key “_NSAlias” as an alias record, PlistEdit Pro will then display all data objects it finds under the “_NSAlias” key as alias records without you having to change each one manually.
• Enable autosaving: Enables in-place autosave and Versions for plist documents. If you don’t want PlistEdit Pro to save changes you’ve made unless you explicitly use the Save menu item, you can disable autosaving. Note that autosave is not compatible with PlistEdit Pro’s ability to edit files that require admin privileges, so having autosave enabled will mean you will not be able to authenticate in order to save root owned files.
• When PlistEdit Pro is activated: Defines what PlistEdit Pro when you click its dock icon in the dock if no windows are currently open.
• Install Command Line Tool: Installs the pledit command line tool

Display tab

• Outline font: Selects the font that the outline view uses to display property list content. Click the Choose… button to select a different font from the font panel.
• Text font: Selects the font that the text view uses to display property list content. Click the Choose… button to select a different font from the font panel.
• Browser font: Selects the font that property list browser use to display their file lists. Click the Choose… button to select a different font from the font panel.
• Color XML tags: Allows you to choose a color with which to color the tags in the raw text of an XML formatted property list
• Sort options: Allows you to customize how sorting is done in PlistEdit Pro. Case sensitive sorting will cause all uppercase characters to be sorted before all lowercase characters, and enabling numeric sorting will cause any numeric values to be treated and sorted as numbers, rather than as alphabetic characters.
• JSON text formatting: Allows you to specify whether you would like PlistEdit Pro to generated condensed JSON text (i.e. with all whitespace stripped out), or indented (i.e. with whitespace and indentation included). There are two separate settings for the formatting used in the plist document window versus the formatting used when actually saving the file. For example, this lets you view the text in PlistEdit Pro as indented, to make it easier to read, but save as condensed, to have a smaller file size.

Definitions tab

This tab displays all the structure definitions that are installed on your system. Refer to “Managing installed structure definitions” for more details on this tab.

Browsing tab

This tab contains settings that affect property list browsers. When creating a new browser from a folder, or adding new items to an existing browser window, you can tell PlistEdit Pro what file extensions to scan the newly added folder for. Only files that match an extension in the list will be added. PlistEdit Pro can also read the ‘plst’ resource from the resource fork of a file (used by non-bundled Carbon applications). Checking the “Scan resource forks” checkbox will add any file that has a resource fork with a ‘plst’ resource whose ID is 0. Be aware that enabling this option can cause the scanning process to take significantly longer.

Scripting PlistEdit Pro

PlistEdit Pro provides tools for automatic workflows with property lists, through Applescript support and the pledit command line tool.

AppleScript

PlistEdit Pro allows you to automate tasks involving property lists by offering full Applescript support. For more information on how to script PlistEdit Pro, refer to its Applescript dictionary using Script Editor, as well as the example scripts which can be found on the PlistEdit Pro website.

The pledit command line tool

PlistEdit Pro also provides a command line tool, pledit, which allows you to open property lists in PlistEdit Pro from the command line and shell scripts. You can open any number of existing property list files by passing them as arguments on the command line:

% pledit ~/Library/Preferences/com.apple.finder.plist
% pledit MyApp.app/Contents/Resources/*.plist

pledit can also read property list data from stdin and open the data up as a new document in PlistEdit Pro:

% ibtool --export keypaths.plist MainMenu.nib | pledit
% hdiutil imageinfo -plist MyDiskImage.dmg | pledit

The first time you open PlistEdit Pro with a new version of pledit, it will ask you if you want to install the tool, which requires an admin password and installs in /usr/bin. You can also install the tool later via the preferences window.

Registration

PlistEdit Pro requires macOS 10.9 or later. You may try out PlistEdit Pro for a free trial period of 14 days. After that period, you will still be able to open files with PlistEdit Pro, but will not be able to save any changes. PlistEdit Pro is $29.95 (US dollars) and can be purchased online with a credit card, debit card, or PayPal at our web store.

Support

Free e-mail support is provided for users of PlistEdit Pro. If you have any problems, questions, feature requests, or other feedback, please send an e-mail to support@fatcatsoftware.com . Please be sure to include what version of PlistEdit Pro, and what version of macOS you are running.

Release Notes

Version 1.9.2 (released 4/3/2020)

• Collapsing the plist text view is now remembered with other window state when opening documents
• Improved behavior of using tab and shift-tab to navigate cells in outline view
• Fixed a bug where plist text wouldn’t be editable after saving the document
• Ensure the outline view has initial focus when creating or opening a document

Version 1.9.1 (released 9/11/2019)

• Improved consistency of saving the default split view position used when creating new documents
• Fixed a bug where the first edit made in the text view of a JSON file would not mark the document as edited
• Added “Copy As” submenu to contextual menu in plist outline editor
• Disabled automatic substitutions (e.g. smart quotes) when editing the raw text of a plist/JSON file
• The “View As” menu now supports byte counts both at 1,000 bytes/KB and 1,024 bytes/KB
• When saving changes to a JSON file with a custom extension, we no longer replace the extension with .json
• PlistEdit Pro is now notarized by Apple
• Fixed a bug where the “Cut” command would copy the wrong plist
• The space bar now opens the info popover when available

Version 1.9 (released 9/25/2018)

• Added support for dark mode on macOS Mojave
• Now requires macOS 10.13 or later
• Added rudimentary Touch Bar support
• Fixed an issue where the “ask to revert” message shown when a document is modified elsewhere could be displayed several times instead of just once
• Improved display of floating point numbers to avoid showing unnecessary fraction digits

Version 1.8.7 (released 6/26/2017)

• Fixed a crash that would occur when launching on OS X Mavericks

Version 1.8.6 (released 6/22/2017)

• Updated “Copy as Swift Literal” command for Swift 3
• Fixed a crash that would occur when searching by content in a plist browser window
• The AppleScript ‘sort’ command can now sort by subkey
• Fixed a crash that could occur when dragging files or folders onto PlistEdit Pro in the dock

Version 1.8.5 (released 11/16/2016)

• We now offer to move PlistEdit Pro to the Applications folder when quitting for the first time
• Prefs for sandboxed apps are now listed in the preferences browser
• Fixed a bug that preventing launching on macOS Mavericks
• Fixed a bug on macOS Sierra that could cause a document to be marked as dirty immediately after opening
• Fixed a crash that could occur when trying to edit a file in /Library/Preferences

Version 1.8.4 (released 10/28/2016)

• Added “Copy as Swift Literal” and “Copy as Objective-C Literal” menu items
• Removed some obsolete built-in structure definitions
• Fixed a crash when sorting the prefs browser by the File Type column
• ‘pledit –help’ now prints basic usage info
• Fixed a crasher when closing the “Edit Content” sheet on a property list browser window
• Fixed an issue where the outline view would lose focus after editing a value and pressing the tab key
• Added ability to view binary plists stored as data objects within another plist
• Fixed a crasher when using the “Refresh Files” command in a property list browser
• Fixed a crasher that could occur when closing a document
• Fixed an error that would be displayed for some users when trying to create a new document with JSON as the default document format

Version 1.8.3 (released 02/10/2016)

• Updated Sparkle framework to fix security vulnerability
• Added a preference for whether to create a new document when activating PlistEdit Pro
• Improved documents updating to reflect recent changes in their structure definition
• Added a button to show NSURL resource values stored in bookmark data objects
• Resizing a structure definition window smaller will no longer collapse any of its table views
• The outline view no longer loses focus after pressing return to change a key or value
• Prevent entering special characters when modifying file extensions for structure definitions
• Fixed an issue with reading system preferences in /Library/Preferences

Version 1.8.2 (released 09/25/2015)

• Fixed a crash that occur when changing fonts in the preferences window
• Fixed a crash that could occur on El Capitan when closing a document
• Fixed a bug where the “Replace” button in the find bar wouldn’t replace
• If performing a find and replace results in an invalid value (e.g. an unparsable date), we now display an error message instead of doing nothing
• We now install the pledit command line tool in /usr/local/bin, as per new requirements in El Capitan
• Fixed a bug where changing an object to a different class would not work while the object’s value was still being edited
• Fixed an issue where folders/packages could no longer be dropped on the dock icon
• Fixed a bug where reordering items could lead to a crash

Version 1.8.1 (released 12/17/2014)

• Changed claimed file types to prevent PlistEdit Pro document icon from appearing on generic documents in the Finder
• Fixed a crash that could happen when creating a new plist object
• Fixed a crash when using the Launch/Reveal Application buttons in the prefs browser
• Fixed a crash that could occur when closing a document
• When selecting a find result inside a long key or value, we now scroll left/right within the cell to show the selection
• You can now double click the splitter to collapse the text view
• Type ahead selection now ignores the value column and only looks at the key column
• Fixed a crasher when using the “View by Subkey” menu command
• Prevent the outline view from scrolling to the top after saving a document

Version 1.8 (released 10/10/2014)

• PlistEdit Pro now requires OS X 10.9 or later
• We now prevent changing the class of the root dictionary when editing a preferences file
• Saving preferences plists on Mavericks and later now pushes changes to CFPreferences when appropriate
• We can now read Xcode 5/6 structure definition files
• Removed the autocompletion feature, due to buginess and lack of time to fix it
• We do a one time “forgetting” of font prefs when launching on Yosemite, to ensure that new system fonts are used where appropriate. If you customized your fonts previously, you may need to reapply those changes.
• Added a preference to enable or disable autosaving
• When editing number values, we now omit the thousands separators to make copying values to other programs easier
• We now automatically save the window configuration used when opening documents, rather than having an explicit “Save Window Configuration” menu item
• We now save and restore the state of the “Show Raw Keys and Values” setting when opening documents
• The “Paste as Child” command will now insert a copy into each selected object when there is a multiple selection
• We now enforce that the root object of a JSON file is either an array or dictionary
• Switching to save as JSON in the save panel no longer appends an extra .plist extension to the saved file
• Fixed a bug where PlistEdit Pro could hang after trying to save a document with a syntax error
• Fixed a crasher when re-reading a changed structure definition file from disk
• Find/replace is now done using find bars in the outline/text views, rather than a separate find panel
• Elements in a structure definition can now be dragged to reorder them
• Save panel no longer tries to append a .plist extension when the default file format is JSON
• After deleting an object, we now select the adjacent object rather than having an empty selection
• Find/replace now works properly with localized key names when using a structure definition
• Removed the preference to have the OS write prefs plists as XML, since it’s no longer supported
• Fixed a hang/crash when performing a “Replace All” where the find string is a substring of the replacement string
• Fixed an issue where the pledit command line tool would not open PlistEdit Pro properly

Version 1.7.4 (released 07/11/2012)

• PlistEdit Pro’s crash reporter now waits until actually submitting a crash report to attempt accessing the address book (which causes a system prompt to appear on 10.8)
• PlistEdit Pro is now signed for running with Gatekeeper on Mountain Lion
• Added a workaround for a Mountain Lion bug that would cause PlistEdit Pro to “forget” any previously changed preferences settings and registration info

Version 1.7.3 (released 12/05/2011)

• Fixed an issue where entered registration info wouldn’t “stick” for some users

Version 1.7.2 (released 11/15/2011)

• Fixed a bug where PlistEdit Pro could hang or take up background CPU when editing with autocomplete enabled

Version 1.7.1 (released 11/09/2011)

• We now read plists created by NSKeyedArchiver properly again (regression from 1.6)
• Fixed a bug where, in certain circumstances, performing a find with the “Wrap around” option enabled would cause PlistEdit Pro to hang
• Fixed a crash that could occur when reopening multiple documents at launch time when running on Lion
• The registration panel now works properly when running with German as your primary language
• When editing a data object, you can now enter hexadecimal text with newlines
• Fixed a crasher that could occur when changing an object from a string to a date
• Fixed a problem that could cause PlistEdit Pro to crash on launch when trying to read certain types of older registration info

Version 1.7 (released 09/15/2011)

• Updated keyboard navigation to match system-wide behavior
• Added “New Dictionary/Array With Selection” menu commands
• PlistEdit Pro is now 64-bit and requires OS X 10.6 or later
• Added support for autosaving and Versions in Lion
• Added support for Resume on Lion, restoring all window state between launches
• Fixed a bug where the format popup in the toolbar would initially read “XML” when opening a JSON file
• Removed the preference to set a custom date formatting string
• Fixed a bug where table columns would not be restored properly for some saved property list browsers
• When converting from plist to JSON, data objects now get converted to equivalent hex strings
• Added buttons to the save panel that let you specify indented/condensed formatting when saving a JSON file
• Increased the maximum width of the “Value” column, for easier viewing of long strings
• When saving to a file with a .json extension, we now automatically convert the underlying property list to JSON format if necessary
• Removed Xcode integration preference, as it is no longer viable with Xcode 4

Version 1.6 (released 01/28/2011)

• Updated iTunes and iPhoto structure definitions with new data from latest versions of iTunes/iPhoto
• Property list browsers now refresh their file list after changing content find options
• Trying to open a favorite whose file is missing now displays an error instead of prompting for admin privileges
• PlistEdit Pro now supports reading and writing JSON files, and converting between plist and JSON formats
• Removed the “Display alternating row colors in tables” preference (we now always use alternating row colors)
• Removed the “Don’t shared find string with other applications” preference
• The label portion of custom formatted data is now a lighter shade of gray when selected, for improved visibility
• When a data object’s row is selected, the hexadecimal text is now drawn in white instead of black
• We now always move dragged plist objects instead of copying, unless dragging an item into itself or to another document
• Fixed a bug where changes made to the favorites list would not be remembered between launches
• Fixed a bug where changing an item from a dictionary to an array could cause PlistEdit Pro to hang
• Fixed a memory leak that would not reclaim some memory when closing documents
• Tweaked a couple things to improve document load time (up to 25% improvement for large files)
• Indexing for autocompletion is now performed in the background, improving the speed of opening documents
• Fixed an issue that could slow down open and find operations when using a structure definition that uses allowable value lists for some elements
• Fixed the “Open Help in Browser” menu item
• Editing using the Storage Size formatter now accepts fractional values correctly
• Fixed a bug where entering a negative floating point value for a number would not set the correct value
• Fixed a crash that could occur when creating a child of a variant dictionary while using a structure definition
• Variant keys and values are now saved properly in structure definitions

Version 1.5 (released 10/31/2009)

• Added a structure definition for hidden Xcode preferences
• Added a new data formatter for viewing/editing Snow Leopard bookmark data objects
• Fixed a bug where keyboard shortcuts in the favorites browser would not appear in the correct rows
• Removed the scripts menu, since it’s just as easy to use the system provided one now
• Removed the “Automatically begin editing newly created objects” preference. The new behavior is to always begin editing newly created objects.
• We now provide a custom interface for creating and editing property list structure definitions
• Added a “View By Subkey” command, to allow previewing a particular key in a list of dictionaries without having to expand each one
• Added a “Sort By Subkey” command that allows sorting an array of dictionaries based on one of their keys
• Fixed a bug where the incorrect row was colored red when a file in a property list browser could not be found
• Fixed a problem that would cause PlistEdit Pro to hang when attempting to save a file on a read-only volume
• Fixed some selection glitches when using the “Select All” command
• Opening the find panel no longer causes Spaces to switch to a different space.
• Improved speed of opening files when autocompletion is enabled.
• We now support the new XML based property list structure definitions introduced by Xcode 3.1
• Removed the preference to control undo levels

Version 1.4.2 (released 08/25/2009)

• Fixed a bug where files would not open properly under Snow Leopard

Version 1.4.1 (released 07/24/2008)

• Fixed a problem where some serial numbers would not work correctly on Tiger
• Updated Sparkle framework to version 1.5
• Fixed a few items in the German localization
• Plist/preferences browsers now resolve aliases when scanning for plists

Version 1.4 (released 04/17/2008)

• We now support editing any files on the system, prompting for an admin password to save changes when necessary
• Added autocompletion when entering data. Suggestions for keys and values are provided based on existing content in the property list and information found in plist definitions
• Plist definitions are now enabled by default. This makes autocompletion much more useful, especially when editing Info.plist files
• Updated plist definition files with new keys for Leopard, and added new definitions for Xgrid, Podcast Producer, iPhoto, and iTunes
• Added a new data formatter for viewing Carbon-style dates stored as a number of seconds since 01/01/1904
• You can now set up and save property list browser configurations, which gives easy access to all plist files in one or more directories on your system
• The minimum system requirement has changed from 10.3.9 to 10.4.0

Version 1.3.1 (released 11/02/2007)

• Added new preferences for case sensitive and numeric sorting
• Implemented ODB editor suite and Xcode editor interface, improving PlistEdit Pro’s ability to be used as an external editor
• Fixed a bug where hex data would be displayed byte swapped on Intel machines
• The search field is now focused by default when opening the preferences browser
• Data items now display how many bytes they contain
• We now use the new yellow find indicator in Leopard

Version 1.3 (released 10/10/2006)

• Added syntax coloring for XML tags in the plist text view
• New data formatters allow viewing of plist values interpreted as different data types. Formatters include:
  • View number objects as: four character code, storage size (KB, MB, etc.), hours/minutes/seconds, hexadecimal (big and little endian), or dates expressed as time intervals
  • View data objects as: alias records, strings (UTF-8, UTF-16, MacOS Roman, and ASCII encodings)
• Added Sparkle support, allowing for automatic downloading of updates
• The edit value sheet and the preferences window now remembers their position and size
• Double clicking on parentheses/brackets in the text view now selects to the matching parenthesis/bracket
• Tooltips are now displayed for values to large to draw in the value column (Tiger only)
• Copying drag and drop of plist objects now puts a textual version in the clipboard/drag
• Added toolbar buttons for Edit Value and Prefs Browser

Version 1.2.1 (released 06/05/2006)

• Updated to be a Universal binary which will run on both PPC and Intel Macs. The minimum system requirement is now OS X 10.3.9
• Added a new improved German localization
• Editing a long hex data value in the edit sheet now properly displays the entire value
• Menu items are now enabled properly when triggering a pop-up menu in the main outline view via the space bar
• Added a service to open plist text in PlistEdit Pro. This also allows dragging plist text onto the dock icon to open it (Tiger only).
• Added pledit command line tool, which allows opening plists and piping plist text to PlistEdit Pro

Version 1.2 (released 06/22/2005)

• Added “Goto Line” command for textual editing view
• Long strings and other values can now be viewed/edited in a separate sheet
• You can also assign a value to multiple items at once using the edit sheet
• Added a column to view the format of property list files in property list browsers
• You can now do batch validation and format conversion of plist files within a property list browser
• Created new property list definitions for Info.plist, Core Image, sync schemas, and launchd plists
• Added new menu items to add keys defined in property list definitions
• Xcode integration can now be disabled
• Added new “Select Parent” menu item
• When running under Tiger, you can tell the system to write preference plists as XML instead of binary
• You can now tell PlistEdit Pro to check for updates on the internet
• When activated, PlistEdit Pro can now detect if a file has been changed on disk and ask the user if they want to read in the new changes

Version 1.1.2 (released 04/25/2005)

• Fixed a problem that prevented the prefs browser from displaying on Tiger
• The revert command now reads the contents of files that have been edited externally
• Improved performance when opening large property list files with the text view hidden
• Fixed a problem where some files would not display properly in property list browsers

Version 1.1.1 (released 01/08/2005)

• Fixed some issues in the German localization
• You can now use PlistEdit Pro as an external editor for Xcode/Project Builder
• You can now add a plist file directly to an open Xcode project while saving
• When opening a corrupt property list, you can now examine and fix the plist text
• Property list browsers now support multiple selection

Version 1.1 (released 08/10/2004)

• Added a favorites menu, with configurable keyboard shortcuts
• The preferences browser now scans subfolders of the preferences folders
• Added a generic property list browser, so you can view lists of plist files other than the preferences folder
• Added the ability to drag a folder to the application and view all the property list files within
• Added search by content in plist browsers
• Added a scripts menu
• Added a German localization
• You can now choose what font to use in plist browsers
• There is now an option to automatically start editing newly created objects
• Fixed a bug with input of non-English formatted numbers

Version 1.0.1 (released 3/10/2004)

• Numbers are now formatted correctly in non-US localizations
• Added support for reading/writing ‘plst’ resources
• We now handle page up/down and home/end keys in the outline view