MovableType.org - Home for the MT Community tag:www.movabletype.org,2007-05-25://2 2008-11-19T20:20:41Z Professional Publishing Platform for Bloggers Movable Type Pro 4.23-en This is an XML content feed. It is intended to be viewed in a newsreader or syndicated to another site, subject to copyright and fair use. bugs.mt.org scheduled downtime tag:www.movabletype.org,2008://2.11350 2008-11-19T20:19:05Z 2008-11-19T20:20:41Z Just a quick heads up that our bug tracking system at:http://bugs.movabletype.orgwill be unavailable from 9am to 1pm (pacific time) on Friday Nov. 21st as we migrate it to a new data center. Apologies in advance for any inconvenience.... Chris Ernest Hall http://www.djchall.com
http://bugs.movabletype.org

will be unavailable from 9am to 1pm (pacific time) on Friday Nov. 21st as we migrate it to a new data center. Apologies in advance for any inconvenience.
]]> Hacking the UI to make Movable Type better tag:www.movabletype.org,2008://2.10754 2008-11-10T17:56:13Z 2008-11-10T18:40:39Z One of the great things about Movable Type is the multitude of ways it provides for folks to modify the core user interface without disturbing existing functionality. In fact Movable Type allows virtually anyone to: easily skin any screen in... Byrne Reese http://www.majordojo.com One of the great things about Movable Type is the multitude of ways it provides for folks to modify the core user interface without disturbing existing functionality. In fact Movable Type allows virtually anyone to:

And any developer to:

It is these systems that we can use to help prototype and test new functionality and concepts in a more agile way that allows us to be more responsive to the feedback we receive. Take for example one of our latest hacks: an improvement to the User Management area for a blog:

New User Management Screenshot

This new plugin, available to users of Movable Type 4.2 and greater provides an improved layout and design to the user management area. There is not a lot of added functionality under the hood... yet. That is of course where you come in: what kind of added functionality would you like to see? And what do you think of the new design? What additional changes would you like to see? What kind of activities do you engage in most frequently when managing your readers and members?

]]> What do you want to build using Movable Type? tag:www.movabletype.org,2008://2.10736 2008-11-07T23:25:42Z 2008-11-10T15:08:02Z Movable Type has a well earned reputation as an incredibly scalable, flexible and powerful publishing platform and is used by large enterprises, publishers and bloggers alike. Movable Type however was not designed exclusively for large publishers - Movable Type is... Byrne Reese http://www.majordojo.com Movable Type has a well earned reputation as an incredibly scalable, flexible and powerful publishing platform and is used by large enterprises, publishers and bloggers alike. Movable Type however was not designed exclusively for large publishers - Movable Type is in fact suitable for anyone wanting to create a web site, big and small.

To help our users build the next generation of popular, innovative and ground breaking blogs we have begun to invest heavily in one of the community's most critical resources: documentation. Movable Type's developer documentation has already received an enormous overhaul, and now we turn our attention to our documentation for designers.

In fact, our work has already begun on that documentation; but before we make too much progress, we wanted to first check with our community and see if we are covering the right concepts, tutorials and topics. We therefore invite you to check out our new Movable Type Designer Guide's table of contents and give us feedback on the set of topics it outlines for our new designer documentation. Do you feel it will leave any major questions for you unanswered? Do you wish it would just cover one more thing? Let us know, we want to hear from you!

We are also working on training materials and will soon be offering free webinars on Building Web Sites with Movable Type, just as soon as we work through and develop a solid curriculum. Check out the following preview of just such a training session:

If you are interested in attending a free webinar, let me know and I will let you know when we schedule our first session.

Do you have a passion or interest in our documentation? Want to stay up to date with our documentation project? Check out the following resources:

