doc-multipart.c

   1 /*
   2  * Copyright Neil Brown ©2016-2023 <neil@brown.name>
   3  * May be distributed under terms of GPLv2 - see file:COPYING
   4  *
   5  * doc-multipart: Present a sequence of documents as though it were
   6  *   just one.
   7  *   This is used for stitching together the parts of a MIME email message.
   8  *
   9  * The document is created empty, and then given subordinate documents
  10  * using a "multipart-add" command which causes the "focus" to be added
  11  * to a list.
  12  * If more sophisticated edits are needed, they can come later.
  13  */
  14
  15 #include <unistd.h>
  16 #include <stdlib.h>
  17 #include <fcntl.h>
  18 #include <string.h>
  19 #include <stdio.h>
  20
  21 #define PRIVATE_DOC_REF
  22
  23 struct doc_ref {
  24         struct mark *m;
  25         int docnum; /* may be 'nparts', in which case 'm' == NULL */
  26 };
  27
  28 /* mark->mdata in marks we create on individual component documents
  29  * is used to track if the mark is shared among multiple marks in the
  30  * multipart document.
  31  */
  32 #define GET_REFS(_mark) ((unsigned long)((_mark)->mdata))
  33 #define SET_REFS(_mark, val) ((_mark)->mdata = (void*)(unsigned long)(val))
  34 #define ADD_REFS(_mark, inc) SET_REFS(_mark, GET_REFS(_mark) + (inc))
  35
  36 #define DOC_DATA_TYPE struct mp_info
  37
  38 #define DOC_NEXT(p,m,r,b) multipart_next_prev(p, m, r, 1, b, ci->str)
  39 #define DOC_PREV(p,m,r,b) multipart_next_prev(p, m, r, 0, b, ci->str)
  40 #define DOC_NEXT_DECL(p,m,r,b) multipart_next_prev(p, m, r, int forward, b, const char *str)
  41 #define DOC_PREV_DECL(p,m,r,b) multipart_next_prev(p, m, r, int forward, b, const char *str)
  42 #include "core.h"
  43
  44 struct mp_info {
  45         struct doc      doc;
  46         int             nparts;
  47         int             parts_size;
  48         struct part {
  49                 struct pane     *pane;
  50         } *parts safe;
  51 };
  52 #include "core-pane.h"
  53
  54 static struct map *mp_map safe;
  55
  56 /* Before moving a mark, we make sure m->ref.m is not shared.
  57  * After moving, we make sure the mark is correctly ordered among
  58  * siblings, and then share if m->ref.m should be shared.
  59  */
  60 static void pre_move(struct mark *m safe)
  61 {
  62         struct mark *m2;
  63
  64         if (!m->ref.m || GET_REFS(m->ref.m) == 1)
  65                 return;
  66         /* Mark is shared, make it unshared */
  67         m2 = mark_dup(m->ref.m);
  68         ADD_REFS(m->ref.m, -1);
  69         SET_REFS(m2, 1);
  70         m->ref.m = m2;
  71 }
  72
  73 static void post_move(struct mark *m)
  74 {
  75         /* m->ref.m might have moved.  If so, move m in the list of
  76          * marks so marks in this document are still properly ordered
  77          * Then ensure that if neighbouring marks are at same location,
  78          * they use same marks.
  79          */
  80         struct mark *m2, *mtarget;
  81
  82         if (!m || hlist_unhashed(&m->all))
  83                 return;
  84         ASSERT(m->ref.m == NULL || GET_REFS(m->ref.m) == 1);
  85         mtarget = m;
  86         while ((m2 = mark_next(mtarget)) != NULL &&
  87                (m2->ref.docnum < m->ref.docnum ||
  88                 (m2->ref.docnum == m->ref.docnum &&
  89                  m2->ref.m && m->ref.m &&
  90                  m2->ref.m->seq < m->ref.m->seq)))
  91                 mtarget = m2;
  92         if (mtarget != m)
  93                 /* m should be after mtarget */
  94                 mark_to_mark_noref(m, mtarget);
  95
  96         mtarget = m;
  97         while ((m2 = mark_prev(mtarget)) != NULL &&
  98                (m2->ref.docnum > m->ref.docnum||
  99                 (m2->ref.docnum == m->ref.docnum &&
 100                  m2->ref.m && m->ref.m &&
 101                  m2->ref.m->seq > m->ref.m->seq)))
 102                 mtarget = m2;
 103         if (mtarget != m)
 104                 /* m should be before mtarget */
 105                 mark_to_mark_noref(m, mtarget);
 106
 107         if (!m->ref.m)
 108                 return;
 109         ASSERT(GET_REFS(m->ref.m) == 1);
 110         /* Check if it should be shared */
 111         m2 = mark_next(m);
 112         if (m2 && m2->ref.docnum == m->ref.docnum && m2->ref.m) {
 113                 if (m->ref.m != m2->ref.m &&
 114                     mark_same(m->ref.m, m2->ref.m)) {
 115                         SET_REFS(m->ref.m, 0);
 116                         mark_free(m->ref.m);
 117                         m->ref.m = m2->ref.m;
 118                         ADD_REFS(m->ref.m, 1);
 119                         return;
 120                 }
 121         }
 122         m2 = mark_prev(m);
 123         if (m2 && m2->ref.docnum == m->ref.docnum && m2->ref.m) {
 124                 if (m->ref.m != m2->ref.m &&
 125                     mark_same(m->ref.m, m2->ref.m)) {
 126                         SET_REFS(m->ref.m, 0);
 127                         mark_free(m->ref.m);
 128                         m->ref.m = m2->ref.m;
 129                         ADD_REFS(m->ref.m, 1);
 130                         return;
 131                 }
 132         }
 133 }
 134
 135 static void mp_mark_refcnt(struct mark *m safe, int inc)
 136 {
 137         if (!m->ref.m)
 138                 return;
 139
 140         if (inc > 0)
 141                 /* Duplicate being created of this mark */
 142                 ADD_REFS(m->ref.m, 1);
 143
 144         if (inc < 0) {
 145                 /* mark is being discarded, or ref over-written */
 146                 ADD_REFS(m->ref.m, -1);
 147                 if (GET_REFS(m->ref.m) == 0)
 148                         mark_free(m->ref.m);
 149                 m->ref.m = NULL;
 150         }
 151 }
 152
 153 static void mp_check_consistent(struct mp_info *mpi safe)
 154 {
 155 //      struct mark *m;
 156         struct doc *d = &mpi->doc;
 157 //      int s = -1;
 158
 159         doc_check_consistent(d);
 160 #if 0
 161         for (m = mark_first(d); m; m = mark_next(m)) {
 162                 if (!m->ref.m || m->ref.m->seq <= s) {
 163                         for (m = mark_first(d); m;
 164                              m = mark_next(m))
 165                                 if (m && m->ref.m)
 166                                         printf("%p %d %d\n", m, m->seq,
 167                                                m->ref.m->seq);
 168
 169                         abort();
 170                 }
 171                 s = m->ref.m->seq;
 172         }
 173         doc_check_consistent(d);
 174 #endif
 175 }
 176
 177 static void change_part(struct mp_info *mpi safe, struct mark *m safe,
 178                         int part, int end)
 179 {
 180         struct mark *m1;
 181         struct part *p;
 182
 183         if (part < 0 || part > mpi->nparts)
 184                 return;
 185         if (m->ref.m) {
 186                 ASSERT(GET_REFS(m->ref.m) == 1);
 187                 SET_REFS(m->ref.m, 0);
 188                 mark_free(m->ref.m);
 189                 m->ref.m = NULL;
 190         }
 191         if (part < mpi->nparts && (p = &mpi->parts[part]) && p->pane) {
 192                 m1 = mark_new(p->pane);
 193                 if (m1) {
 194                         call("doc:set-ref", p->pane, !end, m1);
 195                         m->ref.m = m1;
 196                         SET_REFS(m1, 1);
 197                 }
 198         } else
 199                 m->ref.m = NULL;
 200         m->ref.docnum = part;
 201 }
 202
 203 static void mp_normalize(struct mp_info *mpi safe, struct mark *m safe,
 204                          const char *vis)
 205 {
 206         /* If points the end of a document, point to the start
 207          * of the next instead.
 208          */
 209         struct part *p;
 210         while (m->ref.m && (p = &mpi->parts[m->ref.docnum]) && p->pane &&
 211                doc_following(p->pane, m->ref.m) == WEOF) {
 212                 int n = m->ref.docnum + 1;
 213                 while (n < mpi->nparts && vis && vis[n] == 'i')
 214                         n += 1;
 215                 change_part(mpi, m, n, 0);
 216         }
 217 }
 218
 219 DEF_CMD(mp_close)
 220 {
 221         struct mp_info *mpi = ci->home->doc_data;
 222         int i;
 223         struct mark *m;
 224
 225         for (m = mark_first(&mpi->doc); m ; m = mark_next(m))
 226                 if (m->ref.m) {
 227                         struct mark *m2 = m->ref.m;
 228                         m->ref.m = NULL;
 229                         ADD_REFS(m2, -1);
 230                         if (GET_REFS(m2) == 0)
 231                                 mark_free(m2);
 232                 }
 233         for (i = 0; i < mpi->nparts; i++) {
 234                 struct pane *p = mpi->parts[i].pane;
 235                 if (p)
 236                         call("doc:closed", p);
 237         }
 238         return Efallthrough;
 239 }
 240
 241 DEF_CMD(mp_free)
 242 {
 243         struct mp_info *mpi = ci->home->doc_data;
 244
 245         free(mpi->parts);
 246         return 1;
 247 }
 248
 249 DEF_CMD(mp_set_ref)
 250 {
 251         struct mp_info *mpi = ci->home->doc_data;
 252         const char *vis = ci->str && (int)strlen(ci->str) >= mpi->nparts ?
 253                 ci->str : NULL;
 254         int ret = 1;
 255
 256         if (!ci->mark)
 257                 return Enoarg;
 258
 259         /* Need to trigger a point:moved notification.  FIXME I wonder
 260          * if this can be simpler
 261          */
 262         mark_step(ci->mark, 0);
 263
 264         if (!ci->mark->ref.m && !ci->mark->ref.docnum) {
 265                 /* First time set-ref was called */
 266                 pre_move(ci->mark);
 267                 change_part(mpi, ci->mark, 0, 0);
 268                 mark_to_end(ci->home, ci->mark, 0);
 269                 post_move(ci->mark);
 270         }
 271         pre_move(ci->mark);
 272
 273         if (ci->num == 1) {
 274                 /* start */
 275                 int n = 0;
 276                 while (n < mpi->nparts && vis && vis[n] == 'i')
 277                         n += 1;
 278                 change_part(mpi, ci->mark, n, 0);
 279                 mp_normalize(mpi, ci->mark, vis);
 280         } else
 281                 change_part(mpi, ci->mark, mpi->nparts, 1);
 282
 283         post_move(ci->mark);
 284         mp_check_consistent(mpi);
 285         return ret;
 286 }
 287
 288 static inline wint_t multipart_next_prev(struct pane *home safe, struct mark *mark safe,
 289                                          struct doc_ref *r safe,
 290                                          int forward, bool bytes, const char *str)
 291 {
 292         int move = r == &mark->ref;
 293         struct mp_info *mpi = home->doc_data;
 294         struct mark *m1 = NULL;
 295         struct mark *m = mark;
 296         const char *vis = str && (int)strlen(str) >= mpi->nparts ?
 297                 str : NULL;
 298         int n;
 299         int ret;
 300
 301         /* Document access commands are handled by the 'cropper'.  First
 302          * we need to substitute the marks, then call the cropper which
 303          * calls the document.  Then make sure the marks are still in
 304          * order.
 305          */
 306
 307         mp_check_consistent(mpi);
 308
 309         if (move) {
 310                 mark_step(m, forward);
 311                 pre_move(m);
 312         }
 313
 314         m1 = m->ref.m;
 315
 316         if (m->ref.docnum >= mpi->nparts)
 317                 ret = -1;
 318         else
 319                 ret = home_call(mpi->parts[m->ref.docnum].pane,
 320                                 "doc:char", home,
 321                                 move ? (forward ? 1 : -1) : 0,
 322                                 m1, str,
 323                                 move ? 0 : (forward ? 1 : -1),
 324                                 NULL, NULL);
 325         while (ret == CHAR_RET(WEOF) || ret == -1) {
 326                 if (!move && m == mark) {
 327                         /* don't change mark when not moving */
 328                         m = mark_dup(m);
 329                         pre_move(m);
 330                 }
 331                 if (forward) {
 332                         if (m->ref.docnum >= mpi->nparts)
 333                                 break;
 334                         n = m->ref.docnum + 1;
 335                         while (n < mpi->nparts && vis && vis[n] == 'i')
 336                                 n += 1;
 337                         change_part(mpi, m, n, 0);
 338                 } else {
 339                         n = m->ref.docnum - 1;
 340                         while (n >= 0 && vis && vis[n] == 'i')
 341                                 n -= 1;
 342                         if (n < 0)
 343                                 break;
 344                         change_part(mpi, m, n, 1);
 345                 }
 346                 m1 = m->ref.m;
 347                 if (m->ref.docnum >= mpi->nparts)
 348                         ret = -1;
 349                 else
 350                         ret = home_call(mpi->parts[m->ref.docnum].pane,
 351                                         "doc:char", home,
 352                                         move ? (forward ? 1 : -1) : 0,
 353                                         m1, str,
 354                                         move ? 0 : (forward ? 1 : -1));
 355         }
 356         if (move) {
 357                 mp_normalize(mpi, mark, vis);
 358                 post_move(mark);
 359         }
 360
 361         if (m != mark)
 362                 mark_free(m);
 363
 364         mp_check_consistent(mpi);
 365         return ret == -1 ? (int)CHAR_RET(WEOF) : ret;
 366 }
 367
 368 DEF_CMD(mp_char)
 369 {
 370         return do_char_byte(ci);
 371 }
 372
 373 DEF_CMD(mp_step_part)
 374 {
 375         /* Step forward or backward to part boundary.
 376          * Stepping forward takes us to start of next part.
 377          * Stepping backward takes us to start of this
 378          * part - we might not move.
 379          * if ->num is -1, step to start of previous part
 380          * Return part number plus 1.
 381          * If ->str is given, only consider visible parts.
 382          */
 383         struct mp_info *mpi = ci->home->doc_data;
 384         struct mark *m = ci->mark;
 385         const char *vis = ci->str && (int)strlen(ci->str) >= mpi->nparts ?
 386                 ci->str : NULL;
 387         int start;
 388         int first_vis;
 389         int n;
 390
 391         if (!m)
 392                 return Enoarg;
 393         pre_move(m);
 394         start = m->ref.docnum;
 395         n = start;
 396         if (ci->num > 0) {
 397                 /* Forward - start of next part */
 398                 n += 1;
 399                 while (n < mpi->nparts && vis && vis[n] == 'i')
 400                         n += 1;
 401         } else if (ci->num < 0) {
 402                 /* Backward - start of prev part */
 403                 n -= 1;
 404                 while (n >= 0 && vis && vis[n] == 'i')
 405                         n -= 1;
 406                 if (n < 0)
 407                         n = m->ref.docnum;
 408         }
 409         /* otherwise start of this part */
 410         change_part(mpi, m, n, 0);
 411
 412         /* If this part is empty, need to move to next visible part */
 413         mp_normalize(mpi, m, vis);
 414         first_vis = 0;
 415         while (vis && vis[first_vis] == 'i')
 416                 first_vis++;
 417         while (ci->num < 0 && m->ref.docnum == start && n > first_vis) {
 418                 /* didn't move - must have an empty part, try further */
 419                 n -= 1;
 420                 change_part(mpi, m, n, 0);
 421                 mp_normalize(mpi, m, vis);
 422         }
 423         post_move(m);
 424         if (ci->num && start == m->ref.docnum)
 425                 return Efail;
 426         return m->ref.docnum + 1;
 427 }
 428
 429 DEF_CMD(mp_get_boundary)
 430 {
 431         /* return a mark past which rendering must not go. */
 432         struct mark *m = ci->mark;
 433
 434         if (!m || !ci->comm2)
 435                 return Enoarg;
 436         m = mark_dup(m);
 437         call("doc:step-part", ci->home, ci->num, m, ci->str);
 438         comm_call(ci->comm2, "cb", ci->focus, 0, m);
 439         return 1;
 440 }
 441
 442 struct mp_cb {
 443         struct command c;
 444         struct command *cb;
 445         struct pane *p safe;
 446         struct mark *m safe;
 447         int last_ret;
 448 };
 449
 450 DEF_CB(mp_content_cb)
 451 {
 452         struct mp_cb *c = container_of(ci->comm, struct mp_cb, c);
 453         struct mark *m1 = NULL;
 454
 455         if (ci->mark) {
 456                 m1 = c->m;
 457                 pre_move(m1);
 458                 if (m1->ref.m)
 459                         mark_to_mark(m1->ref.m, ci->mark);
 460                 post_move(m1);
 461         }
 462
 463         c->last_ret = comm_call(c->cb, ci->key, c->p,
 464                                 ci->num, m1, ci->str,
 465                                 ci->num2, NULL, ci->str2,
 466                                 ci->x, ci->y);
 467         return c->last_ret;
 468 }
 469
 470 DEF_CMD(mp_content)
 471 {
 472         /* Call doc:content on any visible docs in the range.
 473          * Callback must re-wrap any marks
 474          */
 475         struct mp_info *mpi = ci->home->doc_data;
 476         struct mp_cb cb;
 477         struct mark *m, *m2;
 478         const char *invis = ci->str;
 479         int ret = 1;
 480
 481         if (!ci->mark || !ci->comm2)
 482                 return Enoarg;
 483         m = mark_dup(ci->mark);
 484         m2 = ci->mark2;
 485         cb.last_ret = 1;
 486         while (cb.last_ret > 0 && m->ref.docnum < mpi->nparts &&
 487                (!m2 || m->ref.docnum <= m2->ref.docnum)) {
 488                 /* Need to call doc:content on this document */
 489                 int n = m->ref.docnum;
 490                 if ((!invis || invis[n] != 'i') && m->ref.m) {
 491                         struct mark *m2a = NULL;
 492                         struct mark *mtmp = NULL;
 493                         cb.c = mp_content_cb;
 494                         cb.cb = ci->comm2;
 495                         cb.p = ci->focus;
 496                         cb.m = m;
 497
 498                         if (m->ref.m)
 499                                 mtmp = mark_dup(m->ref.m);
 500                         if (m2 && m2->ref.docnum == n && m2->ref.m)
 501                                 m2a = mark_dup(m2->ref.m);
 502
 503                         ret = home_call_comm(mpi->parts[n].pane,
 504                                              ci->key, ci->home, &cb.c,
 505                                              ci->num, mtmp, NULL,
 506                                              ci->num2, m2a);
 507                         mark_free(m2a);
 508                         mark_free(mtmp);
 509                         if (ret < 0)
 510                                 break;
 511                 }
 512                 if (cb.last_ret > 0) {
 513                         pre_move(m);
 514                         change_part(mpi, m, n+1, 0);
 515                         post_move(m);
 516                 }
 517         }
 518         mark_free(m);
 519         return ret;
 520 }
 521
 522 DEF_CMD(mp_attr)
 523 {
 524         struct mp_info *mpi = ci->home->doc_data;
 525         struct mark *m1 = NULL;
 526         struct part *p;
 527         int ret = Efallthrough;
 528         int d;
 529         const char *attr = ci->str;
 530
 531         if (!ci->mark || !attr)
 532                 return Enoarg;
 533
 534         m1 = ci->mark->ref.m;
 535         d = ci->mark->ref.docnum;
 536
 537         if (d < mpi->nparts && m1 && (p = &mpi->parts[d]) &&
 538             p->pane &&  doc_following(p->pane, m1) == WEOF)
 539                 /* at the wrong end of a part */
 540                 d += 1;
 541
 542         if (strstarts(attr, "multipart-next:")) {
 543                 d += 1;
 544                 attr += 15;
 545                 if (d >= mpi->nparts)
 546                         return 1;
 547         } else if (strstarts(attr, "multipart-prev:")) {
 548                 d -= 1;
 549                 attr += 15;
 550                 if (d < 0)
 551                         return 1;
 552         } else if (strstarts(attr, "multipart-this:"))
 553                 attr += 15;
 554
 555         if (strcmp(attr, "multipart:part-num") == 0) {
 556                 char n[11];
 557                 snprintf(n, sizeof(n), "%d", d);
 558                 comm_call(ci->comm2, "callback:get_attr", ci->focus,
 559                           0, ci->mark, n, 0, NULL, attr);
 560                 return 1;
 561         }
 562
 563         if (d >= mpi->nparts || d < 0)
 564                 return 1;
 565
 566         if (attr != ci->str) {
 567                 /* Get a pane attribute, not char attribute */
 568                 char *s = pane_attr_get(mpi->parts[d].pane, attr);
 569                 if (s)
 570                         return comm_call(ci->comm2, "callback", ci->focus,
 571                                          0, ci->mark, s, 0, NULL, ci->str);
 572                 return 1;
 573         }
 574
 575         p = &mpi->parts[d];
 576         if (d != ci->mark->ref.docnum && p->pane) {
 577                 m1 = mark_new(p->pane);
 578                 call("doc:set-ref", p->pane,
 579                      (d > ci->mark->ref.docnum), m1);
 580         }
 581
 582         if (p->pane)
 583                 ret = home_call(p->pane,
 584                                 ci->key, ci->focus, ci->num, m1, ci->str,
 585                                 ci->num2, NULL, ci->str2, 0,0, ci->comm2);
 586         if (d != ci->mark->ref.docnum)
 587                 mark_free(m1);
 588         return ret;
 589 }
 590
 591 DEF_CMD(mp_set_attr)
 592 {
 593         struct mp_info *mpi = ci->home->doc_data;
 594         struct part *p;
 595         struct mark *m = ci->mark;
 596         struct mark *m1;
 597         int dn;
 598         const char *attr = ci->str;
 599
 600         if (!attr)
 601                 return Enoarg;
 602         if (!m)
 603                 return Efallthrough;
 604         dn = m->ref.docnum;
 605         m1 = m->ref.m;
 606
 607         if (strstarts(attr, "multipart-")) {
 608                 /* Set an attribute on a part */
 609                 if (strstarts(attr, "multipart-prev:") &&
 610                     dn > 0 && (p = &mpi->parts[dn-1]) && p->pane)
 611                         attr_set_str(&p->pane->attrs,
 612                                      attr+15, ci->str2);
 613                 else if (strstarts(attr, "multipart-next:") &&
 614                          dn < mpi->nparts && (p = &mpi->parts[dn+1]) && p->pane)
 615                         attr_set_str(&p->pane->attrs,
 616                                      attr+15, ci->str2);
 617                 else if (strstarts(attr, "multipart-this:") &&
 618                          (p = &mpi->parts[dn]) && p->pane)
 619                         attr_set_str(&p->pane->attrs,
 620                                      attr+15, ci->str2);
 621                 else
 622                         return Efail;
 623                 return 1;
 624         }
 625         /* Send the request to a sub-document */
 626         p = &mpi->parts[dn];
 627         if (p->pane)
 628                 return call(ci->key, p->pane, ci->num, m1, ci->str,
 629                             0, NULL, ci->str2);
 630         return Efail;
 631 }
 632
 633 DEF_CMD(mp_notify_close)
 634 {
 635         /* sub-document has been closed.
 636          * Can we survive? or should we just shut down?
 637          */
 638         struct mp_info *mpi = ci->home->doc_data;
 639         int i;
 640
 641         for (i = 0; i < mpi->nparts; i++)
 642                 if (mpi->parts[i].pane == ci->focus) {
 643                         /* sub-document has been closed.
 644                          * Can we survive? or should we just shut down?
 645                          */
 646                         mpi->parts[i].pane = NULL;
 647                         pane_close(ci->home);
 648                         return 1;
 649                 }
 650         /* Not a sub-pane, maybe an owner for vmarks */
 651         return Efallthrough;
 652 }
 653
 654 DEF_CMD(mp_notify_viewers)
 655 {
 656         /* The autoclose document wants to know if it should close.
 657          * tell it "no" */
 658         return 1;
 659 }
 660
 661 DEF_CMD(mp_doc_replaced)
 662 {
 663         /* Something changed in a component, report that the
 664          * whole doc changed - simplest for now.
 665          */
 666         pane_notify("doc:replaced", ci->home);
 667         return 1;
 668 }
 669
 670 static void mp_resize(struct mp_info *mpi safe, int size)
 671 {
 672         if (mpi->parts_size >= size)
 673                 return;
 674         size += 4;
 675         mpi->parts = realloc(mpi->parts, size * sizeof(struct part));
 676         mpi->parts_size = size;
 677 }
 678
 679 DEF_CMD(mp_add)
 680 {
 681         struct mp_info *mpi = ci->home->doc_data;
 682         struct mark *m;
 683         int n;
 684
 685         mp_resize(mpi, mpi->nparts+1);
 686         if (ci->mark == NULL)
 687                 n = mpi->nparts;
 688         else
 689                 n = ci->mark->ref.docnum;
 690         memmove(&mpi->parts[n+1], &mpi->parts[n],
 691                 (mpi->nparts - n)*sizeof(mpi->parts[0]));
 692         mpi->nparts += 1;
 693         mpi->parts[n].pane = ci->focus;
 694         hlist_for_each_entry(m, &mpi->doc.marks, all)
 695                 if (m->ref.docnum >= n)
 696                         m->ref.docnum ++;
 697         if (ci->mark)
 698                 /* move mark to start of new part */
 699                 change_part(mpi, ci->mark, n, 0);
 700
 701         pane_add_notify(ci->home, ci->focus, "Notify:Close");
 702         home_call(ci->focus, "doc:request:doc:notify-viewers", ci->home);
 703         home_call(ci->focus, "doc:request:doc:replaced", ci->home);
 704
 705         return 1;
 706 }
 707
 708 DEF_CMD(mp_forward_by_num)
 709 {
 710         struct mp_info *mpi = ci->home->doc_data;
 711         struct mark *m1 = NULL, *m2 = NULL;
 712         struct part *p;
 713         const char *key;
 714         int d;
 715         int ret;
 716
 717         key = ksuffix(ci, "doc:multipart-");
 718         d = atoi(key);
 719         key = strchr(key, '-');
 720         if (!key)
 721                 return Einval;
 722         key += 1;
 723
 724         if (d >= mpi->nparts || d < 0)
 725                 return 1;
 726
 727         if (ci->mark && ci->mark->ref.docnum == d)
 728                 m1 = ci->mark->ref.m;
 729         if (ci->mark2 && ci->mark2->ref.docnum == d)
 730                 m2 = ci->mark2->ref.m;
 731
 732         p = &mpi->parts[d];
 733         if (p->pane)
 734                 ret = call(key, p->pane, ci->num, m1, ci->str,
 735                            ci->num2, m2, ci->str2, ci->x, ci->y, ci->comm2);
 736         else
 737                 ret = Efail;
 738         return ret;
 739 }
 740
 741 DEF_CMD(mp_get_part)
 742 {
 743         struct mp_info *mpi = ci->home->doc_data;
 744         struct part *p;
 745         int d = ci->num;
 746
 747         if (d < 0 || d >= mpi->nparts)
 748                 return Einval;
 749         p = &mpi->parts[d];
 750         if (p->pane)
 751                 comm_call(ci->comm2, "cb", p->pane);
 752         return 1;
 753 }
 754
 755 DEF_CMD(mp_forward)
 756 {
 757         /* forward this command to this/next/prev document based on
 758          * ci->mark2.
 759          * ci->mark is forwarded if it is in same document
 760          */
 761         struct mp_info *mpi = ci->home->doc_data;
 762         struct part *p;
 763         struct mark *m1, *m2;
 764         const char *key;
 765         int d;
 766
 767         if (!ci->mark2)
 768                 return Enoarg;
 769
 770         m2 = ci->mark2->ref.m;
 771         d = ci->mark2->ref.docnum;
 772
 773         if (d < mpi->nparts && m2 && (p = &mpi->parts[d]) && p->pane &&
 774             doc_following(p->pane, m2) == WEOF)
 775                 /* at the wrong end of a part */
 776                 d += 1;
 777
 778         if ((key = ksuffix(ci, "multipart-next:"))[0]) {
 779                 d += 1;
 780                 if (d >= mpi->nparts)
 781                         return 1;
 782         } else if ((key = ksuffix(ci, "multipart-prev:"))[0]) {
 783                 d -= 1;
 784                 if (d < 0)
 785                         return 1;
 786         } else if ((key = ksuffix(ci, "multipart-this:"))[0]) {
 787                 ;
 788         } else return Einval;
 789
 790         if (d >= mpi->nparts || d < 0)
 791                 return 1;
 792
 793         m1 = NULL;
 794         if (ci->mark && ci->mark->ref.docnum == d)
 795                 m1 = ci->mark->ref.m;
 796         p = &mpi->parts[d];
 797         if (p->pane)
 798                 return call(key, p->pane, ci->num, m1, ci->str,
 799                             ci->num2, NULL, ci->str2, 0,0, ci->comm2);
 800         return Efail;
 801 }
 802
 803 DEF_CMD(mp_val_marks)
 804 {
 805         struct mark *m1, *m2;
 806
 807         if (!ci->mark || !ci->mark2)
 808                 return Enoarg;
 809
 810         if (ci->mark->ref.docnum < ci->mark2->ref.docnum)
 811                 return 1;
 812         if (ci->mark->ref.docnum > ci->mark2->ref.docnum) {
 813                 LOG("mp_val_marks: docs not in order");
 814                 return Efalse;
 815         }
 816
 817         m1 = ci->mark->ref.m;
 818         m2 = ci->mark->ref.m;
 819         if (m1 == m2)
 820                 return 1;
 821         if (m1 && m2 && m1->seq > m2->seq) {
 822                 LOG("mp_val_marks: subordinate marks out of order!");
 823                 return Efalse;
 824         }
 825         if (!m1)
 826                 LOG("mp_val_marks: m1 is NULL");
 827         else if (!m2 || marks_validate(m1, m2))
 828                 return 1;
 829         return Efalse;
 830 }
 831
 832 static void mp_init_map(void)
 833 {
 834         mp_map = key_alloc();
 835         key_add_chain(mp_map, doc_default_cmd);
 836         key_add(mp_map, "doc:set-ref", &mp_set_ref);
 837         key_add(mp_map, "doc:char", &mp_char);
 838         key_add(mp_map, "doc:content", &mp_content);
 839         key_add(mp_map, "doc:content-bytes", &mp_content);
 840         key_add(mp_map, "doc:get-attr", &mp_attr);
 841         key_add(mp_map, "doc:set-attr", &mp_set_attr);
 842         key_add(mp_map, "doc:step-part", &mp_step_part);
 843         key_add(mp_map, "doc:get-boundary", &mp_get_boundary);
 844         key_add(mp_map, "Close", &mp_close);
 845         key_add(mp_map, "Free", &mp_free);
 846         key_add(mp_map, "Notify:Close", &mp_notify_close);
 847         key_add(mp_map, "doc:notify-viewers", &mp_notify_viewers);
 848         key_add(mp_map, "doc:replaced", &mp_doc_replaced);
 849         key_add(mp_map, "multipart-add", &mp_add);
 850         key_add(mp_map, "debug:validate-marks", &mp_val_marks);
 851         key_add(mp_map, "doc:multipart:get-part", &mp_get_part);
 852         key_add_prefix(mp_map, "multipart-this:", &mp_forward);
 853         key_add_prefix(mp_map, "multipart-next:", &mp_forward);
 854         key_add_prefix(mp_map, "multipart-prev:", &mp_forward);
 855         key_add_prefix(mp_map, "doc:multipart-", &mp_forward_by_num);
 856 }
 857 DEF_LOOKUP_CMD(mp_handle, mp_map);
 858
 859 DEF_CMD(attach_mp)
 860 {
 861         struct mp_info *mpi;
 862         struct pane *h;
 863
 864         h = doc_register(ci->home, &mp_handle.c);
 865         if (!h)
 866                 return Efail;
 867         mpi = h->doc_data;
 868
 869         mpi->doc.refcnt = mp_mark_refcnt;
 870         attr_set_str(&h->attrs, "render-default", "text");
 871         return comm_call(ci->comm2, "callback:doc", h);
 872 }
 873
 874 void edlib_init(struct pane *ed safe)
 875 {
 876         mp_init_map();
 877         call_comm("global-set-command", ed, &attach_mp, 0, NULL,
 878                   "attach-doc-multipart");
 879 }