Subversion Repositories HelenOS

Rev

Rev 4419 | Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed

  1. /*
  2.  * Copyright (c) 2006 Ondrej Palkovsky
  3.  * All rights reserved.
  4.  *
  5.  * Redistribution and use in source and binary forms, with or without
  6.  * modification, are permitted provided that the following conditions
  7.  * are met:
  8.  *
  9.  * - Redistributions of source code must retain the above copyright
  10.  *   notice, this list of conditions and the following disclaimer.
  11.  * - Redistributions in binary form must reproduce the above copyright
  12.  *   notice, this list of conditions and the following disclaimer in the
  13.  *   documentation and/or other materials provided with the distribution.
  14.  * - The name of the author may not be used to endorse or promote products
  15.  *   derived from this software without specific prior written permission.
  16.  *
  17.  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  18.  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  19.  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  20.  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  21.  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  22.  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  23.  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  24.  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  25.  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  26.  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27.  */
  28.  
  29. /** @addtogroup console
  30.  * @{
  31.  */
  32. /** @file
  33.  */
  34.  
  35. #include <ipc/fb.h>
  36. #include <ipc/ipc.h>
  37. #include <async.h>
  38. #include <stdio.h>
  39. #include <sys/mman.h>
  40. #include <string.h>
  41. #include <align.h>
  42.  
  43. #include "console.h"
  44. #include "gcons.h"
  45.  
  46. #define CONSOLE_TOP     66
  47. #define CONSOLE_MARGIN  6
  48.  
  49. #define STATUS_START   110
  50. #define STATUS_TOP     8
  51. #define STATUS_SPACE   4
  52. #define STATUS_WIDTH   48
  53. #define STATUS_HEIGHT  48
  54.  
  55. #define MAIN_COLOR  0xffffff
  56.  
  57. static int use_gcons = 0;
  58. static ipcarg_t xres,yres;
  59.  
  60. enum butstate {
  61.     CONS_DISCONNECTED = 0,
  62.     CONS_SELECTED,
  63.     CONS_IDLE,
  64.     CONS_HAS_DATA,
  65.     CONS_KERNEL,
  66.     CONS_DISCONNECTED_SEL,
  67.     CONS_LAST
  68. };
  69.  
  70. static int console_vp;
  71. static int cstatus_vp[CONSOLE_COUNT];
  72. static enum butstate console_state[CONSOLE_COUNT];
  73.  
  74. static int fbphone;
  75.  
  76. /** List of pixmaps identifying these icons */
  77. static int ic_pixmaps[CONS_LAST] = {-1, -1, -1, -1, -1, -1};
  78. static int animation = -1;
  79.  
  80. static int active_console = 0;
  81.  
  82. static void vp_switch(int vp)
  83. {
  84.     async_msg_1(fbphone, FB_VIEWPORT_SWITCH, vp);
  85. }
  86.  
  87. /** Create view port */
  88. static int vp_create(unsigned int x, unsigned int y, unsigned int width,
  89.     unsigned int height)
  90. {
  91.     return async_req_2_0(fbphone, FB_VIEWPORT_CREATE, (x << 16) | y,
  92.         (width << 16) | height);
  93. }
  94.  
  95. static void clear(void)
  96. {
  97.     async_msg_0(fbphone, FB_CLEAR);
  98. }
  99.  
  100. static void set_rgb_color(int fgcolor, int bgcolor)
  101. {
  102.     async_msg_2(fbphone, FB_SET_RGB_COLOR, fgcolor, bgcolor);
  103. }
  104.  
  105. /** Transparent putchar */
  106. static void tran_putch(char c, int row, int col)
  107. {
  108.     async_msg_3(fbphone, FB_PUTCHAR, c, row, col);
  109. }
  110.  
  111. /** Redraw the button showing state of a given console */
  112. static void redraw_state(int consnum)
  113. {
  114.     char data[5];
  115.     int i;
  116.     enum butstate state = console_state[consnum];
  117.    
  118.     vp_switch(cstatus_vp[consnum]);
  119.     if (ic_pixmaps[state] != -1)
  120.         async_msg_2(fbphone, FB_VP_DRAW_PIXMAP, cstatus_vp[consnum],
  121.             ic_pixmaps[state]);
  122.    
  123.     if (state != CONS_DISCONNECTED && state != CONS_KERNEL &&
  124.         state != CONS_DISCONNECTED_SEL) {
  125.         snprintf(data, 5, "%d", consnum + 1);
  126.         for (i = 0; data[i]; i++)
  127.             tran_putch(data[i], 1, 2 + i);
  128.     }
  129. }
  130.  
  131. /** Notification run on changing console (except kernel console) */
  132. void gcons_change_console(int consnum)
  133. {
  134.     int i;
  135.    
  136.     if (!use_gcons)
  137.         return;
  138.    
  139.     if (active_console == KERNEL_CONSOLE) {
  140.         for (i = 0; i < CONSOLE_COUNT; i++)
  141.             redraw_state(i);
  142.         if (animation != -1)
  143.             async_msg_1(fbphone, FB_ANIM_START, animation);
  144.     } else {
  145.         if (console_state[active_console] == CONS_DISCONNECTED_SEL)
  146.             console_state[active_console] = CONS_DISCONNECTED;
  147.         else
  148.             console_state[active_console] = CONS_IDLE;
  149.         redraw_state(active_console);
  150.     }
  151.     active_console = consnum;
  152.    
  153.     if (console_state[consnum] == CONS_DISCONNECTED) {
  154.         console_state[consnum] = CONS_DISCONNECTED_SEL;
  155.         redraw_state(consnum);
  156.     } else
  157.         console_state[consnum] = CONS_SELECTED;
  158.     redraw_state(consnum);
  159.    
  160.     vp_switch(console_vp);
  161. }
  162.  
  163. /** Notification function that gets called on new output to virtual console */
  164. void gcons_notify_char(int consnum)
  165. {
  166.     if (!use_gcons)
  167.         return;
  168.    
  169.     if ((consnum == active_console) ||
  170.         (console_state[consnum] == CONS_HAS_DATA))
  171.         return;
  172.    
  173.     console_state[consnum] = CONS_HAS_DATA;
  174.    
  175.     if (active_console == KERNEL_CONSOLE)
  176.         return;
  177.    
  178.     redraw_state(consnum);
  179.    
  180.     vp_switch(console_vp);
  181. }
  182.  
  183. /** Notification function called on service disconnect from console */
  184. void gcons_notify_disconnect(int consnum)
  185. {
  186.     if (!use_gcons)
  187.         return;
  188.    
  189.     if (active_console == consnum)
  190.         console_state[consnum] = CONS_DISCONNECTED_SEL;
  191.     else
  192.         console_state[consnum] = CONS_DISCONNECTED;
  193.    
  194.     if (active_console == KERNEL_CONSOLE)
  195.         return;
  196.    
  197.     redraw_state(consnum);
  198.     vp_switch(console_vp);
  199. }
  200.  
  201. /** Notification function called on console connect */
  202. void gcons_notify_connect(int consnum)
  203. {
  204.     if (!use_gcons)
  205.         return;
  206.    
  207.     if (active_console == consnum)
  208.         console_state[consnum] = CONS_SELECTED;
  209.     else
  210.         console_state[consnum] = CONS_IDLE;
  211.    
  212.     if (active_console == KERNEL_CONSOLE)
  213.         return;
  214.    
  215.     redraw_state(consnum);
  216.     vp_switch(console_vp);
  217. }
  218.  
  219. /** Change to kernel console */
  220. void gcons_in_kernel(void)
  221. {
  222.     if (animation != -1)
  223.         async_msg_1(fbphone, FB_ANIM_STOP, animation);
  224.    
  225.     active_console = KERNEL_CONSOLE;
  226.     vp_switch(0);
  227. }
  228.  
  229. /** Return x, where left <= x <= right && |a-x|==min(|a-x|) is smallest */
  230. static inline int limit(int a, int left, int right)
  231. {
  232.     if (a < left)
  233.         a = left;
  234.     if (a >= right)
  235.         a = right - 1;
  236.     return a;
  237. }
  238.  
  239. int mouse_x, mouse_y;
  240. int btn_pressed, btn_x, btn_y;
  241.  
  242. /** Handle mouse move
  243.  *
  244.  * @param dx Delta X of mouse move
  245.  * @param dy Delta Y of mouse move
  246.  */
  247. void gcons_mouse_move(int dx, int dy)
  248. {
  249.     mouse_x = limit(mouse_x + dx, 0, xres);
  250.     mouse_y = limit(mouse_y + dy, 0, yres);
  251.    
  252.     async_msg_2(fbphone, FB_POINTER_MOVE, mouse_x, mouse_y);
  253. }
  254.  
  255. static int gcons_find_conbut(int x, int y)
  256. {
  257.     int status_start = STATUS_START + (xres - 800) / 2;
  258.    
  259.     if ((y < STATUS_TOP) || (y >= STATUS_TOP + STATUS_HEIGHT))
  260.         return -1;
  261.    
  262.     if (x < status_start)
  263.         return -1;
  264.    
  265.     if (x >= status_start + (STATUS_WIDTH + STATUS_SPACE) * CONSOLE_COUNT)
  266.         return -1;
  267.     if (((x - status_start) % (STATUS_WIDTH + STATUS_SPACE)) < STATUS_SPACE)
  268.         return -1;
  269.    
  270.     return (x - status_start) / (STATUS_WIDTH + STATUS_SPACE);
  271. }
  272.  
  273. /** Handle mouse click
  274.  *
  275.  * @param state New state (1-pressed, 0-depressed)
  276.  */
  277. int gcons_mouse_btn(int state)
  278. {
  279.     int conbut;
  280.    
  281.     if (state) {
  282.         conbut = gcons_find_conbut(mouse_x, mouse_y);
  283.         if (conbut != -1) {
  284.             btn_pressed = 1;
  285.             btn_x = mouse_x;
  286.             btn_y = mouse_y;
  287.         }
  288.         return -1;
  289.     }
  290.    
  291.     if ((!state) && (!btn_pressed))
  292.         return -1;
  293.    
  294.     btn_pressed = 0;
  295.    
  296.     conbut = gcons_find_conbut(mouse_x, mouse_y);
  297.     if (conbut == gcons_find_conbut(btn_x, btn_y))
  298.         return conbut;
  299.    
  300.     return -1;
  301. }
  302.  
  303.  
  304. /** Draw a PPM pixmap to framebuffer
  305.  *
  306.  * @param logo Pointer to PPM data
  307.  * @param size Size of PPM data
  308.  * @param x Coordinate of upper left corner
  309.  * @param y Coordinate of upper left corner
  310.  */
  311. static void draw_pixmap(char *logo, size_t size, int x, int y)
  312. {
  313.     char *shm;
  314.     int rc;
  315.    
  316.     /* Create area */
  317.     shm = mmap(NULL, size, PROTO_READ | PROTO_WRITE, MAP_SHARED |
  318.         MAP_ANONYMOUS, 0, 0);
  319.     if (shm == MAP_FAILED)
  320.         return;
  321.    
  322.     memcpy(shm, logo, size);
  323.    
  324.     /* Send area */
  325.     rc = async_req_1_0(fbphone, FB_PREPARE_SHM, (ipcarg_t) shm);
  326.     if (rc)
  327.         goto exit;
  328.    
  329.     rc = ipc_share_out_start(fbphone, shm, PROTO_READ);
  330.     if (rc)
  331.         goto drop;
  332.    
  333.     /* Draw logo */
  334.     async_msg_2(fbphone, FB_DRAW_PPM, x, y);
  335.    
  336. drop:
  337.     /* Drop area */
  338.     async_msg_0(fbphone, FB_DROP_SHM);
  339.    
  340. exit:
  341.     /* Remove area */
  342.     munmap(shm, size);
  343. }
  344.  
  345. extern char _binary_gfx_helenos_ppm_start[0];
  346. extern int _binary_gfx_helenos_ppm_size;
  347. extern char _binary_gfx_nameic_ppm_start[0];
  348. extern int _binary_gfx_nameic_ppm_size;
  349.  
  350. /** Redraws console graphics */
  351. void gcons_redraw_console(void)
  352. {
  353.     int i;
  354.    
  355.     if (!use_gcons)
  356.         return;
  357.    
  358.     vp_switch(0);
  359.     set_rgb_color(MAIN_COLOR, MAIN_COLOR);
  360.     clear();
  361.     draw_pixmap(_binary_gfx_helenos_ppm_start,
  362.         (size_t) &_binary_gfx_helenos_ppm_size, xres - 66, 2);
  363.     draw_pixmap(_binary_gfx_nameic_ppm_start,
  364.         (size_t) &_binary_gfx_nameic_ppm_size, 5, 17);
  365.    
  366.     for (i = 0; i < CONSOLE_COUNT; i++)
  367.         redraw_state(i);
  368.    
  369.     vp_switch(console_vp);
  370. }
  371.  
  372. /** Creates a pixmap on framebuffer
  373.  *
  374.  * @param data PPM data
  375.  * @param size PPM data size
  376.  * @return Pixmap identification
  377.  */
  378. static int make_pixmap(char *data, int size)
  379. {
  380.     char *shm;
  381.     int rc;
  382.     int pxid = -1;
  383.    
  384.     /* Create area */
  385.     shm = mmap(NULL, size, PROTO_READ | PROTO_WRITE, MAP_SHARED |
  386.         MAP_ANONYMOUS, 0, 0);
  387.     if (shm == MAP_FAILED)
  388.         return -1;
  389.    
  390.     memcpy(shm, data, size);
  391.    
  392.     /* Send area */
  393.     rc = async_req_1_0(fbphone, FB_PREPARE_SHM, (ipcarg_t) shm);
  394.     if (rc)
  395.         goto exit;
  396.    
  397.     rc = ipc_share_out_start(fbphone, shm, PROTO_READ);
  398.     if (rc)
  399.         goto drop;
  400.    
  401.     /* Obtain pixmap */
  402.     rc = async_req_0_0(fbphone, FB_SHM2PIXMAP);
  403.     if (rc < 0)
  404.         goto drop;
  405.    
  406.     pxid = rc;
  407.    
  408. drop:
  409.     /* Drop area */
  410.     async_msg_0(fbphone, FB_DROP_SHM);
  411.    
  412. exit:
  413.     /* Remove area */
  414.     munmap(shm, size);
  415.    
  416.     return pxid;
  417. }
  418.  
  419. extern char _binary_gfx_anim_1_ppm_start[0];
  420. extern int _binary_gfx_anim_1_ppm_size;
  421. extern char _binary_gfx_anim_2_ppm_start[0];
  422. extern int _binary_gfx_anim_2_ppm_size;
  423. extern char _binary_gfx_anim_3_ppm_start[0];
  424. extern int _binary_gfx_anim_3_ppm_size;
  425. extern char _binary_gfx_anim_4_ppm_start[0];
  426. extern int _binary_gfx_anim_4_ppm_size;
  427.  
  428. static void make_anim(void)
  429. {
  430.     int an = async_req_1_0(fbphone, FB_ANIM_CREATE, cstatus_vp[KERNEL_CONSOLE]);
  431.     if (an < 0)
  432.         return;
  433.    
  434.     int pm = make_pixmap(_binary_gfx_anim_1_ppm_start,
  435.         (int) &_binary_gfx_anim_1_ppm_size);
  436.     async_msg_2(fbphone, FB_ANIM_ADDPIXMAP, an, pm);
  437.    
  438.     pm = make_pixmap(_binary_gfx_anim_2_ppm_start,
  439.         (int) &_binary_gfx_anim_2_ppm_size);
  440.     async_msg_2(fbphone, FB_ANIM_ADDPIXMAP, an, pm);
  441.    
  442.     pm = make_pixmap(_binary_gfx_anim_3_ppm_start,
  443.         (int) &_binary_gfx_anim_3_ppm_size);
  444.     async_msg_2(fbphone, FB_ANIM_ADDPIXMAP, an, pm);
  445.    
  446.     pm = make_pixmap(_binary_gfx_anim_4_ppm_start,
  447.         (int) &_binary_gfx_anim_4_ppm_size);
  448.     async_msg_2(fbphone, FB_ANIM_ADDPIXMAP, an, pm);
  449.    
  450.     async_msg_1(fbphone, FB_ANIM_START, an);
  451.    
  452.     animation = an;
  453. }
  454.  
  455. extern char _binary_gfx_cons_selected_ppm_start[0];
  456. extern int _binary_gfx_cons_selected_ppm_size;
  457. extern char _binary_gfx_cons_idle_ppm_start[0];
  458. extern int _binary_gfx_cons_idle_ppm_size;
  459. extern char _binary_gfx_cons_has_data_ppm_start[0];
  460. extern int _binary_gfx_cons_has_data_ppm_size;
  461. extern char _binary_gfx_cons_kernel_ppm_start[0];
  462. extern int _binary_gfx_cons_kernel_ppm_size;
  463.  
  464. /** Initialize nice graphical console environment */
  465. void gcons_init(int phone)
  466. {
  467.     int rc;
  468.     int i;
  469.     int status_start = STATUS_START;
  470.    
  471.     fbphone = phone;
  472.    
  473.     rc = async_req_0_2(phone, FB_GET_RESOLUTION, &xres, &yres);
  474.     if (rc)
  475.         return;
  476.    
  477.     if ((xres < 800) || (yres < 600))
  478.         return;
  479.    
  480.     /* Create console viewport */
  481.    
  482.     /* Align width & height to character size */
  483.     console_vp = vp_create(CONSOLE_MARGIN, CONSOLE_TOP,
  484.         ALIGN_DOWN(xres - 2 * CONSOLE_MARGIN, 8),
  485.         ALIGN_DOWN(yres - (CONSOLE_TOP + CONSOLE_MARGIN), 16));
  486.     if (console_vp < 0)
  487.         return;
  488.    
  489.     /* Create status buttons */
  490.     status_start += (xres - 800) / 2;
  491.     for (i = 0; i < CONSOLE_COUNT; i++) {
  492.         cstatus_vp[i] = vp_create(status_start + CONSOLE_MARGIN +
  493.             i * (STATUS_WIDTH + STATUS_SPACE), STATUS_TOP,
  494.             STATUS_WIDTH, STATUS_HEIGHT);
  495.         if (cstatus_vp[i] < 0)
  496.             return;
  497.         vp_switch(cstatus_vp[i]);
  498.         set_rgb_color(0x202020, 0xffffff);
  499.     }
  500.    
  501.     /* Initialize icons */
  502.     ic_pixmaps[CONS_SELECTED] =
  503.         make_pixmap(_binary_gfx_cons_selected_ppm_start,
  504.         (int) &_binary_gfx_cons_selected_ppm_size);
  505.     ic_pixmaps[CONS_IDLE] =
  506.         make_pixmap(_binary_gfx_cons_idle_ppm_start,
  507.         (int) &_binary_gfx_cons_idle_ppm_size);
  508.     ic_pixmaps[CONS_HAS_DATA] =
  509.         make_pixmap(_binary_gfx_cons_has_data_ppm_start,
  510.         (int) &_binary_gfx_cons_has_data_ppm_size);
  511.     ic_pixmaps[CONS_DISCONNECTED] =
  512.         make_pixmap(_binary_gfx_cons_idle_ppm_start,
  513.         (int) &_binary_gfx_cons_idle_ppm_size);
  514.     ic_pixmaps[CONS_KERNEL] =
  515.         make_pixmap(_binary_gfx_cons_kernel_ppm_start,
  516.         (int) &_binary_gfx_cons_kernel_ppm_size);
  517.     ic_pixmaps[CONS_DISCONNECTED_SEL] = ic_pixmaps[CONS_SELECTED];
  518.    
  519.     make_anim();
  520.    
  521.     use_gcons = 1;
  522.     console_state[0] = CONS_DISCONNECTED_SEL;
  523.     console_state[KERNEL_CONSOLE] = CONS_KERNEL;
  524.     gcons_redraw_console();
  525. }
  526.  
  527. /** @}
  528.  */
  529.