And finally, want to see the progress we have already made on our developer documentation? Check it out:

]]> Taking full advantage of template module caching tag:www.movabletype.org,2008://2.10420 2008-10-31T18:39:35Z 2008-10-30T18:56:16Z Movable Type offers a number of features to help administrators increase the performance of their system. Chief among them is template module caching. As the name may imply, any template module in Movable Type can have caching enabled, which causes... Byrne Reese http://www.majordojo.com Template_Module_Caching.jpgMovable Type offers a number of features to help administrators increase the performance of their system. Chief among them is template module caching. As the name may imply, any template module in Movable Type can have caching enabled, which causes Movable Type to store the output and HTML from the module in Movable Type's database for later use. That way, if a template module is used frequently, then Movable Type will minimize the number of times it goes to the database to generate its content.

To help our users take complete advantage of this important feature introduced in Movable Type 4.2, we have assembled the "Ultimate Guide to Template Module Caching." It comes complete with:

  • insight into why this feature can have such profound performance benefits
  • sample code
  • tips on what to look for when decided which modules to cache
  • a detailed explanation of how this feature can be used in conjunction with server side includes
  • information you may not have known about, like the ability to override the global cache context and create more granular and context sensitive module caches

We hope to make this guide the most definitive source for information about this feature, so if you have additions or ideas for how to make Ultimate Guide to Template Module Caching better, please let us know by leaving us a comment.

]]> Taking full advantage of template module caching tag:www.movabletype.org,2008://2.10418 2008-10-31T18:39:35Z 2008-10-30T18:54:11Z Movable Type offers a number of features to help administrators increase the performance of their system. Chief among them is template module caching. As the name may imply, any template module in Movable Type can have caching enabled, which causes... Byrne Reese http://www.majordojo.com Template_Module_Caching.jpgMovable Type offers a number of features to help administrators increase the performance of their system. Chief among them is template module caching. As the name may imply, any template module in Movable Type can have caching enabled, which causes Movable Type to store the output and HTML from the module in Movable Type's database for later use. That way, if a template module is used frequently, then Movable Type will minimize the number of times it goes to the database to generate its content.

To help our users take complete advantage of this important feature introduced in Movable Type 4.2, we have assembled the "Ultimate Guide to Template Module Caching." It comes complete with:

  • insight into why this feature can have such profound performance benefits
  • sample code
  • tips on what to look for when decided which modules to cache
  • a detailed explanation of how this feature can be used in conjunction with server side includes
  • information you may not have known about, like the ability to override the global cache context and create more granular and context sensitive module caches
]]> Making it easier to debug and test your templates tag:www.movabletype.org,2008://2.10408 2008-10-30T19:36:41Z 2008-10-30T18:39:24Z Sometimes there can be nothing more frustrating than trying to troubleshoot publishing performance. Often users must resort to the brute force method of debugging, such as: embedding print STDERR statements in Movable Type's source code - but how many people... Byrne Reese http://www.majordojo.com Sometimes there can be nothing more frustrating than trying to troubleshoot publishing performance. Often users must resort to the brute force method of debugging, such as:

  • embedding print STDERR statements in Movable Type's source code - but how many people know how to do that?

  • blocking out huge swaths of code using the <mt:ignore> tag to hone in on the root cause - a cumbersome and time consuming process.

  • turning on performance logging - a feature whose output was intended for machines and as a result is sometimes too verbose or difficult to read by mere mortals.

To help our users find a more elegant and efficient way to debug their templates and optimize their system, we have developed a simple tool that can more quickly and effectively help users hone in on those aspects of their templates that are the bottlenecks in their publishing system. The tool is a simple command line tool that outputs four very useful things:

  1. the output from the template itself - very the accuracy of the template's output yourself.

  2. a table of all the template tags invoked by the template - this table not only shows the template tag name, but also the average time it took to process each one.

  3. total build time and total number of queries executed - when trying to find the template at the root of your performance problem, this will help you to quickly identify the outlier.

  4. a table of all the SQL statements made during the publishing process - an effective way to find the actual query that is problematic.

Check out this sample output:

