Drag and drop, delayed rendering, OnRenderGlobalData problem

>>I am having a bit of trouble with delayed rendering

better to use COleDataSource::CacheData. Look at this sample
http://download.microsoft.com/download/platformsdk/sample20/1/W351/EN-US/FileDrag.exe

-MAHESH

Thats what I expected too. But it generates multiple messages as I said - when first dragged, when passing focus to other applications windows and the final message being when dropped (mouse button up).

I'll give more detail.

I have implemented my own instance of COleDropSource and I am overwriding "virtual BOOL OnRenderGlobalData(LPFORMATETC lpFormatEtc, HGLOBAL* phGlobal);" to recieve the render message.

In my CListControl derived class I have a list of files on a device that I have to read (its not a Windows format). When the user drags file(s) from it and drop them on say an Explorer window, I first get the OnDragDrop message in my list control where I make a list of filenames for my render routine and I tell windows to use my COleDataSource derived class to send the render message to.

So, when my CMyOleDropSource::OnRenderGlobalData routine is called I create my files in a temporary folder and pass the filenames to the drop source. In the case of explorer - the files are then moved to the real destination (the path where they were dropped).

Of course, since "CMyOleDropSource::OnRenderGlobalData" is called multiple times inbetween the drag and the release of the button, I am currently setting a flag in my files list to say I've already created the file, otherwise I end up creating the file X number of times which of course takes too long and is pointless. This solution works OK, but I do end up creating the files unnecissarily if the user ends up not dropping the files somewhere valid.


Here is the code:-

// In my list control, on a drag event, I pass a list of filenames

void CShellListCtrl::OnDragDrop(NM_LISTVIEW* /*pNMListView*/)
{
      TRACE( "CShellListCtrl::OnDragDrop\n" );

      CStringList    *lsSourceDraggedFiles;
      int            nSelItem;
      CString        sFile;

      lsSourceDraggedFiles = new CStringList;                  
      // lsSourceDraggedFiles is my list of files that are being dragged, this is
      // just a list I want my render routine to get so it knows what to render/copy.


      CMyOLEDragDrop *pDataSource = new CMyOLEDragDrop();

      BOOL bAbort = FALSE;
      struct sFileInfo *psFileInfo=NULL;
      POSITION pos = m_pListCtrl->GetFirstSelectedItemPosition();
      while (NULL != pos && !bAbort)                  // Repeat for all drag items
      {            
            nSelItem = m_pListCtrl->GetNextSelectedItem(pos);
            psFileInfo = (struct sFileInfo *)m_pListCtrl->GetItemData(nSelItem);

            if( psFileInfo!=NULL )
            {
                  sFile = psFileInfo->csPath;            // Filename of drag item
      
                  CString csPass;
                  csPass.Format( "%s%i%i", psFileInfo->csPath, psFileInfo->iAttribs, psFileInfo->iPartition );
                  lsSourceDraggedFiles->AddTail(csPass);
            }
      }

      pDataSource->SetCallDatas(lsSourceDraggedFiles, this, m_pWnd);
      pDataSource->DoDragDrop(DROPEFFECT_COPY|DROPEFFECT_MOVE|DROPEFFECT_LINK);
      delete pDataSource;

      TRACE( "out CShellListCtrl::OnDragDrop(NM_LISTVIEW* /*pNMListView*/)\n" );
      return;
}


// In my COleDropSource derived class

