Nexsys: Connecting the NavigationWidget to the Main Window

In the last window, we started connecting our UI components from our NavigationWidget class to itself to start with some of our basic file system navigation.

Now, we're going to connect the system up to the Main Window, to the actions that we had created on the window itself.

This is a little trickier - because while the navigation widget knows its own relationships, we're going to need to determine out of a multitude of possible navigation widgets, which one to apply the action to from the main window - its not as simple as just connecting the signal to a slot on the widget.

Nexsys: NavigationWidget Slots

We've started blocking in our interface pretty well - we're at least getting some of what we'd expect for a file browsing application - namely, we can see files.

But now we really have to get in there and start working with connecting up all the blocked in actions to some slots to do the real work.

Nexsys: NavigationWidget

While the Main Window is going to be the container for our filesystem browsing, the real heavy lifting is going to come from a separate custom widget - the NavigationWidget.

This tutorial will start us going through the creation of this smaller component that we'll then use inside of our main window.

By the end of this tutorial, your application should actually start navigating the folder system and look like this:

Nexsys: Running the Application

The last few tutorials have been almost entirely based in the Qt Designer, and with our Main Window now mostly complete, it's time to jump back into the code.

While each of those tutorials was long and may have taken a long time to go through (or maybe not, I don't know), the more you get into this workflow and become comfortable with the Qt toolset - the faster you'll be able to get those ui mockups done.

The next step though is to start putting that UI to use.

Nexsys: Main Window Ui (Part IV)

In this section we're going to finish up our main window by adding some icons to our actions, and then look into how to reuse them for a toolbar.

Nexsys: Main Window Ui (Part III)

At this point we have a pretty well blocked out interface for our main window.  There are still a couple more steps that we're going to do in designer before we jump back into the, to make sure we get the most out of our interface builder.

Nexsys: Main Window Ui (Part II)

Now that we have our menu's and actions flushed out, we can start adding in the main components to our central widget.

Nexsys: Main Window Ui

If you've made it this far, then you will know that our main window is really dull.  It pops up at random, doesn't load anything and generally is rather unimpressive.

This is where we start actually putting some information into our appliction and make it look like an actual application.

Nexsys: Main Window

 So we have the root package setup for the nexsys application.  Right now, it is not doing anything more than our Hello, World example however.  So the next step we're going to do is to create the main window for our application.

Nexsys: Starting a Full Application

So far, the tutorials we've been doing have all been single scripts, and isolated from each other.

Now that we have a basic understanding of what Qt is, we're going to go more in depth on the real power of what Qt can do.  We'll do this by starting to build a full application.

This is going to be the first of many tutorials designed to take you step-by-step through my thought process as I develop a new application using Qt.

PyQt Coding Style Guidelines (Cont.)

One of the aspects of developing consistent code is having a common naming style.  We talked about this for the Designer a bit in the last post - and we'll go into it a bit more in depth now.

PyQt Coding Style Guidelines

One of the most important thing a developer can do is develop clean, consistent, code.  Develop a style and follow it.  It will make reading your code much easier for other people, and even yourself, if you have to go back to something you wrote much earlier.

This is a series of coding standards that I follow when I develop PyQt applications - which is a mixture of the Python and Qt guidelines to try to make clean, consistent applications.  Coding style guides are often disagreed on, so take these with a grain of salt - I've thought about them a lot, but you may not agree with my reasoning...which is perfectly good.  The important thing is to develop consistency more than any one style.

Comparison of Loading Techniques

In the last tutorial we started working with Qt's Designer - which can greatly improve your coding workflow if you use it correctly.  It can also become very confusing for other developers if you don't cultivate a well organized structure to the way you integrate designer files into your project.

This tutorial will cover some tips and tricks that I've found make working with designer files, taking advantage of the power that is provided with Designer while keeping the code clean and easy to follow.

Introduction to Designer

The Qt Designer is a WYSIWYG (what you see is what you get) interface for laying out the widgets for your applications.

It allows you to drag and drop widgets onto your custom class and lay them out with minimal effort and 0 code. Your template will then be saved out to an XML based file (a .ui file) format that you can read into your application.

In this tutorial, we'll re-do our last code using Qt's designer to create our actions and link everything together.

Introduction to Layouts

Layouts are a powerful feature of Qt's GUI system - what they allow you to do is completely avoid having to deal with resizing logic.

If you have ever had to write your own code to determine how to resize the contents of a desktop application - you will be thrilled to never have to deal with that ever again.

This tutorial will take you through the basics of working with laying widgets out in Qt.

Introduction to Signals/Slots

So whether or not you realize it, so far all the examples we've worked through have been preparing you for event-driven programming.  The way that Qt is structured forces us into this model when working with widgets and their MVC (model-view-controller) system.

This is going to be an introduction to how that system works, becuase you should embrace their development paradigm as soon as you can, or you may end up fighting against it unnecessarily and banging your head against a wall.

Show vs. Execute

There are some important things to keep in mind when dealing with the difference between showing a window and executing one.

This tutorial will highlight some of those differences and how to protect yourself from unanticipated problems.

Dialogs, Windows, and Wizards - oh My!

Introduction to the Qt Gui Framework

Qt is a very large framework, and whie it extends into many aspects of software development, one of the most popular uses is as a desktop GUI application system.

In this tutorial, we'll look at the differences between the 3 main windowing widgets: the QDialog, QMainWindow and QWizard classes.

Hello, World

 Everyone's favorite topic...Hello, World.

So cliche, and yet, an obviously good starting point.

This tutorial will get you into the Qt world by having you create a very simple QApplication.

Getting Started

The focus of this blog will probably be mostly on Python, Qt and PyQt.

If you are sitting there and saying "What is Python, Qt, and PyQt?"  you'll probably want to do a little bit of background research before diving into these posts.  Otherwise - we'll jump through what these 3 different technologies are quickly.

A bit of background...

I suppose a bit of background on myself is in order...

My name is Eric Hulser - I've been working in the Games/Animation/VFX/Film industry for just about a decade now.  Ever since I got my hands on 3d Studio Max back in college, I've been hooked.  This blog will be a series of tutorials based on the experiences I've had and knowledge I've acquired over the years.