Still, the first time you upload the file you need to set the permission manually though. This can be most likely be done configuring some umask property in the configuration file of the ftp server.

Thanks to you all WP bloggers, you make my life so much easier !

Opabinia

$args = array(
‘to’ => $to,
‘subject’ => $subject,
‘text’ => $message,
‘api_user’ => $options['username'],
‘api_key’ => $options['password'],
‘files’ => $attachment_array,
‘from’ => ‘will@itsananderson.com’
);

from: will@itsananderson.com via sendgrid.me

Something must be hard coded into the plugin, but other than that it seems to work.

Cheers

The tricky part, as always with Windows 7 64-bit, is the permissions. You have to take ownership of the directories and subdirectories.

Oddly, I am both an admin and user — with the same username — which means I don’t automatically have read/write control over my directories, because I’m also a lowly user. (Lowest context/user status wins.) So, if you are in the same boat, > directory properties > security > select your username (not your admin name) > Edit > username (again) > check full control > apply > and watch your permissions multiply.

When you’re done, your username is the owner of the folder & subfolders.

Find the line starting with “$newConfFileContents = ” and change $newConfFileContents = ‘Alias /’.$newAliasDir.’/ ”
with
$newConfFileContents = ‘Alias /’.$newAliasDir.’ ”

You’ll also need to update the c:\wamp\scripts\refresh.php file or “Edit Alias” links in the tray menu won’t work.

Find the line: preg_match(‘|^Alias /’.$newalias_dir.’/ “(.+)”|’,$alias_contents,$match);

and remove the slash from there too:

preg_match(‘|^Alias /’.$newalias_dir.’ “(.+)”|’,$alias_contents,$match);

Note: Don’t forget to create backups and use at your own risk. Don’t blame me if this breaks some other functionality…

public function __construct() {
	trigger_error( 'It is not possible to create instances of the ' . __class__ . ' class.', E_USER_ERROR );
}

Wondering what you thought about this?

Thanks again!

Cheers for the quickly posted reply. Much appreciated!

function filterRSSQuery($query) {
	if ( $query->is_feed ) {
		$cats = array();
		$cats[] = get_cat_ID( 'Category 1' );
		$cats[] = get_cat_ID( 'Category 2' );
		$cats[] = get_cat_ID( 'Another Category' );
		$query->set('cat', $cats);
	}
	return $query;
}

Thanks for the great bit of coding. Very helpful.

I wonder if you know how to tweak the code so that the RSS feed will include two categories rather than just one. I’ve tried a number of variations (including using an array), but I can’t seem to sort it out.

Any ideas or guidance would be really appreciated.

Many thanks!

https://github.com/mfields/wc-presentations

https://github.com/mfields/mfields-opengraph-meta-tags

https://github.com/mfields/mfields-extensions

https://github.com/mfields/mfields-bookmarks

They are all free and released under the GPL.

I’ve also used the “functional” style. I do not really prefer one over the other. I’ve read arguments by well-known developers that using a class for a namespace is not a good idea and have heard opposing arguments by well-known developers as well. I use whatever makes sense for the task at hand.

That said, I think it’s a fantastic idea and I encourage just about every serious WP developer I meet to use this kind of development pattern.

Truly yours,
Daniel

Thanks for that tip on this… I’m not much of a sysadmin and that would have kept me worried why it wasn’t “finishing” so to speak.

Paul
Webmaster
Home Theater Hack

David

What I usually do when I have several components that I want to reuse in multiple templates is to place them in functions in a separate file called “template-tags.php”, then call those functions from my templates. All I have to do then is include “template-tags.php” (once) from my functions.php, and those functions are available. The advantage of putting those functions in a different files is that you only need to include them on the front end. In the admin, they’re unnecessary. Of course, this is true of your method as well.

In the end, do whatever you have the easiest time maintaining. The performance difference between one method and another, when compared with the entire execution time of a WordPress page request, is for the most part unimportant.

