After talking to one of our engineers about the problem, it was suggested that I just restore from the Time Machine backup.  I haven’t been too familiar with Time Machine in the past; however I figured I would investigate doing this.  After a few minutes on the Apple support site I was convinced that this would work and I was relieved to know that I wouldn’t have to spend hours installing software and searching for the little things, such as the fonts that were installed on the system before the crash.

It took me a bit to locate the OSX disks, as they were stored away, after the move to Softwyre’s awesome new office.

Once I started the system recovery, I realized that I have never used a recovery system that is so user friendly.  With a few clicks of the mouse the system took care of the rest.  Sure it took a while to recover everything, but Time Machine saved the company and me, hours of manual work.

In conclusion, I must say that this has taught me the beauty of backups.

Are you sure you are backing up?  If not, Contact Hardwyre/Softwyre, we back it up!

Overriding Components with Specific Hooks

Okay, let’s say we’re building a table to display data for the front or backend of a component.  First we need to have the foresight to realize that having too much data on the page is bad and that we want some pagination.  Since we’re skilled Joomla! developers (or we’d like to think we are), we know that Joomla! packs pagination capabilities we can draw upon in the JPagination class.  Check it out in /libraries/html/pagination.php if you haven’t seen it before.

Fast forward a bit and we’ve built our table to use JPagination and it’s great… except we don’t like the output and we’d like to rearrange to look a little nicer.  Well that’s not a problem at all.  If you took the opportunity to poke through JPagination, you probably noticed this little block of code:

$chromePath = JPATH_THEMES.DS.$mainframe->getTemplate().DS.'html'.DS.'pagination.php';
if (file_exists( $chromePath ))
{
	require_once( $chromePath );
	if (function_exists( 'pagination_list_footer' )) {
		return pagination_list_footer( $list );
	}
}
return $this->_list_footer($list);

What this block of code is doing is essentially saying that if /mytemplate/html/pagination.php exists and it has a function called “pagination_list_footer” then call that to display the output.  Otherwise call the default class’ “_list_footer” function.  All we need to do in this case to get a custom display is create that file and function.

Overriding Component Templates

Overriding components with hooks is rough because many times we don’t know the hook exists.  Until I sat down and looked through JPagination, I had no idea there was a hook there for an output override.  Unlike those, overriding templates is much easier for us thanks to the great way template files are implemented.

Let’s look at the directory structure for article of com_content as that is a piece which we will likely want to override fairly often.

- /com_content
  - /helpers
  - /models
  - /views
    - /archive
	- /article
	  - /tmpl
	    - default.php
		- default.xml
		- form.php
		- form.xml
		- pagebreak.php
		- pagebreak.xml
		- index.html
	- /category
	- /frontpage
	- /section

The important things to notice here are the contents of the tmpl directory as those are the pieces we can override.  default.php is the main file we’re interested in as it controls the display of all articles.  In order to override it, we need to place an override file in our template.

- /templates
  - /ourTemplate
    - /html
	  - /com_content
	    - /article
		  - default.php

Once this file and directory structure are in place, Joomla! will call our default.php file when it renders an article.

Overriding Module Templates

This is really no different from components but we should go over it because the module directory structure looks a little bit different (but not too much so).  For this example, let’s say we’re going to override mod_mainmenu.  First, we find our template file.

- /modules
  - /mod_mainmen
    - /tmpl
	  - default.php
	  - index.html

Next we copy default.php over to our template like so…

- /templates
  - /ourTemplate
    - /html
	  - /mod_mainmenu
	    - default.php
		- index.php

And that’s it.  We can modify the template default.php and see the changes on the website as Joomla! will prefer that one to its own.

Jerry at The Print Shop really considers printing an artform and is very careful about putting everything in the right place. He has a strong attention to detail.

Well, now it’s onto the letterhead.

Choosing between the two isn’t so very difficult, it’s just a matter of picking out the strengths of each and deciding which of them you will take advantage of.

