pico/osdep/mswin_spell.c

   1 /*
   2  * ========================================================================
   3  * MSWIN_SPELL.C
   4  *
   5  * Licensed under the Apache License, Version 2.0 (the "License");
   6  * you may not use this file except in compliance with the License.
   7  * You may obtain a copy of the License at
   8  *
   9  *     http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  * ========================================================================
  12  */
  13
  14 #include "../headers.h"
  15
  16 #include "mswin_aspell.h"
  17 #include "mswin_spell.h"
  18
  19 #include <windowsx.h>
  20
  21 typedef struct WORD_INFO
  22 {
  23     ASPELLINFO *aspellinfo;         // Aspell information
  24
  25     const char *utf8_err_message;   // Error message, if any
  26
  27     char       *word_utf8;          // utf-8
  28     LPTSTR      word_lptstr;
  29
  30     int         word_doto;          // UCS
  31     LINE       *word_dotp;          //
  32     int         word_size;          //
  33 } WORD_INFO;
  34
  35 extern HINSTANCE        ghInstance;
  36 extern HWND             ghTTYWnd;
  37
  38 /*
  39  * Function prototypes
  40  */
  41 static int get_next_bad_word(WORD_INFO *word_info);
  42 static void free_word_info_words(WORD_INFO *word_info);
  43 static INT_PTR CALLBACK spell_dlg_proc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam);
  44
  45 /*
  46  * spell() - check for potentially missspelled words and offer them for
  47  *      correction. Microsoft Windows specific version.
  48  */
  49 int
  50 spell(int f, int n)
  51 {
  52     int w_marko_bak;
  53     LINE *w_markp_bak;
  54     WORD_INFO word_info;
  55     ASPELLINFO *aspellinfo;
  56     char *lang = NULL;
  57
  58     emlwrite(_("Checking spelling..."), NULL);  /* greetings! */
  59
  60     memset(&word_info, 0, sizeof(WORD_INFO));
  61
  62     lang = speller_choice(dictionary, &chosen_dict);
  63
  64     if (chosen_dict == -2){             /* user cancelled */
  65         chosen_dict = -1;
  66         emlwrite(_("Speller Cancelled"), NULL);
  67         return 1;
  68     }
  69
  70     aspellinfo = speller_init(lang);
  71     if(!aspellinfo ||
  72         (word_info.utf8_err_message = speller_get_error_message(aspellinfo)))
  73     {
  74         if(word_info.utf8_err_message)
  75             emlwrite((char *)word_info.utf8_err_message, NULL);  /* sad greetings! */
  76         else
  77             emlwrite(_("Spelling: initializing Aspell failed"), NULL);
  78
  79         chosen_dict = -1;       /* try a different one next time */
  80         speller_close(aspellinfo);
  81         return -1;
  82     }
  83
  84     // Back up current mark.
  85     w_marko_bak = curwp->w_marko;
  86     w_markp_bak = curwp->w_markp;
  87
  88     setimark(0, 1);
  89     gotobob(0, 1);
  90
  91     word_info.aspellinfo = aspellinfo;
  92
  93     if(get_next_bad_word(&word_info))
  94     {
  95         DialogBoxParam(ghInstance, MAKEINTRESOURCE(DLG_SPELL), ghTTYWnd,
  96             spell_dlg_proc, (LPARAM)&word_info);
  97     }
  98
  99     // Restore original mark if possible.
 100     if(curwp->w_markp)
 101     {
 102         // Clear any set marks.
 103         setmark(0, 1);
 104
 105         if(w_markp_bak && llength(w_markp_bak))
 106         {
 107             // Make sure we don't set mark off the line.
 108             if(w_marko_bak >= llength(w_markp_bak))
 109                 w_marko_bak = llength(w_markp_bak) - 1;
 110
 111             curwp->w_marko = w_marko_bak;
 112             curwp->w_markp = w_markp_bak;
 113         }
 114     }
 115
 116     if(word_info.utf8_err_message)
 117         emlwrite((char *)word_info.utf8_err_message, NULL);
 118     else
 119         emlwrite(_("Done checking spelling"), NULL);
 120
 121     speller_close(aspellinfo);
 122     free_word_info_words(&word_info);
 123
 124     swapimark(0, 1);
 125     curwp->w_flag |= WFHARD|WFMODE;
 126
 127     update();
 128     return 1;
 129 }
 130
 131 /*
 132  * handle_cb_editchange() - combobox contents have changed so enable/disable
 133  *      the Change and Change All buttons accordingly.
 134  */
 135 static void
 136 handle_cb_editchange(HWND hDlg, HWND hwnd_combo)
 137 {
 138     int text_len = ComboBox_GetTextLength(hwnd_combo);
 139
 140     Button_Enable(GetDlgItem(hDlg, ID_BUTTON_CHANGE), !!text_len);
 141     Button_Enable(GetDlgItem(hDlg, ID_BUTTON_CHANGEALL), !!text_len);
 142 }
 143
 144 /*
 145  * spell_dlg_proc_set_word() - Set up the dialog to display spelling
 146  *      information and suggestions for the current word.
 147  */
 148 static void
 149 spell_dlg_proc_set_word(HWND hDlg, WORD_INFO *word_info)
 150 {
 151     TCHAR dlg_title[256];
 152     HWND hwnd_combo = GetDlgItem(hDlg, ID_COMBO_SUGGESTIONS);
 153
 154     // Clear the combobox.
 155     ComboBox_ResetContent(hwnd_combo);
 156
 157     // Set the dialog box title
 158     _sntprintf(dlg_title, ARRAYSIZE(dlg_title), TEXT("Not in Dictionary: %s"),
 159         word_info->word_lptstr);
 160     dlg_title[ARRAYSIZE(dlg_title) - 1] = 0;
 161     SetWindowText(hDlg, dlg_title);
 162
 163     // Populate the combobox with suggestions
 164     if(speller_suggestion_init(word_info->aspellinfo, word_info->word_utf8, -1))
 165     {
 166         const char *suggestion_utf8;
 167
 168         while(suggestion_utf8 = speller_suggestion_getnext(word_info->aspellinfo))
 169         {
 170             LPTSTR suggestion_lptstr = utf8_to_lptstr((LPSTR)suggestion_utf8);
 171
 172             if(suggestion_lptstr)
 173             {
 174                 ComboBox_AddString(hwnd_combo, suggestion_lptstr);
 175                 fs_give((void **)&suggestion_lptstr);
 176             }
 177         }
 178
 179         // Select the first one.
 180         ComboBox_SetCurSel(hwnd_combo, 0);
 181
 182         speller_suggestion_close(word_info->aspellinfo);
 183     }
 184
 185     handle_cb_editchange(hDlg, hwnd_combo);
 186 }
 187
 188 /*
 189  * spell_dlg_next_word() - Move to the next misspelled word and display
 190  *      the information for it. If no more bad words, kill the dialog.
 191  */
 192 static void
 193 spell_dlg_next_word(HWND hDlg, WORD_INFO *word_info)
 194 {
 195     if(!get_next_bad_word(word_info))
 196     {
 197         EndDialog(hDlg, 0);
 198         return;
 199     }
 200
 201     spell_dlg_proc_set_word(hDlg, word_info);
 202 }
 203
 204 /*
 205  * chword_n() - change the given word_len pointed to by the curwp->w_dot
 206  *      pointers to the word in cb
 207  */
 208 static void
 209 chword_n(int wb_len, UCS *cb)
 210 {
 211     ldelete(wb_len, NULL);  /* not saved in kill buffer */
 212
 213     while(*cb != '\0')
 214         linsert(1, *cb++);
 215
 216     curwp->w_flag |= WFEDIT;
 217 }
 218
 219 /*
 220  * replace_all() - replace all instances of oldword with newword from
 221  *      the current '.' on. Mark is where curwp will get restored to.
 222  */
 223 static void
 224 replace_all(UCS *oldword, int oldword_len, UCS *newword)
 225 {
 226     int             wrap;
 227
 228     // Mark should be at "." right now - ie the start of the word we're
 229     //  checking. We're going to use mark below to restore curwp since
 230     //  chword_n can potentially realloc LINES and it knows about markp.
 231     assert(curwp->w_markp);
 232     assert(curwp->w_markp == curwp->w_dotp);
 233     assert(curwp->w_marko == curwp->w_doto);
 234
 235     curwp->w_bufp->b_mode |= MDEXACT;           /* case sensitive */
 236     while(forscan(&wrap, oldword, 0, NULL, 0, 1))
 237     {
 238         if(wrap)
 239             break;                              /* wrap NOT allowed! */
 240
 241         /*
 242          * We want to minimize the number of substrings that we report
 243          * as matching a misspelled word...
 244          */
 245         if(lgetc(curwp->w_dotp, 0).c != '>')
 246         {
 247             LINE *lp  = curwp->w_dotp;          /* for convenience */
 248             int   off = curwp->w_doto;
 249
 250             if(off == 0 || !ucs4_isalpha(lgetc(lp, off - 1).c))
 251             {
 252                 off += oldword_len;
 253
 254                 if(off == llength(lp) || !ucs4_isalpha(lgetc(lp, off).c))
 255                 {
 256                     // Replace this word
 257                     chword_n(oldword_len, newword);
 258                 }
 259             }
 260         }
 261
 262         forwchar(0, 1);                         /* move on... */
 263
 264     }
 265     curwp->w_bufp->b_mode ^= MDEXACT;           /* case insensitive */
 266
 267     curwp->w_dotp = curwp->w_markp;
 268     curwp->w_doto = curwp->w_marko;
 269 }
 270
 271 /*
 272  * handle_button_change() - Someone pressed the Change or Change All button.
 273  *      So deal with it.
 274  */
 275 static void
 276 handle_button_change(HWND hDlg, WORD_INFO *word_info, int do_replace_all)
 277 {
 278     int str_lptstr_len;
 279     TCHAR str_lptstr[128];
 280
 281     // Get the length of what they want to change to.
 282     str_lptstr_len = ComboBox_GetText(GetDlgItem(hDlg, ID_COMBO_SUGGESTIONS),
 283         str_lptstr, ARRAYSIZE(str_lptstr));
 284     if(str_lptstr_len)
 285     {
 286         UCS *str_ucs4;
 287         char *str_utf8;
 288
 289         // Notify the speller so it'll suggest this word next time around.
 290         str_utf8 = lptstr_to_utf8(str_lptstr);
 291         if(str_utf8)
 292         {
 293             speller_replace_word(word_info->aspellinfo,
 294                 word_info->word_utf8, -1, str_utf8, -1);
 295             fs_give((void **)&str_utf8);
 296         }
 297
 298         str_ucs4 = lptstr_to_ucs4(str_lptstr);
 299         if(!str_ucs4)
 300         {
 301             // Uh oh - massive error.
 302             word_info->utf8_err_message = _("Spelling: lptstr_to_ucs4() failed");
 303             EndDialog(hDlg, -1);
 304             return;
 305         }
 306
 307         // Move back to start of this word.
 308         curwp->w_doto = word_info->word_doto;
 309         curwp->w_dotp = word_info->word_dotp;
 310
 311         if(do_replace_all)
 312         {
 313             int i;
 314             int word_size;
 315             UCS word[128];
 316
 317             word_size = word_info->word_size;
 318             if(word_size >= ARRAYSIZE(word) - 1)
 319                 word_size = ARRAYSIZE(word) - 1;
 320
 321             for(i = 0; i < word_size; i++)
 322                 word[i] = lgetc(curwp->w_dotp, curwp->w_doto + i).c;
 323
 324             word[i] = 0;
 325
 326             replace_all(word, word_size, str_ucs4);
 327
 328             // Skip over the word we just inserted.
 329             forwchar(FALSE, (int)ucs4_strlen(str_ucs4));
 330         }
 331         else
 332         {
 333             // Swap it with the new improved version.
 334             chword_n(word_info->word_size, str_ucs4);
 335         }
 336         fs_give((void **)&str_ucs4);
 337     }
 338
 339     update();
 340     spell_dlg_next_word(hDlg, word_info);
 341 }
 342
 343 /*
 344  * center_dialog() - Center a dialog with respect to its parent.
 345  */
 346 static void
 347 center_dialog(HWND hDlg)
 348 {
 349     int dx;
 350     int dy;
 351     RECT rcDialog;
 352     RECT rcParent;
 353
 354     GetWindowRect(GetParent(hDlg), &rcParent);
 355     GetWindowRect(hDlg, &rcDialog);
 356
 357     dx = ((rcParent.right - rcParent.left) -
 358             (rcDialog.right - rcDialog.left)) / 2 + rcParent.left - rcDialog.left;
 359
 360     dy = ((rcParent.bottom - rcParent.top) -
 361             (rcDialog.bottom - rcDialog.top)) / 2 + rcParent.top - rcDialog.top;
 362
 363     OffsetRect(&rcDialog, dx, dy);
 364
 365     SetWindowPos(hDlg, NULL, rcDialog.left, rcDialog.top, 0, 0,
 366         SWP_NOSIZE | SWP_NOZORDER);
 367 }
 368
 369 /*
 370  * spell_dlg_on_command() - Handle the WM_COMMAND stuff for the spell dialog.
 371  */
 372 static void
 373 spell_dlg_on_command(HWND hDlg, int id, HWND hwndCtl, UINT codeNotify)
 374 {
 375     WORD_INFO *word_info =
 376         (WORD_INFO *)(LONG_PTR)GetWindowLongPtr(hDlg, GWLP_USERDATA);
 377
 378     switch(id)
 379     {
 380     case ID_COMBO_SUGGESTIONS:
 381         if(codeNotify == CBN_EDITCHANGE)
 382             handle_cb_editchange(hDlg, hwndCtl);
 383         break;
 384
 385     case ID_BUTTON_CHANGE:
 386         handle_button_change(hDlg, word_info, 0);
 387         break;
 388
 389     case ID_BUTTON_CHANGEALL:
 390         handle_button_change(hDlg, word_info, 1);
 391         break;
 392
 393     case ID_BUTTON_IGNOREONCE:
 394         spell_dlg_next_word(hDlg, word_info);
 395         break;
 396
 397     case ID_BUTTON_IGNOREALL:
 398         speller_ignore_all(word_info->aspellinfo, word_info->word_utf8, -1);
 399         spell_dlg_next_word(hDlg, word_info);
 400         break;
 401
 402     case ID_BUTTON_ADD_TO_DICT:
 403         speller_add_to_dictionary(word_info->aspellinfo, word_info->word_utf8, -1);
 404         spell_dlg_next_word(hDlg, word_info);
 405         break;
 406
 407     case ID_BUTTON_CANCEL:
 408         EndDialog(hDlg, 0);
 409         break;
 410     }
 411 }
 412
 413 /*
 414  * spell_dlg_proc() - Main spell dialog proc.
 415  */
 416 static INT_PTR CALLBACK
 417 spell_dlg_proc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
 418 {
 419     WORD_INFO *word_info;
 420
 421     switch(message)
 422     {
 423     case WM_INITDIALOG:
 424         center_dialog(hDlg);
 425
 426         // Limit how much junk they can type in.
 427         ComboBox_LimitText(GetDlgItem(hDlg, ID_COMBO_SUGGESTIONS), 128);
 428
 429         word_info = (WORD_INFO *)lParam;
 430         SetWindowLongPtr(hDlg, GWLP_USERDATA, (LONG_PTR)word_info);
 431
 432         spell_dlg_proc_set_word(hDlg, word_info);
 433         return TRUE;
 434
 435     case WM_COMMAND:
 436         HANDLE_WM_COMMAND(hDlg, wParam, lParam, spell_dlg_on_command);
 437         return TRUE;
 438     }
 439
 440     return FALSE;
 441 }
 442
 443 /*
 444  * get_next_word() - Get the next word from dot. And skip words in
 445  *      quoted lines.
 446  */
 447 static int
 448 get_next_word(WORD_INFO *word_info)
 449 {
 450     UCS *tmp = NULL;
 451     int i;
 452
 453     // Skip quoted lines
 454     while(lgetc(curwp->w_dotp, 0).c == '>')
 455     {
 456         if(curwp->w_dotp == curbp->b_linep)
 457             return 0;
 458
 459         curwp->w_dotp  = lforw(curwp->w_dotp);
 460         curwp->w_doto  = 0;
 461         curwp->w_flag |= WFMOVE;
 462     }
 463
 464     // Move to a word.
 465     while(inword() == FALSE)
 466     {
 467         if(forwchar(FALSE, 1) == FALSE)
 468         {
 469             // There is no next word.
 470             return 0;
 471         }
 472     }
 473
 474     // If mark is currently set, clear it.
 475     if(curwp->w_markp)
 476         setmark(0, 1);
 477
 478     // Set mark to beginning of this word.
 479     curwp->w_markp = curwp->w_dotp;
 480     curwp->w_marko = curwp->w_doto;
 481
 482     // Get word length
 483     word_info->word_doto = curwp->w_doto;
 484     word_info->word_dotp = curwp->w_dotp;
 485     word_info->word_size = 0;
 486
 487     while((inword() != FALSE) && (word_info->word_dotp == curwp->w_dotp))
 488     {
 489         word_info->word_size++;
 490
 491         if(forwchar(FALSE, 1) == FALSE)
 492             break;
 493     }
 494
 495     tmp = fs_get((word_info->word_size+1)*sizeof(UCS));
 496     if(tmp != NULL){
 497        for(i = 0; i < word_info->word_size; i++)
 498           tmp[i] = word_info->word_dotp->l_text[word_info->word_doto+i].c;
 499        tmp[i] = 0;
 500        word_info->word_utf8 = ucs4_to_utf8_cpystr_n(tmp, word_info->word_size);
 501        fs_give((void **)&tmp);
 502     }
 503     return 1;
 504 }
 505
 506 /*
 507  * get_next_word() - free the word_info members word_utf8 and word_lptstr.
 508  */
 509 static void
 510 free_word_info_words(WORD_INFO *word_info)
 511 {
 512     if(word_info->word_utf8)
 513     {
 514         fs_give((void **)&word_info->word_utf8);
 515         word_info->word_utf8 = NULL;
 516     }
 517
 518     if(word_info->word_lptstr)
 519     {
 520         fs_give((void **)&word_info->word_lptstr);
 521         word_info->word_lptstr = NULL;
 522     }
 523 }
 524
 525 /*
 526  * get_next_bad_word() - Search from '.' for the next word we think is
 527  *      rotten. Mark it and highlight it.
 528  */
 529 static int
 530 get_next_bad_word(WORD_INFO *word_info)
 531 {
 532     free_word_info_words(word_info);
 533
 534     while(get_next_word(word_info))
 535     {
 536         int ret;
 537
 538         /* pass over words that contain @ */
 539         if(strchr(word_info->word_utf8, '@'))
 540           ret = 1;
 541         else
 542           ret = speller_check_word(word_info->aspellinfo, word_info->word_utf8, -1);
 543
 544         if(ret == -1)
 545         {
 546             word_info->utf8_err_message =
 547                 speller_get_error_message(word_info->aspellinfo);
 548             if(!word_info->utf8_err_message)
 549                 word_info->utf8_err_message = _("Spelling: speller_check_word() failed");
 550             return 0;
 551         }
 552         else if(ret == 0)
 553         {
 554             // Highlight word.
 555             update();
 556
 557             word_info->word_lptstr = utf8_to_lptstr(word_info->word_utf8);
 558             return 1;
 559         }
 560
 561         free_word_info_words(word_info);
 562     }
 563
 564     return 0;
 565 }