Stephan Sokolow's Blog | Programming, Linux, Web, and Fiction Reviews

…and a ScummVM.org userscript for collectors

Posted on 2015-11-28 by Stephan Sokolow

As you start collecting a lot of ScummVM-compatible games, it gets awkward to keep track of what you’re still looking for… so I wrote a little script which lets you check them off and have them fade out so you can easily scan what remains.

It’ll remember your list between visits and it’s on GreasyFork as Mark owned ScummVM Games if you want it.

Posted in Geek Stuff | Leave a comment

My New Fanfiction.net-Filtering Userscript

Posted on 2015-10-30 by Stephan Sokolow

After spending so much time on fandom-specific sites with much better search systems (like Twisting the Hellmouth), Fanfiction.net’s search system feels really constricting.

As such, I’ve started to hack together a little userscript to make up for that. As of this writing, it hides slash and stories which involve a list of fandoms I’m not interested in. (So I can formulate searches like “All Harry Potter crossovers except series X, Y, and Z”)

You can find it (and ~~instructions for customizing it~~ screenshots) over on GreasyFork.

Fanfiction.net Unwanted Result Filter

UPDATE: No instructions necessary anymore. It now has a nice configuration GUI.

UPDATE 2: And I now also have another little script for setting custom default values for Fanfiction.net’s own limited result filters system.

Posted in Geek Stuff, Otaku Stuff | Leave a comment

Script to open in default web search provider

Posted on 2015-09-14 by Stephan Sokolow

Inspired by this post for Windows on Raymond Chen’s blog, detailing how to make a best-effort attempt to open a query in the user’s default browser and search provider, I decided to write a Linux equivalent.

Since Raymond used C# for Windows (what could be more Windows?), I decided to use Bourne shell script for the Linux version (what could be more UNIXy?). Of course, me being me, I couldn’t help but add more error handling than Raymond does for his little programs.

Enjoy.

Posted in Geek Stuff | Leave a comment

Desktop-spanning backgrounds in KDE 4.x

Posted on 2015-07-22 by Stephan Sokolow

One of the simplest ways to make a multi-monitor system look more impressive is to set a desktop background which spans across all of the monitors. Just scale the image up to the smallest size that fills all of the visible desktop space, then cut out monitor-shaped pieces to display.

Every system (even lightweight, older Linux desktops) supports this… every system except one. When KDE went from 3.5.x to 4.x, they dropped support for spanning a background across all desktops and, to this day, they still haven’t brought it back.

…and since everything more lightweight has bugs with the desktop layout I’m currently dealing with while I wait for the new monitor bracket I ordered, that’s a problem. (Even worse, there’s no API I could find to programmatically set a background either!)

The solution I settled on was to write a little Python script which uses maybe half a dozen lines of PyQt 4.x/5.x calls (before line-wrapping and boilerplate) to do what KDE should have, then spits out image files to be set as per-monitor backgrounds.

I also implemented a --randomize option which can be used with cron to produce input for KDE’s slideshow mode. (Basically, you set each monitor background to be a single-entry slideshow that the script updates)

Just give it an image (or --randomize and a list of files and/or folders) and an output directory. (See --help for more details)

UPDATE: It now also gives more control over how the background is matched to the desktop’s aspect ratio via --gravity and I included, as an example, the .desktop file I use to integrate it with Geeqie via Zenity. (KDialog’s equivalent to zenity --list is inferior.)

