lisp/ox-odt.el

   1 ;;; ox-odt.el --- OpenDocument Text Exporter for Org Mode
   2
   3 ;; Copyright (C) 2010-2013 Free Software Foundation, Inc.
   4
   5 ;; Author: Jambunathan K <kjambunathan at gmail dot com>
   6 ;; Keywords: outlines, hypermedia, calendar, wp
   7 ;; Homepage: http://orgmode.org
   8
   9 ;; This file is part of GNU Emacs.
  10
  11 ;; GNU Emacs is free software: you can redistribute it and/or modify
  12 ;; it under the terms of the GNU General Public License as published by
  13 ;; the Free Software Foundation, either version 3 of the License, or
  14 ;; (at your option) any later version.
  15
  16 ;; GNU Emacs is distributed in the hope that it will be useful,
  17 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
  18 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19 ;; GNU General Public License for more details.
  20
  21 ;; You should have received a copy of the GNU General Public License
  22 ;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
  23
  24 ;;; Commentary:
  25
  26 ;;; Code:
  27
  28 (eval-when-compile
  29   (require 'cl)
  30   (require 'table nil 'noerror))
  31 (require 'format-spec)
  32 (require 'ox)
  33 (require 'org-compat)
  34
  35 ;;; Define Back-End
  36
  37 (org-export-define-backend 'odt
  38   '((bold . org-odt-bold)
  39     (center-block . org-odt-center-block)
  40     (clock . org-odt-clock)
  41     (code . org-odt-code)
  42     (drawer . org-odt-drawer)
  43     (dynamic-block . org-odt-dynamic-block)
  44     (entity . org-odt-entity)
  45     (example-block . org-odt-example-block)
  46     (export-block . org-odt-export-block)
  47     (export-snippet . org-odt-export-snippet)
  48     (fixed-width . org-odt-fixed-width)
  49     (footnote-definition . org-odt-footnote-definition)
  50     (footnote-reference . org-odt-footnote-reference)
  51     (headline . org-odt-headline)
  52     (horizontal-rule . org-odt-horizontal-rule)
  53     (inline-src-block . org-odt-inline-src-block)
  54     (inlinetask . org-odt-inlinetask)
  55     (italic . org-odt-italic)
  56     (item . org-odt-item)
  57     (keyword . org-odt-keyword)
  58     (latex-environment . org-odt-latex-environment)
  59     (latex-fragment . org-odt-latex-fragment)
  60     (line-break . org-odt-line-break)
  61     (link . org-odt-link)
  62     (node-property . org-odt-node-property)
  63     (paragraph . org-odt-paragraph)
  64     (plain-list . org-odt-plain-list)
  65     (plain-text . org-odt-plain-text)
  66     (planning . org-odt-planning)
  67     (property-drawer . org-odt-property-drawer)
  68     (quote-block . org-odt-quote-block)
  69     (quote-section . org-odt-quote-section)
  70     (radio-target . org-odt-radio-target)
  71     (section . org-odt-section)
  72     (special-block . org-odt-special-block)
  73     (src-block . org-odt-src-block)
  74     (statistics-cookie . org-odt-statistics-cookie)
  75     (strike-through . org-odt-strike-through)
  76     (subscript . org-odt-subscript)
  77     (superscript . org-odt-superscript)
  78     (table . org-odt-table)
  79     (table-cell . org-odt-table-cell)
  80     (table-row . org-odt-table-row)
  81     (target . org-odt-target)
  82     (template . org-odt-template)
  83     (timestamp . org-odt-timestamp)
  84     (underline . org-odt-underline)
  85     (verbatim . org-odt-verbatim)
  86     (verse-block . org-odt-verse-block))
  87   :export-block "ODT"
  88   :filters-alist '((:filter-parse-tree
  89                     . (org-odt--translate-latex-fragments
  90                        org-odt--translate-description-lists
  91                        org-odt--translate-list-tables)))
  92   :menu-entry
  93   '(?o "Export to ODT"
  94        ((?o "As ODT file" org-odt-export-to-odt)
  95         (?O "As ODT file and open"
  96             (lambda (a s v b)
  97               (if a (org-odt-export-to-odt t s v)
  98                 (org-open-file (org-odt-export-to-odt nil s v) 'system))))))
  99   :options-alist
 100   '((:odt-styles-file "ODT_STYLES_FILE" nil nil t)
 101     ;; Redefine regular option.
 102     (:with-latex nil "tex" org-odt-with-latex)))
 103
 104
 105 ;;; Dependencies
 106
 107 ;;; Hooks
 108
 109 ;;; Function Declarations
 110
 111 (declare-function org-id-find-id-file "org-id" (id))
 112 (declare-function hfy-face-to-style "htmlfontify" (fn))
 113 (declare-function hfy-face-or-def-to-name "htmlfontify" (fn))
 114 (declare-function archive-zip-extract "arc-mode" (archive name))
 115 (declare-function org-create-math-formula "org" (latex-frag &optional mathml-file))
 116 (declare-function browse-url-file-url "browse-url" (file))
 117
 118
 119 \f
 120 ;;; Internal Variables
 121
 122 (defconst org-odt-lib-dir
 123   (file-name-directory load-file-name)
 124   "Location of ODT exporter.
 125 Use this to infer values of `org-odt-styles-dir' and
 126 `org-odt-schema-dir'.")
 127
 128 (defvar org-odt-data-dir
 129   (expand-file-name "../../etc/" org-odt-lib-dir)
 130   "Data directory for ODT exporter.
 131 Use this to infer values of `org-odt-styles-dir' and
 132 `org-odt-schema-dir'.")
 133
 134 (defconst org-odt-special-string-regexps
 135   '(("\\\\-" . "&#x00ad;\\1")           ; shy
 136     ("---\\([^-]\\)" . "&#x2014;\\1")   ; mdash
 137     ("--\\([^-]\\)" . "&#x2013;\\1")    ; ndash
 138     ("\\.\\.\\." . "&#x2026;"))         ; hellip
 139   "Regular expressions for special string conversion.")
 140
 141 (defconst org-odt-schema-dir-list
 142   (list
 143    (and org-odt-data-dir
 144         (expand-file-name "./schema/" org-odt-data-dir)) ; bail out
 145    (eval-when-compile
 146      (and (boundp 'org-odt-data-dir) org-odt-data-dir ; see make install
 147           (expand-file-name "./schema/" org-odt-data-dir))))
 148   "List of directories to search for OpenDocument schema files.
 149 Use this list to set the default value of
 150 `org-odt-schema-dir'.  The entries in this list are
 151 populated heuristically based on the values of `org-odt-lib-dir'
 152 and `org-odt-data-dir'.")
 153
 154 (defconst org-odt-styles-dir-list
 155   (list
 156    (and org-odt-data-dir
 157         (expand-file-name "./styles/" org-odt-data-dir)) ; bail out
 158    (eval-when-compile
 159      (and (boundp 'org-odt-data-dir) org-odt-data-dir ; see make install
 160           (expand-file-name "./styles/" org-odt-data-dir)))
 161    (expand-file-name "../../etc/styles/" org-odt-lib-dir) ; git
 162    (expand-file-name "./etc/styles/" org-odt-lib-dir)  ; elpa
 163    (expand-file-name "./org/" data-directory)          ; system
 164    )
 165   "List of directories to search for OpenDocument styles files.
 166 See `org-odt-styles-dir'.  The entries in this list are populated
 167 heuristically based on the values of `org-odt-lib-dir' and
 168 `org-odt-data-dir'.")
 169
 170 (defconst org-odt-styles-dir
 171   (let* ((styles-dir
 172           (catch 'styles-dir
 173             (message "Debug (ox-odt): Searching for OpenDocument styles files...")
 174             (mapc (lambda (styles-dir)
 175                     (when styles-dir
 176                       (message "Debug (ox-odt): Trying %s..." styles-dir)
 177                       (when (and (file-readable-p
 178                                   (expand-file-name
 179                                    "OrgOdtContentTemplate.xml" styles-dir))
 180                                  (file-readable-p
 181                                   (expand-file-name
 182                                    "OrgOdtStyles.xml" styles-dir)))
 183                         (message "Debug (ox-odt): Using styles under %s"
 184                                  styles-dir)
 185                         (throw 'styles-dir styles-dir))))
 186                   org-odt-styles-dir-list)
 187             nil)))
 188     (unless styles-dir
 189       (error "Error (ox-odt): Cannot find factory styles files, aborting"))
 190     styles-dir)
 191   "Directory that holds auxiliary XML files used by the ODT exporter.
 192
 193 This directory contains the following XML files -
 194  \"OrgOdtStyles.xml\" and \"OrgOdtContentTemplate.xml\".  These
 195  XML files are used as the default values of
 196  `org-odt-styles-file' and
 197  `org-odt-content-template-file'.
 198
 199 The default value of this variable varies depending on the
 200 version of org in use and is initialized from
 201 `org-odt-styles-dir-list'.  Note that the user could be using org
 202 from one of: org's own private git repository, GNU ELPA tar or
 203 standard Emacs.")
 204
 205 (defconst org-odt-bookmark-prefix "OrgXref.")
 206
 207 (defconst org-odt-manifest-file-entry-tag
 208   "\n<manifest:file-entry manifest:media-type=\"%s\" manifest:full-path=\"%s\"%s/>")
 209
 210 (defconst org-odt-file-extensions
 211   '(("odt" . "OpenDocument Text")
 212     ("ott" . "OpenDocument Text Template")
 213     ("odm" . "OpenDocument Master Document")
 214     ("ods" . "OpenDocument Spreadsheet")
 215     ("ots" . "OpenDocument Spreadsheet Template")
 216     ("odg" . "OpenDocument Drawing (Graphics)")
 217     ("otg" . "OpenDocument Drawing Template")
 218     ("odp" . "OpenDocument Presentation")
 219     ("otp" . "OpenDocument Presentation Template")
 220     ("odi" . "OpenDocument Image")
 221     ("odf" . "OpenDocument Formula")
 222     ("odc" . "OpenDocument Chart")))
 223
 224 (defconst org-odt-table-style-format
 225   "
 226 <style:style style:name=\"%s\" style:family=\"table\">
 227   <style:table-properties style:rel-width=\"%s%%\" fo:margin-top=\"0cm\" fo:margin-bottom=\"0.20cm\" table:align=\"center\"/>
 228 </style:style>
 229 "
 230   "Template for auto-generated Table styles.")
 231
 232 (defvar org-odt-automatic-styles '()
 233   "Registry of automatic styles for various OBJECT-TYPEs.
 234 The variable has the following form:
 235 \(\(OBJECT-TYPE-A
 236   \(\(OBJECT-NAME-A.1 OBJECT-PROPS-A.1\)
 237    \(OBJECT-NAME-A.2 OBJECT-PROPS-A.2\) ...\)\)
 238  \(OBJECT-TYPE-B
 239   \(\(OBJECT-NAME-B.1 OBJECT-PROPS-B.1\)
 240    \(OBJECT-NAME-B.2 OBJECT-PROPS-B.2\) ...\)\)
 241  ...\).
 242
 243 OBJECT-TYPEs could be \"Section\", \"Table\", \"Figure\" etc.
 244 OBJECT-PROPS is (typically) a plist created by passing
 245 \"#+ATTR_ODT: \" option to `org-odt-parse-block-attributes'.
 246
 247 Use `org-odt-add-automatic-style' to add update this variable.'")
 248
 249 (defvar org-odt-object-counters nil
 250   "Running counters for various OBJECT-TYPEs.
 251 Use this to generate automatic names and style-names. See
 252 `org-odt-add-automatic-style'.")
 253
 254 (defvar org-odt-src-block-paragraph-format
 255   "<style:style style:name=\"OrgSrcBlock\" style:family=\"paragraph\" style:parent-style-name=\"Preformatted_20_Text\">
 256    <style:paragraph-properties fo:background-color=\"%s\" fo:padding=\"0.049cm\" fo:border=\"0.51pt solid #000000\" style:shadow=\"none\">
 257     <style:background-image/>
 258    </style:paragraph-properties>
 259    <style:text-properties fo:color=\"%s\"/>
 260   </style:style>"
 261   "Custom paragraph style for colorized source and example blocks.
 262 This style is much the same as that of \"OrgFixedWidthBlock\"
 263 except that the foreground and background colors are set
 264 according to the default face identified by the `htmlfontify'.")
 265
 266 (defvar hfy-optimisations)
 267 (defvar org-odt-embedded-formulas-count 0)
 268 (defvar org-odt-embedded-images-count 0)
 269 (defvar org-odt-image-size-probe-method
 270   (append (and (executable-find "identify") '(imagemagick)) ; See Bug#10675
 271           '(emacs fixed))
 272   "Ordered list of methods for determining image sizes.")
 273
 274 (defvar org-odt-default-image-sizes-alist
 275   '(("as-char" . (5 . 0.4))
 276     ("paragraph" . (5 . 5)))
 277   "Hardcoded image dimensions one for each of the anchor
 278   methods.")
 279
 280 ;; A4 page size is 21.0 by 29.7 cms
 281 ;; The default page settings has 2cm margin on each of the sides. So
 282 ;; the effective text area is 17.0 by 25.7 cm
 283 (defvar org-odt-max-image-size '(17.0 . 20.0)
 284   "Limiting dimensions for an embedded image.")
 285
 286 (defconst org-odt-label-styles
 287   '(("math-formula" "%c" "text" "(%n)")
 288     ("math-label" "(%n)" "text" "(%n)")
 289     ("category-and-value" "%e %n: %c" "category-and-value" "%e %n")
 290     ("value" "%e %n: %c" "value" "%n"))
 291   "Specify how labels are applied and referenced.
 292
 293 This is an alist where each element is of the form:
 294
 295   \(STYLE-NAME ATTACH-FMT REF-MODE REF-FMT)
 296
 297 ATTACH-FMT controls how labels and captions are attached to an
 298 entity.  It may contain following specifiers - %e and %c.  %e is
 299 replaced with the CATEGORY-NAME.  %n is replaced with
 300 \"<text:sequence ...> SEQNO </text:sequence>\".  %c is replaced
 301 with CAPTION.
 302
 303 REF-MODE and REF-FMT controls how label references are generated.
 304 The following XML is generated for a label reference -
 305 \"<text:sequence-ref text:reference-format=\"REF-MODE\" ...>
 306 REF-FMT </text:sequence-ref>\".  REF-FMT may contain following
 307 specifiers - %e and %n.  %e is replaced with the CATEGORY-NAME.
 308 %n is replaced with SEQNO.
 309
 310 See also `org-odt-format-label'.")
 311
 312 (defvar org-odt-category-map-alist
 313   '(("__Table__" "Table" "value" "Table" org-odt--enumerable-p)
 314     ("__Figure__" "Illustration" "value" "Figure" org-odt--enumerable-image-p)
 315     ("__MathFormula__" "Text" "math-formula" "Equation" org-odt--enumerable-formula-p)
 316     ("__DvipngImage__" "Equation" "value" "Equation" org-odt--enumerable-latex-image-p)
 317     ("__Listing__" "Listing" "value" "Listing" org-odt--enumerable-p))
 318   "Map a CATEGORY-HANDLE to OD-VARIABLE and LABEL-STYLE.
 319
 320 This is a list where each entry is of the form:
 321
 322   \(CATEGORY-HANDLE OD-VARIABLE LABEL-STYLE CATEGORY-NAME ENUMERATOR-PREDICATE)
 323
 324 CATEGORY_HANDLE identifies the captionable entity in question.
 325
 326 OD-VARIABLE is the OpenDocument sequence counter associated with
 327 the entity.  These counters are declared within
 328 \"<text:sequence-decls>...</text:sequence-decls>\" block of
 329 `org-odt-content-template-file'.
 330
 331 LABEL-STYLE is a key into `org-odt-label-styles' and specifies
 332 how a given entity should be captioned and referenced.
 333
 334 CATEGORY-NAME is used for qualifying captions on export.
 335
 336 ENUMERATOR-PREDICATE is used for assigning a sequence number to
 337 the entity.  See `org-odt--enumerate'.")
 338
 339 (defvar org-odt-manifest-file-entries nil)
 340 (defvar hfy-user-sheet-assoc)
 341
 342 (defvar org-odt-zip-dir nil
 343   "Temporary work directory for OpenDocument exporter.")
 344
 345
 346 \f
 347 ;;; User Configuration Variables
 348
 349 (defgroup org-export-odt nil
 350   "Options for exporting Org mode files to ODT."
 351   :tag "Org Export ODT"
 352   :group 'org-export)
 353
 354
 355 ;;;; Debugging
 356
 357 (defcustom org-odt-prettify-xml nil
 358   "Specify whether or not the xml output should be prettified.
 359 When this option is turned on, `indent-region' is run on all
 360 component xml buffers before they are saved.  Turn this off for
 361 regular use.  Turn this on if you need to examine the xml
 362 visually."
 363   :group 'org-export-odt
 364   :version "24.1"
 365   :type 'boolean)
 366
 367
 368 ;;;; Document schema
 369
 370 (require 'rng-loc)
 371 (defcustom org-odt-schema-dir
 372   (let* ((schema-dir
 373           (catch 'schema-dir
 374             (message "Debug (ox-odt): Searching for OpenDocument schema files...")
 375             (mapc
 376              (lambda (schema-dir)
 377                (when schema-dir
 378                  (message "Debug (ox-odt): Trying %s..." schema-dir)
 379                  (when (and (file-expand-wildcards
 380                              (expand-file-name "od-manifest-schema*.rnc"
 381                                                schema-dir))
 382                             (file-expand-wildcards
 383                              (expand-file-name "od-schema*.rnc"
 384                                                schema-dir))
 385                             (file-readable-p
 386                              (expand-file-name "schemas.xml" schema-dir)))
 387                    (message "Debug (ox-odt): Using schema files under %s"
 388                             schema-dir)
 389                    (throw 'schema-dir schema-dir))))
 390              org-odt-schema-dir-list)
 391             (message "Debug (ox-odt): No OpenDocument schema files installed")
 392             nil)))
 393     schema-dir)
 394   "Directory that contains OpenDocument schema files.
 395
 396 This directory contains:
 397 1. rnc files for OpenDocument schema
 398 2. a \"schemas.xml\" file that specifies locating rules needed
 399    for auto validation of OpenDocument XML files.
 400
 401 Use the customize interface to set this variable.  This ensures
 402 that `rng-schema-locating-files' is updated and auto-validation
 403 of OpenDocument XML takes place based on the value
 404 `rng-nxml-auto-validate-flag'.
 405
 406 The default value of this variable varies depending on the
 407 version of org in use and is initialized from
 408 `org-odt-schema-dir-list'.  The OASIS schema files are available
 409 only in the org's private git repository.  It is *not* bundled
 410 with GNU ELPA tar or standard Emacs distribution."
 411   :type '(choice
 412           (const :tag "Not set" nil)
 413           (directory :tag "Schema directory"))
 414   :group 'org-export-odt
 415   :version "24.1"
 416   :set
 417   (lambda (var value)
 418     "Set `org-odt-schema-dir'.
 419 Also add it to `rng-schema-locating-files'."
 420     (let ((schema-dir value))
 421       (set var
 422            (if (and
 423                 (file-expand-wildcards
 424                  (expand-file-name "od-manifest-schema*.rnc" schema-dir))
 425                 (file-expand-wildcards
 426                  (expand-file-name "od-schema*.rnc" schema-dir))
 427                 (file-readable-p
 428                  (expand-file-name "schemas.xml" schema-dir)))
 429                schema-dir
 430              (when value
 431                (message "Error (ox-odt): %s has no OpenDocument schema files"
 432                         value))
 433              nil)))
 434     (when org-odt-schema-dir
 435       (eval-after-load 'rng-loc
 436         '(add-to-list 'rng-schema-locating-files
 437                       (expand-file-name "schemas.xml"
 438                                         org-odt-schema-dir))))))
 439
 440
 441 ;;;; Document styles
 442
 443 (defcustom org-odt-content-template-file nil
 444   "Template file for \"content.xml\".
 445 The exporter embeds the exported content just before
 446 \"</office:text>\" element.
 447
 448 If unspecified, the file named \"OrgOdtContentTemplate.xml\"
 449 under `org-odt-styles-dir' is used."
 450   :type '(choice (const nil)
 451                  (file))
 452   :group 'org-export-odt
 453   :version "24.3")
 454
 455 (defcustom org-odt-styles-file nil
 456   "Default styles file for use with ODT export.
 457 Valid values are one of:
 458 1. nil
 459 2. path to a styles.xml file
 460 3. path to a *.odt or a *.ott file
 461 4. list of the form (ODT-OR-OTT-FILE (FILE-MEMBER-1 FILE-MEMBER-2
 462 ...))
 463
 464 In case of option 1, an in-built styles.xml is used. See
 465 `org-odt-styles-dir' for more information.
 466
 467 In case of option 3, the specified file is unzipped and the
 468 styles.xml embedded therein is used.
 469
 470 In case of option 4, the specified ODT-OR-OTT-FILE is unzipped
 471 and FILE-MEMBER-1, FILE-MEMBER-2 etc are copied in to the
 472 generated odt file.  Use relative path for specifying the
 473 FILE-MEMBERS.  styles.xml must be specified as one of the
 474 FILE-MEMBERS.
 475
 476 Use options 1, 2 or 3 only if styles.xml alone suffices for
 477 achieving the desired formatting.  Use option 4, if the styles.xml
 478 references additional files like header and footer images for
 479 achieving the desired formatting.
 480
 481 Use \"#+ODT_STYLES_FILE: ...\" directive to set this variable on
 482 a per-file basis.  For example,
 483
 484 #+ODT_STYLES_FILE: \"/path/to/styles.xml\" or
 485 #+ODT_STYLES_FILE: (\"/path/to/file.ott\" (\"styles.xml\" \"image/hdr.png\"))."
 486   :group 'org-export-odt
 487   :version "24.1"
 488   :type
 489   '(choice
 490     (const :tag "Factory settings" nil)
 491     (file :must-match t :tag "styles.xml")
 492     (file :must-match t :tag "ODT or OTT file")
 493     (list :tag "ODT or OTT file + Members"
 494           (file :must-match t :tag "ODF Text or Text Template file")
 495           (cons :tag "Members"
 496                 (file :tag "    Member" "styles.xml")
 497                 (repeat (file :tag "Member"))))))
 498
 499 (defcustom org-odt-display-outline-level 2
 500   "Outline levels considered for enumerating captioned entities."
 501   :group 'org-export-odt
 502   :version "24.4"
 503   :package-version '(Org . "8.0")
 504   :type 'integer)
 505
 506 ;;;; Document conversion
 507
 508 (defcustom org-odt-convert-processes
 509   '(("LibreOffice"
 510      "soffice --headless --convert-to %f%x --outdir %d %i")
 511     ("unoconv"
 512      "unoconv -f %f -o %d %i"))
 513   "Specify a list of document converters and their usage.
 514 The converters in this list are offered as choices while
 515 customizing `org-odt-convert-process'.
 516
 517 This variable is a list where each element is of the
 518 form (CONVERTER-NAME CONVERTER-CMD).  CONVERTER-NAME is the name
 519 of the converter.  CONVERTER-CMD is the shell command for the
 520 converter and can contain format specifiers.  These format
 521 specifiers are interpreted as below:
 522
 523 %i input file name in full
 524 %I input file name as a URL
 525 %f format of the output file
 526 %o output file name in full
 527 %O output file name as a URL
 528 %d output dir in full
 529 %D output dir as a URL.
 530 %x extra options as set in `org-odt-convert-capabilities'."
 531   :group 'org-export-odt
 532   :version "24.1"
 533   :type
 534   '(choice
 535     (const :tag "None" nil)
 536     (alist :tag "Converters"
 537            :key-type (string :tag "Converter Name")
 538            :value-type (group (string :tag "Command line")))))
 539
 540 (defcustom org-odt-convert-process "LibreOffice"
 541   "Use this converter to convert from \"odt\" format to other formats.
 542 During customization, the list of converter names are populated
 543 from `org-odt-convert-processes'."
 544   :group 'org-export-odt
 545   :version "24.1"
 546   :type '(choice :convert-widget
 547                  (lambda (w)
 548                    (apply 'widget-convert (widget-type w)
 549                           (eval (car (widget-get w :args)))))
 550                  `((const :tag "None" nil)
 551                    ,@(mapcar (lambda (c)
 552                                `(const :tag ,(car c) ,(car c)))
 553                              org-odt-convert-processes))))
 554
 555 (defcustom org-odt-convert-capabilities
 556   '(("Text"
 557      ("odt" "ott" "doc" "rtf" "docx")
 558      (("pdf" "pdf") ("odt" "odt") ("rtf" "rtf") ("ott" "ott")
 559       ("doc" "doc" ":\"MS Word 97\"") ("docx" "docx") ("html" "html")))
 560     ("Web"
 561      ("html")
 562      (("pdf" "pdf") ("odt" "odt") ("html" "html")))
 563     ("Spreadsheet"
 564      ("ods" "ots" "xls" "csv" "xlsx")
 565      (("pdf" "pdf") ("ots" "ots") ("html" "html") ("csv" "csv") ("ods" "ods")
 566       ("xls" "xls") ("xlsx" "xlsx")))
 567     ("Presentation"
 568      ("odp" "otp" "ppt" "pptx")
 569      (("pdf" "pdf") ("swf" "swf") ("odp" "odp") ("otp" "otp") ("ppt" "ppt")
 570       ("pptx" "pptx") ("odg" "odg"))))
 571   "Specify input and output formats of `org-odt-convert-process'.
 572 More correctly, specify the set of input and output formats that
 573 the user is actually interested in.
 574
 575 This variable is an alist where each element is of the
 576 form (DOCUMENT-CLASS INPUT-FMT-LIST OUTPUT-FMT-ALIST).
 577 INPUT-FMT-LIST is a list of INPUT-FMTs.  OUTPUT-FMT-ALIST is an
 578 alist where each element is of the form (OUTPUT-FMT
 579 OUTPUT-FILE-EXTENSION EXTRA-OPTIONS).
 580
 581 The variable is interpreted as follows:
 582 `org-odt-convert-process' can take any document that is in
 583 INPUT-FMT-LIST and produce any document that is in the
 584 OUTPUT-FMT-LIST.  A document converted to OUTPUT-FMT will have
 585 OUTPUT-FILE-EXTENSION as the file name extension.  OUTPUT-FMT
 586 serves dual purposes:
 587 - It is used for populating completion candidates during
 588   `org-odt-convert' commands.
 589 - It is used as the value of \"%f\" specifier in
 590   `org-odt-convert-process'.
 591
 592 EXTRA-OPTIONS is used as the value of \"%x\" specifier in
 593 `org-odt-convert-process'.
 594
 595 DOCUMENT-CLASS is used to group a set of file formats in
 596 INPUT-FMT-LIST in to a single class.
 597
 598 Note that this variable inherently captures how LibreOffice based
 599 converters work.  LibreOffice maps documents of various formats
 600 to classes like Text, Web, Spreadsheet, Presentation etc and
 601 allow document of a given class (irrespective of it's source
 602 format) to be converted to any of the export formats associated
 603 with that class.
 604
 605 See default setting of this variable for an typical
 606 configuration."
 607   :group 'org-export-odt
 608   :version "24.1"
 609   :type
 610   '(choice
 611     (const :tag "None" nil)
 612     (alist :tag "Capabilities"
 613            :key-type (string :tag "Document Class")
 614            :value-type
 615            (group (repeat :tag "Input formats" (string :tag "Input format"))
 616                   (alist :tag "Output formats"
 617                          :key-type (string :tag "Output format")
 618                          :value-type
 619                          (group (string :tag "Output file extension")
 620                                 (choice
 621                                  (const :tag "None" nil)
 622                                  (string :tag "Extra options"))))))))
 623
 624 (defcustom org-odt-preferred-output-format nil
 625   "Automatically post-process to this format after exporting to \"odt\".
 626 Command `org-odt-export-to-odt' exports first to \"odt\" format
 627 and then uses `org-odt-convert-process' to convert the
 628 resulting document to this format.  During customization of this
 629 variable, the list of valid values are populated based on
 630 `org-odt-convert-capabilities'.
 631
 632 You can set this option on per-file basis using file local
 633 values.  See Info node `(emacs) File Variables'."
 634   :group 'org-export-odt
 635   :version "24.1"
 636   :type '(choice :convert-widget
 637                  (lambda (w)
 638                    (apply 'widget-convert (widget-type w)
 639                           (eval (car (widget-get w :args)))))
 640                  `((const :tag "None" nil)
 641                    ,@(mapcar (lambda (c)
 642                                `(const :tag ,c ,c))
 643                              (org-odt-reachable-formats "odt")))))
 644 ;;;###autoload
 645 (put 'org-odt-preferred-output-format 'safe-local-variable 'stringp)
 646
 647
 648 ;;;; Drawers
 649
 650 (defcustom org-odt-format-drawer-function
 651   (lambda (name contents) contents)
 652   "Function called to format a drawer in ODT code.
 653
 654 The function must accept two parameters:
 655   NAME      the drawer name, like \"LOGBOOK\"
 656   CONTENTS  the contents of the drawer.
 657
 658 The function should return the string to be exported.
 659
 660 The default value simply returns the value of CONTENTS."
 661   :group 'org-export-odt
 662   :version "24.4"
 663   :package-version '(Org . "8.3")
 664   :type 'function)
 665
 666
 667 ;;;; Headline
 668
 669 (defcustom org-odt-format-headline-function 'ignore
 670   "Function to format headline text.
 671
 672 This function will be called with 5 arguments:
 673 TODO      the todo keyword \(string or nil\).
 674 TODO-TYPE the type of todo \(symbol: `todo', `done', nil\)
 675 PRIORITY  the priority of the headline \(integer or nil\)
 676 TEXT      the main headline text \(string\).
 677 TAGS      the tags string, separated with colons \(string or nil\).
 678
 679 The function result will be used as headline text."
 680   :group 'org-export-odt
 681   :version "24.4"
 682   :package-version '(Org . "8.0")
 683   :type 'function)
 684
 685
 686 ;;;; Inlinetasks
 687
 688 (defcustom org-odt-format-inlinetask-function 'ignore
 689   "Function called to format an inlinetask in ODT code.
 690
 691 The function must accept six parameters:
 692   TODO      the todo keyword, as a string
 693   TODO-TYPE the todo type, a symbol among `todo', `done' and nil.
 694   PRIORITY  the inlinetask priority, as a string
 695   NAME      the inlinetask name, as a string.
 696   TAGS      the inlinetask tags, as a string.
 697   CONTENTS  the contents of the inlinetask, as a string.
 698
 699 The function should return the string to be exported."
 700   :group 'org-export-odt
 701   :version "24.4"
 702   :package-version '(Org . "8.0")
 703   :type 'function)
 704
 705
 706 ;;;; LaTeX
 707
 708 (defcustom org-odt-with-latex t
 709   "Non-nil means process LaTeX math snippets.
 710
 711 When set, the exporter will process LaTeX environments and
 712 fragments.
 713
 714 This option can also be set with the +OPTIONS line,
 715 e.g. \"tex:mathjax\".  Allowed values are:
 716
 717 nil            Ignore math snippets.
 718 `verbatim'     Keep everything in verbatim
 719 `dvipng'       Process the LaTeX fragments to images.  This will also
 720                include processing of non-math environments.
 721 `imagemagick'  Convert the LaTeX fragments to pdf files and use
 722                imagemagick to convert pdf files to png files.
 723 `mathjax'      Do MathJax preprocessing and arrange for MathJax.js to
 724                be loaded.
 725 t              Synonym for `mathjax'."
 726   :group 'org-export-odt
 727   :version "24.4"
 728   :package-version '(Org . "8.0")
 729   :set (lambda (var val) (set-default var org-export-with-latex))
 730   :type '(choice
 731           (const :tag "Do not process math in any way" nil)
 732           (const :tag "Use dvipng to make images" dvipng)
 733           (const :tag "Use imagemagick to make images" imagemagick)
 734           (const :tag "Use MathJax to display math" mathjax)
 735           (const :tag "Leave math verbatim" verbatim)))
 736
 737
 738 ;;;; Links
 739
 740 (defcustom org-odt-inline-formula-rules
 741   '(("file" . "\\.\\(mathml\\|mml\\|odf\\)\\'"))
 742   "Rules characterizing formula files that can be inlined into ODT.
 743
 744 A rule consists in an association whose key is the type of link
 745 to consider, and value is a regexp that will be matched against
 746 link's path."
 747   :group 'org-export-odt
 748   :version "24.4"
 749   :package-version '(Org . "8.0")
 750   :type '(alist :key-type (string :tag "Type")
 751                 :value-type (regexp :tag "Path")))
 752
 753 (defcustom org-odt-inline-image-rules
 754   '(("file" . "\\.\\(jpeg\\|jpg\\|png\\|gif\\)\\'"))
 755   "Rules characterizing image files that can be inlined into ODT.
 756
 757 A rule consists in an association whose key is the type of link
 758 to consider, and value is a regexp that will be matched against
 759 link's path."
 760   :group 'org-export-odt
 761   :version "24.4"
 762   :package-version '(Org . "8.0")
 763   :type '(alist :key-type (string :tag "Type")
 764                 :value-type (regexp :tag "Path")))
 765
 766 (defcustom org-odt-pixels-per-inch 96.0
 767   "Scaling factor for converting images pixels to inches.
 768 Use this for sizing of embedded images.  See Info node `(org)
 769 Images in ODT export' for more information."
 770   :type 'float
 771   :group 'org-export-odt
 772   :version "24.4"
 773   :package-version '(Org . "8.1"))
 774
 775
 776 ;;;; Src Block
 777
 778 (defcustom org-odt-create-custom-styles-for-srcblocks t
 779   "Whether custom styles for colorized source blocks be automatically created.
 780 When this option is turned on, the exporter creates custom styles
 781 for source blocks based on the advice of `htmlfontify'.  Creation
 782 of custom styles happen as part of `org-odt-hfy-face-to-css'.
 783
 784 When this option is turned off exporter does not create such
 785 styles.
 786
 787 Use the latter option if you do not want the custom styles to be
 788 based on your current display settings.  It is necessary that the
 789 styles.xml already contains needed styles for colorizing to work.
 790
 791 This variable is effective only if
 792 `org-odt-fontify-srcblocks' is turned on."
 793   :group 'org-export-odt
 794   :version "24.1"
 795   :type 'boolean)
 796
 797 (defcustom org-odt-fontify-srcblocks t
 798   "Specify whether or not source blocks need to be fontified.
 799 Turn this option on if you want to colorize the source code
 800 blocks in the exported file.  For colorization to work, you need
 801 to make available an enhanced version of `htmlfontify' library."
 802   :type 'boolean
 803   :group 'org-export-odt
 804   :version "24.1")
 805
 806
 807 ;;;; Table
 808
 809 (defcustom org-odt-table-styles
 810   '(("OrgEquation" "OrgEquation"
 811      ((use-first-column-styles . t)
 812       (use-last-column-styles . t)))
 813     ("TableWithHeaderRowAndColumn" "Custom"
 814      ((use-first-row-styles . t)
 815       (use-first-column-styles . t)))
 816     ("TableWithFirstRowandLastRow" "Custom"
 817      ((use-first-row-styles . t)
 818       (use-last-row-styles . t)))
 819     ("GriddedTable" "Custom" nil))
 820   "Specify how Table Styles should be derived from a Table Template.
 821 This is a list where each element is of the
 822 form (TABLE-STYLE-NAME TABLE-TEMPLATE-NAME TABLE-CELL-OPTIONS).
 823
 824 TABLE-STYLE-NAME is the style associated with the table through
 825 \"#+ATTR_ODT: :style TABLE-STYLE-NAME\" line.
 826
 827 TABLE-TEMPLATE-NAME is a set of - upto 9 - automatic
 828 TABLE-CELL-STYLE-NAMEs and PARAGRAPH-STYLE-NAMEs (as defined
 829 below) that is included in
 830 `org-odt-content-template-file'.
 831
 832 TABLE-CELL-STYLE-NAME := TABLE-TEMPLATE-NAME + TABLE-CELL-TYPE +
 833                          \"TableCell\"
 834 PARAGRAPH-STYLE-NAME  := TABLE-TEMPLATE-NAME + TABLE-CELL-TYPE +
 835                          \"TableParagraph\"
 836 TABLE-CELL-TYPE       := \"FirstRow\"   | \"LastColumn\" |
 837                          \"FirstRow\"   | \"LastRow\"    |
 838                          \"EvenRow\"    | \"OddRow\"     |
 839                          \"EvenColumn\" | \"OddColumn\"  | \"\"
 840 where \"+\" above denotes string concatenation.
 841
 842 TABLE-CELL-OPTIONS is an alist where each element is of the
 843 form (TABLE-CELL-STYLE-SELECTOR . ON-OR-OFF).
 844 TABLE-CELL-STYLE-SELECTOR := `use-first-row-styles'       |
 845                              `use-last-row-styles'        |
 846                              `use-first-column-styles'    |
 847                              `use-last-column-styles'     |
 848                              `use-banding-rows-styles'    |
 849                              `use-banding-columns-styles' |
 850                              `use-first-row-styles'
 851 ON-OR-OFF                 := `t' | `nil'
 852
 853 For example, with the following configuration
 854
 855 \(setq org-odt-table-styles
 856       '\(\(\"TableWithHeaderRowsAndColumns\" \"Custom\"
 857          \(\(use-first-row-styles . t\)
 858           \(use-first-column-styles . t\)\)\)
 859         \(\"TableWithHeaderColumns\" \"Custom\"
 860          \(\(use-first-column-styles . t\)\)\)\)\)
 861
 862 1. A table associated with \"TableWithHeaderRowsAndColumns\"
 863    style will use the following table-cell styles -
 864    \"CustomFirstRowTableCell\", \"CustomFirstColumnTableCell\",
 865    \"CustomTableCell\" and the following paragraph styles
 866    \"CustomFirstRowTableParagraph\",
 867    \"CustomFirstColumnTableParagraph\", \"CustomTableParagraph\"
 868    as appropriate.
 869
 870 2. A table associated with \"TableWithHeaderColumns\" style will
 871    use the following table-cell styles -
 872    \"CustomFirstColumnTableCell\", \"CustomTableCell\" and the
 873    following paragraph styles
 874    \"CustomFirstColumnTableParagraph\", \"CustomTableParagraph\"
 875    as appropriate..
 876
 877 Note that TABLE-TEMPLATE-NAME corresponds to the
 878 \"<table:table-template>\" elements contained within
 879 \"<office:styles>\".  The entries (TABLE-STYLE-NAME
 880 TABLE-TEMPLATE-NAME TABLE-CELL-OPTIONS) correspond to
 881 \"table:template-name\" and \"table:use-first-row-styles\" etc
 882 attributes of \"<table:table>\" element.  Refer ODF-1.2
 883 specification for more information.  Also consult the
 884 implementation filed under `org-odt-get-table-cell-styles'.
 885
 886 The TABLE-STYLE-NAME \"OrgEquation\" is used internally for
 887 formatting of numbered display equations.  Do not delete this
 888 style from the list."
 889   :group 'org-export-odt
 890   :version "24.1"
 891   :type '(choice
 892           (const :tag "None" nil)
 893           (repeat :tag "Table Styles"
 894                   (list :tag "Table Style Specification"
 895                         (string :tag "Table Style Name")
 896                         (string  :tag "Table Template Name")
 897                         (alist :options (use-first-row-styles
 898                                          use-last-row-styles
 899                                          use-first-column-styles
 900                                          use-last-column-styles
 901                                          use-banding-rows-styles
 902                                          use-banding-columns-styles)
 903                                :key-type symbol
 904                                :value-type (const :tag "True" t))))))
 905
 906 ;;;; Timestamps
 907
 908 (defcustom org-odt-use-date-fields nil
 909   "Non-nil, if timestamps should be exported as date fields.
 910
 911 When nil, export timestamps as plain text.
 912
 913 When non-nil, map `org-time-stamp-custom-formats' to a pair of
 914 OpenDocument date-styles with names \"OrgDate1\" and \"OrgDate2\"
 915 respectively.  A timestamp with no time component is formatted
 916 with style \"OrgDate1\" while one with explicit hour and minutes
 917 is formatted with style \"OrgDate2\".
 918
 919 This feature is experimental.  Most (but not all) of the common
 920 %-specifiers in `format-time-string' are supported.
 921 Specifically, locale-dependent specifiers like \"%c\", \"%x\" are
 922 formatted as canonical Org timestamps.  For finer control, avoid
 923 these %-specifiers.
 924
 925 Textutal specifiers like \"%b\", \"%h\", \"%B\", \"%a\", \"%A\"
 926 etc., are displayed by the application in the default language
 927 and country specified in `org-odt-styles-file'.  Note that the
 928 default styles file uses language \"en\" and country \"GB\".  You
 929 can localize the week day and month strings in the exported
 930 document by setting the default language and country either using
 931 the application UI or through a custom styles file.
 932
 933 See `org-odt--build-date-styles' for implementation details."
 934   :group 'org-export-odt
 935   :version "24.4"
 936   :package-version '(Org . "8.0")
 937   :type 'boolean)
 938
 939
 940 \f
 941 ;;; Internal functions
 942
 943 ;;;; Date
 944
 945 (defun org-odt--format-timestamp (timestamp &optional end iso-date-p)
 946   (let* ((format-timestamp
 947           (lambda (timestamp format &optional end utc)
 948             (if timestamp
 949                 (org-timestamp-format timestamp format end utc)
 950               (format-time-string format nil utc))))
 951          (has-time-p (or (not timestamp)
 952                          (org-timestamp-has-time-p timestamp)))
 953          (iso-date (let ((format (if has-time-p "%Y-%m-%dT%H:%M:%S"
 954                                    "%Y-%m-%dT%H:%M:%S")))
 955                      (funcall format-timestamp timestamp format end))))
 956     (if iso-date-p iso-date
 957       (let* ((style (if has-time-p "OrgDate2" "OrgDate1"))
 958              ;; LibreOffice does not care about end goes as content
 959              ;; within the "<text:date>...</text:date>" field.  The
 960              ;; displayed date is automagically corrected to match the
 961              ;; format requested by "style:data-style-name" attribute.  So
 962              ;; don't bother about formatting the date contents to be
 963              ;; compatible with "OrgDate1" and "OrgDateTime" styles.  A
 964              ;; simple Org-style date should suffice.
 965              (date (let* ((formats
 966                            (if org-display-custom-times
 967                                (cons (substring
 968                                       (car org-time-stamp-custom-formats) 1 -1)
 969                                      (substring
 970                                       (cdr org-time-stamp-custom-formats) 1 -1))
 971                              '("%Y-%m-%d %a" . "%Y-%m-%d %a %H:%M")))
 972                           (format (if has-time-p (cdr formats) (car formats))))
 973                      (funcall format-timestamp timestamp format end)))
 974              (repeater (let ((repeater-type (org-element-property
 975                                              :repeater-type timestamp))
 976                              (repeater-value (org-element-property
 977                                               :repeater-value timestamp))
 978                              (repeater-unit (org-element-property
 979                                              :repeater-unit timestamp)))
 980                          (concat
 981                           (case repeater-type
 982                             (catchup "++") (restart ".+") (cumulate "+"))
 983                           (when repeater-value
 984                             (number-to-string repeater-value))
 985                           (case repeater-unit
 986                             (hour "h") (day "d") (week "w") (month "m")
 987                             (year "y"))))))
 988         (concat
 989          (format "<text:date text:date-value=\"%s\" style:data-style-name=\"%s\" text:fixed=\"true\">%s</text:date>"
 990                  iso-date style date)
 991          (and (not (string= repeater ""))  " ")
 992          repeater)))))
 993
 994 ;;;; Frame
 995
 996 (defun org-odt--frame (text width height style &optional extra
 997                               anchor-type &rest title-and-desc)
 998   (let ((frame-attrs
 999          (concat
1000           (if width (format " svg:width=\"%0.2fcm\"" width) "")
1001           (if height (format " svg:height=\"%0.2fcm\"" height) "")
1002           extra
1003           (format " text:anchor-type=\"%s\"" (or anchor-type "paragraph")))))
1004     (format
1005      "\n<draw:frame draw:style-name=\"%s\"%s>\n%s\n</draw:frame>"
1006      style frame-attrs
1007      (concat text
1008              (let ((title (car title-and-desc))
1009                    (desc (cadr title-and-desc)))
1010                (concat (when title
1011                          (format "<svg:title>%s</svg:title>"
1012                                  (org-odt--encode-plain-text title t)))
1013                        (when desc
1014                          (format "<svg:desc>%s</svg:desc>"
1015                                  (org-odt--encode-plain-text desc t)))))))))
1016
1017
1018 ;;;; Library wrappers
1019
1020 (defun org-odt--zip-extract (archive members target)
1021   (when (atom members) (setq members (list members)))
1022   (mapc (lambda (member)
1023           (require 'arc-mode)
1024           (let* ((--quote-file-name
1025                   ;; This is shamelessly stolen from `archive-zip-extract'.
1026                   (lambda (name)
1027                     (if (or (not (memq system-type '(windows-nt ms-dos)))
1028                             (and (boundp 'w32-quote-process-args)
1029                                  (null w32-quote-process-args)))
1030                         (shell-quote-argument name)
1031                       name)))
1032                  (target (funcall --quote-file-name target))
1033                  (archive (expand-file-name archive))
1034                  (archive-zip-extract
1035                   (list "unzip" "-qq" "-o" "-d" target))
1036                  exit-code command-output)
1037             (setq command-output
1038                   (with-temp-buffer
1039                     (setq exit-code (archive-zip-extract archive member))
1040                     (buffer-string)))
1041             (unless (zerop exit-code)
1042               (message command-output)
1043               (error "Extraction failed"))))
1044         members))
1045
1046 ;;;; Target
1047
1048 (defun org-odt--target (text id)
1049   (if (not id) text
1050     (concat
1051      (format "\n<text:bookmark-start text:name=\"OrgXref.%s\"/>" id)
1052      (format "\n<text:bookmark text:name=\"%s\"/>" id) text
1053      (format "\n<text:bookmark-end text:name=\"OrgXref.%s\"/>" id))))
1054
1055 ;;;; Textbox
1056
1057 (defun org-odt--textbox (text width height style &optional
1058                                 extra anchor-type)
1059   (org-odt--frame
1060    (format "\n<draw:text-box %s>%s\n</draw:text-box>"
1061            (concat (format " fo:min-height=\"%0.2fcm\"" (or height .2))
1062                    (and (not width)
1063                         (format " fo:min-width=\"%0.2fcm\"" (or width .2))))
1064            text)
1065    width nil style extra anchor-type))
1066
1067
1068
1069 ;;;; Table of Contents
1070
1071 (defun org-odt-begin-toc (index-title depth)
1072   (concat
1073    (format "
1074     <text:table-of-content text:style-name=\"OrgIndexSection\" text:protected=\"true\" text:name=\"Table of Contents\">
1075      <text:table-of-content-source text:outline-level=\"%d\">
1076       <text:index-title-template text:style-name=\"Contents_20_Heading\">%s</text:index-title-template>
1077 " depth index-title)
1078
1079    (let ((levels (number-sequence 1 10)))
1080      (mapconcat
1081       (lambda (level)
1082         (format
1083          "
1084       <text:table-of-content-entry-template text:outline-level=\"%d\" text:style-name=\"Contents_20_%d\">
1085        <text:index-entry-link-start text:style-name=\"Internet_20_link\"/>
1086        <text:index-entry-chapter/>
1087        <text:index-entry-text/>
1088        <text:index-entry-link-end/>
1089       </text:table-of-content-entry-template>
1090 " level level)) levels ""))
1091
1092    (format  "
1093      </text:table-of-content-source>
1094
1095      <text:index-body>
1096       <text:index-title text:style-name=\"Sect1\" text:name=\"Table of Contents1_Head\">
1097        <text:p text:style-name=\"Contents_20_Heading\">%s</text:p>
1098       </text:index-title>
1099  " index-title)))
1100
1101 (defun org-odt-end-toc ()
1102   (format "
1103      </text:index-body>
1104     </text:table-of-content>
1105 "))
1106
1107 (defun* org-odt-format-toc-headline
1108     (todo todo-type priority text tags
1109           &key level section-number headline-label &allow-other-keys)
1110   (setq text
1111         (concat
1112          ;; Section number.
1113          (when section-number (concat section-number ". "))
1114          ;; Todo.
1115          (when todo
1116            (let ((style (if (member todo org-done-keywords)
1117                             "OrgDone" "OrgTodo")))
1118              (format "<text:span text:style-name=\"%s\">%s</text:span> "
1119                      style todo)))
1120          (when priority
1121            (let* ((style (format "OrgPriority-%s" priority))
1122                   (priority (format "[#%c]" priority)))
1123              (format "<text:span text:style-name=\"%s\">%s</text:span> "
1124                      style priority)))
1125          ;; Title.
1126          text
1127          ;; Tags.
1128          (when tags
1129            (concat
1130             (format " <text:span text:style-name=\"%s\">[%s]</text:span>"
1131                     "OrgTags"
1132                     (mapconcat
1133                      (lambda (tag)
1134                        (format
1135                         "<text:span text:style-name=\"%s\">%s</text:span>"
1136                         "OrgTag" tag)) tags " : "))))))
1137   (format "<text:a xlink:type=\"simple\" xlink:href=\"#%s\">%s</text:a>"
1138           headline-label text))
1139
1140 (defun org-odt-toc (depth info)
1141   (assert (wholenump depth))
1142   ;; When a headline is marked as a radio target, as in the example below:
1143   ;;
1144   ;; ** <<<Some Heading>>>
1145   ;;    Some text.
1146   ;;
1147   ;; suppress generation of radio targets.  i.e., Radio targets are to
1148   ;; be marked as targets within /document body/ and *not* within
1149   ;; /TOC/, as otherwise there will be duplicated anchors one in TOC
1150   ;; and one in the document body.
1151   ;;
1152   ;; FIXME-1: Currently exported headings are memoized.  `org-export.el'
1153   ;; doesn't provide a way to disable memoization.  So this doesn't
1154   ;; work.
1155   ;;
1156   ;; FIXME-2: Are there any other objects that need to be suppressed
1157   ;; within TOC?
1158   (let* ((title (org-export-translate "Table of Contents" :utf-8 info))
1159          (headlines (org-export-collect-headlines
1160                      info (and (wholenump depth) depth)))
1161          (backend (org-export-create-backend
1162                    :parent (org-export-backend-name
1163                             (plist-get info :back-end))
1164                    :transcoders (mapcar
1165                                  (lambda (type) (cons type (lambda (d c i) c)))
1166                                  (list 'radio-target)))))
1167     (when headlines
1168       (concat
1169        (org-odt-begin-toc title depth)
1170        (mapconcat
1171         (lambda (headline)
1172           (let* ((entry (org-odt-format-headline--wrap
1173                          headline backend info 'org-odt-format-toc-headline))
1174                  (level (org-export-get-relative-level headline info))
1175                  (style (format "Contents_20_%d" level)))
1176             (format "\n<text:p text:style-name=\"%s\">%s</text:p>"
1177                     style entry)))
1178         headlines "\n")
1179        (org-odt-end-toc)))))
1180
1181
1182 ;;;; Document styles
1183
1184 (defun org-odt-add-automatic-style (object-type &optional object-props)
1185   "Create an automatic style of type OBJECT-TYPE with param OBJECT-PROPS.
1186 OBJECT-PROPS is (typically) a plist created by passing
1187 \"#+ATTR_ODT: \" option of the object in question to
1188 `org-odt-parse-block-attributes'.
1189
1190 Use `org-odt-object-counters' to generate an automatic
1191 OBJECT-NAME and STYLE-NAME.  If OBJECT-PROPS is non-nil, add a
1192 new entry in `org-odt-automatic-styles'.  Return (OBJECT-NAME
1193 . STYLE-NAME)."
1194   (assert (stringp object-type))
1195   (let* ((object (intern object-type))
1196          (seqvar object)
1197          (seqno (1+ (or (plist-get org-odt-object-counters seqvar) 0)))
1198          (object-name (format "%s%d" object-type seqno)) style-name)
1199     (setq org-odt-object-counters
1200           (plist-put org-odt-object-counters seqvar seqno))
1201     (when object-props
1202       (setq style-name (format "Org%s" object-name))
1203       (setq org-odt-automatic-styles
1204             (plist-put org-odt-automatic-styles object
1205                        (append (list (list style-name object-props))
1206                                (plist-get org-odt-automatic-styles object)))))
1207     (cons object-name style-name)))
1208
1209 ;;;; Checkbox
1210
1211 (defun org-odt--checkbox (item)
1212   "Return check-box string associated to ITEM."
1213   (let ((checkbox (org-element-property :checkbox item)))
1214     (if (not checkbox) ""
1215       (format "<text:span text:style-name=\"%s\">%s</text:span>"
1216               "OrgCode" (case checkbox
1217                           (on "[&#x2713;] ") ; CHECK MARK
1218                           (off "[ ] ")
1219                           (trans "[-] "))))))
1220
1221 ;;; Template
1222
1223 (defun org-odt--build-date-styles (fmt style)
1224   ;; In LibreOffice 3.4.6, there doesn't seem to be a convenient way
1225   ;; to modify the date fields.  A date could be modified by
1226   ;; offsetting in days.  That's about it.  Also, date and time may
1227   ;; have to be emitted as two fields - a date field and a time field
1228   ;; - separately.
1229
1230   ;; One can add Form Controls to date and time fields so that they
1231   ;; can be easily modified.  But then, the exported document will
1232   ;; become tightly coupled with LibreOffice and may not function
1233   ;; properly with other OpenDocument applications.
1234
1235   ;; I have a strange feeling that Date styles are a bit flaky at the
1236   ;; moment.
1237
1238   ;; The feature is experimental.
1239   (when (and fmt style)
1240     (let* ((fmt-alist
1241             '(("%A" . "<number:day-of-week number:style=\"long\"/>")
1242               ("%B" . "<number:month number:textual=\"true\" number:style=\"long\"/>")
1243               ("%H" . "<number:hours number:style=\"long\"/>")
1244               ("%M" . "<number:minutes number:style=\"long\"/>")
1245               ("%S" . "<number:seconds number:style=\"long\"/>")
1246               ("%V" . "<number:week-of-year/>")
1247               ("%Y" . "<number:year number:style=\"long\"/>")
1248               ("%a" . "<number:day-of-week number:style=\"short\"/>")
1249               ("%b" . "<number:month number:textual=\"true\" number:style=\"short\"/>")
1250               ("%d" . "<number:day number:style=\"long\"/>")
1251               ("%e" . "<number:day number:style=\"short\"/>")
1252               ("%h" . "<number:month number:textual=\"true\" number:style=\"short\"/>")
1253               ("%k" . "<number:hours number:style=\"short\"/>")
1254               ("%m" . "<number:month number:style=\"long\"/>")
1255               ("%p" . "<number:am-pm/>")
1256               ("%y" . "<number:year number:style=\"short\"/>")))
1257            (case-fold-search nil)
1258            (re (mapconcat 'identity (mapcar 'car fmt-alist) "\\|"))
1259            match rpl (start 0) (filler-beg 0) filler-end filler output)
1260       (mapc
1261        (lambda (pair)
1262          (setq fmt (replace-regexp-in-string (car pair) (cdr pair) fmt t t)))
1263        '(("\\(?:%[[:digit:]]*N\\)" . "") ; strip ns, us and ns
1264          ("%C" . "Y")                    ; replace century with year
1265          ("%D" . "%m/%d/%y")
1266          ("%G" . "Y")                 ; year corresponding to iso week
1267          ("%I" . "%H")                ; hour on a 12-hour clock
1268          ("%R" . "%H:%M")
1269          ("%T" . "%H:%M:%S")
1270          ("%U\\|%W" . "%V")           ; week no. starting on Sun./Mon.
1271          ("%Z" . "")                  ; time zone name
1272          ("%c" . "%Y-%M-%d %a %H:%M" ) ; locale's date and time format
1273          ("%g" . "%y")
1274          ("%X" . "%x" )  ; locale's pref. time format
1275          ("%j" . "")     ; day of the year
1276          ("%l" . "%k")   ; like %I blank-padded
1277          ("%s" . "")     ; no. of secs since 1970-01-01 00:00:00 +0000
1278          ("%n" . "<text:line-break/>")
1279          ("%r" . "%I:%M:%S %p")
1280          ("%t" . "<text:tab/>")
1281          ("%u\\|%w" . "")  ; numeric day of week - Mon (1-7), Sun(0-6)
1282          ("%x" . "%Y-%M-%d %a")         ; locale's pref. time format
1283          ("%z" . "")                    ; time zone in numeric form
1284          ))
1285       (while (string-match re fmt start)
1286         (setq match (match-string 0 fmt))
1287         (setq rpl (assoc-default match fmt-alist))
1288         (setq start (match-end 0))
1289         (setq filler-end (match-beginning 0))
1290         (setq filler (substring fmt (prog1 filler-beg
1291                                       (setq filler-beg (match-end 0)))
1292                                 filler-end))
1293         (setq filler (and (not (string= filler ""))
1294                           (format "<number:text>%s</number:text>"
1295                                   (org-odt--encode-plain-text filler))))
1296         (setq output (concat output "\n" filler "\n" rpl)))
1297       (setq filler (substring fmt filler-beg))
1298       (unless (string= filler "")
1299         (setq output (concat output
1300                              (format "\n<number:text>%s</number:text>"
1301                                      (org-odt--encode-plain-text filler)))))
1302       (format "\n<number:date-style style:name=\"%s\" %s>%s\n</number:date-style>"
1303               style
1304               (concat " number:automatic-order=\"true\""
1305                       " number:format-source=\"fixed\"")
1306               output ))))
1307
1308 (defun org-odt-template (contents info)
1309   "Return complete document string after ODT conversion.
1310 CONTENTS is the transcoded contents string.  RAW-DATA is the
1311 original parsed data.  INFO is a plist holding export options."
1312   ;; Write meta file.
1313   (let ((title (org-export-data (plist-get info :title) info))
1314         (author (let ((author (plist-get info :author)))
1315                   (if (not author) "" (org-export-data author info))))
1316         (email (plist-get info :email))
1317         (keywords (plist-get info :keywords))
1318         (description (plist-get info :description)))
1319     (write-region
1320      (concat
1321       "<?xml version=\"1.0\" encoding=\"UTF-8\"?>
1322      <office:document-meta
1323          xmlns:office=\"urn:oasis:names:tc:opendocument:xmlns:office:1.0\"
1324          xmlns:xlink=\"http://www.w3.org/1999/xlink\"
1325          xmlns:dc=\"http://purl.org/dc/elements/1.1/\"
1326          xmlns:meta=\"urn:oasis:names:tc:opendocument:xmlns:meta:1.0\"
1327          xmlns:ooo=\"http://openoffice.org/2004/office\"
1328          office:version=\"1.2\">
1329        <office:meta>\n"
1330       (format "<dc:creator>%s</dc:creator>\n" author)
1331       (format "<meta:initial-creator>%s</meta:initial-creator>\n" author)
1332       ;; Date, if required.
1333       (when (plist-get info :with-date)
1334         ;; Check if DATE is specified as an Org-timestamp.  If yes,
1335         ;; include it as meta information.  Otherwise, just use
1336         ;; today's date.
1337         (let* ((date (let ((date (plist-get info :date)))
1338                        (and (not (cdr date))
1339                             (eq (org-element-type (car date)) 'timestamp)
1340                             (car date)))))
1341           (let ((iso-date (org-odt--format-timestamp date nil 'iso-date)))
1342             (concat
1343              (format "<dc:date>%s</dc:date>\n" iso-date)
1344              (format "<meta:creation-date>%s</meta:creation-date>\n"
1345                      iso-date)))))
1346       (format "<meta:generator>%s</meta:generator>\n"
1347               (let ((creator-info (plist-get info :with-creator)))
1348                 (if (or (not creator-info) (eq creator-info 'comment)) ""
1349                   (plist-get info :creator))))
1350       (format "<meta:keyword>%s</meta:keyword>\n" keywords)
1351       (format "<dc:subject>%s</dc:subject>\n" description)
1352       (format "<dc:title>%s</dc:title>\n" title)
1353       "\n"
1354       "  </office:meta>\n" "</office:document-meta>")
1355      nil (concat org-odt-zip-dir "meta.xml"))
1356     ;; Add meta.xml in to manifest.
1357     (org-odt-create-manifest-file-entry "text/xml" "meta.xml"))
1358
1359   ;; Update styles file.
1360   ;; Copy styles.xml.  Also dump htmlfontify styles, if there is any.
1361   ;; Write styles file.
1362   (let* ((styles-file (plist-get info :odt-styles-file))
1363          (styles-file (and styles-file (read (org-trim styles-file))))
1364          ;; Non-availability of styles.xml is not a critical
1365          ;; error. For now, throw an error.
1366          (styles-file (or styles-file
1367                           org-odt-styles-file
1368                           (expand-file-name "OrgOdtStyles.xml"
1369                                             org-odt-styles-dir)
1370                           (error "org-odt: Missing styles file?"))))
1371     (cond
1372      ((listp styles-file)
1373       (let ((archive (nth 0 styles-file))
1374             (members (nth 1 styles-file)))
1375         (org-odt--zip-extract archive members org-odt-zip-dir)
1376         (mapc
1377          (lambda (member)
1378            (when (org-file-image-p member)
1379              (let* ((image-type (file-name-extension member))
1380                     (media-type (format "image/%s" image-type)))
1381                (org-odt-create-manifest-file-entry media-type member))))
1382          members)))
1383      ((and (stringp styles-file) (file-exists-p styles-file))
1384       (let ((styles-file-type (file-name-extension styles-file)))
1385         (cond
1386          ((string= styles-file-type "xml")
1387           (copy-file styles-file (concat org-odt-zip-dir "styles.xml") t))
1388          ((member styles-file-type '("odt" "ott"))
1389           (org-odt--zip-extract styles-file "styles.xml" org-odt-zip-dir)))))
1390      (t
1391       (error (format "Invalid specification of styles.xml file: %S"
1392                      org-odt-styles-file))))
1393
1394     ;; create a manifest entry for styles.xml
1395     (org-odt-create-manifest-file-entry "text/xml" "styles.xml")
1396
1397     ;; FIXME: Who is opening an empty styles.xml before this point?
1398     (with-current-buffer
1399         (find-file-noselect (concat org-odt-zip-dir "styles.xml") t)
1400       (revert-buffer t t)
1401
1402       ;; Write custom styles for source blocks
1403       ;; Save STYLES used for colorizing of source blocks.
1404       ;; Update styles.xml with styles that were collected as part of
1405       ;; `org-odt-hfy-face-to-css' callbacks.
1406       (let ((styles (mapconcat (lambda (style) (format " %s\n" (cddr style)))
1407                                hfy-user-sheet-assoc "")))
1408         (when styles
1409           (goto-char (point-min))
1410           (when (re-search-forward "</office:styles>" nil t)
1411             (goto-char (match-beginning 0))
1412             (insert "\n<!-- Org Htmlfontify Styles -->\n" styles "\n"))))
1413
1414       ;; Update styles.xml - take care of outline numbering
1415
1416       ;; Don't make automatic backup of styles.xml file. This setting
1417       ;; prevents the backed-up styles.xml file from being zipped in to
1418       ;; odt file. This is more of a hackish fix. Better alternative
1419       ;; would be to fix the zip command so that the output odt file
1420       ;; includes only the needed files and excludes any auto-generated
1421       ;; extra files like backups and auto-saves etc etc. Note that
1422       ;; currently the zip command zips up the entire temp directory so
1423       ;; that any auto-generated files created under the hood ends up in
1424       ;; the resulting odt file.
1425       (set (make-local-variable 'backup-inhibited) t)
1426
1427       ;; Outline numbering is retained only upto LEVEL.
1428       ;; To disable outline numbering pass a LEVEL of 0.
1429
1430       (goto-char (point-min))
1431       (let ((regex
1432              "<text:outline-level-style\\([^>]*\\)text:level=\"\\([^\"]*\\)\"\\([^>]*\\)>")
1433             (replacement
1434              "<text:outline-level-style\\1text:level=\"\\2\" style:num-format=\"\">"))
1435         (while (re-search-forward regex nil t)
1436           (unless (let ((sec-num (plist-get info :section-numbers))
1437                         (level (string-to-number (match-string 2))))
1438                     (if (wholenump sec-num) (<= level sec-num) sec-num))
1439             (replace-match replacement t nil))))
1440       (save-buffer 0)))
1441   ;; Update content.xml.
1442
1443   (let* ( ;; `org-display-custom-times' should be accessed right
1444          ;; within the context of the Org buffer.  So obtain it's
1445          ;; value before moving on to temp-buffer context down below.
1446          (custom-time-fmts
1447           (if org-display-custom-times
1448               (cons (substring (car org-time-stamp-custom-formats) 1 -1)
1449                     (substring (cdr org-time-stamp-custom-formats) 1 -1))
1450             '("%Y-%M-%d %a" . "%Y-%M-%d %a %H:%M"))))
1451     (with-temp-buffer
1452       (insert-file-contents
1453        (or org-odt-content-template-file
1454            (expand-file-name "OrgOdtContentTemplate.xml"
1455                              org-odt-styles-dir)))
1456       ;; Write automatic styles.
1457       ;; - Position the cursor.
1458       (goto-char (point-min))
1459       (re-search-forward "  </office:automatic-styles>" nil t)
1460       (goto-char (match-beginning 0))
1461       ;; - Dump automatic table styles.
1462       (loop for (style-name props) in
1463             (plist-get org-odt-automatic-styles 'Table) do
1464             (when (setq props (or (plist-get props :rel-width) "96"))
1465               (insert (format org-odt-table-style-format style-name props))))
1466       ;; - Dump date-styles.
1467       (when org-odt-use-date-fields
1468         (insert (org-odt--build-date-styles (car custom-time-fmts)
1469                                               "OrgDate1")
1470                 (org-odt--build-date-styles (cdr custom-time-fmts)
1471                                               "OrgDate2")))
1472       ;; Update display level.
1473       ;; - Remove existing sequence decls.  Also position the cursor.
1474       (goto-char (point-min))
1475       (when (re-search-forward "<text:sequence-decls" nil t)
1476         (delete-region (match-beginning 0)
1477                        (re-search-forward "</text:sequence-decls>" nil nil)))
1478       ;; Update sequence decls according to user preference.
1479       (insert
1480        (format
1481         "\n<text:sequence-decls>\n%s\n</text:sequence-decls>"
1482         (mapconcat
1483          (lambda (x)
1484            (format
1485             "<text:sequence-decl text:display-outline-level=\"%d\" text:name=\"%s\"/>"
1486             org-odt-display-outline-level (nth 1 x)))
1487          org-odt-category-map-alist "\n")))
1488       ;; Position the cursor to document body.
1489       (goto-char (point-min))
1490       (re-search-forward "</office:text>" nil nil)
1491       (goto-char (match-beginning 0))
1492
1493       ;; Preamble - Title, Author, Date etc.
1494       (insert
1495        (let* ((title (org-export-data (plist-get info :title) info))
1496               (author (and (plist-get info :with-author)
1497                            (let ((auth (plist-get info :author)))
1498                              (and auth (org-export-data auth info)))))
1499               (email (plist-get info :email))
1500               ;; Switch on or off above vars based on user settings
1501               (author (and (plist-get info :with-author) (or author email)))
1502               (email (and (plist-get info :with-email) email)))
1503          (concat
1504           ;; Title.
1505           (when title
1506             (concat
1507              (format "\n<text:p text:style-name=\"%s\">%s</text:p>"
1508                      "OrgTitle" (format "\n<text:title>%s</text:title>" title))
1509              ;; Separator.
1510              "\n<text:p text:style-name=\"OrgTitle\"/>"))
1511           (cond
1512            ((and author (not email))
1513             ;; Author only.
1514             (concat
1515              (format "\n<text:p text:style-name=\"%s\">%s</text:p>"
1516                      "OrgSubtitle"
1517                      (format "<text:initial-creator>%s</text:initial-creator>" author))
1518              ;; Separator.
1519              "\n<text:p text:style-name=\"OrgSubtitle\"/>"))
1520            ((and author email)
1521             ;; Author and E-mail.
1522             (concat
1523              (format
1524               "\n<text:p text:style-name=\"%s\">%s</text:p>"
1525               "OrgSubtitle"
1526               (format
1527                "<text:a xlink:type=\"simple\" xlink:href=\"%s\">%s</text:a>"
1528                (concat "mailto:" email)
1529                (format "<text:initial-creator>%s</text:initial-creator>" author)))
1530              ;; Separator.
1531              "\n<text:p text:style-name=\"OrgSubtitle\"/>")))
1532           ;; Date, if required.
1533           (when (plist-get info :with-date)
1534             (let* ((date (plist-get info :date))
1535                    ;; Check if DATE is specified as a timestamp.
1536                    (timestamp (and (not (cdr date))
1537                                    (eq (org-element-type (car date)) 'timestamp)
1538                                    (car date))))
1539               (concat
1540                (format "\n<text:p text:style-name=\"%s\">%s</text:p>"
1541                        "OrgSubtitle"
1542                        (if (and org-odt-use-date-fields timestamp)
1543                            (org-odt--format-timestamp (car date))
1544                          (org-export-data (plist-get info :date) info)))
1545                ;; Separator
1546                "<text:p text:style-name=\"OrgSubtitle\"/>"))))))
1547       ;; Table of Contents
1548       (let* ((with-toc (plist-get info :with-toc))
1549              (depth (and with-toc (if (wholenump with-toc)
1550                                       with-toc
1551                                     (plist-get info :headline-levels)))))
1552         (when depth (insert (or (org-odt-toc depth info) ""))))
1553       ;; Contents.
1554       (insert contents)
1555       ;; Return contents.
1556       (buffer-substring-no-properties (point-min) (point-max)))))
1557
1558
1559 \f
1560 ;;; Transcode Functions
1561
1562 ;;;; Bold
1563
1564 (defun org-odt-bold (bold contents info)
1565   "Transcode BOLD from Org to ODT.
1566 CONTENTS is the text with bold markup.  INFO is a plist holding
1567 contextual information."
1568   (format "<text:span text:style-name=\"%s\">%s</text:span>"
1569           "Bold" contents))
1570
1571
1572 ;;;; Center Block
1573
1574 (defun org-odt-center-block (center-block contents info)
1575   "Transcode a CENTER-BLOCK element from Org to ODT.
1576 CONTENTS holds the contents of the center block.  INFO is a plist
1577 holding contextual information."
1578   contents)
1579
1580
1581 ;;;; Clock
1582
1583 (defun org-odt-clock (clock contents info)
1584   "Transcode a CLOCK element from Org to ODT.
1585 CONTENTS is nil.  INFO is a plist used as a communication
1586 channel."
1587   (let ((timestamp (org-element-property :value clock))
1588         (duration (org-element-property :duration clock)))
1589     (format "\n<text:p text:style-name=\"%s\">%s</text:p>"
1590             (if (eq (org-element-type (org-export-get-next-element clock info))
1591                     'clock) "OrgClock" "OrgClockLastLine")
1592             (concat
1593              (format "<text:span text:style-name=\"%s\">%s</text:span>"
1594                      "OrgClockKeyword" org-clock-string)
1595              (org-odt-timestamp timestamp contents info)
1596              (and duration (format " (%s)" duration))))))
1597
1598
1599 ;;;; Code
1600
1601 (defun org-odt-code (code contents info)
1602   "Transcode a CODE object from Org to ODT.
1603 CONTENTS is nil.  INFO is a plist used as a communication
1604 channel."
1605   (format "<text:span text:style-name=\"%s\">%s</text:span>"
1606           "OrgCode" (org-odt--encode-plain-text
1607                      (org-element-property :value code))))
1608
1609
1610 ;;;; Comment
1611
1612 ;; Comments are ignored.
1613
1614
1615 ;;;; Comment Block
1616
1617 ;; Comment Blocks are ignored.
1618
1619
1620 ;;;; Drawer
1621
1622 (defun org-odt-drawer (drawer contents info)
1623   "Transcode a DRAWER element from Org to ODT.
1624 CONTENTS holds the contents of the block.  INFO is a plist
1625 holding contextual information."
1626   (let* ((name (org-element-property :drawer-name drawer))
1627          (output (funcall org-odt-format-drawer-function
1628                           name contents)))
1629     output))
1630
1631
1632 ;;;; Dynamic Block
1633
1634 (defun org-odt-dynamic-block (dynamic-block contents info)
1635   "Transcode a DYNAMIC-BLOCK element from Org to ODT.
1636 CONTENTS holds the contents of the block.  INFO is a plist
1637 holding contextual information.  See `org-export-data'."
1638   contents)
1639
1640
1641 ;;;; Entity
1642
1643 (defun org-odt-entity (entity contents info)
1644   "Transcode an ENTITY object from Org to ODT.
1645 CONTENTS are the definition itself.  INFO is a plist holding
1646 contextual information."
1647   (org-element-property :utf-8 entity))
1648
1649
1650 ;;;; Example Block
1651
1652 (defun org-odt-example-block (example-block contents info)
1653   "Transcode a EXAMPLE-BLOCK element from Org to ODT.
1654 CONTENTS is nil.  INFO is a plist holding contextual information."
1655   (org-odt-format-code example-block info))
1656
1657
1658 ;;;; Export Snippet
1659
1660 (defun org-odt-export-snippet (export-snippet contents info)
1661   "Transcode a EXPORT-SNIPPET object from Org to ODT.
1662 CONTENTS is nil.  INFO is a plist holding contextual information."
1663   (when (eq (org-export-snippet-backend export-snippet) 'odt)
1664     (org-element-property :value export-snippet)))
1665
1666
1667 ;;;; Export Block
1668
1669 (defun org-odt-export-block (export-block contents info)
1670   "Transcode a EXPORT-BLOCK element from Org to ODT.
1671 CONTENTS is nil.  INFO is a plist holding contextual information."
1672   (when (string= (org-element-property :type export-block) "ODT")
1673     (org-remove-indentation (org-element-property :value export-block))))
1674
1675
1676 ;;;; Fixed Width
1677
1678 (defun org-odt-fixed-width (fixed-width contents info)
1679   "Transcode a FIXED-WIDTH element from Org to ODT.
1680 CONTENTS is nil.  INFO is a plist holding contextual information."
1681   (org-odt-do-format-code (org-element-property :value fixed-width)))
1682
1683
1684 ;;;; Footnote Definition
1685
1686 ;; Footnote Definitions are ignored.
1687
1688
1689 ;;;; Footnote Reference
1690
1691 (defun org-odt-footnote-reference (footnote-reference contents info)
1692   "Transcode a FOOTNOTE-REFERENCE element from Org to ODT.
1693 CONTENTS is nil.  INFO is a plist holding contextual information."
1694   (let ((--format-footnote-definition
1695          (function
1696           (lambda (n def)
1697             (setq n (format "%d" n))
1698             (let ((id (concat  "fn" n))
1699                   (note-class "footnote")
1700                   (par-style "Footnote"))
1701               (format
1702                "<text:note text:id=\"%s\" text:note-class=\"%s\">%s</text:note>"
1703                id note-class
1704                (concat
1705                 (format "<text:note-citation>%s</text:note-citation>" n)
1706                 (format "<text:note-body>%s</text:note-body>" def)))))))
1707         (--format-footnote-reference
1708          (function
1709           (lambda (n)
1710             (setq n (format "%d" n))
1711             (let ((note-class "footnote")
1712                   (ref-format "text")
1713                   (ref-name (concat "fn" n)))
1714               (format
1715                "<text:span text:style-name=\"%s\">%s</text:span>"
1716                "OrgSuperscript"
1717                (format "<text:note-ref text:note-class=\"%s\" text:reference-format=\"%s\" text:ref-name=\"%s\">%s</text:note-ref>"
1718                        note-class ref-format ref-name n)))))))
1719     (concat
1720      ;; Insert separator between two footnotes in a row.
1721      (let ((prev (org-export-get-previous-element footnote-reference info)))
1722        (and (eq (org-element-type prev) 'footnote-reference)
1723             (format "<text:span text:style-name=\"%s\">%s</text:span>"
1724                     "OrgSuperscript" ",")))
1725      ;; Trancode footnote reference.
1726      (let ((n (org-export-get-footnote-number footnote-reference info)))
1727        (cond
1728         ((not (org-export-footnote-first-reference-p footnote-reference info))
1729          (funcall --format-footnote-reference n))
1730         ;; Inline definitions are secondary strings.
1731         ;; Non-inline footnotes definitions are full Org data.
1732         (t
1733          (let* ((raw (org-export-get-footnote-definition
1734                       footnote-reference info))
1735                 (def
1736                  (let ((def (org-trim
1737                              (org-export-data-with-backend
1738                               raw
1739                               (org-export-create-backend
1740                                :parent 'odt
1741                                :transcoders
1742                                '((paragraph . (lambda (p c i)
1743                                                 (org-odt--format-paragraph
1744                                                  p c "Footnote"
1745                                                  "OrgFootnoteCenter"
1746                                                  "OrgFootnoteQuotations")))))
1747                               info))))
1748                    (if (eq (org-element-type raw) 'org-data) def
1749                      (format "\n<text:p text:style-name=\"%s\">%s</text:p>"
1750                              "Footnote" def)))))
1751            (funcall --format-footnote-definition n def))))))))
1752
1753
1754 ;;;; Headline
1755
1756 (defun* org-odt-format-headline
1757     (todo todo-type priority text tags
1758           &key level section-number headline-label &allow-other-keys)
1759   (concat
1760    ;; Todo.
1761    (when todo
1762      (let ((style (if (member todo org-done-keywords) "OrgDone" "OrgTodo")))
1763        (format "<text:span text:style-name=\"%s\">%s</text:span> "
1764                style todo)))
1765    (when priority
1766      (let* ((style (format "OrgPriority-%s" priority))
1767             (priority (format "[#%c]" priority)))
1768        (format "<text:span text:style-name=\"%s\">%s</text:span> "
1769                style priority)))
1770    ;; Title.
1771    text
1772    ;; Tags.
1773    (when tags
1774      (concat
1775       "<text:tab/>"
1776       (format "<text:span text:style-name=\"%s\">[%s]</text:span>"
1777               "OrgTags" (mapconcat
1778                          (lambda (tag)
1779                            (format
1780                             "<text:span text:style-name=\"%s\">%s</text:span>"
1781                             "OrgTag" tag)) tags " : "))))))
1782
1783 (defun org-odt-format-headline--wrap (headline backend info
1784                                                &optional format-function
1785                                                &rest extra-keys)
1786   "Transcode a HEADLINE element using BACKEND.
1787 INFO is a plist holding contextual information."
1788   (setq backend (or backend (plist-get info :back-end)))
1789   (let* ((level (+ (org-export-get-relative-level headline info)))
1790          (headline-number (org-export-get-headline-number headline info))
1791          (section-number (and (org-export-numbered-headline-p headline info)
1792                               (mapconcat 'number-to-string
1793                                          headline-number ".")))
1794          (todo (and (plist-get info :with-todo-keywords)
1795                     (let ((todo (org-element-property :todo-keyword headline)))
1796                       (and todo
1797                            (org-export-data-with-backend todo backend info)))))
1798          (todo-type (and todo (org-element-property :todo-type headline)))
1799          (priority (and (plist-get info :with-priority)
1800                         (org-element-property :priority headline)))
1801          (text (org-export-data-with-backend
1802                 (org-element-property :title headline) backend info))
1803          (tags (and (plist-get info :with-tags)
1804                     (org-export-get-tags headline info)))
1805          (headline-label (concat "sec-" (mapconcat 'number-to-string
1806                                                    headline-number "-")))
1807          (format-function (cond
1808                            ((functionp format-function) format-function)
1809                            ((not (eq org-odt-format-headline-function 'ignore))
1810                             (function*
1811                              (lambda (todo todo-type priority text tags
1812                                            &allow-other-keys)
1813                                (funcall org-odt-format-headline-function
1814                                         todo todo-type priority text tags))))
1815                            (t 'org-odt-format-headline))))
1816     (apply format-function
1817            todo todo-type  priority text tags
1818            :headline-label headline-label :level level
1819            :section-number section-number extra-keys)))
1820
1821 (defun org-odt-headline (headline contents info)
1822   "Transcode a HEADLINE element from Org to ODT.
1823 CONTENTS holds the contents of the headline.  INFO is a plist
1824 holding contextual information."
1825   ;; Case 1: This is a footnote section: ignore it.
1826   (unless (org-element-property :footnote-section-p headline)
1827     (let* ((text (org-export-data (org-element-property :title headline) info))
1828            ;; Create the headline text.
1829            (full-text (org-odt-format-headline--wrap headline nil info))
1830            ;; Get level relative to current parsed data.
1831            (level (org-export-get-relative-level headline info))
1832            ;; Get canonical label for the headline.
1833            (id (concat "sec-" (mapconcat 'number-to-string
1834                                          (org-export-get-headline-number
1835                                           headline info) "-")))
1836            ;; Get user-specified labels for the headline.
1837            (extra-ids (list (org-element-property :CUSTOM_ID headline)
1838                             (org-element-property :ID headline)))
1839            ;; Extra targets.
1840            (extra-targets
1841             (mapconcat (lambda (x)
1842                          (when x
1843                            (let ((x (if (org-uuidgen-p x) (concat "ID-" x) x)))
1844                              (org-odt--target
1845                               "" (org-export-solidify-link-text x)))))
1846                        extra-ids ""))
1847            ;; Title.
1848            (anchored-title (org-odt--target full-text id)))
1849       (cond
1850        ;; Case 2. This is a deep sub-tree: export it as a list item.
1851        ;;         Also export as items headlines for which no section
1852        ;;         format has been found.
1853        ((org-export-low-level-p headline info)
1854         ;; Build the real contents of the sub-tree.
1855         (concat
1856          (and (org-export-first-sibling-p headline info)
1857               (format "\n<text:list text:style-name=\"%s\" %s>"
1858                       ;; Choose style based on list type.
1859                       (if (org-export-numbered-headline-p headline info)
1860                           "OrgNumberedList" "OrgBulletedList")
1861                       ;; If top-level list, re-start numbering.  Otherwise,
1862                       ;; continue numbering.
1863                       (format "text:continue-numbering=\"%s\""
1864                               (let* ((parent (org-export-get-parent-headline
1865                                               headline)))
1866                                 (if (and parent
1867                                          (org-export-low-level-p parent info))
1868                                     "true" "false")))))
1869          (let ((headline-has-table-p
1870                 (let ((section (assq 'section (org-element-contents headline))))
1871                   (assq 'table (and section (org-element-contents section))))))
1872            (format "\n<text:list-item>\n%s\n%s"
1873                    (concat
1874                     (format "\n<text:p text:style-name=\"%s\">%s</text:p>"
1875                             "Text_20_body"
1876                             (concat extra-targets anchored-title))
1877                     contents)
1878                    (if headline-has-table-p
1879                        "</text:list-header>"
1880                      "</text:list-item>")))
1881          (and (org-export-last-sibling-p headline info)
1882               "</text:list>")))
1883        ;; Case 3. Standard headline.  Export it as a section.
1884        (t
1885         (concat
1886          (format
1887           "\n<text:h text:style-name=\"%s\" text:outline-level=\"%s\">%s</text:h>"
1888           (format "Heading_20_%s" level)
1889           level
1890           (concat extra-targets anchored-title))
1891          contents))))))
1892
1893
1894 ;;;; Horizontal Rule
1895
1896 (defun org-odt-horizontal-rule (horizontal-rule contents info)
1897   "Transcode an HORIZONTAL-RULE  object from Org to ODT.
1898 CONTENTS is nil.  INFO is a plist holding contextual information."
1899   (format "\n<text:p text:style-name=\"%s\">%s</text:p>"
1900           "Horizontal_20_Line" ""))
1901
1902
1903 ;;;; Inline Babel Call
1904
1905 ;; Inline Babel Calls are ignored.
1906
1907
1908 ;;;; Inline Src Block
1909
1910 (defun org-odt--find-verb-separator (s)
1911   "Return a character not used in string S.
1912 This is used to choose a separator for constructs like \\verb."
1913   (let ((ll "~,./?;':\"|!@#%^&-_=+abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ<>()[]{}"))
1914     (loop for c across ll
1915           when (not (string-match (regexp-quote (char-to-string c)) s))
1916           return (char-to-string c))))
1917
1918 (defun org-odt-inline-src-block (inline-src-block contents info)
1919   "Transcode an INLINE-SRC-BLOCK element from Org to ODT.
1920 CONTENTS holds the contents of the item.  INFO is a plist holding
1921 contextual information."
1922   (let* ((org-lang (org-element-property :language inline-src-block))
1923          (code (org-element-property :value inline-src-block))
1924          (separator (org-odt--find-verb-separator code)))
1925     (error "FIXME")))
1926
1927
1928 ;;;; Inlinetask
1929
1930 (defun org-odt-inlinetask (inlinetask contents info)
1931   "Transcode an INLINETASK element from Org to ODT.
1932 CONTENTS holds the contents of the block.  INFO is a plist
1933 holding contextual information."
1934   (cond
1935    ;; If `org-odt-format-inlinetask-function' is not 'ignore, call it
1936    ;; with appropriate arguments.
1937    ((not (eq org-odt-format-inlinetask-function 'ignore))
1938     (let ((format-function
1939            (function*
1940             (lambda (todo todo-type priority text tags
1941                      &key contents &allow-other-keys)
1942               (funcall org-odt-format-inlinetask-function
1943                        todo todo-type priority text tags contents)))))
1944       (org-odt-format-headline--wrap
1945        inlinetask nil info format-function :contents contents)))
1946    ;; Otherwise, use a default template.
1947    (t
1948     (format "\n<text:p text:style-name=\"%s\">%s</text:p>"
1949             "Text_20_body"
1950             (org-odt--textbox
1951              (concat
1952               (format "\n<text:p text:style-name=\"%s\">%s</text:p>"
1953                       "OrgInlineTaskHeading"
1954                       (org-odt-format-headline--wrap inlinetask nil info))
1955               contents)
1956              nil nil "OrgInlineTaskFrame" " style:rel-width=\"100%\"")))))
1957
1958 ;;;; Italic
1959
1960 (defun org-odt-italic (italic contents info)
1961   "Transcode ITALIC from Org to ODT.
1962 CONTENTS is the text with italic markup.  INFO is a plist holding
1963 contextual information."
1964   (format "<text:span text:style-name=\"%s\">%s</text:span>"
1965           "Emphasis" contents))
1966
1967
1968 ;;;; Item
1969
1970 (defun org-odt-item (item contents info)
1971   "Transcode an ITEM element from Org to ODT.
1972 CONTENTS holds the contents of the item.  INFO is a plist holding
1973 contextual information."
1974   (let* ((plain-list (org-export-get-parent item))
1975          (type (org-element-property :type plain-list))
1976          (counter (org-element-property :counter item))
1977          (tag (let ((tag (org-element-property :tag item)))
1978                 (and tag
1979                      (concat (org-odt--checkbox item)
1980                              (org-export-data tag info))))))
1981     (case type
1982       ((ordered unordered descriptive-1 descriptive-2)
1983        (format "\n<text:list-item>\n%s\n%s"
1984                contents
1985                (let* ((--element-has-a-table-p
1986                        (function
1987                         (lambda (element info)
1988                           (loop for el in (org-element-contents element)
1989                                 thereis (eq (org-element-type el) 'table))))))
1990                  (cond
1991                   ((funcall --element-has-a-table-p item info)
1992                    "</text:list-header>")
1993                   (t "</text:list-item>")))))
1994       (t (error "Unknown list type: %S" type)))))
1995
1996 ;;;; Keyword
1997
1998 (defun org-odt-keyword (keyword contents info)
1999   "Transcode a KEYWORD element from Org to ODT.
2000 CONTENTS is nil.  INFO is a plist holding contextual information."
2001   (let ((key (org-element-property :key keyword))
2002         (value (org-element-property :value keyword)))
2003     (cond
2004      ((string= key "ODT") value)
2005      ((string= key "INDEX")
2006       ;; FIXME
2007       (ignore))
2008      ((string= key "TOC")
2009       (let ((value (downcase value)))
2010         (cond
2011          ((string-match "\\<headlines\\>" value)
2012           (let ((depth (or (and (string-match "[0-9]+" value)
2013                                 (string-to-number (match-string 0 value)))
2014                            (plist-get info :with-toc))))
2015             (when (wholenump depth) (org-odt-toc depth info))))
2016          ((member value '("tables" "figures" "listings"))
2017           ;; FIXME
2018           (ignore))))))))
2019
2020
2021 ;;;; Latex Environment
2022
2023
2024 ;; (eval-after-load 'ox-odt '(ad-deactivate 'org-format-latex-as-mathml))
2025 ;; (defadvice org-format-latex-as-mathml        ; FIXME
2026 ;;   (after org-odt-protect-latex-fragment activate)
2027 ;;   "Encode LaTeX fragment as XML.
2028 ;; Do this when translation to MathML fails."
2029 ;;   (unless (> (length ad-return-value) 0)
2030 ;;     (setq ad-return-value (org-odt--encode-plain-text (ad-get-arg 0)))))
2031
2032 (defun org-odt-latex-environment (latex-environment contents info)
2033   "Transcode a LATEX-ENVIRONMENT element from Org to ODT.
2034 CONTENTS is nil.  INFO is a plist holding contextual information."
2035   (let* ((latex-frag (org-remove-indentation
2036                       (org-element-property :value latex-environment))))
2037     (org-odt-do-format-code latex-frag)))
2038
2039
2040 ;;;; Latex Fragment
2041
2042 ;; (when latex-frag                     ; FIXME
2043 ;;      (setq href (org-propertize href :title "LaTeX Fragment"
2044 ;;                                 :description latex-frag)))
2045 ;; handle verbatim
2046 ;; provide descriptions
2047
2048 (defun org-odt-latex-fragment (latex-fragment contents info)
2049   "Transcode a LATEX-FRAGMENT object from Org to ODT.
2050 CONTENTS is nil.  INFO is a plist holding contextual information."
2051   (let* ((latex-frag (org-element-property :value latex-fragment))
2052          (processing-type (plist-get info :with-latex)))
2053     (format "<text:span text:style-name=\"%s\">%s</text:span>"
2054             "OrgCode" (org-odt--encode-plain-text latex-frag t))))
2055
2056
2057 ;;;; Line Break
2058
2059 (defun org-odt-line-break (line-break contents info)
2060   "Transcode a LINE-BREAK object from Org to ODT.
2061 CONTENTS is nil.  INFO is a plist holding contextual information."
2062   "<text:line-break/>")
2063
2064
2065 ;;;; Link
2066
2067 ;;;; Links :: Label references
2068
2069 (defun org-odt--enumerate (element info &optional predicate n)
2070   (when predicate (assert (funcall predicate element info)))
2071   (let* ((--numbered-parent-headline-at-<=-n
2072           (function
2073            (lambda (element n info)
2074              (loop for x in (org-export-get-genealogy element)
2075                    thereis (and (eq (org-element-type x) 'headline)
2076                                 (<= (org-export-get-relative-level x info) n)
2077                                 (org-export-numbered-headline-p x info)
2078                                 x)))))
2079          (--enumerate
2080           (function
2081            (lambda (element scope info &optional predicate)
2082              (let ((counter 0))
2083                (org-element-map (or scope (plist-get info :parse-tree))
2084                    (org-element-type element)
2085                  (lambda (el)
2086                    (and (or (not predicate) (funcall predicate el info))
2087                         (incf counter)
2088                         (eq element el)
2089                         counter))
2090                  info 'first-match)))))
2091          (scope (funcall --numbered-parent-headline-at-<=-n
2092                          element (or n org-odt-display-outline-level) info))
2093          (ordinal (funcall --enumerate element scope info predicate))
2094          (tag
2095           (concat
2096            ;; Section number.
2097            (and scope
2098                 (mapconcat 'number-to-string
2099                            (org-export-get-headline-number scope info) "."))
2100            ;; Separator.
2101            (and scope ".")
2102            ;; Ordinal.
2103            (number-to-string ordinal))))
2104     tag))
2105
2106 (defun org-odt-format-label (element info op)
2107   "Return a label for ELEMENT.
2108
2109 ELEMENT is a `link', `table', `src-block' or `paragraph' type
2110 element.  INFO is a plist used as a communication channel.  OP is
2111 either `definition' or `reference', depending on the purpose of
2112 the generated string.
2113
2114 Return value is a string if OP is set to `reference' or a cons
2115 cell like CAPTION . SHORT-CAPTION) where CAPTION and
2116 SHORT-CAPTION are strings."
2117   (assert (memq (org-element-type element) '(link table src-block paragraph)))
2118   (let* ((caption-from
2119           (case (org-element-type element)
2120             (link (org-export-get-parent-element element))
2121             (t element)))
2122          ;; Get label and caption.
2123          (label (org-element-property :name caption-from))
2124          (caption (org-export-get-caption caption-from))
2125          (short-caption (org-export-get-caption caption-from t))
2126          ;; Transcode captions.
2127          (caption (and caption (org-export-data caption info)))
2128          ;; Currently short caption are sneaked in as object names.
2129          ;;
2130          ;; The advantages are:
2131          ;;
2132          ;; - Table Of Contents: Currently, there is no support for
2133          ;;   building TOC for figures, listings and tables.  See
2134          ;;   `org-odt-keyword'.  User instead has to rely on
2135          ;;   external application for building such indices.  Within
2136          ;;   LibreOffice, building an "Illustration Index" or "Index
2137          ;;   of Tables" will create a table with long captions (only)
2138          ;;   and building a table with "Object names" will create a
2139          ;;   table with short captions.
2140          ;;
2141          ;; - Easy navigation: In LibreOffice, object names are
2142          ;;   offered via the navigation bar.  This way one can
2143          ;;   quickly locate and jump to object of his choice in the
2144          ;;   exported document.
2145          ;;
2146          ;; The main disadvantage is that there cannot be any markups
2147          ;; within object names i.e., one cannot embolden, italicize
2148          ;; or underline text within short caption.  So suppress
2149          ;; generation of <text:span >...</text:span> and other
2150          ;; markups by overriding the default translators.  We
2151          ;; probably shouldn't be suppressing translators for all
2152          ;; elements in `org-element-all-objects', but for now this
2153          ;; will do.
2154          (short-caption
2155           (let ((short-caption (or short-caption caption))
2156                 (backend (org-export-create-backend
2157                           :parent (org-export-backend-name
2158                                    (plist-get info :back-end))
2159                           :transcoders
2160                           (mapcar (lambda (type) (cons type (lambda (o c i) c)))
2161                                   org-element-all-objects))))
2162             (when short-caption
2163               (org-export-data-with-backend short-caption backend info)))))
2164     (when (or label caption)
2165       (let* ((default-category
2166                (case (org-element-type element)
2167                  (table "__Table__")
2168                  (src-block "__Listing__")
2169                  ((link paragraph)
2170                   (cond
2171                    ((org-odt--enumerable-latex-image-p element info)
2172                     "__DvipngImage__")
2173                    ((org-odt--enumerable-image-p element info)
2174                     "__Figure__")
2175                    ((org-odt--enumerable-formula-p element info)
2176                     "__MathFormula__")
2177                    (t (error "Don't know how to format label for link: %S"
2178                              element))))
2179                  (t (error "Don't know how to format label for element type: %s"
2180                            (org-element-type element)))))
2181              seqno)
2182         (assert default-category)
2183         (destructuring-bind (counter label-style category predicate)
2184             (assoc-default default-category org-odt-category-map-alist)
2185           ;; Compute sequence number of the element.
2186           (setq seqno (org-odt--enumerate element info predicate))
2187           ;; Localize category string.
2188           (setq category (org-export-translate category :utf-8 info))
2189           (case op
2190             ;; Case 1: Handle Label definition.
2191             (definition
2192               ;; Assign an internal label, if user has not provided one
2193               (setq label (org-export-solidify-link-text
2194                            (or label (format  "%s-%s" default-category seqno))))
2195               (cons
2196                (concat
2197                 ;; Sneak in a bookmark.  The bookmark is used when the
2198                 ;; labeled element is referenced with a link that
2199                 ;; provides it's own description.
2200                 (format "\n<text:bookmark text:name=\"%s\"/>" label)
2201                 ;; Label definition: Typically formatted as below:
2202                 ;;     CATEGORY SEQ-NO: LONG CAPTION
2203                 ;; with translation for correct punctuation.
2204                 (format-spec
2205                  (org-export-translate
2206                   (cadr (assoc-string label-style org-odt-label-styles t))
2207                   :utf-8 info)
2208                  `((?e . ,category)
2209                    (?n . ,(format
2210                            "<text:sequence text:ref-name=\"%s\" text:name=\"%s\" text:formula=\"ooow:%s+1\" style:num-format=\"1\">%s</text:sequence>"
2211                            label counter counter seqno))
2212                    (?c . ,(or caption "")))))
2213                short-caption))
2214             ;; Case 2: Handle Label reference.
2215             (reference
2216              (assert label)
2217              (setq label (org-export-solidify-link-text label))
2218              (let* ((fmt (cddr (assoc-string label-style org-odt-label-styles t)))
2219                     (fmt1 (car fmt))
2220                     (fmt2 (cadr fmt)))
2221                (format "<text:sequence-ref text:reference-format=\"%s\" text:ref-name=\"%s\">%s</text:sequence-ref>"
2222                        fmt1 label (format-spec fmt2 `((?e . ,category)
2223                                                       (?n . ,seqno))))))
2224             (t (error "Unknown %S on label" op))))))))
2225
2226
2227 ;;;; Links :: Inline Images
2228
2229 (defun org-odt--copy-image-file (path)
2230   "Returns the internal name of the file"
2231   (let* ((image-type (file-name-extension path))
2232          (media-type (format "image/%s" image-type))
2233          (target-dir "Images/")
2234          (target-file
2235           (format "%s%04d.%s" target-dir
2236                   (incf org-odt-embedded-images-count) image-type)))
2237     (message "Embedding %s as %s..."
2238              (substring-no-properties path) target-file)
2239
2240     (when (= 1 org-odt-embedded-images-count)
2241       (make-directory (concat org-odt-zip-dir target-dir))
2242       (org-odt-create-manifest-file-entry "" target-dir))
2243
2244     (copy-file path (concat org-odt-zip-dir target-file) 'overwrite)
2245     (org-odt-create-manifest-file-entry media-type target-file)
2246     target-file))
2247
2248 (defun org-odt--image-size (file &optional user-width
2249                                    user-height scale dpi embed-as)
2250   (let* ((--pixels-to-cms
2251           (function (lambda (pixels dpi)
2252                       (let ((cms-per-inch 2.54)
2253                             (inches (/ pixels dpi)))
2254                         (* cms-per-inch inches)))))
2255          (--size-in-cms
2256           (function
2257            (lambda (size-in-pixels dpi)
2258              (and size-in-pixels
2259                   (cons (funcall --pixels-to-cms (car size-in-pixels) dpi)
2260                         (funcall --pixels-to-cms (cdr size-in-pixels) dpi))))))
2261          (dpi (or dpi org-odt-pixels-per-inch))
2262          (anchor-type (or embed-as "paragraph"))
2263          (user-width (and (not scale) user-width))
2264          (user-height (and (not scale) user-height))
2265          (size
2266           (and
2267            (not (and user-height user-width))
2268            (or
2269             ;; Use Imagemagick.
2270             (and (executable-find "identify")
2271                  (let ((size-in-pixels
2272                         (let ((dim (shell-command-to-string
2273                                     (format "identify -format \"%%w:%%h\" \"%s\""
2274                                             file))))
2275                           (when (string-match "\\([0-9]+\\):\\([0-9]+\\)" dim)
2276                             (cons (string-to-number (match-string 1 dim))
2277                                   (string-to-number (match-string 2 dim)))))))
2278                    (funcall --size-in-cms size-in-pixels dpi)))
2279             ;; Use Emacs.
2280             (let ((size-in-pixels
2281                    (ignore-errors       ; Emacs could be in batch mode
2282                      (clear-image-cache)
2283                      (image-size (create-image file) 'pixels))))
2284               (funcall --size-in-cms size-in-pixels dpi))
2285             ;; Use hard-coded values.
2286             (cdr (assoc-string anchor-type
2287                                org-odt-default-image-sizes-alist))
2288             ;; Error out.
2289             (error "Cannot determine image size, aborting"))))
2290          (width (car size)) (height (cdr size)))
2291     (cond
2292      (scale
2293       (setq width (* width scale) height (* height scale)))
2294      ((and user-height user-width)
2295       (setq width user-width height user-height))
2296      (user-height
2297       (setq width (* user-height (/ width height)) height user-height))
2298      (user-width
2299       (setq height (* user-width (/ height width)) width user-width))
2300      (t (ignore)))
2301     ;; ensure that an embedded image fits comfortably within a page
2302     (let ((max-width (car org-odt-max-image-size))
2303           (max-height (cdr org-odt-max-image-size)))
2304       (when (or (> width max-width) (> height max-height))
2305         (let* ((scale1 (/ max-width width))
2306                (scale2 (/ max-height height))
2307                (scale (min scale1 scale2)))
2308           (setq width (* scale width) height (* scale height)))))
2309     (cons width height)))
2310
2311 (defun org-odt-link--inline-image (element info)
2312   "Return ODT code for an inline image.
2313 LINK is the link pointing to the inline image.  INFO is a plist
2314 used as a communication channel."
2315   (assert (eq (org-element-type element) 'link))
2316   (let* ((src (let* ((type (org-element-property :type element))
2317                      (raw-path (org-element-property :path element)))
2318                 (cond ((member type '("http" "https"))
2319                        (concat type ":" raw-path))
2320                       ((file-name-absolute-p raw-path)
2321                        (expand-file-name raw-path))
2322                       (t raw-path))))
2323          (src-expanded (if (file-name-absolute-p src) src
2324                          (expand-file-name src (file-name-directory
2325                                                 (plist-get info :input-file)))))
2326          (href (format
2327                 "\n<draw:image xlink:href=\"%s\" xlink:type=\"simple\" xlink:show=\"embed\" xlink:actuate=\"onLoad\"/>"
2328                 (org-odt--copy-image-file src-expanded)))
2329          ;; Extract attributes from #+ATTR_ODT line.
2330          (attr-from (case (org-element-type element)
2331                       (link (org-export-get-parent-element element))
2332                       (t element)))
2333          ;; Convert attributes to a plist.
2334          (attr-plist (org-export-read-attribute :attr_odt attr-from))
2335          ;; Handle `:anchor', `:style' and `:attributes' properties.
2336          (user-frame-anchor
2337           (car (assoc-string (plist-get attr-plist :anchor)
2338                              '(("as-char") ("paragraph") ("page")) t)))
2339          (user-frame-style
2340           (and user-frame-anchor (plist-get attr-plist :style)))
2341          (user-frame-attrs
2342           (and user-frame-anchor (plist-get attr-plist :attributes)))
2343          (user-frame-params
2344           (list user-frame-style user-frame-attrs user-frame-anchor))
2345          ;; (embed-as (or embed-as user-frame-anchor "paragraph"))
2346          ;; extrac
2347          ;;
2348          ;; Handle `:width', `:height' and `:scale' properties.  Read
2349          ;; them as numbers since we need them for computations.
2350          (size (org-odt--image-size
2351                 src-expanded
2352                 (let ((width (plist-get attr-plist :width)))
2353                   (and width (read width)))
2354                 (let ((length (plist-get attr-plist :length)))
2355                   (and length (read length)))
2356                 (let ((scale (plist-get attr-plist :scale)))
2357                   (and scale (read scale)))
2358                 nil                     ; embed-as
2359                 "paragraph"             ; FIXME
2360                 ))
2361          (width (car size)) (height (cdr size))
2362          (standalone-link-p (org-odt--standalone-link-p element info))
2363          (embed-as (if standalone-link-p "paragraph" "as-char"))
2364          (captions (org-odt-format-label element info 'definition))
2365          (caption (car captions)) (short-caption (cdr captions))
2366          (entity (concat (and caption "Captioned") embed-as "Image"))
2367          ;; Check if this link was created by LaTeX-to-PNG converter.
2368          (replaces (org-element-property
2369                     :replaces (if (not standalone-link-p) element
2370                                 (org-export-get-parent-element element))))
2371          ;; If yes, note down the type of the element - LaTeX Fragment
2372          ;; or LaTeX environment.  It will go in to frame title.
2373          (title (and replaces (capitalize
2374                                (symbol-name (org-element-type replaces)))))
2375
2376          ;; If yes, note down it's contents.  It will go in to frame
2377          ;; description.  This quite useful for debugging.
2378          (desc (and replaces (org-element-property :value replaces))))
2379     (org-odt--render-image/formula entity href width height
2380                                      captions user-frame-params title desc)))
2381
2382
2383 ;;;; Links :: Math formula
2384
2385 (defun org-odt-link--inline-formula (element info)
2386   (let* ((src (let* ((type (org-element-property :type element))
2387                      (raw-path (org-element-property :path element)))
2388                 (cond
2389                  ((file-name-absolute-p raw-path)
2390                   (expand-file-name raw-path))
2391                  (t raw-path))))
2392          (src-expanded (if (file-name-absolute-p src) src
2393                          (expand-file-name src (file-name-directory
2394                                                 (plist-get info :input-file)))))
2395          (href
2396           (format
2397            "\n<draw:object %s xlink:href=\"%s\" xlink:type=\"simple\"/>"
2398            " xlink:show=\"embed\" xlink:actuate=\"onLoad\""
2399            (file-name-directory (org-odt--copy-formula-file src-expanded))))
2400          (standalone-link-p (org-odt--standalone-link-p element info))
2401          (embed-as (if standalone-link-p 'paragraph 'character))
2402          (captions (org-odt-format-label element info 'definition))
2403          (caption (car captions)) (short-caption (cdr captions))
2404          ;; Check if this link was created by LaTeX-to-MathML
2405          ;; converter.
2406          (replaces (org-element-property
2407                     :replaces (if (not standalone-link-p) element
2408                                 (org-export-get-parent-element element))))
2409          ;; If yes, note down the type of the element - LaTeX Fragment
2410          ;; or LaTeX environment.  It will go in to frame title.
2411          (title (and replaces (capitalize
2412                                (symbol-name (org-element-type replaces)))))
2413
2414          ;; If yes, note down it's contents.  It will go in to frame
2415          ;; description.  This quite useful for debugging.
2416          (desc (and replaces (org-element-property :value replaces)))
2417          width height)
2418     (cond
2419      ((eq embed-as 'character)
2420       (org-odt--render-image/formula "InlineFormula" href width height
2421                                        nil nil title desc))
2422      (t
2423       (let* ((equation (org-odt--render-image/formula
2424                         "CaptionedDisplayFormula" href width height
2425                         captions nil title desc))
2426              (label
2427               (let* ((org-odt-category-map-alist
2428                       '(("__MathFormula__" "Text" "math-label" "Equation"
2429                          org-odt--enumerable-formula-p))))
2430                 (car (org-odt-format-label element info 'definition)))))
2431         (concat equation "<text:tab/>" label))))))
2432
2433 (defun org-odt--copy-formula-file (src-file)
2434   "Returns the internal name of the file"
2435   (let* ((target-dir (format "Formula-%04d/"
2436                              (incf org-odt-embedded-formulas-count)))
2437          (target-file (concat target-dir "content.xml")))
2438     ;; Create a directory for holding formula file.  Also enter it in
2439     ;; to manifest.
2440     (make-directory (concat org-odt-zip-dir target-dir))
2441     (org-odt-create-manifest-file-entry
2442      "application/vnd.oasis.opendocument.formula" target-dir "1.2")
2443     ;; Copy over the formula file from user directory to zip
2444     ;; directory.
2445     (message "Embedding %s as %s..." src-file target-file)
2446     (let ((case-fold-search nil))
2447       (cond
2448        ;; Case 1: Mathml.
2449        ((string-match "\\.\\(mathml\\|mml\\)\\'" src-file)
2450         (copy-file src-file (concat org-odt-zip-dir target-file) 'overwrite))
2451        ;; Case 2: OpenDocument formula.
2452        ((string-match "\\.odf\\'" src-file)
2453         (org-odt--zip-extract src-file "content.xml"
2454                                 (concat org-odt-zip-dir target-dir)))
2455        (t (error "%s is not a formula file" src-file))))
2456     ;; Enter the formula file in to manifest.
2457     (org-odt-create-manifest-file-entry "text/xml" target-file)
2458     target-file))
2459
2460 ;;;; Targets
2461
2462 (defun org-odt--render-image/formula (cfg-key href width height &optional
2463                                                 captions user-frame-params
2464                                                 &rest title-and-desc)
2465   (let* ((frame-cfg-alist
2466           ;; Each element of this alist is of the form (CFG-HANDLE
2467           ;; INNER-FRAME-PARAMS OUTER-FRAME-PARAMS).
2468
2469           ;; CFG-HANDLE is the key to the alist.
2470
2471           ;; INNER-FRAME-PARAMS and OUTER-FRAME-PARAMS specify the
2472           ;; frame params for INNER-FRAME and OUTER-FRAME
2473           ;; respectively.  See below.
2474
2475           ;; Configurations that are meant to be applied to
2476           ;; non-captioned image/formula specifies no
2477           ;; OUTER-FRAME-PARAMS.
2478
2479           ;; TERMINOLOGY
2480           ;; ===========
2481           ;; INNER-FRAME :: Frame that directly surrounds an
2482           ;;                image/formula.
2483
2484           ;; OUTER-FRAME :: Frame that encloses the INNER-FRAME.  This
2485           ;;                frame also contains the caption, if any.
2486
2487           ;; FRAME-PARAMS :: List of the form (FRAME-STYLE-NAME
2488           ;;                 FRAME-ATTRIBUTES FRAME-ANCHOR).  Note
2489           ;;                 that these are the last three arguments
2490           ;;                 to `org-odt--frame'.
2491
2492           ;; Note that an un-captioned image/formula requires just an
2493           ;; INNER-FRAME, while a captioned image/formula requires
2494           ;; both an INNER and an OUTER-FRAME.
2495           '(("As-CharImage" ("OrgInlineImage" nil "as-char"))
2496             ("ParagraphImage" ("OrgDisplayImage" nil "paragraph"))
2497             ("PageImage" ("OrgPageImage" nil "page"))
2498             ("CaptionedAs-CharImage"
2499              ("OrgCaptionedImage"
2500               " style:rel-width=\"100%\" style:rel-height=\"scale\"" "paragraph")
2501              ("OrgInlineImage" nil "as-char"))
2502             ("CaptionedParagraphImage"
2503              ("OrgCaptionedImage"
2504               " style:rel-width=\"100%\" style:rel-height=\"scale\"" "paragraph")
2505              ("OrgImageCaptionFrame" nil "paragraph"))
2506             ("CaptionedPageImage"
2507              ("OrgCaptionedImage"
2508               " style:rel-width=\"100%\" style:rel-height=\"scale\"" "paragraph")
2509              ("OrgPageImageCaptionFrame" nil "page"))
2510             ("InlineFormula" ("OrgInlineFormula" nil "as-char"))
2511             ("DisplayFormula" ("OrgDisplayFormula" nil "as-char"))
2512             ("CaptionedDisplayFormula"
2513              ("OrgCaptionedFormula" nil "paragraph")
2514              ("OrgFormulaCaptionFrame" nil "paragraph"))))
2515          (caption (car captions)) (short-caption (cdr captions))
2516          ;; Retrieve inner and outer frame params, from configuration.
2517          (frame-cfg (assoc-string cfg-key frame-cfg-alist t))
2518          (inner (nth 1 frame-cfg))
2519          (outer (nth 2 frame-cfg))
2520          ;; User-specified frame params (from #+ATTR_ODT spec)
2521          (user user-frame-params)
2522          (--merge-frame-params (function
2523                                 (lambda (default user)
2524                                   "Merge default and user frame params."
2525                                   (if (not user) default
2526                                     (assert (= (length default) 3))
2527                                     (assert (= (length user) 3))
2528                                     (loop for u in user
2529                                           for d in default
2530                                           collect (or u d)))))))
2531     (cond
2532      ;; Case 1: Image/Formula has no caption.
2533      ;;         There is only one frame, one that surrounds the image
2534      ;;         or formula.
2535      ((not caption)
2536       ;; Merge user frame params with that from configuration.
2537       (setq inner (funcall --merge-frame-params inner user))
2538       (apply 'org-odt--frame href width height
2539              (append inner title-and-desc)))
2540      ;; Case 2: Image/Formula is captioned or labeled.
2541      ;;         There are two frames: The inner one surrounds the
2542      ;;         image or formula.  The outer one contains the
2543      ;;         caption/sequence number.
2544      (t
2545       ;; Merge user frame params with outer frame params.
2546       (setq outer (funcall --merge-frame-params outer user))
2547       ;; Short caption, if specified, goes as part of inner frame.
2548       (setq inner (let ((frame-params (copy-sequence inner)))
2549                     (setcar (cdr frame-params)
2550                             (concat
2551                              (cadr frame-params)
2552                              (when short-caption
2553                                (format " draw:name=\"%s\" " short-caption))))
2554                     frame-params))
2555       (apply 'org-odt--textbox
2556              (format "\n<text:p text:style-name=\"%s\">%s</text:p>"
2557                      "Illustration"
2558                      (concat
2559                       (apply 'org-odt--frame href width height
2560                              (append inner title-and-desc))
2561                       caption))
2562              width height outer)))))
2563
2564 (defun org-odt--enumerable-p (element info)
2565   ;; Element should have a caption or label.
2566   (or (org-element-property :caption element)
2567       (org-element-property :name element)))
2568
2569 (defun org-odt--enumerable-image-p (element info)
2570   (org-odt--standalone-link-p
2571    element info
2572    ;; Paragraph should have a caption or label.  It SHOULD NOT be a
2573    ;; replacement element. (i.e., It SHOULD NOT be a result of LaTeX
2574    ;; processing.)
2575    (lambda (p)
2576      (and (not (org-element-property :replaces p))
2577           (or (org-element-property :caption p)
2578               (org-element-property :name p))))
2579    ;; Link should point to an image file.
2580    (lambda (l)
2581      (assert (eq (org-element-type l) 'link))
2582      (org-export-inline-image-p l org-odt-inline-image-rules))))
2583
2584 (defun org-odt--enumerable-latex-image-p (element info)
2585   (org-odt--standalone-link-p
2586    element info
2587    ;; Paragraph should have a caption or label.  It SHOULD also be a
2588    ;; replacement element. (i.e., It SHOULD be a result of LaTeX
2589    ;; processing.)
2590    (lambda (p)
2591      (and (org-element-property :replaces p)
2592           (or (org-element-property :caption p)
2593               (org-element-property :name p))))
2594    ;; Link should point to an image file.
2595    (lambda (l)
2596      (assert (eq (org-element-type l) 'link))
2597      (org-export-inline-image-p l org-odt-inline-image-rules))))
2598
2599 (defun org-odt--enumerable-formula-p (element info)
2600   (org-odt--standalone-link-p
2601    element info
2602    ;; Paragraph should have a caption or label.
2603    (lambda (p)
2604      (or (org-element-property :caption p)
2605          (org-element-property :name p)))
2606    ;; Link should point to a MathML or ODF file.
2607    (lambda (l)
2608      (assert (eq (org-element-type l) 'link))
2609      (org-export-inline-image-p l org-odt-inline-formula-rules))))
2610
2611 (defun org-odt--standalone-link-p (element info &optional
2612                                              paragraph-predicate
2613                                              link-predicate)
2614   "Test if ELEMENT is a standalone link for the purpose ODT export.
2615 INFO is a plist holding contextual information.
2616
2617 Return non-nil, if ELEMENT is of type paragraph satisfying
2618 PARAGRAPH-PREDICATE and it's sole content, save for whitespaces,
2619 is a link that satisfies LINK-PREDICATE.
2620
2621 Return non-nil, if ELEMENT is of type link satisfying
2622 LINK-PREDICATE and it's containing paragraph satisfies
2623 PARAGRAPH-PREDICATE inaddtion to having no other content save for
2624 leading and trailing whitespaces.
2625
2626 Return nil, otherwise."
2627   (let ((p (case (org-element-type element)
2628              (paragraph element)
2629              (link (and (or (not link-predicate)
2630                             (funcall link-predicate element))
2631                         (org-export-get-parent element)))
2632              (t nil))))
2633     (when (and p (eq (org-element-type p) 'paragraph))
2634       (when (or (not paragraph-predicate)
2635                 (funcall paragraph-predicate p))
2636         (let ((contents (org-element-contents p)))
2637           (loop for x in contents
2638                 with inline-image-count = 0
2639                 always (case (org-element-type x)
2640                          (plain-text
2641                           (not (org-string-nw-p x)))
2642                          (link
2643                           (and (or (not link-predicate)
2644                                    (funcall link-predicate x))
2645                                (= (incf inline-image-count) 1)))
2646                          (t nil))))))))
2647
2648 (defun org-odt-link--infer-description (destination info)
2649   ;; DESTINATION is a HEADLINE, a "<<target>>" or an element (like
2650   ;; paragraph, verse-block etc) to which a "#+NAME: label" can be
2651   ;; attached.  Note that labels that are attached to captioned
2652   ;; entities - inline images, math formulae and tables - get resolved
2653   ;; as part of `org-odt-format-label' and `org-odt--enumerate'.
2654
2655   ;; Create a cross-reference to DESTINATION but make best-efforts to
2656   ;; create a *meaningful* description.  Check item numbers, section
2657   ;; number and section title in that order.
2658
2659   ;; NOTE: Counterpart of `org-export-get-ordinal'.
2660   ;; FIXME: Handle footnote-definition footnote-reference?
2661   (let* ((genealogy (org-export-get-genealogy destination))
2662          (data (reverse genealogy))
2663          (label (case (org-element-type destination)
2664                   (headline
2665                    (format "sec-%s" (mapconcat 'number-to-string
2666                                                (org-export-get-headline-number
2667                                                 destination info) "-")))
2668                   (target
2669                    (org-element-property :value destination))
2670                   (t (error "FIXME: Resolve %S" destination)))))
2671     (or
2672      (let* ( ;; Locate top-level list.
2673             (top-level-list
2674              (loop for x on data
2675                    when (eq (org-element-type (car x)) 'plain-list)
2676                    return x))
2677             ;; Get list item nos.
2678             (item-numbers
2679              (loop for (plain-list item . rest) on top-level-list by #'cddr
2680                    until (not (eq (org-element-type plain-list) 'plain-list))
2681                    collect (when (eq (org-element-property :type
2682                                                            plain-list)
2683                                      'ordered)
2684                              (1+ (length (org-export-get-previous-element
2685                                           item info t))))))
2686             ;; Locate top-most listified headline.
2687             (listified-headlines
2688              (loop for x on data
2689                    when (and (eq (org-element-type (car x)) 'headline)
2690                              (org-export-low-level-p (car x) info))
2691                    return x))
2692             ;; Get listified headline numbers.
2693             (listified-headline-nos
2694              (loop for el in listified-headlines
2695                    when (eq (org-element-type el) 'headline)
2696                    collect (when (org-export-numbered-headline-p el info)
2697                              (1+ (length (org-export-get-previous-element
2698                                           el info t)))))))
2699        ;; Combine item numbers from both the listified headlines and
2700        ;; regular list items.
2701
2702        ;; Case 1: Check if all the parents of list item are numbered.
2703        ;; If yes, link to the item proper.
2704        (let ((item-numbers (append listified-headline-nos item-numbers)))
2705          (when (and item-numbers (not (memq nil item-numbers)))
2706            (format "<text:bookmark-ref text:reference-format=\"number-all-superior\" text:ref-name=\"%s\">%s</text:bookmark-ref>"
2707                    (org-export-solidify-link-text label)
2708                    (mapconcat (lambda (n) (if (not n) " "
2709                                             (concat (number-to-string n) ".")))
2710                               item-numbers "")))))
2711      ;; Case 2: Locate a regular and numbered headline in the
2712      ;; hierarchy.  Display it's section number.
2713      (let ((headline (loop for el in (cons destination genealogy)
2714                            when (and (eq (org-element-type el) 'headline)
2715                                      (not (org-export-low-level-p el info))
2716                                      (org-export-numbered-headline-p el info))
2717                            return el)))
2718        ;; We found one.
2719        (when headline
2720          (format "<text:bookmark-ref text:reference-format=\"chapter\" text:ref-name=\"OrgXref.%s\">%s</text:bookmark-ref>"
2721                  (org-export-solidify-link-text label)
2722                  (mapconcat 'number-to-string (org-export-get-headline-number
2723                                                headline info) "."))))
2724      ;; Case 4: Locate a regular headline in the hierarchy.  Display
2725      ;; it's title.
2726      (let ((headline (loop for el in (cons destination genealogy)
2727                            when (and (eq (org-element-type el) 'headline)
2728                                      (not (org-export-low-level-p el info)))
2729                            return el)))
2730        ;; We found one.
2731        (when headline
2732          (format "<text:bookmark-ref text:reference-format=\"text\" text:ref-name=\"OrgXref.%s\">%s</text:bookmark-ref>"
2733                  (org-export-solidify-link-text label)
2734                  (let ((title (org-element-property :title headline)))
2735                    (org-export-data title info)))))
2736      (error "FIXME?"))))
2737
2738 (defun org-odt-link (link desc info)
2739   "Transcode a LINK object from Org to ODT.
2740
2741 DESC is the description part of the link, or the empty string.
2742 INFO is a plist holding contextual information.  See
2743 `org-export-data'."
2744   (let* ((type (org-element-property :type link))
2745          (raw-path (org-element-property :path link))
2746          ;; Ensure DESC really exists, or set it to nil.
2747          (desc (and (not (string= desc "")) desc))
2748          (imagep (org-export-inline-image-p
2749                   link org-odt-inline-image-rules))
2750          (path (cond
2751                 ((member type '("http" "https" "ftp" "mailto"))
2752                  (concat type ":" raw-path))
2753                 ((string= type "file")
2754                  (if (file-name-absolute-p raw-path)
2755                      (concat "file://" (expand-file-name raw-path))
2756                    (concat "file://" raw-path)))
2757                 (t raw-path)))
2758          ;; Convert & to &amp; for correct XML representation
2759          (path (replace-regexp-in-string "&" "&amp;" path))
2760          protocol)
2761     (cond
2762      ;; Image file.
2763      ((and (not desc) (org-export-inline-image-p
2764                        link org-odt-inline-image-rules))
2765       (org-odt-link--inline-image link info))
2766      ;; Formula file.
2767      ((and (not desc) (org-export-inline-image-p
2768                        link org-odt-inline-formula-rules))
2769       (org-odt-link--inline-formula link info))
2770      ;; Radio target: Transcode target's contents and use them as
2771      ;; link's description.
2772      ((string= type "radio")
2773       (let ((destination (org-export-resolve-radio-link link info)))
2774         (when destination
2775           (let ((desc (org-export-data (org-element-contents destination) info))
2776                 (href (org-export-solidify-link-text path)))
2777             (format
2778              "<text:bookmark-ref text:reference-format=\"text\" text:ref-name=\"OrgXref.%s\">%s</text:bookmark-ref>"
2779              href desc)))))
2780      ;; Links pointing to a headline: Find destination and build
2781      ;; appropriate referencing command.
2782      ((member type '("custom-id" "fuzzy" "id"))
2783       (let ((destination (if (string= type "fuzzy")
2784                              (org-export-resolve-fuzzy-link link info)
2785                            (org-export-resolve-id-link link info))))
2786         (case (org-element-type destination)
2787           ;; Case 1: Fuzzy link points nowhere.
2788           ('nil
2789            (format "<text:span text:style-name=\"%s\">%s</text:span>"
2790                    "Emphasis"
2791                    (or desc
2792                        (org-export-data (org-element-property :raw-link link)
2793                                         info))))
2794           ;; Case 2: Fuzzy link points to a headline.
2795           (headline
2796            ;; If there's a description, create a hyperlink.
2797            ;; Otherwise, try to provide a meaningful description.
2798            (if (not desc) (org-odt-link--infer-description destination info)
2799              (let* ((headline-no
2800                      (org-export-get-headline-number destination info))
2801                     (label
2802                      (format "sec-%s"
2803                              (mapconcat 'number-to-string headline-no "-"))))
2804                (format
2805                 "<text:a xlink:type=\"simple\" xlink:href=\"#%s\">%s</text:a>"
2806                 label desc))))
2807           ;; Case 3: Fuzzy link points to a target.
2808           (target
2809            ;; If there's a description, create a hyperlink.
2810            ;; Otherwise, try to provide a meaningful description.
2811            (if (not desc) (org-odt-link--infer-description destination info)
2812              (let ((label (org-element-property :value destination)))
2813                (format "<text:a xlink:type=\"simple\" xlink:href=\"#%s\">%s</text:a>"
2814                        (org-export-solidify-link-text label)
2815                        desc))))
2816           ;; Case 4: Fuzzy link points to some element (e.g., an
2817           ;; inline image, a math formula or a table).
2818           (otherwise
2819            (let ((label-reference
2820                   (ignore-errors (org-odt-format-label
2821                                   destination info 'reference))))
2822              (cond ((not label-reference)
2823                     (org-odt-link--infer-description destination info))
2824                    ;; LINK has no description.  Create
2825                    ;; a cross-reference showing entity's sequence
2826                    ;; number.
2827                    ((not desc) label-reference)
2828                    ;; LINK has description.  Insert a hyperlink with
2829                    ;; user-provided description.
2830                    (t
2831                     (let ((label (org-element-property :name destination)))
2832                       (format "<text:a xlink:type=\"simple\" xlink:href=\"#%s\">%s</text:a>"
2833                               (org-export-solidify-link-text label)
2834                               desc)))))))))
2835      ;; Coderef: replace link with the reference name or the
2836      ;; equivalent line number.
2837      ((string= type "coderef")
2838       (let* ((line-no (format "%d" (org-export-resolve-coderef path info)))
2839              (href (concat "coderef-" path)))
2840         (format
2841          (org-export-get-coderef-format path desc)
2842          (format
2843           "<text:bookmark-ref text:reference-format=\"number\" text:ref-name=\"OrgXref.%s\">%s</text:bookmark-ref>"
2844           href line-no))))
2845      ;; Link type is handled by a special function.
2846      ((functionp (setq protocol (nth 2 (assoc type org-link-protocols))))
2847       (funcall protocol (org-link-unescape path) desc 'odt))
2848      ;; External link with a description part.
2849      ((and path desc)
2850       (let ((link-contents (org-element-contents link)))
2851         ;; Check if description is a link to an inline image.
2852         (if (and (not (cdr link-contents))
2853                  (let ((desc-element (car link-contents)))
2854                    (and (eq (org-element-type desc-element) 'link)
2855                         (org-export-inline-image-p
2856                          desc-element org-odt-inline-image-rules))))
2857             ;; Format link as a clickable image.
2858             (format "\n<draw:a xlink:type=\"simple\" xlink:href=\"%s\">\n%s\n</draw:a>"
2859                     path desc)
2860           ;; Otherwise, format it as a regular link.
2861           (format "<text:a xlink:type=\"simple\" xlink:href=\"%s\">%s</text:a>"
2862                   path desc))))
2863      ;; External link without a description part.
2864      (path
2865       (format "<text:a xlink:type=\"simple\" xlink:href=\"%s\">%s</text:a>"
2866               path path))
2867      ;; No path, only description.  Try to do something useful.
2868      (t (format "<text:span text:style-name=\"%s\">%s</text:span>"
2869                 "Emphasis" desc)))))
2870
2871
2872 ;;;; Node Property
2873
2874 (defun org-odt-node-property (node-property contents info)
2875   "Transcode a NODE-PROPERTY element from Org to ODT.
2876 CONTENTS is nil.  INFO is a plist holding contextual
2877 information."
2878   (org-odt--encode-plain-text
2879    (format "%s:%s"
2880            (org-element-property :key node-property)
2881            (let ((value (org-element-property :value node-property)))
2882              (if value (concat " " value) "")))))
2883
2884 ;;;; Paragraph
2885
2886 (defun org-odt--format-paragraph (paragraph contents default center quote)
2887   "Format paragraph according to given styles.
2888 PARAGRAPH is a paragraph type element.  CONTENTS is the
2889 transcoded contents of that paragraph, as a string.  DEFAULT,
2890 CENTER and QUOTE are, respectively, style to use when paragraph
2891 belongs to no special environment, a center block, or a quote
2892 block."
2893   (let* ((parent (org-export-get-parent paragraph))
2894          (parent-type (org-element-type parent))
2895          (style (case parent-type
2896                   (quote-block quote)
2897                   (center-block center)
2898                   (t default))))
2899     ;; If this paragraph is a leading paragraph in an item and the
2900     ;; item has a checkbox, splice the checkbox and paragraph contents
2901     ;; together.
2902     (when (and (eq (org-element-type parent) 'item)
2903                (eq paragraph (car (org-element-contents parent))))
2904       (setq contents (concat (org-odt--checkbox parent) contents)))
2905     (format "\n<text:p text:style-name=\"%s\">%s</text:p>" style contents)))
2906
2907 (defun org-odt-paragraph (paragraph contents info)
2908   "Transcode a PARAGRAPH element from Org to ODT.
2909 CONTENTS is the contents of the paragraph, as a string.  INFO is
2910 the plist used as a communication channel."
2911   (org-odt--format-paragraph
2912    paragraph contents
2913    (or (org-element-property :style paragraph) "Text_20_body")
2914    "OrgCenter"
2915    "Quotations"))
2916
2917
2918 ;;;; Plain List
2919
2920 (defun org-odt-plain-list (plain-list contents info)
2921   "Transcode a PLAIN-LIST element from Org to ODT.
2922 CONTENTS is the contents of the list.  INFO is a plist holding
2923 contextual information."
2924   (format "\n<text:list text:style-name=\"%s\" %s>\n%s</text:list>"
2925           ;; Choose style based on list type.
2926           (case (org-element-property :type plain-list)
2927             (ordered "OrgNumberedList")
2928             (unordered "OrgBulletedList")
2929             (descriptive-1 "OrgDescriptionList")
2930             (descriptive-2 "OrgDescriptionList"))
2931           ;; If top-level list, re-start numbering.  Otherwise,
2932           ;; continue numbering.
2933           (format "text:continue-numbering=\"%s\""
2934                   (let* ((parent (org-export-get-parent plain-list)))
2935                     (if (and parent (eq (org-element-type parent) 'item))
2936                         "true" "false")))
2937           contents))
2938
2939 ;;;; Plain Text
2940
2941 (defun org-odt--encode-tabs-and-spaces (line)
2942   (replace-regexp-in-string
2943    "\\([\t]\\|\\([ ]+\\)\\)"
2944    (lambda (s)
2945      (cond
2946       ((string= s "\t") "<text:tab/>")
2947       (t (let ((n (length s)))
2948            (cond
2949             ((= n 1) " ")
2950             ((> n 1) (concat " " (format "<text:s text:c=\"%d\"/>" (1- n))))
2951             (t ""))))))
2952    line))
2953
2954 (defun org-odt--encode-plain-text (text &optional no-whitespace-filling)
2955   (mapc
2956    (lambda (pair)
2957      (setq text (replace-regexp-in-string (car pair) (cdr pair) text t t)))
2958    '(("&" . "&amp;") ("<" . "&lt;") (">" . "&gt;")))
2959   (if no-whitespace-filling text
2960     (org-odt--encode-tabs-and-spaces text)))
2961
2962 (defun org-odt-plain-text (text info)
2963   "Transcode a TEXT string from Org to ODT.
2964 TEXT is the string to transcode.  INFO is a plist holding
2965 contextual information."
2966   (let ((output text))
2967     ;; Protect &, < and >.
2968     (setq output (org-odt--encode-plain-text output t))
2969     ;; Handle smart quotes.  Be sure to provide original string since
2970     ;; OUTPUT may have been modified.
2971     (when (plist-get info :with-smart-quotes)
2972       (setq output (org-export-activate-smart-quotes output :utf-8 info text)))
2973     ;; Convert special strings.
2974     (when (plist-get info :with-special-strings)
2975       (mapc
2976        (lambda (pair)
2977          (setq output
2978                (replace-regexp-in-string (car pair) (cdr pair) output t nil)))
2979        org-odt-special-string-regexps))
2980     ;; Handle break preservation if required.
2981     (when (plist-get info :preserve-breaks)
2982       (setq output (replace-regexp-in-string
2983                     "\\(\\\\\\\\\\)?[ \t]*\n" "<text:line-break/>" output t)))
2984     ;; Return value.
2985     output))
2986
2987
2988 ;;;; Planning
2989
2990 (defun org-odt-planning (planning contents info)
2991   "Transcode a PLANNING element from Org to ODT.
2992 CONTENTS is nil.  INFO is a plist used as a communication
2993 channel."
2994   (format "\n<text:p text:style-name=\"%s\">%s</text:p>"
2995           "OrgPlanning"
2996           (concat
2997            (let ((closed (org-element-property :closed planning)))
2998              (when closed
2999                (concat
3000                 (format "<text:span text:style-name=\"%s\">%s</text:span>"
3001                         "OrgClosedKeyword" org-closed-string)
3002                 (org-odt-timestamp closed contents info))))
3003            (let ((deadline (org-element-property :deadline planning)))
3004              (when deadline
3005                (concat
3006                 (format "<text:span text:style-name=\"%s\">%s</text:span>"
3007                         "OrgDeadlineKeyword" org-deadline-string)
3008                 (org-odt-timestamp deadline contents info))))
3009            (let ((scheduled (org-element-property :scheduled planning)))
3010              (when scheduled
3011                (concat
3012                 (format "<text:span text:style-name=\"%s\">%s</text:span>"
3013                         "OrgScheduledKeyword" org-deadline-string)
3014                 (org-odt-timestamp scheduled contents info)))))))
3015
3016
3017 ;;;; Property Drawer
3018
3019 (defun org-odt-property-drawer (property-drawer contents info)
3020   "Transcode a PROPERTY-DRAWER element from Org to ODT.
3021 CONTENTS holds the contents of the drawer.  INFO is a plist
3022 holding contextual information."
3023   (and (org-string-nw-p contents)
3024        (format "<text:p text:style-name=\"OrgFixedWidthBlock\">%s</text:p>"
3025                contents)))
3026
3027
3028 ;;;; Quote Block
3029
3030 (defun org-odt-quote-block (quote-block contents info)
3031   "Transcode a QUOTE-BLOCK element from Org to ODT.
3032 CONTENTS holds the contents of the block.  INFO is a plist
3033 holding contextual information."
3034   contents)
3035
3036
3037 ;;;; Quote Section
3038
3039 (defun org-odt-quote-section (quote-section contents info)
3040   "Transcode a QUOTE-SECTION element from Org to ODT.
3041 CONTENTS is nil.  INFO is a plist holding contextual information."
3042   (let ((value (org-remove-indentation
3043                 (org-element-property :value quote-section))))
3044     (when value (org-odt-do-format-code value))))
3045
3046
3047 ;;;; Section
3048
3049 (defun org-odt-format-section (text style &optional name)
3050   (let ((default-name (car (org-odt-add-automatic-style "Section"))))
3051     (format "\n<text:section text:style-name=\"%s\" %s>\n%s\n</text:section>"
3052             style
3053             (format "text:name=\"%s\"" (or name default-name))
3054             text)))
3055
3056
3057 (defun org-odt-section (section contents info) ; FIXME
3058   "Transcode a SECTION element from Org to ODT.
3059 CONTENTS holds the contents of the section.  INFO is a plist
3060 holding contextual information."
3061   contents)
3062
3063 ;;;; Radio Target
3064
3065 (defun org-odt-radio-target (radio-target text info)
3066   "Transcode a RADIO-TARGET object from Org to ODT.
3067 TEXT is the text of the target.  INFO is a plist holding
3068 contextual information."
3069   (org-odt--target
3070    text (org-export-solidify-link-text
3071          (org-element-property :value radio-target))))
3072
3073
3074 ;;;; Special Block
3075
3076 (defun org-odt-special-block (special-block contents info)
3077   "Transcode a SPECIAL-BLOCK element from Org to ODT.
3078 CONTENTS holds the contents of the block.  INFO is a plist
3079 holding contextual information."
3080   (let ((type (downcase (org-element-property :type special-block)))
3081         (attributes (org-export-read-attribute :attr_odt special-block)))
3082     (cond
3083      ;; Annotation.
3084      ((string= type "annotation")
3085       (let* ((author (or (plist-get attributes :author)
3086                          (let ((author (plist-get info :author)))
3087                            (and author (org-export-data author info)))))
3088              (date (or (plist-get attributes :date)
3089                        ;; FIXME: Is `car' right thing to do below?
3090                        (car (plist-get info :date)))))
3091         (format "\n<text:p>%s</text:p>"
3092                 (format "<office:annotation>\n%s\n</office:annotation>"
3093                         (concat
3094                          (and author
3095                               (format "<dc:creator>%s</dc:creator>" author))
3096                          (and date
3097                               (format "<dc:date>%s</dc:date>"
3098                                       (org-odt--format-timestamp date nil 'iso-date)))
3099                          contents)))))
3100      ;; Textbox.
3101      ((string= type "textbox")
3102       (let ((width (plist-get attributes :width))
3103             (height (plist-get attributes :height))
3104             (style (plist-get attributes :style))
3105             (extra (plist-get attributes :extra))
3106             (anchor (plist-get attributes :anchor)))
3107         (format "\n<text:p text:style-name=\"%s\">%s</text:p>"
3108                 "Text_20_body" (org-odt--textbox contents width height
3109                                                    style extra anchor))))
3110      (t contents))))
3111
3112
3113 ;;;; Src Block
3114
3115 (defun org-odt-hfy-face-to-css (fn)
3116   "Create custom style for face FN.
3117 When FN is the default face, use it's foreground and background
3118 properties to create \"OrgSrcBlock\" paragraph style.  Otherwise
3119 use it's color attribute to create a character style whose name
3120 is obtained from FN.  Currently all attributes of FN other than
3121 color are ignored.
3122
3123 The style name for a face FN is derived using the following
3124 operations on the face name in that order - de-dash, CamelCase
3125 and prefix with \"OrgSrc\".  For example,
3126 `font-lock-function-name-face' is associated with
3127 \"OrgSrcFontLockFunctionNameFace\"."
3128   (let* ((css-list (hfy-face-to-style fn))
3129          (style-name (concat "OrgSrc"
3130                              (mapconcat
3131                               'capitalize (split-string
3132                                            (hfy-face-or-def-to-name fn) "-")
3133                               "")))
3134          (color-val (cdr (assoc "color" css-list)))
3135          (background-color-val (cdr (assoc "background" css-list)))
3136          (style (and org-odt-create-custom-styles-for-srcblocks
3137                      (cond
3138                       ((eq fn 'default)
3139                        (format org-odt-src-block-paragraph-format
3140                                background-color-val color-val))
3141                       (t
3142                        (format
3143                         "
3144 <style:style style:name=\"%s\" style:family=\"text\">
3145   <style:text-properties fo:color=\"%s\"/>
3146  </style:style>" style-name color-val))))))
3147     (cons style-name style)))
3148
3149 (defun org-odt-htmlfontify-string (line)
3150   (let* ((hfy-html-quote-regex "\\([<\"&>       ]\\)")
3151          (hfy-html-quote-map '(("\"" "&quot;")
3152                                ("<" "&lt;")
3153                                ("&" "&amp;")
3154                                (">" "&gt;")
3155                                (" " "<text:s/>")
3156                                ("       " "<text:tab/>")))
3157          (hfy-face-to-css 'org-odt-hfy-face-to-css)
3158          (hfy-optimisations-1 (copy-sequence hfy-optimisations))
3159          (hfy-optimisations (add-to-list 'hfy-optimisations-1
3160                                          'body-text-only))
3161          (hfy-begin-span-handler
3162           (lambda (style text-block text-id text-begins-block-p)
3163             (insert (format "<text:span text:style-name=\"%s\">" style))))
3164          (hfy-end-span-handler (lambda nil (insert "</text:span>"))))
3165     (org-no-warnings (htmlfontify-string line))))
3166
3167 (defun org-odt-do-format-code
3168   (code &optional lang refs retain-labels num-start)
3169   (let* ((lang (or (assoc-default lang org-src-lang-modes) lang))
3170          (lang-mode (and lang (intern (format "%s-mode" lang))))
3171          (code-lines (org-split-string code "\n"))
3172          (code-length (length code-lines))
3173          (use-htmlfontify-p (and (functionp lang-mode)
3174                                  org-odt-fontify-srcblocks
3175                                  (require 'htmlfontify nil t)
3176                                  (fboundp 'htmlfontify-string)))
3177          (code (if (not use-htmlfontify-p) code
3178                  (with-temp-buffer
3179                    (insert code)
3180                    (funcall lang-mode)
3181                    (font-lock-fontify-buffer)
3182                    (buffer-string))))
3183          (fontifier (if use-htmlfontify-p 'org-odt-htmlfontify-string
3184                       'org-odt--encode-plain-text))
3185          (par-style (if use-htmlfontify-p "OrgSrcBlock"
3186                       "OrgFixedWidthBlock"))
3187          (i 0))
3188     (assert (= code-length (length (org-split-string code "\n"))))
3189     (setq code
3190           (org-export-format-code
3191            code
3192            (lambda (loc line-num ref)
3193              (setq par-style
3194                    (concat par-style (and (= (incf i) code-length) "LastLine")))
3195
3196              (setq loc (concat loc (and ref retain-labels (format " (%s)" ref))))
3197              (setq loc (funcall fontifier loc))
3198              (when ref
3199                (setq loc (org-odt--target loc (concat "coderef-" ref))))
3200              (assert par-style)
3201              (setq loc (format "\n<text:p text:style-name=\"%s\">%s</text:p>"
3202                                par-style loc))
3203              (if (not line-num) loc
3204                (format "\n<text:list-item>%s\n</text:list-item>" loc)))
3205            num-start refs))
3206     (cond
3207      ((not num-start) code)
3208      ((= num-start 0)
3209       (format
3210        "\n<text:list text:style-name=\"OrgSrcBlockNumberedLine\"%s>%s</text:list>"
3211        " text:continue-numbering=\"false\"" code))
3212      (t
3213       (format
3214        "\n<text:list text:style-name=\"OrgSrcBlockNumberedLine\"%s>%s</text:list>"
3215        " text:continue-numbering=\"true\"" code)))))
3216
3217 (defun org-odt-format-code (element info)
3218   (let* ((lang (org-element-property :language element))
3219          ;; Extract code and references.
3220          (code-info (org-export-unravel-code element))
3221          (code (car code-info))
3222          (refs (cdr code-info))
3223          ;; Does the src block contain labels?
3224          (retain-labels (org-element-property :retain-labels element))
3225          ;; Does it have line numbers?
3226          (num-start (case (org-element-property :number-lines element)
3227                       (continued (org-export-get-loc element info))
3228                       (new 0))))
3229     (org-odt-do-format-code code lang refs retain-labels num-start)))
3230
3231 (defun org-odt-src-block (src-block contents info)
3232   "Transcode a SRC-BLOCK element from Org to ODT.
3233 CONTENTS holds the contents of the item.  INFO is a plist holding
3234 contextual information."
3235   (let* ((lang (org-element-property :language src-block))
3236          (attributes (org-export-read-attribute :attr_odt src-block))
3237          (captions (org-odt-format-label src-block info 'definition))
3238          (caption (car captions)) (short-caption (cdr captions)))
3239     (concat
3240      (and caption
3241           (format "\n<text:p text:style-name=\"%s\">%s</text:p>"
3242                   "Listing" caption))
3243      (let ((--src-block (org-odt-format-code src-block info)))
3244        (if (not (plist-get attributes :textbox)) --src-block
3245          (format "\n<text:p text:style-name=\"%s\">%s</text:p>"
3246                  "Text_20_body"
3247                  (org-odt--textbox --src-block nil nil nil)))))))
3248
3249
3250 ;;;; Statistics Cookie
3251
3252 (defun org-odt-statistics-cookie (statistics-cookie contents info)
3253   "Transcode a STATISTICS-COOKIE object from Org to ODT.
3254 CONTENTS is nil.  INFO is a plist holding contextual information."
3255   (let ((cookie-value (org-element-property :value statistics-cookie)))
3256     (format "<text:span text:style-name=\"%s\">%s</text:span>"
3257             "OrgCode" cookie-value)))
3258
3259
3260 ;;;; Strike-Through
3261
3262 (defun org-odt-strike-through (strike-through contents info)
3263   "Transcode STRIKE-THROUGH from Org to ODT.
3264 CONTENTS is the text with strike-through markup.  INFO is a plist
3265 holding contextual information."
3266   (format "<text:span text:style-name=\"%s\">%s</text:span>"
3267           "Strikethrough" contents))
3268
3269
3270 ;;;; Subscript
3271
3272 (defun org-odt-subscript (subscript contents info)
3273   "Transcode a SUBSCRIPT object from Org to ODT.
3274 CONTENTS is the contents of the object.  INFO is a plist holding
3275 contextual information."
3276   (format "<text:span text:style-name=\"%s\">%s</text:span>"
3277           "OrgSubscript" contents))
3278
3279
3280 ;;;; Superscript
3281
3282 (defun org-odt-superscript (superscript contents info)
3283   "Transcode a SUPERSCRIPT object from Org to ODT.
3284 CONTENTS is the contents of the object.  INFO is a plist holding
3285 contextual information."
3286   (format "<text:span text:style-name=\"%s\">%s</text:span>"
3287           "OrgSuperscript" contents))
3288
3289
3290 ;;;; Table Cell
3291
3292 (defun org-odt-table-style-spec (element info)
3293   (let* ((table (org-export-get-parent-table element))
3294          (table-attributes (org-export-read-attribute :attr_odt table))
3295          (table-style (plist-get table-attributes :style)))
3296     (assoc table-style org-odt-table-styles)))
3297
3298 (defun org-odt-get-table-cell-styles (table-cell info)
3299   "Retrieve styles applicable to a table cell.
3300 R and C are (zero-based) row and column numbers of the table
3301 cell.  STYLE-SPEC is an entry in `org-odt-table-styles'
3302 applicable to the current table.  It is `nil' if the table is not
3303 associated with any style attributes.
3304
3305 Return a cons of (TABLE-CELL-STYLE-NAME . PARAGRAPH-STYLE-NAME).
3306
3307 When STYLE-SPEC is nil, style the table cell the conventional way
3308 - choose cell borders based on row and column groupings and
3309 choose paragraph alignment based on `org-col-cookies' text
3310 property.  See also
3311 `org-odt-get-paragraph-style-cookie-for-table-cell'.
3312
3313 When STYLE-SPEC is non-nil, ignore the above cookie and return
3314 styles congruent with the ODF-1.2 specification."
3315   (let* ((table-cell-address (org-export-table-cell-address table-cell info))
3316          (r (car table-cell-address)) (c (cdr table-cell-address))
3317          (style-spec (org-odt-table-style-spec table-cell info))
3318          (table-dimensions (org-export-table-dimensions
3319                             (org-export-get-parent-table table-cell)
3320                             info)))
3321     (when style-spec
3322       ;; LibreOffice - particularly the Writer - honors neither table
3323       ;; templates nor custom table-cell styles.  Inorder to retain
3324       ;; inter-operability with LibreOffice, only automatic styles are
3325       ;; used for styling of table-cells.  The current implementation is
3326       ;; congruent with ODF-1.2 specification and hence is
3327       ;; future-compatible.
3328
3329       ;; Additional Note: LibreOffice's AutoFormat facility for tables -
3330       ;; which recognizes as many as 16 different cell types - is much
3331       ;; richer. Unfortunately it is NOT amenable to easy configuration
3332       ;; by hand.
3333       (let* ((template-name (nth 1 style-spec))
3334              (cell-style-selectors (nth 2 style-spec))
3335              (cell-type
3336               (cond
3337                ((and (cdr (assoc 'use-first-column-styles cell-style-selectors))
3338                      (= c 0)) "FirstColumn")
3339                ((and (cdr (assoc 'use-last-column-styles cell-style-selectors))
3340                      (= (1+ c) (cdr table-dimensions)))
3341                 "LastColumn")
3342                ((and (cdr (assoc 'use-first-row-styles cell-style-selectors))
3343                      (= r 0)) "FirstRow")
3344                ((and (cdr (assoc 'use-last-row-styles cell-style-selectors))
3345                      (= (1+ r) (car table-dimensions)))
3346                 "LastRow")
3347                ((and (cdr (assoc 'use-banding-rows-styles cell-style-selectors))
3348                      (= (% r 2) 1)) "EvenRow")
3349                ((and (cdr (assoc 'use-banding-rows-styles cell-style-selectors))
3350                      (= (% r 2) 0)) "OddRow")
3351                ((and (cdr (assoc 'use-banding-columns-styles cell-style-selectors))
3352                      (= (% c 2) 1)) "EvenColumn")
3353                ((and (cdr (assoc 'use-banding-columns-styles cell-style-selectors))
3354                      (= (% c 2) 0)) "OddColumn")
3355                (t ""))))
3356         (concat template-name cell-type)))))
3357
3358 (defun org-odt-table-cell (table-cell contents info)
3359   "Transcode a TABLE-CELL element from Org to ODT.
3360 CONTENTS is nil.  INFO is a plist used as a communication
3361 channel."
3362   (let* ((table-cell-address (org-export-table-cell-address table-cell info))
3363          (r (car table-cell-address))
3364          (c (cdr table-cell-address))
3365          (horiz-span (or (org-export-table-cell-width table-cell info) 0))
3366          (table-row (org-export-get-parent table-cell))
3367          (custom-style-prefix (org-odt-get-table-cell-styles
3368                                table-cell info))
3369          (paragraph-style
3370           (or
3371            (and custom-style-prefix
3372                 (format "%sTableParagraph" custom-style-prefix))
3373            (concat
3374             (cond
3375              ((and (= 1 (org-export-table-row-group table-row info))
3376                    (org-export-table-has-header-p
3377                     (org-export-get-parent-table table-row) info))
3378               "OrgTableHeading")
3379              ((let* ((table (org-export-get-parent-table table-cell))
3380                      (table-attrs (org-export-read-attribute :attr_odt table))
3381                      (table-header-columns
3382                       (let ((cols (plist-get table-attrs :header-columns)))
3383                         (and cols (read cols)))))
3384                 (<= c (cond ((wholenump table-header-columns)
3385                              (- table-header-columns 1))
3386                             (table-header-columns 0)
3387                             (t -1))))
3388               "OrgTableHeading")
3389              (t "OrgTableContents"))
3390             (capitalize (symbol-name (org-export-table-cell-alignment
3391                                       table-cell info))))))
3392          (cell-style-name
3393           (or
3394            (and custom-style-prefix (format "%sTableCell"
3395                                             custom-style-prefix))
3396            (concat
3397             "OrgTblCell"
3398             (when (or (org-export-table-row-starts-rowgroup-p table-row info)
3399                       (zerop r)) "T")
3400             (when (org-export-table-row-ends-rowgroup-p table-row info) "B")
3401             (when (and (org-export-table-cell-starts-colgroup-p table-cell info)
3402                        (not (zerop c)) ) "L"))))
3403          (cell-attributes
3404           (concat
3405            (format " table:style-name=\"%s\"" cell-style-name)
3406            (and (> horiz-span 0)
3407                 (format " table:number-columns-spanned=\"%d\""
3408                         (1+ horiz-span))))))
3409     (unless contents (setq contents ""))
3410     (concat
3411      (assert paragraph-style)
3412      (format "\n<table:table-cell%s>\n%s\n</table:table-cell>"
3413              cell-attributes
3414              (let ((table-cell-contents (org-element-contents table-cell)))
3415                (if (memq (org-element-type (car table-cell-contents))
3416                          org-element-all-elements)
3417                    contents
3418                  (format "\n<text:p text:style-name=\"%s\">%s</text:p>"
3419                          paragraph-style contents))))
3420      (let (s)
3421        (dotimes (i horiz-span s)
3422          (setq s (concat s "\n<table:covered-table-cell/>"))))
3423      "\n")))
3424
3425
3426 ;;;; Table Row
3427
3428 (defun org-odt-table-row (table-row contents info)
3429   "Transcode a TABLE-ROW element from Org to ODT.
3430 CONTENTS is the contents of the row.  INFO is a plist used as a
3431 communication channel."
3432   ;; Rules are ignored since table separators are deduced from
3433   ;; borders of the current row.
3434   (when (eq (org-element-property :type table-row) 'standard)
3435     (let* ((rowgroup-tags
3436             (if (and (= 1 (org-export-table-row-group table-row info))
3437                      (org-export-table-has-header-p
3438                       (org-export-get-parent-table table-row) info))
3439                 ;; If the row belongs to the first rowgroup and the
3440                 ;; table has more than one row groups, then this row
3441                 ;; belongs to the header row group.
3442                 '("\n<table:table-header-rows>" . "\n</table:table-header-rows>")
3443               ;; Otherwise, it belongs to non-header row group.
3444               '("\n<table:table-rows>" . "\n</table:table-rows>"))))
3445       (concat
3446        ;; Does this row begin a rowgroup?
3447        (when (org-export-table-row-starts-rowgroup-p table-row info)
3448          (car rowgroup-tags))
3449        ;; Actual table row
3450        (format "\n<table:table-row>\n%s\n</table:table-row>" contents)
3451        ;; Does this row end a rowgroup?
3452        (when (org-export-table-row-ends-rowgroup-p table-row info)
3453          (cdr rowgroup-tags))))))
3454
3455
3456 ;;;; Table
3457
3458 (defun org-odt-table-first-row-data-cells (table info)
3459   (let ((table-row
3460          (org-element-map table 'table-row
3461            (lambda (row)
3462              (unless (eq (org-element-property :type row) 'rule) row))
3463            info 'first-match))
3464         (special-column-p (org-export-table-has-special-column-p table)))
3465     (if (not special-column-p) (org-element-contents table-row)
3466       (cdr (org-element-contents table-row)))))
3467
3468 (defun org-odt--table (table contents info)
3469   "Transcode a TABLE element from Org to ODT.
3470 CONTENTS is the contents of the table.  INFO is a plist holding
3471 contextual information."
3472   (case (org-element-property :type table)
3473     ;; Case 1: table.el doesn't support export to OD format.  Strip
3474     ;; such tables from export.
3475     (table.el
3476      (prog1 nil
3477        (message
3478         (concat
3479          "(ox-odt): Found table.el-type table in the source Org file."
3480          "  table.el doesn't support export to ODT format."
3481          "  Stripping the table from export."))))
3482     ;; Case 2: Native Org tables.
3483     (otherwise
3484      (let* ((captions (org-odt-format-label table info 'definition))
3485             (caption (car captions)) (short-caption (cdr captions))
3486             (attributes (org-export-read-attribute :attr_odt table))
3487             (custom-table-style (nth 1 (org-odt-table-style-spec table info)))
3488             (table-column-specs
3489              (function
3490               (lambda (table info)
3491                 (let* ((table-style (or custom-table-style "OrgTable"))
3492                        (column-style (format "%sColumn" table-style)))
3493                   (mapconcat
3494                    (lambda (table-cell)
3495                      (let ((width (1+ (or (org-export-table-cell-width
3496                                            table-cell info) 0)))
3497                            (s (format
3498                                "\n<table:table-column table:style-name=\"%s\"/>"
3499                                column-style))
3500                            out)
3501                        (dotimes (i width out) (setq out (concat s out)))))
3502                    (org-odt-table-first-row-data-cells table info) "\n"))))))
3503        (concat
3504         ;; caption.
3505         (when caption
3506           (format "\n<text:p text:style-name=\"%s\">%s</text:p>"
3507                   "Table" caption))
3508         ;; begin table.
3509         (let* ((automatic-name
3510                 (org-odt-add-automatic-style "Table" attributes)))
3511           (format
3512            "\n<table:table table:style-name=\"%s\"%s>"
3513            (or custom-table-style (cdr automatic-name) "OrgTable")
3514            (concat (when short-caption
3515                      (format " table:name=\"%s\"" short-caption)))))
3516         ;; column specification.
3517         (funcall table-column-specs table info)
3518         ;; actual contents.
3519         "\n" contents
3520         ;; end table.
3521         "</table:table>")))))
3522
3523 (defun org-odt-table (table contents info)
3524   "Transcode a TABLE element from Org to ODT.
3525 CONTENTS is the contents of the table.  INFO is a plist holding
3526 contextual information.
3527
3528 Use `org-odt--table' to typeset the table.  Handle details
3529 pertaining to indentation here."
3530   (let* ((--element-preceded-by-table-p
3531           (function
3532            (lambda (element info)
3533              (loop for el in (org-export-get-previous-element element info t)
3534                    thereis (eq (org-element-type el) 'table)))))
3535          (--walk-list-genealogy-and-collect-tags
3536           (function
3537            (lambda (table info)
3538              (let* ((genealogy (org-export-get-genealogy table))
3539                     (list-genealogy
3540                      (when (eq (org-element-type (car genealogy)) 'item)
3541                        (loop for el in genealogy
3542                              when (memq (org-element-type el)
3543                                         '(item plain-list))
3544                              collect el)))
3545                     (llh-genealogy
3546                      (apply 'nconc
3547                             (loop for el in genealogy
3548                                   when (and (eq (org-element-type el) 'headline)
3549                                             (org-export-low-level-p el info))
3550                                   collect
3551                                   (list el
3552                                         (assq 'headline
3553                                               (org-element-contents
3554                                                (org-export-get-parent el)))))))
3555                     parent-list)
3556                (nconc
3557                 ;; Handle list genealogy.
3558                 (loop for el in list-genealogy collect
3559                       (case (org-element-type el)
3560                         (plain-list
3561                          (setq parent-list el)
3562                          (cons "</text:list>"
3563                                (format "\n<text:list text:style-name=\"%s\" %s>"
3564                                        (case (org-element-property :type el)
3565                                          (ordered "OrgNumberedList")
3566                                          (unordered "OrgBulletedList")
3567                                          (descriptive-1 "OrgDescriptionList")
3568                                          (descriptive-2 "OrgDescriptionList"))
3569                                        "text:continue-numbering=\"true\"")))
3570                         (item
3571                          (cond
3572                           ((not parent-list)
3573                            (if (funcall --element-preceded-by-table-p table info)
3574                                '("</text:list-header>" . "<text:list-header>")
3575                              '("</text:list-item>" . "<text:list-header>")))
3576                           ((funcall --element-preceded-by-table-p
3577                                     parent-list info)
3578                            '("</text:list-header>" . "<text:list-header>"))
3579                           (t '("</text:list-item>" . "<text:list-item>"))))))
3580                 ;; Handle low-level headlines.
3581                 (loop for el in llh-genealogy
3582                       with step = 'item collect
3583                       (case step
3584                         (plain-list
3585                          (setq step 'item) ; Flip-flop
3586                          (setq parent-list el)
3587                          (cons "</text:list>"
3588                                (format "\n<text:list text:style-name=\"%s\" %s>"
3589                                        (if (org-export-numbered-headline-p
3590                                             el info)
3591                                            "OrgNumberedList"
3592                                          "OrgBulletedList")
3593                                        "text:continue-numbering=\"true\"")))
3594                         (item
3595                          (setq step 'plain-list) ; Flip-flop
3596                          (cond
3597                           ((not parent-list)
3598                            (if (funcall --element-preceded-by-table-p table info)
3599                                '("</text:list-header>" . "<text:list-header>")
3600                              '("</text:list-item>" . "<text:list-header>")))
3601                           ((let ((section? (org-export-get-previous-element
3602                                             parent-list info)))
3603                              (and section?
3604                                   (eq (org-element-type section?) 'section)
3605                                   (assq 'table (org-element-contents section?))))
3606                            '("</text:list-header>" . "<text:list-header>"))
3607                           (t
3608                            '("</text:list-item>" . "<text:list-item>")))))))))))
3609          (close-open-tags (funcall --walk-list-genealogy-and-collect-tags
3610                                    table info)))
3611     ;; OpenDocument schema does not permit table to occur within a
3612     ;; list item.
3613
3614     ;; One solution - the easiest and lightweight, in terms of
3615     ;; implementation - is to put the table in an indented text box
3616     ;; and make the text box part of the list-item.  Unfortunately if
3617     ;; the table is big and spans multiple pages, the text box could
3618     ;; overflow.  In this case, the following attribute will come
3619     ;; handy.
3620
3621     ;; ,---- From OpenDocument-v1.1.pdf
3622     ;; | 15.27.28 Overflow behavior
3623     ;; |
3624     ;; | For text boxes contained within text document, the
3625     ;; | style:overflow-behavior property specifies the behavior of text
3626     ;; | boxes where the containing text does not fit into the text
3627     ;; | box.
3628     ;; |
3629     ;; | If the attribute's value is clip, the text that does not fit
3630     ;; | into the text box is not displayed.
3631     ;; |
3632     ;; | If the attribute value is auto-create-new-frame, a new frame
3633     ;; | will be created on the next page, with the same position and
3634     ;; | dimensions of the original frame.
3635     ;; |
3636     ;; | If the style:overflow-behavior property's value is
3637     ;; | auto-create-new-frame and the text box has a minimum width or
3638     ;; | height specified, then the text box will grow until the page
3639     ;; | bounds are reached before a new frame is created.
3640     ;; `----
3641
3642     ;; Unfortunately, LibreOffice-3.4.6 doesn't honor
3643     ;; auto-create-new-frame property and always resorts to clipping
3644     ;; the text box.  This results in table being truncated.
3645
3646     ;; So we solve the problem the hard (and fun) way using list
3647     ;; continuations.
3648
3649     ;; The problem only becomes more interesting if you take in to
3650     ;; account the following facts:
3651     ;;
3652     ;; - Description lists are simulated as plain lists.
3653     ;; - Low-level headlines can be listified.
3654     ;; - In Org-mode, a table can occur not only as a regular list
3655     ;;   item, but also within description lists and low-level
3656     ;;   headlines.
3657
3658     ;; See `org-odt-translate-description-lists' and
3659     ;; `org-odt-translate-low-level-headlines' for how this is
3660     ;; tackled.
3661
3662     (concat "\n"
3663             ;; Discontinue the list.
3664             (mapconcat 'car close-open-tags "\n")
3665             ;; Put the table in an indented section.
3666             (let* ((table (org-odt--table table contents info))
3667                    (level (/ (length (mapcar 'car close-open-tags)) 2))
3668                    (style (format "OrgIndentedSection-Level-%d" level)))
3669               (when table (org-odt-format-section table style)))
3670             ;; Continue the list.
3671             (mapconcat 'cdr (nreverse close-open-tags) "\n"))))
3672
3673
3674 ;;;; Target
3675
3676 (defun org-odt-target (target contents info)
3677   "Transcode a TARGET object from Org to ODT.
3678 CONTENTS is nil.  INFO is a plist holding contextual
3679 information."
3680   (let ((value (org-element-property :value target)))
3681     (org-odt--target "" (org-export-solidify-link-text value))))
3682
3683
3684 ;;;; Timestamp
3685
3686 (defun org-odt-timestamp (timestamp contents info)
3687   "Transcode a TIMESTAMP object from Org to ODT.
3688 CONTENTS is nil.  INFO is a plist used as a communication
3689 channel."
3690   (let* ((raw-value (org-element-property :raw-value timestamp))
3691          (type (org-element-property :type timestamp)))
3692     (if (not org-odt-use-date-fields)
3693         (let ((value (org-odt-plain-text
3694                       (org-timestamp-translate timestamp) info)))
3695           (case (org-element-property :type timestamp)
3696             ((active active-range)
3697              (format "<text:span text:style-name=\"%s\">%s</text:span>"
3698                      "OrgActiveTimestamp" value))
3699             ((inactive inactive-range)
3700              (format "<text:span text:style-name=\"%s\">%s</text:span>"
3701                      "OrgInactiveTimestamp" value))
3702             (otherwise value)))
3703       (case type
3704         (active
3705          (format "<text:span text:style-name=\"%s\">%s</text:span>"
3706                  "OrgActiveTimestamp"
3707                  (format "&lt;%s&gt;" (org-odt--format-timestamp timestamp))))
3708         (inactive
3709          (format "<text:span text:style-name=\"%s\">%s</text:span>"
3710                  "OrgInactiveTimestamp"
3711                  (format "[%s]" (org-odt--format-timestamp timestamp))))
3712         (active-range
3713          (format "<text:span text:style-name=\"%s\">%s</text:span>"
3714                  "OrgActiveTimestamp"
3715                  (format "&lt;%s&gt;&#x2013;&lt;%s&gt;"
3716                          (org-odt--format-timestamp timestamp)
3717                          (org-odt--format-timestamp timestamp 'end))))
3718         (inactive-range
3719          (format "<text:span text:style-name=\"%s\">%s</text:span>"
3720                  "OrgInactiveTimestamp"
3721                  (format "[%s]&#x2013;[%s]"
3722                          (org-odt--format-timestamp timestamp)
3723                          (org-odt--format-timestamp timestamp 'end))))
3724         (otherwise
3725          (format "<text:span text:style-name=\"%s\">%s</text:span>"
3726                  "OrgDiaryTimestamp"
3727                  (org-odt-plain-text (org-timestamp-translate timestamp)
3728                                        info)))))))
3729
3730
3731 ;;;; Underline
3732
3733 (defun org-odt-underline (underline contents info)
3734   "Transcode UNDERLINE from Org to ODT.
3735 CONTENTS is the text with underline markup.  INFO is a plist
3736 holding contextual information."
3737   (format "<text:span text:style-name=\"%s\">%s</text:span>"
3738           "Underline" contents))
3739
3740
3741 ;;;; Verbatim
3742
3743 (defun org-odt-verbatim (verbatim contents info)
3744   "Transcode a VERBATIM object from Org to ODT.
3745 CONTENTS is nil.  INFO is a plist used as a communication
3746 channel."
3747   (format "<text:span text:style-name=\"%s\">%s</text:span>"
3748           "OrgCode" (org-odt--encode-plain-text
3749                      (org-element-property :value verbatim))))
3750
3751
3752 ;;;; Verse Block
3753
3754 (defun org-odt-verse-block (verse-block contents info)
3755   "Transcode a VERSE-BLOCK element from Org to ODT.
3756 CONTENTS is verse block contents.  INFO is a plist holding
3757 contextual information."
3758   ;; Add line breaks to each line of verse.
3759   (setq contents (replace-regexp-in-string
3760                   "\\(<text:line-break/>\\)?[ \t]*\n"
3761                   "<text:line-break/>" contents))
3762   ;; Replace tabs and spaces.
3763   (setq contents (org-odt--encode-tabs-and-spaces contents))
3764   ;; Surround it in a verse environment.
3765   (format "\n<text:p text:style-name=\"%s\">%s</text:p>"
3766           "OrgVerse" contents))
3767
3768
3769 \f
3770 ;;; Filters
3771
3772 ;;;; LaTeX fragments
3773
3774 (defun org-odt--translate-latex-fragments (tree backend info)
3775   (let ((processing-type (plist-get info :with-latex))
3776         (count 0))
3777     ;; Normalize processing-type to one of dvipng, mathml or verbatim.
3778     ;; If the desired converter is not available, force verbatim
3779     ;; processing.
3780     (case processing-type
3781       ((t mathml)
3782        (if (and (fboundp 'org-format-latex-mathml-available-p)
3783                 (org-format-latex-mathml-available-p))
3784            (setq processing-type 'mathml)
3785          (message "LaTeX to MathML converter not available.")
3786          (setq processing-type 'verbatim)))
3787       ((dvipng imagemagick)
3788        (unless (and (org-check-external-command "latex" "" t)
3789                     (org-check-external-command
3790                      (if (eq processing-type 'dvipng) "dvipng" "convert") "" t))
3791          (message "LaTeX to PNG converter not available.")
3792          (setq processing-type 'verbatim)))
3793       (otherwise
3794        (message "Unknown LaTeX option.  Forcing verbatim.")
3795        (setq processing-type 'verbatim)))
3796
3797     ;; Store normalized value for later use.
3798     (when (plist-get info :with-latex)
3799       (plist-put info :with-latex processing-type))
3800     (message "Formatting LaTeX using %s" processing-type)
3801
3802     ;; Convert `latex-fragment's and `latex-environment's.
3803     (when (memq processing-type '(mathml dvipng imagemagick))
3804       (org-element-map tree '(latex-fragment latex-environment)
3805         (lambda (latex-*)
3806           (incf count)
3807           (let* ((latex-frag (org-element-property :value latex-*))
3808                  (input-file (plist-get info :input-file))
3809                  (cache-dir (file-name-directory input-file))
3810                  (cache-subdir (concat
3811                                 (case processing-type
3812                                   ((dvipng imagemagick) "ltxpng/")
3813                                   (mathml "ltxmathml/"))
3814                                 (file-name-sans-extension
3815                                  (file-name-nondirectory input-file))))
3816                  (display-msg
3817                   (case processing-type
3818                     ((dvipng imagemagick) (format "Creating LaTeX Image %d..." count))
3819                     (mathml (format "Creating MathML snippet %d..." count))))
3820                  ;; Get an Org-style link to PNG image or the MathML
3821                  ;; file.
3822                  (org-link
3823                   (let ((link (with-temp-buffer
3824                                 (insert latex-frag)
3825                                 (org-format-latex cache-subdir cache-dir
3826                                                   nil display-msg
3827                                                   nil nil processing-type)
3828                                 (buffer-substring-no-properties
3829                                  (point-min) (point-max)))))
3830                     (if (not (string-match "file:\\([^]]*\\)" link))
3831                         (prog1 nil (message "LaTeX Conversion failed."))
3832                       link))))
3833             (when org-link
3834               ;; Conversion succeeded.  Parse above Org-style link to a
3835               ;; `link' object.
3836               (let* ((link (car (org-element-map (with-temp-buffer
3837                                                    (org-mode)
3838                                                    (insert org-link)
3839                                                    (org-element-parse-buffer))
3840                                     'link 'identity))))
3841                 ;; Orphan the link.
3842                 (org-element-put-property link :parent nil)
3843                 (let* (
3844                        (replacement
3845                         (case (org-element-type latex-*)
3846                           ;; Case 1: LaTeX environment.
3847                           ;; Mimic a "standalone image or formula" by
3848                           ;; enclosing the `link' in a `paragraph'.
3849                           ;; Copy over original attributes, captions to
3850                           ;; the enclosing paragraph.
3851                           (latex-environment
3852                            (org-element-adopt-elements
3853                             (list 'paragraph
3854                                   (list :style "OrgFormula"
3855                                         :name (org-element-property :name
3856                                                                     latex-*)
3857                                         :caption (org-element-property :caption
3858                                                                        latex-*)))
3859                             link))
3860                           ;; Case 2: LaTeX fragment.
3861                           ;; No special action.
3862                           (latex-fragment link))))
3863                   ;; Note down the object that link replaces.
3864                   (org-element-put-property replacement :replaces
3865                                             (list (org-element-type latex-*)
3866                                                   (list :value latex-frag)))
3867                   ;; Replace now.
3868                   (org-element-set-element latex-* replacement))))))
3869         info)))
3870   tree)
3871
3872
3873 ;;;; Description lists
3874
3875 ;; This translator is necessary to handle indented tables in a uniform
3876 ;; manner.  See comment in `org-odt--table'.
3877
3878 (defun org-odt--translate-description-lists (tree backend info)
3879   ;; OpenDocument has no notion of a description list.  So simulate it
3880   ;; using plain lists.  Description lists in the exported document
3881   ;; are typeset in the same manner as they are in a typical HTML
3882   ;; document.
3883   ;;
3884   ;; Specifically, a description list like this:
3885   ;;
3886   ;;     ,----
3887   ;;     | - term-1 :: definition-1
3888   ;;     | - term-2 :: definition-2
3889   ;;     `----
3890   ;;
3891   ;; gets translated in to the following form:
3892   ;;
3893   ;;     ,----
3894   ;;     | - term-1
3895   ;;     |   - definition-1
3896   ;;     | - term-2
3897   ;;     |   - definition-2
3898   ;;     `----
3899   ;;
3900   ;; Further effect is achieved by fixing the OD styles as below:
3901   ;;
3902   ;; 1. Set the :type property of the simulated lists to
3903   ;;    `descriptive-1' and `descriptive-2'.  Map these to list-styles
3904   ;;    that has *no* bullets whatsoever.
3905   ;;
3906   ;; 2. The paragraph containing the definition term is styled to be
3907   ;;    in bold.
3908   ;;
3909   (org-element-map tree 'plain-list
3910     (lambda (el)
3911       (when (equal (org-element-property :type el) 'descriptive)
3912         (org-element-set-element
3913          el
3914          (apply 'org-element-adopt-elements
3915                 (list 'plain-list (list :type 'descriptive-1))
3916                 (mapcar
3917                  (lambda (item)
3918                    (org-element-adopt-elements
3919                     (list 'item (list :checkbox (org-element-property
3920                                                  :checkbox item)))
3921                     (list 'paragraph (list :style "Text_20_body_20_bold")
3922                           (or (org-element-property :tag item) "(no term)"))
3923                     (org-element-adopt-elements
3924                      (list 'plain-list (list :type 'descriptive-2))
3925                      (apply 'org-element-adopt-elements
3926                             (list 'item nil)
3927                             (org-element-contents item)))))
3928                  (org-element-contents el)))))
3929       nil)
3930     info)
3931   tree)
3932
3933 ;;;; List tables
3934
3935 ;; Lists that are marked with attribute `:list-table' are called as
3936 ;; list tables.  They will be rendered as a table within the exported
3937 ;; document.
3938
3939 ;; Consider an example.  The following list table
3940 ;;
3941 ;; #+attr_odt :list-table t
3942 ;; - Row 1
3943 ;;   - 1.1
3944 ;;   - 1.2
3945 ;;   - 1.3
3946 ;; - Row 2
3947 ;;   - 2.1
3948 ;;   - 2.2
3949 ;;   - 2.3
3950 ;;
3951 ;; will be exported as though it were an Org table like the one show
3952 ;; below.
3953 ;;
3954 ;; | Row 1 | 1.1 | 1.2 | 1.3 |
3955 ;; | Row 2 | 2.1 | 2.2 | 2.3 |
3956 ;;
3957 ;; Note that org-tables are NOT multi-line and each line is mapped to
3958 ;; a unique row in the exported document.  So if an exported table
3959 ;; needs to contain a single paragraph (with copious text) it needs to
3960 ;; be typed up in a single line.  Editing such long lines using the
3961 ;; table editor will be a cumbersome task.  Furthermore inclusion of
3962 ;; multi-paragraph text in a table cell is well-nigh impossible.
3963 ;;
3964 ;; A LIST-TABLE circumvents above problems.
3965 ;;
3966 ;; Note that in the example above the list items could be paragraphs
3967 ;; themselves and the list can be arbitrarily deep.
3968 ;;
3969 ;; Inspired by following thread:
3970 ;; https://lists.gnu.org/archive/html/emacs-orgmode/2011-03/msg01101.html
3971
3972 ;; Translate lists to tables
3973
3974 (defun org-odt--translate-list-tables (tree backend info)
3975   (org-element-map tree 'plain-list
3976     (lambda (l1-list)
3977       (when (org-export-read-attribute :attr_odt l1-list :list-table)
3978         ;; Replace list with table.
3979         (org-element-set-element
3980          l1-list
3981          ;; Build replacement table.
3982          (apply 'org-element-adopt-elements
3983                 (list 'table '(:type org :attr_odt (":style \"GriddedTable\"")))
3984                 (org-element-map l1-list 'item
3985                   (lambda (l1-item)
3986                     (let* ((l1-item-contents (org-element-contents l1-item))
3987                            l1-item-leading-text l2-list)
3988                       ;; Remove Level-2 list from the Level-item.  It
3989                       ;; will be subsequently attached as table-cells.
3990                       (let ((cur l1-item-contents) prev)
3991                         (while (and cur (not (eq (org-element-type (car cur))
3992                                                  'plain-list)))
3993                           (setq prev cur)
3994                           (setq cur (cdr cur)))
3995                         (when prev
3996                           (setcdr prev nil)
3997                           (setq l2-list (car cur)))
3998                         (setq l1-item-leading-text l1-item-contents))
3999                       ;; Level-1 items start a table row.
4000                       (apply 'org-element-adopt-elements
4001                              (list 'table-row (list :type 'standard))
4002                              ;;  Leading text of level-1 item define
4003                              ;;  the first table-cell.
4004                              (apply 'org-element-adopt-elements
4005                                     (list 'table-cell nil)
4006                                     l1-item-leading-text)
4007                              ;; Level-2 items define subsequent
4008                              ;; table-cells of the row.
4009                              (org-element-map l2-list 'item
4010                                (lambda (l2-item)
4011                                  (apply 'org-element-adopt-elements
4012                                         (list 'table-cell nil)
4013                                         (org-element-contents l2-item)))
4014                                info nil 'item))))
4015                   info nil 'item))))
4016       nil)
4017     info)
4018   tree)
4019
4020 \f
4021 ;;; Interactive functions
4022
4023 (defun org-odt-create-manifest-file-entry (&rest args)
4024   (push args org-odt-manifest-file-entries))
4025
4026 (defun org-odt-write-manifest-file ()
4027   (make-directory (concat org-odt-zip-dir "META-INF"))
4028   (let ((manifest-file (concat org-odt-zip-dir "META-INF/manifest.xml")))
4029     (with-current-buffer
4030         (let ((nxml-auto-insert-xml-declaration-flag nil))
4031           (find-file-noselect manifest-file t))
4032       (insert
4033        "<?xml version=\"1.0\" encoding=\"UTF-8\"?>
4034      <manifest:manifest xmlns:manifest=\"urn:oasis:names:tc:opendocument:xmlns:manifest:1.0\" manifest:version=\"1.2\">\n")
4035       (mapc
4036        (lambda (file-entry)
4037          (let* ((version (nth 2 file-entry))
4038                 (extra (if (not version) ""
4039                          (format " manifest:version=\"%s\"" version))))
4040            (insert
4041             (format org-odt-manifest-file-entry-tag
4042                     (nth 0 file-entry) (nth 1 file-entry) extra))))
4043        org-odt-manifest-file-entries)
4044       (insert "\n</manifest:manifest>"))))
4045
4046 (defmacro org-odt--export-wrap (out-file &rest body)
4047   `(let* ((--out-file ,out-file)
4048           (out-file-type (file-name-extension --out-file))
4049           (org-odt-xml-files '("META-INF/manifest.xml" "content.xml"
4050                                  "meta.xml" "styles.xml"))
4051           ;; Initialize temporary workarea.  All files that end up in
4052           ;; the exported document get parked/created here.
4053           (org-odt-zip-dir (file-name-as-directory
4054                               (make-temp-file (format "%s-" out-file-type) t)))
4055           (org-odt-manifest-file-entries nil)
4056           (--cleanup-xml-buffers
4057            (function
4058             (lambda nil
4059               ;; Kill all XML buffers.
4060               (mapc (lambda (file)
4061                       (let ((buf (find-buffer-visiting
4062                                   (concat org-odt-zip-dir file))))
4063                         (when buf
4064                           (with-current-buffer buf
4065                             (set-buffer-modified-p nil)
4066                             (kill-buffer buf)))))
4067                     org-odt-xml-files)
4068               ;; Delete temporary directory and also other embedded
4069               ;; files that get copied there.
4070               (delete-directory org-odt-zip-dir t)))))
4071      (condition-case err
4072          (progn
4073            (unless (executable-find "zip")
4074              ;; Not at all OSes ship with zip by default
4075              (error "Executable \"zip\" needed for creating OpenDocument files"))
4076            ;; Do export.  This creates a bunch of xml files ready to be
4077            ;; saved and zipped.
4078            (progn ,@body)
4079            ;; Create a manifest entry for content.xml.
4080            (org-odt-create-manifest-file-entry "text/xml" "content.xml")
4081            ;; Write mimetype file
4082            (let* ((mimetypes
4083                    '(("odt" . "application/vnd.oasis.opendocument.text")
4084                      ("odf" .  "application/vnd.oasis.opendocument.formula")))
4085                   (mimetype (cdr (assoc-string out-file-type mimetypes t))))
4086              (unless mimetype
4087                (error "Unknown OpenDocument backend %S" out-file-type))
4088              (write-region mimetype nil (concat org-odt-zip-dir "mimetype"))
4089              (org-odt-create-manifest-file-entry mimetype "/" "1.2"))
4090            ;; Write out the manifest entries before zipping
4091            (org-odt-write-manifest-file)
4092            ;; Save all XML files.
4093            (mapc (lambda (file)
4094                    (let ((buf (find-buffer-visiting
4095                                (concat org-odt-zip-dir file))))
4096                      (when buf
4097                        (with-current-buffer buf
4098                          ;; Prettify output if needed.
4099                          (when org-odt-prettify-xml
4100                            (indent-region (point-min) (point-max)))
4101                          (save-buffer 0)))))
4102                  org-odt-xml-files)
4103            ;; Run zip.
4104            (let* ((target --out-file)
4105                   (target-name (file-name-nondirectory target))
4106                   (cmds `(("zip" "-mX0" ,target-name "mimetype")
4107                           ("zip" "-rmTq" ,target-name "."))))
4108              ;; If a file with same name as the desired output file
4109              ;; exists, remove it.
4110              (when (file-exists-p target)
4111                (delete-file target))
4112              ;; Zip up the xml files.
4113              (let ((coding-system-for-write 'no-conversion) exitcode err-string)
4114                (message "Creating ODT file...")
4115                ;; Switch temporarily to content.xml.  This way Zip
4116                ;; process will inherit `org-odt-zip-dir' as the current
4117                ;; directory.
4118                (with-current-buffer
4119                    (find-file-noselect (concat org-odt-zip-dir "content.xml") t)
4120                  (mapc
4121                   (lambda (cmd)
4122                     (message "Running %s" (mapconcat 'identity cmd " "))
4123                     (setq err-string
4124                           (with-output-to-string
4125                             (setq exitcode
4126                                   (apply 'call-process (car cmd)
4127                                          nil standard-output nil (cdr cmd)))))
4128                     (or (zerop exitcode)
4129                         (error (concat "Unable to create OpenDocument file."
4130                                        (format "  Zip failed with error (%s)"
4131                                                err-string)))))
4132                   cmds)))
4133              ;; Move the zip file from temporary work directory to
4134              ;; user-mandated location.
4135              (rename-file (concat org-odt-zip-dir target-name) target)
4136              (message "Created %s" (expand-file-name target))
4137              ;; Cleanup work directory and work files.
4138              (funcall --cleanup-xml-buffers)
4139              ;; Open the OpenDocument file in archive-mode for
4140              ;; examination.
4141              (find-file-noselect target t)
4142              ;; Return exported file.
4143              (cond
4144               ;; Case 1: Conversion desired on exported file.  Run the
4145               ;; converter on the OpenDocument file.  Return the
4146               ;; converted file.
4147               (org-odt-preferred-output-format
4148                (or (org-odt-convert target org-odt-preferred-output-format)
4149                    target))
4150               ;; Case 2: No further conversion.  Return exported
4151               ;; OpenDocument file.
4152               (t target))))
4153        (error
4154         ;; Cleanup work directory and work files.
4155         (funcall --cleanup-xml-buffers)
4156         (message "OpenDocument export failed: %s"
4157                  (error-message-string err))))))
4158
4159
4160 ;;;; Export to OpenDocument formula
4161
4162 ;;;###autoload
4163 (defun org-odt-export-as-odf (latex-frag &optional odf-file)
4164   "Export LATEX-FRAG as OpenDocument formula file ODF-FILE.
4165 Use `org-create-math-formula' to convert LATEX-FRAG first to
4166 MathML.  When invoked as an interactive command, use
4167 `org-latex-regexps' to infer LATEX-FRAG from currently active
4168 region.  If no LaTeX fragments are found, prompt for it.  Push
4169 MathML source to kill ring depending on the value of
4170 `org-export-copy-to-kill-ring'."
4171   (interactive
4172    `(,(let (frag)
4173         (setq frag (and (setq frag (and (region-active-p)
4174                                         (buffer-substring (region-beginning)
4175                                                           (region-end))))
4176                         (loop for e in org-latex-regexps
4177                               thereis (when (string-match (nth 1 e) frag)
4178                                         (match-string (nth 2 e) frag)))))
4179         (read-string "LaTeX Fragment: " frag nil frag))
4180      ,(let ((odf-filename (expand-file-name
4181                            (concat
4182                             (file-name-sans-extension
4183                              (or (file-name-nondirectory buffer-file-name)))
4184                             "." "odf")
4185                            (file-name-directory buffer-file-name))))
4186         (read-file-name "ODF filename: " nil odf-filename nil
4187                         (file-name-nondirectory odf-filename)))))
4188   (let ((filename (or odf-file
4189                       (expand-file-name
4190                        (concat
4191                         (file-name-sans-extension
4192                          (or (file-name-nondirectory buffer-file-name)))
4193                         "." "odf")
4194                        (file-name-directory buffer-file-name)))))
4195     (org-odt--export-wrap
4196      filename
4197      (let* ((buffer (progn
4198                       (require 'nxml-mode)
4199                       (let ((nxml-auto-insert-xml-declaration-flag nil))
4200                         (find-file-noselect (concat org-odt-zip-dir
4201                                                     "content.xml") t))))
4202             (coding-system-for-write 'utf-8)
4203             (save-buffer-coding-system 'utf-8))
4204        (set-buffer buffer)
4205        (set-buffer-file-coding-system coding-system-for-write)
4206        (let ((mathml (org-create-math-formula latex-frag)))
4207          (unless mathml (error "No Math formula created"))
4208          (insert mathml)
4209          ;; Add MathML to kill ring, if needed.
4210          (when (org-export--copy-to-kill-ring-p)
4211            (org-kill-new (buffer-string))))))))
4212
4213 ;;;###autoload
4214 (defun org-odt-export-as-odf-and-open ()
4215   "Export LaTeX fragment as OpenDocument formula and immediately open it.
4216 Use `org-odt-export-as-odf' to read LaTeX fragment and OpenDocument
4217 formula file."
4218   (interactive)
4219   (org-open-file (call-interactively 'org-odt-export-as-odf) 'system))
4220
4221
4222 ;;;; Export to OpenDocument Text
4223
4224 ;;;###autoload
4225 (defun org-odt-export-to-odt (&optional async subtreep visible-only ext-plist)
4226   "Export current buffer to a ODT file.
4227
4228 If narrowing is active in the current buffer, only export its
4229 narrowed part.
4230
4231 If a region is active, export that region.
4232
4233 A non-nil optional argument ASYNC means the process should happen
4234 asynchronously.  The resulting file should be accessible through
4235 the `org-export-stack' interface.
4236
4237 When optional argument SUBTREEP is non-nil, export the sub-tree
4238 at point, extracting information from the headline properties
4239 first.
4240
4241 When optional argument VISIBLE-ONLY is non-nil, don't export
4242 contents of hidden elements.
4243
4244 EXT-PLIST, when provided, is a property list with external
4245 parameters overriding Org default settings, but still inferior to
4246 file-local settings.
4247
4248 Return output file's name."
4249   (interactive)
4250   (let ((outfile (org-export-output-file-name ".odt" subtreep)))
4251     (if async
4252         (org-export-async-start (lambda (f) (org-export-add-to-stack f 'odt))
4253           `(expand-file-name
4254             (org-odt--export-wrap
4255              ,outfile
4256              (let* ((org-odt-embedded-images-count 0)
4257                     (org-odt-embedded-formulas-count 0)
4258                     (org-odt-automatic-styles nil)
4259                     (org-odt-object-counters nil)
4260                     ;; Let `htmlfontify' know that we are interested in
4261                     ;; collecting styles.
4262                     (hfy-user-sheet-assoc nil))
4263                ;; Initialize content.xml and kick-off the export
4264                ;; process.
4265                (let ((out-buf
4266                       (progn
4267                         (require 'nxml-mode)
4268                         (let ((nxml-auto-insert-xml-declaration-flag nil))
4269                           (find-file-noselect
4270                            (concat org-odt-zip-dir "content.xml") t))))
4271                      (output (org-export-as
4272                               'odt ,subtreep ,visible-only nil ,ext-plist)))
4273                  (with-current-buffer out-buf
4274                    (erase-buffer)
4275                    (insert output)))))))
4276       (org-odt--export-wrap
4277        outfile
4278        (let* ((org-odt-embedded-images-count 0)
4279               (org-odt-embedded-formulas-count 0)
4280               (org-odt-automatic-styles nil)
4281               (org-odt-object-counters nil)
4282               ;; Let `htmlfontify' know that we are interested in collecting
4283               ;; styles.
4284               (hfy-user-sheet-assoc nil))
4285          ;; Initialize content.xml and kick-off the export process.
4286          (let ((output (org-export-as 'odt subtreep visible-only nil ext-plist))
4287                (out-buf (progn
4288                           (require 'nxml-mode)
4289                           (let ((nxml-auto-insert-xml-declaration-flag nil))
4290                             (find-file-noselect
4291                              (concat org-odt-zip-dir "content.xml") t)))))
4292            (with-current-buffer out-buf (erase-buffer) (insert output))))))))
4293
4294
4295 ;;;; Convert between OpenDocument and other formats
4296
4297 (defun org-odt-reachable-p (in-fmt out-fmt)
4298   "Return non-nil if IN-FMT can be converted to OUT-FMT."
4299   (catch 'done
4300     (let ((reachable-formats (org-odt-do-reachable-formats in-fmt)))
4301       (dolist (e reachable-formats)
4302         (let ((out-fmt-spec (assoc out-fmt (cdr e))))
4303           (when out-fmt-spec
4304             (throw 'done (cons (car e) out-fmt-spec))))))))
4305
4306 (defun org-odt-do-convert (in-file out-fmt &optional prefix-arg)
4307   "Workhorse routine for `org-odt-convert'."
4308   (require 'browse-url)
4309   (let* ((in-file (expand-file-name (or in-file buffer-file-name)))
4310          (dummy (or (file-readable-p in-file)
4311                     (error "Cannot read %s" in-file)))
4312          (in-fmt (file-name-extension in-file))
4313          (out-fmt (or out-fmt (error "Output format unspecified")))
4314          (how (or (org-odt-reachable-p in-fmt out-fmt)
4315                   (error "Cannot convert from %s format to %s format?"
4316                          in-fmt out-fmt)))
4317          (convert-process (car how))
4318          (out-file (concat (file-name-sans-extension in-file) "."
4319                            (nth 1 (or (cdr how) out-fmt))))
4320          (extra-options (or (nth 2 (cdr how)) ""))
4321          (out-dir (file-name-directory in-file))
4322          (cmd (format-spec convert-process
4323                            `((?i . ,(shell-quote-argument in-file))
4324                              (?I . ,(browse-url-file-url in-file))
4325                              (?f . ,out-fmt)
4326                              (?o . ,out-file)
4327                              (?O . ,(browse-url-file-url out-file))
4328                              (?d . , (shell-quote-argument out-dir))
4329                              (?D . ,(browse-url-file-url out-dir))
4330                              (?x . ,extra-options)))))
4331     (when (file-exists-p out-file)
4332       (delete-file out-file))
4333
4334     (message "Executing %s" cmd)
4335     (let ((cmd-output (shell-command-to-string cmd)))
4336       (message "%s" cmd-output))
4337
4338     (cond
4339      ((file-exists-p out-file)
4340       (message "Exported to %s" out-file)
4341       (when prefix-arg
4342         (message "Opening %s..."  out-file)
4343         (org-open-file out-file 'system))
4344       out-file)
4345      (t
4346       (message "Export to %s failed" out-file)
4347       nil))))
4348
4349 (defun org-odt-do-reachable-formats (in-fmt)
4350   "Return verbose info about formats to which IN-FMT can be converted.
4351 Return a list where each element is of the
4352 form (CONVERTER-PROCESS . OUTPUT-FMT-ALIST).  See
4353 `org-odt-convert-processes' for CONVERTER-PROCESS and see
4354 `org-odt-convert-capabilities' for OUTPUT-FMT-ALIST."
4355   (let* ((converter
4356           (and org-odt-convert-process
4357                (cadr (assoc-string org-odt-convert-process
4358                                    org-odt-convert-processes t))))
4359          (capabilities
4360           (and org-odt-convert-process
4361                (cadr (assoc-string org-odt-convert-process
4362                                    org-odt-convert-processes t))
4363                org-odt-convert-capabilities))
4364          reachable-formats)
4365     (when converter
4366       (dolist (c capabilities)
4367         (when (member in-fmt (nth 1 c))
4368           (push (cons converter (nth 2 c)) reachable-formats))))
4369     reachable-formats))
4370
4371 (defun org-odt-reachable-formats (in-fmt)
4372   "Return list of formats to which IN-FMT can be converted.
4373 The list of the form (OUTPUT-FMT-1 OUTPUT-FMT-2 ...)."
4374   (let (l)
4375     (mapc (lambda (e) (add-to-list 'l e))
4376           (apply 'append (mapcar
4377                           (lambda (e) (mapcar 'car (cdr e)))
4378                           (org-odt-do-reachable-formats in-fmt))))
4379     l))
4380
4381 (defun org-odt-convert-read-params ()
4382   "Return IN-FILE and OUT-FMT params for `org-odt-do-convert'.
4383 This is a helper routine for interactive use."
4384   (let* ((input (if (featurep 'ido) 'ido-completing-read 'completing-read))
4385          (in-file (read-file-name "File to be converted: "
4386                                   nil buffer-file-name t))
4387          (in-fmt (file-name-extension in-file))
4388          (out-fmt-choices (org-odt-reachable-formats in-fmt))
4389          (out-fmt
4390           (or (and out-fmt-choices
4391                    (funcall input "Output format: "
4392                             out-fmt-choices nil nil nil))
4393               (error
4394                "No known converter or no known output formats for %s files"
4395                in-fmt))))
4396     (list in-file out-fmt)))
4397
4398 ;;;###autoload
4399 (defun org-odt-convert (&optional in-file out-fmt prefix-arg)
4400   "Convert IN-FILE to format OUT-FMT using a command line converter.
4401 IN-FILE is the file to be converted.  If unspecified, it defaults
4402 to variable `buffer-file-name'.  OUT-FMT is the desired output
4403 format.  Use `org-odt-convert-process' as the converter.
4404 If PREFIX-ARG is non-nil then the newly converted file is opened
4405 using `org-open-file'."
4406   (interactive
4407    (append (org-odt-convert-read-params) current-prefix-arg))
4408   (org-odt-do-convert in-file out-fmt prefix-arg))
4409
4410 ;;; Library Initializations
4411
4412 (mapc
4413  (lambda (desc)
4414    ;; Let Emacs open all OpenDocument files in archive mode
4415    (add-to-list 'auto-mode-alist
4416                 (cons (concat  "\\." (car desc) "\\'") 'archive-mode)))
4417  org-odt-file-extensions)
4418
4419 (provide 'ox-odt)
4420
4421 ;; Local variables:
4422 ;; generated-autoload-file: "org-loaddefs.el"
4423 ;; End:
4424
4425 ;;; ox-odt.el ends here