I am used to have a php include almost for anything

Per instance I have head-end.php, body-begin.php, footer-begin.php and footer-end.php with an “include” at before , after , etc in order to insert the usual tracking and other plugin codes that have to be inserted in that concrete places instead ot manually insert them in every custom template I have.

From your point of view, it would be better to add all this funcionts to functions.php and use the call_user_function() ??

Per instance I also include many other parts of code where I have ads, related posts, etc. All this is much better with functions.php??

Thanks and regards

If you use includeds, you reduce a lot the functions.php. I believe that totla size of html is also a performance issue.

So, what is better, to run an extra include or to load an extra non-used 30KB in your html??

Second, functions.php is loaded for every WordPress page request anyway. If it weren’t, WordPress wouldn’t function (no pun intended) properly.

Performance has nothing to do with whether functions.php is included. Instead, the question is whether the performance improvements gained by using function calls instead of includes is worth the extra complication it adds.

so do you think is it better to use call_user_func() instead of doing an include?

Does funcions.php load every time a page is loaded right?

What do you thing is it better:
1) To alway load funcions.php of lets say, 30 KB and use call_user_func
2) To use include and just load the 3 or 4 Kb of a single function

In terms of performance what do you think is it better, 1) or 2)?

Thanks

There’s a lot of awesomeness built into get_template_part() that, IMHO, far offsets any potential PHP performance hit the function incurs.

Although I do like the use of the ‘call_user_func()’ as you are suggesting, I see it as best for one or two post formats being implemented whereas Dougal’s would be better for organization if “all” of the post formats are implemented.

I’m not positive off the top of my head, but I think that an opcode cache like APC or XCache will help mitigate the cost of including the same template multiple times in a view. In other words, once a template is loaded the first time, APC/XCache should cache a compiled version of it, and re-use that the next time it’s called.

function get_breadcrumbs(){
global $post;

$separator = ‘ > ‘; // what to place between the pages

if ( is_page() ){
// bread crumb structure only logical on pages
$trail = array($post); // initially $trail only contains the current page
$parent = $post; // initially set to current post
$show_on_front = get_option( ‘show_on_front’); // does the front page display the latest posts or a static page
$page_on_front = get_option( ‘page_on_front’ ); // if it shows a page, what page
// while the current page isn’t the home page and it has a parent
while ( $parent->post_parent && !($parent->ID == $page_on_front && ‘page’) == $show_on_front ){
$parent = get_post( $parent->post_parent ); // get the current page’s parent
array_unshift( $trail, $parent ); // add the parent object to beginning of array
}
if ( ‘posts’ == $show_on_front ) // if the front page shows latest posts, simply display a home link
echo “Home“; // home page link

foreach ( $trail as $page){

if ($page->ID==$post->ID) {
// print the link to the current page in the foreach
echo “$separator{$page->post_title}”;
} else {
echo “$separatorID ) . “‘>{$page->post_title}“;

}
}
}
}

[...]

else if (is_category()) {

global $wp_query;

// Get the queried category
$queried = $wp_query->get_queried_object();

// Append its hierarchy to the document (links)
echo $separator . get_category_parents($queried->term_id, 1, $separator);

} else if (is_single()) {

$cats = get_the_category();

// Append the hierarchy of categories to the document (links)
// Note: if posts are associated with more than one category, printing the hierarchies in this way may not be desirable

echo $separator . get_category_parents($cats[0], 1, $separator);

// Append the title of the current single element (text)
the_title();
}

The only question I have is, I wish Twenty Ten would let me upload a bunch of images to choose from, randomly or otherwise, instead of only allowing me to use at a time, discarding one to get another.

Thus I would be willing to accept (am looking for) something that will look into a folder I specify, and make a list of all the files there, and use them.

If I am reading your post correctly, it can only choose from those few header images that come standard (as being registered by the theme — in this case, those few that come “out of the box” with Twenty Ten).

