PSP Blog Hop

I have donated a prize to the First Annual PSP Blog Hop.  It is a script that will make an 280pt chipboard alpha containing capitals and the numbers 0-9.  Or, for the scripting-shy, I will provide 5 Chipboard alpha templates (also containing capitals and the numbers 0-9) in the fonts of your choice.  You can find the entry form for my prize at the Official Blog Hop blog.

This is a one-off prize which means that I will not be offering it for free on my blog.  In order to get the prize, you have to fill out the prize entry form at the PSP Blog Hop.

I noticed that one of the requirements to win the prize is leaving a comment on the prize post at the Blog Hop.  However, I can't see any way to leave a comment over there.

Pinwheel Script

This is the script that I made while writing up the pinwheel tutorial.  It has been tested and should work in all versions of PSP 9 and up.

Script

Sequin Script

Here is a script for PSP users. It has been tested and works in all versions of PSP 9 and up.

Script

Interactive Script Steps

When the execution mode button on the script tool bar is selected, a script will run in interactive mode. This means that the default for effects and other steps which have a popup is to display the popup so that the user can change settings.

When the execution mode button on the script tool bar is not selected, then the script will run in silent mode.  This means that the default for effects and other steps which have a popup is to NOT display the popup.

When a script is recorded, all the steps are automatically set to Default, meaning that they will run as interactive in interactive mode and silent in silent mode.  To force a step to be interactive even when the script is in silent mode, the step must be changed to interactive.  To change the way the script step will behave, it is necessary to edit the script.

First, select Edit Selected Script.

When the script editor appears, click the arrow next to default for the step that you want to change.

This will produce a menu with three choices: Default, Interactive and Silent. To force a step to always be interactive, select Interactive from the menu.  To force a step to always be silent, select Silent from the menu.  Silent is good if you do not want the user to ever change a setting in the step.

Seamless Tile Script

It has been raining a lot here and I spent part of this week without power.  My basement has also flooded twice.  So, there hasn't been much scrapping as there has been a lot of cleanup to perform.

This is a utility script that I wrote while making patterns for a bunch of alphas.  The script takes an image then mirrors it 3 times to create a seamless tile.  It won't work with patterned images with directionality as the images will look like they are upside down.  This script is a nice timesaver for me and I thought other people might find it useful so I am sharing it.  It has not been tested, but I'm fairly confident that it will work PSP 9 and higher versions of PSP.  If you use this script and it works for you, please leave a comment.

Script

Triple Frame Scripts

This is a set of two scripts which make a set of triple frames. These scripts are the result of a request for scripts which make triple frames without embellishments. The scripts will take any color, gradient or pattern and turn them into a set of triple frames. I have not had these scripts tested, but they work for the requestor in PSP 9.  I'm fairly confident that they will work in other versions of PSP.  If you use these scripts in a different version of PSP and they work for you, then please leave a comment.

Scripts

Mirrored Mitered Corners Frame

So, the original version of the script was not what the person was looking for.  The mitered corners need to be mirrors of each other across the cut.  Therefore, I've modified the original script to mirror the mitered corners.  I have not had this script tested, but I am 99% confident that it should work in all versions of PSP from 9 on up.  Please leave a comment if it doesn't.

Script

Circularize Script

The previous circular frame script did not fulfill the request.  I made this script while working on a script to circularize an existing paper.  Though that script is still incomplete, I have made this circularize script which may work with papers, but I haven't tested it yet.  If you do not wish to use the script, you can follow my tutorial on how to circularize an element.

This script will take any linear element (ribbon, lace, wordart, string of beads, etc) and turn it into a circular element.  The script should check for orientation of the element.  Though the script works best if your linear element has its widest part going from left to right.  It has been tested and works in all versions of PSP 9 and up.  Please leave a comment if you have a problem with this script.

Script

Rectangular Frame Script

This is the companion to the elliptical frame script.  This script takes any size paper and turns it into a rectangular or square frame the same size as the original paper.  I have not had this script tested, but it is a modification of the elliptical frame script so I am 99% confident that it should work in all versions of PSP from 9 and up.  Please leave a comment if this script does not work for you.

Script

Elliptical Frame Script

This script was a request.  It takes any size paper and turns it into either a round or an oval frame.  The frame will be the same size as the original paper.  I am still working on the script that will turn any paper into a square or rectangular frame.

Script

Mitered Corner Frame Script

