/* Toolkit independent way of determining if an event window is in the
menubar. */
Boolean
lw_window_is_in_menubar (Window win, Widget menubar_widget)
{
return menubar_widget
#if defined (USE_LUCID)
&& XtWindow (menubar_widget) == win;
#endif
#if defined (USE_MOTIF)
&& ((XtWindow (menubar_widget) == win)
|| (XtWindowToWidget (XtDisplay (menubar_widget), win)
&& (XtParent (XtWindowToWidget (XtDisplay (menubar_widget), win))
== menubar_widget)));
#endif
}
NPError nsPluginInstance::SetWindow(NPWindow* aWindow)
{
if(aWindow == NULL)
return FALSE;
mX = aWindow->x;
mY = aWindow->y;
mWidth = aWindow->width;
mHeight = aWindow->height;
if (mWindow != (Window) aWindow->window) {
mWindow = (Window) aWindow->window;
NPSetWindowCallbackStruct *ws_info = (NPSetWindowCallbackStruct *)aWindow->ws_info;
mDisplay = ws_info->display;
mVisual = ws_info->visual;
mDepth = ws_info->depth;
mColormap = ws_info->colormap;
if (!mFontInfo) {
if (!(mFontInfo = XLoadQueryFont(mDisplay, "9x15")))
printf("Cannot open 9X15 font\n");
}
// add xt event handler
Widget xtwidget = XtWindowToWidget(mDisplay, mWindow);
if (xtwidget && mXtwidget != xtwidget) {
mXtwidget = xtwidget;
long event_mask = ExposureMask;
XSelectInput(mDisplay, mWindow, event_mask);
XtAddEventHandler(xtwidget, event_mask, False, (XtEventHandler)xt_event_handler, this);
}
}
draw();
return TRUE;
}
int INTERNAL_cursorpos(float *x, float *y)
{
int rootx, rooty, wx, wy, ret;
Window root, child;
unsigned int mask;
Widget wid;
*x = *y = 0.0;
if ((wid=XtWindowToWidget(INTERNAL_display,xwini[GD.win_id].xwin))==NULL)
return FALSE;
if (XtIsManaged(wid)==FALSE)
return FALSE;
if (XmGetVisibility(wid) == XmVISIBILITY_FULLY_OBSCURED)
return FALSE;
ret = (int) XQueryPointer(INTERNAL_display,
xwini[GD.win_id].xwin,
&root,
&child,
&rootx, &rooty,
&wx, &wy,
&mask);
*x = usercoorx((float) wx);
*y = usercoory((float) wy);
return ret;
}
void g_retrievecursor(int store_id)
{
Widget wid;
Window w;
int x,y;
if (store_id < 0 || store_id > G_MAX_STORE_CURSOR || SC[store_id].w == 0)
return;
wid = XtWindowToWidget(INTERNAL_display,SC[store_id].w);
if (wid && XtIsManaged(wid) &&
XmGetVisibility(wid) != XmVISIBILITY_FULLY_OBSCURED) {
w = SC[store_id].w;
x = SC[store_id].x;
y = SC[store_id].y;
}
else {
w = INTERNAL_rootwin;
x = SC[store_id].rootx;
y = SC[store_id].rooty;
}
XWarpPointer(INTERNAL_display,
None,
w,
0, 0,
0, 0,
x, y);
XFlush(INTERNAL_display);
}
/*!
For internal use only.
*/
void QNPWidget::setWindow(bool delold)
{
saveWId = winId(); // ### Don't need this anymore
create((WId)pi->window, FALSE, delold);
if ( delold ) {
// Make sure they get a show()
clearWState( WState_Visible );
}
#ifdef _WS_X11_
Widget w = XtWindowToWidget (qt_xdisplay(), pi->window);
XtAddEventHandler(w, EnterWindowMask, FALSE, enter_event_handler, pi);
XtAddEventHandler(w, LeaveWindowMask, FALSE, leave_event_handler, pi);
Pixmap bgpm=0;
XColor col;
XtVaGetValues(w,
XtNbackground, &col.pixel,
XtNbackgroundPixmap, &bgpm,
0, 0);
XQueryColor(qt_xdisplay(), x11Colormap(), &col);
setBackgroundColor(QColor(col.red >> 8, col.green >> 8, col.blue >> 8));
if (bgpm) {
// ### Need an under-the-hood function here, or we have to
// ### rewrite lots of code from QPixmap::convertToImage().
// ### Doesn't matter yet, because Netscape doesn't ever set
// ### the background image of the window it gives us.
}
#endif
createNewWindowsForAllChildren(this);
setGeometry( pi->x, pi->y, pi->width, pi->height );
}
static void
xt_add_focus_listener_tree ( Widget treeroot, XtPointer user_data)
{
Window win = XtWindow(treeroot);
Window *children;
Window root, parent;
Display *dpy = XtDisplay(treeroot);
unsigned int i, nchildren;
/* ensure we don't add more than once */
xt_remove_focus_listener( treeroot, user_data);
xt_add_focus_listener( treeroot, user_data);
trap_errors();
if(!XQueryTree(dpy, win, &root, &parent, &children, &nchildren)) {
untrap_error();
return;
}
if(untrap_error())
return;
for(i=0; i<nchildren; ++i) {
Widget child = XtWindowToWidget(dpy, children[i]);
if (child)
xt_add_focus_listener_tree( child, user_data);
}
XFree((void*)children);
return;
}
void XmdsPopupMenuPosition(XmRowColumnWidget w,XButtonEvent *event)
{
Widget option = w->row_column.memory_subwidget;
XtX(w) = event->x_root - (option ? XtX(option) + XtWidth(option) / 2 : 0);
XtY(w) = event->y_root - (option ? XtY(option) + XtHeight(option) / 2 : 0);
RC_SetWidgetMoved(w,1);
RC_CascadeBtn(w) = XtWindowToWidget(XtDisplay(w),event->window);
}
// When we are in an event loop of QApplication rather than the browser's
// event loop (eg. for a modal dialog), we still send events to Xt.
static
void np_event_proc( XEvent* e )
{
Widget xtw = XtWindowToWidget( e->xany.display, e->xany.window );
if ( xtw && qApp->loopLevel() > 0 ) {
// Allow Xt to process the event
qt_np_cascade_event_handler[e->type]( e );
}
}
// When we are in an event loop of QApplication rather than the browser's
// event loop (eg. for a modal dialog), we still send repaint events to
// the browser.
static
void np_event_proc( XEvent* e )
{
Widget xtw = XtWindowToWidget( e->xany.display, e->xany.window );
if ( xtw && filterTypeFor( e->type ) == Safe ) {
// Graciously allow the browser to process the event
qt_np_cascade_event_handler[e->type]( e );
}
}
static void
xt_client_focus_listener( Widget w, XtPointer user_data, XEvent *event)
{
Display *dpy = XtDisplay(w);
XtClient *xtclient = user_data;
Window win = XtWindow(w);
switch(event->type)
{
case CreateNotify:
if(event->xcreatewindow.parent == win) {
Widget child=XtWindowToWidget( dpy, event->xcreatewindow.window);
if (child)
xt_add_focus_listener_tree(child, user_data);
}
break;
case DestroyNotify:
xt_remove_focus_listener( w, user_data);
break;
case ReparentNotify:
if(event->xreparent.parent == win) {
/* I am the new parent */
Widget child=XtWindowToWidget(dpy, event->xreparent.window);
if (child)
xt_add_focus_listener_tree( child, user_data);
}
else if(event->xreparent.window == win) {
/* I am the new child */
}
else {
/* I am the old parent */
}
break;
case ButtonRelease:
#if 0
XSetInputFocus(dpy, XtWindow(xtclient->child_widget), RevertToParent, event->xbutton.time);
#endif
send_xembed_message ( xtclient,
XEMBED_REQUEST_FOCUS, 0, 0, 0, 0);
break;
default:
break;
} /* End of switch(event->type) */
}
static void
SetUpWindow(SqueakPlugin *plugin)
{
Widget w= XtWindowToWidget(plugin->display, plugin->nswindow);
DPRINT("NP: SetUpWindow(0x%X)\n", plugin->nswindow);
XSelectInput(plugin->display, plugin->nswindow, 0);
if (plugin->embedded) {
/* need to capture destroys when page is re-layouted */
XtAddCallback(w, XtNdestroyCallback,
(XtCallbackProc) DestroyCallback, plugin);
}
}
/*
* test if there is a menu that has the current focus
* called from awt_Dialog.c and awt_Component.c
*/
Boolean
awt_util_focusIsOnMenu(Display *display)
{
Window window;
Widget widget;
int32_t rtr;
XGetInputFocus(display, &window, &rtr);
if (window == None) {
return False;
}
widget = XtWindowToWidget(display, window);
if (widget == NULL) {
return False;
}
if (XtIsSubclass(widget, xmMenuShellWidgetClass)) {
return True;
}
#if MOTIF_VERSION!=1
/* Motif 2.1 uses XmGrabShell on XmComboBox instead
of XmMenuShell
*/
if (XtIsSubclass(widget, xmGrabShellWidgetClass)) {
return True;
}
/* Fix 4800638 check the ancestor of focus widget is
GrabSell
*/
if (XtIsSubclass(widget, xmListWidgetClass))
{
Widget shell = getShellWidget(widget);
if (shell && XtIsSubclass(shell,
xmGrabShellWidgetClass))
{
return True;
}
}
#endif
if (XtIsSubclass(widget, xmRowColumnWidgetClass)) {
unsigned char type;
XtVaGetValues(widget, XmNrowColumnType, &type, NULL);
if (type == XmMENU_BAR) {
return True;
}
}
return False;
}
static void
addXtEventHandler(PluginInstance *This)
{
#ifdef MOZ_X11
Display *dpy = (Display*) This->display;
Window xwin = (Window) This->window;
Widget xt_w = XtWindowToWidget(dpy, xwin);
if (xt_w)
{
long event_mask = ExposureMask | ButtonReleaseMask | ButtonPressMask;
XSelectInput(dpy, xwin, event_mask);
XtAddEventHandler(xt_w, event_mask, False, (XtEventHandler)xt_event_handler, This);
}
#endif
}
static Widget camshellof(int id, struct camwins **cwp)
{
struct camwins *cw;
Widget w;
if (id < 0 || INDEXOF(id) >= VVCOUNT(camshells)) {
return NULL;
}
cw = VVINDEX(camshells, struct camwins, INDEXOF(id));
if ((w = XtWindowToWidget(dpy, cw->shellwin)) == NULL) {
return NULL;
}
if (cwp) {
*cwp = cw;
}
return w;
}
/*!
For internal use only.
*/
void QNPWidget::unsetWindow()
{
#ifdef _WS_X11_
WId wi = winId();
Widget w = XtWindowToWidget (qt_xdisplay(), wi);
if ( w ) {
XtRemoveEventHandler(w, LeaveWindowMask, FALSE, leave_event_handler, pi);
XtRemoveEventHandler(w, EnterWindowMask, FALSE, enter_event_handler, pi);
}
destroy( FALSE, FALSE ); // Xt has already destroyed all the windows
#endif
#ifdef _WS_WIN_
// Nothing special
destroy( FALSE, TRUE ); // Browser will the window, but not the subwindows
#endif
}
// Relacement for Qt function - add Xt stuff for top-level widgets
void qt_XDestroyWindow( const QWidget* qw, Display *display, Window window )
{
if ( qw->isTopLevel() && !qw->isA("QNPWidget") ) {
Widget xtw = XtWindowToWidget( display, window );
if ( xtw ) {
XtRemoveEventHandler(xtw, LeaveWindowMask, TRUE, leave_event_handler, 0);
XtRemoveEventHandler(xtw, EnterWindowMask, TRUE, enter_event_handler, 0);
XtDestroyWidget( xtw );
} else {
XDestroyWindow( display, window );
}
} else {
XDestroyWindow( display, window );
}
}
static pxembed_server_data
getDataByServerHandle(Window serverHandle) {
JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
pxembed_server_data temp = xembed_list;
Widget serverWidget = NULL;
if (serverHandle == None) {
return NULL;
}
serverWidget = XtWindowToWidget(awt_display, serverHandle);
while (temp != NULL) {
if (temp->serverHandle == serverHandle || temp->serverWidget == serverWidget) {
temp->serverHandle = serverWidget;
return temp;
}
temp = temp->next;
}
return NULL;
}
static GdkWindow *getGdkWindow(PluginInstance *This)
{
#ifdef MOZ_X11
GdkWindow *gdk_window;
Window xwin = (Window) This->window;
Widget xt_w = XtWindowToWidget(This->display, xwin);
if (xt_w) {
xt_w = XtParent(xt_w);
if (xt_w) {
xwin = XtWindow(xt_w);
/* xwin = xt_w->core.window; */
}
}
gdk_window = gdk_window_lookup(xwin);
return gdk_window;
#else
return NULL;
#endif
}
void filePopup(Widget w, XEvent *event, String *params, Cardinal *num_params)
{
Window root, child, win;
Widget button;
FileWindowRec *fw;
int x, y, x_win, y_win;
unsigned int mask;
int item;
fw = findFileWidgetByForm(w);
if (!fw || fw->scrolled == None) return;
win = XtWindow(fw->icon_box);
XQueryPointer(dpy, win, &root, &child, &x, &y, &x_win, &y_win, &mask);
if (child != None)
{
button = XtWindowToWidget(dpy, child);
item = findFileItem(fw, button);
XtVaSetValues(fw->form, XmNuserData, (XtPointer) item, NULL);
fileSelect(fw, item);
if (S_ISDIR(fw->files[item]->stats.st_mode))
{
XmMenuPosition(fw->dirPopup, (XButtonPressedEvent *) event);
XtManageChild(fw->dirPopup);
}
else if (fw->files[item]->stats.st_mode & (S_IXUSR | S_IXGRP | S_IXOTH))
{
XmMenuPosition(fw->execPopup, (XButtonPressedEvent *) event);
XtManageChild(fw->execPopup);
}
else
{
XmMenuPosition(fw->filePopup, (XButtonPressedEvent *) event);
XtManageChild(fw->filePopup);
}
}
else
{
XmMenuPosition(fw->formPopup, (XButtonPressedEvent *) event);
XtManageChild(fw->formPopup);
}
}
void XFE_ComposeAttachFolderView::doCommand(CommandType command, void*,XFE_CommandInfo* info)
{
if (command==xfeCmdAttachFile) {
attachFile();
} else if (command==xfeCmdAttachWebPage) {
attachLocation();
} else if ((command==xfeCmdDelete || command==xfeCmdDeleteAttachment) &&
_folderVisible) {
deleteAttach();
} else if (command==xfeCmdShowPopup) {
// Handle popup menu
XEvent *event = info->event;
Widget w = XtWindowToWidget(event->xany.display, event->xany.window);
if (w == NULL) w=getBaseWidget();
if (_xfePopup) {
_xfePopup->position(event);
_xfePopup->show();
}
}
}
void INTERNAL_warpcursor(long x, long y)
{
int destx, desty;
Widget wid;
if ((wid=XtWindowToWidget(INTERNAL_display,xwini[GD.win_id].xwin))==NULL)
return;
if (XtIsManaged(wid)==FALSE)
return;
if (XmGetVisibility(wid) == XmVISIBILITY_FULLY_OBSCURED)
return;
destx = (int) x;
desty = (int) y;
XWarpPointer(INTERNAL_display,
None,
xwini[GD.win_id].xwin,
0, 0,
0, 0,
destx, desty);
xwini[GD.win_id].xlib_old_x = destx;
xwini[GD.win_id].xlib_old_y = desty;
}
Widget
WmPanelistWindowToSubpanel (Display *dpy, Window win)
{
Widget subpanel_shell;
Widget * child_list;
int num_children;
Arg al[2];
int ac;
/* Get the widget for the subpanel (Should be only child of the shell!) */
subpanel_shell = XtWindowToWidget (dpy, win);
ac = 0;
XtSetArg (al[ac], XmNchildren, &child_list); ac++;
XtSetArg (al[ac], XmNnumChildren, &num_children); ac++;
XtGetValues (subpanel_shell, al, ac);
return ((num_children > 0) ? child_list[0] : (Widget)NULL);
}
JNIEXPORT jobject JNICALL
awt_GetComponent(JNIEnv* env, void* platformInfo)
{
Window window = (Window)platformInfo;
Widget widget = NULL;
jobject peer = NULL;
jobject target = NULL;
AWT_LOCK();
#ifndef XAWT
if (window != None) {
widget = XtWindowToWidget(awt_display, window);
}
if (widget != NULL) {
XtVaGetValues (widget, XmNuserData, &peer, NULL);
}
if (peer != NULL) {
target = (*env)->GetObjectField(env, peer, mComponentPeerIDs.target);
}
#else
target = (*env)->GetObjectField(env, peer, targetID);
#endif
if (target == NULL) {
JNU_ThrowNullPointerException(env, "NullPointerException");
AWT_UNLOCK();
return (jobject)NULL;
}
AWT_UNLOCK();
return target;
}
static void
callback (Widget w, Resource * node, XmPushButtonCallbackStruct * pbcs)
{
int vi;
have_xy = 0;
lesstif_show_crosshair (0);
if (pbcs->event && pbcs->event->type == KeyPress)
{
Dimension wx, wy;
Widget aw = XtWindowToWidget (display, pbcs->event->xkey.window);
action_x = pbcs->event->xkey.x;
action_y = pbcs->event->xkey.y;
if (aw)
{
Widget p = work_area;
while (p && p != aw)
{
n = 0;
stdarg (XmNx, &wx);
stdarg (XmNy, &wy);
XtGetValues (p, args, n);
action_x -= wx;
action_y -= wy;
p = XtParent (p);
}
if (p == aw)
have_xy = 1;
}
//printf("have xy from %s: %d %d\n", XtName(aw), action_x, action_y);
}
lesstif_need_idle_proc ();
for (vi = 1; vi < node->c; vi++)
if (resource_type (node->v[vi]) == 10)
if (hid_parse_actions (node->v[vi].value))
return;
}
int findWindow(Window w, FileWindowRec **fw_ret)
{
Widget w_source = XtWindowToWidget(XtDisplay(toplevel),w);
return findWidget(w_source, fw_ret);
/*
for(fw=file_windows; fw; fw=fw->next)
{
if(XtWindow(fw->icon_box)==w || XtWindow(fw->label)==w)
{
*fw_ret=fw;
return -1;
}
for(i=0;i<fw->n_files;i++)
if(XtWindow(fw->files[i]->icon.toggle)==w)
{
*fw_ret = fw;
return i;
}
}
*fw_ret=NULL;
return 0;
*/
}
/***********************************************************************
* This function gets called first when the plugin widget is created and
* then whenever the plugin is changed.
***********************************************************************/
NPError
NPP_SetWindow(NPP instance, NPWindow* window)
{
PluginInstance* This;
Widget netscape_widget;
if (instance == NULL)
return NPERR_INVALID_INSTANCE_ERROR;
if (window == NULL)
return NPERR_NO_ERROR;
/*
* PLUGIN DEVELOPERS:
* Before setting window to point to the
* new window, you may wish to compare the new window
* info to the previous window (if any) to note window
* size changes, etc.
*/
This = (PluginInstance*) instance->pdata;
#ifdef PLUGIN_TRACE
fprintf(stderr, "SetWindow 0x%x.\n", (Window) window->window);
fprintf(stderr, "This: 0x%x\n", This);
if (This->plugin_widget)
fprintf(stderr, "This->plugin_widget: 0x%x\n", This->plugin_widget);
#endif
if (RxGlobal.dpy == NULL) {
RxGlobal.dpy = ((NPSetWindowCallbackStruct *)window->ws_info)->display;
RxGlobal.wm_delete_window =
XInternAtom (RxGlobal.dpy, "WM_DELETE_WINDOW", TRUE);
RxGlobal.wm_protocols = XInternAtom (RxGlobal.dpy, "WM_PROTOCOLS", TRUE);
}
netscape_widget = XtWindowToWidget(RxGlobal.dpy, (Window) window->window);
if (This->toplevel_widget == NULL)
This->toplevel_widget = FindToplevel(netscape_widget);
if (This->plugin_widget != netscape_widget) {
/* We have a new widget store it */
This->plugin_widget = netscape_widget;
This->width = window->width;
This->height = window->height;
XtAddCallback (This->plugin_widget, XtNdestroyCallback,
DestroyCB, (XtPointer) This);
XtAddCallback (This->plugin_widget, "resizeCallback",
ResizeCB, (XtPointer) This);
if (This->app_group)
RxpSetupPluginEventHandlers (This);
if (This->nclient_windows > 0) {
int i;
/* We already have the client, so we need to reparent it to the
new window */
for (i = 0; i < This->nclient_windows; i++) {
XReparentWindow(RxGlobal.dpy, This->client_windows[i].win,
XtWindow(netscape_widget),
This->client_windows[i].x,
This->client_windows[i].y);
if (This->dont_reparent == RxTrue) {
XMapWindow (RxGlobal.dpy, This->client_windows[i].win);
This->client_windows[i].flags |= RxpMapped;
}
}
} else /* no client window, display status widget */
RxpSetStatusWidget(This, This->state);
if (This->dont_reparent != RxFalse) /* can be True or Undef */
This->dont_reparent = RxFalse;
else
This->dont_reparent = RxTrue;
}
return NPERR_NO_ERROR;
}
NPError NPP_SetWindow( NPP instance, NPWindow* window )
{
#if defined(XP_UNIX)
Window control;
unsigned int i_control_height = 0, i_control_width = 0;
#endif
if( ! instance )
{
return NPERR_INVALID_INSTANCE_ERROR;
}
/* NPP_SetWindow may be called before NPP_New (Opera) */
VlcPlugin* p_plugin = reinterpret_cast<VlcPlugin*>(instance->pdata);
if( NULL == p_plugin )
{
/* we should probably show a splash screen here */
return NPERR_NO_ERROR;
}
#if defined(XP_UNIX)
control = p_plugin->getControlWindow();
#endif
libvlc_instance_t *p_vlc = p_plugin->getVLC();
/*
* PLUGIN DEVELOPERS:
* Before setting window to point to the
* new window, you may wish to compare the new window
* info to the previous window (if any) to note window
* size changes, etc.
*/
/* retrieve current window */
NPWindow& curwin = p_plugin->getWindow();
#ifdef XP_MACOSX
if( window && window->window )
{
/* check if plugin has a new parent window */
CGrafPtr drawable = (((NP_Port*) (window->window))->port);
/* as MacOS X video output is windowless, set viewport */
libvlc_rectangle_t view, clip;
/*
** browser sets port origin to top-left location of plugin
** relative to GrafPort window origin is set relative to document,
** which of little use for drawing
*/
view.top = ((NP_Port*) (window->window))->porty;
view.left = ((NP_Port*) (window->window))->portx;
view.bottom = window->height+view.top;
view.right = window->width+view.left;
/* clipRect coordinates are also relative to GrafPort */
clip.top = window->clipRect.top;
clip.left = window->clipRect.left;
clip.bottom = window->clipRect.bottom;
clip.right = window->clipRect.right;
#ifdef NOT_WORKING
libvlc_video_set_viewport(p_vlc, p_plugin->getMD(), &view, &clip);
#else
#warning disabled code
#endif
/* remember new window */
p_plugin->setWindow(*window);
}
else if( curwin.window )
{
/* change/set parent */
curwin.window = NULL;
}
#endif /* XP_MACOSX */
#ifdef XP_WIN
if( window && window->window )
{
/* check if plugin has a new parent window */
HWND drawable = (HWND) (window->window);
if( !curwin.window || drawable != curwin.window )
{
/* reset previous window settings */
HWND oldwin = (HWND)p_plugin->getWindow().window;
WNDPROC oldproc = p_plugin->getWindowProc();
if( oldproc )
{
/* reset WNDPROC */
SetWindowLong( oldwin, GWL_WNDPROC, (LONG)oldproc );
}
/* attach our plugin object */
SetWindowLongPtr((HWND)drawable, GWLP_USERDATA,
reinterpret_cast<LONG_PTR>(p_plugin));
/* install our WNDPROC */
p_plugin->setWindowProc( (WNDPROC)SetWindowLong( drawable,
GWL_WNDPROC, (LONG)Manage ) );
/* change window style to our liking */
LONG style = GetWindowLong((HWND)drawable, GWL_STYLE);
style |= WS_CLIPCHILDREN|WS_CLIPSIBLINGS;
SetWindowLong((HWND)drawable, GWL_STYLE, style);
/* remember new window */
p_plugin->setWindow(*window);
/* Redraw window */
InvalidateRect( (HWND)drawable, NULL, TRUE );
UpdateWindow( (HWND)drawable );
}
}
else if( curwin.window )
{
/* reset WNDPROC */
HWND oldwin = (HWND)curwin.window;
SetWindowLong( oldwin, GWL_WNDPROC, (LONG)(p_plugin->getWindowProc()) );
p_plugin->setWindowProc(NULL);
curwin.window = NULL;
}
#endif /* XP_WIN */
#if defined(XP_UNIX)
/* default to hidden toolbar, shown at the end of this method if asked *
* developers note : getToolbarSize need to wait the end of this method
*/
i_control_height = 0;
i_control_width = window->width;
if( window && window->window )
{
Window parent = (Window) window->window;
if( !curwin.window || (parent != (Window)curwin.window) )
{
Display *p_display = ( (NPSetWindowCallbackStruct *)
window->ws_info )->display;
XResizeWindow( p_display, parent, window->width, window->height );
int i_blackColor = BlackPixel(p_display, DefaultScreen(p_display));
/* create windows */
Window video = XCreateSimpleWindow( p_display, parent, 0, 0,
window->width, window->height - i_control_height,
0, i_blackColor, i_blackColor );
Window controls = (Window) NULL;
controls = XCreateSimpleWindow( p_display, parent,
0, window->height - i_control_height-1,
window->width, i_control_height-1,
0, i_blackColor, i_blackColor );
XMapWindow( p_display, parent );
XMapWindow( p_display, video );
if( controls ) { XMapWindow( p_display, controls ); }
XFlush(p_display);
/* bind events */
Widget w = XtWindowToWidget( p_display, parent );
XtAddEventHandler( w, ExposureMask, FALSE,
(XtEventHandler)Redraw, p_plugin );
XtAddEventHandler( w, StructureNotifyMask, FALSE,
(XtEventHandler)Resize, p_plugin );
XtAddEventHandler( w, ButtonReleaseMask, FALSE,
(XtEventHandler)ControlHandler, p_plugin );
/* remember window */
p_plugin->setWindow( *window );
p_plugin->setVideoWindow( video );
if( controls )
{
p_plugin->setControlWindow( controls );
}
Redraw( w, (XtPointer)p_plugin, NULL );
/* now display toolbar if asked through parameters */
if( p_plugin->b_toolbar )
{
p_plugin->showToolbar();
}
}
}
else if( curwin.window )
{
curwin.window = NULL;
}
#endif /* XP_UNIX */
if( !p_plugin->b_stream )
{
if( p_plugin->psz_target )
{
if( p_plugin->playlist_add( p_plugin->psz_target ) != -1 )
{
if( p_plugin->b_autoplay )
{
p_plugin->playlist_play();
}
}
p_plugin->b_stream = true;
}
}
return NPERR_NO_ERROR;
}
Boolean qnpxt_event_dispatcher( XEvent *event )
{
static bool grabbed = FALSE;
QApplication::sendPostedEvents();
QWidgetIntDict *mapper = &static_d->mapper;
QWidget* qnpxt = mapper->find( event->xany.window );
if ( !qnpxt && QWidget::find( event->xany.window) == 0 ) {
// event is not for Qt, try Xt
Widget w = XtWindowToWidget( QPaintDevice::x11AppDisplay(),
event->xany.window );
while ( w && ! ( qnpxt = mapper->find( XtWindow( w ) ) ) ) {
if ( XtIsShell( w ) ) {
break;
}
w = XtParent( w );
}
if ( qnpxt && ( event->type == XKeyPress ||
event->type == XKeyRelease ) ) {
// remap key events to keep accelerators working
event->xany.window = qnpxt->winId();
}
if ( w ) {
if ( !grabbed && ( event->type == XFocusIn &&
event->xfocus.mode == NotifyGrab ) ) {
// qDebug( "Xt: grab started" );
grabbed = TRUE;
} else if ( grabbed && ( event->type == XFocusOut &&
event->xfocus.mode == NotifyUngrab ) ) {
// qDebug( "Xt: grab ended" );
grabbed = FALSE;
}
}
}
/*
If the mouse has been grabbed for a window that we don't know
about, we shouldn't deliver any pointer events, since this will
intercept the event that ends the mouse grab that Xt/Motif
started.
*/
bool do_deliver = TRUE;
if ( grabbed && ( event->type == ButtonPress ||
event->type == ButtonRelease ||
event->type == MotionNotify ||
event->type == EnterNotify ||
event->type == LeaveNotify ) )
do_deliver = FALSE;
last_xevent = event;
bool delivered = do_deliver && ( qApp->x11ProcessEvent( event ) != -1 );
last_xevent = 0;
if ( qnpxt ) {
switch ( event->type ) {
case EnterNotify:
case LeaveNotify:
event->xcrossing.focus = False;
delivered = FALSE;
break;
case XKeyPress:
case XKeyRelease:
delivered = TRUE;
break;
case XFocusIn:
case XFocusOut:
delivered = FALSE;
break;
default:
delivered = FALSE;
break;
}
}
qnpxt_keep_alive();
if ( delivered ) {
// qDebug( "Qt: delivered event" );
return True;
}
// discard user input events when we have an active popup widget
if ( QApplication::activePopupWidget() ) {
switch ( event->type ) {
case ButtonPress: // disallow mouse/key events
case ButtonRelease:
case MotionNotify:
case XKeyPress:
case XKeyRelease:
case EnterNotify:
case LeaveNotify:
case ClientMessage:
// qDebug( "Qt: active popup - discarding event" );
return True;
default:
break;
}
}
if ( QApplication::activeModalWidget() ) {
if ( qnpxt ) {
// send event through Qt modality handling...
if ( !qt_try_modal( qnpxt, event ) ) {
// qDebug( "Qt: active modal widget discarded event" );
return True;
}
} else if ( !grabbed ) {
// we could have a pure Xt shell as a child of the active
// modal widget
QWidget *qw = 0;
Widget xw = XtWindowToWidget( QPaintDevice::x11AppDisplay(),
event->xany.window );
while ( xw && !( qw = mapper->find( XtWindow( xw ) ) ) )
xw = XtParent( xw );
while ( qw && qw != QApplication::activeModalWidget() )
qw = qw->parentWidget();
if ( !qw ) {
// event is destined for an Xt widget, but since Qt has an
// active modal widget, we stop here...
switch ( event->type ) {
case ButtonPress: // disallow mouse/key events
case ButtonRelease:
case MotionNotify:
case XKeyPress:
case XKeyRelease:
case EnterNotify:
case LeaveNotify:
case ClientMessage:
// qDebug( "Qt: active modal widget discarded unknown event" );
return True;
default:
break;
}
}
}
}
if ( static_d->dispatchers[ event->type ]( event ) ) {
// qDebug( "Xt: delivered event" );
// Xt handled the event.
return True;
}
return False;
}
Boolean qmotif_event_dispatcher( XEvent *event )
{
TQApplication::sendPostedEvents();
TQWidgetIntDict *mapper = &static_d->mapper;
TQWidget* qMotif = mapper->find( event->xany.window );
if ( !qMotif && TQWidget::find( event->xany.window) == 0 ) {
// event is not for Qt, try Xt
Display* dpy = TQPaintDevice::x11AppDisplay();
Widget w = XtWindowToWidget( dpy, event->xany.window );
while ( w && ! ( qMotif = mapper->find( XtWindow( w ) ) ) ) {
if ( XtIsShell( w ) ) {
break;
}
w = XtParent( w );
}
if ( qMotif &&
( event->type == XKeyPress || event->type == XKeyRelease ) ) {
// remap key events
event->xany.window = qMotif->winId();
}
}
last_xevent = event;
bool delivered = ( tqApp->x11ProcessEvent( event ) != -1 );
last_xevent = 0;
if ( qMotif ) {
switch ( event->type ) {
case EnterNotify:
case LeaveNotify:
event->xcrossing.focus = False;
delivered = FALSE;
break;
case XKeyPress:
case XKeyRelease:
delivered = TRUE;
break;
case XFocusIn:
case XFocusOut:
delivered = FALSE;
break;
default:
delivered = FALSE;
break;
}
}
if ( delivered )
return True;
if ( TQApplication::activePopupWidget() )
// we get all events through the popup grabs. discard the event
return True;
if ( qMotif && TQApplication::activeModalWidget() ) {
if ( !tqt_try_modal(qMotif, event) )
return True;
}
if ( static_d->dispatchers[ event->type ]( event ) )
// Xt handled the event.
return True;
return False;
}
/*
** Button1 press: evaluate at curpos
** Button2 press: clear marks. start mark at curpos.
** Button2 motion: clear old stop mark. stop mark at curpos
** Button2 release: same as motion.
*/
static void video_event_handler(Widget w, XtPointer clientData, XEvent *event, Boolean *b)
{
PLOT *plot = (PLOT *)clientData;
XButtonEvent *butevent;
XMotionEvent *motevent;
XKeyEvent *keyevent;
char *keybuf;
KeySym key_sym;
Modifiers mod_return;
Widget ew;
switch (event->type)
{
case KeyRelease:
keyevent = (XKeyEvent *)event;
ew = XtWindowToWidget(XtDisplay(w), keyevent->window);
if (ew != plot->plot_widget)
panel_event_handler(ew, (XtPointer)plot->panel, event, b);
else
{
XtTranslateKeycode(XtDisplay(w), keyevent->keycode, 0, &mod_return, &key_sym);
if ((keybuf = XKeysymToString(key_sym)) != NULL)
{
if (KEY_IS_UP(keybuf))
{
panel_unzoom(plot->panel);
}
else
{
panel_handle_keyrelease(w, plot, keyevent, keybuf);
}
}
}
break;
case ButtonPress:
butevent = (XButtonEvent *) event;
switch (butevent->button)
{
case Button1:
break;
case Button2:
break;
case Button3:
XmMenuPosition(plot->plot_popupmenu_widget, butevent);
XtManageChild(plot->plot_popupmenu_widget);
break;
default:
break;
}
break;
case ButtonRelease:
butevent = (XButtonEvent *) event;
switch (butevent->button)
{
case Button1:
break;
case Button2:
break;
case Button3:
break;
default:
break;
}
break;
case MotionNotify:
motevent = (XMotionEvent *)event;
if (motevent->state & Button1Mask)
{
}
else if (motevent->state & Button2Mask)
{
}
else if (motevent->state & Button2Mask)
{
}
break;
default:
break;
}
}
