Using OLE Drag-and-Drop in Visual Basic 6

Using OLE Drag-and-Drop in Visual Basic 6

ll graphical user interfaces, including Windows, make excellent use of the mouse. One way that the mouse can be used is drag-and-drop, the ability to initiate some action by dragging from one element on the screen to another. You might drag a file name to the recycle bin icon to delete it, drag an image to a printer icon to print it, or drag selected text to another location to copy it. Visual Basic provides excellent support for drag-and-drop. One type of drag-and-drop, sometimes referred to as traditional drag-and-drop, is limited to dragging between controls in the same application. I covered traditional drag-and-drop in an earlier article. The second type, called OLE (for Object Linking and Embedding) drag-and-drop, lets the user drag data between applications as well as within an application. In this article I explain how to implement OLE drag-and-drop in your VB 6 applications.

OLE drag-and-drop works only with applications that support it. This is the case with most Microsoft applications and many programs from other vendors as well. If you attempt OLE drag-and-drop with an application that does not support it, the operation simply does not work.

The DataObject Class
The DataObject class is at the heart of OLE drag-and-drop. When a drag-and-drop operation is started, the data that is being dragged is packaged in a DataObject object. When the item is dropped, this object is available to the target, which examines the DataObject to determine if the data it contains is in a format that the target can accept. If so, the data is accepted by the target. If you have Microsoft Office installed you can see OLE drag-and-drop in action by starting Word and Excel, selecting some text in Word, and dragging it to Excel. The text appears in the Excel worksheet cell where it was dropped. You can use OLE drag-and-drop with more complex kind of data as well, such as charts and images. Traditionally, the drag-and-drop operation moves the data or, if the Ctrl key is depressed, copies the data.

Only a subset of VB controls support OLE drag-and-drop. Those that can act as a source as well as a target are:

  • ComboBox
  • DirListBox
  • FileListBox
  • Image
  • ListBox
  • PictureBox
  • TextBox

The following components are limited to serving as a target:

  • CheckBox
  • CommandButton
  • Data
  • Form
  • Frame
  • Label
  • MDIForm
  • OptionButton
  • PropertyPage
  • UserControl
  • UserDocument

Properties and Events for Drag and Drop
There are several properties and events related to OLE drag-and-drop, some relevant to sources and some to targets. They are described in Tables 1 and 2.

Table 1. OLE drag-and-drop related properties.


Relevant to




Determines whether OLE drag-and-drop operations are initiated manually (VbOLEDragManual, the default) or automatically (vBOLEDragAutomatic).



Specifies whether OLE drops are ignored (vbOLEDropNone, the default), are handled manually (vbOLEDropManual), or handled automatically (vbOLEDropAutomatic).



Specifies the image displayed under the mouse cursor during an OLE drag-and-drop operation. Possible formats are .bmp, .dib, .jpg, .gif, .ani, .cur, and .ico.



Specifies the type of drop operations supported by the target.



Specifies how the target handles a drop operation.

Table 2. Events related to OLE drag-and-drop operations.


Fires in

Fires when



A source object is dragged over the target.



A source object is dropped on the target.



An OLE drag operation is initiated.



The source is dropped on a target.



After every OLEDragOverEvent.



When the source is dropped on a target but the data has not been loaded into the DataObject.