[Desktop Entry] # IMPORTANT: THIS FILE IS A ONE-OFF HACK THAT I WROTE FOR MYSELF AND I AM # SHARING IT AS AN EXAMPLE. I DO NOT GUARANTEE THAT IT WILL WORK AS-IS ON # YOUR DESKTOP. # # Requirements: # - Geeqie # - Zenity # - ~/bin/set_background.py # # Instructions: # 1. `xdg-desktop-menu install geeqie-prepare-background.desktop` # 2. `mkdir -p ~/.local/share/images/background` Version=1.0 Type=Application Name=Prepare Desktop Background # call the helper script Exec=sh -c 'python ~/bin/set_background.py --gravity $(zenity --list --title="Select Gravity" --column="Gravity" --text="Select Background Alignment" --hide-header --height=300 top-left top-center top-right middle-left middle-center middle-right bottom-left bottom-middle bottom-right | cut -d\| -f1) %F ~/.local/share/images/background' # Desktop files that are usable only in Geeqie should be marked like this: Categories=X-Geeqie; OnlyShowIn=X-Geeqie; # Show in "Edit" menu X-Geeqie-Menu-Path=EditMenu#!/usr/bin/env python3 # -*- coding: utf-8 -*- """Simple PyQt5 script to chop up multi-monitor backgrounds for KDE.""" from __future__ import (absolute_import, division, print_function, with_statement, unicode_literals) __author__ = "Stephan Sokolow (deitarion/SSokolow)" __version__ = "0.2.1" __license__ = "MIT" IMG_EXTS = [ '.bmp', '.gif', '.jpg', '.jpe', '.jpeg', '.png', '.pbm', '.pgm', '.ppm', '.xbm', '.xpm', '.svg' ] import logging log = logging.getLogger(__name__) import errno, os, random try: from PyQt5.QtCore import QRect, QPoint, Qt from PyQt5.QtGui import QImage from PyQt5.QtWidgets import QApplication except ImportError: from PyQt4.QtCore import QRect, QPoint, Qt from PyQt4.QtGui import QApplication, QImage V_GRAV = { 'top': Qt.AlignTop, 'middle': Qt.AlignVCenter, 'bottom': Qt.AlignBottom } H_GRAV = { 'left': Qt.AlignLeft, 'center': Qt.AlignHCenter, 'right': Qt.AlignRight } GRAVITIES = {'%s-%s' % (x, y): V_GRAV[x] | H_GRAV[y] for x in V_GRAV for y in H_GRAV} def get_desktop_geom(): """Get the box we must upscale to fill and the pieces to crop out""" app = QApplication([]) deskwid = app.desktop() desktop = QRect(0, 0, deskwid.width(), deskwid.height()) log.debug("Desktop rectangle: %s", desktop) monitors = [deskwid.screenGeometry(x) for x in range(deskwid.screenCount())] log.debug("Monitor rectangles: %s", monitors) return desktop, monitors def write_backgrounds(image, monitors, outdir): """Given a QImage, a list of QRects, and a target directory, crop out a bunch of numbered PNG files. """ for idx, geom in enumerate(monitors): # We can't cleanly force a refresh in plasma, so we must instead # provide single-image sets to Plasma's randomizer so it can notice # the changes outparent = os.path.join(outdir, '%d' % idx) if not os.path.exists(outparent): log.debug("Creating directory: %s", outparent) os.makedirs(outparent) outpath = os.path.join(outparent, 'piece.png') log.info("Extracting %s and writing as %s", geom, outpath) if not image.copy(geom).save(outpath): log.warning("Failed to write image!") def apply_gravity(image, tgt_rect, gravity): """Crop an image to a target rect based on a given alignment""" # Verticals if gravity & Qt.AlignTop: tgt_rect.moveTop(0) if gravity & Qt.AlignVCenter: tgt_rect.moveCenter(QPoint(tgt_rect.center().x(), int(image.height() / 2))) elif gravity & Qt.AlignBottom: tgt_rect.moveBottom(image.height()) # Horizontals if gravity & Qt.AlignLeft: tgt_rect.moveLeft(0) if gravity & Qt.AlignHCenter: tgt_rect.moveCenter(QPoint(int(image.width() / 2), tgt_rect.center().y())) elif gravity & Qt.AlignRight: tgt_rect.moveRight(image.width()) log.debug("Cropping to %s", tgt_rect) return image.copy(tgt_rect) def set_background(img_path, outdir, gravity=0): """Given a path, [re]generate output files matching the monitors.""" if not os.path.exists(outdir): raise IOError(errno.ENOENT, "Destination directory does not exist", outdir) if not os.path.isdir(outdir): raise IOError(errno.ENOTDIR, "Destination path is not a directory", outdir) if not os.access(outdir, os.W_OK): raise IOError(errno.EACCES, "Destination directory not writable", outdir) if not os.access(img_path, os.R_OK): raise IOError(errno.EACCES, "Source file not readable", outdir) log.debug("Loading image: %s", img_path) infile = QImage(img_path) if infile.isNull(): raise ValueError("Could not load image: %s", img_path) desktop, monitors = get_desktop_geom() log.debug("Image size before: %s", infile.size()) infile = infile.scaled(desktop.size(), Qt.KeepAspectRatioByExpanding, Qt.SmoothTransformation) log.debug("Image size after fitting to desktop with " "KeepAspectRatioByExpanding: %s", infile.size()) infile = apply_gravity(infile, desktop, gravity) write_backgrounds(infile, monitors, outdir) def is_image(path): """Determine whether the given path represents a potential background""" return os.path.splitext(path)[1].lower() in IMG_EXTS def pick_recursive(roots): """Recursively traverse a list of paths and pick an image file.""" log.debug("Picking random file from: %s", roots) potentials = [] for root in roots: if os.path.isfile(root): potentials.append(root) elif os.path.isdir(root): for path, _, files in os.walk(root): for fname in files: fpath = os.path.join(path, fname) if is_image(fpath): potentials.append(fpath) return random.choice(potentials) def main(): """The main entry point, compatible with setuptools entry points.""" from argparse import ArgumentParser parser = ArgumentParser( description=__doc__.replace('\r\n', '\n').split('\n--snip--\n')[0]) parser.add_argument('--version', action='version', version='%%(prog)s v%s' % __version__) parser.add_argument('-v', '--verbose', action="count", default=2, help="Increase verbosity. Use twice for extra effect") parser.add_argument('-q', '--quiet', action="count", default=0, help="Decrease verbosity. Use twice for extra effect") parser.add_argument('--gravity', default='top-left', choices=GRAVITIES, help="Choose how to align the image before cropping if" " its aspect ratio doesn't match the desktop.") parser.add_argument('--randomize', action="store_true", default=False, help="Randomly select an image from the given paths") parser.add_argument('paths', nargs='+') parser.add_argument('outpath') args = parser.parse_args() # Set up clean logging to stderr log_levels = [logging.CRITICAL, logging.ERROR, logging.WARNING, logging.INFO, logging.DEBUG] args.verbose = min(args.verbose - args.quiet, len(log_levels) - 1) args.verbose = max(args.verbose, 0) logging.basicConfig(level=log_levels[args.verbose], format='%(levelname)s: %(message)s') if args.randomize: args.paths = [pick_recursive(args.paths)] if args.paths: path = args.paths[0] if os.path.isfile(path): log.debug("Requested alignment/gravity: %s", args.gravity) try: set_background(args.paths[0], args.outpath, GRAVITIES[args.gravity]) except IOError as err: log.error(err) else: log.error("Not a valid file: %s", path) if __name__ == '__main__': main() # vim: set sw=4 sts=4 expandtab :

