wnd.cc

kaffe Java 解释器语言,源码,Java的子集系统,开放源代码

/**
 * wnd.c - native toplevel window related functions
 *
 * Copyright (c) 1998
 *      Transvirtual Technologies, Inc.  All rights reserved.
 *
 * See the file "license.terms" for information on usage and redistribution 
 * of this file. 
 */

#include <limits.h>

#ifdef QPE
#  include <qpe/qpeapplication.h>
#else
#  include <qapplication.h>
#endif

#include <qframe.h>
#include <qcursor.h>
#include <qwidget.h>

#include "toolkit.h"

#define QCOLOR(c) QColor(JRED(c), JGREEN(c), JBLUE(c))

#ifdef QPE
extern QPEApplication *qapp;
#else
extern QApplication *qapp;
#endif

#if 0
long StdEvents = ExposureMask | KeyPressMask | KeyReleaseMask |
		 PointerMotionMask | /* PointerMotionHintMask | */
		 ButtonPressMask | ButtonReleaseMask | ButtonMotionMask |
		 EnterWindowMask | LeaveWindowMask | StructureNotifyMask |
		 FocusChangeMask | VisibilityChangeMask;

long PopupEvents = ExposureMask |
		 PointerMotionMask | /* PointerMotionHintMask | */
		 ButtonPressMask | ButtonReleaseMask | ButtonMotionMask |
		 EnterWindowMask | LeaveWindowMask | StructureNotifyMask |
		 VisibilityChangeMask;
#endif
/*
 * X dosen't have "owned" popups (menus, choice windows etc.), all it has
 * are 'isTransientFor' properties, and these might not be honored by native
 * window managers in a way that the popup, when getting the focus, doesn't
 * visibly take the focus away from the owner ("shading" its titlebar). The
 * only reliable, non wm-dependent way to prevent this seems to be not to
 * select key events for the popup (i.e. not giving it the focus at all). But
 * we don't want to let this native layer deficiency (of a single platform)
 * show up on the Java side. We implement these temporary popup focus shifts
 * by means of focus forwarding in the native layer, which means we have to
 * take care of propper forwarding/restore during
 * setVisible/requestFocus/destroy, and
 * focus/key events. The owner never gives up the focus with respect to X,
 * but the native layer keeps track of all the involved retargeting of
 * Java events, thus giving Java the illusion of a real focus switch.
 * Since this comes with some "artificial" events we have to process in the
 * Java event queue, we use ClientMessages mapped to the corresponding Java
 * FocusEvents.
 */

/* also used in evt.c */
void forwardFocus ( int cmd, void* wnd )
{
#if 0
  XEvent event;

  event.xclient.type = ClientMessage; 
  event.xclient.message_type = FORWARD_FOCUS;
  event.xclient.format = 32;
  event.xclient.data.l[0] = cmd;
  event.xclient.window = wnd;
	  
  XSendEvent( X->dsp, wnd, False, StdEvents, &event);
#endif
}

static void 
retryFocus ( void* wnd, void* owner, int count )
{
#if 0
  XEvent event;

  event.xclient.type = ClientMessage; 
  event.xclient.message_type = RETRY_FOCUS;
  event.xclient.format = 32;
  event.xclient.data.l[0] = count;
  event.xclient.data.l[1] = owner;
  event.xclient.window = wnd;
	  
  XSendEvent( X->dsp, (Window)wnd, False, StdEvents, &event);
  XSync( X->dsp, False);
#endif
}

