All sorts of nitty-gritty technical things.

Drupal – Debug Output not Displaying?

Have you ever noticed that sometimes no debug output whatsoever appears when you call a debug output function like dprint_r() from the PHP code that you’re working on?  For example, if you call one of the debug dump functions from the default argument handler for a block view (see earlier post) you won’t see a blessed thing! It seems that there are plenty of situations in the drupal processing lifecycle where output debug information will not get through for display on a page…

 

So what’s to be done? life without debug information can get very difficult and frustrating, but not to worry as in these difficult cases we can always log our debug info to a file using file_put_contents() (as suggested here), for example if you wanted to dump information about a variable called $my_variable you could call:

[code lang="php"]
file_put_contents("./drupal.debug",
                 print_r($my_variable, TRUE),
                 FILE_APPEND);
[/code]

Then simply read the contents of the file drupal.debug, not pretty and not perfect but a whole lot better than nothing!

Matrox Mil & Firewire 1394 Image Acquisition

With newer versions of Matrox Mil (>= Mil 8 ) it is possible to grab images from firewire cameras without the need for any Matrox hardware, Mil will just use your PC’s normal Firewire/1394 adaptor(s) to acquire the images. When setup correctly you should be able to grab from either code or from intellicam.

 

However in typical Matrox fashion finding out how to set Mil up this way is quite difficult as there isn’t much information ‘out there’ or in the Mil documentation on how to do it,  and (again in typical Matrox fashion) the procedure is a tad non-intuitive.

 

So to add 1394 support – Install Mil, and when you get to the stage where it asks you which drivers it should install for the various possible frame grabber cards choose ‘Meteor II 1394’ remember though that you don’t  actually need a Meteor II frame grabber – Mil will use your existing Firewire adaptor(s) instead!

 

The next thing to note is that whenever you want to see or use any of the Mil 1394 features from Intellicam or from code you must have your camera(s) plugged in – otherwise Mil will deny all knlowedge!

 

For example if you start up Intellicam without your firewire camera plugged in then you may get an error message like the following, plugging the camera in and restarting Intellicam will fix things:

 

ooops camera is unplugged!
 

To grab images from Intellicam, first plug in your camera and then launch Intellicam and make sure the ‘Meteor-II /1394’ system is selected.

 

 Choose the 1394 System

 

With firewire Mil does not use DCF files like it does for other frame-grabber and camera combinations, instead the required camera and digitiser format is specified by a string.  To see the available formats hit the ‘New DCF’ toolbar button or choose the ‘File/New…’ menu option,  this will display a list of format strings:  

 

 

Choose your digitiser format

 

Once you select a suitable format you should be able to grab from the camera!

Shutting Down Windows from C++

Windows can be programmatically shutdown using the ExitWindowsEx() Win32 function.  However it turns out that the trick to getting it to work is to first grant shutdown priviliges to the calling process via some rather ugly security functions – this type of faffing around can never me remembered so I will post some sample code here in the hopes that it might help me (in the future) or maybe someone else:

[code lang="cpp"]
bool ShutdownPC(const bool reboot)
{
  HANDLE hToken = NULL;


  if(!OpenProcessToken(GetCurrentProcess(),
                       TOKEN_ADJUST_PRIVILEGES |
                       TOKEN_QUERY, &hToken))
  {
    cerr << "OpenProcessToken() " << GetLastError();
    return false;
  }


  TOKEN_PRIVILEGES tkp;

  if (!LookupPrivilegeValue(NULL,
                            SE_SHUTDOWN_NAME,
                            &tkp.Privileges[0].Luid))
  {
    cerr << "LookupPrivilegeValue() " << GetLastError();
    return false;
  }


  tkp.PrivilegeCount = 1;
  tkp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;

  if(!AdjustTokenPrivileges(hToken, false,
                         &tkp, 0, NULL, NULL))
  {
    cerr << "AdjustTokenPrivileges() " << GetLastError();
    return false;
  }

  // And shutdown... with force!
  bool ret = ExitWindowsEx((reboot ? EWX_REBOOT : EWX_SHUTDOWN)
                           | EWX_FORCE | EWX_FORCEIFHUNG,
                           SHTDN_REASON_MAJOR_APPLICATION |
                           SHTDN_REASON_MINOR_MAINTENANCE) == TRUE;

  if (!ret)
  {
    cerr << "ExitWindowsEx() " << GetLastError();
  }

  return ret;
}
[/code]