Posted in Geek Stuff | 2 Comments

Extracting The Soundtrack From Your Copy of Desktop Dungeons

Posted on 2015-02-22 by Stephan Sokolow

As I mentioned on previous occasions, I don’t take too kindly to people trying to make me pay once for a game and again for its soundtrack and, as a matter of principle, I rip my soundtracks straight from the data files I paid for rather than pirating the officially separated versions.

This time, it’s Desktop Dungeons. Unfortunately, this is a relatively recent Unity Engine game, so the only tool I’ve found which will extract the audio is Unity Assets Explorer.

Thankfully, it’ll run just fine inside Wine, so I wrote a script similar to what I did for Cave Story+.

So, here are the Linux instructions for extracting your Desktop Dungeons soundtrack from the game you bought:

Download Unity Assets Explorer 1.2 or newer
Use it to open DesktopDungeons_Data/resources.assets
Extract all of the .ogg files
Load them all in your music player and manually delete the ones which are sound effects. (You should be left with pairs of Intro and Loop files.)
Download the following script and install the packages listed in the Requirements section
Place the script in the same folder as your .ogg files, run it, and wait.

#!/usr/bin/env python2 # -*- coding: utf-8 -*- """Script to convert ripped Desktop Dungeons unity resources to an OST Usage: Place inside the same folder as your extracted .ogg files and run. Requirements: - Python 2.7 (3.x may work if you change the shebang) - SoX - oggvideotools """ from __future__ import (absolute_import, division, print_function, with_statement, unicode_literals) __author__ = "Stephan Sokolow (deitarion/SSokolow)" __version__ = "0.0pre1" __license__ = "MIT" import glob, os, re, subprocess camelcase_re = re.compile(r'((?<=[a-z])[A-Z0-9]|(?<!\A)[A-Z](?=[a-z]))') files = glob.glob("*.ogg") files.sort() # Group the files into tracks songs = {} for fname, match in [(x, re.match(r'(.*)(Intro|Loop)_?(\d)?\.ogg', x)) for x in files]: songs.setdefault(match.group(1) + (match.group(3) or ''), []).append(fname) try: os.makedirs('output') except OSError, err: if not err.errno == 17: raise # Race-less check for "already exists" for key, files in sorted(songs.items()): print(', '.join(files), '->', key + '.ogg') # Determine the final filename name = camelcase_re.sub(r' \1', key) # Generate a fade-out so the track doesn't just abruptly stop assert 'loop' in files[-1].lower() fade_base, fade_ext = os.path.splitext(files[-1]) fadename = fade_base + '_fade' + fade_ext subprocess.check_call(['sox', files[-1], '-C', '5', fadename, 'fade', 'h', '0', '6', '6']) # Losslessly concatenate the files subprocess.check_call(['oggCat', os.path.join('output', name + '.ogg')] + files + [fadename]) # Delete the temporary fade file os.remove(fadename) # vim: set sw=4 sts=4 expandtab :

