Full download ebook at ebookname.

com

iOS 7 Programming Cookbook 2nd Edition Vandad

Nahavandipoor

https://ebookname.com/product/ios-7-programming-
cookbook-2nd-edition-vandad-nahavandipoor/

OR CLICK BUTTON

DOWLOAD NOW

Download more ebook from https://ebookname.com

More products digital (pdf, epub, mobi) instant
download maybe you interests ...

iOS 4 Programming Cookbook Solutions Examples for

iPhone iPad and iPod touch Apps 1st Edition Vandad
Nahavandipoor

https://ebookname.com/product/ios-4-programming-cookbook-
solutions-examples-for-iphone-ipad-and-ipod-touch-apps-1st-
edition-vandad-nahavandipoor/

Writing Game Center Apps in iOS Bringing Your Players

Into the Game 1st Edition Vandad Nahavandipoor

https://ebookname.com/product/writing-game-center-apps-in-ios-
bringing-your-players-into-the-game-1st-edition-vandad-
nahavandipoor/

iOS and OS X Network Programming Cookbook 1st Edition

Jon Hoffman

https://ebookname.com/product/ios-and-os-x-network-programming-
cookbook-1st-edition-jon-hoffman/

Programming ArcGIS with Python Cookbook 2nd Edition

Eric Pimpler

https://ebookname.com/product/programming-arcgis-with-python-
cookbook-2nd-edition-eric-pimpler/
IOS development with Xamarin cookbook over 100 exciting
recipes to help you develop iOS applications with
Xamarin 2nd Edition Tavlikos

https://ebookname.com/product/ios-development-with-xamarin-
cookbook-over-100-exciting-recipes-to-help-you-develop-ios-
applications-with-xamarin-2nd-edition-tavlikos/

Swift Pocket Reference 2nd Edition Programming for iOS

and OS X Anthony Gray

https://ebookname.com/product/swift-pocket-reference-2nd-edition-
programming-for-ios-and-os-x-anthony-gray/

iOS SDK Programming A Beginners Guide 1st Edition James

Brannan

https://ebookname.com/product/ios-sdk-programming-a-beginners-
guide-1st-edition-james-brannan/

Learning iOS Programming From Xcode to App Store Third

Edition Alasdair Allan

https://ebookname.com/product/learning-ios-programming-from-
xcode-to-app-store-third-edition-alasdair-allan/

Java Extreme Programming Cookbook 1st Edition Eric M.

Burke

https://ebookname.com/product/java-extreme-programming-
cookbook-1st-edition-eric-m-burke/
iOS 7 Programming Cookbook

