xdrag.cc

Go to the documentation of this file.

/*
 *  Xdrag.cc - Drag-and-drop under X.
 *
 *  Copyright (C) 2000-2001  The Exult Team
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 */

#ifdef HAVE_CONFIG_H
#  include <config.h>
#endif

#if defined(USE_EXULTSTUDIO) && !defined(WIN32)

#include <iostream>     /* Debugging messages */
#include <X11/X.h>
#include <X11/Xlib.h>
#include <X11/Xatom.h>
#include "xdrag.h"
#include "u7drag.h"

using std::cout;
using std::endl;

/*
 *  Get a window's screen coords.
 */

static void Get_window_coords
  (
  Display *display,
  Window win,
  int &sx, int& sy    // Coords. returned.
  )
  {
  Window root, parent;    // Get parent window.
  Window *children;
  unsigned int nchildren;
  XQueryTree(display, win, &root, &parent, &children, &nchildren);
  if (children)
    XFree(children);
  if (parent && parent != root) // Recurse on parent.
    Get_window_coords(display, parent, sx, sy);
  else
    sx = sy = 0;
  XWindowAttributes atts;   // Get position within parent.
  XGetWindowAttributes(display, win, &atts);
  sx += atts.x;
  sy += atts.y;
  }

/*
 *  Initialize.
 */

Xdnd::Xdnd
  (
  Display *d,
  Window xw,      // Window-manager window.
  Window xgw,     // Game's display window in xw.
  Move_shape_handler_fun movefun,
  Move_combo_handler_fun movecmbfun,
  Drop_shape_handler_fun shapefun,
  Drop_chunk_handler_fun cfun,
  Drop_combo_handler_fun cmbfun
  ) : display(d), xwmwin(xw), xgamewin(xgw),
    num_types(0), lastx(-1), lasty(-1),
    file(-1), shape(-1), frame(-1), chunknum(-1), 
    combo_cnt(-1), combo(0), combo_xtiles(0), combo_ytiles(0),
    data_valid(false), move_shape_handler(movefun),
    move_combo_handler(movecmbfun),
    shape_handler(shapefun), chunk_handler(cfun),
    combo_handler(cmbfun)
  {
  shapeid_atom = XInternAtom(display, U7_TARGET_SHAPEID_NAME, 0);
  chunkid_atom = XInternAtom(display, U7_TARGET_CHUNKID_NAME, 0);
  comboid_atom = XInternAtom(display, U7_TARGET_COMBOID_NAME, 0);
          // Atom for Xdnd protocol:
  xdnd_aware = XInternAtom(display, "XdndAware", 0);
  xdnd_enter = XInternAtom(display, "XdndEnter", 0);
  xdnd_leave = XInternAtom(display, "XdndLeave", 0);
  xdnd_position = XInternAtom(display, "XdndPosition", 0);
  xdnd_drop = XInternAtom(display, "XdndDrop", 0);
  xdnd_status = XInternAtom(display, "XdndStatus", 0);
  xdnd_copy = XInternAtom(display, "XdndActionCopy", 0);
  xdnd_ask = XInternAtom(display, "XdndActionAsk", 0);
  xdnd_typelist = XInternAtom(display, "XdndTypeList", 0);
  xdnd_selection = XInternAtom(display, "XdndSelection", 0);
  xdnd_version = 3;
          // Create XdndAware property.
  if (xwmwin)
    XChangeProperty(display, xwmwin, xdnd_aware, XA_ATOM, 32,
      PropModeReplace, reinterpret_cast<unsigned char *>(
              &xdnd_version), 1);
  }

/*
 *  Cleanup.
 */

Xdnd::~Xdnd
  (
  )
  {
  delete combo;
  }

/*
 *  Handle drag-and-drop.
 */

