WerkPress

Cleaning Up WordPress Admin Menus

Justin Rhodes — Mon, 06 May 2013 14:31:57 +0000

As a WordPress developer, I often find myself tasked with building very specific WP themes. So specific in fact, that I end up leaving out a lot of the default functionality. The problem is, I want the client to have a seamless experience while dealing with the back-end of their site. I don’t want them wondering what the Comments tab does, or why the Posts tab brings them to an empty list, because maybe their site didn’t require those options.

So, what to do? Well, hide them. Hiding unused menu tabs is a quick and easy way to de-clutter the back-end of your WordPress site. WordPress 3.1.0 introduced two new ways of doing this: remove_menu_page and remove_submenu_page.

The example below shows how you would remove the Comments menu item, by pasting this code in your functions.php file:

	add_action( 'admin_menu', 'my_remove_menu_pages' );

	function my_remove_menu_pages() {
		// the parameter is the slug of the menu item to be removed
		remove_menu_page(‘edit-comments.php’);
        }

But what if you want to remove more than just the comments? That the easy part, just call remove_menu_page() again, inside the function, passing the menu item’s slug as the main parameter.

That works great for top-level menu items, but what if we want to remove sub-menu items? That’s where remove_submenu_page() comes in. The example below shows how you would remove the Editor sub-menu item, by pasting this code in your functions.php file:


add_action( 'admin_menu', 'my_remove_sub_menu_pages' );

	function my_ remove_sub _menu_pages() {
		// the first parameter is the slug of the top menu item to be removed
		// the second parameter is the slug of the sub-menu item
		remove_submenu_page( 'themes.php', 'theme-editor.php' );
        }

Again, you can call this as many times as you’d like, to remove even more sub-menu items.

The post Cleaning Up WordPress Admin Menus appeared first on WerkPress.

It’s Greek To Me: Learning To Customize Your WordPress Site When PHP And CSS Is Foreign

Lindsey Guajardo — Fri, 03 May 2013 15:21:14 +0000

People are drawn to WordPress as a CMS because it’s a solution that anyone can implement without a lot of technical knowledge. I set up my first WordPress site in 2009, and since then I’ve learned a lot about how to start just a basic site with the default theme and no plugins and make it a totally unique, customized website – even if you don’t know how to write a single line of code.

The easiest way to hone the default look of WordPress into a site that reflects your vision, is to leverage the existing tools that have been built by the amazing WordPress community.

Think about the purpose of your site and head on over to WordPress.org. You can find a theme that pulls the important elements into the spotlight. Searching by subject – photography, business, portfolio, journal – is the best place to start. It might be tempting to search by style elements, but it’s so much easier to change the color of the homepage than the layout!

A good theme can get you nearly all the functions you need to launch your site, but even the best might not have that one tool you really need. That’s where plugins come in. You can make slick contact forms, detailed events lists, sell your band’s MP3s, support your site through managed ad campaigns, or even reach a whole new audience.

If you’re like me, after a bit of tinkering, you start to feel confident and want to check out that little area of your site’s admin labeled ‘Editor’. If you’re ready to get your hands dirty you can’t be afraid to break things. The best way to start is to back up your data. You can use any of the backup plugins available or make a copy of the theme folder (if you know how to use an FTP client or if your hosting provider has an interface for you to browse your files it will be in the wp-content/themes area).

If you’re feeling especially adventurous, you may want to review this article on debugging. This will be important information to have if you need to search for help later on.

Now that you have something to roll back to in case your experimenting goes all pear-shaped, start trying things out! Use some of these free resources online to help you navigate the PHP and CSS that runs WordPress.

At this point you’ve either discovered your hidden talents (hopefully) as a front-end web developer, or you’ve realized you need a hand. The WordPress community is there for you if you experiment yourself into a corner. You can get help online at WordPress.org, or look for meetups or user groups in your city.

Get in there and get your site online! Even if you don’t know where the tag goes, you can create your own unique online presence.

The post It’s Greek To Me: Learning To Customize Your WordPress Site When PHP And CSS Is Foreign appeared first on WerkPress.

WordCamp Minneapolis

Stephanie Lee — Thu, 02 May 2013 15:25:41 +0000

Check out our post, WordCamp: How We Went All Out in the WP Daily:

This past weekend’s sold-out WordCamp Minneapolis was a blast. We had beautiful spring weather (finally), brilliant speakers, enthusiastic attendees, and amazing volunteers.

And to make the very best of it we decided, as a small company, to go all out on it.

The post WordCamp Minneapolis appeared first on WerkPress.

WerkPress Featured in WP Daily

Travis Totz — Thu, 18 Apr 2013 15:14:17 +0000