<template output omitted>
Template Tag Utilization:
.----------+----------------------+--------+---------+--------+--------+-------.
| Time     | Tag                  | Calls  | Avg     | SQL    | Hits   | Miss  |
+----------+----------------------+--------+---------+--------+--------+-------+
| 0.083    | entryassets          | 20     | 0.004   | 40     | 20     | 20    |
| 0.040    | entries              | 8      | 0.005   | 12     | 16     | 4     |
| 0.027    | assetproperty        | 16     | 0.002   | 16     | 0      | 0     |
| 0.020    | include              | 6      | 0.003   | 7      | 3      | 3     |
| 0.019    | categories           | 4      | 0.005   | 5      | 20     | 5     |
| 0.014    | assetthumbnaillink   | 4      | 0.003   | 4      | 4      | 0     |
| 0.010    | keyvalues            | 4      | 0.002   | 0      | 0      | 0     |
| 0.006    | collatesetfield      | 32     | 0.000   | 0      | 0      | 0     |
| 0.004    | setvarblock          | 28     | 0.000   | 0      | 0      | 0     |
| 0.004    | gridcell             | 8      | 0.000   | 0      | 0      | 0     |
                                   -- snip--
'----------+----------------------+--------+---------+--------+--------+-------'
  Total Queries: 86
  Total Build Time: 0.261901
.------------------------------------------------------------------+-----------.
| Query                                                            | Number    |
+------------------------------------------------------------------+-----------+
| RAMCACHE_GET ?                                                   | 63        |
| RAMCACHE_ADD ?                                                   | 32        |
| SELECT asset_id FROM mt_asset, mt_objectasset WHERE (objectasse- | 20        |
| t_object_ds = ?) AND (objectasset_asset_id = asset_id) AND (obj- |           |
| ectasset_object_id = ?)                                          |           |
| SELECT asset_id, asset_blog_id, asset_class, asset_created_by, - | 20        |
| asset_created_on, asset_description, asset_file_ext, asset_file- |           |
| _name, asset_file_path, asset_label, asset_mime_type, asset_mod- |           |
| ified_by, asset_modified_on, asset_parent, asset_url FROM mt_as- |           |
| set WHERE (asset_id IN (?))                                      |           |
| SELECT asset_meta_asset_id, asset_meta_type, asset_meta_vchar, - | 20        |
| asset_meta_vchar_idx, asset_meta_vdatetime, asset_meta_vdatetim- |           |
| e_idx, asset_meta_vinteger, asset_meta_vinteger_idx, asset_meta- |           |
| _vfloat, asset_meta_vfloat_idx, asset_meta_vblob, asset_meta_vc- |           |
| lob FROM mt_asset_meta WHERE (asset_meta_asset_id = ?)           |           |
                                   -- snip--
'------------------------------------------------------------------+-----------'

Using the tool is relatively straight forward: all you need to do is give the tool the ID of the template you want to debug, in addition to any other contextual information that template might need, e.g. a category ID if you are publishing a category archive. Running the tool with the conventional --help flag will tell you all of the possible options.

Keep reading behind the cut to learn more specifically how to use this tool.

]]> Example Usage

First, installation:

prompt> cp mt-tmpl-test /path/to/mt/tools

Now, how to get help:

prompt> cd /path/to/mt
prompt> perl ./tools/mt-tmpl-test --help
usage:  ./tools/mt-tmpl-test [template name]

    --blog <name>      Specify a blog context by blog ID or name.
    --template <name>  Specify a template to process by template ID or name.
    --category <label> Specify a category to process by category ID or label.
    --entry <title>    Specify an entry to process by entry ID or title.
    --author <name>    Specify an author to process by ID or username.
    --archive <type>   Specify a archive type.
    --profile          Enables SQL and template tag profiling.
    --debug <mode>     Sets MT's DebugMode.

And finally, how to actually use the tool:

prompt> perl ./tools/mt-tmpl-test --template=123 --profile
* output to appear here *
]]> Obtaining total transparency into your publishing system tag:www.movabletype.org,2008://2.10364 2008-10-24T18:36:51Z 2008-10-30T17:25:34Z Movable Type has proven time and time again that it can help some of the Internet's most influential and most innovative blogs become some of the largest as well. Not every content management system is up to the task of... Byrne Reese http://www.majordojo.com Movable Type has proven time and time again that it can help some of the Internet's most influential and most innovative blogs become some of the largest as well. Not every content management system is up to the task of publishing sites on this scale, but Movable Type is. One reason for that is that its publishing engine has tremendous flexibility in regards to how it can be deployed, allowing every site to fine tune its performance independently across as many machines as is necessary.

