如何在Linux下用C语言画图?

lonalpha

我想画一些函数的图像，Linux下可不可以像Turbo C下仅仅调用一些库函数来完成。

linuxahah

/usr/include/curses.h

elais

用这个比较痛苦的

gamedragon

LZ不要把Linux当DOS啊
看看framebuffer的东西，可能回有点帮助

lonalpha

我只想在Linux下用最简单的办法完成我想要做的事情，不想学太多新的东西。
谢谢楼上的建议。curses.h是处理字符的，画图不太方便。有更好的办法吗？

弥敦路九号

framebuffer 编程

pointer

好像得学一个图形库的

建议学OpenGL.

ideawu

摘自：http://users.actcom.co.il/%7Echo ... rogramming/events.c
也许对你有帮助。
编绎方法：cc events.c -o event -L/usr/X11R6/lib -lX11
运行方法：在X下
在Debian3下测试通过。

2. /*
3. * events.c - demonstrate handling of X events using an events loop.
4. */
6. #include <X11/Xlib.h>
8. #include <stdio.h>
9. #include <stdlib.h>                /* getenv(), etc. */
11. /*
12. * function: create_simple_window. Creates a window with a white background
13. *           in the given size.
14. * input:    display, size of the window (in pixels), and location of the window
15. *           (in pixels).
16. * output:   the window's ID.
17. * notes:    window is created with a black border, 2 pixels wide.
18. *           the window is automatically mapped after its creation.
19. */
20. Window
21. create_simple_window(Display* display, int width, int height, int x, int y)
22. {
23.   int screen_num = DefaultScreen(display);
24.   int win_border_width = 2;
25.   Window win;
27.   /* create a simple window, as a direct child of the screen's */
28.   /* root window. Use the screen's black and white colors as   */
29.   /* the foreground and background colors of the window,       */
30.   /* respectively. Place the new window's top-left corner at   */
31.   /* the given 'x,y' coordinates.                              */
32.   win = XCreateSimpleWindow(display, RootWindow(display, screen_num),
33.                             x, y, width, height, win_border_width,
34.                             BlackPixel(display, screen_num),
35.                             WhitePixel(display, screen_num));
37.   /* make the window actually appear on the screen. */
38.   XMapWindow(display, win);
40.   /* flush all pending requests to the X server. */
41.   XFlush(display);
43.   return win;
44. }
46. GC
47. create_gc(Display* display, Window win, int reverse_video)
48. {
49.   GC gc;                                /* handle of newly created GC.  */
50.   unsigned long valuemask = 0;                /* which values in 'values' to  */
51.                                         /* check when creating the GC.  */
52.   XGCValues values;                        /* initial values for the GC.   */
53.   unsigned int line_width = 2;                /* line width for the GC.       */
54.   int line_style = LineSolid;                /* style for lines drawing and  */
55.   int cap_style = CapButt;                /* style of the line's edje and */
56.   int join_style = JoinBevel;                /*  joined lines.                */
57.   int screen_num = DefaultScreen(display);
59.   gc = XCreateGC(display, win, valuemask, &values);
60.   if (gc < 0) {
61.         fprintf(stderr, "XCreateGC: \n");
62.   }
64.   /* allocate foreground and background colors for this GC. */
65.   if (reverse_video) {
66.     XSetForeground(display, gc, WhitePixel(display, screen_num));
67.     XSetBackground(display, gc, BlackPixel(display, screen_num));
68.   }
69.   else {
70.     XSetForeground(display, gc, BlackPixel(display, screen_num));
71.     XSetBackground(display, gc, WhitePixel(display, screen_num));
72.   }
74.   /* define the style of lines that will be drawn using this GC. */
75.   XSetLineAttributes(display, gc,
76.                      line_width, line_style, cap_style, join_style);
78.   /* define the fill style for the GC. to be 'solid filling'. */
79.   XSetFillStyle(display, gc, FillSolid);
81.   return gc;
82. }
84. /*
85. * function: handle_expose. handles an Expose event by redrawing the window.
86. * input:    display, 2 GCs, XExposeEvent event structure, dimensions of
87. *           the window, pixels array.
88. * output:   none.
89. */
90. void
91. handle_expose(Display* display, GC gc, GC rev_gc, XExposeEvent* expose_event,
92.               unsigned int win_width, unsigned int win_height,
93.               short pixels[1000][1000])
94. {
95.   /* if this is the first in a set of expose events - ignore this event. */
96.   if (expose_event->count != 0)
97.     return;
98.   /* draw the contents of our window. */
100.   /* draw one pixel near each corner of the window */
101.   XDrawPoint(display, expose_event->window, gc, 5, 5);
102.   XDrawPoint(display, expose_event->window, gc, 5, win_height-5);
103.   XDrawPoint(display, expose_event->window, gc, win_width-5, 5);
104.   XDrawPoint(display, expose_event->window, gc, win_width-5, win_height-5);
106.   /* draw two intersecting lines, one horizontal and one vertical, */
107.   /* which intersect at point "50,100".                            */
108.   XDrawLine(display, expose_event->window, gc, 50, 0, 50, 200);
109.   XDrawLine(display, expose_event->window, gc, 0, 100, 200, 100);
111.   /* now use the XDrawArc() function to draw a circle whose diameter */
112.   /* is 30 pixels, and whose center is at location '50,100'.         */
113.   XDrawArc(display, expose_event->window, gc,
114.            50-(30/2), 100-(30/2), 30, 30, 0, 360*64);
116.   {
117.     XPoint points[] = {
118.       {0, 0},
119.       {15, 15},
120.       {0, 15},
121.       {0, 0}
122.     };
123.     int npoints = sizeof(points)/sizeof(XPoint);
125.     /* draw a small triangle at the top-left corner of the window. */
126.     /* the triangle is made of a set of consecutive lines, whose   */
127.     /* end-point pixels are specified in the 'points' array.       */
128.     XDrawLines(display, expose_event->window, gc,
129.                points, npoints, CoordModeOrigin);
130.   }
132.   /* draw a rectangle whose top-left corner is at '120,150', its width is */
133.   /* 50 pixels, and height is 60 pixels.                                  */
134.   XDrawRectangle(display, expose_event->window, gc, 120, 150, 50, 60);
136.   /* draw a filled rectangle of the same size as above, to the left of the */
137.   /* previous rectangle.                                                   */
138.   XFillRectangle(display, expose_event->window, gc, 60, 150, 50, 60);
140.   /* finally, draw all the pixels in the 'pixels' array. */
141.   {
142.     int x, y;
143.     for (x=0; x<win_width; x++)
144.       for (y=0; y<win_height; y++)
145.         switch(pixels[x][y]) {
146.           case 1: /* draw point. */
147.             XDrawPoint(display, expose_event->window, gc, x, y);
148.             break;
149.           case -1: /* erase point. */
150.             XDrawPoint(display, expose_event->window, rev_gc, x, y);
151.             break;
152.         }
153.   }
154. }
156. /*
157. * function: handle_drag. handles a Mouse drag event - if the left button
158. *           is depressed - draws the pixel below the mouse pointer. if the
159. *           middle button is depressed - erases the pixel below the mouse
160. *           pointer.
161. * input:    display, 2 GCs, XButtonEvent event structure, dimensions of
162. *           the window, pixels array.
163. * output:   none.
164. */
165. void
166. handle_drag(Display* display, GC gc, GC rev_gc, XButtonEvent* drag_event,
167.             unsigned int win_width, unsigned int win_height,
168.             short pixels[1000][1000])
169. {
170.   int x, y;
172.   /* invert the pixel under the mouse. */
173.   x = drag_event->x;
174.   y = drag_event->y;
175.   switch (drag_event->state) {
176.     case Button1Mask: /* draw the given pixel in black color. */
177.       XDrawPoint(display, drag_event->window, gc, x, y);
178.       pixels[x][y] = 1;
179.       break;
180.     case Button2Mask: /* draw the given pixel in white color. */
181.       XDrawPoint(display, drag_event->window, rev_gc, x, y);
182.       pixels[x][y] = -1;
183.       break;
184.   }
185. }
187. /*
188. * function: handle_button_down. handles a Mouse press event - if the left
189. *           button is depressed - draws the pixel below the mouse pointer.
190. *           if the middle button is depressed - erases the pixel below the
191. *           mouse pointer.
192. * input:    display, 2 GCs, XButtonEvent event structure, dimensions of
193. *           the window, pixels array.
194. * output:   none.
195. */
196. void
197. handle_button_down(Display* display, GC gc, GC rev_gc,
198.                    XButtonEvent* button_event,
199.                    unsigned int win_width, unsigned int win_height,
200.                    short pixels[1000][1000])
201. {
202.   int x, y;
204.   /* invert the pixel under the mouse. */
205.   x = button_event->x;
206.   y = button_event->y;
207.   switch (button_event->button) {
208.     case Button1: /* draw the given pixel in black color. */
209.       XDrawPoint(display, button_event->window, gc, x, y);
210.       pixels[x][y] = 1;
211.       break;
212.     case Button2: /* draw the given pixel in white color. */
213.       XDrawPoint(display, button_event->window, rev_gc, x, y);
214.       pixels[x][y] = -1;
215.       break;
216.   }
217. }
219. void
220. main(int argc, char* argv[])
221. {
222.   Display* display;                /* pointer to X Display structure.           */
223.   int screen_num;                /* number of screen to place the window on.  */
224.   Window win;                        /* pointer to the newly created window.      */
225.   unsigned int display_width,
226.                display_height;        /* height and width of the X display.        */
227.   unsigned int width, height;        /* height and width for the new window.      */
228.   char *display_name = getenv("DISPLAY");  /* address of the X display.      */
229.   GC gc, rev_gc;                /* GC (graphics context) used for drawing    */
230.                                 /*  in our window.                             */
231.   short pixels[1000][1000];        /* used to store pixels on screen that were  */
232.                                 /* explicitly drawn or erased by the user.   */
234.   /* initialize the 'pixels' array to contain 0 values. */
235.   {
236.     int x, y;
237.     for (x=0; x<1000; x++)
238.       for (y=0; y<1000; y++)
239.         pixels[x][y] = 0;
240.   }
242.   /* open connection with the X server. */
243.   display = XOpenDisplay(display_name);
244.   if (display == NULL) {
245.     fprintf(stderr, "%s: cannot connect to X server '%s'\n",
246.             argv[0], display_name);
247.     exit(1);
248.   }
250.   /* get the geometry of the default screen for our display. */
251.   screen_num = DefaultScreen(display);
252.   display_width = DisplayWidth(display, screen_num);
253.   display_height = DisplayHeight(display, screen_num);
255.   /* make the new window occupy 1/9 of the screen's size. */
256.   width = (display_width / 3);
257.   height = (display_height / 3);
258.   printf("window width - '%d'; height - '%d'\n", width, height);
260.   /* create a simple window, as a direct child of the screen's   */
261.   /* root window. Use the screen's white color as the background */
262.   /* color of the window. Place the new window's top-left corner */
263.   /* at the given 'x,y' coordinates.                             */
264.   win = create_simple_window(display, width, height, 0, 0);
266.   /* allocate two new GCs (graphics contexts) for drawing in the window. */
267.   /* the first is used for drawing black over white, the second is used  */
268.   /* for drawing white over black.                                       */
269.   gc = create_gc(display, win, 0);
270.   rev_gc = create_gc(display, win, 1);
272.   /* subscribe to the given set of event types. */
273.   XSelectInput(display, win, ExposureMask | KeyPressMask |
274.                      ButtonPressMask | Button1MotionMask |
275.                      Button2MotionMask | StructureNotifyMask);
277.   /* perform an events loop */
278.   {
279.     int done = 0;
280.     XEvent an_event;
281.     while (!done) {
282.       XNextEvent(display, &an_event);
283.       switch (an_event.type) {
284.         case Expose:
285.           /* redraw our window. */
286.           handle_expose(display, gc, rev_gc, (XExposeEvent*)&an_event.xexpose,
287.                              width, height, pixels);
288.           break;
289.   
290.         case ConfigureNotify:
291.           /* update the size of our window, for expose events. */
292.           width = an_event.xconfigure.width;
293.           height = an_event.xconfigure.height;
294.           break;
295.   
296.         case ButtonPress:
297.           /* invert the pixel under the mouse pointer. */
298.           handle_button_down(display, gc, rev_gc,
299.                              (XButtonEvent*)&an_event.xbutton,
300.                              width, height, pixels);
301.           break;
302.   
303.         case MotionNotify:
304.           /* invert the pixel under the mouse pointer. */
305.           handle_drag(display, gc, rev_gc,
306.                       (XButtonEvent*)&an_event.xbutton,
307.                       width, height, pixels);
308.           break;
309.   
310.         case KeyPress:
311.           /* exit the application by braking out of the events loop. */
312.           done = 1;
313.           break;
314.   
315.         default: /* ignore any other event types. */
316.           break;
317.       } /* end switch on event type */
318.     } /* end while events handling */
319.   }
321.   /* free the GCs. */
322.   XFreeGC(display, gc);
323.   XFreeGC(display, rev_gc);
325.   /* close the connection to the X server. */
326.   XCloseDisplay(display);
327. }

复制代码