Module Strengths

Multiple instances on page. Sometimes there is a need to show things multiple times on a page and for modules this is as easy as copying a module, changing the position of the new one, and enabling it. Good examples of modules that can take advantage of this are Joomla!’s mod_banners and mod_mainmenu as you may often want to display ads in various positions on the page or use secondary navigation such as a footer menu in addition to your main menu.

Coexists with components. Modules do not overwrite the component so you can easily display module contents such as banners and menus alongside components such as com_content which provides your articles.

Smaller than components. Modules are, quite simply, easier to build than components. There are fewer files to work with and their use and implementation are fairly straightforward. In my experience, you write a module to gather some kind of data from a database and display it.

Component Strengths

Administrative functionality. Modules have limited configuration ability granted by their parameters however components may have very rich backends with robust feature sets that usually center around full CRUD operations on Joomla!’s database.

Diverse views. While the module can parse the request URL and produce different views based on the input provided, the structure for this functionality is better presented in the form of a component as the framework is already there.

Direct menu linking ability. As components form the content of the page with the template and usually with modules surrounding it, they also provide you the ability to directly link to it. Something worth noting here is that you do have the option of embedding a module position in an article thus getting a unique page with this module.

In structure, it’s sheer brillance as the letter thickness and spacing are spot on. They really take advantage of the horizontal line passing through the entire wordmark, starting with the H, moving 3 E’s and flying out symmetrically from the G. It looks really good on the printer itself, popping off of the side of it with the thick bold lettering. It makes me wish we were doing a website redesign for them. I could really make that logo stand out on the page. Currently it’s been pushed to the far right on their current site, which is a real shame. Hopefully their next site will take advantage of what is, in my opinion, a very solid logo that will be great for many years to come.

[another iPhone entry]

Another example: I am in the process of looking for a new home, I started looking for mortgage calculators online. But then i figured that there had to be one for the iPhone. Turns out there was and now I own Loan Shark ($4.99). Well, actually it’s on sale for $2.99 at the moment. Darn. Not only does it take care of the mortgage questions, but it does car and personal loans as well. All in a nice, slick interface.

And actually, this kinda thing has happened quite often, and thanks to the fact that you can download entire apps via 3G, I can immediately take care of the problem. Whatever has come up, there seems to be an app for it. And as I discover more apps, I plan to tell you about them, so stay posted.

I love the development community that Apple has built. So far it’s really paying off for the developer AND the end user.

- jrsr

Now let’s say you and I are building a Joomla! component. We want the people using it to regard it as polished. We want the component to look as good as it works. We already know it will work amazingly well because we’re the ones building it (and we’re awesome) so let’s focus on making it look at little better. An easy way to make a component look a little more stylish is by adding a custom menu image. For example, let’s have a look at this screenshot:

We can easily notice that DOCman has its own custom menu image while the rest have the generic Joomla! component image. It looks pretty good and really stands out compared to the rest. Of course, if we make our own component, we end up with it looking like this:

Well, we have a component but the image is the Joomla! generic one. We need to figure out how to change it to a custom image which might be tough but we already have a great example in DOCman so we’ll analyze where the image comes from and how DOCman got its image there to do it ourselves.

We need to know where the image is coming from and the answer lays within the jos_components table. Among all the various columns in the table, we find the column called “admin_menu_img” and that’s exactly what we’re looking for. All the generic ones have “js/ThemeOffice/component.png” while DOCman has “http://blahblahblah/administrator/components/com_docman/images/dm_documents_16.png” in its field.

Now that we know where the image is coming from, the rest is pretty easy from here (because we’re awesome). We need two things: a query to put our image in that field and a way to call that query during installation. To understand how to do the first part properly, we must understand the second.

Joomla! has a section in its installer.xml marked with “” which represents files that will be called during installation. These allow you to do fun and interesting things like what we’re doing. First let’s make a file and put it in there.

In the install.xml:

<installfile>install.com_catliketyping.php</installfile>

