diff options
Diffstat (limited to 'nx-X11/include/DPS')
25 files changed, 5516 insertions, 0 deletions
diff --git a/nx-X11/include/DPS/ColorSB.h b/nx-X11/include/DPS/ColorSB.h new file mode 100644 index 000000000..04aa06136 --- /dev/null +++ b/nx-X11/include/DPS/ColorSB.h @@ -0,0 +1,173 @@ +/* + * ColorSB.h + * + * (c) Copyright 1993-1994 Adobe Systems Incorporated. + * All rights reserved. + * + * Permission to use, copy, modify, distribute, and sublicense this software + * and its documentation for any purpose and without fee is hereby granted, + * provided that the above copyright notices appear in all copies and that + * both those copyright notices and this permission notice appear in + * supporting documentation and that the name of Adobe Systems Incorporated + * not be used in advertising or publicity pertaining to distribution of the + * software without specific, written prior permission. No trademark license + * to use the Adobe trademarks is hereby granted. If the Adobe trademark + * "Display PostScript"(tm) is used to describe this software, its + * functionality or for any other purpose, such use shall be limited to a + * statement that this software works in conjunction with the Display + * PostScript system. Proper trademark attribution to reflect Adobe's + * ownership of the trademark shall be given whenever any such reference to + * the Display PostScript system is made. + * + * ADOBE MAKES NO REPRESENTATIONS ABOUT THE SUITABILITY OF THE SOFTWARE FOR + * ANY PURPOSE. IT IS PROVIDED "AS IS" WITHOUT EXPRESS OR IMPLIED WARRANTY. + * ADOBE DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL + * IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NON- INFRINGEMENT OF THIRD PARTY RIGHTS. IN NO EVENT SHALL ADOBE BE LIABLE + * TO YOU OR ANY OTHER PARTY FOR ANY SPECIAL, INDIRECT, OR CONSEQUENTIAL + * DAMAGES OR ANY DAMAGES WHATSOEVER WHETHER IN AN ACTION OF CONTRACT, + * NEGLIGENCE, STRICT LIABILITY OR ANY OTHER ACTION ARISING OUT OF OR IN + * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. ADOBE WILL NOT + * PROVIDE ANY TRAINING OR OTHER SUPPORT FOR THE SOFTWARE. + * + * Adobe, PostScript, and Display PostScript are trademarks of Adobe Systems + * Incorporated which may be registered in certain jurisdictions + * + * Author: Adobe Systems Incorporated + */ +/* $XFree86$ */ + +#ifndef _ColorSelectionBox_h +#define _ColorSelectionBox_h + +/* New resouce names and classes */ + +#define XtNcontext "context" +#define XtCContext "Context" +#define XtNrgbLabels "rgbLabels" +#define XtCRgbLabels "RgbLabels" +#define XtNcmykLabels "cmykLabels" +#define XtCCmykLabels "CmykLabels" +#define XtNhsbLabels "hsbLabels" +#define XtCHsbLabels "HsbLabels" +#define XtNgrayLabels "grayLabels" +#define XtCGrayLabels "GrayLabels" +#define XtNcellSize "cellSize" +#define XtCCellSize "CellSize" +#define XtNnumCells "numCells" +#define XtCNumCells "NumCells" +#define XtNfillMe "fillMe" +#define XtCFillMe "FillMe" +#define XtNcurrentSpace "currentSpace" +#define XtCCurrentSpace "CurrentSpace" +#define XtNcurrentRendering "currentRendering" +#define XtCCurrentRendering "CurrentRendering" +#define XtNcurrentPalette "currentPalette" +#define XtCCurrentPalette "CurrentPalette" +#define XtNbrokenPaletteLabel "brokenPaletteLabel" +#define XtCBrokenPaletteLabel "BrokenPaletteLabel" +#define XtNbrokenPaletteMessage "brokenPaletteMessage" +#define XtCBrokenPaletteMessage "BrokenPaletteMessage" + +#define XtNpalette0Label "palette0Label" +#define XtNpalette0Space "palette0Space" +#define XtNpalette0ColorDependent "palette0ColorDependent" +#define XtNpalette0Function "palette0Function" +#define XtNpalette1Label "palette1Label" +#define XtNpalette1Space "palette1Space" +#define XtNpalette1ColorDependent "palette1ColorDependent" +#define XtNpalette1Function "palette1Function" +#define XtNpalette2Label "palette2Label" +#define XtNpalette2Space "palette2Space" +#define XtNpalette2ColorDependent "palette2ColorDependent" +#define XtNpalette2Function "palette2Function" +#define XtNpalette3Label "palette3Label" +#define XtNpalette3Space "palette3Space" +#define XtNpalette3ColorDependent "palette3ColorDependent" +#define XtNpalette3Function "palette3Function" +#define XtNpalette4Label "palette4Label" +#define XtNpalette4Space "palette4Space" +#define XtNpalette4ColorDependent "palette4ColorDependent" +#define XtNpalette4Function "palette4Function" +#define XtNpalette5Label "palette5Label" +#define XtNpalette5Space "palette5Space" +#define XtNpalette5ColorDependent "palette5ColorDependent" +#define XtNpalette5Function "palette5Function" +#define XtNpalette6Label "palette6Label" +#define XtNpalette6Space "palette6Space" +#define XtNpalette6ColorDependent "palette6ColorDependent" +#define XtNpalette6Function "palette6Function" +#define XtNpalette7Label "palette7Label" +#define XtNpalette7Space "palette7Space" +#define XtNpalette7ColorDependent "palette7ColorDependent" +#define XtNpalette7Function "palette7Function" +#define XtNpalette8Label "palette8Label" +#define XtNpalette8Space "palette8Space" +#define XtNpalette8ColorDependent "palette8ColorDependent" +#define XtNpalette8Function "palette8Function" +#define XtNpalette9Label "palette9Label" +#define XtNpalette9Space "palette9Space" +#define XtNpalette9ColorDependent "palette9ColorDependent" +#define XtNpalette9Function "palette9Function" + +#define XtCPaletteLabel "PaletteLabel" +#define XtCPaletteSpace "PaletteSpace" +#define XtCPaletteColorDependent "PaletteColorDependent" +#define XtCPaletteFunction "PaletteFunction" + +#define XtNokCallback "okCallback" +#define XtNapplyCallback "applyCallback" +#define XtNresetCallback "resetCallback" +#ifndef XtNcancelCallback +#define XtNcancelCallback "cancelCallback" +#endif +#define XtNvalueChangedCallback "valueChangedCallback" + +/* New resource types */ + +#define XtRDPSContext "DPSContext" +#define XtRColorSpace "CSBColorSpace" +#define XtRRenderingType "CSBRenderingType" + +typedef enum {CSBSpaceRGB, CSBSpaceCMYK, CSBSpaceHSB, + CSBSpaceGray} CSBColorSpace; +typedef enum {CSBDisplayX, CSBDisplayDPS, CSBDisplayBoth} CSBRenderingType; +typedef enum {CSBOK, CSBApply, CSBReset, + CSBCancel, CSBValueChanged} CSBCallbackReason; + +typedef struct { + CSBCallbackReason reason; + CSBColorSpace current_space; + float red, green, blue; + float cyan, magenta, yellow, black; + float hue, saturation, brightness; + float gray; +} CSBCallbackRec; + +/* Class record constants */ + +extern WidgetClass colorSelectionBoxWidgetClass; + +typedef struct _ColorSelectionBoxRec *ColorSelectionBoxWidget; + +/* Convenience routine */ + +#if defined(__cplusplus) || defined(c_plusplus) +extern "C" { +#endif + +/* Note use of Bool and double in prototypes: this makes the library + work correctly when linked with no-prototype compiled objects */ + +extern Boolean CSBSetColor(Widget w, CSBColorSpace space, double c1, + double c2, double c3, double c4, Bool setSpace); + +extern void CSBGetColor(Widget w, CSBColorSpace space, float *c1, + float *c2, float *c3, float *c4); + +#if defined(__cplusplus) || defined(c_plusplus) +extern "C" } +#endif + +#endif /* _ColorSelectionBox_h */ +/* DON'T ADD ANYTHING AFTER THIS #endif */ diff --git a/nx-X11/include/DPS/ColorSBP.h b/nx-X11/include/DPS/ColorSBP.h new file mode 100644 index 000000000..c26dc71f4 --- /dev/null +++ b/nx-X11/include/DPS/ColorSBP.h @@ -0,0 +1,183 @@ +/* + * ColorSBP.h + * + * (c) Copyright 1993-1994 Adobe Systems Incorporated. + * All rights reserved. + * + * Permission to use, copy, modify, distribute, and sublicense this software + * and its documentation for any purpose and without fee is hereby granted, + * provided that the above copyright notices appear in all copies and that + * both those copyright notices and this permission notice appear in + * supporting documentation and that the name of Adobe Systems Incorporated + * not be used in advertising or publicity pertaining to distribution of the + * software without specific, written prior permission. No trademark license + * to use the Adobe trademarks is hereby granted. If the Adobe trademark + * "Display PostScript"(tm) is used to describe this software, its + * functionality or for any other purpose, such use shall be limited to a + * statement that this software works in conjunction with the Display + * PostScript system. Proper trademark attribution to reflect Adobe's + * ownership of the trademark shall be given whenever any such reference to + * the Display PostScript system is made. + * + * ADOBE MAKES NO REPRESENTATIONS ABOUT THE SUITABILITY OF THE SOFTWARE FOR + * ANY PURPOSE. IT IS PROVIDED "AS IS" WITHOUT EXPRESS OR IMPLIED WARRANTY. + * ADOBE DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL + * IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NON- INFRINGEMENT OF THIRD PARTY RIGHTS. IN NO EVENT SHALL ADOBE BE LIABLE + * TO YOU OR ANY OTHER PARTY FOR ANY SPECIAL, INDIRECT, OR CONSEQUENTIAL + * DAMAGES OR ANY DAMAGES WHATSOEVER WHETHER IN AN ACTION OF CONTRACT, + * NEGLIGENCE, STRICT LIABILITY OR ANY OTHER ACTION ARISING OUT OF OR IN + * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. ADOBE WILL NOT + * PROVIDE ANY TRAINING OR OTHER SUPPORT FOR THE SOFTWARE. + * + * Adobe, PostScript, and Display PostScript are trademarks of Adobe Systems + * Incorporated which may be registered in certain jurisdictions + * + * Author: Adobe Systems Incorporated + */ +/* $XFree86$ */ + +#ifndef _ColorSelectionBoxP_H +#define _ColorSelectionBoxP_H + +#include <DPS/ColorSB.h> + +typedef struct { + float red, green, blue; + float cyan, magenta, yellow, black; + float hue, saturation, brightness; + float gray; +} ColorRec; + +/* Redefining PALETTE_MAX requires program alterations. */ + +#define PALETTE_MAX 10 + +typedef struct { + DPSContext context; + String rgb_labels; + String cmyk_labels; + String hsb_labels; + String gray_labels; + Dimension cell_size; + short num_cells; + short current_palette; + String fill_me; + CSBColorSpace current_space; + CSBRenderingType current_rendering; + String broken_palette_label; + String broken_palette_message; + + String palette_label[PALETTE_MAX]; + CSBColorSpace palette_space[PALETTE_MAX]; + Boolean palette_color_dependent[PALETTE_MAX]; + Boolean palette_broken[PALETTE_MAX]; + String palette_function[PALETTE_MAX]; + + XtCallbackList ok_callback; + XtCallbackList apply_callback; + XtCallbackList reset_callback; + XtCallbackList cancel_callback; + XtCallbackList face_select_callback; + XtCallbackList value_changed_callback; + + /* Subwidgets */ + Widget form_child; + Widget slider_child[4]; + Widget value_child[4]; + Widget label_child[4]; + Widget model_option_menu_child; + Widget display_option_menu_child; + Widget patch_child; + Widget dock_child; + Widget palette_option_menu_child; + Widget palette_child; + + /* Private fields */ + + Pixel background; + Boolean static_visual; + Boolean no_background; + Boolean palette_pixmap_valid; + int visual_class; + DPSGState base_gstate; + DPSGState patch_gstate; + DPSGState dock_gstate; + ColorRec current_color; + ColorRec palette_color; + ColorRec save_color; + + Pixmap red_pixmap; + Pixmap green_pixmap; + Pixmap blue_pixmap; + Pixmap cyan_pixmap; + Pixmap magenta_pixmap; + Pixmap yellow_pixmap; + Pixmap black_pixmap; + Pixmap hue_pixmap; + Pixmap sat_pixmap; + Pixmap bright_pixmap; + Pixmap gray_pixmap; + + Dimension rgb_slider_width; + Dimension cmyk_slider_width; + Dimension hsb_slider_width; + Dimension gray_slider_width; + + float itransform[6]; + + float *dock_cyan, *dock_magenta, *dock_yellow, *dock_black; + Boolean *dock_used; + Boolean dock_changed; + + Cursor eyedrop; + Cursor square; + Boolean eyedrop_grabbed; +} ColorSelectionBoxPart; + +typedef struct _ColorSelectionBoxRec { + CorePart core; + CompositePart composite; + ConstraintPart constraint; + XmManagerPart manager; + ColorSelectionBoxPart csb; +} ColorSelectionBoxRec; + +#if defined(__cplusplus) || defined(c_plusplus) +extern "C" { +#endif + +/* Note use of Bool and double in prototypes: this makes the library + work correctly when linked with no-prototype compiled objects */ + +typedef Boolean (*CSBSetColorProc) (Widget w, CSBColorSpace space, double c1, + double c2, double c3, double c4, Bool setSpace); + +typedef void (*CSBGetColorProc) (Widget w, CSBColorSpace space, float *c1, + float *c2, float *c3, float *c4); + +#if defined(__cplusplus) || defined(c_plusplus) +} +#endif + +#define InheritSetColor ((CSBSetColorProc) _XtInherit) +#define InheritGetColor ((CSBGetColorProc) _XtInherit) + +typedef struct { + CSBSetColorProc set_color; + CSBGetColorProc get_color; + XtPointer extension; +} ColorSelectionBoxClassPart; + +typedef struct _ColorSelectionBoxClassRec { + CoreClassPart core_class; + CompositeClassPart composite_class; + ConstraintClassPart constraint_class; + XmManagerClassPart manager_class; + ColorSelectionBoxClassPart csb_class; +} ColorSelectionBoxClassRec, *ColorSelectionBoxWidgetClass; + +extern ColorSelectionBoxClassRec colorSelectionBoxClassRec; + +#endif /* _ColorSelectionBoxP_H */ +/* DON'T ADD ANYTHING AFTER THIS #endif */ diff --git a/nx-X11/include/DPS/DPSScrollW.h b/nx-X11/include/DPS/DPSScrollW.h new file mode 100644 index 000000000..5baeec785 --- /dev/null +++ b/nx-X11/include/DPS/DPSScrollW.h @@ -0,0 +1,192 @@ +/* + * DPSScrollW.h + * + * (c) Copyright 1993-1994 Adobe Systems Incorporated. + * All rights reserved. + * + * Permission to use, copy, modify, distribute, and sublicense this software + * and its documentation for any purpose and without fee is hereby granted, + * provided that the above copyright notices appear in all copies and that + * both those copyright notices and this permission notice appear in + * supporting documentation and that the name of Adobe Systems Incorporated + * not be used in advertising or publicity pertaining to distribution of the + * software without specific, written prior permission. No trademark license + * to use the Adobe trademarks is hereby granted. If the Adobe trademark + * "Display PostScript"(tm) is used to describe this software, its + * functionality or for any other purpose, such use shall be limited to a + * statement that this software works in conjunction with the Display + * PostScript system. Proper trademark attribution to reflect Adobe's + * ownership of the trademark shall be given whenever any such reference to + * the Display PostScript system is made. + * + * ADOBE MAKES NO REPRESENTATIONS ABOUT THE SUITABILITY OF THE SOFTWARE FOR + * ANY PURPOSE. IT IS PROVIDED "AS IS" WITHOUT EXPRESS OR IMPLIED WARRANTY. + * ADOBE DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL + * IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NON- INFRINGEMENT OF THIRD PARTY RIGHTS. IN NO EVENT SHALL ADOBE BE LIABLE + * TO YOU OR ANY OTHER PARTY FOR ANY SPECIAL, INDIRECT, OR CONSEQUENTIAL + * DAMAGES OR ANY DAMAGES WHATSOEVER WHETHER IN AN ACTION OF CONTRACT, + * NEGLIGENCE, STRICT LIABILITY OR ANY OTHER ACTION ARISING OUT OF OR IN + * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. ADOBE WILL NOT + * PROVIDE ANY TRAINING OR OTHER SUPPORT FOR THE SOFTWARE. + * + * Adobe, PostScript, and Display PostScript are trademarks of Adobe Systems + * Incorporated which may be registered in certain jurisdictions + * + * Author: Adobe Systems Incorporated + */ +/* $XFree86$ */ + +#ifndef _DPSScrolledWindow_h +#define _DPSScrolledWindow_h + +#include <DPS/dpsXshare.h> + +/* New resouce names and classes */ + +#define XtNcontext "context" +#define XtCContext "Context" +#define XtNareaWidth "areaWidth" +#define XtCAreaWidth "AreaWidth" +#define XtNareaHeight "areaHeight" +#define XtCAreaHeight "AreaHeight" +#define XtNscale "scale" +#define XtCScale "Scale" +#define XtNctm "ctm" +#define XtCCtm "Ctm" +#define XtNinvCtm "invCtm" +#define XtCInvCtm "InvCtm" +#define XtNuseBackingPixmap "useBackingPixmap" +#define XtCUseBackingPixmap "UseBackingPixmap" +#define XtNuseFeedbackPixmap "useFeedbackPixmap" +#define XtCUseFeedbackPixmap "UseFeedbackPixmap" +#define XtNbackingPixmap "backingPixmap" +#define XtCBackingPixmap "BackingPixmap" +#define XtNfeedbackPixmap "feedbackPixmap" +#define XtCFeedbackPixmap "FeedbackPixmap" +#define XtNdocumentSizePixmaps "documentSizePixmaps" +#define XtCDocumentSizePixmaps "DocumentSizePixmaps" +#define XtNwindowGState "windowGState" +#define XtCWindowGState "WindowGState" +#define XtNbackingGState "backingGState" +#define XtCBackingGState "BackingGState" +#define XtNfeedbackGState "feedbackGState" +#define XtCFeedbackGState "FeedbackGState" +#define XtNdirtyAreas "dirtyAreas" +#define XtCDirtyAreas "DirtyAreas" +#define XtNnumDirtyAreas "numDirtyAreas" +#define XtCNumDirtyAreas "NumDirtyAreas" +#define XtNpixmapLimit "pixmapLimit" +#define XtCPixmapLimit "PixmapLimit" +#define XtNabsolutePixmapLimit "absolutePixmapLimit" +#define XtCAbsolutePixmapLimit "AbsolutePixmapLimit" +#define XtNwatchProgress "watchProgress" +#define XtCWatchProgress "WatchProgress" +#define XtNminimalDrawing "minimalDrawing" +#define XtCMinimalDrawing "MinimalDrawing" +#define XtNwatchProgressDelay "watchProgressDelay" +#define XtCWatchProgressDelay "WatchProgressDelay" +#define XtNapplicationScrolling "applicationScrolling" +#define XtCApplicationScrolling "ApplicationScrolling" +#define XtNsetupCallback "setupCallback" +#define XtNexposeCallback "exposeCallback" +#define XtNbackgroundCallback "backgroundCallback" +#define XtNfeedbackCallback "feedbackCallback" +#define XtNresizeCallback "resizeCallback" + +/* New resource types */ + +#define XtRDPSContext "DPSContext" +#define XtRDPSGState "DPSGState" +#define XtRFloatArray "FloatArray" + +/* Callback records */ + +typedef struct { + DPSContext context; +} DSWSetupCallbackRec; + +typedef enum {DSWWindow, DSWBackingPixmap, DSWFeedbackPixmap} DSWDrawableType; +typedef enum {DSWDrawSome, DSWAbort, DSWFinish, + DSWAbortOrFinish} DSWDirections; +typedef enum {DSWUndefined, DSWCallAgain, DSWAborted, DSWFinished} DSWResults; + +typedef struct { + DSWDrawableType type; + DSWDirections directions; + DSWResults results; /* Filled in by callback */ + Boolean first; + Boolean background; + Drawable drawable; + DPSGState gstate; + DPSContext context; + float *rects; + int rect_count; +} DSWExposeCallbackRec; + +typedef struct { + Dimension oldw, oldh; + Dimension neww, newh; + Position x, y; +} DSWResizeCallbackRec; + +typedef struct { + XtPointer start_feedback_data; + XtPointer continue_feedback_data; + DSWDrawableType type; + Drawable drawable; + DPSGState gstate; + DPSContext context; + float *dirty_rects; + int dirty_count; +} DSWFeedbackCallbackRec; + +/* Class record constants */ + +extern WidgetClass dpsScrolledWindowWidgetClass; + +typedef struct _DPSScrolledWindowRec *DPSScrolledWindowWidget; + +/* Interface routines */ + +#if defined(__cplusplus) || defined(c_plusplus) +extern "C" { +#endif + +/* Note use of long and double in prototypes: this makes the library + work correctly when linked with no-prototype compiled objects */ + +extern void DSWSetScale(Widget w, double scale, long fixedX, long fixedY); +extern void DSWScrollPoint(Widget w, double psX, double psY, long xX, long xY); +extern void DSWScrollBy(Widget w, long dx, long dy); +extern void DSWScrollTo(Widget w, long x, long y); +extern void DSWSetScaleAndScroll(Widget w, double scale, + double psX, double psY, long xX, long xY); +extern void DSWConvertXToPS(Widget w, long xX, long xY, + float *psX, float *psY); +extern void DSWConvertPSToX(Widget w, double psX, double psY, + int *xX, int *xY); +extern void DSWAddToDirtyArea(Widget w, float *rect, long n); +extern Boolean DSWTakeFeedbackPixmap(Widget w, Pixmap *p, int *width, + int *height, int *depth, Screen **screen); +extern Boolean DSWGiveFeedbackPixmap(Widget w, Pixmap p, int width, int height, + int depth, Screen *screen); +extern void DSWStartFeedbackDrawing(Widget w, XtPointer start_feedback_data); +extern void DSWEndFeedbackDrawing(Widget w, Bool restore_window); +extern void DSWSetFeedbackDirtyArea(Widget w, float *rects, int count, + XtPointer continue_feedback_data); +extern void DSWFinishPendingDrawing(Widget w); +extern void DSWAbortPendingDrawing(Widget w); +extern void DSWGetDrawingInfo(Widget w, DSWDrawableType *type, + Drawable *drawable, DPSGState *gstate, + DPSContext *context); +extern void DSWUpdateDrawing(Widget w, float *rects, int count); +extern void DSWGetScrollInfo(Widget w, int *h_value, int *h_size, int *h_max, + int *v_value, int *v_size, int *v_max); + +#if defined(__cplusplus) || defined(c_plusplus) +}; +#endif + +#endif /* _DPSScrolledWindow_h */ +/* DON'T ADD ANYTHING AFTER THIS #endif */ diff --git a/nx-X11/include/DPS/DPSScrollWP.h b/nx-X11/include/DPS/DPSScrollWP.h new file mode 100644 index 000000000..a1bf26a76 --- /dev/null +++ b/nx-X11/include/DPS/DPSScrollWP.h @@ -0,0 +1,260 @@ +/* + * DPSScrollWP.h + * + * (c) Copyright 1993-1994 Adobe Systems Incorporated. + * All rights reserved. + * + * Permission to use, copy, modify, distribute, and sublicense this software + * and its documentation for any purpose and without fee is hereby granted, + * provided that the above copyright notices appear in all copies and that + * both those copyright notices and this permission notice appear in + * supporting documentation and that the name of Adobe Systems Incorporated + * not be used in advertising or publicity pertaining to distribution of the + * software without specific, written prior permission. No trademark license + * to use the Adobe trademarks is hereby granted. If the Adobe trademark + * "Display PostScript"(tm) is used to describe this software, its + * functionality or for any other purpose, such use shall be limited to a + * statement that this software works in conjunction with the Display + * PostScript system. Proper trademark attribution to reflect Adobe's + * ownership of the trademark shall be given whenever any such reference to + * the Display PostScript system is made. + * + * ADOBE MAKES NO REPRESENTATIONS ABOUT THE SUITABILITY OF THE SOFTWARE FOR + * ANY PURPOSE. IT IS PROVIDED "AS IS" WITHOUT EXPRESS OR IMPLIED WARRANTY. + * ADOBE DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL + * IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NON- INFRINGEMENT OF THIRD PARTY RIGHTS. IN NO EVENT SHALL ADOBE BE LIABLE + * TO YOU OR ANY OTHER PARTY FOR ANY SPECIAL, INDIRECT, OR CONSEQUENTIAL + * DAMAGES OR ANY DAMAGES WHATSOEVER WHETHER IN AN ACTION OF CONTRACT, + * NEGLIGENCE, STRICT LIABILITY OR ANY OTHER ACTION ARISING OUT OF OR IN + * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. ADOBE WILL NOT + * PROVIDE ANY TRAINING OR OTHER SUPPORT FOR THE SOFTWARE. + * + * Adobe, PostScript, and Display PostScript are trademarks of Adobe Systems + * Incorporated which may be registered in certain jurisdictions + * + * Author: Adobe Systems Incorporated + */ +/* $XFree86$ */ + +#ifndef _DPSScrolledWindowP_H +#define _DPSScrolledWindowP_H + +#include <DPS/DPSScrollW.h> + +typedef enum {DSWStart, DSWDrawingVisible, DSWDrewVisible, + DSWDrawingBackground, DSWDone} DSWDrawingStage; + +typedef struct { + /* Resources */ + DPSContext context; + int area_width; + int area_height; + float scale; + float *ctm_ptr; + float *inv_ctm_ptr; + Pixmap backing_pixmap; + Pixmap feedback_pixmap; + DPSGState window_gstate; + DPSGState backing_gstate; + DPSGState feedback_gstate; + float *dirty_areas; + short num_dirty_areas; + int pixmap_limit; + int absolute_pixmap_limit; + int watch_progress_delay; + Boolean use_backing_pixmap; + Boolean use_feedback_pixmap; + Boolean watch_progress; + Boolean minimal_drawing; + Boolean document_size_pixmaps; + Boolean application_scrolling; + + XtCallbackList setup_callback; + XtCallbackList expose_callback; + XtCallbackList background_callback; + XtCallbackList feedback_callback; + XtCallbackList resize_callback; + + /* Subwidgets */ + + Widget scrolled_window; + Widget h_scroll; + Widget v_scroll; + Widget drawing_area; + + /* Private fields */ + float ctm[6]; + float orig_inv_ctm[6]; + float inv_ctm[6]; + int x_offset, y_offset; + int feedback_width, feedback_height; + float drawing_width, drawing_height; /* scaled drawing size in X coords */ + int unscaled_width, unscaled_height; + int pixmap_width, pixmap_height; + float scroll_pic_x, scroll_pic_y; + int scroll_win_x, scroll_win_y; + int scroll_x, scroll_y; + int scroll_h_value, scroll_v_value; /* These may be virtual */ + int scroll_h_size, scroll_v_size; + int scroll_h_max, scroll_v_max; + int origin_x, origin_y; /* origin loc. relative to X offset */ + int *pending_expose; + short num_pending_expose; + short pending_expose_size; + float *pending_dirty; + short num_pending_dirty; + short pending_dirty_size; + float *current_drawing; + short num_current_drawing; + short current_drawing_size; + short dirty_areas_size; + float *prev_dirty_areas; + short prev_dirty_areas_size; + short num_prev_dirty_areas; + float *scratch; /* To avoid reallocating buffers */ + short num_scratch; + short scratch_size; + GC ge_gc; /* Generates GraphicsExposes on copy */ + GC no_ge_gc; /* Generates no GraphicsExposes */ + XtWorkProcId work; + XtPointer start_feedback_data; + XtPointer continue_feedback_data; + DSWDrawingStage drawing_stage; + Boolean use_saved_scroll; + Boolean context_inited; + Boolean doing_feedback; + Boolean feedback_displayed; + Boolean big_pixmap; /* Is the pixmap larger than the window? */ + Boolean scrolling; +} DPSScrolledWindowPart; + +typedef struct _DPSScrolledWindowRec { + CorePart core; + CompositePart composite; + ConstraintPart constraint; + XmManagerPart manager; + DPSScrolledWindowPart sw; +} DPSScrolledWindowRec; + +/* Here's a list of the various rectangle lists we use in the widget and + what they're for. In all cases _size is the number of slots in the + list, and num_ is the number of slots currently in use. + + dirty_areas: A list of all areas of the drawing that either need to + be drawn or are in the process of being drawn. + + prev_dirty_areas: Used as a buffer during feedback drawing. + + current_drawing: A list of all areas of the drawing that are currently + being drawn. This is the view clip for any calls to the expose callback. + + pending_dirty: A list of all areas for which exposures have arrived + since drawing was begun. This is only maintained if drawing is + being done to the window (either watch progress is on, or there is no + backing pixmap, or we're doing feedback without a feedback pixmap). + + pending_expose: Same areas as pending_dirty, but kept in X coordinates. + This is always maintained. + + scratch: Used to hold temporary copies of rectangle lists. +*/ + +#if defined(__cplusplus) || defined(c_plusplus) +typedef "C" { +#endif + +/* Note use of long and double in prototypes: this makes the library + work correctly when linked with no-prototype compiled objects */ + +typedef void (*DSWSetScaleProc) (Widget w, double scale, + long fixedX, long fixedY); +typedef void (*DSWScrollPointProc) (Widget w, double psX, double psY, + long xX, long xY); +typedef void (*DSWScrollByProc) (Widget w, long dx, long dy); +typedef void (*DSWScrollToProc) (Widget w, long x, long y); +typedef void (*DSWSetScaleAndScrollProc) (Widget w, double scale, + double psX, double psY, + long xX, long xY); +typedef void (*DSWConvertXToPSProc) (Widget w, long xX, long xY, + float *psX, float *psY); +typedef void (*DSWConvertPSToXProc) (Widget w, double psX, double psY, + int *xX, int *xY); +typedef void (*DSWAddToDirtyAreaProc) (Widget w, float *rect, long n); +typedef Boolean (*DSWTakeFeedbackPixmapProc) (Widget w, Pixmap *p, + int *width, int *height, + int *depth, Screen **screen); +typedef Boolean (*DSWGiveFeedbackPixmapProc) (Widget w, Pixmap p, + int width, int height, + int depth, Screen *screen); +typedef void (*DSWStartFeedbackDrawingProc) (Widget w, + XtPointer start_feedback_data); +typedef void (*DSWEndFeedbackDrawingProc) (Widget w, Bool restore_window); +typedef void (*DSWSetFeedbackDirtyAreaProc) (Widget w, float *rects, int count, + XtPointer continue_feedback_data); +typedef void (*DSWFinishPendingDrawingProc) (Widget w); +typedef void (*DSWAbortPendingDrawingProc) (Widget w); +typedef void (*DSWGetDrawingInfoProc) (Widget w, DSWDrawableType *type, + Drawable *drawable, DPSGState *gstate, DPSContext *context); +typedef void (*DSWUpdateDrawingProc) (Widget w, float *rects, int count); +typedef void (*DSWGetScrollInfoProc) (Widget w, int *h_value, int *h_size, + int *h_max, int *v_value, int *v_size, + int *v_max); + +#if defined(__cplusplus) || defined(c_plusplus) +} +#endif + +#define InheritSetScale ((DSWSetScaleProc) _XtInherit) +#define InheritScrollPoint ((DSWScrollPointProc) _XtInherit) +#define InheritScrollBy ((DSWScrollByProc) _XtInherit) +#define InheritScrollTo ((DSWScrollToProc) _XtInherit) +#define InheritSetScaleAndScroll ((DSWSetScaleAndScrollProc) _XtInherit) +#define InheritConvertXToPS ((DSWConvertXToPSProc) _XtInherit) +#define InheritConvertPSToX ((DSWConvertPSToXProc) _XtInherit) +#define InheritAddToDirtyArea ((DSWAddToDirtyAreaProc) _XtInherit) +#define InheritTakeFeedbackPixmap ((DSWTakeFeedbackPixmapProc) _XtInherit) +#define InheritGiveFeedbackPixmap ((DSWGiveFeedbackPixmapProc) _XtInherit) +#define InheritStartFeedbackDrawing ((DSWStartFeedbackDrawingProc) _XtInherit) +#define InheritEndFeedbackDrawing ((DSWEndFeedbackDrawingProc) _XtInherit) +#define InheritSetFeedbackDirtyArea ((DSWSetFeedbackDirtyAreaProc) _XtInherit) +#define InheritFinishPendingDrawing ((DSWFinishPendingDrawingProc) _XtInherit) +#define InheritAbortPendingDrawing ((DSWAbortPendingDrawingProc) _XtInherit) +#define InheritGetDrawingInfo ((DSWGetDrawingInfoProc) _XtInherit) +#define InheritUpdateDrawing ((DSWUpdateDrawingProc) _XtInherit) +#define InheritGetScrollInfo ((DSWGetScrollInfoProc) _XtInherit) + +typedef struct { + DSWSetScaleProc set_scale; + DSWScrollPointProc scroll_point; + DSWScrollByProc scroll_by; + DSWScrollToProc scroll_to; + DSWSetScaleAndScrollProc set_scale_and_scroll; + DSWConvertXToPSProc convert_x_to_ps; + DSWConvertPSToXProc convert_ps_to_x; + DSWAddToDirtyAreaProc add_to_dirty_area; + DSWTakeFeedbackPixmapProc take_feedback_pixmap; + DSWGiveFeedbackPixmapProc give_feedback_pixmap; + DSWStartFeedbackDrawingProc start_feedback_drawing; + DSWEndFeedbackDrawingProc end_feedback_drawing; + DSWSetFeedbackDirtyAreaProc set_feedback_dirty_area; + DSWFinishPendingDrawingProc finish_pending_drawing; + DSWAbortPendingDrawingProc abort_pending_drawing; + DSWGetDrawingInfoProc get_drawing_info; + DSWUpdateDrawingProc update_drawing; + DSWGetScrollInfoProc get_scroll_info; + XtPointer extension; +} DPSScrolledWindowClassPart; + +typedef struct _DPSScrolledWindowClassRec { + CoreClassPart core_class; + CompositeClassPart composite_class; + ConstraintClassPart constraint_class; + XmManagerClassPart manager_class; + DPSScrolledWindowClassPart sw_class; +} DPSScrolledWindowClassRec, *DPSScrolledWindowWidgetClass; + +extern DPSScrolledWindowClassRec dpsScrolledWindowClassRec; + +#endif /* _DPSScrolledWindowP_H */ +/* DON'T ADD ANYTHING AFTER THIS #endif */ diff --git a/nx-X11/include/DPS/FontCreatP.h b/nx-X11/include/DPS/FontCreatP.h new file mode 100644 index 000000000..6683e0d34 --- /dev/null +++ b/nx-X11/include/DPS/FontCreatP.h @@ -0,0 +1,106 @@ +/* + * FontCreatP.h + * + * (c) Copyright 1991-1994 Adobe Systems Incorporated. + * All rights reserved. + * + * Permission to use, copy, modify, distribute, and sublicense this software + * and its documentation for any purpose and without fee is hereby granted, + * provided that the above copyright notices appear in all copies and that + * both those copyright notices and this permission notice appear in + * supporting documentation and that the name of Adobe Systems Incorporated + * not be used in advertising or publicity pertaining to distribution of the + * software without specific, written prior permission. No trademark license + * to use the Adobe trademarks is hereby granted. If the Adobe trademark + * "Display PostScript"(tm) is used to describe this software, its + * functionality or for any other purpose, such use shall be limited to a + * statement that this software works in conjunction with the Display + * PostScript system. Proper trademark attribution to reflect Adobe's + * ownership of the trademark shall be given whenever any such reference to + * the Display PostScript system is made. + * + * ADOBE MAKES NO REPRESENTATIONS ABOUT THE SUITABILITY OF THE SOFTWARE FOR + * ANY PURPOSE. IT IS PROVIDED "AS IS" WITHOUT EXPRESS OR IMPLIED WARRANTY. + * ADOBE DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL + * IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NON- INFRINGEMENT OF THIRD PARTY RIGHTS. IN NO EVENT SHALL ADOBE BE LIABLE + * TO YOU OR ANY OTHER PARTY FOR ANY SPECIAL, INDIRECT, OR CONSEQUENTIAL + * DAMAGES OR ANY DAMAGES WHATSOEVER WHETHER IN AN ACTION OF CONTRACT, + * NEGLIGENCE, STRICT LIABILITY OR ANY OTHER ACTION ARISING OUT OF OR IN + * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. ADOBE WILL NOT + * PROVIDE ANY TRAINING OR OTHER SUPPORT FOR THE SOFTWARE. + * + * Adobe, PostScript, and Display PostScript are trademarks of Adobe Systems + * Incorporated which may be registered in certain jurisdictions + * + * Author: Adobe Systems Incorporated + */ + +#ifndef _FontCreatorP_H +#define _FontCreatorP_H + +#define MAX_AXES 4 + +#include <DPS/FontCreato.h> + +typedef struct { + float *sizes; + int size_count; + FontSelectionBoxWidget fsb; + XtCallbackList dismiss_callback; + + Widget pane_child; + Widget preview_child; + Widget display_text_child; + Widget axis_label_child[MAX_AXES]; + Widget axis_scale_child[MAX_AXES]; + Widget axis_min_label_child[MAX_AXES]; + Widget axis_max_label_child[MAX_AXES]; + Widget axis_value_text_child[MAX_AXES]; + Widget face_scrolled_list_child; + Widget blend_label_child; + Widget blend_scrolled_list_child; + Widget size_text_field_child; + Widget size_option_menu_child; + Widget generate_button_child; + Widget name_label_child; + Widget name_text_child; + Widget do_all_toggle_child; + Widget follow_size_toggle_child; + + /* Private fields */ + + DPSGState gstate; + Widget other_size; + Widget size_menu; + Widget option_box; + FontFamilyRec *family; + FontRec *font; + int managed_axes; + Boolean preview_fixed; +} FontCreatorPart; + +typedef struct _FontCreatorRec { + CorePart core; + CompositePart composite; + ConstraintPart constraint; + XmManagerPart manager; + FontCreatorPart creator; +} FontCreatorRec; + +typedef struct { + XtPointer extension; +} FontCreatorClassPart; + +typedef struct _FontCreatorClassRec { + CoreClassPart core_class; + CompositeClassPart composite_class; + ConstraintClassPart constraint_class; + XmManagerClassPart manager_class; + FontCreatorClassPart creator_class; +} FontCreatorClassRec, *FontCreatorWidgetClass; + +extern FontCreatorClassRec fontCreatorClassRec; + +#endif /* _FontCreatorP_H */ +/* DON'T ADD ANYTHING AFTER THIS #endif */ diff --git a/nx-X11/include/DPS/FontCreato.h b/nx-X11/include/DPS/FontCreato.h new file mode 100644 index 000000000..9d3162141 --- /dev/null +++ b/nx-X11/include/DPS/FontCreato.h @@ -0,0 +1,59 @@ +/* + * FontCreato.h + * + * (c) Copyright 1992-1994 Adobe Systems Incorporated. + * All rights reserved. + * + * Permission to use, copy, modify, distribute, and sublicense this software + * and its documentation for any purpose and without fee is hereby granted, + * provided that the above copyright notices appear in all copies and that + * both those copyright notices and this permission notice appear in + * supporting documentation and that the name of Adobe Systems Incorporated + * not be used in advertising or publicity pertaining to distribution of the + * software without specific, written prior permission. No trademark license + * to use the Adobe trademarks is hereby granted. If the Adobe trademark + * "Display PostScript"(tm) is used to describe this software, its + * functionality or for any other purpose, such use shall be limited to a + * statement that this software works in conjunction with the Display + * PostScript system. Proper trademark attribution to reflect Adobe's + * ownership of the trademark shall be given whenever any such reference to + * the Display PostScript system is made. + * + * ADOBE MAKES NO REPRESENTATIONS ABOUT THE SUITABILITY OF THE SOFTWARE FOR + * ANY PURPOSE. IT IS PROVIDED "AS IS" WITHOUT EXPRESS OR IMPLIED WARRANTY. + * ADOBE DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL + * IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NON- INFRINGEMENT OF THIRD PARTY RIGHTS. IN NO EVENT SHALL ADOBE BE LIABLE + * TO YOU OR ANY OTHER PARTY FOR ANY SPECIAL, INDIRECT, OR CONSEQUENTIAL + * DAMAGES OR ANY DAMAGES WHATSOEVER WHETHER IN AN ACTION OF CONTRACT, + * NEGLIGENCE, STRICT LIABILITY OR ANY OTHER ACTION ARISING OUT OF OR IN + * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. ADOBE WILL NOT + * PROVIDE ANY TRAINING OR OTHER SUPPORT FOR THE SOFTWARE. + * + * Adobe, PostScript, and Display PostScript are trademarks of Adobe Systems + * Incorporated which may be registered in certain jurisdictions + * + * Author: Adobe Systems Incorporated + */ + +#ifndef _FontCreator_h +#define _FontCreator_h + +/* New resouce names and classes */ + +#define XtNsizes "sizes" +#define XtCSizes "Sizes" +#define XtNsizeCount "sizeCount" +#define XtCSizeCount "SizeCount" +#define XtNdismissCallback "dismissCallback" +#define XtNfontSelectionBox "fontSelectionBox" +#define XtCFontSelectionBox "FontSelectionBox" + +/* Class record constants */ + +extern WidgetClass fontCreatorWidgetClass; + +typedef struct _FontCreatorRec *FontCreatorWidget; + +#endif /* _FontCreator_h */ +/* DON'T ADD ANYTHING AFTER THIS #endif */ diff --git a/nx-X11/include/DPS/FontSB.h b/nx-X11/include/DPS/FontSB.h new file mode 100644 index 000000000..d37d126c7 --- /dev/null +++ b/nx-X11/include/DPS/FontSB.h @@ -0,0 +1,287 @@ +/* + * FontSB.h + * + * (c) Copyright 1991-1994 Adobe Systems Incorporated. + * All rights reserved. + * + * Permission to use, copy, modify, distribute, and sublicense this software + * and its documentation for any purpose and without fee is hereby granted, + * provided that the above copyright notices appear in all copies and that + * both those copyright notices and this permission notice appear in + * supporting documentation and that the name of Adobe Systems Incorporated + * not be used in advertising or publicity pertaining to distribution of the + * software without specific, written prior permission. No trademark license + * to use the Adobe trademarks is hereby granted. If the Adobe trademark + * "Display PostScript"(tm) is used to describe this software, its + * functionality or for any other purpose, such use shall be limited to a + * statement that this software works in conjunction with the Display + * PostScript system. Proper trademark attribution to reflect Adobe's + * ownership of the trademark shall be given whenever any such reference to + * the Display PostScript system is made. + * + * ADOBE MAKES NO REPRESENTATIONS ABOUT THE SUITABILITY OF THE SOFTWARE FOR + * ANY PURPOSE. IT IS PROVIDED "AS IS" WITHOUT EXPRESS OR IMPLIED WARRANTY. + * ADOBE DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL + * IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NON- INFRINGEMENT OF THIRD PARTY RIGHTS. IN NO EVENT SHALL ADOBE BE LIABLE + * TO YOU OR ANY OTHER PARTY FOR ANY SPECIAL, INDIRECT, OR CONSEQUENTIAL + * DAMAGES OR ANY DAMAGES WHATSOEVER WHETHER IN AN ACTION OF CONTRACT, + * NEGLIGENCE, STRICT LIABILITY OR ANY OTHER ACTION ARISING OUT OF OR IN + * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. ADOBE WILL NOT + * PROVIDE ANY TRAINING OR OTHER SUPPORT FOR THE SOFTWARE. + * + * Adobe, PostScript, and Display PostScript are trademarks of Adobe Systems + * Incorporated which may be registered in certain jurisdictions + * + * Author: Adobe Systems Incorporated + */ +/* $XFree86$ */ + +#ifndef _FontSelectionBox_h +#define _FontSelectionBox_h + +/* New resouce names and classes */ + +#define XtNcontext "context" +#define XtCContext "Context" +#define XtNpreviewString "previewString" +#define XtCPreviewString "PreviewString" +#define XtNsizes "sizes" +#define XtCSizes "Sizes" +#define XtNsizeCount "sizeCount" +#define XtCSizeCount "SizeCount" +#define XtNdefaultResourcePath "defaultResourcePath" +#define XtCDefaultResourcePath "DefaultResourcePath" +#define XtNresourcePathOverride "resourcePathOverride" +#define XtCResourcePathOverride "ResourcePathOverride" +#define XtNuseFontName "useFontName" +#define XtCUseFontName "UseFontName" +#define XtNfontName "fontName" +#define XtCFontName "FontName" +#define XtNfontFamily "fontFamily" +#define XtCFontFamily "FontFamily" +#define XtNfontFace "fontFace" +#define XtCFontFace "FontFace" +#define XtNfontSize "fontSize" +#define XtCFontSize "FontSize" +#define XtNfontBlend "fontBlend" +#define XtCFontBlend "FontBlend" +#define XtNfontNameMultiple "fontNameMultiple" +#define XtCFontNameMultiple "FontNameMultiple" +#define XtNfontFamilyMultiple "fontFamilyMultiple" +#define XtCFontFamilyMultiple "FontFamilyMultiple" +#define XtNfontFaceMultiple "fontFaceMultiple" +#define XtCFontFaceMultiple "FontFaceMultiple" +#define XtNfontSizeMultiple "fontSizeMultiple" +#define XtCFontSizeMultiple "FontSizeMultiple" +#define XtNgetServerFonts "getServerFonts" +#define XtCGetServerFonts "GetServerFonts" +#define XtNgetAFM "getAFM" +#define XtCGetAFM "GetAFM" +#define XtNautoPreview "autoPreview" +#define XtCAutoPreview "AutoPreview" +#define XtNpreviewOnChange "previewOnChange" +#define XtCPreviewOnChange "PreviewOnChange" +#define XtNundefUnusedFonts "undefUnusedFonts" +#define XtCUndefUnusedFonts "UndefUnusedFonts" +#define XtNmaxPendingDeletes "maxPendingDeletes" +#define XtCMaxPendingDeletes "MaxPendingDeletes" +#define XtNmakeFontsShared "makeFontsShared" +#define XtCMakeFontsShared "MakeFontsShared" +#define XtNshowSampler "showSampler" +#define XtCShowSampler "ShowSampler" +#define XtNshowSamplerButton "showSamplerButton" +#define XtCShowSamplerButton "ShowSamplerButton" +#define XtNtypographicSort "typographicSort" +#define XtCTypographicSort "TypographicSort" +#define XtNokCallback "okCallback" +#define XtNapplyCallback "applyCallback" +#define XtNresetCallback "resetCallback" +#ifndef XtNcancelCallback +#define XtNcancelCallback "cancelCallback" +#endif +#define XtNvalidateCallback "validateCallback" +#define XtNfaceSelectCallback "faceSelectCallback" +#define XtNvalueChangedCallback "valueChangedCallback" +#define XtNcreateSamplerCallback "createSamplerCallback" +#define XtNcreateCreatorCallback "createCreatorCallback" + +/* Read-only resources for all the subwidgets */ + +#define XtNpaneChild "paneChild" +#define XtNpreviewChild "previewChild" +#define XtNpanelChild "panelChild" +#define XtNfamilyLabelChild "familyLabelChild" +#define XtNfamilyMultipleLabelChild "familyMultipleLabelChild" +#define XtNfamilyScrolledListChild "familyScrolledListChild" +#define XtNfaceLabelChild "faceLabelChild" +#define XtNfaceMultipleLabelChild "faceMultipleLabelChild" +#define XtNfaceScrolledListChild "faceScrolledListChild" +#define XtNsizeLabelChild "sizeLabelChild" +#define XtNsizeTextFieldChild "sizeTextFieldChild" +#define XtNsizeOptionMenuChild "sizeOptionMenuChild" +#define XtNsizeMultipleLabelChild "sizeMultipleLabelChild" +#define XtNsamplerButtonChild "samplerButtonChild" +#define XtNpreviewButtonChild "previewButtonChild" +#define XtNseparatorChild "separatorChild" +#define XtNokButtonChild "okButtonChild" +#define XtNapplyButtonChild "applyButtonChild" +#define XtNresetButtonChild "resetButtonChild" +#define XtNcancelButtonChild "cancelButtonChild" +#define XtNmultipleMasterButtonChild "multipleMasterButtonChild" + +/* New resource types */ + +#define XtRFloatList "FloatList" +#define XtRDPSContext "DPSContext" + +/* Class record constants */ + +extern WidgetClass fontSelectionBoxWidgetClass; + +typedef struct _FontSelectionBoxRec *FontSelectionBoxWidget; + +typedef enum {FSBNone, FSBOne, FSBMultiple} FSBSelectionType; +typedef enum {FSBOK, FSBApply, FSBReset, FSBCancel, + FSBValueChanged} FSBCallbackReason; + +typedef struct { + FSBCallbackReason reason; + String family; + String face; + float size; + String name; + String afm_filename; + FSBSelectionType family_selection; + FSBSelectionType face_selection; + FSBSelectionType size_selection; + FSBSelectionType name_selection; + Boolean afm_present; + Boolean unused; + String blend; + String base_name; + float axis_percent[4]; +} FSBCallbackRec; + +typedef struct { + FSBCallbackReason reason; + String family; + String face; + float size; + String name; + String afm_filename; + FSBSelectionType family_selection; + FSBSelectionType face_selection; + FSBSelectionType size_selection; + FSBSelectionType name_selection; + Boolean afm_present; + Boolean doit; + String blend; + String base_name; + float axis_percent[4]; +} FSBValidateCallbackRec; + +typedef struct { + String *available_faces; + int num_available_faces; + String current_face; + String new_face; +} FSBFaceSelectCallbackRec; + +typedef struct { + Widget sampler; + Widget sampler_shell; +} FSBCreateSamplerCallbackRec; + +typedef struct { + Widget creator; + Widget creator_shell; +} FSBCreateCreatorCallbackRec; + +typedef enum {FSBAddBlend, FSBReplaceBlend, FSBDeleteBlend} FSBBlendAction; + +/* Convenience and info routines */ + +#if defined(__cplusplus) || defined(c_plusplus) +extern "C" { +#endif + +/* Note use of Bool and double in prototypes: this makes the library + work correctly when linked with no-prototype compiled objects */ + +extern void FSBSetFontName(Widget w, + String font_name, + Bool font_name_multiple); + +extern void FSBSetFontFamilyFace(Widget w, + String font_family, String font_face, + Bool font_family_multiple, + Bool font_face_multiple); + +extern void FSBSetFontSize(Widget w, double font_size, + Bool font_size_multiple); + +extern void FSBRefreshFontList(Widget w); + +extern void FSBGetFamilyList(Widget w, int *count_return, + String **family_return); + +extern void FSBGetFaceList(Widget w, String family, int *count_return, + String **face_return, String **font_return); + +extern void FSBUndefineUnusedFonts(Widget w); + +extern Boolean FSBDownloadFontName(Widget w, String font_name); + +extern Boolean FSBMatchFontFace(Widget w, String old_face, String new_family, + String *new_face); + +extern void FSBFontNameToFamilyFace(Widget w, String font_name, + String *family, String *face); + +extern void FSBFontFamilyFaceToName(Widget w, String family, String face, + String *font_name); + +extern String FSBFindAFM(Widget w, String font_name); + +extern String FSBFindFontFile(Widget w, String font_name); + +extern void FSBGetTextDimensions(Widget w, String text, String font, + double size, double x, double y, + float *dx, float *dy, + float *left, float *right, + float *top, float *bottom); + +extern void FSBSetFontFamilyFaceBlend(Widget w, String family, String face, + String blend, Bool family_multiple, + Bool face_multiple); + +extern void FSBFontNameToFamilyFaceBlend(Widget w, String font_name, + String *family, String *face, + String *blend); + +extern void FSBFontFamilyFaceBlendToName(Widget w, String family, String face, + String blend, String *font_name); + +extern void FSBGetBlendList(Widget w, String font_name, int *count_return, + String **blend_return, String **font_name_return, + float **axis_values_return); + +extern void FSBGetBlendInfo(Widget w, String name, int *num_axes_return, + int *num_designs_return, + String **axis_names_return, + float **blend_positions_return, + int **blend_map_count_return, + int **blend_design_coords_return, + float **blend_normalized_coords_return); + +extern Boolean FSBChangeBlends(Widget w, String base_name, String blend_name, + FSBBlendAction action, int *axis_values, + float *axis_percents); + +#if defined(__cplusplus) || defined(c_plusplus) +} +#endif + +#endif /* _FontSelectionBox_h */ +/* DON'T ADD ANYTHING AFTER THIS #endif */ diff --git a/nx-X11/include/DPS/FontSBP.h b/nx-X11/include/DPS/FontSBP.h new file mode 100644 index 000000000..99a867f52 --- /dev/null +++ b/nx-X11/include/DPS/FontSBP.h @@ -0,0 +1,335 @@ +/* + * FontSBP.h + * + * (c) Copyright 1991-1994 Adobe Systems Incorporated. + * All rights reserved. + * + * Permission to use, copy, modify, distribute, and sublicense this software + * and its documentation for any purpose and without fee is hereby granted, + * provided that the above copyright notices appear in all copies and that + * both those copyright notices and this permission notice appear in + * supporting documentation and that the name of Adobe Systems Incorporated + * not be used in advertising or publicity pertaining to distribution of the + * software without specific, written prior permission. No trademark license + * to use the Adobe trademarks is hereby granted. If the Adobe trademark + * "Display PostScript"(tm) is used to describe this software, its + * functionality or for any other purpose, such use shall be limited to a + * statement that this software works in conjunction with the Display + * PostScript system. Proper trademark attribution to reflect Adobe's + * ownership of the trademark shall be given whenever any such reference to + * the Display PostScript system is made. + * + * ADOBE MAKES NO REPRESENTATIONS ABOUT THE SUITABILITY OF THE SOFTWARE FOR + * ANY PURPOSE. IT IS PROVIDED "AS IS" WITHOUT EXPRESS OR IMPLIED WARRANTY. + * ADOBE DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL + * IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NON- INFRINGEMENT OF THIRD PARTY RIGHTS. IN NO EVENT SHALL ADOBE BE LIABLE + * TO YOU OR ANY OTHER PARTY FOR ANY SPECIAL, INDIRECT, OR CONSEQUENTIAL + * DAMAGES OR ANY DAMAGES WHATSOEVER WHETHER IN AN ACTION OF CONTRACT, + * NEGLIGENCE, STRICT LIABILITY OR ANY OTHER ACTION ARISING OUT OF OR IN + * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. ADOBE WILL NOT + * PROVIDE ANY TRAINING OR OTHER SUPPORT FOR THE SOFTWARE. + * + * Adobe, PostScript, and Display PostScript are trademarks of Adobe Systems + * Incorporated which may be registered in certain jurisdictions + * + * Author: Adobe Systems Incorporated + */ +/* $XFree86$ */ + +#ifndef _FontSelectionBoxP_H +#define _FontSelectionBoxP_H + +#include <DPS/FontSB.h> + +/* Typedefs used in private fields */ + +#define MAX_AXES 4 +#define MAX_BLENDS 16 /* = 2**MAX_AXES */ + +typedef struct _BlendRec { + char *blend_name; + char *font_name; + XmString CS_blend_name; + XmString CS_space_blend_name; + float data[MAX_AXES]; + struct _BlendRec *next; +} BlendRec; + +typedef struct { + int num_axes, num_designs; + int min[MAX_AXES], max[MAX_AXES]; + String name[MAX_AXES]; + int internal_points[MAX_AXES]; + int *internal_break[MAX_AXES]; + float *internal_value[MAX_AXES]; + float *design_positions; + BlendRec *blends; +} BlendDataRec; + +typedef struct _FontRec { + char *font_name; + char *face_name; + XmString CS_face_name; + char *full_name; + Boolean resident; + Boolean temp_resident; + struct _FontRec *pending_delete_next; + struct _FontRec *next; + int blend_count; + Boolean in_font_creator; + BlendDataRec *blend_data; +} FontRec; + +typedef struct _FontFamilyRec { + char *family_name; + char *sort_key; + FontRec *fonts; + int font_count; + struct _FontFamilyRec *next; + int blend_count; +} FontFamilyRec; + +typedef struct { + DPSContext context; + String preview_string; + float *sizes; + int size_count; + String default_resource_path; + String resource_path_override; + String font_name; + String font_family; + String font_face; + float font_size; + Boolean use_font_name; + Boolean font_name_multiple; + Boolean font_family_multiple; + Boolean font_face_multiple; + Boolean font_size_multiple; + Boolean get_server_fonts; + Boolean get_afm; + Boolean auto_preview; + Boolean preview_on_change; + Boolean undef_unused_fonts; + Boolean make_fonts_shared; + Boolean show_sampler; + Boolean show_sampler_button; + Cardinal max_pending_deletes; + XtCallbackList ok_callback; + XtCallbackList apply_callback; + XtCallbackList reset_callback; + XtCallbackList cancel_callback; + XtCallbackList validate_callback; + XtCallbackList face_select_callback; + XtCallbackList create_sampler_callback; + Widget pane_child; + Widget preview_child; + Widget panel_child; + Widget family_label_child; + Widget family_multiple_label_child; + Widget family_scrolled_list_child; + Widget face_label_child; + Widget face_multiple_label_child; + Widget face_scrolled_list_child; + Widget size_label_child; + Widget size_text_field_child; + Widget size_option_menu_child; + Widget size_multiple_label_child; + Widget sampler_button_child; + Widget preview_button_child; + Widget separator_child; + Widget ok_button_child; + Widget apply_button_child; + Widget reset_button_child; + Widget cancel_button_child; + + /* Private fields */ + + DPSGState gstate; + Widget other_size; + Widget size_menu; + Widget sampler; + FontFamilyRec *known_families; + int family_count; + Boolean preview_fixed; + Boolean current_family_multiple, current_face_multiple; + Boolean current_size_multiple; + FontRec *pending_delete_font; + int pending_delete_count; + FontRec *currently_previewed; + FontRec *currently_selected_face; + FontFamilyRec *currently_selected_family; + float currently_previewed_size; + float currently_selected_size; + + /* New resource fields */ + + String font_blend; + Boolean typographic_sort; + XtCallbackList create_creator_callback; + XtCallbackList value_changed_callback; + Widget multiple_master_button_child; + + /* New private fields */ + + Widget creator, creator_shell; + BlendRec *currently_previewed_blend; + BlendRec *currently_selected_blend; + Boolean blends_changed; + Boolean old_server; +} FontSelectionBoxPart; + +typedef struct _FontSelectionBoxRec { + CorePart core; + CompositePart composite; + ConstraintPart constraint; + XmManagerPart manager; + FontSelectionBoxPart fsb; +} FontSelectionBoxRec; + +#if defined(__cplusplus) || defined(c_plusplus) +extern "C" { +#endif + +/* Note use of Bool and double in prototypes: this makes the library + work correctly when linked with no-prototype compiled objects */ + +typedef void (*FSBSetFontNameProc) (Widget w, + String font_name, + Bool font_name_multiple); + +typedef void (*FSBSetFontFamilyFaceProc) (Widget w, + String font_family, + String font_face, + Bool font_family_multiple, + Bool font_face_multiple); + +typedef void (*FSBSetFontSizeProc) (Widget w, + double font_size, + Bool font_size_multiple); + +typedef void (*FSBRefreshFontListProc) (Widget w); + +typedef void (*FSBGetFamilyListProc) (Widget w, int *count_return, + String **family_return); + +typedef void (*FSBGetFaceListProc) (Widget w, String family, int *count_return, + String **face_return, + String **font_return); + +typedef void (*FSBUndefUnusedFontsProc) (Widget w); + +typedef Boolean (*FSBDownloadFontNameProc) (Widget w, String font_name); + +typedef Boolean (*FSBMatchFontFaceProc) (Widget w, String old_face, + String new_family, String *new_face); + +typedef void (*FSBFontNameToFamilyFaceProc) (Widget w, String font_name, + String *family, String *face); + +typedef void (*FSBFontFamilyFaceToNameProc) (Widget w, String family, + String face, String *font_name); + +typedef String (*FSBFindAFMProc) (Widget w, String font_name); + +typedef String (*FSBFindFontFileProc) (Widget w, String font_name); + +typedef void (*FSBGetTextDimensionsProc) (Widget w, String text, String font, + double size, double x, double y, + float *dx, float *dy, + float *left, float *right, + float *top, float *bottom); + +typedef void (*FSBSetFontFamilyFaceBlendProc) (Widget w, + String font_family, + String font_face, + String font_blend, + Bool font_family_multiple, + Bool font_face_multiple); +typedef void (*FSBFontNameToFamilyFaceBlendProc) (Widget w, String font_name, + String *family, String *face, + String *blend); +typedef void (*FSBFontFamilyFaceBlendToNameProc) (Widget w, String family, + String face, String blend, + String *font_name); +typedef void (*FSBGetBlendListProc) (Widget w, String name, + int *count_return, String **blend_return, + String **font_name_return, + float **axis_values_return); +typedef void (*FSBGetBlendInfoProc) (Widget w, String name, + int *num_axes_return, + int *num_designs_return, + String **axis_names_return, + float **blend_positions_return, + int **blend_map_count_return, + int **blend_design_coords_return, + float **blend_normalized_coords_return); +typedef Boolean (*FSBChangeBlendsProc) (Widget w, String base_name, + String blend_name, + FSBBlendAction action, + int *axis_values, + float *axis_percents); +#if defined(__cplusplus) || defined(c_plusplus) +} +#endif + +#define InheritSetFontName ((FSBSetFontNameProc) _XtInherit) +#define InheritSetFontFamilyFace ((FSBSetFontFamilyFaceProc) _XtInherit) +#define InheritSetFontSize ((FSBSetFontSizeProc) _XtInherit) +#define InheritRefreshFontList ((FSBRefreshFontListProc) _XtInherit) +#define InheritGetFamilyList ((FSBGetFamilyListProc) _XtInherit) +#define InheritGetFaceList ((FSBGetFaceListProc) _XtInherit) +#define InheritUndefUnusedFonts ((FSBUndefUnusedFontsProc) _XtInherit) +#define InheritDownloadFontName ((FSBDownloadFontNameProc) _XtInherit) +#define InheritMatchFontFace ((FSBMatchFontFaceProc) _XtInherit) +#define InheritFontNameToFamilyFace ((FSBFontNameToFamilyFaceProc) _XtInherit) +#define InheritFontFamilyFaceToName ((FSBFontFamilyFaceToNameProc) _XtInherit) +#define InheritFindAFM ((FSBFindAFMProc) _XtInherit) +#define InheritFindFontFile ((FSBFindFontFileProc) _XtInherit) +#define InheritGetTextDimensions ((FSBGetTextDimensionsProc) _XtInherit) +#define InheritSetFontFamilyFaceBlend \ + ((FSBSetFontFamilyFaceBlendProc) _XtInherit) +#define InheritFontNameToFamilyFaceBlend \ + ((FSBFontNameToFamilyFaceBlendProc) _XtInherit) +#define InheritFontFamilyFaceBlendToName \ + ((FSBFontFamilyFaceBlendToNameProc) _XtInherit) +#define InheritGetBlendList ((FSBGetBlendListProc) _XtInherit) +#define InheritGetBlendInfo ((FSBGetBlendInfoProc) _XtInherit) +#define InheritChangeBlends ((FSBChangeBlendsProc) _XtInherit) + +typedef struct { + FSBSetFontNameProc set_font_name; + FSBSetFontFamilyFaceProc set_font_family_face; + FSBSetFontSizeProc set_font_size; + FSBRefreshFontListProc refresh_font_list; + FSBGetFamilyListProc get_family_list; + FSBGetFaceListProc get_face_list; + FSBUndefUnusedFontsProc undef_unused_fonts; + FSBDownloadFontNameProc download_font_name; + FSBMatchFontFaceProc match_font_face; + FSBFontNameToFamilyFaceProc font_name_to_family_face; + FSBFontFamilyFaceToNameProc font_family_face_to_name; + FSBFindAFMProc find_afm; + FSBFindFontFileProc find_font_file; + FSBGetTextDimensionsProc get_text_dimensions; + FSBSetFontFamilyFaceBlendProc set_font_family_face_blend; + FSBFontNameToFamilyFaceBlendProc font_name_to_family_face_blend; + FSBFontFamilyFaceBlendToNameProc font_family_face_blend_to_name; + FSBGetBlendListProc get_blend_list; + FSBGetBlendInfoProc get_blend_info; + FSBChangeBlendsProc change_blends; + XtPointer extension; +} FontSelectionBoxClassPart; + +typedef struct _FontSelectionBoxClassRec { + CoreClassPart core_class; + CompositeClassPart composite_class; + ConstraintClassPart constraint_class; + XmManagerClassPart manager_class; + FontSelectionBoxClassPart fsb_class; +} FontSelectionBoxClassRec, *FontSelectionBoxWidgetClass; + +extern FontSelectionBoxClassRec fontSelectionBoxClassRec; + +#endif /* _FontSelectionBoxP_H */ +/* DON'T ADD ANYTHING AFTER THIS #endif */ diff --git a/nx-X11/include/DPS/FontSamplP.h b/nx-X11/include/DPS/FontSamplP.h new file mode 100644 index 000000000..045b83ed6 --- /dev/null +++ b/nx-X11/include/DPS/FontSamplP.h @@ -0,0 +1,168 @@ +/* + * FontSamplP.h + * + * (c) Copyright 1991-1994 Adobe Systems Incorporated. + * All rights reserved. + * + * Permission to use, copy, modify, distribute, and sublicense this software + * and its documentation for any purpose and without fee is hereby granted, + * provided that the above copyright notices appear in all copies and that + * both those copyright notices and this permission notice appear in + * supporting documentation and that the name of Adobe Systems Incorporated + * not be used in advertising or publicity pertaining to distribution of the + * software without specific, written prior permission. No trademark license + * to use the Adobe trademarks is hereby granted. If the Adobe trademark + * "Display PostScript"(tm) is used to describe this software, its + * functionality or for any other purpose, such use shall be limited to a + * statement that this software works in conjunction with the Display + * PostScript system. Proper trademark attribution to reflect Adobe's + * ownership of the trademark shall be given whenever any such reference to + * the Display PostScript system is made. + * + * ADOBE MAKES NO REPRESENTATIONS ABOUT THE SUITABILITY OF THE SOFTWARE FOR + * ANY PURPOSE. IT IS PROVIDED "AS IS" WITHOUT EXPRESS OR IMPLIED WARRANTY. + * ADOBE DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL + * IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NON- INFRINGEMENT OF THIRD PARTY RIGHTS. IN NO EVENT SHALL ADOBE BE LIABLE + * TO YOU OR ANY OTHER PARTY FOR ANY SPECIAL, INDIRECT, OR CONSEQUENTIAL + * DAMAGES OR ANY DAMAGES WHATSOEVER WHETHER IN AN ACTION OF CONTRACT, + * NEGLIGENCE, STRICT LIABILITY OR ANY OTHER ACTION ARISING OUT OF OR IN + * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. ADOBE WILL NOT + * PROVIDE ANY TRAINING OR OTHER SUPPORT FOR THE SOFTWARE. + * + * Adobe, PostScript, and Display PostScript are trademarks of Adobe Systems + * Incorporated which may be registered in certain jurisdictions + * + * Author: Adobe Systems Incorporated + */ +/* $XFree86$ */ + +#ifndef _FontSamplerP_H +#define _FontSamplerP_H + +#include <DPS/FontSample.h> +#include <DPS/FontSB.h> + +typedef struct _DisplayedTextRec { + String str; + float size; + struct _DisplayedTextRec *next; +} DisplayedTextRec; + +typedef struct _DisplayedFontRec { + Position l, r, t, b; + Position x, y; + FontRec *font; + BlendRec *blend; + DisplayedTextRec *text; + struct _DisplayedFontRec *next; +} DisplayedFontRec; + +typedef struct { + FontSamplerWidget sampler; + Boolean inited, any_shown; + Dimension column_width; + Position x, y; + Dimension height, width; + Dimension window_height; + int depth; + FontFamilyRec *current_family; + FontRec *current_font; + BlendRec *current_blend; + DisplayedTextRec *text_list; + DisplayedFontRec *shown_fonts; +} DisplayRecord; + +typedef struct { + float *sizes; + int size_count; + FontSelectionBoxWidget fsb; + XtCallbackList dismiss_callback; + Dimension minimum_width; + Dimension minimum_height; + XmString no_room_message; + XmString no_font_message; + XmString no_selected_font_message; + XmString no_selected_family_message; + XmString no_family_font_message; + XmString no_match_message; + Widget panel_child; + Widget area_child; + Widget text_child; + Widget font_label_child; + Widget scrolled_window_child; + Widget display_button_child; + Widget dismiss_button_child; + Widget stop_button_child; + Widget clear_button_child; + Widget radio_frame_child; + Widget radio_box_child; + Widget all_toggle_child; + Widget selected_toggle_child; + Widget selected_family_toggle_child; + Widget filter_toggle_child; + Widget filter_text_child; + Widget filter_box_child; + Widget filter_frame_child; + Widget size_option_menu_child; + Widget size_text_field_child; + Widget size_label_child; + + /* Private fields */ + + Widget size_menu; + Widget other_size; + Widget *filter_widgets; + Widget clip_widget; + Boolean displaying; + Pixmap pixmap; + XtWorkProcId current_display_proc; + DisplayRecord *current_display_info; + DisplayedFontRec *highlighted_font; + DPSGState gstate; + DPSGState pixmap_gstate; + GC gc; + char *filter_text; + Boolean *filter_flags; + Boolean filters_changed; + float ctm[6]; + float invctm[6]; +} FontSamplerPart; + +typedef struct _FontSamplerRec { + CorePart core; + CompositePart composite; + ConstraintPart constraint; + XmManagerPart manager; + FontSamplerPart sampler; +} FontSamplerRec; + +#if defined(__cplusplus) || defined(c_plusplus) +extern "C" { +#endif + +typedef void (*FSBCancelProc) (Widget w); + +#if defined(__cplusplus) || defined(c_plusplus) +} +#endif + +#define InheritCancel ((FSBCancelProc) _XtInherit) + +typedef struct { + FSBCancelProc cancel; + XtPointer extension; +} FontSamplerClassPart; + +typedef struct _FontSamplerClassRec { + CoreClassPart core_class; + CompositeClassPart composite_class; + ConstraintClassPart constraint_class; + XmManagerClassPart manager_class; + FontSamplerClassPart sampler_class; +} FontSamplerClassRec, *FontSamplerWidgetClass; + +extern FontSamplerClassRec fontSamplerClassRec; + +#endif /* _FontSamplerP_H */ +/* DON'T ADD ANYTHING AFTER THIS #endif */ diff --git a/nx-X11/include/DPS/FontSample.h b/nx-X11/include/DPS/FontSample.h new file mode 100644 index 000000000..6197217b5 --- /dev/null +++ b/nx-X11/include/DPS/FontSample.h @@ -0,0 +1,97 @@ +/* + * FontSample.h + * + * (c) Copyright 1991-1994 Adobe Systems Incorporated. + * All rights reserved. + * + * Permission to use, copy, modify, distribute, and sublicense this software + * and its documentation for any purpose and without fee is hereby granted, + * provided that the above copyright notices appear in all copies and that + * both those copyright notices and this permission notice appear in + * supporting documentation and that the name of Adobe Systems Incorporated + * not be used in advertising or publicity pertaining to distribution of the + * software without specific, written prior permission. No trademark license + * to use the Adobe trademarks is hereby granted. If the Adobe trademark + * "Display PostScript"(tm) is used to describe this software, its + * functionality or for any other purpose, such use shall be limited to a + * statement that this software works in conjunction with the Display + * PostScript system. Proper trademark attribution to reflect Adobe's + * ownership of the trademark shall be given whenever any such reference to + * the Display PostScript system is made. + * + * ADOBE MAKES NO REPRESENTATIONS ABOUT THE SUITABILITY OF THE SOFTWARE FOR + * ANY PURPOSE. IT IS PROVIDED "AS IS" WITHOUT EXPRESS OR IMPLIED WARRANTY. + * ADOBE DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL + * IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NON- INFRINGEMENT OF THIRD PARTY RIGHTS. IN NO EVENT SHALL ADOBE BE LIABLE + * TO YOU OR ANY OTHER PARTY FOR ANY SPECIAL, INDIRECT, OR CONSEQUENTIAL + * DAMAGES OR ANY DAMAGES WHATSOEVER WHETHER IN AN ACTION OF CONTRACT, + * NEGLIGENCE, STRICT LIABILITY OR ANY OTHER ACTION ARISING OUT OF OR IN + * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. ADOBE WILL NOT + * PROVIDE ANY TRAINING OR OTHER SUPPORT FOR THE SOFTWARE. + * + * Adobe, PostScript, and Display PostScript are trademarks of Adobe Systems + * Incorporated which may be registered in certain jurisdictions + * + * Author: Adobe Systems Incorporated + */ +/* $XFree86$ */ + +#ifndef _FontSampler_h +#define _FontSampler_h + +/* New resouce names and classes */ + +#define XtNdismissCallback "dismissCallback" +#define XtNsizes "sizes" +#define XtCSizes "Sizes" +#define XtNsizeCount "sizeCount" +#define XtCSizeCount "SizeCount" +#define XtNfontSelectionBox "fontSelectionBox" +#define XtCFontSelectionBox "FontSelectionBox" +#define XtNminimumWidth "minimumWidth" +#define XtCMinimumWidth "MinimumWidth" +#define XtNminimumHeight "minimumHeight" +#define XtCMinimumHeight "MinimumHeight" +#define XtNnoRoomMessage "noRoomMessage" +#define XtNnoFontMessage "noFontMessage" +#define XtNnoSelectedFontMessage "noSelectedFontMessage" +#define XtNnoSelectedFamilyMessage "noSelectedFamilyMessage" +#define XtNnoFamilyFontMessage "noFamilyFontMessage" +#define XtNnoMatchMessage "noMatchMessage" +#define XtCMessage "Message" + +/* Read-only resources for all the subwidgets */ + +#define XtNpanelChild "panelChild" +#define XtNareaChild "areaChild" +#define XtNtextChild "textChild" +#define XtNfontLabelChild "fontLabelChild" +#define XtNscrolledWindowChild "scrolledWindowChild" +#define XtNdisplayButtonChild "displayButtonChild" +#define XtNdismissButtonChild "dismissButtonChild" +#define XtNstopButtonChild "stopButtonChild" +#define XtNclearButtonChild "clearButtonChild" +#define XtNradioFrameChild "radioFrameChild" +#define XtNradioBoxChild "radioBoxChild" +#define XtNallToggleChild "allToggleChild" +#define XtNselectedToggleChild "selectedToggleChild" +#define XtNselectedFamilyToggleChild "selectedFamilyToggleChild" +#define XtNfilterToggleChild "filterToggleChild" +#define XtNfilterTextChild "filterTextChild" +#define XtNfilterBoxChild "filterBoxChild" +#define XtNfilterFrameChild "filterFrameChild" +#define XtNsizeOptionMenuChild "sizeOptionMenuChild" +#define XtNsizeTextFieldChild "sizeTextFieldChild" +#define XtNsizeLabelChild "sizeLabelChild" + +/* Class record constants */ + +extern WidgetClass fontSamplerWidgetClass; + +typedef struct _FontSamplerRec *FontSamplerWidget; + +extern void FSBCancelSampler(Widget w); + +#endif /* _FontSampler_h */ +/* DON'T ADD ANYTHING AFTER THIS #endif */ diff --git a/nx-X11/include/DPS/Imakefile b/nx-X11/include/DPS/Imakefile new file mode 100644 index 000000000..197f16ae3 --- /dev/null +++ b/nx-X11/include/DPS/Imakefile @@ -0,0 +1,32 @@ +XCOMM $XFree86: xc/include/DPS/Imakefile,v 1.3 2000/02/19 14:23:06 tsi Exp $ + +HEADERS = \ + XDPS.h\ + XDPSproto.h\ + dpsclient.h\ + dpsexcept.h\ + XDPSlib.h\ + dpsXclient.h\ + dpsconfig.h\ + dpsfriends.h\ + dpsNXargs.h\ + dpsXshare.h\ + dpsXuserpath.h\ + dpsXpreview.h\ + dpsXcommon.h\ + FontSB.h\ + FontSBP.h\ + FontSample.h\ + FontSamplP.h\ + FontCreato.h\ + FontCreatP.h\ + ColorSB.h\ + ColorSBP.h\ + DPSScrollW.h\ + DPSScrollWP.h\ + PSres.h + +BuildIncludes($(HEADERS),DPS,..) + +InstallMultipleFlags($(HEADERS),$(INCDIR)/DPS,$(INSTINCFLAGS)) + diff --git a/nx-X11/include/DPS/PSres.h b/nx-X11/include/DPS/PSres.h new file mode 100644 index 000000000..b6b4c4184 --- /dev/null +++ b/nx-X11/include/DPS/PSres.h @@ -0,0 +1,107 @@ +/* + * PSres.h + * + * (c) Copyright 1991-1994 Adobe Systems Incorporated. + * All rights reserved. + * + * Permission to use, copy, modify, distribute, and sublicense this software + * and its documentation for any purpose and without fee is hereby granted, + * provided that the above copyright notices appear in all copies and that + * both those copyright notices and this permission notice appear in + * supporting documentation and that the name of Adobe Systems Incorporated + * not be used in advertising or publicity pertaining to distribution of the + * software without specific, written prior permission. No trademark license + * to use the Adobe trademarks is hereby granted. If the Adobe trademark + * "Display PostScript"(tm) is used to describe this software, its + * functionality or for any other purpose, such use shall be limited to a + * statement that this software works in conjunction with the Display + * PostScript system. Proper trademark attribution to reflect Adobe's + * ownership of the trademark shall be given whenever any such reference to + * the Display PostScript system is made. + * + * ADOBE MAKES NO REPRESENTATIONS ABOUT THE SUITABILITY OF THE SOFTWARE FOR + * ANY PURPOSE. IT IS PROVIDED "AS IS" WITHOUT EXPRESS OR IMPLIED WARRANTY. + * ADOBE DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL + * IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NON- INFRINGEMENT OF THIRD PARTY RIGHTS. IN NO EVENT SHALL ADOBE BE LIABLE + * TO YOU OR ANY OTHER PARTY FOR ANY SPECIAL, INDIRECT, OR CONSEQUENTIAL + * DAMAGES OR ANY DAMAGES WHATSOEVER WHETHER IN AN ACTION OF CONTRACT, + * NEGLIGENCE, STRICT LIABILITY OR ANY OTHER ACTION ARISING OUT OF OR IN + * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. ADOBE WILL NOT + * PROVIDE ANY TRAINING OR OTHER SUPPORT FOR THE SOFTWARE. + * + * Adobe, PostScript, and Display PostScript are trademarks of Adobe Systems + * Incorporated which may be registered in certain jurisdictions + * + * Author: Adobe Systems Incorporated + */ +/* $XFree86$ */ + +#ifndef _PSres_h +#define _PSres_h + +extern char *PSResFontOutline, *PSResFontPrebuilt, *PSResFontAFM, + *PSResFontBDF, *PSResFontFamily, *PSResFontBDFSizes, + *PSResForm, *PSResPattern, *PSResEncoding, *PSResProcSet; + +typedef enum {PSSaveReturnValues, PSSaveByType, PSSaveEverything} + PSResourceSavePolicy; + +#if defined(__cplusplus) || defined(c_plusplus) +extern "C" { +#endif + +extern int ListPSResourceFiles(char *psResourcePathOverride, + char *defaultPath, + char *resourceType, + char *resourceName, + char ***resourceNamesReturn, + char ***resourceFilesReturn); + +extern int ListPSResourceTypes(char *psResourcePathOverride, + char *defaultPath, + char ***resourceTypeReturn); + +extern void FreePSResourceStorage(int everything); + +extern void SetPSResourcePolicy(PSResourceSavePolicy policy, + int willList, + char **resourceTypes); + +typedef int (*PSResourceEnumerator)(char *resourceType, + char *resourceName, + char *resourceFile, + char *privateData); + +extern void EnumeratePSResourceFiles(char *psResourcePathOverride, + char *defaultPath, + char *resourceType, + char *resourceName, + PSResourceEnumerator enumerator, + char *privateData); + +extern int CheckPSResourceTime(char *psResourcePathOverride, + char *defaultPath); + +typedef char *(*PSResMallocProc)(int size); + +typedef char *(*PSResReallocProc)(char *ptr, + int size); + +typedef void (*PSResFreeProc)(char *ptr); + +typedef void (*PSResFileWarningHandlerProc)(char *fileNamem, char *extraInfo); + +#if defined(__cplusplus) || defined(c_plusplus) +} +#endif + +extern PSResMallocProc PSResMalloc; + +extern PSResReallocProc PSResRealloc; + +extern PSResFreeProc PSResFree; + +extern PSResFileWarningHandlerProc PSResFileWarningHandler; + +#endif /* _PSres_h */ diff --git a/nx-X11/include/DPS/XDPS.h b/nx-X11/include/DPS/XDPS.h new file mode 100644 index 000000000..4071c931f --- /dev/null +++ b/nx-X11/include/DPS/XDPS.h @@ -0,0 +1,119 @@ +/* + XDPS.h -- DPS extension constants, analogous to X.h + +Copyright 1988-1994 Adobe Systems Incorporated. +Portions Copyright 1988, 1989 Digital Equipment Corporation. + +Permission to use, copy, modify, and distribute this software and +its documentation for any purpose and without fee is hereby granted, +provided that the above copyright notices appear in all copies and +that both those copyright notices and this permission notice appear +in supporting documentation, and that the names of Adobe Systems +Incorporated and Digital Equipment Corporation not be used in +advertising or publicity pertaining to distribution of the software +without specific, written prior permission. Adobe Systems Incorporated +and Digital Equipment Corporation make no representations about the +suitability of this software for any purpose. It is provided "as is" +without express or implied warranty. + +ADOBE SYSTEMS INCORPORATED AND DIGITAL EQUIPMENT CORPORATION DISCLAIM +ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL ADOBE +SYSTEMS INCORPORATED AND DIGITAL EQUIPMENT CORPORATION BE LIABLE FOR +ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN +ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT +OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + +Author: Adobe Systems Incorporated and Digital Equipment Corporation + +*/ + + +#ifndef _XDPS_h +#define _XDPS_h + +#include <X11/Xmd.h> + +/* + * Number of events and errors required by extension + */ +#define NPSEVENTS 3 /* L2-DPS/PROTO 9 change */ +#define NPSERRORS 3 /* L2-DPS/PROTO 9 change */ + +#define NPSEVENTS_P8 2 +#define NPSERRORS_P8 2 + + +/* + * For XPSNotifyContext: types of notification. + */ + +#define PSKILL 0 +#define PSINTERRUPT 1 +#define PSUNFREEZE 2 + + +/* + * For XPSGetStatus: types of status. + */ + +#define PSSTATUSERROR 0 +#define PSRUNNING 1 +#define PSNEEDSINPUT 2 +#define PSZOMBIE 3 +#define PSFROZEN 4 + +#define PSNUMSTATUS 4 /* Number of real status codes */ + +/* + * For XPSSetStatusMask: Status Masks + */ + +#define PSRUNNINGMASK 0x0001 +#define PSNEEDSINPUTMASK 0x0002 +#define PSZOMBIEMASK 0x0004 +#define PSFROZENMASK 0x0008 + + +/* + * Error codes (offset from extension error base) + */ + +#define PSERRORBADCONTEXT 0 +#define PSERRORBADSPACE 1 +#define PSERRORABORT 2 /* L2-DPS/PROTO 9 addition */ + + +/* + * Event codes (offset from extension event base) + */ + +#define PSEVENTOUTPUT 0 +#define PSEVENTSTATUS 1 +#define PSEVENTREADY 2 /* L2-DPS/PROTO 9 addition */ + + +/* + * Request field types + */ + +typedef int ContextPSID; +typedef XID ContextXID; +typedef XID SpaceXID; + + +/* + * Floating point types (the same as in dpsfriends.h). + */ + +#ifndef DPS_HI_IEEE + +#define DPS_HI_IEEE 128 +#define DPS_LO_IEEE 129 +#define DPS_HI_NATIVE 130 +#define DPS_LO_NATIVE 131 + +#endif /* not DPS_HI_IEEE */ + +#endif /* _XDPS_h */ diff --git a/nx-X11/include/DPS/XDPSlib.h b/nx-X11/include/DPS/XDPSlib.h new file mode 100644 index 000000000..e9bd563af --- /dev/null +++ b/nx-X11/include/DPS/XDPSlib.h @@ -0,0 +1,304 @@ +/* + * XDPSlib.h - client header file for DPS library. This file describes the + * Xlib interface to the Display Postscript extension. It should be used only + * by that interface and by code that actually uses this interface (e.g., the + * client library interface). + * + * Copyright (C) 1988-1994 by Adobe Systems Incorporated and Digital Equipment + * Corporation + * All rights reserved. + * + * Permission to use, copy, modify, and distribute this software and + * its documentation for any purpose and without fee is hereby granted, + * provided that the above copyright notices appear in all copies and + * that both those copyright notices and this permission notice appear + * in supporting documentation, and that the names of Adobe Systems + * Incorporated and Digital Equipment Corporation not be used in + * advertising or publicity pertaining to distribution of the software + * without specific, written prior permission. Adobe Systems Incorporated + * and Digital Equipment Corporation make no representations about the + * suitability of this software for any purpose. It is provided "as is" + * without express or implied warranty. + * + * ADOBE SYSTEMS INCORPORATED AND DIGITAL EQUIPMENT CORPORATION DISCLAIM + * ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL ADOBE + * SYSTEMS INCORPORATED AND DIGITAL EQUIPMENT CORPORATION BE LIABLE FOR + * ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT + * OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + * + * PostScript, Display PostScript, and Adobe are trademarks of Adobe Systems + * Incorporated registered in the U.S.A. and other countries. + * + * Author: Adobe Systems Incorporated and Digital Equipment Corporation + */ +/* $XFree86$ */ + +#ifndef _XDPSlib_h +#define _XDPSlib_h + +#undef _XEVENT_ + +#include <X11/Xlib.h> +#include <DPS/XDPS.h> +#include <X11/Xutil.h> + +/* + * Default standard colormap type. + */ + +#define DefaultStdCMap ((XStandardColormap *) -1) + + +/* + * event masks defined for convenience + */ + +#define XDPSL_ALL_EVENTS \ + (PSRUNNINGMASK|PSNEEDSINPUTMASK|PSZOMBIEMASK|PSFROZENMASK) + +typedef enum { + csdps_not, + csdps_noop, + csdps_output, + csdps_output_with_len, + csdps_status, + csdps_ready /* L2-DPS/PROTO 9 addition */ +} CSDPSFakeEventTypes; + +typedef enum { + not_pserror, + pserror_badcontext, + pserror_badspace, + pserror_abort +} XDPSLPSErrors; + +#define DPSCAP_SYNCMASK_NONE 0x00 +#define DPSCAP_SYNCMASK_SYNC (1<<0) +#define DPSCAP_SYNCMASK_RECONCILE (1<<1) +#define DPSCAP_SYNCMASK_BUFFER (1<<2) + +#define DPSCAP_SYNCMASK_DFLT DPSCAP_SYNCMASK_RECONCILE + +typedef void (*XDPSLEventHandler)(XEvent *event); + +#if defined(__cplusplus) || defined(c_plusplus) +extern "C" { +#endif + +/* + * XDPSLInit returns the first event number for the extension. + */ + +extern int XDPSLInit(Display *dpy, + int *numberType_return, + char **floatingName_return); + +extern ContextXID XDPSLCreateContext(Display *dpy, + SpaceXID sxid, + Drawable drawable, + GC gc, + int x, int y, + unsigned int eventMask, + XStandardColormap *grayRamp, + XStandardColormap *colorCube, + unsigned int actual, + ContextPSID *cpsid_return, + Bool secure); /* L2-DPS/PROTO 9 */ + +extern ContextXID XDPSLCreateContextAndSpace(Display *dpy, + Drawable drawable, + GC gc, + int x, int y, + unsigned int eventMask, + XStandardColormap *grayRamp, + XStandardColormap *colorCube, + unsigned int actual, + ContextPSID *cpsid_return, + SpaceXID *sxid_return, + Bool secure); /* L2-DPS/PROTO 9 */ + +extern SpaceXID XDPSLCreateSpace(Display *dpy); + +extern void XDPSLGiveInput(Display *dpy, ContextXID cxid, + char *data, int length); + +extern int XDPSLGetStatus(Display *dpy, ContextXID cxid); + +extern void XDPSLDestroySpace(Display *dpy, SpaceXID sxid); + +extern void XDPSLReset(Display *dpy, ContextXID cxid); + +extern void XDPSLNotifyContext(Display *dpy, ContextXID cxid, int type); + +extern ContextXID XDPSLCreateContextFromID(Display *dpy, + ContextPSID cpsid, + SpaceXID *sxid_return); + +extern Status XDPSLIDFromContext(Display *dpy, + ContextPSID cpsid, + ContextXID *cxid_return, + SpaceXID *sxid_return); + +/* Returns 1 on success, 0 on failure (cpsid not a valid context). */ + +extern ContextPSID XDPSLContextFromXID(Display *dpy, ContextXID cxid); + +extern void XDPSLSetStatusMask(Display *dpy, ContextXID cxid, + unsigned int enableMask, + unsigned int disableMask, + unsigned int nextMask); + + +extern XExtCodes *XDPSLGetCodes(Display *dpy); + +extern void XDPSLSetTextEventHandler(Display *dpy, + XDPSLEventHandler proc); + +extern void XDPSLCallOutputEventHandler(Display *dpy, XEvent *event); + +extern void XDPSLSetStatusEventHandler(Display *dpy, + XDPSLEventHandler proc); + +extern void XDPSLCallStatusEventHandler(Display *dpy, XEvent *event); + +extern void XDPSLInitDisplayFlags(Display *dpy); + +extern Bool XDPSLGetPassEventsFlag(Display *dpy); + +extern void XDPSLSetPassEventsFlag(Display *dpy, Bool flag); + +extern Bool XDPSLGetWrapWaitingFlag(Display *dpy); + +extern void XDPSLSetWrapWaitingFlag(Display *dpy, Bool flag); + +/* L2-DPS/PROTO 9 additions */ + +extern void XDPSLNotifyWhenReady(Display *dpy, ContextXID cxid, int val[4]); + +extern XDPSLPSErrors XDPSLTestErrorCode(Display *dpy, int ecode); + +extern int XDPSLGetVersion(Display *dpy); + +extern void XDPSLSetReadyEventHandler(Display *dpy, + XDPSLEventHandler proc); + +extern void XDPSLCallReadyEventHandler(Display *dpy, XEvent *event); + + +/* DPS NX additions */ + +extern char * XDPSLSetAgentName(Display *dpy, char *name, int deflt); + +extern void XDPSLSetCodes(Display *dpy, XExtCodes *codes); + +extern Display * XDPSLGetShunt(Display *dpy_in); + +extern void XDPSLSetShunt(Display *dpy_in, Display *dpy_out); + +extern void XDPSLSetVersion(Display *dpy, unsigned ver); + +extern void XDPSLSetClientMessageHandler(Display *dpy); + +extern CSDPSFakeEventTypes XDPSLGetCSDPSFakeEventType(Display *dpy, + XEvent *event); + +extern Bool XDPSLDispatchCSDPSFakeEvent(Display *dpy, + XEvent *event, CSDPSFakeEventTypes t); + +extern void XDPSLGetCSDPSStatus(Display *dpy, + XEvent *event, + void **ret_ctxt, + int *ret_status); + +extern void XDPSLSetXErrorConvertProc(Display *dpy); + +extern void XDPSLCAPNotify(Display *xdpy, + ContextXID cxid, + unsigned int ntype, + unsigned int data, + unsigned int extra); + +extern void XDPSLSync(Display *xdpy); + +extern void *XDPSLEnumerateEvents(Display *dpy, + XEvent *event, + Bool (*predicate)(Display *pdpy, + XEvent *ev, + char *a), + char *arg, + void *next); + + +extern void XDPSLSetAfterProc(Display *dpy); + +extern int XDPSLGetSyncMask(Display *dpy); + +extern void XDPSLSetSyncMask(Display *dpy, int mask); + +extern void XDPSLFlush(Display *dpy); + +extern void XDPSLSyncGCClip(Display *xdpy, GC gc); + +extern void XDPSLGetCSDPSReady(Display *xdpy, + XEvent *event, + void **ret_ctxt, + int *ret_val); + +extern void XDPSLReconcileRequests(Display *xdpy, ContextXID cxid); + +extern Status XDPSLSetAgentArg(Display *xdpy, int arg, int val); + +extern void XDPSLCleanAll(Display *xdpy); + +extern void XDPSLUpdateAgentArgs(Display *xdpy); + +extern void XDPSLCleanContext(Display *xdpy, ContextXID cxid); + +#ifdef VMS +extern void XDPSLSetDisplay(Display *dpy); +#endif /* VMS */ + +/* DPS NX 2.0 */ +extern void XDPSLFlushGC(Display *dpy, GC gc); + +extern void XDPSLSetGCFlushMode(Display *dpy, int value); + +extern int XDPSLGetGCFlushMode(Display *dpy); + +#if defined(__cplusplus) || defined(c_plusplus) +} +#endif + +typedef struct _XDPSLOutputEvent { + int type; /* of event. */ + unsigned long serial; /* # of last request processed by server. */ + Bool send_event; /* True if this came from a SendEvent req. */ + Display *display; /* Display the event was read from. */ + ContextXID cxid; /* Context from which data comes. */ + int length; /* Number of characters of data. */ + char data[24]; /* Data received. */ +} XDPSLOutputEvent; + + +typedef struct _XDPSLStatusEvent { + int type; /* of event. */ + unsigned long serial; /* # of last request processed by server. */ + Bool send_event; /* True if this came from a SendEvent req. */ + Display *display; /* Display the event was read from. */ + ContextXID cxid; /* Context whose status we're reporting. */ + int status; /* Status of context. */ +} XDPSLStatusEvent; + +typedef struct _XDPSLReadyEvent { + int type; /* of event. */ + unsigned long serial; /* # of last request processed by server. */ + Bool send_event; /* True if this came from a SendEvent req. */ + Display *display; /* Display the event was read from. */ + ContextXID cxid; /* Context whose status we're reporting. */ + int val[4]; /* Array of client defined integer values */ +} XDPSLReadyEvent; + +#endif /* _XDPSlib_h */ diff --git a/nx-X11/include/DPS/XDPSproto.h b/nx-X11/include/DPS/XDPSproto.h new file mode 100644 index 000000000..f553471fb --- /dev/null +++ b/nx-X11/include/DPS/XDPSproto.h @@ -0,0 +1,391 @@ +/* + XDPSproto.h -- protocol requests constants and alignment values, + analogous to Xproto.h + +Copyright 1988-1994 Adobe Systems Incorporated. +Portions Copyright 1988, 1989 Digital Equipment Corporation. + +Permission to use, copy, modify, and distribute this software and +its documentation for any purpose and without fee is hereby granted, +provided that the above copyright notices appear in all copies and +that both those copyright notices and this permission notice appear +in supporting documentation, and that the names of Adobe Systems +Incorporated and Digital Equipment Corporation not be used in +advertising or publicity pertaining to distribution of the software +without specific, written prior permission. Adobe Systems Incorporated +and Digital Equipment Corporation make no representations about the +suitability of this software for any purpose. It is provided "as is" +without express or implied warranty. + +ADOBE SYSTEMS INCORPORATED AND DIGITAL EQUIPMENT CORPORATION DISCLAIM +ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL ADOBE +SYSTEMS INCORPORATED AND DIGITAL EQUIPMENT CORPORATION BE LIABLE FOR +ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN +ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT +OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + +Author: Adobe Systems Incorporated and Digital Equipment Corporation + +*/ + +#ifndef _XDPSproto_h +#define _XDPSproto_h + +#include <X11/Xmd.h> + +/* For the purpose of the structure definitions in this file, we must + redefine the following types in terms of Xmd.h's types, which may + include bit fields. All of these are #undef'd at the end of this + file, restoring the typedefs in X.h. */ + +#define Window CARD32 +#define Drawable CARD32 +#define Font CARD32 +#define Pixmap CARD32 +#define Cursor CARD32 +#define Colormap CARD32 +#define GContext CARD32 +#define Atom CARD32 +#define VisualID CARD32 +#define Time CARD32 +#define KeyCode CARD8 +#define KeySym CARD32 + +/* NOTE: The Digital UWS 2.2 DECWindows/DPS server uses "DPSExtension" + for the name of the extension. The name registered with + the X Consortium is "Adobe-DPS-Extension". Your client + should query both names. */ + +#define DPSNAME "Adobe-DPS-Extension" +#define DECDPSNAME "DPSExtension" + +#define DPSPROTO_V09 9 /* L2-DPS Rel 1.0 */ +#define DPSPROTO_V08 8 /* L1-DPS */ +#define DPSPROTO_OLDEST DPSPROTO_V08 + +#ifndef DPSPROTOCOLVERSION +#define DPSPROTOCOLVERSION DPSPROTO_V09 +#endif + +#define CONTEXTXID CARD32 +#define SPACEXID CARD32 + +#ifndef BYTESPEROUTPUTEVENT +#define BYTESPEROUTPUTEVENT 24 +#endif /* Might be fewer for wide architectures with messy padding */ + +/* + * Requests: + */ + +#define X_PSInit 1 +#define X_PSCreateContext 2 +#define X_PSCreateSpace 3 +#define X_PSGiveInput 4 +#define X_PSGetStatus 5 +#define X_PSDestroySpace 6 +#define X_PSReset 7 +#define X_PSNotifyContext 8 +#define X_PSCreateContextFromID 9 +#define X_PSXIDFromContext 10 +#define X_PSContextFromXID 11 +#define X_PSSetStatusMask 12 +#define X_PSCreateSecureContext 13 /* L2-DPS/PROTO 9 addition */ +#define X_PSNotifyWhenReady 14 /* L2-DPS/PROTO 9 addition */ + +#define PSLASTREQUEST X_PSNotifyWhenReady +#define PSLASTREQUEST_P8 X_PSSetStatusMask + +typedef struct _PSInit { + CARD8 reqType; /* always DPSReqCode */ + CARD8 dpsReqType; /* always X_PSInit */ + CARD16 length B16; /* length of request */ + CARD32 libraryversion B32; /* version of protocol implementation */ +} xPSInitReq; +#define sz_xPSInitReq 8 + +typedef struct _PSCreateContext { + CARD8 reqType; /* always DPSReqCode */ + CARD8 dpsReqType; /* always X_PSCreateContext */ + CARD16 length B16; /* length of request */ + CONTEXTXID cxid B32; /* XID for context */ + SPACEXID sxid B32; /* XID for Space to use for new context */ + Drawable drawable B32; /* Drawable for new context */ + GContext gc B32; /* GC for new context */ + INT16 x B16; /* x, initial origin of context's device */ + INT16 y B16; /* y, initial origin of context's device */ + CARD32 eventmask B32; /* events that context is interested in */ + Colormap cmap B32; /* colormap for this context */ + CARD32 redmax B32; /* color cube */ + CARD32 redmult B32; + CARD32 greenmax B32; + CARD32 greenmult B32; + CARD32 bluemax B32; + CARD32 bluemult B32; + CARD32 colorbase B32; + CARD32 graymax B32; /* gray ramp */ + CARD32 graymult B32; + CARD32 graybase B32; + CARD32 actual B32; /* actual colors, if any */ +} xPSCreateContextReq; +#define sz_xPSCreateContextReq 76 + +typedef struct _PSCreateSpace { + CARD8 reqType; /* always DPSReqCode */ + CARD8 dpsReqType; /* always X_PSCreateSpace */ + CARD16 length B16; + SPACEXID sxid B32; /* Space to be created */ +} xPSCreateSpaceReq; +#define sz_xPSCreateSpaceReq 8 + +typedef struct _PSGiveInput { + CARD8 reqType; /* always DPSReqCode */ + CARD8 dpsReqType; /* always X_PSGiveInput */ + CARD16 length B16; /* length of request */ + CARD16 nunits B16; /* number of bytes in following string */ + CARD16 pad B16; + CONTEXTXID cxid B32; /* Context for input. */ +} xPSGiveInputReq; +#define sz_xPSGiveInputReq 12 + +typedef struct _PSGetStatus { + CARD8 reqType; /* always DPSReqCode */ + CARD8 dpsReqType; /* always X_PSGetStatus */ + CARD16 length B16; + CONTEXTXID cxid B32; + CARD32 notifyIfChange B32; /* unused */ +} xPSGetStatusReq; +#define sz_xPSGetStatusReq 12 + +typedef struct _PSDestroySpace { + CARD8 reqType; /* always DPSReqCode */ + CARD8 dpsReqType; /* always X_PSDestroySpace */ + CARD16 length B16; + SPACEXID sxid B32; +} xPSDestroySpaceReq; +#define sz_xPSDestroySpaceReq 8 + + +typedef struct _PSReset { + CARD8 reqType; /* always DPSReqCode */ + CARD8 dpsReqType; /* always X_PSReset */ + CARD16 length B16; + CONTEXTXID cxid B32; +} xPSResetReq; +#define sz_xPSResetReq 8 + +typedef struct _PSNotifyContext { + CARD8 reqType; /* always DPSReqCode */ + CARD8 dpsReqType; /* always X_PSNotifyContext */ + CARD16 length B16; + CONTEXTXID cxid B32; + CARD8 notifyType; /* see XDPS.h */ + CARD8 pad1; + CARD8 pad2; + CARD8 pad3; +} xPSNotifyContextReq; +#define sz_xPSNotifyContextReq 12 + + +typedef struct _PSCreateContextFromID { + CARD8 reqType; /* always DPSReqCode */ + CARD8 dpsReqType; /* always X_PSCreateContextFromID */ + CARD16 length B16; + CARD32 cpsid B32; /* the PostScript context ID */ + CONTEXTXID cxid B32; /* resource ID to associate with cpsid */ +} xPSCreateContextFromIDReq; +#define sz_xPSCreateContextFromIDReq 12 + + +typedef struct _PSXIDFromContext { + CARD8 reqType; /* always DPSReqCode */ + CARD8 dpsReqType; /* always X_PSXIDFromContext */ + CARD16 length B16; + CARD32 cpsid B32; +} xPSXIDFromContextReq; +#define sz_xPSXIDFromContextReq 8 + +typedef struct _PSContextFromXID { + CARD8 reqType; /* always DPSReqCode */ + CARD8 dpsReqType; /* always X_PSContextFromXID */ + CARD16 length B16; + CONTEXTXID cxid B32; +} xPSContextFromXIDReq; +#define sz_xPSContextFromXIDReq 8 + +typedef struct _PSSetStatusMask { + CARD8 reqType; /* always DPSReqCode */ + CARD8 dpsReqType; /* always X_PSContextFromXID */ + CARD16 length B16; + CONTEXTXID cxid B32; + CARD32 enableMask B32; + CARD32 disableMask B32; + CARD32 nextMask B32; +} xPSSetStatusMaskReq; +#define sz_xPSSetStatusMaskReq 20 + +/* L2-DPS/PROTO 9 addition */ +typedef struct _PSCreateContext xPSCreateSecureContextReq; +#define sz_xPSCreateSecureContextReq sz_xPSCreateContextReq + +/* L2-DPS/PROTO 9 addition */ +typedef struct _PSNotifyWhenReady { + CARD8 reqType; /* always DPSReqCode */ + CARD8 dpsReqType; /* always X_PSNotifyWhenReady */ + CARD16 length B16; + CONTEXTXID cxid B32; + INT32 val1 B32; + INT32 val2 B32; + INT32 val3 B32; + INT32 val4 B32; +} xPSNotifyWhenReadyReq; +#define sz_xPSNotifyWhenReadyReq 24 + + + +/* + * Replies: + */ + +typedef struct { + BYTE type; /* X_Reply */ + BYTE pad; + CARD16 sequenceNumber B16; /* of last request received by server */ + CARD32 length B32; /* 4 byte quantities beyond size of GenericReply */ + CARD32 cpsid B32; + CARD32 pad1 B32; + CARD32 pad2 B32; + CARD32 pad3 B32; + CARD32 pad4 B32; + CARD32 pad5 B32; + } xPSCreateContextReply; /* use same reply for CreateSecureContext */ + +typedef struct { + BYTE type; /* X_Reply */ + BYTE status; /* see XDPS.h */ + CARD16 sequenceNumber B16; /* of last request received by server */ + CARD32 length B32; /* 4 byte quantities beyond size of GenericReply */ + CARD32 pad0 B32; + CARD32 pad1 B32; + CARD32 pad2 B32; + CARD32 pad3 B32; + CARD32 pad4 B32; + CARD32 pad5 B32; + } xPSGetStatusReply; + +typedef struct { + BYTE type; /* X_Reply */ + BYTE pad; + CARD16 sequenceNumber B16; /* of last request received by server */ + CARD32 length B32; /* 4 byte quantities beyond size of GenericReply */ + SPACEXID sxid B32; + CARD32 pad1 B32; + CARD32 pad2 B32; + CARD32 pad3 B32; + CARD32 pad4 B32; + CARD32 pad5 B32; + } xPSCreateContextFromIDReply; + +typedef struct { + BYTE type; /* X_Reply */ + BYTE pad; + CARD16 sequenceNumber B16; /* of last request received by server */ + CARD32 length B32; /* 4 byte quantities beyond size of GenericReply */ + CONTEXTXID cxid B32; + SPACEXID sxid B32; + CARD32 pad2 B32; + CARD32 pad3 B32; + CARD32 pad4 B32; + CARD32 pad5 B32; + } xPSXIDFromContextReply; + +typedef struct { + BYTE type; /* X_Reply */ + BYTE pad; + CARD16 sequenceNumber B16; /* of last request received by server */ + CARD32 length B32; /* 4 byte quantities beyond size of GenericReply */ + CARD32 cpsid B32; + CARD32 pad1 B32; + CARD32 pad2 B32; + CARD32 pad3 B32; + CARD32 pad4 B32; + CARD32 pad5 B32; + } xPSContextFromXIDReply; + +typedef struct { + BYTE type; /* X_Reply */ + BYTE pad; + CARD16 sequenceNumber B16; /* of last request received by server */ + CARD32 length B32; /* 4 byte quantities beyond size of GenericReply */ + CARD32 serverversion B32; /* version of protocol implementation */ + CARD32 preferredNumberFormat B32; /* that the server wants to use */ + CARD32 floatingNameLength B32; /* length of name of native floating fmt */ + CARD32 pad1 B32; + CARD32 pad2 B32; + CARD32 pad3 B32; + } xPSInitReply; /* Followed by name of native floating fmt. */ + + + +/* + * Events: + */ + +/* NOTE: The useful data in DPS extension events must fit inside + of the data portion of a ClientMessage event for the sake of + DPS NX */ + +typedef struct { + BYTE type; + CARD8 length; + CARD16 sequenceNumber B16; + CONTEXTXID cxid B32; + CARD8 data[BYTESPEROUTPUTEVENT]; +} PSOutputEvent; + + +typedef struct { + BYTE type; + BYTE status; /* see XDPS.h */ + CARD16 sequenceNumber B16; + CONTEXTXID cxid B32; + CARD32 pad1 B32; + CARD32 pad2 B32; + CARD32 pad3 B32; + CARD32 pad4 B32; + CARD32 pad5 B32; + CARD32 pad6 B32; +} PSStatusEvent; + +/* L2-DPS/PROTO 9 addition */ +typedef struct { + BYTE type; + BYTE pad; + CARD16 sequenceNumber B16; + CONTEXTXID cxid B32; + INT32 val1 B32; + INT32 val2 B32; + INT32 val3 B32; + INT32 val4 B32; + CARD32 pad1 B32; + CARD32 pad2 B32; +} PSReadyEvent; + +/* restore these definitions back to the typedefs in X.h */ + +#undef Window +#undef Drawable +#undef Font +#undef Pixmap +#undef Cursor +#undef Colormap +#undef GContext +#undef Atom +#undef VisualID +#undef Time +#undef KeyCode +#undef KeySym + +#endif /* _XDPSproto_h */ diff --git a/nx-X11/include/DPS/dpsNXargs.h b/nx-X11/include/DPS/dpsNXargs.h new file mode 100644 index 000000000..88863b67d --- /dev/null +++ b/nx-X11/include/DPS/dpsNXargs.h @@ -0,0 +1,233 @@ +/* + * dpsNXargs.h -- constant values for XDPSNXSetClientArg() + * + * (c) Copyright 1993-1994 Adobe Systems Incorporated. + * All rights reserved. + * + * Permission to use, copy, modify, distribute, and sublicense this software + * and its documentation for any purpose and without fee is hereby granted, + * provided that the above copyright notices appear in all copies and that + * both those copyright notices and this permission notice appear in + * supporting documentation and that the name of Adobe Systems Incorporated + * not be used in advertising or publicity pertaining to distribution of the + * software without specific, written prior permission. No trademark license + * to use the Adobe trademarks is hereby granted. If the Adobe trademark + * "Display PostScript"(tm) is used to describe this software, its + * functionality or for any other purpose, such use shall be limited to a + * statement that this software works in conjunction with the Display + * PostScript system. Proper trademark attribution to reflect Adobe's + * ownership of the trademark shall be given whenever any such reference to + * the Display PostScript system is made. + * + * ADOBE MAKES NO REPRESENTATIONS ABOUT THE SUITABILITY OF THE SOFTWARE FOR + * ANY PURPOSE. IT IS PROVIDED "AS IS" WITHOUT EXPRESS OR IMPLIED WARRANTY. + * ADOBE DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL + * IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NON- INFRINGEMENT OF THIRD PARTY RIGHTS. IN NO EVENT SHALL ADOBE BE LIABLE + * TO YOU OR ANY OTHER PARTY FOR ANY SPECIAL, INDIRECT, OR CONSEQUENTIAL + * DAMAGES OR ANY DAMAGES WHATSOEVER WHETHER IN AN ACTION OF CONTRACT, + * NEGLIGENCE, STRICT LIABILITY OR ANY OTHER ACTION ARISING OUT OF OR IN + * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. ADOBE WILL NOT + * PROVIDE ANY TRAINING OR OTHER SUPPORT FOR THE SOFTWARE. + * + * Adobe, PostScript, and Display PostScript are trademarks of Adobe Systems + * Incorporated which may be registered in certain jurisdictions + * + * Author: Adobe Systems Incorporated + */ + +#ifndef DPSNXARGS_H +#define DPSNXARGS_H + +/* XDPSNXSetClientArg arg values */ + +#define XDPSNX_AGENT 0 /* val := (char *), default := NULL + * val is a string in the form: + * transport/host:[:]port + * specifying the agent to establish a + * connection with. + */ +#define XDPSNX_EXEC_FILE 1 /* val := (char *), default := (see docs) + * val is a string giving the name of the + * agent executable to launch if + * XDPSNX_AUTO_LAUNCH is set to true. The + * caller may explicity give the full path to + * the agent in val or just the name - which + * will cause the user's search path to + * searched for the named program file. + */ +#define XDPSNX_EXEC_ARGS 2 /* val := (char **), default := NULL + * val is expected to be a pointer to an array + * of pointers to the arguments to be given to + * the program specified by + * XDPSNX_EXEC_FILE. + * Last array member must be (char *) NULL. + */ +#define XDPSNX_AUTO_LAUNCH 3 /* val := Bool, default := False + * val specifies if library cannot find a + * suitable agent to connect to then it should + * try to start the one defined by + * XDPSNX_EXEC_FILE with XDPSNX_EXEC_ARGS as + * arguments. + */ +#define XDPSNX_LAUNCHED_AGENT_TRANS 4 + /* val := int, default := XDPSNX_USE_BEST + * val specifies the transport a new, auto- + * launched agent is to use. See values + * below. + */ +#define XDPSNX_LAUNCHED_AGENT_PORT 5 + /* val := int, default := XDPSNX_USE_BEST + * val specifies the port that a new, auto- + * launched agent is to use for advertising in + * the transport protocol specified by + * XDPSNX_LAUNCHED_AGENT_TRANS. The default + * port of XDPXNX_USE_BEST specifies that + * the agent is to use its default + * "well-known" port. + */ +#define XDPSNX_REQUEST_XSYNC 6 + /* val := (Display *), default := NULL + * val specifies a Display handle whose DPS + * request handling mode should be changed. + * When ANY DPS request is called, + * an unconditional XSync is done on the + * Display before sending the DPS request. + * This guarantees that any buffered X requests + * are processed by the server before the + * DPS request is sent to the agent. + * The DPS request itself is flushed to the + * agent. This mode is primarily useful + * for debugging. + */ +#define XDPSNX_REQUEST_RECONCILE 7 + /* val := (Display *), default := NULL + * val specifies a Display handle whose DPS + * request handling mode should be changed. + * When ANY DPS request is called, + * the logical equivalent of the routine + * XDPSReconcileRequests is done on the + * Display before sending the DPS request. + * This guarantees that any buffered X requests + * will be processed by the server before the + * DPS request is processed by the agent. + * Connections to the server and agent are + * flushed. This is the default mode. + */ +#define XDPSNX_REQUEST_BUFFER 8 + /* val := (Display *), default := NULL + * val specifies a display handle whose DPS + * request handling mode should be changed. + * When ANY DPS request is called, + * the DPS request is simply buffered as + * usual. This is equivalent to what happens + * when the Client Library drives a DPS/X + * server extension. This mode should + * only be used when the app has adequate + * synchronization through explicit calls + * to XDPSReconcileRequests. + */ +/* DPS NX 2.0 */ +#define XDPSNX_GC_UPDATES_SLOW 9 + /* val := (Display *), default := NULL + * val specifies a Display handle whose GC + * update handling mode should be changed. + * The library automatically tracks changes + * to the GCs used by the application. + * When ANY GC is changed by any component + * of the application (widget, toolkit, etc.), + * a notification of the change is sent + * to the agent. This guarantees that + * the agent tracks all GC changes that + * it cares about correctly, at the cost + * of sending unnecessary updates for GC's + * that the agent doesn't care about. + * Connections to the server and agent are + * are both syncronized. + * This is the default mode. + */ +#define XDPSNX_GC_UPDATES_FAST 10 + /* val := (Display *), default := NULL + * val specifies a Display handle whose GC + * update handling mode should be changed. + * No automatic tracking of GC changes is + * done. The library depends upon the + * application to do explicit notification + * of relevant GC changes by using the + * XDPSFlushGC() function. Setting this + * mode means that the application commits + * to all updates, including components + * linked in (widgets, toolkits), with the + * benefit of substantial performance + * enhancement in certain situations. Do + * not use this mode unless you are sure + * that all components of your application + * use XDPSFlushGC() properly, or else + * inaccurate display renderings will occur. + * No additional synchronization occurs. + */ +#define XDPSNX_SEND_BUF_SIZE 11 + /* val := int, default := XDPSNX_USE_BEST + * val specifies the size in bytes that + * the library should use for low-level + * output buffering on the agent connection. + * Sizes less than 4096 or greater than + * 65536 are ignored. + */ + +#define XDPSNXLASTARG XDPSNX_SEND_BUF_SIZE + +/* ---Special Values--- */ + +#define XDPSNX_USE_BEST -1 + +/* ---Transport Values--- */ + +#define XDPSNX_TRANS_UNIX 0 +#define XDPSNX_TRANS_TCP 1 +#define XDPSNX_TRANS_DECNET 2 + + +/* XDPSNXSetAgentArg arg values */ + +#define AGENT_ARG_SMALLFONTS -1 + /* val := (AGENT_SMALLFONTS_*, see below), + * default := AGENT_SMALLFONTS_ACCURATE. + * The value of this argument tells the + * agent whether fonts with small sizes + * (6-24 points) should be shown with + * accurate spacing but slowly, or as + * fast as possible with potentially + * inaccurate spacing. This argument + * is a hint: the agent may not be able + * to satisfy the request for fast showing + * if matching screen fonts cannot be found. + */ + +#define AGENT_ARG_PIXMEM -2 + /* val := (AGENT_PIXMEM_*, see below), + * default := AGENT_PIXMEM_LIMITED. + * The value of this argument is a hint + * to the agent about the availability + * of pixmap storage on the X server. + * If there is ample pixmap memory, the + * agent can use various caching techniques + * to improve performance. If memory + * is limited, the agent will minimize its + * use of pixmaps. This argument is + * a hint: the agent may not be able to + * do anything about the specified value. + */ + +#define AGENTLASTARG AGENT_ARG_PIXMEM + +/* ---AGENT_ARG_SMALLFONTS Values--- */ +#define AGENT_SMALLFONTS_ACCURATE 0 +#define AGENT_SMALLFONTS_FAST 1 + +/* ---AGENT_ARG_PIXMEM--- */ +#define AGENT_PIXMEM_LIMITED 0 +#define AGENT_PIXMEM_MODERATE 1 +#define AGENT_PIXMEM_UNLIMITED 2 + +#endif /* DPSNXARGS_H */ diff --git a/nx-X11/include/DPS/dpsXclient.h b/nx-X11/include/DPS/dpsXclient.h new file mode 100644 index 000000000..afd06f0de --- /dev/null +++ b/nx-X11/include/DPS/dpsXclient.h @@ -0,0 +1,423 @@ +/* + * dpsXclient.h -- XDPS extension interface to the Display Postscript Library. + * + * (c) Copyright 1989-1994 Adobe Systems Incorporated. + * All rights reserved. + * + * Permission to use, copy, modify, distribute, and sublicense this software + * and its documentation for any purpose and without fee is hereby granted, + * provided that the above copyright notices appear in all copies and that + * both those copyright notices and this permission notice appear in + * supporting documentation and that the name of Adobe Systems Incorporated + * not be used in advertising or publicity pertaining to distribution of the + * software without specific, written prior permission. No trademark license + * to use the Adobe trademarks is hereby granted. If the Adobe trademark + * "Display PostScript"(tm) is used to describe this software, its + * functionality or for any other purpose, such use shall be limited to a + * statement that this software works in conjunction with the Display + * PostScript system. Proper trademark attribution to reflect Adobe's + * ownership of the trademark shall be given whenever any such reference to + * the Display PostScript system is made. + * + * ADOBE MAKES NO REPRESENTATIONS ABOUT THE SUITABILITY OF THE SOFTWARE FOR + * ANY PURPOSE. IT IS PROVIDED "AS IS" WITHOUT EXPRESS OR IMPLIED WARRANTY. + * ADOBE DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL + * IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NON- INFRINGEMENT OF THIRD PARTY RIGHTS. IN NO EVENT SHALL ADOBE BE LIABLE + * TO YOU OR ANY OTHER PARTY FOR ANY SPECIAL, INDIRECT, OR CONSEQUENTIAL + * DAMAGES OR ANY DAMAGES WHATSOEVER WHETHER IN AN ACTION OF CONTRACT, + * NEGLIGENCE, STRICT LIABILITY OR ANY OTHER ACTION ARISING OUT OF OR IN + * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. ADOBE WILL NOT + * PROVIDE ANY TRAINING OR OTHER SUPPORT FOR THE SOFTWARE. + * + * Adobe, PostScript, and Display PostScript are trademarks of Adobe Systems + * Incorporated which may be registered in certain jurisdictions + * + * Author: Adobe Systems Incorporated + */ + +#ifndef DPSXCLIENT_H +#define DPSXCLIENT_H + +#ifdef VMS +#include <decw$include/X.h> +#include <decw$include/Xlib.h> +#include <decw$include/Xutil.h> +#else /* VMS */ +#include <X11/X.h> +#include <X11/Xlib.h> +#include <X11/Xutil.h> +#endif /* VMS */ +#include <DPS/XDPS.h> +#include <DPS/dpsclient.h> +#include <DPS/dpsNXargs.h> + +/* Codes 2000 thru 2099 reserved for XDPS extension error codes */ + +/* dps_err_invalidAccess was promoted to a general error code; maintain its + old value for compatibility */ + +#undef dps_err_invalidAccess +#define dps_err_invalidAccess 2000 +#define dps_err_encodingCheck 2001 +#define dps_err_closedDisplay 2002 +#define dps_err_deadContext 2003 +#define dps_err_warning 2004 +#define dps_err_fatal 2005 +#define dps_err_recursiveWait 2006 + + /* The above definitions specify additional error conditions: + + dps_err_invalidAccess: signaled when expecting output from a context + created by another client. Such contexts send their + output only to the original creator and attempting to + receive output from them would cause indefinite blocking. + + dps_err_encodingCheck: signaled when changing name encoding for a + context created by another client or a context created + in a space which was created by another client. Such + contexts can only accept string name encoding. This + error is also generated when an attempt is made to change + name or program encoding to other than acceptable values. + + dps_err_closedDisplay: when sending PostScript code to a context + that has had its 'display' closed. + + dps_err_deadContext: signaled when expecting output from a context + which has died in the server but still has its X resources + active (a zombie context). Attempting to receive output + from such a context would cause indefinite blocking. + + dps_err_warning: a recoverable error has been found by the Client + Library. The error proc should display the message + (text string passed through arg1) and then simply + return. + + dps_err_fatal: a non-recoverable error has been found by the Client + Library. The error proc should display the message + (text string passed through arg1), and then call + abort() or should otherwise exit the application. + The error proc should not return. + + dps_err_recursiveWait: a client has called a wrap that returns + a value from a status or output handler, and this handler + was invoked while waiting for the results of another + value-returning wrap. Such a recursive wait would + cause indefinite blocking. This error will usually + cause both wraps to return incorrect values and will + often trigger further errors. + + */ + +extern long int DPSLastUserObjectIndex; + +typedef enum {dps_event_pass_through, dps_event_internal_dispatch, + dps_event_query} DPSEventDelivery; + +/* Event delivery types for XDPSSetEventDelivery */ + +#if defined(__cplusplus) || defined(c_plusplus) +extern "C" { +#endif + +extern DPSContext XDPSCreateContext(Display *dpy, + Drawable drawable, + GC gc, + int x, + int y, + unsigned int eventmask, + XStandardColormap *grayramp, + XStandardColormap *ccube, + int actual, + DPSTextProc textProc, + DPSErrorProc errorProc, + DPSSpace space); + + /* Checks to see if 'dpy' supports the DPS extension. If not, NULL is + returned. If so, a context associated with 'dpy', 'drawable' and + 'gc' is created. 'x' and 'y' are offsets from the drawable's origin + to the PostScript device's origin in X coordinates. 'eventmask' is + currently ignored. 'grayramp', 'ccube', and 'actual' collectively + define the colormap that will be associated with the new context. + 'textProc' is called to dispose of text sent by the context. + 'errorProc' is called to handle errors reported by the context. + 'space' determines the execution space of the new context. A null + space causes a new one to be created. */ + +extern DPSContext XDPSCreateSimpleContext(Display *dpy, + Drawable drawable, + GC gc, + int x, + int y, + DPSTextProc textProc, + DPSErrorProc errorProc, + DPSSpace space); + + /* Does the same thing as XDPSCreateContext (above) but uses the + standard colormap information for the new context. */ + +extern DPSContext DPSCreateTextContext(DPSTextProc textProc, + DPSErrorProc errorProc); + + /* Create a new DPSContext whose PostScript is converted to text and sent + to 'textProc' (rather than the interpreter). 'errorProc' can + be used by the implementation of 'textProc' to report any i/o + errors. */ + + +extern DPSContext XDPSCreateSecureContext(Display *dpy, + Drawable drawable, + GC gc, + int x, + int y, + unsigned int eventmask, + XStandardColormap *grayramp, + XStandardColormap *ccube, + int actual, + DPSTextProc textProc, + DPSErrorProc errorProc, + DPSSpace space); + + /* Identical to XDPSCreateContext, but creates a secure context. */ + +extern DPSContext DPSContextFromContextID(DPSContext ctxt, + ContextPSID cid, + DPSTextProc textProc, + DPSErrorProc errorProc); + + /* Returns a DPSContext that is bound to the PostScript context + created when the "fork" operator was executed by 'ctxt', resulting + in the integer value 'cid'. + + If a DPSContext has already been created for cid, that DPSContext + is returned. Otherwise, a new one is created, as follows: + + If 'textProc' or 'errorProc' are NULL, the new DPSContext will + inherit the respective procs from 'ctxt', otherwise the the new + context gets the 'textProc' and/or 'errorProc' passed in. The new + DPSContext inherits everything else from 'ctxt', except its + chaining properties, which are set to NULL. + + DPSContextFromContextID will return NULL if it is unable to create + the context. */ + +extern DPSContext XDPSFindContext(Display *dpy, ContextPSID cid); + + /* Find a known context based on its PostScript id, return its DPSContext. */ + + +extern void DPSDefaultTextBackstop(DPSContext ctxt, char *buf, + long unsigned int count); + + /* This is the text backstop proc automatically installed by + the client library. Since it is a DPSTextProc, you may + use it as your context textProc. Writes text to stdout + and flushes stdout. */ + +extern void DPSChangeEncoding(DPSContext ctxt, + DPSProgramEncoding newProgEncoding, + DPSNameEncoding newNameEncoding); + + /* Change one or more of the context's 2 encoding parameters. + If the formats and encodings for the system on which the client + library is built are different than the formats and encodings + specified by 'ctxt', DPSWritePostScript (as well as the + operations BinObjSeqWrite and WriteTypedObjectArray defined + above, but not WriteData) will convert the bytes of + code from the former to the latter before sending + them on to 'ctxt'. */ + +typedef void (*XDPSStatusProc)(DPSContext ctxt, int code); + +extern XDPSStatusProc XDPSRegisterStatusProc(DPSContext ctxt, + XDPSStatusProc proc); + + /* Register a procedure to be called when a XDPSLStatusEvent + is received by the client. The procedure will be called with two + parameters: the context it was registered with, and the + status code derived from the event. The proc may be + called at any time that the client processes events. Overwrites + any previously registered routine and returns it. See XDPS.h */ + +extern int XDPSGetContextStatus(DPSContext ctxt); + + /* Returns the status of 'ctxt' as defined in XDPS.h. */ + +extern long int DPSNewUserObjectIndex(void); + + /* Returns a new user object index. The Client Library is + the sole allocator of new user object indices. User object + indices are dynamic, and should not be used for computation + or stored in long term storage, such as a file. */ + +/* ============================= */ +/* The following items are provided for lower level access to the DPS + X library extension. +*/ + +extern DPSContext XDPSContextFromSharedID(Display *dpy, + ContextPSID cid, + DPSTextProc textProc, + DPSErrorProc errorProc); + + /* Create a context record for PostScript "cid" shared by another client. */ + +extern DPSSpace XDPSSpaceFromSharedID(Display *dpy, SpaceXID sxid); + + /* Create a space record for a "sxid" shared by another client. */ + +extern XID XDPSXIDFromContext(Display **Pdpy, DPSContext ctxt); + + /* Get the XID for the given context record. Return its 'dpy' */ + +extern XID XDPSXIDFromSpace(Display **Pdpy, DPSSpace spc); + + /* Get the XID for the given space record. Retunr its 'dpy' */ + +extern DPSContext XDPSContextFromXID (Display *dpy, XID xid); + + /* Get the context record for the given XID on 'dpy'*/ + +extern DPSSpace XDPSSpaceFromXID (Display *dpy, XID xid); + + /* Get the space record for the given XID on 'dpy'*/ + +extern void XDPSUnfreezeContext(DPSContext ctxt); + + /* Notify a context that is in "frozen" mode to continue + with execution. */ + +extern void XDPSSetStatusMask(DPSContext ctxt, + unsigned long enableMask, + unsigned long disableMask, + unsigned long nextMask); + + /* Set the status reporting mask for the client. The enableMask + specifies the events the client wants to receive, the + disableMask specifies the events the client no longer wants + to receive, and the nextMask specifies the events that + the client wishes to receive only the next instance of. + The mask values are specified in XDPS.h */ + +/* ============================= */ +/* New event dispatching procedures */ + +extern DPSEventDelivery XDPSSetEventDelivery(Display *dpy, + DPSEventDelivery newMode); + + /* Set or query the event delivery mode */ + +extern Bool XDPSIsStatusEvent(XEvent *event, DPSContext *ctxt, int *status); + + /* Check if an event is a DPS status event; return the context and + status if so. */ + +extern Bool XDPSIsOutputEvent(XEvent *event); + + /* Check if an event is a DPS output event. */ + +extern Bool XDPSIsReadyEvent(XEvent *event, DPSContext *ctxt, int *val); + + /* Check if an event is a DPS ready event; return the context and + data if so. */ + +extern Bool XDPSIsDPSEvent(XEvent *event); + + /* Check if an event is a DPS event. */ + +extern Bool XDPSDispatchEvent(XEvent *event); + + /* Check if an event is a DPS event; call the status or output + handler if so. */ + +extern void XDPSSyncGCClip(Display *dpy, GC gc); + + /* This procedure guarantees that changes made to the GC clip are + recognized by the DPS contexts associated with them. This is + particularly important whenever XClipRectangles or XSetRegion is + used. */ + +extern void XDPSReconcileRequests(DPSContext ctxt); + + /* This procedure guarantees that any X requests sent prior to + the call are processed before any DPS requests sent after the + call are processed, without doing a round-trip. */ + +extern Status XDPSNXSetClientArg(int arg, void *value); + + /* Set arguments that alter the behavior of the Client Library + when using DPS NX. Arguments are detailed in dpsNXargs.h. + It is assumed that val is of the correct type. Return value + is Success only if argument is set successfully, or if + the results are a no-op because DPS NX is not being used. */ + +extern Status XDPSNXSetAgentArg(Display *dpy, int arg, int value); + + /* Set arguments that alter the behavior of a DPS NX agent associated + with the X server specified by dpy. Arguments are detailed + in dpsNXargs.h. It is assumed that val is of the correct + type. Return value is Success only if argument is set + successfully, or if the results are a no-op because DPS NX + is not being used. */ + +/* L2 DPS/PROTO 9 */ + +extern void XDPSNotifyWhenReady(DPSContext ctxt, + int i1, int i2, int i3, int i4); + + /* Send a ready event with that data */ + +typedef void (*XDPSReadyProc)(DPSContext ctxt, int data[4]); + +extern XDPSReadyProc XDPSRegisterReadyProc(DPSContext ctxt, + XDPSReadyProc proc); + + /* Register a procedure to be called when a XDPSLReadyEvent + is received by the client. The procedure will be called with two + parameters: the context it was registered with, and the + Ready data derived from the event. The proc may be + called at any time that the client processes events. Overwrites + any previously registered routine and returns it. See XDPS.h */ + +extern int XDPSGetProtocolVersion(Display *dpy); + + /* Returns the protocol version for that display */ + +extern Status XDPSCreateStandardColormaps( + Display *dpy, + Drawable drawable, + Visual *visual, + int reds, int greens, int blues, int grays, + XStandardColormap *colorCube, XStandardColormap *grayRamp, + Bool retain); + + /* Create a color cube and gray ramp in a colormap, using ICCCM + properties if present and optionally setting them */ + +extern void XDPSGetDefaultColorMaps(Display *dpy, + Screen *screen, + Drawable drawable, + XStandardColormap *colorcube, + XStandardColormap *grayramp); + + /* Get the default color maps for the screen, such as they are. If screen + is NULL, use the drawable to find out which screen. Either colorcube or + grayramp may be NULL to indicate that you don't want that colormap. */ + +/* DPS NX 2.0 */ + +extern void XDPSFlushGC(Display *dpy, GC gc); + + /* Update the interpreter's copy of the GC, flushing all changes. + Whenever the GC associated with a context is changed + (either the values of the GC are changed, or the entire + GC is to be changed with setXgcdrawable or setgstate), + XDPSFlushGC should be called on the changed GC before + any PostScript language that depends on the change is + sent to the interpreter. */ + +#if defined(__cplusplus) || defined(c_plusplus) +} +#endif + +#endif /* DPSXCLIENT_H */ diff --git a/nx-X11/include/DPS/dpsXcommon.h b/nx-X11/include/DPS/dpsXcommon.h new file mode 100644 index 000000000..adf4cfd6d --- /dev/null +++ b/nx-X11/include/DPS/dpsXcommon.h @@ -0,0 +1,52 @@ +/* + * dpsXcommon.h + * + * (c) Copyright 1990-1994 Adobe Systems Incorporated. + * All rights reserved. + * + * Permission to use, copy, modify, distribute, and sublicense this software + * and its documentation for any purpose and without fee is hereby granted, + * provided that the above copyright notices appear in all copies and that + * both those copyright notices and this permission notice appear in + * supporting documentation and that the name of Adobe Systems Incorporated + * not be used in advertising or publicity pertaining to distribution of the + * software without specific, written prior permission. No trademark license + * to use the Adobe trademarks is hereby granted. If the Adobe trademark + * "Display PostScript"(tm) is used to describe this software, its + * functionality or for any other purpose, such use shall be limited to a + * statement that this software works in conjunction with the Display + * PostScript system. Proper trademark attribution to reflect Adobe's + * ownership of the trademark shall be given whenever any such reference to + * the Display PostScript system is made. + * + * ADOBE MAKES NO REPRESENTATIONS ABOUT THE SUITABILITY OF THE SOFTWARE FOR + * ANY PURPOSE. IT IS PROVIDED "AS IS" WITHOUT EXPRESS OR IMPLIED WARRANTY. + * ADOBE DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL + * IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NON- INFRINGEMENT OF THIRD PARTY RIGHTS. IN NO EVENT SHALL ADOBE BE LIABLE + * TO YOU OR ANY OTHER PARTY FOR ANY SPECIAL, INDIRECT, OR CONSEQUENTIAL + * DAMAGES OR ANY DAMAGES WHATSOEVER WHETHER IN AN ACTION OF CONTRACT, + * NEGLIGENCE, STRICT LIABILITY OR ANY OTHER ACTION ARISING OUT OF OR IN + * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. ADOBE WILL NOT + * PROVIDE ANY TRAINING OR OTHER SUPPORT FOR THE SOFTWARE. + * + * Adobe, PostScript, and Display PostScript are trademarks of Adobe Systems + * Incorporated which may be registered in certain jurisdictions + * + * Author: Adobe Systems Incorporated + */ + +#ifndef DPS_X_COMMON_H +#define DPS_X_COMMON_H + +#define dps_status_success 0 +#define dps_status_failure 1 +#define dps_status_no_extension 2 +#define dps_status_unregistered_context 3 +#define dps_status_illegal_value 4 +#define dps_status_postscript_error 5 +#define dps_status_imaging_incomplete 6 + +typedef char *DPSPointer; + +#endif /* DPS_X_COMMON_H */ diff --git a/nx-X11/include/DPS/dpsXpreview.h b/nx-X11/include/DPS/dpsXpreview.h new file mode 100644 index 000000000..17c050bc0 --- /dev/null +++ b/nx-X11/include/DPS/dpsXpreview.h @@ -0,0 +1,222 @@ +/* + * dosXpreview.h + * + * (c) Copyright 1990-1994 Adobe Systems Incorporated. + * All rights reserved. + * + * Permission to use, copy, modify, distribute, and sublicense this software + * and its documentation for any purpose and without fee is hereby granted, + * provided that the above copyright notices appear in all copies and that + * both those copyright notices and this permission notice appear in + * supporting documentation and that the name of Adobe Systems Incorporated + * not be used in advertising or publicity pertaining to distribution of the + * software without specific, written prior permission. No trademark license + * to use the Adobe trademarks is hereby granted. If the Adobe trademark + * "Display PostScript"(tm) is used to describe this software, its + * functionality or for any other purpose, such use shall be limited to a + * statement that this software works in conjunction with the Display + * PostScript system. Proper trademark attribution to reflect Adobe's + * ownership of the trademark shall be given whenever any such reference to + * the Display PostScript system is made. + * + * ADOBE MAKES NO REPRESENTATIONS ABOUT THE SUITABILITY OF THE SOFTWARE FOR + * ANY PURPOSE. IT IS PROVIDED "AS IS" WITHOUT EXPRESS OR IMPLIED WARRANTY. + * ADOBE DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL + * IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NON- INFRINGEMENT OF THIRD PARTY RIGHTS. IN NO EVENT SHALL ADOBE BE LIABLE + * TO YOU OR ANY OTHER PARTY FOR ANY SPECIAL, INDIRECT, OR CONSEQUENTIAL + * DAMAGES OR ANY DAMAGES WHATSOEVER WHETHER IN AN ACTION OF CONTRACT, + * NEGLIGENCE, STRICT LIABILITY OR ANY OTHER ACTION ARISING OUT OF OR IN + * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. ADOBE WILL NOT + * PROVIDE ANY TRAINING OR OTHER SUPPORT FOR THE SOFTWARE. + * + * Adobe, PostScript, and Display PostScript are trademarks of Adobe Systems + * Incorporated which may be registered in certain jurisdictions + * + * Author: Adobe Systems Incorporated + */ +/* $XFree86$ */ + +#ifndef DPS_X_PREVIEW_H +#define DPS_X_PREVIEW_H + +#include <DPS/dpsXcommon.h> + +typedef struct { + long startPos; + int nestingLevel; + unsigned long binaryCount; + Bool continuedLine; +} XDPSPosition; + +#if defined(__cplusplus) || defined(c_plusplus) +extern "C" { +#endif + +/* The rewind function should set the file pointer to the beginning of an + area of interest. +*/ + +typedef void (*XDPSRewindFunction)(FILE *f, + DPSPointer clientData); + +/* The gets function should duplicate the behavior of the fgets function, + but it may return NULL to indicate that the area of interest is over + even if the end of file is not yet reached. +*/ + +typedef char *(*XDPSGetsFunction)(char *buf, + int n, + FILE *f, + DPSPointer clientData); + +/* XDPSSetFileFunctions defines the functions XDPSCreatePixmapForEPSF and + XDPSImageFileIntoDrawable will use to reset the file to its beginning + and to read the next line of the file. +*/ + +extern int XDPSSetFileFunctions(XDPSRewindFunction rewindFunction, + DPSPointer rewindClientData, + XDPSGetsFunction getsFunction, + DPSPointer getsClientData); + +/* The following two functions expect NULL as client data and are appropriate + for dealing with a separate EPSF file. They are the default rewind and + gets functions, and may be used to reset the functions after changing them. +*/ + +extern void XDPSFileRewindFunc(FILE *f, + DPSPointer data); + +extern char *XDPSFileGetsFunc(char *buf, + int n, + FILE *f, + DPSPointer data); + +/* The following two functions expect the address of an XDPSPosition + structure as client data and are appropriate for dealing with an ESPF + file embedded in another file. The 2.0 document structuring conventions + %%BeginDocument and %%EndDocument are used to detect the end of the + included file and to identify any embedded files. The startPos + in the XDPSPosition structure should be the first character of the + embedded file (as found by, for example, ftell). It must *not* include + the initial %%BeginDocument comment for this document. The nestingLevel, + continuedLine, and binaryCount fields are used internally by the functions + and should not be modified. After calling XDPSImageFileIntoDrawable, + startPos will be modified to be the first character after the complete + EPSF file, or -1 if the EPSF ended with end-of-file. +*/ + +extern void XDPSEmbeddedEPSFRewindFunc(FILE *f, + DPSPointer data); + +extern char *XDPSEmbeddedGetsFunc(char *buf, int n, FILE *f, DPSPointer data); + +extern char *XDPSEmbeddedEPSFGetsFunc(char *buf, + int n, + FILE *f, + DPSPointer data); + +/* XDPSCreatePixmapForEPSF creates a pixmap for use on the specified screen. + The size of the pixmap is determined by reading the %%BoundingBox comment + in the file, scaled by the pixelsPerPoint value. The size of the + pixmap is returned in pixelSize (x and y will be zero) and the bounding + box (in points) is returned in bbox. The context parameter may be NULL, + in which case the shared context for the display will be used. If a real + context is passed, it must be registered with XDPSRegisterContext. +*/ + +extern int XDPSCreatePixmapForEPSF(DPSContext context, + Screen *screen, + FILE *epsf, + int depth, + double pixelsPerPoint, + Pixmap *p, + XRectangle *pixelSize, + XRectangle *bbox); + +/* XDPSPixelsPerPoint returns the number of pixels in one point on the given + screen. Note that if the server lies about the resolution of the screen + (as it often does) the lie will be repeated here. */ + +extern double XDPSPixelsPerPoint(Screen *screen); + +/* XDPSImageFileIntoDrawable images a PostScript file into a drawable. + The imaging will be offset by the xOffset and yOffset values, these + must be in points. If the clear parameter is True, the area defined + by the bbox will be cleared to white before imaging. If createMask is + True, the drawable must be 1 bit deep and it will end up containing a + 1 bit everywhere that the PostScript file images, if clear is also True + any untouched bits will be 0. If the drawable is a pixmap, the result + is suitable for use as a mask in X drawing call. The context parameter + may be NULL, in which case the shared context for the display will + be used. If a real context is passed, it must be registered with + XDPSRegisterContext. + + If waitForCompletion is True, XDPSImageFileIntoDrawable + will wait for the imaging to be finished before returning. If + waitForCompletion parameter is False, XDPSImageFileIntoDrawable will wait + for a time as specified by the XDPSSetImagingTimeout before returning + dps_status_imaging_incomplete. The caller checks for the completion of + the imaging by calling XDPSCheckImagingResults periodically. + + Partial imaging may be stopped by destroying the context with + XDPSDestroySharedContext or both DPSDestroyContext and + XDPSUnregisterContext. Doing anything with a context between the time + XDPSImageFileIntoDrawable returns dps_status_imaging_incomplete and the + time XDPSCheckImagingResults returns other than + dps_status_imaging_incomplete will yield incorrect imaging + results and leave the context in an undefined state, don't do it. + + If the display does not support the DPS extension, the image area as + determined by the bbox parameter will be filled with a 50% gray stipple + pattern, or set to solid 1's if createMask is True. + + The context parameter may be NULL, in which case the shared context + for the display will be used. If a real context is passed, it must + be registered with XDPSRegisterContext. +*/ + +extern int XDPSImageFileIntoDrawable(DPSContext context, + Screen *screen, + Drawable dest, + FILE *file, + int drawableHeight, + int drawableDepth, + XRectangle *bbox, + int xOffset, + int yOffset, + double pixelsPerPoint, + Bool clear, + Bool createMask, + Bool waitForCompletion, + Bool *doneFlag); + +/* XDPSCheckImagingResults checks the status of the imaging on the context. + If the imaging is not done, it returns dps_status_imaging_incomplete, if + it is done, it returns dps_status_success or dps_status_postscript_error, + if the context is not currently involved in imaging it returns + dps_status_illegal_value. + + The context parameter may be NULL, in which case the shared context + for the display will be used. If a real context is passed, it must + be registered with XDPSRegisterContext. +*/ + +extern int XDPSCheckImagingResults(DPSContext context, + Screen *screen); + +/* XDPSSetImagingTimeout determines how long XDPSImageFileIntoDrawable will + wait before returning after an incomplete imaging, in milliseconds. + XDPSImageFileIntoDrawable will start by waiting the timeout and will + repeatedly double the wait until the imaging is complete or until + maxDoublings have occurred. */ + +extern void XDPSSetImagingTimeout(int timeout, + int maxDoublings); + +#if defined(__cplusplus) || defined(c_plusplus) +} +#endif + +#endif /* DPS_X_PREVIEW_H */ diff --git a/nx-X11/include/DPS/dpsXshare.h b/nx-X11/include/DPS/dpsXshare.h new file mode 100644 index 000000000..581b5b066 --- /dev/null +++ b/nx-X11/include/DPS/dpsXshare.h @@ -0,0 +1,254 @@ +/* + * dpsXshare.h + * + * (c) Copyright 1990-1994 Adobe Systems Incorporated. + * All rights reserved. + * + * Permission to use, copy, modify, distribute, and sublicense this software + * and its documentation for any purpose and without fee is hereby granted, + * provided that the above copyright notices appear in all copies and that + * both those copyright notices and this permission notice appear in + * supporting documentation and that the name of Adobe Systems Incorporated + * not be used in advertising or publicity pertaining to distribution of the + * software without specific, written prior permission. No trademark license + * to use the Adobe trademarks is hereby granted. If the Adobe trademark + * "Display PostScript"(tm) is used to describe this software, its + * functionality or for any other purpose, such use shall be limited to a + * statement that this software works in conjunction with the Display + * PostScript system. Proper trademark attribution to reflect Adobe's + * ownership of the trademark shall be given whenever any such reference to + * the Display PostScript system is made. + * + * ADOBE MAKES NO REPRESENTATIONS ABOUT THE SUITABILITY OF THE SOFTWARE FOR + * ANY PURPOSE. IT IS PROVIDED "AS IS" WITHOUT EXPRESS OR IMPLIED WARRANTY. + * ADOBE DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL + * IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NON- INFRINGEMENT OF THIRD PARTY RIGHTS. IN NO EVENT SHALL ADOBE BE LIABLE + * TO YOU OR ANY OTHER PARTY FOR ANY SPECIAL, INDIRECT, OR CONSEQUENTIAL + * DAMAGES OR ANY DAMAGES WHATSOEVER WHETHER IN AN ACTION OF CONTRACT, + * NEGLIGENCE, STRICT LIABILITY OR ANY OTHER ACTION ARISING OUT OF OR IN + * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. ADOBE WILL NOT + * PROVIDE ANY TRAINING OR OTHER SUPPORT FOR THE SOFTWARE. + * + * Adobe, PostScript, and Display PostScript are trademarks of Adobe Systems + * Incorporated which may be registered in certain jurisdictions + * + * Author: Adobe Systems Incorporated + */ +/* $XFree86$ */ + +#ifndef DPS_X_SHARE_H +#define DPS_X_SHARE_H + +#include <DPS/dpsXcommon.h> + +/* We have to duplicate this to make the _mult fields signed */ + +typedef struct { + Colormap colormap; + unsigned int red_max; + int red_mult; + unsigned int green_max; + int green_mult; + unsigned int blue_max; + int blue_mult; + unsigned int base_pixel; + unsigned int visualid; + unsigned int killid; +} XDPSStandardColormap; + +typedef unsigned int DPSGState; + +#define XDPSContextScreenDepth (1L<<0) +#define XDPSContextDrawable (1L<<1) +#define XDPSContextRGBMap (1L<<2) +#define XDPSContextGrayMap (1L<<3) + +#if defined(__cplusplus) || defined(c_plusplus) +extern "C" { +#endif + +/* XDPSRegisterContext registers a DPS context with the context sharing + mangager and enables manipulation of the context through the other + procedures in this module. The makeSharedContext parameter establishes + whether or not the context will be made the shared context for its + display. It does not destroy the previous shared context for the + display, if any. +*/ + +extern void XDPSRegisterContext(DPSContext context, + Bool makeSharedContext); + +/* XDPSGetSharedContext returns the shared context for its display. If no + shared context exists, it creates one. XDPSGetSharedContext returns NULL + if the display does not support the DPS extension. The context is + initially set to use the default colormap on the default screen with the + default depth, but is not set to use any drawable. +*/ + +extern DPSContext XDPSGetSharedContext(Display *display); + +/* XDPSDestroySharedContext destroys the shared context for a display. +*/ + +extern void XDPSDestroySharedContext(DPSContext context); + +/* XDPSUnregisterContext frees the context information but doesn't destroy + the context. +*/ + +extern void XDPSUnregisterContext(DPSContext context); + +/* XDPSFreeDisplayInfo frees the stored display info for a display */ + +extern void XDPSFreeDisplayInfo(Display *display); + +/* XDPSChainTextContext either enables or disables a chained text context + for a context. The context must be registered. The text context will + be created automatically. +*/ + +extern int XDPSChainTextContext(DPSContext context, + Bool enable); + +/* XDPSSetContextDepth sets a context for use with a particular screen + and depth. +*/ + +extern int XDPSSetContextDepth(DPSContext context, + Screen *screen, + int depth); + +/* XDPSSetContextDrawable sets a context for use with a particular + drawable. The origin is at the lower left corner. +*/ + +extern int XDPSSetContextDrawable(DPSContext context, + Drawable drawable, + int height); + +/* XDPSSetContextRGBMap sets the RGB map for the context. The colormap in + the structure must be appropriate for the current drawable and depth. + A colormap value of None is allowed when imaging into a pixmap, but the + ramps must be set to the same values as will be used in the window that + will ultimately show the pixmap. +*/ + +extern int XDPSSetContextRGBMap(DPSContext context, + XDPSStandardColormap *map); + +/* XDPSSetContextGrayMap sets the gray map for the context. The colormap in + the structure must be appropriate for the current drawable and depth. + A colormap value of None is allowed when imaging into a pixmap, but the + ramp must be set to the same values as will be used in the window that + will ultimately show the pixmap. +*/ + +extern int XDPSSetContextGrayMap(DPSContext context, + XDPSStandardColormap *map); + +/* XDPSSetContextParameters sets any of the context parameters. The flags + should be a combination of XDPSContextScreenDepth, XDPSContextDrawable, + XDPSContextRGBMap, and XDPSContextGrayMap. +*/ + +extern int XDPSSetContextParameters(DPSContext context, + Screen *screen, + int depth, + Drawable drawable, + int height, + XDPSStandardColormap *rgbMap, + XDPSStandardColormap *grayMap, + unsigned int flags); + +/* XDPSPushContextParameters is identical to XDPSSetContextParameters, but it + can be undone by passing the returned pushCookieReturn to + XDPSPopContextParameters. It is up to the caller to make sure that push + and pop are called in a stack-oriented fashion. +*/ + +extern int XDPSPushContextParameters(DPSContext context, + Screen *screen, + int depth, + Drawable drawable, + int height, + XDPSStandardColormap *rgbMap, + XDPSStandardColormap *grayMap, + unsigned int flags, + DPSPointer *pushCookieReturn); + +extern int XDPSPopContextParameters(DPSPointer pushCookie); + +/* XDPSCaptureContextGState captures the current graphics state as a gstate + and returns a handle to this state. Using this handle with + XDPSSetContextGState or XDPSPushContextGState is more efficient than + using the general routines to return to this state. Note: gstates should + not be used in states that the application doesn't anticipate returning to. +*/ + +extern int XDPSCaptureContextGState(DPSContext context, + DPSGState *gsReturn); + +/* XDPSUpdateContextGState updates the saved gstate to correspond to the + current graphics state. The previous setting of the gstate is no longer + accessible. +*/ + +extern int XDPSUpdateContextGState(DPSContext context, + DPSGState gs); + +/* XDPSFreeContextGState releases a gstate. +*/ + +extern int XDPSFreeContextGState(DPSContext context, + DPSGState gs); + +/* XDPSSetContextGState sets a context to a saved gstate. +*/ + +extern int XDPSSetContextGState(DPSContext context, + DPSGState gs); + +/* XDPSPushContextGState sets a context to a saved gstate, but it can be + undone by passing the returned pushCookieReturn to XDPSPopContextGState. + It is up to the caller to make sure that push and pop are called in a + stack-oriented fashion. +*/ + +extern int XDPSPushContextGState(DPSContext context, + DPSGState gs, + DPSPointer *pushCookieReturn); + +extern int XDPSPopContextGState(DPSPointer pushCookie); + +/* XDPSExtensionPresent returns whether or not the display supports the DPS + extension. +*/ + +extern Bool XDPSExtensionPresent(Display *display); + +/* Define, redefine, and undefine user objects. In all cases the DPS versions + take a context and the PS versions don't */ + +extern int PSDefineAsUserObj(void); +extern int DPSDefineAsUserObj(DPSContext context); + +extern void PSRedefineUserObj(int userObj); +extern void DPSRedefineUserObj(DPSContext context, int userObj); + +extern void PSUndefineUserObj(int userObj); +extern void DPSUndefineUserObj(DPSContext context, int userObj); + +/* Reserve a number of user object indices, and then return them */ + +extern int PSReserveUserObjIndices(int number); +extern int DPSReserveUserObjIndices(DPSContext context, int number); + +extern void PSReturnUserObjIndices(int start, int number); +extern void DPSReturnUserObjIndices(DPSContext context, int start, int number); + +#if defined(__cplusplus) || defined(c_plusplus) +} +#endif + +#endif /* DPS_X_SHARE_H */ diff --git a/nx-X11/include/DPS/dpsXuserpath.h b/nx-X11/include/DPS/dpsXuserpath.h new file mode 100644 index 000000000..59259924e --- /dev/null +++ b/nx-X11/include/DPS/dpsXuserpath.h @@ -0,0 +1,157 @@ +/* + * dpsXuserpath.h + * + * (c) Copyright 1990-1994 Adobe Systems Incorporated. + * All rights reserved. + * + * Permission to use, copy, modify, distribute, and sublicense this software + * and its documentation for any purpose and without fee is hereby granted, + * provided that the above copyright notices appear in all copies and that + * both those copyright notices and this permission notice appear in + * supporting documentation and that the name of Adobe Systems Incorporated + * not be used in advertising or publicity pertaining to distribution of the + * software without specific, written prior permission. No trademark license + * to use the Adobe trademarks is hereby granted. If the Adobe trademark + * "Display PostScript"(tm) is used to describe this software, its + * functionality or for any other purpose, such use shall be limited to a + * statement that this software works in conjunction with the Display + * PostScript system. Proper trademark attribution to reflect Adobe's + * ownership of the trademark shall be given whenever any such reference to + * the Display PostScript system is made. + * + * ADOBE MAKES NO REPRESENTATIONS ABOUT THE SUITABILITY OF THE SOFTWARE FOR + * ANY PURPOSE. IT IS PROVIDED "AS IS" WITHOUT EXPRESS OR IMPLIED WARRANTY. + * ADOBE DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL + * IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NON- INFRINGEMENT OF THIRD PARTY RIGHTS. IN NO EVENT SHALL ADOBE BE LIABLE + * TO YOU OR ANY OTHER PARTY FOR ANY SPECIAL, INDIRECT, OR CONSEQUENTIAL + * DAMAGES OR ANY DAMAGES WHATSOEVER WHETHER IN AN ACTION OF CONTRACT, + * NEGLIGENCE, STRICT LIABILITY OR ANY OTHER ACTION ARISING OUT OF OR IN + * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. ADOBE WILL NOT + * PROVIDE ANY TRAINING OR OTHER SUPPORT FOR THE SOFTWARE. + * + * Adobe, PostScript, and Display PostScript are trademarks of Adobe Systems + * Incorporated which may be registered in certain jurisdictions + * + * Author: Adobe Systems Incorporated + */ +/* $XFree86$ */ + +#ifndef DPS_X_DOUSERPATH_H +#define DPS_X_DOUSERPATH_H + +#include <DPS/dpsXcommon.h> +#include <X11/Xlib.h> +#include <DPS/dpsconfig.h> + +/* Should be 1 for high-order byte first, 0 for low-order byte first. I can + never rember which is big- and which is little-endian. */ + +typedef enum _DPSNumberFormat { +#if SWAPBITS == 1 + dps_float = 128+48, + dps_long = 128, + dps_short = 128+32 +#else /* SWAPBITS */ + dps_float = 48, + dps_long = 0, + dps_short = 32 +#endif /* SWAPBITS */ +} DPSNumberFormat; + +/* Constants for DPSDoUserPath describing what type of coordinates are + being used. Other legal values are: + + For 32-bit fixed point numbers, use dps_long plus the number of bits + in the fractional part. + + For 16-bit fixed point numbers, use dps_short plus the number of bits + in the fractional part. +*/ + +enum _DPSUserPathOp { + dps_setbbox = 0, + dps_moveto, + dps_rmoveto, + dps_lineto, + dps_rlineto, + dps_curveto, + dps_rcurveto, + dps_arc, + dps_arcn, + dps_arct, + dps_closepath, + dps_ucache +}; + +/* We count on the fact that this is a char, so can't put it in the above + typedef. */ + +typedef char DPSUserPathOp; + +typedef enum _DPSUserPathAction { + dps_uappend = 176, + dps_ufill = 179, + dps_ueofill = 178, + dps_ustroke = 183, + dps_ustrokepath = 364, + dps_inufill = 93, + dps_inueofill = 92, + dps_inustroke = 312, + dps_infill = 90, + dps_ineofill = 89, + dps_instroke = 311, + dps_def = 51, + dps_put = 120, + dps_send = 113 /* This is really the null operator */ +} DPSUserPathAction; + +#if defined(__cplusplus) || defined(c_plusplus) +extern "C" { +#endif + +extern void PSDoUserPath(DPSPointer coords, + int numCoords, + DPSNumberFormat numType, + DPSUserPathOp *ops, + int numOp, + DPSPointer bbox, + DPSUserPathAction action); + +extern void DPSDoUserPath(DPSContext ctx, + DPSPointer coords, + int numCoords, + DPSNumberFormat numType, + DPSUserPathOp *ops, + int numOp, + DPSPointer bbox, + DPSUserPathAction action); + +extern Bool PSHitUserPath(double x, double y, + double radius, + + DPSPointer coords, + int numCoords, + DPSNumberFormat numType, + DPSUserPathOp *ops, + int numOp, + DPSPointer bbox, + DPSUserPathAction action); + +extern Bool DPSHitUserPath(DPSContext ctx, + double x, double y, + double radius, + + DPSPointer coords, + int numCoords, + DPSNumberFormat numType, + DPSUserPathOp *ops, + int numOp, + DPSPointer bbox, + DPSUserPathAction action); + +#if defined(__cplusplus) || defined(c_plusplus) +} +#endif + +#endif /* DPS_X_DOUSERPATH_H */ diff --git a/nx-X11/include/DPS/dpsclient.h b/nx-X11/include/DPS/dpsclient.h new file mode 100644 index 000000000..4538a677c --- /dev/null +++ b/nx-X11/include/DPS/dpsclient.h @@ -0,0 +1,392 @@ +/* + * dpsclient.h - Application interface to the Display PostScript Library. + * + * (c) Copyright 1988-1994 Adobe Systems Incorporated. + * All rights reserved. + * + * Permission to use, copy, modify, distribute, and sublicense this software + * and its documentation for any purpose and without fee is hereby granted, + * provided that the above copyright notices appear in all copies and that + * both those copyright notices and this permission notice appear in + * supporting documentation and that the name of Adobe Systems Incorporated + * not be used in advertising or publicity pertaining to distribution of the + * software without specific, written prior permission. No trademark license + * to use the Adobe trademarks is hereby granted. If the Adobe trademark + * "Display PostScript"(tm) is used to describe this software, its + * functionality or for any other purpose, such use shall be limited to a + * statement that this software works in conjunction with the Display + * PostScript system. Proper trademark attribution to reflect Adobe's + * ownership of the trademark shall be given whenever any such reference to + * the Display PostScript system is made. + * + * ADOBE MAKES NO REPRESENTATIONS ABOUT THE SUITABILITY OF THE SOFTWARE FOR + * ANY PURPOSE. IT IS PROVIDED "AS IS" WITHOUT EXPRESS OR IMPLIED WARRANTY. + * ADOBE DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL + * IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NON- INFRINGEMENT OF THIRD PARTY RIGHTS. IN NO EVENT SHALL ADOBE BE LIABLE + * TO YOU OR ANY OTHER PARTY FOR ANY SPECIAL, INDIRECT, OR CONSEQUENTIAL + * DAMAGES OR ANY DAMAGES WHATSOEVER WHETHER IN AN ACTION OF CONTRACT, + * NEGLIGENCE, STRICT LIABILITY OR ANY OTHER ACTION ARISING OUT OF OR IN + * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. ADOBE WILL NOT + * PROVIDE ANY TRAINING OR OTHER SUPPORT FOR THE SOFTWARE. + * + * Adobe, PostScript, and Display PostScript are trademarks of Adobe Systems + * Incorporated which may be registered in certain jurisdictions + * + * Author: Adobe Systems Incorporated + */ +/* $XFree86: xc/include/DPS/dpsclient.h,v 1.3 2000/06/07 22:02:56 tsi Exp $ */ + +#ifndef DPSCLIENT_H +#define DPSCLIENT_H + +#include <DPS/dpsfriends.h> + +/*=== TYPES ===*/ + +typedef int DPSErrorCode; + +/* Standard error codes (type DPSErrorCode) + * These are intended to be used with dpsexcept.h + * System-specific extensions can be made. Codes 1000 through 1099 are + * reserved for use by Adobe. + */ + +#define dps_err_ps 1000 +#define dps_err_nameTooLong 1001 +#define dps_err_resultTagCheck 1002 +#define dps_err_resultTypeCheck 1003 +#define dps_err_invalidContext 1004 +#define dps_err_invalidAccess 1005 + + /* The above definitions specify the error codes passed to a DPSErrorProc: + + dps_err_ps identifies standard PostScript language interpreter + errors. The arg1 argument to the errorProc is the address of the + binary object sequence sent by the handleerror (or resynchandleerror) + operator to report the error. The sequence has 1 object, which is an + array of 4 objects. See the language extensions document for details + on the contents of this sequence. arg2 is the number of bytes in the + entire binary object sequence. + + dps_err_nameTooLong flags user names that are too long. 128 chars + is the maximum length for PostScript language names. The name and its + length are passed as arg1 and arg2 to the error proc. + + dps_err_resultTagCheck flags erroneous result tags, most likely + due to erroneous explicit use of the printobject operator. The + pointer to the binary object sequence and its length are passed + as arg1 and arg2 to the error proc. There is one object in the + sequence. + + dps_err_resultTypeCheck flags incompatible result types. A pointer + to the offending binary object is passed as arg1; arg2 is unused. + + dps_err_invalidContext flags an invalid DPSContext argument. An + attempt to send PostScript language code to a context that has + terminated is the most likely cause of this error. arg1 to the + DPSErrorProc is the context id (see the fork operator); arg2 is + unused. + + dps_err_invalidAccess flags an attempt to access a context in + a way that it does not support. An example is waiting for return + values on a text context. + */ + +typedef void (*DPSTextProc)( + struct _t_DPSContextRec *ctxt, char *buf, + long unsigned int count +); + + /* Call-back procedure to handle text from the PostScript interpreter. + 'buf' contains 'count' bytes of ASCII text. */ + +typedef void (*DPSErrorProc)( + struct _t_DPSContextRec *ctxt, + DPSErrorCode errorCode, + long unsigned int arg1, long unsigned int arg2 +); + + /* Call-back procedure to report errors from the PostScript interpreter. + The meaning of arg1 and arg2 depend on 'errorCode', as described above. + See DPSDefaultErrorProc, below. + */ + +typedef struct { + int systemNameIndex; + char *operatorName; + char *abbrev; +} DPSAbbrevRec; + + /* Abbreviation table for standard context abbreviations. See + DPSFetchAbbrevList, below. + */ + +typedef enum {dps_context_execution, dps_context_text} DPSContextType; + + /* See DPSGetContextType below */ + +/*=== PROCEDURES ===*/ + +#if defined(__cplusplus) || defined(c_plusplus) +extern "C" { +#endif + +extern void DPSversion(DPSContext ctxt, int bufsize, char buf[]); + +extern void DPSDefaultErrorProc(DPSContext ctxt, DPSErrorCode errorCode, + long unsigned int arg1, + long unsigned int arg2); + + /* A sample DPSErrorProc for handling errors from the PostScript interpreter. + The meaning of arg1 and arg2 depend on 'errorCode'. See DPSErrorCode, + above. + + DPSDefaultErrorProc formulates a text message and passes it to the + text backstop proc (see DPSSetTextBackstop). + + If errorCode == dps_err_ps AND the application had previously caused + resyncstart to be executed by ctxt, DPSDefaultErrorProc calls + RAISE(dps_err_ps, ctxt) after invoking the text backstop proc. + DPSDefaultErrorProc is the only procedure in the Display PostScript + library that calls RAISE, and it calls RAISE only in the case outlined + above. + + When DPSDefaultErrorProc is used as a context's errorProc, the exception + to report dps_err_ps can be raised by any of the procedures in the Display + PostScript library, even ones invoked to deal with other contexts. Note + therefore that wraps might raise this exception. Applications that use + resyncstart must be prepared to handle exceptions. + + See DPSResetContext for details on what to do when an exception to + report dps_err_ps is raised. + + See dpsexcept.h for general information on RAISE and exception handling */ + +extern void DPSSetTextBackstop(DPSTextProc textProc); + + /* Call this to establish textProc as the handler for text output from + DPSDefaultErrorProc or from contexts created by the 'fork' operator but + not made known to the dps client library. NULL will be passed as the ctxt + argument to textProc in the latter case. */ + +extern DPSTextProc DPSGetCurrentTextBackstop(void); + + /* Returns the textProc passed most recently to DPSSetTextBackstop, or NULL + if none */ + +extern void DPSSetErrorBackstop(DPSErrorProc errorProc); + + /* Call this to establish errorProc as the handler for PostScript interpreter + errors from contexts created by the 'fork' operator but not made + known to the dps client library. NULL will be passed as the ctxt + argument to errorProc. */ + +extern DPSErrorProc DPSGetCurrentErrorBackstop(void); + + /* Returns the errorProc passed most recently to DPSSetErrorBackstop, or NULL + if none */ + +extern DPSContext DPSGetCurrentContext(void); + + /* Get the default context. Used in conjunction with psops.h and with + wraps that are defined without an explicit DPSContext argument. + Initially NULL. */ + +extern void DPSSetContext(DPSContext ctxt); + + /* Set the default context. Used in conjunction with psops.h and with + wraps that are defined without an explicit DPSContext argument. */ + +extern void DPSWritePostScript(DPSContext ctxt, char *buf, + unsigned int count); + + /* Send as input to 'ctxt' 'count' bytes of PostScript language contained + in 'buf'. The code may be in either of the 3 encodings for PostScript + language programs: plain text, encoded tokens, or binary object sequence. + If the form is encoded tokens or binary object sequence, an entire + one of these must be sent (perhaps in a series of calls on + DPSWritePostScript) before PostScript language in a different encoding + can be sent. + + DPSWritePostScript may transform the PostScript language to a different + encoding, depending on the characteristics established for 'ctxt' when + it was created. For example, a context created to store its PostScript + in an ASCII file would convert binary object sequences to ASCII. + + If 'ctxt' represents an invalid context, for example because + the context has terminated in the server, the dps_err_invalidContext + error will be reported via ctxt's error proc. + + If 'ctxt' is incapable of accepting more PostScript language, for example + because it is backlogged with code that was sent earlier to be executed, + this will block until transmission of 'count' bytes can be completed. */ + +extern void DPSPrintf(DPSContext ctxt, char *fmt, ...); + + /* Write string 'fmt' to ctxt with the optional arguments converted, + formatted and logically inserted into the string in a manner + identical to the C library routine printf. + + If 'ctxt' represents an invalid context, for example because + the context has terminated in the server, the dps_err_invalidContext + error will be reported via ctxt's error proc. + + If 'ctxt' is incapable of accepting more PostScript language, for example + because it is backlogged with code that was sent earlier to be executed, + this will block until transmission of the string can be completed. */ + +extern void DPSWriteData(DPSContext ctxt, char *buf, unsigned int count); + + /* Write 'count' bytes of data from 'buf' to 'ctxt'. This will not + change the data. + + If 'ctxt' represents an invalid context, for example because + the context has terminated in the server, the dps_err_invalidContext + error will be reported via ctxt's error proc. + + If 'ctxt' is incapable of accepting more PostScript language, for example + because it is backlogged with code that was sent earlier to be executed, + this will block until transmission of 'count' bytes can be completed. */ + +extern void DPSFlushContext(DPSContext ctxt); + + /* Force any buffered data to be sent to ctxt. + + If 'ctxt' represents an invalid context, for example because + the context has terminated in the server, the dps_err_invalidContext + error will be reported via ctxt's error proc. + + If 'ctxt' is incapable of accepting more PostScript language, for example + because it is backlogged with code that was sent earlier to be executed, + this will block until transmission of all buffered bytes can be completed. + */ + +extern int DPSChainContext(DPSContext parent, DPSContext child); + + /* This links child and all of child's children onto parent's 'chainChild' + list. The 'chainChild' list threads those contexts that automatically + receive copies of any PostScript code sent to parent. A context may + appear on only one such list. + + Normally, DPSChainContext returns 0. It returns -1 if child already + appears on some other context's 'chainChild' list. */ + +extern void DPSUnchainContext(DPSContext ctxt); + + /* This unlinks ctxt from the chain that it is on, if any. It leaves + ctxt->chainParent == ctxt->chainChild == NULL + */ + +extern void DPSResetContext(DPSContext ctxt); + + /* This should be called by the application in its HANDLER clauses + when Exception.Code == dps_err_ps. See the discussion above about + DPSDefaultErrorProc. Also see the discussion of error handling in + the client library documentation. + + DPSResetContext closes the input stream to the server for the context + and discards any pending bytes on the output stream from the server for + the context. It then waits for this output stream to close, then reopens + both streams. DPSResetContext is designed to work with resyncstart to + leave the context ready to read and execute more input after handling + a PostScript error. + + If 'ctxt' represents an invalid context, for example because + the context has terminated in the server, the dps_err_invalidContext + error will be reported via ctxt's error proc. */ + +extern void DPSInterruptContext(DPSContext ctxt); + + /* Sends a request to the server to interrupt execution of the context. + This causes a PostScript language 'interrupt' error in the context. + + DPSInterruptContext returns immediately after sending the request. + + If 'ctxt' represents an invalid context, for example because + the context has terminated in the server, the dps_err_invalidContext + error will be reported via ctxt's error proc. */ + +extern void DPSDestroyContext(DPSContext ctxt); + + /* This calls DPSUnchainContext, then (for an interpreter context) sends a + request to the interpreter to terminate ctxt, then frees the storage + referenced by ctxt. The termination request is ignored by the + server if the context is invalid, for example if it has already + terminated. */ + +extern void DPSDestroySpace(DPSSpace spc); + + /* Calls DPSDestroyContext for each of the contexts in the space, then + sends a request to the server to terminate the space, then frees the + storage referenced by spc. */ + +extern void DPSSetNumStringConversion(DPSContext ctxt, int flag); + + /* Sets the numstring conversion flag, which tells the client library + to convert numstrings to simple arrays */ + +extern void DPSSetWrapSynchronization(DPSContext ctxt, int flag); + + /* Sets the wrap synchronization flag, which makes all wraps synchronize + with the server */ + +extern void DPSSuppressBinaryConversion(DPSContext ctxt, int flag); + + /* Sets the no binary convert flag, which makes the client library not + convert binary object sequences and binary tokens into ASCII */ + +extern void DPSSetAbbrevMode(DPSContext ctxt, int flag); + + /* Sets the abbrev mode flag, which controls whether the client library + uses abbreviated operator names when converting from binary to ascii */ + +extern void DPSFetchAbbrevList(DPSAbbrevRec **list, int *count); + + /* Returns the list of abbreviations used for binary to ascii conversion. + The returned list is sorted both by systemNameIndex and by operatorName. + */ + +extern char *DPSGetSysnameAbbrev(int n); + + /* Returns the abbreviation for the operator with system name n, or + NULL if there is no such abbreviation */ + +extern char *DPSGetOperatorAbbrev(char *op); + + /* Returns the abbreviation for the operator, or NULL if there is no + such abbreviation */ + +extern DPSContextType DPSGetContextType(DPSContext ctxt); + + /* Returns whether a context is a text context or an execution context */ + + /* generated functions used in dpstk */ +extern void DPSrectfill(DPSContext ctxt, double x, double y, double w, double h); +extern void DPSsetcmykcolor(DPSContext ctxt, double c, double m, double y, double k); +extern void DPSsetgray(DPSContext ctxt, double gray); +extern void DPSsethsbcolor(DPSContext ctxt, double h, double s, double b); +extern void DPSsetrgbcolor(DPSContext ctxt, double r, double g, double b); +extern void DPSsetXoffset(DPSContext ctxt, int x, int y); +extern void DPSinitviewclip(DPSContext ctxt); +extern void DPSinitgraphics(DPSContext ctxt); +extern void DPSscale(DPSContext ctxt, double x, double y); +extern void DPSinitclip(DPSContext ctxt); + +#if defined(__cplusplus) || defined(c_plusplus) +} +#endif + +#define DPSSetTextProc(ctxt, tp) ((ctxt)->textProc = (tp)) + + /* Change ctxt's textProc. */ + +#define DPSSetErrorProc(ctxt, ep) ((ctxt)->errorProc = (ep)) + + /* Change ctxt's errorProc. */ + +#define DPSSpaceFromContext(ctxt) ((ctxt)->space) + + /* Extract space handle from context. */ + +#endif /* DPSCLIENT_H */ diff --git a/nx-X11/include/DPS/dpsconfig.h b/nx-X11/include/DPS/dpsconfig.h new file mode 100644 index 000000000..85d2211ca --- /dev/null +++ b/nx-X11/include/DPS/dpsconfig.h @@ -0,0 +1,232 @@ +/* + * dpsconfig.h + * + * (c) Copyright 1984-1994 Adobe Systems Incorporated. + * All rights reserved. + * + * Permission to use, copy, modify, distribute, and sublicense this software + * and its documentation for any purpose and without fee is hereby granted, + * provided that the above copyright notices appear in all copies and that + * both those copyright notices and this permission notice appear in + * supporting documentation and that the name of Adobe Systems Incorporated + * not be used in advertising or publicity pertaining to distribution of the + * software without specific, written prior permission. No trademark license + * to use the Adobe trademarks is hereby granted. If the Adobe trademark + * "Display PostScript"(tm) is used to describe this software, its + * functionality or for any other purpose, such use shall be limited to a + * statement that this software works in conjunction with the Display + * PostScript system. Proper trademark attribution to reflect Adobe's + * ownership of the trademark shall be given whenever any such reference to + * the Display PostScript system is made. + * + * ADOBE MAKES NO REPRESENTATIONS ABOUT THE SUITABILITY OF THE SOFTWARE FOR + * ANY PURPOSE. IT IS PROVIDED "AS IS" WITHOUT EXPRESS OR IMPLIED WARRANTY. + * ADOBE DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL + * IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NON- INFRINGEMENT OF THIRD PARTY RIGHTS. IN NO EVENT SHALL ADOBE BE LIABLE + * TO YOU OR ANY OTHER PARTY FOR ANY SPECIAL, INDIRECT, OR CONSEQUENTIAL + * DAMAGES OR ANY DAMAGES WHATSOEVER WHETHER IN AN ACTION OF CONTRACT, + * NEGLIGENCE, STRICT LIABILITY OR ANY OTHER ACTION ARISING OUT OF OR IN + * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. ADOBE WILL NOT + * PROVIDE ANY TRAINING OR OTHER SUPPORT FOR THE SOFTWARE. + * + * Adobe, PostScript, and Display PostScript are trademarks of Adobe Systems + * Incorporated which may be registered in certain jurisdictions + * + * Author: Adobe Systems Incorporated + */ +/* $XFree86: xc/include/DPS/dpsconfig.h,v 1.4 2001/07/24 08:32:53 alanh Exp $ */ + +#ifndef DPSCONFIG_H +#define DPSCONFIG_H + +/* + * IEEEFLOAT is true if the representation of type "float" is the IEEE + * standard 32-bit floating point format, with byte order as defined + * by SWAPBITS (below). IEEEFLOAT is false if some other representation + * is used (or, heaven forbid, IEEE representation with some inconsistent + * byte order). This determines the conditions under which conversions + * are required when manipulating external binary representations. + * + * IEEEFLOAT should be true (1) for: + * mc680x0 series, i80x86 series, IBM R6000, MIPS Rx000 series, + * SPARC, Alpha, HPPA + * IEEEFLOAT should be false (0) for: + * VAX + * + * For all non-IEEE architectures, the DPS_FORMATNAME macro must agree + * with the floating point format returned by extensions on that + * server, if any. + */ + +#ifndef IEEEFLOAT + +#ifdef vax +#define IEEEFLOAT 0 +#define DPS_FORMATNAME "VAX" +#endif /* vax */ + +#ifdef MIPSEL +#define IEEEFLOAT 1 +#endif /* MIPSEL */ + +#ifdef MIPSEB +#define IEEEFLOAT 1 +#endif /* MIPSEB */ + +#ifdef sparc +#define IEEEFLOAT 1 +#endif /* sparc */ + +#ifdef mc68000 +#define IEEEFLOAT 1 +#endif /* mc68000 */ + +#if defined(_IBMR2) || defined(_POWER) +#define IEEEFLOAT 1 +#endif /* _IBMR2 */ + +#if defined(__alpha) || defined(__alpha__) || \ + defined(__ia64__) || defined(ia64) || \ + defined(__s390x__) || \ + defined(__amd64__) || defined(amd64) +#define IEEEFLOAT 1 +#endif + +#ifdef __i386__ +#define IEEEFLOAT 1 +#endif /* __i386__ */ + +#ifndef IEEEFLOAT +#define IEEEFLOAT 1 +#endif /* IEEEFLOAT */ + +#endif /* IEEEFLOAT */ + +#ifndef DPS_FORMATNAME +#if IEEEFLOAT +#define DPS_FORMATNAME "IEEE" +#else /* IEEEFLOAT */ +#define DPS_FORMATNAME UNKNOWN /* This should raise an error */ +#endif /* IEEEFLOAT */ +#endif /* DPS_FORMATNAME */ + +/* + * SWAPBITS is true on a CPU whose native order is "little-endian", i.e., + * the low-order byte of a multiple-byte unit (word, longword) appears + * at the lowest address in memory. SWAPBITS is false on a "big-endian" + * CPU, where the high-order byte comes first. This affects the layout + * of structures and determines whether or not conversions are required + * when manipulating external binary representations. + * + * SWAPBITS should be true (1) for: + * Alpha, VAX, i80x86 series, ia64, MIPS little-endian (e.g. DEC version) + * SWAPBITS should be false (0) for: + * mc680x0 series, IBM R6000, MIPS big-endian (e.g. SGI version), SPARC, + * HPPA + */ + +#ifndef SWAPBITS + +#if defined(__alpha) || defined(__alpha__) || \ + defined(__ia64__) || defined(ia64) +#define SWAPBITS 1 +#endif /* __alpha */ + +#ifdef vax +#define SWAPBITS 1 +#endif /* vax */ + +#ifdef MIPSEL +#define SWAPBITS 1 +#endif /* MIPSEL */ + +#ifdef MIPSEB +#define SWAPBITS 0 +#endif /* MIPSEB */ + +#ifdef sparc +#define SWAPBITS 0 +#endif /* sparc */ + +#ifdef mc68000 +#define SWAPBITS 0 +#endif /* mc68000 */ + +#if defined(__s390x__) || defined (__s390__) +#define SWAPBITS 0 +#endif /* s390 and s390x */ + +#if (defined(_IBMR2) || defined(_POWER)) && defined(AIXV3) +#define SWAPBITS 0 +#endif /* _IBMR2 */ + +#ifdef __i386__ +#define SWAPBITS 1 +#endif /* __i386__ */ + +#ifndef SWAPBITS +#define SWAPBITS 0 +#endif /* SWAPBITS */ + +#endif /* SWAPBITS */ + +/* + * MIN_POINTER_ALIGN gives the minimum alignment requirements for pointers + * to structures. If a pointer to an arbitrary buffer is to be cast to + * a pointer to a structure, the buffer must be aligned according to + * MIN_POINTER_ALIGN. MIN_POINTER_ALIGN must be a power of 2. + * + * MIN_POINTER_ALIGN must be 8 on + * Alpha, IA-64, hppa64 (aka hppa2.0 in wide mode) + * MIN_POINTER_ALIGN must be 4 on + * VAX, i80x86 series, MIPS, mc680x0 series, IBM R6000, SPARC, HPPA + */ + +#ifndef MIN_POINTER_ALIGN + +#if defined(__alpha) || defined(__alpha__) || \ + defined(__ia64__) || defined(ia64) || \ + defined(__s390x__) +#define MIN_POINTER_ALIGN 8 +#endif /* __alpha */ + +#if defined(__hppa__) +#if defined(__LP64__) +#define MIN_POINTER_ALIGN 8 +#else +#define MIN_POINTER_ALIGN 4 +#endif +#endif + +#ifdef vax +#define MIN_POINTER_ALIGN 4 +#endif /* vax */ + +#ifdef MIPSEL +#define MIN_POINTER_ALIGN 4 +#endif /* MIPSEL */ + +#ifdef MIPSEB +#define MIN_POINTER_ALIGN 4 +#endif /* MIPSEB */ + +#ifdef sparc +#define MIN_POINTER_ALIGN 4 +#endif /* sparc */ + +#ifdef mc68000 +#define MIN_POINTER_ALIGN 4 +#endif /* mc68000 */ + +#if defined(_IBMR2) || defined(_POWER) +#define MIN_POINTER_ALIGN 4 +#endif /* _IBMR2 */ + +#ifndef MIN_POINTER_ALIGN +#define MIN_POINTER_ALIGN 4 +#endif /* MIN_POINTER_ALIGN */ + +#endif /* MIN_POINTER_ALIGN */ + +#endif /* DPSCONFIG_H */ diff --git a/nx-X11/include/DPS/dpsexcept.h b/nx-X11/include/DPS/dpsexcept.h new file mode 100644 index 000000000..7daf70195 --- /dev/null +++ b/nx-X11/include/DPS/dpsexcept.h @@ -0,0 +1,257 @@ +/* + * dpsexcept.h -- exception handling for the DPS client library + * + * (c) Copyright 1984-1994 Adobe Systems Incorporated. + * All rights reserved. + * + * Permission to use, copy, modify, distribute, and sublicense this software + * and its documentation for any purpose and without fee is hereby granted, + * provided that the above copyright notices appear in all copies and that + * both those copyright notices and this permission notice appear in + * supporting documentation and that the name of Adobe Systems Incorporated + * not be used in advertising or publicity pertaining to distribution of the + * software without specific, written prior permission. No trademark license + * to use the Adobe trademarks is hereby granted. If the Adobe trademark + * "Display PostScript"(tm) is used to describe this software, its + * functionality or for any other purpose, such use shall be limited to a + * statement that this software works in conjunction with the Display + * PostScript system. Proper trademark attribution to reflect Adobe's + * ownership of the trademark shall be given whenever any such reference to + * the Display PostScript system is made. + * + * ADOBE MAKES NO REPRESENTATIONS ABOUT THE SUITABILITY OF THE SOFTWARE FOR + * ANY PURPOSE. IT IS PROVIDED "AS IS" WITHOUT EXPRESS OR IMPLIED WARRANTY. + * ADOBE DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL + * IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NON- INFRINGEMENT OF THIRD PARTY RIGHTS. IN NO EVENT SHALL ADOBE BE LIABLE + * TO YOU OR ANY OTHER PARTY FOR ANY SPECIAL, INDIRECT, OR CONSEQUENTIAL + * DAMAGES OR ANY DAMAGES WHATSOEVER WHETHER IN AN ACTION OF CONTRACT, + * NEGLIGENCE, STRICT LIABILITY OR ANY OTHER ACTION ARISING OUT OF OR IN + * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. ADOBE WILL NOT + * PROVIDE ANY TRAINING OR OTHER SUPPORT FOR THE SOFTWARE. + * + * Adobe, PostScript, and Display PostScript are trademarks of Adobe Systems + * Incorporated which may be registered in certain jurisdictions + * + * Author: Adobe Systems Incorporated + */ +/* $XFree86$ */ + +/* +Original version: Jeffrey Mogul, Stanford, 18 February 1983 +*/ + +#ifndef DPSEXCEPT_H +#define DPSEXCEPT_H + +/* If the macro setjmp_h is defined, it is the #include path to be used + instead of <setjmp.h> + */ +#ifdef setjmp_h +#include setjmp_h +#else /* setjmp_h */ +#ifdef VAXC +#include setjmp +#else /* VAXC */ +#include <setjmp.h> +#endif /* VAXC */ +#endif /* setjmp_h */ + +/* + This interface defines a machine-independent exception handling + facility. It depends only on the availability of setjmp and longjmp. + Note that we depend on native setjmp and longjmp facilities; it's + not possible to interpose a veneer due to the way setjmp works. + (In fact, in ANSI C, setjmp is a macro, not a procedure.) + + The exception handler is largely defined by a collection of macros + that provide some additional "syntax". A stretch of code that needs + to handle exceptions is written thus: + + DURING + statement1; + statement2; + ... + HANDLER + statement3 + statement4; + ... + END_HANDLER + + The meaning of this is as follows. Normally, the statements between + DURING and HANDLER are executed. If no exception occurs, the statements + between HANDLER and END_HANDLER are bypassed; execution resumes at the + statement after END_HANDLER. + + If an exception is raised while executing the statements between + DURING and HANDLER (including any procedure called from those statements), + execution of those statements is aborted and control passes to the + statements between HANDLER and END_HANDLER. These statements + comprise the "exception handler" for exceptions occurring between + the DURING and the HANDLER. + + The exception handler has available to it two local variables, + Exception.Code and Exception.Message, which are the values passed + to the call to RAISE that generated the exception (see below). + These variables have valid contents only between HANDLER and + END_HANDLER. + + If the exception handler simply falls off the end (or returns, or + whatever), propagation of the exception ceases. However, if the + exception handler executes RERAISE, the exception is propagated to + the next outer dynamically enclosing occurrence of DURING ... HANDLER. + + There are two usual reasons for wanting to handle exceptions: + + 1. To clean up any local state (e.g., deallocate dynamically allocated + storage), then allow the exception to propagate further. In this + case, the handler should perform its cleanup, then execute RERAISE. + + 2. To recover from certain exceptions that might occur, then continue + normal execution. In this case, the handler should perform a + "switch" on Exception.Code to determine whether the exception + is one it is prepared to recover from. If so, it should perform + the recovery and just fall through; if not, it should execute + RERAISE to propagate the exception to a higher-level handler. + + It is ILLEGAL to execute a statement between DURING and HANDLER + that would transfer control outside of those statements. In particular, + "return" is illegal (an unspecified malfunction will occur). + To perform a "return", execute E_RETURN_VOID; to perform a "return(x)", + execute E_RETURN(x). This restriction does not apply to the statements + between HANDLER and END_HANDLER. + + Note that in an environment with multiple contexts (i.e., multiple + coroutines), each context has its own stack of nested exception + handlers. An exception is raised within the currently executing + context and transfers control to a handler in the same context; the + exception does not propagate across context boundaries. + */ + + +/* Data structures */ + +typedef struct _Exc_buf_x { + struct _Exc_buf_x *Prev; /* exception chain back-pointer */ + jmp_buf Environ; /* saved environment */ + char *Message; /* Human-readable cause */ + int Code; /* Exception code */ +} _Exc_Buf; + +extern _Exc_Buf *_Exc_Header; /* global exception chain header */ + + +/* Macros defining the exception handler "syntax": + DURING statements HANDLER statements END_HANDLER + (see the description above) + */ + +#define _E_RESTORE _Exc_Header = Exception.Prev + +#define DURING {_Exc_Buf Exception;\ + Exception.Prev=_Exc_Header;\ + _Exc_Header= &Exception;\ + if (! setjmp(Exception.Environ)) { + +#define HANDLER _E_RESTORE;} else { + +#define END_HANDLER }} + +#define E_RETURN(x) {_E_RESTORE; return(x);} + +#define E_RTRN_VOID {_E_RESTORE; return;} + + +/* Exported Procedures */ + +#if defined(__cplusplus) || defined(c_plusplus) +extern "C" { +#endif + +extern void DPSRaise(int Code, char *Message); +/* Initiates an exception; always called via the RAISE macro. + This procedure never returns; instead, the stack is unwound and + control passes to the beginning of the exception handler statements + for the innermost dynamically enclosing occurrence of + DURING ... HANDLER. The Code and Message arguments are passed to + that handler as described above. + + It is legal to call DPSRaise from within a "signal" handler for a + synchronous event such as floating point overflow. It is not reasonable + to do so from within a "signal" handler for an asynchronous event + (e.g., interrupt), since the exception handler's data structures + are not updated atomically with respect to asynchronous events. + + If there is no dynamically enclosing exception handler, DPSRaise + writes an error message to os_stderr and aborts with DPSCantHappen. + */ + +extern void DPSCantHappen(void); +/* Calls abort. This is used only to handle "impossible" errors; + there is no recovery, and DPSCantHappen does not return. + */ + + +/* The following two operations are invoked only from the exception + handler macros and from the DPSRaise procedure. Note that they are + not actually declared here but in <setjmp.h> (or a substitute + specified by the macro SETJMP, above). + + Note that the exception handler facility uses setjmp/longjmp in + a stylized way that may not require the full generality of the + standard setjmp/longjmp mechanism. In particular, setjmp is never + called during execution of a signal handler; thus, the signal + mask saved by setjmp can be constant rather than obtained from + the operating system on each call. This can have considerable + performance consequences. + */ + +#if 0 +extern int setjmp(jmp_buf buf); +/* Saves the caller's environment in the buffer (which is an array + type and therefore passed by pointer), then returns the value zero. + It may return again if longjmp is executed subsequently (see below). + */ + +extern void longjmp(jmp_buf buf, int value); +/* Restores the environment saved by an earlier call to setjmp, + unwinding the stack and causing setjmp to return again with + value as its return value (which must be non-zero). + The procedure that called setjmp must not have returned or + otherwise terminated. The saved environment must be at an earlier + place on the same stack as the call to longjmp (in other words, + it must not be in a different coroutine). It is legal to call + longjmp in a signal handler and to restore an environment + outside the signal handler; longjmp must be able to unwind + the signal cleanly in such a case. + */ +#endif /* 0 */ + +#if defined(__cplusplus) || defined(c_plusplus) +} +#endif + +/* In-line Procedures */ + +#define RAISE DPSRaise +/* See DPSRaise above; defined as a macro simply for consistency */ + +#define RERAISE RAISE(Exception.Code, Exception.Message) +/* Called from within an exception handler (between HANDLER and + END_HANDLER), propagates the same exception to the next outer + dynamically enclosing exception handler; does not return. + */ + +/* + Error code enumerations + + By convention, error codes are divided into blocks belonging to + different components of the Display PostScript system. + + Negative error codes and the codes between 0 and 999 (inclusive) are + reserved for use by the Display PostScript system. + */ + +#define dps_err_base 1000 + +#endif /* DPSEXCEPT_H */ diff --git a/nx-X11/include/DPS/dpsfriends.h b/nx-X11/include/DPS/dpsfriends.h new file mode 100644 index 000000000..920ffc134 --- /dev/null +++ b/nx-X11/include/DPS/dpsfriends.h @@ -0,0 +1,481 @@ +/* + * dpsfriends.h -- Low-level interface to the Display PostScript Library. + * + * (c) Copyright 1988-1994 Adobe Systems Incorporated. + * All rights reserved. + * + * Permission to use, copy, modify, distribute, and sublicense this software + * and its documentation for any purpose and without fee is hereby granted, + * provided that the above copyright notices appear in all copies and that + * both those copyright notices and this permission notice appear in + * supporting documentation and that the name of Adobe Systems Incorporated + * not be used in advertising or publicity pertaining to distribution of the + * software without specific, written prior permission. No trademark license + * to use the Adobe trademarks is hereby granted. If the Adobe trademark + * "Display PostScript"(tm) is used to describe this software, its + * functionality or for any other purpose, such use shall be limited to a + * statement that this software works in conjunction with the Display + * PostScript system. Proper trademark attribution to reflect Adobe's + * ownership of the trademark shall be given whenever any such reference to + * the Display PostScript system is made. + * + * ADOBE MAKES NO REPRESENTATIONS ABOUT THE SUITABILITY OF THE SOFTWARE FOR + * ANY PURPOSE. IT IS PROVIDED "AS IS" WITHOUT EXPRESS OR IMPLIED WARRANTY. + * ADOBE DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL + * IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NON- INFRINGEMENT OF THIRD PARTY RIGHTS. IN NO EVENT SHALL ADOBE BE LIABLE + * TO YOU OR ANY OTHER PARTY FOR ANY SPECIAL, INDIRECT, OR CONSEQUENTIAL + * DAMAGES OR ANY DAMAGES WHATSOEVER WHETHER IN AN ACTION OF CONTRACT, + * NEGLIGENCE, STRICT LIABILITY OR ANY OTHER ACTION ARISING OUT OF OR IN + * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. ADOBE WILL NOT + * PROVIDE ANY TRAINING OR OTHER SUPPORT FOR THE SOFTWARE. + * + * Adobe, PostScript, and Display PostScript are trademarks of Adobe Systems + * Incorporated which may be registered in certain jurisdictions + * + * Author: Adobe Systems Incorporated + */ +/* $XFree86: xc/include/DPS/dpsfriends.h,v 1.4 2001/08/01 00:44:34 tsi Exp $ */ + +#ifndef DPSFRIENDS_H +#define DPSFRIENDS_H + +#include <DPS/dpsconfig.h> + +/*=== CONSTANTS ===*/ + +/* TokenType values, used to specify the format of numeric values + for the system on which the client library is built. See DPS language + reference manual */ + +#define DPS_HI_IEEE 128 +#define DPS_LO_IEEE 129 +#define DPS_HI_NATIVE 130 +#define DPS_LO_NATIVE 131 + +#ifndef DPS_DEF_TOKENTYPE + +#if IEEEFLOAT + +#if SWAPBITS +#define DPS_DEF_TOKENTYPE DPS_LO_IEEE +#else /* SWAPBITS */ +#define DPS_DEF_TOKENTYPE DPS_HI_IEEE +#endif /* SWAPBITS */ + +#else /* IEEEFLOAT */ + +#if SWAPBITS +#define DPS_DEF_TOKENTYPE DPS_LO_NATIVE +#else /* SWAPBITS */ +#define DPS_DEF_TOKENTYPE DPS_HI_NATIVE +#endif /* SWAPBITS */ + +#endif /* IEEEFLOAT */ + +#endif /* DPS_DEF_TOKENTYPE */ + + /* DPS_DEF_TOKENTYPE is the specification code for the form of binary + object sequences generated by PSWrap. The C code generated by pswrap + references this name. DPS_DEF_TOKENTYPE is system-dependent. */ + + +/* --- binary object sequence support --- */ + +/* Object attributes & types: Values for attributedTypes */ + +#define DPS_LITERAL 0 +#define DPS_EXEC 0x080 + + /* Attribute masks */ + + +#define DPS_NULL 0 +#define DPS_INT 1 +#define DPS_REAL 2 +#define DPS_NAME 3 +#define DPS_BOOL 4 +#define DPS_STRING 5 +#define DPS_IMMEDIATE 6 +#define DPS_ARRAY 9 +#define DPS_MARK 10 + + /* Type values */ + + +/* Object sequence constants */ + +#define DPS_HEADER_SIZE 4 +#define DPS_EXT_HEADER_SIZE 8 + + +/*=== TYPES ===*/ + +typedef enum { + dps_ascii, dps_binObjSeq, dps_encodedTokens + } DPSProgramEncoding; + /* Defines the 3 possible encodings of PostScript language programs. */ + +typedef enum { + dps_indexed, dps_strings + } DPSNameEncoding; + /* Defines the 2 possible encodings for user names in the + dps_binObjSeq and dps_encodedTokens forms of PostScript language + programs. */ + +typedef enum { + dps_tBoolean, + dps_tChar, dps_tUChar, + dps_tFloat, dps_tDouble, + dps_tShort, dps_tUShort, + dps_tInt, dps_tUInt, + dps_tLong, dps_tULong } DPSDefinedType; + +struct _t_DPSContextRec; + + /* Enumerates the C data types that can be used to describe wrap + parameters. */ + +typedef void (*DPSContextProc)( + struct _t_DPSContextRec *ctxt +); + +typedef void (*DPSContextBufProc)( + struct _t_DPSContextRec *ctxt, char *buf, + unsigned int count +); + +typedef void (*DPSContextTypedArrayProc)( + struct _t_DPSContextRec *ctxt, + DPSDefinedType type, + char *array, unsigned int length +); + +typedef void (*DPSWriteNumStringProc)( + struct _t_DPSContextRec *ctxt, + DPSDefinedType type, + const void *array, + unsigned int count, + int scale +); + +typedef struct { + DPSContextBufProc BinObjSeqWrite; + /* Begin a new binary object sequence. 'buf' contains 'count' + bytes of a binary object sequence. 'buf' must point to the + beginning of a sequence, which includes at least the header + and the entire top-level sequence of objects. It may also + include subsidiary array elements and/or string chars. + Writes PostScript language as specified by the + encoding variables of ctxt, doing appropriate conversions as + needed. 'buf' and its contents must remain valid until the + entire binary object sequence has been sent. */ + + DPSContextTypedArrayProc WriteTypedObjectArray; + /* 'array' points at an array of 'length' elements of 'type'. + 'array' contains the element values for the body of a subsidiary + array in a binary object sequence. Writes PostScript language + as specified by the 4 format and encoding variables of ctxt, doing + appropriate conversions as needed. 'array' and its contents must + remain valid until the entire binary object sequence has been sent */ + + DPSContextBufProc WriteStringChars; + /* Used both to implement DPSWritePostScript and to send the bodies of + strings in binary object sequences. 'buf' contains 'count' bytes. + For the latter, 'buf' and its contents must remain valid until the + entire binary object sequence has been sent.*/ + + DPSContextBufProc WriteData; + /* See DPSWriteData in dpsclient.h */ + + DPSContextBufProc WritePostScript; + /* See DPSWritePostScript in dpsclient.h */ + + DPSContextProc FlushContext; + /* See DPSFlushContext in dpsclient.h */ + + DPSContextProc ResetContext; + /* See DPSResetContext in dpsclient.h */ + + DPSContextProc UpdateNameMap; + /* This routine is called if the context's space's name map is + out-of-sync with that of the client library's name map. It may + send a series of "defineusername" commands to the service. */ + + DPSContextProc AwaitReturnValues; + /* Called to receive return values. + ctxt->resultTableLength and ctxt->resultTable must have been + set previously. Returns when all expected results are received. + + This is normally called from wraps. It is unusual for an application + program to call this directly. + + See the definitions of DPSResultsRec and DPSContextRec for more info. + */ + + DPSContextProc Interrupt; + /* See DPSInterrupt in dpsclient.h */ + + DPSContextProc DestroyContext; + /* See DPSDestroyContext in dpsclient.h */ + + DPSContextProc WaitContext; + /* See DPSWaitContext in dpsclient.h */ + + DPSWriteNumStringProc WriteNumString; + /* Write a number string, possibly marking it to be converted into + an array depending upon the context flags. */ + +} DPSProcsRec, *DPSProcs; + + /* The DPSProcsRec may be extended to include system-specific items */ + +struct _t_DPSSpaceRec; + +typedef void (*DPSSpaceProc)( + struct _t_DPSSpaceRec *space +); + +typedef struct { + DPSSpaceProc DestroySpace; + /* See DPSDestroySpace in dpsclient.h */ + +} DPSSpaceProcsRec, *DPSSpaceProcs; + + /* The DPSSpaceProcsRec may be extended to include system-specific items */ + +typedef struct { + DPSDefinedType type; + int count; + char *value; +} DPSResultsRec, *DPSResults; + + /* A DPSResultsRec defines one of the formal result args of a wrapped + procedure. The 'type' field specifies the formal type of the + return value. The 'count' field specifies the number of values + expected (this supports array formals). The 'value' field points + to the location of the first value; the storage beginning there + must have room for count values of type. If 'count' == -1, then + 'value' points to a scalar (single) result arg. */ + +typedef struct _t_DPSSpaceRec { + DPSSpaceProcs procs; +} DPSSpaceRec, *DPSSpace; + + /* A DPSSpaceRec provides a representation of a space. + + The DPSSpaceRec may be extended to include system-specific items. + + BEWARE an implementation of the DPS client library is also likely to + extend the DPSSpaceRec to include implementation-dependent information + in additional fields. */ + +typedef struct _t_DPSContextExtensionRec { + int extensionId; + struct _t_DPSContextExtensionRec *next; +} DPSContextExtensionRec; + +struct _t_DPSContextRec; + +typedef struct _t_DPSContextRec { + char *priv; + DPSSpace space; + DPSProgramEncoding programEncoding; + DPSNameEncoding nameEncoding; + DPSProcs procs; + void (*textProc)(struct _t_DPSContextRec *, char *, long unsigned); + void (*errorProc)(struct _t_DPSContextRec *, int, long unsigned, long unsigned); + DPSResults resultTable; + unsigned int resultTableLength; + struct _t_DPSContextRec *chainParent, *chainChild; + unsigned int contextFlags; + DPSContextExtensionRec *extension; +} DPSContextRec, *DPSContext; + + /* A DPSContextRec provides a representation of a context. + + The 'priv' field is provided for use by application code. It is + initialized to NULL and is not touched thereafter by the client + library implementation. + + The 'space' field is the space to which the context belongs. The + 'programEncoding' and 'nameEncoding' fields describe the encodings + preferred by the context (server). The values in these fields are + established when the DPSContext is created and cannot be changed + therafter. The 'procs' field points to a vector of procedures + (in a DPSProcsRec) that implement the context operations. + + The 'textProc' and 'errorProc' are called by the client library + implementation to dispose of ascii text and errors, respectively, that + the PostScript interpreter produces. + + The 'resultTableLength' and 'resultTable' fields define the number, type + and location of values expected back from the PostScript interpreter. + They should be set up before writing any PostScript language that + may return values. + + The chainParent field is non-NIL if this context automatically receives + a copy of any PostScript language sent to the referenced (parent) context. + + The chainChild field is non-NIL if this context automatically sends + a copy of any PostScript language it receives to the referenced (child) + context. + + The contextFlags parameter contains a set of bit flags. The bits 0-15 + are reserved for system-independent flags, bits 16-31 for + system-specific flags. + + The extension parameter points to a linked list of extension records + to allow toolkit to associate arbitrary data with contexts. + + NOTE the client library implementation extends the DPSContextRec to + include implementation-dependent information in additional fields. + + You may read the fields of a DPSContextRec directly, but you should + never modify them directly. Use the macros provided for that purpose. */ + +#define DPS_FLAG_SYNC 0x1 +#define DPS_FLAG_CONVERT_NUMSTRINGS 0x2 +#define DPS_FLAG_NO_BINARY_CONVERSION 0x4 +#define DPS_FLAG_USE_ABBREVS 0x8 + +/* -- binary object sequence support -- */ + +#define DPSSYSNAME 0x0FFFF /* unsigned rep. of -1 */ + +typedef struct { + unsigned char attributedType; + unsigned char tag; + unsigned short length; + int val; +} DPSBinObjGeneric; /* boolean, int, string, name and array */ + + +typedef struct { + unsigned char attributedType; + unsigned char tag; + unsigned short length; + float realVal; +} DPSBinObjReal; /* float */ + + +typedef struct { + unsigned char attributedType; + unsigned char tag; + unsigned short length; + union { + int integerVal; + float realVal; + int nameVal; /* offset or index */ + int booleanVal; + int stringVal; /* offset */ + int arrayVal; /* offset */ + } val; +} DPSBinObjRec, *DPSBinObj; + +typedef struct { + unsigned char tokenType; + unsigned char nTopElements; + unsigned short length; + DPSBinObjRec objects[1]; +} DPSBinObjSeqRec, *DPSBinObjSeq; + +typedef struct { + unsigned char tokenType; + unsigned char escape; /* zero if this is an extended sequence */ + unsigned short nTopElements; + unsigned length; + DPSBinObjRec objects[1]; +} DPSExtendedBinObjSeqRec, *DPSExtendedBinObjSeq; + +/*=== SYNCHRONIZATION MACRO ===*/ + +#ifndef NeXTSTEP +#define DPSSYNCHOOK(ctxt) \ + if ((ctxt)->contextFlags & DPS_FLAG_SYNC) DPSWaitContext(ctxt); +#endif /* NeXT */ + +/*=== PROCEDURES ===*/ + +#if defined(__cplusplus) || defined(c_plusplus) +extern "C" { +#endif + +extern void DPSAwaitReturnValues(DPSContext ctxt); + +extern void DPSUpdateNameMap(DPSContext ctxt); + +extern void DPSBinObjSeqWrite(DPSContext ctxt, char *buf, unsigned int count); + +extern DPSContext DPSPrivCurrentContext(void); + +extern void DPSWriteStringChars(DPSContext ctxt, char *buf, + unsigned int count); + +extern void DPSWriteNumString(DPSContext ctxt, DPSDefinedType type, + char *data, unsigned int size, int scale); + +extern void DPSWriteTypedObjectArray(DPSContext ctxt, DPSDefinedType type, + char *array, unsigned int length); + +extern void DPSSetResultTable(DPSContext ctxt, DPSResults tbl, + unsigned int len); + + +/* Support for user names */ + +extern void DPSMapNames(DPSContext ctxt, unsigned int nNames, char **names, + int **indices); + + /* This routine assigns indices to the given user names. It is + called once for each wrapped procedure. The parameters 'nNames' and + 'names' define an array of strings which are the user names. The + parameter 'indices' is an array of (int *) which are the locations + in which to store the indices. The caller must ensure that the string + pointers remain valid after the return. + + As a storage optimization, DPSMapNames will interpret a NIL + value in the names array as the previous valid string in + the name array. Effectively, if names[n] == NIL, DPSMapNames + will decrement n until names[] is non-NIL and use that string. + names[0] must be non-NIL. */ + +extern char *DPSNameFromIndex(long int index); + + /* This routine returns the text for the user name with the given index. + The string returned is owned by the library (treat it as readonly). */ + +extern DPSContextExtensionRec *DPSGetContextExtensionRec(DPSContext ctxt, + int extensionId); + + /* This procedure finds the context extension record with the given id */ + +extern void DPSAddContextExtensionRec(DPSContext ctxt, + DPSContextExtensionRec *rec); + + /* This procedure adds a context extension record */ + +extern DPSContextExtensionRec *DPSRemoveContextExtensionRec(DPSContext ctxt, + int extensionId); + + /* This procedure removes a context extension record */ + +extern int DPSGenerateExtensionRecID(void); + + /* This procedure generates a unique extension record id. */ + +extern void DPSWaitContext(DPSContext ctxt); + + /* Waits until the PostScript interpreter is ready for more input to + this context. This is useful for synchronizing an application + with the DPS server. + + If 'ctxt' represents an invalid context, for example because + the context has terminated in the server, the dps_err_invalidContext + error will be reported via ctxt's error proc. */ + +#if defined(__cplusplus) || defined(c_plusplus) +} +#endif + +#endif /* DPSFRIENDS_H */ |