One critical component often used by these large sites is the "Movable Type Publishing Queue" - a simple publishing service to which the system can offload the task of keeping a web site up to date. This in turn dramatically increases performance, and improves the stability of the entire system by distributing much of the work a content management system must perform to a set of dedicated and distributed resources.

To give users the transparency and visibility into this critical system, we have begun work on a new plugin called Publish Queue Manager. This free and open source plugin provides its users with the following features:

  • view a list of all the jobs in their publishing queue.
  • see which jobs on the queue are currently being worked on.
  • see if any of the jobs on the queue have produced an error.
  • change the priority of any of the jobs on the queue.
  • delete jobs off the queue.

Publish Queue Manager screenshot

Of course, not every Movable Type user has a need to use Publish Queue, but those that do have come to rely upon the benefits it provides a great deal, which is why this plugin can be so useful to those users. So how do you know if you should be using Publish Queue?

  1. It seems to take Movable Type a long time to publish a single entry or new comment.

  2. Your readers leave a lot of comments, or your site tends to get a lot of comments submitted all at once.

  3. You utilize a lot of archive maps on your site, like Comment Feeds, Author Archives, Category Archives, Category-Monthly Archives, etc.

  4. You have one template on your site, like a large Google Sitemap, or a large archive listing that by itself takes a long time to publish.

  5. Your system is often publishing multiple comments or entries at the same time.

If you feel any of these apply to you, consider consulting our documentation on how to get started using Publish Queue.

Help us test the Publish Queue Manager Beta now by downloading it, installing it and letting us know what you think!

]]> Google Sitemap and Template Caching Tips tag:www.movabletype.org,2008://2.10300 2008-10-16T21:34:02Z 2008-10-16T21:43:01Z On a recent call with the Movable Type Community we discussed and shared tips on how to best take advantage of Movable Type's built in caching system. One of the tips I shared is something I have been doing on... Byrne Reese http://www.majordojo.com On a recent call with the Movable Type Community we discussed and shared tips on how to best take advantage of Movable Type's built in caching system. One of the tips I shared is something I have been doing on my personal site and on a number of customer sites with great success, and it relates to how to optimize the publication of a Google Sitemap in a sustainable way.

Google Sitemaps have become an essential tool for bloggers to help optimize their content for search engines, also known as SEO or "Search Engine Optimization." Google Sitemaps are files published by a web site that detail each and every page on the web site and give some indication as to the frequency they are updated by the system. This helps ensure that when the Google fairy visits your site to slurp up and index your site's content that:

  1. Google indexes all of your content, and does not overlook any content that might be orphaned on your site because no other page links to it directly.

  2. Google is able to schedule additional visits of the Google Fairy when your content is likely to be updated.

Anyone can publish a Google Sitemap for the Movable Type powered web site or blog using a template provided by the community. This template has a number of parameters in it that can be used to fine tune your sitemap specifically for your web site. The challenge rests however in publishing this file. For some large sites, publishing a Google Sitemap can dramatically slow down publishing, as Movable Type needs to load every single entry and page into memory while it outputs a monstrous XML file. Some of these files have known to grow larger than several megabytes.

You can mitigate the impacts of publishing a sitemap by following these simple steps:

  1. Create a template module called "Google Sitemap Include" and paste into it the template provided by the community.

  2. For your "Google Sitemap Include" module turn on caching and set the cache to expire once every 24 hours.

  3. Now, create an index template called "Google Sitemap" and paste into its body the following template code:

    <mt:include module="Google Sitemap Include">

What this does is result in a Google Sitemap being published only once per day. This keeps your Google Sitemap up to date, while only incurring the cost of publishing it once. Handy. Of course this technique could be applied to virtually any template that can take a long time to publish, but also doesn't need to be up to date on a minute-by-minute basis.

