Ben’s pculture blog

This week I worked on a bunch of small to medium issues with trunk.  It’s pretty hard to categorize things because they were all over the place.  One day I spent a bunch of time working on OS X issues, one day I worked on getting the progress throbber to work an animate, etc.  I guess the best way to put it was that I had a bunch of issues that had piled up over the last few weeks and I tried to get as many of them done.

This week I hope to finish up on a couple smaller things, then take on some larger ones.  I think some work needs to be done on the preference window, and I also want to work on channel settings.

This week I had intentions to implement a ton of features, but I got fairly stuck working on searching inside a channel.  It was easy enough to add a search to some of the views, but to make it work in the static tabs, the channels and the playlists at the same time without a lot of hacks was not very easy.  In general that code seemed very complicated and slightly convoluted, so I decided it was time to refactor.

I ended up splitting the module into 3 different ones, each one handling an aspect of MVC.  itemlist now only handles modeling the data — storing lists of items, filtering them by search terms, sorting them, etc.  itemlistwidgets was created that just had a bunch of “dumb” Widgets that would display things to the user, but only handled the presentation logic.  Finally itemlistcontroller had classes thta handled the rest of the logic, responding to user input, handling updates from the backend, etc.

All in all, I’m pretty happy with the new code.  It definitely made it much easier to implement searching, and I think sorting shouldn’t be much of a problem either.  I’m not all that happy that I took a week to implement a relativetly simple feature, but I guess that happens sometime.

This is a double weekly summary because last week I was in Worcester for the Miro Summit.  I thought it went pretty great, it was very nice to finally meet Will, Paul and Jason for the first time and it seemed like we got some important things done.

For the most part I’ve been working on UI tweaks on Miro.  In Worcester Will and I knocked down a bunch of them and I’ve gotten to a bunch since.  I forgot how nice it feels having a huge list of fixed bugs, even if each individual bug isn’t that impressive.

This week I’ve been mostly working the fallout from the show details patch.  Chris has been working on this for a while and it’s nice to have it finally in (go Chris!).  I did a small bit of tweaking on the GTK side of things, then I implemented it on OS X.  It was working as of yesterday, but the added complexity to the items really slowed things down on OS X.  I have several un-checked-in changes that help things, I think I’m going to try to find a few more changes and check it all in today.

This week I’m not totally sure what I’m going to work on.  I have several crashes on windows that I could investigate, but maybe it would make more sense to tackle one of those big missing features that we want to implement before we are going to ask for a lot of testing on this.  I’ll take a look at Will’s list and see if there are things I can take on.

This week wasn’t so productive for me.  I got sidetracked by a bunch of stuff from my personal life.  However, I did get to work on a lot of windows build stuff.  First of all I think the docs are pretty much up-to-date.  I also upgraded xulrunner to 1.9-final.  I fixed some random problems with missing DLLS and the Miro_Dowloader.exe not getting install.  Finally, I added pretty icons to the .exe files.

The other thing I did was work on video playback for windows.  It looks like it’s working to me, although I don’t have sound on my VMWare machine so I couldn’t test it.  It seem more stable than before.  While I was testing things I closed miro while video was playing many times without any problem.  Before that would give me segfaults a good percent of the time.  It also closed pretty much instantaneously which felt better to me.

I’m not exactly sure what I’m going to do this week, but I don’t think it’ll be an issue.  Probably I’ll just got the WidgetsTodo page and pick something random.  Also, I may spend a day cleaning up video playback on GTK.  I’m super excited to finally make it to Worcester and see folks in person.

This week’s update is short and sweet.

This week I worked on re-implementing lots of widgets stuff.  First I worked on context menus, then I worked on playlists, I think both of those things are fully functional now.  Lastly, I got video playback working on linux using Luc’s new improvements.

I don’t have a lot to say about that stuff, except it seems like trunk is getting more and more usable by the second.  In fact, nowadays it seems usable enough for my personal use.

This week I’m going to be working on windows stuff more now that I have a working VMWare image.  First up is getting the build docs up-to-date and making playback work again.

So I haven’t written a blog post in a while.  The reason has been that, after the mad dash to get the widgets branch merged into trunk, I took a vacation for about 2 weeks.  I had been working like crazy trying to get the widgets working and I definitely needed a break.  I started working again this week in the wonderful new era of widgets.  It looks like folks had gotten up to speed with the new code while I was away and gotten some good work in as well.

I started out working on getting the add channel buttons to work with miro guide again.  I though this was going to be a relatively easy bugfix, but I quickly realized that it there was a ton of extra code that went with it.  In addition to subscribing to channels, I implemented downloading videos from channel guides and subscribing to new channel guides.  Of course, that also meant that I had to implement displaying external guides too.

Once I got done with that I fixed a bug that had been annoying me for a while.  When I deleted a channel folder miro would crash every time.  Also I fixed building the windows installer.

Finally I implemented video playback on linux. It wasn’t too hard since Luc had done the portable work.  I went to implement it on windows then my VMWare image crashed..  Bummer.  I guess I’ll try to get that working next week.

Overall I’m pretty excited about the state of trunk.  Now that you can subscribe to feeds and play them back, it seems like miro is a real application again.  Of course there’s lots more work to do, but we’re almost at a state where I can use miro for myself again without feeling like I’m jumping through a ton of hoops.

This week I started off by trying to get the item list to render.  Several times along the way I decided that the rendering an item was way too complex for the tools that we had, so I developed some new classes to try to simplify things.