Dual Personality Properties with Lambdas in .NET

Some time ago (!) I wrote about an investigation that I had carried out into how a literal value could be mapped to and stored as a lambda expression/delegate in C#.  This was important for me at the time because I needed to find some way to have a ‘value’ and a ‘value rule’ appear the same to callers.  I wanted to define a type whose value when queried could either come from the evaluation of a previously specified ‘rule’ or could simply be retrieved from a real, previously stored value – without the caller knowing the difference at all.

 

This type of concept is common in functional and logic programming languages – in these languages the separation between functionality (code) and data is very blurry, what is data one minute can become code the next, and visa verse.  It is harder to achieve (at a high level) in procedural languages but the addition of lambda expressions in .NET 3.0 brings us a a lot closer (in .NET 3.0)!

 

The following might help to demonstrate how such a type might work, imagine a generic class called DualProp whose job is to yield a typed value when requested, this value could have been previously stored as a real value or could be obtaind by evaluating a previously specified lambda expression:

 

[code lang="csharp"]
    // Create an integer property
    var speed = new DualProp();

    // set it to 3
    speed = 3;

    // Create an bool property, whose value depends
    // on the speed's value.
    var visible = new DualProp();

    // visible only true if speed > 5
    visible.Lambda = () => speed > 5;

    // Check visible's value ( this results in the
    // stored delegated being evaluated)
    if (visible == true)
        Console.WriteLine("It is visible");
    else
        Console.WriteLine("It is invisible");

    // Set speed to 8, sould now be visible
    speed = 8;

    // Try again, it should be visible now
    if (visible == true)
        Console.WriteLine("It is visible");
    else
        Console.WriteLine("It is invisible");

    // now just set visible's value to false
    visible = false;

    // And check it's value again, should be invisible
    if (visible == true)
        Console.WriteLine("It is visible");
    else
        Console.WriteLine("It is invisible");
[/code]

 

Two properties are defined, an integer property called ‘speed’ and a bool property called ‘visible’.  Visible’s value depends on the evaluation of the delegate compiled from the lambda expression that was assigned to it:

[code lang="csharp"] visible.Lambda = () => speed > 5; [/code]

So when queried, visible’s value is ‘true’ if speed’s current value is greater than 5.

This scheme should allow us to build up whole sets of properties some of whose values are real and others whose are dynamically computed based on the values of others.  The values on which the lambda expressions depend can themselves be real or computed.

 

This type of set-up could be very handy, especially when used as part of a data driven user interface.  A data driven user interface is typically laid out and behaves in accordance with some specified meta-data, this meta-data is usually static (no meta-rules, just meta-data!).  Employing a scheme such as this should allow us to specify meta-data which can be dynamic, in that some of the meta-data can dynamically change based on applying ‘rules’ to some of the real data.

 

Imagine a CAD/CAM system for a laser drilling machine, it will have various logical tools defined that represent the different laser cutting tools onm the laser cutting machine. The laser tool’s various parameters can be viewed and changed on the CAD/CAM interface via a data driven property-page type interface. As usual the meta-data for this interface will specify a list of parameters along with some other data like:

 

  • Name – Attribute’s Name
  • Type – Attribute’s Type (Number/Boolean/String etc.)
  • Visibility – Is this Attribute visible for editing
  • ReadOnly – Can the attribute’s value be changed?
  • Min – Attribute’s Minimum allowed value
  • Max – Attribute’s Maximum allowed value
  • HelpString – Some help text for the attribute

 

Rule based properties should allow us to do things like set the min & max values based on another parameter’s value or force a parameter to be read-only based on the value of yet another parameter (by specifying a rule for the visibility attribute).  Anyway, I hope to expand on this in a future post.

 

Meanwhile, Here is the code for the DualProp class:

[code lang="csharp"]
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Linq.Expressions;