We share a lot of tips on our community conference calls, you should join us next time!

]]> The Little Things: Comment Replies tag:www.movabletype.org,2008://2.10290 2008-10-15T15:40:41Z 2008-10-15T15:57:10Z A lot of times, some of the most satisfying things about using Movable Type are the little touches that make managing a site easier or more convenient. One of those great, unheralded features that's been around since MT4's release is... Anil Dash http://www.anildash.com/ reply to any comment directly from the Movable Type application.

The feature is documented as part of our larger guide on Managing a Community with Movable Type, but since it's a handy shortcut, it's worth calling out on its own. Simply point at any published comment in a comment listing page in Movable Type, and you'll see a "Reply" link appear. (If you've set your display options for that listing page to "Expanded", you'll always see a Reply link next to the Edit link.)

Click the Reply link, and a simple window will pop up with the full text of the comment you were replying to, along with a big space for you to type your reply.

reply-to-comment.png
As soon as you click on "Submit", your comment will be published on the relevant entry or page. If you're using threaded comments on your site, Movable Type will automatically display your comment as a child comment of the one that inspired it.

There are lots of other ways to make use of this convenient feature, but this one should be a winner if you live in the Movable Type administrative interface all day and prefer to respond to your community from that familiar environment.
]]> Migrating from Right Fields to Custom Fields - the beta begins tag:www.movabletype.org,2008://2.10171 2008-10-03T23:09:30Z 2008-10-03T23:30:11Z Today we are happy to announce a public beta of a new plugin for Movable Type that helps users using Right Fields on Movable Type 3.x upgrade to Movable Type 4.2 using Custom Fields. There has been a great need... Byrne Reese http://www.majordojo.com Today we are happy to announce a public beta of a new plugin for Movable Type that helps users using Right Fields on Movable Type 3.x upgrade to Movable Type 4.2 using Custom Fields. There has been a great need in our community for this, which is why some of our veterans stepped up to assemble partial solutions to this problem. These solutions helped a great number of people, but were not able to address everyone's need universally, because the solution to this problem was not trivial. Recognizing this, we began a process with the community to identify and document what the ideal solution would look like. Then we implemented it so that users who felt they couldn't upgrade to Movable Type 4 could finally do so.

The plugin is called "Linked Entry Custom Fields" because the plugin does not exclusively help you migrate from Right Fields to Custom Fields. The plugin also provides your version of Movable Type Pro with an additional custom field type: linked entries. Linked entries, a feature native to Right Fields, provides a way for bloggers to establish relationships between related blog posts. You can imagine using this feature for example to help curate a list of related entries that you want to link to at the bottom of your post. So even if you have never used Right Fields, you may find some value in this plugin as well.

As with any beta, it is important for users to first make a backup of their system before beginning the migration and upgrade process. This is especially true with this plugin as there is a lot of data being moved around and there is potential for an unanticipated bug resulting in data loss. That being said, we would not be releasing this plugin now without having run a number of tests ourselves and feeling it was of sufficient quality to be released publicly.

To get started, visit the Linked Entry Custom Field page in the Plugin Directory.

]]> Sandbox for Movable Type tag:www.movabletype.org,2008://2.7495 2008-09-10T07:00:01Z 2008-09-10T06:23:27Z Ever thought about radically changing the look of your blog without much design work? Are you a designer who likes to work in semantic HTML and do amazing things with CSS? Maybe you’re moving from WordPress to Movable Type and... Beau Smith http://beausmith.com Ever thought about radically changing the look of your blog without much design work? Are you a designer who likes to work in semantic HTML and do amazing things with CSS? Maybe you’re moving from WordPress to Movable Type and want to keep your current design. Sandbox for Movable Type may just be what you’re looking for.

What began as a hackathon project of between Bryan Tighe and myself a little while ago has yielded some great results: today we’re releasing Sandbox for Movable Type as a plugin that allows the many Sandbox themes to be used on Movable Type blogs as well. (BTW, Hackathons—the ability to spend every Wednesday scratching our own itches—are one of the reasons why I love working at Six Apart. The Vanilla Template Set was another of my recent Hackathon projects.)