Posted in Geek Stuff | 2 Comments

Simple CD-Ripping Wrapper

Posted on 2015-02-18 by Stephan Sokolow

Not much to report over the last few days. I was mainly busy ripping old CDs so I could store them in the closet.

cdparanoia -B and ddrescue (instructions) are essential for damaged audio tracks and CD-Rs. However, for old DOS/Win3.1-era CD-ROM games which use Redbook audio, they don’t really produce something that DOSBox or CDEmu+Wine can mount and play.

As such, I whipped up a quick little script for generating BIN/CUE pairs based on advice for ripping Playstation games under Linux. Here it is in case anyone wants it (you’ll also want my swab.py script that works but is long overdue for a rewrite):

#!/bin/bash # NOTE: If the generated file contains audio tracks, they will have the wrong # endianness for the .CUE file and something like BinChunker or my # swab.py must be used to rewrite the .BIN file before it can be # used. (This isn't automatic because swapping the byte order # will break the .TOC file the .CUE was generated from) # # Required packages: # - cdrdao (for the actual ripping and toc2cue) # - eject (for closing and opening the tray) # - genisoimage (for getting the volume name via isoinfo) # - kde-runtime-data (for the default completion notification sound) # - sox (for audio completion notification) DRIVE_PATH="/dev/sr1" DONE_SOUND="/usr/share/sounds/KDE-Im-Nudge.ogg" # Ensure the disc is loaded # TODO: Figure out how to wait for the TOC to be read eject -t "$DRIVE_PATH" # Get the volume name either from the disc or from the command-line if [ -n "$1" ]; then volname="$1" else volname=$(isoinfo -d -i "$DRIVE_PATH" | grep 'Volume id:' | awk '{ print $3 }') fi volname="${volname// /_}" # Ensure there's a containing folder and change into it mkdir -p "$volname" pushd "$volname" > /dev/null # Make sure we can get exclusive access to the disc umount "$DRIVE_PATH" # Rip it or die cdrdao read-cd --read-raw --datafile "$volname".bin --device "$DRIVE_PATH" --driver generic-mmc-raw "$volname".toc || exit 2 # Notify success and eject play -q "$DONE_SOUND" sleep 1 eject "$DRIVE_PATH" # Generate a .CUE file and make it clear if there are audio tracks to byte-swap # TODO: Find a way to generate an ISO if the full strength of BIN is excessive toc2cue "$volname".toc "$volname".cue > /dev/null # TODO: Detect if there are audio tracks automatically and, if so, byte-swap cat "$volname".cue # Offer a streamlined way to note down the CD key if present read -p "Does the CD have a CD-Key? " -n 1 -r echo if [[ $REPLY =~ ^[Yy]$ ]]; then $VISUAL "cd_key.txt" fi ## Properly quote the cue file contents. (an alernative to subbing in underscores) #sed -i 's@^FILE $[^"].*[^"]$ BINARY@FILE "\1" BINARY@' .cue popd > /dev/null #7z a "$volname".7z "$volname" && rm -rf "$volname"