This script will allow you to take any size ribbon and turn it into a square frame with mitered corners.  It should not matter what type of image you start with.  The script will check for transparency.  Testers have been able to use this script with lace and ric rac.

Script

Postage Stamp Script

It took a bunch of troubleshooting, but this script now works in all versions of PSP 9 and up.  It should take any size image and turn it into a stamp.

Script

Twill Ribbon

This tutorial will show you how to make a twill fabric ribbon with a knobby weave in Paint Shop Pro.

1. Open a new canvas 3600 wide by 150 high.

2. Fill the canvas with a color of your choice (I used #7996bd).

3. Apply the halftone effect (Effects > Artistic Effects > Halftone), choosing an ink color that is a dark shade of your original color (I used #2c3c5e). To make broader stripes, increase the size. Use only even numbers.

 Halftone pattern = Line
Size = 8
Screen angles = 60
Use as overlay = Checked
Blend mode = Normal
Opacity = 100
Color Scheme = Greyscale
Ink = #2c3c5e
Transparent = Checked

4.  Duplicate the layer (Layers > Duplicate).

5.  Increase the canvas size (Image > Canvas Size) to 300 pixels in height.

Width = 3600
Height = 300
Top = 0
Bottom = 150
Left = 0
Right = 0


6.  Flip the layer (Ctrl + I).

7.  Merge the layers (Layers > Merge > Merge Visible).

8.  Apply the blinds effect.  Make the width the same value as the size as in the halftone effect.

Width = 8 (same as size value in halftone effect)
Opacity = 50
Color = Black
Horizontal = Checked
Light from left/top = Checked

9.  Add noise (Adjust > Add/Remove Noise > Add Noise) .

Gaussian = Checked
Noise = 30
Monochrome = Checked

10.  Adjust > Blur > Average.

Filter Aperture = 3

11.  Go to the selection tool and make a custom selection.

Left = 0
Right = 3600
Top = 75
Bottom = 225

12.  Mirror the selection (Ctrl + M).

13.  Ctrl + D to select none.  The ribbon is now complete.

I am providing the script that I saved while writing this tutorial.

Script

Twill Ribbon Script

I have (temporarily) salvaged the broken graphics card by baking it in my oven.  I know it sounds crazy, but I read on several notebook forums that it was possible to salvage a broken graphics card by baking it on balls of aluminum foil.   I did not expect it to work, but I pre-heated my oven to 375 degrees Fahrenheit and then baked the graphics card for 9 minutes.  Then, I turned off the oven and left the door cracked open for 20 minutes to allow the card to slow cool.  Most people get cookies after 9 minutes.  I got a functional graphics card.  The laptop has been resuscitated and I'm using it to make this entry.

I found this twill ribbon script on my hard drive.  I have too many things that are only partially complete.  The script should work in all versions of PSP up to X3.  Please leave a comment if it doesn't.

Script

Customizing a Paintbrush to Use 2 Colors in a Script

The method used to allow a user to choose two colors for a paintbrush can also be used for any of the other brushes in Paint Shop Pro.  This tutorial is an expansion of the Script Customization Tutorial for Paintbrush, Airbrush and Pen Tool.  It is a good idea to be familiar with that tutorial before attempting this tutorial.

1.  For this tutorial, I am going to use my Multi-colored Tinsel Tutorial as the example because it is short.  So, first, perform the steps in that tutorial, except set the foreground and background materials to a color so that editting of the scripts will be easy.  My script looks like this:

from JascApp import *

def ScriptProperties():
    return {
        'Author': u'Spencer Aloysius',
        'Copyright': u'Humbug Graphics Galore',
        'Description': u'Creates tinsel when used with metallic glitter patterns.',
        'Host': u'Paint Shop Pro 9',
        'Host Version': u'9.01'
        }

def Do(Environment):
    # EnableOptimizedScriptUndo
    App.Do( Environment, 'EnableOptimizedScriptUndo', {
            'GeneralSettings': {
                'ExecutionMode': App.Constants.ExecutionMode.Default, 
                'AutoActionMode': App.Constants.AutoActionMode.Match, 
                'Version': ((9,0,1),1)
                }
            })

    # FileNew
    App.Do( Environment, 'NewFile', {
            'Width': 3600, 
            'Height': 300, 
            'ColorDepth': App.Constants.Colordepth.SixteenMillionColor, 
            'DimensionUnits': App.Constants.DimensionType.Pixels, 
            'ResolutionUnits': App.Constants.ResolutionUnits.PixelsPerIn, 
            'Resolution': 300, 
            'FillMaterial': {
                'Color': (255,255,255), 
                'Pattern': None, 
                'Gradient': None, 
                'Texture': None, 
                'Art': None
                }, 
            'Transparent': True, 
            'LayerType': App.Constants.NewLayerType.Raster, 
            'ArtMediaTexture': {
                'Category': u'Art Media', 
                'Name': u'Canvas coarse', 
                'EnableFill': False, 
                'FillColor': (255,255,255)
                }, 
            'GeneralSettings': {
                'ExecutionMode': App.Constants.ExecutionMode.Default, 
                'AutoActionMode': App.Constants.AutoActionMode.Match, 
                'Version': ((9,0,1),1)
                }
            })

    # SelectDocument
    App.Do( Environment, 'SelectDocument', {
            'SelectedImage': 0, 
            'Strict': False, 
            'GeneralSettings': {
                'ExecutionMode': App.Constants.ExecutionMode.Default, 
                'AutoActionMode': App.Constants.AutoActionMode.Match, 
                'Version': ((9,0,1),1)
                }
            })

    # PaintBrush
    App.Do( Environment, 'PaintBrush', {
            'BrushTip': {
                'Shape': App.Constants.BrushShape.Rectangular, 
                'CustomBrush': None, 
                'Size': 200, 
                'Hardness': 25, 
                'Step': 30, 
                'Density': 100, 
                'Thickness': 5, 
                'Rotation': 60, 
                'BrushVariance': {
                    'SizeVariance': App.Constants.VarianceMethod.None, 
                    'SizeJitter': 8, 
                    'OpacityVariance': App.Constants.VarianceMethod.None, 
                    'OpacityJitter': 0, 
                    'DensityVariance': App.Constants.VarianceMethod.None, 
                    'DensityJitter': 0, 
                    'ThicknessVariance': App.Constants.VarianceMethod.None, 
                    'ThicknessJitter': 0, 
                    'RotationVariance': App.Constants.VarianceMethod.None, 
                    'RotationJitter': 100, 
                    'ColorBlendVariance': App.Constants.VarianceMethod.None, 
                    'ColorBlendJitter': 49, 
                    'HueVariance': App.Constants.VarianceMethod.None, 
                    'HueJitter': 0, 
                    'SaturationVariance': App.Constants.VarianceMethod.None, 
                    'SaturationJitter': 0, 
                    'LightnessVariance': App.Constants.VarianceMethod.None, 
                    'LightnessJitter': 0, 
                    'PositionJitter': 23, 
                    'UseScaledPositionJitter': False, 
                    'ImpressionsPerStep': 1, 
                    'FadeRate': 100
                    }
                }, 
            'Brush': {
                'Opacity': 100, 
                'ContinuousPaint': False, 
                'WetLookPaint': False, 
                'BlendMode': App.Constants.BlendMode.Normal
                }, 
            'PrimaryMaterial': App.Constants.MaterialRef.Foreground, 
            'ForegroundMaterial': {
                'Color': (192,192,255), 
                'Pattern': None, 
                'Gradient': None, 
                'Texture': None, 
                'Art': None
                }, 
            'BackgroundMaterial': {
                'Color': (0,0,0), 
                'Pattern': None, 
                'Gradient': None, 
                'Texture': None, 
                'Art': None
                }, 
            'Stroke': [
                (App.Constants.PathEntryInterpretation.Absolute,(87.5,133.5),0)
            ], 
            'GeneralSettings': {
                'ExecutionMode': App.Constants.ExecutionMode.Default, 
                'RandomSeed': 76538406, 
                'AutoActionMode': App.Constants.AutoActionMode.Match, 
                'Version': ((9,0,1),1)
                }
            })

    # PaintBrush
    App.Do( Environment, 'PaintBrush', {
            'BrushTip': {
                'Shape': App.Constants.BrushShape.Rectangular, 
                'CustomBrush': None, 
                'Size': 200, 
                'Hardness': 25, 
                'Step': 30, 
                'Density': 100, 
                'Thickness': 5, 
                'Rotation': 60, 
                'BrushVariance': {
                    'SizeVariance': App.Constants.VarianceMethod.None, 
                    'SizeJitter': 8, 
                    'OpacityVariance': App.Constants.VarianceMethod.None, 
                    'OpacityJitter': 0, 
                    'DensityVariance': App.Constants.VarianceMethod.None, 
                    'DensityJitter': 0, 
                    'ThicknessVariance': App.Constants.VarianceMethod.None, 
                    'ThicknessJitter': 0, 
                    'RotationVariance': App.Constants.VarianceMethod.None, 
                    'RotationJitter': 100, 
                    'ColorBlendVariance': App.Constants.VarianceMethod.None, 
                    'ColorBlendJitter': 49, 
                    'HueVariance': App.Constants.VarianceMethod.None, 
                    'HueJitter': 0, 
                    'SaturationVariance': App.Constants.VarianceMethod.None, 
                    'SaturationJitter': 0, 
                    'LightnessVariance': App.Constants.VarianceMethod.None, 
                    'LightnessJitter': 0, 
                    'PositionJitter': 23, 
                    'UseScaledPositionJitter': False, 
                    'ImpressionsPerStep': 1, 
                    'FadeRate': 100
                    }
                }, 
            'Brush': {
                'Opacity': 100, 
                'ContinuousPaint': False, 
                'WetLookPaint': False, 
                'BlendMode': App.Constants.BlendMode.Normal
                }, 
            'PrimaryMaterial': App.Constants.MaterialRef.Foreground, 
            'ForegroundMaterial': {
                'Color': (192,192,255), 
                'Pattern': None, 
                'Gradient': None, 
                'Texture': None, 
                'Art': None
                }, 
            'BackgroundMaterial': {
                'Color': (0,0,0), 
                'Pattern': None, 
                'Gradient': None, 
                'Texture': None, 
                'Art': None
                }, 
            'Stroke': [
                (App.Constants.PathEntryInterpretation.Absolute,(87.5,133.5),0),
                (App.Constants.PathEntryInterpretation.Absolute,(3537.5,141.5),0)
            ], 
            'GeneralSettings': {
                'ExecutionMode': App.Constants.ExecutionMode.Default, 
                'RandomSeed': 76546953, 
                'AutoActionMode': App.Constants.AutoActionMode.Match, 
                'Version': ((9,0,1),1)
                }
            })

2.  Before the Paintbrush command, add the code snippet to ask the user to choose a color twice like so:

    # MsgBox 
    Result = App.Do( Environment, 'MsgBox', {
        'Buttons': App.Constants.MsgButtons.OK, 
        'Icon': App.Constants.MsgIcons.Info, 
        'Text': 'Choose a color, pattern or gradient.', 
    }) 

    MyFill = App.Do(Environment,'GetMaterial',{ 
            'IsPrimary':App.Constants.Boolean.true, 
            'GeneralSettings': { 
                'ExecutionMode':App.Constants.ExecutionMode.Interactive 
                } 
            })
    # MsgBox 
    Result = App.Do( Environment, 'MsgBox', {
        'Buttons': App.Constants.MsgButtons.OK, 
        'Icon': App.Constants.MsgIcons.Info, 
        'Text': 'Choose a color, pattern or gradient.', 
    }) 

    MyFill2 = App.Do(Environment,'GetMaterial',{ 
            'IsPrimary':App.Constants.Boolean.false, 
            'GeneralSettings': { 
                'ExecutionMode':App.Constants.ExecutionMode.Interactive 
                } 
            })

This sets a color, pattern or gradient for the foreground and the background in the Materials palette.

3.  Now, edit the Paintbrush command to accept both choices made by the user by changing the ForegroundMaterial to MyFill and the BackgroundMaterial to MyFill2.

    # PaintBrush
    App.Do( Environment, 'PaintBrush', {
            'BrushTip': {
                'Shape': App.Constants.BrushShape.Rectangular, 
                'CustomBrush': None, 
                'Size': 200, 
                'Hardness': 25, 
                'Step': 30, 
                'Density': 100, 
                'Thickness': 5, 
                'Rotation': 60, 
                'BrushVariance': {
                    'SizeVariance': App.Constants.VarianceMethod.None, 
                    'SizeJitter': 8, 
                    'OpacityVariance': App.Constants.VarianceMethod.None, 
                    'OpacityJitter': 0, 
                    'DensityVariance': App.Constants.VarianceMethod.None, 
                    'DensityJitter': 0, 
                    'ThicknessVariance': App.Constants.VarianceMethod.None, 
                    'ThicknessJitter': 0, 
                    'RotationVariance': App.Constants.VarianceMethod.None, 
                    'RotationJitter': 100, 
                    'ColorBlendVariance': App.Constants.VarianceMethod.None, 
                    'ColorBlendJitter': 49, 
                    'HueVariance': App.Constants.VarianceMethod.None, 
                    'HueJitter': 0, 
                    'SaturationVariance': App.Constants.VarianceMethod.None, 
                    'SaturationJitter': 0, 
                    'LightnessVariance': App.Constants.VarianceMethod.None, 
                    'LightnessJitter': 0, 
                    'PositionJitter': 23, 
                    'UseScaledPositionJitter': False, 
                    'ImpressionsPerStep': 1, 
                    'FadeRate': 100
                    }
                }, 
            'Brush': {
                'Opacity': 100, 
                'ContinuousPaint': False, 
                'WetLookPaint': False, 
                'BlendMode': App.Constants.BlendMode.Normal
                }, 
            'PrimaryMaterial': App.Constants.MaterialRef.Foreground, 
            'ForegroundMaterial': MyFill, 
            'BackgroundMaterial': MyFill2, 
            'Stroke': [
                (App.Constants.PathEntryInterpretation.Absolute,(87.5,133.5),0)
            ], 
            'GeneralSettings': {
                'ExecutionMode': App.Constants.ExecutionMode.Default, 
                'RandomSeed': 76538406, 
                'AutoActionMode': App.Constants.AutoActionMode.Match, 
                'Version': ((9,0,1),1)
                }
            })

Every Paintbrush command in the script needs to be editted. In this case, that means changing the ForegroundMaterial and BackgroundMaterial twice.

Now the script will allow the user to pick two colors for the paintbrush.  I have provided my copy of the script so that you can compare your result to mine.

Christmas Ball Script

This script will make four different kinds of Christmas ball ornaments.  The user can choose from a matte or glossy finish or a gold or silver hanger.  My Script Testing team also made a huge bunch of samples since I had them test this script 3 separate times.  I will offer them soon because they all look so pretty.

Script 

And, have you seen the new categories offered by Digifree?  I was mis-categorized yesterday, but hopefully that has been corrected now.  We'll have to see what the computer thinks tonight.

Candy Corn Script

For the last day of the 13 Days of Halloween blog train (or the bonus day, depending on how you choose to count), I decided to not give out an alpha.  Now, it is time for something different.  Instead, here is a script for making your own candy corn.

Script

You can also pick up the numbers for the strawberry licorice alpha.

If you liked this series of alphas, please remember to visit during the month of December when I will giving away an alpha a day during the Advent season.

Numbers

Torn Edge Paper Script

Here is a script that I made when working on my torn edge tutorial.

Script

Acorn Script

I don't know that anyone will ever use this script, but it is autumn and there are acorns falling everywhere.

Script

Dotted Paper

This tutorial will show you how to easily make paper covered in different colored dots in Paint Shop Pro.  I think it is a lot easier to make polka-dotted paper in PSP than in Photoshop.

1.  Open a new canvas the size of your paper.  I made mine 3600 x 3600.

2.  Fill the canvas with a color of your choice (I used #f0d7a1).

3.  Go to the Halftone Effect (Effects > Artistic Effects > Halftone) and make a single layer of dots.

Halftone pattern = Round
Size = 100
Screen angles = 137
Use as overlay = Checked
Blend mode = Normal
Opacity = 70
Color Scheme= Greyscale
Ink = Any Color (I used #e3986e)
Transparent = Checked

4.  Return to the Halftone Effect and add a second layer of dots.  This time decrease the size, increase the opacity, change the color and change the screen angle.

Halftone pattern = Round
Size = 75
Screen angles = 85
Use as overlay = Checked
Blend mode = Normal
Opacity = 85
Color Scheme= Greyscale
Ink = Any Color (I used #edbd4f)
Transparent = Checked

5.  You can stop at dots in 2 colors or you can add another layer of colored dots with the Halftone Effect.  If you add a third color, decrease the size, increase the opacity, change the color and change the screen angle.

Halftone pattern = Round
Size = 50
Screen angles = 32
Use as overlay = Checked
Blend mode = Normal
Opacity = 100
Color Scheme= Greyscale
Ink = Any Color (I used #b9818a)
Transparent = Checked

The dotted paper is now complete.

I wrote up a script that will make any sized paper covered in three colors of dots.  The script also randomly generates the screen angle in the halftone effect, so no two papers created with the script will be the same.

Script