Increase font size in mini-buffer (for Japanese Kanji selection)

Question

I'm using Emacs and Xubuntu, and my default input is English, but (in Emacs) I use Japanese input method as well. To enter Kanji (Chinese characters), I type some letters (usually from 2 to about half a dozen), and then select from a list of suggested characters displayed in the mini-buffer. My problem is that I don't know how to increase the size of the Japanese characters in the selection-list in the mini-buffer. I have difficulty distinguishing them because they can be quite fiddly. I know how to increase the size of the font in the editing buffer, which I do, but I don't how to increase the size of the characters in the mini-buffer. I've tried scrolling with the cursor in the mini-buffer, but that made the display area bigger than my screen, so the edges were off the screen (and the image was free to move this way and that, until it reached the edge).

Answer 1

Perhaps you are using built-in input method kkc. I found that only one line (the last line) of kkc-show-conversion-list-update is the target to change the scale of candidates, but my unskilled solution is pretty long as follows (quoting the entire function to override just to change the last line):

revised the code:

• Propertize messages by case before outputting it on the last line to prevent from overwriting selector highlights.
• Setq the scale.

(setq my-kkc-candidate-scale 1.5)

(with-eval-after-load 'kkc
  (defun kkc-show-conversion-list-update ()
    (or kkc-current-conversions-width
        (kkc-setup-current-conversions-width))
    (let* ((current-idx (car kkc-current-conversions))
           (first-slot (aref kkc-current-conversions-width 0))
           (this-idx (aref first-slot 0))
           (next-idx (aref first-slot 1))
           (msg (aref first-slot 2)))
      (if (< current-idx this-idx)
          ;; The currently selected conversion is before the list shown
          ;; previously.  We must start calculation of message width
          ;; from the start again.
          (setq this-idx 1 msg nil)
        (if (>= current-idx next-idx)
            ;; The currently selected conversion is after the list shown
            ;; previously.  We start calculation of message width from
            ;; the conversion next of TO.
            (setq this-idx next-idx msg nil)))
      (if (not msg)
          (let ((len (length kkc-current-conversions))
                (max-width (window-width (minibuffer-window)))
                (width-table kkc-current-conversions-width)
                (width 0)
                (idx this-idx)
                (max-items (length kkc-show-conversion-list-index-chars))
                l)
            ;; Set THIS-IDX to the first index of conversion to be shown
            ;; in MSG, and reflect it in kkc-current-conversions-width.
            (while (<= idx current-idx)
              (if (and (<= (+ width (aref width-table idx)) max-width)
                       (< (- idx this-idx) max-items))
                  (setq width (+ width (aref width-table idx)))
                (setq this-idx idx width (aref width-table idx)))
              (setq idx (1+ idx)
                    l (cdr l)))
            (aset first-slot 0 this-idx)
            ;; Set NEXT-IDX to the next index of the last conversion
            ;; shown in MSG, and reflect it in
            ;; kkc-current-conversions-width.
            (while (and (< idx len)
                        (<= (+ width (aref width-table idx)) max-width)
                        (< (- idx this-idx) max-items))
              (setq width (+ width (aref width-table idx))
                    idx (1+ idx)
                    l (cdr l)))
            (aset first-slot 1 (setq next-idx idx))
            (setq l (nthcdr this-idx kkc-current-conversions))
            (setq msg (format " %c %s"
                              (aref kkc-show-conversion-list-index-chars 0)
                              (propertize (car l)
                                          'kkc-conversion-index this-idx))
                  idx (1+ this-idx)
                  l (cdr l))
            (while (< idx next-idx)
              (setq msg (format "%s  %c %s"
                                msg
                                (aref kkc-show-conversion-list-index-chars
                                      (- idx this-idx))
                                (propertize (car l)
                                            'kkc-conversion-index idx))
                    idx (1+ idx)
                    l (cdr l)))
            (aset first-slot 2 msg)))

      (remove-text-properties 0 (length msg) '(face nil) msg) ;; moved from the highlighting block below
      (put-text-property 0 (length msg) 'face `(:height ,my-kkc-candidate-scale) msg) ;; added

      ;; Highlight the current conversion.
      (if (> current-idx 0)
          (let ((pos 3)
                (limit (length msg)))
            ;; (remove-text-properties 0 (length msg) '(face nil) msg) ;; original.
            (while (not (eq (get-text-property pos 'kkc-conversion-index msg)
                            current-idx))
              (setq pos (next-single-property-change pos 'kkc-conversion-index
                                                     msg limit)))
            (put-text-property pos (next-single-property-change
                                    pos 'kkc-conversion-index msg limit)
                               'face
                               ;; 'highlight ;; original
                               `(:inherit highlight :height ,my-kkc-candidate-scale) ;; modified
                               msg)))
      (let ((message-log-max nil))
        (message "%s" msg)))))

Answer 2

How about toggling manually when you want to use a larger font?

;; global flag for toggle
(setq-default my-scaled nil)

(defun my-scale-minibuf-font ()
  "Increase font size in mini-buffer"
  (setq-local face-remapping-alist '((default :height 1.2)))) ;; set scale as you like

(defun my-toggle-scale-minibuf-font ()
  "Toggle my-scale-minibuf-font"
  (interactive)
  (if my-scaled
      (remove-hook 'minibuffer-setup-hook 'my-scale-minibuf-font)
    (add-hook 'minibuffer-setup-hook 'my-scale-minibuf-font))
  (setq my-scaled (not my-scaled))) ;; invert the flag

;; bind key to toggle
(define-key global-map (kbd "C-c C-t") 'my-toggle-scale-minibuf-font) ;; set key as you like

Answer 3

Another idea is just to set the echo area height. This is using an example from EmacsWiki:

(with-eval-after-load 'kkc
  (with-current-buffer (get-buffer " *Echo Area 0*") ; the leading space character is correct
    (setq-local face-remapping-alist '((default (:height 1.5) variable-pitch)))))