Can you help me understand if I am reading you right? And if so, do you have any plans for doing something like what I mentioned?

Check out the “Dynamic Headers” plugin. It has a lot of neat features. It does not make use of 3.0′s new API, etc, like you’re talking about, but it does find all the images in the given folder, and it lets you assign attributes to each image, such as ALT tag, URL for A tag, target window for A tag, etc.

In Seattle where having an air-conditioner is about as normal as seeing a natural lake in Indiana (at least one big enough to put a boat on) even Microsoft was shutting down some of its air-conditioners for employees citing “overloading” and the need to redirect cooling resources to precious server rooms.

That being said, with a little luck, we’ll have a cloudy summer. Without it, well, we have more than a few lakes here.

Thanks!

Esp. the gradient on the buttons.

Of course, thus is the nature of open source software. I’m just surprised this was committed into core given all the other changes happening.

I was wondering where you would put this in the functions.php file and would the add filter line need to be right next to the query code you put?

Cheers

Paul

I use the “+” and “.” tricks a lot, and I also find that some sites don’t allow the “+” they consider it not valid, even though it is.

Oscar.

First, ASP.NET has its own Ajax Toolkit. The toolkit itself has some design decisions that I disagree with but it also integrates very well with ASP.NET. For any user that is coding in ASP.NET and wants to AJAX-up their website I would recommend starting with ASP.NET.

Also, using the toolkit described about, it would be better to create a JSON control that would handle the situation you described about, if you really wanted JSON. This control would handle all the weird logic that would be associated with the JSON response and abstract it from using it all over the place.

Finally, the solution you describe is not very RESTful. I know that this is hard to do in ASP.NET and don’t know off the top of my head a good solution to it, which leads to my final point..

I love C# and .NET. But ASP.NET is a real-world example of a hack-and-slash framework. It’s useful for the time being and provides a lot of functionality. However, I would recommend shying away from the framework and work toward a Ruby on Rails, Django, Cappuccino, etc. solution. ASP.NET 4.0 seems to be lackluster, too.

Good thing that you’re looking into a bunch of solutions for these things though!

P.S. Add OpenID to your blog so I don’t have to sign in

However, I can’t think of a single reason this would be useful outside of what I was using it for, which was using a single wordpress admin panel to manage a collection of remote wordpress installs. It was a fun exercise regardless.

As for the particular project I mentioned, it looks like it’s not going to do the trick – however, I’m experimenting with the idea of switching the $table_prefix on the post_save hook, running wp_insert_post(), and switching it back when it’s done, because I need to duplicate posts in certain situations.

If anything interesting comes of it, I’ll let you know.

Changing a setting variable in the middle of the request seems like it could cause more trouble than it’d be worth.

I’ve been toying with the idea of one interface to make posts to multiple bogs, and, while I haven’t been able to come up with anything useful, you can get some really interesting results if you change the $table_prefix value later in the load series – like at the plugins_loaded action.

I haven’t taken the time to really figure out what is happening, but if you change it there, you’ll get a blog with settings that match the tables from the prefix in wp_config, but posts from the prefix that you set at plugins_loaded. It’s almost eerie how you can get the info from 2 places, but everything still works. Even the front end will pull from the second tables, and load properly.

As with so many of the other things I discover, I haven’t found anything useful to do with it yet – but it’s a fun experiment anyway.

$option = get_option( 'Option Name' );
if( false === $option ) {
$option = 'My real option value.';
}

I do agree, though, that the improved get_option available with WP 2.7 makes things simpler. No more checking for false.

I changed it slightly so that the CURRENT page, is no longer hyperlinked:

foreach ( $trail as $page){
// print the link to the current page in the foreach
if ($page->ID==$post->ID) {
echo “ID}’ >$separator{$page->post_title}\n”;
} else {
echo “ID}’ >$separatorID ) . “‘>{$page->post_title}\n”;
}
}