void Xdnd::client_msg
  (
  XClientMessageEvent& cev  // Message received.
  )
  {
  cout << "Xwin client msg. received." << endl;
  char *nm = XGetAtomName(display, cev.message_type);
  if (nm)
    cout << "Type = " << nm << endl;
  XEvent xev;     // Return event.
  xev.xclient.type = ClientMessage;
  Window drag_win = cev.data.l[0];// Where drag comes from.
  xev.xclient.format = 32;
  xev.xclient.window = drag_win;
  xev.xclient.data.l[0] = xwmwin;
  if (cev.message_type == xdnd_enter)
    {
    data_valid = false;
    if (cev.data.l[1]&1)  // More than 3 types?
      {
      Atom type;
      int format;
      unsigned long nitems, after;
      Atom *data;
      XGetWindowProperty(display, drag_win,
        xdnd_typelist, 0, 65536,
        false, XA_ATOM, &type, &format, &nitems,
          &after, reinterpret_cast<unsigned char **>(
                &data));
      if (format != 32 || type != XA_ATOM)
        return; // No good.
      if (nitems > max_types)
        nitems = max_types;
      for (num_types = 0; num_types < nitems; num_types++)
        drag_types[num_types] = data[num_types];
      }
    else
      {
      num_types = 0;
      for (int i = 0; i < 3; i++)
        if (cev.data.l[2+i])
          drag_types[num_types++] = 
              cev.data.l[2+i];
      cout << "num_types = " << num_types << endl;
      }
          // Save current window coords.
    Get_window_coords(display, xgamewin, winx, winy);
    }
  else if (cev.message_type == xdnd_position)
    {
    int i;      // For now, just do shapeid.
    for (i = 0; i < num_types; i++)
      if (drag_types[i] == shapeid_atom ||
          drag_types[i] == chunkid_atom ||
          drag_types[i] == comboid_atom)
        break;
    xev.xclient.message_type = xdnd_status;
          // Flags??:  3=good, 0=can't accept.
    xev.xclient.data.l[1] = i < num_types ? 3 : 0;
          // I think next 2 should be a rect.??
    xev.xclient.data.l[2] = 0;
    xev.xclient.data.l[3] = 0;
    xev.xclient.data.l[4] = xdnd_copy;
    XSendEvent(display, drag_win, false, 0, &xev);
          // Save mouse position.
    int x = ((cev.data.l[2]>>16)&0xffff) - winx;
    int y = (cev.data.l[2]&0xffff) - winy;
          // Get timestamp.
    unsigned long time = 0; //????++++++++++++++++
    if (i == num_types)
      return;
    if (!data_valid)  // Tell owner we want data.
      XConvertSelection(display, xdnd_selection, 
        drag_types[i], xdnd_selection, xwmwin, time);
    else if (file == U7_SHAPE_SHAPES)
      (*move_shape_handler)(shape, frame, x,y, 
              lastx, lasty, true);
    else if (combo_cnt > 0)
      (*move_combo_handler)(combo_xtiles, combo_ytiles,
        combo_tiles_right, combo_tiles_below,
            x, y, lastx, lasty, true);
    lastx = x;
    lasty = y;
    }
  else if (cev.message_type == xdnd_leave)
    {
    num_types = 0;    // Clear list.
          // Force repaint to clear grid.
    (*move_shape_handler)(-1, -1, 0, 0, lastx, lasty, true);
    data_valid = false;
    }
  else if (cev.message_type == xdnd_drop)
    {
    int i;      // For now, just do shapes, chunks.
    for (i = 0; i < num_types; i++)
      if (drag_types[i] == shapeid_atom ||
          drag_types[i] == chunkid_atom ||
          drag_types[i] == comboid_atom)
        break;
    bool okay = data_valid && i < num_types;
    num_types = 0;
    if (!okay)
      return;
    if (shape >= 0)   // Dropping a shape?
      {
      if (file == U7_SHAPE_SHAPES)
          // For now, just allow "shapes.vga".
        (*shape_handler)(shape, frame, lastx,lasty, 0);
      }
    else if (chunknum >= 0) // A whole chunk.
      (*chunk_handler)(chunknum, lastx, lasty, 0);
    else if (combo_cnt >= 0 && combo)
      (*combo_handler)(combo_cnt, combo, lastx, lasty, 0);

    data_valid = false;
    }
  }

/*
 *  Get the selection data.
 */

void Xdnd::select_msg
  (
  XSelectionEvent& sev
  )
  {
  cout << "SelectionEvent received with target type: " <<
    XGetAtomName(display, sev.target) << endl;
  if (sev.selection != xdnd_selection || 
    (sev.target != shapeid_atom && sev.target != chunkid_atom &&
     sev.target != comboid_atom) ||
      sev.property == None)
    return;     // Wrong type.
  cout << "HERE" << endl;
  file = shape = frame = -1;  // Invalidate old data.
  chunknum = -1;
  combo_cnt = -1;
  combo_xtiles = combo_ytiles = 0;
  delete combo;
  combo = 0;
  Atom type = None;   // Get data.
  int format;
  unsigned long nitems, after;
  unsigned char *data;    
  if (XGetWindowProperty(display, sev.requestor, sev.property,
          0, 65000, False, AnyPropertyType,
          &type, &format, &nitems, &after, &data) != Success)
    {
    cout << "Error in getting selection" << endl;
    return;
    }
  if (sev.target == shapeid_atom) // Dropping a shape?
    {
          // Get shape info.
    Get_u7_shapeid(data, file, shape, frame);
    data_valid = true;
    }
  else if (sev.target == chunkid_atom)
    {     // A whole chunk.
    Get_u7_chunkid(data, chunknum);
    data_valid = true;
    }
  else if (sev.target == comboid_atom)
    {
    Get_u7_comboid(data, combo_xtiles, combo_ytiles,
        combo_tiles_right, combo_tiles_below, combo_cnt, combo);
cout << "Combo: xtiles=" << combo_xtiles << ", ytiles=" << combo_ytiles <<
  ", tiles_right=" << combo_tiles_right << ", tiles_below=" <<
          combo_tiles_below << endl;
    data_valid = true;
    }
  XFree(data);
  }


#endif  /* USE_EXULTSTUDIO */

---