We were lucky enough to be featured in the WP Daily Creative Workspaces! You can check out the entire article, including more photos, at WP Daily

The post WerkPress Featured in WP Daily appeared first on WerkPress.

WordCamp Miami Recap

Travis Totz — Wed, 10 Apr 2013 14:33:59 +0000

This past weekend was WordCamp and BuddyCamp in Miami. The sun, the people, the experience- WordCamp Miami was definitely one to remember. WordCamp is always an enjoyable (and often beneficial) experience, and this time was especially so- it was the first time we were active contributors to the event. We had the dual honor of being a sponsor of WordCamp and also designing the BuddyCamp t-shirts. Over the weekend, we enjoyed some inspiring talks from industry leaders, including Shane Pearlman of Modern Tribe (@justlikeair), Lisa Sabin-Wilson (@LisaSabinWilson), Brad Williams (@williamsba), Chris Lema (@chrislema), Pippin Williamson (@pippinsplugins), and John James Jacoby (@JJJ). We loved Shane’s informative and fun talk on running a WordPress business, freelancing and how to navigate a successful career (with a lot of sleepless nights). His slides were beautifully designed and concise; his energy on stage was infectious-it was a great talk.

Many WordPress companies are responding to being social and attending these great community events. We have seen our business shift and evolve over the past few years and attending WordCamp events has played a huge role in establishing our business strategy. The exciting thing with WordCamp is how it combines a lot of hungry people who’ve been working for years on a similar set of problems. At these events, we together can communicate, collaborate and listen — getting a great shot at fully delivering WordPress solutions that respond to the needs of the community and our user base. Strolling off of the University of Miami campus afterwards, I had a moment of realization; we had sponsored an amazing event, met and conversed with some of the top minds in the WordPress industry, and we had a weekend that we would not forget. Our excitement for WordCamp Minneapolis has been heightened.

The post WordCamp Miami Recap appeared first on WerkPress.

Showing a Message in WordPress Admin Panel

Justin Rhodes — Fri, 15 Mar 2013 18:34:55 +0000

Show an urgent message in WordPress admin panel

When applying changes to a theme or plugin, you might want to let other WordPress
users know about it. This is especially useful if you have a theme or plugin that
requires an update, or has a dependency that you’d like to inform users about. The
following code snippet shows you how to add an error or status message to the top of
the WordPress admin panel.

Add this code to your theme’s functions.php file.

function showMessage($message, $errormsg = false)
{
  if ($errormsg) {
    echo '';
  }
  else {
    echo '';
  }
  echo '' . $message . '';
}

function showAdminMessages()
{
  showMessage("Working on Theme's function.php, Do not touch it till further notice.", true);
}
add_action('admin_notices', 'showAdminMessages');

The Message is being wrapped in WordPress’s default admin classes, this will apply the generic alert style to your notification.

Just change the string in the showMessage() function to put your desired notification or error message. You can also insert HTML to add links or other styles to your messages, this is especially useful if you want to link to a change log, or maybe a required plugin/update for your theme.

The screenshot below shows how the message will appear in the admin panel.

The post Showing a Message in WordPress Admin Panel appeared first on WerkPress.

!important: Why your custom css isn’t working.

JR — Wed, 27 Feb 2013 15:20:25 +0000

Recently, I was tasked with completing a WordPress site that was using WooCommerce, Gravity Forms, and a Gravity Form plugin for WooCommerce. The site was nearly complete when I started working on it; there were just a couple things that needed polishing.

When I was handed this project I was told that the previous developer (an outside contractor) had been having a hard time getting all form elements styled consistently across the site. To be honest, upon hearing this I was’t convinced the previous developer had been the “expert” he claimed to be. After all, CSS for any seasoned web developer shouldn’t be rocket surgery.

Opening the style.css stylesheet in Coda 2 (imo the best IDE) it was clear what had happened… like a bad episode of CSI, my screen was spattered with thousands of crimson !important style rules. 1,917 of them to be exact, and seeing this made me feel bad- really bad.

The website was using about a dozen forms that were being generated by 3 different plugins. The previous developer had worked through what must have been countless hours of frustration trying to define style rules that would apply to all form elements only to have some rules take and others be ignored. Refusing to be bested, the developer pulled out the big guns: the infamous and hotly debated !important rule. Unfortunately, this too proved to be ineffective as the forms still looked disheveled and mismatched; like Thom Yorke drew them by hand while dancing.