Sandbox is similar to the CSS Zen Garden in that it showcases the power of CSS—the ability to radically transform the look of a site without changing any of the underlying HTML. Movable Type has always supported this concept. Tools like the Movable Type Design Assistant have made it much simpler to customize the look of your Movable Type blog through CSS alone. And this concept and philosophy is also why we supported The Style Contest, which not only succeeded in producing over 150 new designs to style Movable Type’s default templates, but also in rewarding the awesome designers behind each of the winning designs.

Scott Wallick and Andy Skelton created Sandbox as a theme for WordPress and it has since been used as the base for many blogs over the last few years. At its core, Sandbox is a rich and semantic—yet simple—HTML structure with many unique CSS classes throughout in order to make it simple for non-designers to easily make small design adjustments to an existing Sandbox theme. More experienced designers can even radically change the look and structure of a blog using CSS alone. Using the dynamically generated classes, themes can even style the site differently each hour of the day!

This well-thought-out structure has attracted many web designers and developers to create themes for Sandbox which other can then use as a starting point for their own customizations to suit their individual needs. (Though Scott points out that his site uses purely unmodified Sandbox html!)

Here are three of our favorite themes showing off the flexibility of Sandbox… and remember that all of these designs use the exact same HTML templates!

  • Essay by Ian Stewart

    Essay (Sandbox Theme Screenshot)

  • Takimata by Robert Ellis

    sandbox-takimata.gif

  • Blackbox by Hillary Louise Johnson

    sandbox-blackbox.gif

  • Diurnal by Carolyn Smith

    Diurnal is a great example of a theme using Sandbox’s ability to change appearance based upon the time of day. Diurnal has different styles for sunrise, morning, afternoon, sunset, and night which you can see across the top of this screenshot:

    sandbox-diurmal.jpg

And we owe a huge thanks to the designers of all of the variations of Sandbox that we’re making available. Here are their names and the designs they’ve created — be sure to check out their sites and show your appreciation for their work!

Installing Sandbox on Movable Type 4.2 is pretty easy. Sandbox requires that you have PHP setup on your web server in order to create dynamic classes; this should be easy as nearly every host comes standard with PHP out of the box these days.

The Sandbox plugin also ships with a newer version of StyleCatcher (the Style selector within Movable Type), making it simple to switch between different Sandbox styles. Installation instructions for Sandbox and StyleCatcher are included in the plugin, though if you’ve installed a plugin before it should be a snap.

sandbox-stylecatcher.jpg

We’ve shipped all the winning themes from the Sandbox Design Contest and a handful of other Sandbox themes. You can also install other themes from the Sandbox Design Contest with Sandbox for Movable Type or create your own Sandbox theme

Download Sandbox for Movable Type from the plugin directory and please let us know what you think and how we can make it better.

]]> FogBugz reorganization tag:www.movabletype.org,2008://2.7325 2008-08-25T22:48:18Z 2008-08-25T23:01:23Z Just a quick note to say that now we have shipped MT 4.2, we are tweaking the way we organize the MT FogBugz instance. Since we launched the open-source project with MT 4.1, we've had two projects that have held current... Chris Ernest Hall http://www.djchall.com FogBugz instance. Since we launched the open-source project with MT 4.1, we've had two projects that have held current MT cases, MT Internal and MT Open Source. MT Internal corresponded to the packs and any other proprietary non-OS code, while the MTOS project held cases that involve the code that is GPL'ed. The MTOS project was visible to anyone with an account in fbz, while only Six Apart employees could see MT Internal.

The problem with this approach was that there were some MTOS cases that shouldn't have been public (because, for example, they might have a user's email address or other sensitive information, or relate to security vulnerabilities that had not yet been publicly disclosed) There are also many cases that are MT Internal that non-Six Apart employees should be able to see, like bugs and patches that impact enterprise consultants and developers.

Going forward, instead of MT Internal and MTOS, the MT fbz instance will instead have two projects, one public and one private, both of which can contain bugs in both the open source and proprietary portions of the product. To reflect this change, the MTOS project name has been changed to "Movable Type-External." 