// (c) 2009 Kevin Godden, Ridge Solutions.
public class DualProp
{
    // The property's delegate, which will
    // be evaluated whenever the property's value
    // is queried.
    private Func _lambda = null;

    // Map the passed value (of type T) to a lambda and
    // then compile to a delegate.
    private Func ToLambda(T val)
    {
        var body = Expression.Constant(val);
        var exp = Expression.Lambda>(body, null);

        return (Func)exp.Compile();
    }

    // Given a value of type T, convert it
    // to a corresponding lambda delegate
    // and store it.
    private void SetValue(T val)
    {
        _lambda = ToLambda(val);
    }

    // Set for _lambda, used when we want
    // to specify a property 'rule' rather
    // than a literal value.
    public Func Lambda
    {
        set { _lambda = value; }
    }

    // Constructors
    public DualProp()
    {
    }

    // Construct with value
    public DualProp(T val)
    {
        SetValue(val);
    }

    // Construct with a 'rule' (lambda/delegate)
    public DualProp(Func lambda)
    {
        _lambda = lambda;
    }

    // Allows us to assign a value directly to
    // a DualProp i.e. -->
    // DualProp dualProperty = new DualProp();
    // dualProperty = 10;
    public static implicit operator DualProp(T val)
    {
        return new DualProp(val);
    }

    // Allows us to query a DualProp's value directly
    // i.e. -->
    // DualProp dualProperty = new DualProp(10);
    // int value = dualProp;
    public static implicit operator T(DualProp sp)
    {
        return sp._lambda();
    }
}
[/code]

neat_trim() – Handy for tailored drupal teasers

In drupal there are many ways to go about putting together teasers for custom content types created with the Content Creation Kit (CCK). The quickest to get up and running with is often to use the Content Templates (Contemplate) module, this allows you to specify in-line markup and PHP with code to get at and display the node’s data fields – formatted just as you require.

 

Often when putting together a teaser you may want to neatly truncate some long text to a summary and append ‘…’ or the like to the end – well there’s a great little PHP function which does just this called neat_trim() it is provided by Justin Cook and does the job  nicely!

 

One thing to note however is that HTML mark-up as well as newlines and carriage-returns in the input string can confuse this function.  To get around this problem you can arrange to remove the offending material either by modifying the function or by stripping it out of the input string before calling the function.  Use can use strip_tags() to remove HTML mark-up.

Passing an argument to a Block View in Drupal 6

Q: How can I pass an argument to a ‘block view’ in Drupal 6?

A: There is no way to pass an argument to a block view in Drupal 6, but don’t panic as there is a way to achieve the same result through some slight-of-hand.

The use of arguments with Drupal views are vital for getting the most out of the views functionality. How are the arguments normal passed to a view?  Well, if a view is configured to produce a page then the arguments are easily passed as part of the requesting URL,  while if a view is embedded using code, then the arguments are passed in as part of the call to embed the view.  But if a view is configured to produce a block, how do you pass arguments to it?  The bad news is you can’t – the good news is that there is a way fake it and achieve the same result.

The trick involves providing a PHP handler within the view which will be called when the view is invoked without an expected argument (this is what happens when the block is displayed!).  We just arrange for this handler to retrieve and return the argument’s value and then the view will behave as required – just as if the argument had been passed to it in the first place.

To do this create the block view as normal and configure the required argument(s).  For each argument we choose the ‘Provide default argument’ option, and select the ‘PHP code’ sub-option.  We then provide some PHP code which will ‘get’ and return the argument’s value, it doesn’t really matter where or how the PHP code gets the argument once it returns the correct value.   Have a look at screen shot below:

Adding a default parameter

The example above is a bit simplistic as the PHP code just returns a static value – not very useful at all!  A more realistic or useful example  (inspired by one of the posts referenced below) would be to return the argument that was passed to the page that contains and displays the block.  Consider the mythical paths:

www.somedomain.com/content/projects/web-design

and

www.somedomain.com/content/projects/illustration

Here things are set-up so that ‘web-design’ and ‘illustration’ are arguments to the ‘projects’ page, they result in only the projects of that type being displayed.   Assuming we are using the pathauto module for nice clean URLs (as we almost always are!) then the following PHP code when provided as the default argument handler will get the URL, parse it and return the argument part to the view.

