Oren's Folder

Monday, October 26, 2009

Paint Application [C#]

Greetings. I wrote a Paint Application in C#, here is a summary of it:

It is a Multiple-Document Interface application - The Image forms are MdiChildren of the Main application form.
According to this, the main menu is merged with a non-visible MenuStrip on the Image form.
The various tool windows are owned by the Main application form.

The featured tools are: Select, Pencil (1px free-draw), Brush, Eraser, Rectangle, Circle, Fill and Pipette (color picker).

The different parameters for each tool are displayed in the Tool Options window.
Each tool's options are arranged on a dedicated panel on this form. When a tool is chosen, its' options panel toggles to the only visible panel.

The edited image is displayed inside a PictureBox control.
All drawing actions are done in the course of the MouseDown, MouseMove and MouseUp events of that PictureBox.
A boolean named isDragging is turned true on MouseDown event, and false on MouseUp event, thus enabling continuous drawing actions.

Selection definition, dragging and dropping is done in a similar way, based on four selection states listed in an enum.

The algorithm for the flood fill tool is taken from this tutorial.

Two image filters are available from the Image menu - Brightness and Invert, and can also be applied to selections.
Brightness also features a dialog for setting the filter level, with a small preview of its' effect.

The data for the multiple undo and redo features is stored in Stacks.

Image files can be loaded and saved in the various ImageFormats provided by .NET.

Here are a couple of screenshots:

And here is the code for the Image form:

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Drawing.Printing;
using System.Text;
using System.Windows.Forms;

namespace PaintApp
{
    public partial class ImageForm : Form
    {
        public ImageForm()
        {
            InitializeComponent();

// Subscribe to event for PrintDocument page printing.
            myPrintDocument.PrintPage += new PrintPageEventHandler(myPrintDocument_PrintPage);
        }

private string fileName = "";
        private System.Drawing.Imaging.ImageFormat fileImageFormat;

private Stack<Bitmap> undoStack = new Stack<Bitmap>();
        private Stack<Bitmap> redoStack = new Stack<Bitmap>();

// Property for getting the image fileName by the main application form. 
        public string FileName
        {
            get { return fileName; } //
        }

// Property for getting myImage Bitmap by the BrightnessDialog.
        public Bitmap MyImage
        {
            get { return myImage; }
        }

// Property for getting the selection Bitmap by the BrightnessDialog.
        public Bitmap SelectBi
        {
            get { return selectBi; }
        }

// Property for getting the selection state by the BrightnessDialog.
        // If a selection exists, the brightness preview uses it.
        public string MySelectionState
        {
            get { return mySelectionState.ToString(); }
        }

private Bitmap myImage; // the image Bitmap
        private Bitmap tempBi; // for temporary changes in the image
        private Bitmap selectBi; // the selection bitmap
        
        private bool isDragging = false; // enables continuous drawing actions
        private bool selectPaste = false; // determines whether the selection origin is a clipboard paste
        private bool selectChanged = false; // determines if any change was applied on the selection
        
        private enum SelectionState { None, Define, Selected, Drag }; // the list of states for selections
        private SelectionState mySelectionState = SelectionState.None; // the current selection state
        
        private int lastX, lastY, // last mouse position for free drawing tools
            selectionStartX, selectionStartY, // the selection origin
            eFixX, eFixY, // calculated by the FixEValues method, to avoid selecting outside image boundaries
            selectionLocationX, selectionLocationY, // current selection location (upper-left corner)
            selectionDragOffsetX, selectionDragOffsetY, // the distances between SelectionLocation and where the mouse pressed inside the selection
            selectionWidth, selectionHeight, // selection measurements
            shapeStartX, shapeStartY; // shape origin
        private Rectangle mySelection; // Rectangle of the selection location and measurements
        
        private Pen selectPen = new Pen(Brushes.Blue, 1); // Pen for selection frame
        private Pen pencilPen, brushPen, eraserPen, rectanglePen, circlePen; // draw and shape tools Pens
        private SolidBrush selectionCutBrush, rectangleFillBrush, circleFillBrush; // Brushes for filling shapes and the original location of a selection

// The classes needed for printing.
        private PrintDocument myPrintDocument = new PrintDocument();
        private PageSettings myPageSettings = new PageSettings();
        private PageSetupDialog myPageSetupDialog = new PageSetupDialog();
        private PrintPreviewDialog myPrintPreviewDialog = new PrintPreviewDialog();
        private PrintDialog myPrintDialog = new PrintDialog();
        private Rectangle myPrintArea; // the image area on the printed page

/* The three methods below are for the MouseDown, MouseMove and MouseUp events 
           of pictureBox1. All drawing is done in the course of these three events. */

private void pictureBox1_MouseDown(object sender, MouseEventArgs e)
        {
            if (ToolsWindow.MyTool == "select") // the selection tool is different from the rest, since it has four states
            {
                if (mySelectionState == SelectionState.None) // if there is no selection, start defining a new one
                {
                    selectionStartX = e.X;
                    selectionStartY = e.Y;
                    mySelectionState = SelectionState.Define;
                }
                else if (mySelectionState == SelectionState.Selected) // if a selection exists
                {
                    if ((e.X > selectionLocationX) && 
                        (e.X < selectionLocationX + selectionWidth) && 
                        (e.Y > selectionLocationY) && 
                        (e.Y < selectionLocationY + selectionHeight)) // if mouse pressed inside the selection, start dragging it
                    {
                        selectionDragOffsetX = e.X - selectionLocationX;
                        selectionDragOffsetY = e.Y - selectionLocationY;
                        mySelectionState = SelectionState.Drag;
                    }
                    else // if mouse pressed outside the selection, drop it down
                    {
                        DropSelection();

// Immediately after dropping a selection, a new one can be defined by dragging the mouse.
                        selectionStartX = e.X;
                        selectionStartY = e.Y;
                        mySelectionState = SelectionState.Define;
                    }
                }
            }
            else // for all tools other than select
            {
                // If a selection exists, drop it down.
                if (mySelectionState == SelectionState.Selected)
                {
                    DropSelection();
                }

// Before drawing, push the current image to the undoStack.
                PushEdit();

if ((ToolsWindow.MyTool == "pencil") || 
                    (ToolsWindow.MyTool == "brush") || 
                    (ToolsWindow.MyTool == "eraser")) // these tools draw the first 'dot' on MouseDown
                {
                    Graphics g = Graphics.FromImage(myImage);
                    if (ToolsWindow.MyTool == "pencil")
                    {
                        pencilPen = new Pen(new SolidBrush(ColorsWindow.MyForeColor), 1);
                        myImage.SetPixel(e.X, e.Y, pencilPen.Color);
                    }
                    else if (ToolsWindow.MyTool == "brush")
                    {
                        brushPen = new Pen(new SolidBrush(ColorsWindow.MyForeColor), ToolOptionsWindow.MyBrushDiameter);
                        g.FillEllipse(brushPen.Brush, e.X - brushPen.Width / 2, e.Y - brushPen.Width / 2, brushPen.Width, brushPen.Width);
                    }
                    else if (ToolsWindow.MyTool == "eraser")
                    {
                        eraserPen = new Pen(new SolidBrush(ColorsWindow.MyForeColor), ToolOptionsWindow.MyEraserDiameter);
                        g.FillRectangle(eraserPen.Brush, e.X - eraserPen.Width / 2, e.Y - eraserPen.Width / 2, eraserPen.Width, eraserPen.Width);
                    }
                    // Storing the last mouse position is required on the free drawing tools,
                    // to draw a line between that position and the new one.
                    lastX = e.X;
                    lastY = e.Y;
                }
                else if ((ToolsWindow.MyTool == "rectangle") || 
                    (ToolsWindow.MyTool == "circle")) // the shape origin is defined on MouseDown
                {
                    shapeStartX = e.X;
                    shapeStartY = e.Y;
                }
                else if ((ToolsWindow.MyTool == "fill") || 
                    (ToolsWindow.MyTool == "pipette")) // these tools complete their tasks on MouseDown
                {
                    if (ToolsWindow.MyTool == "fill")
                    {
                        Color myReplacedColor = myImage.GetPixel(e.X, e.Y);
                        if (myReplacedColor != ColorsWindow.MyBackColor)
                        {
                            if (ToolOptionsWindow.MyFillContiguous == true) // flood fill
                            {
                                FillContiguously(e.X, e.Y, myImage.GetPixel(e.X, e.Y));
                            }
                            else // fill which replaces all pixels of the pressed pixel color
                            {
                                for (int x = 0; x < myImage.Width; x++)
                                {
                                    for (int y = 0; y < myImage.Height; y++)
                                    {
                                        if (myImage.GetPixel(x, y) == myReplacedColor)
                                        {
                                            myImage.SetPixel(x, y, ColorsWindow.MyBackColor);
                                        }
                                    }
                                }
                            }
                        }
                    }
                    else if (ToolsWindow.MyTool == "pipette")
                    {
                        // Calls a method on the Main form which calls a method on its' owned ColorsWindow form.
                        ((Main)(this.MdiParent)).SetPipetteColor(myImage.GetPixel(e.X, e.Y));
                    }
                }
                pictureBox1.Image = myImage;
                isDragging = true;
            }
        }

private void pictureBox1_MouseMove(object sender, MouseEventArgs e)
        {
            // Update the StatusStrip on the Main form.
            ((Main)(this.MdiParent)).StatusStripUpdate(e.Location);

if (ToolsWindow.MyTool == "select")
            {
                // When a selection is defined or dragged,
                // myImage is cloned to tempBi, for the temporary changes.
                if (mySelectionState == SelectionState.Define)
                {
                    tempBi = (Bitmap)myImage.Clone();
                    Graphics tempGr = Graphics.FromImage(tempBi);
                    FixEValues(e.X, e.Y);
                    tempGr.DrawRectangle(selectPen, (int)Math.Min(selectionStartX, eFixX), (int)Math.Min(selectionStartY, eFixY), Math.Abs(eFixX - selectionStartX), Math.Abs(eFixY - selectionStartY));
                    pictureBox1.Image = tempBi;
                }
                else if (mySelectionState == SelectionState.Drag)
                {
                    selectChanged = true;
                    tempBi = (Bitmap)myImage.Clone();
                    Graphics tempGr = Graphics.FromImage(tempBi);
                    if (selectPaste == false) // if true, the original location will not be erased
                    {
                        selectionCutBrush = new SolidBrush(ColorsWindow.MyBackColor);
                        tempGr.FillRectangle(selectionCutBrush, mySelection);
                    }
                    tempGr.DrawImage(selectBi, e.X - selectionDragOffsetX, e.Y - selectionDragOffsetY);
                    tempGr.DrawRectangle(selectPen, e.X - selectionDragOffsetX, e.Y - selectionDragOffsetY, selectionWidth - 1, selectionHeight - 1);
                    pictureBox1.Image = tempBi;
                }
            }
            else // for all tools other than select
            {
                if (isDragging)
                {
                    if ((ToolsWindow.MyTool == "pencil") || 
                        (ToolsWindow.MyTool == "brush") || 
                        (ToolsWindow.MyTool == "eraser")) // these tools draw a line between the current and last mouse positions on MouseMove
                    {
                        Graphics g = Graphics.FromImage(myImage);
                        if (ToolsWindow.MyTool == "pencil")
                            g.DrawLine(pencilPen, lastX, lastY, e.X, e.Y);
                        else if (ToolsWindow.MyTool == "brush")
                        {
                            g.DrawLine(brushPen, lastX, lastY, e.X, e.Y);
                            g.FillEllipse(brushPen.Brush, e.X - brushPen.Width / 2, e.Y - brushPen.Width / 2, brushPen.Width, brushPen.Width);
                        }
                        else if (ToolsWindow.MyTool == "eraser")
                        {
                            g.DrawLine(eraserPen, lastX, lastY, e.X, e.Y);
                            g.FillRectangle(eraserPen.Brush, e.X - eraserPen.Width / 2, e.Y - eraserPen.Width / 2, eraserPen.Width, eraserPen.Width);
                        }
                        // Storing the last mouse position is required on the free drawing tools,
                        // to draw a line between that position and the new one.
                        lastX = e.X;
                        lastY = e.Y;
                        pictureBox1.Image = myImage;
                    }
                    else if ((ToolsWindow.MyTool == "rectangle") || 
                        (ToolsWindow.MyTool == "circle")) // shapes are previewed dynamically on tempBi on MouseMove
                    {
                        tempBi = (Bitmap)myImage.Clone();
                        Graphics tempGr = Graphics.FromImage(tempBi);
                        if (ToolsWindow.MyTool == "rectangle")
                        {
                            if (ToolOptionsWindow.MyRectangleFill == true) // fill the shape if checked to do so
                            {
                                rectangleFillBrush = new SolidBrush(ColorsWindow.MyBackColor);
                                tempGr.FillRectangle(rectangleFillBrush, (int)Math.Min(shapeStartX, e.X), (int)Math.Min(shapeStartY, e.Y), Math.Abs(e.X - shapeStartX), Math.Abs(e.Y - shapeStartY));
                            }
                            rectanglePen = new Pen(new SolidBrush(ColorsWindow.MyForeColor), ToolOptionsWindow.MyRectangleContour);
                            tempGr.DrawRectangle(rectanglePen, (int)Math.Min(shapeStartX, e.X), (int)Math.Min(shapeStartY, e.Y), Math.Abs(e.X - shapeStartX), Math.Abs(e.Y - shapeStartY));
                        }
                        else if (ToolsWindow.MyTool == "circle")
                        {
                            if (ToolOptionsWindow.MyCircleFill == true) // fill the shape if checked to do so
                            {
                                circleFillBrush = new SolidBrush(ColorsWindow.MyBackColor);
                                tempGr.FillEllipse(circleFillBrush, (int)Math.Min(shapeStartX, e.X), (int)Math.Min(shapeStartY, e.Y), Math.Abs(e.X - shapeStartX), Math.Abs(e.Y - shapeStartY));
                            }
                            circlePen = new Pen(new SolidBrush(ColorsWindow.MyForeColor), ToolOptionsWindow.MyCircleContour);
                            tempGr.DrawEllipse(circlePen, (int)Math.Min(shapeStartX, e.X), (int)Math.Min(shapeStartY, e.Y), Math.Abs(e.X - shapeStartX), Math.Abs(e.Y - shapeStartY));
                        }
                        pictureBox1.Image = tempBi;
                    }
                    else if (ToolsWindow.MyTool == "pipette") // the pipette tool will repeat its' task on MouseMove
                    {
                        ((Main)(this.MdiParent)).SetPipetteColor(myImage.GetPixel(e.X, e.Y));
                    }
                }
            }
        }

private void pictureBox1_MouseUp(object sender, MouseEventArgs e)
        {
            if (ToolsWindow.MyTool == "select")
            {
                if (mySelectionState == SelectionState.Define) // definition of a selection ends on MouseUp
                {
                    FixEValues(e.X, e.Y);
                    selectionWidth = Math.Abs(eFixX - selectionStartX + 1);
                    selectionHeight = Math.Abs(eFixY - selectionStartY + 1);
                    if (selectionWidth > 0 && selectionHeight > 0)
                    {
                        if (eFixX < selectionStartX)
                        {
                            selectionStartX = eFixX;
                        }
                        if (eFixY < selectionStartY)
                        {
                            selectionStartY = eFixY;
                        }
                        mySelection = new Rectangle(selectionStartX, selectionStartY, selectionWidth, selectionHeight);
                        selectionLocationX = selectionStartX;
                        selectionLocationY = selectionStartY;

selectBi = new Bitmap(selectionWidth, selectionHeight);
                        Graphics selectGr = Graphics.FromImage(selectBi);
                        selectGr.DrawImage(myImage, 0, 0, mySelection, GraphicsUnit.Pixel);

mySelectionState = SelectionState.Selected;
                        selectChanged = false;
                        selectPaste = false;
                    }
                    else // if one of the measurements equals 0, no selection is done
                    {
                        mySelectionState = SelectionState.None;
                    }
                }
                else if (mySelectionState == SelectionState.Drag) // location of a dragged selection is updated on MouseUp
                {
                    selectionLocationX = e.X - selectionDragOffsetX;
                    selectionLocationY = e.Y - selectionDragOffsetY;
                    mySelectionState = SelectionState.Selected;
                }
            }
            else // for all tools other than select
            {
                if ((ToolsWindow.MyTool == "rectangle") || 
                    (ToolsWindow.MyTool == "circle")) // shapes are finalized and drawn to myImage on MouseUp
                {
                    Graphics g = Graphics.FromImage(myImage);
                    if (ToolsWindow.MyTool == "rectangle")
                    {
                        if (ToolOptionsWindow.MyRectangleFill == true)
                        {
                            rectangleFillBrush = new SolidBrush(ColorsWindow.MyBackColor);
                            g.FillRectangle(rectangleFillBrush, (int)Math.Min(shapeStartX, e.X), (int)Math.Min(shapeStartY, e.Y), Math.Abs(e.X - shapeStartX), Math.Abs(e.Y - shapeStartY));
                        }
                        rectanglePen = new Pen(new SolidBrush(ColorsWindow.MyForeColor), ToolOptionsWindow.MyRectangleContour);
                        g.DrawRectangle(rectanglePen, (int)Math.Min(shapeStartX, e.X), (int)Math.Min(shapeStartY, e.Y), Math.Abs(e.X - shapeStartX), Math.Abs(e.Y - shapeStartY));
                    }
                    else if (ToolsWindow.MyTool == "circle")
                    {
                        if (ToolOptionsWindow.MyCircleFill == true)
                        {
                            circleFillBrush = new SolidBrush(ColorsWindow.MyBackColor);
                            g.FillEllipse(circleFillBrush, (int)Math.Min(shapeStartX, e.X), (int)Math.Min(shapeStartY, e.Y), Math.Abs(e.X - shapeStartX), Math.Abs(e.Y - shapeStartY));
                        }
                        circlePen = new Pen(new SolidBrush(ColorsWindow.MyForeColor), ToolOptionsWindow.MyCircleContour);
                        g.DrawEllipse(circlePen, (int)Math.Min(shapeStartX, e.X), (int)Math.Min(shapeStartY, e.Y), Math.Abs(e.X - shapeStartX), Math.Abs(e.Y - shapeStartY));
                    }
                    pictureBox1.Image = myImage;
                }
                isDragging = false;
            }

// On MouseUp, the Edit menu items are updated accordingly.
            MonitorEditMenu();
        }

// When mouse leaves the pictureBox1, the StatusStrip on the Main form is cleared.
        private void pictureBox1_MouseLeave(object sender, EventArgs e)
        {
            ((Main)(this.MdiParent)).StatusStripReset();
        }

/* The three methods below are called in the course of the 
           MouseDown, MouseMove and MouseUp events */

// On selection definition, mouse e values are inserted to eFixX, eFixY
        // accordingly, while ensuring values are inside image bounds.
        private void FixEValues(int eX, int eY)
        {
            if (eX < 0)
            {
                eFixX = 0;
            }
            else if (eX > tempBi.Width - 1)
            {
                eFixX = tempBi.Width - 1;
            }
            else
            {
                eFixX = eX;
            }

if (eY < 0)
            {
                eFixY = 0;
            }
            else if (eY > tempBi.Height - 1)
            {
                eFixY = tempBi.Height - 1;
            }
            else
            {
                eFixY = eY;
            }
        }

// Called when a selection is dropped down.
        private void DropSelection()
        {
            if (selectChanged == true)
            {
                // Before dropping, push the current image to the undoStack.
                PushEdit();

Graphics g = Graphics.FromImage(myImage);
                if (selectPaste == false) // if true, the original location will not be erased
                {
                    selectionCutBrush = new SolidBrush(ColorsWindow.MyBackColor);
                    g.FillRectangle(selectionCutBrush, mySelection);
                }
                g.DrawImage(selectBi, selectionLocationX, selectionLocationY);
            }
            mySelectionState = SelectionState.None; // clear selection
            pictureBox1.Image = myImage;
        }

// Called recursively by the flood fill tool. This algorithm is from:
        // http://www.academictutorials.com/graphics/graphics-flood-fill.asp
        private void FillContiguously(int myX, int myY, Color myReplacedColor)
        {
            int myY1;

myY1 = myY;
            while ((myY1 < myImage.Height) && (myImage.GetPixel(myX, myY1) == myReplacedColor))
            {
                myImage.SetPixel(myX, myY1, ColorsWindow.MyBackColor);
                myY1++;
            }

myY1 = myY - 1;
            while ((myY1 >= 0) && (myImage.GetPixel(myX, myY1) == myReplacedColor))
            {
                myImage.SetPixel(myX, myY1, ColorsWindow.MyBackColor);
                myY1--;
            }

myY1 = myY;
            while ((myY1 < myImage.Height) && (myImage.GetPixel(myX, myY1) == ColorsWindow.MyBackColor))
            {
                if ((myX > 0) && (myImage.GetPixel(myX-1, myY1) == myReplacedColor))
                {
                    FillContiguously(myX - 1, myY1, myReplacedColor);
                }
                myY1++;
            }

myY1 = myY - 1;
            while ((myY1 >= 0) && (myImage.GetPixel(myX, myY1) == ColorsWindow.MyBackColor))
            {
                if ((myX > 0) && (myImage.GetPixel(myX-1, myY1) == myReplacedColor))
                {
                    FillContiguously(myX - 1, myY1, myReplacedColor);
                }
                myY1--;
            }

myY1 = myY;
            while ((myY1 < myImage.Height) && (myImage.GetPixel(myX, myY1) == ColorsWindow.MyBackColor))
            {
                if ((myX < myImage.Width - 1) && (myImage.GetPixel(myX + 1, myY1) == myReplacedColor))
                {
                    FillContiguously(myX + 1, myY1, myReplacedColor);
                }
                myY1++;
            }

myY1 = myY - 1;
            while ((myY1 >= 0) && (myImage.GetPixel(myX, myY1) == ColorsWindow.MyBackColor))
            {
                if ((myX < myImage.Width - 1) && (myImage.GetPixel(myX + 1, myY1) == myReplacedColor))
                {
                    FillContiguously(myX + 1, myY1, myReplacedColor);
                }
                myY1--;
            }
        }

// Updates the Edit menu items according to undo and redo Stacks counts,
        // Selection state, and clipboard contents.
        public void MonitorEditMenu()
        {
            if (undoStack.Count < 1)
            {
                undoToolStripMenuItem.Enabled = false;
            }
            else
            {
                undoToolStripMenuItem.Enabled = true;
            }
            if (redoStack.Count < 1)
            {
                redoToolStripMenuItem.Enabled = false;
            }
            else
            {
                redoToolStripMenuItem.Enabled = true;
            }
            if (mySelectionState == SelectionState.Selected)
            {
                cutToolStripMenuItem.Enabled = true;
                copyToolStripMenuItem.Enabled = true;
                deleteToolStripMenuItem.Enabled = true;
            }
            else
            {
                cutToolStripMenuItem.Enabled = false;
                copyToolStripMenuItem.Enabled = false;
                deleteToolStripMenuItem.Enabled = false;
            }
            if (Clipboard.ContainsImage() == true)
            {
                pasteToolStripMenuItem.Enabled = true;
            }
            else
            {
                pasteToolStripMenuItem.Enabled = false;
            }
        }

/* The ten methods below process the tasks of the File menu items,
           in the order of their appearance. */

// Called by the Main form, after a new instance of ImageForm class is declared
        public void FileNew(int myImageWidth, int myImageHeight, Color myImageBackground)
        {
            myImage = new Bitmap(myImageWidth, myImageHeight);
            Graphics g = Graphics.FromImage(myImage);
            g.Clear(myImageBackground);
            pictureBox1.ClientSize = new Size(myImage.Width, myImage.Height);
            pictureBox1.Image = myImage;
            saveToolStripMenuItem.Enabled = false;
            MonitorEditMenu();
        }

// Called by the Main form, using the FileName chosen by an OpenFileDialog
        public void FileOpen(string myFileName)
        {
            fileName = myFileName;

// The ImageFormat is determined according to the FileName extension.
            string myFileExt = myFileName.Substring(myFileName.LastIndexOf(".") + 1).ToLower();
            if ((myFileExt == "bmp") || (myFileExt == "dib"))
            {
                fileImageFormat = System.Drawing.Imaging.ImageFormat.Bmp;
            }
            else if ((myFileExt == "jpg") || (myFileExt == "jpeg") || (myFileExt == "jpe") || (myFileExt == "jfif"))
            {
                fileImageFormat = System.Drawing.Imaging.ImageFormat.Jpeg;
            }
            else if (myFileExt == "gif")
            {
                fileImageFormat = System.Drawing.Imaging.ImageFormat.Gif;
            }
            else if ((myFileExt == "tif") || (myFileExt == "tiff"))
            {
                fileImageFormat = System.Drawing.Imaging.ImageFormat.Tiff;
            }
            else
            {
                fileImageFormat = System.Drawing.Imaging.ImageFormat.Png;
            }

myImage = new Bitmap(Image.FromFile(myFileName));
            pictureBox1.ClientSize = new Size(myImage.Width, myImage.Height);
            pictureBox1.Image = myImage;
            saveToolStripMenuItem.Enabled = false;
            MonitorEditMenu();
        }

private void closeToolStripMenuItem_Click(object sender, EventArgs e)
        {
            this.Close();
        }

// On ImageForm closing the user is prompted to save the image, if needed.
        private void ImageForm_FormClosing(object sender, FormClosingEventArgs e)
        {
            if (saveToolStripMenuItem.Enabled == true)
            {
                DialogResult result;
                result = MessageBox.Show("Save changes to '" + this.Text + "'?", "Paint Application",
                    MessageBoxButtons.YesNoCancel, MessageBoxIcon.Warning, MessageBoxDefaultButton.Button3);
                if (result == DialogResult.Yes)
                {
                    saveAsToolStripMenuItem_Click(sender, e);
                }
                else if (result == DialogResult.Cancel)
                {
                    e.Cancel = true;
                }
            }
        }

private void saveToolStripMenuItem_Click(object sender, EventArgs e)
        {
            if (fileName != "")
            {
                myImage.Save(fileName, fileImageFormat);
                saveToolStripMenuItem.Enabled = false;
            }
            else // if the image isn't provided yet with a fileName, the save method calls saveAs
            {
                saveAsToolStripMenuItem_Click(sender, e);
            }
        }

private void saveAsToolStripMenuItem_Click(object sender, EventArgs e)
        {
            SaveFileDialog saveFile1 = new SaveFileDialog();
            saveFile1.AddExtension = true;
            saveFile1.OverwritePrompt = true;
            saveFile1.Filter = "Bitmap Files (*.bmp;*.dib)|*.bmp;*.dib|JPEG (*.jpg;*.jpeg;*.jpe;*.jfif)|*.jpg;*.jpeg;*.jpe;*.jfif|" +
                "GIF (*.gif)|*.gif|TIFF (*.tif;*.tiff)|*.tif;*.tiff|PNG (*.png)|*.png";

// If the image provides ImageFormat (i.e. it is not 'Untitled'), 
            // the dialog jumps to the appropriate FilterIndex.
            if (fileImageFormat != null) 
            {
                if (fileImageFormat == System.Drawing.Imaging.ImageFormat.Bmp)
                {
                    saveFile1.FilterIndex = 1;
                }
                else if (fileImageFormat == System.Drawing.Imaging.ImageFormat.Jpeg)
                {
                    saveFile1.FilterIndex = 2;
                }
                else if (fileImageFormat == System.Drawing.Imaging.ImageFormat.Gif)
                {
                    saveFile1.FilterIndex = 3;
                }
                else if (fileImageFormat == System.Drawing.Imaging.ImageFormat.Tiff)
                {
                    saveFile1.FilterIndex = 4;
                }
                else if (fileImageFormat == System.Drawing.Imaging.ImageFormat.Png)
                {
                    saveFile1.FilterIndex = 5;
                }                
            }
            else // if the image isn't provided yet with ImageFormat, the default is Png
            {
                fileImageFormat = System.Drawing.Imaging.ImageFormat.Png;
                saveFile1.FilterIndex = 5;
            }

// If the image provides fileName (i.e. it is not 'Untitled'), 
            // the dialog uses it, and also jumps to the appropriate directory.
            if (fileName != "")
            {
                saveFile1.FileName = fileName.Substring(fileName.LastIndexOf("\\") + 1).Remove(fileName.Substring(fileName.LastIndexOf("\\") + 1).LastIndexOf("."));
                saveFile1.InitialDirectory = (fileName.Remove(fileName.LastIndexOf("\\") + 1));
            }
            else // if the image is 'Untitled', it is used as default FileName
            {
                saveFile1.FileName = this.Text;
            }

if (saveFile1.ShowDialog() == System.Windows.Forms.DialogResult.OK &&
               saveFile1.FileName.Length > 0)
            {
                fileName = saveFile1.FileName;
                this.Text = saveFile1.FileName.Substring(fileName.LastIndexOf("\\") + 1);

// On DialogResult.OK, the fileImageFormat is updated.
                switch (saveFile1.FilterIndex)
                {
                    case 1:
                        fileImageFormat = System.Drawing.Imaging.ImageFormat.Bmp;
                        break;
                    case 2:
                        fileImageFormat = System.Drawing.Imaging.ImageFormat.Jpeg;
                        break;
                    case 3:
                        fileImageFormat = System.Drawing.Imaging.ImageFormat.Gif;
                        break;
                    case 4:
                        fileImageFormat = System.Drawing.Imaging.ImageFormat.Tiff;
                        break;
                    case 5:
                        fileImageFormat = System.Drawing.Imaging.ImageFormat.Png;
                        break;
                }
                myImage.Save(saveFile1.FileName, fileImageFormat);
                saveToolStripMenuItem.Enabled = false;
            }
        }

/* The four methods below serve the print items of the File menu. */

private void pageSetupToolStripMenuItem_Click(object sender, EventArgs e)
        {
            myPageSetupDialog.PageSettings = myPageSettings;
            myPageSetupDialog.ShowDialog();
            myPrintDocument.DefaultPageSettings = myPageSettings;
        }

private void printPreviewToolStripMenuItem_Click(object sender, EventArgs e)
        {
            myPrintPreviewDialog.Document = myPrintDocument;
            myPrintPreviewDialog.ShowDialog();
        }

private void printToolStripMenuItem_Click(object sender, EventArgs e)
        {
            myPrintDialog.Document = myPrintDocument;
            myPrintDialog.AllowSomePages = false;
            if (myPrintDialog.ShowDialog() == DialogResult.OK)
            {
                myPrintDocument.Print();
            }
        }

private void myPrintDocument_PrintPage(object sender, PrintPageEventArgs e)
        {
            // Here myPrintArea of the image is determined according to 
            // the page orientation and margins on myPageSettings 
            // (which were defined in myPageSetupDialog).
            if (myPageSettings.Landscape == false) // for Portrait page printing
            {
                myPrintArea = new Rectangle(myPageSettings.Margins.Left, myPageSettings.Margins.Top,
                    (myPageSettings.PaperSize.Width - myPageSettings.Margins.Left - myPageSettings.Margins.Right),
                    (myPageSettings.PaperSize.Height - myPageSettings.Margins.Top - myPageSettings.Margins.Bottom));
                myPrintArea.Height = (int)(myPrintArea.Width * myImage.Height / myImage.Width);

// This fixes myPrintArea if myImage aspect ratio is narrower than the page's. 
                if (myPrintArea.Height > (myPageSettings.PaperSize.Height - myPageSettings.Margins.Top - myPageSettings.Margins.Bottom))
                {
                    myPrintArea.Height = (myPageSettings.PaperSize.Height - myPageSettings.Margins.Top - myPageSettings.Margins.Bottom);
                    myPrintArea.Width = myPrintArea.Height * myImage.Width / myImage.Height;
                }
            }
            else // for landscape page printing
            {
                myPrintArea = new Rectangle(myPageSettings.Margins.Bottom, myPageSettings.Margins.Left,
                   (myPageSettings.PaperSize.Height - myPageSettings.Margins.Top - myPageSettings.Margins.Bottom),
                   (myPageSettings.PaperSize.Width - myPageSettings.Margins.Left - myPageSettings.Margins.Right));
                myPrintArea.Width = (int)(myPrintArea.Height * myImage.Width / myImage.Height);

// This fixes myPrintArea if myImage aspect ratio is wider than the page's.
                if (myPrintArea.Width > (myPageSettings.PaperSize.Height - myPageSettings.Margins.Top - myPageSettings.Margins.Bottom))
                {
                    myPrintArea.Width = (myPageSettings.PaperSize.Height - myPageSettings.Margins.Top - myPageSettings.Margins.Bottom);
                    myPrintArea.Height = myPrintArea.Width * myImage.Height / myImage.Width;
                }
            }

e.Graphics.DrawImage(myImage, myPrintArea);
        }

/* The nine methods below process the tasks of the Edit menu items,
           in the order of their appearance. */

private void undoToolStripMenuItem_Click(object sender, EventArgs e)
        {
            mySelectionState = SelectionState.None; // the Undo first clears any existing selection
            if (undoStack.Count > 0)
            {
                Bitmap pushImage = new Bitmap(myImage);
                redoStack.Push(pushImage); // the current myImage is pushed to the redoStack
                myImage = undoStack.Pop();
                pictureBox1.Image = myImage;
                saveToolStripMenuItem.Enabled = true;
            }
            MonitorEditMenu();
        }

private void redoToolStripMenuItem_Click(object sender, EventArgs e)
        {
            mySelectionState = SelectionState.None; // the Redo first clears any existing selection
            if (redoStack.Count > 0)
            {
                Bitmap pushImage = new Bitmap(myImage);
                undoStack.Push(pushImage); // the current myImage is pushed to the undoStack
                myImage = redoStack.Pop();
                pictureBox1.Image = myImage;
                saveToolStripMenuItem.Enabled = true;
            }
            MonitorEditMenu();
        }

// Pushes myImage into the undoStack.
        // Always called before a change is applied.
        public void PushEdit()
        {
            saveToolStripMenuItem.Enabled = true;
            redoStack.Clear();
            Bitmap pushImage = new Bitmap(myImage);
            undoStack.Push(pushImage);
        }

private void cutToolStripMenuItem_Click(object sender, EventArgs e)
        {
            Clipboard.SetImage(selectBi);

// The cut method calls the delete method to erase the selection original location.
            deleteToolStripMenuItem_Click(sender, e);
        }

private void copyToolStripMenuItem_Click(object sender, EventArgs e)
        {
            Clipboard.SetImage(selectBi);
        }

private void pasteToolStripMenuItem_Click(object sender, EventArgs e)
        {
            mySelectionState = SelectionState.None; // pasting first clears any existing selection
            selectBi = (Bitmap)Clipboard.GetImage();
            FetchSelection();
            selectChanged = true; // a pasted selection is always considered as changed
            selectPaste = true;
        }

// Called by the paste and selectAll methods, to define
        // a selection and locate it on the upper-left corner.
        private void FetchSelection()
        {
            selectionWidth = selectBi.Width;
            selectionHeight = selectBi.Height;
            if (selectionWidth > 0 && selectionHeight > 0)
            {
                selectionLocationX = selectionStartX = 0;
                selectionLocationY = selectionStartY = 0;
                mySelection = new Rectangle(selectionStartX, selectionStartY, selectionWidth, selectionHeight);
                mySelectionState = SelectionState.Selected;

tempBi = (Bitmap)myImage.Clone();
                Graphics tempGr = Graphics.FromImage(tempBi);
                tempGr.DrawImage(selectBi, selectionLocationX, selectionLocationY);
                tempGr.DrawRectangle(selectPen, selectionLocationX, selectionLocationY, selectionWidth - 1, selectionHeight - 1);
                pictureBox1.Image = tempBi;

((Main)(this.MdiParent)).ChosenToolUpdate("select");
            }
        }

private void deleteToolStripMenuItem_Click(object sender, EventArgs e)
        {
            if (selectPaste == false)
            {
                PushEdit();
                Graphics g = Graphics.FromImage(myImage);
                selectionCutBrush = new SolidBrush(ColorsWindow.MyBackColor);
                g.FillRectangle(selectionCutBrush, mySelection);
            }
            pictureBox1.Image = myImage;

// After erasing the selection original location, 
            // the selection is cleared.
            mySelectionState = SelectionState.None;
        }

private void selectAllToolStripMenuItem_Click(object sender, EventArgs e)
        {
            mySelectionState = SelectionState.None;
            selectBi = (Bitmap)myImage.Clone();
            FetchSelection();
            selectPaste = false;
        }

/* The five methods below process the tasks of the Image menu items,
           in the order of their appearance. */

private void brightnessToolStripMenuItem_Click(object sender, EventArgs e)
        {
            BrightnessDialog MyBrightnessDialog = new BrightnessDialog();
            MyBrightnessDialog.Owner = this; // the new BrightnessDialog is owned by the ImageForm for interaction
            if (MyBrightnessDialog.ShowDialog() == DialogResult.OK)
            {
                if (mySelectionState == SelectionState.Selected) // the brightness is applied to the selection, if such exists
                {
                    // Here PushEdit is not needed, since the selection is yet to dropped down.
                    selectBi = BrightenImage(selectBi, MyBrightnessDialog.BrightnessLevel);
                    UpdateProcessedSelectionBitmap();
                }
                else // the brightness is applied to myImage
                {
                    PushEdit();
                    myImage = BrightenImage(myImage, MyBrightnessDialog.BrightnessLevel);
                    pictureBox1.Image = myImage;
                }
            }
        }

// Returns a brightened Bitmap according to the level defined in MyBrightnessDialog.
        // This method is public so MyBrightnessDialog can access it for its' preview.
        public Bitmap BrightenImage(Bitmap imageToBrighten, int brightnessLevel)
        {
            int newR, newG, newB;
            for (int x = 0; x < imageToBrighten.Width; x++)
            {
                for (int y = 0; y < imageToBrighten.Height; y++)
                {
                    newR = imageToBrighten.GetPixel(x, y).R + brightnessLevel;
                    if (newR > 255)
                        newR = 255;
                    else if (newR < 0)
                        newR = 0;
                    newG = imageToBrighten.GetPixel(x, y).G + brightnessLevel;
                    if (newG > 255)
                        newG = 255;
                    else if (newG < 0)
                        newG = 0;
                    newB = imageToBrighten.GetPixel(x, y).B + brightnessLevel;
                    if (newB > 255)
                        newB = 255;
                    else if (newB < 0)
                        newB = 0;
                    imageToBrighten.SetPixel(x, y, Color.FromArgb(newR, newG, newB));
                }
            }
            return imageToBrighten;
        }

private void invertToolStripMenuItem_Click(object sender, EventArgs e)
        {
            if (mySelectionState == SelectionState.Selected) // the inversion is applied to the selection, if such exists
            {
                // Here PushEdit is not needed, since the selection is yet to dropped down.
                selectBi = InvertImage(selectBi);
                UpdateProcessedSelectionBitmap();
            }
            else // the inversion is applied to myImage
            {
                PushEdit();
                myImage = InvertImage(myImage);
                pictureBox1.Image = myImage;
            }
        }

// Returns an inverted Bitmap.
        private Bitmap InvertImage(Bitmap imageToInvert)
        {
            int invR, invG, invB;
            for (int x = 0; x < imageToInvert.Width; x++)
            {
                for (int y = 0; y < imageToInvert.Height; y++)
                {
                    invR = 255 - imageToInvert.GetPixel(x, y).R;
                    invG = 255 - imageToInvert.GetPixel(x, y).G;
                    invB = 255 - imageToInvert.GetPixel(x, y).B;
                    imageToInvert.SetPixel(x, y, Color.FromArgb(invR, invG, invB));
                }
            }
            return imageToInvert;
        }

// If an image filter (i.e. brightness or invert) 
        // is applied to a selection, this method is called 
        // to update the selection display after processing.
        private void UpdateProcessedSelectionBitmap()
        {
            selectChanged = true; // declares the processed selection as changed
            tempBi = (Bitmap)myImage.Clone();
            Graphics tempGr = Graphics.FromImage(tempBi);
            if (selectPaste == false)
            {
                selectionCutBrush = new SolidBrush(ColorsWindow.MyBackColor);
                tempGr.FillRectangle(selectionCutBrush, mySelection);
            }
            tempGr.DrawImage(selectBi, selectionLocationX, selectionLocationY);
            tempGr.DrawRectangle(selectPen, selectionLocationX, selectionLocationY, selectionWidth, selectionHeight);
            pictureBox1.Image = tempBi;
        }
    }
}

Monday, October 5, 2009

VBScript Editor [C#]

Hi there. I wrote a simple VBScript Editor in C#, here is a summary of it:

It is a Multiple-Document Interface application, the main menu is merged with a non-visible MenuStrip on the Document form.

Syntax coloring and letter casing is done live, based on the lines affected by the change in the text. The keywords for each color are stored in a regular expression.

Line numbers and column ruler are achieved by RichTextBoxes moved on separate panels. Line and column markers are updated according to the caret's position.

The data for the multiple undo and redo features is stored in Stacks.

Printing is available using the RichTextBoxPrintCtrl from Microsoft.

The tool windows, 'Find\Replace' and 'Jump to line' are always owned by the current active Document.

Here is the code for the Document form:

using System;
using System.Collections;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
using System.IO;
using System.Runtime.InteropServices;
using System.Text.RegularExpressions;
using System.Drawing.Printing;

namespace VBScriptEditor
{
    public partial class Document : Form
    {
        public Document()
        {
            // Create the font for all controls, and measure its' character size.
            myFont = new Font("Courier New", 11);
            myFontHeight = TextRenderer.MeasureText("A", myFont).Height;
            myFontWidth = TextRenderer.MeasureText("A", myFont).Width;

InitializeComponent();

// Subscribe to events for printing.
            this.printDocument1.BeginPrint += new System.Drawing.Printing.PrintEventHandler(this.printDocument1_BeginPrint);
            this.printDocument1.PrintPage += new System.Drawing.Printing.PrintPageEventHandler(this.printDocument1_PrintPage);

// Set myFont for all RichTextBox controls on the form.
            // Use its' measurements as a basic unit for the size of all controls.
            columnRulerMarker.Font = columnRulerBox.Font = lineNumbersMarker.Font = lineNumbersBox.Font = richTextBox1.Font = myFont;
            verticalSplitContainer.SplitterDistance = lineNumbersMarker.Width = lineNumbersBox.Width = myFontWidth;
            columnRulerMarker.Width = myFontWidth * 2 / 3;
            horizontalSplitContainer.SplitterDistance = columnRulerMarker.Height = columnRulerBox.Height = lineNumbersMarker.Height = lineNumbersBox.Height = myFontHeight;
            columnRulerMarker.Location = columnRulerBox.Location = new Point((lineNumbersBox.Width + verticalSplitContainer.SplitterWidth), 0);
            columnRulerBox.Width = richTextBox1.Width;
            columnRulerBox.Text = rulerUnit;

// Create the ContextMenuStrip for richTextBox1.
            ToolStripMenuItem[] richTextBox1_MenuGroup1 = new ToolStripMenuItem[2];
            richTextBox1_MenuGroup1[0] = new ToolStripMenuItem("Undo",
                null, new System.EventHandler(undoToolStripMenuItem_Click));
            richTextBox1_MenuGroup1[1] = new ToolStripMenuItem("Redo",
                null, new System.EventHandler(redoToolStripMenuItem_Click));
            ToolStripMenuItem[] richTextBox1_MenuGroup2 = new ToolStripMenuItem[4];
            richTextBox1_MenuGroup2[0] = new ToolStripMenuItem("Cut",
                null, new System.EventHandler(cutToolStripMenuItem_Click));
            richTextBox1_MenuGroup2[1] = new ToolStripMenuItem("Copy",
                null, new System.EventHandler(copyToolStripMenuItem_Click));
            richTextBox1_MenuGroup2[2] = new ToolStripMenuItem("Paste",
                null, new System.EventHandler(pasteToolStripMenuItem_Click));
            richTextBox1_MenuGroup2[3] = new ToolStripMenuItem("Delete",
                null, new System.EventHandler(deleteToolStripMenuItem_Click));
            ToolStripMenuItem[] richTextBox1_MenuGroup3 = new ToolStripMenuItem[1];
            richTextBox1_MenuGroup3[0] = new ToolStripMenuItem("Select All",
                null, new System.EventHandler(selectAllToolStripMenuItem_Click));
            ContextMenuStrip richTextBox1_Menu = new ContextMenuStrip();
            richTextBox1_Menu.Items.AddRange(richTextBox1_MenuGroup1);
            richTextBox1_Menu.Items.Add("-");
            richTextBox1_Menu.Items.AddRange(richTextBox1_MenuGroup2);
            richTextBox1_Menu.Items.Add("-");
            richTextBox1_Menu.Items.AddRange(richTextBox1_MenuGroup3);
            richTextBox1.ContextMenuStrip = richTextBox1_Menu;
            richTextBox1.ContextMenuStrip.Opening += new System.ComponentModel.CancelEventHandler(this.contextMenuStrip_Opening);
            richTextBox1.ContextMenuStrip.Enabled = true;

// Set the tabs for richTextBox1.
            int myTabWidth = myFontWidth * 95 / 100;
            int[] myTabs = new int[32];
            for (int i = 0; i < myTabs.Length; i++)
            {
                myTabs[i] = myTabWidth * (i + 1);
            }
            SendMessage(richTextBox1.Handle, EM_SETTABSTOPS, 1, myTabs);

// Arrange the placement of all controls,
            // and update the edit menu items accordingly.
            FixLineNumbers();
            ScrollColumnRuler();
            MoveMarkers();
            MonitorEditMenu();
            saveToolStripMenuItem.Enabled = false;
        }

// needed for window update locking while making adjustments
        [DllImport("user32.dll", CharSet = CharSet.Auto)]
        public static extern bool LockWindowUpdate(IntPtr hWndLock);

// needed for setting the tabs on richTextBox1
        private const int EM_SETTABSTOPS = 0x00CB;
        [DllImport("user32.dll", CharSet = CharSet.Auto)]
        public static extern IntPtr SendMessage(IntPtr h, int msg, int wParam, int[] lParam);

private int checkPrint;

private Font myFont;
        private int myFontHeight, myFontWidth;
        private string rulerUnit = "----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0";
        private string fileName = "";

private Stack undoStack = new Stack();
        private Stack redoStack = new Stack();

private int lastLinesLength;
        private int lastLineNumbersLength = 1;
        
        private int lastKeyPosition;
        private Keys lastKey = new Keys();

// property for getting the document's 
        // filename by the main application form. 
        public string FileName
        {
            get { return fileName; }
        }

// Process syntax coloring, line numbering 
        // and markers location while text is being typed.
        // Any other method which changes the text on richTextBox1
        // will temporarily unsubscribe this method from the TextChanged event.
        private void richTextBox1_TextChanged(object sender, EventArgs e)
        {
            richTextBox1.SelectionChanged -= new System.EventHandler(richTextBox1_SelectionChanged);
            int originStart = richTextBox1.SelectionStart;
            LockWindowUpdate(this.Handle);

// The text is checked a character before and a character after
            // the change location, so in cases of line-breaks
            // both of the new lines will be processed.
            GetLines(originStart - 1, originStart + 1);
            richTextBox1.SelectionStart = originStart;
            MoveMarkers();
            if (richTextBox1.Lines.Length != lastLinesLength)
            {
                FixLineNumbers();
            }
            lineNumbersBox.Location = new Point(0, richTextBox1.GetPositionFromCharIndex(0).Y);
            LockWindowUpdate(IntPtr.Zero);
            lastLinesLength = richTextBox1.Lines.Length;
            saveToolStripMenuItem.Enabled = true;
            richTextBox1.SelectionChanged += new System.EventHandler(richTextBox1_SelectionChanged);
        }

// Gets all lines in a range of character indexes,
        // and sends each line for syntax coloring.
        private void GetLines(int runStart, int runEnd)
        {
            for (int i = richTextBox1.GetLineFromCharIndex(runStart); i <= richTextBox1.GetLineFromCharIndex(runEnd); i++)
            {
                FixLine(i);
            }
        }

// Colors the syntax of a single line.
        private void FixLine(int myLine)
        {
            if (richTextBox1.TextLength < 1)
            {
                richTextBox1.SelectionStart = 0;
                richTextBox1.SelectionStart = 0;
            }
            else
            {
                richTextBox1.Select((richTextBox1.GetFirstCharIndexFromLine(myLine)), (richTextBox1.Lines[myLine].Length));
            }
            richTextBox1.SelectionColor = Color.Black;
            MatchCollection myQuotes = Keywords.QM.Matches(richTextBox1.SelectedText);
            MatchCollection myComments = Keywords.CO.Matches(richTextBox1.SelectedText);
            MatchCollection myFunctions = Keywords.FC.Matches(richTextBox1.SelectedText);
            MatchCollection myStatements = Keywords.ST.Matches(richTextBox1.SelectedText);
            MatchCollection myLetterCase = Keywords.LC.Matches(richTextBox1.SelectedText);
            for (int i = 0; i < myQuotes.Count; i += 2)
            {
                int j = i + 1;
                richTextBox1.SelectionStart = (myQuotes[i].Index + richTextBox1.GetFirstCharIndexFromLine(myLine));
                if (j < myQuotes.Count)
                {    
                    richTextBox1.SelectionLength = (1 - myQuotes[i].Index + myQuotes[j].Index);   
                }
                else
                {
                    richTextBox1.SelectionLength = 1;
                }
                richTextBox1.SelectionColor = Color.DeepPink;
                richTextBox1.DeselectAll();
            }
            for (int i = 0; i < myComments.Count; i++)
            {
                richTextBox1.Select((myComments[i].Index + richTextBox1.GetFirstCharIndexFromLine(myLine)), (myComments[i].Length));
                if (richTextBox1.SelectionColor == Color.Black)
                {
                    richTextBox1.SelectionLength = richTextBox1.Lines[myLine].Length - myComments[i].Index;
                    richTextBox1.SelectionColor = Color.Green;
                }
            }
            for (int i = 0; i < myFunctions.Count; i++)
            {
                richTextBox1.Select((myFunctions[i].Index + richTextBox1.GetFirstCharIndexFromLine(myLine)), (myFunctions[i].Length));
                if (richTextBox1.SelectionColor == Color.Black)
                {
                    richTextBox1.SelectionColor = Color.Red;
                    richTextBox1.SelectionLength = 1;
                    richTextBox1.SelectedText = richTextBox1.SelectedText.ToUpper();
                    if (myFunctions[i].Length > 1)
                    {
                        richTextBox1.SelectionLength = (myFunctions[i].Length - 1);
                        richTextBox1.SelectedText = richTextBox1.SelectedText.ToLower();
                    }
                }
            }
            for (int i = 0; i < myStatements.Count; i++)
            {
                richTextBox1.Select((myStatements[i].Index + richTextBox1.GetFirstCharIndexFromLine(myLine)), (myStatements[i].Length));
                if (richTextBox1.SelectionColor == Color.Black)
                {
                    richTextBox1.SelectionColor = Color.Blue;
                    richTextBox1.SelectionLength = 1;
                    richTextBox1.SelectedText = richTextBox1.SelectedText.ToUpper();
                    if (myStatements[i].Length > 1)
                    {
                        richTextBox1.SelectionLength = (myStatements[i].Length - 1);
                        richTextBox1.SelectedText = richTextBox1.SelectedText.ToLower();
                    }
                }
            }
            for (int i = 0; i < myLetterCase.Count; i++)
            {
                richTextBox1.Select((myLetterCase[i].Index + richTextBox1.GetFirstCharIndexFromLine(myLine)), 1);
                if ((richTextBox1.SelectionColor != Color.Black) && (richTextBox1.SelectionColor != Color.DeepPink) && (richTextBox1.SelectionColor != Color.Green))
                {
                    richTextBox1.SelectedText = richTextBox1.SelectedText.ToUpper();
                }
            }
            richTextBox1.DeselectAll();
        }

/* The four methods below are called accrodingly
           during the various adjustements which occur in the Document. */

// Updates the text and height of the lineNumbersBox.
        private void FixLineNumbers()
        {
            string linesLengthString = (richTextBox1.Lines.Length).ToString();
            if (richTextBox1.Lines.Length > lineNumbersBox.Lines.Length + 1)
            {
                lineNumbersBox.Text = "1";
                for (int i = 2; i <= richTextBox1.Lines.Length; i++)
                {
                    lineNumbersBox.AppendText("\n");
                    lineNumbersBox.AppendText(i.ToString());
                }
            }
            else if (richTextBox1.Lines.Length == lineNumbersBox.Lines.Length + 1)
            {
                lineNumbersBox.AppendText("\n");
                lineNumbersBox.AppendText(richTextBox1.Lines.Length.ToString());
            }
            else if (richTextBox1.Lines.Length < 1)
            {
                lineNumbersBox.Text = "1";
            }
            lineNumbersBox.Height = (richTextBox1.Lines.Length * myFontHeight);
            if (linesLengthString.Length != lastLineNumbersLength)
            {
                lineNumbersBox.Width = linesLengthString.Length * myFontWidth;
                lineNumbersMarker.Width = lineNumbersBox.Width;
                verticalSplitContainer.SplitterDistance = lineNumbersBox.Width;
                ScrollColumnRuler();
                MoveMarkers();
            }
            lastLineNumbersLength = linesLengthString.Length;
        }

// Updates the location of the lineNumbersBox 
        // and lineNumbersMarker for scrolling.
        private void ScrollLineNumbers()
        {
            lineNumbersBox.Location = new Point(0, richTextBox1.GetPositionFromCharIndex(0).Y);
            lineNumbersMarker.Location = new Point(0, richTextBox1.GetPositionFromCharIndex(richTextBox1.SelectionStart).Y);
        }

// Updates the location and of the columnRulerBox 
        // and columnRulerMarker for scrolling.
        // Appends the columnRulerBox with more units if needed.
        private void ScrollColumnRuler()
        {
            columnRulerBox.Location = new Point((richTextBox1.GetPositionFromCharIndex(0).X + lineNumbersBox.Width + verticalSplitContainer.SplitterWidth), 0);
            columnRulerBox.Width = columnRulerBox.Location.X * -1 + this.Width;
            if ((columnRulerBox.Width * 2) > (columnRulerBox.TextLength * myFontWidth))
            {
                columnRulerBox.AppendText(rulerUnit);
            }
        }

// Updates both markers location for non-scrolling actions
        // and sets them with the appropriate text.
        private void MoveMarkers()
        {
            lineNumbersMarker.Location = new Point(0, richTextBox1.GetPositionFromCharIndex(richTextBox1.SelectionStart).Y);
            lineNumbersMarker.Text = ((lineNumbersMarker.Location.Y + lineNumbersBox.Location.Y * -1) / myFontHeight + 1).ToString();
            columnRulerMarker.Location = new Point((richTextBox1.GetPositionFromCharIndex(richTextBox1.SelectionStart).X + lineNumbersBox.Width + verticalSplitContainer.SplitterWidth), 0);
            columnRulerMarker.Text = (columnRulerBox.GetCharFromPosition(new Point(columnRulerBox.Width - this.Width + columnRulerMarker.Location.X, 0)).ToString());
        }

// Uses to block focus from any control other than richTextBox1.
        private void richTextBox2_Enter(object sender, EventArgs e)
        {
            richTextBox1.Focus();
        }

/* The four methods below call the appropriate methods
           when resizing the form, scrolling richTextBox1 
           and moving the caret in richTextBox1. */

private void richTextBox1_VScroll(object sender, EventArgs e)
        {
            ScrollLineNumbers();
        }

private void Form1_SizeChanged(object sender, EventArgs e)
        {
            if (this.WindowState != FormWindowState.Maximized)
            {
                ScrollLineNumbers();
            }
            ScrollColumnRuler();
            MoveMarkers();
        }

private void richTextBox1_SelectionChanged(object sender, EventArgs e)
        {
            MoveMarkers();

// Call the method to update edit menu items,
            // since the cut, copy and delete items are enabled 
            // and disabled according to the selection start and length.
            MonitorEditMenu();
        }

private void richTextBox1_HScroll(object sender, EventArgs e)
        {
            ScrollColumnRuler();
            MoveMarkers();
        }

// Processes keys pressed on richTextBox1,
        // and determines wheter to push the state before into the Undo stack.
        private void richTextBox1_PreviewKeyDown(object sender, PreviewKeyDownEventArgs e)
        {
            if (!e.Control && !e.Alt && !e.Shift && (e.KeyData < Keys.Prior || e.KeyData > Keys.Insert) &&
                ((lastKey < Keys.A || lastKey > Keys.Z) || (richTextBox1.SelectionStart != lastKeyPosition + 1)))
            {
                PushEdit();
            }

// The data and caret location for the last key pressed
            // are used for comparison with the current key pressed.
            lastKey = e.KeyData;
            lastKeyPosition = richTextBox1.SelectionStart;
        }

// Enables and disables the edit menu items appropriatly.
        private void MonitorEditMenu()
        {
            if (undoStack.Count < 1)
            {
                undoToolStripMenuItem.Enabled = false;
            }
            else
            {
                undoToolStripMenuItem.Enabled = true;
            }
            if (redoStack.Count < 1)
            {
                redoToolStripMenuItem.Enabled = false;
            }
            else
            {
                redoToolStripMenuItem.Enabled = true;
            }
            if (richTextBox1.SelectionLength < 1)
            {
                cutToolStripMenuItem.Enabled = false;
                copyToolStripMenuItem.Enabled = false;
            }
            else
            {
                cutToolStripMenuItem.Enabled = true;
                copyToolStripMenuItem.Enabled = true;
            }
            if (richTextBox1.SelectionStart == richTextBox1.TextLength)
            {
                deleteToolStripMenuItem.Enabled = false;
            }
            else
            {
                deleteToolStripMenuItem.Enabled = true;
            }
            if (richTextBox1.TextLength < 1)
            {
                selectAllToolStripMenuItem.Enabled = false;
            }
            else
            {
                selectAllToolStripMenuItem.Enabled = true;
            }
            if (!Clipboard.ContainsText())
            {
                pasteToolStripMenuItem.Enabled = false;
            }
            else
            {
                pasteToolStripMenuItem.Enabled = true;
            }
        }

/* The methods below process the tasks of each menu strip item,
           in the order of their appearance. */

public void FileOpen(string myFileName)
        {
            richTextBox1.TextChanged -= new System.EventHandler(richTextBox1_TextChanged);
            LockWindowUpdate(this.Handle);
            fileName = myFileName;
            richTextBox1.LoadFile(fileName, RichTextBoxStreamType.PlainText);
            GetLines(0, richTextBox1.TextLength);
            FixLineNumbers();
            richTextBox1.SelectionStart = 0;
            saveToolStripMenuItem.Enabled = false;
            LockWindowUpdate(IntPtr.Zero);
            MonitorEditMenu();
            richTextBox1.TextChanged += new System.EventHandler(richTextBox1_TextChanged);
        }

private void closeToolStripMenuItem_Click(object sender, EventArgs e)
        {
            this.Close();
        }

private void Document_FormClosing(object sender, FormClosingEventArgs e)
        {
            if (saveToolStripMenuItem.Enabled == true)
            {
                DialogResult result;
                result = MessageBox.Show("Save changes to '" + this.Text + "'?", "VBScript Editor",
                    MessageBoxButtons.YesNoCancel, MessageBoxIcon.Warning, MessageBoxDefaultButton.Button3);
                if (result == DialogResult.Yes)
                {
                    saveAsToolStripMenuItem_Click(sender, e);
                }
                else if (result == DialogResult.Cancel)
                {
                    e.Cancel = true;
                }
            }
        }

private void saveToolStripMenuItem_Click(object sender, EventArgs e)
        {
            if (fileName != "")
            {
                richTextBox1.SaveFile(fileName, RichTextBoxStreamType.PlainText);
                saveToolStripMenuItem.Enabled = false;
            }
            else
            {
                saveAsToolStripMenuItem_Click(sender, e);
            }
        }

private void saveAsToolStripMenuItem_Click(object sender, EventArgs e)
        {
            SaveFileDialog saveFile1 = new SaveFileDialog();
            saveFile1.OverwritePrompt = true;
            saveFile1.DefaultExt = ("*.vbs");
            saveFile1.Filter = "All Files (*.vbs;*.txt)|*.vbs;*.txt|VBScript (*.vbs)|*.vbs|Text Files (*.txt)|*.txt";
            if (fileName != "")
            {
                saveFile1.FileName = fileName.Substring(fileName.LastIndexOf("\\") + 1);
                saveFile1.InitialDirectory = (fileName.Remove(fileName.LastIndexOf("\\") + 1));
            }
            else
            {
                saveFile1.FileName = this.Text;
            }
            if (saveFile1.ShowDialog() == System.Windows.Forms.DialogResult.OK &&
               saveFile1.FileName.Length > 0)
            {
                fileName = saveFile1.FileName;
                this.Text = saveFile1.FileName.Substring(fileName.LastIndexOf("\\") + 1);
                richTextBox1.SaveFile(saveFile1.FileName, RichTextBoxStreamType.PlainText);
                saveToolStripMenuItem.Enabled = false;
            }
        }

/* The five methods below are copied from Microsoft's RichTextBoxPrintCtrl
           tutorial for printing RichTextBox contents. */

private void pageSetupToolStripMenuItem_Click(object sender, EventArgs e)
        {
            pageSetupDialog1.ShowDialog();
        }

private void printPreviewToolStripMenuItem_Click(object sender, EventArgs e)
        {
            printPreviewDialog1.ShowDialog();
        }

private void printToolStripMenuItem_Click(object sender, EventArgs e)
        {
            if (printDialog1.ShowDialog() == DialogResult.OK)
                printDocument1.Print();
        }

private void printDocument1_BeginPrint(object sender, System.Drawing.Printing.PrintEventArgs e)
        {
            checkPrint = 0;
        }

private void printDocument1_PrintPage(object sender, System.Drawing.Printing.PrintPageEventArgs e)
        {
            // Print the content of RichTextBox. Store the last character printed.
            checkPrint = richTextBox1.Print(checkPrint, richTextBox1.TextLength, e);

// Check for more pages
            if (checkPrint < richTextBox1.TextLength)
                e.HasMorePages = true;
            else
                e.HasMorePages = false;
        }

private void undoToolStripMenuItem_Click(object sender, EventArgs e)
        {
            richTextBox1.TextChanged -= new System.EventHandler(richTextBox1_TextChanged);
            if (undoStack.Count > 0)
            {
                LockWindowUpdate(this.Handle);

// The Undo first pushes the current state
                // into the Redo stack.
                Hashtable myState = new Hashtable();
                myState["text"] = richTextBox1.Rtf;
                myState["position"] = richTextBox1.SelectionStart;
                redoStack.Push(myState);

// Then, the last state is popped from the Undo stack.
                Hashtable undoState = (Hashtable)undoStack.Pop();
                richTextBox1.Rtf = (string)undoState["text"];
                richTextBox1.SelectionStart = (int)undoState["position"];

FixLineNumbers();
                LockWindowUpdate(IntPtr.Zero);
                saveToolStripMenuItem.Enabled = true;
            }
            MonitorEditMenu();
            richTextBox1.TextChanged += new System.EventHandler(richTextBox1_TextChanged);
        }

private void redoToolStripMenuItem_Click(object sender, EventArgs e)
        {
            richTextBox1.TextChanged -= new System.EventHandler(richTextBox1_TextChanged);
            if (redoStack.Count > 0)
            {
                LockWindowUpdate(this.Handle);

// The Redo first pushes the current state
                // into the Undo stack.
                Hashtable myState = new Hashtable();
                myState["text"] = richTextBox1.Rtf;
                myState["position"] = richTextBox1.SelectionStart;
                undoStack.Push(myState);

// Then, the last state is popped from the Redo stack.
                Hashtable redoState = (Hashtable)redoStack.Pop();
                richTextBox1.Rtf = (string)redoState["text"];
                richTextBox1.SelectionStart = (int)redoState["position"];
                FixLineNumbers();
                LockWindowUpdate(IntPtr.Zero);
                saveToolStripMenuItem.Enabled = true;
            }
            MonitorEditMenu();
            richTextBox1.TextChanged += new System.EventHandler(richTextBox1_TextChanged);
        }

// Pushes a state into the Undo stack.
        // This method is always called before the change 
        // in the text is applied (e.g. the PreviewKeyDown event).
        public void PushEdit()
        {
            redoStack.Clear();
            Hashtable myState = new Hashtable();
            myState["text"] = richTextBox1.Rtf;
            myState["position"] = richTextBox1.SelectionStart;
            undoStack.Push(myState);
        }

private void cutToolStripMenuItem_Click(object sender, EventArgs e)
        {
            Clipboard.SetDataObject(richTextBox1.SelectedText);
            richTextBox1.SelectedText = "";
        }

private void copyToolStripMenuItem_Click(object sender, EventArgs e)
        {
            Clipboard.SetDataObject(richTextBox1.SelectedText);
            MonitorEditMenu();
        }

private void pasteToolStripMenuItem_Click(object sender, EventArgs e)
        {
            richTextBox1.TextChanged -= new System.EventHandler(richTextBox1_TextChanged);
            if (Clipboard.ContainsText())
            {
                PushEdit();
                LockWindowUpdate(this.Handle);
                int originStart = richTextBox1.SelectionStart;
                richTextBox1.Paste(DataFormats.GetFormat("Text"));
                int newLocation = richTextBox1.SelectionStart;

// The recoloring range after pasting text
                // starts on the line where the caret was pre-paste,
                // and ends with the line of its' post-paste location.
                GetLines(originStart, newLocation);

FixLineNumbers();
                richTextBox1.SelectionStart = newLocation;
                LockWindowUpdate(IntPtr.Zero);
                saveToolStripMenuItem.Enabled = true;
            }
            richTextBox1.TextChanged += new System.EventHandler(richTextBox1_TextChanged);
        }

private void deleteToolStripMenuItem_Click(object sender, EventArgs e)
        {
            if (richTextBox1.SelectionLength < 1)
            {
                richTextBox1.SelectionLength = 1;
            }
            richTextBox1.SelectedText = "";
        }

/* The eight methods below are for the Find\Replace 
           and Jump to line tools. */

private void findReplaceToolStripMenuItem_Click(object sender, EventArgs e)
        {
            RenewToolWindows();
            ((Main)(this.MdiParent)).FindReplaceWindow.Visible = true;
            ((Main)(this.MdiParent)).FindReplaceWindow.Focus();
        }

public int FindTextDown(string myFind)
        {
            int findResult = -1;
            richTextBox1.Select(richTextBox1.SelectionStart + richTextBox1.SelectionLength, 0);
            findResult = richTextBox1.Find(myFind, richTextBox1.SelectionStart, richTextBox1.TextLength, RichTextBoxFinds.None);
            if (findResult == -1)
            {
                findResult = richTextBox1.Find(myFind, 0, richTextBox1.TextLength , RichTextBoxFinds.None);
            }

if (findResult != -1)
            {
                return richTextBox1.SelectionStart;
            }
            else
            {
                return findResult;
            }
        }

public int FindTextUp(string myFind)
        {
            int findResult = -1;
            richTextBox1.Select(richTextBox1.SelectionStart, 0);
            findResult = richTextBox1.Find(myFind, 0, richTextBox1.SelectionStart, RichTextBoxFinds.Reverse);
            if (findResult == -1)
            {
                findResult = richTextBox1.Find(myFind, 0, richTextBox1.TextLength, RichTextBoxFinds.Reverse);
            }
            return findResult;
        }

public void ReplaceText(string myFind, string myReplace)
        {
            richTextBox1.TextChanged -= new System.EventHandler(richTextBox1_TextChanged);
            if (richTextBox1.SelectedText.ToLower() == myFind.ToLower())
            {
                PushEdit();
                LockWindowUpdate(this.Handle);
                int originStart = richTextBox1.SelectionStart;
                richTextBox1.SelectedText = myReplace;
                int newLocation = richTextBox1.SelectionStart;
                GetLines(originStart, newLocation);
                FixLineNumbers();
                richTextBox1.SelectionStart = newLocation;
                LockWindowUpdate(IntPtr.Zero);
                saveToolStripMenuItem.Enabled = true;
            }
            richTextBox1.TextChanged += new System.EventHandler(richTextBox1_TextChanged);          
        }

public int ReplaceAllText(string myFind, string myReplace)
        {
            int replaceCount = 0;

richTextBox1.TextChanged -= new System.EventHandler(richTextBox1_TextChanged);
            PushEdit();
            LockWindowUpdate(this.Handle);
            richTextBox1.Select(0, 0);
            while (richTextBox1.Find(myFind, richTextBox1.SelectionStart, richTextBox1.TextLength, RichTextBoxFinds.None) != -1)
            {
                richTextBox1.SelectedText = myReplace;
                richTextBox1.SelectionStart += myReplace.Length;
                replaceCount++;
            }
            GetLines(0, richTextBox1.TextLength);
            FixLineNumbers();
            richTextBox1.SelectionStart = 0;
            LockWindowUpdate(IntPtr.Zero);
            saveToolStripMenuItem.Enabled = true;
            richTextBox1.TextChanged += new System.EventHandler(richTextBox1_TextChanged);

return replaceCount;
        }

private void jumpToLineToolStripMenuItem_Click(object sender, EventArgs e)
        {
            ((Main)(this.MdiParent)).JumpToLineWindow.Visible = true;
            ((Main)(this.MdiParent)).JumpToLineWindow.Focus();
        }

public int JumpToLine(int myLine)
        {
            try
            {
                richTextBox1.Select((richTextBox1.GetFirstCharIndexFromLine(myLine - 1)), 0);
            }
            catch
            {
                if ((myLine < 1) || (richTextBox1.TextLength < 1))
                {
                    myLine = 1;
                }
                else if (myLine > richTextBox1.Lines.Length)
                {
                    myLine = richTextBox1.Lines.Length;
                }
            }
            finally
            {
                richTextBox1.Select((richTextBox1.GetFirstCharIndexFromLine(myLine - 1)), 0);
            }
            richTextBox1.Focus();
            return myLine;
        }

// Checks if each of the tool windows are disposed, 
        // and calls a Main application method to re-initialize them.
        private void RenewToolWindows()
        {
            if (((Main)(this.MdiParent)).FindReplaceWindow.IsDisposed)
            {
                ((Main)(this.MdiParent)).RenewFindReplaceWindow();
            }

if (((Main)(this.MdiParent)).JumpToLineWindow.IsDisposed)
            {
                ((Main)(this.MdiParent)).RenewJumpToLineWindow();
            }
        }

private void selectAllToolStripMenuItem_Click(object sender, EventArgs e)
        {
            richTextBox1.SelectAll();
        }

/* Here end the methods for the menu strip items. */

// Enables and disables the ContextMenuStrip items on opening,
        // accroding the items' state in the edit menu.
        private void contextMenuStrip_Opening(object sender, CancelEventArgs e)
        {
            if (undoToolStripMenuItem.Enabled == true)
            {
                richTextBox1.ContextMenuStrip.Items[0].Enabled = true;
            }
            else
            {
                richTextBox1.ContextMenuStrip.Items[0].Enabled = false;
            }
            if (redoToolStripMenuItem.Enabled == true)
            {
                richTextBox1.ContextMenuStrip.Items[1].Enabled = true;
            }
            else
            {
                richTextBox1.ContextMenuStrip.Items[1].Enabled = false;
            }
            if (cutToolStripMenuItem.Enabled == true)
            {
                richTextBox1.ContextMenuStrip.Items[3].Enabled = true;
            }
            else
            {
                richTextBox1.ContextMenuStrip.Items[3].Enabled = false;
            }
            if (copyToolStripMenuItem.Enabled == true)
            {
                richTextBox1.ContextMenuStrip.Items[4].Enabled = true;
            }
            else
            {
                richTextBox1.ContextMenuStrip.Items[4].Enabled = false;
            }
            if (pasteToolStripMenuItem.Enabled == true)
            {
                richTextBox1.ContextMenuStrip.Items[5].Enabled = true;
            }
            else
            {
                richTextBox1.ContextMenuStrip.Items[5].Enabled = false;
            }
            if (deleteToolStripMenuItem.Enabled == true)
            {
                richTextBox1.ContextMenuStrip.Items[6].Enabled = true;
            }
            else
            {
                richTextBox1.ContextMenuStrip.Items[6].Enabled = false;
            }
            if (selectAllToolStripMenuItem.Enabled == true)
            {
                richTextBox1.ContextMenuStrip.Items[8].Enabled = true;
            }
            else
            {
                richTextBox1.ContextMenuStrip.Items[8].Enabled = false;
            }
        }

// When a Document is activated, the edit menu is updated
        // according the active Document state,
        // and the Document takes ownership of the tool windows.
        private void Document_Activated(object sender, EventArgs e)
        {
            MonitorEditMenu();
            FixLineNumbers();
            RenewToolWindows();
            ((Main)(this.MdiParent)).FindReplaceWindow.Owner = this;
            ((Main)(this.MdiParent)).JumpToLineWindow.Owner = this;
        }
    }
}

Wednesday, September 16, 2009

Auto Links Rename [InDesign JavaScript]

Here's my recipe for links renaming in Adobe InDesign.
The following script will rename all linked images in the defined page-sequence, with a padded page number and the user entered prefix. For pages featuring more than one image a letter counter is added, seperated by an underscore.

Page numbers are padded according to the total number of pages in the document. The prefix is checked not to contain any digits or space characters. If the letter counter passes the letter 'z' it resolves to continue with numbers.

The script was written for version CS4, but I assume it should also work on CS3.

// Auto Links Rename
// (c) by Oren Hadar, 2009

var docPages = app.activeDocument.pages;

myDisplayDialog()

function PadPage(myPage){
 var toPad = String(docPages.length).length - String(myPage).length;
 var paddedPage = String(myPage);
 for(var i = 0; i < toPad ; i++){
  paddedPage = "0" + paddedPage;
 }
 return paddedPage;
}

function GetLetter(myNumber){
 if (myNumber <= 26){
  return String.fromCharCode(96 + myNumber);
 }
 else{
  return myNumber;
 }
}

Wednesday, July 22, 2009

Search and Log using SQL

Good evening. The following is an SQL-based version of the Search and Log script.

Here the search is done with the '.Global' parameter turned to false, and so the SQL also takes care of finding the number of instances per file. The logging starts after the search is done, and non-matching folders aren't listed.

SQL usage details: The script creates a temporary table called 'search_log'. My default database is the Northwind sample database, and the connection string is suited to windows authentication mode.

' Search and Log using SQL
' (c) Oren Hadar, 2009

Option Explicit

Dim fso, wshell, f, mainFolder, mySearch, sfInclude, logFileName, logFile, _
cnn, rs, fc, f1, fileSearched, fileMatch, sfc, sf1, _
i, rs2, i2, most

Sub Define

Set fso = CreateObject("Scripting.FileSystemObject")
Set wshell = createobject("wscript.shell")

On Error Resume Next
Set f = fso.GetFolder(InputBox("Enter subfolder or full path:", , wshell.currentdirectory))
If f = False Then 
MsgBox "The entered path does not exist, " _
& "or Cancel was pressed.", vbExclamation
WScript.Quit
End If

mainFolder = f

Set mySearch = New RegExp
With mySearch
  .Pattern = InputBox("Enter search string:")
  .Global = False
  .IgnoreCase = True
End With

If f.subfolders.Count > 0 Then
sfInclude = MsgBox("Include SubFolders?", vbYesNo)
End If

logFileName = "~" & f.name & " - find '" & mySearch.Pattern & "'.tmp"
Set logFile = fso.CreateTextFile(logFileName , True)

logFile.Write("Searching for '" & mySearch.Pattern & "' in " & Chr(34) & mainFolder & Chr(34))
If sfInclude = vbYes Then logFile.Write(" and its' subfolders")
logFile.Write(":" & vbCrLf & vbCrLf)

Set cnn = CreateObject("ADODB.Connection")
Set rs = CreateObject("ADODB.Recordset")

cnn.ConnectionString = "driver={SQL Server};" & _
"server=USER-PC\SQLEXPRESS;database=Northwind;Trusted_Connection=Yes"
cnn.Open

cnn.Execute("Create Table search_log (Path varchar(255), " _
& "FileName varchar(255), Instances Int, FileType varchar(255))")

End Sub

Sub Search

Set fc = f.Files
For Each f1 in fc
If mySearch.Execute(f1.name).Count => 1 Then
cnn.Execute("Insert Into search_log (Path, FileName, FileType) " _
& "Values ('" & Replace(Replace(f1.ParentFolder, mainFolder, ".."), "'", "_") _
& "\', '" & Replace(f1.name, "'", "_") & "', '" & Replace(f1.type, "'", "_") & "')") 
End If
Next

If sfInclude = vbYes Then
Set sfc = f.Subfolders
For Each sf1 In sfc
 Set f = fso.GetFolder(sf1)
 Call Search
Next
End If

End Sub

Sub Log

If cnn.Execute("Select Count(*) From search_log")(0) = 0 Then
logFile.Write(vbCrLf & "No matches were found.")
Exit Sub
End If

cnn.Execute("Update search_log Set Instances = " _
& "(LEN(FileName) - LEN(REPLACE(FileName, '" & mySearch.Pattern & "', ''))) " _
& " / LEN('" & mySearch.Pattern & "')")

Set rs = cnn.Execute("Select Path, Count(FileName), Sum(Instances) From search_log Group By Path")
rs.MoveFirst

For i = 1 To cnn.Execute("Select Count(Distinct Path) From search_log")(0)
logFile.Write(vbCrLf & vbCrLf & rs(0) & "  [" & rs(2) & " instance")
If rs(2) > 1 Then logFile.Write("s")
logFile.Write(" in " & rs(1) & " file")
If rs(1) > 1 Then logFile.Write("s")
logFile.Write("]" & vbCrLf)

Set rs2 = cnn.Execute("Select FileName, Instances From search_log Where Path = '" _
& rs(0) & "'")
rs2.MoveFirst

For i2 = 1 To cnn.Execute("Select Count(*) From search_log Where Path = '" _
& rs(0) & "'")(0)
logFile.Write(rs2(0) & "  [" & rs2(1) & " instance")
If rs2(1) > 1 Then logFile.Write("s")
logFile.Write("]" & vbCrLF)
rs2.MoveNext
Next

rs.MoveNext
Next

rs.Close
rs2.Close

End Sub

Sub Summary

logFile.Write(vbCrLf & vbCrLf & vbCrLf & "* * * * * * * *" _
& vbCrLf & "Search Summary" & vbCrLf _
& "* * * * * * * *" & vbCrLf & vbCrLf & vbCrLf)

logFile.Write(cnn.Execute("Select SUM(Instances) From search_log")(0) _
& " instances of '" & mySearch.Pattern & "' were found in " _
& cnn.Execute("Select Count(FileName) From search_log")(0) & " files, inside " _
& cnn.Execute("Select Count(Distinct Path) From search_log")(0) & " folders." _
& vbCrLf & vbCrLf & vbCrLf & vbCrLf)

Set rs = cnn.Execute("Select Path, Count(FileName), SUM(Instances) From search_log " _
& "Group by Path Order by Count(FileName) DESC")
rs.MoveFirst
most = rs(1)

logFile.Write("Folder(s) with most matching files  [" & most & " files]" & vbCrLf)

Do
logFile.Write(rs(0) & "  [" & rs(2) & " instances]" & vbCrLf)
On Error Resume Next
rs.MoveNext
Loop While rs(1) = most

rs.Close

logFile.Write(vbCrLf & vbCrLf & vbCrLF)

Set rs = cnn.Execute("Select Path, SUM(Instances), Count(FileName) From search_log " _
& "Group by Path Order by SUM(Instances) DESC")
rs.MoveFirst
most = rs(1)

logFile.Write("Folder(s) with most instances  [" & most & " instances]" & vbCrLf)

Do
logFile.Write(rs(0) & "  [" & rs(2) & " files]" & vbCrLf)
On Error Resume Next
rs.MoveNext
Loop While rs(1) = most

rs.Close

logFile.Write(vbCrLf & vbCrLf & vbCrLF)

Set rs = cnn.Execute("Select FileType, Count(FileName) From search_log " _
& "Group by FileType Order by Count(FileName) DESC")
rs.MoveFirst

logFile.Write("The matching files are of the following " _
& cnn.Execute("Select Count(Distinct FileType) From search_log")(0) _
& " file types, in descending order:" & vbCrLf)

Do
logFile.Write(rs(0) & "  [" & rs(1) & " files]" & vbCrLf)
On Error Resume Next
rs.MoveNext
Loop While rs(1) > 0

End Sub

Call Define
Call Search
Call Log
If sfInclude = vbYes And _
cnn.Execute("Select Count(*) From search_log")(0) > 0 Then Call Summary

cnn.Execute("Drop Table search_log")
cnn.Close
logFile.Close
fso.MoveFile logFileName, Mid(Replace(logFileName,".tmp" , ".log"), 2)

Saturday, July 18, 2009

Search and Log [VBScript]

Greetings. I wrote a script that Searches for a string in file names and Logs the results in a text file. It has the following neat features:

* Search results refer also to the number of instances the searched string appears in the file name.

* While the process is running, search data is written to a ~.tmp file, and on successful completion the file is renamed to .log.
File names summarize the target of the search, and cannot be overridden.

* If the selected folder for search contains subfolders, the user is prompted to include them in the search. By calling the search sub procedure from itself, the search drills down into deepest subfolders.

* For searches that include subfolders, a short summary of the search results is featured in the end of the log file, including a list of the file types for the matching files, in descending order.

' Search and Log
' (c) Oren Hadar, 2009

Option Explicit

Dim fso, f, wshell, mainFolder, mySearch, logFile, sfInclude, logFileName, _ 
f1, fc, fileSearched, fileMatch, filesInstances, totalInstances, filesMatching, _
filesTable(), fileId, foldersTable(), folderId, sf1, sfc, _
genI, topX, TopXId, genNestedI, groupTable, groupId, groupExists, _
groupOrderedTable, groupOrderedTableId, tempTopGroup

Sub Define

Set fso = CreateObject("Scripting.FileSystemObject")
Set wshell = createobject("wscript.shell")

mainFolder = f

Set mySearch = New RegExp
With mySearch
  .Pattern = InputBox("Enter search string:")
  .Global = True
  .IgnoreCase = True
End With

If f.subfolders.Count > 0 Then
sfInclude = MsgBox("Include SubFolders?", vbYesNo)
End If

logFileName = "~" & f.name & " - find '" & mySearch.Pattern & "'.tmp"
Set logFile = fso.CreateTextFile(logFileName , True)

logFile.Write("Searching for '" & mySearch.Pattern & "' in " & Chr(34) & mainFolder & Chr(34))
If sfInclude = vbYes Then logFile.Write(" and its' subfolders")
logFile.Write(":" & vbCrLf & vbCrLf)

End Sub

Sub Search

filesInstances = Empty
filesMatching = Empty

If f <> mainFolder Then logFile.Write(".." _
& Replace(f, mainFolder, "") & "\" & vbCrLf)

Set fc = f.Files
For Each f1 in fc
 Set fileSearched = mySearch.Execute(f1.name)
 For Each fileMatch in fileSearched  
  filesInstances = filesInstances + 1
  totalInstances = totalInstances + 1
 Next
If fileSearched.Count > 0 Then
logFile.Write(f1.name & "  [" & fileSearched.Count & " instances]" & vbCrLf)
ReDim Preserve filesTable(2, fileId)
filesTable(0, fileId) = f1
filesTable(1, fileId) = fileSearched.Count
filesTable(2, fileId) = f1.type
filesMatching = filesMatching + 1
fileId = fileId + 1
End If
Next

If filesInstances > 0 Then
ReDim Preserve foldersTable(2, folderId)
foldersTable(0, folderId) = f
foldersTable(1, folderId) = filesMatching
foldersTable(2, folderId) = filesInstances
folderId = folderId + 1
End If

Select Case filesInstances
Case 0
logFile.Write("No matches were found")
If f = mainFolder And sfInclude = vbYes Then logFile.Write(" in the main folder")
logFile.Write("." & vbCrLf & vbCrLf & vbCrLf)
Case 1
logFile.Write("[1 instance in 1 file]" & vbCrLf & vbCrLf & vbCrLf)
Case Else
logFile.Write("[" & filesInstances & " instances in " & filesMatching _
& " files]" & vbCrLf & vbCrLf & vbCrLf)
End Select

If sfInclude = vbYes Then
Set sfc = f.Subfolders
For Each sf1 In sfc
 Set f = fso.GetFolder(sf1)
 Call Search
Next
End If

End Sub

Sub Summary

logFile.Write("* * * * * * * *" & vbCrLf _
& "Search Summary" & vbCrLf _
& "* * * * * * * *" & vbCrLf & vbCrLf & vbCrLf)

If totalInstances = 0 Then 
logFile.Write("No instances of '" & mySearch.Pattern & "' were found.")
Exit Sub
End If

logFile.Write(totalInstances & " instances of '" & mySearch.Pattern _
& "' were found in " & fileId & " files, inside " & folderId & " folders." _
& vbCrLf & vbCrLf & vbCrLf & vbCrLf)

Call ResVar

For genI = 0 To folderId - 1
If foldersTable(1, genI) > foldersTable(1, topX(0)) Then
 ReDim topX(0)
 topX(0) = genI
ElseIf foldersTable(1, genI) = foldersTable(1, topX(0)) And _
foldersTable(0, genI) <> foldersTable(0, topX(0)) Then
 topXId = topXId + 1
 ReDim Preserve topX(topXId)
 topX(topXId)=genI
End If
Next

If topXId = 1 Then topXId = 0

LogFile.Write("Folder(s) with most matching files [" _
& foldersTable(1, topX(0)) & " files]:" & vbCrLf)

For genI=0 To topXId
logFile.Write(foldersTable(0, topX(genI)) & "  [" & foldersTable(2, topX(genI)) _
& " instances]" & vbCrLf)
Next

logFile.Write(vbCrLf & vbCrLf & vbCrLf)

Call ResVar

For genI = 0 To folderId - 1
If foldersTable(2, genI) > foldersTable(2, topX(0)) Then
 ReDim topX(0)
 topX(0) = genI
ElseIf foldersTable(2, genI) = foldersTable(2, topX(0)) And _
foldersTable(0, genI) <> foldersTable(0, topX(0)) Then
 topXId = topXId + 1
 ReDim Preserve topX(topXId)
 topX(topXId)=genI
End If
Next

LogFile.Write("Folder(s) with most instances [" _
& foldersTable(2, topX(0)) & " instances]:" & vbCrLf)

If topXId = 1 Then topXId = 0

For genI=0 To topXId
logFile.Write(foldersTable(0, topX(genI)) & "  [" & foldersTable(1, topX(genI)) _
& " files]" & vbCrLf)
Next

logFile.Write(vbCrLf & vbCrLf & vbCrLf)

Call ResVar

For genI = 0 To fileId - 1
 groupExists = False
 For genNestedI = 0 To groupId
  If filesTable(2, genI) = groupTable(0, genNestedI) Then
  groupExists = True
  groupTable(1, genNestedI) = groupTable(1, genNestedI) + 1
  End If
 Next
 If groupExists = False Then
 groupId = groupId + 1
 ReDim Preserve groupTable(1, groupId)
 groupTable(0, groupId) = filesTable(2, genI)
 groupTable(1, groupId) = 1
 End If
Next

ReDim groupOrderedTable(1, groupId)

For genI = 0 To groupId
 For genNestedI = 0 To groupId
 If groupTable(1, genNestedI) > groupOrderedTable(1, genI) Then
 groupOrderedTable(0, genI) =  groupTable(0, genNestedI)
 groupOrderedTable(1, genI) =  groupTable(1, genNestedI)
 tempTopGroup = genNestedI
 End If
 Next
groupTable(1, tempTopGroup) = 0
Next

logFile.Write("The matching files are of the following " _
& groupId & " file types, in descending order:" & vbCrLf)

For genI = 0 To groupId - 1
logFile.Write(groupOrderedTable(0, genI) & "  [" & groupOrderedTable(1, genI) & " files]" & vbCrLf)
Next

End Sub

Sub ResVar

ReDim topX(0)
topX(0) = 0
topXId = 0

ReDim groupTable(1, 0)
groupTable(0, 0) = "No File Type"
groupTable(1, 0) = 0
groupId = Empty

End Sub

Call Define
Call Search
If sfInclude = vbYes Then Call Summary

logFile.Close
fso.MoveFile logFileName, Mid(Replace(logFileName,".tmp" , ".log"), 2)

Saturday, July 4, 2009

Convert Footnotes to Regular Text [Word VBScript]

The next script for Word converts all footnotes and their references to regular text. The footnotes are inserted at the end of the document.

Find, Replace and Comment [Word VBScript]

Hi there. I wrote a Find and Replace script for Word, which also adds a Comment for each replacement. Note: It works only on the 'body' of the text, since comments are not available on footnotes / endnotes.

Sub find_comment()

' Find, Replace and Comment
' (c) Oren Hadar, 2009

Dim myFind
Dim myReplace
Dim okInput
Dim myCount
Dim myContinue
Dim myRetry

myCount = 0
okInput = False

Do
myFind = InputBox("Find what:", "Find and Comment")
If StrPtr(myFind) = False Then
Exit Sub
ElseIf myFind = "" Then
myRetry = MsgBox("No find string was entered.", _
vbRetryCancel + vbExclamation, "Find and Comment")
Else
okInput = True
End If
If myRetry = vbCancel Then
Exit Sub
End If
Loop While okInput = False

okInput = False

Do
myReplace = InputBox("Replace with:", "Find and Comment")
If StrPtr(myReplace) = False Then
Exit Sub
ElseIf myReplace = "" Then
myRetry = MsgBox("No replacement string was entered." _
& vbCrLf & "The searched string will be deleted!" & vbCrLf _
& "Are you sure?", vbYesNoCancel + vbDefaultButton2 + _
vbExclamation, "Find and Comment")
ElseIf myReplace = myFind Then
myRetry = MsgBox("The replacement string must be different " & vbCrLf _
& "from the searched string.", vbRetryCancel + vbCritical, "Find and Comment")
Else
okInput = True
End If
If myRetry = vbYes Then
okInput = True
ElseIf myRetry = vbCancel Then
Exit Sub
End If
Loop While okInput = False

Do
With Selection.find
    .Forward = True
    .ClearFormatting
    .MatchWholeWord = False
    .MatchCase = False
    .Wrap = wdFindContinue
    .Execute FindText:=myFind
End With
If Selection.Text = myFind Then
Selection.Text = myReplace
myContinue = True
myCount = myCount + 1
ActiveDocument.Comments.Add Range:=Selection.Range, Text:="Replaces " & myFind
Else
myContinue = False
End If
Loop Until myContinue = False
    
MsgBox myCount & " instances of '" & myFind _
& "' were found, replaced with '" & myReplace & _
"' and commented.", , "Find and Comment"

End Sub

Oren's Folder

Monday, October 26, 2009

Paint Application [C#]

Monday, October 5, 2009

VBScript Editor [C#]

Wednesday, September 16, 2009

Auto Links Rename [InDesign JavaScript]

Wednesday, July 22, 2009

Search and Log using SQL

Saturday, July 18, 2009

Search and Log [VBScript]

Saturday, July 4, 2009

Convert Footnotes to Regular Text [Word VBScript]

Find, Replace and Comment [Word VBScript]

Blog Archive

Labels

Contact Me:

Disclaimer