Elisp

Some time ago, I decided to customize my Emacs startup screen in order to display something helpful for me. Ultimately, after much consideration, I settled on the following items I just want to see on my startup screen: 1) 3-month calendar, 2) agenda, 3) diary, 4) something just for fun.

No doubt, there are a number of packages that can assist you in making a pretty good-looking startup screen – like enlight, for instance. However, I decided to construct my own startup screen, a very simple one.

It requires having two command line utilities installed on your system: fortune to print out a random epigram, and calendar to print out some of the events that have occurred on the current date in the past. If you, like me, are using Linux or macOS – it will not be difficult to install them.

And this is what I got…

In the `.emacs` init file

First of all, disable the builtin startup screen.

(setq inhibit-startup-screen t)

Then add a startup hook.

(add-hook 'emacs-startup-hook
  (lambda ()
    (let* ((buffer-today (get-buffer-create "*today*"))
           (buffer-calendar "*Calendar*")
           (buffer-agenda "*Org Agenda*")
           (buffer-diary "*Fancy Diary Entries*"))
      ;; Call calendar first to obtain the current date
      ;; required to display the diary.
      (calendar)
      (diary)
      (org-agenda-list)
      ;; Fill and show the Today Events buffer.
      ;; NOTE: requires `fortune' and `calendar' command line utilities.
      (switch-to-buffer buffer-today)
      (call-process "fortune" nil buffer-today)
      (insert "\n")
      (call-process "calendar" nil buffer-today)
      (goto-char 0)
      (toggle-truncate-lines)
      ;; Maximize the Today Events window
      (delete-other-windows)
      ;; Show Agenda in the lower left quadrant.
      (split-window-vertically)
      (other-window 1)
      (switch-to-buffer (get-buffer buffer-agenda))
      (split-window-horizontally)
      ;; Try to show Diary in the lower right quadrant.
      (other-window 1)
      (if (get-buffer buffer-diary)
          ;; If Diary exists then show it ...
          (switch-to-buffer (get-buffer buffer-diary))
        ;; ... else show the scratch buffer.
        (let* ((buffer-scratch (switch-to-buffer (get-buffer "*scratch*"))))
          (goto-char (point-max))
          (insert (format-time-string "\n;; No diary entries for %A %d %b")))
        )
      ;; Go back to the Today Events buffer.
      (other-window -2)
      (split-window-horizontally)
      ;; Show Calendar in the upper left quadrant.
      (switch-to-buffer (get-buffer buffer-calendar))
      )))

The startup screen

Click or tap to view the full-size picture.

Happy emacsing!

In his comment on Irreal’s post Some Configuration To Solve Common Problems, gregbognar noted that some of my configuration is seriously outdated. In some sense, he is absolutely correct – I’ve been collecting Emacs settings/tweaks since 2012, and keeping them unmodified for 12+ years.

But on the other hand, it demonstrates how stable and powerful Emacs is – everything is still working! If something works, don’t fix it – I’ve since tried to apply this rule wherever possible.

Here are a few functions/enhancements I found helpful.

`dired-mode` enhancements

Function: Calculate the total size of all marked files

The custom dired-get-size function calculates the total size of all marked files in the dired buffer and displays it in the echo area. Files in the dired buffer can be marked with m key and unmarked with u key.

The current version only works on systems with the /usr/bin/du system utility, which actually comprise 100% of the (non-Windows) systems – borrowed from oremacs.com.

