Subversion Repositories Kolibri OS

Rev

Rev 5553 | Blame | Compare with Previous | Last modification | View Log | RSS feed

  1.  
  2. #include <stdint.h>
  3. #include <stdio.h>
  4. #include <stdlib.h>
  5. #include <math.h>
  6. #include <cairo.h>
  7. #include <cairo-ft.h>
  8. #include <ft2build.h>
  9. #include <kos32sys.h>
  10. #include FT_FREETYPE_H
  11. #include "tiger.inc"
  12.  
  13. typedef unsigned int color_t;
  14.  
  15. int width  = 500;
  16. int height = 400;
  17.  
  18. cairo_surface_t *main_surface;
  19. unsigned char *winbitmap;
  20. int winstride;
  21.  
  22. int screen = -1;
  23.  
  24. cairo_font_face_t    *c_face;
  25.  
  26. static void draw_next_msg(cairo_t *cr, int width, int height)
  27. {
  28.     cairo_identity_matrix (cr);
  29.  
  30.     cairo_select_font_face (cr, "cairo:monospace", CAIRO_FONT_SLANT_NORMAL,
  31.                                CAIRO_FONT_WEIGHT_BOLD);
  32.     cairo_set_font_size (cr, 28);
  33.     cairo_set_source_rgb (cr, 0, 0, 0);
  34.     cairo_move_to (cr, 160.0, 360.0);
  35.     cairo_show_text (cr, "Press any key");
  36. };
  37.  
  38.  
  39. static void screen_0(cairo_t *cr, int width, int height)
  40. {
  41.     cairo_identity_matrix (cr);
  42.  
  43.     cairo_set_source_rgb(cr,1,1,1);
  44.     cairo_paint(cr);
  45.  
  46.     cairo_translate(cr, 50, 30);
  47.     cairo_set_source_rgb(cr,0, 0,0);
  48.     cairo_set_line_width(cr, 10);
  49.  
  50.     cairo_rectangle(cr, 20, 20, 120, 80);
  51.     cairo_stroke_preserve(cr);
  52.     cairo_set_source_rgb(cr, 0, 0.5, 0.5);
  53.     cairo_fill(cr);
  54.  
  55.     cairo_set_source_rgb(cr,0, 0,0);
  56.     cairo_rectangle(cr, 180, 20, 80, 80);
  57.     cairo_stroke_preserve(cr);
  58.     cairo_set_source_rgb(cr, 0, 1, 1);
  59.     cairo_fill(cr);
  60.  
  61.     cairo_set_source_rgb(cr, 0, 0, 0);
  62.     cairo_arc(cr, 330, 60, 40, 0, 2*M_PI);
  63.     cairo_stroke_preserve(cr);
  64.     cairo_set_source_rgb(cr, 0.5, 0.0, 0.5);
  65.     cairo_fill(cr);
  66.  
  67.     cairo_set_source_rgb(cr, 0, 0, 0);
  68.     cairo_arc(cr, 90, 160, 40, M_PI/4, M_PI);
  69.     cairo_close_path(cr);
  70.     cairo_stroke_preserve(cr);
  71.     cairo_set_source_rgb(cr, 0.5, 0.5, 0.0);
  72.     cairo_fill(cr);
  73.  
  74.     cairo_set_source_rgb(cr, 0, 0, 0);
  75.     cairo_translate(cr, 220, 180);
  76.     cairo_scale(cr, 1, 0.7);
  77.     cairo_arc(cr, 0, 0, 50, 0, 2*M_PI);
  78.     cairo_stroke_preserve(cr);
  79.     cairo_set_source_rgb(cr, 1, 0, 1);
  80.     cairo_fill(cr);
  81.  
  82.     draw_next_msg(cr, width, height);
  83.  
  84. };
  85.  
  86. static int points[11][2] = {
  87.     { 0, 85 },
  88.     { 75, 75 },
  89.     { 100, 10 },
  90.     { 125, 75 },
  91.     { 200, 85 },
  92.     { 150, 125 },
  93.     { 160, 190 },
  94.     { 100, 150 },
  95.     { 40, 190 },
  96.     { 50, 125 },
  97.     { 0, 85 }
  98. };
  99.  
  100. static void screen_1(cairo_t *cr, int width, int height)
  101. {
  102.     cairo_set_source_rgb(cr, 1, 1, 1);
  103.     cairo_paint(cr);
  104.  
  105.     cairo_translate(cr, 20, 40);
  106.  
  107.     cairo_set_source_rgb(cr, 0, 0, 0);
  108.     cairo_set_line_width(cr, 10);
  109.     cairo_move_to(cr, 0, 85);
  110.  
  111.     int i;
  112.     for ( i = 0; i < 10; i++ ) {
  113.       cairo_line_to(cr, points[i][0], points[i][1]);
  114.     }
  115.  
  116.     cairo_close_path(cr);
  117.     cairo_stroke_preserve(cr);
  118.     cairo_set_source_rgb(cr, 0, 1, 0);
  119.     cairo_fill(cr);
  120.  
  121.     cairo_move_to(cr, 240, 40);
  122.     cairo_line_to(cr, 240, 160);
  123.     cairo_line_to(cr, 350, 160);
  124.     cairo_close_path(cr);
  125.  
  126.     cairo_set_source_rgb(cr, 0, 0, 0);
  127.     cairo_stroke_preserve(cr);
  128.     cairo_set_source_rgb(cr, 1, 0, 0);
  129.     cairo_fill(cr);
  130.  
  131.     cairo_move_to(cr, 380, 40);
  132.     cairo_line_to(cr, 380, 160);
  133.     cairo_line_to(cr, 450, 160);
  134.     cairo_curve_to(cr, 440, 155, 380, 145, 380, 40);
  135.  
  136.     cairo_set_source_rgb(cr, 0, 0, 0);
  137.     cairo_stroke_preserve(cr);
  138.     cairo_set_source_rgb(cr, 1, 0, 1);
  139.     cairo_fill(cr);
  140.  
  141.     draw_next_msg(cr, width, height);
  142.  
  143. };
  144.  
  145. static void screen_2(cairo_t *cr, int width, int height)
  146. {
  147.     cairo_pattern_t *pat1;
  148.     cairo_pattern_t *pat2;
  149.     cairo_pattern_t *pat3;
  150.  
  151.  
  152.     cairo_translate(cr, 75, 0);
  153.  
  154.     cairo_set_source_rgb(cr, 1, 1,1);
  155.     cairo_paint(cr);
  156.  
  157.     cairo_move_to(cr, 0, 85);
  158.  
  159.     pat1 = cairo_pattern_create_linear(0.0, 0.0,  350.0, 350.0);
  160.  
  161.     double j;
  162.     int count = 1;
  163.     for ( j = 0.1; j < 1; j += 0.1 )
  164.     {
  165.         if (( count % 2 ))
  166.         {
  167.             cairo_pattern_add_color_stop_rgb(pat1, j, 0, 0, 0);
  168.         }
  169.         else {
  170.           cairo_pattern_add_color_stop_rgb(pat1, j, 1, 0, 0);
  171.         }
  172.         count++;
  173.     }
  174.  
  175.     cairo_rectangle(cr, 20, 20, 300, 100);
  176.     cairo_set_source(cr, pat1);
  177.     cairo_fill(cr);
  178.  
  179.     pat2 = cairo_pattern_create_linear(0.0, 0.0,  350.0, 0.0);
  180.  
  181.     double i;
  182.     count = 1;
  183.     for ( i = 0.05; i < 0.95; i += 0.025 )
  184.     {
  185.         if (( count % 2 ))
  186.         {
  187.             cairo_pattern_add_color_stop_rgb(pat2, i, 0, 0, 0);
  188.         }
  189.         else {
  190.             cairo_pattern_add_color_stop_rgb(pat2, i, 0, 0, 1);
  191.         }
  192.         count++;
  193.     }
  194.  
  195.     cairo_rectangle(cr, 20, 140, 300, 100);
  196.     cairo_set_source(cr, pat2);
  197.     cairo_fill(cr);
  198.  
  199.     pat3 = cairo_pattern_create_linear(20.0, 260.0, 20.0, 360.0);
  200.  
  201.     cairo_pattern_add_color_stop_rgb(pat3, 0.1, 0, 0, 0);
  202.     cairo_pattern_add_color_stop_rgb(pat3, 0.5, 1, 1, 0);
  203.     cairo_pattern_add_color_stop_rgb(pat3, 0.9, 0, 0, 0);
  204.  
  205.     cairo_rectangle(cr, 20, 260, 300, 100);
  206.     cairo_set_source(cr, pat3);
  207.     cairo_fill(cr);
  208.  
  209.     cairo_pattern_destroy(pat1);
  210.     cairo_pattern_destroy(pat2);
  211.     cairo_pattern_destroy(pat3);
  212.  
  213.     draw_next_msg(cr, width, height);
  214.  
  215. };
  216.  
  217. static void screen_3(cairo_t *cr, int width, int height)
  218. {
  219.     cairo_translate(cr, 110,20);
  220.     cairo_set_source_rgb(cr, 1, 1,1);
  221.     cairo_paint(cr);
  222.  
  223.     cairo_set_source_rgb(cr, 0, 0, 0);
  224.     cairo_set_line_width(cr, 10);
  225.  
  226.     cairo_move_to (cr, 128.0, 25.6);
  227.     cairo_line_to (cr, 230.4, 230.4);
  228.     cairo_rel_line_to (cr, -102.4, 0.0);
  229.     cairo_curve_to (cr, 51.2, 230.4, 51.2, 128.0, 128.0, 128.0);
  230.     cairo_close_path (cr);
  231.  
  232.     cairo_move_to (cr, 64.0, 25.6);
  233.     cairo_rel_line_to (cr, 51.2, 51.2);
  234.     cairo_rel_line_to (cr, -51.2, 51.2);
  235.     cairo_rel_line_to (cr, -51.2, -51.2);
  236.     cairo_close_path (cr);
  237.  
  238.     cairo_set_line_width (cr, 10.0);
  239.     cairo_set_source_rgb (cr, 0, 0, 1);
  240.     cairo_fill_preserve (cr);
  241.     cairo_set_source_rgb (cr, 0, 0, 0);
  242.     cairo_stroke (cr);
  243.  
  244.     draw_next_msg(cr, width, height);
  245. }
  246.  
  247. static void screen_hello(cairo_t *cr, int width, int height)
  248. {
  249.     cairo_set_source_rgb(cr, 0.7, 0.7, 0.7);
  250.     cairo_paint(cr);
  251.  
  252.     cairo_set_line_width(cr, 1);
  253.  
  254.     cairo_select_font_face (cr, "cairo:sans", CAIRO_FONT_SLANT_NORMAL,
  255.                                CAIRO_FONT_WEIGHT_BOLD);
  256.  
  257.     cairo_set_font_size (cr, 200);
  258.  
  259.     cairo_set_source_rgb(cr, 0, 1.0,0);
  260.  
  261.     cairo_move_to (cr, 20.0, 145.0);
  262.     cairo_show_text (cr, "Hello");
  263.  
  264. #if 0
  265.     cairo_move_to (cr, 70.0, 170.0);
  266.     cairo_text_path (cr, "world");
  267.     cairo_set_source_rgb (cr, 0.5, 0.5, 1);
  268.     cairo_fill_preserve (cr);
  269.     cairo_set_source_rgb (cr, 0, 0, 0);
  270.     cairo_set_line_width (cr, 2.56);
  271.     cairo_stroke (cr);
  272.  
  273.  
  274. #else
  275.     cairo_set_font_size (cr, 140);
  276.     cairo_set_source_rgb (cr, 0, 0, 1);
  277.     cairo_move_to (cr, 80.0, 175.0);
  278.     cairo_show_text (cr, "world");
  279. #endif
  280.  
  281.     cairo_identity_matrix (cr);
  282.  
  283.     cairo_select_font_face (cr, "cairo:sans", CAIRO_FONT_SLANT_NORMAL,
  284.                                CAIRO_FONT_WEIGHT_BOLD);
  285.     cairo_set_font_size (cr, 16);
  286.     cairo_set_source_rgb (cr, 0, 0, 1);
  287.     cairo_move_to (cr, 160.0, 210.0);
  288.     cairo_show_text (cr, "www.cairographics.org");
  289.  
  290.     draw_next_msg(cr, width, height);
  291. };
  292.  
  293. static void draw_tiger(cairo_t *cr, int width, int height)
  294. {
  295.         unsigned int i;
  296.  
  297.         cairo_set_operator (cr, CAIRO_OPERATOR_SOURCE);
  298.         cairo_set_source_rgba (cr, 0.1, 0.2, 0.3, 1.0);
  299.         cairo_paint (cr);
  300.         cairo_set_operator (cr, CAIRO_OPERATOR_OVER);
  301.  
  302.         cairo_translate (cr, width/3, height/3);
  303.         cairo_scale (cr, .85, .85);
  304.  
  305.         for (i = 0; i < sizeof (tiger_commands)/sizeof(tiger_commands[0]);i++) {
  306.                 const struct command *cmd = &tiger_commands[i];
  307.                 switch (cmd->type) {
  308.                 case 'm':
  309.                         cairo_move_to (cr, cmd->x0, cmd->y0);
  310.                         break;
  311.                 case 'l':
  312.                         cairo_line_to (cr, cmd->x0, cmd->y0);
  313.                         break;
  314.                 case 'c':
  315.                         cairo_curve_to (cr,
  316.                                         cmd->x0, cmd->y0,
  317.                                         cmd->x1, cmd->y1,
  318.                                         cmd->x2, cmd->y2);
  319.                         break;
  320.                 case 'f':
  321.                         cairo_set_source_rgba (cr,
  322.                                                cmd->x0, cmd->y0, cmd->x1, cmd->y1);
  323.                         cairo_fill (cr);
  324.                         break;
  325.                 }
  326.         }
  327. }
  328.  
  329. static void (*draw_screen[5])(cairo_t *cr, int width, int height)=
  330.     {
  331.         screen_0,
  332.         screen_1,
  333.         screen_2,
  334.         screen_3,
  335.         draw_tiger
  336.     };
  337.  
  338.  
  339. int check_events(cairo_t *cr)
  340. {
  341.     uint32_t ev;
  342.     oskey_t   key;
  343.     int retval = 1;
  344.  
  345.     ev = get_os_event();
  346.  
  347.     switch(ev)
  348.     {
  349.         case 1:
  350.             BeginDraw();
  351.             DrawWindow(0,0,0,0,NULL,0,0x73);
  352.             Blit(winbitmap, TYPE_3_BORDER_WIDTH, get_skin_height(),
  353.                  0, 0, width, height,width,height,winstride);
  354.             EndDraw();
  355.             break;
  356.  
  357.         case 2:
  358.             key = get_key();
  359.  
  360.             if(1 == key.val)
  361.                 break;
  362.  
  363.             if(0x8000 & key.val)
  364.                 break;
  365.  
  366.             if(0x0100 == key.val)
  367.             {
  368.                 retval = 0;
  369.                 break;
  370.             };
  371.             if(++screen > 4){screen = 0;};
  372.             draw_screen[screen](cr,width,height);
  373.             Blit(winbitmap, TYPE_3_BORDER_WIDTH, get_skin_height(),
  374.                  0, 0, width, height,width,height,winstride);
  375.             break;
  376.  
  377.         case 3:
  378.             if(get_os_button()==1)
  379.                 retval = 0;
  380.             break;
  381.     };
  382.     return retval;
  383. }
  384.  
  385. #if 0
  386. static void rounded_flat(cairo_t *cr, int x, int y, int w, int h)
  387. {
  388.     double radius = 4;
  389.     double degrees = M_PI / 180.0;
  390.  
  391.     cairo_new_sub_path (cr);
  392.     cairo_arc (cr, x + w - radius, y + radius, radius, -90 * degrees, 0 * degrees);
  393.     cairo_arc (cr, x + w - radius, y + h - radius, radius, 0 * degrees, 90 * degrees);
  394.     cairo_arc (cr, x +radius, y + h - radius, radius, 90 * degrees, 180 * degrees);
  395.     cairo_arc (cr, x +radius, y + radius, radius, 180 * degrees, 270 * degrees);
  396.     cairo_close_path (cr);
  397.  
  398.     cairo_set_source_rgb (cr, 0.8, 0.8, 0.8);
  399.     cairo_fill_preserve (cr);
  400.     cairo_set_source_rgba (cr, 0.2, 0.2, 0.2, 0.5);
  401.     cairo_set_line_width (cr, 2.0);
  402.     cairo_stroke (cr);
  403. };
  404.  
  405. static void rounded(cairo_t *cr, int x, int y, int w, int h)
  406. {
  407.     cairo_pattern_t *pat;
  408.     double radius = 5;
  409.     double degrees = M_PI / 180.0;
  410.  
  411.     pat = cairo_pattern_create_linear (x, y,  x, y+h);
  412.     cairo_pattern_add_color_stop_rgb (pat, 0, 0.7, 0.7, 0.7);
  413.     cairo_pattern_add_color_stop_rgb (pat, 0.125, 0.85, 0.85, 0.85);
  414.     cairo_pattern_add_color_stop_rgb (pat, 0.25, 1.0, 1.0, 1.0);
  415.     cairo_pattern_add_color_stop_rgb (pat, 0.75, 1.0, 1.0, 1.0);
  416.     cairo_pattern_add_color_stop_rgb (pat, 1, 0.6, 0.6, 0.6);
  417.  
  418.     cairo_new_sub_path (cr);
  419.     cairo_arc (cr, x + w - radius, y + radius, radius, -90 * degrees, 0 * degrees);
  420.     cairo_arc (cr, x + w - radius, y + h - radius, radius, 0 * degrees, 90 * degrees);
  421.     cairo_arc (cr, x +radius, y + h - radius, radius, 90 * degrees, 180 * degrees);
  422.     cairo_arc (cr, x +radius, y + radius, radius, 180 * degrees, 270 * degrees);
  423.     cairo_close_path (cr);
  424.  
  425.     cairo_set_source (cr, pat);
  426.     cairo_fill_preserve (cr);
  427.  
  428.     cairo_set_source_rgba (cr, 0.3, 0.3, 0.3, 0.5);
  429.     cairo_set_line_width (cr, 1.0);
  430.     cairo_stroke (cr);
  431.     cairo_pattern_destroy (pat);
  432. };
  433.  
  434. static void rounded_hl(cairo_t *cr, int x, int y, int w, int h)
  435. {
  436.     cairo_pattern_t *pat;
  437.     double radius = 5;
  438.     double degrees = M_PI / 180.0;
  439.  
  440.     pat = cairo_pattern_create_linear (x, y,  x, y+h);
  441.     cairo_pattern_add_color_stop_rgb (pat, 0, 0.7, 0.7, 0.7);
  442.     cairo_pattern_add_color_stop_rgb (pat, 0.125, 0.85, 0.85, 0.85);
  443.     cairo_pattern_add_color_stop_rgb (pat, 0.25, 1.0, 1.0, 1.0);
  444.     cairo_pattern_add_color_stop_rgb (pat, 0.75, 1.0, 1.0, 1.0);
  445.     cairo_pattern_add_color_stop_rgb (pat, 1, 0.6, 0.6, 0.6);
  446.  
  447.     cairo_new_sub_path (cr);
  448.     cairo_arc (cr, x + w - radius, y + radius, radius, -90 * degrees, 0 * degrees);
  449.     cairo_arc (cr, x + w - radius, y + h - radius, radius, 0 * degrees, 90 * degrees);
  450.     cairo_arc (cr, x +radius, y + h - radius, radius, 90 * degrees, 180 * degrees);
  451.     cairo_arc (cr, x +radius, y + radius, radius, 180 * degrees, 270 * degrees);
  452.     cairo_close_path (cr);
  453.  
  454.     cairo_set_source (cr, pat);
  455.     cairo_fill_preserve (cr);
  456.  
  457.     cairo_set_source_rgba (cr, 0, 0.6, 1, 1);
  458.     cairo_set_line_width (cr, 2.0);
  459.     cairo_stroke (cr);
  460.     cairo_pattern_destroy (pat);
  461.  
  462.     cairo_select_font_face (cr, "cairo:monospace", CAIRO_FONT_SLANT_NORMAL,
  463.                                CAIRO_FONT_WEIGHT_BOLD);
  464.  
  465.     cairo_text_extents_t extents;
  466.  
  467.     cairo_set_font_size (cr, 20);
  468.     cairo_text_extents (cr, "Cancel", &extents);
  469.  
  470.     x+= w/2 -(extents.width/2 + extents.x_bearing);
  471.     y+= h/2 - (extents.height/2 + extents.y_bearing);
  472.  
  473.     cairo_move_to (cr, x, y );
  474.     cairo_set_source_rgb (cr, 0, 0, 0);
  475.  
  476.     cairo_show_text (cr, "Cancel");
  477.     cairo_set_source_rgb (cr, 0, 0, 0);
  478. };
  479. #endif
  480.  
  481. static cairo_surface_t* main_surface_create(int width, int height)
  482. {
  483.  
  484.     cairo_surface_t *surface;
  485.  
  486.     surface = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, width, height);
  487.  
  488.     return surface;
  489. }
  490.  
  491. int main ()
  492. {
  493.     int tmp;
  494.     cairo_t *cr;
  495.  
  496.     __asm__ __volatile__(
  497.     "int $0x40"
  498.     :"=a"(tmp)
  499.     :"a"(66),"b"(1),"c"(1));
  500.  
  501.     __asm__ __volatile__(
  502.     "int $0x40"
  503.     ::"a"(40), "b"(0xc0000027));
  504.  
  505.     main_surface = main_surface_create(width, height);
  506.     cr = cairo_create(main_surface);
  507.  
  508.     winstride = cairo_image_surface_get_stride(main_surface);
  509.     winbitmap = cairo_image_surface_get_data(main_surface);
  510.  
  511.     screen_hello(cr,width,height);
  512.  
  513.     BeginDraw();
  514.     DrawWindow(30, 40, width+TYPE_3_BORDER_WIDTH*2,
  515.                height+TYPE_3_BORDER_WIDTH+get_skin_height(), "Cairo demo", 0x000000, 0x73);
  516.     Blit(winbitmap, TYPE_3_BORDER_WIDTH, get_skin_height(), 0, 0, width, height,
  517.          width,height,winstride);
  518.     EndDraw();
  519.  
  520.     while( check_events(cr));
  521.  
  522.     cairo_destroy(cr);
  523.     cairo_surface_destroy(main_surface);
  524.  
  525.     return 0;
  526. }
  527.