I'd like to welcome you to your second Guice framework tutorial.

Today we're going to be going over the document windows class, which is what allows us to create a blank window for our app where we can change its appearance and size.

As I've said before, I'm learning Guice myself, so I'm going to be creating these new tutorials as I learn, and I hope that they're going to help you learn as well.

And because I'm just learning the Guice framework, I'm going to be a little bit more thorough with the way that I'm going through these classes and through these tutorials.

So I'm going to be basically trying to explain everything that I can rather than just throwing in random stuff.

So as I said before, today we're going to be going through the document windows class, and that's going to allow us to create basically a blank slate with maximize and minimize windows and close windows for us to create our application.

This is going to follow closely the Guice application window class tutorial that's on their website, and I'm going to link that below.

There's also a project that I'm going to link below as well that I've downloaded from the Guice website, and this is what I'm going to be following along with, and I would advise you to download that project as well and follow along so you can learn.

So I'm just going to open this project here, which is mainwindowtutorial.juicer.

So we're just going to go through just the steps.

I like to do a lot of repetition to try to get to know the workflow of something new.

So just going through opening the Pro Juicer, and we have our main.cpp file here.

So now we're just going to open it up in Xcode.

Okay, we're on Mac once again, so just going to wait for that to open.

Okay, so I've taken a look at this already and kind of gone through it, so I'm going to explain it to you the best that I can.

This may look like a lot to really take in, but trust me, when you break it down, it's a little bit more simple than it probably looks at first.

So first, we have a class called mainwindowtutorialapplication, which we can see inherits from another class called the Guice application.

This is just really what allows the Guice framework in your app to kind of start and shut down when it needs to shut down.

So it's just, you know, you're kind of overriding functionality.

So these functions here are just kind of your basic functionality for the Guice framework.

Okay, and then if we scroll down a little bit further, we see another class that's inside of this that's called mainwindow, which inherits from what we were discussing before, the document window class.

Okay, so what we're going to do first is we're going to just command click into document window, command click into this class here just so we can take a look and see the documentation on what exactly the document window class is.

Okay, so we're going to click in there, and I should mention that in my readings I've seen that what they say is that when you're creating a class within Guice, what you would normally do is inherit from a Guice class in this type of fashion, and that'll allow you to have the functionality that you need to do whatever you need to do, and then also to create new things as you need to add more scope to your class.

Okay, so here we go.

The documentation is really good in Guice, so we can see here that it just says that the document window class is a resizable window that has a title bar, maximize, minimize, and close buttons.

Okay, now if we scroll down just a little bit, we can take a look at the that we have our constructor here that has a set of parameters, so we're just taking a look at what those are about.

Okay, so here we have just an explanation here up above, so we have a name for our window, a background color, and then the required buttons.

Now, I found it really interesting the way that these buttons are set up, and it was something new that I learned, and I thought that I should just take a moment to just kind of go through that for other people that might not know.

So this approach that they are taking to adding certain buttons or taking them away is called a bit mask.

Okay, and I've just kind of typed this down real quick.

So if you know about bitwise operations, this is basically where instead of talking about numbers specifically, you're actually talking about the numbers as they're in binary and using these to actually create functions.

So that might sound a little bit confusing.

Let me see if I can explain a little bit better.

So if we look here, okay, and if we go back to thinking about numbers in binary, okay, if we just look here at this 0001, okay, that's one, that's the number one in binary, right?

So and then if we look at 0010, that's the number two in binary, and then four in binary is 0100.

Okay, and then seven in binary is 0111.

Okay, so if we just look over here to the left, the way that they've got these title button bars, title bar buttons, rather.

So you can see that the minimize button is would be button one, maximize button would be button two, close button would be four, if you want all the buttons, it would be seven.

Okay, which is a little bit strange, but I find it really interesting.

And so you can see that I shouldn't take too long on this, but I just found it really fascinating.

So you can see here that if it's just the one in the one spot, then it's just minimize, if it's just the one in the two, in the twos spot, then it would be the maximize button, and then just the one in the fours spot, then it would be just the close button.

But if it's all of them, then it's all the buttons.

Okay, so yeah, I just found that interesting.

And I'll link you to a tutorial video on bitmasks.

And yeah, it's the tutorial that I read in juice said that they use that quite often as well.

So something that you probably want to pick up if don't know it already.

Okay, so going back.

So we have the document window constructor, as I said before, okay, so it has a name.

Okay.

And then if we look, if we go back just above here, to our initialize, okay, so the applications initialization codes, that's what happens when the application first starts.

Okay, so we got main window equals new main window, get application names that so if I compile that right now, okay, and then um, so I'm just gonna compile that quickly here.

