[Forms]

[?music?]

[Jim Hoskins] So now we've created sort of our scaffold for our first page.

We have different buttons for creating new and links that will eventually

dive into different lists of Notes in our application.

Let's actually take a look at it in the Simulator to make sure that it still looks good.

It looks pretty much the same; we have our new buttons,

we have our inset lists.

Now, of course, we're not actually going to get anywhere with them,

but we can see it works in both orientations

and it's pretty flexible.

Now, the next thing in our application is we want to start being able to have Notes

actually in our application.

But before we can really do that, we need to create a form

to input those Notes, and then we can actually start with the business

of creating the logic to save them and then display them later.

So I think our first course of action should be working on making this New Note button work

and bring up a form.

So let's take a look at the jQuery Mobile documentation to see what it gives us

in terms of forms.

So I'm just going to go back to the homepage here,

and we can see there's a section on Form elements.

So what we can do is let's just first take a look at the Form element gallery.

This gives us an idea of what forms look like in our application.

It'll make text inputs look nice; text areas nice and rounded here.

Search inputs will have the correct icon and be rounded to look like a search input.

It has this new item, which is a flipswitch, which we'll use later

which is just basically an on/off toggle.

It also gives us a nice slider attribute which will allow us to have different values

within a range.

For check boxes, it makes these really cool list items here

that are styled like check boxes that we can select multiple of.

You can have different button groups like this,

where we can add them on and off.

Radio buttons look like this.

We can also have them toggle like this, just like if there's only one that's available.

It even makes cool select tags--for instance, this select tag

pops up this cool little style dialog that we can choose.

Or if we have a really long one, it will pop up a dialog like this

which will be much longer.

Now, this will look a little better in a mobile browser

or we could just go with the default like this,

which will pop up a picker

like a normal select item would.

So let's actually take a look at this in a Simulator to see what it looks like

on an actual device.

I'm actually going to just create a new tab here.

I'm going to paste the URL into the Simulator just using Command-V

and then I can use the Paste dialog here to paste it from the device's clipboard.

So here we get the same page, and we can see how they actually look in a browser.

They actually look a little bit nicer; the flipswitch doesn't have as much of the little jaggies

on the end and we can actually use sort of a swiping motion to flip it on and off.

The sliders work.

It looks really good.

And we can see the different select forms that we have here,

and here's what a longer one looks like,

and the default one looks like this.

So you can see that jQuery Mobile really has a good set of form elements

that we can use.

Most of them are really just styling a normal input field

like an input of type text or a text area

or various other things--things like flipswitches, sliders, and our select items

have a few more options that we can put there, but by default,

our form should actually look pretty good.

Now, there is one thing:

we do want to associate our labels with the forms in a certain way.

So you can see here in our portrait orientation, our labels are on top of our items,

but in the landscape orientation, our labels are next to them.

So it actually decides based on how wide our page is if labels should be on top

or below, and there's some markup that it's expecting in order to make this happen.

So if we go back in our documentation

and we look at our Form elements

and take a look right here, we can see our markup conventions.

Basically, what we want to be using is a field container,

and these will be divs with a data-role of fieldcontain

and these will hold both our labels and our inputs in order to group them together

so they can be styled in that nice way.

So let's start on creating another page in our document.

Here, we have our homepage, which goes from this div down here,

and let's add a new form.

So I'm going to just create a div with an id="new".

And then, I'm going to add a data-role="page" just like we normally do.

And then, I'm going to add a title of New Note.

Then, I'm going to add a header, so div data-role="header"

and then inside of the header, I'm going to give it an h1

and we'll say New Note.

And then, let's create our content area inside of our new page.

So we'll give it a div data-role="content">

and there we have it.

Now let's add a comment marker here saying that this is our New Note Form.

Cool, so now that we've created a div with the id of New,

our New button should actually work as expected if we go back to our code.

So checking it out, flipping back.

So if we click this New button here, we're actually taken to our New Note form,

which is empty in the content area, but you can see our title works,

and it added a Back button so we can get back.

Notice we didn't have to add that--it was just something that's automatically created.

Now, the way it actually creates this sliding motion isn't exactly what I want.

I kind of want it to pop up and be more like a dialog and less like a page,

but we'll get to that a little bit later.

We can see it also works for this button here.

It's simply linking to the #"new" page right here.

So to create a form, all we need to do is create a normal form.

Now, its action and method aren't really important

because we're actually going to be intercepting it with a little bit of jQuery and Backbone,

but let's just add an action="#" because it doesn't really go anywhere

and method="post">.

Now, in a typical jQuery Mobile application,

you would actually want your action and method to go to the server

in the way you want it, and it actually works out really well.

It'll do an AJAX request, bring back the information, and do a cool page transition.

However, in our application, we're not communicating with the server--ever--

and we want to handle this all ourselves,

so we're going to actually be doing a little bit of magic to intercept our form submissions.

So let's close our form out and let's create our first field.

We want to create that field container to hold our label and our inputs,

so let's create a div with a data-role="fieldcontain".