mirror of
https://github.com/fltk/fltk.git
synced 2026-06-05 08:06:35 +08:00
Removing Xlib rect calls from public view.
git-svn-id: file:///fltk/svn/fltk/branches/branch-1.3-porting@11028 ea41ed52-d2ee-0310-a9c1-e6b18d33e121
This commit is contained in:
Matthias Melcher
+6
-56
@@ -419,6 +419,7 @@ protected:
|
||||
};
|
||||
|
||||
|
||||
|
||||
#if defined(__APPLE__)
|
||||
|
||||
// FIXME: add Fl_Quartz_Printer_Graphics_Driver
|
||||
@@ -456,65 +457,14 @@ protected:
|
||||
|
||||
#else // X11
|
||||
|
||||
/**
|
||||
\brief The Xlib-specific graphics class.
|
||||
*
|
||||
This class is implemented only on the Xlib platform.
|
||||
*/
|
||||
class FL_EXPORT Fl_Xlib_Graphics_Driver : public Fl_Graphics_Driver {
|
||||
public:
|
||||
static const char *class_id;
|
||||
const char *class_name() {return class_id;};
|
||||
void color(Fl_Color c);
|
||||
void color(uchar r, uchar g, uchar b);
|
||||
void draw(const char* str, int n, int x, int y);
|
||||
void draw(int angle, const char *str, int n, int x, int y);
|
||||
void rtl_draw(const char* str, int n, int x, int y);
|
||||
void font(Fl_Font face, Fl_Fontsize size);
|
||||
void draw(Fl_Pixmap *pxm, int XP, int YP, int WP, int HP, int cx, int cy);
|
||||
void draw(Fl_Bitmap *pxm, int XP, int YP, int WP, int HP, int cx, int cy);
|
||||
void draw(Fl_RGB_Image *img, int XP, int YP, int WP, int HP, int cx, int cy);
|
||||
void draw_image(const uchar* buf, int X,int Y,int W,int H, int D=3, int L=0);
|
||||
void draw_image(Fl_Draw_Image_Cb cb, void* data, int X,int Y,int W,int H, int D=3);
|
||||
void draw_image_mono(const uchar* buf, int X,int Y,int W,int H, int D=1, int L=0);
|
||||
void draw_image_mono(Fl_Draw_Image_Cb cb, void* data, int X,int Y,int W,int H, int D=1);
|
||||
double width(const char *str, int n);
|
||||
double width(unsigned int c);
|
||||
void text_extents(const char*, int n, int& dx, int& dy, int& w, int& h);
|
||||
int height();
|
||||
int descent();
|
||||
void copy_offscreen(int x, int y, int w, int h, Fl_Offscreen pixmap, int srcx, int srcy);
|
||||
#if ! defined(FL_DOXYGEN)
|
||||
void copy_offscreen_with_alpha(int x, int y, int w, int h, Fl_Offscreen pixmap, int srcx, int srcy);
|
||||
#endif
|
||||
protected:
|
||||
// --- implementation is in src/fl_rect.cxx which includes src/cfg_gfx/xlib_rect.cxx
|
||||
void point(int x, int y);
|
||||
void rect(int x, int y, int w, int h);
|
||||
void rectf(int x, int y, int w, int h);
|
||||
void line(int x, int y, int x1, int y1);
|
||||
void line(int x, int y, int x1, int y1, int x2, int y2);
|
||||
void xyline(int x, int y, int x1);
|
||||
void xyline(int x, int y, int x1, int y2);
|
||||
void xyline(int x, int y, int x1, int y2, int x3);
|
||||
void yxline(int x, int y, int y1);
|
||||
void yxline(int x, int y, int y1, int x2);
|
||||
void yxline(int x, int y, int y1, int x2, int y3);
|
||||
void loop(int x0, int y0, int x1, int y1, int x2, int y2);
|
||||
void loop(int x0, int y0, int x1, int y1, int x2, int y2, int x3, int y3);
|
||||
void polygon(int x0, int y0, int x1, int y1, int x2, int y2);
|
||||
void polygon(int x0, int y0, int x1, int y1, int x2, int y2, int x3, int y3);
|
||||
// --- clipping
|
||||
void push_clip(int x, int y, int w, int h);
|
||||
int clip_box(int x, int y, int w, int h, int &X, int &Y, int &W, int &H);
|
||||
int not_clipped(int x, int y, int w, int h);
|
||||
void push_no_clip();
|
||||
void pop_clip();
|
||||
void restore_clip();
|
||||
};
|
||||
// FIXME: it should not be required to include this file here. This is nothing that the user should have access to.
|
||||
#include "src/cfg_gfx/xlib.H"
|
||||
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
/**
|
||||
A drawing surface that's susceptible to receive graphical output.
|
||||
Any FLTK application has at any time a current drawing surface to which all drawing requests are directed.
|
||||
|
||||
@@ -27,7 +27,7 @@
|
||||
*/
|
||||
|
||||
|
||||
#include "quartz.h"
|
||||
#include "quartz.H"
|
||||
|
||||
|
||||
extern float fl_quartz_line_width_;
|
||||
|
||||
+6
-548
File diff suppressed because it is too large
Load Diff
+9
-530
File diff suppressed because it is too large
Load Diff
+4
-301
@@ -106,314 +106,17 @@ Fl_Region Fl_Graphics_Driver::clip_region() {
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
// -----------------------------------------------------------------------------
|
||||
|
||||
|
||||
#ifdef FL_CFG_GFX_XLIB
|
||||
|
||||
#ifndef SHRT_MAX
|
||||
#define SHRT_MAX (32767)
|
||||
#endif
|
||||
|
||||
/*
|
||||
We need to check some coordinates for areas for clipping before we
|
||||
use X functions, because X can't handle coordinates outside the 16-bit
|
||||
range. Since all windows use relative coordinates > 0, we do also
|
||||
check for negative values. X11 only, see also STR #2304.
|
||||
|
||||
Note that this is only necessary for large objects, where only a
|
||||
part of the object is visible. The draw() functions (e.g. box
|
||||
drawing) must be clipped correctly. This is usually only a matter
|
||||
for large container widgets. The individual child widgets will be
|
||||
clipped completely.
|
||||
|
||||
We define the usable X coordinate space as [ -LW : SHRT_MAX - LW ]
|
||||
where LW = current line width for drawing. This is done so that
|
||||
horizontal and vertical line drawing works correctly, even in real
|
||||
border cases, e.g. drawing a rectangle slightly outside the top left
|
||||
window corner, but with a line width so that a part of the line should
|
||||
be visible (in this case 2 of 5 pixels):
|
||||
|
||||
fl_line_style (FL_SOLID,5); // line width = 5
|
||||
fl_rect (-1,-1,100,100); // top/left: 2 pixels visible
|
||||
|
||||
In this example case, no clipping would be done, because X can
|
||||
handle it and clip unneeded pixels.
|
||||
|
||||
Note that we must also take care of the case where fl_line_width_
|
||||
is zero (maybe unitialized). If this is the case, we assume a line
|
||||
width of 1.
|
||||
|
||||
Todo: Arbitrary line drawings (e.g. polygons) and clip regions
|
||||
are not yet done.
|
||||
|
||||
Note:
|
||||
|
||||
We could use max. screen coordinates instead of SHRT_MAX, but that
|
||||
would need more work and would probably be slower. We assume that
|
||||
all window coordinates are >= 0 and that no window extends up to
|
||||
32767 - LW (where LW = current line width). Thus it is safe to clip
|
||||
all coordinates to this range before calling X functions. If this
|
||||
is not true, then clip_to_short() and clip_x() must be redefined.
|
||||
|
||||
It would be somewhat easier if we had fl_clip_w and fl_clip_h, as
|
||||
defined in FLTK 2.0 (for the upper clipping bounds)...
|
||||
*/
|
||||
|
||||
/*
|
||||
clip_to_short() returns 1, if the area is invisible (clipped),
|
||||
because ...
|
||||
|
||||
(a) w or h are <= 0 i.e. nothing is visible
|
||||
(b) x+w or y+h are < kmin i.e. left of or above visible area
|
||||
(c) x or y are > kmax i.e. right of or below visible area
|
||||
|
||||
kmin and kmax are the minimal and maximal X coordinate values,
|
||||
as defined above. In this case x, y, w, and h are not changed.
|
||||
|
||||
It returns 0, if the area is potentially visible and X can handle
|
||||
clipping. x, y, w, and h may have been adjusted to fit into the
|
||||
X coordinate space.
|
||||
|
||||
Use this for clipping rectangles, as used in fl_rect() and
|
||||
fl_rectf().
|
||||
*/
|
||||
static int clip_to_short(int &x, int &y, int &w, int &h) {
|
||||
|
||||
int lw = (fl_line_width_ > 0) ? fl_line_width_ : 1;
|
||||
int kmin = -lw;
|
||||
int kmax = SHRT_MAX - lw;
|
||||
|
||||
if (w <= 0 || h <= 0) return 1; // (a)
|
||||
if (x+w < kmin || y+h < kmin) return 1; // (b)
|
||||
if (x > kmax || y > kmax) return 1; // (c)
|
||||
|
||||
if (x < kmin) { w -= (kmin-x); x = kmin; }
|
||||
if (y < kmin) { h -= (kmin-y); y = kmin; }
|
||||
if (x+w > kmax) w = kmax - x;
|
||||
if (y+h > kmax) h = kmax - y;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*
|
||||
clip_x() returns a coordinate value clipped to the 16-bit coordinate
|
||||
space (see above). This can be used to draw horizontal and vertical
|
||||
lines that can be handled by X11. Each single coordinate value can
|
||||
be clipped individually, and the result can be used directly, e.g.
|
||||
in fl_xyline() and fl_yxline(). Note that this can't be used for
|
||||
arbitrary lines (not horizontal or vertical).
|
||||
*/
|
||||
static int clip_x (int x) {
|
||||
|
||||
int lw = (fl_line_width_ > 0) ? fl_line_width_ : 1;
|
||||
int kmin = -lw;
|
||||
int kmax = SHRT_MAX - lw;
|
||||
|
||||
if (x < kmin)
|
||||
x = kmin;
|
||||
else if (x > kmax)
|
||||
x = kmax;
|
||||
return x;
|
||||
}
|
||||
|
||||
// Missing X call: (is this the fastest way to init a 1-rectangle region?)
|
||||
// MSWindows equivalent exists, implemented inline in win32.H
|
||||
Fl_Region XRectangleRegion(int x, int y, int w, int h) {
|
||||
XRectangle R;
|
||||
clip_to_short(x, y, w, h);
|
||||
R.x = x; R.y = y; R.width = w; R.height = h;
|
||||
Fl_Region r = XCreateRegion();
|
||||
XUnionRectWithRegion(&R, r, r);
|
||||
return r;
|
||||
}
|
||||
|
||||
// --- line and polygon drawing with integer coordinates
|
||||
|
||||
void Fl_Xlib_Graphics_Driver::point(int x, int y) {
|
||||
XDrawPoint(fl_display, fl_window, fl_gc, clip_x(x), clip_x(y));
|
||||
}
|
||||
|
||||
void Fl_Xlib_Graphics_Driver::rect(int x, int y, int w, int h) {
|
||||
if (w<=0 || h<=0) return;
|
||||
if (!clip_to_short(x, y, w, h))
|
||||
XDrawRectangle(fl_display, fl_window, fl_gc, x, y, w-1, h-1);
|
||||
}
|
||||
|
||||
void Fl_Xlib_Graphics_Driver::rectf(int x, int y, int w, int h) {
|
||||
if (w<=0 || h<=0) return;
|
||||
if (!clip_to_short(x, y, w, h))
|
||||
XFillRectangle(fl_display, fl_window, fl_gc, x, y, w, h);
|
||||
}
|
||||
|
||||
void Fl_Xlib_Graphics_Driver::line(int x, int y, int x1, int y1) {
|
||||
XDrawLine(fl_display, fl_window, fl_gc, x, y, x1, y1);
|
||||
}
|
||||
|
||||
void Fl_Xlib_Graphics_Driver::line(int x, int y, int x1, int y1, int x2, int y2) {
|
||||
XPoint p[3];
|
||||
p[0].x = x; p[0].y = y;
|
||||
p[1].x = x1; p[1].y = y1;
|
||||
p[2].x = x2; p[2].y = y2;
|
||||
XDrawLines(fl_display, fl_window, fl_gc, p, 3, 0);
|
||||
}
|
||||
|
||||
void Fl_Xlib_Graphics_Driver::xyline(int x, int y, int x1) {
|
||||
XDrawLine(fl_display, fl_window, fl_gc, clip_x(x), clip_x(y), clip_x(x1), clip_x(y));
|
||||
}
|
||||
|
||||
void Fl_Xlib_Graphics_Driver::xyline(int x, int y, int x1, int y2) {
|
||||
XPoint p[3];
|
||||
p[0].x = clip_x(x); p[0].y = p[1].y = clip_x(y);
|
||||
p[1].x = p[2].x = clip_x(x1); p[2].y = clip_x(y2);
|
||||
XDrawLines(fl_display, fl_window, fl_gc, p, 3, 0);
|
||||
}
|
||||
|
||||
void Fl_Xlib_Graphics_Driver::xyline(int x, int y, int x1, int y2, int x3) {
|
||||
XPoint p[4];
|
||||
p[0].x = clip_x(x); p[0].y = p[1].y = clip_x(y);
|
||||
p[1].x = p[2].x = clip_x(x1); p[2].y = p[3].y = clip_x(y2);
|
||||
p[3].x = clip_x(x3);
|
||||
XDrawLines(fl_display, fl_window, fl_gc, p, 4, 0);
|
||||
}
|
||||
|
||||
void Fl_Xlib_Graphics_Driver::yxline(int x, int y, int y1) {
|
||||
XDrawLine(fl_display, fl_window, fl_gc, clip_x(x), clip_x(y), clip_x(x), clip_x(y1));
|
||||
}
|
||||
|
||||
void Fl_Xlib_Graphics_Driver::yxline(int x, int y, int y1, int x2) {
|
||||
XPoint p[3];
|
||||
p[0].x = p[1].x = clip_x(x); p[0].y = clip_x(y);
|
||||
p[1].y = p[2].y = clip_x(y1); p[2].x = clip_x(x2);
|
||||
XDrawLines(fl_display, fl_window, fl_gc, p, 3, 0);
|
||||
}
|
||||
|
||||
void Fl_Xlib_Graphics_Driver::yxline(int x, int y, int y1, int x2, int y3) {
|
||||
XPoint p[4];
|
||||
p[0].x = p[1].x = clip_x(x); p[0].y = clip_x(y);
|
||||
p[1].y = p[2].y = clip_x(y1); p[2].x = p[3].x = clip_x(x2);
|
||||
p[3].y = clip_x(y3);
|
||||
XDrawLines(fl_display, fl_window, fl_gc, p, 4, 0);
|
||||
}
|
||||
|
||||
void Fl_Xlib_Graphics_Driver::loop(int x, int y, int x1, int y1, int x2, int y2) {
|
||||
XPoint p[4];
|
||||
p[0].x = x; p[0].y = y;
|
||||
p[1].x = x1; p[1].y = y1;
|
||||
p[2].x = x2; p[2].y = y2;
|
||||
p[3].x = x; p[3].y = y;
|
||||
XDrawLines(fl_display, fl_window, fl_gc, p, 4, 0);
|
||||
}
|
||||
|
||||
void Fl_Xlib_Graphics_Driver::loop(int x, int y, int x1, int y1, int x2, int y2, int x3, int y3) {
|
||||
XPoint p[5];
|
||||
p[0].x = x; p[0].y = y;
|
||||
p[1].x = x1; p[1].y = y1;
|
||||
p[2].x = x2; p[2].y = y2;
|
||||
p[3].x = x3; p[3].y = y3;
|
||||
p[4].x = x; p[4].y = y;
|
||||
XDrawLines(fl_display, fl_window, fl_gc, p, 5, 0);
|
||||
}
|
||||
|
||||
void Fl_Xlib_Graphics_Driver::polygon(int x, int y, int x1, int y1, int x2, int y2) {
|
||||
XPoint p[4];
|
||||
p[0].x = x; p[0].y = y;
|
||||
p[1].x = x1; p[1].y = y1;
|
||||
p[2].x = x2; p[2].y = y2;
|
||||
p[3].x = x; p[3].y = y;
|
||||
XFillPolygon(fl_display, fl_window, fl_gc, p, 3, Convex, 0);
|
||||
XDrawLines(fl_display, fl_window, fl_gc, p, 4, 0);
|
||||
}
|
||||
|
||||
void Fl_Xlib_Graphics_Driver::polygon(int x, int y, int x1, int y1, int x2, int y2, int x3, int y3) {
|
||||
XPoint p[5];
|
||||
p[0].x = x; p[0].y = y;
|
||||
p[1].x = x1; p[1].y = y1;
|
||||
p[2].x = x2; p[2].y = y2;
|
||||
p[3].x = x3; p[3].y = y3;
|
||||
p[4].x = x; p[4].y = y;
|
||||
XFillPolygon(fl_display, fl_window, fl_gc, p, 4, Convex, 0);
|
||||
XDrawLines(fl_display, fl_window, fl_gc, p, 5, 0);
|
||||
}
|
||||
|
||||
// --- clipping
|
||||
|
||||
void Fl_Xlib_Graphics_Driver::push_clip(int x, int y, int w, int h) {
|
||||
Fl_Region r;
|
||||
if (w > 0 && h > 0) {
|
||||
r = XRectangleRegion(x,y,w,h);
|
||||
Fl_Region current = rstack[rstackptr];
|
||||
if (current) {
|
||||
Fl_Region temp = XCreateRegion();
|
||||
XIntersectRegion(current, r, temp);
|
||||
XDestroyRegion(r);
|
||||
r = temp;
|
||||
}
|
||||
} else { // make empty clip region:
|
||||
r = XCreateRegion();
|
||||
}
|
||||
if (rstackptr < region_stack_max) rstack[++rstackptr] = r;
|
||||
else Fl::warning("Fl_Xlib_Graphics_Driver::push_clip: clip stack overflow!\n");
|
||||
fl_restore_clip();
|
||||
}
|
||||
|
||||
int Fl_Xlib_Graphics_Driver::clip_box(int x, int y, int w, int h, int& X, int& Y, int& W, int& H){
|
||||
X = x; Y = y; W = w; H = h;
|
||||
Fl_Region r = rstack[rstackptr];
|
||||
if (!r) return 0;
|
||||
switch (XRectInRegion(r, x, y, w, h)) {
|
||||
case 0: // completely outside
|
||||
W = H = 0;
|
||||
return 2;
|
||||
case 1: // completely inside:
|
||||
return 0;
|
||||
default: // partial:
|
||||
break;
|
||||
}
|
||||
Fl_Region rr = XRectangleRegion(x,y,w,h);
|
||||
Fl_Region temp = XCreateRegion();
|
||||
XIntersectRegion(r, rr, temp);
|
||||
XRectangle rect;
|
||||
XClipBox(temp, &rect);
|
||||
X = rect.x; Y = rect.y; W = rect.width; H = rect.height;
|
||||
XDestroyRegion(temp);
|
||||
XDestroyRegion(rr);
|
||||
return 1;
|
||||
}
|
||||
|
||||
int Fl_Xlib_Graphics_Driver::not_clipped(int x, int y, int w, int h) {
|
||||
if (x+w <= 0 || y+h <= 0) return 0;
|
||||
Fl_Region r = rstack[rstackptr];
|
||||
if (!r) return 1;
|
||||
// get rid of coordinates outside the 16-bit range the X calls take.
|
||||
if (clip_to_short(x,y,w,h)) return 0; // clipped
|
||||
return XRectInRegion(r, x, y, w, h);
|
||||
}
|
||||
|
||||
// make there be no clip (used by fl_begin_offscreen() only!)
|
||||
void Fl_Xlib_Graphics_Driver::push_no_clip() {
|
||||
if (rstackptr < region_stack_max) rstack[++rstackptr] = 0;
|
||||
else Fl::warning("fl_push_no_cFl_Xlib_Graphics_Driver::push_no_cliplip: clip stack overflow!\n");
|
||||
fl_restore_clip();
|
||||
}
|
||||
|
||||
// pop back to previous clip:
|
||||
void Fl_Xlib_Graphics_Driver::pop_clip() {
|
||||
if (rstackptr > 0) {
|
||||
Fl_Region oldr = rstack[rstackptr--];
|
||||
if (oldr) XDestroyRegion(oldr);
|
||||
} else Fl::warning("Fl_Xlib_Graphics_Driver::pop_clip: clip stack underflow!\n");
|
||||
fl_restore_clip();
|
||||
}
|
||||
|
||||
void Fl_Xlib_Graphics_Driver::restore_clip() {
|
||||
fl_clip_state_number++;
|
||||
Fl_Region r = rstack[rstackptr];
|
||||
if (r) XSetRegion(fl_display, fl_gc, r);
|
||||
else XSetClipMask(fl_display, fl_gc, 0);
|
||||
}
|
||||
# include "cfg_gfx/xlib_rect.cxx"
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
//
|
||||
// End of "$Id$".
|
||||
//
|
||||
|
||||
Reference in New Issue
Block a user