A lot of them had to do with laying out things and in particular laying out things without something to draw to.  I made a class to handle text layout that’s sort of a trimmed down version of pango or NSLayoutManager.  Also, a Font class that gives a few metrics.  A Button class to size native (or non-native on windows) buttons.  And finally a Layout class, which gives a higher level interface to all of the above.

The buttons are working out pretty cool.  On OS X we use a NSButtonCell, so it’s as native as you can get.  On GTK we get the user’s current style then use it to render buttons — I’m pretty sure this is what Firefox 3 is doing.   You could argue that this is not quite “native”, but I can’t tell the difference.  On windows we just render our own, which you could say is native for that platform

I got buttons working around Thursday.  On Friday I had to take a trip to DC.  It seems like a lot of folks were talking about git-svn, so I decided to give it a try.  Fetching the source from subversion was a pretty awful experience, but after that things were pretty awesome.  I was committing changesets while driving down route 15, then checking them in to our server when I got an internet connection.

The last tool I developed was a box-packing system for rendering cells.  For a while I was trying to calculate things by hand, but the layout there is really too complicated for that.  Now we use some basic hboxes/vboxes and alignments and it works pretty well.  I’m feeling like the system that is in place now is basically what we need and it’s only going to need tweaking rather than creating new stuff.

The last thing I did was add download progress bars.  They are still a work in progress, but when I first saw the info updating every 0.5 seconds it made me want to jump for joy.

The first part of the week I spent working on the finishing touches with the tab list. I did some more backend changes on OS X, then workeded on adding the playlist list and the static tabs list. That went pretty smoothly.

After that I started working on the right hand side. I started working on code to handle switching displays in and out there, but there’s still more work to be done there. Mostly I started working on rendering items in the display. I got pretty far in that before I realized how badly we would interfact with some linux themes.

At that point I sent out an email to the list and tried to come up with some ideas on how we can work things. After thinking about it for a while, I decided to try this system:

1) Whenever the style gets set on our Window object, we check to see if we think our style is compatible with the user’s theme. Right now it’s fairly braindead. It just checks if the background is white or a really light shade of gray. If the check fails, then we don’t modify the style for widgets, and we don’t mess with the background for a widget in the custom drawing code. We do still draw things like the bubbles next to the feed tabs though.

2) When we draw things we pass in the current background color and text color to the drawing code. This lets us use the right color for the theme’s background. It especially helps when the user has a tab on the left-hand side selected.

It’s not the most elegant way of dealing with themes, but it works fine with all but one of my themes on Ubuntu.

The last thing I worked on was text handling. The initial motivation was to deal with the user changing their system font size. Then I realized that we would have to deal with resizing things based on the current font settings. Finally I realized that our text system could be really improved by adding some simple layout management similar to NSLayoutManager or PangoLayout. I just finished that today.

Next week I’m going to keep working on the item list. I think that I’ve finally dealt with all the side issues and can just work on getting everything to look good. I’m also going to be helping Andrew figure out the new system so that he can tweak things here and there.

I keep feeling psyched about the widgets branch. Take a look at this screenshot showing of it resizing the interface based on the user’s large font size. Still need to work on the video controls, but oh well…

This week I spent the entire time working on the tablist and more generally the table API.  I got drag and drop working after a day or two, then I spent almost all of the rest of the week changing the way we access the data that goes in our TableModel classes.

In some ways that means that I didn’t get much done, but I just kept thinking how important it is that we get a things working really fast.  We want to support things like rendering a feed with 1000 or maybe even 10,000 items in it, so there’s a lot of motivation to make sure that we have fast data structures in place.

The main problem is how access each individual row.  I started using the equivelent of GTK’s RowReference class.  This is like an index that gets updated whenever a row gets added or removed.  It’s probably the simplest in terms of what the programmer has to think about, but it’s quite inefficient since we need to update them whenever things are inserted or removed.  The next try was using Tree Paths, which is basically just an index that doesn’t get updated.  This was probably an improvement, but then I realized that GTK implements it’s model classes with linked lists and whenever we used one of the tree paths we were iterating through the list.  So if we wanted to access each row in the list it was O(n^2) time, which is shameful.  Finally I settled on an using Tree iterators, which is basically a pointer to a node in a linked list.  This is the fastest way to access things and I realized that, like RowReferences, they don’t get invalidated when other rows are added/removed.  So it seems like definitely the way to go.

I may spend one more day trying to work on the model classes on OS X.  Unlike GTK we have to roll our own there and the current design could use a couple improvements.

The other thing I did this week was work on those startup tweaks that we talked about.  I made it so that we don’t re-download thumbnails on startup and implemented a queue for updating feeds.  Both changes seem to be working ok so far.

This week I hope to get a lot of visible changes to the widgets branch.  Now that the behind the scenes table code seems pretty complete it means I can work on the fun part of rendering things.

Last week I worked on getting the tablist to work right.  I would say I’m about 90% of the way through it.  I have the channel tabs almost working, the only thing needed is drag and drop.  Once I implement that, then I’ll work on getting playlist tabs and the static tabs, neither of those should be very hard since at that point all the platform-specific code will be in place.

One interesting thing is that the more I work with the widgets branch, the more I realize that once we switch over we can simplify the database a lot.  For example, when I was working with drag and drop, I realized a lot of the book-keeping we do in the TabOrder views can just be thrown out.  Also a lot of the data that’s setup in onRestore() isn’t needed anymore (like if a feed is blinking, or if it’s parent is expanded).  I really like that since it can simplify moving to not having the database in memory.

Next week I’m going to finish up on the tab list, then I guess I’ll move to the items list.