Make Folders

Make Folders (for Capture One 20)
A version of the application for Capture One 20. Application delivered as .dmg file.

 Buy Now View Cart

Support notes

  • This version is for Capture One 20 (13.1.0) -> (13.1.4.) only. Tested on Catalina and Mojave.
  • Mac only!
  • Sessions only
  • The app uses the location of the sessions current capture folder as start point, and builds inside it.
  • The purchase and licensing entitles the app to be used by 1 user. For bulk licensing contact us.


    Make Folders v21 (for Capture One 21)
    A version of the application for Capture One 21. Application delivered as .dmg file.

     Buy Now View Cart

    Support notes

  • This version is for Capture One 21 (14.0.0) -> (14.1.x.) only. Tested on Catalina and Mojave.
  • Mac only!
  • Sessions only
  • The app uses the location of the sessions current capture folder as start point, and builds inside it.

  • What is it?
    The MakeFolders! app allows Capture One users to do bulk Capture folder creation based on a few chosen parameters.

    What does it do?
    On run, the app will:

  • Present different formats to choose from
  • Pick from several parameters – delimiter, digits in counter and how many folders
  • The app will then make all the folders!
  • Who is it for?
    If you are a tech and are always making Capture folders, this might save you a few hours a year.

    How do I use it?
    Either run as an app from the dock or applications, or copy the .app to the Capture One Scripts folder and run from the scripts menu.

    The purchase and licensing entitles the app to be used by 1 user. For bulk licensing contact us.


    Install notes

    Run the .dmg and drag drop the app to applications

    Once installed to applications, I recommend referencing the install in the dock for easy access. Drag the app from applications to the dock to do this. You can also install it to Capture One’s scripts menu as per the article here – but be sure to copy the installed application reference – not the .dmg.

    After running the .dmg and installing, on first run you will see this dialog warning that this is a script file and needs to interact with another app/s to work. These are normal for script applets. The app is otherwise code signed and stapled in accordance with Apple guidelines. Press OK for any dialogs encountered.


    Using the app

    1. The app gives a number of choices for folder format, with [ ] as variables:

  • [ISODATE] [ClientName] “S”[DigitCounter]
  • [ISODATE] “Shot” [DigitCounter]
  • “Shot” [DigitCounter]
  • [SessionName] [DigitCounter]

  • 2. Delimiter just means what do you want to split your elements up with. I’m a big fan of snake case so use “_” but I’m old. Pick what you want and the script will use this in-between each variable in the format.


    3. Depending on the format chosen you may have opportunity to tune the date or free text. Date is automatically taken from the OS so unless your clock is bollocksed this should be as the date you run the script.


    4. Client name is only relevant for the first format choice. It is designed as a custom free text field so if you don’t have a client that is also ok – make something up.


    5. Similar to how C1 does token counters. Pick how many digits you want in the counters – 3 = 000, 4 = 0000 etc.


    6. Lastly the heavy part. How many folders do you want? 5? 10? 1500? Plug it in and press ok to makeFolders! As previously noted, the app uses the location of the sessions current capture folder as start point, and builds inside it. The result is automatically added to favourites.

    If you set a new folder as Capture and run the app again it will build inside that. This can be useful if you need to create folders within folders, but it can also create lots of folders in the wrong place – so beware.


    Clipboard To Capture

    Clipboard To Capture (for Capture One 20)
    A version of the application for Capture One 20. Application delivered as .dmg file.

     Buy Now View Cart

    Support notes

  • This version is for Capture One 20 (13.1.0) -> (13.1.4.) only. Tested on Catalina and Mojave.
  • Mac only!
  • Sessions only
  • The app uses the fixed path sessionnName/Capture/ as start point, and builds inside it.
  • I find this works best when added to the dock for quick access.
  • The purchase and licensing entitles the app to be used by 1 user. For bulk licensing contact us.


    Clipboard To Capture v21 (for Capture One 21)
    A version of the application for Capture One 21. Application delivered as .dmg file.

     Buy Now View Cart

    Support notes

  • This version is for Capture One 21 (14.0.0) -> (14.1.x) only. Tested on Catalina and Mojave.
  • Mac only!
  • Sessions only
  • The app uses the fixed path sessionnName/Capture/ as start point, and builds inside it.
  • I find this works best when added to the dock for quick access.
  • The purchase and licensing entitles the app to be used by 1 user. For bulk licensing contact us.


    What is it?
    A simple widget for making a Capture folder from the OS copy/paste clipboard. Useful for grabbing any source of text (e.g. an Excel cell) and making a Capture folder from it.

    What does it do?
    On run, the app will:

  • Take whatever is on the paste board
  • Display a dialog of whatever, allowing you to edit it (if you maybe copied something wrong)
  • Click “Ok”, and the app will make a new Capture folder with the result as the name of the folder
  • Irrespective if you like naming things with “.” as part of your naming, or if you include something by mistake – there are certain characters which are defined by Apple as illegal or ill-advised if encountered in certain combinations in folder names. In these cases the app will substitute illegals for “_” (underscore) for the sake of stability.
  • Who is it for?
    If you work from long shot lists in Excel this may save you from killing yourself.

    How do I use it?
    Once installed from the dmg, just click-to-run. I suggest though using this one on a shortcut.

    It is designed in a way to act just like a script and so can be installed and shortcut as per the article here or you can shortcut to the app itself as per the Monogram workflow.


    Install notes

    Run the .dmg and drag drop the app to applications

    Once installed to applications, I recommend referencing the install in the dock for easy access. Drag the app from applications to the dock to do this. You can also install it to Capture One’s scripts menu as per the article here – but be sure to copy the installed application reference – not the .dmg.

    After running the .dmg and installing, on first run you will see this dialog warning that this is a script file and needs to interact with another app/s to work. These are normal for script applets. The app is otherwise code signed and stapled in accordance with Apple guidelines. Press OK for any dialogs encountered.


    Using the app

    1. Copy some text from a source – this can be Excel, textEdit, web or just about anything that is considered text when copied to the OS clipboard.

    2. Run the app – either invoked from shortcut or from the dock. The text is presented in a dialog in case you copied some bum text or want to edit it.

    3. Hit return or press ok – the text will be passed as a new Capture folder to C1.


    Auto Reset Batch Counter

    Auto Reset Batch Counter (for Capture One ’20)
    A version of the application for Capture One 20. Application delivered as .dmg file.

     Buy Now View Cart

    Support notes

  • This version is for Capture One 20 (13.1.0) -> (13.1.4.). Tested on Catalina and Mojave. Mac only.
  • Sessions and Catalogs supported.
  • The purchase and licensing entitles the app to be used by 1 user. For bulk licensing contact us.


    Auto Reset Batch Counter v21 (for Capture One ’21)
    A version of the application for Capture One 21. Application delivered as .dmg file.

     Buy Now View Cart

    Support notes

  • This version is for Capture One 21 (14.0.0) -> (14.1.x.). Tested on Catalina and Mojave. Mac only.
  • Sessions and Catalogs supported.
  • The purchase and licensing entitles the app to be used by 1 user. For bulk licensing contact us.


    What is it?
    Every time you process a batch (x images) the counter will remember x and continue from x in the next batch. This is sometimes suboptimal behaviour, often requiring manual reset of the counter between runs/committing the second batch. This app will automatically set the counter to 0 when the batch finishes.

    What does it do?
    The app is:

  • Designed as a toggle. Click once to enable listening, again to disable
  • If enabled, when the processing finishes, the output counter is reset to 0
  • Who is it for?
    Any digi or user with a workflow where you might have to create sequences always starting with 1.

    How do I use it?
    Once installed from the dmg, just click-to-enable/disable.


    Install notes

    Run the .dmg and drag drop the app to applications

    Once installed to applications, I recommend referencing the install in the dock for easy access. Drag the app from applications to the dock to do this. You can also install it to Capture One’s scripts menu as per the article here – but be sure to copy the installed application reference – not the .dmg.

    After running the .dmg and installing, on first run you will see this dialog warning that this is a script file and needs to interact with another app/s to work. These are normal for script applets. The app is otherwise code signed and stapled in accordance with Apple guidelines. Press OK for any dialogs encountered.


    Using the app

    1. The app is designed as a simple toggle. Launch the app from the dock once – this will enable the automatic resetting of the counter.

    2. If you want to disable the behaviour, Launch the app from the dock again – this will disable the automatic resetting of the counter.

    Store coming!

    Over the last few weeks I have been burning hours on fine tuning, code signing, stapling and testing a bunch of apps and widgets for the DIT community using Capture One – and – with the help of some awesome people at FastSpring will finally be able to get these off my desktop and into the world.

    Still some work to do on the back end, but over the next few weeks or so we will have the first releases available to download, starting with Capture One ’20 support, with ’21 supported versions soon after.

    App release plan stage one:

    Folders From Text List – a bulk folder creator from a txt file
    Batch Output Counter Auto reset – a toggle which sets counter to 0 when every processing job is finished
    Clipboard To Capture – copy some text from any source and convert to a Capture folder
    Make Folders! – another bulk folder creator, but takes several params to build a sequence of folders

    If you would like to be notified of a particular app release, or have a request for something particular, hit me up on the contact formula here.

    Folders From Text List

    Folders From Text List (for Capture One ’20)
    A version of the application for Capture One 20. Application delivered as .dmg file.

     Buy Now View Cart

    Support notes

  • This version is for Capture One 20 (13.1.0) -> (13.1.4.) only. Tested on Catalina and Mojave.
  • Mac only!
  • Sessions only
  • The app uses the fixed path sessionnName/Capture/ as start point, and builds inside it.
  • I find this works best when added to the dock for quick access.
  • The purchase and licensing entitles the app to be used by 1 user. For bulk licensing contact us.


    Folders From Text List v21 (for Capture One ’21)
    A version of the application for Capture One 21. Application delivered as .dmg file.

     Buy Now View Cart

    Support notes

  • This version is for Capture One 21 (14.0.0) -> (14.1.x.) only. Tested on Catalina and Mojave.
  • Mac only!
  • Sessions only
  • The app uses the fixed path sessionnName/Capture/ as start point, and builds inside it.
  • I find this works best when added to the dock for quick access.
  • The purchase and licensing entitles the app to be used by 1 user. For bulk licensing contact us.


    What is it?
    The folders from text list widget allows Capture One users to do bulk Capture folder creation from a single text file.

    What does it do?
    The app will:

  • Take each new line in the text file -> name of a folder
  • Make the folder inside the current Capture folder
  • Add the folder to favorites area
  • Irrespective if you like naming things with “.” as part of your naming, or if you include something by mistake – there are certain characters which are defined by Apple as illegal or ill-advised if encountered in certain combinations in folder names. In these cases the app will substitute illegals for “_” (underscore) for the sake of stability.
  • Who is it for?
    Any digi or user with a workflow where you might have a shot list that needs converting to Capture folders quickly and without loosing the will to live.

    How do I use it?
    Once installed from the dmg, either click-to-run and pick the text file, or drag drop the text file on to the app.


    Install notes

    Run the .dmg and drag drop the app to applications

    Once installed to applications, I recommend referencing the install in the dock for easy access. Drag the app from applications to the dock to do this. You can also install it to Capture One’s scripts menu as per the article here – but be sure to copy the installed application reference – not the .dmg.

    After running the .dmg and installing, on first run you will see this dialog warning that this is a script file and needs to interact with another app/s to work. These are normal for script applets. The app is otherwise code signed and stapled in accordance with Apple guidelines. Press OK for any dialogs encountered.


    Using the app

    1. running the app will give you the chance to pick a .txt or .text file.

    2. You can also drag drop the .txt or .text file onto the application.

    3. Each line of text is passed as a new folder and added to Capture One. Note in this grab how the illegal characters are handled.


    Automation workflows with Monogram

    The following was done with Monogram Creator (beta) and a set of the new Monogram Creative Console Studio tiles, in C1 v20.

    This week I was lucky to enough to get hold of the new Monogram kit for evaluation. We sometimes get clients looking for a simple “push this big button -> do workflow” for reducing C1’s somewhat idosyncratic techincal cruft, and so I wanted to see if it could be a useful solution.

    For the uninitiated, Monogram could be equated to a sort of modular “midi controller”; buttons and dials that can be assembled together into a custom controller panel.

    Full disclosure, I have Tangent gear, which I love. Two reasons for looking at this set was:

  • Lower price point makes it easier to approach if you only need a few buttons
  • Desktop footprint is tiny, and more suited to some environments that don’t want full editing solutions (like eCom)
  • The kit I recieved included a new module (Orbiter) which can be used for color grading (different execution, but similar result to how the Tangent balls work) – otherwise the buttons, sliders, and knob modules from the previous generation kit return (albeit redesigned).

    New is the LED illumination on each panel (nice for insinuating function) and the colors are configurable via the new Creator application. The Creator software integrates well with Capture One’s editing tools and is pretty responsive. It also has the ability to emulate shortcuts.

    I’m not doing a full run down of what it does when editing, how it does it or why/if you need it. This is not a review post.

    This post is simply about how best to create a bridge between the devices and the automation capability of C1.


    Launching scripts

    Ideally I just want to press a button and run the automation, but there isnt native support for “run this script” in the Creator app. If C1 is focused you can of course emulate the shortcut to the menu item in C1, but if it isn’t, then a small change up in webbing the stuff together is needed.

    As scripts can be exported as an “.app”, and as scripts can be made to run “on open”, I found a solution:

  • My script saved as an .app
  • A shortcut – potentially global (one that works at any time from any app) to “open application”
  • Configure the button in monogram to emulate said shortcut.
  • As per previous posts on making applets and custom shortcuts the scripts are complied as apps and saved in Capture One’s scripts menu. They still work just like scripts – and can be invoked with your custom shortcuts.

    BUT – by saving the scripts as an app, they can ALSO be copied into the applications folder and launched just like a “real” application (as long as the script logic is within the “on run” handler).

    This also means you you get an extra benefit in that can launched like an application at any time by adding them to the dock. This is great if you don’t have CO focused – you just drop down the cursor to the dock and click-to-run.


    Setup

    1. Save your script as an .app in your applications folder…

    2. Using this post on automator as a guide, create a service to open the app…

    3…. and add a shortcut to the service…

    4. Configure monogram creator to call the same shortcut you set to the service in the system prefs…

    You now have a simple button that will run the automation at anytime from anywhere!


    About Monogram

    Monogram was formally Palette Gear. This set is part of their second gen hardware and software. You can find out more about Monogram here.

    Get Started With AppleScript – Conditional Processing pt1

    The following project/idea I originally produced for the Project Lemonade series for Digital Transitions webinars. The following is a short version of it, if you want to see the full webinar visit and sign up to the DT archive here.

    Before we get started…

    For part 1, we will concentrate on writing the script as if we are mirroring the same logic of using Capture One UI and UX concepts. I’m fully aware there are several approaches, model shortcuts, logic and advanced syntax to ultimately achieve the same results.

    However, this “parity” method I have found is a great way to learn the concepts of scripting Capture One, without blowing your mind on day 1. It also helps underline the moving parts within Capture One. Once we have a good base we can look at the advanced stuff and change up the gears in pt2 and pt3.

    The reason for pearoasting this is, it is a good project covering many of the core/fundamentals of Capture One scripting:

  • Code block
  • Comments
  • Variables
  • Operators
  • If/else statements
  • Selections
  • Commands
  • If you are new to scripting, check out our other posts on getting started.

    Let’s start!


    Conditional Processing

    Why automate processing? Processing/converting images – from RAW to an RGB image format – in batches is fairly well supported in Capture One as a feature. You might ask why you would want to automate it further.

    The kind of case where this makes sense is when the requirments change to more than just: “process everything as TIFF”.

    What if there are certain recipes that should act on images with certain properties? For example, if the image has red tags, process it to here; if they have a certain meta data, process them only as Jpeg.

    This kind of problem occurs in more production type environments where you might need extra dynamism – or one where your users dont have technical accumen to select/deselect the necessary images, switch on/off or change recipes paths and so on.

    This kind of scenario is when errors happen, and errors at scale are expensive.

    Luckily, this is great example of something we can automate!

    File>New…

    Open a new script file in your IDE and paste in the first bit of code below. Use ⌘+K to compile.

    This is what we refer to as a tell block. In AppleScript code blocks start with tell and close with end tell.

    When addressing the application, we always start with “tell “. This directs the script to the application “object”: the first object in the “application model”. All the code between this tell/end tell is directed at the application in question.

    AppleScript is an “object orientated” language. Understanding the model of how the objects are arranged and inherited is key to making scripts for Capture One.

    A good analogy for this is to think of it much like a russian doll. The biggest object is the Application. This contains the next biggest object, the document (session or catalog), which contains the collections (favourites, albums, folders) and these contain variants/images. This is called “object inheritance”.

    As the scripter, we have to make sure our commands are directed to the right objects, and this requires navigating the “levels” of the model in the code.

    As per previous article ScriptDebugger is recommeneded for many reasons but one of the stand out reasons for me is the object model view in the dictionary. This is great for inspecting objects and viewing the model of any AppleScript capable model.

    Next, within the tell application block, we now need to talk to the next object in the model – the document.

    Much like as if you opened a session to see some work, we want our script to work on the document in front of the user.

    As we are only interested in the document we are working on we can use a special object “current document” – this refers to the application’s top most open and active session or catalog. Again we use tell to direct the script to the document object.

    The point of this script is to only process what we are seeing in the document, much like as if we were to do it manually. In order to this next bit, we need to understand about targeting the right “variants” for processing, then committing those to the batch queue.

    Our script so far is talking to the document level, but when the user interfaces with images in the UI, you are always in some sort of “collection”. This can be a folder, album, favourite or any other “container” concept of Capture One that holds images.

    As with current document, there is another super useful object to the collection currenly selected in the UI and thus being viewed by the user – current collection.

    Again, we nest within a tell block.

    This makes sure that the script is only targeting the variants for processing that are A: in the document we have active, and B: in the collection we have selected within that document. Again, this is mirroring somewhat the intended user experience of Capture One’s app design.

    The next part is really a design choice – you could decide you want the script to work on every image in the collection regardless of selection, or just on a number of images selected by the user. So we don’t break character with our user experience/parity mission, let’s work on the user selection.

    Note
    “variants whose selected is true” is a newer syntax from v11 onward, and replaces “selected variants”
    This syntax returns a list of variant objects.

    The repeat (control statement) is designed to loop through the code nested within it, x number of times (which in this case is equal to the number of variants we have selected in the UI). theVariant thus becomes the next variant in the list in each loop.

    We use it here as we want to check every variant given to the script. What to check it for, is defined in the code between repeat and end repeat. As theVariant becomes a variant object we can now use a tell block to talk to it as if we we talking to a variant directly.

    We are now at the fun part, where we decide the design what we want to do with each variant our script encounters.

    Let’s use an IF statement to decide a condition. IF statements only execute the code in the block if the IF equates to true. You can extend IF statements with additional conditions using ELSE IF, which if the first IF equates to FALSE, will run next. You can also use an ELSE statement; if all of the above is FALSE, do this.

    What to check is TRUE is a good question. A simple example is color tag. Ben Liddle looked at color tag peculiarities in his post here, but the short of it is, Capture One uses the numbers 1-7 to represent the colours Red-Purple. In doubt, think of how a Rainbow looks, and count in from Red.

    Note also the — following the first IF. This is an (inline) code comment.
    This allows the scripter to write anything after the line as a comment as to what you were doing or other useful notes that might help decipher what was going on when you come back to it later. Inline comments must be made after the code, not in the middle. You can also start a new line with — and this will also compile as a commented line. Commenting is also useful for removing redundant code, or excluding troublesome stuff when debugging.

    We thus check (in the first If statement) if the color tag is 1 (RED). if it is, then line after will execute. If it isn’t, the code skips to the next ELSE IF and checks if the color tag is 4 (GREEN). If it is, the line after will execute; if not, we go to the final ELSE (the garbage collector) which will set the color tag to yellow – indicating unprocessed.

    But what of our images that were GREEN or RED?

    The process command is added last. Process has two parameters: a list of variants to be processed, and the name of the recipe to use. For RED images, I want the script to process using the recipe “JPEG”, for Green, I want to use the recipe called “TIFF”. For variants that are neither, I will mark those Yellow, just to let me know these weren’t processed.

    Note

    You need to have your recipes defined in Capture One interface and named accordingly. This script is only “pulling on the handles” and assumes the recipes exist. We should make our scripting more robust and check the recipes exist before running – hell maybe even remake them if they don’t, but this is for another day.

    This script is now fully functional, and can be installed and executed from Capture One’s script menu as per this article.

    Get Started With AppleScript – Scripting Selections

    An intro series to scripting Capture One, with Ben Liddle

    Splitting hairs: Variants v. Images

    The thumbnails in Capture One’s browser pane are technically variants. A variant is a unique set of rendering instructions for a given source raw (or TIF, JPG, etc) image file. These instructions are lightweight (few hundred Kb at most), so you can think of these as virtual copies of your image files. Every image file you view in Capture One has at least one variant; unless you objectively create a new variant, there’ll be a 1:1 ratio of variants and images in your browser.

    Setting up the Handler

    Below is the code to set up the AS hander. Create a new script file and save this to the top of the file. Handlers are basically bits of code that you can call from anywhere else in the code (once you have already defined it, thus putting this at the top). They start with the on keyword, and are called with my (when they’re located in the same .scpt file as the code that’s calling it, but you can ignore this for now).

    Let’s break it down:

    Here, I’m declaring that we’re creating a handler arbitrarily called select_vars. The bit in parentheses is a parameter that I’m declaring. Basically, when we call this handler later on, we’ll be passing a variable as well. The ‘as string’ tells the script that whatever I pass to select_vars later on, it must be a string; eg if later on I pass it an integer or list, we’ll get an error.

    The color tags in Capture One are scripted to numeric values between 1 and 7. Here, I’m building a list of readable color tag names in their order: a red tag is actually a 1, a green is actually a 4, etc.

    Repeat with a variable i, from 1 to the length of (ie count) of the color tag list. On each loop through (iteration), i is the index (position) of the item in the list.

    Here we’re checking if the item in position i is the same as the text variable I’m setting. If so, create a new variable called color_tag_number and set its value to the current iteration’s value of i.

    Collect all variant objects of the current collection whose property color tag’s value is equal to the value of color_tag_number . Create a new variable, sel_vars, to store references to them. Since we used the plural of variant, our variable sel_vars is a list.

    The current document is being told to select the variant objects referenced in sel_vars. This is actually an additive select- if we had four other variants selected, we’d have the count of green-tagged images plus those four selected. This can be prevented by throwing in a deselect command before the new select command:

    With this handler set up, we can call it wherever we want in the script without repeating the code block:

    Et voila. Variants selected.

    Ben Liddle is a data manager in Colorado who automates the shit out of the first half of the work/life balance so the second half can be more fun.

    Get Started With AppleScript – Basics

    An intro series to scripting Capture One, with Ben Liddle

    Preamble

    Years ago, in a warehouse in deep industrial Brooklyn, I was a digital technician on an e-commerce photo shoot struggling to stay awake. It was 3:30 in the afternoon on a crisp winter’s day, and the stylist was diligently stringing up the 80 billionth (by my estimate) crossbody’s strap of the day. The photographer was (probably) retouching his latest editorial job on his laptop in the corner. I was working with Capture One Pro 8 (iirc, maybe it was 7, honestly there wasn’t much difference for this workflow), and pulling up yet another go-by for styling reference. It was one of those shit days where you arrive on set at call time before sunrise and just know in your bones that you’re not leaving before sunset.

    As an aside, if you’re reading this and you were on set that day, I don’t mean to offend. I look back fondly on those days, those mid-shoot conversations, the catering, but I think we can all agree that it wasn’t the most enthralling of experiences.
    The actual “work” I was doing on that job was mostly completed in the setup day from the week earlier; after that, it was scan the barcode, create a new Capture folder, name the capture folder, reset the capture counter, set the camera to Live View, set up the proper go-by as an overlay, make sure the stylist can see the Live View, take test shots, check focus, color tag images, process, comp in Photoshop, hit Chronosync, rinse, repeat ad nauseum.

    If you’ve worked e-commerce, you probably had a similar flow.

    I did this for years and years to pay rent, in between the “fun” jobs that filled up my passport pages. I figured there had to be a better way; a way to be lazier, yet not fuck up. Just do less. Fast forward a few years, ~13 versions (Capture One 20-Capture One 7=Capture One 13, the math checks out, fight me), and there’s little from that day on set that can’t be automated. Well, afaik you can’t automate rigging a crossbody strap to match the 799,999,999,999 previous, but I digress. My heart goes out to you still, stylist.

    Heads up!

    I’ll be using Capture One 20, since it’s known to be the most scriptable of the Capture One versions. If you haven’t tried Capture One 20, you can get a trial at https://www.captureone.com/en.
    If you’ve made it this far and are on Windows, I’m afraid I can’t help you achieve peak lazy. As of this writing, only Capture One on macOS (and OSX, if you’re feeling retro) can be automated via scripts.

    Capture One can run .scpt files in AppleScript (aka AS), Javascript for Automation (aka JXA), and AppleScript-ObjC. Frankly, I’m most comfortable in AS, have fairly extensive experience with JXA, but little/none with AS-ObjC. There’s obviously syntactical differences between the three languages, and for the purpose of these articles, I’ll be dealing mostly with AS.

    For the rest of this story, I’ll be doing a bit of beginner’s intro to AppleScript and Capture One. If you have experience with AS, I suggest checking out the next post in this series: Selecting Variants and Images

    Hello, World

    As an introduction, we’re going to write a basic Hello, World to illustrate running scripts in Capture One. There are many, many IDEs (Integrated Development Environment, basically software for writing code) out there. For AS specifically, I’ve used a few:

    Script Editor: already bundled with macOS. Simple. I’d say use this to get your feet wet, and for the first few stories I’ll be screen-shotting from this.

    Atom (https://atom.io/): Open source text editor that can do just about… anything? You’ll need a few extensions to get it to parse/compile/execute AS, but it’s pretty.

    Script Debugger (https://latenightsw.com/): My preference. Extremely verbose and powerful. Not free though, still a bargain at any price if you end up creating any complex automations, especially if they involve multiple applications.

    Open up your IDE and create a new script named hello world.scpt.
    Here’s the code we’ll be adding. Note: comments in AS are denoted by starting with — . Comments are blocks of the code that aren’t actually run and are used to explain what’s going on.

    Press cmd+k to compile the script. If it compiles correctly, you’ll get indentations, syntax-based highlighting, the whole works. If not, you’ve made an error.

    Hit the Run button to run the script.

    Congrats. That’s AppleScript 101. You can find more on the basics here:

  • Mac Automation Scripting Guide (from Apple)
  • Introduction to AppleScript Language Guide (from Apple’s documentation archive)
  • AppleScript Beginner’s Tutorial (from macosxautomation.com)
  • Hello (name of document)

    Let’s start working with Capture One directly to get the name of the document; your session or catalog database file:

    It’s worth pointing out here that the above code has the display dialog verb within the tell current document block. Because it’s nested, the current document is the one calling the display dialog. Any further interaction with the current document is blocked until that dialog is cleared (one of the buttons is pressed). This code appears to result in the same actions, but since display dialog is outside of the tell application and current document blocks, it’s the OS that’s calling it:

    Because we stored the document’s name in the variable doc_name, we can extract that data and use it anywhere we like!

    That’s a good enough intro. In the next story, we’re diving into some more complex workflows.

    Ben Liddle is a data manager in Colorado who automates the shit out of the first half of the work/life balance so the second half can be more fun.

    Wrap beers

    To close the year out we thought we would end with an “off-topic” post on something close to every digi’s heart: beer!

    Inspiration for the is post comes via an annual TV show we get in Denmark (which is very, VERY Danish) – the Natholdets Julekalender.

    The premise for the show is quite simple: Beer expert Carsten Berthelsen takes Anders Breinholt (a sort of ginger Jimmy Falon/Jonathan Ross) and Søren Rasted (keyboardist from the band Aqua) on a “våd rejse” (wet journey) to decide which are a best three christmasy beers for 2020.

    The show is recorded in one day, and a beer for every day of advent (24 total, pre-selected by Berthelsen) are tried. Every 5-10 minutes a new beer is provided in a glass which they must taste – along the way they choose the top 3, which is placed up front on the mini podium.

    They are allowed toilet breaks, but no water. In addition to the beer, there are 4 “Advent-Sunday days” and this also requires a Schnapps shot be taken. The result is something you probably wont see anywhere else – three grown men, absolutely ratfucked trying to hold together a tv show.

    That all aside, the beer list is actually an impressive offering from Denmarks microbrew/craft scene. The full list is below. At the time of writing (afsnit 18) the best 3 beers were:

    • Thisted Bryghus: Julesten (Strong Ale) – 8 % (1st)
    • Bryggeriet Åben: First Light (New England IPA) – 6 % (2nd)
    • Herslev Bryghus: Juleøl (Red Ale) – 6 % (3rd)

    Full list:

    • Nørrebro Bryghus: Bombay IPA (West Coast IPA) – 6,5 %
    • Bryggeriet Åben: First Light (New England IPA) – 6 %
    • Viborg Bryghus: JuleBocken (Doppelbock) – 7,3%
    • Beer Here: Ammestout (Milkstout) – 6,5 %
    • Alefarm Brewing: Decorations (Pale Ale) – 5,2 %
    • Midtfyns Bryghus: Funky Santa (Imperial Brown Ale) – 8,5 %
    • Kissmeyer: Stockholm Syndrome (DIPA) – 9,5 %
    • Flying Couch: Icebreaker (New England IPA) – 6 %
    • Skagen Bryghus: Klitnisse (Doppelbock) – 6,8 %
    • Mikkeller: Sally, oh Sally (Kölsch) – 4,9 %
    • Bryggeriet Skands: Blå Chimpanse (Dubbel) – 6,5 %
    • People Like Us: Oats of Disobedience (Havrestout) – 5,3 %
    • Thisted Bryghus: Julesten (Strong Ale) – 8 %
    • Braunstein: Dragonfly Coffee Bean (Kaffestout) – 9 %
    • Timm Vladimirs Bryghus: Pale Alene i Verden (Pale Ale) – 5 %
    • Grauballe Bryghus: GunsmOak (American-style Ale) – 7,8 %
    • Herslev Bryghus: Juleøl (Red Ale) – 6 %
    • Syndikatet: Hippien (Imperial Saison) – 10 %
    • Aarhus Bryghus: Juletønden (Strong Ale) – 8 %
    • Hancock: Julebryg (Doppelbock) – 10,5 %
    • Albani: Blålys Juleøl, Jubilæums Craft Version (Doppelbock) – 7,5 %
    • Hjort Beer: Brown Bella (Dubbel) – 7,4 %
    • Bryggeriet FRANK: Sinterklaas in Space (Dubbel) – 8 %
    • Amager Bryghus: Secret Santa (Quadrupel) – 10,5 %

    We found a vendor selling a “kit” online, sadly they were out of stock by the time I got this up.