← Back to branch summary

~ubuntu-branches/debian/sid/grub2/sid-200907171834

« back to all changes in this revision

Viewing changes to normal/menu_entry.c

  • Committer: Bazaar Package Importer
  • Author(s): Robert Millan, Updated translations, Robert Millan
  • Date: 2008-11-10 16:18:14 UTC
  • mfrom: (1.1.11 upstream)
  • Revision ID: james.westby@ubuntu.com-20081110161814-1ltb13avouqapmlh
Tags: 1.96+20080724-12
http://bugs.debian.org/504076
http://bugs.debian.org/504207
http://bugs.debian.org/504254
http://bugs.debian.org/504280
http://bugs.debian.org/504324
http://bugs.debian.org/504310
http://bugs.debian.org/504466
http://bugs.debian.org/504683
[ Updated translations ]
* Italian (it.po) by Luca Monducci. (Closes: #504076)
* Swedish (sv.po) by Martin Ågren. (Closes: #504207)
* Arabic (ar.po) by Ossama Khayat. (Closes: #504254)
* Portuguese (pt.po) by Miguel Figueiredo. (Closes: #504280)
* Russian (ru.po) by Yuri Kozlov. (Closes: #504324)
* Finnish (fi.po) by Esko Arajärvi. (Closes: #504310)
* Basque (eu.po) by Piarres Beobide. (Closes: #504466)
* Dutch (nl.po) by Paul Gevers. (Closes: #504683)

[ Robert Millan ]
* Update to new debian theme.
  - grub-pc.postinst: Switch to moreblue-orbit-grub.png.
  - grub.d/05_debian_theme: Likewise.

Show diffs side-by-side

added added

removed removed

Lines of Context:
normal/menu_entry.c
21
21
#include <grub/misc.h>
22
22
#include <grub/mm.h>
23
23
#include <grub/loader.h>
24
 
#include <grub/command.h>
25
 
#include <grub/parser.h>
 
24
#include <grub/script.h>
26
25
 
27
26
enum update_mode
28
27
  {
107
106
{
108
107
  int i;
109
108
  char *p;
110
 
 
 
109
  
111
110
  grub_gotoxy (GRUB_TERM_LEFT_BORDER_X + GRUB_TERM_MARGIN + start + 1,
112
111
               y + GRUB_TERM_FIRST_ENTRY_Y);
113
112
 
130
129
print_empty_line (int y)
131
130
{
132
131
  int i;
133
 
 
 
132
  
134
133
  grub_gotoxy (GRUB_TERM_LEFT_BORDER_X + GRUB_TERM_MARGIN + 1,
135
134
               y + GRUB_TERM_FIRST_ENTRY_Y);
136
135
 
144
143
{
145
144
  grub_gotoxy (GRUB_TERM_LEFT_BORDER_X + GRUB_TERM_BORDER_WIDTH,
146
145
               GRUB_TERM_FIRST_ENTRY_Y);
147
 
 
 
146
  
148
147
  if (flag)
149
148
    grub_putcode (GRUB_TERM_DISP_UP);
150
149
  else
151
150
    grub_putchar (' ');
152
151
}
153
 
 
 
152
          
154
153
/* Print a down arrow.  */
155
154
static void
156
155
print_down (int flag)
157
156
{
158
157
  grub_gotoxy (GRUB_TERM_LEFT_BORDER_X + GRUB_TERM_BORDER_WIDTH,
159
158
               GRUB_TERM_TOP_BORDER_Y + GRUB_TERM_NUM_ENTRIES);
160
 
 
 
159
  
161
160
  if (flag)
162
161
    grub_putcode (GRUB_TERM_DISP_DOWN);
163
162
  else
164
163
    grub_putchar (' ');
165
164
}
166
 
 
 
165
          
167
166
/* Draw the lines of the screen SCREEN.  */
168
167
static void
169
168
update_screen (struct screen *screen, int region_start, int region_column,
174
173
  int y;
175
174
  int i;
176
175
  struct line *linep;
177
 
 
 
176
  
178
177
  /* Check if scrolling is necessary.  */
179
178
  if (screen->y < 0 || screen->y >= GRUB_TERM_NUM_ENTRIES)
180
179
    {
182
181
        screen->y = 0;
183
182
      else
184
183
        screen->y = GRUB_TERM_NUM_ENTRIES - 1;
185
 
 
 
184
      
186
185
      region_start = 0;
187
186
      region_column = 0;
188
187
      up = 1;
203
202
           linep--;
204
203
           y -= get_logical_num_lines (linep);
205
204
        }
206
 
 
 
205
      
207
206
      if (y < 0 || i > 0)
208
207
        up_flag = 1;
209
 
 
 
208
      
210
209
      do
211
210
        {
212
211
          int column;
213
 
 
 
212
          
214
213
          for (column = 0;
215
214
               column <= linep->len && y < GRUB_TERM_NUM_ENTRIES;
216
215
               column += GRUB_TERM_ENTRY_WIDTH, y++)
217
216
            {
218
217
              if (y < 0)
219
218
                continue;
220
 
 
 
219
              
221
220
              if (i == region_start)
222
221
                {
223
222
                  if (region_column >= column
229
228
              else if (i > region_start && mode == ALL_LINES)
230
229
                print_line (linep, column, 0, y);
231
230
            }
232
 
 
 
231
          
233
232
          if (y == GRUB_TERM_NUM_ENTRIES)
234
233
            {
235
234
              if (column <= linep->len || i + 1 < screen->num_lines)
236
235
                down_flag = 1;
237
236
            }
238
 
 
 
237
          
239
238
          linep++;
240
239
          i++;
241
240
 
242
241
          if (mode == ALL_LINES && i == screen->num_lines)
243
242
            for (; y < GRUB_TERM_NUM_ENTRIES; y++)
244
243
              print_empty_line (y);
245
 
 
 
244
                  
246
245
        }
247
246
      while (y < GRUB_TERM_NUM_ENTRIES);
248
 
 
 
247
      
249
248
      /* Draw up and down arrows.  */
250
249
      if (up)
251
250
        print_up (up_flag);
252
251
      if (down)
253
252
        print_down (down_flag);
254
253
    }
255
 
 
 
254
  
256
255
  /* Place the cursor.  */
257
256
  grub_gotoxy (GRUB_TERM_LEFT_BORDER_X + GRUB_TERM_MARGIN + 1 + screen->x,
258
257
               GRUB_TERM_FIRST_ENTRY_Y + screen->y);
259
 
 
 
258
  
260
259
  grub_refresh ();
261
260
}
262
261
 
278
277
          struct line *current_linep;
279
278
          struct line *next_linep;
280
279
          int size;
281
 
 
 
280
          
282
281
          /* Make a new line.  */
283
282
          screen->num_lines++;
284
283
          screen->lines = grub_realloc (screen->lines,
295
294
 
296
295
          if (! init_line (screen->lines + screen->line + 1))
297
296
            return 0;
298
 
 
 
297
          
299
298
          /* Fold the line.  */
300
299
          current_linep = screen->lines + screen->line;
301
300
          next_linep = current_linep + 1;
302
301
          size = current_linep->len - screen->column;
303
 
 
 
302
              
304
303
          if (! ensure_space (next_linep, size))
305
304
            return 0;
306
 
 
 
305
          
307
306
          grub_memmove (next_linep->buf,
308
307
                        current_linep->buf + screen->column,
309
308
                        size);
319
318
 
320
319
          mode = ALL_LINES;
321
320
          down = 1; /* XXX not optimal.  */
322
 
 
 
321
          
323
322
          /* Move the cursor.  */
324
323
          screen->column = screen->real_column = 0;
325
324
          screen->line++;
363
362
              region_start = screen->line;
364
363
              region_column = screen->column;
365
364
            }
366
 
 
 
365
          
367
366
          if (orig_num != new_num)
368
367
            {
369
368
              mode = ALL_LINES;
378
377
          screen->x += size;
379
378
          screen->y += screen->x / GRUB_TERM_ENTRY_WIDTH;
380
379
          screen->x %= GRUB_TERM_ENTRY_WIDTH;
381
 
 
 
380
          
382
381
          s = p;
383
382
        }
384
383
    }
385
384
 
386
385
  if (update)
387
386
    update_screen (screen, region_start, region_column, 0, down, mode);
388
 
 
 
387
  
389
388
  return 1;
390
389
}
391
390
 
399
398
    for (i = 0; i < screen->num_lines; i++)
400
399
      {
401
400
        struct line *linep = screen->lines + i;
402
 
 
 
401
        
403
402
        if (linep)
404
403
          grub_free (linep->buf);
405
404
      }
456
455
forward_char (struct screen *screen, int update)
457
456
{
458
457
  struct line *linep;
459
 
 
 
458
  
460
459
  linep = screen->lines + screen->line;
461
460
  if (screen->column < linep->len)
462
461
    {
499
498
  else if (screen->line > 0)
500
499
    {
501
500
      struct line *linep;
502
 
 
 
501
      
503
502
      screen->line--;
504
503
      linep = screen->lines + screen->line;
505
504
      screen->column = linep->len;
511
510
 
512
511
  if (update)
513
512
    update_screen (screen, screen->num_lines, 0, 0, 0, NO_LINE);
514
 
 
 
513
  
515
514
  return 1;
516
515
}
517
516
 
522
521
    {
523
522
      struct line *linep;
524
523
      int dy;
525
 
 
 
524
      
526
525
      /* How many physical lines from the current position
527
526
         to the first physical line?  */
528
527
      dy = screen->column / GRUB_TERM_ENTRY_WIDTH;
529
 
 
 
528
      
530
529
      screen->line--;
531
 
 
 
530
      
532
531
      linep = screen->lines + screen->line;
533
532
      if (linep->len < screen->real_column)
534
533
        screen->column = linep->len;
535
534
      else
536
535
        screen->column = screen->real_column;
537
 
 
 
536
      
538
537
      /* How many physical lines from the current position
539
538
         to the last physical line?  */
540
539
      dy += (linep->len / GRUB_TERM_ENTRY_WIDTH
541
540
             - screen->column / GRUB_TERM_ENTRY_WIDTH);
542
 
 
 
541
      
543
542
      screen->y -= dy + 1;
544
543
      screen->x = screen->column % GRUB_TERM_ENTRY_WIDTH;
545
544
    }
552
551
 
553
552
  if (update)
554
553
    update_screen (screen, screen->num_lines, 0, 0, 0, NO_LINE);
555
 
 
 
554
  
556
555
  return 1;
557
556
}
558
557
 
563
562
    {
564
563
      struct line *linep;
565
564
      int dy;
566
 
 
 
565
      
567
566
      /* How many physical lines from the current position
568
567
         to the last physical line?  */
569
568
      linep = screen->lines + screen->line;
570
569
      dy = (linep->len / GRUB_TERM_ENTRY_WIDTH
571
570
            - screen->column / GRUB_TERM_ENTRY_WIDTH);
572
 
 
 
571
      
573
572
      screen->line++;
574
 
 
 
573
      
575
574
      linep++;
576
575
      if (linep->len < screen->real_column)
577
576
        screen->column = linep->len;
578
577
      else
579
578
        screen->column = screen->real_column;
580
 
 
 
579
      
581
580
      /* How many physical lines from the current position
582
581
         to the first physical line?  */
583
582
      dy += screen->column / GRUB_TERM_ENTRY_WIDTH;
584
 
 
 
583
      
585
584
      screen->y += dy + 1;
586
585
      screen->x = screen->column % GRUB_TERM_ENTRY_WIDTH;
587
586
    }
598
597
 
599
598
  if (update)
600
599
    update_screen (screen, screen->num_lines, 0, 0, 0, NO_LINE);
601
 
 
 
600
  
602
601
  return 1;
603
602
}
604
603
 
611
610
 
612
611
  if (update)
613
612
    update_screen (screen, screen->num_lines, 0, 0, 0, NO_LINE);
614
 
 
 
613
  
615
614
  return 1;
616
615
}
617
616
 
619
618
end_of_line (struct screen *screen, int update)
620
619
{
621
620
  struct line *linep;
622
 
 
 
621
  
623
622
  linep = screen->lines + screen->line;
624
623
  screen->y += (linep->len / GRUB_TERM_ENTRY_WIDTH
625
624
                - screen->column / GRUB_TERM_ENTRY_WIDTH);
628
627
 
629
628
  if (update)
630
629
    update_screen (screen, screen->num_lines, 0, 0, 0, NO_LINE);
631
 
 
 
630
  
632
631
  return 1;
633
632
}
634
633
 
640
639
  int start = screen->num_lines;
641
640
  int column = 0;
642
641
  int down = 0;
643
 
 
 
642
  
644
643
  linep = screen->lines + screen->line;
645
644
  if (linep->len > screen->column)
646
645
    {
647
646
      int orig_num, new_num;
648
647
 
649
648
      orig_num = get_logical_num_lines (linep);
650
 
 
 
649
      
651
650
      grub_memmove (linep->buf + screen->column,
652
651
                    linep->buf + screen->column + 1,
653
652
                    linep->len - screen->column - 1);
680
679
                    (screen->num_lines - screen->line - 2)
681
680
                    * sizeof (struct line));
682
681
      screen->num_lines--;
683
 
 
 
682
      
684
683
      mode = ALL_LINES;
685
684
      start = screen->line;
686
685
      column = screen->column;
703
702
 
704
703
  saved_column = screen->column;
705
704
  saved_line = screen->line;
706
 
 
 
705
  
707
706
  if (! backward_char (screen, 0))
708
707
    return 0;
709
708
 
721
720
  char *p;
722
721
  int size;
723
722
  int offset;
724
 
 
 
723
  
725
724
  p = screen->killed_text;
726
725
  if (! continuous && p)
727
726
    p[0] = '\0';
728
 
 
 
727
  
729
728
  linep = screen->lines + screen->line;
730
729
  size = linep->len - screen->column;
731
 
 
 
730
  
732
731
  if (p)
733
732
    offset = grub_strlen (p);
734
733
  else
735
734
    offset = 0;
736
 
 
 
735
      
737
736
  if (size > 0)
738
737
    {
739
738
      enum update_mode mode = SINGLE_LINE;
740
739
      int down = 0;
741
740
      int orig_num, new_num;
742
 
 
 
741
      
743
742
      p = grub_realloc (p, offset + size + 1);
744
743
      if (! p)
745
744
        return 0;
748
747
      p[offset + size - 1] = '\0';
749
748
 
750
749
      screen->killed_text = p;
751
 
 
 
750
      
752
751
      orig_num = get_logical_num_lines (linep);
753
752
      linep->len = screen->column;
754
753
      new_num = get_logical_num_lines (linep);
772
771
      p[offset + 1] = '\0';
773
772
 
774
773
      screen->killed_text = p;
775
 
 
 
774
      
776
775
      return delete_char (screen, update);
777
776
    }
778
 
 
 
777
    
779
778
  return 1;
780
779
}
781
780
 
792
791
open_line (struct screen *screen, int update)
793
792
{
794
793
  int saved_y = screen->y;
795
 
 
 
794
  
796
795
  if (! insert_string (screen, "\n", 0))
797
796
    return 0;
798
797
 
812
811
store_completion (const char *item, grub_completion_type_t type, int count)
813
812
{
814
813
  char *p;
815
 
 
 
814
  
816
815
  if (count == 0)
817
816
    {
818
817
      /* If this is the first time, print a label.  */
839
838
          what = "things";
840
839
          break;
841
840
        }
842
 
 
 
841
            
843
842
      grub_gotoxy (0, GRUB_TERM_HEIGHT - 3);
844
843
      grub_printf ("   Possible %s are:\n    ", what);
845
844
    }
849
848
                                   + (int) grub_strlen (item) + 1 + 1))
850
849
    {
851
850
      grub_size_t new_len;
852
 
 
 
851
      
853
852
      new_len = completion_buffer.len + grub_strlen (item) + 80;
854
853
      p = grub_realloc (completion_buffer.buf, new_len);
855
854
      if (! p)
887
886
    count++;
888
887
  else
889
888
    count = 0;
890
 
 
 
889
  
891
890
  pos = grub_getxy ();
892
891
  grub_gotoxy (0, GRUB_TERM_HEIGHT - 3);
893
 
 
 
892
  
894
893
  completion_buffer.buf = 0;
895
894
  completion_buffer.len = 0;
896
895
  completion_buffer.max_len = 0;
902
901
  insert = grub_normal_do_completion (linep->buf, &restore, store_completion);
903
902
 
904
903
  linep->buf[screen->column] = saved_char;
905
 
 
 
904
  
906
905
  if (restore)
907
906
    {
908
907
      char *p = completion_buffer.buf;
909
908
 
910
909
      screen->completion_shown = 1;
911
 
 
 
910
      
912
911
      if (p)
913
912
        {
914
913
          int num_sections = ((completion_buffer.len + GRUB_TERM_WIDTH - 8 - 1)
922
921
            grub_putcode (GRUB_TERM_DISP_LEFT);
923
922
          else
924
923
            grub_putchar (' ');
925
 
 
 
924
          
926
925
          while (*p && p < endp)
927
926
            grub_putchar (*p++);
928
 
 
 
927
          
929
928
          if (*p)
930
929
            grub_putcode (GRUB_TERM_DISP_RIGHT);
931
930
        }
932
931
    }
933
932
 
934
933
  grub_gotoxy (pos >> 8, pos & 0xFF);
935
 
 
 
934
  
936
935
  if (insert)
937
936
    {
938
937
      insert_string (screen, insert, update);
941
940
    }
942
941
  else if (update)
943
942
    grub_refresh ();
944
 
 
 
943
    
945
944
  grub_free (completion_buffer.buf);
946
945
  return 1;
947
946
}
952
951
{
953
952
  grub_uint16_t pos;
954
953
  int i, j;
955
 
 
 
954
  
956
955
  pos = grub_getxy ();
957
956
  grub_gotoxy (0, GRUB_TERM_HEIGHT - 3);
958
 
 
 
957
  
959
958
  for (i = 0; i < 2; i++)
960
959
    {
961
960
      for (j = 0; j < GRUB_TERM_WIDTH - 1; j++)
962
961
        grub_putchar (' ');
963
962
      grub_putchar ('\n');
964
963
    }
965
 
 
 
964
  
966
965
  grub_gotoxy (pos >> 8, pos & 0xFF);
967
966
  grub_refresh ();
968
967
}
971
970
static int
972
971
run (struct screen *screen)
973
972
{
 
973
  struct grub_script *parsed_script = 0;
974
974
  int currline = 0;
975
975
  char *nextline;
976
976
 
977
 
  auto grub_err_t editor_getline (char **line, int cont);
978
 
  grub_err_t editor_getline (char **line, int cont __attribute__ ((unused)))
 
977
  auto grub_err_t editor_getline (char **line);
 
978
  grub_err_t editor_getline (char **line)
979
979
    {
980
980
      struct line *linep = screen->lines + currline;
981
981
      char *p;
996
996
      linep->len = p - linep->buf;
997
997
      for (p = linep->buf; grub_isspace (*p); p++)
998
998
        ;
999
 
      *line = grub_strdup (p);
 
999
      *line = p;
1000
1000
      currline++;
1001
1001
      return 0;
1002
1002
    }
1003
 
 
 
1003
  
1004
1004
  grub_cls ();
1005
1005
  grub_printf ("  Booting a command list\n\n");
1006
1006
 
1008
1008
  /* Execute the script, line for line.  */
1009
1009
  while (currline < screen->num_lines)
1010
1010
    {
1011
 
      editor_getline (&nextline, 0);
1012
 
      if (grub_parser_get_current ()->parse_line (nextline, editor_getline))
 
1011
      editor_getline (&nextline);
 
1012
      parsed_script = grub_script_parse (nextline, editor_getline);
 
1013
      if (parsed_script)
 
1014
        {
 
1015
          /* Execute the command(s).  */
 
1016
          grub_script_execute (parsed_script);
 
1017
          
 
1018
          /* The parsed script was executed, throw it away.  */
 
1019
          grub_script_free (parsed_script);
 
1020
        }
 
1021
      else
1013
1022
        break;
1014
1023
    }
1015
1024
 
1016
1025
  if (grub_errno == GRUB_ERR_NONE && grub_loader_is_loaded ())
1017
1026
    /* Implicit execution of boot, only if something is loaded.  */
1018
 
    grub_command_execute ("boot", 0, 0);
 
1027
    grub_command_execute ("boot", 0);
1019
1028
 
1020
1029
  if (grub_errno != GRUB_ERR_NONE)
1021
1030
    {
1033
1042
{
1034
1043
  struct screen *screen;
1035
1044
  int prev_c;
1036
 
 
 
1045
  
1037
1046
  screen = make_screen (entry);
1038
1047
  if (! screen)
1039
1048
    return;
1044
1053
  update_screen (screen, 0, 0, 1, 1, ALL_LINES);
1045
1054
  grub_setcursor (1);
1046
1055
  prev_c = '\0';
1047
 
 
 
1056
  
1048
1057
  while (1)
1049
1058
    {
1050
1059
      int c = GRUB_TERM_ASCII_CHAR (grub_getkey ());
1054
1063
          clear_completions ();
1055
1064
          screen->completion_shown = 0;
1056
1065
        }
1057
 
 
 
1066
      
1058
1067
      switch (c)
1059
1068
        {
1060
1069
        case 16: /* C-p */
1071
1080
          if (! forward_char (screen, 1))
1072
1081
            goto fail;
1073
1082
          break;
1074
 
 
 
1083
          
1075
1084
        case 2: /* C-b */
1076
1085
          if (! backward_char (screen, 1))
1077
1086
            goto fail;
1086
1095
          if (! end_of_line (screen, 1))
1087
1096
            goto fail;
1088
1097
          break;
1089
 
 
 
1098
          
1090
1099
        case '\t': /* C-i */
1091
1100
          if (! complete (screen, prev_c == c, 1))
1092
1101
            goto fail;
1093
1102
          break;
1094
 
 
 
1103
          
1095
1104
        case 4: /* C-d */
1096
1105
          if (! delete_char (screen, 1))
1097
1106
            goto fail;
1101
1110
          if (! backward_delete_char (screen, 1))
1102
1111
            goto fail;
1103
1112
          break;
1104
 
 
 
1113
          
1105
1114
        case 11: /* C-k */
1106
1115
          if (! kill_line (screen, prev_c == c, 1))
1107
1116
            goto fail;
1108
1117
          break;
1109
 
 
 
1118
          
1110
1119
        case 21: /* C-u */
1111
1120
          /* FIXME: What behavior is good for this key?  */
1112
1121
          break;
1113
 
 
 
1122
          
1114
1123
        case 25: /* C-y */
1115
1124
          if (! yank (screen, 1))
1116
1125
            goto fail;
1119
1128
        case 12: /* C-l */
1120
1129
          /* FIXME: centering.  */
1121
1130
          goto refresh;
1122
 
 
 
1131
          
1123
1132
        case 15: /* C-o */
1124
1133
          if (! open_line (screen, 1))
1125
1134
            goto fail;
1134
1143
        case '\e':
1135
1144
          destroy_screen (screen);
1136
1145
          return;
1137
 
 
 
1146
          
1138
1147
        case 3: /* C-c */
1139
1148
          grub_cmdline_run (1);
1140
1149
          goto refresh;
1141
 
 
 
1150
          
1142
1151
        case 24: /* C-x */
1143
1152
          if (! run (screen))
1144
1153
            goto fail;
1149
1158
        case 20: /* C-t */
1150
1159
          /* FIXME */
1151
1160
          break;
1152
 
 
 
1161
          
1153
1162
        default:
1154
1163
          if (grub_isprint (c))
1155
1164
            {
1168
1177
 
1169
1178
 fail:
1170
1179
  destroy_screen (screen);
1171
 
 
 
1180
  
1172
1181
  grub_cls ();
1173
1182
  grub_print_error ();
1174
1183
  grub_errno = GRUB_ERR_NONE;