1141 lines
31 KiB
C
1141 lines
31 KiB
C
/*
|
||
|
||
Copyright 1991, 1998 The Open Group
|
||
|
||
Permission to use, copy, modify, distribute, and sell this software and its
|
||
documentation for any purpose is hereby granted without fee, provided that
|
||
the above copyright notice appear in all copies and that both that
|
||
copyright notice and this permission notice appear in supporting
|
||
documentation.
|
||
|
||
The above copyright notice and this permission notice shall be included
|
||
in all copies or substantial portions of the Software.
|
||
|
||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
||
OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
|
||
IN NO EVENT SHALL THE OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR
|
||
OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
|
||
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
|
||
OTHER DEALINGS IN THE SOFTWARE.
|
||
|
||
Except as contained in this notice, the name of The Open Group shall
|
||
not be used in advertising or otherwise to promote the sale, use or
|
||
other dealings in this Software without prior written authorization
|
||
from The Open Group.
|
||
|
||
*/
|
||
|
||
#include "config.h"
|
||
|
||
#include <stdlib.h> /* for exit() and abs() */
|
||
#include <stdio.h>
|
||
|
||
#include <X11/Intrinsic.h>
|
||
#include <X11/StringDefs.h>
|
||
#include <X11/Xaw/Paned.h>
|
||
#include <X11/Xaw/Command.h>
|
||
#include <X11/Xaw/Label.h>
|
||
#include <X11/Shell.h>
|
||
#include <X11/cursorfont.h>
|
||
#include <X11/Xmu/Error.h>
|
||
#include "RootWin.h"
|
||
#include "Scale.h"
|
||
#include "CutPaste.h"
|
||
|
||
#define SRCWIDTH 64
|
||
#define SRCHEIGHT 64
|
||
|
||
#ifndef min
|
||
#define min(a, b) ((a) < (b) ? (a) : (b))
|
||
#endif
|
||
|
||
#ifndef max
|
||
#define max(a, b) ((a) > (b) ? (a) : (b))
|
||
#endif
|
||
|
||
|
||
|
||
/* highlight interval (in milliseconds) */
|
||
#define HLINTERVAL 100
|
||
|
||
/* sleep between draw & erase of highlight
|
||
* 20 milliseconds - enough for screen refresh - not too long to annoy users
|
||
* since we hold a server grab during this time
|
||
*/
|
||
#define HLSLEEPINTERVAL 20 /* milliseconds */
|
||
|
||
#ifdef HAVE_NANOSLEEP
|
||
#include <time.h>
|
||
#define HLSLEEP do { \
|
||
struct timespec sleeptime = { 0 , HLSLEEPINTERVAL * 1000000 } ; \
|
||
nanosleep(&sleeptime, NULL); \
|
||
} while(0)
|
||
#elif defined(HAVE_POLL)
|
||
#include <poll.h>
|
||
#define HLSLEEP poll(NULL, 0, HLSLEEPINTERVAL)
|
||
#elif defined(HAVE_SELECT)
|
||
#include <X11/Xpoll.h>
|
||
#define HLSLEEP do { \
|
||
struct timeval sleeptime = { 0 , HLSLEEPINTERVAL * 1000 } ; \
|
||
select(0, NULL, NULL, NULL, &sleeptime); \
|
||
} while(0)
|
||
#else
|
||
#define HLSLEEP XSync(dpy, False)
|
||
#endif
|
||
|
||
/* highlight mode */
|
||
typedef enum { drag, resize, done } hlMode;
|
||
|
||
/* highlight data structure */
|
||
typedef struct {
|
||
Boolean newScale;
|
||
hlMode selectMode;
|
||
GC gc;
|
||
XWindowAttributes win_info;
|
||
XImage *image;
|
||
Position homeX, homeY, x, y;
|
||
Dimension width, height;
|
||
Widget scaleShell, scaleInstance, pixShell, pixLabel, cmapWinList [2];
|
||
} hlStruct, *hlPtr;
|
||
|
||
|
||
|
||
/* global variables */
|
||
static XtAppContext app;
|
||
static Cursor ulAngle, urAngle, lrAngle, llAngle;
|
||
static Display *dpy;
|
||
static int scr;
|
||
static GC selectGC;
|
||
static XGCValues selectGCV;
|
||
static Widget toplevel, root;
|
||
static Atom wm_delete_window;
|
||
static int numXmags = 0;
|
||
static int srcStat, srcX, srcY;
|
||
static unsigned int srcWidth, srcHeight;
|
||
|
||
/* forward declarations */
|
||
|
||
static int Error(Display *, XErrorEvent *);
|
||
static void CloseAP(Widget, XEvent *, String *, Cardinal *);
|
||
static void SetCmapPropsAP(Widget, XEvent *, String *, Cardinal *);
|
||
static void UnsetCmapPropsAP(Widget, XEvent *, String *, Cardinal *);
|
||
static void NewAP(Widget, XEvent *, String *, Cardinal *);
|
||
static void ReplaceAP(Widget, XEvent *, String *, Cardinal *);
|
||
static void PopupPixelAP(Widget, XEvent *, String *, Cardinal *);
|
||
static void UpdatePixelAP(Widget, XEvent *, String *, Cardinal *);
|
||
static void PopdownPixelAP(Widget, XEvent *, String *, Cardinal *);
|
||
static void SelectRegionAP(Widget, XEvent *, String *, Cardinal *);
|
||
static void CheckPoints(Position *, Position *, Position *, Position *);
|
||
static void HighlightTO(XtPointer, XtIntervalId *);
|
||
static void CloseCB(Widget, XtPointer, XtPointer);
|
||
static void ReplaceCB(Widget, XtPointer, XtPointer);
|
||
static void NewCB(Widget, XtPointer, XtPointer);
|
||
static void SelectCB(Widget, XtPointer, XtPointer);
|
||
static void PasteCB(Widget, XtPointer, XtPointer);
|
||
static void SetupGC(void);
|
||
static Window FindWindow(int, int);
|
||
static void ResizeEH(Widget, XtPointer, XEvent *, Boolean *);
|
||
static void DragEH(Widget, XtPointer, XEvent *, Boolean *);
|
||
static void StartRootPtrGrab(int, hlPtr);
|
||
static void CreateRoot(void);
|
||
static void GetImageAndAttributes(Window, int, int, int, int, hlPtr);
|
||
static int Get_XColors(XWindowAttributes *, XColor **);
|
||
static Pixel GetMaxIntensity(hlPtr);
|
||
static Pixel GetMinIntensity(hlPtr);
|
||
static void PopupNewScale(hlPtr);
|
||
static void RedoOldScale(hlPtr);
|
||
static void InitCursors(void);
|
||
static void ParseSourceGeom(void);
|
||
|
||
/* application resources */
|
||
|
||
typedef struct { String geometry, source, mag, title; } OptionsRec;
|
||
static OptionsRec options;
|
||
|
||
#define Offset(field) XtOffsetOf(OptionsRec, field)
|
||
static XtResource resources[] = {
|
||
{"geometry", "Geometry", XtRString, sizeof(String),
|
||
Offset(geometry), XtRString, (XtPointer)NULL},
|
||
{"mag", "Mag", XtRString, sizeof(String),
|
||
Offset(mag), XtRString, (XtPointer)"5.0"},
|
||
{"source", "Source", XtRString, sizeof(String),
|
||
Offset(source), XtRString, (XtPointer)"SRCWIDTHxSRCHEIGHT"},
|
||
{"title", XtCString, XtRString, sizeof(char *),
|
||
Offset(title), XtRString, "xmag"},
|
||
};
|
||
#undef Offset
|
||
|
||
static XrmOptionDescRec optionDesc[] = {
|
||
{"-bd", "*borderColor", XrmoptionSepArg, (XtPointer)NULL},
|
||
{"-bg", "*background", XrmoptionSepArg, (XtPointer)NULL},
|
||
{"-bw", "*borderWidth", XrmoptionSepArg, (XtPointer)NULL},
|
||
|
||
{"-geometry", "*geometry", XrmoptionSepArg, (XtPointer)NULL},
|
||
{"-mag", "*mag", XrmoptionSepArg, (XtPointer)NULL},
|
||
{"-source", "*source", XrmoptionSepArg, (XtPointer)NULL},
|
||
{"-title", "*title", XrmoptionSepArg, (XtPointer)NULL},
|
||
};
|
||
|
||
|
||
|
||
/* action table */
|
||
|
||
static XtActionsRec actions_table[] = {
|
||
{"close", CloseAP},
|
||
{"set-colors", SetCmapPropsAP},
|
||
{"unset-colors", UnsetCmapPropsAP},
|
||
{"new", NewAP},
|
||
{"replace", ReplaceAP},
|
||
{"popup-pixel", PopupPixelAP},
|
||
{"update-pixel", UpdatePixelAP},
|
||
{"popdown-pixel", PopdownPixelAP},
|
||
{"select-region", SelectRegionAP}
|
||
};
|
||
|
||
|
||
|
||
/*
|
||
* Error() -- Error handler: Catch a bad match in magnifying an
|
||
* area that contains bits of different depths.
|
||
*/
|
||
static int
|
||
Error(Display *dpy, XErrorEvent *err)
|
||
{
|
||
(void) XmuPrintDefaultErrorMessage (dpy, err, stderr);
|
||
return 0;
|
||
}
|
||
|
||
|
||
/*
|
||
* CloseAP() -- Close this dialog. If its the last one exit the program.
|
||
*
|
||
*/
|
||
static void /* ARGSUSED */
|
||
CloseAP(Widget w, XEvent *event, String *params, Cardinal *num_params)
|
||
{
|
||
Arg wargs[2]; int n; hlPtr data;
|
||
if (!--numXmags) exit(0);
|
||
if (event->type != ClientMessage) {
|
||
n = 0; /* get user data */
|
||
XtSetArg(wargs[0], XtNuserData, &data); n++;
|
||
XtGetValues(w, wargs, n);
|
||
w = data->scaleShell;
|
||
}
|
||
XtPopdown(w);
|
||
XtDestroyWidget(w);
|
||
}
|
||
|
||
|
||
|
||
/*
|
||
* SetCmapPropsAP() -- Put the scale widget first in WM_COLORMAP_WINDOWS
|
||
*
|
||
*/
|
||
static void /* ARGSUSED */
|
||
SetCmapPropsAP(Widget w, XEvent *event, String *params, Cardinal *num_params)
|
||
{
|
||
Arg wargs[2]; int n; hlPtr data;
|
||
n = 0; /* get user data */
|
||
XtSetArg(wargs[0], XtNuserData, &data); n++;
|
||
XtGetValues(w, wargs, n);
|
||
if (data->win_info.colormap != DefaultColormap(dpy, scr)) {
|
||
data->cmapWinList[0] = data->scaleInstance;
|
||
data->cmapWinList[1] = data->scaleShell;
|
||
XtSetWMColormapWindows(data->scaleShell, data->cmapWinList, 2);
|
||
}
|
||
}
|
||
|
||
|
||
|
||
/*
|
||
* UnsetCmapPropsAP() -- Put the shell first in WM_COLORMAP_WINDOWS
|
||
*
|
||
*/
|
||
static void /* ARGSUSED */
|
||
UnsetCmapPropsAP(Widget w, XEvent *event, String *params, Cardinal *num_params)
|
||
{
|
||
Arg wargs[2]; int n; hlPtr data;
|
||
n = 0; /* get user data */
|
||
XtSetArg(wargs[0], XtNuserData, &data); n++;
|
||
XtGetValues(w, wargs, n);
|
||
if (data->win_info.colormap != DefaultColormap(dpy, scr)) {
|
||
data->cmapWinList[0] = data->scaleShell;
|
||
data->cmapWinList[1] = data->scaleInstance;
|
||
XtSetWMColormapWindows(data->scaleShell, data->cmapWinList, 2);
|
||
}
|
||
}
|
||
|
||
|
||
|
||
/*
|
||
* NewAP() -- Create an additional xmag dialog. THIS IS A COPY OF NewEH
|
||
* FIND A BETTER WAY....
|
||
*/
|
||
static void /* ARGSUSED */
|
||
NewAP(Widget w, XEvent *event, String *params, Cardinal *num_params)
|
||
{
|
||
StartRootPtrGrab(True, NULL);
|
||
}
|
||
|
||
|
||
|
||
/*
|
||
* ReplaceAP() -- Replace this particular xmag dialog.
|
||
*/
|
||
static void /* ARGSUSED */
|
||
ReplaceAP(Widget w, XEvent *event, String *params, Cardinal *num_params)
|
||
{
|
||
Arg wargs[2]; int n; hlPtr data;
|
||
n = 0; /* get user data */
|
||
XtSetArg(wargs[0], XtNuserData, &data); n++;
|
||
XtGetValues(w, wargs, n);
|
||
StartRootPtrGrab(False, data);
|
||
}
|
||
|
||
|
||
|
||
/*
|
||
* PopupPixelAP() -- Show pixel information.
|
||
*/
|
||
static void /* ARGSUSED */
|
||
PopupPixelAP(Widget w, XEvent *event, String *params, Cardinal *num_params)
|
||
{
|
||
Position scale_x, scale_y;
|
||
Dimension scale_height;
|
||
Position label_x, label_y;
|
||
Dimension label_height;
|
||
int n;
|
||
Arg wargs[3];
|
||
hlPtr data;
|
||
|
||
n = 0; /* get user data */
|
||
XtSetArg(wargs[0], XtNuserData, &data); n++;
|
||
XtGetValues(w, wargs, n);
|
||
|
||
n = 0;
|
||
XtSetArg(wargs[n], XtNheight, &scale_height); n++;
|
||
XtGetValues(w, wargs, n);
|
||
XtTranslateCoords(w, -1, -1, &scale_x, &scale_y);
|
||
|
||
XtRealizeWidget(data->pixShell); /* to get the right height */
|
||
|
||
n = 0;
|
||
XtSetArg(wargs[n], XtNheight, &label_height); n++;
|
||
XtGetValues(data->pixShell, wargs, n);
|
||
|
||
if ((double) event->xbutton.y / (double) scale_height > 0.5) {
|
||
label_x = scale_x;
|
||
label_y = scale_y;
|
||
}
|
||
else {
|
||
label_x = scale_x;
|
||
label_y = scale_y + scale_height - label_height;
|
||
}
|
||
|
||
n = 0;
|
||
XtSetArg(wargs[n], XtNx, label_x); n++;
|
||
XtSetArg(wargs[n], XtNy, label_y); n++;
|
||
XtSetValues(data->pixShell, wargs, n);
|
||
|
||
UpdatePixelAP(w, event, NULL, NULL);
|
||
}
|
||
|
||
|
||
|
||
/*
|
||
* UpdatePixelAP() -- Update pixel information.
|
||
*/
|
||
static void /* ARGSUSED */
|
||
UpdatePixelAP(Widget w, XEvent *event, String *params, Cardinal *num_params)
|
||
{
|
||
Position x, y;
|
||
Pixel pixel;
|
||
XColor color;
|
||
int n;
|
||
Arg wargs[3];
|
||
char string[80];
|
||
hlPtr data;
|
||
|
||
n = 0;
|
||
XtSetArg(wargs[0], XtNuserData, &data); n++;
|
||
XtGetValues(w, wargs, n);
|
||
|
||
if (SWGetImagePixel(w, event->xbutton.x, event->xbutton.y, &x, &y, &pixel))
|
||
XtPopdown(data->pixShell);
|
||
else {
|
||
color.pixel = pixel;
|
||
XQueryColor(dpy, data->win_info.colormap, &color);
|
||
snprintf(string, sizeof(string),
|
||
"Pixel %ld at (%d,%d) colored (%x,%x,%x).",
|
||
pixel, x + data->x, y + data->y,
|
||
color.red, color.green, color.blue);
|
||
n = 0;
|
||
XtSetArg(wargs[n], XtNlabel, string); n++;
|
||
XtSetValues(data->pixLabel, wargs, n);
|
||
XtPopup(data->pixShell, XtGrabNone);
|
||
}
|
||
}
|
||
|
||
|
||
|
||
/*
|
||
* PopdownPixelAP() -- Remove pixel info.
|
||
*/
|
||
static void /* ARGSUSED */
|
||
PopdownPixelAP(Widget w, XEvent *event, String *params, Cardinal *num_params)
|
||
{
|
||
int n;
|
||
Arg wargs[3];
|
||
hlPtr data = NULL;
|
||
|
||
n = 0;
|
||
XtSetArg(wargs[0], XtNuserData, &data); n++;
|
||
XtGetValues(w, wargs, n);
|
||
|
||
if (data)
|
||
XtPopdown(data->pixShell);
|
||
}
|
||
|
||
|
||
|
||
static void /* ARGSUSED */
|
||
SelectRegionAP(Widget w, XEvent *event, String *params, Cardinal *num_params)
|
||
{
|
||
/***** NOT SURE WHAT TO DO WITH THIS
|
||
if (app_resources.unmap)
|
||
XtUnmapWidget(toplevel);
|
||
Redisplay(XtDisplay(w), RootWindow(XtDisplay(w),
|
||
DefaultScreen(XtDisplay(w))),
|
||
source.width, source.height,
|
||
app_resources.freq, app_resources.puls,
|
||
ul_angle, lr_angle,
|
||
app_resources.grab);
|
||
|
||
if (app_resources.unmap)
|
||
XtMapWidget(toplevel);
|
||
******/
|
||
}
|
||
|
||
|
||
|
||
/*
|
||
* CheckPoints() -- Change the cursor for the correct quadrant.
|
||
* Make sure the first point is less than the second
|
||
* for drawing the selection rectangle.
|
||
*
|
||
*/
|
||
static void
|
||
CheckPoints(Position *x1, Position *x2, Position *y1, Position *y2)
|
||
{
|
||
Position tmp;
|
||
Boolean above, left;
|
||
Cursor newC;
|
||
above = (*y2 < *y1); left = (*x2 < *x1);
|
||
if (above&&left) newC = ulAngle;
|
||
else if (above&&!left) newC = urAngle;
|
||
else if (!above&&!left) newC = lrAngle;
|
||
else newC = llAngle;
|
||
XChangeActivePointerGrab
|
||
(dpy, PointerMotionMask|ButtonPressMask|ButtonReleaseMask,
|
||
newC, CurrentTime);
|
||
if (*x2 < *x1) { tmp = *x1; *x1 = *x2; *x2 = tmp; }
|
||
if (*y2 < *y1) { tmp = *y1; *y1 = *y2; *y2 = tmp; }
|
||
}
|
||
|
||
|
||
|
||
/*
|
||
* HighlightTO() -- Timer to highlight the selection box
|
||
*/
|
||
static void
|
||
HighlightTO(XtPointer closure, XtIntervalId *id) /* ARGSUSED */
|
||
{
|
||
hlPtr data = (hlPtr)closure;
|
||
XGrabServer(dpy);
|
||
if (data->selectMode == drag) {
|
||
XDrawRectangle(dpy, DefaultRootWindow(dpy), data->gc,
|
||
data->x, data->y, data->width, data->height);
|
||
XFlush(dpy);
|
||
HLSLEEP;
|
||
XDrawRectangle(dpy, DefaultRootWindow(dpy), data->gc,
|
||
data->x, data->y, data->width, data->height);
|
||
}
|
||
else if (data->selectMode == resize) {
|
||
Position x1 = data->homeX,
|
||
x2 = data->x,
|
||
y1 = data->homeY,
|
||
y2 = data->y;
|
||
CheckPoints(&x1, &x2, &y1, &y2);
|
||
XDrawRectangle(dpy, DefaultRootWindow(dpy), data->gc,
|
||
x1, y1, x2 - x1, y2 - y1);
|
||
XFlush(dpy);
|
||
HLSLEEP;
|
||
XDrawRectangle(dpy, DefaultRootWindow(dpy), data->gc,
|
||
x1, y1, x2 - x1, y2 - y1);
|
||
}
|
||
XUngrabServer(dpy);
|
||
if (data->selectMode != done)
|
||
XtAppAddTimeOut(app, HLINTERVAL, HighlightTO, (XtPointer)data);
|
||
}
|
||
|
||
|
||
|
||
/*
|
||
* CloseCB() -- Delete this xmag dialog. If its the only one on the screen
|
||
* then exit.
|
||
*/
|
||
static void /* ARGSUSED */
|
||
CloseCB(Widget w, XtPointer clientData, XtPointer callData)
|
||
{
|
||
Widget shell = (Widget)clientData;
|
||
if (!--numXmags) exit(0);
|
||
XtPopdown(shell);
|
||
XtDestroyWidget(shell);
|
||
}
|
||
|
||
|
||
|
||
/*
|
||
* ReplaceCB() -- Replace this particular xmag dialog.
|
||
*/
|
||
static void /* ARGSUSED */
|
||
ReplaceCB(Widget w, XtPointer clientData, XtPointer callData)
|
||
{
|
||
hlPtr data = (hlPtr)clientData;
|
||
StartRootPtrGrab(False, data);
|
||
}
|
||
|
||
|
||
|
||
/*
|
||
* NewCB() -- Create an additional xmag dialog.
|
||
*/
|
||
static void /* ARGSUSED */
|
||
NewCB(Widget w, XtPointer clientData, XtPointer callData)
|
||
{
|
||
StartRootPtrGrab(True, NULL);
|
||
}
|
||
|
||
|
||
|
||
/*
|
||
* SelectCB() -- Own the primary selection.
|
||
*/
|
||
static void /* ARGSUSED */
|
||
SelectCB(Widget w, XtPointer clientData, XtPointer callData)
|
||
{
|
||
hlPtr data = (hlPtr)clientData;
|
||
SWGrabSelection(data->scaleInstance, XtLastTimestampProcessed(dpy));
|
||
}
|
||
|
||
|
||
|
||
/*
|
||
* PasteCB() -- Paste from the primary selectin into xmag.
|
||
*/
|
||
static void /* ARGSUSED */
|
||
PasteCB(Widget w, XtPointer clientData, XtPointer callData)
|
||
{
|
||
hlPtr data = (hlPtr)clientData;
|
||
SWRequestSelection(data->scaleInstance, XtLastTimestampProcessed(dpy));
|
||
}
|
||
|
||
|
||
|
||
/*
|
||
* SetupGC() -- Graphics context for magnification selection.
|
||
*/
|
||
static void
|
||
SetupGC(void)
|
||
{
|
||
selectGCV.function = GXxor;
|
||
selectGCV.foreground = 0xffffffff;
|
||
selectGCV.subwindow_mode = IncludeInferiors;
|
||
selectGC = XtGetGC(toplevel, GCFunction|GCForeground|GCSubwindowMode,
|
||
&selectGCV);
|
||
}
|
||
|
||
|
||
|
||
/*
|
||
* FindWindow() -- Determine window the pointer is over.
|
||
*
|
||
*/
|
||
static Window
|
||
FindWindow(int x, int y) /* Location of cursor */
|
||
{
|
||
XWindowAttributes wa;
|
||
Window findW = DefaultRootWindow(dpy), stopW, childW;
|
||
|
||
/* Setup for first window find */
|
||
stopW = findW;
|
||
|
||
while (stopW) {
|
||
XTranslateCoordinates(dpy, findW, stopW,
|
||
x, y, &x, &y, &childW);
|
||
findW = stopW;
|
||
/* If child is not InputOutput (for example, InputOnly) */
|
||
/* then don't continue, return the present findW which */
|
||
/* can be the root, or a root child of class InputOutput */
|
||
if (childW &&
|
||
XGetWindowAttributes(dpy, childW, &wa) &&
|
||
wa.class != InputOutput)
|
||
break;
|
||
stopW = childW;
|
||
}
|
||
return findW;
|
||
}
|
||
|
||
|
||
|
||
/*
|
||
* ResizeEH() -- Event Handler for resize of selection box.
|
||
*/
|
||
static void
|
||
ResizeEH(Widget w, XtPointer closure, XEvent *event,
|
||
Boolean *continue_to_dispatch) /* ARGSUSED */
|
||
{
|
||
hlPtr data = (hlPtr)closure;
|
||
switch (event->type) {
|
||
case MotionNotify:
|
||
data->x = event->xmotion.x_root;
|
||
data->y = event->xmotion.y_root;
|
||
break;
|
||
case ButtonRelease:
|
||
GetImageAndAttributes(FindWindow(event->xmotion.x_root,
|
||
event->xmotion.y_root),
|
||
min(data->homeX,event->xbutton.x_root),
|
||
min(data->homeY,event->xbutton.y_root),
|
||
abs(data->homeX - event->xbutton.x_root),
|
||
abs(data->homeY - event->xbutton.y_root),
|
||
data);
|
||
if (data->newScale)
|
||
PopupNewScale(data);
|
||
else
|
||
SWSetImage(data->scaleInstance, data->image);
|
||
XtUngrabPointer(w, CurrentTime);
|
||
/*****
|
||
XtRemoveRawEventHandler(w, PointerMotionMask|ButtonReleaseMask,
|
||
True, ResizeEH, (XtPointer)data);
|
||
*****/
|
||
XtRemoveEventHandler(w, PointerMotionMask|ButtonReleaseMask,
|
||
True, ResizeEH, (XtPointer)data);
|
||
data->selectMode = done;
|
||
break;
|
||
}
|
||
}
|
||
|
||
|
||
|
||
/*
|
||
* DragEH() -- Event Handler for dragging selection box.
|
||
*/
|
||
static void
|
||
DragEH(Widget w, XtPointer closure, XEvent *event,
|
||
Boolean *continue_to_dispatch) /* ARGSUSED */
|
||
{
|
||
hlPtr data = (hlPtr)closure;
|
||
switch (event->type) {
|
||
case MotionNotify: /* drag mode */
|
||
data->x = event->xmotion.x_root;
|
||
data->y = event->xmotion.y_root;
|
||
break;
|
||
case ButtonRelease: /* end drag mode */
|
||
if (event->xbutton.button == Button1) { /* get image */
|
||
/* Problem: You can't get bits with XGetImage outside of its window.
|
||
* xmag will only do a GetImage on the actual window in the case
|
||
* where the depth of the window does not match the depth of
|
||
* the root window.
|
||
*/
|
||
GetImageAndAttributes(FindWindow(event->xmotion.x_root,
|
||
event->xmotion.y_root),
|
||
event->xbutton.x_root,
|
||
event->xbutton.y_root,
|
||
srcWidth, srcHeight, data);
|
||
if (data->newScale)
|
||
PopupNewScale(data);
|
||
else
|
||
RedoOldScale(data);
|
||
XtUngrabPointer(w, CurrentTime);
|
||
XtRemoveRawEventHandler(w, PointerMotionMask|ButtonPressMask|
|
||
ButtonReleaseMask, True, DragEH,
|
||
(XtPointer)data);
|
||
data->selectMode = done;
|
||
}
|
||
|
||
break;
|
||
case ButtonPress:
|
||
if (event->xbutton.button == Button2) { /* turn on resize mode */
|
||
data->homeX = event->xbutton.x_root;
|
||
data->homeY = event->xbutton.y_root;
|
||
data->x = event->xbutton.x_root + srcWidth;
|
||
data->y = event->xbutton.y_root + srcHeight;
|
||
data->selectMode = resize;
|
||
XtRemoveRawEventHandler(w, PointerMotionMask|ButtonPressMask|
|
||
ButtonReleaseMask, True, DragEH, (XtPointer)data);
|
||
XChangeActivePointerGrab
|
||
(dpy, PointerMotionMask|ButtonPressMask|ButtonReleaseMask,
|
||
lrAngle, CurrentTime);
|
||
XWarpPointer(dpy, None, None, 0, 0, 0, 0,
|
||
srcWidth, srcHeight);
|
||
XtAddEventHandler(w, PointerMotionMask|ButtonReleaseMask,
|
||
True, ResizeEH, (XtPointer)data);
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
|
||
|
||
|
||
|
||
/*
|
||
* StartRootPtrGrab() -- Bring up the selection box.
|
||
*
|
||
*/
|
||
static void
|
||
StartRootPtrGrab(int new, /* do we create a new scale instance? */
|
||
hlPtr data) /* highlight data */
|
||
{
|
||
Window rootR, childR;
|
||
int rootX, rootY, winX, winY;
|
||
unsigned int mask;
|
||
hlPtr hlData;
|
||
XtGrabPointer
|
||
(root, False,
|
||
PointerMotionMask|ButtonPressMask|ButtonReleaseMask,
|
||
GrabModeAsync, GrabModeAsync, None, ulAngle, CurrentTime);
|
||
XQueryPointer(dpy, DefaultRootWindow(dpy), &rootR, &childR,
|
||
&rootX, &rootY, &winX, &winY, &mask);
|
||
if (new) {
|
||
numXmags++;
|
||
hlData = (hlPtr)XtMalloc(sizeof(hlStruct));
|
||
}
|
||
else hlData = data;
|
||
hlData->newScale = new;
|
||
hlData->selectMode = drag;
|
||
hlData->x = rootX;
|
||
hlData->y = rootY;
|
||
hlData->gc = selectGC;
|
||
hlData->width = srcWidth;
|
||
hlData->height = srcHeight;
|
||
XtAddRawEventHandler
|
||
(root, PointerMotionMask|ButtonPressMask|ButtonReleaseMask,
|
||
True, DragEH, (XtPointer)hlData);
|
||
(void) XtAppAddTimeOut(app, HLINTERVAL, HighlightTO, (XtPointer)hlData);
|
||
}
|
||
|
||
|
||
|
||
/*
|
||
* CreateRoot() -- Create a root window widget. If the user specified x and y
|
||
* in the source geometry then use this to directly get the
|
||
* image.
|
||
*/
|
||
static void
|
||
CreateRoot(void)
|
||
{
|
||
hlPtr data;
|
||
root = XtCreateWidget("root", rootWindowWidgetClass, toplevel, NULL, 0);
|
||
XtRealizeWidget(root);
|
||
if (XValue & srcStat && YValue &srcStat) {
|
||
numXmags = 1;
|
||
data = (hlPtr)XtMalloc(sizeof(hlStruct));
|
||
data = data;
|
||
data->newScale = True;
|
||
data->selectMode = drag;
|
||
data->x = srcX;
|
||
data->y = srcY;
|
||
data->gc = selectGC;
|
||
data->width = srcWidth;
|
||
data->height = srcHeight;
|
||
GetImageAndAttributes(RootWindow(dpy, scr), srcX, srcY, srcWidth,
|
||
srcHeight, data);
|
||
PopupNewScale(data);
|
||
return;
|
||
}
|
||
}
|
||
|
||
|
||
/*
|
||
* GetImageAndAttributes() -- Get the image bits from the screen.
|
||
* We will also determine here the colormap, depth, and
|
||
* visual to be used for the magnification image.
|
||
*/
|
||
static void
|
||
GetImageAndAttributes(Window w, int x, int y, int width, int height,
|
||
hlPtr data)
|
||
{
|
||
/* get parameters of window being magnified */
|
||
XGetWindowAttributes(dpy, w, &data->win_info);
|
||
|
||
if (data->win_info.depth == DefaultDepth(dpy, scr)) {
|
||
/* avoid off screen pixels */
|
||
if (x < 0)
|
||
x = 0;
|
||
if (y < 0)
|
||
y = 0;
|
||
if (x + width > DisplayWidth(dpy,scr))
|
||
x = DisplayWidth(dpy,scr) - width;
|
||
if (y + height > DisplayHeight(dpy,scr))
|
||
y = DisplayHeight(dpy,scr) - height;
|
||
data->x = x; data->y = y;
|
||
/* get image pixels */
|
||
data->image = XGetImage (dpy,
|
||
RootWindow(dpy, scr),
|
||
x, y,
|
||
width, height,
|
||
AllPlanes, ZPixmap);
|
||
}
|
||
else {
|
||
int t0, t1;
|
||
int x0, x1, y0, y1;
|
||
int xInWin, yInWin;
|
||
Window childWin;
|
||
|
||
XTranslateCoordinates(dpy, DefaultRootWindow(dpy), w, x, y,
|
||
&xInWin, &yInWin, &childWin);
|
||
|
||
/* Avoid off screen pixels. Assume this routine is not
|
||
* called for totally offscreen windows. */
|
||
x0 = max(x, 0);
|
||
y0 = max(y, 0);
|
||
x1 = min(DisplayWidth(dpy, scr),
|
||
min(x0 + width, x0 + (data->win_info.width - xInWin)));
|
||
y1 = min(DisplayHeight(dpy, scr),
|
||
min(y0 + height, y0 + (data->win_info.height - yInWin)));
|
||
|
||
/* Try to use up to width x height pixels */
|
||
if (x1 - x0 < width) {
|
||
t0 = x0;
|
||
t1 = max(0, x - xInWin + data->win_info.width -
|
||
DisplayWidth(dpy, scr));
|
||
x0 = max(0, x1 - min(width, data->win_info.width - t1));
|
||
xInWin -= t0 - x0;
|
||
}
|
||
if (y1 - y0 < height) {
|
||
t0 = y0;
|
||
t1 = max(0, y - yInWin + data->win_info.height -
|
||
DisplayHeight(dpy, scr));
|
||
y0 = max(0, y1 - min(height, data->win_info.height - t1));
|
||
yInWin -= t0 - y0;
|
||
}
|
||
|
||
data->x = x0;
|
||
data->y = y0;
|
||
data->width = x1 - x0;
|
||
data->height = y1 - y0;
|
||
|
||
data->image = XGetImage (dpy,
|
||
w,
|
||
xInWin, yInWin,
|
||
data->width, data->height,
|
||
AllPlanes, ZPixmap);
|
||
|
||
}
|
||
}
|
||
|
||
|
||
|
||
/*
|
||
* Get_XColors() Get the XColors of all pixels in image - returns # of colors
|
||
* This function was taken from xwd (thanks Bob...)
|
||
*/
|
||
#define lowbit(x) ((x) & (~(x) + 1))
|
||
static int
|
||
Get_XColors(XWindowAttributes *win_info, XColor **colors)
|
||
{
|
||
int i, ncolors;
|
||
|
||
if (!win_info->colormap)
|
||
return(0);
|
||
|
||
ncolors = win_info->visual->map_entries;
|
||
if (!(*colors = (XColor *) XtMalloc (sizeof(XColor) * ncolors)))
|
||
XtError("Out of memory!");
|
||
|
||
if (win_info->visual->class == DirectColor ||
|
||
win_info->visual->class == TrueColor) {
|
||
Pixel red, green, blue, red1, green1, blue1;
|
||
|
||
red = green = blue = 0;
|
||
red1 = lowbit(win_info->visual->red_mask);
|
||
green1 = lowbit(win_info->visual->green_mask);
|
||
blue1 = lowbit(win_info->visual->blue_mask);
|
||
for (i=0; i<ncolors; i++) {
|
||
(*colors)[i].pixel = red|green|blue;
|
||
(*colors)[i].pad = 0;
|
||
red += red1;
|
||
if (red > win_info->visual->red_mask)
|
||
red = 0;
|
||
green += green1;
|
||
if (green > win_info->visual->green_mask)
|
||
green = 0;
|
||
blue += blue1;
|
||
if (blue > win_info->visual->blue_mask)
|
||
blue = 0;
|
||
}
|
||
} else {
|
||
for (i=0; i<ncolors; i++) {
|
||
(*colors)[i].pixel = i;
|
||
(*colors)[i].pad = 0;
|
||
}
|
||
}
|
||
|
||
XQueryColors(dpy, win_info->colormap, *colors, ncolors);
|
||
|
||
return(ncolors);
|
||
}
|
||
|
||
|
||
|
||
#define Intensity(cptr) (3.0*cptr->red+0.59*cptr->green+0.11*cptr->blue)
|
||
|
||
/*
|
||
* GetMaxIntensity() -- Find the maximum intensity pixel value for a colormap.
|
||
*/
|
||
static Pixel
|
||
GetMaxIntensity(hlPtr data)
|
||
{
|
||
XColor *colors = NULL, *mptr, *tptr;
|
||
int i, ncolors;
|
||
|
||
if (data->win_info.colormap == DefaultColormap(dpy, scr))
|
||
return WhitePixel(dpy, scr);
|
||
ncolors = Get_XColors(&data->win_info, &colors);
|
||
mptr = tptr = colors; tptr++;
|
||
for (i=1; i<ncolors; i++) {
|
||
if ((int)Intensity(mptr) < (int)Intensity(tptr))
|
||
mptr = tptr;
|
||
tptr++;
|
||
}
|
||
/* Null pointer protection */
|
||
if(mptr)
|
||
return mptr->pixel;
|
||
else
|
||
return WhitePixel(dpy, scr);
|
||
}
|
||
|
||
/*
|
||
* GetMinIntensity() -- Find the minimum intensity pixel value for a colormap.
|
||
*/
|
||
static Pixel
|
||
GetMinIntensity(hlPtr data)
|
||
{
|
||
XColor *colors = NULL, *mptr, *tptr;
|
||
int i, ncolors;
|
||
|
||
if (data->win_info.colormap == DefaultColormap(dpy, scr))
|
||
return BlackPixel(dpy, scr);
|
||
ncolors = Get_XColors(&data->win_info, &colors);
|
||
mptr = tptr = colors; tptr++;
|
||
for (i=1; i<ncolors; i++) {
|
||
if ((int)Intensity(mptr) > (int)Intensity(tptr))
|
||
mptr = tptr;
|
||
tptr++;
|
||
}
|
||
/* Null pointer protection */
|
||
if(mptr)
|
||
return mptr->pixel;
|
||
else
|
||
return BlackPixel(dpy, scr);
|
||
}
|
||
|
||
|
||
|
||
|
||
static Widget pane1, pane2, pane3, cclose, replace, new, select_w, paste;
|
||
|
||
/*
|
||
* PopupNewScale() -- Create and popup a new scale composite.
|
||
*/
|
||
static void
|
||
PopupNewScale(hlPtr data)
|
||
{
|
||
Arg warg;
|
||
|
||
data->scaleShell =
|
||
XtVaCreatePopupShell("xmag", topLevelShellWidgetClass, toplevel,
|
||
XtNgeometry, (XtArgVal)options.geometry,
|
||
XtNtitle, (XtArgVal)options.title,
|
||
NULL);
|
||
pane1 = XtCreateManagedWidget("pane1", panedWidgetClass, data->scaleShell,
|
||
(Arg *) NULL, 0);
|
||
pane2 = XtCreateManagedWidget("pane2", panedWidgetClass, pane1,
|
||
(Arg *) NULL, 0);
|
||
cclose = XtCreateManagedWidget("close", commandWidgetClass, pane2,
|
||
(Arg *) NULL, 0);
|
||
XtAddCallback(cclose, XtNcallback, CloseCB, (XtPointer)data->scaleShell);
|
||
replace = XtCreateManagedWidget("replace", commandWidgetClass, pane2,
|
||
(Arg *) NULL, 0);
|
||
XtAddCallback(replace, XtNcallback, ReplaceCB, (XtPointer)data);
|
||
new = XtCreateManagedWidget("new", commandWidgetClass, pane2,
|
||
(Arg *) NULL, 0);
|
||
XtAddCallback(new, XtNcallback, NewCB, (XtPointer)NULL);
|
||
select_w = XtCreateManagedWidget("select", commandWidgetClass, pane2,
|
||
(Arg *) NULL, 0);
|
||
XtAddCallback(select_w, XtNcallback, SelectCB, (XtPointer)data);
|
||
paste = XtCreateManagedWidget("paste", commandWidgetClass, pane2,
|
||
(Arg *) NULL, 0);
|
||
XtAddCallback(paste, XtNcallback, PasteCB, (XtPointer)data);
|
||
(void) XtCreateManagedWidget("helpLabel", labelWidgetClass, pane2,
|
||
(Arg *) NULL, 0);
|
||
pane3 = XtCreateManagedWidget("pane2", panedWidgetClass, pane1,
|
||
(Arg *) NULL, 0);
|
||
data->scaleInstance =
|
||
XtVaCreateManagedWidget("scale", scaleWidgetClass,
|
||
pane3,
|
||
XtNvisual, (XtArgVal)data->win_info.visual,
|
||
XtNcolormap, (XtArgVal)data->win_info.colormap,
|
||
XtNdepth, (XtArgVal)data->win_info.depth,
|
||
XtNscaleX, (XtArgVal)options.mag,
|
||
XtNscaleY, (XtArgVal)options.mag,
|
||
NULL);
|
||
SWSetImage(data->scaleInstance, data->image);
|
||
XtOverrideTranslations
|
||
(data->scaleShell,
|
||
XtParseTranslationTable ("<Message>WM_PROTOCOLS: close()"));
|
||
XtSetArg(warg, XtNuserData, data);
|
||
XtSetValues(data->scaleInstance, &warg, 1);
|
||
data->pixShell =
|
||
XtVaCreatePopupShell("pixShell", overrideShellWidgetClass,
|
||
toplevel,
|
||
XtNvisual, (XtArgVal)data->win_info.visual,
|
||
XtNcolormap, (XtArgVal)data->win_info.colormap,
|
||
XtNdepth, (XtArgVal)data->win_info.depth,
|
||
XtNborderWidth, (XtPointer)0,
|
||
NULL);
|
||
data->pixLabel =
|
||
XtVaCreateManagedWidget("pixLabel", labelWidgetClass,
|
||
data->pixShell,
|
||
XtNforeground, (XtPointer)GetMaxIntensity(data),
|
||
XtNbackground, (XtPointer)GetMinIntensity(data),
|
||
XtNborderWidth, (XtPointer)0,
|
||
NULL);
|
||
XtInstallAllAccelerators(pane1, pane1); /* install accelerators */
|
||
if (data->newScale) {
|
||
XtPopup(data->scaleShell, XtGrabNone);
|
||
(void) XSetWMProtocols /* ICCCM delete window */
|
||
(dpy, XtWindow(data->scaleShell), &wm_delete_window, 1);
|
||
}
|
||
if (data->win_info.colormap != DefaultColormap(dpy, scr)) {
|
||
data->cmapWinList[0] = data->scaleShell;
|
||
data->cmapWinList[1] = data->scaleInstance;
|
||
XtSetWMColormapWindows(data->scaleShell, data->cmapWinList, 2);
|
||
}
|
||
}
|
||
|
||
|
||
|
||
/*
|
||
* RedoOldScale() -- If the visual, depth, or colormap has changed, unrealize
|
||
* the scale widget and change its colormap/depth/visual.
|
||
* Then re-realize it. Also do this for the pixel display
|
||
* widget.
|
||
*/
|
||
static void
|
||
RedoOldScale(hlPtr data)
|
||
{
|
||
Arg wargs[3];
|
||
int n;
|
||
Visual *oldVis;
|
||
int oldDepth;
|
||
Colormap oldCmap;
|
||
|
||
n=0;
|
||
XtSetArg(wargs[n], XtNvisual, &oldVis); n++;
|
||
XtSetArg(wargs[n], XtNdepth, &oldDepth); n++;
|
||
XtSetArg(wargs[n], XtNcolormap, &oldCmap); n++;
|
||
XtGetValues(data->scaleInstance, wargs, n);
|
||
if (oldVis == data->win_info.visual && oldDepth == data->win_info.depth
|
||
&& oldCmap == data->win_info.colormap) {
|
||
SWSetImage(data->scaleInstance, data->image);
|
||
return;
|
||
}
|
||
/* get width and height, save and reuse them */
|
||
XtUnmanageChild(data->scaleInstance);
|
||
XtUnrealizeWidget(data->scaleInstance);
|
||
n=0;
|
||
XtSetArg(wargs[n], XtNcolormap, data->win_info.colormap); n++;
|
||
XtSetArg(wargs[n], XtNdepth, data->win_info.depth); n++;
|
||
XtSetArg(wargs[n], XtNvisual, data->win_info.visual); n++;
|
||
XtSetValues(data->scaleInstance, wargs, n);
|
||
n=0;
|
||
XtSetArg(wargs[n], XtNforeground, GetMaxIntensity(data)); n++;
|
||
XtSetArg(wargs[n], XtNbackground, GetMinIntensity(data)); n++;
|
||
XtSetValues(data->pixLabel, wargs, n);
|
||
SWSetImage(data->scaleInstance, data->image);
|
||
XtRealizeWidget(data->scaleInstance);
|
||
XtManageChild(data->scaleInstance);
|
||
}
|
||
|
||
|
||
|
||
/*
|
||
* InitCursors() -- Create our cursors for area selection.
|
||
*/
|
||
static void
|
||
InitCursors(void)
|
||
{
|
||
ulAngle = XCreateFontCursor(dpy, XC_ul_angle);
|
||
urAngle = XCreateFontCursor(dpy, XC_ur_angle);
|
||
lrAngle = XCreateFontCursor(dpy, XC_lr_angle);
|
||
llAngle = XCreateFontCursor(dpy, XC_ll_angle);
|
||
}
|
||
|
||
|
||
|
||
/*
|
||
* ParseSourceGeom() -- Determine dimensions of area to magnify from resources.
|
||
*/
|
||
static void
|
||
ParseSourceGeom(void)
|
||
{
|
||
/* source */
|
||
srcStat =
|
||
XParseGeometry(options.source, &srcX, &srcY, &srcWidth, &srcHeight);
|
||
if (!srcWidth) srcWidth = SRCWIDTH;
|
||
if (!srcHeight) srcHeight = SRCHEIGHT;
|
||
if (XNegative & srcStat) srcX = DisplayWidth(dpy, scr) + srcX - srcWidth;
|
||
if (YNegative & srcStat) srcY = DisplayHeight(dpy, scr) + srcY - srcHeight;
|
||
/* mag */
|
||
}
|
||
|
||
|
||
|
||
/*
|
||
* Main program.
|
||
*/
|
||
int
|
||
main(int argc, char *argv[])
|
||
{
|
||
XSetErrorHandler(Error);
|
||
|
||
/* SUPPRESS 594 */
|
||
toplevel = XtAppInitialize(&app, "Xmag", optionDesc, XtNumber(optionDesc),
|
||
&argc, argv, NULL,
|
||
NULL, 0);
|
||
|
||
dpy = XtDisplay(toplevel);
|
||
scr = DefaultScreen(dpy);
|
||
XtGetApplicationResources(toplevel, (XtPointer) &options, resources,
|
||
XtNumber(resources), NULL, 0);
|
||
if (argc != 1) {
|
||
fprintf (stderr,
|
||
"usage: xmag [-source geom] [-mag magfactor] [-toolkitoption]\n");
|
||
exit(1);
|
||
}
|
||
|
||
|
||
ParseSourceGeom();
|
||
XtAppAddActions(app, actions_table, XtNumber(actions_table));
|
||
InitCursors();
|
||
SetupGC();
|
||
CreateRoot();
|
||
if (!(XValue & srcStat && YValue & srcStat))
|
||
StartRootPtrGrab(True, (hlPtr)NULL);
|
||
wm_delete_window = XInternAtom(dpy, "WM_DELETE_WINDOW", False);
|
||
XtAppMainLoop(app);
|
||
exit(0);
|
||
}
|