This shouldn't change too much for the MT community, but it means that if you wish to enter a bug report for the Pro or Enterprise components of the product, you can do that directly instead of filing a case in the MTOS project, then having the case seemingly disappear when it was moved to MT Internal. 

If you have any questions or concerns about these changes, or anything else relating to MT case management process, please let us know in the comments to this post. 
]]> Connecting mixi Users with Movable Type Communities tag:www.movabletype.org,2008://2.7273 2008-08-22T16:40:32Z 2008-08-22T16:41:31Z As we started to show with Movable Type Pro last week, blogging is evolving to encompass the world of social networking and connect to the rest of the web; merging publishing with community. Since the release of Movable Type 4.0... David Recordon http://www.davidrecordon.com/ As we started to show with Movable Type Pro last week, blogging is evolving to encompass the world of social networking and connect to the rest of the web; merging publishing with community. Since the release of Movable Type 4.0 last year, we've built in native support for technologies like OpenID and now OAuth, to make it even easier for people to bring parts of their profile with them when they come to your blog. Last month we demoed integration of Facebook Connect with Movable Type which continues to make this vision a reality, though it isn't enough to integrate with just one social network.

mixi is Japan's most popular social network (one in five Japanese web users use mixi) and earlier this week they launched support for OpenID. Six Apart's Japan team participated in this launch and we are now shipping a plugin to make it easy for mixi users to interact with Movable Type powered communities. The mixiComment plugin brings the community of mixi to your site, giving commenters an even better experience by signing in using their mixi OpenID. Even better, the user interface takes advantage of new features in OpenID 2.0 so that normal people don't even need to know what OpenID is; instead just click a button to login with their mixi account. Just like Facebook Connect, this makes it easier for a wide range of people to participate on your site by being less work for them to sign in while allowing them to bring pieces of their profile with them all over the web.

mixilogin.png

mixiComments.png

You can download the mixiComment plugin from our plugin directory and easily add support for the largest social network in Japan to your blog.

]]> Important Update: Movable Type 4.21 now available tag:www.movabletype.org,2008://2.7271 2008-08-21T23:11:23Z 2008-08-22T16:21:11Z In recent days two significant issues in the Movable Type 4.2 release were reported by our community. One of these bugs can potentially result in some form of limited data loss, and the other could cause loss of some configuration... Byrne Reese http://www.majordojo.com In recent days two significant issues in the Movable Type 4.2 release were reported by our community. One of these bugs can potentially result in some form of limited data loss, and the other could cause loss of some configuration data in some circumstances. We have reproduced these issues as quickly as possible, and created patches to remedy the problems. Most users are not at any risk from these issues, but here are the circumstances under which you may have been affected:

  • Custom fields data. If you are upgrading from Movable Type Commercial or Enterprise 4.1 to Movable Type Pro or Enterprise 4.2 and you are using custom fields on any object in Movable Type and there are more than 100 rows in the table for that object, some of your custom field data could be lost in the migration.

  • Archive mappings. If you create a new blog on your Movable Type 4.2 installation and you delete an archive mapping from one of the archive templates, this action will remove the rest of your blog archive mappings inadvertently.

Both of these issues have been fixed and verified by our quality assurance team. The fixes can be found in the newly released Movable Type 4.21, a free update for all users of Movable Type 4.2. If you've downloaded 4.2, but have not yet upgraded, please download 4.21 first and then upgrade.

As always, please make a backup before performing any system update or upgrade.

To the best of our knowledge, only a very small number of people have been affected by this bug. To those people, we offer our sincerest apologies for any inconvenience or frustration. We work our hardest to prevent issues of this sort. It's thanks to our community that we've been able to find, fix, and respond to this issue so quickly. We appreciate your participation, and we thank you for using Movable Type.

  • If you're using a paid license of Movable Type Pro: Sign in to your account to download the update.
  • If you're using the free Blogger license of Movable Type Pro: Grab the code from movabletype.com.
  • If you're using Movable Type: The open source download is right here.

