Open G/L feedback buffer not capturing output to pixmap RC

I have a C/C++ application, which makes heavy use of OpenGL for rendering 2 dimensional
vector data. There is a need to create hardcopy output of some of the "plots". However, the
plots need to be substantially bigger than the size of the GUI's window, so i create an offscreen
pixmap to draw into:

static int
allocMemhDC(int w, int h, HPIXMAP *dib, HDC *memDC)

{
                     BITMAPINFO            bmi;
                     BITMAPINFOHEADER      *bmih = &bmi.bmiHeader;
      void            *memPtr;

      memset(&bmi, 0, sizeof(bmi));
      bmih->biSize = sizeof(BITMAPINFOHEADER);
      bmih->biWidth = w;
      bmih->biHeight = h;
      bmih->biPlanes = 1;
      bmih->biBitCount = 24;
      bmih->biCompression = BI_RGB;
      bmih->biSizeImage = w * h * 3;

      if (!(*memDC = CreateCompatibleDC(NULL)))
            return FALSE;
      *dib = CreateDIBSection(*memDC, &bmi, DIB_RGB_COLORS, &memPtr, NULL, 0);
      if (!*dib)
            return FALSE;
      SelectObject(*memDC, *dib);
      return TRUE;
}

I then create an OpenGL Rendering context, using the memory Device Context (memDC) created above:

                     // HDC is passed in here: its either unset if plotting to a window, else set to an existing window's
                     // HDC if wanting to draw into a pixmap (strange logic, but a holdover from previous work):

      PIXELFORMATDESCRIPTOR pfd =
      {
            sizeof(pfd),
            1,
            (hdc ?
             PFD_DRAW_TO_BITMAP | PFD_SUPPORT_OPENGL :
             PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER),
            PFD_TYPE_RGBA,
            24,                        // 24 bit color depth
            0, 0, 0, 0, 0, 0,            // color bits ignored
            0,                        // no alpha color
            0,                        // shift bit ignored
            0,                        // no accumulation buffer
            0, 0, 0, 0,                  // accum bits ignored
            0,                        // 32 bit z buffer
            8,                        // stencil bits
            0,                        // no auxiliary buffer
            PFD_MAIN_PLANE,
            0,                        // reserved
            0, 0, 0                        // ignore layer masks
      };
      GLint      iPixelFormat;
      HGLRC      hglrc;

                     if (hdc == 0)
                               hdc = GetDC(handle);
      else if (!allocMemhDC(w, h, &dib, &hdc))
      {
            fprintf(stderr, "Cant create off-screen memory for rendering");
            return 0;
      }
      if ((iPixelFormat = ChoosePixelFormat(hdc, &pfd)) == 0)
      {
            fprintf(stderr, "Cannot choose pixel format");
            return 0;
      }
      if (SetPixelFormat(hdc, iPixelFormat, &pfd) == FALSE)
      {
            fprintf(stderr, "Cannot set pixel format");
            return 0;
      }

      hglrc = wglCreateContext(hdc);
      if (hglrc == (HGLRC)0)
      {
            fprintf(stderr, "Cannot create OpenGL context\n");
            return 0;
      }

and finally make it the "current context":

      if (wglGetCurrentContext() != hglrc &&
         !wglMakeCurrent(hdc, hglrc))
            fprintf(stderr, "Wv2: Cannot change rendering context. "
                  "Please restart\n");

So far, so good. No errors, everything's fine.

I then set up to capture the output of my rendering into the OpenGL feedback buffer (via a call to a 3rd
party function, which does the following):

        if (anything_fails...)
                return FAILURE;
        glFeedbackBuffer(size, GL_3D);
        glRenderMode(GL_FEEDBACK);
        return SUCCESS;

I then render a bunch of vectors, which should get captured in the feedback buffer. However, they
dont: they end up being drawn into the pixmap (i know, because i've checked what picture in the
pixmap looks like).

Now, if i use a normal window's rendering context, instead of using the pixmap's, everything works
perfectly: the feedback buffer fills up as expected, and the window is not 'drawn into'.

So, the question is: does anyone know what i might be doing wrong, or what i can change to get
things to work properly?