Adding upstream version 4.6.2.upstream/4.6.2upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 708 insertions, 0 deletions

diff --git a/list_window.c b/list_window.c
new file mode 100644
index 0000000..4dec643
--- /dev/null
+++ b/list_window.c
@@ -0,0 +1,708 @@
+/* Copyright (c) 2010
+ *      Juergen Weigert (jnweiger@immd4.informatik.uni-erlangen.de)
+ *      Sadrul Habib Chowdhury (sadrul@users.sourceforge.net)
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program (see the file COPYING); if not, see
+ * http://www.gnu.org/licenses/, or contact Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA
+ *
+ ****************************************************************
+ */
+
+/* Deals with the list of windows */
+
+/* NOTE: A 'struct win *' is used as the 'data' for each row. It might make more sense
+ * to use 'struct win* ->w_number' as the 'data', instead, because that way, we can
+ * verify that the window does exist (by looking at wtab[]).
+ */
+
+#include "config.h"
+#include "screen.h"
+#include "layer.h"
+#include "extern.h"
+#include "list_generic.h"
+
+extern struct layer *flayer;
+extern struct display *display, *displays;
+
+extern char *wlisttit;
+extern char *wliststr;
+
+extern struct mchar mchar_blank, mchar_so;
+extern int renditions[];
+
+extern struct win **wtab, *windows, *fore;
+extern int maxwin;
+
+extern char *noargs[];
+
+static char ListID[] = "window";
+
+struct gl_Window_Data
+{
+  struct win *group;	/* Set only for a W_TYPE_GROUP window */
+  int order;		/* MRU? NUM? */
+  int onblank;
+  int nested;
+  struct win *fore;	/* The foreground window we had. */
+};
+
+/* Is this wdata for a group window? */
+#define WLIST_FOR_GROUP(wdate)	((wdata)->group && !(wdata)->onblank && Layer2Window(flayer) && Layer2Window(flayer)->w_type == W_TYPE_GROUP)
+
+/* This macro should not be used if 'fn' is expected to update the window list */
+#define FOR_EACH_WINDOW(_wdata, _w, fn) do {	\
+    if ((_wdata)->order == WLIST_MRU)	\
+      {	\
+	struct win *_ww;	\
+	for (_ww = windows; _ww; _ww = _ww->w_next)	\
+	  {	\
+	    _w = _ww;	\
+	    fn	\
+	  }	\
+      }	\
+    else	\
+      {	\
+	struct win **_ww, *_witer;	\
+	for (_ww = wtab, _witer = windows; _witer && _ww - wtab < maxwin; _ww++)	\
+	  {	\
+	    if (!(_w = *_ww))	continue;	\
+	    fn	\
+	    _witer = _witer->w_next;	\
+	  }	\
+      }	\
+  } while (0)
+
+/* Is 'a' an ancestor of 'd'? */
+static int
+window_ancestor(struct win *a, struct win *d)
+{
+  if (!a)
+    return 1;	/* Every window is a descendant of the 'null' group */
+  for (; d; d = d->w_group)
+    if (d->w_group == a)
+      return 1;
+  return 0;
+}
+
+static void
+window_kill_confirm(char *buf, int len, char *data)
+{
+  struct win *w = windows;
+  struct action act;
+
+  if (len || (*buf != 'y' && *buf != 'Y'))
+    {
+      *buf = 0;
+      return;
+    }
+
+  /* Loop over the windows to make sure that the window actually still exists. */
+  for (; w; w = w->w_next)
+    if (w == (struct win *)data)
+      break;
+
+  if (!w)
+    return;
+
+  /* Pretend the selected window is the foreground window. Then trigger a non-interactive 'kill' */
+  fore = w;
+  act.nr = RC_KILL;
+  act.args = noargs;
+  act.argl = 0;
+  act.quiet = 0;
+  DoAction(&act, -1);
+}
+
+static struct ListRow *
+gl_Window_add_group(struct ListData *ldata, struct ListRow *row)
+{
+  /* Right now, 'row' doesn't have any child. */
+  struct gl_Window_Data *wdata = ldata->data;
+  struct win *group = row->data, *w;
+  struct ListRow *cur = row;
+
+  ASSERT(wdata->nested);
+
+  FOR_EACH_WINDOW(wdata, w,
+    if (w->w_group != group)
+      continue;
+
+    cur = glist_add_row(ldata, w, cur);
+    if (w == wdata->fore)
+      ldata->selected = cur;
+
+    if (w->w_type == W_TYPE_GROUP)
+      cur = gl_Window_add_group(ldata, cur);
+  );
+
+  return cur;
+}
+
+static void
+gl_Window_rebuild(struct ListData *ldata)
+{
+  struct ListRow *row = NULL;
+  struct gl_Window_Data *wdata = ldata->data;
+  struct win *w;
+
+  FOR_EACH_WINDOW(wdata, w,
+    if (w->w_group != wdata->group)
+      continue;
+    row = glist_add_row(ldata, w, row);
+    if (w == wdata->fore)
+      ldata->selected = row;
+    if (w->w_type == W_TYPE_GROUP && wdata->nested)
+      row = gl_Window_add_group(ldata, row);
+  );
+  glist_display_all(ldata);
+}
+
+static struct ListRow *
+gl_Window_findrow(struct ListData *ldata, struct win *p)
+{
+  struct ListRow *row = ldata->root;
+  for (; row; row = row->next)
+    {
+      if (row->data == p)
+	break;
+    }
+  return row;
+}
+
+static int
+gl_Window_remove(struct ListData *ldata, struct win *p)
+{
+  struct ListRow *row = gl_Window_findrow(ldata, p);
+  if (!row)
+    return 0;
+
+  /* Remove 'row'. Update 'selected', 'top', 'root' if necessary. */
+  if (row->next)
+    row->next->prev = row->prev;
+  if (row->prev)
+    row->prev->next = row->next;
+
+  if (ldata->selected == row)
+    ldata->selected = row->prev ? row->prev : row->next;
+  if (ldata->top == row)
+    ldata->top = row->prev ? row->prev : row->next;
+  if (ldata->root == row)
+    ldata->root = row->next;
+
+  ldata->list_fn->gl_freerow(ldata, row);
+  free(row);
+
+  return 1;
+}
+
+static int
+gl_Window_header(struct ListData *ldata)
+{
+  char *str;
+  struct gl_Window_Data *wdata = ldata->data;
+  int g;
+
+  if ((g = (wdata->group != NULL)))
+    {
+      LPutWinMsg(flayer, "Group: ", 7, &mchar_blank, 0, 0);
+      LPutWinMsg(flayer, wdata->group->w_title, strlen(wdata->group->w_title), &mchar_blank, 7, 0);
+    }
+
+  str = MakeWinMsgEv(wlisttit, (struct win *)0, '%', flayer->l_width, (struct event *)0, 0);
+
+  LPutWinMsg(flayer, str, strlen(str), &mchar_blank, 0, g);
+  return 2 + g;
+}
+
+static int
+gl_Window_footer(struct ListData *ldata)
+{
+  return 0;
+}
+
+static int
+gl_Window_row(struct ListData *ldata, struct ListRow *lrow)
+{
+  char *str;
+  struct win *w, *g;
+  int xoff;
+  struct mchar *mchar;
+  struct mchar mchar_rend = mchar_blank;
+  struct gl_Window_Data *wdata = ldata->data;
+
+  w = lrow->data;
+
+  /* First, make sure we want to display this window in the list.
+   * If we are showing a list for a group, and not on blank, then we must
+   * only show the windows directly belonging to that group.
+   * Otherwise, do some more checks. */
+
+  for (xoff = 0, g = w->w_group; g != wdata->group; g = g->w_group)
+    xoff += 2;
+  str = MakeWinMsgEv(wliststr, w, '%', flayer->l_width - xoff, NULL, 0);
+  if (ldata->selected == lrow)
+    mchar = &mchar_so;
+  else if (w->w_monitor == MON_DONE && renditions[REND_MONITOR] != -1)
+    {
+      mchar = &mchar_rend;
+      ApplyAttrColor(renditions[REND_MONITOR], mchar);
+    }
+  else if ((w->w_bell == BELL_DONE || w->w_bell == BELL_FOUND) && renditions[REND_BELL] != -1)
+    {
+      mchar = &mchar_rend;
+      ApplyAttrColor(renditions[REND_BELL], mchar);
+    }
+  else if ((w->w_silence == SILENCE_FOUND || w->w_silence == SILENCE_DONE) && renditions[REND_SILENCE] != -1)
+    {
+      mchar = &mchar_rend;
+      ApplyAttrColor(renditions[REND_SILENCE], mchar);
+    }
+  else
+    mchar = &mchar_blank;
+
+  LPutWinMsg(flayer, str, flayer->l_width, mchar, xoff, lrow->y);
+  if (xoff)
+    LPutWinMsg(flayer, "", xoff, mchar, 0, lrow->y);
+
+  return 1;
+}
+
+static int
+gl_Window_input(struct ListData *ldata, char **inp, int *len)
+{
+  struct win *win;
+  unsigned char ch;
+  struct display *cd = display;
+  struct gl_Window_Data *wdata = ldata->data;
+
+  if (!ldata->selected)
+    return 0;
+
+  ch = (unsigned char) **inp;
+  ++*inp;
+  --*len;
+
+  win = ldata->selected->data;
+  switch (ch)
+    {
+    case ' ':
+    case '\n':
+    case '\r':
+      if (!win)
+	break;
+#ifdef MULTIUSER
+      if (display && AclCheckPermWin(D_user, ACL_READ, win))
+	return 0;		/* Not allowed to switch to this window. */
+#endif
+      if (WLIST_FOR_GROUP(wdata))
+	SwitchWindow(win->w_number);
+      else
+	{
+	  /* Abort list only when not in a group window. */
+	  glist_abort();
+	  display = cd;
+	  if (D_fore != win)
+	    SwitchWindow(win->w_number);
+	}
+      *len = 0;
+      break;
+
+    case 'm':
+      /* Toggle MRU-ness */
+      wdata->order = wdata->order == WLIST_MRU ? WLIST_NUM : WLIST_MRU;
+      glist_remove_rows(ldata);
+      gl_Window_rebuild(ldata);
+      break;
+
+    case 'g':
+      /* Toggle nestedness */
+      wdata->nested = !wdata->nested;
+      glist_remove_rows(ldata);
+      gl_Window_rebuild(ldata);
+      break;
+
+    case 'a':
+      /* All-window view */
+      if (wdata->group)
+	{
+	  int order = wdata->order | (wdata->nested ? WLIST_NESTED : 0);
+	  glist_abort();
+	  display = cd;
+	  display_windows(1, order, NULL);
+	  *len = 0;
+	}
+      else if (!wdata->nested)
+	{
+	  wdata->nested = 1;
+	  glist_remove_rows(ldata);
+	  gl_Window_rebuild(ldata);
+	}
+      break;
+
+    case 010:	/* ^H */
+    case 0177:	/* Backspace */
+      if (!wdata->group)
+	break;
+      if (wdata->group->w_group)
+	{
+	  /* The parent is another group window. So switch to that window. */
+	  struct win *g = wdata->group->w_group;
+	  glist_abort();
+	  display = cd;
+	  SetForeWindow(g);
+	  *len = 0;
+	}
+      else
+	{
+	  /* We were in a group view. Now we are moving to an all-window view.
+	   * So treat it as 'windowlist on blank'. */
+	  int order = wdata->order | (wdata->nested ? WLIST_NESTED : 0);
+	  glist_abort();
+	  display = cd;
+	  display_windows(1, order, NULL);
+	  *len = 0;
+	}
+      break;
+
+    case ',':	/* Switch numbers with the previous window. */
+      if (wdata->order == WLIST_NUM && ldata->selected->prev)
+	{
+	  struct win *pw = ldata->selected->prev->data;
+	  if (win->w_group != pw->w_group)
+	    break;	/* Do not allow switching with the parent group */
+
+	  /* When a windows's number is successfully changed, it triggers a WListUpdatecv
+	   * with NULL window. So that causes a redraw of the entire list. So reset the
+	   * 'selected' after that. */
+	  wdata->fore = win;
+	  WindowChangeNumber(win->w_number, pw->w_number);
+	}
+      break;
+
+    case '.':	/* Switch numbers with the next window. */
+      if (wdata->order == WLIST_NUM && ldata->selected->next)
+	{
+	  struct win *nw = ldata->selected->next->data;
+	  if (win->w_group != nw->w_group)
+	    break;	/* Do not allow switching with the parent group */
+
+	  wdata->fore = win;
+	  WindowChangeNumber(win->w_number, nw->w_number);
+	}
+      break;
+
+    case 'K':	/* Kill a window */
+      {
+	char str[MAXSTR];
+	snprintf(str, sizeof(str) - 1, "Really kill window %d (%s) [y/n]",
+	    win->w_number, win->w_title);
+	Input(str, 1, INP_RAW, window_kill_confirm, (char *)win, 0);
+      }
+      break;
+
+    case 033:	/* escape */
+    case 007:	/* ^G */
+      if (!WLIST_FOR_GROUP(wdata))
+	{
+	  int fnumber = wdata->onblank ? wdata->fore->w_number : -1;
+	  glist_abort();
+	  display = cd;
+	  if (fnumber >= 0)
+	    SwitchWindow(fnumber);
+	  *len = 0;
+	}
+      break;
+    default:
+      if (ch >= '0' && ch <= '9')
+	{
+	  struct ListRow *row = ldata->root;
+	  for (; row; row = row->next)
+	    {
+	      struct win *w = row->data;
+	      if (w->w_number == ch - '0')
+		{
+		  struct ListRow *old = ldata->selected;
+		  if (old == row)
+		    break;
+		  ldata->selected = row;
+		  if (ldata->selected->y == -1)
+		    {
+		      /* We need to list all the rows, since we are scrolling down. But first,
+		       * find the top of the visible list. */
+		      ldata->top = row;
+		      glist_display_all(ldata);
+		    }
+		  else
+		    {
+		      /* just redisplay the two lines. */
+		      ldata->list_fn->gl_printrow(ldata, old);
+		      ldata->list_fn->gl_printrow(ldata, ldata->selected);
+		      flayer->l_y = ldata->selected->y;
+		      LaySetCursor();
+		    }
+		  break;
+		}
+	    }
+	  break;
+	}
+      --*inp;
+      ++*len;
+      return 0;
+    }
+  return 1;
+}
+
+static int
+gl_Window_freerow(struct ListData *ldata, struct ListRow *row)
+{
+  return 0;
+}
+
+static int
+gl_Window_free(struct ListData *ldata)
+{
+  Free(ldata->data);
+  return 0;
+}
+
+static int
+gl_Window_match(struct ListData *ldata, struct ListRow *row, const char *needle)
+{
+  struct win *w = row->data;
+  if (InStr(w->w_title, needle))
+    return 1;
+  return 0;
+}
+
+static struct GenericList gl_Window =
+{
+  gl_Window_header,
+  gl_Window_footer,
+  gl_Window_row,
+  gl_Window_input,
+  gl_Window_freerow,
+  gl_Window_free,
+  gl_Window_match
+};
+
+void
+display_windows(int onblank, int order, struct win *group)
+{
+  struct win *p;
+  struct ListData *ldata;
+  struct gl_Window_Data *wdata;
+
+  if (flayer->l_width < 10 || flayer->l_height < 6)
+    {
+      LMsg(0, "Window size too small for window list page");
+      return;
+    }
+
+  if (group)
+    onblank = 0;	/* When drawing a group window, ignore 'onblank' */
+
+  if (onblank)
+    {
+      debug3("flayer %x %d %x\n", flayer, flayer->l_width, flayer->l_height);
+      if (!display)
+	{
+	  LMsg(0, "windowlist -b: display required");
+	  return;
+	}
+      p = D_fore;
+      if (p)
+	{
+	  SetForeWindow((struct win *)0);
+          if (p->w_group)
+	    {
+	      D_fore = p->w_group;
+	      flayer->l_data = (char *)p->w_group;
+	    }
+	  Activate(0);
+	}
+      if (flayer->l_width < 10 || flayer->l_height < 6)
+	{
+	  LMsg(0, "Window size too small for window list page");
+	  return;
+	}
+    }
+  else
+    p = Layer2Window(flayer);
+  if (!group && p)
+    group = p->w_group;
+
+  ldata = glist_display(&gl_Window, ListID);
+  if (!ldata)
+    {
+      if (onblank && p)
+	{
+	  /* Could not display the list. So restore the window. */
+	  SetForeWindow(p);
+	  Activate(1);
+	}
+      return;
+    }
+
+  wdata = calloc(1, sizeof(struct gl_Window_Data));
+  wdata->group = group;
+  wdata->order = (order & ~WLIST_NESTED);
+  wdata->nested = !!(order & WLIST_NESTED);
+  wdata->onblank = onblank;
+
+  /* Set the most recent window as selected. */
+  wdata->fore = windows;
+  while (wdata->fore && wdata->fore->w_group != group)
+    wdata->fore = wdata->fore->w_next;
+
+  ldata->data = wdata;
+
+  gl_Window_rebuild(ldata);
+}
+
+static void
+WListUpdate(struct win *p, struct ListData *ldata)
+{
+  struct gl_Window_Data *wdata = ldata->data;
+  struct ListRow *row, *rbefore;
+  struct win *before;
+  int d = 0, sel = 0;
+
+  if (!p)
+    {
+      if (ldata->selected)
+	wdata->fore = ldata->selected->data;	/* Try to retain the current selection */
+      glist_remove_rows(ldata);
+      gl_Window_rebuild(ldata);
+      return;
+    }
+
+  /* First decide if this window should be displayed at all. */
+  d = 1;
+  if (wdata->order == WLIST_NUM || wdata->order == WLIST_MRU)
+    {
+      if (p->w_group != wdata->group)
+	{
+	  if (!wdata->nested)
+	    d = 0;
+	  else
+	    d = window_ancestor(wdata->group, p);
+	}
+    }
+
+  if (!d)
+    {
+      if (gl_Window_remove(ldata, p))
+	glist_display_all(ldata);
+      return;
+    }
+
+  /* OK, so we keep the window in the list. Update the ordering.
+   * First, find the row where this window should go to. Then, either create
+   * a new row for that window, or move the exising row for the window to the
+   * correct place. */
+  before = NULL;
+  if (wdata->order == WLIST_MRU)
+    {
+      if (windows != p)
+	for (before = windows; before; before = before->w_next)
+	  if (before->w_next == p)
+	    break;
+    }
+  else if (wdata->order == WLIST_NUM)
+    {
+      if (p->w_number != 0)
+	{
+	  struct win **w = wtab + p->w_number - 1;
+	  for (; w >= wtab; w--)
+	    {
+	      if (*w && (*w)->w_group == wdata->group)
+		{
+		  before = *w;
+		  break;
+		}
+	    }
+	}
+    }
+
+  /* Now, find the row belonging to 'before' */
+  if (before)
+    rbefore = gl_Window_findrow(ldata, before);
+  else if (wdata->nested && p->w_group)	/* There's no 'before'. So find the group window */
+    rbefore = gl_Window_findrow(ldata, p->w_group);
+  else
+    rbefore = NULL;
+
+  /* For now, just remove the row containing 'p' if it is not already in the right place . */
+  row = gl_Window_findrow(ldata, p);
+  if (row)
+    {
+      if (row->prev != rbefore)
+	{
+	  sel = ldata->selected->data == p;
+	  gl_Window_remove(ldata, p);
+	}
+      else
+	p = NULL;		/* the window is in the correct place */
+    }
+  if (p)
+    {
+      row = glist_add_row(ldata, p, rbefore);
+      if (sel)
+	ldata->selected = row;
+    }
+  glist_display_all(ldata);
+}
+
+void
+WListUpdatecv(cv, p)
+struct canvas *cv;
+struct win *p;
+{
+  struct ListData *ldata;
+  struct gl_Window_Data *wdata;
+
+  if (cv->c_layer->l_layfn != &ListLf)
+    return;
+  ldata = cv->c_layer->l_data;
+  if (ldata->name != ListID)
+    return;
+  wdata = ldata->data;
+  CV_CALL(cv, WListUpdate(p, ldata));
+}
+
+void
+WListLinkChanged()
+{
+  struct display *olddisplay = display;
+  struct canvas *cv;
+  struct ListData *ldata;
+  struct gl_Window_Data *wdata;
+
+  for (display = displays; display; display = display->d_next)
+    for (cv = D_cvlist; cv; cv = cv->c_next)
+      {
+        if (!cv->c_layer || cv->c_layer->l_layfn != &ListLf)
+	  continue;
+	ldata = cv->c_layer->l_data;
+	if (ldata->name != ListID)
+	  continue;
+	wdata = ldata->data;
+	if (!(wdata->order & WLIST_MRU))
+	  continue;
+        CV_CALL(cv, WListUpdate(0, ldata));
+      }
+  display = olddisplay;
+}
+