Hi again. 🙂 A practical example... Alright...
But promise me you make yourself a hot beverage of choice (coffee-time!) before continuing if you're new to all this. Is important!
How to use this: the code below can be pasted in 1 single file and will work as normal when you run it. (at least, it does on my computer)
What it does:
It will give you 2 alerts. One where the stretchme class's instance IsStretch is still at it's default values, and one alert after modifying the value using SetLeft.
How it does it:
you'll see there are 2 big clumps of code, both starting with (function(){ and both ending with })();
These are both anonymous (they have no name) functions... Something similar to classes.
The final (); part is what "starts" them. At least, to my understanding. I'm by no means an excellent "programmer" so I might use somewhat confusing terminology at times. Apologies.
The top blob of code (the part containing this.StretchMe... ) is the class OP was asking about.
The bottom blob of code is the actual script/program/callitwhatyouwant that uses that top blob.
If we rephrase... the top blob The StretchMe class is used by the bottom blob Kukurykus class.
StretchMe contains data and can be used in different scripts easily.* Just write var x = new StretchMe(), include the file and it works.
The Kukurykys class is the part with a specific name, it immediately tells us something about what we're about to do. (In this case, the name is clear enough to me that when I read it, I know it's not part of my normal script files, not part of a "script that does anything", and your name is memorable enough for me to have my penny drop. 🙂
*move the whole top blob to a separate and #include it wherever you feel like using it.
I put it in one big chunk of code here just for demonstration purposes... So you can see everything easily.
Ok, hot beverage ready? here's commented code.
#target photoshop;
(function() {
this.StretchMe = (function() {
var _left = false;
var _right = false;
var _top = false;
var _bottom = false;
function constructor() {/* nothing special here */ };
constructor.prototype.GetLeft = function() {return _left;};
constructor.prototype.SetLeft = function(stretch) {_left = stretch;};
constructor.prototype.GetRight = function() {return _right;};
constructor.prototype.SetRight = function(stretch) {_right = stretch;};
constructor.prototype.GetTop = function() {return _top;};
constructor.prototype.SetTop = function(stretch) {_top = stretch;};
constructor.prototype.GetBottom = function() {return _bottom;};
constructor.prototype.SetBottom = function(stretch) {_bottom = stretch;};
constructor.prototype.NeedsStretching = function(){
return (_left && _right && _top && _bottom) ? true : false;
}
return constructor;
})();
}).call(this);
//A: This line wraps everything below in a nice little closed off /protected package
(function() {
var Kukurykus = (function() {
// These variables can be accessed from almost anywhere in the kukurykus class
var actDoc = "a reference to the active document set in the constructor.";
var IsStretch = "an instance of my StretchMe class";
function constructor() {
/* for me, this is where I fill up the variables I'm going to use everywhere
* there is usually not much in here...
*/
IsStretch = new StretchMe();
alert("constructor alert: "+IsStretch.GetLeft());
actDoc = app.activeDocument;
this.init();
}
constructor.prototype.init = function() {
/*this is called in the constructor: this.init(); */
// changing the value of isstretch
IsStretch.SetLeft(this.checkLeftForStretching());
//after gathering my data in init(), I move on to main() to do the actual changes
this.main();
};
constructor.prototype.main = function() {
// setup document
this.PrepareDocument();
/* do the stretching. (content-aware stretch, selection + transform, ... )
* in this case, give an alert that shows you that IsStretch is an object, and IsStretch.GetLeft() gives you a value.
*/
alert("main alert: " + IsStretch + ", " + IsStretch.GetLeft());
/* Why do all this?
* Well, I can now do this, and everybody will understand what it's doing.
* To me, that's the main benefit. It makes everything readable if you come back to it 2 years later.
*/
if(IsStretch.NeedsStretching()){
if(IsStretch.GetLeft()) {
//do the thing you want it to do
}
if(IsStretch.GetRight()) {
//do the thing you want it to do
}
if(IsStretch.GetBottom()) {
//do the thing you want it to do
}
if(IsStretch.GetTop()) {
//do the thing you want it to do
}
}
};
constructor.prototype.PrepareDocument = function() {
try {
//ps prefs
displayDialogs = DialogModes.NO;
app.preferences.rulerUnits = Units.PIXELS;
this.setColorPickerToDefault();
//doc settings
activeDocument.changeMode(ChangeMode.RGB);
activeDocument.bitsPerChannel = BitsPerChannelType.EIGHT;
activeDocument.convertProfile('sRGB IEC61966-2.1', Intent.RELATIVECOLORIMETRIC, true, true);
activeDocument.resizeImage(activeDocument.width, activeDocument.height, 72);
} catch (e) {
$.writeln("Line: " + $.line + " in \" " + $.fileName + "\"\n--------------\n" + e + "\n");
}
};
constructor.prototype.checkLeftForStretching = function() {
var result = false;
/* Code to get a selection on the left of the document.
* Using SelectSubject, or MagicWand or whatever else */
var TheCodeSaysIts = true;
result = TheCodeSaysIts;
return result;
}
return constructor;
})();
/* This line "starts" the code inside the var Kukurykus. So all the code above here, up until A: is known to photoshop before starting. */
new Kukurykus();
/* This is the end of "A", wrapping up the whole code in one anonymous function. Ready for christmas.
* Why do this? --> You're now sure that all the variables inside here can't appear anywhere else.
* Very nice if you work with multiple people writing scripts or have another script running (event manager) that also happens to use IsStretch as a variable name ...
* --> It doesn't matter if your variables have the same name as the other script. They're protected in here.
*/
})();
18
Replies
AdChoices