Take a look at a simple example of OLE drag-and-Drop using the automatic settings before getting into the details.

  1. Create a new Visual Basic project and place one Text Box and two Picture Box controls on the form.
  2. Set the OLEDragMode and OLEDropMode properties to Automatic for all three controls.
  3. Run the project.
  4. Launch a graphics program that supports OLE drag-and-drop. I know that PhotoShop does?for other programs you’ll have to try and see if it works.

  5. Playing Around with OLE
    Now you are ready to do some experimenting. Open a picture in the graphics program, select it, and drag it to one of the Picture Box controls in the Visual Basic program. You’ll see that the image is moved to the Picture Box. If you hold down the Ctrl key while dragging the picture will be copied rather than moved. You can also drag the picture from one Picture Box to the other. You cannot, however, drag a picture to the Text Box. To experiment with non-image data, launch your word processor and select some text. You’ll be able to drag the text to both the Text Box and the Picture Box on your form.

    As you have seen, automatic OLE drag-and-drop is quite easy to implement, requiring only that you set a couple of control properties. Simplicity is often accompanied by lack of flexibility, and that’s the case here too. Automatic OLE drag-and-drop is undoubtedly more limited than what you can accomplish with manual control.

    You need to understand the DataObject class to use manual OLE drag-and-drop. During an OLE drag-and-drop operation, this class is used to store data and information about the data’s format. Most of the OLE drag-and-drop related event procedures have an argument that references the DataObject object that is part of the current operation. In the event procedures, you use the object’s methods to manage the data.

    The DataObject class has four methods. The Clear() method removes all data and other information from the DataObject object. The GetData(format) method returns the data from a DataObject object as a type Variant. The format argument is a constant that specifies the format of the data, as shown in Table 3. If you omit the format argument or pass a value of 0, the method will attempt to determine the best format for the data.

    Table3. Format argument values for the GetData method.




    0 or omitted

    Automatic format detection based on the data.












    Enhanced metafile



    Device-independent bitmap



    Color palette



    List of files



    Rich text format.

    The SetData method inserts data into a DataObject object using a specified format. The syntax is:

    SetData data, format 

    Both arguments are optional (although you must use at least one). Data is a type Variant containing the data to insert, and format is a constant (from Table 3) specifying the format of the data. If you specify the data argument but not format, Visual Basic will try to determine the format by examining the data. If you specify format without data, the specified format is added to the list of formats the existing data is available in.

    A Practical Example
    Here’s an example. Suppose the variable X contains some text data, and myDO refers to a DataObject object. The following code makes the data in X available in myDO as text, as rich text, and as a bitmap:

    myDO.SetData X, vbCFTextmyDO.SetData , vbCFRTFmyDO.SetData , vbCFBitmap

    The GetFormat() method returns a true/false value indicating whether data is available in the specified format. The method takes a single argument, one of the format constants from Table 3, and it returns True only if the DataFormat object contains data in the specified format.The drag-and-drop related events work together, and the relationship between them is somewhat confusing. Some actions cause events to fire in both the source and target objects. Table 4 explains how this works.

    Table4. User actions and corresponding OLE drag-and-drop events. 


    Event procedure(s) fired

    What your code does

    Drag operation starts

    OLEStartDrag (source)

    Set the effects (move, copy) that are permitted. Put the data being dragged in the DataObject.

    Cursor moves over a potential target.

    OLEDragOver (target), then OLEGiveFeedback (source).

    In OLEDragOver: Examine the format of data being dragged and set the mouse cursor to indicate whether a drop is permitted. In OLEGiveFeedback: change the appearance of the source control if desired (optional).

    Object is dropped.

    OLEDragDrop (target) and then OLECompleteDrag (source).

    In OLEDragDrop: check the format of the data and retrieve it if it is acceptible. In OLECompleteDrag: erase the data from the souce control (only if the data is being moved instead of copied).

    The OLEStartDrag event procedure, which fires when a manual OLE drag-and-drop operation begins, has an AllowedEffects argument which you use to specify the drag-and-drop effects which will be permitted. The constants for this argument are listed in Table 5, and can be combined with the Or operator. Which of the allowed operations actually occurs (at the end of the operation when the drop is done) is determined elsewhere in code.

    Table5. Constants for the effects argument.






    Drop target cannot accept the data.



    Drop results in data being copied from source to target.



    Drop results in data being moved from source to target.

    The OLEDragOver, OLEDragDrop, OLECompleteDrag, and OLEGiveFeedback event procedures have an effects argument that is used to specify and to determine the drag-and-drop operations permitted. You use the constants listed in Table 5 for this argument. Code in these event procedures can read the effects argument to see what effects have been permitted by the source, and can also change the value as needed. You’ll see how this works in the sample application to be developed later.

    Putting It All Together
    Now let’s look at the basic steps required to implement manual OLE drag-and-drop for Visual Basic controls. There are two things to consider: a control that serves as a source, and a control that serves as a target. Some controls can do both, of course. In either case, the control’s OLEDragMode and OLEDropMode properties must be set to Manual. For a target control:

    1. Place code in the control’s OLEDragOver event procedure that checks the format of the data in the DataObject object. Depending on whether the available format or formats are appropriate for the control, set the effect argument to the appropriate value (vbDropEffectNone, vbDropEffectCopy, or vbDropEffectMove). This causes the mouse cursor to display the appropriate symbol while dragging over the target control.
    2. Place code in the control’s OLEDragDrop event procedure to check the format of the DataObject’s data. The code can also check the state of the keyboard to see if the Ctrl key is depressed indicating a Copy operation rather than a move. If the format of the data is acceptable, and depending on other factors such as the state of the keyboard, set the effect argument to the appropriate action (vbDropEffectNone, vbDropEffectCopy, or vbDropEffectMove) and retrieve the data from the DataObject.

    When a control is acting as an OLE drag-and-drop source here’s what is required:

    1. In the control’s MouseMove event procedure, check the state of the mouse buttons and if the left button is depressed initiate an OLE drag-and-drop operation by calling the control’s OLEDrag method.
    2. In the control’s OLEStartDrag event procedure, which is called as soon as the OLEDrag method is executed, insert the data from the control into the DataObject object using the SetData method (although this step can be deferred, as I’ll explain soon). If necessary, call SetData additional times to specify additional data formats. Also, set the AllowedEffects argument as appropriate.
    3. Optionally, put code in the control’s OLEGiveFeedback event procedure to provide visual feedback as the data is dragged over various parts of the screen. Information set in a target’s OLEDragOver event procedure, specifically the effects argument, is available in the OLEGiveFeedback event procedure. Most often this event procedure is used to change the appearance of the source control depending on where it is being dragged.
    4. In the control’s OLECompleteDrag event procedure place any code that is required to complete the operation. Typically this consists of erasing the original data from the control after a move operation. For a copy operation this event procedure is usually not used.

    A Demonstration
    The following demonstration program puts these techniques into action. While this is a simple application, it demonstrates all of the techniques you’ll need to implement full-featured OLE drag-and-drop in your Visual Basic programs. To create the application, start a new Visual Basic project and place two Text Box controls and one Picture Box control on its form. Set the OLEDropMode and OLEDragMode properties to Manual for each of these controls. Here’s how the program works:

    Figure 1 shows the program after an image was dragged from another program to the Picture Box control.

    • You can drag from the first Text Box to copy its data to a target such as the second Text Box or another program that supports OLE drag-and-drop of text, such as Microsoft Word. If you drag the first Text Box over the form or Picture Box, or anywhere else where a drop is not permitted, the text in the Text Box changes to red.
    • The second Text Box operates the same as the first Text Box except you can specify whether the data is to be copied (by depressing Ctrl) or moved (no keys depressed).
    • Bitmap data from another program, such as PhotoShop, can be dragged to the Picture Box. If bitmap data is dragged over either of the Text Box controls, the “no drop” icon is displayed.

    Listing 1 shows the code for this demo’s event procedures. Each procedure is commented so you can relate it to the explanations in the text. Figure 1 shows the program after an image was dragged from another program to the Picture Box control.


About Our Editorial Process

At DevX, we’re dedicated to tech entrepreneurship. Our team closely follows industry shifts, new products, AI breakthroughs, technology trends, and funding announcements. Articles undergo thorough editing to ensure accuracy and clarity, reflecting DevX’s style and supporting entrepreneurs in the tech sphere.

See our full editorial policy.

About Our Journalist