The previous developer had made the same mistake that I myself have made countless times in the past; they forgot to take into account that some WordPress plugins generate their own CSS. To make things worse, the order in which a plugin’s CSS is imported means that resistance is futile (thanks Borg). Fortunately, this CSS can usually be switched off in the plugin’s options panel. If for some reason the option doesn’t exist, you could just locate the source of the offending CSS and comment it out. If you end up doing the latter, keep in mind that any future updates to the plugin will likely undo your commenting out of the code.

This project has reminded me of one !important lesson; you don’t know what you don’t know. It wasn’t that long ago that I experienced the same situation; in my case it took me two days and a new keyboard before I figured out what was happening.

The post !important: Why your custom css isn’t working. appeared first on WerkPress.

The CSS3 Box-sizing Property and the Complacency of Assumptions

Eric Jorgensen — Mon, 11 Feb 2013 15:55:03 +0000

It’s amazing how easy it is to be frustrated repeatedly by a technical issue without realizing there has been a simple solution available for years.

In this case, I’m writing about a common CSS problem, specifically when you would like to add padding or a border to an element but have that element stretch to fill 100% of its container. The traditional box model includes interior padding and a border in an element’s width, so if you added padding to, for example, a textarea element and set the width of that element to 100%, it would stretch outside its containing element. Very frustrating.

Enter the CSS3 spec’s box-sizing property. If you set this property value like so:
{ box-sizing: border-box; }

. . . the affected element will fill its containing element without overflowing the parent’s boundaries. Neat.

I’ve dealt with this issue in various projects for years by hacking element widths as necessary, assuming that it would always be a limitation of the box model. Turns out it’s not, at least not anymore. Technology changes, and the world we live in evolves. This is especially true for those of us who work on the web, where change seems to be happen almost overnight. One would think that the rapid pace of change in our industry would force us to constantly reevaluate the things we think we know, but as the above example shows, it’s still easy to become complacent and stuck in old, inefficient ways of working.

I’m finally figuring out that it’s better to think that I know nothing instead of assuming that I know everything.

My advice to you is this: Don’t give up on searching for solutions to long-standing problems, especially the really frustrating ones. There will always be new things to learn and discover about whatever it is you do for a living; if you make a habit of questioning and reevaluating your skills, tools, and methods, you’ll make yourself more valuable as an employee and more well-rounded as a person.

Footnote: For more on the box-sizing property, visit CSS Tricks.

The post The CSS3 Box-sizing Property and the Complacency of Assumptions appeared first on WerkPress.

Making Your WordPress Theme Future Proof (And Some Common Mistakes)

Nick Pelton — Tue, 05 Feb 2013 15:21:13 +0000

WordPress Core updates are considered so solid these days that most hosts auto-update WordPress. It’s a different story for themes and plugins, which are often the culprit when a WordPress site starts misbehaving after an update. At WerkPress we specialize in customizing WordPress themes and plugins, but we also do a fair share of *fixing* code. Put simply, there some rather poorly written themes and plugins out there; as WordPress evangelists it’s our mission to raise the bar. Here are some best practices (and common mistakes to avoid) that will help build better themes, make clients happier and reduce support requests.

Enqueueing Scripts, CSS, & Libraries

Time and again we see HTML references to Javascript and CSS files. This can cause the same libraries to be loaded over and over, creating errors. Since version 2.6 WordPress has built-in methods to deal with multiple dependancies on libraries, using wp_enqueue_script() and wp_enqueue_style() can prevent these collisions. I’ve heard this advice repeated hundreds of times on other blogs, yet many still put them in the HTML.

Mo Libraries Mo Problems

More and more libraries of code are being included in themes and plugins, and while they are awesome (jQuery in particular), they can bring problems. For example, jQuery 1.9.0 was released on January 15,2013 and depreciated the live() function for the newer (and better) on() function. It was common practice to use the live() function to bind click events before on() was available. Unfortunately, many theme and plugin authors have failed to update. We’ve already received quite a few requests to fix this issue. So how can we deal with external libraries being updated when we don’t have control of this third party code?

Link to a fixed, not latest, version on CDNs. It’s considered best practice to link to a CDN hosted version of a library. Then, if you’ve visited another site that uses the same file, it will already be cached in your browser and you’ll experience faster load times. But often we see authors pointing to the “latest” versions on CDNs. So when this library is updated, the theme will point to the new file and potentially break. If you want to ensure your site won’t break every time the latest and greatest libraries are released, instead point to a known supported version.
Use the bundled libraries in WP Core. While you lose the advantage of a CDN, WordPress bundles many common libraries-like jQuery- right into core. This makes it easy use an updated version while keeping an eye on WordPress release cycles, which can be tested daily using the WordPress Beta Tester plugin and give you a heads-up to test your theme when libraries are updated.

WordPress Core