BOOL CMyOleDropSource::OnRenderGlobalData(LPFORMATETC lpFormatEtc, HGLOBAL* phGlobal)
{
      VERIFY(lpFormatEtc->cfFormat==CF_HDROP);

      // Allocate space for DROPFILE structure plus the file path and one extra
      // byte for final NULL terminator
      *phGlobal = GlobalAlloc(GHND|GMEM_SHARE,(DWORD)(sizeof(DROPFILES)+_MAX_PATH+1));

      if (*phGlobal)
      {
            // Make temp file name
            BOOL bAbort = FALSE;
            if( m_plsDraggedFiles != NULL )
            {
                  POSITION       pos;
                  TCHAR          szBuff[MAX_PATH*2];

                  pos = m_plsDraggedFiles->GetHeadPosition();

                  int nSelItem;
                  CString csFile="";
                  CStringList *plsNewList = new CStringList;
                  while (NULL != pos)
                  {
                        lstrcpy (szBuff, (LPCTSTR) m_plsDraggedFiles->GetNext (pos));
                        TRACE( "szBuff=%s\n", szBuff );

                        // Copy the file to our temp folder
                        struct sFileInfo sFileInfo;
                        sFileInfo.csPath = szBuff;
                        sFileInfo.iAttribs = sFileInfo.csPath.GetAt(sFileInfo.csPath.GetLength()-2) - '0';
                        sFileInfo.iPartition = sFileInfo.csPath.GetAt(sFileInfo.csPath.GetLength()-1) - '0';
                        int iLen = sFileInfo.csPath.GetLength();
                        sFileInfo.csPath = sFileInfo.csPath.Left( iLen-2 );

                        // Mark this entry as processed as we get multiple calls to the render routine at present!!!
                        szBuff[_tcslen(szBuff)-2] = 0xff;
                        plsNewList->AddTail(szBuff);

                        CString csDestFile;
                  
                        CString csTemp;                        // Destination on PC (temp folder)
                        csTemp = g_AppPathName;
                        csTemp += "\\Temp\\";
                        if( sFileInfo.iAttribs>=0 )
                        {
                              if( CopyFileOrFolder( &sFileInfo, csTemp, csDestFile )!=0 )
                                    bAbort = TRUE;
                        }
                        else
                        {
                              csDestFile = g_AppPathName;
                              csDestFile += "\\temp\\";
                              CString cs = ExtractFileName( sFileInfo.csPath );
                              csDestFile += cs;
                        }

                        if( !bAbort )
                        {
                              csFile.Append( csDestFile );
                              csFile.Append( "\1" );
                        }
                  }

                  delete m_plsDraggedFiles;
                  m_plsDraggedFiles = plsNewList;

                  if( !bAbort )
                  {
                        int iLen = csFile.GetLength()+2;
                        TCHAR *szStr = (TCHAR*)malloc( iLen );
                        _tcscpy( szStr, csFile.GetBuffer() );
                        TRACE( "To Exp: %s\n", szStr );
                        ReplaceAllChars( szStr, '\1', '\0' );

                        // Last string will end with two 0 bytes.

                        LPDROPFILES pDropFiles;
                        pDropFiles = (LPDROPFILES)GlobalLock(*phGlobal);

                        // Set the offset where the starting point of the file start
                        pDropFiles->pFiles = sizeof(DROPFILES);

                        // File doesn't contain wide characters
                        pDropFiles->fWide=FALSE;

                        // Copy file name.
                        memcpy(((LPSTR)pDropFiles)+sizeof(DROPFILES), (LPCSTR)szStr, iLen*sizeof(TCHAR));
                        free( szStr );
                  }
            }

            GlobalUnlock(*phGlobal);
            return TRUE;
      }
     
      return *phGlobal!=NULL;
}

Sorr, in the above post, I meant I am using "COleDataSource", not COleDropSource!

> better to use COleDataSource::CacheData. Look at this sample
> http://download.microsoft.com/download/platformsdk/sample20/1/W351/EN-US/FileDrag.exe
> -MAHESH

Thanks for the comment MAHESH. I've expanded my explanation of my problem, I am using COleDataSource and hence COleDataSource::OnRenderGlobalData.

I am using CF_HDROP format.

That sample doesn't work by the way, it doesn't run properly in VC++ 6 or 7 I think it is just a very old Win32 sample that doesn't quite work anymore; But as in the sample, that is essentially what I am doing.

It all works fine apart from getting multiple calls to OnRenderGlobalData. I assume what is happening is that other windows who see the drag item passing over them, take a sneaky peek at what is being dragged and cause me to have to render the data. When I only really want to do is render the data when the real drop happens (the user lets go of the mouse button on an explorer window or editor).

<When I only really want to do is render the data when the real drop happens (the user lets go of the mouse button on an explorer window or editor).>

Still puzzled - why not just do that, ignore the requests to render inbetween (OR do you not get the chance to render when it is dropped?)

In reply to Andy:

The whole thing relies on me getting a "CMyOleDropSource::OnRenderGlobalData" message when the drop target (say an explorer window) tells me that it wants the data. Unfortunatly, "CMyOleDropSource::OnRenderGlobalData" gets called by other things like the focus changing as the item is dragged. The very last call will be when the user has actually dropped (released the mouse button).

When writing the code I expected "CMyOleDropSource::OnRenderGlobalData" to only get called when the mouse button is released over a drop target but it doesn't.

My problem is - I don't know when the last call is, or when the user has actually let go of the mouse button.

The passed parameters to "BOOL CMyOleDropSource::OnRenderGlobalData(LPFORMATETC lpFormatEtc, HGLOBAL* phGlobal)"';  "LPFORMATETC lpFormatEtc" and "HGLOBAL* phGlobal" are exactly the same for each call.