static int
getCursor ( jint jCursor )
{
  int cursor;

  if ( jCursor > 13 ) jCursor = 0;

  if ( !(cursor = X->cursors[jCursor]) ){
    QCursorShape shape;
    switch ( jCursor ) {

#if QT_VERSION < 300
      /* Qt2 */
      case  0: shape = ArrowCursor; break;     /*  0: DEFAULT_CURSOR     */
      case  1: shape = CrossCursor; break;     /*  1: CROSSHAIR_CURSOR   */
      case  2: shape = IbeamCursor; break;     /*  2: TEXT_CURSOR        */
      case  3: shape = WaitCursor; break;      /*  3: WAIT_CURSOR        */
      case  4: shape = SizeBDiagCursor; break; /*  4: SW_RESIZE_CURSOR */
      case  5: shape = SizeFDiagCursor; break; /*  5: SE_RESIZE_CURSOR   */
      case  6: shape = SizeFDiagCursor; break; /*  6: NW_RESIZE_CURSOR   */
      case  7: shape = SizeBDiagCursor; break; /*  7: NE_RESIZE_CURSOR   */
      case  8: shape = SizeVerCursor; break;   /*  8: N_RESIZE_CURSOR    */
      case  9: shape = SizeVerCursor; break;   /*  9: S_RESIZE_CURSOR    */
      case 10: shape = SizeHorCursor; break;   /* 10: W_RESIZE_CURSOR    */
      case 11: shape = SizeHorCursor; break;   /* 11: E_RESIZE_CURSOR    */
      case 12: shape = PointingHandCursor; break; /* 12: HAND_CURSOR        */
      case 13: shape = SizeAllCursor; break;   /* 13: MOVE_CURSOR        */
      default: shape = ArrowCursor;
#else
      /* Qt3 */
      case  0: shape = Qt::ArrowCursor; break;     /*  0: DEFAULT_CURSOR     */
      case  1: shape = Qt::CrossCursor; break;     /*  1: CROSSHAIR_CURSOR   */
      case  2: shape = Qt::IbeamCursor; break;     /*  2: TEXT_CURSOR        */
      case  3: shape = Qt::WaitCursor; break;      /*  3: WAIT_CURSOR        */
      case  4: shape = Qt::SizeBDiagCursor; break; /*  4: SW_RESIZE_CURSOR */
      case  5: shape = Qt::SizeFDiagCursor; break; /*  5: SE_RESIZE_CURSOR   */
      case  6: shape = Qt::SizeFDiagCursor; break; /*  6: NW_RESIZE_CURSOR   */
      case  7: shape = Qt::SizeBDiagCursor; break; /*  7: NE_RESIZE_CURSOR   */
      case  8: shape = Qt::SizeVerCursor; break;   /*  8: N_RESIZE_CURSOR    */
      case  9: shape = Qt::SizeVerCursor; break;   /*  9: S_RESIZE_CURSOR    */
      case 10: shape = Qt::SizeHorCursor; break;   /* 10: W_RESIZE_CURSOR    */
      case 11: shape = Qt::SizeHorCursor; break;   /* 11: E_RESIZE_CURSOR    */
      case 12: shape = Qt::PointingHandCursor; break; /* 12: HAND_CURSOR        */
      case 13: shape = Qt::SizeAllCursor; break;   /* 13: MOVE_CURSOR        */
      default: shape = Qt::ArrowCursor;
#endif
    }

    cursor = X->cursors[jCursor] = shape;
  }

  return cursor;
}


void Java_java_awt_Toolkit_wndSetTitle(JNIEnv* env, jclass clazz,
  void* wnd, jstring jTitle )
{
  fprintf(stderr,"wndSetTitle\n");
  if ( jTitle ) {
    char *buf = java2CString( env, X, jTitle);
    ((QWidget*)wnd)->setCaption(QString(buf));
  }
}


void Java_java_awt_Toolkit_wndSetResizable(JNIEnv* env, jclass clazz,
  void* wnd, jboolean isResizable, int x, int y, int width, int height)
{
  fprintf(stderr,"wndSetResizable\n");
  int min_width, max_width;
  int min_height, max_height;

  AWT_DBG(printf("setResizable: %p, %d, %d,%d,%d,%d\n",
    wnd, isResizable, x, y, width, height));

  if ( !isResizable ) {
    min_width = max_width = width;
    min_height = max_height = height;    
  }
  else {
    min_width = min_height = 0;
    max_width = max_height = 32767;
  }

  ((QWidget*)wnd)->setMinimumWidth(min_width);
  ((QWidget*)wnd)->setMaximumWidth(max_width);
  ((QWidget*)wnd)->setMinimumHeight(min_height);
  ((QWidget*)wnd)->setMaximumHeight(max_height);
}

