Picot Ribbon Tutorial

This digital scrap tutorial describes how to make a basic undecorated ribbon with a picot edging.

1. Open a new canvas, 3600 x 300.

2. Go the paintbrush and select the +50 Round brush. Change the settings as follows:



Size = 75
Hardness = 95
Step = 100
Density = 100
Thickness = 100
Rotation = 0
Opacity = 100
Blend mode = Normal
Continuous = Unchecked
Wet look paint = Unchecked

3. With the paintbrush selected, left click with the mouse in the upper left hand corner.



4. Press the shift key, then while holding the shift key down, left click with the mouse click in the upper right hand corner.



5. Click in the lower left hand corner with the paintbrush.



6. Press the shift key, then left click the mouse in the lower right hand corner.



7. Select All (Ctrl+A).

8. Choose the selection tool and click the selection to float it.

9. Defloat the selection (Ctrl+Shift+F).

10. With Match mode = None, fill the selection with your color.

Match mode = None
Blend mode = Normal
Opacity = 100

11. Go the eraser and select the +50 Round. Change the settings as follows:



Size = 50
Hardness = 90
Step = 150
Density = 100
Thickness = 100
Rotation = 0
Opacity = 100

12. Click in the upper left hand corner with the eraser.



13. Press the shift key, then while holding the shift key down, left click with the mouse click in the upper right hand corner.



14. Click in the lower left hand corner with the eraser.



15. Press the shift key, then left click the mouse in the lower right hand corner.



16. Create a Custom Selection. I have circled the location of the custom selection button in red Selection Dialog.



Top = 35
Bottom = 265
Left = 0
Right = 3600

17. Fill the selection.



The basic ribbon is now complete. You can texture and decorate it as you see fit.

This tutorial could also be used to make picot edging along just one side of the ribbon. Just skip steps 5, 6, 14 and 15.

To make scalloped edging, skip steps 11-15.

Feel the Music Quick Page

I am also having trouble with assembling a preview for my Feel the Music kit, so I diverted myself with making a couple of quick pages.

Here is the first quick page.


Here is the second quick page for the Feel the Music blog train.

The train leaves the station on May 18th.

EDIT:  As the station blog is now gone, you can get the quickpages here.

Simple Ribbon Tutorial

1. Open a new canvas, 3600 x 150 with a transparent background.

2. Fill canvas with the color of your choice.

3. Select All (Ctrl + A).

4. Select a 10 pixel border (Selections > Modify > Select Selection Borders)



Inside = Checked
Anti-alias = Checked
Border width = 10

5. Fill the selection with a color.

6. Resize Canvas (Image > Canvas Size) to 3580 x 150.



Width = 3580
Height = 150
Canvas Placement = Center

7. Apply the Blinds Effect (Effects > Texture Effects > Blinds).



Width = 5
Opacity = 25
Color = (Same as the color in step 5)
Horizontal = Unchecked
Light from left/top = Checked

8. Invert Selection (Ctrl + I).

9. Apply the Halftone Effect (Effects > Artistic Effects > Halftone).



Halftone Pattern = Line
Size = 5
Screen angles = 90
Use as overlay= Checked
Blend mode = Screen
Opacity = 48
Color Scheme = Greyscale
Ink = Black
Background = White
Transparent = Unchecked

10. Select None (Ctrl + D) and the basic ribbon is complete.

Optional:

11. Add depth to the stripes. Select the stripes with the magic wand.



12. Apply a weak drop shadow (Effects > 3D Effects > Drop Shadow) to the stripes.


13. Add depth to the ribbon with the very popular Greg's Factory Output Vol. II: Pool Shadow plugin. This gives the ribbon a rippled look.


Here is a comparison of the ribbons after each of the optional steps.

Water Colored Flowers

I'm trying to debug a script that will create a flower that looks like it has been painted in water colors. As a result, I have a bunch of flowers. I thought some of the flowers were rather pretty so I am sharing them.

Flowers

Turning a Tutorial Into a Script

This tutorial will show you how to make a script and then modify the script to allow a user to choose their own color, gradient or pattern. I am going to use my ric rac tutorial to show how a tutorial can easily be converted into a script.

Supplies:

Ric Rac Tutorial