(defun dired-get-size ()
  "Display file size in dired."
  (interactive)
  (let ((files (dired-get-marked-files)))
    (with-temp-buffer
      (apply 'call-process "/usr/bin/du" nil t nil "-sch" files)
      (message
       "Size of all marked files: %s"
       (progn
         (re-search-backward "\\(^[ 0-9.,]+[A-Za-z]+\\).*total$")
         (match-string 1))))))

In my config, dired-get-size is bound to z key in the dired-mode.

;; https://oremacs.com/2015/01/12/dired-file-size/
(define-key dired-mode-map "z" #'dired-get-size)

The result of pressing the `z` key in dired.

Some other `dired-mode` enhancements

Move to the parent directory

It reuses the current dired buffer for opening the parent directory (oremacs.com) instead of creating a new buffer. Bounded to the a key in dired-mode.

;; Move to the parent directory.
(define-key dired-mode-map "a"
  (lambda ()
    (interactive)
    (find-alternate-file "..")))

Run `eshell` in the current `dired` directory

Bounded to the ` back-tick key in dired-mode.

;; Run eshell.
(define-key dired-mode-map "`"
  (lambda ()
    (interactive)
    (eshell)))

Date and time stamps

Inserting the date and/or time stamps at the current cursor position. You can bind these functions to any key chords you prefer or call the corresponding function with M-x.

(defun my/time-stamp ()
  "Insert full date/time stamp as 2024-11-29 10:41 +0100 CET"
  (interactive)
  (insert (format-time-string "%Y-%m-%d %R %z %Z")))

(defun my/time-stamp-short ()
  "Insert short date/time stamp as 2024-11-29 10:41"
  (interactive)
  (insert (format-time-string "%Y-%m-%d %R")))

(defun my/date-stamp ()
  "Insert date stamp as 2024-11-29"
  (interactive)
  (insert (format-time-string "%Y-%m-%d")))

Some editing tweaks

Inserting a new line

Insert a new line, indent it, and move the cursor there. This behavior is different then the typical function bound to Enter which may be open-line or newline-and-indent. When you call them with the cursor between ^ (beginning of line) and $ (end of line), the contents of the line to the right of it will be moved to the newly inserted line. This function will not do that. Instead, the current line is left alone, a new line is inserted, indented, and the cursor is moved there. Borrowed from emacsredux.

(defun smart-open-line ()
  "Insert a new line, indent it, and move the cursor there."
  (interactive)
  (move-end-of-line nil)
  (newline-and-indent))

(global-set-key (kbd "<C-return>") #'smart-open-line)

I have bound it globally to Ctrl-Enter – C-return in the Emacs notation – so it should work in any mode.

Smart beginning of line

Move point to first non-whitespace character or beginning-of-line.

(defun smart-beginning-of-line ()
  "Move point to first non-whitespace character or `beginning-of-line`."
  (interactive)
  (let ((oldpos (point)))
    (back-to-indentation)
    (and (= oldpos (point))
         (beginning-of-line))))

(global-set-key (kbd "C-a") #'smart-beginning-of-line)

I’ve rebound the default Ctrl-A – C-a in the Emacs notation – to move to first non-whitespace character of a line instead of first column.

Killing a word at point

Deleting the whole word at the cursor position.

(defun kill-whole-word ()
  "Kill the current word at point."
  (interactive)
  (backward-word)
  (kill-word 1))

(define-key global-map (kbd "<M-DEL>") #'kill-whole-word)

I’ve rebound it to Alt-delete – M-DEL in the Emacs notation.

Nuke all buffers

Kill all buffers, leaving *scratch* only.

(defun nuke-all-buffers ()
  "Kill all buffers, leaving *scratch* only."
  (interactive)
  (mapc
   (lambda (buffer)
     (kill-buffer buffer))
   (buffer-list))
  (delete-other-windows))

To be continued. Happy emacsing!

I’m happy to be back after one year away and it feels great.

Below are some chaotic mini/micro – or even nano – excerpts from my ~/.emacs file I have been tuning in for 12 years. These days, I’m running Emacs 29.4 on Ubuntu (Pop!_OS) 22.04 and, rarely, on macOS.

These tweaks have been collected from various sources; I provide a reference to the source if available.

Checking the operating system Emacs is running on

(defvar my/os-linux (string-equal system-type "gnu/linux") "I'm on Linux")
(defvar my/os-macos (string-equal system-type "darwin") "Oh, I'm on macOS")
(defvar my/os-windows (string-equal system-type "windows-nt") "OMG, that's Windows!")

macOS keyboard

;; Disable Command key and enable Options as Meta.
(if my/os-macos
    (setq mac-command-key-is-meta nil
          mac-command-modifier 'super
          mac-option-key-is-meta t
          mac-option-modifier 'meta))

Everything is UTF-8

(set-language-environment 'utf-8)
(setq locale-coding-system 'utf-8)
(setq buffer-file-coding-system 'utf-8-unix)
(set-terminal-coding-system 'utf-8)
(set-keyboard-coding-system 'utf-8)
(set-selection-coding-system 'utf-8)
(prefer-coding-system 'utf-8)

Smooth scrolling

Borrowed from http://home.thep.lu.se/~karlf/emacs.html

(setq scroll-step 1)

;; Marker distance from center (don't jump to center).
(setq scroll-conservatively 100000)

;; Try to keep screen position when PgDn/PgUp.
(setq scroll-preserve-screen-position 1)

;; Start scrolling when marker at top/bottom.
(setq scroll-margin 0)

;; Mouse scroll moves 1 line at a time, instead of 5 lines.
(setq mouse-wheel-scroll-amount '(1))

;; On a long mouse scroll keep scrolling by 1 line.
(setq mouse-wheel-progressive-speed nil)

Some helpful tips for emacsing in comfort

Clipboard

;; Non-nil means cutting and pasting uses the clipboard.
(setq x-select-enable-clipboard t)

Turning off some annoying features

;; No ToolBar, please.
(tool-bar-mode -1)

;; No alarms, please.
(setq ring-bell-function 'ignore)

;; No lock files, please.
;; https://emacs.stackexchange.com/questions/78800/how-to-disable-automatic-appearance-of-warnings-buffer-in-emacs
(setq create-lockfiles nil)

;; Sentences do not need double spaces to end. Period.
(set-default 'sentence-end-double-space nil)

;; Replace "yes" by "y".
(fset 'yes-or-no-p 'y-or-n-p)

;; Don’t use dialog boxes.
(setq use-dialog-box nil)

;; For gpg (works on Ubuntu and macOS) to disable custom prompt.
(setenv "GPG_AGENT_INFO" nil)

;; Speedup cursor movement.
;; https://emacs.stackexchange.com/questions/28736/emacs-pointcursor-movement-lag/28746
(setq auto-window-vscroll nil)

;; Spaces instead of tabs when indenting.
;; Some people may not agree with this though.
(setq-default indent-tabs-mode nil)

Turning on some helpful features

;; Nonzero means echo unfinished commands after this many seconds of
;; pause. The value may be integer or floating point. If the value is
;; zero, don’t echo at all.
(setq echo-keystrokes 0.01)

;; Winner mode is a global minor mode that records the changes in the
;; window configuration.
;; https://www.gnu.org/software/emacs/manual/html_node/emacs/Window-Convenience.html
(winner-mode t)

;; Turn on highlighting current line.
;; http://ergoemacs.org/emacs/emacs_make_modern.html
(global-hl-line-mode 1)

;; Replace highlighted text with what I type rather than just
;; inserting at point.
(delete-selection-mode t)

;; Restore opened files.
(desktop-save-mode 1)

;; Save minibuffer history.
(savehist-mode 1)

;; When on a tab, make the cursor the tab length.
(setq-default x-stretch-cursor t)

;; Auto refresh dired when file changes.
;; http://pragmaticemacs.com/emacs/automatically-revert-buffers/
(add-hook 'dired-mode-hook 'auto-revert-mode)

;; Auto refresh dired, but be quiet about it.
(setq global-auto-revert-non-file-buffers t)
(setq auto-revert-verbose nil)

;; Automatically reload files was modified by external program.
;; https://www.emacswiki.org/emacs/AutoRevertMode
(global-auto-revert-mode 1)

;; Make URLs in comments/strings clickable, (Emacs > v22).
(add-hook 'find-file-hooks 'goto-address-prog-mode)

;; Display fringe indicators in `visual-line-mode`.
(setq visual-line-fringe-indicators '(left-curly-arrow right-curly-arrow))

;; Switching the focus to the help window when it's opened.
(setq help-window-select t)

Frame title

Template for displaying the title bar of visible frames. (Assuming the window manager supports this feature.)

This variable has the same structure as mode-line-format, except that the %c, %C, and %l constructs are ignored.

;; Frame title.
(setq frame-title-format "%F--%b-[%f]--%Z")

Electric Pair mode

Electric Pair mode is a global minor mode. When enabled, typing an open parenthesis automatically inserts the corresponding closing parenthesis, and vice versa. (Likewise for brackets, etc.). If the region is active, the parentheses (brackets, etc.) are inserted around the region instead.

;; Global.
(electric-pair-mode 1)

Calendar tweaks

If you want to be informed about the times of sunrise and sunset for any date at your location, Emacs is always ready to lend a hand – you just need to provide your coordinates to Emacs. Use one decimal place in the values of calendar-latitude and calendar-longitude.

(defvar calendar-latitude NN.N)
(defvar calendar-longitude NN.N)

;; Number of minutes difference between local standard time and UTC.
;; For example, -300 for New York City, -480 for Los Angeles.
(defvar calendar-time-zone NNN)

;; Optional, the default value is just the variable `calendar-latitude`
;; paired with the variable `calendar-longitude`.
(defvar calendar-location-name "Your City, Your Country")

Within the calendar, the following commands are available:

S: Display times of sunrise and sunset for the selected date (calendar-sunrise-sunset).
M-x sunrise-sunset: Display times of sunrise and sunset for today’s date.
C-u M-x sunrise-sunset: Display times of sunrise and sunset for a specified date.
M-x calendar-sunrise-sunset-month: Display times of sunrise and sunset for the selected month.

The command M-x sunrise-sunset is also available outside the calendar to display the sunrise and sunset information for today’s date in the echo area.

Some other Calendar tweaks

;; First day of the week: 0:Sunday, 1:Monday.
(defvar calendar-week-start-day 1)

;; Use European date format (DD/MM/YYYY or 9 October 2024).
(defvar calendar-date-style 'european)

To be continued. Happy emacsing!

After reading a quite interesting post by Irreal on Org mode clock tables, I decided to share my — a bit specific — experience with the subject.

The Task

Like many of us these days, I’m working remotely. My employer requires a periodic report and I should track my time I spend on various task — exactly as Irreal describes in his post. Of course, I’m using Org mode clock tables for that purpose.

#+TITLE: Worktime Tracker for July 2023
#+OPTIONS: num:nil toc:nil

#+BEGIN: clocktable :maxlevel 3 :scope file
#+END

* 2023-07    :2023:

** 2023-07-03
*** Impl. a test gRPC server                            :TEST:
:LOGBOOK:
CLOCK: [2023-07-03 Mon 15:05]--[2023-07-03 Mon 15:50] =>  0:45
CLOCK: [2023-07-03 Mon 09:45]--[2023-07-03 Mon 14:10] =>  4:25
:END:

** 2023-07-04
*** Fix client timeout                                   :FIX:
:LOGBOOK:
CLOCK: [2023-07-04 Tue 12:45]--[2023-07-04 Tue 13:10] =>  0:25
:END:
*** Add AddOrder handler                                :FEAT:
:LOGBOOK:
CLOCK: [2023-07-04 Tue 14:05]--[2023-07-04 Tue 15:10] =>  1:05
:END:

Then if I put the cursor at the line with the word #+BEGIN (line #4 in my org file) and press C-c C-c (in the Org mode, this chord runs the multipurpose command org-ctrl-c-ctrl-c), the dynamic clock table block is getting updated immediately and I get a standard clock table report as shown below.

#+BEGIN: clocktable :maxlevel 3 :scope file
#+CAPTION: Clock summary at [2023-07-30 Sun 15:32]
| Headline                       | Time |      |      |
|--------------------------------+------+------+------|
| *Total time*                   |*6:40*|      |      |
|--------------------------------+------+------+------|
| 2023-07                        | 6:40 |      |      |
| \_  2023-07-03                 |      | 5:10 |      |
| \_    Impl. a test gRPC server |      |      | 5:10 |
| \_  2023-07-04                 |      | 1:30 |      |
| \_    Fix client timeout       |      |      | 0:25 |
| \_    Add AddOrder handler     |      |      | 1:05 |
#+END

So far, everything looks fine.

The Problem

The problem is that my employer wants the report to be in a specific format.

The required MS Word (sic!) file with the work time report.

Please note the column #1 should contain a tag of the task, all dates should be in the DD.MM.YYYY format, a time spent for the task should be in the hh:mm format, left-padded with 0s if required, and the total time should be in the hhh:mm format, left-padded with 0s as well.

Here the adventure begins.

The Adventure

I decided to implement my exporter as the Elisp code block inside my time tracking org file. Therefore, if I press C-c C-c when the cursor is over the exporter code block, Emacs evaluates this block and prints the result just below the block. This would allow us to make some experiments.

First of all, I need an access to my clock table entries. After some research I found what I need — org-clock-get-table-data, a built-in function defined in the org-clock.el[.gz] file (as of Emacs 28.2).

(defun org-clock-get-table-data (file params)
  "Get the clocktable data for file FILE, with parameters PARAMS.
FILE is only for identification - this function assumes that
the correct buffer is current, and that the wanted restriction is
in place.
The return value will be a list with the file name and the total
file time (in minutes) as 1st and 2nd elements.  The third element
of this list will be a list of headline entries.  Each entry has the
following structure:

  (LEVEL HEADLINE TAGS TIMESTAMP TIME PROPERTIES)

LEVEL:      The level of the headline, as an integer.  This will be
            the reduced level, so 1,2,3,... even if only odd levels
            are being used.
HEADLINE:   The text of the headline.  Depending on PARAMS, this may
            already be formatted like a link.
TAGS:       The list of tags of the headline.
TIMESTAMP:  If PARAMS require it, this will be a time stamp found in the
            entry, any of SCHEDULED, DEADLINE, NORMAL, or first inactive,
            in this sequence.
TIME:       The sum of all time spend in this tree, in minutes.  This time
            will of cause be restricted to the time block and tags match
            specified in PARAMS.
PROPERTIES: The list properties specified in the `:properties' parameter
            along with their value, as an alist following the pattern
            (NAME . VALUE)."

Let’s make an experiment.

#+begin_src elisp
(org-clock-get-table-data buffer-file-name '(:tags t))
#+end_src

#+RESULTS:
| /home/magnolia/Desktop/demo.org | 400 | ((1 2023-07 (2023) nil 400 nil) (2 2023-07-03 (2023) nil 310 nil) (3 Impl. a test gRPC server (2023 TEST) nil 310 nil) (2 2023-07-04 (2023) nil 90 nil) (3 Fix client timeout (2023 FIX) nil 25 nil) (3 Add AddOrder handler (2023 FEAT) nil 65 nil)) |

Please note the output is an Org table because the result is a list. Please also note the '(:tags t) parameter — it is required because we want all tags to be included in the output.

Obviously, we actually want the 3rd element of the output list.

#+begin_src elisp
(nth 2 (org-clock-get-table-data buffer-file-name '(:tags t)))
#+end_src

#+RESULTS:
| 1 |                  2023-07 | (2023)      | nil | 400 | nil |
| 2 |               2023-07-03 | (2023)      | nil | 310 | nil |
| 3 | Impl. a test gRPC server | (2023 TEST) | nil | 310 | nil |
| 2 |               2023-07-04 | (2023)      | nil |  90 | nil |
| 3 |       Fix client timeout | (2023 FIX)  | nil |  25 | nil |
| 3 |     Add AddOrder handler | (2023 FEAT) | nil |  65 | nil |

It seems we are on the right way. The column #1 contains the level of the headline, as an integer; #2 — the text of the headline; #3 — the list of tags of the headline; #5 — the sum of all time spend in this tree, in minutes, as an integer.

The Magic

Before implementing the clock table parser, we need some utilities.

First of all we should convert a date from the ISO 8601 format (YYYY-MM-DD) to the European DD.MM.YYYY format. According to the GNU Emacs Lisp Reference Manual, we can use two built-in functions for this purpose:

Function: format-time-string format-string &optional time zone

This function converts time (which should be a Lisp timestamp, and defaults to the current time if time is omitted or nil) to a string according to format-string.

and

Function: date-to-time string

This function parses the time-string string and returns the corresponding Lisp timestamp. This function assumes Universal Time if string lacks explicit time zone information, and assumes earliest values if string lacks month, day, or time.

As we’ll see below, the last sentence (in italic) is wrong — at least as of Emacs 28.2. Maybe it has something to do with this bug in Emacs 28, I don’t know.

Okay, let’s test it out.

#+begin_src elisp
  (format-time-string "%d.%m.%Y" (date-to-time "2023-07"))
#+end_src

Error: date-to-time: Invalid date: 2023-07

This doesn’t work.

#+begin_src elisp
  (format-time-string "%d.%m.%Y" (date-to-time "2023-07-04"))
#+end_src

Error: date-to-time: Invalid date: 2023-07-04

This doesn’t work as well.

This is where the magic begins. Let’s add a fake time component T01 to the ISO date string.

#+begin_src elisp
  (format-time-string "%d.%m.%Y" (date-to-time "2023-07-04T01"))
#+end_src

#+RESULTS:
: 04.07.2023

It worked, I’m so happy.

Now let’s implement a utility function that converts a time, in minutes, as an integer, to the properly padded string.

#+begin_src elisp
  (defun my/clock--format-time (time-in-minutes &optional padding)
  "Convert TIME-IN-MINUTES, as an integer, to a string,
   with hours left-padded with zeroes. Default PADDING is 2."
    (let* ((hours (/ time-in-minutes 60))
           (minutes (- time-in-minutes (* hours 60))))
      (format (concat "%0" (format "%d" (or padding 2)) "d:%02d")
               hours minutes)))

;; TEST
(my/clock--format-time 310)
#+end_src

#+RESULTS:
: 05:10

Okay, it works.

The Result

Now let’s combine everything together and then evaluate the code block.

#+begin_src elisp
  (require 'org-clock)

  (defvar my/cur-date nil "Holds the current entry date.")

  (defun my/clock--format-time (time-in-minutes &optional padding)
  "Convert TIME-IN-MINUTES, as an integer, to a string,
   with hours left-padded with zeroes. Default PADDING is 2."
    (let* ((hours (/ time-in-minutes 60))
           (minutes (- time-in-minutes (* hours 60))))
      (format (concat "%0" (format "%d" (or padding 2)) "d:%02d")
               hours minutes)))

  (defun my/clock--parse-entry (entry)
  "Parse the clock table ENTRY, returning a list of row items,
   depending on the level of the headline."
    (let* ((level (car entry))
           (headline (nth 1 entry))
           (tag (nth 1 (nth 2 entry)))
           (minutes (nth 4 entry))
           (date (if (= level 2)
                     (format-time-string "%d.%m.%Y"
                         (date-to-time (concat headline "T01"))))))
      (cond
        ((= level 1) (list headline "TOTAL" "" (my/clock--format-time minutes 3)))
        ((= level 2) (progn (setq my/cur-date date) nil))
        ((= level 3) (list tag headline my/cur-date (my/clock--format-time minutes)))
      )))

  ;; Apply the parser to every entry in the clock table.
  (mapcar #'my/clock--parse-entry
     (nth 2 (org-clock-get-table-data buffer-file-name '(:tags t))))
#+end_src

#+RESULTS:
| 2023-07 | TOTAL                    |            | 006:40 |
| TEST    | Impl. a test gRPC server | 03.07.2023 |  05:10 |
| FIX     | Fix client timeout       | 04.07.2023 |  00:25 |
| FEAT    | Add AddOrder handler     | 04.07.2023 |  01:05 |

Bingo! We’ve got what we exactly want — the Org mode table filled with properly formatted data. Now I can just copy this table from my work time org file to another org file and export it to the ODT file (and then save it as the MS Word file).

The MS Word file with the work time report.

Tested on Ubuntu Linux (Pop!_OS 20.10) and MS Windows 10 using Emacs 28.2.

Conclusions

We can have access to all the data collected in a clock table.
Org mode code blocks provide an ideal way to make experiments, testing your code, and getting the result inplace.
In Emacs, you can do everything.

Happy emacsing!

Working with satellite data I often have to convert a coordinate value or an angle value from the DMS notation (degree@minute’second") to a decimal degree in the floating point number format and vice versa.

DMS to Decimal Degree

Of course, I want to do this directly in an Emacs buffer, so I wrote a simple function that uses deg and hms functions provided by the built-in superb calc package.

(defun dms2deg (p1 p2)
  "Converts a region from the DMS (dd@mm'ss\")
  to a decimal degree.
  P1,P2 are the beginning and the end of the region
  (selection) respectively."
  (interactive "r")
  (let (s)
    (if (region-active-p)
        (progn
          (setq s (calc-eval
              (concat "deg(" (buffer-substring-no-properties p1 p2) ")")))
          (delete-active-region)
          (insert s))
      (message "No active region!"))
    )
  )

I’ve bound this function to the Ctrl+F6 key chord (C-f6 in the Emacs notation) globally. Of course, you can use your own key combination.

(global-set-key [(control f6)] #'dms2deg)

Now I can select a region in a buffer, press C-f6 and replace the selection with its decimal value, so 30@15'54" becomes 30.265.

Decimal Degree to DMS

The inverse function (bound to S-f6 or Shift+F6) replaces a floating point with the corresponding DMS string.

(defun deg2dms (p1 p2)
  "Converts a region from a decimal degree
  to the DMS format (dd@ mm' ss\").
  P1,P2 - beginning and end of the region
  (selection) respectively."
  (interactive "r")
  (let (s)
    (if (region-active-p)
        (progn
          (setq s (calc-eval
              (concat "hms(" (buffer-substring-no-properties p1 p2) ")")))
          (delete-active-region)
          (insert s))
      (message "No active region!"))
    )
  )

(global-set-key [(shift f6)] #'deg2dms)

Now if you select a region in a buffer and then press S-f6, your 30.265 becomes 30@ 15' 54."

Enhanced Version

After a while, I decided to enhance the first conversion function by adding an ‘inline calculator’ feature. It works quite simple: if a selected region contains the ‘@’ character, the region is considered as a coordinate (angle) value in the DMS notation, and it should be replaced with its decimal value. Otherwise, the region is considered as an arithmetic expression (in terms of the Emacs’ calc) and its calculated value will be inserted just after the region.

(defun avs/calc-region (p1 p2)
  "Calculates a region or converts DMS to decimal.
   P1,P2 - beginning and end of the region
   respectively."
  (interactive "r")
  (if (region-active-p)
      (let ((b (buffer-substring-no-properties p1 p2)))
        (cond ((string-match-p "@" b) ; convert DMS to decimal ...
               (delete-active-region)
               (insert (calc-eval (concat "deg(" b ")"))))
              (t ; ... otherwise calculate a region
               (goto-char (region-end))
               (pop-mark)
               (insert " = " (calc-eval b))))
        )
    (message "No active region!"))
  )

(global-set-key [(f6)] 'avs/calc-region)

The enhanced function is bound to f6. So now if you press F6, 15@45'20" becomes 15.7555555556, and ((350.0 / 7) + 48.314) becomes ((350.0 / 7) + 48.314) = 98.314.

Conclusion

Emacs’ calc is great.

As a next step, I want to implement DMS and Decimal degree conversions to the DD:MM:SS format used by the excellent Generic Mapping Tools (GMT) toolbox.

In the .emacs init file