Cleanup: style, use braces for editors
[blender.git] / source / blender / editors / space_info / textview.c
1 /*
2  * This program is free software; you can redistribute it and/or
3  * modify it under the terms of the GNU General Public License
4  * as published by the Free Software Foundation; either version 2
5  * of the License, or (at your option) any later version.
6  *
7  * This program is distributed in the hope that it will be useful,
8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10  * GNU General Public License for more details.
11  *
12  * You should have received a copy of the GNU General Public License
13  * along with this program; if not, write to the Free Software Foundation,
14  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
15  */
16
17 /** \file
18  * \ingroup spinfo
19  */
20
21 #include <math.h>
22 #include <string.h>
23 #include <sys/stat.h>
24 #include <limits.h>
25 #include <assert.h>
26
27 #include "MEM_guardedalloc.h"
28
29 #include "BLF_api.h"
30
31 #include "BLI_math.h"
32 #include "BLI_utildefines.h"
33 #include "BLI_string_utf8.h"
34
35 #include "GPU_immediate.h"
36 #include "GPU_state.h"
37
38 #include "BKE_text.h"
39
40 #include "textview.h"
41
42 static void console_font_begin(const int font_id, const int lheight)
43 {
44   /* 0.875 is based on: 16 pixels lines get 14 pixel text */
45   BLF_size(font_id, 0.875 * lheight, 72);
46 }
47
48 typedef struct ConsoleDrawContext {
49   int font_id;
50   int cwidth;
51   int lheight;
52   /** text vertical offset */
53   int lofs;
54   /** number of characters that fit into the width of the console (fixed width) */
55   int console_width;
56   int winx;
57   int ymin, ymax;
58   int *xy;   // [2]
59   int *sel;  // [2]
60   /* bottom of view == 0, top of file == combine chars, end of line is lower then start. */
61   int *pos_pick;
62   const int *mval;  // [2]
63   int draw;
64 } ConsoleDrawContext;
65
66 BLI_INLINE void console_step_sel(ConsoleDrawContext *cdc, const int step)
67 {
68   cdc->sel[0] += step;
69   cdc->sel[1] += step;
70 }
71
72 static void console_draw_sel(const char *str,
73                              const int sel[2],
74                              const int xy[2],
75                              const int str_len_draw,
76                              int cwidth,
77                              int lheight,
78                              const unsigned char bg_sel[4])
79 {
80   if (sel[0] <= str_len_draw && sel[1] >= 0) {
81     const int sta = txt_utf8_offset_to_column(str, max_ii(sel[0], 0));
82     const int end = txt_utf8_offset_to_column(str, min_ii(sel[1], str_len_draw));
83
84     GPU_blend(true);
85     GPU_blend_set_func_separate(
86         GPU_SRC_ALPHA, GPU_ONE_MINUS_SRC_ALPHA, GPU_ONE, GPU_ONE_MINUS_SRC_ALPHA);
87
88     GPUVertFormat *format = immVertexFormat();
89     uint pos = GPU_vertformat_attr_add(format, "pos", GPU_COMP_I32, 2, GPU_FETCH_INT_TO_FLOAT);
90     immBindBuiltinProgram(GPU_SHADER_2D_UNIFORM_COLOR);
91
92     immUniformColor4ubv(bg_sel);
93     immRecti(pos, xy[0] + (cwidth * sta), xy[1] - 2 + lheight, xy[0] + (cwidth * end), xy[1] - 2);
94
95     immUnbindProgram();
96
97     GPU_blend(false);
98   }
99 }
100
101 /* warning: allocated memory for 'offsets' must be freed by caller */
102 static int console_wrap_offsets(const char *str, int len, int width, int *lines, int **offsets)
103 {
104   int i, end; /* column */
105   int j;      /* mem */
106
107   *lines = 1;
108
109   *offsets = MEM_callocN(
110       sizeof(**offsets) *
111           (len * BLI_UTF8_WIDTH_MAX / MAX2(1, width - (BLI_UTF8_WIDTH_MAX - 1)) + 1),
112       "console_wrap_offsets");
113   (*offsets)[0] = 0;
114
115   for (i = 0, end = width, j = 0; j < len && str[j]; j += BLI_str_utf8_size_safe(str + j)) {
116     int columns = BLI_str_utf8_char_width_safe(str + j);
117
118     if (i + columns > end) {
119       (*offsets)[*lines] = j;
120       (*lines)++;
121
122       end = i + width;
123     }
124     i += columns;
125   }
126   return j; /* return actual length */
127 }
128
129 /* return 0 if the last line is off the screen
130  * should be able to use this for any string type */
131
132 static int console_draw_string(ConsoleDrawContext *cdc,
133                                const char *str,
134                                int str_len,
135                                const unsigned char fg[3],
136                                const unsigned char bg[3],
137                                const unsigned char bg_sel[4])
138 {
139   int tot_lines; /* total number of lines for wrapping */
140   int *offsets;  /* offsets of line beginnings for wrapping */
141   int y_next;
142
143   str_len = console_wrap_offsets(str, str_len, cdc->console_width, &tot_lines, &offsets);
144   y_next = cdc->xy[1] + cdc->lheight * tot_lines;
145
146   /* just advance the height */
147   if (cdc->draw == 0) {
148     if (cdc->pos_pick && cdc->mval[1] != INT_MAX && cdc->xy[1] <= cdc->mval[1]) {
149       if (y_next >= cdc->mval[1]) {
150         int ofs = 0;
151
152         /* wrap */
153         if (tot_lines > 1) {
154           int iofs = (int)((float)(y_next - cdc->mval[1]) / cdc->lheight);
155           ofs += offsets[MIN2(iofs, tot_lines - 1)];
156         }
157
158         /* last part */
159         ofs += txt_utf8_column_to_offset(str + ofs, (int)floor((float)cdc->mval[0] / cdc->cwidth));
160
161         CLAMP(ofs, 0, str_len);
162         *cdc->pos_pick += str_len - ofs;
163       }
164       else {
165         *cdc->pos_pick += str_len + 1;
166       }
167     }
168
169     cdc->xy[1] = y_next;
170     MEM_freeN(offsets);
171     return 1;
172   }
173   else if (y_next < cdc->ymin) {
174     /* have not reached the drawable area so don't break */
175     cdc->xy[1] = y_next;
176
177     /* adjust selection even if not drawing */
178     if (cdc->sel[0] != cdc->sel[1]) {
179       console_step_sel(cdc, -(str_len + 1));
180     }
181
182     MEM_freeN(offsets);
183     return 1;
184   }
185
186   if (tot_lines > 1) { /* wrap? */
187     const int initial_offset = offsets[tot_lines - 1];
188     size_t len = str_len - initial_offset;
189     const char *s = str + initial_offset;
190     int i;
191
192     int sel_orig[2];
193     copy_v2_v2_int(sel_orig, cdc->sel);
194
195     /* invert and swap for wrapping */
196     cdc->sel[0] = str_len - sel_orig[1];
197     cdc->sel[1] = str_len - sel_orig[0];
198
199     if (bg) {
200       GPUVertFormat *format = immVertexFormat();
201       uint pos = GPU_vertformat_attr_add(format, "pos", GPU_COMP_I32, 2, GPU_FETCH_INT_TO_FLOAT);
202       immBindBuiltinProgram(GPU_SHADER_2D_UNIFORM_COLOR);
203
204       immUniformColor3ubv(bg);
205       immRecti(pos, 0, cdc->xy[1], cdc->winx, (cdc->xy[1] + (cdc->lheight * tot_lines)));
206
207       immUnbindProgram();
208     }
209
210     /* last part needs no clipping */
211     BLF_position(cdc->font_id, cdc->xy[0], cdc->lofs + cdc->xy[1], 0);
212     BLF_color3ubv(cdc->font_id, fg);
213     BLF_draw_mono(cdc->font_id, s, len, cdc->cwidth);
214
215     if (cdc->sel[0] != cdc->sel[1]) {
216       console_step_sel(cdc, -initial_offset);
217       /* BLF_color3ub(cdc->font_id, 255, 0, 0); // debug */
218       console_draw_sel(s, cdc->sel, cdc->xy, len, cdc->cwidth, cdc->lheight, bg_sel);
219     }
220
221     cdc->xy[1] += cdc->lheight;
222
223     for (i = tot_lines - 1; i > 0; i--) {
224       len = offsets[i] - offsets[i - 1];
225       s = str + offsets[i - 1];
226
227       BLF_position(cdc->font_id, cdc->xy[0], cdc->lofs + cdc->xy[1], 0);
228       BLF_draw_mono(cdc->font_id, s, len, cdc->cwidth);
229
230       if (cdc->sel[0] != cdc->sel[1]) {
231         console_step_sel(cdc, len);
232         /* BLF_color3ub(cdc->font_id, 0, 255, 0); // debug */
233         console_draw_sel(s, cdc->sel, cdc->xy, len, cdc->cwidth, cdc->lheight, bg_sel);
234       }
235
236       cdc->xy[1] += cdc->lheight;
237
238       /* check if were out of view bounds */
239       if (cdc->xy[1] > cdc->ymax) {
240         MEM_freeN(offsets);
241         return 0;
242       }
243     }
244
245     copy_v2_v2_int(cdc->sel, sel_orig);
246     console_step_sel(cdc, -(str_len + 1));
247   }
248   else { /* simple, no wrap */
249
250     if (bg) {
251       GPUVertFormat *format = immVertexFormat();
252       uint pos = GPU_vertformat_attr_add(format, "pos", GPU_COMP_I32, 2, GPU_FETCH_INT_TO_FLOAT);
253       immBindBuiltinProgram(GPU_SHADER_2D_UNIFORM_COLOR);
254
255       immUniformColor3ubv(bg);
256       immRecti(pos, 0, cdc->xy[1], cdc->winx, cdc->xy[1] + cdc->lheight);
257
258       immUnbindProgram();
259     }
260
261     BLF_color3ubv(cdc->font_id, fg);
262     BLF_position(cdc->font_id, cdc->xy[0], cdc->lofs + cdc->xy[1], 0);
263     BLF_draw_mono(cdc->font_id, str, str_len, cdc->cwidth);
264
265     if (cdc->sel[0] != cdc->sel[1]) {
266       int isel[2];
267
268       isel[0] = str_len - cdc->sel[1];
269       isel[1] = str_len - cdc->sel[0];
270
271       /* BLF_color3ub(cdc->font_id, 255, 255, 0); // debug */
272       console_draw_sel(str, isel, cdc->xy, str_len, cdc->cwidth, cdc->lheight, bg_sel);
273       console_step_sel(cdc, -(str_len + 1));
274     }
275
276     cdc->xy[1] += cdc->lheight;
277
278     if (cdc->xy[1] > cdc->ymax) {
279       MEM_freeN(offsets);
280       return 0;
281     }
282   }
283
284   MEM_freeN(offsets);
285   return 1;
286 }
287
288 #define CONSOLE_DRAW_MARGIN 4
289
290 int textview_draw(
291     TextViewContext *tvc, const int draw, int mval[2], void **mouse_pick, int *pos_pick)
292 {
293   ConsoleDrawContext cdc = {0};
294
295   int x_orig = CONSOLE_DRAW_MARGIN, y_orig = CONSOLE_DRAW_MARGIN + tvc->lheight / 6;
296   int xy[2], y_prev;
297   int sel[2] = {-1, -1}; /* defaults disabled */
298   unsigned char fg[3], bg[3];
299   const int font_id = blf_mono_font;
300
301   console_font_begin(font_id, tvc->lheight);
302
303   xy[0] = x_orig;
304   xy[1] = y_orig;
305
306   if (mval[1] != INT_MAX) {
307     mval[1] += (tvc->ymin + CONSOLE_DRAW_MARGIN);
308   }
309
310   if (pos_pick) {
311     *pos_pick = 0;
312   }
313
314   /* constants for the sequencer context */
315   cdc.font_id = font_id;
316   cdc.cwidth = (int)BLF_fixed_width(font_id);
317   assert(cdc.cwidth > 0);
318   cdc.lheight = tvc->lheight;
319   cdc.lofs = -BLF_descender(font_id);
320   /* note, scroll bar must be already subtracted () */
321   cdc.console_width = (tvc->winx - (CONSOLE_DRAW_MARGIN * 2)) / cdc.cwidth;
322   /* avoid divide by zero on small windows */
323   if (cdc.console_width < 1) {
324     cdc.console_width = 1;
325   }
326   cdc.winx = tvc->winx - CONSOLE_DRAW_MARGIN;
327   cdc.ymin = tvc->ymin;
328   cdc.ymax = tvc->ymax;
329   cdc.xy = xy;
330   cdc.sel = sel;
331   cdc.pos_pick = pos_pick;
332   cdc.mval = mval;
333   cdc.draw = draw;
334
335   /* shouldnt be needed */
336   tvc->cwidth = cdc.cwidth;
337   tvc->console_width = cdc.console_width;
338   tvc->iter_index = 0;
339
340   if (tvc->sel_start != tvc->sel_end) {
341     sel[0] = tvc->sel_start;
342     sel[1] = tvc->sel_end;
343   }
344
345   if (tvc->begin(tvc)) {
346     unsigned char bg_sel[4] = {0};
347
348     if (draw && tvc->const_colors) {
349       tvc->const_colors(tvc, bg_sel);
350     }
351
352     do {
353       const char *ext_line;
354       int ext_len;
355       int color_flag = 0;
356
357       y_prev = xy[1];
358
359       if (draw) {
360         color_flag = tvc->line_color(tvc, fg, bg);
361       }
362
363       tvc->line_get(tvc, &ext_line, &ext_len);
364
365       if (!console_draw_string(&cdc,
366                                ext_line,
367                                ext_len,
368                                (color_flag & TVC_LINE_FG) ? fg : NULL,
369                                (color_flag & TVC_LINE_BG) ? bg : NULL,
370                                bg_sel)) {
371         /* when drawing, if we pass v2d->cur.ymax, then quit */
372         if (draw) {
373           break; /* past the y limits */
374         }
375       }
376
377       if ((mval[1] != INT_MAX) && (mval[1] >= y_prev && mval[1] <= xy[1])) {
378         *mouse_pick = (void *)tvc->iter;
379         break;
380       }
381
382       tvc->iter_index++;
383
384     } while (tvc->step(tvc));
385   }
386
387   tvc->end(tvc);
388
389   xy[1] += tvc->lheight * 2;
390
391   return xy[1] - y_orig;
392 }