diff options
Diffstat (limited to 'Bitmap.c')
| -rw-r--r-- | Bitmap.c | 1956 |
1 files changed, 1956 insertions, 0 deletions
diff --git a/Bitmap.c b/Bitmap.c new file mode 100644 index 0000000..5e92d39 --- /dev/null +++ b/Bitmap.c @@ -0,0 +1,1956 @@ +/* $Xorg: Bitmap.c,v 1.4 2001/02/09 02:05:28 xorgcvs Exp $ */ +/* + +Copyright 1989, 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. + +*/ + +/* + * Author: Davor Matic, MIT X Consortium + */ + +#include <X11/IntrinsicP.h> +#include <X11/StringDefs.h> +#include <X11/Xaw/XawInit.h> +#include <X11/Xmu/CharSet.h> +#include <X11/Xmu/Drawing.h> +#include <X11/Xatom.h> +#include <X11/Xfuncs.h> +#include <X11/Xos.h> +#include "BitmapP.h" + +#include <stdio.h> +#include <math.h> + +#ifndef abs +#define abs(x) ((((int)(x)) > 0) ? (x) : -(x)) +#endif +#define min(x, y) ((((int)(x)) < (int)(y)) ? (x) : (y)) +#define max(x, y) ((((int)(x)) > (int)(y)) ? (x) : (y)) + +Boolean DEBUG; + +#define DefaultGridTolerance 8 +#define DefaultBitmapSize "16x16" +#define FallbackBitmapWidth 16 +#define FallbackBitmapHeight 16 +#define DefaultGrid TRUE +#define DefaultDashed TRUE +#define DefaultStippled TRUE +#define DefaultProportional TRUE +#define DefaultAxes FALSE +#define DefaultMargin 16 +#define DefaultSquareWidth 16 +#define DefaultSquareHeight 16 +#define DefaultFilename "" + +#define Offset(field) XtOffsetOf(BitmapRec, bitmap.field) + +static XtResource resources[] = { +{XtNforeground, XtCForeground, XtRPixel, sizeof(Pixel), + Offset(foreground_pixel), XtRString, XtDefaultForeground}, +{XtNhighlight, XtCHighlight, XtRPixel, sizeof(Pixel), + Offset(highlight_pixel), XtRString, XtDefaultForeground}, +{XtNframe, XtCFrame, XtRPixel, sizeof(Pixel), + Offset(frame_pixel), XtRString, XtDefaultForeground}, +{XtNgridTolerance, XtCGridTolerance, XtRDimension, sizeof(Dimension), + Offset(grid_tolerance), XtRImmediate, (XtPointer) DefaultGridTolerance}, +{XtNsize, XtCSize, XtRString, sizeof(String), + Offset(size), XtRImmediate, (XtPointer) DefaultBitmapSize}, +{XtNdashed, XtCDashed, XtRBoolean, sizeof(Boolean), + Offset(dashed), XtRImmediate, (XtPointer) DefaultDashed}, +{XtNgrid, XtCGrid, XtRBoolean, sizeof(Boolean), + Offset(grid), XtRImmediate, (XtPointer) DefaultGrid}, +{XtNstippled, XtCStippled, XtRBoolean, sizeof(Boolean), + Offset(stippled), XtRImmediate, (XtPointer) DefaultStippled}, +{XtNproportional, XtCProportional, XtRBoolean, sizeof(Boolean), + Offset(proportional), XtRImmediate, (XtPointer) DefaultProportional}, +{XtNaxes, XtCAxes, XtRBoolean, sizeof(Boolean), + Offset(axes), XtRImmediate, (XtPointer) DefaultAxes}, +{XtNsquareWidth, XtCSquareWidth, XtRDimension, sizeof(Dimension), + Offset(squareW), XtRImmediate, (XtPointer) DefaultSquareWidth}, +{XtNsquareHeight, XtCSquareHeight, XtRDimension, sizeof(Dimension), + Offset(squareH), XtRImmediate, (XtPointer) DefaultSquareHeight}, +{XtNmargin, XtCMargin, XtRDimension, sizeof(Dimension), + Offset(margin), XtRImmediate, (XtPointer) DefaultMargin}, +{XtNxHot, XtCXHot, XtRPosition, sizeof(Position), + Offset(hot.x), XtRImmediate, (XtPointer) NotSet}, +{XtNyHot, XtCYHot, XtRPosition, sizeof(Position), + Offset(hot.y), XtRImmediate, (XtPointer) NotSet}, +{XtNbutton1Function, XtCButton1Function, XtRButtonFunction, sizeof(int), + Offset(button_function[0]), XtRImmediate, (XtPointer) Set}, +{XtNbutton2Function, XtCButton2Function, XtRButtonFunction, sizeof(int), + Offset(button_function[1]), XtRImmediate, (XtPointer) Invert}, +{XtNbutton3Function, XtCButton3Function, XtRButtonFunction, sizeof(int), + Offset(button_function[2]), XtRImmediate, (XtPointer) Clear}, +{XtNbutton4Function, XtCButton4Function, XtRButtonFunction, sizeof(int), + Offset(button_function[3]), XtRImmediate, (XtPointer) Clear}, +{XtNbutton5Function, XtCButton5Function, XtRButtonFunction, sizeof(int), + Offset(button_function[4]), XtRImmediate, (XtPointer) Clear}, +{XtNfilename, XtCFilename, XtRString, sizeof(String), + Offset(filename), XtRImmediate, (XtPointer) DefaultFilename}, +{XtNbasename, XtCBasename, XtRString, sizeof(String), + Offset(basename), XtRImmediate, (XtPointer) DefaultFilename}, +{XtNdashes, XtCDashes, XtRBitmap, sizeof(Pixmap), + Offset(dashes), XtRImmediate, (XtPointer) XtUnspecifiedPixmap}, +{XtNstipple, XtCStipple, XtRBitmap, sizeof(Pixmap), + Offset(stipple), XtRImmediate, (XtPointer) XtUnspecifiedPixmap}, +}; +#undef Offset + +void BWDebug(); +void BWChangeNotify(); +void BWSetChanged(); +void BWAbort(); +void BWUp(); +void BWDown(); +void BWLeft(); +void BWRight(); +void BWFold(); +void BWFlipHoriz(); +void BWFlipVert(); +void BWRotateRight(); +void BWRotateLeft(); +void BWSet(); +void BWClear(); +void BWInvert(); +void BWUndo(); +void BWRedraw(); +void BWTMark(); +void BWTMarkAll(); +void BWTUnmark(); +void BWTPaste(); + +static XtActionsRec actions[] = +{ +{"mark", BWTMark}, +{"mark-all", BWTMarkAll}, +{"unmark", BWTUnmark}, +{"paste", BWTPaste}, +{"bw-debug", BWDebug}, +{"abort", BWAbort}, +{"store-to-buffer", BWStoreToBuffer}, +{"change-notify", BWChangeNotify}, +{"set-changed", BWSetChanged}, +{"up", BWUp}, +{"down", BWDown}, +{"left", BWLeft}, +{"right", BWRight}, +{"fold", BWFold}, +{"flip-horiz", BWFlipHoriz}, +{"flip-vert", BWFlipVert}, +{"rotate-right", BWRotateRight}, +{"rotate-left", BWRotateLeft}, +{"set", BWSet}, +{"clear", BWClear}, +{"invert", BWInvert}, +{"undo", BWUndo}, +{"redraw", BWRedraw}, +}; + +static char translations1[] = +"\ +Shift<Btn1Down>: mark()\n\ +Shift<Btn2Down>: mark-all()\n\ +Shift<Btn3Down>: unmark()\n\ +Ctrl<BtnDown>: paste()\n\ +Ctrl<Key>l: redraw()\n\ +<Key>d: bw-debug()\n\ +<Key>a: abort()\n\ +<Key>Up: store-to-buffer()\ + up()\ + change-notify()\ + set-changed()\n\ +<Key>KP_Up: store-to-buffer()\ + up()\ + change-notify()\ + set-changed()\n\ +<Key>Down: store-to-buffer()\ + down()\ + change-notify()\ + set-changed()\n\ +<Key>KP_Down: store-to-buffer()\ + down()\ + change-notify()\ + set-changed()\n\ +<Key>Left: store-to-buffer()\ + left()\ + change-notify()\ + set-changed()\n\ +<Key>KP_Left: store-to-buffer()\ + left()\ + change-notify()\ + set-changed()\n\ +<Key>Right: store-to-buffer()\ + right()\ + change-notify()\ + set-changed()\n\ +<Key>KP_Right: store-to-buffer()\ + right()\ + change-notify()\ + set-changed()\n\ +<Key>f: store-to-buffer()\ + fold()\ + change-notify()\ + set-changed()\n\ +<Key>h: store-to-buffer()\ + flip-horiz()\ + change-notify()\ + set-changed()\n\ +"; + +static char translations2[] = +"<Key>v: store-to-buffer()\ + flip-vert()\ + change-notify()\ + set-changed()\n\ +<Key>r: store-to-buffer()\ + rotate-right()\ + change-notify()\ + set-changed()\n\ +<Key>l: store-to-buffer()\ + rotate-left()\ + change-notify()\ + set-changed()\n\ +<Key>s: store-to-buffer()\ + set()\ + change-notify()\ + set-changed()\n\ +<Key>c: store-to-buffer()\ + clear()\ + change-notify()\ + set-changed()\n\ +<Key>i: store-to-buffer()\ + invert()\ + change-notify()\ + set-changed()\n\ +<Key>u: undo()\ + change-notify()\ + set-changed()\n\ +"; + +Atom targets[] = { + XA_BITMAP, + XA_PIXMAP +}; + +#include "Requests.h" + +static void ClassInitialize(); +static void Initialize(); +static void Redisplay(); +static void Resize(); +static void Destroy(); +static Boolean SetValues(); + +BitmapClassRec bitmapClassRec = { +{ /* core fields */ + /* superclass */ (WidgetClass) &simpleClassRec, + /* class_name */ "Bitmap", + /* widget_size */ sizeof(BitmapRec), + /* class_initialize */ ClassInitialize, + /* class_part_initialize */ NULL, + /* class_inited */ FALSE, + /* initialize */ Initialize, + /* initialize_hook */ NULL, + /* realize */ XtInheritRealize, + /* actions */ actions, + /* num_actions */ XtNumber(actions), + /* resources */ resources, + /* num_resources */ XtNumber(resources), + /* xrm_class */ NULLQUARK, + /* compress_motion */ TRUE, + /* compress_exposure */ FALSE, + /* compress_enterleave */ TRUE, + /* visible_interest */ TRUE, + /* destroy */ Destroy, + /* resize */ Resize, + /* expose */ Redisplay, + /* set_values */ SetValues, + /* set_values_hook */ NULL, + /* set_values_almost */ XtInheritSetValuesAlmost, + /* get_values_hook */ NULL, + /* accept_focus */ NULL, + /* version */ XtVersion, + /* callback_private */ NULL, + /* tm_table */ NULL , /* set in code */ + /* query_geometry */ XtInheritQueryGeometry, + /* display_accelerator */ XtInheritDisplayAccelerator, + /* extension */ NULL, + }, + { + /* empty */ XtInheritChangeSensitive, + }, + { + /* targets */ targets, + /* num_trets */ XtNumber(targets), + /* requests */ requests, + /* num_requests */ XtNumber(requests), + } +}; + +WidgetClass bitmapWidgetClass = (WidgetClass) &bitmapClassRec; + +/* ARGSUSED */ + +void BWDebug(w, event, params, num_params) + Widget w; + XEvent *event; + String *params; + Cardinal *num_params; +{ + DEBUG ^= True; +} + +Pixmap BWGetPixmap(w) + Widget w; +{ + BitmapWidget BW = (BitmapWidget) w; + + return GetPixmap(BW, BW->bitmap.zoom.image); +} + +Pixmap BWGetUnzoomedPixmap(w) + Widget w; +{ + BitmapWidget BW = (BitmapWidget) w; + GC gc; + Pixmap pix; + + if (BW->bitmap.zooming) { + pix = XCreatePixmap(XtDisplay(w), XtWindow(w), + BW->bitmap.zoom.image->width, + BW->bitmap.zoom.image->height, 1); + if (!(gc = XCreateGC(XtDisplay(w), pix, + (unsigned long) 0, (XGCValues *) 0))) + return (Pixmap) None; + + XPutImage(XtDisplay(w), pix, gc, + BW->bitmap.zoom.image, + 0, 0, 0, 0, + BW->bitmap.zoom.image->width, + BW->bitmap.zoom.image->height); + XPutImage(XtDisplay(w), pix, gc, + BW->bitmap.image, + 0, 0, + BW->bitmap.zoom.at_x, + BW->bitmap.zoom.at_y, + BW->bitmap.image->width, + BW->bitmap.image->height); + } + else { + pix = XCreatePixmap(XtDisplay(w), XtWindow(w), + BW->bitmap.image->width, + BW->bitmap.image->height, 1); + if (! (gc = XCreateGC(XtDisplay(w), pix, + (unsigned long) 0, (XGCValues *) 0))) + return (Pixmap) None; + + XPutImage(XtDisplay(w), pix, gc, + BW->bitmap.image, + 0, 0, 0, 0, + BW->bitmap.image->width, + BW->bitmap.image->height); + } + XFreeGC(XtDisplay(w), gc); + return(pix); +} + +XImage *CreateBitmapImage(); + +XImage *ConvertToBitmapImage(); + +XImage *GetImage(BW, pixmap) + BitmapWidget BW; + Pixmap pixmap; +{ + Window root; + int x, y; + unsigned int width, height, border_width, depth; + XImage *source, *image; + + XGetGeometry(XtDisplay(BW), pixmap, &root, &x, &y, + &width, &height, &border_width, &depth); + + source = XGetImage(XtDisplay(BW), pixmap, x, y, width, height, + 1, XYPixmap); + + image = ConvertToBitmapImage(BW, source); + + return image; +} + +XImage *CreateBitmapImage(BW, data, width, height) + BitmapWidget BW; + char *data; + Dimension width, height; +{ + XImage *image = XCreateImage(XtDisplay(BW), + DefaultVisual(XtDisplay(BW), + DefaultScreen(XtDisplay(BW))), + 1, XYBitmap, 0, + data, width, height, + 8, ((int)width + 7) / 8); + + image->height = height; + image->width = width; + image->depth = 1; + image->xoffset = 0; + image->format = XYBitmap; + image->data = (char *)data; + image->byte_order = LSBFirst; + image->bitmap_unit = 8; + image->bitmap_bit_order = LSBFirst; + image->bitmap_pad = 8; + image->bytes_per_line = ((int)width + 7) / 8; + + return image; +} + +void DestroyBitmapImage(image) + XImage **image; +{ + /*XDestroyImage(*image);*/ + if (image) { + if (*image) { + if ((*image)->data) + XtFree((*image)->data); + XtFree((char *)*image); + } + *image = NULL; + } +} + +XImage *BWGetImage(w, event, params, num_params) + Widget w; + XEvent *event; + String *params; + Cardinal *num_params; +{ + BitmapWidget BW = (BitmapWidget) w; + + return BW->bitmap.image; +} + +void BWChangeNotify(w, event, params, num_params) + Widget w; + XEvent *event; + String *params; + Cardinal *num_params; +{ + BitmapWidget BW = (BitmapWidget) w; + + if (BW->bitmap.notify) + (*BW->bitmap.notify)(w, event, params, num_params); +} + +void BWNotify(w, proc) /* ARGSUSED */ + Widget w; + void (*proc)(); +{ + BitmapWidget BW = (BitmapWidget) w; + + BW->bitmap.notify = proc; +} + +void BWSetChanged(w, event, params, num_params) + Widget w; + XEvent *event; + String *params; + Cardinal *num_params; +{ + BitmapWidget BW = (BitmapWidget) w; + + BW->bitmap.changed = True; +} + +Boolean BWQueryChanged(w) + Widget w; +{ + BitmapWidget BW = (BitmapWidget) w; + + return BW->bitmap.changed; +} + +void BWClearChanged(w) + Widget w; +{ + BitmapWidget BW = (BitmapWidget) w; + + BW->bitmap.changed = False; +} + +Boolean BWQueryStored(w) + Widget w; +{ + BitmapWidget BW = (BitmapWidget) w; + + return (BW->bitmap.storage != NULL); +} + +Boolean BWQueryStippled(w) + Widget w; +{ + BitmapWidget BW = (BitmapWidget) w; + + return BW->bitmap.stippled; +} + +void RedrawStippled(BW) + BitmapWidget(BW); +{ + XExposeEvent event; + + event.type = Expose; + event.display = XtDisplay((Widget)BW); + event.window = XtWindow((Widget)BW); + event.x = 0; + event.y = 0; + event.width = BW->core.width; + event.height = BW->core.height; + event.count = 0; + + BWRedrawMark((Widget)BW); + + BW->bitmap.stipple_change_expose_event = True; + + XtDispatchEvent((XEvent *)&event); + + BW->bitmap.stipple_change_expose_event = False; +} + +void BWSwitchStippled(w) + Widget w; +{ + BitmapWidget BW = (BitmapWidget) w; + + RedrawStippled(BW); + + BW->bitmap.stippled ^= True; + XSetFillStyle(XtDisplay(BW), BW->bitmap.highlighting_gc, + (BW->bitmap.stippled ? FillStippled : FillSolid)); + + RedrawStippled(BW); +} + +void BWSelect(w, from_x, from_y, to_x, to_y, btime) + Widget w; + Position from_x, from_y, + to_x, to_y; + Time btime; +{ + BWMark(w, from_x, from_y, to_x, to_y); + + BWGrabSelection(w, btime); +} + +Boolean BWQueryAxes(w) + Widget w; +{ + BitmapWidget BW = (BitmapWidget) w; + + return BW->bitmap.axes; +} + +void BWSwitchAxes(w) + Widget w; +{ + BitmapWidget BW = (BitmapWidget) w; + + BW->bitmap.axes ^= True; + BWHighlightAxes(w); +} + +void BWAxes(w, _switch) + Widget w; + Boolean _switch; +{ + BitmapWidget BW = (BitmapWidget) w; + + if (BW->bitmap.axes != _switch) + BWSwitchAxes(w); +} + +void BWRedrawAxes(w) + Widget w; +{ + BitmapWidget BW = (BitmapWidget) w; + + if (BW->bitmap.axes) + BWHighlightAxes(w); +} + +void BWPutImage(w, display, drawable, gc, x, y) + BitmapWidget w; + Display *display; + Drawable drawable; + GC gc; + Position x, y; +{ + BitmapWidget BW = (BitmapWidget) w; + + XPutImage(display, drawable, gc, BW->bitmap.image, + 0, 0, x, y, BW->bitmap.image->width, BW->bitmap.image->height); +} + +String StripFilename(filename) + String filename; +{ + char *begin = strrchr(filename, '/'); + char *end, *result; + int length; + + if (filename) { + begin = (begin ? begin + 1 : filename); + end = strchr(begin, '.'); /* change to strrchr to allow longer names */ + length = (end ? (end - begin) : strlen (begin)); + result = (char *) XtMalloc (length + 1); + strncpy (result, begin, length); + result [length] = '\0'; + return (result); + } + else + return (NULL); +} + +int XmuWriteBitmapDataToFile (filename, basename, + width, height, datap, x_hot, y_hot) + String filename, basename; + int width, height; + char *datap; + int x_hot, y_hot; +{ + FILE *file; + int i, data_length; + + data_length = Length(width, height); + + if(!filename || !strcmp(filename, "") || !strcmp(filename, "-")) { + file = stdout; + filename = "dummy"; + } + else + file = fopen(filename, "w+"); + + if (!basename || !strcmp(basename, "") || !strcmp(basename, "-")) + basename = StripFilename(filename); + + if (file) { + fprintf(file, "#define %s_width %d\n", basename, width); + fprintf(file, "#define %s_height %d\n", basename, height); + if (QuerySet(x_hot, y_hot)) { + fprintf(file, "#define %s_x_hot %d\n", basename, x_hot); + fprintf(file, "#define %s_y_hot %d\n", basename, y_hot); + } + fprintf(file, "static unsigned char %s_bits[] = {\n 0x%02x", + basename, (unsigned char) datap[0]); + for(i = 1; i < data_length; i++) { + fprintf(file, ","); + fprintf(file, (i % 12) ? " " : "\n "); + fprintf(file, "0x%02x", (unsigned char) datap[i]); + } + fprintf(file, "};\n"); + + if (file != stdout) + fclose(file); + + return BitmapSuccess; + } + + return 1; +} + +/* + * + */ + + /* ARGSUSED */ +static void CvtStringToButtonFunction(args, num_args, from_val, to_val) + XrmValuePtr args; /* not used */ + Cardinal *num_args; /* not used */ + XrmValuePtr from_val; + XrmValuePtr to_val; +{ + static button_function; + char lower_name[80]; + + XmuCopyISOLatin1Lowered (lower_name, (char*)from_val->addr); + + if (!strcmp(lower_name, XtClear)) { + button_function = Clear; + to_val->addr = (XPointer) &button_function; + to_val->size = sizeof(button_function); + return; + } + + if (!strcmp(lower_name, XtSet)) { + button_function = Set; + to_val->addr = (XPointer) &button_function; + to_val->size = sizeof(button_function); + return; + } + + if (!strcmp(lower_name, XtInvert)) { + button_function = Invert; + to_val->addr = (XPointer) &button_function; + to_val->size = sizeof(button_function); + return; + } + + XtStringConversionWarning(from_val->addr, XtRButtonFunction); + button_function = Clear; + to_val->addr = (XPointer) &button_function; + to_val->size = sizeof(button_function); + +} + +void Refresh(); + +static void ClassInitialize() +{ + char *tm_table = XtMalloc(strlen(translations1) + strlen(translations2) + 1); + strcpy(tm_table, translations1); + strcat(tm_table, translations2); + bitmapClassRec.core_class.tm_table = tm_table; + + XawInitializeWidgetSet(); + XtAddConverter(XtRString, XtRButtonFunction, CvtStringToButtonFunction, + NULL, 0); + DEBUG = False; +} + +static void SetSizeFromSizeResource(bw) + BitmapWidget bw; +{ + if (BWParseSize(bw->bitmap.size, + &bw->bitmap.width, + &bw->bitmap.height) + == + False) { + bw->bitmap.width = FallbackBitmapWidth; + bw->bitmap.height = FallbackBitmapHeight; + XtWarning("Cannot parse the size resource. BitmapWidget"); + } +} + +void TransferImageData(); + +/* ARGSUSED */ +static void Initialize(wrequest, wnew, argv, argc) + Widget wrequest, wnew; + ArgList argv; + Cardinal *argc; +{ + BitmapWidget new = (BitmapWidget) wnew; + + XGCValues values; + XtGCMask mask; + char *image_data, *buffer_data; + + new->bitmap.stipple_change_expose_event = False; + new->bitmap.notify = NULL; + new->bitmap.cardinal = 0; + new->bitmap.current = 0; + new->bitmap.fold = False; + new->bitmap.changed = False; + new->bitmap.zooming = False; + new->bitmap.selection.own = False; + new->bitmap.selection.limbo = False; + + new->bitmap.request_stack = (BWRequestStack *) + XtMalloc(sizeof(BWRequestStack)); + + new->bitmap.request_stack[0].request = NULL; + new->bitmap.request_stack[0].call_data = NULL; + new->bitmap.request_stack[0].trap = False; + + SetSizeFromSizeResource(new); + + new->core.width = new->bitmap.width * new->bitmap.squareW + + 2 * new->bitmap.margin; + new->core.height = new->bitmap.height * new->bitmap.squareH + + 2 * new->bitmap.margin; + + new->bitmap.hot.x = new->bitmap.hot.y = NotSet; + new->bitmap.buffer_hot.x = new->bitmap.buffer_hot.y = NotSet; + + new->bitmap.mark.from_x = new->bitmap.mark.from_y = NotSet; + new->bitmap.mark.to_x = new->bitmap.mark.to_y = NotSet; + new->bitmap.buffer_mark.from_x = new->bitmap.buffer_mark.from_y = NotSet; + new->bitmap.buffer_mark.to_x = new->bitmap.buffer_mark.to_y = NotSet; + + values.foreground = new->bitmap.foreground_pixel; + values.background = new->core.background_pixel; + values.foreground ^= values.background; + values.function = GXxor; + mask = GCForeground | GCBackground | GCFunction; + new->bitmap.drawing_gc = XCreateGC(XtDisplay(new), + RootWindow(XtDisplay(new), + DefaultScreen(XtDisplay(new))), + mask, &values); + + values.foreground = new->bitmap.highlight_pixel; + values.background = new->core.background_pixel; + values.foreground ^= values.background; + values.function = GXxor; + mask = GCForeground | GCBackground | GCFunction; + if (new->bitmap.stipple != XtUnspecifiedPixmap) + { + values.stipple = new->bitmap.stipple; + mask |= GCStipple | GCFillStyle; + } + values.fill_style = (new->bitmap.stippled ? FillStippled : FillSolid); + + new->bitmap.highlighting_gc = XCreateGC(XtDisplay(new), + RootWindow(XtDisplay(new), + DefaultScreen(XtDisplay(new))), + mask, &values); + + + values.foreground = new->bitmap.frame_pixel; + values.background = new->core.background_pixel; + values.foreground ^= values.background; + mask = GCForeground | GCBackground | GCFunction; + if (new->bitmap.dashes != XtUnspecifiedPixmap) + { + values.stipple = new->bitmap.dashes; + mask |= GCStipple | GCFillStyle; + } + values.fill_style = (new->bitmap.dashed ? FillStippled : FillSolid); + + new->bitmap.frame_gc = XCreateGC(XtDisplay(new), + RootWindow(XtDisplay(new), + DefaultScreen(XtDisplay(new))), + mask, &values); + + values.foreground = new->bitmap.highlight_pixel; + values.background = new->core.background_pixel; + values.foreground ^= values.background; + mask = GCForeground | GCBackground | GCFunction; + new->bitmap.axes_gc = XCreateGC(XtDisplay(new), + RootWindow(XtDisplay(new), + DefaultScreen(XtDisplay(new))), + mask, &values); + + image_data = CreateCleanData(Length(new->bitmap.width, + new->bitmap.height)); + buffer_data = CreateCleanData(Length(new->bitmap.width, + new->bitmap.height)); + + new->bitmap.storage = NULL; + + new->bitmap.image = CreateBitmapImage(new, + image_data, + new->bitmap.width, + new->bitmap.height); + new->bitmap.buffer = CreateBitmapImage(new, + buffer_data, + new->bitmap.width, + new->bitmap.height); + + /* Read file */ + { + int status; + XImage *image, *buffer; + unsigned char *image_data; + char *buffer_data; + unsigned int width, height; + int x_hot, y_hot; + + status = XmuReadBitmapDataFromFile(new->bitmap.filename, + &width, &height, &image_data, + &x_hot, &y_hot); + if (status == BitmapSuccess) { + + buffer_data = CreateCleanData(Length(width, height)); + + image = CreateBitmapImage(new, (char *)image_data, width, height); + buffer = CreateBitmapImage(new, buffer_data, width, height); + + TransferImageData(new->bitmap.image, buffer); + + DestroyBitmapImage(&new->bitmap.image); + DestroyBitmapImage(&new->bitmap.buffer); + + new->bitmap.image = image; + new->bitmap.buffer = buffer; + new->bitmap.width = width; + new->bitmap.height = height; + + new->bitmap.hot.x = x_hot; + new->bitmap.hot.y = y_hot; + + new->bitmap.changed = False; + new->bitmap.zooming = False; + } + + new->bitmap.filename = XtNewString(new->bitmap.filename); + + if (!strcmp(new->bitmap.basename, "")) { + new->bitmap.basename = StripFilename(new->bitmap.filename); + } + else + new->bitmap.basename = XtNewString(new->bitmap.basename); + } + + Resize(new); +} + + +/* returns False if the format is wrong */ +Boolean BWParseSize(size, width, height) + String size; + Dimension *width, *height; +{ + int x, y; + unsigned int w, h; + int status; + + status = XParseGeometry(size, &x, &y, &w, &h); + + if (status & (WidthValue | HeightValue)) { + *width = (Dimension) w; + *height = (Dimension) h; + return True; + } + else return False; + +} + + +Boolean BWQueryMarked(w) + Widget w; +{ + BitmapWidget BW = (BitmapWidget) w; + + return QuerySet(BW->bitmap.mark.from_x, BW->bitmap.mark.from_y); +} + +void FixMark(BW) + BitmapWidget BW; +{ + if (QuerySet(BW->bitmap.mark.from_x, BW->bitmap.mark.from_y)) { + BW->bitmap.mark.from_x = min(BW->bitmap.mark.from_x, + BW->bitmap.image->width); + BW->bitmap.mark.from_y = min(BW->bitmap.mark.from_y, + BW->bitmap.image->height); + BW->bitmap.mark.to_x = min(BW->bitmap.mark.to_x, + BW->bitmap.image->width); + BW->bitmap.mark.to_y = min(BW->bitmap.mark.to_y, + BW->bitmap.image->height); + + if((BW->bitmap.mark.from_x == BW->bitmap.mark.from_y) && + (BW->bitmap.mark.to_x == BW->bitmap.mark.to_y)) + BW->bitmap.mark.from_x = + BW->bitmap.mark.from_y = + BW->bitmap.mark.to_x = + BW->bitmap.mark.to_y = NotSet; + } +} + +/* ARGSUSED */ +int BWStoreFile(w, filename, basename) + Widget w; + String filename, *basename; +{ + BitmapWidget BW = (BitmapWidget) w; + int status; + unsigned char *storage_data; + unsigned int width, height; + int x_hot, y_hot; + + status = XmuReadBitmapDataFromFile(filename, &width, &height, + &storage_data, &x_hot, &y_hot); + if (status == BitmapSuccess) { + + DestroyBitmapImage(&BW->bitmap.storage); + + BW->bitmap.storage = CreateBitmapImage(BW, (char *)storage_data, width, height); + + return BitmapSuccess; + } + else + XtWarning(" read file failed. BitmapWidget"); + + return status; +} + +String BWUnparseStatus(w) + Widget w; +{ + BitmapWidget BW = (BitmapWidget) w; + + sprintf(BW->bitmap.status, + "Filename: %s Basename: %s Size: %dx%d", + (strcmp(BW->bitmap.filename, "") ? BW->bitmap.filename : "<none>"), + (strcmp(BW->bitmap.basename, "") ? BW->bitmap.basename : "<none>"), + BW->bitmap.width, BW->bitmap.height); + + return BW->bitmap.status; +} + +void BWChangeFilename(w, str) + Widget w; + String str; +{ + BitmapWidget BW = (BitmapWidget) w; + + if (str) { + XtFree(BW->bitmap.filename); + BW->bitmap.filename = XtNewString( str); + } +} + +void BWChangeBasename(w, str) + Widget w; + String str; +{ + BitmapWidget BW = (BitmapWidget) w; + + if (str) { + XtFree(BW->bitmap.basename); + BW->bitmap.basename = XtNewString(str); + } +} + + +int BWReadFile(w, filename, basename) /* ARGSUSED */ + Widget w; + String filename, basename; +{ + BitmapWidget BW = (BitmapWidget) w; + int status; + XImage *image, *buffer; + unsigned char *image_data; + char *buffer_data; + unsigned int width, height; + int x_hot, y_hot; + + if (!filename) + filename = BW->bitmap.filename; + + status = XmuReadBitmapDataFromFile(filename, &width, &height, &image_data, + &x_hot, &y_hot); + if (status == BitmapSuccess) { + + buffer_data = CreateCleanData(Length(width, height)); + + image = CreateBitmapImage(BW, (char *)image_data, width, height); + buffer = CreateBitmapImage(BW, buffer_data, width, height); + + TransferImageData(BW->bitmap.image, buffer); + + DestroyBitmapImage(&BW->bitmap.image); + DestroyBitmapImage(&BW->bitmap.buffer); + + BW->bitmap.image = image; + BW->bitmap.buffer = buffer; + BW->bitmap.width = width; + BW->bitmap.height = height; + + BW->bitmap.hot.x = x_hot; + BW->bitmap.hot.y = y_hot; + + BW->bitmap.changed = False; + BW->bitmap.zooming = False; + + XtFree(BW->bitmap.filename); + BW->bitmap.filename = XtNewString(filename); + XtFree(BW->bitmap.basename); + BW->bitmap.basename= XtNewString(StripFilename(filename)); + + BWUnmark(w); + + Resize(BW); + + if (BW->core.visible) { + XClearArea(XtDisplay(BW), XtWindow(BW), + 0, 0, + BW->core.width, BW->core.height, + True); + } + + return BitmapSuccess; + } + else + XtWarning(" read file failed. BitmapWidget"); + + return status; +} + +void BWSetImage(w, image) + Widget w; + XImage *image; +{ + BitmapWidget BW = (BitmapWidget) w; + XImage *buffer; + char *buffer_data; + + buffer_data = CreateCleanData(Length(image->width, image->height)); + buffer = CreateBitmapImage(BW, buffer_data, + (Dimension) image->width, + (Dimension) image->height); + + TransferImageData(BW->bitmap.image, buffer); + + DestroyBitmapImage(&BW->bitmap.image); + DestroyBitmapImage(&BW->bitmap.buffer); + + BW->bitmap.image = image; + BW->bitmap.buffer = buffer; + BW->bitmap.width = image->width; + BW->bitmap.height = image->height; + + Resize(BW); + + if (BW->core.visible) { + XClearArea(XtDisplay(BW), XtWindow(BW), + 0, 0, + BW->core.width, BW->core.height, + True); + } +} + +int BWWriteFile(w, filename, basename) + Widget w; + String filename, basename; +{ + BitmapWidget BW = (BitmapWidget) w; + char *data; + XImage *image; + XPoint hot; + int status; + + if (BW->bitmap.zooming) { + data = XtMalloc(Length(BW->bitmap.zoom.image->width, + BW->bitmap.zoom.image->height)); + memmove( data, BW->bitmap.zoom.image->data, + Length(BW->bitmap.zoom.image->width, + BW->bitmap.zoom.image->height)); + image = CreateBitmapImage(BW, data, + (Dimension) BW->bitmap.zoom.image->width, + (Dimension) BW->bitmap.zoom.image->height); + CopyImageData(BW->bitmap.image, image, + 0, 0, + BW->bitmap.image->width - 1, + BW->bitmap.image->height - 1, + BW->bitmap.zoom.at_x, BW->bitmap.zoom.at_y); + + if (QuerySet(BW->bitmap.hot.x, BW->bitmap.hot.y)) { + hot.x = BW->bitmap.hot.x + BW->bitmap.zoom.at_x; + hot.y = BW->bitmap.hot.y + BW->bitmap.zoom.at_y; + } + else + hot = BW->bitmap.zoom.hot; + } + else { + image = BW->bitmap.image; + hot = BW->bitmap.hot; + } + + if (!filename) filename = BW->bitmap.filename; + else { + XtFree(BW->bitmap.filename); + BW->bitmap.filename = XtNewString(filename); + XtFree(BW->bitmap.basename); + BW->bitmap.basename= XtNewString(StripFilename(filename)); + } + if (!basename) basename = BW->bitmap.basename; + else { + XtFree(BW->bitmap.basename); + BW->bitmap.basename = XtNewString(basename); + } + + if (DEBUG) + fprintf(stderr, "Saving filename: %s %s\n", filename, basename); + + status = XmuWriteBitmapDataToFile(filename, basename, + image->width, image->height, image->data, + hot.x, hot.y); + if (BW->bitmap.zooming) + DestroyBitmapImage(&image); + + if (status == BitmapSuccess) + BW->bitmap.changed = False; + + return status; +} + +String BWGetFilename(w, str) + Widget w; + String *str; +{ + BitmapWidget BW = (BitmapWidget) w; + + *str = XtNewString(BW->bitmap.filename); + + return *str; +} + +String BWGetFilepath(w, str) + Widget w; + String *str; +{ + BitmapWidget BW = (BitmapWidget) w; + String end; + + *str = XtNewString(BW->bitmap.filename); + end = strrchr(*str, '/'); + + if (end) + *(end + 1) = '\0'; + else + **str = '\0'; + + return *str; +} + + +String BWGetBasename(w, str) + Widget w; + String *str; +{ + BitmapWidget BW = (BitmapWidget) w; + + *str = XtNewString(BW->bitmap.basename); + + return *str; +} + +void FixHotSpot(BW) + BitmapWidget BW; +{ + if (!QueryInBitmap(BW, BW->bitmap.hot.x, BW->bitmap.hot.y)) + BW->bitmap.hot.x = BW->bitmap.hot.y = NotSet; +} + +void ZoomOut(BW) + BitmapWidget BW; +{ + CopyImageData(BW->bitmap.image, BW->bitmap.zoom.image, + 0, 0, + BW->bitmap.image->width - 1, + BW->bitmap.image->height - 1, + BW->bitmap.zoom.at_x, BW->bitmap.zoom.at_y); + + DestroyBitmapImage(&BW->bitmap.image); + DestroyBitmapImage(&BW->bitmap.buffer); + + BW->bitmap.image = BW->bitmap.zoom.image; + BW->bitmap.buffer = BW->bitmap.zoom.buffer; + BW->bitmap.width = BW->bitmap.image->width; + BW->bitmap.height = BW->bitmap.image->height; + BW->bitmap.fold = BW->bitmap.zoom.fold; + BW->bitmap.changed |= BW->bitmap.zoom.changed; + BW->bitmap.grid = BW->bitmap.zoom.grid; + + if (QuerySet(BW->bitmap.hot.x, BW->bitmap.hot.y)) { + BW->bitmap.hot.x += BW->bitmap.zoom.at_x; + BW->bitmap.hot.y += BW->bitmap.zoom.at_y; + } + else + BW->bitmap.hot = BW->bitmap.zoom.hot; + + BW->bitmap.mark.from_x = NotSet; + BW->bitmap.mark.from_y = NotSet; + BW->bitmap.mark.to_x = NotSet; + BW->bitmap.mark.to_y = NotSet; + BW->bitmap.zooming = False; +} + +void BWZoomOut(w) + Widget w; +{ + BitmapWidget BW = (BitmapWidget) w; + + if (BW->bitmap.zooming) { + ZoomOut(BW); + + Resize(BW); + if (BW->core.visible) + XClearArea(XtDisplay(BW), XtWindow(BW), + 0, 0, + BW->core.width, BW->core.height, + True); + } +} + +void BWZoomIn(); + +void BWZoomMarked(w) + Widget w; +{ + BitmapWidget BW = (BitmapWidget) w; + + BWZoomIn(w, + BW->bitmap.mark.from_x, BW->bitmap.mark.from_y, + BW->bitmap.mark.to_x, BW->bitmap.mark.to_y); +} + +void BWZoomIn(w, from_x, from_y, to_x, to_y) + Widget w; + Position from_x, from_y, + to_x, to_y; +{ + BitmapWidget BW = (BitmapWidget) w; + XImage *image, *buffer; + Dimension width, height; + char *image_data, *buffer_data; + + if (BW->bitmap.zooming) + ZoomOut(BW); + + QuerySwap(from_x, to_x); + QuerySwap(from_y, to_y); + from_x = max(0, from_x); + from_y = max(0, from_y); + to_x = min(BW->bitmap.width - 1, to_x); + to_y = min(BW->bitmap.height - 1, to_y); + + width = to_x - from_x + 1; + height = to_y - from_y + 1; + + image_data = CreateCleanData(Length(width, height)); + buffer_data = CreateCleanData(Length(width, height)); + + image = CreateBitmapImage(BW, image_data, width, height); + buffer = CreateBitmapImage(BW, buffer_data, width, height); + + CopyImageData(BW->bitmap.image, image, from_x, from_y, to_x, to_y, 0, 0); + CopyImageData(BW->bitmap.buffer, buffer, from_x, from_y, to_x, to_y, 0, 0); + + BW->bitmap.zoom.image = BW->bitmap.image; + BW->bitmap.zoom.buffer = BW->bitmap.buffer; + BW->bitmap.zoom.at_x = from_x; + BW->bitmap.zoom.at_y = from_y; + BW->bitmap.zoom.fold = BW->bitmap.fold; + BW->bitmap.zoom.changed = BW->bitmap.changed; + BW->bitmap.zoom.hot = BW->bitmap.hot; + BW->bitmap.zoom.grid = BW->bitmap.grid; + + BW->bitmap.image = image; + BW->bitmap.buffer = buffer; + BW->bitmap.width = width; + BW->bitmap.height = height; + BW->bitmap.changed = False; + BW->bitmap.hot.x -= from_x; + BW->bitmap.hot.y -= from_y; + BW->bitmap.mark.from_x = NotSet; + BW->bitmap.mark.from_y = NotSet; + BW->bitmap.mark.to_x = NotSet; + BW->bitmap.mark.to_y = NotSet; + BW->bitmap.zooming = True; + BW->bitmap.grid = True; /* potencially true, could use a resource here */ + + FixHotSpot(BW); + + Resize(BW); + if (BW->core.visible) + XClearArea(XtDisplay(BW), XtWindow(BW), + 0, 0, + BW->core.width, BW->core.height, + True); +} + +XImage *ScaleBitmapImage(); + +void BWRescale(w, width, height) + Widget w; + Dimension width, height; +{ + BitmapWidget BW = (BitmapWidget) w; + XImage *image, *buffer; + char *buffer_data; + + if (BW->bitmap.zooming) + ZoomOut(BW); + + image = ScaleBitmapImage(BW, BW->bitmap.image, + (double) width / (double) BW->bitmap.image->width, + (double) height / (double) BW->bitmap.image->height); + + buffer_data = CreateCleanData(Length(image->width, image->height)); + buffer = CreateBitmapImage(BW, buffer_data, + (Dimension) image->width, + (Dimension) image->height); + + TransferImageData(BW->bitmap.buffer, buffer); + + DestroyBitmapImage(&BW->bitmap.image); + DestroyBitmapImage(&BW->bitmap.buffer); + + BW->bitmap.image = image; + BW->bitmap.buffer = buffer; + BW->bitmap.width = image->width; + BW->bitmap.height = image->height; + + FixHotSpot(BW); + FixMark(BW); + + Resize(BW); + if (BW->core.visible) + XClearArea(XtDisplay(BW), XtWindow(BW), + 0, 0, + BW->core.width, BW->core.height, + True); +} + +Boolean BWQueryZooming(w) + Widget w; +{ + BitmapWidget BW = (BitmapWidget) w; + + return BW->bitmap.zooming; +} + + +static void ResizeGrid(BW, width, height) + BitmapWidget BW; + Dimension width, height; +{ + XImage *image, *buffer; + char *image_data, *buffer_data; + + if (BW->bitmap.zooming) + ZoomOut(BW); + + image_data = CreateCleanData(Length(width, height)); + buffer_data = CreateCleanData(Length(width, height)); + + image = CreateBitmapImage(BW, image_data, width, height); + buffer = CreateBitmapImage(BW, buffer_data, width, height); + + TransferImageData(BW->bitmap.image, image); + TransferImageData(BW->bitmap.buffer, buffer); + + DestroyBitmapImage(&BW->bitmap.image); + DestroyBitmapImage(&BW->bitmap.buffer); + + BW->bitmap.image = image; + BW->bitmap.buffer = buffer; + BW->bitmap.width = width; + BW->bitmap.height = height; + + FixHotSpot(BW); + FixMark(BW); +} + +void BWResize(w, width, height) + Widget w; + Dimension width, height; +{ + BitmapWidget BW = (BitmapWidget) w; + + ResizeGrid(BW, width, height); + + Resize(BW); + if (BW->core.visible) + XClearArea(XtDisplay(BW), XtWindow(BW), + 0, 0, + BW->core.width, BW->core.height, + True); +} + +static void Destroy(w) + Widget w; +{ + BitmapWidget BW = (BitmapWidget) w; + + XFreeGC(XtDisplay(w), BW->bitmap.drawing_gc); + XFreeGC(XtDisplay(w), BW->bitmap.highlighting_gc); + XFreeGC(XtDisplay(w), BW->bitmap.frame_gc); + XFreeGC(XtDisplay(w), BW->bitmap.axes_gc); + BWRemoveAllRequests(w); + + XtFree(BW->bitmap.filename); + XtFree(BW->bitmap.basename); +} + + +static void Resize(w) + Widget w; +{ + BitmapWidget BW = (BitmapWidget) w; + + Dimension squareW, squareH; + + squareW = max(1, ((int)BW->core.width - 2 * (int)BW->bitmap.margin) / + (int)BW->bitmap.width); + squareH = max(1, ((int)BW->core.height - 2 * (int)BW->bitmap.margin) / + (int)BW->bitmap.height); + + if (BW->bitmap.proportional) + BW->bitmap.squareW = BW->bitmap.squareH = min(squareW, squareH); + else { + BW->bitmap.squareW = squareW; + BW->bitmap.squareH = squareH; + } + + BW->bitmap.horizOffset = max((Position)BW->bitmap.margin, + (Position)(BW->core.width - + BW->bitmap.width * + BW->bitmap.squareW) / 2); + BW->bitmap.vertOffset = max((Position)BW->bitmap.margin, + (Position)(BW->core.height - + BW->bitmap.height * + BW->bitmap.squareH) / 2); + + BW->bitmap.grid &= ((BW->bitmap.squareW > BW->bitmap.grid_tolerance) && + (BW->bitmap.squareH > BW->bitmap.grid_tolerance)); +} + +/* ARGSUSED */ +static void Redisplay(w, event, region) + Widget w; + XEvent *event; + Region region; +{ + BitmapWidget BW = (BitmapWidget) w; + + if(event->type == Expose + && + BW->core.visible) + if (BW->bitmap.stipple_change_expose_event == False) + Refresh(BW, + event->xexpose.x, event->xexpose.y, + event->xexpose.width, event->xexpose.height); +} + +void BWClip(w, x, y, width, height) + Widget w; + Position x, y; + Dimension width, height; +{ + Position from_x, from_y, + to_x, to_y; + BitmapWidget BW = (BitmapWidget) w; + XRectangle rectangle; + + from_x = InBitmapX(BW, x); + from_y = InBitmapY(BW, y); + to_x = InBitmapX(BW, x + width); + to_y = InBitmapY(BW, y + height); + QuerySwap(from_x, to_x); + QuerySwap(from_y, to_y); + from_x = max(0, from_x); + from_y = max(0, from_y); + to_x = min(BW->bitmap.width - 1, to_x); + to_y = min(BW->bitmap.height - 1, to_y); + + rectangle.x = InWindowX(BW, from_x); + rectangle.y = InWindowY(BW, from_y); + rectangle.width = InWindowX(BW, to_x + 1) - InWindowX(BW, from_x); + rectangle.height = InWindowY(BW, to_y + 1) - InWindowY(BW, from_y); + XSetClipRectangles(XtDisplay(BW), + BW->bitmap.highlighting_gc, + 0, 0, + &rectangle, 1, + Unsorted); + XSetClipRectangles(XtDisplay(BW), + BW->bitmap.drawing_gc, + 0, 0, + &rectangle, 1, + Unsorted); + XSetClipRectangles(XtDisplay(BW), + BW->bitmap.frame_gc, + 0, 0, + &rectangle, 1, + Unsorted); + XSetClipRectangles(XtDisplay(BW), + BW->bitmap.axes_gc, + 0, 0, + &rectangle, 1, + Unsorted); +} + +void BWUnclip(w) + Widget w; +{ + BitmapWidget BW = (BitmapWidget) w; + XRectangle rectangle; + + rectangle.x = InWindowX(BW, 0); + rectangle.y = InWindowY(BW, 0); + rectangle.width = InWindowX(BW, BW->bitmap.width) - InWindowX(BW, 0); + rectangle.height = InWindowY(BW, BW->bitmap.height) - InWindowY(BW, 0); + XSetClipRectangles(XtDisplay(BW), + BW->bitmap.highlighting_gc, + 0, 0, + &rectangle, 1, + Unsorted); + XSetClipRectangles(XtDisplay(BW), + BW->bitmap.drawing_gc, + 0, 0, + &rectangle, 1, + Unsorted); + XSetClipRectangles(XtDisplay(BW), + BW->bitmap.frame_gc, + 0, 0, + &rectangle, 1, + Unsorted); + XSetClipRectangles(XtDisplay(BW), + BW->bitmap.axes_gc, + 0, 0, + &rectangle, 1, + Unsorted); +} + +void Refresh(BW, x, y, width, height) + BitmapWidget BW; + Position x, y; + Dimension width, height; +{ + XRectangle rectangle; + + rectangle.x = min(x, InWindowX(BW, InBitmapX(BW, x))); + rectangle.y = min(y, InWindowY(BW, InBitmapY(BW, y))); + rectangle.width = max(x + width, + InWindowX(BW, InBitmapX(BW, x + width)+1)) - rectangle.x; + rectangle.height = max(y + height, + InWindowY(BW, InBitmapY(BW, y + height)+1)) - rectangle.y; + + XClearArea(XtDisplay(BW), XtWindow(BW), + rectangle.x, rectangle.y, + rectangle.width, rectangle.height, + False); + + XSetClipRectangles(XtDisplay(BW), + BW->bitmap.frame_gc, + 0, 0, + &rectangle, 1, + Unsorted); + + XDrawRectangle(XtDisplay(BW), XtWindow(BW), + BW->bitmap.frame_gc, + InWindowX(BW, 0) - 1, InWindowY(BW, 0) - 1, + InWindowX(BW, BW->bitmap.width) - InWindowX(BW, 0) + 1, + InWindowY(BW, BW->bitmap.height) - InWindowY(BW, 0) + 1); + + BWClip((Widget) BW, x, y, width, height); + + BWRedrawGrid((Widget) BW, x, y, width, height); + + BWRedrawSquares((Widget) BW, x, y, width, height); + + BWRedrawMark((Widget) BW); + BWRedrawHotSpot((Widget) BW); + BWRedrawAxes((Widget) BW); + BWUnclip((Widget) BW); +} + +Boolean BWQueryGrid(w) + Widget w; +{ + BitmapWidget BW = (BitmapWidget) w; + + return BW->bitmap.grid; +} + +void BWSwitchGrid(w) + Widget w; +{ + BitmapWidget BW = (BitmapWidget) w; + BW->bitmap.grid ^= TRUE; + BWDrawGrid(w, + 0, 0, + BW->bitmap.image->width - 1, BW->bitmap.image->height - 1); +} + +void BWGrid(w, _switch) + Widget w; + Boolean _switch; +{ + BitmapWidget BW = (BitmapWidget) w; + + if (BW->bitmap.grid != _switch) + BWSwitchGrid(w); +} + +Boolean BWQueryDashed(w) + Widget w; +{ + BitmapWidget BW = (BitmapWidget) w; + + return (BW->bitmap.dashed); +} + +void BWSwitchDashed(w) + Widget w; +{ + BitmapWidget BW = (BitmapWidget) w; + XRectangle rectangle; + + BWRedrawGrid(w, 0, 0, BW->bitmap.width - 1, BW->bitmap.height - 1); + + rectangle.x = 0; + rectangle.y = 0; + rectangle.width = BW->core.width; + rectangle.height = BW->core.height; + + XSetClipRectangles(XtDisplay(BW), + BW->bitmap.frame_gc, + 0, 0, + &rectangle, 1, + Unsorted); + + XDrawRectangle(XtDisplay(BW), XtWindow(BW), + BW->bitmap.frame_gc, + InWindowX(BW, 0) - 1, InWindowY(BW, 0) - 1, + InWindowX(BW, BW->bitmap.width) - InWindowX(BW, 0) + 1, + InWindowY(BW, BW->bitmap.height) - InWindowY(BW, 0) + 1); + + BW->bitmap.dashed ^= True; + XSetFillStyle(XtDisplay(BW), BW->bitmap.frame_gc, + (BW->bitmap.dashed ? FillStippled : FillSolid)); + + XDrawRectangle(XtDisplay(BW), XtWindow(BW), + BW->bitmap.frame_gc, + InWindowX(BW, 0) - 1, InWindowY(BW, 0) - 1, + InWindowX(BW, BW->bitmap.width) - InWindowX(BW, 0) + 1, + InWindowY(BW, BW->bitmap.height) - InWindowY(BW, 0) + 1); + + BWUnclip(w); + + BWRedrawGrid(w, 0, 0, BW->bitmap.width - 1, BW->bitmap.height - 1); +} + +void BWDashed(w, _switch) + Widget w; + Boolean _switch; +{ + BitmapWidget BW = (BitmapWidget) w; + + if (BW->bitmap.dashed != _switch) + BWSwitchDashed(w); +} + +static Boolean SetValues(old, request, new, args, num_args) /* ARGSUSED */ + Widget old, request, new; + ArgList args; + Cardinal *num_args; +{ + BitmapWidget oldbw = (BitmapWidget) old; + BitmapWidget newbw = (BitmapWidget) new; + Boolean resize = False; + Boolean redisplay = False; + +#define NE(field) (oldbw->field != newbw->field) + + if (NE(bitmap.grid)) + BWSwitchGrid(old); + + if (NE(bitmap.dashed)) + BWSwitchDashed(old); + + if (NE(bitmap.axes)) + BWSwitchAxes(old); + + if (NE(bitmap.stippled)) + BWSwitchStippled(old); + + if (NE(bitmap.proportional)) + resize = True; + + if (NE(bitmap.filename) || NE(bitmap.basename) || NE(bitmap.size)) + BWChangeNotify(old, NULL, NULL, NULL); + + if (NE(bitmap.filename)) + if (newbw->bitmap.filename) { + XtFree(oldbw->bitmap.filename); + newbw->bitmap.filename = XtNewString(newbw->bitmap.filename); + } + else + newbw->bitmap.filename = oldbw->bitmap.filename; + + if (NE(bitmap.basename)) + if (newbw->bitmap.basename) { + XtFree(oldbw->bitmap.basename); + newbw->bitmap.basename = XtNewString(newbw->bitmap.basename); + } + else + newbw->bitmap.basename = oldbw->bitmap.basename; + + if (NE(bitmap.size)) { + Dimension width, height; + + if (BWParseSize(newbw->bitmap.size, &width, &height)) { + ResizeGrid(newbw, width, height); + resize = True; + } + } + + if (NE(bitmap.margin) || + NE(bitmap.grid_tolerance) || + NE(bitmap.squareW) || + NE(bitmap.squareH) || + NE(core.height) || + NE(core.width)) + resize = True; + + if (NE(bitmap.hot.x) || NE(bitmap.hot.y)) + BWSetHotSpot(old, newbw->bitmap.hot.x, newbw->bitmap.hot.y); + + if (NE(bitmap.foreground_pixel) || NE(core.background_pixel)) { + XSetForeground(XtDisplay(new), + newbw->bitmap.drawing_gc, + newbw->bitmap.foreground_pixel + ^ + newbw->core.background_pixel); + redisplay = True; + } + + if (NE(bitmap.frame_pixel) || NE(core.background_pixel)) { + XSetForeground(XtDisplay(new), + newbw->bitmap.frame_gc, + newbw->bitmap.frame_pixel + ^ + newbw->core.background_pixel); + redisplay = True; + } + + if (NE(bitmap.dashes)) { + XSetStipple(XtDisplay(new), + newbw->bitmap.frame_gc, + newbw->bitmap.dashes); + redisplay = True; + } + + if (NE(bitmap.highlight_pixel) || NE(core.background_pixel)) { + RedrawStippled(newbw); + XSetForeground(XtDisplay(new), + newbw->bitmap.highlighting_gc, + newbw->bitmap.highlight_pixel + ^ + newbw->core.background_pixel); + RedrawStippled(newbw); + } + + if (NE(bitmap.stipple)) { + RedrawStippled(newbw); + XSetStipple(XtDisplay(new), + newbw->bitmap.highlighting_gc, + newbw->bitmap.stipple); + RedrawStippled(newbw); + } + + if (resize) Resize(newbw); + + return (redisplay || resize); + +#undef NE +} + +Boolean BWQueryProportional(w) + Widget w; +{ + BitmapWidget BW = (BitmapWidget) w; + + return (BW->bitmap.proportional); +} + +void BWSwitchProportional(w) + Widget w; +{ + BitmapWidget BW = (BitmapWidget) w; + + BW->bitmap.proportional ^= True; + + Resize(BW); + if (BW->core.visible) + XClearArea(XtDisplay(BW), XtWindow(BW), + 0, 0, + BW->core.width, BW->core.height, + True); +} + +void BWProportional(w, _switch) + Widget w; + Boolean _switch; +{ + BitmapWidget BW = (BitmapWidget) w; + + if (BW->bitmap.proportional != _switch) + BWSwitchProportional(w); +} + + +void BWTPaste(w, event, params, num_params) + Widget w; + XEvent *event; + String *params; + Cardinal *num_params; +{ + BitmapWidget BW = (BitmapWidget) w; + + BWRequestSelection(w, event->xbutton.time, TRUE); + + if (!BWQueryStored(w)) + return; + + BWEngageRequest(w, RestoreRequest, False, + (char *)&(event->xbutton.state), sizeof(int)); + + OnePointHandler(w, + (BWStatus*) BW->bitmap.request_stack[BW->bitmap.current].status, + event); +} + +void BWTMark(w, event, params, num_params) + Widget w; + XEvent *event; + String *params; + Cardinal *num_params; +{ + BitmapWidget BW = (BitmapWidget) w; + + BWEngageRequest(w, MarkRequest, False, + (char *)&(event->xbutton.state), sizeof(int)); + TwoPointsHandler(w, + (BWStatus*) BW->bitmap.request_stack[BW->bitmap.current].status, + event); + +} + +void BWTMarkAll(w, event, params, num_params) + Widget w; + XEvent *event; + String *params; + Cardinal *num_params; +{ + BWMarkAll(w); + + BWGrabSelection(w, event->xkey.time); +} + +void BWTUnmark(w, event, params, num_params) + Widget w; + XEvent *event; + String *params; + Cardinal *num_params; +{ + BWUnmark(w); +} + +/*****************************************************************************/ |