[BACK]Return to cmd-swap-pane.c CVS log [TXT][DIR] Up to [local] / src / usr.bin / tmux

Diff for /src/usr.bin/tmux/cmd-swap-pane.c between version 1.7 and 1.8

version 1.7, 2009/07/26 12:58:44 version 1.8, 2009/07/30 13:45:56
Line 26 
Line 26 
  * Swap two panes.   * Swap two panes.
  */   */
   
 int     cmd_swap_pane_parse(struct cmd *, int, char **, char **);  
 int     cmd_swap_pane_exec(struct cmd *, struct cmd_ctx *);  
 void    cmd_swap_pane_free(struct cmd *);  
 void    cmd_swap_pane_init(struct cmd *, int);  void    cmd_swap_pane_init(struct cmd *, int);
 size_t  cmd_swap_pane_print(struct cmd *, char *, size_t);  int     cmd_swap_pane_exec(struct cmd *, struct cmd_ctx *);
   
 struct cmd_swap_pane_data {  
         char    *target;  
         int      src;  
         int      dst;  
         int      flag_detached;  
         int      flag_up;  
         int      flag_down;  
 };  
   
 const struct cmd_entry cmd_swap_pane_entry = {  const struct cmd_entry cmd_swap_pane_entry = {
         "swap-pane", "swapp",          "swap-pane", "swapp",
         "[-dDU] [-t target-window] [-p src-index] [-q dst-index]",          "[-dDU] " CMD_SRCDST_PANE_USAGE,
         0, 0,          0, CMD_CHFLAG('d')|CMD_CHFLAG('D')|CMD_CHFLAG('U'),
         cmd_swap_pane_init,          cmd_swap_pane_init,
         cmd_swap_pane_parse,          cmd_srcdst_parse,
         cmd_swap_pane_exec,          cmd_swap_pane_exec,
         cmd_swap_pane_free,          cmd_srcdst_free,
         cmd_swap_pane_print          cmd_srcdst_print
 };  };
   
 void  void
 cmd_swap_pane_init(struct cmd *self, int key)  cmd_swap_pane_init(struct cmd *self, int key)
 {  {
         struct cmd_swap_pane_data        *data;          struct cmd_target_data  *data;
   
         self->data = data = xmalloc(sizeof *data);          cmd_srcdst_init(self, key);
         data->target = NULL;  
         data->src = -1;  
         data->dst = -1;  
         data->flag_detached = 0;  
         data->flag_up = 0;  
         data->flag_down = 0;  
   
         switch (key) {  
         case '{':  
                 data->flag_up = 1;  
                 break;  
         case '}':  
                 data->flag_down = 1;  
                 break;  
         }  
 }  
   
 int  
 cmd_swap_pane_parse(struct cmd *self, int argc, char **argv, char **cause)  
 {  
         struct cmd_swap_pane_data       *data;  
         int                              opt, n;  
         const char                      *errstr;  
   
         self->entry->init(self, 0);  
         data = self->data;          data = self->data;
   
         while ((opt = getopt(argc, argv, "dDt:p:q:U")) != -1) {          if (key == '{')
                 switch (opt) {                  data->chflags |= CMD_CHFLAG('U');
                 case 'd':          else if (key == '}')
                         data->flag_detached = 1;                  data->chflags |= CMD_CHFLAG('D');
                         break;  
                 case 'D':  
                         data->flag_up = 0;  
                         data->flag_down = 1;  
                         data->dst = -1;  
                         break;  
                 case 't':  
                         if (data->target == NULL)  
                                 data->target = xstrdup(optarg);  
                         break;  
                 case 'p':  
                         if (data->src == -1) {  
                                 n = strtonum(optarg, 0, INT_MAX, &errstr);  
                                 if (errstr != NULL) {  
                                         xasprintf(cause, "src %s", errstr);  
                                         goto error;  
                                 }  
                                 data->src = n;  
                         }  
                         break;  
                 case 'q':  
                         if (data->dst == -1) {  
                                 n = strtonum(optarg, 0, INT_MAX, &errstr);  
                                 if (errstr != NULL) {  
                                         xasprintf(cause, "dst %s", errstr);  
                                         goto error;  
                                 }  
                                 data->dst = n;  
                         }  
                         data->flag_up = 0;  
                         data->flag_down = 0;  
                         break;  
                 case 'U':  
                         data->flag_up = 1;  
                         data->flag_down = 0;  
                         data->dst = -1;  
                         break;  
   
                 default:  
                         goto usage;  
                 }  
         }  
         argc -= optind;  
         argv += optind;  
         if (argc != 0)  
                 goto usage;  
   
         return (0);  
   
 usage:  
         xasprintf(cause, "usage: %s %s", self->entry->name, self->entry->usage);  
   
 error:  
         self->entry->free(self);  
         return (-1);  
 }  }
   
 int  int
 cmd_swap_pane_exec(struct cmd *self, struct cmd_ctx *ctx)  cmd_swap_pane_exec(struct cmd *self, struct cmd_ctx *ctx)
 {  {
         struct cmd_swap_pane_data       *data = self->data;          struct cmd_srcdst_data  *data = self->data;
         struct winlink                  *wl;          struct winlink          *src_wl, *dst_wl;
         struct window                   *w;          struct window           *src_w, *dst_w;
         struct window_pane              *tmp_wp, *src_wp, *dst_wp;          struct window_pane      *tmp_wp, *src_wp, *dst_wp;
         struct layout_cell              *lc;          struct layout_cell      *src_lc, *dst_lc;
         u_int                            sx, sy, xoff, yoff;          u_int                    sx, sy, xoff, yoff;
   
         if (data == NULL)          if (data == NULL)
                 return (0);                  return (0);
   
         if ((wl = cmd_find_window(ctx, data->target, NULL)) == NULL)          if ((dst_wl = cmd_find_pane(ctx, data->dst, NULL, &dst_wp)) == NULL)
                 return (-1);                  return (-1);
         w = wl->window;          dst_w = dst_wl->window;
   
         if (data->src == -1)          if (data->src == NULL) {
                 src_wp = w->active;                  src_wl = dst_wl;
         else {                  src_w = dst_w;
                 src_wp = window_pane_at_index(w, data->src);                  if (data->chflags & CMD_CHFLAG('D')) {
                 if (src_wp == NULL) {                          src_wp = TAILQ_NEXT(dst_wp, entry);
                         ctx->error(ctx, "no pane: %d", data->src);                          if (src_wp == NULL)
                                   src_wp = TAILQ_FIRST(&dst_w->panes);
                   } else if (data->chflags & CMD_CHFLAG('U')) {
                           src_wp = TAILQ_PREV(dst_wp, window_panes, entry);
                           if (src_wp == NULL)
                                   src_wp = TAILQ_LAST(&dst_w->panes, window_panes);
                   } else
                           return (0);
           } else {
                   src_wl = cmd_find_pane(ctx, data->src, NULL, &src_wp);
                   if (src_wl == NULL)
                         return (-1);                          return (-1);
                 }                  src_w = src_wl->window;
         }          }
         if (data->dst == -1)  
                 dst_wp = w->active;  
         else {  
                 dst_wp = window_pane_at_index(w, data->dst);  
                 if (dst_wp == NULL) {  
                         ctx->error(ctx, "no pane: %d", data->dst);  
                         return (-1);  
                 }  
         }  
   
         if (data->dst == -1 && data->flag_up) {  
                 if ((dst_wp = TAILQ_PREV(src_wp, window_panes, entry)) == NULL)  
                         dst_wp = TAILQ_LAST(&w->panes, window_panes);  
         }  
         if (data->dst == -1 && data->flag_down) {  
                 if ((dst_wp = TAILQ_NEXT(src_wp, entry)) == NULL)  
                         dst_wp = TAILQ_FIRST(&w->panes);  
         }  
   
         if (src_wp == dst_wp)          if (src_wp == dst_wp)
                 return (0);                  return (0);
   
         tmp_wp = TAILQ_PREV(dst_wp, window_panes, entry);          tmp_wp = TAILQ_PREV(dst_wp, window_panes, entry);
         TAILQ_REMOVE(&w->panes, dst_wp, entry);          TAILQ_REMOVE(&dst_w->panes, dst_wp, entry);
         TAILQ_REPLACE(&w->panes, src_wp, dst_wp, entry);          TAILQ_REPLACE(&src_w->panes, src_wp, dst_wp, entry);
         if (tmp_wp == src_wp)          if (tmp_wp == src_wp)
                 tmp_wp = dst_wp;                  tmp_wp = dst_wp;
         if (tmp_wp == NULL)          if (tmp_wp == NULL)
                 TAILQ_INSERT_HEAD(&w->panes, src_wp, entry);                  TAILQ_INSERT_HEAD(&dst_w->panes, src_wp, entry);
         else          else
                 TAILQ_INSERT_AFTER(&w->panes, tmp_wp, src_wp, entry);                  TAILQ_INSERT_AFTER(&dst_w->panes, tmp_wp, src_wp, entry);
   
         lc = src_wp->layout_cell;          src_lc = src_wp->layout_cell;
         src_wp->layout_cell = dst_wp->layout_cell;          dst_lc = dst_wp->layout_cell;
         if (src_wp->layout_cell != NULL)          src_lc->wp = dst_wp;
                 src_wp->layout_cell->wp = src_wp;          dst_wp->layout_cell = src_lc;
         dst_wp->layout_cell = lc;          dst_lc->wp = src_wp;
         if (dst_wp->layout_cell != NULL)          src_wp->layout_cell = dst_lc;
                 dst_wp->layout_cell->wp = dst_wp;  
           src_wp->window = dst_w;
           dst_wp->window = src_w;
   
         sx = src_wp->sx; sy = src_wp->sy;          sx = src_wp->sx; sy = src_wp->sy;
         xoff = src_wp->xoff; yoff = src_wp->yoff;          xoff = src_wp->xoff; yoff = src_wp->yoff;
Line 219 
Line 121 
         dst_wp->xoff = xoff; dst_wp->yoff = yoff;          dst_wp->xoff = xoff; dst_wp->yoff = yoff;
         window_pane_resize(dst_wp, sx, sy);          window_pane_resize(dst_wp, sx, sy);
   
         if (!data->flag_detached) {          if (!(data->chflags & CMD_CHFLAG('d'))) {
                 tmp_wp = dst_wp;                  if (src_w != dst_w) {
                 if (!window_pane_visible(tmp_wp))                          window_set_active_pane(src_w, dst_wp);
                         tmp_wp = src_wp;                          window_set_active_pane(dst_w, src_wp);
                 window_set_active_pane(w, tmp_wp);                  } else {
                           tmp_wp = dst_wp;
                           if (!window_pane_visible(tmp_wp))
                                   tmp_wp = src_wp;
                           window_set_active_pane(src_w, tmp_wp);
                   }
           } else {
                   if (src_w->active == src_wp)
                           window_set_active_pane(src_w, dst_wp);
                   if (dst_w->active == dst_wp)
                           window_set_active_pane(dst_w, src_wp);
         }          }
         server_redraw_window(w);          server_redraw_window(src_w);
           server_redraw_window(dst_w);
   
         return (0);          return (0);
 }  
   
 void  
 cmd_swap_pane_free(struct cmd *self)  
 {  
         struct cmd_swap_pane_data       *data = self->data;  
   
         if (data->target != NULL)  
                 xfree(data->target);  
         xfree(data);  
 }  
   
 size_t  
 cmd_swap_pane_print(struct cmd *self, char *buf, size_t len)  
 {  
         struct cmd_swap_pane_data       *data = self->data;  
         size_t                           off = 0;  
   
         off += xsnprintf(buf, len, "%s", self->entry->name);  
         if (data == NULL)  
                 return (off);  
         if (off < len &&  
             (data->flag_down || data->flag_up || data->flag_detached)) {  
                 off += xsnprintf(buf + off, len - off, " -");  
                 if (off < len && data->flag_detached)  
                         off += xsnprintf(buf + off, len - off, "d");  
                 if (off < len && data->flag_up)  
                         off += xsnprintf(buf + off, len - off, "D");  
                 if (off < len && data->flag_down)  
                         off += xsnprintf(buf + off, len - off, "U");  
         }  
         if (off < len && data->target != NULL)  
                 off += cmd_prarg(buf + off, len - off, " -t ", data->target);  
         if (off < len && data->src != -1)  
                 off += xsnprintf(buf + off, len - off, " -p %d", data->src);  
         if (off < len && data->dst != -1)  
                 off += xsnprintf(buf + off, len - off, " -q %d", data->dst);  
         return (off);  
 }  }
Legend:
Removed from v.1.7  
changed lines
  Added in v.1.8