As always, Enterprise customers and licensees will be personally contacted by a Six Apart account representative.

]]> Creating Drop-Down Navigation with Movable Type tag:www.movabletype.org,2008://2.7199 2008-08-16T16:09:54Z 2008-08-16T17:20:43Z A common question from Movable Type users and designers is, "how do I create nice navigation for my web site?" The Professional Website template set and even Mid-Century have navigation build in. But there are Movable Type themes out there... Byrne Reese http://www.majordojo.com A common question from Movable Type users and designers is, "how do I create nice navigation for my web site?" The Professional Website template set and even Mid-Century have navigation build in. But there are Movable Type themes out there that don't have this feature and users want to know how to add it. This brief tutorial will show you how.

The Objective

The goal of this tutorial is to demonstrate how to add category driven drop-down menus to your web site that approximates the look and feel below:

Drop Down Menu Navigation

What does this mean? Well, there are lots of ways to build navigation for a site. The method you will choose depends largely upon your content and implementation strategy. This methods are:

  • category driven navigation - using category and sub-category names as the menu and menu item names
  • page driven navigation - using page names as the menu and menu item names
  • folder driven navigation - using a hierarchy of folders (folders contain pages)

This article will focus on creating menus based upon your category hierarchy.

]]> The HTML <head>

This example utilizes MooTools for the javascript that powers the fancy pull-down nature of the menus. You will need to download and install mootools.js into a js directory. Then you will need to link to the javascript in the html > head of your document like so:

<script src="/js/mootools.js" type="text/javascript"></script>

The CSS

#nav, #nav * {
        margin:0;
        padding:0;
        list-style: none;

}
#nav {
        height: 30px;
        font-weight:bold;
        font-size:14px;
        line-height: 30px;
        margin:0px 15px;
        border:1px solid #ddd;
}
#nav li {
        line-height: 30px;
        float: left;
        list-style:none;
}
#nav li a {
        color: #666666;
        display: block;
        padding: 0 13px;
        font-size: 11px;
        font-weight: bold;
        font-family: Verdana, Arial, Helvetica, sans-serif;
        line-height: 30px;
        border-right:1px solid #ddd;
}
#nav li a:hover {
        text-decoration: none;
}
#nav li ul {
        position:absolute;
        left: -999em;
        width:15em;
}
#nav li:hover ul, #nav2 li.sfhover ul {
        left:auto;
        z-index:10 !important;
}
#nav li ul li {
        display:block !important;
        width:15em;
        border:1px solid #ddd !important;
        border-top:none !important;
        background:#fff;
}

The JavaScript

Once MooTools is "installed" you need to add the magic sauce that triggers the pull down menus. This should also be in the html > head of your document. Just cut and paste the following into your header:

<script type="text/javascript">
sfHover = function() {
  var sfEls = document.getElementById("nav").getElementsByTagName("LI");
  for (var i=0; i<sfEls.length; i++) {
    sfEls[i].onmouseover=function() {
      this.className+=" sfhover";
    }
    sfEls[i].onmouseout=function() {
      this.className=this.className.replace(new RegExp(" sfhover\\b"), "");
    }
  }
}
if (window.attachEvent) window.attachEvent("onload", sfHover);
</script>

The Template Code

Finally, you need the template code that produces the actual menu:

    <ul id="nav">
    <mt:TopLevelCategories>
      <mt:SubCatIsFirst><mt:HasParentCategory><ul class="children"></mt:HasParentCategory></mt:SubCatIsFirst>
      <li class="cat-item">
      <mt:IfNonZero tag="MTCategoryCount">
          <a href="<$MTCategoryArchiveLink$>"<MTIfNonEmpty tag="MTCategoryDescription"> title="<$MTCategoryDescription$>"</MTIfNonEmpty>>
            <$MTCategoryLabel$> (<$MTCategoryCount$>)
          </a>
      <mt:Else>
          <$MTCategoryLabel$>
      </mt:IfNonZero>
      <mt:SubCatsRecurse>
      </li>
      <mt:SubCatIsLast><mt:HasParentCategory></ul></mt:HasParentCategory></mt:SubCatIsLast>
    </mt:TopLevelCategories>
    </ul>
  </div><!--/nav-->
]]>