While writing a custom batch application for a client to update standard EXIF tags for photos based on directory names I came across a particular challenge.

He asked if I could update the XPKeywords, XPAuthor, and XPTitle tags so that if someone downloaded one of his photos, right clicked on it, and chose Properties->Details the tags would display.

Since they are listed in the Exiv2 standard tags list I thought it would be a piece of cake. However it turns out that Windows doesn’t want a text string, it wants it in a byte array encoded in UCS2 (which I’ve never heard of before). Google/Github wasn’t much help, but I did find one reference to it, and through trial and error I came up with the following code which gets the job done. I’m not sure if this is the right way to do it, or the most efficient, but it works.

Basically, it wants a string comprised of the ascii value of each letter, separated by a zero, with three zeros at the end. Here is the C++ snippet that I’m using:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

// Note: allTags is a string with each tag separated by a space

string XPString;
string::iterator it; 

for ( it = allTags.begin() ; it != allTags.end() ; it++ ) { 
   if ( XPString.length() > 0 ) { 
       XPString += " 0 ";
   }   
   XPString += fmt::format("{:d}", *it);    
}   

XPString += " 000";
exifData[ "XPKeywords" ] = XPString;

Note: the above code uses the fmt C++ string formatting library. Even though I’m using c++20, since I’m cross compiling for some reason the new c++20 format library wasn’t available.

Logo by Pixel Perfect / Flat Icon

A recent job I landed through UpWork gave me the chance to set up a new application development workflow that I’ve been wanting to nail down which allows me to do all the development and testing of the windows applications on my Linux workstation.

Up till now I’ve been doing Windows development in a Windows10 VM utilizing Cygwin and wxWidgets. While very doable, I’m just not as efficient working in Windows. This comes from the majority of my last 20 years spent on Linux server and workstations.

So now I just have to:

• set up the Makefile to call the cygwin toolchain executables for g++, gcc, ld, and windres
• create a resource file for windres to set the APPINFO resources in the executable
• use Wine to do inital debugging and testing
• set up a shared folder with VMware to easily move executables and data to my WIN10 environment for further testing

Since this was a console application, one of the most tedious parts was to find just the right compile/link options to prevent Windows from opening a separate output window for the messages send to STDOUT.

For this particular project I also had to download and compile the Exiv2 Library and the Mini YAML parser for the config file.

In a nutshell the client had a large library of JPG photos dating back many years but were meticulously orgainized in a detailed folder structure. The goal of the application would be recursively descend a given directory structure, find all the JPG files, and add the TAGS to them based on parsing of the full directory path, including splitting tags where CamelCase, spaces, and numbers where found. All of the photos would then be loaded into Piwigo, which would use the embedded EXIF information to add the tags to the system when the files were imported.

Here is the Makefile I wound up using:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

#
# Makefile for compiling windows console application
# on a Linux host
#
OBJS = exifupdate.o Yaml.o

# note - the ws2_32 and psapi libraries were needed
#        to be linked into the final application
#        by the Exiv2 library
LIBS = -lstdc++  -lpthread -lws2_32 -lpsapi

COPTS = -D__USE_MINGW_ANSI_STDIO -std=c++20 -I exiv2/include/ -I exiv2/build
LDOPTS = -static -mconsole 
LD = i686-w64-mingw32-ld
CC = i686-w64-mingw32-gcc
CPP = i686-w64-mingw32-g++
WINDRES = i686-w64-mingw32-windres

manifest.o: manifest.rc
	$(WINDRES) $< -o $@

.cpp.o :
	$(CPP) $(COPTS) -c $< 

.c.o :
	$(CC) $(COPTS) -c $< 

exifupdate:	$(OBJS)
	$(CPP) $(OBJS) -o $@ exiv2/build/lib/libexiv2.a \
	$(LIBS) $(LDOPTS) manifest.o

clean:
	rm *.o
	rm *.exe

Let me know if you have any questions about how I set this up.

photo by Alex Andres from Pexels

The latest project that I’ve been indulging on is for the Lost Boys Center For Leadership Development and their Lost Boys Interview Project. If you aren’t familar with these groups please take a moment visit these sites. The latest iteration of this project is to come up with a mobile solution that would allow them to take everything they need to search and print the interview archives in a self containted unit to their new center in Juba, South Sudan.

Images Of The New Juba Center

Some of the challenges for this solution are:

• lack of internet connectivity
• intermittent and unreliable power
• secure the archive data
• use low cost computer solutions in case they are lost

The short version of the answer is going to be a web based search interface powered by a Raspbery Pi embedded computer. All of the archive data will stored in an encrypted database, and queries be able to be done on standard tablets and smartphones while at the center.

We will have a desktop laser printer for producing hard copy documents, along with a self contained Power Source to keep everything going. Some of the units we are considering are:

• Goal Zero Yeti 500x from either Goal Zero or REI
• Jackery Power Station from Harbor Freight
• Mossomo Power Station at Costco

Each of these units should power everything for at least a couple hours, along with recharging the tables and phones and running a few lights when needed.

I’ve created a project page which I will update from time to time with details on the implimentation in case anyone is interested.

It’s been a while since I’ve posted. Nothing earth shattering. Just been keeping busy with personal/family stuff and have picked up a few gigs on UpWork. From an IT standpoint I decided to try and make my work environment a little more efficient. Part of this was spurred on by spending an hour or two tracking down something that turned out to be the result of a keyboard-bounced character that I couldn’t spot easily. After that I decided to get a better keyboard, and set up a bluetooth mouse that I can take with me on the road.

While the keyboard is on order, and should be able to just be plugged in, the bluetooth mouse is something I’ve toyed with over the years but haven’t really had much success with.

As a little background, my laptop (a Lenovo X240) spends 95% of it’s time in a docking station next to my desk (and usually under a cat, but that’s another story). When I do take it on the road I find it annoying that brushing the trackpad or touchpoint devices have some undesired effects - especially since I’m using the Awesome Windows Manger. My windows and screens wind up flying around in the most undesireable ways. The local Officemax had a clearance on Logitech bluetooth mice so I picked one up and much to my surprise, the Linux support for it is much better than it was last time I tried it. The mouse automatically connects each time I reboot the computer.

Now when I’m on the road I can take the mouse with me, and if it’s turned on the following script that is run at boot time will automatically disable the trackpad and pogo stick on the laptop:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

#!/usr/bin/tclsh

set btMouse "Bluetooth Mouse M336"
set targetList [list "TPPS/2 IBM TrackPoin" "Synaptics TM2749-001"]
set disableList [list]
set gotBTMouse 0

set inputpipe [open "| xinput list"]
while { [gets $inputpipe thisDevice] >= 0 } {
	 set deviceName [string range $thisDevice 6 25]
	 puts $deviceName
	 if { $deviceName == $btMouse } {
		 set gotBTMouse 1
	 } elseif { [lsearch -exact $targetList $deviceName] != -1  } {
		 puts $deviceName
		 set thisId [string range $thisDevice \
			   [expr [string first "id=" $thisDevice] + 3] \
			   [expr [string first "id=" $thisDevice] + 4]]
		 lappend disableList $thisId
	 }
}
close $inputpipe

if { $gotBTMouse } {
	foreach thisDevice $disableList  {
		exec xinput disable $thisDevice
	}
}