bool wxApp::ProcessXEvent(WXEvent* _event)
{
XEvent* event = (XEvent*) _event;
wxWindow* win = NULL;
Window window = XEventGetWindow(event);
#if 0
Window actualWindow = window;
#endif
// Find the first wxWindow that corresponds to this event window
// Because we're receiving events after a window
// has been destroyed, assume a 1:1 match between
// Window and wxWindow, so if it's not in the table,
// it must have been destroyed.
win = wxGetWindowFromTable(window);
if (!win)
{
#if wxUSE_TWO_WINDOWS
win = wxGetClientWindowFromTable(window);
if (!win)
#endif
return false;
}
#ifdef __WXDEBUG__
wxString windowClass = win->GetClassInfo()->GetClassName();
#endif
switch (event->type)
{
case Expose:
{
#if wxUSE_TWO_WINDOWS && !wxUSE_NANOX
if (event->xexpose.window != (Window)win->GetClientAreaWindow())
{
XEvent tmp_event;
wxExposeInfo info;
info.window = event->xexpose.window;
info.found_non_matching = false;
while (XCheckIfEvent( wxGlobalDisplay(), &tmp_event, wxX11ExposePredicate, (XPointer) &info ))
{
// Don't worry about optimizing redrawing the border etc.
}
win->NeedUpdateNcAreaInIdle();
}
else
#endif
{
win->GetUpdateRegion().Union( XExposeEventGetX(event), XExposeEventGetY(event),
XExposeEventGetWidth(event), XExposeEventGetHeight(event));
win->GetClearRegion().Union( XExposeEventGetX(event), XExposeEventGetY(event),
XExposeEventGetWidth(event), XExposeEventGetHeight(event));
#if !wxUSE_NANOX
XEvent tmp_event;
wxExposeInfo info;
info.window = event->xexpose.window;
info.found_non_matching = false;
while (XCheckIfEvent( wxGlobalDisplay(), &tmp_event, wxX11ExposePredicate, (XPointer) &info ))
{
win->GetUpdateRegion().Union( tmp_event.xexpose.x, tmp_event.xexpose.y,
tmp_event.xexpose.width, tmp_event.xexpose.height );
win->GetClearRegion().Union( tmp_event.xexpose.x, tmp_event.xexpose.y,
tmp_event.xexpose.width, tmp_event.xexpose.height );
}
#endif
// This simplifies the expose and clear areas to simple
// rectangles.
win->GetUpdateRegion() = win->GetUpdateRegion().GetBox();
win->GetClearRegion() = win->GetClearRegion().GetBox();
// If we only have one X11 window, always indicate
// that borders might have to be redrawn.
if (win->GetMainWindow() == win->GetClientAreaWindow())
win->NeedUpdateNcAreaInIdle();
// Only erase background, paint in idle time.
win->SendEraseEvents();
// EXPERIMENT
//win->Update();
}
return true;
}
#if !wxUSE_NANOX
case GraphicsExpose:
{
wxLogTrace( _T("expose"), _T("GraphicsExpose from %s"), win->GetName().c_str());
win->GetUpdateRegion().Union( event->xgraphicsexpose.x, event->xgraphicsexpose.y,
event->xgraphicsexpose.width, event->xgraphicsexpose.height);
win->GetClearRegion().Union( event->xgraphicsexpose.x, event->xgraphicsexpose.y,
event->xgraphicsexpose.width, event->xgraphicsexpose.height);
if (event->xgraphicsexpose.count == 0)
{
// Only erase background, paint in idle time.
win->SendEraseEvents();
// win->Update();
}
return true;
}
#endif
case KeyPress:
{
if (!win->IsEnabled())
return false;
wxKeyEvent keyEvent(wxEVT_KEY_DOWN);
wxTranslateKeyEvent(keyEvent, win, window, event);
// wxLogDebug( "OnKey from %s", win->GetName().c_str() );
// We didn't process wxEVT_KEY_DOWN, so send wxEVT_CHAR
if (win->GetEventHandler()->ProcessEvent( keyEvent ))
return true;
keyEvent.SetEventType(wxEVT_CHAR);
// Do the translation again, retaining the ASCII
// code.
if (wxTranslateKeyEvent(keyEvent, win, window, event, true) &&
win->GetEventHandler()->ProcessEvent( keyEvent ))
return true;
if ( (keyEvent.m_keyCode == WXK_TAB) &&
win->GetParent() && (win->GetParent()->HasFlag( wxTAB_TRAVERSAL)) )
{
wxNavigationKeyEvent new_event;
new_event.SetEventObject( win->GetParent() );
/* GDK reports GDK_ISO_Left_Tab for SHIFT-TAB */
new_event.SetDirection( (keyEvent.m_keyCode == WXK_TAB) );
/* CTRL-TAB changes the (parent) window, i.e. switch notebook page */
new_event.SetWindowChange( keyEvent.ControlDown() );
new_event.SetCurrentFocus( win );
return win->GetParent()->GetEventHandler()->ProcessEvent( new_event );
}
return false;
}
case KeyRelease:
{
if (!win->IsEnabled())
return false;
wxKeyEvent keyEvent(wxEVT_KEY_UP);
wxTranslateKeyEvent(keyEvent, win, window, event);
return win->GetEventHandler()->ProcessEvent( keyEvent );
}
case ConfigureNotify:
{
#if wxUSE_NANOX
if (event->update.utype == GR_UPDATE_SIZE)
#endif
{
wxTopLevelWindow *tlw = wxDynamicCast(win, wxTopLevelWindow);
if ( tlw )
{
tlw->SetConfigureGeometry( XConfigureEventGetX(event), XConfigureEventGetY(event),
XConfigureEventGetWidth(event), XConfigureEventGetHeight(event) );
}
if ( tlw && tlw->IsShown() )
{
tlw->SetNeedResizeInIdle();
}
else
{
wxSizeEvent sizeEvent( wxSize(XConfigureEventGetWidth(event), XConfigureEventGetHeight(event)), win->GetId() );
sizeEvent.SetEventObject( win );
return win->GetEventHandler()->ProcessEvent( sizeEvent );
}
}
return false;
}
#if !wxUSE_NANOX
case PropertyNotify:
{
//wxLogDebug("PropertyNotify: %s", windowClass.c_str());
return HandlePropertyChange(_event);
}
case ClientMessage:
{
if (!win->IsEnabled())
return false;
Atom wm_delete_window = XInternAtom(wxGlobalDisplay(), "WM_DELETE_WINDOW", True);
Atom wm_protocols = XInternAtom(wxGlobalDisplay(), "WM_PROTOCOLS", True);
if (event->xclient.message_type == wm_protocols)
{
if ((Atom) (event->xclient.data.l[0]) == wm_delete_window)
{
win->Close(false);
return true;
}
}
return false;
}
#if 0
case DestroyNotify:
{
printf( "destroy from %s\n", win->GetName().c_str() );
break;
}
case CreateNotify:
{
printf( "create from %s\n", win->GetName().c_str() );
break;
}
case MapRequest:
{
printf( "map request from %s\n", win->GetName().c_str() );
break;
}
case ResizeRequest:
{
printf( "resize request from %s\n", win->GetName().c_str() );
Display *disp = (Display*) wxGetDisplay();
XEvent report;
// to avoid flicker
report = * event;
while( XCheckTypedWindowEvent (disp, actualWindow, ResizeRequest, &report));
wxSize sz = win->GetSize();
wxSizeEvent sizeEvent(sz, win->GetId());
sizeEvent.SetEventObject(win);
return win->GetEventHandler()->ProcessEvent( sizeEvent );
}
#endif
#endif
#if wxUSE_NANOX
case GR_EVENT_TYPE_CLOSE_REQ:
{
if (win)
{
win->Close(false);
return true;
}
return false;
break;
}
#endif
case EnterNotify:
case LeaveNotify:
case ButtonPress:
case ButtonRelease:
case MotionNotify:
{
if (!win->IsEnabled())
return false;
// Here we check if the top level window is
// disabled, which is one aspect of modality.
wxWindow *tlw = win;
while (tlw && !tlw->IsTopLevel())
tlw = tlw->GetParent();
if (tlw && !tlw->IsEnabled())
return false;
if (event->type == ButtonPress)
{
if ((win != wxWindow::FindFocus()) && win->AcceptsFocus())
{
// This might actually be done in wxWindow::SetFocus()
// and not here. TODO.
g_prevFocus = wxWindow::FindFocus();
g_nextFocus = win;
wxLogTrace( _T("focus"), _T("About to call SetFocus on %s of type %s due to button press"), win->GetName().c_str(), win->GetClassInfo()->GetClassName() );
// Record the fact that this window is
// getting the focus, because we'll need to
// check if its parent is getting a bogus
// focus and duly ignore it.
// TODO: may need to have this code in SetFocus, too.
extern wxWindow* g_GettingFocus;
g_GettingFocus = win;
win->SetFocus();
}
}
#if !wxUSE_NANOX
if (event->type == LeaveNotify || event->type == EnterNotify)
{
// Throw out NotifyGrab and NotifyUngrab
if (event->xcrossing.mode != NotifyNormal)
return false;
}
#endif
wxMouseEvent wxevent;
wxTranslateMouseEvent(wxevent, win, window, event);
return win->GetEventHandler()->ProcessEvent( wxevent );
}
case FocusIn:
#if !wxUSE_NANOX
if ((event->xfocus.detail != NotifyPointer) &&
(event->xfocus.mode == NotifyNormal))
#endif
{
wxLogTrace( _T("focus"), _T("FocusIn from %s of type %s"), win->GetName().c_str(), win->GetClassInfo()->GetClassName() );
extern wxWindow* g_GettingFocus;
if (g_GettingFocus && g_GettingFocus->GetParent() == win)
{
// Ignore this, this can be a spurious FocusIn
// caused by a child having its focus set.
g_GettingFocus = NULL;
wxLogTrace( _T("focus"), _T("FocusIn from %s of type %s being deliberately ignored"), win->GetName().c_str(), win->GetClassInfo()->GetClassName() );
return true;
}
else
{
wxFocusEvent focusEvent(wxEVT_SET_FOCUS, win->GetId());
focusEvent.SetEventObject(win);
focusEvent.SetWindow( g_prevFocus );
g_prevFocus = NULL;
return win->GetEventHandler()->ProcessEvent(focusEvent);
}
}
return false;
case FocusOut:
#if !wxUSE_NANOX
if ((event->xfocus.detail != NotifyPointer) &&
(event->xfocus.mode == NotifyNormal))
#endif
{
wxLogTrace( _T("focus"), _T("FocusOut from %s of type %s"), win->GetName().c_str(), win->GetClassInfo()->GetClassName() );
wxFocusEvent focusEvent(wxEVT_KILL_FOCUS, win->GetId());
focusEvent.SetEventObject(win);
focusEvent.SetWindow( g_nextFocus );
g_nextFocus = NULL;
return win->GetEventHandler()->ProcessEvent(focusEvent);
}
return false;
#ifdef __WXDEBUG__
default:
//wxString eventName = wxGetXEventName(XEvent& event);
//wxLogDebug(wxT("Event %s not handled"), eventName.c_str());
break;
#endif // __WXDEBUG__
}
return false;
}
/**
* Retrieves the data from a certain source Atom using a specific
* format.
*
* \param source The currently active clipboard Atom to get the data from.
* \param format The format of the data to get.
* \param length Out parameter that contains the length of the returned
* buffer.
* \return The requested content or NULL in case no content exists or an
* error occured.
*/
static int
_get_data_as (Atom source, Atom format, char **data, unsigned int *size)
{
Window owner;
time_t start;
Atom sel_type;
int sel_format;
unsigned long nbytes, overflow;
*size = 0;
unsigned char *src;
unsigned long offset = 0;
unsigned long chunk = 0;
int step = 1;
XEvent ev;
Time timestamp;
/* If we are the owner, simply return the clip buffer, if it matches
* the request type.
*/
if (!scrap_lost_x11 ())
{
char *fmt;
fmt = _atom_to_string (format);
/* TODO */
free (fmt);
return 1;
}
Lock_Display ();
/* Find a selection owner. */
owner = _get_scrap_owner (&source);
if (owner == None)
{
Unlock_Display ();
SDL_SetError ("no clipboard owner found");
return 0;
}
timestamp = (source == XA_PRIMARY) ? _selectiontime : _cliptime;
/* Copy and convert the selection into our SDL_SELECTION atom of the
* window.
* Flush afterwards, so we have an immediate effect and do not receive
* the old buffer anymore.
*/
XConvertSelection (_sdldisplay, source, format, _atom_SDL, _sdlwindow,
timestamp);
XSync (_sdldisplay, False);
/* Let's wait for the SelectionNotify event from the callee and
* react upon it as soon as it is received.
*/
for (start = time (0);;)
{
if (XCheckTypedWindowEvent (_sdldisplay, _sdlwindow,
SelectionNotify, &ev))
break;
if (time (0) - start >= 5)
{
/* Timeout, damn. */
Unlock_Display ();
SDL_SetError ("timeout on retrieving the clipboard data");
return 0;
}
}
/* Get any property type and check the sel_type afterwards to decide
* what to do.
*/
if (XGetWindowProperty (_sdldisplay, ev.xselection.requestor, _atom_SDL,
0, 0, True, AnyPropertyType, &sel_type, &sel_format, &nbytes,
&overflow, &src) != Success)
{
XFree (src);
Unlock_Display ();
SDL_SetError ("could not receive clipboard buffer");
return 0;
}
/* In case we requested a SCRAP_TEXT, any property type of
* XA_STRING, XA_COMPOUND_TEXT, UTF8_STRING and TEXT is valid.
*/
if (format == _atom_MIME_PLAIN &&
(sel_type != _atom_UTF8 && sel_type != _atom_TEXT
&& sel_type != _atom_COMPOUND && sel_type != XA_STRING))
{
/* No matching text type found. Return nothing then. */
XFree (src);
Unlock_Display ();
SDL_SetError ("text format not found");
return 0;
}
/* Anything is fine, so copy the buffer and return it. */
switch (sel_format)
{
case 16:
step = sizeof (short) / 2;
break;
case 32:
step = sizeof (long) / 4;
break;
case 8:
default:
step = sizeof (char);
*size = overflow; /* 8 bit size is already correctly set in nbytes.*/
break;
}
/* X11 guarantees NULL termination, add an extra byte. */
*size = step * overflow;
*data = malloc (*size + 1);
if (*data)
{
unsigned long boffset = 0;
chunk = MAX_CHUNK_SIZE(_sdldisplay);
memset (*data, 0, (size_t) (*size + 1));
/* Read as long as there is data. */
while (overflow)
{
if (XGetWindowProperty (_sdldisplay, ev.xselection.requestor,
_atom_SDL, offset, chunk, True, AnyPropertyType, &sel_type,
&sel_format, &nbytes, &overflow, &src) != Success)
{
break;
}
offset += nbytes / (32 / sel_format);
nbytes *= step * sel_format / 8;
memcpy ((*data) + boffset, src, nbytes);
boffset += nbytes;
XFree (src);
}
}
else
{
/* ENOMEM */
SDL_SetError ("could not allocate memory");
return 0;
}
/* In case we've got a COMPOUND_TEXT, convert it to the current
* multibyte locale.
*/
if (sel_type == _atom_COMPOUND && sel_format == 8)
{
char **list = NULL;
int count, status = 0;
XTextProperty p;
p.encoding = sel_type;
p.format = sel_format;
p.nitems = nbytes;
p.value = (unsigned char*)(*data);
status = XmbTextPropertyToTextList (_sdldisplay, &p, &list, &count);
if (status == XLocaleNotSupported || status == XConverterNotFound)
{
free (*data);
SDL_SetError ("current locale is not supported for conversion.");
return 0;
}
else if (status == XNoMemory)
{
free (*data);
SDL_SetError ("could not allocate memory");
return 0;
}
else if (status == Success)
{
if (count && list)
{
int i = 0;
int ioffset = 0;
char *tmp;
free (*data);
*data = NULL;
for (i = 0; i < count; i++)
{
*size = strlen (list[i]);
tmp = *data;
*data = realloc (*data, (*size) + 1);
if (!(*data))
{
free (tmp);
SDL_SetError ("could not allocate memory");
return 0;
}
ioffset += *size;
memcpy (*data, list[i], *size);
memset ((*data) + ioffset, '\n', 1);
}
memset ((*data) + ioffset, 0, 1);
}
}
if (list)
XFreeStringList (list);
}
Unlock_Display ();
return 1;
}
int
scrap_put_x11 (char *type, char *data, unsigned int size)
{
Atom clip, cliptype;
Time timestamp = CurrentTime;
time_t start;
XEvent ev;
Lock_Display ();
clip = GET_CLIPATOM (_currentmode);
cliptype = _convert_format (type);
/* We've some types which should not be set by the user. */
if (cliptype == _atom_TARGETS || cliptype == _atom_SDL ||
cliptype == _atom_TIMESTAMP)
{
SDL_SetError ("the requested format type is reserved");
Unlock_Display ();
return -1;
}
/* Update the clipboard property with the buffer. */
XChangeProperty (_sdldisplay, _sdlwindow, clip, cliptype, 8,
PropModeReplace, (unsigned char *) data, (int) size);
_add_clip_data (cliptype, data, size);
if (cliptype == _atom_MIME_PLAIN)
{
/* Set SCRAP_FORMAT_TEXT. Also set XA_STRING, TEXT and
* UTF8_STRING if they are not set in the dictionary.
*/
_add_clip_data (XA_STRING, data, size);
_add_clip_data (_atom_UTF8, data, size);
_add_clip_data (_atom_TEXT, data, size);
}
XSync (_sdldisplay, False);
/* Update the timestamp */
for (start = time (0);;)
{
if (XCheckTypedWindowEvent (_sdldisplay, _sdlwindow, PropertyNotify,
&ev))
break;
if (time (0) - start >= 5)
{
/* Timeout, damn. */
Unlock_Display ();
goto SETSELECTIONOWNER;
}
}
if (ev.xproperty.atom == clip)
{
timestamp = ev.xproperty.time;
if (cliptype == XA_PRIMARY)
_selectiontime = timestamp;
else
_cliptime = timestamp;
}
else
timestamp = (cliptype == XA_PRIMARY) ? _selectiontime : _cliptime;
SETSELECTIONOWNER:
/* Set the selection owner to the own window. */
XSetSelectionOwner (_sdldisplay, clip, _sdlwindow, timestamp);
if (XGetSelectionOwner (_sdldisplay, clip) != _sdlwindow)
{
/* Ouch, we could not toggle the selection owner. Raise an
* error, as it's not guaranteed, that the clipboard
* contains valid data.
*/
Unlock_Display ();
SDL_SetError ("could not set the proper owner for the clipboard");
return -1;
}
Unlock_Display ();
return 1;
}
char *osd_get_clipboard_text(void)
{
SDL_SysWMinfo info;
Display* display;
Window our_win;
Window selection_win;
Atom data_type;
int data_format;
unsigned long nitems;
unsigned long bytes_remaining;
unsigned char* prop;
char* result;
XEvent event;
Uint32 t0, t1;
Atom types[2];
int i;
/* get & validate SDL sys-wm info */
SDL_VERSION(&info.version);
if ( ! SDL_GetWMInfo( &info ) )
return NULL;
if ( info.subsystem != SDL_SYSWM_X11 )
return NULL;
if ( (display = info.info.x11.display) == NULL )
return NULL;
if ( (our_win = info.info.x11.window) == None )
return NULL;
/* request data to owner */
selection_win = XGetSelectionOwner( display, XA_PRIMARY );
if ( selection_win == None )
return NULL;
/* first, try UTF-8, then latin-1 */
types[0] = XInternAtom( display, "UTF8_STRING", False );
types[1] = XA_STRING; /* latin-1 */
for ( i = 0; i < ARRAY_LENGTH(types); i++ )
{
XConvertSelection( display, XA_PRIMARY, types[i], types[i], our_win, CurrentTime );
/* wait for SelectionNotify, but no more than 100 ms */
t0 = t1 = SDL_GetTicks();
while ( 1 )
{
if ( XCheckTypedWindowEvent( display, our_win, SelectionNotify, &event ) ) break;
SDL_Delay( 1 );
t1 = SDL_GetTicks();
if ( t1 - t0 > 100 )
return NULL;
}
if ( event.xselection.property == None )
continue;
/* get property & check its type */
if ( XGetWindowProperty( display, our_win, types[i], 0, 65536, False, types[i],
&data_type, &data_format, &nitems, &bytes_remaining, &prop )
!= Success )
continue;
if ( ! prop )
continue;
if ( (data_format != 8) || (data_type != types[i]) )
{
XFree( prop );
continue;
}
/* return a copy & free original */
if (prop != NULL)
{
result = (char *) osd_malloc_array(strlen((char *)prop)+1);
strcpy(result, (char *)prop);
}
else
result = NULL;
XFree( prop );
return result;
}
return NULL;
}
void
gui_main_loop (void)
{
XEvent event;
struct gui_instance *gi;
while (0 == XNextEvent (GUI_display, &event))
{
if (0 == (gi = find_instance (event.xany.window)))
continue;
if (XFilterEvent (&event, gi->window))
continue;
if (gi->definition.x11_event)
gi->definition.x11_event (gi, &event);
switch (event.type)
{
case KeyPress:
gi->last_event = event.xkey.time;
if (gi->definition.key_pressed)
{
wchar_t text[32];
Status status;
KeySym key_sym;
int len;
len = XwcLookupString (gi->xic, &event.xkey, text, sizeof (text) / sizeof (text[0]) - 1, &key_sym, &status);
text[len] = 0;
if (status == XLookupNone)
return;
gi->definition.key_pressed (gi,
(status == XLookupKeySym || status == XLookupBoth) ? key_sym : 0,
(status == XLookupChars || status == XLookupBoth) ? text : NULL,
event.xkey.state);
}
break;
case KeyRelease:
gi->last_event = event.xkey.time;
if (gi->definition.key_released)
{
KeySym key_sym;
key_sym = XLookupKeysym (&event.xkey, 0);
gi->definition.key_released (gi, key_sym);
}
break;
case MotionNotify:
gi->last_event = event.xmotion.time;
if (gi->definition.mouse_moved)
gi->definition.mouse_moved (gi, event.xmotion.x,
event.xmotion.y);
break;
case ButtonPress:
gi->last_event = event.xbutton.time;
if (gi->definition.button_pressed)
gi->definition.button_pressed (gi, event.xbutton.button - 1,
event.xbutton.state);
break;
case ButtonRelease:
gi->last_event = event.xbutton.time;
if (gi->definition.button_released)
gi->definition.button_released (gi, event.xbutton.button - 1,
event.xbutton.state);
break;
case ConfigureNotify:
while (XCheckTypedWindowEvent (GUI_display, gi->window, ConfigureNotify, &event))
{
/* Do nothing */
}
if (gi->width == event.xconfigure.width && gi->height == event.xconfigure.height)
break;
gi->width = event.xconfigure.width;
gi->height = event.xconfigure.height;
configure_window (gi);
XClearArea (GUI_display, gi->window, 0, 0, 0, 0, True);
break;
case NoExpose:
break;
case Expose:
{
int minx = event.xexpose.x;
int miny = event.xexpose.y;
int maxx = minx + event.xexpose.width;
int maxy = miny + event.xexpose.height;
while (XCheckTypedWindowEvent (GUI_display, gi->window, Expose, &event))
{
if (event.xexpose.x < minx) minx = event.xexpose.x;
if (event.xexpose.y < miny) miny = event.xexpose.y;
if (event.xexpose.x + event.xexpose.width > maxx) maxx = event.xexpose.x + event.xexpose.width;
if (event.xexpose.y + event.xexpose.height > maxx) maxx = event.xexpose.y + event.xexpose.height;
}
gi->repaint_waiting = 0;
if (!gi->back_buffer)
configure_window (gi);
gi->definition.paint (gi, minx, miny, maxx - minx, maxy - miny);
XRenderComposite (GUI_display, PictOpSrc, gi->back_buffer, None,
gi->front_buffer, minx, miny, 0, 0, minx, miny,
maxx - minx, maxy - miny);
}
break;
case ClientMessage:
if (event.xclient.data.l[0] == xa_wm_delete_window)
gi->definition.destroy (gi);
break;
case SelectionRequest:
{
XSelectionRequestEvent* request;
XSelectionEvent response;
enum gui_clipboard clipboard;
int ret;
request = &event.xselectionrequest;
if (request->selection == XA_PRIMARY)
clipboard = GUI_PRIMARY_SELECTION;
else if (request->selection == XA_SECONDARY)
clipboard = GUI_SECONDARY_SELECTION;
else if (request->selection == xa_clipboard)
clipboard = GUI_CLIPBOARD;
else
break;
if (!gi->clipboards[clipboard].length)
break;
if (request->target != XA_STRING
&& request->target != xa_utf8_string)
break;
if (request->property == None)
request->property = request->target;
response.type = SelectionNotify;
response.send_event = True;
response.display = GUI_display;
response.requestor = request->requestor;
response.selection = request->selection;
response.target = request->target;
response.property = None;
response.time = request->time;
ret = XChangeProperty (GUI_display, request->requestor,
request->property, request->target,
8, PropModeReplace,
gi->clipboards[clipboard].data,
gi->clipboards[clipboard].length);
if (ret != BadAlloc && ret != BadAtom
&& ret != BadValue && ret != BadWindow)
response.property = request->property;
XSendEvent (request->display, request->requestor, False,
NoEventMask, (XEvent*) &response);
}
break;
case SelectionNotify:
{
unsigned char* prop;
unsigned long nitems, bytes_after;
Atom type;
int format, result;
result = XGetWindowProperty (GUI_display, gi->window,
xa_prop_paste, 0, 0, False,
AnyPropertyType, &type, &format,
&nitems, &bytes_after, &prop);
if (result != Success)
break;
XFree (prop);
result = XGetWindowProperty (GUI_display, gi->window,
xa_prop_paste, 0, bytes_after,
False, AnyPropertyType, &type,
&format, &nitems, &bytes_after,
&prop);
if (result != Success)
break;
if (gi->definition.paste
&& type == xa_utf8_string && format == 8)
{
gi->definition.paste (gi, (const char*) prop, nitems);
}
XFree (prop);
}
break;
}
}
}
main(int argc, char * argv [])
{
Display * sdpy = XOpenDisplay(argv[1]);
Display * tdpy = XOpenDisplay(argv[2]);
int sscr = XDefaultScreen(sdpy);
int tscr = XDefaultScreen(tdpy);
GC tgc = DefaultGC(tdpy,tscr);
Window swin=RootWindow (sdpy,sscr);
int width, height, dummy;
XGetGeometry(sdpy, swin, (Window *)&dummy, &dummy, &dummy, &width, &height, &dummy, &dummy);
Window twin=CreateWindow(tdpy,tscr,width,height);
XSelectInput(sdpy, swin, PointerMotionMask);
XImage * image;
XImage * simage;
XImage * timage;
int use_shm=1;
XShmSegmentInfo xshm_sinfo;
XShmSegmentInfo xshm_tinfo;
if(use_shm) createShmImage(width,height,&xshm_sinfo,&xshm_tinfo,sdpy,tdpy,sscr,tscr,&simage,&timage);
int frame=0;
for(;;) {
XEvent e;
XNextEvent(tdpy, &e);
if (e.type == MapNotify)
break;
}
int emulate_events=0;
int xmouse, ymouse;
while(1)
{
{
XEvent e;
//long mask=ButtonPressMask|ButtonReleaseMask|MotionNotifyMask;
//while(XCheckWindowEvent(tdpy, twin, mask, &e)!=False)
while(XCheckTypedWindowEvent(tdpy, twin, ButtonPress, &e)!=False ||
XCheckTypedWindowEvent(tdpy, twin, ButtonRelease, &e)!=False)
{
printf("button event\n");
if(emulate_events)
{
e.xbutton.display=sdpy;
e.xbutton.window=swin;
e.xbutton.root=swin;
e.xbutton.window=swin;
e.xbutton.x_root=e.xbutton.x;
e.xbutton.y_root=e.xbutton.y;
//XSendEvent( sdpy, swin, True, mask, &e );
XPutBackEvent( sdpy, &e );
//XTestFakeMotionEvent(sdpy,sscr,e.xbutton.x,e.xbutton.y,0);
XTestFakeButtonEvent(sdpy,e.xbutton.button,e.xbutton.type==ButtonPress,0);
}
}
while(XCheckTypedWindowEvent(sdpy, swin, MotionNotify, &e)!=False)
{
//printf("motion event\n");
xmouse=e.xbutton.x_root;
ymouse=e.xbutton.y_root;
}
}
//printf("frame %d\n", frame++);
usleep(60000);
if(!use_shm)
{
image=CaptRoot(sdpy,sscr);
DrawImage(tdpy,twin,image);
XDestroyImage(image);
}
else
{
// XShmAttach(sdpy, &xshm_sinfo);
XShmGetImage (sdpy, swin, simage, 0, 0, AllPlanes);
// XShmAttach(sdpy, &xshm_tinfo);
//printf("simage: w:%d h:%d d:%d\n",simage->width, simage->height, simage->depth);
//printf("timage: w:%d h:%d d:%d\n",timage->width, timage->height, timage->depth);
if(!emulate_events)
{
Window rwin,cwin;
int xmouse,ymouse,x,y,mask;
XQueryPointer(sdpy,swin,&rwin,&cwin,&xmouse,&ymouse,&x,&y,&mask);
drawMouse(timage, xmouse, ymouse);
}
XShmPutImage (tdpy, twin, tgc, timage, 0, 0, 0, 0, timage->width, timage->height, False);
//XPutImage (tdpy, twin, tgc, timage, 0, 0, 0, 0, timage->width, timage->height);
}
//XFlush(sdpy);
XFlush(tdpy);
// getchar();
}
}
Bool wsEvents( Display * display,XEvent * Event,XPointer arg )
{
unsigned long i = 0;
int l;
int x,y;
Window child_window = 0;
l=wsSearch( Event->xany.window );
if ( l == -1 ) return !wsTrue;
wsWindowList[l]->State=0;
switch( Event->type )
{
case ClientMessage:
if ( Event->xclient.message_type == wsWindowList[l]->AtomProtocols )
{
if ( (Atom)Event->xclient.data.l[0] == wsWindowList[l]->AtomDeleteWindow )
{ i=wsWindowClosed; goto expose; }
if ( (Atom)Event->xclient.data.l[0] == wsWindowList[l]->AtomTakeFocus )
{ i=wsWindowFocusIn; wsWindowList[l]->Focused=wsFocused; goto expose; }
if ( (Atom)Event->xclient.data.l[0] == wsWindowList[l]->AtomRolle )
{ mp_msg( MSGT_GPLAYER,MSGL_V,"[ws] role set.\n" ); }
} else {
/* try to process DND events */
wsXDNDProcessClientMessage(wsWindowList[l],&Event->xclient);
}
break;
case MapNotify: i=wsWindowMapped; wsWindowList[l]->Mapped=wsMapped; goto expose;
case UnmapNotify: i=wsWindowUnmapped; wsWindowList[l]->Mapped=wsNone; goto expose;
case FocusIn:
if ( wsWindowList[l]->Focused == wsFocused ) break;
i=wsWindowFocusIn;
wsWindowList[l]->Focused=wsFocused;
goto expose;
case FocusOut:
if ( wsWindowList[l]->Focused == wsNone ) break;
i=wsWindowFocusOut;
wsWindowList[l]->Focused=wsNone;
goto expose;
case VisibilityNotify:
switch( Event->xvisibility.state )
{
case VisibilityUnobscured: i=wsWindowVisible; wsWindowList[l]->Visible=wsVisible; goto expose;
case VisibilityFullyObscured: i=wsWindowNotVisible; wsWindowList[l]->Visible=wsNotVisible; goto expose;
case VisibilityPartiallyObscured: i=wsWindowPartialVisible; wsWindowList[l]->Visible=wsPVisible; goto expose;
}
expose:
wsWindowList[l]->State=i;
if ( wsWindowList[l]->ReDraw ) wsWindowList[l]->ReDraw();
break;
case Expose:
wsWindowList[l]->State=wsWindowExpose;
if ( ( wsWindowList[l]->ReDraw )&&( !Event->xexpose.count ) ) wsWindowList[l]->ReDraw();
break;
case ConfigureNotify:
XTranslateCoordinates( wsDisplay,wsWindowList[l]->WindowID,wsRootWin,0,0,&x,&y,&child_window );
if ( ( wsWindowList[l]->X != x )||( wsWindowList[l]->Y != y )||( wsWindowList[l]->Width != Event->xconfigure.width )||( wsWindowList[l]->Height != Event->xconfigure.height ) )
{
wsWindowList[l]->X=x; wsWindowList[l]->Y=y;
wsWindowList[l]->Width=Event->xconfigure.width; wsWindowList[l]->Height=Event->xconfigure.height;
if ( wsWindowList[l]->ReSize ) wsWindowList[l]->ReSize( wsWindowList[l]->X,wsWindowList[l]->Y,wsWindowList[l]->Width,wsWindowList[l]->Height );
}
wsWindowList[l]->Rolled=wsNone;
if ( Event->xconfigure.y < 0 )
{ i=wsWindowRolled; wsWindowList[l]->Rolled=wsRolled; goto expose; }
break;
case KeyPress: i=wsKeyPressed; goto keypressed;
case KeyRelease: i=wsKeyReleased;
keypressed:
wsWindowList[l]->Alt=0;
wsWindowList[l]->Shift=0;
wsWindowList[l]->NumLock=0;
wsWindowList[l]->Control=0;
wsWindowList[l]->CapsLock=0;
if ( Event->xkey.state & Mod1Mask ) wsWindowList[l]->Alt=1;
if ( Event->xkey.state & Mod2Mask ) wsWindowList[l]->NumLock=1;
if ( Event->xkey.state & ControlMask ) wsWindowList[l]->Control=1;
if ( Event->xkey.state & ShiftMask ) wsWindowList[l]->Shift=1;
if ( Event->xkey.state & LockMask ) wsWindowList[l]->CapsLock=1;
#if 0
{
KeySym keySym;
keySym=XKeycodeToKeysym( wsDisplay,Event->xkey.keycode,0 );
if ( keySym != NoSymbol )
{
keySym=( (keySym&0xff00) != 0?( (keySym&0x00ff) + 256 ):( keySym ) );
wsKeyTable[ keySym ]=i;
if ( wsWindowList[l]->KeyHandler )
wsWindowList[l]->KeyHandler( Event->xkey.state,i,keySym );
}
}
#else
{
int key;
char buf[100];
KeySym keySym;
static XComposeStatus stat;
XLookupString( &Event->xkey,buf,sizeof(buf),&keySym,&stat );
key=( (keySym&0xff00) != 0?( (keySym&0x00ff) + 256 ):( keySym ) );
wsKeyTable[ key ]=i;
if ( wsWindowList[l]->KeyHandler ) wsWindowList[l]->KeyHandler( Event->xkey.keycode,i,key );
}
#endif
break;
case MotionNotify:
i=wsMoveMouse;
{
/* pump all motion events from the display queue:
this way it works faster when moving the window */
static XEvent e;
if ( Event->xmotion.state )
{
while(XCheckTypedWindowEvent(display,Event->xany.window,MotionNotify,&e)){
/* FIXME: need to make sure we didn't release/press the button in between...*/
/* FIXME: do we need some timeout here to make sure we don't spend too much time
removing events from the queue? */
Event = &e;
}
}
}
goto buttonreleased;
case ButtonRelease: i=Event->xbutton.button + 128; goto buttonreleased;
case ButtonPress: i=Event->xbutton.button; goto buttonreleased;
case EnterNotify: i=wsEnterWindow; goto buttonreleased;
case LeaveNotify: i=wsLeaveWindow;
buttonreleased:
if ( wsWindowList[l]->MouseHandler )
wsWindowList[l]->MouseHandler( i,Event->xbutton.x,Event->xbutton.y,Event->xmotion.x_root,Event->xmotion.y_root );
break;
case SelectionNotify:
/* Handle DandD */
wsXDNDProcessSelection(wsWindowList[l],Event);
break;
}
XFlush( wsDisplay );
XSync( wsDisplay,False );
return !wsTrue;
}
static void feh_event_handle_MotionNotify(XEvent * ev)
{
winwidget winwid = NULL;
int dx, dy;
int scr_width, scr_height;
scr_width = scr->width;
scr_height = scr->height;
#ifdef HAVE_LIBXINERAMA
if (opt.xinerama && xinerama_screens) {
scr_width = xinerama_screens[xinerama_screen].width;
scr_height = xinerama_screens[xinerama_screen].height;
}
#endif /* HAVE_LIBXINERAMA */
if (menu_root) {
feh_menu *m;
feh_menu_item *selected_item, *mouseover_item;
D(("motion notify with menus open\n"));
while (XCheckTypedWindowEvent(disp, ev->xmotion.window, MotionNotify, ev));
if (ev->xmotion.window == menu_cover) {
return;
} else if ((m = feh_menu_get_from_window(ev->xmotion.window))) {
selected_item = feh_menu_find_selected(m);
mouseover_item = feh_menu_find_at_xy(m, ev->xmotion.x, ev->xmotion.y);
if (selected_item != mouseover_item) {
D(("selecting a menu item\n"));
if (selected_item)
feh_menu_deselect_selected(m);
if ((mouseover_item)
&& ((mouseover_item->action)
|| (mouseover_item->submenu)
|| (mouseover_item->func_gen_sub)))
feh_menu_select(m, mouseover_item);
}
/* check if we are close to the right and/or the bottom edge of the
* screen. If so, and if the menu we are currently over is partially
* hidden, slide the menu to the left and/or up until it is
* fully visible */
/* FIXME: get this working nicely with xinerama screen edges --
* at the moment it does really funky stuff with
* scr_{width,height} instead of scr->{width,height} -- pabs*/
if (mouseover_item
&& ((scr->width - (ev->xmotion.x + m->x)) <
m->w || (scr->height - (ev->xmotion.y + m->y)) < m->w)) {
dx = scr_width - (m->x + m->w);
dy = scr_height - (m->y + m->h);
dx = dx < 0 ? dx : 0;
dy = dy < 0 ? dy : 0;
if (dx || dy)
feh_menu_slide_all_menus_relative(dx, dy);
}
/* if a submenu is open we want to see that also */
if (mouseover_item && m->next && ((scr->width - (ev->xmotion.x + m->next->x))
< m->next->w
|| (scr->height -
(ev->xmotion.y + m->next->y)) < m->next->w)) {
dx = scr->width - (m->next->x + m->next->w);
dy = scr->height - (m->next->y + m->next->h);
dx = dx < 0 ? dx : 0;
dy = dy < 0 ? dy : 0;
if (dx || dy)
feh_menu_slide_all_menus_relative(dx, dy);
}
}
} else if (opt.mode == MODE_ZOOM) {
while (XCheckTypedWindowEvent(disp, ev->xmotion.window, MotionNotify, ev));
winwid = winwidget_get_from_window(ev->xmotion.window);
if (winwid) {
if (ev->xmotion.x > winwid->click_offset_x)
winwid->zoom = winwid->old_zoom + (
((double) ev->xmotion.x - (double) winwid->click_offset_x)
/ 128.0);
else
winwid->zoom = winwid->old_zoom - (
((double) winwid->click_offset_x - (double) ev->xmotion.x)
/ 128.0);
if (winwid->zoom < ZOOM_MIN)
winwid->zoom = ZOOM_MIN;
else if (winwid->zoom > ZOOM_MAX)
winwid->zoom = ZOOM_MAX;
/* center around click_offset */
winwid->im_x = winwid->click_offset_x
- (winwid->im_click_offset_x * winwid->zoom);
winwid->im_y = winwid->click_offset_y
- (winwid->im_click_offset_y * winwid->zoom);
winwidget_render_image(winwid, 0, 1);
}
} else if ((opt.mode == MODE_PAN) || (opt.mode == MODE_NEXT)) {
int orig_x, orig_y;
while (XCheckTypedWindowEvent(disp, ev->xmotion.window, MotionNotify, ev));
winwid = winwidget_get_from_window(ev->xmotion.window);
if (winwid) {
if (opt.mode == MODE_NEXT) {
if ((abs(winwid->click_offset_x - (ev->xmotion.x - winwid->im_x)) > FEH_JITTER_OFFSET)
|| (abs(winwid->click_offset_y - (ev->xmotion.y - winwid->im_y)) > FEH_JITTER_OFFSET)
|| (time(NULL) - winwid->click_start_time > FEH_JITTER_TIME)) {
opt.mode = MODE_PAN;
winwid->mode = MODE_PAN;
}
else
return;
}
D(("Panning\n"));
orig_x = winwid->im_x;
orig_y = winwid->im_y;
winwid->im_x = ev->xmotion.x - winwid->click_offset_x;
winwid->im_y = ev->xmotion.y - winwid->click_offset_y;
winwidget_sanitise_offsets(winwid);
D(("im_x %d, im_w %d, off %d, mx %d, my %d\n", winwid->im_x,
winwid->im_w, winwid->click_offset_x, ev->xmotion.x,
ev->xmotion.y));
/* XWarpPointer generates a MotionNotify event which we will
* parse. Since that event would undo the effect of the pointer
* warp, we need to change the click_offset to compensate this.
*/
if ((winwid->w - ev->xmotion.x <= 1) && (winwid->im_x < 0))
{
XWarpPointer(disp, None, winwid->win, 0, 0, 0, 0, 3,
ev->xmotion.y);
winwid->click_offset_x -= winwid->w - 4;
}
// TODO needlessly warps for certain zoom levels
else if ((ev->xmotion.x <= 1) && (winwid->im_x >
(winwid->w - winwid->im_w * winwid->zoom)))
{
XWarpPointer(disp, None, winwid->win, 0, 0, 0, 0,
winwid->w - 4, ev->xmotion.y);
winwid->click_offset_x += winwid->w - 4;
}
else if ((winwid->h - ev->xmotion.y <= 1)
&& (winwid->im_y < 0))
{
XWarpPointer(disp, None, winwid->win, 0, 0, 0, 0,
ev->xmotion.x, 3);
winwid->click_offset_y -= winwid->h - 4;
}
// TODO needlessly warps for certain zoomlevels
else if ((ev->xmotion.y <= 1) && (winwid->im_y >
(winwid->h - winwid->im_h * winwid->zoom)))
{
XWarpPointer(disp, None, winwid->win, 0, 0, 0, 0,
ev->xmotion.x, winwid->h - 4);
winwid->click_offset_y += winwid->h - 4;
}
if ((winwid->im_x != orig_x)
|| (winwid->im_y != orig_y))
winwidget_render_image(winwid, 0, 1);
}
} else if (opt.mode == MODE_ROTATE) {
while (XCheckTypedWindowEvent(disp, ev->xmotion.window, MotionNotify, ev));
winwid = winwidget_get_from_window(ev->xmotion.window);
if (winwid) {
D(("Rotating\n"));
if (!winwid->has_rotated) {
Imlib_Image temp;
temp = gib_imlib_create_rotated_image(winwid->im, 0.0);
winwid->im_w = gib_imlib_image_get_width(temp);
winwid->im_h = gib_imlib_image_get_height(temp);
gib_imlib_free_image_and_decache(temp);
if (!winwid->full_screen && !opt.geom_flags)
winwidget_resize(winwid, winwid->im_w, winwid->im_h);
winwid->has_rotated = 1;
}
winwid->im_angle = (ev->xmotion.x - winwid->w / 2) / ((double) winwid->w / 2) * 3.1415926535;
D(("angle: %f\n", winwid->im_angle));
winwidget_render_image(winwid, 0, 1);
}
} else if (opt.mode == MODE_BLUR) {
while (XCheckTypedWindowEvent(disp, ev->xmotion.window, MotionNotify, ev));
winwid = winwidget_get_from_window(ev->xmotion.window);
if (winwid) {
Imlib_Image temp, ptr;
signed int blur_radius;
D(("Blurring\n"));
temp = gib_imlib_clone_image(winwid->im);
blur_radius = (((double) ev->xmotion.x / winwid->w) * 20) - 10;
D(("angle: %d\n", blur_radius));
if (blur_radius > 0)
gib_imlib_image_sharpen(temp, blur_radius);
else
gib_imlib_image_blur(temp, 0 - blur_radius);
ptr = winwid->im;
winwid->im = temp;
winwidget_render_image(winwid, 0, 1);
gib_imlib_free_image_and_decache(winwid->im);
winwid->im = ptr;
}
} else {
while (XCheckTypedWindowEvent(disp, ev->xmotion.window, MotionNotify, ev));
winwid = winwidget_get_from_window(ev->xmotion.window);
if ((winwid != NULL) && (winwid->type == WIN_TYPE_THUMBNAIL)) {
feh_thumbnail *thumbnail;
int x, y;
x = (ev->xbutton.x - winwid->im_x) / winwid->zoom;
y = (ev->xbutton.y - winwid->im_y) / winwid->zoom;
thumbnail = feh_thumbnail_get_thumbnail_from_coords(x, y);
feh_thumbnail_select(winwid, thumbnail);
}
}
return;
}
static void
handle_event(XEvent * event)
{
XWindowAttributes wa;
/* fprintf(stderr,"event:handle_event entered\n");*/
set_window(event->xany.window);
if (event->type == MotionNotify) {
/* fprintf(stderr,"event:handle_event type=MotionNotify\n");*/
handle_motion_event((XMotionEvent *)event);
motion = 1;
return;
}
make_busy_cursors();
switch (event->type) {
case DestroyNotify:
/* fprintf(stderr,"event:handle_event type=DestroyNotify\n");*/
break;
case Expose:
/* fprintf(stderr,"event:handle_event type=Expose\n");*/
XGetWindowAttributes(gXDisplay, gWindow->fMainWindow, &wa);
if ((gWindow->width == 0 && gWindow->height == 0) ||
(wa.width != gWindow->width || wa.height != gWindow->height)) {
gWindow->width = wa.width;
gWindow->height = wa.height;
display_page(gWindow->page);
gWindow->fWindowHashTable = gWindow->page->fLinkHashTable;
}
else /** just redraw the thing **/
expose_page(gWindow->page);
XFlush(gXDisplay);
clear_exposures(gWindow->fMainWindow);
clear_exposures(gWindow->fScrollWindow);
break;
case ButtonPress:
/* fprintf(stderr,"event:handle_event type=ButtonPress\n");*/
handle_button(event->xbutton.button, (XButtonEvent *)event);
XFlush(gXDisplay);
if (gWindow) {
while (XCheckTypedWindowEvent(gXDisplay, gWindow->fMainWindow,
Expose, event));
while (XCheckTypedWindowEvent(gXDisplay, gWindow->fScrollWindow,
Expose, event));
}
break;
case KeyPress:
/* fprintf(stderr,"event:handle_event type=KeyPress\n");*/
handle_key(event);
if (gWindow) {
while (XCheckTypedWindowEvent(gXDisplay, gWindow->fMainWindow,
Expose, event));
while (XCheckTypedWindowEvent(gXDisplay, gWindow->fScrollWindow,
Expose, event));
}
break;
case MapNotify:
/* fprintf(stderr,"event:handle_event type=MapNotify\n");*/
create_window();
break;
case SelectionNotify:
/* fprintf(stderr,"event:handle_event type=SelectionNotify\n");*/
/* this is in response to a previous request in an input area */
if ( gSavedInputAreaLink ) {
XSelectionEvent *pSelEvent;
Atom dataProperty;
pSelEvent = (XSelectionEvent *) event;
dataProperty = XInternAtom(gXDisplay, "PASTE_SELECTION", False);
/* change the input focus */
/* change_input_focus(gSavedInputAreaLink); */
/* try to get the selection as a window property */
if ( pSelEvent->requestor == gWindow->fMainWindow &&
pSelEvent->selection == XA_PRIMARY &&
/* pSelEvent->time == CurrentTime && */
pSelEvent->target == XA_STRING &&
pSelEvent->property == dataProperty )
{
Atom actual_type;
int actual_format;
unsigned long nitems, leftover;
unsigned char *pSelection = NULL;
if (Success == XGetWindowProperty(gXDisplay,
gWindow->fMainWindow,
pSelEvent->property, 0L, 100000000L, True,
AnyPropertyType, &actual_type, &actual_format,
&nitems, &leftover, (unsigned char **) &pSelection) )
{
char *pBuffer;
InputItem *item = gSavedInputAreaLink->reference.string;
for (pBuffer = pSelection; *pBuffer; ++pBuffer)
add_buffer_to_sym(pBuffer, item);
XFree(pSelection);
}
}
/* clear the link info */
gSavedInputAreaLink = NULL;
}
break;
default:
/* fprintf(stderr,"event:handle_event type=default\n");*/
break;
}
}
static void
ShowAlert(const char *title,
const char *ignore, const char *restart, const char *quit,
const char *fmt, va_list args)
{
char text[4096], buf1[64], buf2[64], buf3[64];
Window win, b1 = 0, b2 = 0, b3 = 0, root;
Display *dd;
int wid, hih, w, h, i, k, mask;
XGCValues gcv;
GC gc;
unsigned int len;
XEvent ev;
XSetWindowAttributes att;
XRectangle rect1, rect2;
char colorful;
unsigned long cols[5];
XColor xcl;
Colormap cmap;
int cnum, fh, x, y, ww, hh, bw, bh;
char *str1, *str2, *str3, *p;
KeyCode keycode;
int button;
char **missing_charset_list_return, *def_string_return;
int missing_charset_count_return;
XFontStruct **font_struct_list_return;
char **font_name_list_return;
#if 0
/* Don't play sound here (maybe if not forked/in signal handler - later) */
SoundPlay(SOUND_ALERT);
#endif
if (!fmt)
return;
Evsnprintf(text, sizeof(text), fmt, args);
/*
* We may get here from obscure places like an X-error or signal handler
* and things seem to work properly only if we do a new XOpenDisplay().
*/
dd = XOpenDisplay(NULL);
if (!dd)
{
fprintf(stderr, "%s\n", text);
fflush(stderr);
return;
}
button = 0;
if (!title)
title = _("Enlightenment Error");
str1 = AlertButtonText(1, buf1, sizeof(buf1), ignore);
str2 = AlertButtonText(2, buf2, sizeof(buf2), restart);
str3 = AlertButtonText(3, buf3, sizeof(buf3), quit);
cnum = 0;
colorful = 0;
cols[0] = cols[1] = cols[2] = cols[3] = cols[4] = 0;
cmap = DefaultColormap(dd, DefaultScreen(dd));
if (DefaultDepth(dd, DefaultScreen(dd)) > 4)
{
ExSetColor(&xcl, 220, 220, 220);
if (!XAllocColor(dd, cmap, &xcl))
goto CN;
cols[cnum++] = xcl.pixel;
ExSetColor(&xcl, 160, 160, 160);
if (!XAllocColor(dd, cmap, &xcl))
goto CN;
cols[cnum++] = xcl.pixel;
ExSetColor(&xcl, 100, 100, 100);
if (!XAllocColor(dd, cmap, &xcl))
goto CN;
cols[cnum++] = xcl.pixel;
ExSetColor(&xcl, 0, 0, 0);
if (!XAllocColor(dd, cmap, &xcl))
goto CN;
cols[cnum++] = xcl.pixel;
ExSetColor(&xcl, 255, 255, 255);
if (!XAllocColor(dd, cmap, &xcl))
goto CN;
cols[cnum++] = xcl.pixel;
colorful = 1;
}
CN:
if (colorful)
att.background_pixel = cols[1];
else
att.background_pixel = BlackPixel(dd, DefaultScreen(dd));
if (colorful)
att.border_pixel = cols[3];
else
att.border_pixel = WhitePixel(dd, DefaultScreen(dd));
att.backing_store = Always;
att.save_under = True;
att.override_redirect = True;
mask = CWBackPixel | CWBorderPixel | CWOverrideRedirect | CWSaveUnder |
CWBackingStore;
#if USE_COMPOSITE_OVERLAY_WINDOW
/*
* Intended workings:
* Composite extension not enabled (or COW not available?)
* - fall back to root
* Composite extension enabled
* - use COW whether or not compositing is enabled, window mode too
*/
root = XCompositeGetOverlayWindow(dd, DefaultRootWindow(dd));
if (root == None)
#endif
{
root = DefaultRootWindow(dd);
}
win = XCreateWindow(dd, root, -100, -100, 1, 1, 0,
CopyFromParent, InputOutput, CopyFromParent, mask, &att);
gc = XCreateGC(dd, win, 0, &gcv);
if (colorful)
XSetForeground(dd, gc, cols[3]);
else
XSetForeground(dd, gc, att.border_pixel);
xfs = XCreateFontSet(dd, "fixed",
&missing_charset_list_return,
&missing_charset_count_return, &def_string_return);
if (!xfs)
goto done;
if (missing_charset_list_return)
XFreeStringList(missing_charset_list_return);
k = XFontsOfFontSet(xfs, &font_struct_list_return, &font_name_list_return);
fh = 0;
for (i = 0; i < k; i++)
{
h = font_struct_list_return[i]->ascent +
font_struct_list_return[i]->descent;
if (fh < h)
fh = h;
}
XSelectInput(dd, win, ExposureMask);
XMapWindow(dd, win);
XGrabServer(dd);
XGrabPointer(dd, win, False, ButtonPressMask | ButtonReleaseMask,
GrabModeAsync, GrabModeAsync, None, None, CurrentTime);
XGrabKeyboard(dd, win, False, GrabModeAsync, GrabModeAsync, CurrentTime);
XSetInputFocus(dd, win, RevertToPointerRoot, CurrentTime);
XSync(dd, False);
wid = DisplayWidth(dd, DefaultScreen(dd));
hih = DisplayHeight(dd, DefaultScreen(dd));
ww = (wid >= 600) ? 600 : (wid / 40) * 40;
hh = (hih >= 440) ? 440 : (hih / 40) * 40;
for (i = 40; i < ww; i += 40)
{
w = i;
h = (i * hh) / ww;
x = (wid - w) >> 1;
y = (hih - h) >> 1;
XMoveResizeWindow(dd, win, x, y, w, h);
DRAW_BOX_OUT(dd, gc, win, 0, 0, w, h);
XSync(dd, False);
SleepUs(20000);
}
x = (wid - ww) >> 1;
y = (hih - hh) >> 1;
XMoveResizeWindow(dd, win, x, y, ww, hh);
XSync(dd, False);
bw = 0;
if (str1)
{
ExTextExtents(xfs, str1, strlen(str1), &rect1, &rect2);
bw = (rect2.width > bw) ? rect2.width : bw;
}
if (str2)
{
ExTextExtents(xfs, str2, strlen(str2), &rect1, &rect2);
bw = (rect2.width > bw) ? rect2.width : bw;
}
if (str3)
{
ExTextExtents(xfs, str3, strlen(str3), &rect1, &rect2);
bw = (rect2.width > bw) ? rect2.width : bw;
}
bw += 20;
bh = fh + 10;
#define BX(i) (5 + (((ww - bw - 10) * (i)) / 2))
#define BY (hh - bh - 5)
if (str1)
{
b1 = XCreateWindow(dd, win, BX(0), BY, bw, bh, 0, CopyFromParent,
InputOutput, CopyFromParent, mask, &att);
XMapWindow(dd, b1);
}
if (str2)
{
b2 = XCreateWindow(dd, win, BX(1), BY, bw, bh, 0, CopyFromParent,
InputOutput, CopyFromParent, mask, &att);
XMapWindow(dd, b2);
}
if (str3)
{
b3 = XCreateWindow(dd, win, BX(2), BY, bw, bh, 0, CopyFromParent,
InputOutput, CopyFromParent, mask, &att);
XMapWindow(dd, b3);
}
XSync(dd, False);
button = 0;
for (; button == 0;)
{
XNextEvent(dd, &ev);
switch (ev.type)
{
case KeyPress:
keycode = XKeysymToKeycode(dd, XK_F1);
if (keycode == ev.xkey.keycode)
{
DRAW_BOX_IN(dd, gc, b1, 0, 0, bw, bh);
XSync(dd, False);
SleepUs(500000);
DRAW_BOX_OUT(dd, gc, b1, 0, 0, bw, bh);
button = 1;
goto do_sync;
}
keycode = XKeysymToKeycode(dd, XK_F2);
if (keycode == ev.xkey.keycode)
{
DRAW_BOX_IN(dd, gc, b2, 0, 0, bw, bh);
XSync(dd, False);
SleepUs(500000);
DRAW_BOX_OUT(dd, gc, b2, 0, 0, bw, bh);
button = 2;
goto do_sync;
}
keycode = XKeysymToKeycode(dd, XK_F3);
if (keycode == ev.xkey.keycode)
{
DRAW_BOX_IN(dd, gc, b3, 0, 0, bw, bh);
XSync(dd, False);
SleepUs(500000);
DRAW_BOX_OUT(dd, gc, b3, 0, 0, bw, bh);
button = 3;
goto do_sync;
}
break;
case ButtonPress:
if (!(ev.xbutton.y >= BY && ev.xbutton.y < BY + bh))
break;
x = BX(0);
if (b1 && ev.xbutton.x >= x && ev.xbutton.x < x + bw)
{
DRAW_BOX_IN(dd, gc, b1, 0, 0, bw, bh);
goto do_sync;
}
x = BX(1);
if (b2 && ev.xbutton.x >= x && ev.xbutton.x < x + bw)
{
DRAW_BOX_IN(dd, gc, b2, 0, 0, bw, bh);
goto do_sync;
}
x = BX(2);
if (b3 && ev.xbutton.x >= x && ev.xbutton.x < x + bw)
{
DRAW_BOX_IN(dd, gc, b3, 0, 0, bw, bh);
goto do_sync;
}
break;
case ButtonRelease:
if (!(ev.xbutton.y >= BY && ev.xbutton.y < BY + bh))
break;
x = BX(0);
if (b1 && ev.xbutton.x >= x && ev.xbutton.x < x + bw)
{
DRAW_BOX_OUT(dd, gc, b1, 0, 0, bw, bh);
button = 1;
goto do_sync;
}
x = BX(1);
if (b2 && ev.xbutton.x >= x && ev.xbutton.x < x + bw)
{
DRAW_BOX_OUT(dd, gc, b2, 0, 0, bw, bh);
button = 2;
goto do_sync;
}
x = BX(2);
if (b3 && ev.xbutton.x >= x && ev.xbutton.x < x + bw)
{
DRAW_BOX_OUT(dd, gc, b3, 0, 0, bw, bh);
button = 3;
goto do_sync;
}
break;
case Expose:
/* Flush all other Expose events */
while (XCheckTypedWindowEvent(dd, ev.xexpose.window, Expose, &ev))
;
ExTextExtents(xfs, title, strlen(title), &rect1, &rect2);
w = rect2.width;
DRAW_HEADER(dd, gc, win, (ww - w) / 2, 5 - rect2.y, title);
DRAW_BOX_OUT(dd, gc, win, 0, 0, ww, bh);
DRAW_BOX_OUT(dd, gc, win, 0, bh - 1, ww, hh - fh - fh - 30 + 2);
DRAW_BOX_OUT(dd, gc, win, 0, hh - fh - 20, ww, fh + 20);
k = bh;
for (p = text;; p += len + 1)
{
len = strcspn(p, "\n");
DRAW_STRING(dd, gc, win, 6, 6 + k + fh, p, len);
k += fh + 2;
if (p[len] == '\0')
break;
}
if (str1)
{
ExTextExtents(xfs, str1, strlen(str1), &rect1, &rect2);
w = rect2.width;
DRAW_HEADER(dd, gc, b1, (bw - w) / 2, 5 - rect2.y, str1);
DRAW_BOX_OUT(dd, gc, b1, 0, 0, bw, bh);
DRAW_THIN_BOX_IN(dd, gc, win,
BX(0) - 2, BY - 2, bw + 4, bh + 4);
}
if (str2)
{
ExTextExtents(xfs, str2, strlen(str2), &rect1, &rect2);
w = rect2.width;
DRAW_HEADER(dd, gc, b2, (bw - w) / 2, 5 - rect2.y, str2);
DRAW_BOX_OUT(dd, gc, b2, 0, 0, bw, bh);
DRAW_THIN_BOX_IN(dd, gc, win,
BX(1) - 2, BY - 2, bw + 4, bh + 4);
}
if (str3)
{
ExTextExtents(xfs, str3, strlen(str3), &rect1, &rect2);
w = rect2.width;
DRAW_HEADER(dd, gc, b3, (bw - w) / 2, 5 - rect2.y, str3);
DRAW_BOX_OUT(dd, gc, b3, 0, 0, bw, bh);
DRAW_THIN_BOX_IN(dd, gc, win,
BX(2) - 2, BY - 2, bw + 4, bh + 4);
}
do_sync:
XSync(dd, False);
break;
default:
break;
}
}
XFreeFontSet(dd, xfs);
done:
XUngrabServer(dd);
XDestroyWindow(dd, win);
XFreeGC(dd, gc);
if (cnum > 0)
XFreeColors(dd, cmap, cols, cnum, 0);
XCloseDisplay(dd);
switch (button)
{
default:
case 1:
break;
case 2:
SessionExit(EEXIT_RESTART, NULL);
break;
case 3:
SessionExit(EEXIT_EXIT, NULL);
break;
}
}
void feh_event_handle_keypress(XEvent * ev)
{
int len;
char kbuf[20];
KeySym keysym;
XKeyEvent *kev;
winwidget winwid = NULL;
int curr_screen = 0;
feh_menu_item *selected_item;
feh_menu *selected_menu;
D_ENTER(4);
winwid = winwidget_get_from_window(ev->xkey.window);
/* nuke dupe events, unless we're typing text */
if (winwid && !winwid->caption_entry) {
while (XCheckTypedWindowEvent(disp, ev->xkey.window, KeyPress, ev));
}
kev = (XKeyEvent *) ev;
len = XLookupString(&ev->xkey, (char *) kbuf, sizeof(kbuf), &keysym, NULL);
/* menus are showing, so this is a menu control keypress */
if (ev->xbutton.window == menu_cover) {
selected_item = feh_menu_find_selected_r(menu_root, &selected_menu);
switch (keysym) {
case XK_Escape:
feh_menu_hide(menu_root, True);
break;
case XK_Left:
feh_menu_select_parent(selected_menu, selected_item);
break;
case XK_Down:
feh_menu_select_next(selected_menu, selected_item);
break;
case XK_Up:
feh_menu_select_prev(selected_menu, selected_item);
break;
case XK_Right:
feh_menu_select_submenu(selected_menu, selected_item);
break;
case XK_Return:
feh_menu_item_activate(selected_menu, selected_item);
break;
default:
break;
}
if (len <= 0 || len > (int) sizeof(kbuf))
D_RETURN_(4);
kbuf[len] = '\0';
switch (*kbuf) {
case 'h':
feh_menu_select_parent(selected_menu, selected_item);
break;
case 'j':
feh_menu_select_next(selected_menu, selected_item);
break;
case 'k':
feh_menu_select_prev(selected_menu, selected_item);
break;
case 'l':
feh_menu_select_submenu(selected_menu, selected_item);
break;
case ' ':
feh_menu_item_activate(selected_menu, selected_item);
break;
default:
break;
}
D_RETURN_(4);
}
if (winwid == NULL)
D_RETURN_(4);
if (winwid->caption_entry) {
switch (keysym) {
case XK_Return:
if (kev->state & ControlMask) {
/* insert actual newline */
ESTRAPPEND(FEH_FILE(winwid->file->data)->caption, "\n");
winwidget_render_image_cached(winwid);
} else {
/* finish caption entry, write to captions file */
FILE *fp;
char *caption_filename;
caption_filename = build_caption_filename(FEH_FILE(winwid->file->data));
winwid->caption_entry = 0;
winwidget_render_image_cached(winwid);
XFreePixmap(disp, winwid->bg_pmap_cache);
winwid->bg_pmap_cache = 0;
fp = fopen(caption_filename, "w");
if (!fp) {
weprintf("couldn't write to captions file %s:", caption_filename);
D_RETURN_(4);
}
fprintf(fp, "%s", FEH_FILE(winwid->file->data)->caption);
free(caption_filename);
fclose(fp);
}
break;
case XK_Escape:
/* cancel, revert caption */
winwid->caption_entry = 0;
free(FEH_FILE(winwid->file->data)->caption);
FEH_FILE(winwid->file->data)->caption = NULL;
winwidget_render_image_cached(winwid);
XFreePixmap(disp, winwid->bg_pmap_cache);
winwid->bg_pmap_cache = 0;
break;
case XK_BackSpace:
/* backspace */
ESTRTRUNC(FEH_FILE(winwid->file->data)->caption, 1);
winwidget_render_image_cached(winwid);
break;
default:
if (isascii(keysym)) {
/* append to caption */
ESTRAPPEND_CHAR(FEH_FILE(winwid->file->data)->caption, keysym);
winwidget_render_image_cached(winwid);
}
break;
}
D_RETURN_(4);
}
switch (keysym) {
case XK_Left:
if (opt.slideshow)
slideshow_change_image(winwid, SLIDE_PREV);
break;
case XK_Right:
if (opt.slideshow)
slideshow_change_image(winwid, SLIDE_NEXT);
break;
case XK_Page_Up:
case XK_KP_Page_Up:
if (opt.slideshow)
slideshow_change_image(winwid, SLIDE_JUMP_BACK);
break;
case XK_Escape:
winwidget_destroy_all();
break;
case XK_Page_Down:
case XK_KP_Page_Down:
if (opt.slideshow)
slideshow_change_image(winwid, SLIDE_JUMP_FWD);
break;
case XK_Delete:
/* Holding ctrl gets you a filesystem deletion and removal from the *
filelist. Just DEL gets you filelist removal only. */
if (kev->state & ControlMask) {
if (winwid->type == WIN_TYPE_THUMBNAIL_VIEWER)
feh_thumbnail_mark_removed(FEH_FILE(winwid->file->data), 1);
feh_filelist_image_remove(winwid, 1);
} else {
if (winwid->type == WIN_TYPE_THUMBNAIL_VIEWER)
feh_thumbnail_mark_removed(FEH_FILE(winwid->file->data), 0);
feh_filelist_image_remove(winwid, 0);
}
break;
case XK_Home:
case XK_KP_Home:
if (opt.slideshow)
slideshow_change_image(winwid, SLIDE_FIRST);
break;
case XK_End:
case XK_KP_End:
if (opt.slideshow)
slideshow_change_image(winwid, SLIDE_LAST);
break;
case XK_Return:
feh_event_invoke_action(winwid, opt.actions[0]);
break;
case XK_0:
feh_event_invoke_action(winwid, opt.actions[0]);
break;
case XK_1:
feh_event_invoke_action(winwid, opt.actions[1]);
break;
case XK_2:
feh_event_invoke_action(winwid, opt.actions[2]);
break;
case XK_3:
feh_event_invoke_action(winwid, opt.actions[3]);
break;
case XK_4:
feh_event_invoke_action(winwid, opt.actions[4]);
break;
case XK_5:
feh_event_invoke_action(winwid, opt.actions[5]);
break;
case XK_6:
feh_event_invoke_action(winwid, opt.actions[6]);
break;
case XK_7:
feh_event_invoke_action(winwid, opt.actions[7]);
break;
case XK_8:
feh_event_invoke_action(winwid, opt.actions[8]);
break;
case XK_9:
feh_event_invoke_action(winwid, opt.actions[9]);
break;
case XK_KP_Left:
winwid->im_x = winwid->im_x - 10;
winwidget_render_image(winwid, 0, 0);
break;
case XK_KP_Right:
winwid->im_x = winwid->im_x + 10;
winwidget_render_image(winwid, 0, 0);
break;
case XK_KP_Up:
winwid->im_y = winwid->im_y - 10;
winwidget_render_image(winwid, 0, 0);
break;
case XK_KP_Down:
winwid->im_y = winwid->im_y + 10;
winwidget_render_image(winwid, 0, 0);
break;
case XK_KP_Add:
/* erroneously recognized as '+' in the *kbuf switch. Work around this. */
len = 0;
winwid->zoom = winwid->zoom * 1.25;
winwidget_render_image(winwid, 0, 0);
break;
case XK_KP_Subtract:
len = 0;
winwid->zoom = winwid->zoom * 0.75;
winwidget_render_image(winwid, 0, 0);
break;
case XK_KP_Multiply:
len = 0;
winwid->zoom = 1;
winwidget_render_image(winwid, 0, 0);
break;
case XK_KP_Divide:
len = 0;
feh_calc_needed_zoom(&winwid->zoom, winwid->im_w, winwid->im_h, winwid->w, winwid->h);
winwidget_render_image(winwid, 0, 1);
break;
case XK_KP_Begin:
winwidget_render_image(winwid, 0, 1);
break;
default:
break;
}
if (len <= 0 || len > (int) sizeof(kbuf))
D_RETURN_(4);
kbuf[len] = '\0';
switch (*kbuf) {
case 'a':
case 'A':
opt.draw_actions = !opt.draw_actions;
winwidget_rerender_all(0, 1);
break;
case 'd':
case 'D':
opt.draw_filename = !opt.draw_filename;
winwidget_rerender_all(0, 1);
break;
case 'n':
case 'N':
case ' ':
if (opt.slideshow)
slideshow_change_image(winwid, SLIDE_NEXT);
break;
case 'p':
case 'P':
case '\b':
if (opt.slideshow)
slideshow_change_image(winwid, SLIDE_PREV);
break;
case 'z':
case 'Z':
if (opt.slideshow)
slideshow_change_image(winwid, SLIDE_RAND);
break;
case 'q':
case 'Q':
winwidget_destroy_all();
break;
case 'c':
case 'C':
if (opt.caption_path)
winwid->caption_entry = 1;
winwidget_render_image(winwid, 0, 1);
break;
case 'r':
case 'R':
feh_reload_image(winwid, 0, 0);
break;
case 'h':
case 'H':
slideshow_pause_toggle(winwid);
break;
case 's':
case 'S':
slideshow_save_image(winwid);
break;
case 'f':
case 'F':
feh_save_filelist();
break;
case 'w':
case 'W':
winwidget_size_to_image(winwid);
break;
case 'm':
case 'M':
winwidget_show_menu(winwid);
break;
case 'x':
case 'X':
winwidget_destroy(winwid);
break;
case '>':
feh_edit_inplace_orient(winwid, 1);
break;
case '<':
feh_edit_inplace_orient(winwid, 3);
break;
case 'v':
case 'V':
#ifdef HAVE_LIBXINERAMA
if (opt.xinerama && xinerama_screens) {
int i, rect[4];
winwidget_get_geometry(winwid, rect);
/* printf("window: (%d, %d)\n", rect[0], rect[1]);
printf("found %d screens.\n", num_xinerama_screens); */
for (i = 0; i < num_xinerama_screens; i++) {
xinerama_screen = 0;
/* printf("%d: [%d, %d, %d, %d] (%d, %d)\n",
i,
xinerama_screens[i].x_org, xinerama_screens[i].y_org,
xinerama_screens[i].width, xinerama_screens[i].height,
rect[0], rect[1]); */
if (XY_IN_RECT(rect[0], rect[1],
xinerama_screens[i].x_org,
xinerama_screens[i].y_org,
xinerama_screens[i].width,
xinerama_screens[i].height)) {
curr_screen = xinerama_screen = i;
break;
}
}
}
#endif /* HAVE_LIBXINERAMA */
winwid->full_screen = !winwid->full_screen;
winwidget_destroy_xwin(winwid);
winwidget_create_window(winwid, winwid->im_w, winwid->im_h);
winwidget_render_image(winwid, 1, 1);
winwidget_show(winwid);
#ifdef HAVE_LIBXINERAMA
/* if we have xinerama and we're using it, then full screen the window
* on the head that the window was active on */
if (winwid->full_screen == TRUE && opt.xinerama && xinerama_screens) {
xinerama_screen = curr_screen;
winwidget_move(winwid,
xinerama_screens[curr_screen].x_org, xinerama_screens[curr_screen].y_org);
}
#endif /* HAVE_LIBXINERAMA */
case '=':
case '+':
if (opt.reload < SLIDESHOW_RELOAD_MAX)
opt.reload++;
else if (opt.verbose)
weprintf("Cannot set RELOAD higher than %d seconds.", opt.reload);
break;
case '-':
case '_':
if (opt.reload > 1)
opt.reload--;
else if (opt.verbose)
weprintf("Cannot set RELOAD lower than 1 second.");
break;
default:
break;
}
D_RETURN_(4);
}
/***********************************************************************
*
* Procedure:
* HandleUnmapNotify - UnmapNotify event handler
*
************************************************************************/
void HandleUnmapNotify()
{
int dstx, dsty;
Window dumwin;
XEvent dummy;
extern FvwmWindow *colormap_win;
int weMustUnmap;
DBUG("HandleUnmapNotify","Routine Entered");
/*
* Don't ignore events as described below.
*/
if((Event.xunmap.event != Event.xunmap.window) &&
(Event.xunmap.event != Scr.Root || !Event.xunmap.send_event))
{
return;
}
/*
* The July 27, 1988 ICCCM spec states that a client wishing to switch
* to WithdrawnState should send a synthetic UnmapNotify with the
* event field set to (pseudo-)root, in case the window is already
* unmapped (which is the case for fvwm for IconicState). Unfortunately,
* we looked for the FvwmContext using that field, so try the window
* field also.
*/
weMustUnmap = 0;
if (!Tmp_win)
{
Event.xany.window = Event.xunmap.window;
weMustUnmap = 1;
if (XFindContext(dpy, Event.xany.window,
FvwmContext, (caddr_t *)&Tmp_win) == XCNOENT)
Tmp_win = NULL;
}
if(!Tmp_win)
return;
if(weMustUnmap)
XUnmapWindow(dpy, Event.xunmap.window);
if(Tmp_win == Scr.Hilite)
Scr.Hilite = NULL;
if(Scr.PreviousFocus == Tmp_win)
Scr.PreviousFocus = NULL;
if((Tmp_win == Scr.Focus)&&(Tmp_win->flags & ClickToFocus))
{
if(Tmp_win->next)
{
HandleHardFocus(Tmp_win->next);
}
else
SetFocus(Scr.NoFocusWin,NULL,1);
}
if(Scr.Focus == Tmp_win)
SetFocus(Scr.NoFocusWin,NULL,1);
if(Tmp_win == Scr.pushed_window)
Scr.pushed_window = NULL;
if(Tmp_win == colormap_win)
colormap_win = NULL;
if ((!(Tmp_win->flags & MAPPED)&&!(Tmp_win->flags&ICONIFIED)))
{
return;
}
MyXGrabServer(dpy);
if(XCheckTypedWindowEvent (dpy, Event.xunmap.window, DestroyNotify,&dummy))
{
Destroy(Tmp_win);
MyXUngrabServer (dpy);
return;
}
/*
* The program may have unmapped the client window, from either
* NormalState or IconicState. Handle the transition to WithdrawnState.
*
* We need to reparent the window back to the root (so that fvwm exiting
* won't cause it to get mapped) and then throw away all state (pretend
* that we've received a DestroyNotify).
*/
if (XTranslateCoordinates (dpy, Event.xunmap.window, Scr.Root,
0, 0, &dstx, &dsty, &dumwin))
{
XEvent ev;
Bool reparented;
reparented = XCheckTypedWindowEvent (dpy, Event.xunmap.window,
ReparentNotify, &ev);
SetMapStateProp (Tmp_win, WithdrawnState);
if (reparented)
{
if (Tmp_win->old_bw)
XSetWindowBorderWidth (dpy, Event.xunmap.window, Tmp_win->old_bw);
if((!(Tmp_win->flags & SUPPRESSICON))&&
(Tmp_win->wmhints && (Tmp_win->wmhints->flags & IconWindowHint)))
XUnmapWindow (dpy, Tmp_win->wmhints->icon_window);
}
else
{
RestoreWithdrawnLocation (Tmp_win,False);
}
XRemoveFromSaveSet (dpy, Event.xunmap.window);
XSelectInput (dpy, Event.xunmap.window, NoEventMask);
Destroy(Tmp_win); /* do not need to mash event before */
/*
* Flush any pending events for the window.
*/
/* Bzzt! it could be about to re-map */
/* while(XCheckWindowEvent(dpy, Event.xunmap.window,
StructureNotifyMask | PropertyChangeMask |
ColormapChangeMask | VisibilityChangeMask |
EnterWindowMask | LeaveWindowMask, &dummy));
*/
} /* else window no longer exists and we'll get a destroy notify */
MyXUngrabServer(dpy);
XFlush (dpy);
}
/***********************************************************************
*
* Procedure:
* HandleEnterNotify - EnterNotify event handler
*
************************************************************************/
void HandleEnterNotify()
{
XEnterWindowEvent *ewp = &Event.xcrossing;
XEvent d;
DBUG("HandleEnterNotify","Routine Entered");
/* look for a matching leaveNotify which would nullify this enterNotify */
if(XCheckTypedWindowEvent (dpy, ewp->window, LeaveNotify, &d))
{
/*
RBW - if we're in startup, this is a coerced focus, so we don't
want to save the event time, or exit prematurely.
*/
if (! fFvwmInStartup)
{
StashEventTime(&d);
if((d.xcrossing.mode==NotifyNormal)&&
(d.xcrossing.detail!=NotifyInferior))
return;
}
}
/* an EnterEvent in one of the PanFrameWindows activates the Paging */
#ifndef NON_VIRTUAL
if (ewp->window==Scr.PanFrameTop.win
|| ewp->window==Scr.PanFrameLeft.win
|| ewp->window==Scr.PanFrameRight.win
|| ewp->window==Scr.PanFrameBottom.win )
{
int delta_x=0, delta_y=0;
/* this was in the HandleMotionNotify before, HEDU */
HandlePaging(Scr.EdgeScrollX,Scr.EdgeScrollY,
&Event.xcrossing.x_root,&Event.xcrossing.y_root,
&delta_x,&delta_y,True);
return;
}
#endif /* NON_VIRTUAL */
/* multi screen? */
if (Event.xany.window == Scr.Root)
{
if (!Scr.Focus || (!(Scr.Focus->flags&ClickToFocus)&&
!(Scr.Focus->flags&SloppyFocus)))
{
SetFocus(Scr.NoFocusWin,NULL,1);
}
if (Scr.ColormapFocus == COLORMAP_FOLLOWS_MOUSE)
{
InstallWindowColormaps(NULL);
}
return;
}
/* make sure its for one of our windows */
if (!Tmp_win)
return;
if(!(Tmp_win->flags & ClickToFocus))
{
SetFocus(Tmp_win->w,Tmp_win,1);
}
if (Scr.ColormapFocus == COLORMAP_FOLLOWS_MOUSE)
{
if((!(Tmp_win->flags & ICONIFIED))&&(Event.xany.window == Tmp_win->w))
InstallWindowColormaps(Tmp_win);
else
InstallWindowColormaps(NULL);
}
return;
}
/************************************************************************
*
* Draw the window
*
***********************************************************************/
void RedrawWindow(Window target)
{
static int xv= 0,yv= 0,hv=0,wv=0;
static int xh=0,yh=0,hh=0,wh=0;
int x,y,w,h;
XEvent dummy;
while (XCheckTypedWindowEvent (dpy, main_win, Expose, &dummy))
exposed |= 1;
XSetWindowBorderWidth(dpy,target,0);
RelieveWindow(main_win,PAD_WIDTH3-2,PAD_WIDTH3-2,
Width-BAR_WIDTH-PAD_WIDTH3+4,
Height-BAR_WIDTH-PAD_WIDTH3+4,ShadowGC,ReliefGC);
y = (Height-BAR_WIDTH-PAD_WIDTH3-2*SCROLL_BAR_WIDTH)*
target_y_offset/target_height
+ PAD_WIDTH2 + 2 + SCROLL_BAR_WIDTH;
x = Width-SCROLL_BAR_WIDTH- PAD_WIDTH2-2;
w = SCROLL_BAR_WIDTH;
h = (Height-BAR_WIDTH-PAD_WIDTH3-2*SCROLL_BAR_WIDTH)*
(Height-BAR_WIDTH-PAD_WIDTH3)/
target_height;
if((y!=yv)||(x != xv)||(w != wv)||(h != hv)||(exposed & 1))
{
yv = y;
xv = x;
wv = w;
hv = h;
XClearArea(dpy,main_win,x,PAD_WIDTH3+SCROLL_BAR_WIDTH,
w,Height-BAR_WIDTH-PAD_WIDTH3-2*SCROLL_BAR_WIDTH,False);
RelieveWindow(main_win,x,y,w,h,ReliefGC,ShadowGC);
}
if(exposed & 1)
RelieveWindow(main_win,x-2,PAD_WIDTH2,
w+4,Height-BAR_WIDTH-PAD_WIDTH2+2,ShadowGC,ReliefGC);
if(exposed)
{
if(motion == TOP)
RedrawTopButton(ShadowGC,ReliefGC,x,PAD_WIDTH3);
else
RedrawTopButton(ReliefGC,ShadowGC,x,PAD_WIDTH3);
if(motion == BOTTOM)
RedrawBottomButton(ShadowGC,ReliefGC,x,
Height-BAR_WIDTH-SCROLL_BAR_WIDTH);
else
RedrawBottomButton(ReliefGC,ShadowGC,x,
Height-BAR_WIDTH-SCROLL_BAR_WIDTH);
}
x = (Width-BAR_WIDTH-PAD_WIDTH3-2*SCROLL_BAR_WIDTH)*target_x_offset/
target_width+PAD_WIDTH2+2 + SCROLL_BAR_WIDTH;
y = Height-SCROLL_BAR_WIDTH-PAD_WIDTH2-2;
w = (Width-BAR_WIDTH-PAD_WIDTH3-2*SCROLL_BAR_WIDTH)*
(Width-BAR_WIDTH-PAD_WIDTH3)/target_width;
h = SCROLL_BAR_WIDTH;
if((y!=yh)||(x != xh)||(w != wh)||(h != hh)||(exposed & 1))
{
yh = y;
xh = x;
wh = w;
hh = h;
XClearArea(dpy,main_win,PAD_WIDTH3+SCROLL_BAR_WIDTH,y,
Width-BAR_WIDTH-PAD_WIDTH3-2*SCROLL_BAR_WIDTH,h,False);
RelieveWindow(main_win,x,y,w,h,ReliefGC,ShadowGC);
}
if(exposed& 1)
{
RelieveWindow(main_win,PAD_WIDTH2,y-2,Width-BAR_WIDTH-PAD_WIDTH2+2,h+4,
ShadowGC,ReliefGC);
}
if(exposed)
{
if(motion == LEFT)
RedrawLeftButton(ShadowGC,ReliefGC,PAD_WIDTH3,y);
else
RedrawLeftButton(ReliefGC,ShadowGC,PAD_WIDTH3,y);
if(motion ==RIGHT)
RedrawRightButton(ShadowGC,ReliefGC,
Width-BAR_WIDTH-SCROLL_BAR_WIDTH,y);
else
RedrawRightButton(ReliefGC,ShadowGC,
Width-BAR_WIDTH-SCROLL_BAR_WIDTH,y);
}
if(exposed)
{
XClearArea(dpy,main_win,Width-BAR_WIDTH+2,
Height-BAR_WIDTH+2,BAR_WIDTH-3,BAR_WIDTH-3,False);
if(motion == QUIT)
RelieveWindow(main_win,Width-SCROLL_BAR_WIDTH-PAD_WIDTH2-4,
Height-SCROLL_BAR_WIDTH-PAD_WIDTH2-4,
SCROLL_BAR_WIDTH+4,SCROLL_BAR_WIDTH+4,
ShadowGC,ReliefGC);
else
RelieveWindow(main_win,Width-SCROLL_BAR_WIDTH-PAD_WIDTH2-4,
Height-SCROLL_BAR_WIDTH-PAD_WIDTH2-4,
SCROLL_BAR_WIDTH+4,SCROLL_BAR_WIDTH+4,
ReliefGC,ShadowGC);
}
exposed = 0;
}
void TopWindow::Open(Ctrl *owner)
{
LLOG("TopWindow::Open");
GuiLock __;
if(dokeys && (!GUI_AKD_Conservative() || GetAccessKeysDeep() <= 1))
DistributeAccessKeys();
USRLOG(" OPEN " + Desc(this));
LLOG("OPEN " << Name() << " owner: " << UPP::Name(owner));
IgnoreMouseUp();
bool weplace = owner && center == 1 || center == 2 || !GetRect().IsEmpty();
if(fullscreen)
SetRect(0, 0, Xwidth, Xheight);
else
CenterRect(owner);
LLOG("Open NextRequest " << NextRequest(Xdisplay));
Create(owner, false, false);
XSetWMProperties (Xdisplay, GetWindow(), NULL, NULL, NULL, 0, NULL, NULL, NULL);
xminsize.cx = xmaxsize.cx = Null;
title2.Clear();
if(!weplace) {
LLOG("SyncCaption");
SyncCaption();
}
LLOG("SyncSizeHints");
size_hints->flags = 0;
SyncSizeHints();
Rect r = GetRect();
size_hints->x = r.left;
size_hints->y = r.top;
size_hints->width = r.Width();
size_hints->height = r.Height();
size_hints->win_gravity = StaticGravity;
size_hints->flags |= PPosition|PSize|PWinGravity;
if(owner) {
ASSERT(owner->IsOpen());
LLOG("XSetTransientForHint");
XSetTransientForHint(Xdisplay, GetWindow(), owner->GetWindow());
}
LLOG("XSetWMNormalHints");
XSetWMNormalHints(Xdisplay, GetWindow(), size_hints);
Atom protocols[3];
protocols[0] = XAtom("WM_DELETE_WINDOW");
protocols[1] = XAtom("WM_TAKE_FOCUS");
protocols[2] = XAtom("_NET_WM_PING");
LLOG("XSetWMProtocols");
XSetWMProtocols(Xdisplay, GetWindow(), protocols, 3);
String x = GetExeTitle().ToString();
const char *progname = ~x;
class_hint->res_name = (char *)progname;
class_hint->res_class = (char *)progname;
XSetClassHint(Xdisplay, GetWindow(), class_hint);
LLOG("WndShow(" << visible << ")");
WndShow(visible);
if(visible) {
XEvent e;
LLOG("XWindowEvent");
XWindowEvent(Xdisplay, top->window, VisibilityChangeMask, &e);
ignoretakefocus = true;
SetTimeCallback(500, THISBACK(EndIgnoreTakeFocus));
LLOG("SetWndFocus");
SetWndFocus();
for(int i = 0; i < 50; i++) {
// X11 tries to move our window, so ignore the first set of ConfigureNotify
// and move the window into position after FocusIn - but not if we want WM to
// place the window
if(weplace)
while(XCheckTypedWindowEvent(Xdisplay, top->window, ConfigureNotify, &e)) {
if(e.xconfigure.window != top->window)
ProcessEvent(&e);
}
if(XCheckTypedWindowEvent(Xdisplay, top->window, FocusIn, &e)) {
ProcessEvent(&e);
if(e.xfocus.window == top->window)
break;
}
Sleep(10);
}
}
if(weplace) {
WndSetPos(GetRect());
LLOG("SyncCaption");
SyncCaption();
}
LLOG(">Open NextRequest " << NextRequest(Xdisplay));
LLOG(">OPENED " << Name());
PlaceFocus();
StateH(OPEN);
Vector<int> fe = GetPropertyInts(top->window, XAtom("_NET_FRAME_EXTENTS"));
if(fe.GetCount() >= 4 &&
fe[0] >= 0 && fe[0] <= 16 && fe[1] >= 0 && fe[1] <= 16 && //fluxbox returns wrong numbers - quick&dirty workaround
fe[2] >= 0 && fe[2] <= 64 && fe[3] >= 0 && fe[3] <= 48)
{
GuiLock __;
windowFrameMargin.left = max(windowFrameMargin.left, fe[0]);
windowFrameMargin.right = max(windowFrameMargin.right, fe[1]);
windowFrameMargin.top = max(windowFrameMargin.top, fe[2]);
windowFrameMargin.bottom = max(windowFrameMargin.bottom, fe[3]);
}
if(IsOpen() && top)
top->owner = owner;
long curr_pid = getpid();
static Window wm_client_leader;
ONCELOCK {
wm_client_leader = XCreateSimpleWindow(Xdisplay, Xroot, 0, 0, 1, 1, 0, 0, 0);
XChangeProperty(Xdisplay, wm_client_leader, XAtom("WM_CLIENT_LEADER"),
XA_WINDOW, 32, PropModeReplace, (byte *)&wm_client_leader, 1);
XChangeProperty(Xdisplay, wm_client_leader, XAtom("_NET_WM_PID"), XA_CARDINAL, 32,
PropModeReplace, (byte *) &curr_pid, 1);
}
Window win = GetWindow();
XChangeProperty(Xdisplay, win, XAtom("_NET_WM_PID"), XA_CARDINAL, 32,
PropModeReplace, (byte *) &curr_pid, 1);
XChangeProperty(Xdisplay, win, XAtom("WM_CLIENT_LEADER"),
XA_WINDOW, 32, PropModeReplace, (byte *)&wm_client_leader, 1);
int version = 5;
XChangeProperty(Xdisplay, win, XAtom("XdndAware"), XA_ATOM, 32,
0, (byte *)&version, 1);
SyncState();
FixIcons();
}
void event_loop(void * args){
static XEvent xevent;
Binding binding;
Window xwin;
//Context context;
Window lastxwin = 0;
BWindow win = NULL;
Link * link = NULL;
Link win_link = NULL;
Atom atom;
int format;
int status;
unsigned long nitems;
unsigned long remaining;
int event_ready=0;
int mousex , mousey, mousedx, mousedy;
mousex= mousey= mousedx= mousedy = 0;
//atexit(graphics_at_exit);
while(1){
XNextEvent(display, &xevent);
xwin = xevent.xany.window;
/* if this window is the same as the last don't look it up */
if (xwin != lastxwin) {
mousex = 0;
mousey = 0;
status = XGetWindowProperty(
display, // the display
xwin, // the window
bl_window, // name of property
0,
sizeof(Link)/4,
False, // don't delete
AnyPropertyType, //type
&atom, // return type
&format, // return format
&nitems, // return number of items
&remaining, // return bytes remaining
(void *)&link);
//(unsigned char **)&blwin);
if (status == Success){
lastxwin = xwin;
win_link = *link;
win = win_link->value.vptr;
XFree(link);
}else{
continue;
}
}
switch (xevent.type){
case ConfigureNotify:
if (! win) break;
win->width = xevent.xconfigure.width;
win->height = xevent.xconfigure.height;
win->x = xevent.xconfigure.x;
win->y = xevent.xconfigure.y;
break;
case Expose:
bwindow_paint(win);
break;
case DestroyNotify:
//while(XCheckWindowEvent(display, win->hwindow, event_mask, &xevent)){}
//glXMakeCurrent(display, None, NULL);
//glXDestroyContext(display, win->context);
//DPRINT("DESTROY MESSAGE")
bwindow_free(win);
break;
/* EVENTS */
case MotionNotify:
win->event.state = BEVT_MOTION | BEVT_MOUSE;
//printf("Motion %i %i %i\n", xevent.xmotion.state,xevent.xmotion.x,xevent.xmotion.y);
switch (xevent.xmotion.state & (Button1Mask|Button2Mask|Button3Mask|Button4Mask|Button5Mask) ){
case Button1Mask:
win->event.state |= BEVT_MOUSE1;
break;
case Button2Mask:
win->event.state |= BEVT_MOUSE2;
break;
case Button3Mask:
win->event.state |= BEVT_MOUSE3;
break;
case Button4Mask:
win->event.state |= BEVT_MOUSE4;
break;
case Button5Mask:
win->event.state |= BEVT_MOUSE5;
break;
}
while( XCheckTypedWindowEvent(display, xwin, MotionNotify,&xevent) ){};
mousedx = xevent.xmotion.x - mousex;
mousex = xevent.xmotion.x;
mousedy = xevent.xmotion.y - mousey;
mousey = xevent.xmotion.y;
goto MaskCommon;
break;
case ButtonRelease:
win->event.state = BEVT_RELEASE | BEVT_MOUSE;
//printf("Button Release %i %i %i\n", xevent.xbutton.button,xevent.xbutton.x,xevent.xbutton.y);
goto ButtonCommon;
break;
case ButtonPress:
win->event.state = BEVT_PRESS | BEVT_MOUSE;
//printf("Button Press %i %i %i\n", xevent.xbutton.button,xevent.xbutton.x,xevent.xbutton.y);
goto ButtonCommon;
break;
case KeyRelease:
win->event.state = BEVT_RELEASE | BEVT_KEY;
//printf("Key Release %i %i %i\n", (int)XLookupKeysym(&xevent.xkey, 0),xevent.xkey.x,xevent.xkey.y);
goto KeyCommon;
break;
case KeyPress:
win->event.state = BEVT_PRESS | BEVT_KEY;
//printf("Key Press %i %i %i\n", (int)XLookupKeysym(&xevent.xkey, 0),xevent.xkey.x,xevent.xkey.y);
goto KeyCommon;
break;
KeyCommon:
mousedx = xevent.xkey.x - mousex;
mousex = xevent.xkey.x;
mousedy = xevent.xkey.y - mousey;
mousey = xevent.xkey.y;
win->event.key = XLookupKeysym(&xevent.xkey, 0);
goto MaskCommon;
break;
ButtonCommon:
switch(xevent.xbutton.button){
case 1:
win->event.state |= BEVT_MOUSE1;
break;
case 2:
win->event.state |= BEVT_MOUSE2;
break;
case 3:
win->event.state |= BEVT_MOUSE3;
break;
case 4:
win->event.state |= BEVT_MOUSE4;
break;
case 5:
win->event.state |= BEVT_MOUSE5;
break;
}
win->event.key = 0;
mousedx = xevent.xbutton.x - mousex;
mousex = xevent.xbutton.x;
mousedy = xevent.xbutton.y - mousey;
mousey = xevent.xbutton.y;
goto MaskCommon;
break;
MaskCommon:
if (xevent.xbutton.state & ShiftMask) win->event.state |= BEVT_SHIFT;
if (xevent.xbutton.state & LockMask) win->event.state |= BEVT_SHIFTLOCK;
if (xevent.xbutton.state & ControlMask) win->event.state |= BEVT_CTRL;
if (xevent.xbutton.state & Mod1Mask) win->event.state |= BEVT_ALT;
if (xevent.xbutton.state & Mod4Mask) win->event.state |= BEVT_WIN;
event_ready = 1;
break;
case ClientMessage:
/* CLOSE WINDOW */
if (xevent.xclient.message_type == wm_protocols
&& xevent.xclient.format == 32
&& xevent.xclient.data.l[0] == wm_delete)
{
XUnmapWindow(display, win->hwindow);
win->event.state = BEVT_CLOSE;
binding = win->bindings;
while(binding){
if( (binding->event.state & win->event.state) == binding->event.state){
callback(win_link,binding->callback);
}
binding = binding->next;
}
}else if (xevent.xclient.message_type == bl_message){
win = (BWindow) xevent.xclient.data.l[1];
switch (xevent.xclient.data.l[0]){
/* UPDATE */
case UPDATE:
bwindow_paint(win);
break;
/* RESIZE */
case RESIZE:
XResizeWindow(display,win->hwindow,win->width,win->height);
break;
/* POSITION */
case POSITION:
XMoveWindow(display,win->hwindow, win->x, win->y);
break;
/* TITLE */
case TITLE:
XStoreName(display, win->hwindow,win->title->data);
XSetIconName(display, win->hwindow,win->title->data);
break;
/* VISIBILITY */
case VISIBILITY:
if (xevent.xclient.data.l[2] == 0 ){
XUnmapWindow(display, win->hwindow);
}else{
XMapRaised(display, win->hwindow);
XResizeWindow(display,win->hwindow,win->width,win->height);
XMoveWindow(display,win->hwindow, win->x, win->y);
}
break;
/* FREE */
case FREE:
//DPRINT("FREE MESSAGE")
//glFlush();
while(XCheckWindowEvent(display, win->hwindow, event_mask, &xevent)){}
//glXMakeCurrent(display, None, NULL);
//context = win->context;
XDestroyWindow(display, win->hwindow);
glXDestroyContext(display, win->context);
//glXMakeCurrent(display, None, NULL);
//XUnmapWindow(display, win->hwindow);
//DPRINT("FREE MESSAGE DONE")
break;
}
}
break;
}
if (event_ready){
//printf("WINDOW %g %g\n", win->event.pos.x,win->event.pos.y);
win->event.pos.x = mousex;
win->event.dpos.x = mousedx;
win->event.pos.y = mousey;
win->event.dpos.y = mousedy;
win->event.pos.z = 0;
win->event.dpos.z = 0;
bwindow_pick(win);
event_ready = 0;
}
}
}
bool QX11Data::clipboardWaitForEvent(Window win, int type, XEvent *event, int timeout)
{
QElapsedTimer started;
started.start();
QElapsedTimer now = started;
if (QAbstractEventDispatcher::instance()->inherits("QtMotif")
|| QApplication::clipboard()->property("useEventLoopWhenWaiting").toBool()) {
if (waiting_for_data) {
Q_ASSERT(!"QClipboard: internal error, qt_xclb_wait_for_event recursed");
return false;
}
waiting_for_data = true;
has_captured_event = false;
capture_event_win = win;
capture_event_type = type;
QApplication::EventFilter old_event_filter =
qApp->setEventFilter(qt_x11_clipboard_event_filter);
do {
if (XCheckTypedWindowEvent(display, win, type, event)) {
waiting_for_data = false;
qApp->setEventFilter(old_event_filter);
return true;
}
XSync(X11->display, false);
usleep(50000);
now.start();
QEventLoop::ProcessEventsFlags flags(QEventLoop::ExcludeUserInputEvents
| QEventLoop::ExcludeSocketNotifiers
| QEventLoop::WaitForMoreEvents
| QEventLoop::X11ExcludeTimers);
QAbstractEventDispatcher *eventDispatcher = QAbstractEventDispatcher::instance();
eventDispatcher->processEvents(flags);
if (has_captured_event) {
waiting_for_data = false;
*event = captured_event;
qApp->setEventFilter(old_event_filter);
return true;
}
} while (started.msecsTo(now) < timeout);
waiting_for_data = false;
qApp->setEventFilter(old_event_filter);
} else {
do {
if (XCheckTypedWindowEvent(X11->display,win,type,event))
return true;
// process other clipboard events, since someone is probably requesting data from us
XEvent e;
if (XCheckIfEvent(X11->display, &e, checkForClipboardEvents, 0))
qApp->x11ProcessEvent(&e);
now.start();
XFlush(X11->display);
// sleep 50 ms, so we don't use up CPU cycles all the time.
struct timeval usleep_tv;
usleep_tv.tv_sec = 0;
usleep_tv.tv_usec = 50000;
select(0, 0, 0, 0, &usleep_tv);
} while (started.msecsTo(now) < timeout);
}
return false;
}
void feh_event_handle_keypress(XEvent * ev)
{
int state;
char kbuf[20];
KeySym keysym;
XKeyEvent *kev;
winwidget winwid = NULL;
feh_menu_item *selected_item;
feh_menu *selected_menu;
winwid = winwidget_get_from_window(ev->xkey.window);
/* nuke dupe events, unless we're typing text */
if (winwid && !winwid->caption_entry) {
while (XCheckTypedWindowEvent(disp, ev->xkey.window, KeyPress, ev));
}
kev = (XKeyEvent *) ev;
XLookupString(&ev->xkey, (char *) kbuf, sizeof(kbuf), &keysym, NULL);
state = kev->state & (ControlMask | ShiftMask | Mod1Mask | Mod4Mask);
if (isascii(keysym))
state &= ~ShiftMask;
/* menus are showing, so this is a menu control keypress */
if (ev->xbutton.window == menu_cover) {
selected_item = feh_menu_find_selected_r(menu_root, &selected_menu);
if (feh_is_kp(&keys.menu_close, state, keysym, 0))
feh_menu_hide(menu_root, True);
else if (feh_is_kp(&keys.menu_parent, state, keysym, 0))
feh_menu_select_parent(selected_menu);
else if (feh_is_kp(&keys.menu_down, state, keysym, 0))
feh_menu_select_next(selected_menu, selected_item);
else if (feh_is_kp(&keys.menu_up, state, keysym, 0))
feh_menu_select_prev(selected_menu, selected_item);
else if (feh_is_kp(&keys.menu_child, state, keysym, 0))
feh_menu_select_submenu(selected_menu);
else if (feh_is_kp(&keys.menu_select, state, keysym, 0))
feh_menu_item_activate(selected_menu, selected_item);
return;
}
if (winwid == NULL)
return;
if (winwid->caption_entry) {
switch (keysym) {
case XK_Return:
if (state & ControlMask) {
/* insert actual newline */
ESTRAPPEND(FEH_FILE(winwid->file->data)->caption, "\n");
winwidget_render_image_cached(winwid);
} else {
/* finish caption entry, write to captions file */
FILE *fp;
char *caption_filename;
caption_filename =
build_caption_filename(FEH_FILE(winwid->file->data), 1);
winwid->caption_entry = 0;
winwidget_render_image_cached(winwid);
XFreePixmap(disp, winwid->bg_pmap_cache);
winwid->bg_pmap_cache = 0;
fp = fopen(caption_filename, "w");
if (!fp) {
eprintf("couldn't write to captions file %s:", caption_filename);
return;
}
fprintf(fp, "%s", FEH_FILE(winwid->file->data)->caption);
free(caption_filename);
fclose(fp);
}
break;
case XK_Escape:
/* cancel, revert caption */
winwid->caption_entry = 0;
free(FEH_FILE(winwid->file->data)->caption);
FEH_FILE(winwid->file->data)->caption = NULL;
winwidget_render_image_cached(winwid);
XFreePixmap(disp, winwid->bg_pmap_cache);
winwid->bg_pmap_cache = 0;
break;
case XK_BackSpace:
/* backspace */
ESTRTRUNC(FEH_FILE(winwid->file->data)->caption, 1);
winwidget_render_image_cached(winwid);
break;
default:
if (isascii(keysym)) {
/* append to caption */
ESTRAPPEND_CHAR(FEH_FILE(winwid->file->data)->caption, keysym);
winwidget_render_image_cached(winwid);
}
break;
}
return;
}
feh_event_handle_generic(winwid, state, keysym, 0);
}
void TWindow::HandleEvent(XEvent& event)
{
TPoint mouse;
const TPoint& scroll = GetScroll();
switch (event.type)
{
case Expose:
{
TRect r(event.xexpose.x, event.xexpose.y, event.xexpose.x + event.xexpose.width, event.xexpose.y + event.xexpose.height);
if (fUpdateRegion)
fUpdateRegion->Union(r);
else
{
fUpdateRegion = new TRegion(r);
fNextUpdate = sFirstUpdate;
sFirstUpdate = this;
}
// if (event.xexpose.count == 0)
// Update();
break;
}
case KeyPress:
case KeyRelease:
{
TTopLevelWindow* topLevel = GetTopLevelWindow();
if (topLevel)
topLevel->DispatchKeyEvent(event);
break;
}
case ButtonPress:
if (event.xbutton.button >= 1 && event.xbutton.button <= 3)
{
fCurrentEventTime = event.xbutton.time;
mouse.Set(event.xbutton.x + scroll.h, event.xbutton.y + scroll.v);
// check for multiple clicks
TTime now = gApplication->GetCurrentTime();
if (now - fLastClickTime < kDoubleClickTime &&
abs(fLastClick.h - mouse.h) <= kDoubleClickDelta &&
abs(fLastClick.v - mouse.v) <= kDoubleClickDelta)
++fClickCount;
else
fClickCount = 1;
fLastClick = mouse;
fLastClickTime = now;
if (IsTargetable() && event.xbutton.button != 2)
RequestTarget();
HandleMouseDown(mouse, (TMouseButton)event.xbutton.button, event.xbutton.state);
}
else if (event.xbutton.button == 4 || event.xbutton.button == 5)
{
HandleScrollWheel(event.xbutton.button == 5);
}
break;
case ButtonRelease:
if (event.xbutton.button >= 1 && event.xbutton.button <= 3)
{
fCurrentEventTime = event.xbutton.time;
mouse.Set(event.xbutton.x + scroll.h, event.xbutton.y + scroll.v);
HandleMouseUp(mouse, (TMouseButton)event.xbutton.button, event.xbutton.state);
}
break;
case EnterNotify:
fCurrentEventTime = event.xcrossing.time;
mouse.Set(event.xcrossing.x + scroll.h, event.xcrossing.y + scroll.v);
HandleMouseEnter(mouse, event.xcrossing.state);
break;
case LeaveNotify:
fCurrentEventTime = event.xcrossing.time;
mouse.Set(event.xcrossing.x + scroll.h, event.xcrossing.y + scroll.v);
HandleMouseLeave(mouse, event.xcrossing.state);
break;
case MotionNotify:
{
// avoid getting too many MotionNotify events by ignoring them if we have more in the queue
XEvent testEvent;
if (XPending(sDisplay) > 0 && XCheckTypedWindowEvent(sDisplay, event.xany.window, MotionNotify, &testEvent))
break;
fLastMouseMovedLocation.Set(event.xmotion.x, event.xmotion.y);
fLastMouseMovedModifiers = event.xmotion.state;
fCurrentEventTime = event.xmotion.time;
mouse.Set(event.xmotion.x + scroll.h, event.xmotion.y + scroll.v);
HandleMouseMoved(mouse, event.xmotion.state);
break;
}
case FocusIn:
{
if (event.xfocus.detail == NotifyAncestor ||
event.xfocus.detail == NotifyInferior ||
event.xfocus.detail == NotifyNonlinear ||
event.xfocus.detail == NotifyNonlinearVirtual)
{
if (event.xfocus.mode != NotifyGrab &&
event.xfocus.mode != NotifyUngrab) // these events confuse XIM, according to gdk comment
{
TTopLevelWindow* topLevel = GetTopLevelWindow();
if (topLevel)
topLevel->GotFocus(this);
break;
}
}
}
case FocusOut:
{
if (event.xfocus.detail == NotifyAncestor ||
event.xfocus.detail == NotifyInferior ||
event.xfocus.detail == NotifyNonlinear ||
event.xfocus.detail == NotifyNonlinearVirtual)
{
if (event.xfocus.mode != NotifyGrab &&
event.xfocus.mode != NotifyUngrab) // these events confuse XIM, according to gdk comment
{
TTopLevelWindow* topLevel = GetTopLevelWindow();
if (topLevel)
topLevel->LostFocus(this);
break;
}
}
}
case KeymapNotify:
// printf("KeymapNotify\n");
break;
case GraphicsExpose:
// printf("GraphicsExpose\n");
break;
case NoExpose:
//mgl why are we getting these when drawing scrollbars?
// printf("NoExpose\n");
break;
case VisibilityNotify:
fObscured = (event.xvisibility.state != VisibilityUnobscured);
break;
case CreateNotify:
printf("CreateNotify\n");
break;
case DestroyNotify:
printf("DestroyNotify\n");
break;
case MapNotify:
DoMapped(true);
break;
case UnmapNotify:
DoMapped(false);
break;
case MapRequest:
printf("MapRequest\n");
break;
case ReparentNotify:
// printf("ReparentNotify\n");
break;
case ConfigureNotify:
{
// we manage child window notification ourselves
if (fParent == NULL)
{
TRect oldBounds(fBounds);
fBounds.Set(event.xconfigure.x, event.xconfigure.y,
event.xconfigure.x + event.xconfigure.width,
event.xconfigure.y + event.xconfigure.height);
NotifyBoundsChanged(oldBounds);
}
break;
}
case ConfigureRequest:
printf("ConfigureRequest\n");
break;
case GravityNotify:
printf("GravityNotify\n");
break;
case ResizeRequest:
printf("ResizeRequest\n");
break;
case CirculateNotify:
printf("CirculateNotify\n");
break;
case CirculateRequest:
printf("CirculateRequest\n");
break;
case PropertyNotify:
printf("PropertyNotify\n");
break;
case SelectionClear:
{
if (fIsSelectionOwner)
{
LostSelectionOwnership();
fIsSelectionOwner = false;
}
break;
}
case SelectionRequest:
{
XSelectionEvent response;
response.type = SelectionNotify;
response.display = event.xselectionrequest.display;
response.requestor = event.xselectionrequest.requestor;
response.selection = event.xselectionrequest.selection;
response.target = event.xselectionrequest.target;
response.property = event.xselectionrequest.property;
response.time = event.xselectionrequest.time;
Atom targetAtom = XInternAtom(event.xselectionrequest.display, "TARGETS", false);
if (event.xselectionrequest.target == targetAtom)
{
Atom targets[] = { XA_STRING };
int result;
result = XChangeProperty(event.xselectionrequest.display,
event.xselectionrequest.requestor,
event.xselectionrequest.property,
event.xselectionrequest.target,
8,
PropModeReplace,
(const unsigned char*)targets,
sizeof(targets));
if (result == BadAlloc || result == BadAtom || result == BadMatch || result == BadValue || result == BadWindow)
printf ("SelectionRequest - XChangeProperty failed: %d\n", result);
response.send_event = true;
}
else
{
unsigned char* data;
uint32 length;
Atom type = event.xselectionrequest.target;
if (response.selection == XA_PRIMARY && RequestSelectionData(type, data, length))
{
response.target = type;
XChangeProperty(response.display, response.requestor, event.xselectionrequest.property, type,
8, PropModeReplace, data, length);
free(data);
}
else
response.property = None;
}
XSendEvent(sDisplay, response.requestor, false, NoEventMask, (XEvent *)&response);
break;
}
case SelectionNotify:
{
if (event.xselection.property != None)
{
Atom type;
unsigned long items, length, remaining;
int actualFormat;
unsigned char* data;
// first compute the length
XGetWindowProperty(sDisplay, fWindow, event.xselection.property, 0, 0, false, AnyPropertyType,
&type, &actualFormat, &items, &length, &data);
if (data)
XFree(data);
// now get the data
XGetWindowProperty(sDisplay, fWindow, event.xselection.property, 0, length, true, AnyPropertyType,
&type, &actualFormat, &items, &remaining, &data);
ASSERT(remaining == 0);
ReceiveSelectionData(type, data, length);
XFree(data);
}
break;
}
case ColormapNotify:
printf("ColormapNotify\n");
break;
case ClientMessage:
if ((Atom)event.xclient.data.l[0] == sDeleteWindowAtom)
{
Close();
}
else if ((Atom)event.xclient.data.l[0] == sTakeFocusAtom)
{
/* TTopLevelWindow* topLevel = GetTopLevelWindow();
ASSERT(topLevel == this);
topLevel->TakeFocus();
*/
}
else
printf("unknown ClientMessage\n");
break;
case MappingNotify:
printf("MappingNotify\n");
break;
default:
break;
}
}
GstImxEglVivSinkMainloopRetval gst_imx_egl_viv_sink_egl_platform_mainloop(GstImxEglVivSinkEGLPlatform *platform)
{
Display *x11_display = (Display *)(platform->native_display);
gboolean expose_required = TRUE;
gboolean continue_loop = TRUE;
while (continue_loop)
{
XEvent xevent;
XNextEvent(x11_display, &xevent);
/* handle X11 events */
EGL_PLATFORM_LOCK(platform);
switch (xevent.type)
{
case Expose:
{
Window this_window = (Window)(platform->native_window);
/* In case this window is child of another window that is not the root
* window, resize this window; sometimes, ConfigureNotify is not trigger
* when the windows show up for the first time*/
if ((xevent.xexpose.count == 0) && (platform->parent_window != 0))
{
Window root_window;
int x, y;
unsigned int width, height, border_width, depth;
XGetGeometry(
x11_display,
platform->parent_window,
&root_window,
&x, &y,
&width, &height,
&border_width,
&depth
);
XResizeWindow(x11_display, this_window, width, height);
if ((platform->fixed_window_width != 0) || (platform->fixed_window_height != 0))
{
platform->fixed_window_width = width;
platform->fixed_window_height = height;
}
if (platform->window_resized_event_cb != NULL)
platform->window_resized_event_cb(platform, width, height, platform->user_context);
}
/* Make sure no more expose events are there */
while (XCheckTypedWindowEvent(x11_display, platform->parent_window, Expose, &xevent) == True);
while (XCheckTypedWindowEvent(x11_display, this_window, Expose, &xevent) == True);
expose_required = TRUE;
break;
}
case ClientMessage:
if ((xevent.xclient.format == 32) && (xevent.xclient.data.l[0] == (long)(platform->wm_delete_atom)))
{
GST_INFO("window got closed");
EGL_PLATFORM_UNLOCK(platform);
return GST_IMX_EGL_VIV_SINK_MAINLOOP_RETVAL_WINDOW_CLOSED;
}
else if ((xevent.xclient.format == 32) && (xevent.xclient.data.l[0] == 0))
{
switch (xevent.xclient.data.l[1])
{
case GSTIMX_EGLX11_CMD_EXPOSE:
expose_required = TRUE;
break;
case GSTIMX_EGLX11_CMD_CALL_RESIZE_CB:
if (platform->window_resized_event_cb != NULL)
platform->window_resized_event_cb(platform, platform->fixed_window_width, platform->fixed_window_height, platform->user_context);
break;
case GSTIMX_EGLX11_CMD_STOP_MAINLOOP:
continue_loop = FALSE;
break;
default:
break;
}
}
break;
case ConfigureNotify:
{
Window this_window = (Window)(platform->native_window);
GST_TRACE("received ConfigureNotify event -> calling resize callback");
/* Make sure no other ConfigureNotify events are there */
while (XCheckTypedWindowEvent(x11_display, platform->parent_window, ConfigureNotify, &xevent) == True);
/* Resize if this is a child window of a non-root parent window;
* this is usually the case when this window is embedded inside another one */
if (platform->parent_window != 0)
XResizeWindow(x11_display, this_window, xevent.xconfigure.width, xevent.xconfigure.height);
if ((platform->fixed_window_width != 0) || (platform->fixed_window_height != 0))
{
platform->fixed_window_width = xevent.xconfigure.width;
platform->fixed_window_height = xevent.xconfigure.height;
}
if (platform->window_resized_event_cb != NULL)
platform->window_resized_event_cb(platform, xevent.xconfigure.width, xevent.xconfigure.height, platform->user_context);
expose_required = TRUE;
break;
}
default:
break;
}
EGL_PLATFORM_UNLOCK(platform);
if (expose_required)
{
platform->render_frame_cb(platform, platform->user_context);
eglSwapBuffers(platform->egl_display, platform->egl_surface);
expose_required = FALSE;
}
}
return GST_IMX_EGL_VIV_SINK_MAINLOOP_RETVAL_OK;
}
void QX11Data::motifdndHandle(QWidget *widget, const XEvent * xe, bool /* passive */)
{
XEvent event = *xe;
XClientMessageEvent cm ;
DndData dnd_data ;
char receiver ;
if (!(DndParseClientMessage ((XClientMessageEvent*)&event,
&dnd_data, &receiver))) {
return;
}
switch (dnd_data.reason) {
case DND_DRAG_MOTION:
{
QPoint p = widget->mapFromGlobal(QPoint(dnd_data.x, dnd_data.y));
QWidget *c = widget->childAt(p);
if (!c || !c->acceptDrops()) {
// not over a drop site
if (dropWidget) {
QDragLeaveEvent dragLeaveEvent;
QApplication::sendEvent(dropWidget, &dragLeaveEvent);
dropWidget = 0;
lastAcceptedAction = Qt::IgnoreAction;
dnd_data.reason = DND_DROP_SITE_LEAVE;
dnd_data.time = X11->time;
DndFillClientMessage (event.xclient.display, sourceWindow, &cm, &dnd_data, receiver);
XSendEvent(event.xbutton.display, sourceWindow, False, 0, (XEvent *)&cm) ;
} else {
dnd_data.reason = DND_DRAG_MOTION;
dnd_data.status = DND_NO_DROP_SITE;
dnd_data.time = X11->time;
dnd_data.operation = DND_NOOP;
dnd_data.operations = DND_NOOP;
DndFillClientMessage (event.xclient.display, sourceWindow, &cm, &dnd_data, receiver);
XSendEvent(event.xbutton.display, sourceWindow, False, 0, (XEvent *)&cm) ;
}
} else {
Q_ASSERT(c != 0);
p = c->mapFrom(widget, p);
if (dropWidget != c) {
if (dropWidget) {
QDragLeaveEvent le;
QApplication::sendEvent(dropWidget, &le);
}
dropWidget = c;
lastAcceptedAction = Qt::IgnoreAction;
const Qt::DropActions possibleActions =
DndOperationsToQtDropActions(dnd_data.operations);
QDragEnterEvent de(p, possibleActions, QDragManager::self()->dropData,
QApplication::mouseButtons(), QApplication::keyboardModifiers());
QApplication::sendEvent(dropWidget, &de);
dnd_data.reason = DND_DROP_SITE_ENTER;
dnd_data.time = X11->time;
if (de.isAccepted()) {
lastAcceptedAction = de.dropAction();
dnd_data.status = DND_VALID_DROP_SITE;
dnd_data.operation = QtDropActionToDndOperation(lastAcceptedAction);
} else {
dnd_data.status = DND_INVALID_DROP_SITE;
dnd_data.operation = DND_NOOP;
dnd_data.operations = DND_NOOP;
}
DndFillClientMessage (event.xclient.display, sourceWindow, &cm, &dnd_data, receiver);
XSendEvent(event.xbutton.display, sourceWindow, False, 0, (XEvent *)&cm);
} else {
const Qt::DropActions possibleActions =
DndOperationsToQtDropActions(dnd_data.operations);
QDragMoveEvent me(p, possibleActions, QDragManager::self()->dropData,
QApplication::mouseButtons(), QApplication::keyboardModifiers());
if (lastAcceptedAction != Qt::IgnoreAction) {
me.setDropAction(lastAcceptedAction);
me.accept();
}
QApplication::sendEvent(dropWidget, &me);
dnd_data.reason = DND_DRAG_MOTION;
dnd_data.time = X11->time;
if (me.isAccepted()) {
lastAcceptedAction = me.dropAction();
dnd_data.status = DND_VALID_DROP_SITE;
dnd_data.operation = QtDropActionToDndOperation(lastAcceptedAction);
} else {
dnd_data.status = DND_INVALID_DROP_SITE;
dnd_data.operation = DND_NOOP;
dnd_data.operations = DND_NOOP;
}
DndFillClientMessage (event.xclient.display, sourceWindow, &cm, &dnd_data, receiver);
XSendEvent(event.xbutton.display, sourceWindow, False, 0, (XEvent *)&cm);
}
}
break;
}
case DND_TOP_LEVEL_ENTER:
{
/* get the size of our drop site for later use */
motifdnd_active = true;
sourceWindow = dnd_data.src_window;
/* no answer needed, just read source property */
DndReadSourceProperty (event.xclient.display,
sourceWindow,
dnd_data.property,
&src_targets, &num_src_targets);
break;
}
case DND_TOP_LEVEL_LEAVE:
{
XEvent nextEvent;
if (XCheckTypedWindowEvent(X11->display, widget->winId(), ClientMessage, &nextEvent)) {
// we just want to check, not eat (should use XPeekIfEvent)
XPutBackEvent(X11->display, &nextEvent);
if (DndParseClientMessage (&nextEvent.xclient, &dnd_data, &receiver)
&& dnd_data.reason == DND_DROP_START) {
// expecting drop next, keeping DnD alive
break;
}
}
// not expecting drop, need to send drag leave events and such here
if (dropWidget) {
QDragLeaveEvent le;
QApplication::sendEvent(dropWidget, &le);
}
sourceWindow = XNone;
dropWidget = 0;
lastAcceptedAction = Qt::IgnoreAction;
motifdnd_active = false;
break;
}
case DND_OPERATION_CHANGED:
// ### need to echo
break;
case DND_DROP_START:
{
Q_ASSERT(motifdnd_active);
Q_ASSERT(sourceWindow == dnd_data.src_window);
if (!dropWidget || lastAcceptedAction == Qt::IgnoreAction) {
// echo DROP_START
dnd_data.reason = DND_DROP_START;
dnd_data.status = DND_NO_DROP_SITE;
dnd_data.operation = DND_NOOP;
dnd_data.operations = DND_NOOP;
DndFillClientMessage (event.xclient.display, sourceWindow, &cm, &dnd_data, 0);
XSendEvent(event.xbutton.display, sourceWindow, False, 0, (XEvent *)&cm);
// we have to convert selection in order to indicate failure to the initiator
XConvertSelection (X11->display, dnd_data.property, ATOM(XmTRANSFER_FAILURE),
dnd_data.property, dnd_data.src_window, dnd_data.time);
if (dropWidget) {
QDragLeaveEvent e;
QApplication::sendEvent(dropWidget, &e);
}
motifdnd_active = false;
sourceWindow = XNone;
dropWidget = 0;
lastAcceptedAction = Qt::IgnoreAction;
return;
}
// store selection and its time
Dnd_selection = dnd_data.property;
Dnd_selection_time = dnd_data.time;
QPoint p(dnd_data.x, dnd_data.y);
QDropEvent de(dropWidget->mapFromGlobal(p), Qt::CopyAction, QDragManager::self()->dropData,
QApplication::mouseButtons(), QApplication::keyboardModifiers());
if (lastAcceptedAction != Qt::IgnoreAction) {
de.setDropAction(lastAcceptedAction);
de.accept();
}
QApplication::sendEvent(dropWidget, &de);
// reset
Dnd_selection = XNone;
Dnd_selection_time = 0;
// echo DROP_START depending on the result of the dropEvent
if (de.isAccepted()) {
dnd_data.reason = DND_DROP_START;
dnd_data.status = DND_VALID_DROP_SITE;
dnd_data.operation = QtDropActionToDndOperation(de.dropAction());
} else {
dnd_data.reason = DND_DROP_START;
dnd_data.status = DND_NO_DROP_SITE;
dnd_data.operation = DND_NOOP;
dnd_data.operations = DND_NOOP;
}
DndFillClientMessage (event.xclient.display, sourceWindow, &cm, &dnd_data, 0);
XSendEvent(event.xbutton.display, sourceWindow, False, 0, (XEvent *)&cm);
sourceWindow = XNone;
dropWidget = 0;
lastAcceptedAction = Qt::IgnoreAction;
motifdnd_active = false;
break;
}
default:
break;
} // end of switch (dnd_data.reason)
}
/* static */
void gdk_superwin_handle_expose (GdkSuperWin *superwin, XEvent *xevent,
GdkRegion **region, gboolean dont_recurse)
{
GSList *tmp_list;
gboolean send_event = TRUE;
unsigned long serial = xevent->xany.serial;
XEvent extra_event;
GdkRectangle rect;
GdkRegion *tmp_region = NULL;
gboolean is_special = TRUE;
/* set up our rect for the damaged area */
rect.x = xevent->xexpose.x;
rect.y = xevent->xexpose.y;
rect.width = xevent->xexpose.width;
rect.height = xevent->xexpose.height;
/* try to see if this is a special event that matches an antiexpose */
tmp_list = superwin->translate_queue;
while (tmp_list) {
GdkSuperWinTranslate *xlate = tmp_list->data;
if (xlate->type == GDK_SUPERWIN_ANTIEXPOSE && serial == xlate->serial) {
GdkRegion *antiexpose_region = gdk_region_new();
tmp_region = gdk_region_union_with_rect(antiexpose_region,
&xlate->data.antiexpose.rect);
gdk_region_destroy(antiexpose_region);
antiexpose_region = tmp_region;
/* if the rect of the expose event is contained in the
antiexpose then we should just drop it on the floor. */
if (gdk_region_rect_in(antiexpose_region, &rect) == GDK_OVERLAP_RECTANGLE_IN) {
gdk_region_destroy(antiexpose_region);
goto end;
}
gdk_region_destroy(antiexpose_region);
}
tmp_list = tmp_list->next;
}
/* we walk the list looking for any transformations */
tmp_list = superwin->translate_queue;
while (tmp_list) {
GdkSuperWinTranslate *xlate = tmp_list->data;
/* apply translations to this event if we can. */
if (xlate->type == GDK_SUPERWIN_TRANSLATION && serial < xlate->serial ) {
rect.x += xlate->data.translation.dx;
rect.y += xlate->data.translation.dy;
}
tmp_list = tmp_list->next;
}
/* add this expose area to our damaged rect */
tmp_region = gdk_region_union_with_rect(*region, &rect);
gdk_region_destroy(*region);
*region = tmp_region;
end:
/* remove any events from the queue that are old */
tmp_list = superwin->translate_queue;
while (tmp_list) {
GdkSuperWinTranslate *xlate = tmp_list->data;
if (serial > xlate->serial) {
GSList *tmp_link = tmp_list;
tmp_list = tmp_list->next;
superwin->translate_queue = g_slist_remove_link(superwin->translate_queue,
tmp_link);
g_free(tmp_link->data);
g_slist_free_1(tmp_link);
}
else {
tmp_list = tmp_list->next;
}
}
/* if we're not supposed to recurse or paint then return now */
if (dont_recurse)
return;
/* try to do any expose event compression we can */
while (XCheckTypedWindowEvent(xevent->xany.display,
xevent->xany.window,
Expose,
&extra_event) == True) {
gdk_superwin_handle_expose(superwin, &extra_event, region, TRUE);
}
/* if the region isn't empty, send the paint event */
if (gdk_region_empty(*region) == FALSE) {
GdkRectangle clip_box;
gdk_region_get_clipbox(*region, &clip_box);
if (superwin->paint_func)
superwin->paint_func(clip_box.x, clip_box.y,
clip_box.width, clip_box.height,
superwin->func_data);
}
}
int main(int argc, char **argv)
{
int x, y;
Window win1;
GC gc1;
XEvent event;
XImage *ximg1;
int flag;
struct IplImage *prev1, *curr1, *motion;
struct IplDev *dev1;
time_t start, end;
int f;
f = 0;
start = 0;
end = 0;
x = 0;
y = 0;
initX();
getXinfo();
win1 = openWindow(500, 500, 640, 480, 0, &gc1);
XNextEvent(theDisplay, &event);
ximg1 = XGetImage(theDisplay, win1, x, y, 640, 480, AllPlanes, ZPixmap);
if(XInitImage(ximg1) == 0) {
fprintf(stderr,"error: XInitImage\n");
return 1;
}
printf("first xgetimage done\n");
if ((dev1 = ipl_opendev(0, IPL_RGB_MODE)) == NULL) {
printf("error while creating device 0\n");
return 1;
}
if (ipl_setparams(dev1, 320, 240, IPL_FORCE_SCALE_ON) < 0) {
fprintf(stderr, "error on changing cam params\n");
free(dev1);
return 1;
}
if ((prev1 = ipl_getframe(dev1)) == NULL) {
printf("error capturing prev1\n");
return 1;
}
flag = 1;
start = time(NULL);
while (flag) {
f++;
end = time(NULL);
if (end - start >= 1.0) {
printf("fps = %i\n", f);
f = 0;
start = end;
}
if ((curr1 = ipl_getframe(dev1)) == NULL) {
printf("error capturing curr1\n");
return 1;
}
motion = framescompare(curr1, prev1);
ipl_scaleimg(&motion, 640, 480);
camera_shoot(motion, ximg1, gc1, win1, x, y);
ipl_freeimg(&prev1);
prev1 = curr1;
ipl_freeimg(&motion);
XCheckTypedWindowEvent(theDisplay, win1, ButtonPress, &event);
if (event.xbutton.button == 1)
flag = 0;
}
ipl_freeimg(&curr1);
XDestroyImage(ximg1);
XDestroyWindow(theDisplay, win1);
quitX();
return 0;
}
FILE *
Format(ManpageGlobals * man_globals, char * entry)
{
FILE * file = NULL;
#ifdef HAS_MKSTEMP
int fd;
#endif
Widget manpage = man_globals->manpagewidgets.manpage;
char cmdbuf[BUFSIZ], tmp[BUFSIZ], filename[BUFSIZ], error_buf[BUFSIZ];
char path[BUFSIZ], sect[BUFSIZ];
XEvent event;
Position x,y; /* location to pop up the
"would you like to save" widget. */
#ifndef HAS_MKSTEMP
if ( !UncompressUnformatted(man_globals, entry, filename) ) {
#else
if ( !UncompressUnformatted(man_globals, entry, filename, &file) ) {
#endif
/* We Really could not find it, this should never happen, yea right. */
snprintf(error_buf, sizeof(error_buf),
"Could not open manual page, %s", entry);
PopupWarning(man_globals, error_buf);
XtPopdown( XtParent(man_globals->standby) );
return(NULL);
}
#ifndef HAS_MKSTEMP
if ((file = fopen(filename, "r")) != NULL) {
#else
if (file != NULL) {
#endif
char line[BUFSIZ];
if (fgets(line, sizeof(line), file) != NULL) {
if (strncmp(line, ".so ", 4) == 0) {
line[strlen(line) - 1] = '\0';
fclose(file);
unlink(filename);
if (line[4] != '/') {
char *ptr = NULL;
strcpy(tmp, entry);
if ((ptr = rindex(tmp, '/')) != NULL) {
*ptr = '\0';
if ((ptr = rindex(tmp, '/')) != NULL)
ptr[1] = '\0';
}
}
else
*tmp = '\0';
snprintf(filename, sizeof(filename), "%s%s", tmp, line + 4);
return (Format(man_globals, filename));
}
}
fclose(file);
}
Popup(XtParent(man_globals->standby), XtGrabExclusive);
while ( !XCheckTypedWindowEvent(XtDisplay(man_globals->standby),
XtWindow(man_globals->standby),
Expose, &event) );
XtDispatchEvent( &event );
XFlush(XtDisplay(man_globals->standby));
strcpy(tmp,MANTEMP); /* Get a temp file. */
#ifndef HAS_MKSTEMP
(void) mktemp(tmp);
#else
fd = mkstemp(tmp);
file = fdopen(fd, "r");
#endif
strcpy(man_globals->tempfile, tmp);
ParseEntry(entry, path, sect, NULL);
#ifndef HANDLE_ROFFSEQ
#ifndef HAS_MKSTEMP
snprintf(cmdbuf, sizeof(cmdbuf), "cd %s ; %s %s %s > %s %s", path, TBL,
filename, FORMAT, man_globals->tempfile, "2> /dev/null");
#else
snprintf(cmdbuf, sizeof(cmdbuf), "cd %s ; %s %s %s >> %s %s", path, TBL,
filename, FORMAT, man_globals->tempfile, "2> /dev/null");
#endif
#else
/* Handle more flexible way of specifying the formatting pipeline */
if (! ConstructCommand(cmdbuf, path, filename, man_globals->tempfile)) {
sprintf(error_buf, "Constructed command was too long!");
PopupWarning(man_globals, error_buf);
file = NULL;
}
else
#endif /* HANDLE_ROFFSEQ */
if(system(cmdbuf) != 0) { /* execute search. */
snprintf(error_buf, sizeof(error_buf),
"Something went wrong trying to run the command: %s", cmdbuf);
PopupWarning(man_globals, error_buf);
file = NULL;
}
else {
#ifndef HAS_MKSTEMP
if ((file = fopen(man_globals->tempfile,"r")) == NULL) {
sprintf(error_buf, "Something went wrong in retrieving the %s",
"temp file, try cleaning up /tmp");
PopupWarning(man_globals, error_buf);
}
else {
#endif
XtPopdown( XtParent(man_globals->standby) );
if ( (man_globals->save == NULL) ||
(man_globals->manpagewidgets.manpage == NULL) )
unlink(man_globals->tempfile);
else {
char * ptr, catdir[BUFSIZ];
/*
* If the catdir is writeable then ask the user if he/she wants to
* write the man page to it.
*/
strcpy(catdir, man_globals->save_file);
if ( (ptr = rindex(catdir, '/')) != NULL) {
*ptr = '\0';
if ( access(catdir, W_OK) != 0 )
unlink(man_globals->tempfile);
else {
x = (Position) Width(man_globals->manpagewidgets.manpage)/2;
y = (Position) Height(man_globals->manpagewidgets.manpage)/2;
XtTranslateCoords(manpage, x, y, &x, &y);
PositionCenter( man_globals->save, (int) x, (int) y, 0, 0, 0, 0);
XtPopup( man_globals->save, XtGrabExclusive);
}
}
else
unlink(man_globals->tempfile);
}
#ifndef HAS_MKSTEMP
}
#endif
}
/*
* If the original was compressed or in another format, delete temporary file.
*/
if (man_globals->deletetempfile)
unlink(filename);
return(file);
}
#ifdef HANDLE_ROFFSEQ
/* Function Name: ConstructCommand
* Description: Constructs the pipeline of commands necessary to format
* a manual page.
* Arguments: cmdbuf - the buffer into which to write the command
* path - the directory in which the original man page resides
* filename - the (uncompressed) manpage source file
* tempfile - the name of a temporary file to direct the final
* output of the pipeline into
* Returns: TRUE if the command fit into the buffer, FALSE if it would
* be too long (more than BUFSIZ characters)
*/
static Boolean
ConstructCommand(cmdbuf, path, filename, tempfile)
char *cmdbuf, *path, *filename, *tempfile;
{
/* The original code did the following to produce a command line:
* sprintf(cmdbuf,"cd %s ; %s %s %s > %s %s", path, TBL,
* filename, FORMAT, man_globals->tempfile, "2> /dev/null");
* We are more flexible and follow more or less the algorithm used
* by the Linux man command:
* + Obtain a string of letters from the following sources in order
* of preference:
* + a command line option (not implemented in xman; it's probably not
* useful)
* + the first line of the manpage source, if it is of the form:
* '\" <string>
* + the MANROFFSEQ environment variable
* + a default string; this is "".
* + Interpret the string as a pipeline of filters:
* + e = eqn g = grap p = pic t = tbl v = vgrind r = refer
* + zsoelim is always run as the first preprocessor in any case.
*
* Strictly speaking we should save a catpage iff the string comes
* from the file or is the default.
*
* You'll notice that we format a man page into ASCII text output and then
* attempt to interpret things like L^HL as bold and so forth. This
* is so obviously the Wrong Thing it's untrue.
*/
char *c = cmdbuf; /* current posn in buffer */
int left = BUFSIZ; /* space left in buffer */
int used;
char *fmt;
FILE *file;
char fmtbuf[128];
int gotfmt = 0; /* set to 1 if we got a directive from source */
char *fname = NULL;
#ifdef __UNIXOS2__
int i;
#endif
fmt = NULL;
/* If you have a command line option that gives a setting for fmt,
set it here. */
if (!fmt) {
/* This is the tricky bit: extract a format string from the source file
* Annoyingly, filename might be relative or absolute. We cheat and
* use system to get the thing to a known absoute filename.
*/
if (filename[0] == '/') {
fname = filename;
} else {
fname = malloc(strlen(path) + 1 + strlen(filename) + 1);
if (!fname)
return FALSE;
sprintf(fname, "%s/%s", path, filename);
}
if ((file = fopen(fname, "r")) &&
(fgets(fmtbuf, sizeof(fmtbuf), file)) &&
(!memcmp(fmtbuf, "'\\\" ", 4))) {
/* that's squote-backslash-dquote-space */
int len;
fmt = fmtbuf + 3;
len = strlen(fmt);
if (len && (fmt[len-1] == '\n')) {
fmt[len-1] = 0;
gotfmt++;
}
}
if (fname && fname != filename)
free(fname);
if (!gotfmt) /* not there or some error */
{
fmt = getenv("MANROFFSEQ");
}
}
if (!fmt)
{
fmt = DEFAULT_MANROFFSEQ;
}
/* Start with the first fixed part of the command line */
#ifdef __UNIXOS2__
for (i = 0; i < strlen(path); i++) {
if (path[i] == '/')
path[i] = '\\';
}
used = snprintf(c, left, "cd %s & %s %s ", path, ZSOELIM, filename);
#else
used = snprintf(c, left, "cd %s; %s %s ", path, ZSOELIM, filename);
#endif
left -= used;
c += used;
if (left <= 1)
return (FALSE);
/* Now add preprocessors of the form '| processor' */
for ( ; *fmt; fmt++)
{
char *filter;
switch (*fmt)
{
case 'e':
filter = EQN;
break;
case 'g':
filter = GRAP;
break;
case 'p':
filter = PIC;
break;
case 't':
filter = TBL;
break;
case 'v':
filter = VGRIND;
break;
case 'r':
filter = REFER;
break;
default:
filter = NULL;
break;
}
if (filter)
{
used = snprintf(c, left, " | %s ", filter);
left -= used;
c += used;
if (left <= 1)
return (FALSE);
}
}
/* Now add the fixed trailing part 'formatprog > tempfile 2> /dev/null' */
#ifdef __UNIXOS2__
used = snprintf(c, left, " | %s > %s 2>NUL", FORMAT, tempfile);
#else
#ifndef HAS_MKSTEMP
used = snprintf(c, left, " | %s > %s 2>/dev/null", FORMAT, tempfile);
#else
used = snprintf(c, left, " | %s >> %s 2>/dev/null", FORMAT, tempfile);
#endif
#endif /* __UNIXOS2__ */
left -= used;
if (left <= 1)
return (FALSE);
return (TRUE);
}
#endif /* HANDLE_ROFFSEQ */
/* Function Name: UncompressUnformatted
* Description: Finds an uncompressed unformatted manual page.
* Arguments: man_globals - the psuedo global structure.
* entry - the manual page entry.
* RETURNED filename - location to put the name of the file.
* Returns: TRUE if the file was found.
*/
static Boolean
#ifndef HAS_MKSTEMP
UncompressUnformatted(ManpageGlobals * man_globals, char * entry,
char * filename)
#else
UncompressUnformatted(ManpageGlobals * man_globals, char * entry,
char * filename, FILE **file)
#endif
{
char path[BUFSIZ], page[BUFSIZ], section[BUFSIZ], input[BUFSIZ];
int len_cat = strlen(CAT), len_man = strlen(MAN);
#if defined(SMAN) && defined(SFORMAT)
int len_sman = strlen(SMAN);
#endif
ParseEntry(entry, path, section, page);
man_globals->bzip2 = FALSE;
man_globals->lzma = FALSE;
#if defined(__OpenBSD__) || defined(__NetBSD__)
/*
* look for uncompressed file in machine subdir first
*/
snprintf(filename, BUFSIZ, "%s/%s%s/%s/%s", path, MAN,
section + len_cat, MACHINE, page);
if ( access( filename, R_OK ) == 0 ) {
man_globals->compress = FALSE;
man_globals->gzip = FALSE;
man_globals->deletetempfile = FALSE;
snprintf(man_globals->save_file, sizeof(man_globals->save_file),
"%s/%s%s/%s/%s", path, CAT, section + len_cat, MACHINE, page);
return(TRUE);
}
/*
* Then for compressed files in an uncompressed directory.
*/
snprintf(input, sizeof(input), "%s.%s", filename, COMPRESSION_EXTENSION);
#ifndef HAS_MKSTEMP
if ( UncompressNamed(man_globals, input, filename) ) {
#else
if ( UncompressNamed(man_globals, input, filename, file) ) {
#endif
man_globals->compress = TRUE;
man_globals->deletetempfile = TRUE;
snprintf(man_globals->save_file, sizeof(man_globals->save_file),
"%s/%s%s/%s.%s", path, CAT, section + len_cat, page,
COMPRESSION_EXTENSION);
return(TRUE);
}
#ifdef GZIP_EXTENSION
else {
snprintf(input, sizeof(input), "%s.%s", filename, GZIP_EXTENSION);
#ifndef HAS_MKSTEMP
if ( UncompressNamed(man_globals, input, filename) ) {
#else
if ( UncompressNamed(man_globals, input, filename, file) ) {
#endif
man_globals->compress = TRUE;
man_globals->gzip = TRUE;
man_globals->deletetempfile = TRUE;
snprintf(man_globals->save_file, sizeof(man_globals->save_file),
"%s/%s%s/%s.%s", path, CAT, section + len_cat, page,
GZIP_EXTENSION);
return(TRUE);
}
}
#endif /* GZIP_EXTENSION */
#endif /* __OpenBSD__ || __NetBSD__ */
#ifdef BZIP2_EXTENSION
{
sprintf(input, "%s.%s", filename, BZIP2_EXTENSION);
#ifndef HAS_MKSTEMP
if ( UncompressNamed(man_globals, input, filename) ) {
#else
if ( UncompressNamed(man_globals, input, filename, file) ) {
#endif
man_globals->compress = TRUE;
man_globals->gzip = FALSE;
man_globals->bzip2 = TRUE;
sprintf(man_globals->save_file, "%s/%s%s/%s.%s", path,
CAT, section + len_cat, page, BZIP2_EXTENSION);
return(TRUE);
}
}
#endif /* BZIP2_EXTENSION */
#ifdef LZMA_EXTENSION
{
sprintf(input, "%s.%s", filename, LZMA_EXTENSION);
#ifndef HAS_MKSTEMP
if ( UncompressNamed(man_globals, input, filename) ) {
#else
if ( UncompressNamed(man_globals, input, filename, file) ) {
#endif
man_globals->compress = TRUE;
man_globals->gzip = FALSE;
man_globals->lzma = TRUE;
sprintf(man_globals->save_file, "%s/%s%s/%s.%s", path,
CAT, section + len_cat, page, LZMA_EXTENSION);
return(TRUE);
}
}
#endif /* LZMA_EXTENSION */
/*
* Look for uncompressed file first.
*/
snprintf(filename, BUFSIZ, "%s/%s%s/%s", path, MAN, section + len_man, page);
if ( access( filename, R_OK ) == 0 ) {
man_globals->compress = FALSE;
man_globals->gzip = FALSE;
man_globals->deletetempfile = FALSE;
snprintf(man_globals->save_file, sizeof(man_globals->save_file),
"%s/%s%s/%s", path, CAT, section + len_cat, page);
return(TRUE);
}
#if defined(SMAN) && defined(SFORMAT)
/*
* Look for uncompressed sgml file next.
*/
snprintf(input, BUFSIZ, "%s/%s%s/%s", path, SMAN, section + len_sman, page);
#ifndef HAS_MKSTEMP
if ( SgmlToRoffNamed(man_globals, input, filename) ) {
#else
if ( SgmlToRoffNamed(man_globals, input, filename, file) ) {
#endif
man_globals->compress = FALSE;
man_globals->gzip = FALSE;
man_globals->deletetempfile = TRUE;
snprintf(man_globals->save_file, sizeof(man_globals->save_file),
"%s/%s%s/%s", path, CAT, section + len_cat, page);
return(TRUE);
}
#endif
/*
* Then for compressed files in an uncompressed directory.
*/
snprintf(input, sizeof(input), "%s.%s", filename, COMPRESSION_EXTENSION);
#ifndef HAS_MKSTEMP
if ( UncompressNamed(man_globals, input, filename) ) {
#else
if ( UncompressNamed(man_globals, input, filename, file) ) {
#endif
man_globals->compress = TRUE;
man_globals->deletetempfile = TRUE;
snprintf(man_globals->save_file, sizeof(man_globals->save_file),
"%s/%s%s/%s.%s", path, CAT, section + len_cat, page,
COMPRESSION_EXTENSION);
return(TRUE);
}
#ifdef GZIP_EXTENSION
else {
snprintf(input, sizeof(input), "%s.%s", filename, GZIP_EXTENSION);
#ifndef HAS_MKSTEMP
if ( UncompressNamed(man_globals, input, filename) ) {
#else
if ( UncompressNamed(man_globals, input, filename, file) ) {
#endif
man_globals->compress = TRUE;
man_globals->gzip = TRUE;
man_globals->deletetempfile = TRUE;
snprintf(man_globals->save_file, sizeof(man_globals->save_file),
"%s/%s%s/%s.%s", path, CAT, section + len_cat, page,
GZIP_EXTENSION);
return(TRUE);
}
}
#endif
#ifdef BZIP2_EXTENSION
{
sprintf(input, "%s.%s", filename, BZIP2_EXTENSION);
#ifndef HAS_MKSTEMP
if ( UncompressNamed(man_globals, input, filename) ) {
#else
if ( UncompressNamed(man_globals, input, filename, file) ) {
#endif
man_globals->compress = TRUE;
man_globals->gzip = TRUE;
sprintf(man_globals->save_file, "%s/%s%s/%s.%s", path,
CAT, section + len_cat, page, BZIP2_EXTENSION);
return(TRUE);
}
}
#endif
#ifdef LZMA_EXTENSION
{
sprintf(input, "%s.%s", filename, LZMA_EXTENSION);
#ifndef HAS_MKSTEMP
if ( UncompressNamed(man_globals, input, filename) ) {
#else
if ( UncompressNamed(man_globals, input, filename, file) ) {
#endif
man_globals->compress = TRUE;
man_globals->lzma = TRUE;
sprintf(man_globals->save_file, "%s/%s%s/%s.%s", path,
CAT, section + len_cat, page, LZMA_EXTENSION);
return(TRUE);
}
}
#endif
/*
* And lastly files in a compressed directory.
*/
snprintf(input, sizeof(input), "%s/%s%s.%s/%s", path,
MAN, section + len_man, COMPRESSION_EXTENSION, page);
#ifndef HAS_MKSTEMP
if ( UncompressNamed(man_globals, input, filename) ) {
#else
if ( UncompressNamed(man_globals, input, filename, file) ) {
#endif
man_globals->compress = TRUE;
man_globals->deletetempfile = TRUE;
snprintf(man_globals->save_file, sizeof(man_globals->save_file),
"%s/%s%s.%s/%s", path, CAT, section + len_cat,
COMPRESSION_EXTENSION, page);
return(TRUE);
}
return(FALSE);
}
/* Function Name: AddCursor
* Description: This function adds the cursor to the window.
* Arguments: w - the widget to add the cursor to.
* cursor - the cursor to add to this widget.
* Returns: none
*/
void
AddCursor(Widget w, Cursor cursor)
{
XColor colors[2];
Arg args[10];
Cardinal num_args = 0;
Colormap c_map;
if (!XtIsRealized(w)) {
PopupWarning(NULL, "Widget is not realized, no cursor added.\n");
return;
}
XtSetArg( args[num_args], XtNcolormap, &c_map); num_args++;
XtGetValues( w, args, num_args);
colors[0].pixel = resources.cursors.fg_color;
colors[1].pixel = resources.cursors.bg_color;
XQueryColors (XtDisplay(w), c_map, colors, 2);
XRecolorCursor(XtDisplay(w), cursor, colors, colors+1);
XDefineCursor(XtDisplay(w),XtWindow(w),cursor);
}
/* Function Name: ChangeLabel
* Description: This function changes the label field of the
* given widget to the string in str.
* Arguments: w - the widget.
* str - the string to change the label to.
* Returns: none
*/
void
ChangeLabel(Widget w, char * str)
{
Arg arglist[3]; /* An argument list. */
if (w == NULL) return;
XtSetArg(arglist[0], XtNlabel, str);
/* shouldn't really have to do this. */
XtSetArg(arglist[1], XtNwidth, 0);
XtSetArg(arglist[2], XtNheight, 0);
XtSetValues(w, arglist, (Cardinal) 1);
}
/*
* In an ideal world this would be part of the XToolkit, and I would not
* have to do it, but such is life sometimes. Perhaps in X11R3.
*/
/* Function Name: PositionCenter
* Description: This function positions the given widgets center
* in the following location.
* Arguments: widget - the widget widget to postion
* x,y - The location for the center of the widget
* above - number of pixels above center to locate this widget
* left - number of pixels left of center to locate this widget
* h_space, v_space - how close to get to the edges of the
* parent window.
* Returns: none
* Note: This should only be used with a popup widget that has override
* redirect set.
*/
void
PositionCenter(Widget widget, int x, int y, int above, int left, int v_space, int h_space)
{
Arg wargs[2];
int x_temp,y_temp; /* location of the new window. */
int parent_height,parent_width; /* Height and width of the parent widget or
the root window if it has no parent. */
x_temp = x - left - Width(widget) / 2 + BorderWidth(widget);
y_temp = y - above - Height(widget) / 2 + BorderWidth(widget);
parent_height = HeightOfScreen(XtScreen(widget));
parent_width = WidthOfScreen(XtScreen(widget));
/*
* Check to make sure that all edges are within the viewable part of the
* root window, and if not then force them to be.
*/
if (x_temp < h_space)
x_temp = v_space;
if (y_temp < v_space)
(y_temp = 2);
if ( y_temp + Height(widget) + v_space > parent_height )
y_temp = parent_height - Height(widget) - v_space;
if ( x_temp + Width(widget) + h_space > parent_width )
x_temp = parent_width - Width(widget) - h_space;
XtSetArg(wargs[0], XtNx, x_temp);
XtSetArg(wargs[1], XtNy, y_temp);
XtSetValues(widget, wargs, 2);
}
/* Function Name: ParseEntry(entry, path, sect, page)
* Description: Parses the manual pages entry filenames.
* Arguments: str - the full path name.
* path - the path name. RETURNED
* sect - the section name. RETURNED
* page - the page name. RETURNED
* Returns: none.
*/
void
ParseEntry(char *entry, char *path, char *sect, char *page)
{
char *c, temp[BUFSIZ];
strcpy(temp, entry);
c = rindex(temp, '/');
if (c == NULL)
PrintError("index failure in ParseEntry.");
*c++ = '\0';
if (page != NULL)
strcpy(page, c);
c = rindex(temp, '/');
if (c == NULL)
PrintError("index failure in ParseEntry.");
*c++ = '\0';
#if defined(SFORMAT) && defined(SMAN)
/* sgmltoroff sometimes puts an extra ./ in the path to .so entries */
if (strcmp(c, ".") == 0) {
c = rindex(temp, '/');
if (c == NULL)
PrintError("index failure in ParseEntry.");
*c++ = '\0';
}
#endif
#if defined(__OpenBSD__) || defined(__NetBSD__)
/* Skip machine subdirectory if present */
if (strcmp(c, MACHINE) == 0) {
c = rindex(temp, '/');
if (c == NULL)
PrintError("index failure in ParseEntry.");
*c++ = '\0';
}
#endif
if (sect != NULL)
strcpy(sect, c);
if (path != NULL)
strcpy(path, temp);
}
/* Function Name: GetGlobals
* Description: Gets the psuedo globals associated with the
* manpage associated with this widget.
* Arguments: w - a widget in the manpage.
* Returns: the psuedo globals.
* Notes: initial_widget is a globals variable.
* manglobals_context is a global variable.
*/
ManpageGlobals *
GetGlobals(Widget w)
{
Widget temp;
caddr_t data;
while ( (temp = XtParent(w)) != initial_widget && (temp != NULL))
w = temp;
if (temp == NULL)
XtAppError(XtWidgetToApplicationContext(w),
"Xman: Could not locate widget in tree, exiting");
if (XFindContext(XtDisplay(w), XtWindow(w),
manglobals_context, &data) != XCSUCCESS)
XtAppError(XtWidgetToApplicationContext(w),
"Xman: Could not find global data, exiting");
return( (ManpageGlobals *) data);
}
/* Function Name: SaveGlobals
* Description: Saves the psuedo globals on the widget passed
* to this function, although GetGlobals assumes that
* the data is associated with the popup child of topBox.
* Arguments: w - the widget to associate the data with.
* globals - data to associate with this widget.
* Returns: none.
* Notes: WIDGET MUST BE REALIZED.
* manglobals_context is a global variable.
*/
void
SaveGlobals(Widget w, ManpageGlobals * globals)
{
if (XSaveContext(XtDisplay(w), XtWindow(w), manglobals_context,
(caddr_t) globals) != XCSUCCESS)
XtAppError(XtWidgetToApplicationContext(w),
"Xman: Could not save global data, are you out of memory?");
}
/* Function Name: RemoveGlobals
* Description: Removes the psuedo globals from the widget passed
* to this function.
* Arguments: w - the widget to remove the data from.
* Returns: none.
* Notes: WIDGET MUST BE REALIZED.
* manglobals_context is a global variable.
*/
void
RemoveGlobals(Widget w)
{
if (XDeleteContext(XtDisplay(w), XtWindow(w),
manglobals_context) != XCSUCCESS)
XtAppError(XtWidgetToApplicationContext(w),
"Xman: Could not remove global data?");
}