1. Have my Ric Rac Tutorial available (either printed or open in a web browser).

2. Go to the script toolbar (or menu) and press the circle to start recording.

Toolbar

Menu

3. Follow the directions in the Ric Rac Tutorial. Do not worry if you make a mistake. If you make a mistake, just undo the action (Ctrl-Z).

4. Once you have finished the tutorial, save the script by going to the script toolbar (or menu) and pressing the disk icon.

A window will pop up asking you for a name (and location) to save the script. Make sure 'Remove Undone Commands' is checked and 'Save Dialog Positions' is unchecked. To make sure that your script will be identical to the one in this tutorial, make sure 'Save Materials' is checked. You now have a script that will make a ric rac in only one set of colors. If you save the script with 'Save Materials' unchecked, then the script will make a ric rac in your existing foreground and background colors.

5. Now we will edit the script so that the user can select colors. Open up the script editor by clicking the scroll button on the script toolbar.

A pop up window for the Script Editor will appear. Go to the bottom and click 'Text Editor.'

6. The text editor is Notepad. In Notepad, the script looks like this:

from JascApp import *

def ScriptProperties():
    return {
        'Author': u'',
        'Copyright': u'',
        'Description': u'',
        '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': 150, 
            '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)
                }
            })

    # Fill
    App.Do( Environment, 'Fill', {
            'BlendMode': App.Constants.BlendMode.Normal, 
            'MatchMode': App.Constants.MatchMode.None, 
            'Material': {
            'Color': (80,235,236),
               'Pattern': None,
               'Gradient': None,
               'Texture': None,
               'Art': None
               },
            'UseForeground': True, 
            'Opacity': 100, 
            'Point': (1594.5,30.5), 
            'SampleMerged': False, 
            'Tolerance': 20, 
            'GeneralSettings': {
                'ExecutionMode': App.Constants.ExecutionMode.Default, 
                'AutoActionMode': App.Constants.AutoActionMode.Match, 
                'Version': ((9,0,1),1)
                }
            })

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

    # Select Selection Borders
    App.Do( Environment, 'SelectSelectionBorders', {
            'Antialias': True, 
            'BordersType': App.Constants.BordersType.Inside, 
            'BorderWidth': 10, 
            'GeneralSettings': {
                'ExecutionMode': App.Constants.ExecutionMode.Default, 
                'AutoActionMode': App.Constants.AutoActionMode.Match, 
                'Version': ((9,0,1),1)
                }
            })

    # Fill
    App.Do( Environment, 'Fill', {
            'BlendMode': App.Constants.BlendMode.Normal, 
            'MatchMode': App.Constants.MatchMode.None, 
            'Material': {
               'Color': (3,166,167),
               'Pattern': None,
               'Gradient': None,
               'Texture': None,
               'Art': None
               },
            'UseForeground': True, 
            'Opacity': 100, 
            'Point': (1830.5,10.5), 
            'SampleMerged': False, 
            'Tolerance': 20, 
            'GeneralSettings': {
                'ExecutionMode': App.Constants.ExecutionMode.Default, 
                'AutoActionMode': App.Constants.AutoActionMode.Match, 
                'Version': ((9,0,1),1)
                }
            })

    # ResizeCanvas
    App.Do( Environment, 'ResizeCanvas', {
            'AspectRatio': 24, 
            'FillColor': (192,117,0), 
            'HoriPlace': App.Constants.HorizontalType.Center, 
            'MaintainAspect': False, 
            'NewDimUnits': App.Constants.UnitsOfMeasure.Pixels, 
            'NewHeight': 300, 
            'NewWidth': 3580, 
            'PlaceBottom': 75, 
            'PlaceLeft': -10, 
            'PlaceRight': -10, 
            'PlaceTop': 75, 
            'VertPlace': App.Constants.VerticalType.Center, 
            'GeneralSettings': {
                'ExecutionMode': App.Constants.ExecutionMode.Default, 
                'AutoActionMode': App.Constants.AutoActionMode.Match, 
                'Version': ((9,0,1),1)
                }
            })

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

    # Halftone
    App.Do( Environment, 'Halftone', {
            'BackgroundColor': (255,255,255), 
            'ColorScheme': App.Constants.ColorScheme.Greyscale, 
            'HalftonePattern': App.Constants.HalftonePattern.Round, 
            'Overlay': True, 
            'OverlayBlendMode': App.Constants.BlendMode.Overlay, 
            'OverlayOpacity': 48, 
            'PatternColor': (0,0,0), 
            'ScreenAngles': (130,162,90), 
            'Size': 15, 
            'TransparentBackground': False, 
            'GeneralSettings': {
                'ExecutionMode': App.Constants.ExecutionMode.Default, 
                'AutoActionMode': App.Constants.AutoActionMode.Match, 
                'Version': ((9,0,1),1)
                }
            })

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

    # Wave
    App.Do( Environment, 'Wave', {
            'HorizontalAmplitude': 0, 
            'HorizontalWavelength': 25, 
            'VerticalAmplitude': 20, 
            'VerticalWavelength': 12, 
            'EdgeMode': App.Constants.EdgeMode.Repeat, 
            'BackgroundColor': (255,255,255), 
            'GeneralSettings': {
                'ExecutionMode': App.Constants.ExecutionMode.Default, 
                'AutoActionMode': App.Constants.AutoActionMode.Match, 
                'Version': ((9,0,1),1)
                }
            })

