← Back to branch summary

~ubuntu-branches/debian/stretch/grub2/stretch

« back to all changes in this revision

Viewing changes to term/gfxterm.c

Tags: upstream-1.98+20100705
Import upstream version 1.98+20100705

Show diffs side-by-side

added added

removed removed

Lines of Context:
term/gfxterm.c
35
35
#define DEFAULT_BORDER_WIDTH    10
36
36
 
37
37
#define DEFAULT_STANDARD_COLOR  0x07
38
 
#define DEFAULT_NORMAL_COLOR    0x07
39
 
#define DEFAULT_HIGHLIGHT_COLOR 0x70
40
38
 
41
39
struct grub_dirty_region
42
40
{
49
47
struct grub_colored_char
50
48
{
51
49
  /* An Unicode codepoint.  */
52
 
  grub_uint32_t code;
 
50
  struct grub_unicode_glyph *code;
53
51
 
54
52
  /* Color values.  */
55
53
  grub_video_color_t fg_color;
92
90
 
93
91
  /* Terminal color settings.  */
94
92
  grub_uint8_t standard_color_setting;
95
 
  grub_uint8_t normal_color_setting;
96
 
  grub_uint8_t highlight_color_setting;
97
93
  grub_uint8_t term_color;
98
94
 
99
95
  /* Color settings.  */
146
142
 
147
143
static unsigned char calculate_character_width (struct grub_font_glyph *glyph);
148
144
 
149
 
static void grub_gfxterm_refresh (void);
 
145
static void grub_gfxterm_refresh (struct grub_term_output *term __attribute__ ((unused)));
 
146
 
 
147
static grub_ssize_t
 
148
grub_gfxterm_getcharwidth (struct grub_term_output *term __attribute__ ((unused)),
 
149
                           const struct grub_unicode_glyph *c);
150
150
 
151
151
static void
152
152
set_term_color (grub_uint8_t term_color)
177
177
static void
178
178
clear_char (struct grub_colored_char *c)
179
179
{
180
 
  c->code = ' ';
 
180
  grub_free (c->code);
 
181
  c->code = grub_unicode_glyph_from_code (' ');
 
182
  if (!c->code)
 
183
    grub_errno = GRUB_ERR_NONE;
181
184
  c->fg_color = virtual_screen.fg_color;
182
185
  c->bg_color = virtual_screen.bg_color;
183
186
  c->width = 0;
253
256
  grub_video_set_active_render_target (text_layer);
254
257
 
255
258
  virtual_screen.standard_color_setting = DEFAULT_STANDARD_COLOR;
256
 
  virtual_screen.normal_color_setting = DEFAULT_NORMAL_COLOR;
257
 
  virtual_screen.highlight_color_setting = DEFAULT_HIGHLIGHT_COLOR;
258
259
 
259
 
  virtual_screen.term_color = virtual_screen.normal_color_setting;
 
260
  virtual_screen.term_color = GRUB_TERM_DEFAULT_NORMAL_COLOR;
260
261
 
261
262
  set_term_color (virtual_screen.term_color);
262
263
 
266
267
 
267
268
  /* Clear out text buffer. */
268
269
  for (i = 0; i < virtual_screen.columns * virtual_screen.rows; i++)
269
 
    clear_char (&(virtual_screen.text_buffer[i]));
 
270
    {
 
271
      virtual_screen.text_buffer[i].code = 0;
 
272
      clear_char (&(virtual_screen.text_buffer[i]));
 
273
    }
270
274
 
271
275
  return grub_errno;
272
276
}
355
359
}
356
360
 
357
361
static grub_err_t
358
 
grub_gfxterm_term_init (void)
 
362
grub_gfxterm_term_init (struct grub_term_output *term __attribute__ ((unused)))
359
363
{
360
364
  char *tmp;
361
365
  grub_err_t err;
399
403
}
400
404
 
401
405
static grub_err_t
402
 
grub_gfxterm_term_fini (void)
 
406
grub_gfxterm_term_fini (struct grub_term_output *term __attribute__ ((unused)))
403
407
{
404
408
  destroy_window ();
405
409
  grub_video_restore ();
611
615
  p -= p->index;
612
616
 
613
617
  /* Get glyph for character.  */
614
 
  glyph = grub_font_get_glyph (virtual_screen.font, p->code);
 
618
  glyph = grub_font_construct_glyph (virtual_screen.font, p->code);
 
619
  if (!glyph)
 
620
    {
 
621
      grub_errno = GRUB_ERR_NONE;
 
622
      return;
 
623
    }
615
624
  ascent = grub_font_get_ascent (virtual_screen.font);
616
625
 
617
626
  width = virtual_screen.normal_char_width * calculate_character_width(glyph);
632
641
  /* Mark character to be drawn.  */
633
642
  dirty_region_add (virtual_screen.offset_x + x, virtual_screen.offset_y + y,
634
643
                    width, height);
 
644
  grub_free (glyph);
635
645
}
636
646
 
637
647
static inline void
782
792
{
783
793
  unsigned int i;
784
794
 
 
795
  /* Clear first line in text buffer.  */
 
796
  for (i = 0;
 
797
       i < virtual_screen.columns;
 
798
       i++)
 
799
    {
 
800
      virtual_screen.text_buffer[i].code = 0;
 
801
      clear_char (&(virtual_screen.text_buffer[i]));
 
802
    }
 
803
 
785
804
  /* Scroll text buffer with one line to up.  */
786
805
  grub_memmove (virtual_screen.text_buffer,
787
806
                virtual_screen.text_buffer + virtual_screen.columns,
793
812
  for (i = virtual_screen.columns * (virtual_screen.rows - 1);
794
813
       i < virtual_screen.columns * virtual_screen.rows;
795
814
       i++)
796
 
    clear_char (&(virtual_screen.text_buffer[i]));
 
815
    {
 
816
      virtual_screen.text_buffer[i].code = 0;
 
817
      clear_char (&(virtual_screen.text_buffer[i]));
 
818
    }
797
819
 
798
820
  virtual_screen.total_scroll++;
799
821
}
800
822
 
801
823
static void
802
 
grub_gfxterm_putchar (grub_uint32_t c)
 
824
grub_gfxterm_putchar (struct grub_term_output *term,
 
825
                      const struct grub_unicode_glyph *c)
803
826
{
804
 
  if (c == '\a')
 
827
  if (c->base == '\a')
805
828
    /* FIXME */
806
829
    return;
807
830
 
809
832
  if (virtual_screen.cursor_state)
810
833
    draw_cursor (0);
811
834
 
812
 
  if (c == '\b' || c == '\n' || c == '\r')
 
835
  if (c->base == '\b' || c->base == '\n' || c->base == '\r')
813
836
    {
814
 
      switch (c)
 
837
      switch (c->base)
815
838
        {
816
839
        case '\b':
817
840
          if (virtual_screen.cursor_x > 0)
832
855
    }
833
856
  else
834
857
    {
835
 
      struct grub_font_glyph *glyph;
836
858
      struct grub_colored_char *p;
837
859
      unsigned char char_width;
838
860
 
839
 
      /* Get properties of the character.  */
840
 
      glyph = grub_font_get_glyph (virtual_screen.font, c);
841
 
 
842
861
      /* Calculate actual character width for glyph. This is number of
843
862
         times of normal_font_width.  */
844
 
      char_width = calculate_character_width(glyph);
 
863
      char_width = grub_gfxterm_getcharwidth (term, c);
845
864
 
846
865
      /* If we are about to exceed line length, wrap to next line.  */
847
866
      if (virtual_screen.cursor_x + char_width > virtual_screen.columns)
848
 
        grub_putchar ('\n');
 
867
        {
 
868
          if (virtual_screen.cursor_y >= virtual_screen.rows - 1)
 
869
            scroll_up ();
 
870
          else
 
871
            virtual_screen.cursor_y++;
 
872
        }
849
873
 
850
874
      /* Find position on virtual screen, and fill information.  */
851
875
      p = (virtual_screen.text_buffer +
852
876
           virtual_screen.cursor_x +
853
877
           virtual_screen.cursor_y * virtual_screen.columns);
854
 
      p->code = c;
 
878
      grub_free (p->code);
 
879
      p->code = grub_unicode_glyph_dup (c);
 
880
      if (!p->code)
 
881
        grub_errno = GRUB_ERR_NONE;
855
882
      p->fg_color = virtual_screen.fg_color;
856
883
      p->bg_color = virtual_screen.bg_color;
857
884
      p->width = char_width - 1;
864
891
 
865
892
          for (i = 1; i < char_width; i++)
866
893
            {
867
 
              p[i].code = ' ';
 
894
              grub_free (p[i].code);
 
895
              p[i].code = grub_unicode_glyph_from_code (' ');
 
896
              if (!p[i].code)
 
897
                grub_errno = GRUB_ERR_NONE;
868
898
              p[i].width = char_width - 1;
869
899
              p[i].index = i;
870
900
            }
929
959
}
930
960
 
931
961
static grub_ssize_t
932
 
grub_gfxterm_getcharwidth (grub_uint32_t c)
 
962
grub_gfxterm_getcharwidth (struct grub_term_output *term __attribute__ ((unused)),
 
963
                           const struct grub_unicode_glyph *c)
933
964
{
934
 
  struct grub_font_glyph *glyph;
935
 
  unsigned char char_width;
936
 
 
937
 
  /* Get properties of the character.  */
938
 
  glyph = grub_font_get_glyph (virtual_screen.font, c);
939
 
 
940
 
  /* Calculate actual character width for glyph.  */
941
 
  char_width = calculate_character_width (glyph);
942
 
 
943
 
  return char_width;
 
965
  int dev_width;
 
966
  dev_width = grub_font_get_constructed_device_width (virtual_screen.font, c);
 
967
 
 
968
  if (dev_width == 0)
 
969
    return 1;
 
970
 
 
971
  return (dev_width + (virtual_screen.normal_char_width - 1))
 
972
    / virtual_screen.normal_char_width;
944
973
}
945
974
 
946
975
static grub_uint16_t
947
 
grub_virtual_screen_getwh (void)
 
976
grub_virtual_screen_getwh (struct grub_term_output *term __attribute__ ((unused)))
948
977
{
949
978
  return (virtual_screen.columns << 8) | virtual_screen.rows;
950
979
}
951
980
 
952
981
static grub_uint16_t
953
 
grub_virtual_screen_getxy (void)
 
982
grub_virtual_screen_getxy (struct grub_term_output *term __attribute__ ((unused)))
954
983
{
955
984
  return ((virtual_screen.cursor_x << 8) | virtual_screen.cursor_y);
956
985
}
957
986
 
958
987
static void
959
 
grub_gfxterm_gotoxy (grub_uint8_t x, grub_uint8_t y)
 
988
grub_gfxterm_gotoxy (struct grub_term_output *term __attribute__ ((unused)),
 
989
                     grub_uint8_t x, grub_uint8_t y)
960
990
{
961
991
  if (x >= virtual_screen.columns)
962
992
    x = virtual_screen.columns - 1;
977
1007
}
978
1008
 
979
1009
static void
980
 
grub_virtual_screen_cls (void)
 
1010
grub_virtual_screen_cls (struct grub_term_output *term __attribute__ ((unused)))
981
1011
{
982
1012
  grub_uint32_t i;
983
1013
 
988
1018
}
989
1019
 
990
1020
static void
991
 
grub_gfxterm_cls (void)
 
1021
grub_gfxterm_cls (struct grub_term_output *term)
992
1022
{
993
1023
  grub_video_color_t color;
994
1024
 
995
1025
  /* Clear virtual screen.  */
996
 
  grub_virtual_screen_cls ();
 
1026
  grub_virtual_screen_cls (term);
997
1027
 
998
1028
  /* Clear text layer.  */
999
1029
  grub_video_set_active_render_target (text_layer);
1005
1035
  /* Mark virtual screen to be redrawn.  */
1006
1036
  dirty_region_add_virtualscreen ();
1007
1037
 
1008
 
  grub_gfxterm_refresh ();
 
1038
  grub_gfxterm_refresh (term);
1009
1039
}
1010
1040
 
1011
1041
static void
1012
 
grub_virtual_screen_setcolorstate (grub_term_color_state state)
 
1042
grub_virtual_screen_setcolorstate (struct grub_term_output *term,
 
1043
                                   grub_term_color_state state)
1013
1044
{
1014
1045
  switch (state)
1015
1046
    {
1018
1049
      break;
1019
1050
 
1020
1051
    case GRUB_TERM_COLOR_NORMAL:
1021
 
      virtual_screen.term_color = virtual_screen.normal_color_setting;
 
1052
      virtual_screen.term_color = term->normal_color;
1022
1053
      break;
1023
1054
 
1024
1055
    case GRUB_TERM_COLOR_HIGHLIGHT:
1025
 
      virtual_screen.term_color = virtual_screen.highlight_color_setting;
 
1056
      virtual_screen.term_color = term->highlight_color;
1026
1057
      break;
1027
1058
 
1028
1059
    default:
1034
1065
}
1035
1066
 
1036
1067
static void
1037
 
grub_virtual_screen_setcolor (grub_uint8_t normal_color,
1038
 
                              grub_uint8_t highlight_color)
1039
 
{
1040
 
  virtual_screen.normal_color_setting = normal_color;
1041
 
  virtual_screen.highlight_color_setting = highlight_color;
1042
 
}
1043
 
 
1044
 
static void
1045
 
grub_virtual_screen_getcolor (grub_uint8_t *normal_color,
1046
 
                              grub_uint8_t *highlight_color)
1047
 
{
1048
 
  *normal_color = virtual_screen.normal_color_setting;
1049
 
  *highlight_color = virtual_screen.highlight_color_setting;
1050
 
}
1051
 
 
1052
 
static void
1053
 
grub_gfxterm_setcursor (int on)
 
1068
grub_gfxterm_setcursor (struct grub_term_output *term __attribute__ ((unused)),
 
1069
                        int on)
1054
1070
{
1055
1071
  if (virtual_screen.cursor_state != on)
1056
1072
    {
1064
1080
}
1065
1081
 
1066
1082
static void
1067
 
grub_gfxterm_refresh (void)
 
1083
grub_gfxterm_refresh (struct grub_term_output *term __attribute__ ((unused)))
1068
1084
{
1069
1085
  real_scroll ();
1070
1086
 
1175
1191
    .gotoxy = grub_gfxterm_gotoxy,
1176
1192
    .cls = grub_gfxterm_cls,
1177
1193
    .setcolorstate = grub_virtual_screen_setcolorstate,
1178
 
    .setcolor = grub_virtual_screen_setcolor,
1179
 
    .getcolor = grub_virtual_screen_getcolor,
1180
1194
    .setcursor = grub_gfxterm_setcursor,
1181
1195
    .refresh = grub_gfxterm_refresh,
1182
 
    .flags = 0,
 
1196
    .flags = GRUB_TERM_CODE_TYPE_VISUAL_GLYPHS,
 
1197
    .normal_color = GRUB_TERM_DEFAULT_NORMAL_COLOR,
 
1198
    .highlight_color = GRUB_TERM_DEFAULT_HIGHLIGHT_COLOR,
1183
1199
    .next = 0
1184
1200
  };
1185
1201