In every WordPress update some old, replaced, or unnecessary functions are moved to a depreciated file for safekeeping and backwards compatibility. If possible, authors should regularly remove/replace depreciated functions from their themes and plugins. Why? Some argue that this is the beauty of WordPress; it worked in 2008 and it works now. But by using old functions, you’re missing out on performance increases and new usability afforded by these new functions. Also, at some point in the future, these depreciated functions may be removed entirely. Here are a few ways to track down and clean up those pesky depreciated functions:

Use WP_DEBUG(true); This is a best practice when developing in WordPress. Used in combination with a few other settings, you can log everything to a file and avoid nasty looking errors in your beautiful themes. Our preferred settings at WerkPress are: define(‘WP_DEBUG’, true);
define(‘WP_DEBUG_LOG’, true);
define(‘WP_DEBUG_DISPLAY’, false); This will log all errors the file /wp-content/debug.log.
Use the plugin Log Depreciated Functions. This neat plugin provides a automated search of your WordPress Themes and Plugins for depreciated functions that should be replaced. It puts them in a nice GUI interface and even suggests the replacement function.

PHP Depreciations

PHP has been releasing new versions at a good clip. Just like WordPress, the creators of PHP deprecate functions, but in this case they often don’t maintain backwards compatibility. This can be risky, as with most cheap shared hosting companies, you don’t have much choice when it comes to PHP versions. One day a large host could do a collective update and break thousands of sites that use depreciated functions. While probably a rare occurrence, it still good to periodically review latest versions of PHP what they are depreciating.

Child Themes

If you’re looking to customize your theme and your author provides regular theme updates, child themes are the way to go. A child theme will separate all of your hard work from being erased when the original theme gets updated. It accomplishes this by separating your code from the parent theme in a discrete folder that uses the parent theme as a template. This allows you to override templates, functions, and styles from the parent theme without ever modifying the parent theme’s code.

Occasionally, child themes won’t be enough, and you may need to edit the parent theme when making major changes in functionality or you discover parts of the parent theme that are not “overridable”. In this case, you’ll want to make note that you are no longer able to update. At Werkpress, if we must edit the parent theme we’ll usually remove the update capability to prevent an accidental update and loss of code.

This is the End

We hope this rundown has been helpful to a fellow WordPresser or two. Don’t forget, next time you see a mistake like any of the above – speak up! It’s in the spirit of WordPress to help the community grow by writing the best code possible. Now let’s raise the bar and build some awesome WordPress stuff.

The post Making Your WordPress Theme Future Proof (And Some Common Mistakes) appeared first on WerkPress.

How WordCamp Jumpstarted Our Business

Travis Totz — Mon, 28 Jan 2013 16:28:32 +0000

When I was trying to decide on a good topic in hopes of being selected to speak at the upcoming WordCamps in Atlanta and Miami, I considered something along the lines of the title of this post. For the sake of being too obvious, it’s evident that WordCamp conferences can be beneficial, but I want to share just how important the WordCamp San Francisco 2011 was in building WerkPress, so that it might inspire some attendees to really make WordCamp work for them in a big way, right now. Though I submitted my original topic, “A Designer’s Approach to Customizing Themes”, I still wanted to express how thankful I am both personally and professionally to WordCamp, as well as share how absolutely imperative they are for those that work with WordPress.

Attending WordCamp SF in 2011 was a bit of a happy accident. At the office we had discussed the travel expenses, possible opportunities and the connections we may potentially make— needless to say, we made the trip to San Fran for WordCamp that year.

My goal for WordCamp was to build some new WerkPress relationships and ideally, even partner up with more theme shops, including the Theme Foundry, who would connect us with an important soon-to-be client.

The client was on the hunt for an agency capable of designing and building an enterprise-level custom WordPress theme to replace the over 200 WP installs they were currently managing. They were having difficulty finding an agency that could deliver both design and development, and by chance had talked to the Theme Foundry, who recommended us. We forged a relationship with them, mostly as a resource for them in determining how to best approach their massive project. Fast-forward a few months, and we received a RFP (request for proposal) to design/develop their website. On a (huge) gamble, we flew out to meet with their web staff- and were thankfully awarded the contract. Creating a massive custom WordPress theme set us apart from other agencies who work in WordPress in a meaningful way: by effectively using WordPress to meet the needs of a major University, not just to power newspaper or sports blog. It enabled us to grow significantly that first year, by hiring additional staff, moving into a bigger office and by connecting us with more clients.
The generosity of spirit of WordCamp opened the door for a big opportunity for us, which, mixed with a little rapport-building pro-bono consulting work, resulted in a big win.

The post How WordCamp Jumpstarted Our Business appeared first on WerkPress.