7. To make the script compatible with all versions of PSP, if the script was recorded PSP X or higher make sure that the first line of the script says 'from JascApp import *'.

from PSPApp import *  ------> Change to ------> from JascApp import *

def ScriptProperties():
    return {
        'Author': u'',
        'Copyright': u'',
        'Description': u'',
        'Host': u'Paint Shop Pro X',
        'Host Version': u'10.03'
        }

8. We are going to add the Material Picker code snippet to allow for the user to choose their own color, gradient or pattern. The code will make a pop up box on the screen that says, "Choose a color, gradient or pattern." It will have an OK button for the user to click. After the user clicks OK, the Materials palette will display. This is the code snippet:

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

The code is placed before the fill command, like this:

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

    # Fill
    App.Do( Environment, 'Fill', {
            'BlendMode': App.Constants.BlendMode.Normal, 
            'MatchMode': App.Constants.MatchMode.None, 
            'Material': {
            'Color': (80,235,236),
               'Pattern': None,
               'Gradient': None,
               'Texture': None,
               'Art': None
             },
            'UseForeground': True, 
            'Opacity': 100, 
            'Point': (1594.5,30.5), 
            'SampleMerged': False, 
            'Tolerance': 20, 
            'GeneralSettings': {
                'ExecutionMode': App.Constants.ExecutionMode.Default, 
                'AutoActionMode': App.Constants.AutoActionMode.Match, 
                'Version': ((9,0,1),1)
                }
            })

9. Next, we change the Fill command to accept the user's Material by removing all the Material information and replacing it with the variable (MyFill) holding the information from the user's selection from the Materials palette.

    # Fill
    App.Do( Environment, 'Fill', {
            'BlendMode': App.Constants.BlendMode.Normal, 
            'MatchMode': App.Constants.MatchMode.None, 
            'Material': MyFill, 
            'UseForeground': True, 
            'Opacity': 100, 
            'Point': (1594.5,30.5), 
            'SampleMerged': False, 
            'Tolerance': 20, 
            'GeneralSettings': {
                'ExecutionMode': App.Constants.ExecutionMode.Default, 
                'AutoActionMode': App.Constants.AutoActionMode.Match, 
                'Version': ((9,0,1),1)
                }
            })

10. Repeat this change for the second color selection.

    # Select Selection Borders
    App.Do( Environment, 'SelectSelectionBorders', {
            'Antialias': True, 
            'BordersType': App.Constants.BordersType.Inside, 
            'BorderWidth': 10, 
            'GeneralSettings': {
                'ExecutionMode': App.Constants.ExecutionMode.Default, 
                'AutoActionMode': App.Constants.AutoActionMode.Match, 
                'Version': ((9,0,1),1)
                }
            })

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

    # Fill
    App.Do( Environment, 'Fill', {
            'BlendMode': App.Constants.BlendMode.Normal, 
            'MatchMode': App.Constants.MatchMode.None, 
            'Material': MyFill,
            'UseForeground': True, 
            'Opacity': 100, 
            'Point': (1830.5,10.5), 
            'SampleMerged': False, 
            'Tolerance': 20, 
            'GeneralSettings': {
                'ExecutionMode': App.Constants.ExecutionMode.Default, 
                'AutoActionMode': App.Constants.AutoActionMode.Match, 
                'Version': ((9,0,1),1)
                }
            })