Vandad Nahavandipoor
iOS 7 Programming Cookbook
by Vandad Nahavandipoor
Copyright © 2014 Vandad Nahavandipoor. All rights reserved.
Printed in the United States of America.
Published by O’Reilly Media, Inc., 1005 Gravenstein Highway North, Sebastopol, CA 95472.
O’Reilly books may be purchased for educational, business, or sales promotional use. Online editions are
also available for most titles (http://my.safaribooksonline.com). For more information, contact our corporate/
institutional sales department: 800-998-9938 or [email protected].
Editors: Andy Oram and Rachel Roumeliotis Indexer: Angela Howard
Production Editor: Christopher Hearse Cover Designer: Randy Comer
Copyeditor: Zyg Group, LLC Interior Designer: David Futato
Proofreader: Julie Van Keuren Illustrator: Rebecca Demarest

October 2013: First Edition

Revision History for the First Edition:

2013-10-09: First release

See http://oreilly.com/catalog/errata.csp?isbn=9781449372422 for release details.

Nutshell Handbook, the Nutshell Handbook logo, and the O’Reilly logo are registered trademarks of O’Reilly
Media, Inc., iOS 7 Programming Cookbook, the image of a Cowan’s shrew tenrec, and related trade dress are
trademarks of O’Reilly Media, Inc.
Many of the designations used by manufacturers and sellers to distinguish their products are claimed as
trademarks. Where those designations appear in this book, and O’Reilly Media, Inc., was aware of a trade‐
mark claim, the designations have been printed in caps or initial caps.
While every precaution has been taken in the preparation of this book, the publisher and author assume no
responsibility for errors or omissions, or for damages resulting from the use of the information contained
herein.

ISBN: 978-1-449-37242-2
[QG]
 Table of Contents

Preface. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . xi

1. Implementing Controllers and Views. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1

1.1. Displaying Alerts with UIAlertView 23
1.2. Creating and Using Switches with UISwitch 32
1.3. Customizing the UISwitch 36
1.4. Picking Values with the UIPickerView 39
1.5. Picking the Date and Time with UIDatePicker 45
1.6. Implementing Range Pickers with UISlider 50
1.7. Customizing the UISlider 54
1.8. Grouping Compact Options with UISegmentedControl 59
1.9. Presenting and Managing Views with UIViewController 63
1.10. Presenting Sharing Options with UIActivityViewController 67
1.11. Presenting Custom Sharing Options with UIActivityViewController 73
1.12. Implementing Navigation with UINavigationController 79
1.13. Manipulating a Navigation Controller’s Array of View Controllers 85
1.14. Displaying an Image on a Navigation Bar 86
1.15. Adding Buttons to Navigation Bars Using UIBarButtonItem 88
1.16. Presenting Multiple View Controllers with UITabBarController 94
1.17. Displaying Static Text with UILabel 101
1.18. Customizing the UILabel 105
1.19. Accepting User Text Input with UITextField 108
1.20. Displaying Long Lines of Text with UITextView 118
1.21. Adding Buttons to the User Interface with UIButton 123
1.22. Displaying Images with UIImageView 127
1.23. Creating Scrollable Content with UIScrollView 132
1.24. Loading Web Pages with UIWebView 137
1.25. Displaying Progress with UIProgressView 141
1.26. Constructing and Displaying Styled Texts 143

iii
 1.27. Presenting Master-Detail Views with UISplitViewController 148
1.28. Enabling Paging with UIPageViewController 153
1.29. Displaying Popovers with UIPopoverController 158

2. Creating Dynamic and Interactive User Interfaces. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 169

2.1. Adding Gravity to Your UI Components 171
2.2. Detecting and Reacting to Collisions Between UI Components 172
2.3. Animating Your UI Components with a Push 180
2.4. Attaching Multiple Dynamic Items to Each Other 184
2.5. Adding a Dynamic Snap Effect to Your UI Components 189
2.6. Assigning Characteristics to Your Dynamic Effects 192

3. Auto Layout and the Visual Format Language. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 197

3.1. Placing UI Components in the Center of the Screen 201
3.2. Defining Horizontal and Vertical Constraints with the Visual Format
Language 203
3.3. Utilizing Cross View Constraints 210
3.4. Configuring Auto Layout Constraints in Interface Builder 217

4. Constructing and Using Table Views. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 221

4.1. Populating a Table View with Data 225
4.2. Using Different Types of Accessories in a Table View Cell 229
4.3. Creating Custom Table View Cell Accessories 232
4.4. Enabling Swipe Deletion of Table View Cells 235
4.5. Constructing Headers and Footers in Table Views 237
4.6. Displaying Context Menus on Table View Cells 246
4.7. Moving Cells and Sections in Table Views 251
4.8. Deleting Cells and Sections from Table Views 257
4.9. Utilizing the UITableViewController for Easy Creation of Table Views 268
4.10. Displaying a Refresh Control for Table Views 274

5. Building Complex Layouts with Collection Views. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 279

5.1. Constructing Collection Views 281
5.2. Assigning a Data Source to a Collection View 284
5.3. Providing a Flow Layout to a Collection View 285
5.4. Providing Basic Content to a Collection View 288
5.5. Feeding Custom Cells to Collection Views Using .xib Files 294
5.6. Handling Events in Collection Views 299
5.7. Providing a Header and a Footer in a Flow Layout 303
5.8. Adding Custom Interactions to Collection Views 308

iv | Table of Contents
 5.9. Providing Contextual Menus on Collection View Cells 311

6. Storyboards. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 315
6.1. Adding a Navigation Controller to a Storyboard 316
6.2. Passing Data from One Screen to Another 318
6.3. Adding a Tab Bar Controller to a Storyboard 325
6.4. Introducing Custom Segue Transitions to Your Storyboard 328
6.5. Placing Images and Other UI Components on Storyboards 332

7. Concurrency. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 335
7.1. Constructing Block Objects 342
7.2. Accessing Variables in Block Objects 346
7.3. Invoking Block Objects 352
7.4. Performing UI-Related Tasks with GCD 354
7.5. Executing Non-UI Related Tasks Synchronously with GCD 358
7.6. Executing Non-UI Related Tasks Asynchronously with GCD 361
7.7. Performing Tasks after a Delay with GCD 368
7.8. Performing a Task Only Once with GCD 371
7.9. Grouping Tasks Together with GCD 373
7.10. Constructing Your Own Dispatch Queues with GCD 377
7.11. Running Tasks Synchronously with Operations 380
7.12. Running Tasks Asynchronously with Operations 387
7.13. Creating Dependency Between Operations 393
7.14. Creating Timers 395
7.15. Creating Concurrency with Threads 400
7.16. Invoking Background Methods 406
7.17. Exiting Threads and Timers 407

8. Security. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 411
8.1. Enabling Security and Protection for Your Apps 418
8.2. Storing Values in the Keychain 422
8.3. Finding Values in the Keychain 424
8.4. Updating Existing Values in the Keychain 429
8.5. Deleting Exiting Values in the Keychain 432
8.6. Sharing Keychain Data Between Multiple Apps 434
8.7. Writing to and Reading Keychain Data from iCloud 440
8.8. Storing Files Securely in the App Sandbox 443
8.9. Securing Your User Interface 446

9. Core Location and Maps. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 449

9.1. Creating a Map View 450
9.2. Handling the Events of a Map View 452

Table of Contents | v
 9.3. Pinpointing the Location of a Device 453
9.4. Displaying Pins on a Map View 455
9.5. Displaying Pins with Different Colors on a Map View 459
9.6. Displaying Custom Pins on a Map View 465
9.7. Converting Meaningful Addresses to Longitude and Latitude 468
9.8. Converting Longitude and Latitude to a Meaningful Address 470
9.9. Searching on a Map View 472
9.10. Displaying Directions on the Map 475

10. Implementing Gesture Recognizers. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 481

10.1. Detecting Swipe Gestures 483
10.2. Detecting Rotation Gestures 485
10.3. Detecting Panning and Dragging Gestures 489
10.4. Detecting Long-Press Gestures 491
10.5. Detecting Tap Gestures 495
10.6. Detecting Pinch Gestures 497

11. Networking, JSON, XML, and Sharing. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 501

11.1. Downloading Asynchronously with NSURLConnection 501
11.2. Handling Timeouts in Asynchronous Connections 504
11.3. Downloading Synchronously with NSURLConnection 506
11.4. Modifying a URL Request with NSMutableURLRequest 508
11.5. Sending HTTP GET Requests with NSURLConnection 509
11.6. Sending HTTP POST Requests with NSURLConnection 511
11.7. Sending HTTP DELETE Requests with NSURLConnection 513
11.8. Sending HTTP PUT Requests with NSURLConnection 514
11.9. Serializing Arrays and Dictionaries into JSON 516
11.10. Deserializing JSON into Arrays and Dictionaries 518
11.11. Integrating Social Sharing into Your Apps 521
11.12. Parsing XML with NSXMLParser 525

12. Audio and Video. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 531

12.1. Playing Audio Files 531
12.2. Handling Interruptions While Playing Audio 534
12.3. Recording Audio 535
12.4. Handling Interruptions While Recording Audio 542
12.5. Playing Audio over Other Active Sounds 543
12.6. Playing Video Files 547
12.7. Capturing Thumbnails from Video Files 551
12.8. Accessing the Music Library 554

13. Address Book. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 563

vi | Table of Contents
 13.1. Requesting Access to the Address Book 564
13.2. Retrieving a Reference to an Address Book 568
13.3. Retrieving All the People in the Address Book 571
13.4. Retrieving Properties of Address Book Entries 573
13.5. Inserting a Person Entry into the Address Book 577
13.6. Inserting a Group Entry into the Address Book 581
13.7. Adding Persons to Groups 584
13.8. Searching the Address Book 587
13.9. Retrieving and Setting a Person’s Address Book Image 592

14. Files and Folder Management. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 601

14.1. Finding the Paths of the Most Useful Folders on Disk 603
14.2. Writing to and Reading from Files 605
14.3. Creating Folders on Disk 610
14.4. Enumerating Files and Folders 612
14.5. Deleting Files and Folders 618
14.6. Saving Objects to Files 621

15. Camera and the Photo Library. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 625

15.1. Detecting and Probing the Camera 627
15.2. Taking Photos with the Camera 632
15.3. Taking Videos with the Camera 636
15.4. Storing Photos in the Photo Library 639
15.5. Storing Videos in the Photo Library 644
15.6. Retrieving Photos and Videos from the Photo Library 646
15.7. Retrieving Assets from the Assets Library 649
15.8. Editing Videos on an iOS Device 656

16. Multitasking. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 663

16.1. Detecting the Availability of Multitasking 664
16.2. Completing a Long-Running Task in the Background 665
16.3. Adding Background Fetch Capabilities to Your Apps 669
16.4. Playing Audio in the Background 678
16.5. Handling Location Changes in the Background 682
16.6. Saving and Loading the State of Multitasking Apps 684
16.7. Handling Network Connections in the Background 688
16.8. Opting Out of Multitasking 691

17. Notifications. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 693

17.1. Sending Notifications 694
17.2. Listening for and Reacting to Notifications 696
17.3. Listening and Reacting to Keyboard Notifications 700

Table of Contents | vii

 17.4. Scheduling Local Notifications 707
17.5. Listening for and Reacting to Local Notifications 711
17.6. Handling Local System Notifications 714
17.7. Setting Up Your App for Push Notifications 718
17.8. Delivering Push Notifications to Your App 724
17.9. Reacting to Push Notifications 732

18. Core Data. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 735

18.1. Creating a Core Data Model with Xcode 737
18.2. Generating Class Files for Core Data Entities 741
18.3. Creating and Saving Data Using Core Data 745
18.4. Reading Data from Core Data 747
18.5. Deleting Data from Core Data 750
18.6. Sorting Data in Core Data 752
18.7. Boosting Data Access in Table Views 754
18.8. Implementing Relationships in Core Data 761
18.9. Fetching Data in the Background 768
18.10. Using Custom Data Types in Your Core Data Model 772

19. Dates, Calendars, and Events. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 779

19.1. Requesting Permission to Access Calendars 784
19.2. Retrieving Calendar Groups on an iOS Device 790
19.3. Adding Events to Calendars 792
19.4. Accessing the Contents of Calendars 796
19.5. Removing Events from Calendars 799
19.6. Adding Recurring Events to Calendars 803
19.7. Retrieving the Attendees of an Event 808
19.8. Adding Alarms to Calendars 811
19.9. Handling Event Changed Notifications 814
19.10. Presenting Event View Controllers 816
19.11. Presenting Event Edit View Controllers 822

20. Graphics and Animations. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 827

20.1. Enumerating and Loading Fonts 833
20.2. Drawing Text 835
20.3. Constructing, Setting, and Using Colors 836
20.4. Drawing Images 841
20.5. Constructing Resizable Images 845
20.6. Drawing Lines 850
20.7. Constructing Paths 858
20.8. Drawing Rectangles 862
20.9. Adding Shadows to Shapes 866

viii | Table of Contents

 20.10. Drawing Gradients 873
20.11. Moving Shapes Drawn on Graphic Contexts 882
20.12. Scaling Shapes Drawn on Graphic Contexts 886
20.13. Rotating Shapes Drawn on Graphic Contexts 889
20.14. Animating and Moving Views 890
20.15. Animating and Scaling Views 900
20.16. Animating and Rotating Views 901
20.17. Capturing a Screenshot of Your View into an Image 903

21. Core Motion. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 907

21.1. Detecting the Availability of an Accelerometer 908
21.2. Detecting the Availability of a Gyroscope 910
21.3. Retrieving Accelerometer Data 911
21.4. Detecting Shakes on an iOS Device 915
21.5. Retrieving Gyroscope Data 916

22. iCloud. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 919

22.1. Setting Up Your App for iCloud 920
22.2. Storing and Synchronizing Dictionaries in iCloud 924
22.3. Creating and Managing Folders for Apps in iCloud 929
22.4. Searching for Files and Folders in iCloud 936
22.5. Storing User Documents in iCloud 946
22.6. Managing the State of Documents in iCloud 961

23. Pass Kit. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 965

23.1. Creating Pass Kit Certificates 968
23.2. Creating Pass Files 975
23.3. Providing Icons and Images for Passes 984
23.4. Preparing Your Passes for Digital Signature 987
23.5. Signing Passes Digitally 989
23.6. Distributing Passes Using Email 993
23.7. Distributing Passes Using Web Services 995
23.8. Enabling Your iOS Apps to Access Passes on iOS Devices 997
23.9. Interacting with Passbook Programmatically 1003

Index. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1007

Table of Contents | ix
 Preface

This edition of the book is not just an update, but a total remake of the previous edition.
iOS 7 changed everything: the look and feel, the way we use our iOS devices, and most
importantly, the way we program for iOS devices. This called for a substantial rewrite
indeed. I have added roughly 50 new recipes to this book, talking about things such as
UIKit dynamics, collection views, the keychain, push notifications, and whatnot. I have
also gone through all the example codes and figures and updated them for iOS 7.
iOS 7 is a huge step forward for this amazing operating system that we all, as program‐
mers and users, have grown to love and enjoy programming for. You must have noticed
how the focus of iOS 7 is on being dynamic: how your UI should adapt to various
movements and motions that can be applied to the device. What I mean by that is Apple
wants developers to really look at the details of their apps and bring real-world physics
and dynamics into them. That’s why Apple introduced UIKit Dynamics to the SDK, and
that is why this book has a whole chapter dedicated to this concept. The more expensive
a high-end device such as the new iPhone becomes, the more demanding the users will
get as well. Nobody blames them, though! They have just bought a fantastic and top-
of-the-line new iPhone or iPad and they want to see amazing apps running on them,
leveraging all the capabilities that those devices have to offer.
That is why now more than ever developers have to get an in-depth knowledge of the
SDK and what the SDK has to offer to the developers so that we can create better and
faster apps for iOS users. Apple introduced a lot of cool new APIs to the iOS 7 SDK, and
we are going to explore them in this book.
The focus of iOS 7 is dynamics!
Before you read about this book, maybe you’d like to know about my background a bit
and how I can help you through this journey. I will just briefly let you know who I am
and how I got to love iOS. I started out writing Basic code for my Commodore 64 when
I was a kid. I then moved on to buy my own PC and started experimenting with Assembly
code. At first, it was 8-bit Assembly for DOS. I then moved onto writing my own hobby

xi
operating system, which was never really released as a commercial product, for 32-bit
Intel x86 CPU architectures.
Among all the programming languages that I have programmed in, Assembly and
Objective-C are the two that have really been different from the others, and I’ve really
liked them. Assembly because of the purity of the language: a command does only one
thing and does that one thing well. I believe that I like Objective-C for the same reason,
and in fact iOS shares the same trait with Assembly and Objective-C. Even though iOS
is an operating system and not a programming language, whatever it does, it does it best
and better than its rivals. From its simplicity to the sheer power that you can harvest
from the software and the hardware combined, using technologies such as GCD, the
bar that iOS has set in terms of ease of use and beauty is unprecedented.
This edition of the book has seen all the recipes inside all chapters completely renewed
for iOS 7. All screenshots have been updated, and many more recipes—such as those
related to security and the keychain, UI dynamics, collection views, push and local
notifications, and many more—have exclusively been written for this edition of the
book. I really have had a fun time writing this edition of the book, and packed as it is
with new features, I hope you’ll enjoy reading it. May it be a valuable addition to your
tech-book library.

Audience
I assume you are comfortable with the iOS development environment and know how
to create an app for the iPhone or iPad. This book does not get novice programmers
started but presents useful ways to get things done for iOS programmers ranging from
novices to experts.

Organization of This Book

In this book, we will discuss frameworks and classes that are available in the iOS 7 SDK.
This book does its best to teach you the latest and the greatest APIs. As you know, some
users of your apps may still be on older versions of iOS, so please consider those users
and choose your APIs wisely, depending on the minimum iOS version that you want to
target with your apps.
Apple has recommended that you write your apps so that they support and run on iOS
6 and iOS 7. This means you need to use the latest SDK as your base SDK (the SDK that
you use to compile your app) and choose iOS 6 as your target, if that’s what your business
requirements dictate. If you are required to write your app to support only iOS 7, then
you are in for a lot of fun, as you can use all the cool APIs that have been introduced in
iOS 7 and discussed in this book.

xii | Preface
Here is a concise breakdown of the material each chapter covers:
Chapter 1, Implementing Controllers and Views
Explains how Objective-C classes are structured and how objects can be instanti‐
ated. The chapter talks about properties and delegates and subscripting by keys and
indexes. Even if you are competent in Objective-C, I strongly suggest that you read
this chapter, even if you only skim through it, to understand the basic material that
is used in the rest of the book. In this chapter, we will also explore the common
usage of various UI components, such as alert views, segmented controls, switches,
and labels. We will also talk about customizing these components with the latest
APIs provided in the SDK.
Chapter 2, Creating Dynamic and Interactive User Interfaces
Talks about UIKit Dynamics, the newest addition to the UIKit framework. These
dynamics allow you to add real-life physics and dynamics to your UI components.
This will allow you to create even livelier user interfaces with very small effort on
your side.
Chapter 3, Auto Layout and the Visual Format Language
Explains how you can take advantage of Auto Layout in the iOS SDK in order to
construct your UI in such a way that it can be resized and stretched to pretty much
any screen dimension.
Chapter 4, Constructing and Using Table Views
Shows how you can work with table views to create professional-looking iOS ap‐
plications. Table views are very dynamic in nature, and as a result, programmers
sometimes have difficulty understanding how they should work with them. By
reading this chapter and trying out the example code, you will gain the knowledge
that is required to comfortably work with table views.
Chapter 5, Building Complex Layouts with Collection Views
Collection views have been available to OS X programmers for quite some time
now, and Apple decided to provide the same APIs to iOS programmers in the iOS
SDK. Collection views are very much like table views, but they are much more
configurable and dynamic. Where in table views we have the concept of sections
and rows in each section, collection views bring columns to the equation as well,
so that you can display many items in one row if you want to. In this chapter we
will have a look at all the great user interfaces that you can create using collection
views.
Chapter 6, Storyboards
Demonstrates the process of storyboarding, the new way to define the connections
between different screens in your app. The great thing about storyboarding is that
you don’t have to know anything about iOS programming to get a simple app run‐
ning. This helps product analysts, product owners, or designers who work inde‐
pendently of developers to gain knowledge of the UI components iOS offers and to

Preface | xiii
 build more robust products. Programmers can also take advantage of storyboarding
to easily create prototypes. Storyboarding is just fun, whether you do it on paper
or using Xcode.
Chapter 7, Concurrency
As humans, we can do many things simultaneously without thinking much about
it. With advances in computer technology, mobile devices are also able to multitask,
and they provide programmers with tools and mechanisms that can accomplish
more than one task at the same time. This is called concurrency. In this chapter, you
will learn about Grand Central Dispatch, Apple’s preferred way of achieving con‐
currency in iOS. You will also learn about timers, threads, and operations.
Chapter 8, Security
iOS is a very secure operating system, and apps that we write for it also have to
adhere to certain security standards and practices. In this chapter, we will discuss
how you can take advantage of keychain APIs to make your apps more secure. We
will also talk about various steps that you can take to make your user interface more
secure.
Chapter 9, Core Location and Maps
Describes how you should use Map Kit and Core Location APIs to develop location-
aware iOS applications. First you will learn about maps, and then you will learn
how to detect a device’s location and tailor your maps with custom annotations.
You will also learn about geocoding and reverse geocoding, as well as some of the
methods of the Core Location framework, which are available only in iOS 7.
Chapter 10, Implementing Gesture Recognizers
Demonstrates how to use gesture recognizers, which enable your users to easily and
intuitively manipulate the graphical interface of your iOS applications. In this
chapter, you will learn how to use all available gesture recognizers in the iOS SDK,
with working examples tested on iOS 7.
Chapter 11, Networking, JSON, XML, and Sharing
Demonstrates the built-in JSON and XML parsers. On top of that, this chapter talks
about various networking APIs and how programmers can build social networking
into our apps to allow our users to share their creations and data to social networks
such as Facebook.
Chapter 12, Audio and Video
Discusses the AV Foundation and Media Player frameworks that are available on
the iOS SDK. You will learn how to play audio and video files and how to handle
interruptions, such as a phone call, while the audio or video is being played. This
chapter also explains how to record audio using an iOS device’s built-in micro‐
phone(s). At the end of the chapter, you will learn how to access the Music Library
and play its media content, all from inside your application.

xiv | Preface
Chapter 13, Address Book
Explains the Address Book framework and how to retrieve contacts, groups, and
their information from the Address Book database on an iOS device. The Address
Book framework is composed entirely of C APIs. Because of this, many Objective-
C developers find it difficult to use this framework, as compared with frameworks
that provide an Objective-C interface. After reading this chapter and trying the
examples for yourself, you will feel much more confident using the Address Book
framework.
Chapter 14, Files and Folder Management
One of the most important tasks that, as developers, we want to perform in our iOS
apps is manipulating files and folders. Whether this means creating, reading from,
writing to, or deleting them, this chapter contains enough material to get you up
and running with file and folder management in the iOS SDK.
Chapter 15, Camera and the Photo Library
Demonstrates how you can determine the availability of front- and back-facing
cameras on an iOS device. You will also learn how to access the photo library using
the Assets Library framework. At the end of the chapter, you will learn about editing
videos right on an iOS device using a built-in view controller.
Chapter 16, Multitasking
Shows multitasking-aware applications that run beautifully on iOS devices. You will
learn about background processing, including how to play audio and retrieve users’
locations in the background, as well as how to download content from a URL while
your application is running in the background. On top of that, we will explore some
of the new APIs that iOS 7 provides to us, in order to enable our apps to download
content periodically while in the background or even while our app is not even
running.
Chapter 17, Notifications
Notifications are objects that can be composed by a source and delivered to multiple
recipients. In this chapter, we will discuss notifications, including local notifications
and push notifications, along with how you can use the latest capabilities built into
Xcode to easily enable these features in your own apps.
Chapter 18, Core Data
Describes the details of Core Data stacks and what they are made out of. You will
then be able to design your own object-oriented data models right into Xcode, using
the Core Data model editor, and also create and retrieve your objects in Core Data.
On top of that, you will learn how to add your own custom data to Core Data and
how to search for data in the background thread, leaving your UI thread ready to
process user events.

Preface | xv
Chapter 19, Dates, Calendars, and Events
Demonstrates the use of the Event Kit and Event Kit UI frameworks in order to
manage calendars and events on an iOS device. You will see how to create, modify,
save, and delete events. You will also learn, through examples, how to add alarms
to calendar events and how to set up CalDAV calendars so that you can share a
single calendar among multiple devices.
Chapter 20, Graphics and Animations
Introduces the Core Graphics framework. You will learn how to draw images and
text on a graphics context; draw lines, rectangles, and paths; and much more. You
will also learn to use the new iOS SDK APIs to capture your views’ contents as
screenshots.
Chapter 21, Core Motion
Explains the Core Motion framework. Using Core Motion, you will access the ac‐
celerometer and the gyroscope on an iOS device. You will also learn how to detect
shakes on a device. Of course, not all iOS devices are equipped with an accelerom‐
eter and a gyroscope, so you will also learn how to detect the availability of the
required hardware.
Chapter 22, iCloud
Shows how to use the iCloud service, which ties devices together and allows them
to share data to provide a seamless user experience as the user moves from one
device to another.
Chapter 23, Pass Kit
Describes Passbook: a virtual wallet, if you will, capable of managing your coupons,
boarding passes, rail and bus tickets, and much more. In this chapter, you will learn
all there is to know in order to be able to create your own digitally signed passes
and distribute them to your users easily.

Additional Resources
From time to time, I refer to official Apple documentation. Some of Apple’s descriptions
are right on the mark, and there is no point in trying to restate them. Throughout this
book, I have listed the most important documents and guides in the official Apple doc‐
umentation that every professional iOS developer should read.
For starters, I suggest that you have a look at the iOS Human Interface Guidelines for
all iOS devices. This document will tell you everything you need to know about devel‐
oping engaging and intuitive user interfaces for all iOS devices. Every iOS programmer
should read this document. In fact, I believe this should be required reading for the
product design and development teams of any company that develops iOS applications.

xvi | Preface
I also suggest that you skim through the “iOS App Programming Guide” in the iOS
Developer Library for some tips and advice on how to make great iOS applications.
iOS 7 brings with itself quite a lot of changes to how UI components appear on the
screen. We will talk at great length about these changes and how you, as the programmer,
can use the latest APIs to create great-looking apps for iOS 7. However, I would like to
suggest that you have a look at the iOS 7 UI Transition Guide provided by Apple, which
outlines all the UI changes that have now been made to the latest version of the SDK.
One of the things you will notice when reading Chapter 16 is the use of block objects.
This book concisely explains block objects, but if you require further details on the
subject, I suggest you read “A Short Practical Guide to Blocks”.
Throughout this book, you will see references to “bundles” and loading images and data
from bundles. You will read a concise overview about bundles in this book, but if you
require further information, head over to the “Bundle Programming Guide”.

Conventions Used in This Book

The following typographical conventions are used in this book:
Italic
Indicates new terms, URLs, email addresses, filenames, and file extensions.
Constant width
Used for program listings, as well as within paragraphs to refer to program elements
such as variable or function names, databases, data types, environment variables,
statements, and keywords.
Constant width bold
Shows commands or other text that should be typed literally by the user.
Constant width italic
Shows text that should be replaced with user-supplied values or by values deter‐
mined by context.

This icon signifies a tip, suggestion, or general note.

This icon indicates a warning or caution.

Preface | xvii
Using Code Examples
Supplemental material (code examples, exercises, etc.) is available for download at
https://github.com/oreillymedia/iOS7_programming_cookbook.
This book is here to help you get your job done. In general, if example code is offered
with this book, you may use it in your programs and documentation. You do not need
to contact us for permission unless you’re reproducing a significant portion of the code.
For example, writing a program that uses several chunks of code from this book does
not require permission. Selling or distributing a CD-ROM of examples from O’Reilly
books does require permission. Answering a question by citing this book and quoting
example code does not require permission. Incorporating a significant amount of ex‐
ample code from this book into your product’s documentation does require permission.
We appreciate, but do not require, attribution. An attribution usually includes the title,
author, publisher, and ISBN. For example: “iOS 7 Programming Cookbook
by Vandad Nahavandipoor (O’Reilly). Copyright 2014 Vandad Nahavandipoor,
978-1-4493-7242-2.”
If you feel your use of code examples falls outside fair use or the permission given here,
feel free to contact us at [email protected].

Safari® Books Online

Safari Books Online (www.safaribooksonline.com) is an on-
demand digital library that delivers expert content in both book and
video form from the world’s leading authors in technology and busi‐
ness.
Technology professionals, software developers, web designers, and business and crea‐
tive professionals use Safari Books Online as their primary resource for research, prob‐
lem solving, learning, and certification training.
Safari Books Online offers a range of product mixes and pricing programs for organi‐
zations, government agencies, and individuals. Subscribers have access to thousands of
books, training videos, and prepublication manuscripts in one fully searchable database
from publishers like O’Reilly Media, Prentice Hall Professional, Addison-Wesley Pro‐
fessional, Microsoft Press, Sams, Que, Peachpit Press, Focal Press, Cisco Press, John
Wiley & Sons, Syngress, Morgan Kaufmann, IBM Redbooks, Packt, Adobe Press, FT
Press, Apress, Manning, New Riders, McGraw-Hill, Jones & Bartlett, Course Technol‐
ogy, and dozens more. For more information about Safari Books Online, please visit us
online.

xviii | Preface
How to Contact Us
Please address comments and questions concerning this book to the publisher:

O’Reilly Media, Inc.

1005 Gravenstein Highway North
Sebastopol, CA 95472
800-998-9938 (in the United States or Canada)
707-829-0515 (international or local)
707-829-0104 (fax)

We have a web page for this book, where we list errata, examples, and any additional
information. You can access this page at http://oreil.ly/iOS7-Programming-Cookbook.
To comment or ask technical questions about this book, send email to bookques
[email protected].
For more information about our books, courses, conferences, and news, see our website
at http://www.oreilly.com.
Find us on Facebook: http://facebook.com/oreilly
Follow us on Twitter: http://twitter.com/oreillymedia
Watch us on YouTube: http://www.youtube.com/oreillymedia

Acknowledgments
Andy Oram, my lovely editor, has again done an amazing job going through all the
changes that I made in this edition of the book. In fact, the whole book is updated in
this edition, and all example codes and screenshots have also been updated. I’d like to
also thank Krzysztof Grobelny and Krzysztof Gutowski, my great friends and colleagues,
for tech-reviewing this book. Without their help, this book wouldn’t be in your hands.
I’d like to say thank you to Rachel Roumeliotis, for supporting me and Andy, among all
the other admin work that she did for us behind the scenes. Rachel, you may be quiet,
but we’d have to be blind not to notice your hard work in the background. Also, Meghan
Connolly of O’Reilly has been a fantastic sport, listening to my nagging about paper‐
work, and she has been absolute bliss to work with. A thank-you goes to Jessica Hosman
for helping us a great deal with Git issues. Even though I didn’t believe the simple sol‐
utions that she suggested to me would work, they did, and I looked like a fool.
Last but not least, thank you to Alina Rizzoni, Bruno Packham, and Thomas Packham
for being real friends. I feel blessed to know them, and I appreciate their help and
support.

Preface | xix
 CHAPTER 1
Implementing Controllers and Views

1.0. Introduction
iOS 7 has introduced a lot of new features to users, as well as tons of new APIs for us
programmers to use and play with. You probably already know that the user interface
has drastically changed in iOS 7. This user interface had stayed intact all the way from
the first version of iOS till now, and because of this, many apps were coded on the
assumption that this user interface would not ever change. Graphic designers are now
faced with the challenge of creating the user interface and thinking about the user ex‐
perience in a way that makes it great for both pre- and post-iOS 7 user interfaces (UIs).
In order to write apps for iOS 7, you need to know some of the basics of the Objective-
C programming language that we will use throughout this book. Objective-C, as its
name implies, is based on C with extensions that allow it to make use of objects. Objects
and classes are fundamental in object-oriented programming (OOP) languages such as
Objective-C, Java, C++, and many others. In Objective-C, like any other object-oriented
language (OOL), you have not only access to objects, but also to primitives. For instance,
the number –20 (minus twenty) can be expressed simply as a primitive in this way:
NSInteger myNumber = -20;

This simple line of code will define a variable named myNumber with the data type of
NSInteger and sets its value to 20. This is how we define variables in Objective-C. A
variable is a simple assignment of a name to a location in memory. In this case, when
we set 20 as the value of the myNumber variable, we are telling the machine that will
eventually run this piece of code to put the aforementioned value in a memory location
that belongs to the variable myNumber.
All iOS applications essentially use the model-view-controller (MVC) architecture.
Model, view, and controller are the three main components of an iOS application from
an architectural perspective.

1
The model is the brain of the application. It does the calculations and creates a virtual
world for itself that can live without the views and controllers. In other words, think of
a model as a virtual copy of your application, without a face!
A view is the window through which your users interact with your application. It displays
what’s inside the model most of the time, but in addition to that, it accepts users’ inter‐
actions. Any interaction between the user and your application is sent to a view, which
then can be captured by a view controller and sent to the model.
The controller in iOS programming usually refers to the view controllers I just men‐
tioned. Think of a view controller as a bridge between the model and your views. This
controller interprets what is happening on one side and uses that information to alter
the other side as needed. For instance, if the user changes some field in a view, the
controller makes sure the model changes in response. And if the model gets new data,
the controller tells the view to reflect it.
In this chapter, you will learn how to create the structure of an iOS application and how
to use views and view controllers to create intuitive applications.

In this chapter, for most of the user interface (UI) components that we
create, we are using a Single View Application template in Xcode. To
reproduce the examples, follow the instructions in “Creating and Run‐
ning Our First iOS App” on page 2. Make sure that your app is uni‐
versal, as opposed to an iPhone or iPad app. A universal app can run
on both iPhone and iPad.

Creating and Running Our First iOS App

Before we dive any deeper into the features of Objective-C, we should have a brief look
at how to create a simple iOS app in Xcode. Xcode is Apple’s IDE (integrated develop‐
ment environment) that allows you to create, build, and run your apps on iOS Simulator
and even on real iOS devices. We will talk more about Xcode and its features as we go
along, but for now let’s focus on creating and running a simple iOS app. I assume that
you’ve already downloaded Xcode into your computer from the Mac App Store. Once
that step is taken care of, please follow these steps to create and run a simple iOS app:

1. Open Xcode if it’s not already open.

2. From the File menu, choose New Project...
3. In the New Project window that appears, on the lefthand side under the iOS cate‐
gory, choose Application and then on the righthand side choose Single View Ap‐
plication. Then press the Next button.
4. On the next screen, for the Product Name, enter a name that makes sense for you.
For instance, you can set the name of your product as My First iOS App. In the

2 | Chapter 1: Implementing Controllers and Views

 Organization Name section, enter your company’s name, or if you don’t have a
company, enter anything else that makes sense to you. The organization name is
quite an important piece of information that you can enter here, but for now, you
don’t have to worry about it too much. For the Company Identifier field, enter
com.mycompany. If you really do own a company or you are creating this app for a
company that you work with, replace mycompany with the actual name of the com‐
pany in question. If you are just experimenting with development on your own,
invent a name. For the Devices section, choose Universal.
5. Once you are done setting the aforementioned values, simply press the Next button.
6. You are now being asked by Xcode to save your project to a suitable place. Choose
a suitable folder for your project and press the Create button.
7. As soon as your project is created, you are ready to build and run it. However, before
you begin, make sure that you’ve unplugged all your iOS devices from your com‐
puter. The reason behind this is that once an iOS device is plugged in, by default,
Xcode will attempt to build and run your project on the device, causing some issues
with provisioning profiles (which we haven’t talked about yet). So unplug your iOS
devices and then press the big Run button on the top-lefthand corner of Xcode. If
you cannot find the Run button, go to the Product menu and select the Run menu
item.

Voilà! Your first iOS app is running in iOS Simulator now. Even though the app is not
exactly impressive, simply displaying a white screen in the simulator, this is just the first
step toward our bigger goal of mastering the iOS SDK, so hold on tight as we embark
on this journey together.

Defining and Understanding Variables

All modern programming languages, including Objective-C, have the concept of vari‐
ables. Variables are simple aliases to locations in the memory. Every variable can have
the following properties:

1. A data type, which is either a primitive, such as an integer, or an object

2. A name
3. A value

You don’t always have to set a value for a variable, but you need to specify its type and
its name. Here are a few data types that you will need to know about when writing any
typical iOS app:

1.0. Introduction | 3
 Mutable Versus Immutable
If a data type is mutable, you can change if after it is initialized. For
instance, you can change one of the values in a mutable array, or add
or remove values. In contrast, you must provide the values to an im‐
mutable data type when you initialize it, and cannot add to them,
remove them, or change them later. Immutable types are useful be‐
cause they are more efficient, and because they can prevent errors when
the values are meant to stay the same throughout the life of the data.

NSInteger and NSUInteger

Variables of this type can hold integral values such as 10, 20, etc. The NSInteger
type allows negative values as well as positive ones, but the NSUInteger data type
is the Unsigned type, hence the U in its name. Remember, the phrase unsigned in
programming languages in the context of numbers always means that the number
must not be negative. Only a signed data type can hold negative numbers.
CGFloat
Holds floating point variables with decimal points, such as 1.31 or 2.40.
NSString
Allows you to store strings of characters. We will see examples of this later.
NSNumber
Allows you to store numbers as objects.
id
Variables of type id can point to any object of any type. These are called untyped
objects. Whenever you want to pass an object from one place to another but do not
wish to specify its type for whatever reason, you can take advantage of this data
type.
NSDictionary and NSMutableDictionary
These are immutable and mutable variants of hash tables. A hash table allows you
to store a key and to associate a value to that key, such as a key named phone_num
that has the value 05552487700. Read the values by referring to the keys associated
with them.
NSArray and NSMutableArray
Immutable and mutable arrays of objects. An array is an ordered collection of items.
For instance, you may have 10 string objects that you want to store in memory. An
array could be a good place for that.
NSSet, NSMutableSet, NSOrderedSet, NSMutableOrderedSet
Sets are like arrays in that they can hold series of objects, but they differ from arrays
in that they contain only unique objects. Arrays can hold the same object multiple

4 | Chapter 1: Implementing Controllers and Views

 times, but a set can contain only one instance of an object. I encourage you to learn
the difference between arrays and sets and use them properly.
NSData and NSMutableData
Immutable and mutable containers for any data. These data types are perfect when
you want to read the contents of a file, for instance, into memory.
Some of the data types that we talked about are primitive, and some are classes. You’ll
just have to memorize which is which. For instance, NSInteger is a primitive data type,
but NSString is a class, so objects can be instantiated of it. Objective-C, like C and C++,
has the concept of pointers. A pointer is a data type that stores the memory address
where the real data is stored. You should know by now that pointers to classes are
denoted using an asterisk sign:
NSString *myString = @"Objective-C is great!";

Thus, when you want to assign a string to a variable of type NSString in Objective-C,
you simply have to store the data into a pointer of type NSString *. However, if you are
about to store a floating point value into a variable, you wouldn’t specify it as a pointer
since the data type for that variable is not a class:
/* Set the myFloat variable to PI */
CGFloat myFloat = M_PI;

If you wanted to have a pointer to that floating point variable, you could do so as follows:
/* Set the myFloat variable to PI */
CGFloat myFloat = M_PI;

/* Create a pointer variable that points to the myFloat variable */

CGFloat *pointerFloat = &myFloat;

Getting data from the original float is a simple dereference (myFloat), whereas getting
the value of through the pointer requires the use of the asterisk (*pointerFloat). The
pointer can be useful in some situations, such as when you call a function that sets the
value of a floating-point argument and you want to retrieve the new value after the
function returns.
Going back to classes, we probably have to talk a bit more about classes before things
get lost in translation, so let’s do that next.

Creating and Taking Advantage of Classes

A class is a data structure that can have methods, instance variables, and properties,
along with many other features, but for now we are just going to talk about the basics.
Every class has to follow these rules:

1.0. Introduction | 5
 • The class has to be derived from a superclass, apart from a few exceptions such as
NSObject and NSProxy classes, which are root classes. Root classes do not have a
superclass.
• It has to have a name that conforms to Cocoa’s naming convention for methods.
• It has to have an interface file that defines the interface of the class.
• It has to have an implementation where you implement the features that you have
promised to deliver in the interface of the class.

NSObject is the root class from which almost every other class is inherited. For this
example, we are going to add a class, named Person, to the project we created in “Cre‐
ating and Running Our First iOS App” on page 2. We are going to then add two prop‐
erties to this class, named firstName and lastName, of type NSString. Follow these
steps to create and add the Person class to your project:

1. In Xcode, while your project is open and in front of you, from the File menu, choose
New → File...
2. On the lefthand side, ensure that under the iOS main section you have chosen the
Cocoa Touch category. Once done, select the Objective-C Class item and press the
Next button.
3. In the Class section, enter Person.
4. In the “Subclass of ” section, enter NSObject.
5. Once done, press the Next button, at which point Xcode will ask where you would
like to save this file. Simply save the new class into the folder where you have placed
your project and its files. This is the default selection. Then press the Create button,
and you are done.

You now have two files added to your project: Person.h and Person.m. The former is the
interface and the latter is the implementation file for your Person class. In Objective-
C, .h files are headers, where you define the interface of each class, and .m files are
implementation files where you write the actual implementation of the class.
Now let’s go into the header file of our Person class and define two properties for the
class, of type NSString:
@interface Person : NSObject

@property (nonatomic, copy) NSString *firstName;

@property (nonatomic, copy) NSString *lastName;

@end

Just like a variable, definition of properties has its own format, in this particular order:

6 | Chapter 1: Implementing Controllers and Views

 1. The definition of the property has to start with the @property keyword.
2. You then need to specify the qualifiers of the property. nonatomic properties are
not thread-safe. We will talk about thread safety in Chapter 16. You can also specify
assign, copy, weak, strong, or unsafe_unretained as the property qualifiers. We
will read more about these soon too.
3. You then have to specify the data type of the property, such as NSInteger or
NSString.
4. Last but not least, you have to specify a name for the property. The name of the
property has to follow the Apple guidelines.

We said that properties can have various qualifiers. Here are the important qualifiers
that you need to know about:
strong
Properties of this type will be retained by the runtime. These can only be instances
of classes. In other words, you cannot retain a value into a property of type strong
if the value is a primitive. You can retain objects, but not primitives.
copy
The same as strong, but when you assign to properties of this type, the runtime
will make a copy of the object on the right side of the assignment. The object on
the righthand side of the assignment must conform to the NSCopying or NSMutable
Copying protocol.
assign
Objects or primitive values that are set as the value of a property of type assign will
not be copied or retained by that property. For primitive properties, this qualifier
will create a memory address where you can put the primitive data. For objects,
properties of this type will simply point to the object on the righthand side of the
equation.
unsafe_unretained
The same as the assign qualifier.
weak
The same as the assign qualifier with one big difference. In the case of objects,
when the object that is assigned to a property of this type is released from memory,
the runtime will automatically set the value of this property to nil.
We now have a Person class with two properties: firstName and lastName. Let’s go back
to our app delegate’s implementation (AppDelegate.m) file and instantiate an object of
type Person:
#import "AppDelegate.h"
#import "Person.h"

1.0. Introduction | 7
 @implementation AppDelegate

- (BOOL) application:(UIApplication *)application

didFinishLaunchingWithOptions:(NSDictionary *)launchOptions{

Person *person = [[Person alloc] init];

person.firstName = @"Steve";
person.lastName = @"Jobs";

self.window = [[UIWindow alloc]

initWithFrame:[[UIScreen mainScreen] bounds]];
self.window.backgroundColor = [UIColor whiteColor];
[self.window makeKeyAndVisible];
return YES;
}

We are allocating and initializing our instance of the Person class in this example. You
may not know what that means yet, but continue to the “Adding Functionality to Classes
with Methods” on page 8 section and you will find out.

Adding Functionality to Classes with Methods

Methods are building blocks of classes. For instance, a class named Person can have
logical functionalities such as walk, breathe, eat, and drink. These functionalities are
usually encapsulated in methods.
A method can take parameters, which are variables that the caller passes when calling
the method and are visible only to the method. For instance, in a simple world, we would
have a walk method for our Person class. However, if you want, you can add a parameter
or argument to the method and name it walkingSpeed of type CGFloat, so that when
another programmer calls that method on your class, she can specify the speed at which
the person has to walk. You, as the programmer of that class, would then write the
appropriate code for your class to handle different speeds of walking. Don’t worry if this
all sounds like too much, but have a look at the following example, where I have added
a method to the implementation file we created in “Creating and Taking Advantage of
Classes” on page 5 for our Person class:
#import "Person.h"

@implementation Person

- (void) walkAtKilometersPerHour:(CGFloat)paramSpeedKilometersPerHour{
/* Write the code for this method here */
}

- (void) runAt10KilometersPerHour{
/* Call the walk method in our own class and pass the value of 10 */

8 | Chapter 1: Implementing Controllers and Views

 [self walkAtKilometersPerHour:10.0f];
}

@end

A typical method has the following qualities in Objective-C:

1. A prefix to tell the compiler whether the method is an instance method (-) or a class
method (+). An instance method can be accessed only after the programmer allo‐
cates and initializes an instance of your class. A class method can be accessed by
calling it directly from the class itself. Don’t worry if this all sounds complicated.
We will see examples of these methods in this book, so don’t get hung up on this
for now.
2. A data type for the method, if the method returns any value. In our example, we
have specified void, telling the compiler that we are not returning anything.
3. The first part of the method name followed by the first parameter. You don’t nec‐
essarily have to have any parameters for a method. You can have methods that take
no parameters.
4. The list of subsequent parameters following the first parameter.

Let me show you an example of a method with two parameters:

- (void) singSong:(NSData *)paramSongData loudly:(BOOL)paramLoudly{
/* The parameters that we can access here in this method are:

paramSongData (to access the song's data)

paramLoudly will tell us if we have to sing the song loudly or not
*/
}

It’s important to bear in mind that every parameter in every method has an external and
an internal name. The external name is part of the method, whereas the internal part is
the actual name or alias of the parameter that can be used inside the method’s imple‐
mentation. In the previous example, the external name of the first parameter is sing‐
Song, whereas its internal name is paramSongData. The external name of the second
parameter is loudly, but its internal name is paramLoudly. The method’s name and the
external names of its parameters combine to form what is known as the selector for the
method. The selector for the aforementioned method in this case would be sing
Song:loudly:. A selector, as you will later see in this book, is the runtime identifier of
every method. No two methods inside a single class can have the same selector.
In our example, we have defined three methods for our Person class, inside its imple‐
mentation file (Person.m):

• walkAtKilometersPerHour:
• runAt10KilometersPerHour

1.0. Introduction | 9
 • singSong:loudly:

If we want to be able to use any of these methods from the outside world—for instance,
from the app delegate—we should expose those methods in our interface file (Person.h):
#import <Foundation/Foundation.h>

@interface Person : NSObject

@property (nonatomic, copy) NSString *firstName;

@property (nonatomic, copy) NSString *lastName;

- (void) walkAtKilometersPerHour:(CGFloat)paramSpeedKilometersPerHour;
- (void) runAt10KilometersPerHour;

/* Do not expose the singSong:loudly: method to the outside world.

That method is internal to our class. So why should we expose it? */

@end

Given this interface file, a programmer can call the walkAtKilometersPerHour: and
the runAt10KilometersPerHour methods from outside the Person class, but not the
singSong:loudly: method because it has not been exposed in the file. So let’s go ahead
and try to call all three of these methods from our app delegate to see what happens!
- (BOOL) application:(UIApplication *)application
didFinishLaunchingWithOptions:(NSDictionary *)launchOptions{

Person *person = [[Person alloc] init];

[person walkAtKilometersPerHour:3.0f];
[person runAt10KilometersPerHour];

/* If you uncomment this line of code, the compiler will give

you an error telling you this method doesn't exist on the Person class */
//[person singSong:nil loudly:YES];

self.window = [[UIWindow alloc]

initWithFrame:[[UIScreen mainScreen] bounds]];
self.window.backgroundColor = [UIColor whiteColor];
[self.window makeKeyAndVisible];
return YES;
}

Now we know how to define and call instance methods, but what about class methods?
Let’s first find out what class methods are and how they differ from instance methods.
An instance method is a method that relates to an instance of a class. For instance, in
our Person class, you can instantiate this class twice to create two distinct persons in a
hypothetical game that you are working on and have one of those persons walk at the
speed of 3 kilometers an hour while the other person walks at 2 kilometers an hour.

10 | Chapter 1: Implementing Controllers and Views

Even though you have written the code for the walking instance method only once,
when two separate instances of the Person class are created at runtime, the calls to the
instance methods will be routed to the appropriate instance of this class.
In contrast, class methods work on the class itself. For instance, in a game where you
have instances of a class named Light that light the scenery of your game, you may have
a dimAllLights class method on this class that a programmer can call to dim all lights
in the game, no matter where they are placed. Let’s have a look at an example of a class
method on our Person class:
#import "Person.h"

@implementation Person

+ (CGFloat) maximumHeightInCentimeters{
return 250.0f;
}

+ (CGFloat) minimumHeightInCentimeters{
return 40.0f;
}

@end

The maximumHeightInCentimeters method is a class method that returns the hypo‐

thetical maximum height of any person in centimeters. The minimumHeightInCentim
eters class method returns the minimum height of any person. Here is how we would
then expose these methods in the interface of our class:
#import <Foundation/Foundation.h>

@interface Person : NSObject

@property (nonatomic, copy) NSString *firstName;

@property (nonatomic, copy) NSString *lastName;
@property (nonatomic, assign) CGFloat currentHeight;

+ (CGFloat) maximumHeightInCentimeters;
+ (CGFloat) minimumHeightInCentimeters;

@end

We have also added a new floating point property to our Person class
named currentHeight. This allows instances of this class to be able to
store their height in memory for later reference, just like their first or
last names.

And in our app delegate, we would proceed to use these new methods like so:

1.0. Introduction | 11
 - (BOOL) application:(UIApplication *)application
didFinishLaunchingWithOptions:(NSDictionary *)launchOptions{

Person *steveJobs = [[Person alloc] init];

steveJobs.firstName = @"Steve";
steveJobs.lastName = @"Jobs";
steveJobs.currentHeight = 175.0f; /* Centimeters */

if (steveJobs.currentHeight >= [Person minimumHeightInCentimeters] &&

steveJobs.currentHeight <= [Person maximumHeightInCentimeters]){
/* The height of this particular person is in the acceptable range */
} else {
/* This person's height is not in the acceptable range */
}

self.window = [[UIWindow alloc]

initWithFrame:[[UIScreen mainScreen] bounds]];
self.window.backgroundColor = [UIColor whiteColor];
[self.window makeKeyAndVisible];
return YES;
}

Conforming to Requirements of Other Classes with Protocols

Objective-C has the concept of a protocol. This is a concept found in many other lan‐
guages (always under a different term, it seems); for instance, it is called an interface in
Java. A protocol, as its name implies, is a set of rules that classes can abide by in order
to be used in certain ways. A class that follows the rules is said to conform to the protocol.
Protocols are different from actual classes in that they do not have an implementation.
They are just rules. For instance, every car has wheels, doors, and a main body color,
among many other things. Let’s define these properties in a protocol named Car. Simply
follow these steps to create a header file that can contain our Car protocol:

1. In Xcode, while your project is open, from the File menu, select New → File...
2. In the new dialog, on the lefthand side, make sure that you’ve selected Cocoa Touch
under the iOS main category. Once done, on the righthand side of the dialog, choose
“Objective-C protocol” and then press the Next button.
3. On the next screen, under the Protocol section, enter Car as the protocol’s name
and then press the Next button.
4. You will now be asked to save your protocol on disk. Simply choose a location,
usually in your project’s folder, and press the Create button.

Xcode will now create a file for you named Car.h with content like this:
#import <Foundation/Foundation.h>

@protocol Car <NSObject>

12 | Chapter 1: Implementing Controllers and Views

 @end

So let’s go ahead and define the properties for the Car protocol, as we discussed earlier
in this section:
#import <Foundation/Foundation.h>

@protocol Car <NSObject>

@property (nonatomic, copy) NSArray *wheels;

@property (nonatomic, strong) UIColor *bodyColor;
@property (nonatomic, copy) NSArray *doors;

@end

Now that our protocol has been defined, let’s create a class for a car, such as Jaguar, and
then make that class conform to our protocol. Simply follow the steps provided in
“Creating and Taking Advantage of Classes” on page 5 to create a class named Jaguar
and then make it conform to the Car protocol like so:
#import <Foundation/Foundation.h>
#import "Car.h"

@interface Jaguar : NSObject <Car>

@end

If you build your project now, you will notice that the compiler will give you a few
warnings such as this:
Auto property synthesis will not synthesize property declared in a protocol

This is simply telling you that your Jaguar class is attempting to conform to the Car
protocol but is not really implementing the required properties and/or methods in that
protocol. So you should now know that a protocol can have required or optional items,
and that you denote them by the @optional or the @required keywords. The default
qualifier is @required, and since in our Car protocol we didn’t specify the qualifier
explicitly, the compiler has chosen @required for us implicitly. Therefore, the Jaguar
class now has to implement everything that is required from it by the Car protocol, like
so:
#import <Foundation/Foundation.h>
#import "Car.h"

@interface Jaguar : NSObject <Car>

@property (nonatomic, copy) NSArray *wheels;

@property (nonatomic, strong) UIColor *bodyColor;
@property (nonatomic, copy) NSArray *doors;

@end

1.0. Introduction | 13
Perfect. Now you have an understanding of the basics of protocols and how they work
and how you can define them. We will read more about them later in this book, so what
you know right now about protocols is quite sufficient.

Storing Items in and Retrieving Them from Collections

Collections are instances of objects and can hold other objects. One of the primary
collections is an array, which instantiates either NSArray or NSMutableArray. You can
store any object in an array, and an array can contain more than one instance of the
same object. Here is an example where we create an array of three strings:
NSArray *stringsArray = @[
@"String 1",
@"String 2",
@"String 3"
];

__unused NSString *firstString = stringsArray[0];

__unused NSString *secondString = stringsArray[1];
__unused NSString *thirdString = stringsArray[2];

The __unused macro tells the compiler not to complain when a vari‐
able, such as the firstString variable in our example, is declared but
never used. The default behavior of the compiler is that it throws a
warning to the console saying a variable is not used. Our brief exam‐
ple has declared the variables but not used them, so adding the afore‐
mentioned macro to the beginning of the variable declaration keeps
the compiler and ourselves happy.

A mutable array is an array that can be mutated and changed after it has been created.
An immutable array, like we saw, cannot be tampered with after it is created. Here is an
example of an immutable array:
NSString *string1 = @"String 1";
NSString *string2 = @"String 2";
NSString *string3 = @"String 3";

NSArray *immutableArray = @[string1, string2, string3];

NSMutableArray *mutableArray = [[NSMutableArray alloc]

initWithArray:immutableArray];

[mutableArray exchangeObjectAtIndex:0 withObjectAtIndex:1];

[mutableArray removeObjectAtIndex:1];
[mutableArray setObject:string1 atIndexedSubscript:0];

14 | Chapter 1: Implementing Controllers and Views

 NSLog(@"Immutable array = %@", immutableArray);
NSLog(@"Mutable Array = %@", mutableArray);

The output of this program is as follows:

Immutable array = (
"String 1",
"String 2",
"String 3"
)
Mutable Array = (
"String 1",
"String 3"
)

Another very common collection found throughout iOS programs is a dictionary. Dic‐
tionaries are like arrays, but every object in a dictionary is assigned to a key so that later
you can retrieve the same object using the key. Here is an example:
NSDictionary *personInformation =
@{
@"firstName" : @"Mark",
@"lastName" : @"Tremonti",
@"age" : @30,
@"sex" : @"Male"
};

NSString *firstName = personInformation[@"firstName"];

NSString *lastName = personInformation[@"lastName"];
NSNumber *age = personInformation[@"age"];
NSString *sex = personInformation[@"sex"];

NSLog(@"Full name = %@ %@", firstName, lastName);

NSLog(@"Age = %@, Sex = %@", age, sex);

The output of this program is:

Full name = Mark Tremonti
Age = 30, Sex = Male

You can also have mutable dictionaries, just as you can have mutable arrays. Mutable
dictionaries’ contents can be changed after they are instantiated. Here is an example:
NSDictionary *personInformation =
@{
@"firstName" : @"Mark",
@"lastName" : @"Tremonti",
@"age" : @30,
@"sex" : @"Male"
};

NSMutableDictionary *mutablePersonInformation =
[[NSMutableDictionary alloc] initWithDictionary:personInformation];

1.0. Introduction | 15
 mutablePersonInformation[@"age"] = @32;

NSLog(@"Information = %@", mutablePersonInformation);

The output of this program is:

Information = {
age = 32;
firstName = Mark;
lastName = Tremonti;
sex = Male;
}

You can also take advantage of sets. Sets are like arrays but must contain a unique set of
objects. You cannot add the same instance of an object twice to the same set. Here is an
example:
NSSet *shoppingList = [[NSSet alloc] initWithObjects:
@"Milk",
@"Bananas",
@"Bread",
@"Milk", nil];

NSLog(@"Shopping list = %@", shoppingList);

If you run this program, the output will be:

Shopping list = {(
Milk,
Bananas,
Bread
)}

Note how Milk was mentioned twice in our program but added to the set only once.
That’s the magic behind sets. You can also use mutable sets like so:
NSSet *shoppingList = [[NSSet alloc] initWithObjects:
@"Milk",
@"Bananas",
@"Bread",
@"Milk", nil];

NSMutableSet *mutableList = [NSMutableSet setWithSet:shoppingList];

[mutableList addObject:@"Yogurt"];
[mutableList removeObject:@"Bread"];

NSLog(@"Original list = %@", shoppingList);

NSLog(@"Mutable list = %@", mutableList);

And the output is:

Original list = {(
Milk,
Bananas,

16 | Chapter 1: Implementing Controllers and Views

 Bread
)}
Mutable list = {(
Milk,
Bananas,
Yogurt
)}

There are two other important classes that you need to know about, now that we are
talking about sets and collections:
NSOrderedSet
An immutable set that keeps the order in which objects were added to it
NSMutableOrderedSet
The mutable version of the ordered set
By default, sets do not keep the order in which objects were added to them. Take the
following as an example:
NSSet *setOfNumbers = [NSSet setWithArray:@[@3, @4, @1, @5, @10]];
NSLog(@"Set of numbers = %@", setOfNumbers);

What gets printed to the screen after you run this program is:
Set of numbers = {(
5,
10,
3,
4,
1
)}

But that is not the order in which we created the set. If you want to keep the order intact,
simply use the NSOrderedSet class instead:
NSOrderedSet *setOfNumbers = [NSOrderedSet orderedSetWithArray
:@[@3, @4, @1, @5, @10]];

NSLog(@"Ordered set of numbers = %@", setOfNumbers);

And, of course, you can use the mutable version of an ordered set:
NSMutableOrderedSet *setOfNumbers =
[NSMutableOrderedSet orderedSetWithArray:@[@3, @4, @1, @5, @10]];

[setOfNumbers removeObject:@5];
[setOfNumbers addObject:@0];
[setOfNumbers exchangeObjectAtIndex:1 withObjectAtIndex:2];

NSLog(@"Set of numbers = %@", setOfNumbers);

The results are shown here:

1.0. Introduction | 17
 Set of numbers = {(
3,
1,
4,
10,
0
)}

Before we move off the topic of sets, there is one other handy class that you may need
to know about. The NSCountedSet class can hold a unique instance of an object multiple
times. However, the way this is done is different from the way arrays perform the same
task. In an array, the same object can appear multiple times. But in a counted set, the
object will appear only once, but the set keeps a count of how many times the object
was added to the set and will decrement that counter each time you remove an instance
of the object. Here is an example:
NSCountedSet *setOfNumbers = [NSCountedSet setWithObjects:
@10, @20, @10, @10, @30, nil];

[setOfNumbers addObject:@20];
[setOfNumbers removeObject:@10];

NSLog(@"Count for object @10 = %lu",

(unsigned long)[setOfNumbers countForObject:@10]);

NSLog(@"Count for object @20 = %lu",

(unsigned long)[setOfNumbers countForObject:@20]);

The output is:

Count for object @10 = 2
Count for object @20 = 2

The NSCountedSet class is mutable, despite what its name may lead
you to think.

Adding Object Subscripting Support to Your Classes

Traditionally, when accessing objects in collections such as arrays and dictionaries,
programmers had to access a method on the array or the dictionary to get or set that
object. For instance, this is the traditional way of creating a mutable dictionary, adding
two keys and values to it, and retrieving those values back:
NSString *const kFirstNameKey = @"firstName";
NSString *const kLastNameKey = @"lastName";

NSMutableDictionary *dictionary = [[NSMutableDictionary alloc] init];

18 | Chapter 1: Implementing Controllers and Views

 [dictionary setValue:@"Tim" forKey:kFirstNameKey];
[dictionary setValue:@"Cook" forKey:kLastNameKey];

__unused NSString *firstName = [dictionary valueForKey:kFirstNameKey];

__unused NSString *lastName = [dictionary valueForKey:kLastNameKey];

But with all the advances in the LLVM compiler, this code can now be shortened to this:
NSString *const kFirstNameKey = @"firstName";
NSString *const kLastNameKey = @"lastName";

NSDictionary *dictionary = @{
kFirstNameKey : @"Tim",
kLastNameKey : @"Cook",
};

__unused NSString *firstName = dictionary[kFirstNameKey];

__unused NSString *lastName = dictionary[kLastNameKey];

You can see that we are initializing the dictionary by providing the keys in curly brackets.
The same thing for arrays. Here is how we used to create and use arrays traditionally:
NSArray *array = [[NSArray alloc] initWithObjects:@"Tim", @"Cook", nil];
__unused NSString *firstItem = [array objectAtIndex:0];
__unused NSString *secondObject = [array objectAtIndex:1];

And now with object subscripting, we can shorten this code, as follows:
NSArray *array = @[@"Tim", @"Cook"];
__unused NSString *firstItem = array[0];
__unused NSString *secondObject = array[0];

LLVM didn’t even stop there. You can add subscripting to your own classes as well.
There are two types of subscripting:
Subscripting by key
With this, you can set the value for a specific key inside an object, just like you would
in a dictionary. You can also access/read-from values inside the object by providing
the key.
Subscripting by index
As with arrays, you can set/get values inside the object by providing an index to
that object. This makes sense for array-like classes where the elements lie in a natural
order that can be represented by an index.
For the first example, we are going to look at subscripting by key. To do this, we are
going to create a class named Person with a firstName and a lastName. Then we are
going to allow the programmer to change the first and last names by simply providing
the keys to those properties.
The reason you may want to add subscripting by key to a class like this is if your property
names are volatile and you want to allow the programmer to set the value of those

1.0. Introduction | 19
properties without having to worry about whether the names of those properties will
change later; otherwise, the programmer is better off using the properties directly. The
other reason for implementing subscripting by key is if you want to hide the exact
implementation/declaration of your properties from the programmer and not let her
access them directly.
In order to support subscripting by key on your own classes, you must implement the
following two methods on your class and put the method signatures in your class’s
header file; otherwise, the compiler won’t know that your class supports subscripting
by key.
#import <Foundation/Foundation.h>

/* We will use these as the keys to our firstName and lastName

properties so that if our firstName and lastName properties' names
change in the future in the implementation, we won't break anything
and our class will still work, as we can simply change the value of
these constants inside our implementation file */
extern NSString *const kFirstNameKey;
extern NSString *const kLastNameKey;

@interface Person : NSObject

@property (nonatomic, copy) NSString *firstName;

@property (nonatomic, copy) NSString *lastName;

- (id) objectForKeyedSubscript:(id<NSCopying>)paramKey;
- (void) setObject:(id)paramObject forKeyedSubscript:(id<NSCopying>)paramKey;

@end

The objectForKeyedSubscript: method will be called on your class whenever the

programmer provides a key and wants to read the value of that key in your class. The
parameter that will be given to you will obviously be the key from which the programmer
wants to read the value. To complement this method, the setObject:forKeyedSub
script: method will be called on your class whenever the programmer wants to set the
value for a specified key. So in our implementation, we want to check whether the given
keys are the first name and the last name keys, and if yes, we will set/get the values of
the first name and last name in our class:
#import "Person.h"

NSString *const kFirstNameKey = @"firstName";

NSString *const kLastNameKey = @"lastName";

@implementation Person

- (id) objectForKeyedSubscript:(id<NSCopying>)paramKey{

NSObject<NSCopying> *keyAsObject = (NSObject<NSCopying> *)paramKey;

20 | Chapter 1: Implementing Controllers and Views

 if ([keyAsObject isKindOfClass:[NSString class]]){
NSString *keyAsString = (NSString *)keyAsObject;
if ([keyAsString isEqualToString:kFirstNameKey] ||
[keyAsString isEqualToString:kLastNameKey]){
return [self valueForKey:keyAsString];
}
}

return nil;
}

- (void) setObject:(id)paramObject forKeyedSubscript:(id<NSCopying>)paramKey{

NSObject<NSCopying> *keyAsObject = (NSObject<NSCopying> *)paramKey;
if ([keyAsObject isKindOfClass:[NSString class]]){
NSString *keyAsString = (NSString *)keyAsObject;
if ([keyAsString isEqualToString:kFirstNameKey] ||
[keyAsString isEqualToString:kLastNameKey]){
[self setValue:paramObject forKey:keyAsString];
}
}
}

@end

So in this code, in the objectForKeyedSubscript: method, we are given a key, and we

are expected to return the object that is associated in our instance with that key. The
key that is given to us is an object that conforms to the NSCopying protocol. In other
words, it’s an object that we can make a copy of, if we want to. We expect the key to be
a string so that we can compare it with the predefined keys that we have declared on
top of our class, and if it matches, we will set the value of that property in our class. We
will then use the NSObject method named valueForKey: to return the value associated
with the given key. But obviously, before we do so, we ensure that the given key is one
of the keys that we expect. In the setObject:forKeyedSubscript: method we do the
exact opposite. We set the values for a given key instead of returning them.
Now, elsewhere in your app, you can instantiate an object of type Person and use the
predefined keys of kFirstNameKey and kLastNameKey to change the value of the first
Name and lastName properties like so:
Person *person = [Person new];
person[kFirstNameKey] = @"Tim";
person[kLastNameKey] = @"Cook";
__unused NSString *firstName = person[kFirstNameKey];
__unused NSString *lastName = person[kLastNameKey];

This code will achieve exactly the same effect as the more direct approach of setting the
properties of a class:
Person *person = [Person new];
person.firstName = @"Tim";
person.lastName = @"Cook";

1.0. Introduction | 21
 __unused NSString *firstName = person.firstName;
__unused NSString *lastName = person.lastName;

You can also support subscripting by index, the same way arrays do. This is useful, as
mentioned before, to allow programmers to access objects that have a natural order
inside a class. But there are not many data structures besides arrays where it makes sense
to order and number elements, unlike subscripting by key, which applies to a wide range
of data structures. So the example I’ll use to illustrate subscripting by index is a bit
contrived. In our previous example, we had the Person class with a first and last name.
Now if you want to allow programmers to be able to read the first name by providing
the index of 0 and the last name by providing the index of 1, all you have to do is declare
the objectAtIndexedSubscript: and the setObject:atIndexedSubscript: methods
in the header file of your class, and then write the implementation. Here is how we
declare these methods in our Person class’s header file:
- (id) objectAtIndexedSubscript:(NSUInteger)paramIndex;
- (void) setObject:(id)paramObject atIndexedSubscript:(NSUInteger)paramIndex;

The implementation is also quite simple. We take the index and act upon it in a way that
makes sense to our class. We decided that the first name has to have the index of 0 and
the last name the index of 1. So if we get the index of 0 for setting a value, we set the
value of the first name to the incoming object, and so on:
- (id) objectAtIndexedSubscript:(NSUInteger)paramIndex{

switch (paramIndex){
case 0:{
return self.firstName;
break;
}
case 1:{
return self.lastName;
break;
}
default:{
[NSException raise:@"Invalid index" format:nil];
}
}

return nil;
}

- (void) setObject:(id)paramObject atIndexedSubscript:(NSUInteger)paramIndex{

switch (paramIndex){
case 0:{
self.firstName = paramObject;
break;
}
case 1:{
self.lastName = paramObject;

22 | Chapter 1: Implementing Controllers and Views

 break;
}
default:{
[NSException raise:@"Invalid index" format:nil];
}
}
}

Now we can test out what we’ve written so far, like so:
Person *person = [Person new];
person[kFirstNameKey] = @"Tim";
person[kLastNameKey] = @"Cook";
NSString *firstNameByKey = person[kFirstNameKey];
NSString *lastNameByKey = person[kLastNameKey];

NSString *firstNameByIndex = person[0];

NSString *lastNameByIndex = person[1];

if ([firstNameByKey isEqualToString:firstNameByIndex] &&

[lastNameByKey isEqualToString:lastNameByIndex]){
NSLog(@"Success");
} else {
NSLog(@"Something is not right");
}

If you’ve followed all the steps in this recipe, you should see the value Success printed
to the console now.

1.1. Displaying Alerts with UIAlertView

Problem
You want to display a message to your users in the form of an alert. This could be used
to ask them to confirm an action, to ask for their username and password, or simply to
let them enter some simple text that you can use in your app.

Solution
Utilize the UIAlertView class.

Discussion
If you are an iOS user, you have most certainly already seen an alert view. Figure 1-1
depicts an example.

1.1. Displaying Alerts with UIAlertView | 23

Figure 1-1. Example of an alert view in iOS

The best way to initialize an alert view is to use its designated initializer:
- (void) viewDidAppear:(BOOL)paramAnimated{

[super viewDidAppear:paramAnimated];

UIAlertView *alertView = [[UIAlertView alloc]

initWithTitle:@"Alert"
message:@"You've been delivered an alert"
delegate:nil
cancelButtonTitle:@"Cancel"
otherButtonTitles:@"Ok", nil];
[alertView show];

24 | Chapter 1: Implementing Controllers and Views

When this alert view is displayed to the user, she will see something similar to that shown
in Figure 1-2.

Figure 1-2. A simple alert view displayed to the user

In order to display an alert view to the user, we use the alert view’s show method. Let’s
have a look at the description for each of the parameters that we passed to the initializer
of the alert view:
title
The string that the alert view will display on the top when it is shown to the user.
This string is Title in Figure 1-2.
message
The actual message that gets displayed to the user. In Figure 1-2, this message is set
to Message.

1.1. Displaying Alerts with UIAlertView | 25

delegate
The optional delegate object that we pass to the alert view. This object will get
notified whenever the alert’s state changes; for instance, when the user taps on a
button on the alert view. The object passed to this parameter must conform to the
UIAlertViewDelegate protocol.
cancelButtonTitle
A string that will get assigned to the cancel button on an alert view. An alert view
that has a cancel button usually asks the user for an action. If the user isn’t com‐
fortable with performing that action, he will press the cancel button. This button’s
title does not necessarily have to say Cancel. It is up to you to specify a title for this
button. This parameter is optional; you could put up a dialog box with no cancel
button.
otherButtonTitles
Titles of any other buttons that you want to have appear on the alert view. Separate
the titles with commas and make sure you terminate the list of titles with a nil,
which is called a sentinel. This parameter is optional.

It is possible to create an alert view without any buttons. But the view
cannot be dismissed by the user. If you create such a view, you, as the
programmer, need to make sure this alert view will get dismissed au‐
tomatically; for instance, three seconds after it is displayed. An alert
view without any buttons that does not dismiss itself automatically
gives a really poor user experience. Not only will your app get low
ratings on the App Store for blocking the UI from user access, but
chances are that your app will get rejected by Apple.

Alert views can take various styles. The UIAlertView class has a property called alert
ViewStyle of type UIAlertViewStyle:
typedef NS_ENUM(NSInteger, UIAlertViewStyle) {
UIAlertViewStyleDefault = 0,
UIAlertViewStyleSecureTextInput,
UIAlertViewStylePlainTextInput,
UIAlertViewStyleLoginAndPasswordInput
};

Here is what each of these styles will do:

UIAlertViewStyleDefault
This is the default style of an alert view, as we saw in Figure 1-2.
UIAlertViewStyleSecureTextInput
With this style, the alert view will contain a secure text field, which hides the actual
characters typed by the user. For instance, if you are asking the user for her online
banking credentials, you might choose this style of alert view.

26 | Chapter 1: Implementing Controllers and Views

UIAlertViewStylePlainTextInput
Under this style, the alert view will display a nonsecure text field to the user. This
style is great if you simply want to ask the user for a plain-text entry, such as her
phone number.
UIAlertViewStyleLoginAndPasswordInput
With this style, the alert view will display two text fields: a nonsecure one for a
username and a secure one for a password.
If you need to get notified when the user interacts with the alert view, specify a delegate
object to your alert view. This delegate must conform to the UIAlertViewDelegate
protocol. The most important method defined in this protocol is the alertView:click
edButtonAtIndex: method, which is called as soon as the user taps on one of the buttons
in the alert view. The button index is passed to you through the clickedButtonAtIn
dex parameter.
As an example, let’s display an alert view to the user and ask whether she would like to
visit a website in Safari after having pressed a link to that website available in our UI.
We will display two buttons on our alert view: Yes and No. In our alert view delegate,
we will detect which button she tapped on and will take action accordingly.
Let’s first implement two very simple methods that return the title of our two buttons:
- (NSString *) yesButtonTitle{
return @"Yes";
}

- (NSString *) noButtonTitle{
return @"No";
}

Now we need to make sure that we are conforming to the UIAlertViewDelegate pro‐
tocol in our view controller:
#import "ViewController.h"

@interface ViewController () <UIAlertViewDelegate>

@end

@implementation ViewController

...

The next step is to create and display our alert view to the user:
- (void)viewDidAppear:(BOOL)animated{
[super viewDidAppear:animated];

self.view.backgroundColor = [UIColor whiteColor];

1.1. Displaying Alerts with UIAlertView | 27

 NSString *message = @"Are you sure you want to open this link in Safari?";
UIAlertView *alertView = [[UIAlertView alloc]
initWithTitle:@"Open Link"
message:message
delegate:self
cancelButtonTitle:[self noButtonTitle]
otherButtonTitles:[self yesButtonTitle], nil];
[alertView show];

So now, our alert view will look similar to that shown in Figure 1-3.

Figure 1-3. An alert view with Yes and No buttons

Now we need a way to know whether the user selected the Yes or the No option in our
alert view. For this, we will need to implement the alertView:clickedButtonAtIn
dex: method of our alert view delegate:
- (void) alertView:(UIAlertView *)alertView
clickedButtonAtIndex:(NSInteger)buttonIndex{

28 | Chapter 1: Implementing Controllers and Views

Another random document with
no related content on Scribd:
The Project Gutenberg eBook of Le fameux
chevalier Gaspard de Besse
This ebook is for the use of anyone anywhere in the United
States and most other parts of the world at no cost and with
almost no restrictions whatsoever. You may copy it, give it away
or re-use it under the terms of the Project Gutenberg License
included with this ebook or online at www.gutenberg.org. If you
are not located in the United States, you will have to check the
laws of the country where you are located before using this
eBook.

Title: Le fameux chevalier Gaspard de Besse

ses dernières aventures

Author: Jean Aicard

Release date: March 7, 2024 [eBook #73118]

Language: French

Original publication: Paris: Ernest Flammarion, 1919

Credits: Véronique Le Bris, Laurent Vogel and the Online

Distributed Proofreading Team at
https://www.pgdp.net (This file was produced from
images generously made available by the Bibliothèque
nationale de France (BnF/Gallica))

*** START OF THE PROJECT GUTENBERG EBOOK LE FAMEUX

CHEVALIER GASPARD DE BESSE ***
 JEAN AICARD
de l’Académie française

LE FAMEUX CHEVALIER
GASPARD DE BESSE

SES DERNIÈRES AVENTURES

En France, la gaîté est une vertu.

PARIS
ERNEST FLAMMARION, ÉDITEUR
26, RUE RACINE, 26

Droits de traduction, d’adaptation et de reproduction réservés pour tous les pays

Il a été tiré de cet ouvrage vingt exemplaires sur papier de Hollande
tous numérotés.

ŒUVRES DE JEAN AICARD

Collection à 5 francs.

Alfred de Vigny 1 vol.

Hollande, Algérie 1 vol.
Théâtre, I. Molière à Shakespeare ; William Davenant ;
Othello, le More de Venise 1 vol.
Théâtre, II. Au clair de la Lune ; Pygmalion ; Le Pierrot de
Cristal ; L’Amour gelé ; Smitis 1 vol.
Le Dieu dans l’Homme 1 vol.
Le Livre d’heures de l’Amour 1 vol.
Poèmes de Provence. Les Cigales. Nouvelle édition.
(Ouvrage cour.) 1 vol.
Le Manteau du roi. Pièce en 4 actes en vers 1 vol.
Maurin des Maures (17e mille) 1 vol.
L’illustre Maurin (12e mille) 1 vol.
Benjamine 1 vol.
La légende du Cœur. Drame en 5 actes. Illustré 1 vol.
Le père Lebonnard. Comédie en 4 actes, en vers.
Illustré 1 vol.
Tata 1 vol.
Don Juan 1 vol.
La Chanson de l’enfant (Cour.) 1 vol.
Mélita (Roman bohème) 1 vol.
Miette et Noré (Ouvr. cour.) 1 vol.
Roi de Camargue. Roman 1 vol.
L’âme d’un enfant. Nouvelle édition. Préface de Frédéric
Passy 1 vol.
Le pavé d’amour. Roman 1 vol.
L’été à l’ombre. — 1 vol.
Notre-Dame d’amour. — 1 vol.
Diamant noir. — 1 vol.
L’Ibis bleu. — 1 vol.
Fleur d’abîme. — 1 vol.
Jésus. Poèmes. Nouvelle édition en un joli volume in-32 1 vol.
Othello, le More de Venise, trad. en vers, 1 vol. in-8, sur
papier de Hollande, avec portrait (Prix 10 fr.) 1 vol.
Édition populaire illust. de Maurin des Maures en 9 vol.
(à 75 cent.) 9 vol.
Le Témoin (Prix 2 fr. 50) 1 vol.
Des cris dans la mêlée 1 vol.
Arlette des Mayons. Roman 1 vol.
Le Sang du Sacrifice. Poèmes dédiés aux nations alliées 1 vol.
Comment rénover la France 1 vol.
Gaspard de Besse (Un bandit à la française) 1 vol.
Droits de traduction et de reproduction réservés pour tous les pays.
Copyright 1919,
by Ernest Flammarion
 TABLE DES CHAPITRES

Chapitre I. — Le prisonnier Gaspard, qui a tout le loisir de

méditer sur sa vie passée et de songer à de nouveaux
projets, pressent que, dans la gorgerette d’une chaste
pucelle, il trouvera la clef des champs. 1
Chapitre II. — Sainte Roseline, patronne des prisonniers,
étend sur Gaspard sa protection miraculeuse par
l’intermédiaire d’un pauvre ermite. 21
Chapitre III. — Dom Pablo, avec des arguments frappants,
démontre à Castagne que l’esprit vient toujours à bout de
la force. 33
Chapitre IV. — Bons cœurs, lorsque j’étais prisonnnier, vous
m’êtes venus voir. 49
Chapitre V. — Où, après s’être étonné de la pratique singulière
inventée par un vigneron pour remédier à la maladie de
ses vignes, on verra une mère dévote apprécier sans
indulgence les joies du paradis, ce qui pousse l’incrédule
dom Pablo à révéler son inattendu dégoût des hypocrisies
humaines. 58
Chapitre VI. — Gaspard, hôte de Mme Lizerolles, met à profit
le temps qu’il doit passer au château pour compléter son
éducation politique 74
Chapitre VII. — Le chevalier Gaspard reçoit, à Lizerolles, un
présent digne du sultan Saladin. Réveillé d’un beau rêve
par les sourdes menaces de sa petite armée, il se voit
forcé de reprendre la vie active du partisan. 90
Chapitre VIII. — Pour être un gouvernement, il faut connaître
la science ou l’art de gouverner ; pour monter à cheval il
faut avoir appris ; les démocraties ignorantes courent à
leur perte ; toutes vérités que démontre un apologue en
action, imaginé par le malin Gaspard. 98
Chapitre IX. — Où l’on verra Mlle Clairon, de la Comédie-
Française, honorée comme une sainte et comment, à la
suite d’une conversation à la fois populaire et hautement
métaphysique, Gaspard annonça, sur la foi d’un livre qu’il
venait de lire, la fin des guerres, à jamais assurée par
l’entente des peuples, au nom du sens commun. 118
Chapitre X. — Pablo raconte un miracle qu’il a lui-même
accompli, et Bernard pense à Thérèse. 132
Chapitre XI. — L’oie de frère Anselme. 142
Chapitre XII. — La visite extraordinaire de Gaspard au château
de Fontblanche ; — et comment la peur des voleurs jeta
dans les bras de Gaspard une jeune et belle marquise ; et
comment l’infortune du marquis fut, à bon droit, imputée
à l’abbé de Chaulieu. 153
Chapitre XIII. — Pablo redevient ermite. 174
Chapitre XIV. — Où l’on verra comment Thérèse découvrit que
Gaspard était un voleur, mais que, étant voleur sans l’être,
il se montrait sévère envers ceux qui méritent ce nom
méprisable ; et comment cette découverte impressionna
l’intéressante fiancée de Bernard. 194
Chapitre XV. — Gaspard invite un évêque à bénir les fiançailles
de Thérèse et de Bernard. 204
Chapitre XVI. — La mémorable entrevue de l’évêque de
Castries et du faux moine dom Pablo. 212
Chapitre XVII. — Le diable se sert subtilement d’un innocent
évêque pour encourager un amour profane ; et Gaspard,
avec la femme qu’il aime, contemple les pierres, encore
vivantes, qui furent l’Arc de Triomphe de Marius. 224
Chapitre XVIII. — En attendant la chute du Parlement,
Gaspard, usurpant les fonctions de cette haute assemblée,
rend, à sa façon, et à l’exemple de saint Louis, la justice
sinon sous un chêne, du moins sous un pin parasol. 235
Chapitre XIX. — M. de Paulac, représentant du lieutenant
général de police et envoyé de Paris, par ordre royal, pour
informer aussi bien sur les agissements du Parlement que
sur les actes de Gaspard de Besse, est arrêté et conduit
en prison sur l’ordre non moins royal du bandit populaire. 246
Chapitre XX. — Où l’on verra M. Marin devenu président à
deux mortiers, le mortier populaire étant l’ustensile sans
lequel on ne saurait confectionner un des deux plats
nationaux de Provence : l’aïoli. 255
Chapitre XXI. — M. de Paulac, ayant pris des libertés avec les
soubrettes et avec les conseillers au Parlement, s’élève
avec vivacité contre l’enjouement que montrent les
femmes du beau monde en faveur du bandit Gaspard. 273
Chapitre XXII. — Où l’on assistera à la deuxième rencontre de
Gaspard avec Séraphin Cocarel et aux remontrances
royales de M. de Paulac au Parlement d’Aix-en-Provence. 287
Chapitre XXIII. — Comme quoi M. de Paulac, tout
représentant qu’il fût de M. le lieutenant de la police
royale, n’hésita pas à recevoir de Séraphin Cocarel une
somme fort honorable, en échange d’un service qui ne
l’était pas. 299
Chapitre XXIV. — Le poète Jean Lecor fait recevoir une pièce
en un acte et en vers par la troupe de Gaspard de Besse. 307
Chapitre XXV. — Jean Lecor, prince des poètes, prince des
conteurs, prince des acteurs, — conquiert le droit d’être
proclamé prince des avocats. 315
Chapitre XXVI. — Gaspard, en prononçant son réquisitoire
contre le Parlement, n’échappe pas à ce défaut chéri des
orateurs, qui est d’être prolixe, tandis que Sanplan, au
contraire, motive l’arrêt com-pen-di-eu-se-ment. 329
Chapitre XXVII. — Le dernier acte du bandit gentilhomme. 349
Chapitre XXVIII. — La fin de la grande galégeade et les
prodromes de la Révolution française. 354
La Postérité. 371
 LE FAMEUX CHEVALIER
GASPARD DE BESSE
SES DERNIÈRES AVENTURES [1]
[1] Les premières aventures de Gaspard forment un
volume publié, chez le même éditeur, sous ce titre : Un
Bandit à la française : Gaspard de Besse, raconté aux Poilus
de France, par Jean d’Auriol.

CHAPITRE PREMIER

Dans la prison, Gaspard qui a tout le loisir de méditer sur sa vie passée et de
songer à de nouveaux projets, pressent que, dans la gorgerette d’une
chaste pucelle, il trouvera la clef des champs.

La prison de l’Observance est encore visible dans la partie haute

du vieux Draguignan, et assez voisine de la maison dite Maison du
Bourreau.
Elle a quelque chose de naïf, cette prison historique où fut
enfermé Gaspard de Besse.
Bien qu’ayant un judas, la porte qui donne sur la rue est assez
semblable à toutes les portes massives des maisons voisines :
mêmes dimensions, même aspect paisible, innocent. La porte
ouverte, on se trouve dans un étroit vestibule ; et, à trois pas devant
soi, on a l’entrée du cachot principal, à vrai dire un simple cabinet
noir ; mais un reste de ferrures, scellé dans les murs, atteste que,
tout de même, les prisonniers devaient être, en un tel réduit, assez
misérables pour satisfaire la vindicte publique. Seulement, du cachot
à la rue, il n’y avait littéralement qu’un saut. Et ce saut, tout
prisonnier le faisait en rêve nuit et jour. Beaucoup s’évadaient, pour
peu qu’ils pussent récompenser les complaisances du geôlier. Et les
procès-verbaux d’évasion étaient remarquablement nombreux dans
toutes les villes de France.
Si le mur de son cachot eût été seulement percé d’un fénestron
donnant sur la verte campagne, Gaspard eût considéré le temps de
sa captivité comme une halte reposante, favorable à la lecture et à
la réflexion.
C’est à la lueur d’un calèn qu’il lisait tout le jour.
M. de Tervieille, en lui faisant parvenir divers ouvrages d’histoire,
avait, à prix d’or, obtenu du geôlier que le prisonnier pût s’éclairer de
la pauvre petite lampe de fer, suspendue à un clou et qui donnait
une lamentable mais suffisante clarté au lecteur assidu. Quand il ne
lisait pas, Gaspard réfléchissait, la nuit surtout.
Non sans guetter l’occasion de s’évader, il prit ainsi son mal en
patience.
Il médita sur son existence passée et sur son avenir ; se raconta
plus d’une de ses propres aventures, s’interrogea sur ses sentiments.
Il vécut un peu à la façon d’un novice sincère qui, tout de suite, du
fond de son couvent, juge plus librement et mieux les conflits
humains, les méprise même, et, en vérité, s’élève à des pensées qui
lui étaient étrangères au temps où il vivait dans le siècle.
Il y a toute une littérature qui, au XIXe siècle, s’est appliquée à
montrer le paysan de France comme étant toujours un être sordide,
uniquement préoccupé de s’arrondir, incapable de s’élever à une
vraie vie morale, une sorte de végétal-animal, n’ayant d’autre souci
que celui de satisfaire ses appétits. Cette figure du paysan a passé
pour rigoureusement ressemblante, jusqu’au jour où, lancé dans la
guerre pour la défense du sol, le paysan français a été proclamé un
héros, compréhensif et conscient. Peut-être est-il juste de dire que la
nécessité d’être héroïque a paru transfigurer l’homme de France ; les
circonstances n’ont fait que mettre en lumière des sentiments qui
existaient en lui virtuellement ; ces sentiments, les circonstances ne
les ont pas créés mais seulement fait éclater ; l’homme de la terre ne
s’est élevé à la hauteur des événements qu’en se relevant de toute
sa taille, courbé qu’il était sous les fardeaux d’une vie quotidienne
qui exigeait cette attitude. Ce n’est pas devenir grand tout à coup
que montrer soudainement toute sa stature, en se redressant.

Quelque opinion que l’on ait sur Jean-Jacques Rousseau, on est

bien forcé de convenir que ce valet n’était pas un sot. Épictète fut un
esclave, ce qui prouve que pour penser noblement, il n’est pas
nécessaire d’être empereur comme Marc-Aurèle. Tous les apôtres
n’étaient que de pauvres diables, de très humbles pêcheurs ; et ils
comprirent mieux que les princes des prêtres la plus sublime des
paroles que l’âme humaine ait jamais entendues. Gaspard, fils de
paysan, avait, nous le savons, une intelligence des plus vives, servie
par une mémoire infaillible. Il avait beaucoup lu ; il s’appliqua à lire
beaucoup dans sa prison, car il croyait en son étoile et il ne doutait
pas de sa prochaine libération.
Dans l’ombre de ce cachot sans air, où il passa bien des
semaines, ses bras, chargés d’une chaîne assez légère quoique
solide, soulevaient le livre vers la clarté fumeuse de son calèn ; et il
s’instruisait avidement.
Le Voyage de Provence, écrit par M. l’abbé Papon, tout
particulièrement l’intéressa. Il y retrouvait ses itinéraires de coureur
des bois, de routier ; les paysages familiers de sa province ; des
anecdotes sur ses plus célèbres compatriotes, parmi lesquels deux
surtout lui apparurent comme dignes d’attention et de sympathie : le
marseillais Adraman et le toulonnais Paul qui, de ce pauvre prénom,
fit un nom illustre.
 Adraman tout enfant, fut, par des parents qui vivaient dans la
misère, embarqué comme moussaillon sur un petit navire armé en
course. Pris par les Turcs — tout comme devait l’être un jour l’ami
Sanplan — Adraman ne fit ainsi que changer de misère. A bord du
bateau pirate tunisien, il reçut des coups de garcette turque, des
coups de pieds turcs et des gifles turques. Or, les mêmes traitements
lui avaient d’abord été prodigués par ses concitoyens d’Europe ; en
sorte que, ne pouvant établir aucune différence entre chrétiens et
musulmans, il se fit Turc sans remords et bon serviteur d’Allah. Il
avait du goût pour l’état de pirate et le fit bien voir, si bien voir que,
dit Papon, « dans un pays où tous les hommes sont égaux par la
naissance, et où ils ne sont estimés qu’en raison de leurs services
(où diable, se trouve ce pays-là ?) Adraman ne tarda pas à être élevé
aux premiers emplois… La mer devint son élément… Il y fit des
expéditions dignes des plus grands capitaines… Le Grand Seigneur le
nomma Bacha de Rhodes, ensuite amiral et général des Galères, à la
place du fameux Mezomorvo ! »
Voilà une belle carrière d’aventurier ; mais, plus que tout autre,
un trait de cette curieuse existence charma Gaspard.
Adraman était accoutumé à une discipline sévère.
Un jour, ce Bacha de Rhodes, suivi de quelques soldats « faisait la
patrouille à Scio ». A la porte d’une maison, il vit, attachés à l’anneau
du mur, trois ou quatre bourricots dont les doubles paniers de
sparterie étaient chargés de pierres. Un enfant les gardait.
— Où donc sont les maîtres de ces ânes ?
— Ils sont allés prendre nourriture.
Le Bacha ne répondit rien et continua sa tournée ; mais, une
heure après, repassant par là, et voyant les mêmes animaux
toujours à l’attache et toujours chargés, sous la garde du même
enfant :
— Va me chercher les maîtres de ces ânes, et me les amène.
Et quand les âniers furent en sa présence, Adraman leur dit :
— Avez-vous mangé de bon appétit ?
 — Oui, Seigneur.
— Il est donc juste que vos ânes mangent à leur tour. Je regrette
pour vous que vous ayez cru bon de leur laisser ces lourdes pierres
sur l’échine pendant que vous faisiez durer plus que de raison le
temps de votre repas.
Là-dessus, il leur ordonna de se tenir immobiles devant lui, à
quatre pattes ; et à ses chaouchs de leur mettre sur le dos les
paniers des ânes avec leur chargement de pierres, dont, à vrai dire,
le poids portait en partie sur le sol mais les retenait captifs.
— A présent, leur dit ce Turc très chrétien, vous attendrez
patiemment qu’à leur tour vos ânes aient mangé à leur faim… Il ne
faut pas faire à autrui ce que vous ne voulez pas qui vous soit fait !…
« Quelque étrange et dure que fût la punition, dit Papon, il fallut
la subir. »
Cette histoire, donc, enchantait Gaspard, le faisait à la fois rire et
pleurer de satisfaction, et, bien des fois, plus tard, il la conta à sa
bande.
Il est absurde de prétendre que les livres n’ont aucune influence
sur la moralité des hommes. C’est avec des paraboles simples que
l’Évangile a transformé la pensée humaine.
La sévérité d’Adraman lui fit des ennemis ; sa grandeur, des
jaloux. Faussement accusé d’avoir voulu incendier Constantinople, il
fut « condamné à perdre la vie par le cordon » et fut exécuté en
1706. L’excellent Papon déclarait qu’il était mort victime d’un
« gouvernement arbitraire ».
La vie de ce Toulonnais, demeuré illustre sous le nom de
chevalier Paul n’enchantait pas moins Gaspard.
Paul, simple mousse comme Adraman le Marseillais, s’éleva de
cet humble état au grade de « chevalier de justice dans l’ordre de
Malthe » et de vice-amiral de France. Il était fils d’une blanchisseuse.
Elle était fort avancée dans sa grossesse lorsque, allant de Marseille
au Château d’If, par mauvais temps, tangage et roulis la délivrèrent
brusquement. Ainsi son enfant, le futur amiral, fut un peu le fils de la
mer et de la tempête, ou de « Neptune, dieu des flots ».
Paul commandait la Marine à Toulon, quand Bachaumont et
Chapelle visitèrent la ville ; et leur voyage, en vers de huit pieds, lui
rend hommage en ces termes :

C’est ce Paul dont l’expérience

Gourmande la mer et le vent ;
Dont le bonheur et la vaillance
Rendent formidable la France
A tous les peuples du Levant.

Louis XIV, en 1660, fut reçu à Toulon par le chevalier Paul, qui lui
donna une fête dans son jardin, à Dardennes.
Pour amuser les belles dames de la Cour, Paul fit suspendre, dans
ses orangers, parmi les bigarrées, d’excellentes oranges confites,
attachées aux branches par des fils menus, habilement dissimulés :
— Oh ! voyez, chère marquise, les belles oranges, extraordinaires
d’être si douces, parmi les autres si amères !
— C’est une merveille !
— Cela ne vous étonne point ?
— Un peu sans doute ; mais les fruits du dattier, dit-on, ne sont
pas moins mielleux, collants et sucrés, et se peuvent dire
naturellement confits par les soins de la nature !
On se croyait dans cette Ile des Plaisirs que M. de Fénelon devait
plus tard imaginer pour la joie de Monseigneur le Dauphin.
Un jour, le chevalier Paul rencontra, sur le quai de Toulon, un
pauvre batelier qui, à sa vue, parut vouloir se dissimuler parmi
d’autres. Paul le reconnut pour un de ses anciens camarades. Il
l’appela par son nom ; et, l’homme s’étant approché, l’amiral se
tournant vers ses officiers :
— Je vous présente un de mes anciens camarades de jeunesse et
de misère. Souffrez, messieurs, que je m’entretienne un instant avec
lui.
Il l’interrogea en particulier sur sa famille, sur ses besoins, lui
témoigna beaucoup d’amitié et lui fit accorder un bon petit emploi…
Paul mourut en 1667, laissant toute sa fortune aux pauvres, parmi
lesquels il voulut être enterré.
— Voilà un homme ! s’écriait Gaspard qui, en lisant, dans son
cachot, ce trait de la vie de Paul, versait des larmes. Nobles larmes,
comme celles que firent verser à Condé, Corneille et la clémence
d’Auguste.
Ces émotions de Gaspard, la préférence qu’il eut pour Adraman
et le chevalier Paul — la simple et touchante bonté des actions qui
leur valurent cette préférence — suffiraient à nous révéler la qualité
de son grand cœur populaire ; et à nous faire comprendre pourquoi
le peuple de Provence a fait de Gaspard un de ses favoris.
Gaspard, aidé par les circonstances, aurait pu avoir une destinée
égale à celle des héros dont il admirait la fortune, dont il aimait
surtout la bienveillance envers les existences des plus humbles.
Comme le bandit Mandrin, qui fut un vrai capitaine, Gaspard, sur
un champ d’action plus vaste, eût sans doute acquis une renommée
universelle ; et, dans le rang des réguliers, il eût conquis l’admiration
du monde, grâce à des qualités heureuses qui ne furent pas toujours
celles des chefs de peuples. Avant tout, il aimait, autant que la
justice, la bonté. Et voilà déjà qui n’est pas commun. Son curé lui
avait appris à faire son examen de conscience ; il le fit dans la
solitude du cachot.
Il regrettait de s’être fait bandit. L’idée du juste mépris où l’on
tient les voleurs lui était difficile à supporter. Cependant, si sa
condition de chef de bande le mettait un jour à même de faire
comprendre aux puissants que le peuple exigeait la réforme de la
juridiction pénale, n’y avait-il pas quelque chose de respectable dans
sa condition ? C’est du moins ce qu’il se disait. Les vols à main armée
opérés courtoisement, sans violence inutile, n’étaient à ses yeux
qu’un impôt prélevé par lui pour l’entretien de sa troupe, à laquelle il
ne permettait aucun pillage. Des tributs volontaires rendaient les
vols de jour en jour moins nombreux. On vivait, on ne thésaurisait
pas. Il poursuivait un but hautement politique : il voulait humilier le
parlement, le ridiculiser, le dénoncer à tous les yeux comme une
institution qu’il fallait ou changer ou rendre à elle-même, c’est-à-dire
aux principes dont elle se prétendait issue et que pourtant elle
paraissait mettre souvent en oubli.
Le Parlement avait étouffé l’affaire de l’assassinat de Teisseire
parce que les coupables étaient des puissants selon l’expression du
bon La Fontaine ; et Gaspard voulait que les coupables fussent
atteints ; que la mort du père de Bernard fût expiée ; et que, dans le
châtiment des coupables, les paysans, les petits, vissent le signe de
la protection des lois étendue sur eux. Le but qu’il se donnait lui
avait paru jusqu’alors une satisfaisante excuse à ses actes de
rebelle ; toutefois il les sentait en contradiction permanente avec
l’idée d’obéissance aux lois, qu’il eût voulu servir, et de cela il
souffrait étrangement. Mais, s’il souffrait ainsi, est-ce que ce
tourment ne donnait pas à sa mission un goût de sacrifice qui la
rendait honorable, ne fût-ce qu’à ses propres yeux ? En tous cas, il
ne pouvait plus rien changer aux contradictions dont il gémissait : il
s’était engagé dans une voie où, à sa suite, il avait engagé d’autres
existences ; il se devait à elles ; il poursuivrait sa tâche. Toutefois, et
cela était nouveau en lui, il se répétait souvent : « Il est malheureux
que, pour servir mon désir de justice, j’aie cru pouvoir m’entourer de
coquins ! » L’état d’humiliation où il se voyait réduit, les chaînes qui
l’attachaient aux murs de son cachot, éveillaient en lui ces poignants
regrets. Il se sentait sous le coup de la réprobation publique ! Il
combattait ce regret en se répétant qu’un grand bien sortirait peut-
être de sa révolte condamnable. Et, tout d’abord, n’allait-il pas
donner une vie heureuse à Bernard, son frère d’adoption, en lui
faisant épouser la fille de l’usurier Cabasse, cet ancien valet de
fermier général, qui avait dépouillé tant de pauvres gens, et par qui
il avait été dépouillé lui-même de son patrimoine ?
A l’idée du bonheur qu’il préparait à Bernard et à la pupille de
Cabasse, malgré toutes les résistances du tuteur usurier, Gaspard
s’attendrissait.
 Le bonheur d’amour, dans la paix, selon la loi et selon Dieu,
l’amour dans le devoir, une famille laborieuse et respectée, — c’est
ce que lui, Gaspard, n’aurait jamais ! — Donner ce bonheur à deux
jeunes êtres qui en étaient dignes, n’était-ce pas une bonne œuvre
qui lui serait comptée comme une touchante excuse aux exactions
qu’il était en train d’expier ? Il ne parvenait pas à en être sûr et à
s’absoudre pleinement… Ainsi la solitude de la prison lui montrait les
choses sous un jour nouveau, formait en lui comme une conscience
neuve.
Assis dans l’étroite cellule, les poignets pris dans des bracelets de
fer, attaché aux murs comme un chien à sa niche, Gaspard rêvait. Le
chien enchaîné, lui du moins, voit, du seuil de sa cabane, la lumière
du jour. Gaspard n’avait que la clarté de son calèn fumeux et qui
s’éteignait souvent faute d’huile ; il fallait alors attendre le bon plaisir
du geôlier Castagne. Un grillage épais, au-dessus de la porte, barrait
la mince ouverture rectangulaire par où lui arrivait un peu de la
lumière naturelle. Et cela s’appelait un jour de souffrance.
Dans cette ombre, Gaspard rêvait aussi d’amour ; et c’est là que,
pour la première fois, il se prit à reconnaître que l’image de Mme de
Lizerolles était en lui comme vivante et attirante.
Quoi ! osait-il espérer d’elle autre chose qu’une pitié hautaine ? Il
ne savait pas. Profiterait-il de l’ignorance où elle était de son nom ? Il
se refusait à cette pensée comme au plus criminel des abus de
confiance.
Or, Gaspard avait un secret d’amour, enfoui profondément dans
son cœur. A Aix, il avait trompé, séduit, sous un nom d’emprunt, une
douce et humble petite bourgeoise, misé Brun, la femme d’un
modeste horloger. Celle-là n’avait-elle pas pour lui oublié tous ses
devoirs ? Quelle honte, quelle douleur pour elle, le jour où elle
apprendrait que son amant n’était autre que Gaspard de Besse, un
chef de voleurs !
… Ainsi, il aimait assez Mme de Lizerolles pour vouloir lui
épargner une souffrance que, bien malgré lui, mais fatalement, il
infligerait tôt ou tard à misé Brun. Et la noblesse de son amour pour
la comtesse lui reprocha la bassesse de son acte vis-à-vis de la
plébéienne, en sorte qu’il prit, dans sa prison, la résolution de ne
plus revoir misé Brun. Elle pleurerait un infidèle, mais ignorerait à
jamais — il l’espérait du moins — la qualité de son déplorable
séducteur. Il éprouva un grand bien-être à s’affermir dans cette
résolution ; il se sentit un peu réconcilié avec lui-même, et, d’ailleurs,
libéré en même temps, d’une dangereuse intrigue.
Y avait-il d’autres figures de femmes dans ses souvenirs ? Sans
doute ; mais toutes comme voilées et lointaines. Il était si
« agradant », si plaisant, que, pour s’expliquer ses qualités de
séducteur, les paysans de Besse (et il ne l’ignorait pas) prétendaient
qu’il était un enfant de l’amour. Il était fils, disait-on, du marquis de
X… qui avait séduit sa mère misé Bouis. Facilement ému par la grâce
féminine, il se reconnut troublé par la fille de son geôlier, Louisette,
qui, parfois, remplaçant son père, lui apportait l’eau et le pain.
Quand c’était Louisette qui ouvrait la porte du cachot, un rayon du
joyeux soleil entrait avec elle ; et, elle aussi, était lumière et joie…
Essaierait-il de troubler le cœur de cette fillette pour obtenir d’elle la
liberté ? Il souriait malgré lui à cette idée. On racontait dans le
peuple que la fille d’un geôlier séduite par M. de Mirabeau, enfermé
au château d’If, avait favorisé l’évasion du gentilhomme. Donc, il
imiterait M. de Mirabeau…; mais, là encore, Mme de Lizerolles
intervenait, apparaissait à Gaspard avec un visage sévère : « Vous
laisserez en repos cette fille »…
Comment ! n’était-il donc plus libre de cœur et d’esprit ? Tout
caprice galant lui était-il interdit par une ombre ? Pauvre Louisette !
qu’arriverait-il de cette enfant ?… Mais, quoi ! ne pourrait-elle le
servir sans en être si mal récompensée ? Serait-elle la première qui
l’aurait ému de désir sans être mise à mal ?
Cette question réveilla en lui le souvenir d’une gentille aventure
qui lui était arrivée naguère. Il en revit les moindres détails. Elle
l’égaya tout un jour dans sa misérable geôle…

HISTOIRE D’UNE GORGERETTE.

 … Il avait, un matin, rencontré une femme qui, à pied, s’en allait
à-z-Aï (à Aix) avec sa fille, une mignonne de seize à dix-sept ans, un
peu frêle, mais d’autant plus gracieuse.
— Eh, bonjour, bonne dame ! Où allez-vous comme ça, avec une
si jolie fille ? et si bien attiffées toutes les deux ? Les chemins ne sont
pas sûrs.
— Pas sûrs, les chemins ! dit la femme. Oh ! que si !… Gaspard de
Besse rôde par là, et nous protégerait de « mauvais rencontre ». Il
est doux au pauvre monde !
Gaspard fut charmé.
— Vous pouvez, en effet, dit-il compter sur lui. Il aime les
pauvres gens. Mais tout cela ne me dit pas où vous allez ?
— A Aix, mon gentilhomme, consulter un avocat.
Gaspard n’aimait pas les avocats parce qu’indifféremment, disait-
il, ils plaident pour ou contre l’innocent, ce qui, ainsi présenté, est
une fausse conception de la profession d’avocat. La défense est une
garantie de justice ; et il n’est pas vrai de dire que la culpabilité ou
l’innocence n’émeuvent pas fort différemment les défenseurs.
— Un avocat, dit Gaspard, vous prendra beaucoup d’argent.
Expliquez-moi votre affaire. J’ai appris à connaître les lois parce que
je les voudrais changer.
— Et qu’êtes-vous donc ? dit la femme.
— Gaspard de Besse lui-même.
— Bou-Diou ! s’écria-t-elle sans montrer d’autre trouble qu’une
surprise joyeuse. La Bonne Mère vous envoie ! Pour sûr que je vous
consulterai ! Je le sais bien que vous êtes de bon conseil, et que
souvent, de très loin, les gens viennent à vous, pour vous demander
ça ou ça… Eh bien, donc, je vais vous expliquer. Ma fillette était
fiancée, il y a peu de temps, avec un matelot de la marine du Roi,
dans Toulon. Il faut vous dire qu’à Toulon je tiens un cabaret, rue de
l’Arme à Dieu, mais en tout bien tout honneur.
— Et pourquoi, dit Gaspard, ne consultez-vous pas à Toulon ?
 — Pour pas qu’on sache nos affaires, pardi !… Et puis, dans Aix,
où j’ai des parents qui nous recevront, et où se trouve le Parlement,
chacun sait qu’on a tout ce qui se fait de mieux en fait d’avocats.
— Oui, dit Gaspard, à Toulon on a le bagne ; à Aix, le Parlement…
— Pour lors, dit la cabaretière, le matelot, fiancé de ma Mïette, a,
tout en un coup, rompu les accords. Il ne la veut plus. Et je
voudrais, moi, savoir si, pour le tort qu’il fait à notre réputation, nous
n’avons pas droit à quelque avantage, tel qu’une ronde somme
d’argent qu’on le forcerait à nous payer ?
— Hum ! fit Gaspard, je dois, bonne mère, vous poser une
question indiscrète… Mais, j’aperçois là-bas un rocher en forme de
banc, au bord du chemin. Allons nous y asseoir un moment, on y
causera plus à l’aise.
Et quand tous trois furent assis sur la roche, un peu au-dessus
du bord de la route exhaussée en talus :
— Voilà, dit la mère. Le matelot prétend que ma fille, en été,
porte une gorgerette trop ouverte, et que, par ce jour de souffrance,
elle montre trop d’elle-même ! Il est jaloux cet homme. Bien mal à
propos ! Il ne veut pas comprendre qu’en été on ne peut pas se
cacher toute la poitrine, comme il se doit en hiver ; ni être, dans sa
maison, toute couverte comme aujourd’hui sur le grand chemin.
— Diable ! dit Gaspard, la question est des plus graves, et un curé
y répondrait peut-être mieux que moi.
— Oh ! dit la femme, si on écoutait les curés, on ne montrerait
jamais rien à personne, pas même à l’époux qu’on a choisi devant
Dieu ! J’ai, en mon temps, porté gorgerette bas ouverte, qui me
laissait voir bien rédoune comme j’étais ; et c’est justement la raison
pourquoi feu mon cher mari, qui avait l’œil bien voyant, me choisit
entre beaucoup d’autres. Tout le monde à la foire n’aime pas acheter
une ânesse sans lui avoir tâté la croupe, ni une vache dans un sac.
— Raison vous avez, dit Gaspard riant ; et sans doute votre marin
est bien sot… Toutefois il pourrait avoir raison, au cas, par exemple,
où la gorgerette serait véritablement trop échancrée.
 Aussitôt la mère commanda :
— Lèvo-ti, Mïette ; ote ton fiçu.
La fillette se leva et ôta son fichu.
— Descends sur la route, et te place bien devant nous.
Cela fut fait. Et la fillette, fichu ôté, se trouva toute gracieuse,
avec sa cotte rayée de blanc et de bleu, son casaquin à fleurs, à
petites basques étroites, en saillie sur les hanches ; jolie sous son
large chapeau, et montrant des jambes fines à bas rouges, telles les
pattes fluettes d’une alerte perdrix.
La gorgerette échancrée montrait un cou flexible et le haut d’une
poitrine qui n’avait jamais vu le soleil des paysans ; c’est dans une
ombre fraîche que les doux fruits se formaient, sous le corsage, et
d’ailleurs, dans une des rues les plus obscures du vieux Toulon.
Au soleil, à présent, la peau blanche resplendissait.
— Eh bien ? interrogea la mère.
— Eh bien, dit Gaspard malicieux, je ne vois pas grand’chose.
— J’en étais sûre ! s’écria la mère triomphante… Alors, le procès
sera bon pour nous, hé ?
— Pas si vite ! dit Gaspard, regardant le pied de la petite, sa
cheville et son mollet, qui apparaissaient sous la cotte haut troussée.
— Pas si vite ! ne serait-elle pas, des fois, trop décolletée par en
bas ?
— Jamais plus qu’aujourd’hui, mon bon monsieur Gaspard, dit la
mère. Elle a joué, des fois qu’il y a, la comédie pour Noël, mais elle
n’est pas danseuse… Seulement…
— Seulement, quoi ? dit Gaspard.
— Seulement il se peut faire que, lorsqu’elle verse à boire à la
pratique, elle se penche un peu de trop ; et le matelot a prétendu
qu’en ce cas on lui voit trop au fond.
— Et que voit-on alors ? demanda Gaspard.
A ce mot :
 — Miette, ordonna la mère, penche-toi comme si tu donnais à
boire à M. Gaspard ; il jugera notre affaire.
La gracieuse petite, tenant en main une fiasquette imaginaire, fit
le geste d’emplir pour le matelot la coupe des voluptés permises.
Elle s’inclina. La gorgerette bailla. Gaspard regarda.
— Je ne vois toujours rien, dit-il, naïvement déçu.
— Penche-toi un peu plus, ma fille.
La fille obéit.
— Je ne vois rien, répéta Gaspard.
Peut-être n’était-il pas tout à fait sincère.
La mère, pour la seconde fois, poussa un cri de triomphe.
— Il ne voit rien ! cria-t-elle. Monsieur Gaspard lui-même, qui est
jeune et qui a, comme mon pauvre homme en avait, pechère ! de
bons yeux bien voyants et qui ne demandent qu’à voir, — ne voit
rien du tout, ma belle Mïette ! Je te le disais bien, que nous
gagnerions notre procès !
Et, changeant de ton, après cet éclat de voix qui chantait
victoire, elle reprit avec calme :
— Et puis, vous savez, que je vous dise un peu ! C’est bien
naturel que vous ne voyiez rien, monsieur Gaspard, pourquoi
personne ne pourrait rien voir ; bien entendu que le diable lui-même
y perdrait son latin d’Église, par la raison que ma belle petite n’a pas
encore d’estomac, pechère ! pas plus que sur la main !… C’est plat
comme un ange ; et vous pourriez, si vous n’aviez pas peur des
juges, déposer au procès comme témoin aquilère.
Gaspard riait de bon cœur.
— Et que voulez-vous dire par témoin aquilère ?
— Un témoin qui y était, pardine ! un témoin dont on peut dire :
aqui, l’éro !… Et alors, que vous nous conseillez ? Ce que vous nous
conseillerez, nous ferons, pourquoi en vous nous avons confiance ;
et j’aime mieux vous, qui êtes un bandit bien honnête, que
beaucoup d’hommes honnêtes qui sont de véritables bandits ; et,
surtout, j’aime mieux conseil de vous que d’un avocat à qui,
d’avance, il faudrait donner un bel argent qu’on risquerait de tout
perdre.
Gaspard, devenu grave, cherchait sa sentence.
Il rêva un temps ; les deux femmes le regardaient, toutes
réjouies d’espérance.
— Votre matelot a bien tort, prononça enfin Gaspard. Je devine la
raison pourquoi il ne veut plus de votre jolie fille.
— Et quelle est-elle, sainte Vierge ! la raison pourquoi ?
— C’est que, bonne dame, votre jeune homme ne sait pas que,
sur la terre, il faut savoir se contenter de peu. C’est là, pourtant, la
sagesse, qui seule donne le bonheur. Et maintenant, pour vous bien
prouver que je ne suis pas un avocat, mais un voleur qui aime à rire,
voici un bel écu, en souvenir de moi… Adesias ; ma route va de ce
côté, au rebours de la vôtre…

Seul au fond de son triste cachot, Gaspard, en se remémorant

cette aimable rencontre, riait tout haut ; et Louisette, la fille du
geôlier, survenant tout à coup pour lui présenter la cruche d’eau et la
miche de pain quotidiennes, le trouva tout riant encore. Elle lui
demanda la cause de cette gaîté, singulière en un tel lieu.
— Je ris, dit Gaspard, d’un souvenir que je vous puis conter.
Parler directement aux filles de ce qu’elles doivent cacher n’est
pas convenable, mais le souvenir qui égayait Gaspard restait
aimablement chaste, après tout, avec tout juste la petite pointe de
malice galante que personne ne condamne. Il se complut donc à
narrer son historiette, et si gentiment le fit que Louisette y prit un
plaisir extrême. Elle écoutait, un peu rougissante ; et le jouvent
pensait qu’une prison où l’on reçoit de temps à autre une si plaisante
visite n’est point cruelle autant qu’on le pourrait croire.
Avec sa coquine d’histoire, il n’offrait pas la fleurette à la fille,
mais il lui montrait la fleurette.
 Parler d’amour, c’est déjà appeler l’amour ; et c’est justement ce
que faisait Gaspard, et de quoi il se sentait tout ranimé, dans un
vague espoir d’obtenir quelque chose sans rien demander. C’est bien
ce qui advint, car il se sentit tout à coup regardé avec des yeux dont
le brillant humide se noyait dans un trouble communicatif.
Vivement sortit Louisette, pour cacher ce trouble léger. Ce fut
assez. Gaspard comprit qu’à la fille du geôlier il ouvrait, lui, le captif,
une fenêtre sur l’amour ; et qu’en échange elle lui ouvrirait la porte
qui donnait sur la liberté. C’est dans la gorgerette de Louisette qu’il
trouverait la clef des champs.
 CHAPITRE II

Sainte Roseline, patronne des prisonniers, étend sur Gaspard sa protection

miraculeuse par l’intermédiaire d’un pauvre ermite.

Pendant qu’ainsi rêvait, lisait et souffrait Gaspard, non sans

garder confiance en son étoile, — que devenaient sa bande et ses
amis ?
La bande s’était prudemment dispersée, et chacun des bandits,
chez quelque paysan affilié, vivait en « travailleur de terre ».
Bernard revoyait de temps à autre sa Thérèse. « J’ai trouvé, à
Marseille (lui disait-il), un bon emploi chez un armateur, et j’amasse
un joli pécule qui sera ta fortune un jour. » Pourquoi l’aurait-elle
soupçonné de mensonge ? Elle l’aimait.

Lorsque Sanplan et Bernard se rejoignaient, ils combinaient avec

Pablo et Lecor, des plans d’évasion, toujours modifiés, car on ne
voulait agir qu’avec une certitude de réussite.
A ces conciliabules assistaient souvent deux affidés qui étaient
l’âme secrète de « l’administration » créée par Gaspard pour assurer
la vie de sa bande. C’était Jean Bouilly, de Vidauban, et Joseph
Augias, de la Valette, dont les noms ne furent connus du peuple que
plus tard, lorsqu’ils figurèrent dans l’arrêt du Parlement.
 Donc les amis de Gaspard, Sanplan et Bernard, ne songeaient
qu’à délivrer le prisonnier ; mais, prudents, ils laissaient mûrir leurs
projets. La capture de Gaspard était trop importante, croyaient-ils,
pour que le captif ne fût pas gardé jalousement. D’autre part, si
Sanplan se laissait prendre à son tour, la bande resterait sans chef et
désorganisée. Il fallait donc manœuvrer avec la plus grande
prudence. Bernard était bien novice pour tenter à lui seul une
opération aussi difficile. Lecor s’offrit pour aller aux informations ;
mais Sanplan, en fin de compte, ne se fiant qu’à lui-même, décida
qu’il irait en simple éclaireur à Draguignan ; il y aurait les
renseignements nécessaires sur la prison et les gardiens de la
prison ; à son retour, on aviserait. Il se rendit à Draguignan, en
effet ; il y apprit avec satisfaction que la geôle dracénoise n’était pas
ce qu’il craignait qu’elle fût, mais simplement un pauvre cachot dans
une maison assez mal défendue par le geôlier, un bon vivant nommé
Castagne, veuf et père d’une jolie fille fort sage. Cette enfant
exerçait, sur un père un peu trop amoureux de la bouteille,
l’influence heureuse d’une fille vainement courtisée par les plus jolis
gaillards de la ville. C’est par elle, songea Sanplan, que nous devons
arriver à nos fins, mais il ne faut pas l’effaroucher. Gaspard d’ailleurs
— je le connais — a dû commencer déjà, en faisant un brin de cour
à la fillette, l’œuvre de sa délivrance.
Enfin, tout bien examiné, il fut décidé que, muni de ces premiers
renseignements, dom Pablo irait à son tour à Draguignan ; et, livré à
ses inspirations, trouverait la « combinazione » la meilleure pour
pénétrer dans la prison, y voir Gaspard, lui parler, s’entendre avec
lui. Pour cela, Pablo devrait ou s’assurer les bonnes dispositions de
Louisette, la fille du geôlier ; ou apprivoiser celui-ci.
« Un ami de Bacchus ! déclarait Pablo ; je m’en charge ! »
La bande était dans l’Estérel.
Le moine s’achemina vers Draguignan. Chemin faisant, il
chercha, dans son sac à malice, la combinazione la plus favorable. Il
était parti trop tard dans la matinée pour atteindre Draguignan le
soir même ; et il suivit la grand’route de préférence aux chemins de