[code lang="php"]
$path = drupal_get_path_alias($_GET["q"]); //get URL alias
$path = explode("/", $path); //break path into an array
if ($path[0] == "projects" && $path[1] != "")
{
  return $path[1];
} [/code]

So there is is, it’s definitely not the easiest method in the world but at least it does provide a mechanism of getting those arguments to the view…

Sources: http://drupalsn.com/learn-drupal/drupal-questions/question-2650, http://drupal.org/node/332521

Drupal cron setup on blacknight.ie unix plan

For setting up a Drupal maintenance cron job on the blacknight.ie unix hosting plan, I have found that the following command works well:

 

/usr/bin/wget -O – -q -t 1 http://www.yourdomain.com/cron.php

 

Original Source: http://drupal.org/cron

Custom CCK Input Form in Drupal

We are using good old Drupal and its Content Construction Kit (CCK) once again to create a custom CMS for our client. One of the things that usually completely mystifies me time and time again is how to customise a new content type’s add/edit form layout.  So, lest I forget again in the future, here’s a link to a good article on the subject:

 

http://drupal.org/node/101092

Native Lambda Expressions in C++? Yes Please!!

Today I came across a situation which brought it home to me again how (in my opinion) C++ could desperately do with native lambda function support.  The standard library has introduced a load of great algorithms, but providing predicates and the like to them is a real pain – and I think that because of this people tend to stick to hand rolling good old-fashioned loops.

 

Consider replacing a few different characters in a std::string with a single given character, e.g., replace the characters ‘$’ and ‘|’ with ‘_’.  A good way of doing this in C++ would be to use the boost regular expression library, but we could also use the std::replace_if() algorithm.  All we have to do to use this algorithm is to privide a predicate that indicates if a given character should be replaced or not (say called is_bad_char()), then we do something like:

 

[code lang="cpp"] replace_if(str.begin(), str.end(), is_bad_char(), '_'); [/code]

 Looks easy enough, and it’s nice and concise.  All we have to do now is define is_bad_char(), something like:

[code lang="cpp"]
struct is_bad_char: public std::unary_function
{
  bool operator() (const char& c) const
  {
    return !(c == '$' || c == '|');
  }
};
[/code]

I mean! what a pallava!  that’s quite a mouthful, would you really be bothered? You would have a loop coded in just the time it took to start to remember that syntax, never mind the typing. it also looks terribly inelegant.

 

Now when native lambda support arrvies we will be able to do something like this instead:

[code lang="cpp"]
replace_if(str.begin(), str.end(),
       <>(char c) -> bool { return !(c == '$' || c == '|'); },
       '_');
[/code]

That’s much better… but not available yet, we will just have to wait for c++0x to arrive. In the mean time I will just have to use lambdas in the many other languages that support them and pine when using C++.

Thanks Winmerge!

I have recently been doing some fairly intensive merging and difference checking with Tortoise SVN and subversion and once again find myself thanking my luck stars that Winmerge is installed on my (windows) system just waiting to lend a helping hand!

 

For those who haven’t come across it Winmerge is an open source tool for visually checking file differences, it allows you to move individual changes or differences from one file to the other.  I have found it to be one of the best such tools and it’s free!  It also does a good job of comparing a whole directory tree of files.

 

Tortoise SVN can be configured to use Winmerge when showing differences etc. rather than its default difference visualiser, I find that this makes tortoise much more effective.  Instructions for configuring Winmerge as the default diff viewer can be found in the Tortoise help pages, but to summarise:

 

Right-Click on a folder in explorer, choose the ‘Tortoise SVN’ sub menu and then choose the ‘Settings’ menu option.  Click on the ‘Dif Viewer’ pane, select ‘External’  and  enter the following into the text-box below:

 

C:\Program Files\WinMerge\WinMergeU.exe -e -x -ub -dl %bname -dr %yname %base %mine

 

[the path entered will depend on where you installed Winmerge, for the real low-down on configuring this you had better check the documentation!]

 

Anyway, to sum up, if you find yourself struggling with comparing files or merging changes with subversion then I have found that Winmerge can be of great help, I can’t imagine doing without it anymore!