923ce769f7238e23b0e604f89954459f4ef8b8f3
[claws.git] / src / plugins / litehtml_viewer / container_linux.cpp
1 /*
2  * Claws Mail -- A GTK+ based, lightweight, and fast e-mail client
3  * Copyright(C) 2019 the Claws Mail Team
4  *
5  * This program is free software; you can redistribute it and/or modify
6  * it under the terms of the GNU General Public License as published by
7  * the Free Software Foundation; either version 3 of the License, or
8  * (at your option) any later version.
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12  * GNU General Public License for more details.
13  * You should have received a copy of the GNU General Public License
14  * along with this program; if not, write tothe Free Software
15  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
16  */
17
18 #ifdef HAVE_CONFIG_H
19 #include "config.h"
20 #include "claws-features.h"
21 #endif
22
23 #include "container_linux.h"
24
25 #include <cairo-ft.h>
26
27 #define _USE_MATH_DEFINES
28 #include <math.h>
29
30 #ifndef M_PI
31 #       define M_PI    3.14159265358979323846
32 #endif
33
34 container_linux::container_linux(void)
35 {
36         m_temp_surface  = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, 2, 2);
37         m_temp_cr               = cairo_create(m_temp_surface);
38         g_rec_mutex_init(&m_images_lock);
39 }
40
41 container_linux::~container_linux(void)
42 {
43         clear_images();
44         cairo_surface_destroy(m_temp_surface);
45         cairo_destroy(m_temp_cr);
46         g_rec_mutex_clear(&m_images_lock);
47 }
48
49 int container_linux::pt_to_px( int pt )
50 {
51         GdkScreen* screen = gdk_screen_get_default();
52         double dpi = gdk_screen_get_resolution(screen);
53
54         return (int) ((double) pt * dpi / 72.0);
55 }
56
57 void container_linux::draw_list_marker( litehtml::uint_ptr hdc, const litehtml::list_marker& marker )
58 {
59         if(!marker.image.empty())
60         {
61                 /*litehtml::tstring url;
62                 make_url(marker.image.c_str(), marker.baseurl, url);
63
64                 lock_images_cache();
65                 images_map::iterator img_i = m_images.find(url.c_str());
66                 if(img_i != m_images.end())
67                 {
68                         if(img_i->second)
69                         {
70                                 draw_txdib((cairo_t*) hdc, img_i->second, marker.pos.x, marker.pos.y, marker.pos.width, marker.pos.height);
71                         }
72                 }
73                 unlock_images_cache();*/
74         } else
75         {
76                 switch(marker.marker_type)
77                 {
78                 case litehtml::list_style_type_circle:
79                         {
80                                 draw_ellipse((cairo_t*) hdc, marker.pos.x, marker.pos.y, marker.pos.width, marker.pos.height, marker.color, 0.5);
81                         }
82                         break;
83                 case litehtml::list_style_type_disc:
84                         {
85                                 fill_ellipse((cairo_t*) hdc, marker.pos.x, marker.pos.y, marker.pos.width, marker.pos.height, marker.color);
86                         }
87                         break;
88                 case litehtml::list_style_type_square:
89                         if(hdc)
90                         {
91                                 cairo_t* cr = (cairo_t*) hdc;
92                                 cairo_save(cr);
93
94                                 cairo_new_path(cr);
95                                 cairo_rectangle(cr, marker.pos.x, marker.pos.y, marker.pos.width, marker.pos.height);
96
97                                 set_color(cr, marker.color);
98                                 cairo_fill(cr);
99                                 cairo_restore(cr);
100                         }
101                         break;
102                 default:
103                         /*do nothing*/
104                         break;
105                 }
106         }
107 }
108
109 void container_linux::draw_background( litehtml::uint_ptr hdc, const litehtml::background_paint& bg )
110 {
111         cairo_t* cr = (cairo_t*) hdc;
112         cairo_save(cr);
113         apply_clip(cr);
114
115         rounded_rectangle(cr, bg.border_box, bg.border_radius);
116         cairo_clip(cr);
117
118         cairo_rectangle(cr, bg.clip_box.x, bg.clip_box.y, bg.clip_box.width, bg.clip_box.height);
119         cairo_clip(cr);
120
121         if(bg.color.alpha)
122         {
123                 set_color(cr, bg.color);
124                 cairo_paint(cr);
125         }
126
127         litehtml::tstring url;
128         make_url(bg.image.c_str(), bg.baseurl.c_str(), url);
129
130         lock_images_cache();
131         bool found = false;
132         const image *img_i = NULL;
133
134         for (auto ii = m_images.cbegin(); ii != m_images.cend(); ++ii) {
135                 const image *i = &(*ii);
136                 if (i->first == url) {
137                         img_i = i;
138                         found = true;
139                         break;
140                 }
141         }
142
143         if(img_i != NULL && img_i->second)
144         {
145                 GdkPixbuf *bgbmp = img_i->second;
146
147                 GdkPixbuf *new_img;
148                 if(bg.image_size.width != gdk_pixbuf_get_width(bgbmp) || bg.image_size.height != gdk_pixbuf_get_height(bgbmp))
149                 {
150                         new_img = gdk_pixbuf_scale_simple(bgbmp, bg.image_size.width, bg.image_size.height, GDK_INTERP_BILINEAR);
151                         bgbmp = new_img;
152                 }
153
154                 cairo_surface_t* img = surface_from_pixbuf(bgbmp);
155                 cairo_pattern_t *pattern = cairo_pattern_create_for_surface(img);
156                 cairo_matrix_t flib_m;
157                 cairo_matrix_init_identity(&flib_m);
158                 cairo_matrix_translate(&flib_m, -bg.position_x, -bg.position_y);
159                 cairo_pattern_set_extend (pattern, CAIRO_EXTEND_REPEAT);
160                 cairo_pattern_set_matrix (pattern, &flib_m);
161
162                 switch(bg.repeat)
163                 {
164                 case litehtml::background_repeat_no_repeat:
165                         draw_pixbuf(cr, bgbmp, bg.position_x, bg.position_y, gdk_pixbuf_get_width(bgbmp), gdk_pixbuf_get_height(bgbmp));
166                         break;
167
168                 case litehtml::background_repeat_repeat_x:
169                         cairo_set_source(cr, pattern);
170                         cairo_rectangle(cr, bg.clip_box.left(), bg.position_y, bg.clip_box.width, gdk_pixbuf_get_height(bgbmp));
171                         cairo_fill(cr);
172                         break;
173
174                 case litehtml::background_repeat_repeat_y:
175                         cairo_set_source(cr, pattern);
176                         cairo_rectangle(cr, bg.position_x, bg.clip_box.top(), gdk_pixbuf_get_width(bgbmp), bg.clip_box.height);
177                         cairo_fill(cr);
178                         break;
179
180                 case litehtml::background_repeat_repeat:
181                         cairo_set_source(cr, pattern);
182                         cairo_rectangle(cr, bg.clip_box.left(), bg.clip_box.top(), bg.clip_box.width, bg.clip_box.height);
183                         cairo_fill(cr);
184                         break;
185                 }
186
187                 cairo_pattern_destroy(pattern);
188                 cairo_surface_destroy(img);
189
190         }
191
192         unlock_images_cache();
193         cairo_restore(cr);
194 }
195
196 void container_linux::make_url(const litehtml::tchar_t* url,    const litehtml::tchar_t* basepath, litehtml::tstring& out)
197 {
198         out = url;
199 }
200
201 void container_linux::add_path_arc(cairo_t* cr, double x, double y, double rx, double ry, double a1, double a2, bool neg)
202 {
203         if(rx > 0 && ry > 0)
204         {
205
206                 cairo_save(cr);
207
208                 cairo_translate(cr, x, y);
209                 cairo_scale(cr, 1, ry / rx);
210                 cairo_translate(cr, -x, -y);
211
212                 if(neg)
213                 {
214                         cairo_arc_negative(cr, x, y, rx, a1, a2);
215                 } else
216                 {
217                         cairo_arc(cr, x, y, rx, a1, a2);
218                 }
219
220                 cairo_restore(cr);
221         } else
222         {
223                 cairo_move_to(cr, x, y);
224         }
225 }
226
227 void container_linux::draw_borders(litehtml::uint_ptr hdc, const litehtml::borders& borders, const litehtml::position& draw_pos, bool root)
228 {
229         cairo_t* cr = (cairo_t*) hdc;
230         cairo_save(cr);
231         apply_clip(cr);
232
233         cairo_new_path(cr);
234
235         int bdr_top             = 0;
236         int bdr_bottom  = 0;
237         int bdr_left    = 0;
238         int bdr_right   = 0;
239
240         if(borders.top.width != 0 && borders.top.style > litehtml::border_style_hidden)
241         {
242                 bdr_top = (int) borders.top.width;
243         }
244         if(borders.bottom.width != 0 && borders.bottom.style > litehtml::border_style_hidden)
245         {
246                 bdr_bottom = (int) borders.bottom.width;
247         }
248         if(borders.left.width != 0 && borders.left.style > litehtml::border_style_hidden)
249         {
250                 bdr_left = (int) borders.left.width;
251         }
252         if(borders.right.width != 0 && borders.right.style > litehtml::border_style_hidden)
253         {
254                 bdr_right = (int) borders.right.width;
255         }
256
257         // draw right border
258         if(bdr_right)
259         {
260                 set_color(cr, borders.right.color);
261
262                 double r_top    = borders.radius.top_right_x;
263                 double r_bottom = borders.radius.bottom_right_x;
264
265                 if(r_top)
266                 {
267                         double end_angle        = 2 * M_PI;
268                         double start_angle      = end_angle - M_PI / 2.0  / ((double) bdr_top / (double) bdr_right + 1);
269
270                         add_path_arc(cr,
271                                 draw_pos.right() - r_top,
272                                 draw_pos.top() + r_top,
273                                 r_top - bdr_right,
274                                 r_top - bdr_right + (bdr_right - bdr_top),
275                                 end_angle,
276                                 start_angle, true);
277
278                         add_path_arc(cr,
279                                 draw_pos.right() - r_top,
280                                 draw_pos.top() + r_top,
281                                 r_top,
282                                 r_top,
283                                 start_angle,
284                                 end_angle, false);
285                 } else
286                 {
287                         cairo_move_to(cr, draw_pos.right() - bdr_right, draw_pos.top() + bdr_top);
288                         cairo_line_to(cr, draw_pos.right(), draw_pos.top());
289                 }
290
291                 if(r_bottom)
292                 {
293                         cairo_line_to(cr, draw_pos.right(),     draw_pos.bottom() - r_bottom);
294
295                         double start_angle      = 0;
296                         double end_angle        = start_angle + M_PI / 2.0  / ((double) bdr_bottom / (double) bdr_right + 1);
297
298                         add_path_arc(cr,
299                                 draw_pos.right() - r_bottom,
300                                 draw_pos.bottom() - r_bottom,
301                                 r_bottom,
302                                 r_bottom,
303                                 start_angle,
304                                 end_angle, false);
305
306                         add_path_arc(cr,
307                                 draw_pos.right() - r_bottom,
308                                 draw_pos.bottom() - r_bottom,
309                                 r_bottom - bdr_right,
310                                 r_bottom - bdr_right + (bdr_right - bdr_bottom),
311                                 end_angle,
312                                 start_angle, true);
313                 } else
314                 {
315                         cairo_line_to(cr, draw_pos.right(),     draw_pos.bottom());
316                         cairo_line_to(cr, draw_pos.right() - bdr_right, draw_pos.bottom() - bdr_bottom);
317                 }
318
319                 cairo_fill(cr);
320         }
321
322         // draw bottom border
323         if(bdr_bottom)
324         {
325                 set_color(cr, borders.bottom.color);
326
327                 double r_left   = borders.radius.bottom_left_x;
328                 double r_right  = borders.radius.bottom_right_x;
329
330                 if(r_left)
331                 {
332                         double start_angle      = M_PI / 2.0;
333                         double end_angle        = start_angle + M_PI / 2.0  / ((double) bdr_left / (double) bdr_bottom + 1);
334
335                         add_path_arc(cr,
336                                 draw_pos.left() + r_left,
337                                 draw_pos.bottom() - r_left,
338                                 r_left - bdr_bottom + (bdr_bottom - bdr_left),
339                                 r_left - bdr_bottom,
340                                 start_angle,
341                                 end_angle, false);
342
343                         add_path_arc(cr,
344                                 draw_pos.left() + r_left,
345                                 draw_pos.bottom() - r_left,
346                                 r_left,
347                                 r_left,
348                                 end_angle,
349                                 start_angle, true);
350                 } else
351                 {
352                         cairo_move_to(cr, draw_pos.left(), draw_pos.bottom());
353                         cairo_line_to(cr, draw_pos.left() + bdr_left, draw_pos.bottom() - bdr_bottom);
354                 }
355
356                 if(r_right)
357                 {
358                         cairo_line_to(cr, draw_pos.right() - r_right,   draw_pos.bottom());
359
360                         double end_angle        = M_PI / 2.0;
361                         double start_angle      = end_angle - M_PI / 2.0  / ((double) bdr_right / (double) bdr_bottom + 1);
362
363                         add_path_arc(cr,
364                                 draw_pos.right() - r_right,
365                                 draw_pos.bottom() - r_right,
366                                 r_right,
367                                 r_right,
368                                 end_angle,
369                                 start_angle, true);
370
371                         add_path_arc(cr,
372                                 draw_pos.right() - r_right,
373                                 draw_pos.bottom() - r_right,
374                                 r_right - bdr_bottom + (bdr_bottom - bdr_right),
375                                 r_right - bdr_bottom,
376                                 start_angle,
377                                 end_angle, false);
378                 } else
379                 {
380                         cairo_line_to(cr, draw_pos.right() - bdr_right, draw_pos.bottom() - bdr_bottom);
381                         cairo_line_to(cr, draw_pos.right(),     draw_pos.bottom());
382                 }
383
384                 cairo_fill(cr);
385         }
386
387         // draw top border
388         if(bdr_top)
389         {
390                 set_color(cr, borders.top.color);
391
392                 double r_left   = borders.radius.top_left_x;
393                 double r_right  = borders.radius.top_right_x;
394
395                 if(r_left)
396                 {
397                         double end_angle        = M_PI * 3.0 / 2.0;
398                         double start_angle      = end_angle - M_PI / 2.0  / ((double) bdr_left / (double) bdr_top + 1);
399
400                         add_path_arc(cr,
401                                 draw_pos.left() + r_left,
402                                 draw_pos.top() + r_left,
403                                 r_left,
404                                 r_left,
405                                 end_angle,
406                                 start_angle, true);
407
408                         add_path_arc(cr,
409                                 draw_pos.left() + r_left,
410                                 draw_pos.top() + r_left,
411                                 r_left - bdr_top + (bdr_top - bdr_left),
412                                 r_left - bdr_top,
413                                 start_angle,
414                                 end_angle, false);
415                 } else
416                 {
417                         cairo_move_to(cr, draw_pos.left(), draw_pos.top());
418                         cairo_line_to(cr, draw_pos.left() + bdr_left, draw_pos.top() + bdr_top);
419                 }
420
421                 if(r_right)
422                 {
423                         cairo_line_to(cr, draw_pos.right() - r_right,   draw_pos.top() + bdr_top);
424
425                         double start_angle      = M_PI * 3.0 / 2.0;
426                         double end_angle        = start_angle + M_PI / 2.0  / ((double) bdr_right / (double) bdr_top + 1);
427
428                         add_path_arc(cr,
429                                 draw_pos.right() - r_right,
430                                 draw_pos.top() + r_right,
431                                 r_right - bdr_top + (bdr_top - bdr_right),
432                                 r_right - bdr_top,
433                                 start_angle,
434                                 end_angle, false);
435
436                         add_path_arc(cr,
437                                 draw_pos.right() - r_right,
438                                 draw_pos.top() + r_right,
439                                 r_right,
440                                 r_right,
441                                 end_angle,
442                                 start_angle, true);
443                 } else
444                 {
445                         cairo_line_to(cr, draw_pos.right() - bdr_right, draw_pos.top() + bdr_top);
446                         cairo_line_to(cr, draw_pos.right(),     draw_pos.top());
447                 }
448
449                 cairo_fill(cr);
450         }
451
452         // draw left border
453         if(bdr_left)
454         {
455                 set_color(cr, borders.left.color);
456
457                 double r_top    = borders.radius.top_left_x;
458                 double r_bottom = borders.radius.bottom_left_x;
459
460                 if(r_top)
461                 {
462                         double start_angle      = M_PI;
463                         double end_angle        = start_angle + M_PI / 2.0  / ((double) bdr_top / (double) bdr_left + 1);
464
465                         add_path_arc(cr,
466                                 draw_pos.left() + r_top,
467                                 draw_pos.top() + r_top,
468                                 r_top - bdr_left,
469                                 r_top - bdr_left + (bdr_left - bdr_top),
470                                 start_angle,
471                                 end_angle, false);
472
473                         add_path_arc(cr,
474                                 draw_pos.left() + r_top,
475                                 draw_pos.top() + r_top,
476                                 r_top,
477                                 r_top,
478                                 end_angle,
479                                 start_angle, true);
480                 } else
481                 {
482                         cairo_move_to(cr, draw_pos.left() + bdr_left, draw_pos.top() + bdr_top);
483                         cairo_line_to(cr, draw_pos.left(), draw_pos.top());
484                 }
485
486                 if(r_bottom)
487                 {
488                         cairo_line_to(cr, draw_pos.left(),      draw_pos.bottom() - r_bottom);
489
490                         double end_angle        = M_PI;
491                         double start_angle      = end_angle - M_PI / 2.0  / ((double) bdr_bottom / (double) bdr_left + 1);
492
493                         add_path_arc(cr,
494                                 draw_pos.left() + r_bottom,
495                                 draw_pos.bottom() - r_bottom,
496                                 r_bottom,
497                                 r_bottom,
498                                 end_angle,
499                                 start_angle, true);
500
501                         add_path_arc(cr,
502                                 draw_pos.left() + r_bottom,
503                                 draw_pos.bottom() - r_bottom,
504                                 r_bottom - bdr_left,
505                                 r_bottom - bdr_left + (bdr_left - bdr_bottom),
506                                 start_angle,
507                                 end_angle, false);
508                 } else
509                 {
510                         cairo_line_to(cr, draw_pos.left(),      draw_pos.bottom());
511                         cairo_line_to(cr, draw_pos.left() + bdr_left,   draw_pos.bottom() - bdr_bottom);
512                 }
513
514                 cairo_fill(cr);
515         }
516         cairo_restore(cr);
517 }
518
519 void container_linux::transform_text(litehtml::tstring& text, litehtml::text_transform tt)
520 {
521
522 }
523
524 void container_linux::set_clip( const litehtml::position& pos, const litehtml::border_radiuses& bdr_radius, bool valid_x, bool valid_y )
525 {
526         litehtml::position clip_pos = pos;
527         litehtml::position client_pos;
528         get_client_rect(client_pos);
529         if(!valid_x)
530         {
531                 clip_pos.x              = client_pos.x;
532                 clip_pos.width  = client_pos.width;
533         }
534         if(!valid_y)
535         {
536                 clip_pos.y              = client_pos.y;
537                 clip_pos.height = client_pos.height;
538         }
539         m_clips.emplace_back(clip_pos, bdr_radius);
540 }
541
542 void container_linux::del_clip()
543 {
544         if(!m_clips.empty())
545         {
546                 m_clips.pop_back();
547         }
548 }
549
550 void container_linux::apply_clip( cairo_t* cr )
551 {
552         for(const auto& clip_box : m_clips)
553         {
554                 rounded_rectangle(cr, clip_box.box, clip_box.radius);
555                 cairo_clip(cr);
556         }
557 }
558
559 void container_linux::draw_ellipse( cairo_t* cr, int x, int y, int width, int height, const litehtml::web_color& color, int line_width )
560 {
561         if(!cr) return;
562         cairo_save(cr);
563
564         apply_clip(cr);
565
566         cairo_new_path(cr);
567
568         cairo_translate (cr, x + width / 2.0, y + height / 2.0);
569         cairo_scale (cr, width / 2.0, height / 2.0);
570         cairo_arc (cr, 0, 0, 1, 0, 2 * M_PI);
571
572         set_color(cr, color);
573         cairo_set_line_width(cr, line_width);
574         cairo_stroke(cr);
575
576         cairo_restore(cr);
577 }
578
579 void container_linux::fill_ellipse( cairo_t* cr, int x, int y, int width, int height, const litehtml::web_color& color )
580 {
581         if(!cr) return;
582         cairo_save(cr);
583
584         apply_clip(cr);
585
586         cairo_new_path(cr);
587
588         cairo_translate (cr, x + width / 2.0, y + height / 2.0);
589         cairo_scale (cr, width / 2.0, height / 2.0);
590         cairo_arc (cr, 0, 0, 1, 0, 2 * M_PI);
591
592         set_color(cr, color);
593         cairo_fill(cr);
594
595         cairo_restore(cr);
596 }
597
598 std::shared_ptr<litehtml::element>      container_linux::create_element(const litehtml::tchar_t *tag_name,
599                                                                                                                                           const litehtml::string_map &attributes,
600                                                                                                                                           const std::shared_ptr<litehtml::document> &doc)
601 {
602         return 0;
603 }
604
605 void container_linux::rounded_rectangle( cairo_t* cr, const litehtml::position &pos, const litehtml::border_radiuses &radius )
606 {
607         cairo_new_path(cr);
608         if(radius.top_left_x)
609         {
610                 cairo_arc(cr, pos.left() + radius.top_left_x, pos.top() + radius.top_left_x, radius.top_left_x, M_PI, M_PI * 3.0 / 2.0);
611         } else
612         {
613                 cairo_move_to(cr, pos.left(), pos.top());
614         }
615
616         cairo_line_to(cr, pos.right() - radius.top_right_x, pos.top());
617
618         if(radius.top_right_x)
619         {
620                 cairo_arc(cr, pos.right() - radius.top_right_x, pos.top() + radius.top_right_x, radius.top_right_x, M_PI * 3.0 / 2.0, 2.0 * M_PI);
621         }
622
623         cairo_line_to(cr, pos.right(), pos.bottom() - radius.bottom_right_x);
624
625         if(radius.bottom_right_x)
626         {
627                 cairo_arc(cr, pos.right() - radius.bottom_right_x, pos.bottom() - radius.bottom_right_x, radius.bottom_right_x, 0, M_PI / 2.0);
628         }
629
630         cairo_line_to(cr, pos.left() - radius.bottom_left_x, pos.bottom());
631
632         if(radius.bottom_left_x)
633         {
634                 cairo_arc(cr, pos.left() + radius.bottom_left_x, pos.bottom() - radius.bottom_left_x, radius.bottom_left_x, M_PI / 2.0, M_PI);
635         }
636 }
637
638 void container_linux::draw_pixbuf(cairo_t* cr, const GdkPixbuf *bmp, int x,     int y, int cx, int cy)
639 {
640         cairo_save(cr);
641
642         {
643                 cairo_matrix_t flib_m;
644                 cairo_matrix_init(&flib_m, 1, 0, 0, -1, 0, 0);
645
646                 if(cx != gdk_pixbuf_get_width(bmp) || cy != gdk_pixbuf_get_height(bmp))
647                 {
648                         GdkPixbuf *new_img = gdk_pixbuf_scale_simple(bmp, cx, cy, GDK_INTERP_BILINEAR);
649                         gdk_cairo_set_source_pixbuf(cr, new_img, x, y);
650                         cairo_paint(cr);
651                 } else
652                 {
653                         gdk_cairo_set_source_pixbuf(cr, bmp, x, y);
654                         cairo_paint(cr);
655                 }
656         }
657
658         cairo_restore(cr);
659 }
660
661 cairo_surface_t* container_linux::surface_from_pixbuf(const GdkPixbuf *bmp)
662 {
663         cairo_surface_t* ret = NULL;
664
665         if(gdk_pixbuf_get_has_alpha(bmp))
666         {
667                 ret = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, gdk_pixbuf_get_width(bmp), gdk_pixbuf_get_height(bmp));
668         } else
669         {
670                 ret = cairo_image_surface_create(CAIRO_FORMAT_RGB24, gdk_pixbuf_get_width(bmp), gdk_pixbuf_get_height(bmp));
671         }
672
673 //      Cairo::RefPtr<Cairo::Surface> surface(new Cairo::Surface(ret, false));
674 //      Cairo::RefPtr<Cairo::Context> ctx = Cairo::Context::create(surface);
675 //      Gdk::Cairo::set_source_pixbuf(ctx, bmp, 0.0, 0.0);
676         cairo_t *ctx = cairo_create(ret);
677         cairo_paint(ctx);
678         cairo_destroy(ctx);
679
680         return ret;
681 }
682
683 void container_linux::get_media_features(litehtml::media_features& media) const
684 {
685         litehtml::position client;
686     get_client_rect(client);
687         media.type                      = litehtml::media_type_screen;
688         media.width                     = client.width;
689         media.height            = client.height;
690         media.device_width      = gdk_screen_width();
691         media.device_height     = gdk_screen_height();
692         media.color                     = 8;
693         media.monochrome        = 0;
694         media.color_index       = 256;
695         media.resolution        = 96;
696 }
697
698 void container_linux::get_language(litehtml::tstring& language, litehtml::tstring& culture) const
699 {
700         language = _t("en");
701         culture = _t("");
702 }
703
704 void container_linux::link(const std::shared_ptr<litehtml::document> &ptr, const litehtml::element::ptr& el)
705 {
706
707 }