Okay, just waiting.

Okay, so we can see here that we have a window that's called main window tutorial, which is the same as my app name.

Okay, then we can see that it's it's 300 by 200, it was in the center of the screen when it compiled, and then set visible is the true which just means that it appears on the screen.

Okay, so let's just change a couple things here.

Okay.

So as I said before, this uses a bit mask to, to create the which buttons appear and which ones disappear.

Okay, so let's just try button number four, right?

Okay, there's a couple different ways that we can do this.

Okay.

So that's just the close button.

Okay, so we can we can call that two ways, we can either call it by just by just calling the number four.

Okay, so if I go back into documentation again, four is the close button.

Okay, it's not very intuitive, is it?

So probably a better way of saying it would probably be document window.

We got lost here.

Where am I?

So document window, all buttons.

Okay.

Okay, so let's see if that does it.

Great.

And now we have all of our buttons back.

Okay.

So we see that the background color is black.

Let's just change that.

So once again, we can just Command click into here, just see what options we have in terms of colors.

Okay, we can see all of these colors.

Let's just try lime green.

There we go.

Window with lime green background.

Okay.

We can change the size here.

Okay.

And now we have a bigger window.

Awesome.

Okay, so now, what we can do is we can just take a look to see what other functionality that we can get from from this window.

Okay, so the way that I want to do that is by just looking in the juice API itself.

Okay, so if we go here to the juice API, just the documentation.

Okay, so what are we looking for?

Okay, so we need to look in the document window class.

Okay, so we just go down here to D.

I know some of you might be like, oh, this is, you know, can you just go faster, but I really just want to go through this because this is something that was really useful to me and that I really needed to learn just to get into the kind of flow of how how this framework actually works.

Okay, so just bear with me.

So, so we got document window class reference.

Okay, so this tells us all of our all of our functions.

Okay.

And we can just scroll down here, see what other functionality that we have.

Right, so I've already looked through this didn't really see anything that looked really kind of, you know, that I could demonstrate really easily, but thought it'd be cool just to go down here.

So it also shows here what what other classes that is inheriting.

Okay, so we can see that it's inheriting from the resizable window class.

Okay, so it says public member functions.

So we can use some of these functions from resizable, the resizable window class and top window class.

So let's just click it.

If we click in here in this arrow, it'll show us what we can, what we can do here.

Okay.

So public member functions inherited from resizable window.

Okay.

So we got one here, set background color.

Okay, so let's, let's just try that real quick.

Okay.

So we'll just do set background color.

Okay, and then I'm going to do colors, just from just from what I see up here.

Okay, and then we got, we got a selection of colors here.

So it was lime green, let's make it back to black again.

Okay, let's see what happens.

Okay.

So there we go.

It's black again.

Okay.

So let's see if there's some other stuff that we can do quite easily.

Okay.

So we got this one set resizable.

Okay, so should be resizable.

I don't know exactly what that means.

So I'm just going to click in here.

Okay, I've already done this, but you know, this is just to help you out just to understand kind of the workflow a little bit.

Okay.

So we're just going to click in here, see a little bit more about the function itself.

Okay.

And then it gives a really good explanation on how that works.

Okay.

Whether it's resizable at all is the first parameter.

And these are two Booleans.

Okay, use bottom right hand corner resizer.

Okay, so resizing the window using the bottom right hand corner.

Okay, so let's just give that a try real quick.

So we got set resizable.

Okay, and I'm just going to put true and true again.

Just compile.

Okay, great.

So what we have is see if I put my mouse here in the bottom right hand corner, I can resize the window.

Pretty cool.

Okay, so that's great.

Okay, let's see if there's anything else I'll do.

I'll do one more here.

Okay, so if we go, let's go into top level window.

Okay, another class that the document window is inheriting from.

Okay.

And here's another one that I checked out.

That was from the juice tutorial set using native title bar.

Okay, so this means whether an OS native title bar will be used or a juice one.

Okay, so if we look right now at what we have at the moment.

So we see that this isn't the same as an OS X title bar, but we can set it that way if we want.

So if we just close out, and then we just put set using native title bar, that's a Boolean.

So we're going to put true.

Okay, and then just recompile. succeeded.

Okay, so now we can see that we have the native OS X title bar, which is really nice.

Okay, so, so this is where I'm going to stop.

And I hope that helps you out.

I'd love to hear your feedback.

So give me comments below and be sure to subscribe if you haven't already.

And the next lesson, we're going to talk about the component class and the main window component.

This is where we're going to put all of our sliders, and knobs, so on and so forth.

So hope you learned a lot.

See you next time.