Beginning Table Views

Table views are an integeral part of iOS. In this video, you'll get an overview of them and what this course will cover.

This episode provides an overview of the app that you'll build in this course. You'll get a bird's eye view of the various features you'll implement to get it working.

You can either create a table view controller or a regular table view. Both have advantages and disadvantages. This video will walk you through them.

To display data, you need a table view cell but cells come with a few other features as well. This episode will get you started with them.

In this challenge you'll add a label to your cell and set the auto layout constraints. Sounds easy? Well, give it a try.

IndexPath objects act as addresses in your table. In this video, you'll get an understanding of how they'll work.

With table views, one row is not enough. You'll need a lot more--and your challenge is to make this happen.

Table views use protocols so in this video, you'll get an overview of protocols and how they can be used.

A table view defines both a delegate and a datasource which is how you provide data and respond to events. This episode covers how they work.

Delegation is a very important concept in iOS since it's used everywhere. In this video, you'll get an understanding of delegation from the ground up.

In this episode we'll review what we learned, what you can do to learn more, and what awaits in the next part.

This episode will cover the basics of working with MVC and why learning MVC is crucial to being a successful iOS developer.

This episode review each major component of MVC. That is, the model, the view, and the controller.

Getting stated with MVC means creating your first model. In this episode, you'll create your model, then update your controller to use it.

While the controller works, the checkmarks are out of sync with the actual data. This episode will show how to fix the bug.

With one Checkmark instance created, there's only four more to go which also just happens to the topic of your challenge.

This episode has you create another model object to hold all the instances of your checkmarks. Introducing the todo list.

With your new todo list in hand, all you have to do is use. Your challenge is to implement it in your controller.

We're not even through the second part, and your controller is starting to get messy. In this episode, you'll break out the mop and do some code cleaning.

This video gives a review of MVC, then introduces you to the upcoming part on adding and deleting items.

So far your, users of your checklist app can't add or delete items. In this video, you'll get an overview on how that will be accomplished.

Navigation controllers are a means to display lots of view controllers in your app and you'll learn how to use them.

Navigation bars can take buttons for you to add interactivity. In your challenge, you'll add one to your app.

Now's the time to add new check-list items! This video will walk you through the process.

When a new checklist item is added, your challenge is to give checklist items a random title.

Table views provide swipe to delete functionality, but it's up to you to do the actual delete action. In this video, you'll learn how to do that.

So far, this app only has one screeen. You'll take it to the next level by adding a new screen.

Prototype cells allow you to customize your cells at run time, whereas you customize static cells at build time. You'll add a static cell in this video.

In this challenge, you'll add a text field to your static table view cell.

Understanding the responder chain is critical for working with text fields. You'll the responder chain to work in this video.

There are times when you need to respond to special kinds of events. These are called control events and you'll learn about them in this video.

This video wraps up the process of adding and deleting items to your todo app.

When you add items, you'll ultimately need to edit them. This video will give you an overview of what this means.

In this episode, you'll write your own protocol to handle adding new items and canceling item addition.

Segues are relationships between view controllers and can also pass information between them. This video will cover the basics of them.

Making the edit view controller takes some work. Your challenge will to come up with a task list to make it happen.

This episode covers the use of the detail disclosure indicator and why it is necessary for the todo app.

Why have one segue, when you can have two? Your task is to create a second segue for editing.

Segues allow you to gain access to view controllers and then how to pass data to them. In this video, you'll learn how to do that.

Your challenge is to answer a simple question about your app behavior.

Often times, you can save time and subclass the NSObject to gain additional behavior to your object.

You'll often spend time refactoring your code and Xcode provides a few tools to do this.

Your challenge is to refactor a protocol by way of Xcode's refactor tools.

This video wraps up work on the todo list app and it will show you where to go.

In this final part, you'll get an overview of some other cool table view features that you can incorporate into your app.

Subclassing table view cells provides a lot of advantages. For one thing, we get IBOutlets and IBActions.

Moving rows is actually pretty easy with table views but it means we have to enter mode. Thankfully, that's easy as well.

Deleting multiple rows means you'll have to enable the selection of multiple rows. This episode walks you through the process.

In thie episode, you'll rewrite the table view to provide data in sections and you'll do this via the UILocalizedIndexCollation object.

Table views only you to also create indexes your content. It involves implementing specific methods which you'll do in this video.

At this point, you'll rewrite the model to organize your todos by priority to be later organized into individual sections.

With the model completely rewritten, you'll also have to rewrite the controller as well.

With the model complete and the controller almost rewritten, you'll finish the rewrite by completing sections and correcting any errors.

In this challenge, you'll provide header titles for all your priority sections.

In this episode, you'll learn how to move items between sections, allowing you to shift todos between priorty categories.

This final episode wraps up the entire series and provides some resources on where you might like to go next.