Posted in Geek Stuff | Leave a comment

How to easily jekyll-import a WordPress site hosted on NearlyFreeSpeech.NET

Posted on 2015-02-07 by Stephan Sokolow

In the time since I last tried migrating my blog to Jekyll, it has gained an official WordPress importer. Unfortunately, that importer requires direct database access and NearlyFreeSpeech.NET doesn’t have the requisite Ruby dependencies.

…so I decided to hack around that. It’s much easier to run the importer locally, but NFSN doesn’t expose their database servers to the world at large… SSH port forwarding to the rescue.

Install the development headers for libmysqlclient
gem install jekyll-import sequel mysql2 unidecode`
Note: Make sure it does complain about `htmlentities` being missing or you’ll get a broken import with things like the / in </a> escaped.
Open up two terminal windows
In one terminal, adjust this SSH command and run it to forward the MySQL client port
ssh -L 3306:YOUR_DSN_HERE:3306 USERNAME_SITENAME@ssh.phx.nearlyfreespeech.net

In the other terminal, adjust and run this jekyll-import command to dump the blog

    ruby -rubygems -e 'require "jekyll-import";
        JekyllImport::Importers::WordPress.run({
          "dbname"   => "___________",
          "user"     => "___________",
          "password" => "___________",
          "host"     => "127.0.0.1",
          "socket"   => "",
          "table_prefix"   => "wp_",
          "clean_entities" => true,
          "comments"       => true,
          "categories"     => true,
          "tags"           => true,
          "more_excerpt"   => true,
          "more_anchor"    => true,
          "status"         => ["publish"]
        })'

Note: Make sure `host` is set to 127.0.0.1. If you use localhost, it will try to use a UNIX domain socket rather than a TCP socket and fail.

Exit the ssh connection to close the tunnel and start fine-tuning the exported content.

Unfortunately, I found jekyll-import insufficient (eg. it made no attempt to preserve permalinks) so I started investigating alternatives. I discovered that Pelican (a Python alternative to Jekyll) has some very appealing plugins (eg. [1] [2] [3] [4]), so I’ll probably use that instead.

Posted in Geek Stuff | 1 Comment

About the Author
I'm Stephan, a Linux user with a passion for open-source, UI/UX design, and exploring what makes fiction work.

In my spare time, I focus on (and write about):
- Programming (mainly in Python and Rust)
- Retrocomputing (mostly DOS but, as of January 2023, I also own a machine running Mac OS 9.2)
- Reading and Reviewing Fiction
- The odd bit of UI/UX design or literary theory
For notification of significant updates to existing posts, consider following me on Mastodon.
Popular Posts
September 2026

S M T W T F S

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

« Jul
Meta
- Privacy Policy
Geek Links
Otaku Links
- Know It Alls (HP fic recs)

About the Author

Popular Posts

Meta

Geek Links

Otaku Links