Next we create our file in the admin folder and our image in the images folder. The folder structure should look about like this:

com_catliketyping > admin > install.com_catliketyping.php
com_catliketyping > admin > images > softwyre_16.png

Now let’s fill in our php install file:

<?php
defined('_VALID_MOS') or die('Restricted access');
define( '_CLT_INSTALLER_ICONPATH', JURI::root().
  'administrator/components/com_catliketyping/images/');
 
function com_install() 
{	
	global $database;
 
	$database->setQuery("
		UPDATE #__components 
		SET admin_menu_img = '
			"._CLT_INSTALLER_ICONPATH.
			"softwyre_16.png' 
		WHERE name='Cat-Like Typing'");
	$database->query();
 
	return true;
}
?>

Let’s stop for a moment and look at what just happened here:

Line 1: Start PHP.
Line 2: Die if someone is maliciously accessing this script
Line 3-4: Let’s get the path to our images folder (post-installation)
Line 6: We define the function called during installation – com_install
Line 8: We get our global database variable
Line 10-15: This is the query that will set our component’s image to the chosen one
Line 16: We query the database
Line 18: We return true because all went well (no error testing for now)

And that’s it. If we reinstall our component, we see our menu now looks like this:

Other things to note are that the image is 16×16 (pixels) and that it should probably be on a matching grey background or possibly transparent.

Enjoy your custom menu images!

I’m not going to go through the whole class as the documentation is readily available here for you to read at your own leisure however I will go through a few usage examples where it has come in rather handy for me.

The first uses are rather innocuous:

$currentURI = JURI::getInstance();
$myURI = JURI::getInstance( $myURL );

These two lines each give me a JURI object.  The first produces a JURI object based off the current request URL/URI.  The second creates a JURI object from the URL sent in.  In some cases, I want to modify the current URI (figure out where I am in the menu system, analyze query string variables passed in, etc) and in some cases I want to build my own new URL.  JURI gives me the ability to do both easily.

So now that we have our URI/URLs, we can start playing with them and the area that we generally want to play with the most is the query string.  JURI provides three methods that see the most use in this area:

$myVar = $currentURI->getVar('myVar');
$currentURI->setVar('myVar', 'myNewVarValue');
$currentURL->delVar('myVar');

The first line above gets the variable from the query string that looks like “myVar=…”  The second line sets that same variable in the query string to a new one (”myVar=myNewVarValue”).  The third line removes the variable from the query string if it exists.  These three methods let me do pretty much whatever I want to the query string.

Of course, there are times when you want to rebuild the query string and not worry about what values are already present and JURI has a solution for that as well:

$myURIAndPath = JURI::getCurrent();

This will get you the current URI without the query string allowing you to repopulate it yourself.

None of these things are amazing or revolutionary but they’re useful, fairly intuitive, and a much cleaner alternative to calling parse_url directly.  If you find yourself manipulating URLs/URIs in Joomla! then give them a try.

Web development is really no different. If you deliver what you say you are going to deliver, and do it in a timely and reasonable fashion, then you would hope that a client would appreciate that and respond to it positively. Although this is typically the case, sometimes you just can’t win everyone over. There are always folks that will never be satisfied. I am not saying this to point anyone out, quite the contrary… I say this because it is a fact of life and of doing business. You can’t please everybody.

I think that’s one thing that really gets me down about the Web business… there is always something that seems to come up and tarnishes otherwise well executed work. And a lot of the time, its not something in the work itself, but a personal preference that in the long run has little bearing on the project itself. Luckily, these incidents are few and far between the good times and ususally pass quickly.

What made me think of all of this was a video I watched at lunch today. Its footage (from another country) of a dog pulling another injured dog off of the road after it had been hit. I am going to post the link here but not the video, as it’s a little disturbing to watch. Its certainly not for the squeamish but certainly worth the watch.

If you’ve ever questioned a dog’s capacity to be loyal, you won’t anymore.