#if 0
static Window
createWindow ( JNIEnv* env, jclass clazz, Window parent, Window owner,
  jstring jTitle, jint x, jint y, jint width, jint height,
  jint jCursor, jint clrBack, jboolean isResizable )
{
  unsigned long          valueMask;
  XSetWindowAttributes   attributes;
  Window                 wnd;
  Atom                   protocol[2];
  int                    i;

  /* note that we don't select on key / focus events for popus
     (owner, no title) */
  attributes.event_mask = (owner && !jTitle) ? PopupEvents :  StdEvents;
  attributes.background_pixel = clrBack;
  attributes.bit_gravity = ForgetGravity;
  attributes.cursor = getCursor( jCursor);
  valueMask = CWEventMask | CWBackPixel | CWBitGravity | CWCursor;

  if ( !jTitle ) {
	attributes.override_redirect = True;
	attributes.save_under = True;
	valueMask |= CWOverrideRedirect | CWSaveUnder;
  }
  else {
	attributes.backing_store = WhenMapped;
	valueMask |= CWBackingStore;
  }

  if ( width <= 0 )  width = 1;
  if ( height <= 0 ) height = 1;

  DBG( AWT_WND, printf("XCreateWindow %d,%d,%d,%d\n", x, y, width, height));
  wnd = XCreateWindow( X->dsp, parent, x, y, width, height, 0,
					   CopyFromParent, InputOutput, CopyFromParent,
					   valueMask, &attributes);
  DBG( AWT_WND, printf(" -> %lx\n", wnd));

  if ( wnd ) {
	i=0;
	protocol[i++] = WM_DELETE_WINDOW;
	protocol[i++] = WM_TAKE_FOCUS;
	XSetWMProtocols( X->dsp, wnd, protocol, i);

	if ( owner ){
	  XSetTransientForHint( X->dsp, wnd, owner ); // ???
	}

	if ( !isResizable )
	  Java_java_awt_Toolkit_wndSetResizable( env, clazz,
			 (void*)wnd, isResizable, x, y, width, height);

	if ( jTitle )
	  Java_java_awt_Toolkit_wndSetTitle( env, clazz, (void*)wnd, jTitle);

	return wnd;
  }
  else {
	return 0;
  }
}
#endif
/*
 * We register here (and not in evt.c, during evtRegisterSource) because
 * we want to be able to store attributes (flags, owner), without being
 * forced to use fancy intermediate cache mechanisms (or intermediate
 * register states). Storing own Window attributes (flags, owners) in
 * the native layer is essential for mechanisms like the popup focus
 * forwarding, but can be used in other places (like inset detection
 * and mapping) as well, to avoid costly round-trips or additional state
 * passed in from the Java side
 */
static int registerSource(Toolkit* X, QWidget* wnd, QWidget* owner,
  int flags)
{
  int i = getFreeSourceIdx( X, wnd);

  if ( i >= 0 ) {
	X->windows[i].w = wnd;
	X->windows[i].flags = flags;
	X->windows[i].owner = owner;
	return i;
  }
  else {
	DBG( AWT_EVT, printf("window table out of space: %d", X->nWindows));
	return -1;
  }
}


void* Java_java_awt_Toolkit_wndCreateFrame(JNIEnv* env, jclass clazz,
  jstring jTitle, jint x, jint y, jint width, jint height,
  jint jCursor, jint clrBack, jboolean isResizable)
{
//  Window w = createWindow( env, clazz, DefaultRootWindow( X->dsp), 0, jTitle,
//	   x, y, width, height, jCursor, clrBack, isResizable);

  fprintf(stderr,"wndCreateFrame\n");
  //QMainWindow* mw = new QMainWindow();
  QFrame *mw = new QFrame();
  AWT_DBG(printf("createFrame( %p, %d,%d,%d,%d,..) -> %p\n", 
    jTitle, x, y, width, height, mw));

  if ( width <= 0 )  width = 1;
  if ( height <= 0 ) height = 1;

  mw->setGeometry(x, y, width, height);

  ((QWidget *)mw)->setCursor(QCursor(getCursor(jCursor)));

  mw->setBackgroundColor(QCOLOR(clrBack));

  Java_java_awt_Toolkit_wndSetResizable( env, clazz, (void*)mw,
    isResizable, x, y, width, height);

  Java_java_awt_Toolkit_wndSetTitle(env, clazz, (void*)mw, jTitle);

  //mw->show(); // this should be removed

  int idx = registerSource( X, (QWidget*)mw, 0, WND_FRAME);
  AWT_DBG(printf("registerSource: mw=%p idx=%d\n",mw,idx));