11. To finish off the customization, add a window that will tell the user that the script is complete. At the very end of the script add the following snippet of code:

    Result = App.Do(Environment,'MsgBox',{
        'Buttons':App.Constants.MsgButtons.OK,
        'Icon':App.Constants.MsgIcons.Info,
        'Text':'The script is now complete./n'   
               'Thank you for using my script.',

You can modify the phrase however you like. I have indicated below what you can change.

    Result = App.Do(Environment,'MsgBox',{
        'Buttons':App.Constants.MsgButtons.OK,
        'Icon':App.Constants.MsgIcons.Info,
        'Text':'The script is now complete./n'   <----- You can change anything
               'Thank you for using my script.', <----- between the single quotes.

Your modified script is now complete. As blogger appears to enjoy removing the indents in my code, you may download my final version of the script to compare to your own. Please note that spacing and the number of spaces (meaning the indentation) in the code is critical. If you have the wrong number of spaces on the left side of your code, then the script will not run.

Polka Dot Ric Rac Tutorial

I know there are tons of ric rac tutorials out on the internet, but I wrote this one as a template for showing people how to turn a tutorial into a script.

1. Open a new file, 3600 x 150 with a transparent background.

2. Fill the canvas with a color.

3. Select All (Ctrl + A ).

4. Select a 10 pixel border (Selections > Modify > Select Selection Borders)



Inside = Checked
Anti-alias = Checked
Border width = 10

5. Fill the selection with a color.

6. Resize Canvas (Image > Canvas Size) to 3580 x 300.



Width = 3580
Height = 300
Canvas Placement = Center

7. Invert Selection (Ctrl + I).

8. Apply the Halftone Effect (Effects > Artistic Effects > Halftone).



Halftone pattern = Round
Size = 15
Screen Angles = 130
Use as overlay = Checked
Blend Mode = Overlay
Opacity = 48
Color Scheme = Greyscale
Ink = Black
Background = White
Transparent = Unchecked

9. Select None (Ctrl + D).

10. Apply the Wave Deformation (Effects > Distortion Effects > Wave).



Horizontal displacement
Amplitude = 0 (by setting to zero, nulls the wavelength value)
Wavelength = 25
Vertical displacement
Amplitude = 20
Wavelength = 12
Edge Mode = Repeat

The ric rac is now complete.

Round Bow Script

I wrote this script based on the button bow script and used it to make bows for the Airs of Spring kit. It makes a 1000 x 1000 bow, so I actually had to re-size the items for the smaller kit. Everything is left in layers so that you can add finishing touches once the script is complete.

Script

Criss-Cross Checks Script

I wrote this script to make seamless tiles for the Airs of Spring kit. I thought people might enjoy using it.

Script

Feel the Music Blog Train Coming

I've signed up to take part in the Feel the Music Blog Train. There are freebies available at the station with more being posted every day until the train leaves the station on May 18th. I am also providing a pre-launch freebie. It is a piece of word art. I hope it provides a hint towards what my kit is going to contain.

Word Art

Airs of Spring Blog Train

Abba Dabba Scraps (Host, go here if you get lost)
The Cat's Meow
Candy's Treasures
XelaxScrapFree
Boonie Scraps
Tabby's Digi Designs
Designs By Foxylady Creations
This Complicated Life
Humbug Graphics Galore
Gothic Inspirations

and Amber, who does not have a blog. (You can find her download at Abba Dabba Scraps)

I am trying to acquire Filter Forge, a plugin for PSP and PS. I cannot afford to buy it right now, but I am hopeful that people who visit this blog might help me out. This is a trial of the donation button as I'm not certain people would be willing to help me out. If you are willing to help me buy Filter Forge so that I can make more nifty things for you, then please make a donation.

My portion of the blog train:


This tagger-size kit comes with:

16 papers
7 butterflies
4 bows
5 tags
5 sets of photo corners
5 flowers
3 alphas

Tagger-sized Kit