September 1997

What a drag!

Let's face it: As computer users we live in a drag-and-drop world. Sure, drag-and-drop is a buzz phrase, but this technique is also very useful. When I get a new software package, it isn't long before I find myself trying to drag and drop some element of the program. If dragging and dropping works, I'm happy and on my way again. If it doesn't work, I grumble a little. To produce high-quality applications, you need to implement the features users have come to expect in recent years--and drag-and-drop is definitely one of those features. VCL offers a certain degree of drag-and-drop capability. For example, you can drag and drop from one component to another on a form. You can even drag from a component on one form to a component on another form. However, VCL lacks support for dragging and dropping files from Windows Explorer to an application.

In this article, we'll demonstrate how you can let your C++Builder applications accept files dropped from applications such as Windows Explorer, the Find Files dialog box, or the Windows Desktop. In the course of our discussion, we'll examine the Windows API functions DragAcceptFiles() and DragQueryFile(), along with the WM_DROPFILES message. For a discussion of dragging and dropping between VCL components, see "A Drop in the Bucket."

Laying the groundwork

1. Tell Windows that your application will accept dropped files.
2. Catch and handle the WM_DROPFILES message.
3. Process the dropped files.
   

Receiving

DragAcceptFiles(Handle, true);

The second parameter of the DragAcceptFiles() function is a Boolean value that specifies whether the window will accept dropped files. To accept dropped files, pass true for this parameter. To stop accepting dropped files, call DragAcceptFiles() again with this parameter set to false.

Your program may or may not accept dropped files depending on different states, so it's important to be able to turn off drag-and-drop capabilities. You can call DragAcceptFiles() at almost any time, but your form's OnCreate event handler is a good place to initially register your application to accept dropped files.

The window that will accept dropped files can be either a form or a specific component on a form. For example, you may want only a Memo component to accept dropped files, rather than the entire form. In this case, you can pass the Handle property of the Memo component to DragAcceptFiles(). However, doing so won't help you much unless you create a component derived from TMemo, which processes the WM_DROPFILES message. Creating a component is necessary because the window handle passed to DragAcceptFiles() is the window handle that will receive the WM_DROPFILES message when you drop files. If you make the form the recipient of dropped files, then your life will be a little easier. The lesson here is to add drag-and-drop support for individual components only when necessary, since doing so involves extra work.

Catch the wave

 class TForm1 : public TForm
 {
 __published:    // IDE-managed Components
 private:        // User declarations
   void __fastcall WmDropFiles(
   TWMDropFiles& Message);
 public:         // User declarations
   __fastcall TForm1(TComponent* Owner);
 BEGIN_MESSAGE_MAP
   MESSAGE_HANDLER(WM_DROPFILES, TWMDropFiles, WmDropFiles)
 END_MESSAGE_MAP(TForm)
 };

 void __fastcall TForm1::WmDropFiles(TWMDropFiles& Message)
 {
   char buff[MAX_PATH];
   HDROP hDrop = (HDROP)Message.Drop;
   int numFiles = 
      DragQueryFile(hDrop, -1, NULL, NULL);
   for (int i=0;i < numFiles;i++) {
      DragQueryFile(hDrop, i, buff, sizeof(buff));
      // process the file in 'buff'
   }
   DragFinish(hDrop);
 }

//---------------------------------------------
#ifndef DDMainH
#define DDMainH
//---------------------------------------------
#include 
#include 
#include 
#include 
#include 
//---------------------------------------------
class TForm1 : public TForm
{
  __published:    // IDE-managed Components
    TMemo *Memo1;
    void __fastcall FormCreate(TObject *Sender);
  private:        // User declarations
    void __fastcall
    WmDropFiles(TWMDropFiles& Message);
  public:         // User declarations
    __fastcall TForm1(TComponent* Owner);
  BEGIN_MESSAGE_MAP
    MESSAGE_HANDLER(WM_DROPFILES, TWMDropFiles, WmDropFiles)
  END_MESSAGE_MAP(TForm)
};

//---------------------------------------------
extern TForm1 *Form1;
//---------------------------------------------

#endif

//---------------------------------------------
#include 
#pragma hdrstop

#include "DDMain.h"
//---------------------------------------------

#pragma resource "*.dfm"
TForm1 *Form1;

//---------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner)
{
}
//---------------------------------------------

void __fastcall TForm1::FormCreate(TObject *Sender)
{
  DragAcceptFiles(Handle, true);
}
//---------------------------------------------

void __fastcall TForm1::WmDropFiles(TWMDropFiles& Message)
{
  char buff[MAX_PATH];
  volatile int x = -1;
  HDROP hDrop = (HDROP)Message.Drop;
  int numFiles = DragQueryFile(hDrop, -1, NULL, NULL);
  Memo1->Lines->Clear();
  for (int i=0;i < numFiles;i++) {
    DragQueryFile(hDrop, i, buff, sizeof(buff));
    if (numFiles == 1) 
      Memo1->Lines->LoadFromFile(buff);
    else 
      Memo1->Lines->Add(buff);
  }
  DragFinish(hDrop);
}