1 Correct answer
You can prompt the color picker to open via scripting:
app.showColorPicker(
app.activeDocument[
"default" + (app.isFillActive() ? "Fill" : "Stroke") + "Color"
]
);
If you were to save the above as a text file with a name like "openColorPicker.jsx", you can place it in the Program Files for your startup scripts and record an Action with Insert Menu Item (searching for "openColorPicker") targeting this script which lets you trigger it via hotkeys assigned to the action like F12. Th
...
Explore related tutorials & articles
12
Replies
I’ve seen tutorials on how to add the Foreground Color Picker to the keyboard shortcuts available in Illustrator
By TomMxEdit
Are you sure these weren't for Photoshop? Can you link to one?
It seems opeing the Color Picker and preparing it to receive hex code input for a different fill color of text is more complex than it at first appears.
It is. Scripting doesn't really simulate user actions, so if you were to want to apply a certain color to your selection you'd have to do all the logic above to determine which objects in your selection should be painted and etc. This actually set me down a path of looking further into AIA text (like exporting Actions) because there is a "Set Color" command that Actions use which skips all of this. If you could properly create the AIA text for a Set Color command from some given color, you could skip all the above logic and issues with the script -- it would more closely replicate the same action that a user would be doing.
I’m thinking this script must have the further functionality for either inputting values for the fill or stroke color of an object, is that correct? Does it test for the current focus of either fill or stroke? Or is there something else going on in the script?
That's right. The first line in the main function is:
var bool = app.isFillActive(),
This returns true or false (a boolean, hence the name) and then will apply to either Fill or Stroke depending on which it was opened with. So essentially the script checks if you're reassinging Fill or Stroke before doing anything else then uses that as the basis to know which it should be applying -- this again is a pretty longwinded way of doing it and you could much more easily handle this through Actions but that requires a lot of supporting work be done first (like properly encoding keys noted in that Github link).
1) If run "directly" by selecting the script as a script menu item, the script opens up the Color Picker and allows manual input of a color code number. In my case, I run it from the script menu using Keyboard Maestro as such:
If I were doing this through AutoHotKey (which is very similar to Keyboard Maestro) I'd probably run a sequence of key presses starting with Alt + F (selects File menu), R (selects File > Scripts), then double up keys to run the last entry in the Scripts menu. It's not ideal but it could be an alternative that also works given the problem you note with #2.
2) If I try to run the script inside of an Illustrator action -- run by pressing F12 -- when I press that hotkey the Color Picker opens with focus on the hex input window, ready for me to type a number. I manually input my selected color number. However, when I hit "Okay," Illustrator freezes (spinning beachball).
So, although the latest script runs properly when selecting it manually as a script menu item or from KM as a script menu item, it freezes Illustrator when called from an Illustrator action. Is that what you would expect?
I'd have to look into this. I've seen mentions on other threads about dealing with Actions that running one within another (like we're doing here, using an Action to run a script which itself creates and runs an Action) causes freezing. I wasn't sure if this was OS or app-version specific but it may just be a general rule-of-thumb. If this were the case (and it's very likely) then it does make sense here because the "inside" Action isn't opening the color picker but setting the color from our color value; the moment the picker closes would be the exact time freezing would occur.
Also, am I supposed to be entering the pre-determined color code someplace before running the script? Or does the script simply "take" you to the point of entering the hex number in the proper Color Picker window (which is what it seems to be doing)?
The script is supposed to take you there. Prompting the picker with a color value just sets the value to that given color, so if you were to have a green active fill then the picker should open on that green instead of coming up as black each time and so on.
Thanks again for the very interesting solution to this and for providing the first baby steps in my JSON education. Do you have a recommendation for the best book(s) to learn about JSON? Or would you say that language is on the way out and one’s time would be better spent learning a different language?
Well, JSON isn't formally a part of Extendscript but otherwise it's very much standard practice and arguably more relevant in modern coding than ever before. JSON is Javascript Object Notation, which is (and this is somewhat a simplification) a way of writing a given Javascript value to a string for use in a text file or as something like a message between two endpoints (like how Slack in your browser can prompt or open the desktop app version of Slack through WebSockets). So for instance, if I have a Javascript variable like this:
var data = {
foo: "bar",
list: [1, 2, 3]
};
alert(data.foo); // "bar"
Let's say we need to write the content of the variable data and everything inside no matter the count, how deep or complex then how would we do this? If we try writing it to a text file:
var tempFile = File(Folder.desktop + "/tempFile.txt");
tempFile.open("w");
tempFile.write(data);
tempFile.close();
It would come out looking something like this:
{
foo: "bar",
list: [1, 2, 3]
}
That doesn't look bad and seems like it might be fine, but how do we get it out? How do we make it so that it's an object again?
var tempFile = File(Folder.desktop + "/tempFile.txt");
tempFile.open("r");
var data = tempFile.read();
tempFile.close();
alert(data); // "\{\r\n\tfoo:\s\"bar\",\r\n\tlist:\s[1,\s2,\s3]\r\n}"
alert(typeof data); // "String"
It looks a lot different when we try to retreive it and it's a string. How would we fix that? Well you could theoretically use eval() on it to try and evaluate it's value though eval is very dangerous (and deprecated specifically due to this) because you're trying to evaluate something you might not understand the value of or that value could be rewritten/reassigned just before evaluation in certain methods for hacking.
The way we solve for this entire problem is by using JSON:
var tempFile = File(Folder.desktop + "/tempFile.json");
tempFile.open("w");
tempFile.write(JSON.stringify(data)); // <== Note the difference here
tempFile.close();
// You cannot do this in scripting natively, you have to add JSON2.jsx or a similar polyfill.
This means our new file looks like this:
{
"foo": "bar",
"list": [1, 2, 3]
}
Your first reaction might be "That looks identical to the first time" and, well, yeah 😏 It's very close. The real difference is that I can re-integrate this value from an external source like a file very easily:
var tempFile = File(Folder.desktop + "/tempFile.json");
tempFile.open("r");
var data = tempFile.read();
tempFile.close();
alert(data); // "\{\r\n\tfoo:\s\"bar\",\r\n\tlist:\s[1,\s2,\s3]\r\n}"
alert(typeof data); // "String"
data = JSON.parse(data); // Because we can parse a JSON, it can become identical to it's original value.
alert(data); // "[Object Object]"
alert(data.foo); // "bar"
And the difference looks very minor here only because I'm using such a simple example. JSON can't handle every kind of Javascript value though; it can't store functions or RegExp primitives mostly for security reasons; but you can store any amount of basic data like objects, arrays, strings, numbers, evaluated expressions, and so on regardless of the depth or complexity of that data.
AdChoices