+109 -301

actions.c

··· 44 44 arg_KEYMAP, 45 45 arg_KEY, 46 46 arg_GRAVITY, 47 47 - arg_GROUP, 47 47 + arg_VSCREEN, 48 48 arg_HOOK, 49 49 arg_VARIABLE, 50 50 arg_RAW, ··· 56 56 float fnumber; 57 57 rp_window *win; 58 58 rp_keymap *keymap; 59 59 - rp_group *group; 59 59 + rp_vscreen *vscreen; 60 60 struct list_head *hook; 61 61 struct set_var *variable; 62 62 struct rp_key *key; ··· 200 200 static cmdret *cmd_focusup(int interactive, struct cmdarg **args); 201 201 static cmdret *cmd_frestore(int interactive, struct cmdarg **args); 202 202 static cmdret *cmd_fselect(int interactive, struct cmdarg **args); 203 203 - static cmdret *cmd_gdelete(int interactive, struct cmdarg **args); 204 203 static cmdret *cmd_getenv(int interactive, struct cmdarg **args); 205 204 static cmdret *cmd_getsel(int interactive, struct cmdarg **args); 206 206 - static cmdret *cmd_gmerge(int interactive, struct cmdarg **args); 207 207 - static cmdret *cmd_gmove(int interactive, struct cmdarg **args); 208 208 - static cmdret *cmd_gnew(int interactive, struct cmdarg **args); 209 209 - static cmdret *cmd_gnewbg(int interactive, struct cmdarg **args); 210 210 - static cmdret *cmd_gnext(int interactive, struct cmdarg **args); 211 211 - static cmdret *cmd_gnumber(int interactive, struct cmdarg **args); 212 212 - static cmdret *cmd_gother(int interactive, struct cmdarg **args); 213 213 - static cmdret *cmd_gprev(int interactive, struct cmdarg **args); 214 205 static cmdret *cmd_gravity(int interactive, struct cmdarg **args); 215 215 - static cmdret *cmd_grename(int interactive, struct cmdarg **args); 216 216 - static cmdret *cmd_groups(int interactive, struct cmdarg **args); 217 217 - static cmdret *cmd_gselect(int interactive, struct cmdarg **args); 218 206 static cmdret *cmd_h_split(int interactive, struct cmdarg **args); 219 207 static cmdret *cmd_help(int interactive, struct cmdarg **args); 220 208 static cmdret *cmd_inext(int interactive, struct cmdarg **args); ··· 274 262 static cmdret *cmd_verbexec(int interactive, struct cmdarg **args); 275 263 static cmdret *cmd_version(int interactive, struct cmdarg **args); 276 264 static cmdret *cmd_vmove(int interactive, struct cmdarg **args); 265 265 + static cmdret *cmd_vrename(int interactive, struct cmdarg **args); 266 266 + static cmdret *cmd_vscreens(int interactive, struct cmdarg **args); 277 267 static cmdret *cmd_vselect(int interactive, struct cmdarg **args); 278 268 static cmdret *cmd_windows(int interactive, struct cmdarg **args); 279 269 ··· 460 450 "Frames: ", arg_REST); 461 451 add_command("fselect", cmd_fselect, 1, 1, 1, 462 452 "", arg_FRAME); 463 463 - add_command("gdelete", cmd_gdelete, 1, 0, 0, 464 464 - "Group:", arg_GROUP); 465 453 add_command("getenv", cmd_getenv, 1, 1, 1, 466 454 "Variable: ", arg_STRING); 467 455 add_command("getsel", cmd_getsel, 0, 0, 0); 468 468 - add_command("gmerge", cmd_gmerge, 1, 1, 1, 469 469 - "Group: ", arg_GROUP); 470 470 - add_command("gmove", cmd_gmove, 1, 1, 1, 471 471 - "Group: ", arg_GROUP); 472 472 - add_command("gnew", cmd_gnew, 1, 1, 1, 473 473 - "Name: ", arg_STRING); 474 474 - add_command("gnewbg", cmd_gnewbg, 1, 1, 1, 475 475 - "Name: ", arg_STRING); 476 476 - add_command("gnext", cmd_gnext, 0, 0, 0); 477 477 - add_command("gnumber", cmd_gnumber, 2, 1, 1, 478 478 - "Number: ", arg_NUMBER, 479 479 - "Number: ", arg_NUMBER); 480 480 - add_command("gother", cmd_gother, 0, 0, 0); 481 481 - add_command("gprev", cmd_gprev, 0, 0, 0); 482 456 add_command("gravity", cmd_gravity, 1, 0, 0, 483 457 "Gravity: ", arg_GRAVITY); 484 484 - add_command("grename", cmd_grename, 1, 1, 1, 485 485 - "Change group name to: ", arg_REST); 486 486 - add_command("groups", cmd_groups, 0, 0, 0); 487 487 - add_command("gselect", cmd_gselect, 1, 1, 1, 488 488 - "Group: ", arg_GROUP); 489 458 add_command("help", cmd_help, 1, 0, 0, 490 459 "Keymap: ", arg_KEYMAP); 491 460 add_command("hsplit", cmd_h_split, 1, 0, 0, ··· 584 553 "/bin/sh -c ", arg_SHELLCMD); 585 554 add_command("version", cmd_version, 0, 0, 0); 586 555 add_command("vmove", cmd_vmove, 1, 1, 1, 587 587 - "Virtual Screen: ", arg_NUMBER); 556 556 + "Virtual Screen: ", arg_VSCREEN); 557 557 + add_command("vrename", cmd_vrename, 1, 1, 1, 558 558 + "Change virtual screen name to: ", arg_REST); 559 559 + add_command("vscreens", cmd_vscreens, 0, 0, 0); 588 560 add_command("vselect", cmd_vselect, 1, 1, 1, 589 589 - "Virtual Screen: ", arg_NUMBER); 561 561 + "Virtual Screen: ", arg_VSCREEN); 590 562 add_command("vsplit", cmd_v_split, 1, 0, 0, 591 563 "Split: ", arg_STRING); 592 564 add_command("windows", cmd_windows, 1, 0, 0, ··· 1367 1339 { 1368 1340 rp_window *cur, *win; 1369 1341 cur = current_window(); 1370 1370 - win = group_prev_window(rp_current_group, cur); 1342 1342 + win = vscreen_prev_window(rp_current_vscreen, cur); 1371 1343 1372 1344 if (win) 1373 1345 set_active_window(win); ··· 1399 1371 { 1400 1372 rp_window *cur, *win; 1401 1373 cur = current_window(); 1402 1402 - win = group_next_window(rp_current_group, cur); 1374 1374 + win = vscreen_next_window(rp_current_vscreen, cur); 1403 1375 1404 1376 if (win) 1405 1377 set_active_window(win); ··· 1432 1404 rp_window *w; 1433 1405 1434 1406 /* w = find_window_other (); */ 1435 1435 - w = group_last_window(rp_current_vscreen->current_group); 1407 1407 + w = vscreen_last_window(rp_current_vscreen); 1436 1408 if (!w) 1437 1409 return cmdret_new(RET_FAILURE, "%s", MESSAGE_NO_OTHER_WINDOW); 1438 1410 ··· 1503 1475 INIT_LIST_HEAD(list); 1504 1476 1505 1477 /* Gather the names of all the windows. */ 1506 1506 - list_for_each_entry(cur, &rp_current_group->mapped_windows, node) { 1478 1478 + list_for_each_entry(cur, &rp_current_vscreen->mapped_windows, node) { 1507 1479 struct sbuf *name; 1508 1480 1509 1481 name = sbuf_new(0); ··· 1543 1515 ret = cmdret_new(RET_SUCCESS, NULL); 1544 1516 } else if ((n = string_to_positive_int(str)) >= 0) { 1545 1517 /* try by number */ 1546 1546 - rp_window_elem *elem = group_find_window_by_number( 1547 1547 - rp_current_group, n); 1518 1518 + rp_window_elem *elem = vscreen_find_window_by_number( 1519 1519 + rp_current_vscreen, n); 1548 1520 1549 1521 if (elem) { 1550 1522 goto_window(elem->win); ··· 1764 1736 } 1765 1737 1766 1738 static struct list_head * 1767 1767 - group_completions(char *str) 1739 1739 + vscreen_completions(char *str) 1768 1740 { 1769 1769 - struct list_head *list; 1770 1770 - rp_group *cur; 1741 1741 + struct list_head *list; 1742 1742 + rp_vscreen *cur; 1771 1743 1772 1772 - /* Initialize our list. */ 1773 1773 - list = xmalloc(sizeof(struct list_head)); 1774 1774 - INIT_LIST_HEAD(list); 1744 1744 + /* Initialize our list. */ 1745 1745 + list = xmalloc(sizeof(struct list_head)); 1746 1746 + INIT_LIST_HEAD(list); 1775 1747 1776 1776 - /* Grab all the group names. */ 1777 1777 - list_for_each_entry(cur, &(rp_current_screen->current_vscreen->groups), 1778 1778 - node) { 1779 1779 - struct sbuf *s; 1748 1748 + /* Grab all the vscreen names. */ 1749 1749 + list_for_each_entry(cur, &(rp_current_screen)->vscreens, node) { 1750 1750 + struct sbuf *s; 1780 1751 1781 1781 - s = sbuf_new(0); 1782 1782 - /* 1783 1783 - * A group may not have a name, so if it doesn't, use it's 1784 1784 - * number. 1785 1785 - */ 1786 1786 - if (cur->name) { 1787 1787 - sbuf_copy(s, cur->name); 1788 1788 - } else { 1789 1789 - sbuf_printf(s, "%d", cur->number); 1790 1790 - } 1752 1752 + s = sbuf_new(0); 1753 1753 + if (cur->name) { 1754 1754 + sbuf_copy(s, cur->name); 1755 1755 + } else { 1756 1756 + sbuf_printf(s, "%d", cur->number); 1757 1757 + } 1791 1758 1792 1792 - list_add_tail(&s->node, list); 1793 1793 - } 1759 1759 + list_add_tail(&s->node, list); 1760 1760 + } 1794 1761 1795 1795 - return list; 1762 1762 + return list; 1796 1763 } 1797 1764 1798 1765 static struct list_head * ··· 2061 2028 if (name) { 2062 2029 /* try by number */ 2063 2030 if ((n = string_to_positive_int(name)) >= 0) { 2064 2064 - rp_window_elem *elem = group_find_window_by_number( 2065 2065 - rp_current_group, n); 2031 2031 + rp_window_elem *elem = vscreen_find_window_by_number( 2032 2032 + rp_current_vscreen, n); 2066 2033 if (elem) 2067 2034 win = elem->win; 2068 2035 } else { ··· 2151 2118 } 2152 2119 2153 2120 /* 2154 2154 - * Given a string, find a matching group. First check if the string exactly 2155 2155 - * matches a group name, then check if it is a number & lastly check if it 2156 2156 - * partially matches the name of a group. 2121 2121 + * Given a string, find a matching vscreen. First check if the string exactly 2122 2122 + * matches a vscreen name, then check if it is a number & lastly check if it 2123 2123 + * partially matches the name of a vscreen. 2157 2124 */ 2158 2158 - static rp_group * 2159 2159 - find_group(char *str) 2125 2125 + static rp_vscreen * 2126 2126 + find_vscreen(char *str) 2160 2127 { 2161 2161 - rp_group *group; 2128 2128 + rp_vscreen *vscreen; 2162 2129 int n; 2163 2130 2164 2164 - /* Check if the user typed a group number. */ 2131 2131 + /* Check if the user typed a vsceen number. */ 2165 2132 n = string_to_positive_int(str); 2166 2133 if (n >= 0) { 2167 2167 - group = groups_find_group_by_number(rp_current_vscreen, n); 2168 2168 - if (group) 2169 2169 - return group; 2134 2134 + vscreen = screen_find_vscreen_by_number(rp_current_screen, n); 2135 2135 + if (vscreen) 2136 2136 + return vscreen; 2170 2137 } 2171 2138 2172 2139 /* Exact matches are special cases. */ 2173 2173 - if ((group = groups_find_group_by_name(rp_current_vscreen, str, 1))) 2174 2174 - return group; 2140 2140 + if ((vscreen = screen_find_vscreen_by_name(rp_current_screen, str, 1))) 2141 2141 + return vscreen; 2175 2142 2176 2176 - group = groups_find_group_by_name(rp_current_vscreen, str, 0); 2177 2177 - return group; 2143 2143 + vscreen = screen_find_vscreen_by_name(rp_current_screen, str, 0); 2144 2144 + return vscreen; 2178 2145 } 2179 2146 2180 2147 static cmdret * 2181 2181 - read_group(struct argspec *spec, struct sbuf *s, struct cmdarg **arg) 2148 2148 + read_vscreen(struct argspec *spec, struct sbuf *s, struct cmdarg **arg) 2182 2149 { 2183 2150 char *input; 2184 2151 2185 2152 if (s) 2186 2153 input = xstrdup(sbuf_get(s)); 2187 2154 else 2188 2188 - input = get_input(spec->prompt, hist_GROUP, group_completions); 2155 2155 + input = get_input(spec->prompt, hist_VSCREEN, 2156 2156 + vscreen_completions); 2189 2157 2190 2158 if (input) { 2191 2191 - rp_group *g = find_group(input); 2192 2192 - 2193 2193 - if (g) { 2159 2159 + rp_vscreen *v = find_vscreen(input); 2160 2160 + if (v) { 2194 2161 *arg = xmalloc(sizeof(struct cmdarg)); 2195 2195 - (*arg)->type = arg_GROUP; 2196 2196 - (*arg)->arg.group = g; 2162 2162 + (*arg)->type = arg_VSCREEN; 2163 2163 + (*arg)->arg.vscreen = v; 2197 2164 (*arg)->string = input; 2198 2165 return NULL; 2199 2166 } 2200 2167 2201 2201 - cmdret *ret = cmdret_new(RET_FAILURE, "unknown group '%s'", 2168 2168 + cmdret *ret = cmdret_new(RET_FAILURE, "unknown vscreen '%s'", 2202 2169 input); 2203 2170 free(input); 2204 2171 return ret; ··· 2283 2250 list = xmalloc(sizeof(struct list_head)); 2284 2251 INIT_LIST_HEAD(list); 2285 2252 2286 2286 - /* Grab all the group names. */ 2253 2253 + /* Grab all the vscreen names. */ 2287 2254 list_for_each_entry(cur, &set_vars, node) { 2288 2255 struct sbuf *s; 2289 2256 ··· 2401 2368 case arg_FRAME: 2402 2369 ret = read_frame(s, arg); 2403 2370 break; 2404 2404 - case arg_GROUP: 2405 2405 - ret = read_group(spec, s, arg); 2371 2371 + case arg_VSCREEN: 2372 2372 + ret = read_vscreen(spec, s, arg); 2406 2373 break; 2407 2374 case arg_HOOK: 2408 2375 ret = read_hook(spec, s, arg); ··· 2615 2582 case arg_SHELLCMD: 2616 2583 case arg_KEYMAP: 2617 2584 case arg_GRAVITY: 2618 2618 - case arg_GROUP: 2585 2585 + case arg_VSCREEN: 2619 2586 case arg_HOOK: 2620 2587 case arg_VARIABLE: 2621 2588 case arg_RAW: ··· 2859 2826 child->pid = pid; 2860 2827 child->terminated = 0; 2861 2828 child->frame = frame; 2862 2862 - child->group = rp_current_group; 2863 2829 child->vscreen = rp_current_vscreen; 2864 2830 child->screen = rp_current_screen; 2865 2831 child->window_mapped = 0; ··· 2886 2852 /* Gather the args. */ 2887 2853 new_number = ARG(0, number); 2888 2854 if (args[1]) 2889 2889 - win = group_find_window_by_number(rp_current_group, 2855 2855 + win = vscreen_find_window_by_number(rp_current_vscreen, 2890 2856 ARG(1, number)); 2891 2891 - else { 2892 2892 - rp_group *g = rp_current_group; 2893 2893 - win = group_find_window(&g->mapped_windows, current_window()); 2894 2894 - } 2857 2857 + else 2858 2858 + win = vscreen_find_window(&rp_current_vscreen->mapped_windows, 2859 2859 + current_window()); 2895 2860 2896 2861 /* Make the switch. */ 2897 2862 if (new_number >= 0 && win) { 2898 2863 /* Find other window with same number and give it old number. */ 2899 2899 - other_win = group_find_window_by_number(rp_current_group, 2864 2864 + other_win = vscreen_find_window_by_number(rp_current_vscreen, 2900 2865 new_number); 2901 2866 if (other_win != NULL) { 2902 2867 old_number = win->number; 2903 2868 other_win->number = old_number; 2904 2869 2905 2870 /* Resort the window in the list */ 2906 2906 - group_resort_window(rp_current_group, other_win); 2871 2871 + vscreen_resort_window(rp_current_vscreen, other_win); 2907 2872 } else { 2908 2908 - numset_release(rp_current_group->numset, win->number); 2873 2873 + numset_release(rp_current_vscreen->numset, win->number); 2909 2874 } 2910 2875 2911 2876 win->number = new_number; 2912 2912 - numset_add_num(rp_current_group->numset, new_number); 2877 2877 + numset_add_num(rp_current_vscreen->numset, new_number); 2913 2878 2914 2879 /* resort the the window in the list */ 2915 2915 - group_resort_window(rp_current_group, win); 2880 2880 + vscreen_resort_window(rp_current_vscreen, win); 2916 2881 2917 2882 /* Update the window list. */ 2918 2883 update_window_names(win->win->vscr->screen, ··· 4365 4330 if (current_window() != NULL) { 4366 4331 rp_window *win = current_window(); 4367 4332 rp_window_elem *win_elem; 4368 4368 - win_elem = group_find_window(&(rp_current_group->mapped_windows), 4333 4333 + win_elem = vscreen_find_window(&rp_current_vscreen->mapped_windows, 4369 4334 win); 4370 4335 if (!win_elem) 4371 4371 - win_elem = group_find_window( 4372 4372 - &(rp_current_group->unmapped_windows), win); 4373 4373 - 4374 4374 - if (!win_elem) { 4375 4375 - rp_group *g = groups_find_group_by_window(win); 4376 4376 - if (g != NULL) 4377 4377 - win_elem = group_find_window(&g->mapped_windows, 4378 4378 - win); 4379 4379 - if (!win_elem && g != NULL) 4380 4380 - win_elem = group_find_window( 4381 4381 - &g->unmapped_windows, win); 4382 4382 - } 4336 4336 + win_elem = vscreen_find_window( 4337 4337 + &rp_current_vscreen->unmapped_windows, win); 4383 4338 4384 4339 if (win_elem) { 4385 4340 char *s; ··· 4963 4918 } 4964 4919 4965 4920 cmdret * 4966 4966 - cmd_gnext(int interactive, struct cmdarg **args) 4967 4967 - { 4968 4968 - set_current_group(group_next_group(rp_current_vscreen)); 4969 4969 - return cmdret_new(RET_SUCCESS, NULL); 4970 4970 - } 4971 4971 - 4972 4972 - cmdret * 4973 4973 - cmd_gprev(int interactive, struct cmdarg **args) 4974 4974 - { 4975 4975 - set_current_group(group_prev_group(rp_current_vscreen)); 4976 4976 - return cmdret_new(RET_SUCCESS, NULL); 4977 4977 - } 4978 4978 - 4979 4979 - cmdret * 4980 4980 - cmd_gother(int interactive, struct cmdarg **args) 4921 4921 + cmd_vrename(int interactive, struct cmdarg **args) 4981 4922 { 4982 4982 - set_current_group(group_last_group(rp_current_vscreen)); 4983 4983 - return cmdret_new(RET_SUCCESS, NULL); 4984 4984 - } 4923 4923 + if (screen_find_vscreen_by_name(rp_current_screen, ARG_STRING(0), 1)) 4924 4924 + return cmdret_new(RET_FAILURE, "vrename: duplicate vscreen name"); 4925 4925 + vscreen_rename(rp_current_vscreen, ARG_STRING(0)); 4985 4926 4986 4986 - cmdret * 4987 4987 - cmd_gnew(int interactive, struct cmdarg **args) 4988 4988 - { 4989 4989 - if (groups_find_group_by_name(rp_current_vscreen, ARG_STRING(0), 1)) 4990 4990 - return cmdret_new(RET_FAILURE, "gnew: group already exists"); 4991 4991 - set_current_group(group_add_new_group(rp_current_vscreen, ARG_STRING(0))); 4992 4992 - return cmdret_new(RET_SUCCESS, NULL); 4993 4993 - } 4927 4927 + /* Update the vscreen list. */ 4928 4928 + update_vscreen_names(rp_current_screen); 4994 4929 4995 4995 - cmdret * 4996 4996 - cmd_gnewbg(int interactive, struct cmdarg **args) 4997 4997 - { 4998 4998 - if (groups_find_group_by_name(rp_current_vscreen, ARG_STRING(0), 1)) 4999 4999 - return cmdret_new(RET_FAILURE, "gnewbg: group already exists"); 5000 5000 - group_add_new_group(rp_current_vscreen, ARG_STRING(0)); 5001 4930 return cmdret_new(RET_SUCCESS, NULL); 5002 4931 } 5003 4932 5004 4933 cmdret * 5005 5005 - cmd_gnumber(int interactive, struct cmdarg **args) 4934 4934 + cmd_vselect(int interactive, struct cmdarg **args) 5006 4935 { 5007 5007 - int old_number, new_number; 5008 5008 - rp_group *other_g, *g; 4936 4936 + rp_vscreen *v; 5009 4937 5010 5010 - struct numset *g_numset = group_get_numset(rp_current_vscreen); 5011 5011 - 5012 5012 - /* Gather the args. */ 5013 5013 - new_number = ARG(0, number); 5014 5014 - if (args[1]) 5015 5015 - g = groups_find_group_by_number(rp_current_vscreen, 5016 5016 - ARG(1, number)); 4938 4938 + v = find_vscreen(ARG_STRING(0)); 4939 4939 + if (v) 4940 4940 + set_current_vscreen(v); 5017 4941 else 5018 5018 - g = rp_current_group; 4942 4942 + return cmd_vscreens(interactive, NULL); 5019 4943 5020 5020 - /* Make the switch. */ 5021 5021 - if (new_number >= 0 && g) { 5022 5022 - /* Find other window with same number and give it old number. */ 5023 5023 - other_g = groups_find_group_by_number(rp_current_vscreen, 5024 5024 - new_number); 5025 5025 - if (other_g != NULL) { 5026 5026 - old_number = g->number; 5027 5027 - other_g->number = old_number; 5028 5028 - 5029 5029 - /* Resort the window in the list */ 5030 5030 - group_resort_group(other_g); 5031 5031 - } else { 5032 5032 - numset_release(g_numset, g->number); 5033 5033 - } 5034 5034 - 5035 5035 - g->number = new_number; 5036 5036 - numset_add_num(g_numset, new_number); 5037 5037 - 5038 5038 - /* resort the the window in the list */ 5039 5039 - group_resort_group(g); 5040 5040 - 5041 5041 - /* Update the group list. */ 5042 5042 - update_group_names(rp_current_screen); 5043 5043 - } 5044 4944 return cmdret_new(RET_SUCCESS, NULL); 5045 4945 } 5046 4946 4947 4947 + /* Show all the vscreens, with the current one highlighted. */ 5047 4948 cmdret * 5048 5048 - cmd_grename(int interactive, struct cmdarg **args) 4949 4949 + cmd_vscreens(int interactive, struct cmdarg **args) 5049 4950 { 5050 5050 - if (groups_find_group_by_name(rp_current_vscreen, ARG_STRING(0), 1)) 5051 5051 - return cmdret_new(RET_FAILURE, "grename: duplicate group name"); 5052 5052 - group_rename(rp_current_group, ARG_STRING(0)); 5053 5053 - 5054 5054 - /* Update the group list. */ 5055 5055 - update_group_names(rp_current_screen); 5056 5056 - 5057 5057 - return cmdret_new(RET_SUCCESS, NULL); 5058 5058 - } 5059 5059 - 5060 5060 - cmdret * 5061 5061 - cmd_gselect(int interactive, struct cmdarg **args) 5062 5062 - { 5063 5063 - rp_group *g; 5064 5064 - 5065 5065 - g = find_group(ARG_STRING(0)); 5066 5066 - 5067 5067 - if (g) 5068 5068 - set_current_group(g); 5069 5069 - else 5070 5070 - return cmd_groups(interactive, NULL); 5071 5071 - 5072 5072 - return cmdret_new(RET_SUCCESS, NULL); 5073 5073 - } 5074 5074 - 5075 5075 - /* Show all the groups, with the current one highlighted. */ 5076 5076 - cmdret * 5077 5077 - cmd_groups(int interactive, struct cmdarg **args) 5078 5078 - { 5079 5079 - struct sbuf *group_list = NULL; 4951 4951 + struct sbuf *vscreen_list = NULL; 5080 4952 int dummy; 5081 4953 5082 4954 if (interactive) { 5083 5083 - show_group_bar(rp_current_screen); 4955 4955 + show_vscreen_bar(rp_current_screen); 5084 4956 return cmdret_new(RET_SUCCESS, NULL); 5085 4957 } else { 5086 4958 cmdret *ret; 5087 4959 5088 5088 - group_list = sbuf_new(0); 5089 5089 - get_group_list(rp_current_vscreen, "\n", group_list, &dummy, 4960 4960 + vscreen_list = sbuf_new(0); 4961 4961 + get_vscreen_list(rp_current_screen, "\n", vscreen_list, &dummy, 5090 4962 &dummy); 5091 5091 - ret = cmdret_new(RET_SUCCESS, "%s", sbuf_get(group_list)); 5092 5092 - sbuf_free(group_list); 4963 4963 + ret = cmdret_new(RET_SUCCESS, "%s", sbuf_get(vscreen_list)); 4964 4964 + sbuf_free(vscreen_list); 5093 4965 return ret; 5094 4966 } 5095 5095 - } 5096 5096 - 5097 5097 - /* Move a window to a different group. */ 5098 5098 - cmdret * 5099 5099 - cmd_gmove(int interactive, struct cmdarg **args) 5100 5100 - { 5101 5101 - if (current_window() == NULL) 5102 5102 - return cmdret_new(RET_FAILURE, "gmove: no focused window"); 5103 5103 - 5104 5104 - group_move_window(ARG(0, group), current_window()); 5105 5105 - return cmdret_new(RET_SUCCESS, NULL); 5106 5106 - } 5107 5107 - 5108 5108 - cmdret * 5109 5109 - cmd_gmerge(int interactive, struct cmdarg **args) 5110 5110 - { 5111 5111 - groups_merge(ARG(0, group), rp_current_group); 5112 5112 - return cmdret_new(RET_SUCCESS, NULL); 5113 4967 } 5114 4968 5115 4969 cmdret * ··· 5176 5030 } 5177 5031 5178 5032 cmdret * 5179 5179 - cmd_gdelete(int interactive, struct cmdarg **args) 5180 5180 - { 5181 5181 - rp_group *g; 5182 5182 - 5183 5183 - if (args[0] == NULL) 5184 5184 - g = rp_current_group; 5185 5185 - else 5186 5186 - g = ARG(0, group); 5187 5187 - 5188 5188 - switch (group_delete_group(g)) { 5189 5189 - case GROUP_DELETE_GROUP_OK: 5190 5190 - break; 5191 5191 - case GROUP_DELETE_GROUP_NONEMPTY: 5192 5192 - return cmdret_new(RET_FAILURE, 5193 5193 - "gdelete: non-empty group"); 5194 5194 - break; 5195 5195 - case GROUP_DELETE_LAST_GROUP: 5196 5196 - return cmdret_new(RET_FAILURE, 5197 5197 - "gdelete: cannot delete the sole group"); 5198 5198 - break; 5199 5199 - default: 5200 5200 - return cmdret_new(RET_FAILURE, 5201 5201 - "gdelete: unknown return code (this shouldn't happen)"); 5202 5202 - } 5203 5203 - 5204 5204 - return cmdret_new(RET_SUCCESS, NULL); 5205 5205 - } 5206 5206 - 5207 5207 - cmdret * 5208 5033 cmd_readkey(int interactive, struct cmdarg **args) 5209 5034 { 5210 5035 char *keysym_name; ··· 5550 5375 return cmd_next(interactive, args); 5551 5376 5552 5377 /* CUR !in cycle list, so LAST marks last node. */ 5553 5553 - last = group_prev_window(rp_current_group, cur); 5378 5378 + last = vscreen_prev_window(rp_current_vscreen, cur); 5554 5379 5555 5380 if (last) 5556 5556 - for (win = group_next_window(rp_current_group, cur); 5381 5381 + for (win = vscreen_next_window(rp_current_vscreen, cur); 5557 5382 win; 5558 5558 - win = group_next_window(rp_current_group, win)) { 5383 5383 + win = vscreen_next_window(rp_current_vscreen, win)) { 5559 5384 if (win->res_class 5560 5385 && strcmp(cur->res_class, win->res_class)) { 5561 5386 set_active_window_force(win); ··· 5578 5403 return cmd_next(interactive, args); 5579 5404 5580 5405 /* CUR !in cycle list, so LAST marks last node. */ 5581 5581 - last = group_next_window(rp_current_group, cur); 5406 5406 + last = vscreen_next_window(rp_current_vscreen, cur); 5582 5407 5583 5408 if (last) 5584 5584 - for (win = group_prev_window(rp_current_group, cur); 5409 5409 + for (win = vscreen_prev_window(rp_current_vscreen, cur); 5585 5410 win; 5586 5586 - win = group_prev_window(rp_current_group, win)) { 5411 5411 + win = vscreen_prev_window(rp_current_vscreen, win)) { 5587 5412 if (win->res_class 5588 5413 && strcmp(cur->res_class, win->res_class)) { 5589 5414 set_active_window_force(win); ··· 5606 5431 return cmd_next(interactive, args); 5607 5432 5608 5433 /* CUR !in cycle list, so LAST marks last node. */ 5609 5609 - last = group_prev_window(rp_current_group, cur); 5434 5434 + last = vscreen_prev_window(rp_current_vscreen, cur); 5610 5435 5611 5436 if (last) 5612 5612 - for (win = group_next_window(rp_current_group, cur); 5437 5437 + for (win = vscreen_next_window(rp_current_vscreen, cur); 5613 5438 win; 5614 5614 - win = group_next_window(rp_current_group, win)) { 5439 5439 + win = vscreen_next_window(rp_current_vscreen, win)) { 5615 5440 if (win->res_class 5616 5441 && !strcmp(cur->res_class, win->res_class)) { 5617 5442 set_active_window_force(win); ··· 5634 5459 return cmd_next(interactive, args); 5635 5460 5636 5461 /* CUR !in cycle list, so LAST marks last node. */ 5637 5637 - last = group_next_window(rp_current_group, cur); 5462 5462 + last = vscreen_next_window(rp_current_vscreen, cur); 5638 5463 5639 5464 if (last) 5640 5640 - for (win = group_prev_window(rp_current_group, cur); 5465 5465 + for (win = vscreen_prev_window(rp_current_vscreen, cur); 5641 5466 win; 5642 5642 - win = group_prev_window(rp_current_group, win)) { 5467 5467 + win = vscreen_prev_window(rp_current_vscreen, win)) { 5643 5468 if (win->res_class 5644 5469 && !strcmp(cur->res_class, win->res_class)) { 5645 5470 set_active_window_force(win); ··· 5659 5484 5660 5485 cur = current_window(); 5661 5486 if (cur) 5662 5662 - w = group_last_window_by_class(rp_current_group, cur->res_class); 5487 5487 + w = vscreen_last_window_by_class(rp_current_vscreen, 5488 5488 + cur->res_class); 5663 5489 5664 5490 if (!w) 5665 5491 return cmdret_new(RET_FAILURE, "%s", MESSAGE_NO_OTHER_WINDOW); ··· 5676 5502 5677 5503 cur = current_window(); 5678 5504 if (cur) 5679 5679 - w = group_last_window_by_class_complement(rp_current_group, 5505 5505 + w = vscreen_last_window_by_class_complement(rp_current_vscreen, 5680 5506 cur->res_class); 5681 5507 5682 5508 if (!w) ··· 5864 5690 5865 5691 n = string_to_positive_int(ARG_STRING(0)); 5866 5692 if (n >= 0) { 5867 5867 - v = vscreens_find_vscreen_by_number(rp_current_screen, n); 5693 5693 + v = screen_find_vscreen_by_number(rp_current_screen, n); 5868 5694 if (v) { 5869 5695 vscreen_move_window(v, w); 5870 5696 set_current_vscreen(v); ··· 5874 5700 } 5875 5701 5876 5702 return cmdret_new(RET_FAILURE, "vmove: invalid virtual screen"); 5877 5877 - } 5878 5878 - 5879 5879 - cmdret * 5880 5880 - cmd_vselect(int interactive, struct cmdarg **args) 5881 5881 - { 5882 5882 - rp_vscreen *v; 5883 5883 - int n; 5884 5884 - 5885 5885 - n = string_to_positive_int(ARG_STRING(0)); 5886 5886 - if (n >= 0) { 5887 5887 - v = vscreens_find_vscreen_by_number(rp_current_screen, n); 5888 5888 - if (v) { 5889 5889 - set_current_vscreen(v); 5890 5890 - return cmdret_new(RET_SUCCESS, NULL); 5891 5891 - } 5892 5892 - } 5893 5893 - 5894 5894 - return cmdret_new(RET_FAILURE, "vselect: invalid virtual screen"); 5895 5703 } 5896 5704 5897 5705 cmdret *

+11 -12

bar.c

··· 35 35 /* Possible values for bar_is_raised status. */ 36 36 #define BAR_IS_HIDDEN 0 37 37 #define BAR_IS_WINDOW_LIST 1 38 38 - #define BAR_IS_GROUP_LIST 2 38 38 + #define BAR_IS_VSCREEN_LIST 2 39 39 #define BAR_IS_MESSAGE 3 40 40 #define BAR_IS_STICKY 4 41 41 ··· 168 168 reset_alarm(); 169 169 } 170 170 171 171 - /* Show group listing in bar. */ 171 171 + /* Show vscreen listing in bar. */ 172 172 void 173 173 - show_group_bar(rp_screen *s) 173 173 + show_vscreen_bar(rp_screen *s) 174 174 { 175 175 - s->bar_is_raised = BAR_IS_GROUP_LIST; 175 175 + s->bar_is_raised = BAR_IS_VSCREEN_LIST; 176 176 XMapRaised(dpy, s->bar_window); 177 177 - update_group_names(s); 177 177 + update_vscreen_names(s); 178 178 179 179 /* Switch to the default colormap */ 180 180 if (current_window()) ··· 272 272 case BAR_IS_WINDOW_LIST: 273 273 update_window_names(s, defaults.window_fmt); 274 274 break; 275 275 - case BAR_IS_GROUP_LIST: 276 276 - update_group_names(s); 275 275 + case BAR_IS_VSCREEN_LIST: 276 276 + update_vscreen_names(s); 277 277 break; 278 278 case BAR_IS_STICKY: 279 279 hide_bar(s, 0); ··· 550 550 * Note that we use marked_message_internal to avoid resetting the alarm. 551 551 */ 552 552 void 553 553 - update_group_names(rp_screen *s) 553 553 + update_vscreen_names(rp_screen *s) 554 554 { 555 555 struct sbuf *bar_buffer; 556 556 int mark_start = 0; 557 557 int mark_end = 0; 558 558 char *delimiter; 559 559 560 560 - if (s->bar_is_raised != BAR_IS_GROUP_LIST) 560 560 + if (s->bar_is_raised != BAR_IS_VSCREEN_LIST) 561 561 return; 562 562 563 563 delimiter = (defaults.window_list_style == STYLE_ROW) ? " " : "\n"; 564 564 565 565 bar_buffer = sbuf_new(0); 566 566 567 567 - get_group_list(s->current_vscreen, delimiter, bar_buffer, &mark_start, 568 568 - &mark_end); 567 567 + get_vscreen_list(s, delimiter, bar_buffer, &mark_start, &mark_end); 569 568 marked_message_internal(sbuf_get(bar_buffer), mark_start, mark_end, 570 570 - BAR_IS_GROUP_LIST); 569 569 + BAR_IS_VSCREEN_LIST); 571 570 572 571 sbuf_free(bar_buffer); 573 572 }

+2 -2

bar.h

··· 24 24 void init_bar(void); 25 25 void redraw_sticky_bar_text(rp_screen *s, int force); 26 26 void update_window_names(rp_screen *s, char *fmt); 27 27 - void update_group_names(rp_screen *s); 27 27 + void update_vscreen_names(rp_screen *s); 28 28 void update_bar(rp_screen *s); 29 29 void show_bar(rp_screen *s, char *fmt); 30 30 - void show_group_bar(rp_screen *s); 30 30 + void show_vscreen_bar(rp_screen *s); 31 31 void hide_bar(rp_screen *s, int force); 32 32 int bar_y(rp_screen *s, int height); 33 33 int bar_x(rp_screen *s, int width);

+2 -2

config.h

··· 100 100 */ 101 101 #define IGNORE_BADWINDOW 1 102 102 103 103 - /* This is the name of the first group that is created. */ 104 104 - #define DEFAULT_GROUP_NAME "default" 103 103 + /* This is the name of the first vscreen that is created. */ 104 104 + #define DEFAULT_VSCREEN_NAME "default" 105 105 106 106 /* Maximum allowed history size */ 107 107 #define MAX_HISTORY_SIZE 100

+17 -42

data.h

··· 36 36 typedef struct rp_keymap rp_keymap; 37 37 typedef struct rp_frame rp_frame; 38 38 typedef struct rp_child_info rp_child_info; 39 39 - typedef struct rp_group rp_group; 40 39 typedef struct rp_window_elem rp_window_elem; 41 40 typedef struct rp_completions rp_completions; 42 41 typedef struct rp_input_line rp_input_line; ··· 82 81 83 82 /* 84 83 * A number uniquely identifying this window. This is a different 85 85 - * number than the one given to it by the group it is in. This number 86 86 - * is used for internal purposes, whereas the group number is what the 87 87 - * user sees. 84 84 + * number than the one given to it by the vscreen it is in. This number 85 85 + * is used for internal purposes, whereas the vscreen number is what 86 86 + * the user sees. 88 87 */ 89 88 int number; 90 89 ··· 140 139 struct list_head node; 141 140 }; 142 141 143 143 - /* 144 144 - * An rp_group is a group of windows. By default all windows are added to the 145 145 - * same group. But a new group can be created. All new windows will be part of 146 146 - * this new current group. The windows of any other group may be visible in 147 147 - * another frame, but will not show up in the window list and will not be 148 148 - * accessible with select, next, or prev. These window navigation commands only 149 149 - * navigate the current group. 150 150 - */ 151 151 - struct rp_group { 152 152 - rp_vscreen *vscreen; 153 153 - 154 154 - /* 155 155 - * The name and number of this group. This is to allow the user to 156 156 - * quickly jump to the desired group. 157 157 - */ 158 158 - char *name; 159 159 - int number; 160 160 - 161 161 - /* For determining the last group. */ 162 162 - int last_access; 163 163 - 164 164 - /* The list of windows participating in this group. */ 165 165 - struct list_head mapped_windows, unmapped_windows; 166 166 - 167 167 - /* 168 168 - * This numset is responsible for giving out numbers for each window in 169 169 - * the group. 170 170 - */ 171 171 - struct numset *numset; 172 172 - 173 173 - /* This structure can exist in a list. */ 174 174 - struct list_head node; 175 175 - }; 176 176 - 177 142 struct rp_global_screen { 178 143 Window root, wm_check; 179 144 unsigned long fg_color, bg_color, fw_color, bw_color; /* The pixel color. */ ··· 203 168 /* Virtual screen number, handled by rp_screen's vscreens_numset */ 204 169 int number; 205 170 171 171 + /* Name */ 172 172 + char *name; 173 173 + 174 174 + /* For determining the last vscreen. */ 175 175 + int last_access; 176 176 + 206 177 /* 207 178 * A list of frames that may or may not contain windows. There should 208 179 * always be one in the list. ··· 218 189 */ 219 190 int current_frame; 220 191 221 221 - struct numset *group_numset; 222 222 - struct list_head groups; 223 223 - rp_group *current_group; 192 192 + /* The list of windows participating in this vscreen. */ 193 193 + struct list_head mapped_windows, unmapped_windows; 194 194 + 195 195 + /* 196 196 + * This numset is responsible for giving out numbers for each window in 197 197 + * the vscreen. 198 198 + */ 199 199 + struct numset *numset; 224 200 225 201 struct list_head node; 226 202 }; ··· 388 364 int terminated; 389 365 390 366 /* what was current when it was launched? */ 391 391 - rp_group *group; 392 367 rp_frame *frame; 393 368 rp_screen *screen; 394 369 rp_vscreen *vscreen;

+10 -21

events.c

··· 48 48 void 49 49 show_rudeness_msg(rp_window *win, int raised) 50 50 { 51 51 - rp_group *g = groups_find_group_by_window(win); 52 52 - rp_window_elem *elem = group_find_window(&g->mapped_windows, win); 51 51 + rp_vscreen *v = win->vscr; 52 52 + rp_window_elem *elem = vscreen_find_window(&v->mapped_windows, win); 53 53 54 54 - if (win->vscr != rp_current_vscreen) { 55 55 - if (win->transient) 56 56 - marked_message_printf(0, 0, raised ? 57 57 - MESSAGE_RAISE_TRANSIENT_VSCREEN : 58 58 - MESSAGE_MAP_TRANSIENT_VSCREEN, 59 59 - elem->number, window_name(win), win->vscr->number); 60 60 - else 61 61 - marked_message_printf(0, 0, raised ? 62 62 - MESSAGE_RAISE_WINDOW_VSCREEN : 63 63 - MESSAGE_MAP_WINDOW_VSCREEN, 64 64 - elem->number, window_name(win), win->vscr->number); 65 65 - } else if (g == rp_current_group) { 54 54 + if (v == rp_current_vscreen) { 66 55 if (win->transient) 67 56 marked_message_printf(0, 0, raised ? 68 57 MESSAGE_RAISE_TRANSIENT : MESSAGE_MAP_TRANSIENT, ··· 74 63 } else { 75 64 if (win->transient) 76 65 marked_message_printf(0, 0, raised ? 77 77 - MESSAGE_RAISE_TRANSIENT_GROUP : 78 78 - MESSAGE_MAP_TRANSIENT_GROUP, 79 79 - elem->number, window_name(win), g->name); 66 66 + MESSAGE_RAISE_TRANSIENT_VSCREEN : 67 67 + MESSAGE_MAP_TRANSIENT_VSCREEN, 68 68 + elem->number, window_name(win), win->vscr->number); 80 69 else 81 70 marked_message_printf(0, 0, raised ? 82 82 - MESSAGE_RAISE_WINDOW_GROUP : MESSAGE_MAP_WINDOW_GROUP, 83 83 - elem->number, window_name(win), g->name); 71 71 + MESSAGE_RAISE_WINDOW_VSCREEN : 72 72 + MESSAGE_MAP_WINDOW_VSCREEN, 73 73 + elem->number, window_name(win), win->vscr->number); 84 74 } 85 75 } 86 76 ··· 385 375 PRINT_DEBUG(("Received _NET_CURRENT_DESKTOP = %ld\n", 386 376 ev->data.l[0])); 387 377 388 388 - v = vscreens_find_vscreen_by_number(s, ev->data.l[0]); 378 378 + v = screen_find_vscreen_by_number(s, ev->data.l[0]); 389 379 if (v) 390 380 set_current_vscreen(v); 391 381 } else { ··· 555 545 */ 556 546 child_info->window_mapped = 1; 557 547 } 558 558 - /* TODO: also adopt group information? */ 559 548 } 560 549 } else if (ev->xproperty.atom == XA_WM_NAME) { 561 550 PRINT_DEBUG(("updating window name\n"));

+1 -3

globals.c

··· 259 259 LIST_HEAD(rp_key_hook); 260 260 LIST_HEAD(rp_switch_win_hook); 261 261 LIST_HEAD(rp_switch_frame_hook); 262 262 - LIST_HEAD(rp_switch_group_hook); 263 262 LIST_HEAD(rp_switch_screen_hook); 264 263 LIST_HEAD(rp_quit_hook); 265 264 LIST_HEAD(rp_restart_hook); ··· 271 270 {{"key", &rp_key_hook}, 272 271 {"switchwin", &rp_switch_win_hook}, 273 272 {"switchframe", &rp_switch_frame_hook}, 274 274 - {"switchgroup", &rp_switch_group_hook}, 275 273 {"switchscreen", &rp_switch_screen_hook}, 276 274 {"deletewindow", &rp_delete_window_hook}, 277 275 {"quit", &rp_quit_hook}, ··· 592 590 593 591 list_for_each_safe_entry(cur, iter, tmp, &rp_screens, node) { 594 592 list_for_each_entry(vcur, &cur->vscreens, node) 595 595 - free_groups(vcur); 593 593 + vscreen_del(vcur); 596 594 597 595 list_del(&cur->node); 598 596 screen_free(cur);

-9

globals.h

··· 54 54 #define COMPLETION_NEXT 0 55 55 #define COMPLETION_PREVIOUS 1 56 56 57 57 - /* Error codes for group_delete_group() */ 58 58 - #define GROUP_DELETE_GROUP_OK 0 59 59 - #define GROUP_DELETE_GROUP_NONEMPTY 1 60 60 - #define GROUP_DELETE_LAST_GROUP 2 61 61 - 62 57 /* Font styles */ 63 58 #define STYLE_NORMAL 0 64 59 #define STYLE_INVERSE 1 65 65 - 66 66 - /* The list of groups. */ 67 67 - extern struct list_head rp_groups; 68 60 69 61 /* Whether or not we support xrandr */ 70 62 extern int rp_have_xrandr; ··· 181 173 extern struct list_head rp_key_hook; 182 174 extern struct list_head rp_switch_win_hook; 183 175 extern struct list_head rp_switch_frame_hook; 184 184 - extern struct list_head rp_switch_group_hook; 185 176 extern struct list_head rp_switch_screen_hook; 186 177 extern struct list_head rp_delete_window_hook; 187 178 extern struct list_head rp_quit_hook;

-718

group.c

··· 1 1 - /* 2 2 - * Copyright (C) 2000, 2001, 2002, 2003, 2004 Shawn Betts <sabetts@vcn.bc.ca> 3 3 - * 4 4 - * This program is free software; you can redistribute it and/or modify it 5 5 - * under the terms of the GNU General Public License as published by the Free 6 6 - * Software Foundation; either version 2 of the License, or (at your option) 7 7 - * any later version. 8 8 - * 9 9 - * This program is distributed in the hope that it will be useful, but WITHOUT 10 10 - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 11 11 - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for 12 12 - * more details. 13 13 - * 14 14 - * You should have received a copy of the GNU General Public License along with 15 15 - * this program; if not, write to the Free Software Foundation, Inc., 59 Temple 16 16 - * Place, Suite 330, Boston, MA 02111-1307 USA. 17 17 - */ 18 18 - 19 19 - #include "sdorfehs.h" 20 20 - 21 21 - #include <string.h> 22 22 - 23 23 - void group_insert_window(struct list_head *h, rp_window_elem *w); 24 24 - 25 25 - static void 26 26 - set_current_group_1(rp_group *g) 27 27 - { 28 28 - static int counter = 1; 29 29 - g->vscreen->current_group = g; 30 30 - g->last_access = counter++; 31 31 - } 32 32 - 33 33 - void 34 34 - init_groups(rp_vscreen *v) 35 35 - { 36 36 - rp_group *g; 37 37 - 38 38 - v->group_numset = numset_new(); 39 39 - INIT_LIST_HEAD(&v->groups); 40 40 - 41 41 - /* 42 42 - * Create the first group in the list (We always need at least one). 43 43 - */ 44 44 - g = group_new(v, numset_request(v->group_numset), DEFAULT_GROUP_NAME); 45 45 - set_current_group_1(g); 46 46 - list_add_tail(&g->node, &v->groups); 47 47 - } 48 48 - 49 49 - void 50 50 - free_groups(rp_vscreen *v) 51 51 - { 52 52 - rp_group *cur; 53 53 - struct list_head *iter, *tmp; 54 54 - 55 55 - list_for_each_safe_entry(cur, iter, tmp, &v->groups, node) { 56 56 - group_free(cur); 57 57 - } 58 58 - } 59 59 - 60 60 - struct numset * 61 61 - group_get_numset(rp_vscreen *v) 62 62 - { 63 63 - return v->group_numset; 64 64 - } 65 65 - 66 66 - /* 67 67 - * get the group list and store it in buffer delimiting each window with delim. 68 68 - * mark_start and mark_end will be filled with the text positions for the start 69 69 - * and end of the current window. 70 70 - */ 71 71 - void 72 72 - get_group_list(rp_vscreen *vscreen, char *delim, struct sbuf *buffer, 73 73 - int *mark_start, int *mark_end) 74 74 - { 75 75 - rp_group *cur, *last; 76 76 - 77 77 - if (buffer == NULL) 78 78 - return; 79 79 - 80 80 - sbuf_clear(buffer); 81 81 - 82 82 - last = group_last_group(vscreen); 83 83 - 84 84 - /* Generate the string. */ 85 85 - list_for_each_entry(cur, &vscreen->groups, node) { 86 86 - char *fmt; 87 87 - char separator; 88 88 - 89 89 - if (cur == vscreen->current_group) 90 90 - *mark_start = strlen(sbuf_get(buffer)); 91 91 - 92 92 - if (cur == vscreen->current_group) 93 93 - separator = '*'; 94 94 - else if (cur == last) 95 95 - separator = '+'; 96 96 - else 97 97 - separator = '-'; 98 98 - 99 99 - /* 100 100 - * A hack, pad the group with a space at the beginning and end 101 101 - * if there is no delimiter. 102 102 - */ 103 103 - if (!delim) 104 104 - sbuf_concat(buffer, " "); 105 105 - 106 106 - fmt = xsprintf("%d%c%s", cur->number, separator, cur->name); 107 107 - sbuf_concat(buffer, fmt); 108 108 - free(fmt); 109 109 - 110 110 - /* 111 111 - * A hack, pad the group with a space at the beginning and end 112 112 - * if there is no delimiter. 113 113 - */ 114 114 - if (!delim) 115 115 - sbuf_concat(buffer, " "); 116 116 - 117 117 - /* 118 118 - * Only put the delimiter between the group, and not after the 119 119 - * the last group. 120 120 - */ 121 121 - if (delim && cur->node.next != &vscreen->groups) 122 122 - sbuf_concat(buffer, delim); 123 123 - 124 124 - if (cur == vscreen->current_group) 125 125 - *mark_end = strlen(sbuf_get(buffer)); 126 126 - } 127 127 - } 128 128 - 129 129 - rp_group * 130 130 - group_new(rp_vscreen *vscreen, int number, char *name) 131 131 - { 132 132 - rp_group *g; 133 133 - 134 134 - g = xmalloc(sizeof(rp_group)); 135 135 - 136 136 - g->vscreen = vscreen; 137 137 - if (name) 138 138 - g->name = xstrdup(name); 139 139 - else 140 140 - g->name = NULL; 141 141 - g->last_access = 0; 142 142 - g->number = number; 143 143 - g->numset = numset_new(); 144 144 - INIT_LIST_HEAD(&g->unmapped_windows); 145 145 - INIT_LIST_HEAD(&g->mapped_windows); 146 146 - 147 147 - return g; 148 148 - } 149 149 - 150 150 - void 151 151 - group_free(rp_group *g) 152 152 - { 153 153 - free(g->name); 154 154 - numset_free(g->numset); 155 155 - numset_release(g->vscreen->group_numset, g->number); 156 156 - free(g); 157 157 - } 158 158 - 159 159 - rp_group * 160 160 - group_add_new_group(rp_vscreen *vscreen, char *name) 161 161 - { 162 162 - rp_group *g; 163 163 - rp_group *cur; 164 164 - 165 165 - g = group_new(vscreen, numset_request(vscreen->group_numset), name); 166 166 - 167 167 - list_for_each_entry(cur, &vscreen->groups, node) { 168 168 - if (cur->number > g->number) { 169 169 - list_add_tail(&g->node, &cur->node); 170 170 - return g; 171 171 - } 172 172 - } 173 173 - 174 174 - list_add_tail(&g->node, &vscreen->groups); 175 175 - 176 176 - return g; 177 177 - } 178 178 - 179 179 - void 180 180 - group_resort_group(rp_group *g) 181 181 - { 182 182 - rp_group *cur; 183 183 - struct list_head *last = &g->vscreen->groups; 184 184 - 185 185 - list_del(&g->node); 186 186 - list_for_each_entry(cur, &g->vscreen->groups, node) { 187 187 - if (cur->number > g->number) { 188 188 - list_add(&g->node, last); 189 189 - return; 190 190 - } 191 191 - last = &cur->node; 192 192 - } 193 193 - list_add(&g->node, last); 194 194 - } 195 195 - 196 196 - void 197 197 - group_rename(rp_group *g, char *name) 198 198 - { 199 199 - free(g->name); 200 200 - g->name = xstrdup(name); 201 201 - } 202 202 - 203 203 - rp_group * 204 204 - group_next_group(rp_vscreen *vscreen) 205 205 - { 206 206 - return list_next_entry(vscreen->current_group, &vscreen->groups, node); 207 207 - } 208 208 - 209 209 - rp_group * 210 210 - group_prev_group(rp_vscreen *vscreen) 211 211 - { 212 212 - return list_prev_entry(vscreen->current_group, &vscreen->groups, node); 213 213 - } 214 214 - 215 215 - rp_group * 216 216 - group_last_group(rp_vscreen *vscreen) 217 217 - { 218 218 - int last_access = 0; 219 219 - rp_group *most_recent = NULL; 220 220 - rp_group *cur; 221 221 - 222 222 - list_for_each_entry(cur, &vscreen->groups, node) { 223 223 - if (cur != vscreen->current_group && 224 224 - cur->last_access > last_access) { 225 225 - most_recent = cur; 226 226 - last_access = cur->last_access; 227 227 - } 228 228 - } 229 229 - return most_recent; 230 230 - } 231 231 - 232 232 - rp_group * 233 233 - groups_find_group_by_name(rp_vscreen *v, char *s, int exact_match) 234 234 - { 235 235 - rp_group *cur; 236 236 - 237 237 - if (!exact_match) { 238 238 - list_for_each_entry(cur, &v->groups, node) { 239 239 - if (cur->name && str_comp(s, cur->name, strlen(s))) 240 240 - return cur; 241 241 - } 242 242 - } else { 243 243 - list_for_each_entry(cur, &v->groups, node) { 244 244 - if (cur->name && !strcmp(cur->name, s)) 245 245 - return cur; 246 246 - } 247 247 - } 248 248 - 249 249 - return NULL; 250 250 - } 251 251 - 252 252 - rp_group * 253 253 - groups_find_group_by_number(rp_vscreen *v, int n) 254 254 - { 255 255 - rp_group *cur; 256 256 - 257 257 - list_for_each_entry(cur, &v->groups, node) { 258 258 - if (cur->number == n) 259 259 - return cur; 260 260 - } 261 261 - 262 262 - return NULL; 263 263 - } 264 264 - 265 265 - /* Return the first group that contains the window. */ 266 266 - rp_group * 267 267 - groups_find_group_by_window(rp_window *win) 268 268 - { 269 269 - rp_group *cur; 270 270 - rp_window_elem *elem; 271 271 - 272 272 - list_for_each_entry(cur, &win->vscr->groups, node) { 273 273 - elem = group_find_window(&cur->mapped_windows, win); 274 274 - if (elem) 275 275 - return cur; 276 276 - } 277 277 - 278 278 - return NULL; 279 279 - } 280 280 - 281 281 - 282 282 - /* Return the first group that is g. */ 283 283 - rp_group * 284 284 - groups_find_group_by_group(rp_group *g) 285 285 - { 286 286 - rp_group *cur; 287 287 - 288 288 - list_for_each_entry(cur, &g->vscreen->groups, node) { 289 289 - if (cur == g) 290 290 - return cur; 291 291 - } 292 292 - 293 293 - return NULL; 294 294 - } 295 295 - 296 296 - rp_window_elem * 297 297 - group_find_window(struct list_head *list, rp_window *win) 298 298 - { 299 299 - rp_window_elem *cur; 300 300 - 301 301 - list_for_each_entry(cur, list, node) { 302 302 - if (cur->win == win) 303 303 - return cur; 304 304 - } 305 305 - 306 306 - return NULL; 307 307 - } 308 308 - 309 309 - rp_window_elem * 310 310 - group_find_window_by_number(rp_group *g, int num) 311 311 - { 312 312 - rp_window_elem *cur; 313 313 - 314 314 - list_for_each_entry(cur, &g->mapped_windows, node) { 315 315 - if (cur->number == num) 316 316 - return cur; 317 317 - } 318 318 - 319 319 - return NULL; 320 320 - 321 321 - } 322 322 - 323 323 - /* 324 324 - * Insert a window_elem into the correct spot in the group's window list to 325 325 - * preserve window number ordering. 326 326 - */ 327 327 - void 328 328 - group_insert_window(struct list_head *h, rp_window_elem *w) 329 329 - { 330 330 - rp_window_elem *cur; 331 331 - 332 332 - list_for_each_entry(cur, h, node) { 333 333 - if (cur->number > w->number) { 334 334 - list_add_tail(&w->node, &cur->node); 335 335 - return; 336 336 - } 337 337 - } 338 338 - 339 339 - list_add_tail(&w->node, h); 340 340 - } 341 341 - 342 342 - static int 343 343 - group_in_list(struct list_head *h, rp_window_elem *w) 344 344 - { 345 345 - rp_window_elem *cur; 346 346 - 347 347 - list_for_each_entry(cur, h, node) { 348 348 - if (cur == w) 349 349 - return 1; 350 350 - } 351 351 - 352 352 - return 0; 353 353 - } 354 354 - 355 355 - /* 356 356 - * If a window_elem's number has changed then the list has to be resorted. 357 357 - */ 358 358 - void 359 359 - group_resort_window(rp_group *g, rp_window_elem *w) 360 360 - { 361 361 - /* Only a mapped window can be resorted. */ 362 362 - if (!group_in_list(&g->mapped_windows, w)) { 363 363 - PRINT_DEBUG(("Attempting to restort an unmapped window!\n")); 364 364 - return; 365 365 - } 366 366 - list_del(&w->node); 367 367 - group_insert_window(&g->mapped_windows, w); 368 368 - } 369 369 - 370 370 - void 371 371 - group_add_window(rp_group *g, rp_window *w) 372 372 - { 373 373 - rp_window_elem *we; 374 374 - 375 375 - /* Create our container structure for the window. */ 376 376 - we = xmalloc(sizeof(rp_window_elem)); 377 377 - we->win = w; 378 378 - we->number = -1; 379 379 - 380 380 - /* Finally, add it to our list. */ 381 381 - list_add_tail(&we->node, &g->unmapped_windows); 382 382 - } 383 383 - 384 384 - void 385 385 - group_map_window(rp_group *g, rp_window *win) 386 386 - { 387 387 - rp_window_elem *we; 388 388 - 389 389 - we = group_find_window(&g->unmapped_windows, win); 390 390 - 391 391 - if (we) { 392 392 - we->number = numset_request(g->numset); 393 393 - list_del(&we->node); 394 394 - group_insert_window(&g->mapped_windows, we); 395 395 - } 396 396 - } 397 397 - 398 398 - void 399 399 - groups_map_window(rp_vscreen *vscreen, rp_window *win) 400 400 - { 401 401 - rp_group *cur; 402 402 - 403 403 - list_for_each_entry(cur, &vscreen->groups, node) { 404 404 - group_map_window(cur, win); 405 405 - } 406 406 - } 407 407 - 408 408 - void 409 409 - group_unmap_window(rp_group *g, rp_window *win) 410 410 - { 411 411 - rp_window_elem *we; 412 412 - 413 413 - we = group_find_window(&g->mapped_windows, win); 414 414 - 415 415 - if (we) { 416 416 - numset_release(g->numset, we->number); 417 417 - list_move_tail(&we->node, &g->unmapped_windows); 418 418 - } 419 419 - } 420 420 - 421 421 - void 422 422 - groups_unmap_window(rp_window *win) 423 423 - { 424 424 - rp_group *cur; 425 425 - 426 426 - list_for_each_entry(cur, &win->vscr->groups, node) { 427 427 - group_unmap_window(cur, win); 428 428 - } 429 429 - } 430 430 - 431 431 - void 432 432 - group_del_window(rp_group *g, rp_window *win) 433 433 - { 434 434 - rp_window_elem *cur; 435 435 - struct list_head *iter, *tmp; 436 436 - 437 437 - /* The assumption is that a window is unmapped before it's deleted. */ 438 438 - list_for_each_safe_entry(cur, iter, tmp, &g->unmapped_windows, node) { 439 439 - if (cur->win == win) { 440 440 - list_del(&cur->node); 441 441 - free(cur); 442 442 - } 443 443 - } 444 444 - 445 445 - /* 446 446 - * Make sure the window isn't in the list of mapped windows. This would 447 447 - * mean there is a bug. 448 448 - */ 449 449 - #ifdef DEBUG 450 450 - list_for_each_entry(cur, &g->mapped_windows, node) { 451 451 - if (cur->win == win) 452 452 - PRINT_DEBUG(("This window wasn't removed from the " 453 453 - "mapped window list.\n")); 454 454 - } 455 455 - #endif 456 456 - } 457 457 - 458 458 - /* Remove the window from any groups in resides in. */ 459 459 - void 460 460 - groups_del_window(rp_window *win) 461 461 - { 462 462 - rp_group *cur; 463 463 - 464 464 - list_for_each_entry(cur, &win->vscr->groups, node) { 465 465 - group_del_window(cur, win); 466 466 - } 467 467 - } 468 468 - 469 469 - rp_window * 470 470 - group_last_window(rp_group *g) 471 471 - { 472 472 - rp_frame *f; 473 473 - rp_window_elem *most_recent = NULL; 474 474 - rp_window_elem *cur; 475 475 - int last_access = 0; 476 476 - 477 477 - f = current_frame(g->vscreen); 478 478 - list_for_each_entry(cur, &g->mapped_windows, node) { 479 479 - if (cur->win->sticky_frame != EMPTY && 480 480 - (!f || (cur->win->sticky_frame != f->number))) 481 481 - continue; 482 482 - 483 483 - if (cur->win->last_access >= last_access 484 484 - && cur->win != current_window() 485 485 - && !find_windows_frame(cur->win) 486 486 - && (cur->win->vscr == g->vscreen || rp_have_xrandr)) { 487 487 - most_recent = cur; 488 488 - last_access = cur->win->last_access; 489 489 - } 490 490 - } 491 491 - 492 492 - if (most_recent) 493 493 - return most_recent->win; 494 494 - 495 495 - return NULL; 496 496 - } 497 497 - 498 498 - rp_window * 499 499 - group_next_window(rp_group *g, rp_window *win) 500 500 - { 501 501 - rp_window_elem *cur, *we; 502 502 - rp_frame *f; 503 503 - 504 504 - /* If there is no window, then get the last accessed one. */ 505 505 - if (win == NULL) 506 506 - return group_last_window(g); 507 507 - 508 508 - /* 509 509 - * If we can't find the window, then it's in a different group, so get 510 510 - * the last accessed one in this group. 511 511 - */ 512 512 - we = group_find_window(&g->mapped_windows, win); 513 513 - if (we == NULL) 514 514 - return group_last_window(g); 515 515 - 516 516 - /* 517 517 - * The window is in this group, so find the next one in the list that 518 518 - * isn't already displayed. 519 519 - */ 520 520 - f = current_frame(g->vscreen); 521 521 - for (cur = list_next_entry(we, &g->mapped_windows, node); 522 522 - cur != we; 523 523 - cur = list_next_entry(cur, &g->mapped_windows, node)) { 524 524 - if (cur->win->sticky_frame != EMPTY && 525 525 - (!f || (cur->win->sticky_frame != f->number))) 526 526 - continue; 527 527 - 528 528 - if (!find_windows_frame(cur->win) && 529 529 - (cur->win->vscr == win->vscr || rp_have_xrandr)) 530 530 - return cur->win; 531 531 - } 532 532 - 533 533 - return NULL; 534 534 - } 535 535 - 536 536 - rp_window * 537 537 - group_prev_window(rp_group *g, rp_window *win) 538 538 - { 539 539 - rp_window_elem *cur, *we; 540 540 - rp_frame *f; 541 541 - 542 542 - /* If there is no window, then get the last accessed one. */ 543 543 - if (win == NULL) 544 544 - return group_last_window(g); 545 545 - 546 546 - /* 547 547 - * If we can't find the window, then it's in a different group, so get 548 548 - * the last accessed one in this group. 549 549 - */ 550 550 - we = group_find_window(&g->mapped_windows, win); 551 551 - if (we == NULL) 552 552 - return group_last_window(g); 553 553 - 554 554 - /* 555 555 - * The window is in this group, so find the previous one in the list 556 556 - * that isn't already displayed. 557 557 - */ 558 558 - f = current_frame(g->vscreen); 559 559 - for (cur = list_prev_entry(we, &g->mapped_windows, node); 560 560 - cur != we; 561 561 - cur = list_prev_entry(cur, &g->mapped_windows, node)) { 562 562 - if (cur->win->sticky_frame != EMPTY && 563 563 - (!f || (cur->win->sticky_frame != f->number))) 564 564 - continue; 565 565 - 566 566 - if (!find_windows_frame(cur->win) && 567 567 - (cur->win->vscr == win->vscr || rp_have_xrandr)) 568 568 - return cur->win; 569 569 - } 570 570 - 571 571 - return NULL; 572 572 - 573 573 - } 574 574 - 575 575 - void 576 576 - group_move_window(rp_group *to, rp_window *win) 577 577 - { 578 578 - rp_group *cur, *from = NULL; 579 579 - rp_window_elem *we = NULL; 580 580 - 581 581 - /* 582 582 - * Find the group that the window belongs to. FIXME: If the window 583 583 - * exists in multiple groups, then we're going to find the first group 584 584 - * with this window in it. 585 585 - */ 586 586 - list_for_each_entry(cur, &win->vscr->groups, node) { 587 587 - we = group_find_window(&cur->mapped_windows, win); 588 588 - if (we) { 589 589 - from = cur; 590 590 - break; 591 591 - } 592 592 - } 593 593 - 594 594 - if (we == NULL || from == NULL) { 595 595 - PRINT_DEBUG(("Unable to find window in mapped window lists.\n")); 596 596 - return; 597 597 - } 598 598 - /* Manually remove the window from one group... */ 599 599 - numset_release(from->numset, we->number); 600 600 - list_del(&we->node); 601 601 - 602 602 - /* and shove it into the other one. */ 603 603 - we->number = numset_request(to->numset); 604 604 - group_insert_window(&to->mapped_windows, we); 605 605 - } 606 606 - 607 607 - void 608 608 - groups_merge(rp_group *from, rp_group *to) 609 609 - { 610 610 - rp_window_elem *cur; 611 611 - struct list_head *iter, *tmp; 612 612 - 613 613 - /* Merging a group with itself makes no sense. */ 614 614 - if (from == to) 615 615 - return; 616 616 - 617 617 - /* Move the unmapped windows. */ 618 618 - list_for_each_safe_entry(cur, iter, tmp, &from->unmapped_windows, node) { 619 619 - list_del(&cur->node); 620 620 - list_add_tail(&cur->node, &to->unmapped_windows); 621 621 - } 622 622 - 623 623 - /* Move the mapped windows. */ 624 624 - list_for_each_safe_entry(cur, iter, tmp, &from->mapped_windows, node) { 625 625 - numset_release(from->numset, cur->number); 626 626 - list_del(&cur->node); 627 627 - 628 628 - cur->number = numset_request(to->numset); 629 629 - group_insert_window(&to->mapped_windows, cur); 630 630 - } 631 631 - } 632 632 - 633 633 - void 634 634 - set_current_group(rp_group *g) 635 635 - { 636 636 - if (g == NULL || g->vscreen->current_group == g) 637 637 - return; 638 638 - 639 639 - set_current_group_1(g); 640 640 - 641 641 - /* Call the switch group hook. */ 642 642 - hook_run(&rp_switch_group_hook); 643 643 - } 644 644 - 645 645 - int 646 646 - group_delete_group(rp_group *g) 647 647 - { 648 648 - if (list_empty(&(g->mapped_windows)) 649 649 - && list_empty(&(g->unmapped_windows))) { 650 650 - /* don't delete the last group */ 651 651 - if (list_size(&g->vscreen->groups) == 1) 652 652 - return GROUP_DELETE_LAST_GROUP; 653 653 - 654 654 - /* we can safely delete the group */ 655 655 - if (g == g->vscreen->current_group) { 656 656 - rp_group *next = group_last_group(g->vscreen); 657 657 - set_current_group(next ? next : 658 658 - group_next_group(g->vscreen)); 659 659 - } 660 660 - list_del(&(g->node)); 661 661 - group_free(g); 662 662 - return GROUP_DELETE_GROUP_OK; 663 663 - } else { 664 664 - return GROUP_DELETE_GROUP_NONEMPTY; 665 665 - } 666 666 - } 667 667 - 668 668 - /* Used by :cother / :iother */ 669 669 - rp_window * 670 670 - group_last_window_by_class(rp_group *g, char *class) 671 671 - { 672 672 - int last_access = 0; 673 673 - rp_window_elem *most_recent = NULL; 674 674 - rp_window_elem *cur; 675 675 - rp_vscreen *v = rp_current_vscreen; 676 676 - 677 677 - list_for_each_entry(cur, &g->mapped_windows, node) { 678 678 - if (cur->win->last_access >= last_access 679 679 - && cur->win != current_window() 680 680 - && !find_windows_frame(cur->win) 681 681 - && (cur->win->vscr == v || rp_have_xrandr) 682 682 - && strcmp(class, cur->win->res_class)) { 683 683 - most_recent = cur; 684 684 - last_access = cur->win->last_access; 685 685 - } 686 686 - } 687 687 - 688 688 - if (most_recent) 689 689 - return most_recent->win; 690 690 - 691 691 - return NULL; 692 692 - } 693 693 - 694 694 - /* Used by :cother / :iother */ 695 695 - rp_window * 696 696 - group_last_window_by_class_complement(rp_group *g, char *class) 697 697 - { 698 698 - int last_access = 0; 699 699 - rp_window_elem *most_recent = NULL; 700 700 - rp_window_elem *cur; 701 701 - rp_vscreen *v = rp_current_vscreen; 702 702 - 703 703 - list_for_each_entry(cur, &g->mapped_windows, node) { 704 704 - if (cur->win->last_access >= last_access 705 705 - && cur->win != current_window() 706 706 - && !find_windows_frame(cur->win) 707 707 - && (cur->win->vscr == v || rp_have_xrandr) 708 708 - && !strcmp(class, cur->win->res_class)) { 709 709 - most_recent = cur; 710 710 - last_access = cur->win->last_access; 711 711 - } 712 712 - } 713 713 - 714 714 - if (most_recent) 715 715 - return most_recent->win; 716 716 - 717 717 - return NULL; 718 718 - }

-75

group.h

··· 1 1 - /* 2 2 - * Copyright (C) 2000, 2001, 2002, 2003, 2004 Shawn Betts <sabetts@vcn.bc.ca> 3 3 - * 4 4 - * This program is free software; you can redistribute it and/or modify it 5 5 - * under the terms of the GNU General Public License as published by the Free 6 6 - * Software Foundation; either version 2 of the License, or (at your option) 7 7 - * any later version. 8 8 - * 9 9 - * This program is distributed in the hope that it will be useful, but WITHOUT 10 10 - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 11 11 - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for 12 12 - * more details. 13 13 - * 14 14 - * You should have received a copy of the GNU General Public License along with 15 15 - * this program; if not, write to the Free Software Foundation, Inc., 59 Temple 16 16 - * Place, Suite 330, Boston, MA 02111-1307 USA. 17 17 - */ 18 18 - 19 19 - #ifndef GROUP_H 20 20 - #define GROUP_H 21 21 - 22 22 - void init_groups(rp_vscreen *v); 23 23 - void free_groups(rp_vscreen *v); 24 24 - 25 25 - void group_add_window(rp_group *g, rp_window *w); 26 26 - void group_resort_window(rp_group *g, rp_window_elem *w); 27 27 - void group_free(rp_group *g); 28 28 - rp_group *group_new(rp_vscreen *vscreen, int number, char *name); 29 29 - int group_delete_group(rp_group *g); 30 30 - 31 31 - void group_del_window(rp_group *g, rp_window *win); 32 32 - void groups_del_window(rp_window *win); 33 33 - 34 34 - void group_map_window(rp_group *g, rp_window *win); 35 35 - void groups_map_window(rp_vscreen *v, rp_window *win); 36 36 - 37 37 - void group_unmap_window(rp_group *g, rp_window *win); 38 38 - void groups_unmap_window(rp_window *win); 39 39 - 40 40 - struct numset *group_get_numset(rp_vscreen *v); 41 41 - void get_group_list(rp_vscreen *v, char *delim, struct sbuf *buffer, 42 42 - int *mark_start, int *mark_end); 43 43 - 44 44 - rp_window *group_prev_window(rp_group *g, rp_window *win); 45 45 - rp_window *group_next_window(rp_group *g, rp_window *win); 46 46 - rp_group *groups_find_group_by_name(rp_vscreen *v, char *s, int exact_match); 47 47 - rp_group *groups_find_group_by_number(rp_vscreen *v, int n); 48 48 - rp_group *groups_find_group_by_window(rp_window *win); 49 49 - rp_group *groups_find_group_by_group(rp_group *g); 50 50 - 51 51 - rp_window *group_last_window(rp_group *g); 52 52 - 53 53 - rp_group *group_prev_group(rp_vscreen *vscreen); 54 54 - rp_group *group_next_group(rp_vscreen *vscreen); 55 55 - rp_group *group_last_group(rp_vscreen *vscreen); 56 56 - 57 57 - void group_resort_group(rp_group *g); 58 58 - 59 59 - rp_group *group_add_new_group(rp_vscreen *vscreen, char *name); 60 60 - void group_rename(rp_group *g, char *name); 61 61 - 62 62 - rp_window_elem *group_find_window(struct list_head *list, rp_window *win); 63 63 - rp_window_elem *group_find_window_by_number(rp_group *g, int num); 64 64 - 65 65 - void group_move_window(rp_group *to, rp_window *win); 66 66 - void groups_merge(rp_group *from, rp_group *to); 67 67 - 68 68 - void set_current_group(rp_group *g); 69 69 - 70 70 - rp_window *group_last_window_by_class(rp_group *g, char *class); 71 71 - rp_window *group_last_window_by_class_complement(rp_group *g, char *class); 72 72 - 73 73 - rp_group *current_group(void); 74 74 - #define rp_current_group (rp_current_screen->current_vscreen->current_group) 75 75 - #endif

+1 -1

history.h

··· 22 22 enum { 23 23 hist_NONE = 0, hist_COMMAND, hist_SHELLCMD, 24 24 hist_SELECT, hist_KEYMAP, hist_KEY, 25 25 - hist_WINDOW, hist_GRAVITY, hist_GROUP, 25 25 + hist_WINDOW, hist_GRAVITY, hist_VSCREEN, 26 26 hist_HOOK, hist_VARIABLE, hist_PROMPT, 27 27 hist_OTHER, 28 28 /* must be last, do not use, for length only: */

+4 -5

manage.c

··· 392 392 unmanage(rp_window *w) 393 393 { 394 394 list_del(&w->node); 395 395 - groups_del_window(w); 395 395 + vscreen_del_window(w->vscr, w); 396 396 397 397 remove_atom(rp_glob_screen.root, _net_client_list, XA_WINDOW, w->w); 398 398 remove_atom(rp_glob_screen.root, _net_client_list_stacking, XA_WINDOW, ··· 840 840 list_del(&win->node); 841 841 insert_into_list(win, &rp_mapped_window); 842 842 843 843 - /* Update all groups. */ 844 844 - groups_map_window(win->vscr, win); 843 843 + vscreen_map_window(win->vscr, win); 845 844 846 845 /* 847 846 * The window has never been accessed since it was brought back from the ··· 939 938 940 939 list_move_tail(&win->node, &rp_unmapped_window); 941 940 942 942 - /* Update the groups. */ 943 943 - groups_unmap_window(win); 941 941 + /* Update the vscreens. */ 942 942 + vscreen_unmap_window(win->vscr, win); 944 943 945 944 ignore_badwindow++; 946 945

+1 -5

messages.h

··· 28 28 29 29 #define MESSAGE_RAISE_TRANSIENT "Raise request from transient window %d (%s)" 30 30 #define MESSAGE_RAISE_WINDOW "Raise request from window %d (%s)" 31 31 - #define MESSAGE_RAISE_TRANSIENT_GROUP "Raise request from transient window %d (%s) in group %s" 32 32 - #define MESSAGE_RAISE_WINDOW_GROUP "Raise request from window %d (%s) in group %s" 33 31 #define MESSAGE_RAISE_TRANSIENT_VSCREEN "Raise request from transient window %d (%s) on vscreen %d" 34 32 #define MESSAGE_RAISE_WINDOW_VSCREEN "Raise request from window %d (%s) on vscreen %d" 35 33 #define MESSAGE_MAP_TRANSIENT "New transient window %d (%s)" 36 34 #define MESSAGE_MAP_WINDOW "New window %d (%s)" 37 37 - #define MESSAGE_MAP_TRANSIENT_GROUP "New transient window %d (%s) in group %s" 38 38 - #define MESSAGE_MAP_WINDOW_GROUP "New window %d (%s) in group %s" 39 35 #define MESSAGE_MAP_TRANSIENT_VSCREEN "New transient window %d (%s) on vscreen %d" 40 36 #define MESSAGE_MAP_WINDOW_VSCREEN "New window %d (%s) on vscreen %d" 41 37 ··· 44 40 #define MESSAGE_PROMPT_SHELL_COMMAND "/bin/sh -c " 45 41 #define MESSAGE_PROMPT_COMMAND ":" 46 42 #define MESSAGE_PROMPT_XTERM_COMMAND MESSAGE_PROMPT_SHELL_COMMAND TERM_PROG " -e " 47 47 - #define MESSAGE_PROMPT_SWITCH_TO_GROUP "Switch to group: " 43 43 + #define MESSAGE_PROMPT_SWITCH_TO_VSCREEN "Switch to vscreen: " 48 44 #define MESSAGE_PROMPT_SELECT_VAR "Variable: " 49 45 #define MESSAGE_PROMPT_VAR_VALUE "Value: " 50 46

+18 -66

sdorfehs.1

··· 160 160 .It Cm switchframe 161 161 Run after a frame actually switched, but before the window in it is 162 162 focused. 163 163 - .It Cm switchgroup 164 164 - Run after selecting a new group. 165 163 .It Cm switchscreen 166 164 Run when the user switches to a different screen. 167 165 .It Cm switchwin ··· 215 213 .It Ic cother 216 214 Like 217 215 .Ic other 218 218 - but switch to the window of the current group that was last accessed and 216 216 + but switch to the window of the current vscreen that was last accessed and 219 217 has another resource class but is not currently visible. 220 218 .It Ic curframe Pq Ic C\-a F 221 219 Show a bar marking the current frame. ··· 380 378 .Ic set Ns 381 379 ting 382 380 .Ar framesels . 383 383 - .It Ic gdelete Op Ar group 384 384 - If the optional argument 385 385 - .Ar group 386 386 - is supplied, delete 387 387 - .Ar group . 388 388 - Otherwise delete the current group. 389 389 - If the last group is deleted, a new group with name 390 390 - .Li default 391 391 - is created. 392 392 - The group has to be empty, otherwise it cannot be deleted. 393 381 .It Ic getenv Ar variable 394 382 Output the value of the environment variable 395 383 .Ar variable . 396 384 .It Ic getsel 397 385 Paste the current X Selection into the current window. 398 398 - .It Ic gmerge Ar group 399 399 - Move all windows from group 400 400 - .Ar group 401 401 - into the current group. 402 402 - .It Ic gmove Ar group 403 403 - Move the current window into group 404 404 - .Ar group . 405 405 - .It Ic gnew Ar group 406 406 - Create a new group with name 407 407 - .Ar group 408 408 - and select it. 409 409 - Most window commands only see (and thus select, consider next, 410 410 - previous or last) windows within the group active when they are 411 411 - issued. 412 412 - .It Ic gnewbg Ar group 413 413 - Create a new group named 414 414 - .Ar group , 415 415 - but do not select it. 416 416 - .It Ic gnext 417 417 - Select the next group. 418 418 - Most window commands only see windows in the effective group. 419 419 - .It Ic gnumber Op Ar old new 420 420 - Give the number 421 421 - .Ar new 422 422 - to the group with the number 423 423 - .Ar old 424 424 - or the current group. 425 425 - .It Ic gother 426 426 - Select the last accessed group. 427 427 - Most window commands only see windows in the effective group. 428 428 - .It Ic gprev 429 429 - Select the prior group. 430 430 - Most window commands only see windows in the effective group. 431 386 .It Ic gravity Op Cm nw | w | sw | n | c | s | ne | e | se 432 387 Change how in its frame the current window is aligned. 433 433 - .It Ic grename 434 434 - Rename current group. 435 435 - .It Ic groups 436 436 - Output a list of all groups with their number. 437 437 - .It Ic gselect Ar group 438 438 - Select the group named 439 439 - .Ar group . 440 388 .It Ic help Op Ar keymap 441 389 If the optional parameter 442 390 .Ar keymap ··· 490 438 .It Ic iother 491 439 Like 492 440 .Ic other 493 493 - but switch to the window of the current group that was last accessed and 441 441 + but switch to the window of the current vscreen that was last accessed and 494 442 has the same resource class but is not currently visible. 495 443 .It Ic kill Pq Ic C\-a K 496 444 Close the X-connection of the X-client responsible for the current window. ··· 530 478 and can be called with 531 479 .Ic readkey . 532 480 .It Ic next Pq Ic C\-a Return | C\-a n | C\-a space 533 533 - Switch to the next window in the current group. 481 481 + Switch to the next window in the current vscreen. 534 482 .It Ic nextscreen Pq Ic C\-a N 535 483 Switch to the next screen. (If you have multiple physical ones.) 536 484 .It Ic number Ar new Op Ar old ··· 543 491 Remove all frames on the current screen except the current frame and 544 492 maximize this one to the size of the whole screen. 545 493 .It Ic other Pq Ic C\-a C\-a 546 546 - Switch to the window of the current group that was last 494 494 + Switch to the window of the current vscreen that was last 547 495 accessed but is not currently visible. 548 496 .It Ic prev Pq Ic C\-a p 549 549 - Switch to the previous window in the current group. 497 497 + Switch to the previous window in the current vscreen. 550 498 .It Ic prevscreen Pq Ic C\-a P 551 499 Switch to the previous screen. (If you have multiple physical ones.) 552 500 .It Ic prompt Op Ar prompt ··· 675 623 .It Ic select ( Cm \- | Ar name | Ar number ) Pq Ic C\-a \&' 676 624 If a number is given, switch to the window with number 677 625 .Ar number . 678 678 - If a name is given, switch to the window in the current group with 626 626 + If a name is given, switch to the window in the current vscreen with 679 627 name 680 628 .Ar name . 681 629 Blank the current frame, if ··· 788 736 after showing a message with the command. 789 737 .It Ic version Pq Ic C\-a v 790 738 Output version and compile time information. 791 791 - .It Ic vselect Oo Ar vscreenno Oc 792 792 - Switch to the virtual screen numbered 793 793 - .Ar vscreenno . 794 794 - .It Ic vmove Oo Ar vscreenno Oc 795 795 - Move the current window to the virtual screen numbered 796 796 - .Ar vscreenno . 739 739 + .It Ic vmove Oo Ar vscreen Oc 740 740 + Move the current window to the virtual screen 741 741 + .Ar vscreen . 742 742 + .It Ic vrename 743 743 + Rename current vscreen. 744 744 + .It Ic vscreens 745 745 + Output a list of all vscreens with their number. 746 746 + .It Ic vselect Ar vscreen 747 747 + Select the vscreen named 748 748 + .Ar vscreen . 797 749 .It Ic vsplit Oo Ar l Ns Li / Ns Ar p | Ar "pixels-from-top" | Li \- Ns Ar "pixels-from-bottom" Oc Pq Ic C\-a s 798 750 Split the current frame into upper frame and a lower frame. 799 751 If no parameter is given, split in halves. ··· 818 770 in front of the number or not. 819 771 .It Ic windows Oo Ar format Oc Pq Ic C\-a w 820 772 In interactive mode, 821 821 - show the list of all windows in the current group for the duration 773 773 + show the list of all windows in the current vscreen for the duration 822 774 specified by the variable 823 775 .Va msgwait . 824 776 If ··· 897 849 .Li %20t 898 850 .Pc 899 851 .Pp 900 900 - In non\-interactive mode, output the list of windows in the current group 852 852 + In non\-interactive mode, output the list of windows in the current vscreen 901 853 line by line. 902 854 The format string can be overwritten by the optional parameter 903 855 .Ar format .

-1

sdorfehs.h

··· 78 78 #include "frame.h" 79 79 #include "screen.h" 80 80 #include "vscreen.h" 81 81 - #include "group.h" 82 81 #include "editor.h" 83 82 #include "history.h" 84 83 #include "completions.h"

+6 -12

split.c

··· 265 265 rp_window_elem *most_recent = NULL; 266 266 rp_window_elem *cur; 267 267 268 268 - list_for_each_entry(cur, &rp_current_group->mapped_windows, node) { 269 269 - if ((cur->win->vscr == v || rp_have_xrandr) 270 270 - && cur->win != current_window() 268 268 + list_for_each_entry(cur, &v->mapped_windows, node) { 269 269 + if (cur->win != current_window() 271 270 && cur->win->sticky_frame != frame->number 272 271 && !find_windows_frame(cur->win) 273 272 && cur->win->last_access >= last_access ··· 937 936 frame = current_frame(rp_current_vscreen); 938 937 win = current_window(); 939 938 if (win) { 940 940 - rp_group *g; 941 941 - 942 942 - g = groups_find_group_by_window(win); 943 943 - if (g) 944 944 - elem = group_find_window(&g->mapped_windows, win); 945 945 - else 946 946 - warnx("window 0x%lx not in any group\n", 939 939 + elem = vscreen_find_window(&win->vscr->mapped_windows, win); 940 940 + if (!elem) 941 941 + warnx("window 0x%lx not on any vscreen\n", 947 942 (unsigned long)win->w); 948 943 } 949 944 /* A frame doesn't always contain a window. */ 950 945 msgbuf = sbuf_new(0); 951 946 if (elem) 952 947 format_string(msg, elem, msgbuf); 953 953 - else { 948 948 + else 954 949 sbuf_concat(msgbuf, EMPTY_FRAME_MESSAGE); 955 955 - } 956 950 957 951 width = defaults.bar_x_padding * 2 958 952 + rp_text_width(s, msgbuf->data, msgbuf->len, NULL);

+485 -38

vscreen.c

··· 22 22 rp_vscreen *vscreen_next(void); 23 23 rp_vscreen *vscreen_prev(void); 24 24 25 25 + static int vscreen_access = 1; 26 26 + 25 27 void 26 28 init_vscreen(rp_vscreen *v, rp_screen *s) 27 29 { 28 30 v->screen = s; 29 31 v->number = numset_request(s->vscreens_numset); 30 32 v->frames_numset = numset_new(); 33 33 + v->numset = numset_new(); 34 34 + v->last_access = 0; 31 35 32 32 - init_groups(v); 36 36 + if (v->number == 0) 37 37 + v->name = xstrdup(DEFAULT_VSCREEN_NAME); 38 38 + else 39 39 + v->name = xsprintf("%d", v->number); 40 40 + 41 41 + INIT_LIST_HEAD(&v->unmapped_windows); 42 42 + INIT_LIST_HEAD(&v->mapped_windows); 33 43 } 34 44 35 45 void ··· 40 50 rp_window *cur; 41 51 42 52 if (v->number != 0) 43 43 - target = vscreens_find_vscreen_by_number(s, 0); 53 53 + target = screen_find_vscreen_by_number(s, 0); 44 54 45 55 list_for_each_entry(cur, &rp_mapped_window, node) { 46 56 if (cur->vscr == v && target) ··· 105 115 106 116 if (scr->current_vscreen == cur) 107 117 set_current_vscreen( 108 108 - vscreens_find_vscreen_by_number(scr, 118 118 + screen_find_vscreen_by_number(scr, 109 119 0)); 110 120 111 121 vscreen_del(cur); ··· 127 137 return 0; 128 138 } 129 139 130 130 - rp_vscreen * 131 131 - vscreens_find_vscreen_by_number(rp_screen *s, int n) 132 132 - { 133 133 - rp_vscreen *cur; 134 134 - 135 135 - list_for_each_entry(cur, &s->vscreens, node) { 136 136 - if (cur->number == n) 137 137 - return cur; 138 138 - } 139 139 - 140 140 - return NULL; 141 141 - } 142 142 - 143 140 /* Returns a pointer to a list of frames. */ 144 141 struct list_head * 145 142 vscreen_copy_frameset(rp_vscreen *v) ··· 246 243 247 244 rp_current_screen = v->screen; 248 245 v->screen->current_vscreen = v; 246 246 + v->last_access = vscreen_access++; 249 247 250 248 list_for_each_entry(frame, &rp_current_vscreen->frames, node) { 251 249 if (frame->restore_win_number == EMPTY) ··· 287 285 } 288 286 289 287 void 290 290 - vscreen_move_window(rp_vscreen *v, rp_window *w) 288 288 + vscreen_move_window(rp_vscreen *to, rp_window *w) 291 289 { 292 292 - rp_group *cur, *oldg = NULL; 293 293 - rp_window_elem *we = NULL; 294 294 - rp_window *last; 290 290 + rp_vscreen *from = w->vscr; 295 291 rp_frame *f; 292 292 + rp_window_elem *we; 296 293 297 297 - /* find the group this window is currently in */ 298 298 - list_for_each_entry(cur, &w->vscr->groups, node) { 299 299 - we = group_find_window(&cur->mapped_windows, w); 300 300 - if (we) { 301 301 - oldg = cur; 302 302 - break; 303 303 - } 294 294 + we = vscreen_find_window(&from->mapped_windows, w); 295 295 + if (we == NULL) { 296 296 + PRINT_DEBUG(("Unable to find window in mapped window lists.\n")); 297 297 + return; 304 298 } 305 299 306 306 - /* and its frame */ 307 300 f = find_windows_frame(w); 308 308 - 309 309 - /* move it to the new vscreen in its current group */ 310 310 - group_move_window(v->current_group, w); 311 311 - w->vscr = v; 301 301 + w->vscr = to; 312 302 w->sticky_frame = EMPTY; 313 303 314 304 /* forget that this window was in the frame it was in */ 315 305 if (f) 316 306 f->win_number = EMPTY; 317 307 318 318 - /* cycle the window's old group */ 319 319 - if (oldg) { 320 320 - last = group_last_window(oldg); 321 321 - if (last) 322 322 - set_active_window_force(last); 308 308 + numset_release(from->numset, we->number); 309 309 + list_del(&we->node); 310 310 + 311 311 + we->number = numset_request(to->numset); 312 312 + vscreen_insert_window(&to->mapped_windows, we); 313 313 + 314 314 + if (to == rp_current_vscreen) 315 315 + set_active_window_force(w); 316 316 + else 317 317 + hide_window(w); 318 318 + } 319 319 + 320 320 + struct numset * 321 321 + vscreen_get_numset(rp_vscreen *v) 322 322 + { 323 323 + return v->numset; 324 324 + } 325 325 + 326 326 + /* 327 327 + * Get the vscreen list and store it in buffer delimiting each window with 328 328 + * delim. mark_start and mark_end will be filled with the text positions for 329 329 + * the start and end of the current window. 330 330 + */ 331 331 + void 332 332 + get_vscreen_list(rp_screen *screen, char *delim, struct sbuf *buffer, 333 333 + int *mark_start, int *mark_end) 334 334 + { 335 335 + rp_vscreen *cur, *last; 336 336 + 337 337 + if (buffer == NULL) 338 338 + return; 339 339 + 340 340 + sbuf_clear(buffer); 341 341 + 342 342 + last = screen_last_vscreen(screen); 343 343 + list_for_each_entry(cur, &screen->vscreens, node) { 344 344 + char *fmt; 345 345 + char separator; 346 346 + 347 347 + if (cur == screen->current_vscreen) { 348 348 + *mark_start = strlen(sbuf_get(buffer)); 349 349 + separator = '*'; 350 350 + } else if (cur == last) 351 351 + separator = '+'; 352 352 + else 353 353 + separator = '-'; 354 354 + 355 355 + /* 356 356 + * A hack, pad the vscreen with a space at the beginning and end 357 357 + * if there is no delimiter. 358 358 + */ 359 359 + if (!delim) 360 360 + sbuf_concat(buffer, " "); 361 361 + 362 362 + fmt = xsprintf("%d%c%s", cur->number, separator, cur->name); 363 363 + sbuf_concat(buffer, fmt); 364 364 + free(fmt); 365 365 + 366 366 + /* 367 367 + * A hack, pad the vscreen with a space at the beginning and 368 368 + * end if there is no delimiter. 369 369 + */ 370 370 + if (!delim) 371 371 + sbuf_concat(buffer, " "); 372 372 + 373 373 + /* 374 374 + * Only put the delimiter between the vscreen, and not after 375 375 + * the the last vscreen. 376 376 + */ 377 377 + if (delim && cur->node.next != &screen->vscreens) 378 378 + sbuf_concat(buffer, delim); 379 379 + 380 380 + if (cur == screen->current_vscreen) 381 381 + *mark_end = strlen(sbuf_get(buffer)); 382 382 + } 383 383 + } 384 384 + 385 385 + void 386 386 + vscreen_rename(rp_vscreen *v, char *name) 387 387 + { 388 388 + free(v->name); 389 389 + v->name = xstrdup(name); 390 390 + } 391 391 + 392 392 + rp_vscreen * 393 393 + vscreen_next_vscreen(rp_vscreen *vscreen) 394 394 + { 395 395 + return list_next_entry(vscreen->screen->current_vscreen, 396 396 + &vscreen->screen->vscreens, node); 397 397 + } 398 398 + 399 399 + rp_vscreen * 400 400 + vscreen_prev_vscreen(rp_vscreen *vscreen) 401 401 + { 402 402 + return list_prev_entry(vscreen->screen->current_vscreen, 403 403 + &vscreen->screen->vscreens, node); 404 404 + } 405 405 + 406 406 + rp_vscreen * 407 407 + screen_last_vscreen(rp_screen *screen) 408 408 + { 409 409 + int last_access = 0; 410 410 + rp_vscreen *most_recent = NULL; 411 411 + rp_vscreen *cur; 412 412 + 413 413 + list_for_each_entry(cur, &screen->vscreens, node) { 414 414 + if (cur != screen->current_vscreen && 415 415 + cur->last_access > last_access) { 416 416 + most_recent = cur; 417 417 + last_access = cur->last_access; 418 418 + } 419 419 + } 420 420 + return most_recent; 421 421 + } 422 422 + 423 423 + rp_vscreen * 424 424 + screen_find_vscreen_by_number(rp_screen *s, int n) 425 425 + { 426 426 + rp_vscreen *cur; 427 427 + 428 428 + list_for_each_entry(cur, &s->vscreens, node) { 429 429 + if (cur->number == n) 430 430 + return cur; 431 431 + } 432 432 + 433 433 + return NULL; 434 434 + } 435 435 + 436 436 + rp_vscreen * 437 437 + screen_find_vscreen_by_name(rp_screen *s, char *name, int exact_match) 438 438 + { 439 439 + rp_vscreen *cur; 440 440 + 441 441 + if (exact_match) { 442 442 + list_for_each_entry(cur, &s->vscreens, node) { 443 443 + if (cur->name && !strcmp(cur->name, name)) 444 444 + return cur; 445 445 + } 446 446 + } else { 447 447 + list_for_each_entry(cur, &s->vscreens, node) { 448 448 + if (cur->name && str_comp(name, cur->name, 449 449 + strlen(name))) 450 450 + return cur; 451 451 + } 452 452 + } 453 453 + 454 454 + return NULL; 455 455 + } 456 456 + 457 457 + rp_window_elem * 458 458 + vscreen_find_window(struct list_head *list, rp_window *win) 459 459 + { 460 460 + rp_window_elem *cur; 461 461 + 462 462 + list_for_each_entry(cur, list, node) { 463 463 + if (cur->win == win) 464 464 + return cur; 465 465 + } 466 466 + 467 467 + return NULL; 468 468 + } 469 469 + 470 470 + rp_window_elem * 471 471 + vscreen_find_window_by_number(rp_vscreen *v, int num) 472 472 + { 473 473 + rp_window_elem *cur; 474 474 + 475 475 + list_for_each_entry(cur, &v->mapped_windows, node) { 476 476 + if (cur->number == num) 477 477 + return cur; 478 478 + } 479 479 + 480 480 + return NULL; 481 481 + 482 482 + } 483 483 + 484 484 + /* 485 485 + * Insert a window_elem into the correct spot in the vscreen's window list to 486 486 + * preserve window number ordering. 487 487 + */ 488 488 + void 489 489 + vscreen_insert_window(struct list_head *h, rp_window_elem *w) 490 490 + { 491 491 + rp_window_elem *cur; 492 492 + 493 493 + list_for_each_entry(cur, h, node) { 494 494 + if (cur->number > w->number) { 495 495 + list_add_tail(&w->node, &cur->node); 496 496 + return; 497 497 + } 498 498 + } 499 499 + 500 500 + list_add_tail(&w->node, h); 501 501 + } 502 502 + 503 503 + static int 504 504 + vscreen_in_list(struct list_head *h, rp_window_elem *w) 505 505 + { 506 506 + rp_window_elem *cur; 507 507 + 508 508 + list_for_each_entry(cur, h, node) { 509 509 + if (cur == w) 510 510 + return 1; 511 511 + } 512 512 + 513 513 + return 0; 514 514 + } 515 515 + 516 516 + /* 517 517 + * If a window_elem's number has changed then the list has to be resorted. 518 518 + */ 519 519 + void 520 520 + vscreen_resort_window(rp_vscreen *v, rp_window_elem *w) 521 521 + { 522 522 + /* Only a mapped window can be resorted. */ 523 523 + if (!vscreen_in_list(&v->mapped_windows, w)) { 524 524 + PRINT_DEBUG(("Attempting to resort an unmapped window!\n")); 525 525 + return; 526 526 + } 527 527 + list_del(&w->node); 528 528 + vscreen_insert_window(&v->mapped_windows, w); 529 529 + } 530 530 + 531 531 + void 532 532 + vscreen_add_window(rp_vscreen *v, rp_window *w) 533 533 + { 534 534 + rp_window_elem *we; 535 535 + 536 536 + /* Create our container structure for the window. */ 537 537 + we = xmalloc(sizeof(rp_window_elem)); 538 538 + we->win = w; 539 539 + we->number = -1; 540 540 + 541 541 + /* Finally, add it to our list. */ 542 542 + list_add_tail(&we->node, &v->unmapped_windows); 543 543 + } 544 544 + 545 545 + void 546 546 + vscreen_map_window(rp_vscreen *v, rp_window *win) 547 547 + { 548 548 + rp_window_elem *we; 549 549 + 550 550 + we = vscreen_find_window(&v->unmapped_windows, win); 551 551 + if (we) { 552 552 + we->number = numset_request(v->numset); 553 553 + list_del(&we->node); 554 554 + vscreen_insert_window(&v->mapped_windows, we); 555 555 + } 556 556 + } 557 557 + 558 558 + void 559 559 + vscreen_unmap_window(rp_vscreen *v, rp_window *win) 560 560 + { 561 561 + rp_window_elem *we; 562 562 + 563 563 + we = vscreen_find_window(&v->mapped_windows, win); 564 564 + if (we) { 565 565 + numset_release(v->numset, we->number); 566 566 + list_move_tail(&we->node, &v->unmapped_windows); 567 567 + } 568 568 + } 569 569 + 570 570 + void 571 571 + vscreen_del_window(rp_vscreen *v, rp_window *win) 572 572 + { 573 573 + rp_window_elem *cur; 574 574 + struct list_head *iter, *tmp; 575 575 + 576 576 + /* The assumption is that a window is unmapped before it's deleted. */ 577 577 + list_for_each_safe_entry(cur, iter, tmp, &v->unmapped_windows, node) { 578 578 + if (cur->win == win) { 579 579 + list_del(&cur->node); 580 580 + free(cur); 581 581 + } 582 582 + } 583 583 + 584 584 + /* 585 585 + * Make sure the window isn't in the list of mapped windows. This would 586 586 + * mean there is a bug. 587 587 + */ 588 588 + #ifdef DEBUG 589 589 + list_for_each_entry(cur, &v->mapped_windows, node) { 590 590 + if (cur->win == win) 591 591 + PRINT_DEBUG(("This window wasn't removed from the " 592 592 + "mapped window list.\n")); 593 593 + } 594 594 + #endif 595 595 + } 596 596 + 597 597 + rp_window * 598 598 + vscreen_last_window(rp_vscreen *v) 599 599 + { 600 600 + rp_frame *f; 601 601 + rp_window_elem *most_recent = NULL; 602 602 + rp_window_elem *cur; 603 603 + int last_access = 0; 604 604 + 605 605 + f = current_frame(v); 606 606 + list_for_each_entry(cur, &v->mapped_windows, node) { 607 607 + if (cur->win->sticky_frame != EMPTY && 608 608 + (!f || (cur->win->sticky_frame != f->number))) 609 609 + continue; 610 610 + 611 611 + if (cur->win->last_access >= last_access 612 612 + && cur->win != current_window() 613 613 + && !find_windows_frame(cur->win) 614 614 + && (cur->win->vscr == v || rp_have_xrandr)) { 615 615 + most_recent = cur; 616 616 + last_access = cur->win->last_access; 617 617 + } 618 618 + } 619 619 + 620 620 + if (most_recent) 621 621 + return most_recent->win; 622 622 + 623 623 + return NULL; 624 624 + } 625 625 + 626 626 + rp_window * 627 627 + vscreen_next_window(rp_vscreen *v, rp_window *win) 628 628 + { 629 629 + rp_window_elem *cur, *we; 630 630 + rp_frame *f; 631 631 + 632 632 + /* If there is no window, then get the last accessed one. */ 633 633 + if (win == NULL) 634 634 + return vscreen_last_window(v); 635 635 + 636 636 + /* 637 637 + * If we can't find the window, then it's in a different vscreen, so 638 638 + * get the last accessed one in this vscreen. 639 639 + */ 640 640 + we = vscreen_find_window(&v->mapped_windows, win); 641 641 + if (we == NULL) 642 642 + return vscreen_last_window(v); 643 643 + 644 644 + /* 645 645 + * The window is in this vscreen, so find the next one in the list that 646 646 + * isn't already displayed. 647 647 + */ 648 648 + f = current_frame(v); 649 649 + for (cur = list_next_entry(we, &v->mapped_windows, node); 650 650 + cur != we; 651 651 + cur = list_next_entry(cur, &v->mapped_windows, node)) { 652 652 + if (cur->win->sticky_frame != EMPTY && 653 653 + (!f || (cur->win->sticky_frame != f->number))) 654 654 + continue; 655 655 + 656 656 + if (!find_windows_frame(cur->win) && 657 657 + (cur->win->vscr == win->vscr || rp_have_xrandr)) 658 658 + return cur->win; 659 659 + } 660 660 + 661 661 + return NULL; 662 662 + } 663 663 + 664 664 + rp_window * 665 665 + vscreen_prev_window(rp_vscreen *v, rp_window *win) 666 666 + { 667 667 + rp_window_elem *cur, *we; 668 668 + rp_frame *f; 669 669 + 670 670 + /* If there is no window, then get the last accessed one. */ 671 671 + if (win == NULL) 672 672 + return vscreen_last_window(v); 673 673 + 674 674 + /* 675 675 + * If we can't find the window, then it's in a different vscreen, so 676 676 + * get the last accessed one in this vscreen. 677 677 + */ 678 678 + we = vscreen_find_window(&v->mapped_windows, win); 679 679 + if (we == NULL) 680 680 + return vscreen_last_window(v); 681 681 + 682 682 + /* 683 683 + * The window is in this vscreen, so find the previous one in the list 684 684 + * that isn't already displayed. 685 685 + */ 686 686 + f = current_frame(v); 687 687 + for (cur = list_prev_entry(we, &v->mapped_windows, node); 688 688 + cur != we; 689 689 + cur = list_prev_entry(cur, &v->mapped_windows, node)) { 690 690 + if (cur->win->sticky_frame != EMPTY && 691 691 + (!f || (cur->win->sticky_frame != f->number))) 692 692 + continue; 693 693 + 694 694 + if (!find_windows_frame(cur->win) && rp_have_xrandr) 695 695 + return cur->win; 323 696 } 324 697 325 325 - hide_window(w); 698 698 + return NULL; 699 699 + } 700 700 + 701 701 + void 702 702 + vscreens_merge(rp_vscreen *from, rp_vscreen *to) 703 703 + { 704 704 + rp_window_elem *cur; 705 705 + struct list_head *iter, *tmp; 706 706 + 707 707 + /* Merging a vscreen with itself makes no sense. */ 708 708 + if (from == to) 709 709 + return; 710 710 + 711 711 + /* Move the unmapped windows. */ 712 712 + list_for_each_safe_entry(cur, iter, tmp, &from->unmapped_windows, node) { 713 713 + list_del(&cur->node); 714 714 + list_add_tail(&cur->node, &to->unmapped_windows); 715 715 + } 716 716 + 717 717 + /* Move the mapped windows. */ 718 718 + list_for_each_safe_entry(cur, iter, tmp, &from->mapped_windows, node) { 719 719 + numset_release(from->numset, cur->number); 720 720 + list_del(&cur->node); 721 721 + 722 722 + cur->number = numset_request(to->numset); 723 723 + vscreen_insert_window(&to->mapped_windows, cur); 724 724 + } 725 725 + } 726 726 + 727 727 + /* Used by :cother / :iother */ 728 728 + rp_window * 729 729 + vscreen_last_window_by_class(rp_vscreen *v, char *class) 730 730 + { 731 731 + int last_access = 0; 732 732 + rp_window_elem *most_recent = NULL; 733 733 + rp_window_elem *cur; 734 734 + 735 735 + list_for_each_entry(cur, &v->mapped_windows, node) { 736 736 + if (cur->win->last_access >= last_access 737 737 + && cur->win != current_window() 738 738 + && !find_windows_frame(cur->win) 739 739 + && strcmp(class, cur->win->res_class)) { 740 740 + most_recent = cur; 741 741 + last_access = cur->win->last_access; 742 742 + } 743 743 + } 744 744 + 745 745 + if (most_recent) 746 746 + return most_recent->win; 747 747 + 748 748 + return NULL; 749 749 + } 750 750 + 751 751 + /* Used by :cother / :iother */ 752 752 + rp_window * 753 753 + vscreen_last_window_by_class_complement(rp_vscreen *v, char *class) 754 754 + { 755 755 + int last_access = 0; 756 756 + rp_window_elem *most_recent = NULL; 757 757 + rp_window_elem *cur; 758 758 + 759 759 + list_for_each_entry(cur, &v->mapped_windows, node) { 760 760 + if (cur->win->last_access >= last_access 761 761 + && cur->win != current_window() 762 762 + && !find_windows_frame(cur->win) 763 763 + && !strcmp(class, cur->win->res_class)) { 764 764 + most_recent = cur; 765 765 + last_access = cur->win->last_access; 766 766 + } 767 767 + } 768 768 + 769 769 + if (most_recent) 770 770 + return most_recent->win; 771 771 + 772 772 + return NULL; 326 773 }

+39 -1

vscreen.h

··· 24 24 void vscreen_free(rp_vscreen *v); 25 25 int vscreens_resize(int n); 26 26 27 27 - rp_vscreen *vscreens_find_vscreen_by_number(rp_screen *s, int n); 27 27 + rp_vscreen *screen_find_vscreen_by_number(rp_screen *s, int n); 28 28 + rp_vscreen *screen_find_vscreen_by_name(rp_screen *s, char *name, int exact_match); 28 29 29 30 struct list_head *vscreen_copy_frameset(rp_vscreen *v); 30 31 void vscreen_restore_frameset(rp_vscreen *v, struct list_head *head); ··· 35 36 36 37 void set_current_vscreen(rp_vscreen *v); 37 38 void vscreen_move_window(rp_vscreen *v, rp_window *w); 39 39 + 40 40 + 41 41 + void vscreen_add_window(rp_vscreen *v, rp_window *w); 42 42 + void vscreen_resort_window(rp_vscreen *v, rp_window_elem *w); 43 43 + void vscreen_insert_window(struct list_head *h, rp_window_elem *w); 44 44 + 45 45 + void vscreen_del_window(rp_vscreen *v, rp_window *win); 46 46 + 47 47 + void vscreen_map_window(rp_vscreen *v, rp_window *win); 48 48 + 49 49 + void vscreen_unmap_window(rp_vscreen *v, rp_window *win); 50 50 + 51 51 + struct numset *vscreen_get_numset(rp_vscreen *v); 52 52 + void get_vscreen_list(rp_screen *s, char *delim, struct sbuf *buffer, 53 53 + int *mark_start, int *mark_end); 54 54 + 55 55 + rp_window *vscreen_prev_window(rp_vscreen *v, rp_window *win); 56 56 + rp_window *vscreen_next_window(rp_vscreen *v, rp_window *win); 57 57 + 58 58 + rp_window *vscreen_last_window(rp_vscreen *v); 59 59 + 60 60 + rp_vscreen *vscreen_prev_vscreen(rp_vscreen *v); 61 61 + rp_vscreen *vscreen_next_vscreen(rp_vscreen *v); 62 62 + rp_vscreen *screen_last_vscreen(rp_screen *screen); 63 63 + 64 64 + void vscreen_rename(rp_vscreen *v, char *name); 65 65 + 66 66 + rp_window_elem *vscreen_find_window(struct list_head *list, rp_window *win); 67 67 + rp_window_elem *vscreen_find_window_by_number(rp_vscreen *g, int num); 68 68 + 69 69 + void vscreen_move_window(rp_vscreen *to, rp_window *win); 70 70 + void vscreens_merge(rp_vscreen *from, rp_vscreen *to); 71 71 + 72 72 + void set_current_vscreen(rp_vscreen *v); 73 73 + 74 74 + rp_window *vscreen_last_window_by_class(rp_vscreen *v, char *class); 75 75 + rp_window *vscreen_last_window_by_class_complement(rp_vscreen *v, char *class); 38 76 39 77 #define rp_current_vscreen (rp_current_screen->current_vscreen) 40 78

+17 -17

window.c

··· 140 140 cur->pid = pid; 141 141 cur->terminated = 0; 142 142 cur->frame = current_frame(rp_current_vscreen); 143 143 - cur->group = rp_current_group; 144 143 cur->vscreen = rp_current_vscreen; 145 144 cur->screen = rp_current_screen; 146 145 cur->window_mapped = 0; ··· 156 155 { 157 156 struct rp_child_info *child_info; 158 157 rp_window *new_window; 159 159 - rp_group *group = NULL; 158 158 + rp_vscreen *vscreen = NULL; 160 159 int frame_num = -1; 161 160 162 161 new_window = xmalloc(sizeof(rp_window)); ··· 203 202 child_info->vscreen, child_info->frame); 204 203 205 204 PRINT_DEBUG(("frame=%p\n", frame)); 206 206 - group = groups_find_group_by_group(child_info->group); 205 205 + vscreen = child_info->vscreen; 207 206 if (frame) 208 207 frame_num = frame->number; 209 208 /* Only map the first window in the launch frame. */ ··· 212 211 } 213 212 214 213 /* 215 215 - * Add the window to the group its pid was launched in or the current 214 214 + * Add the window to the vscreen its pid was launched in or the current 216 215 * one. 217 216 */ 218 218 - if (group) 219 219 - group_add_window(group, new_window); 217 217 + if (vscreen) 218 218 + vscreen_add_window(vscreen, new_window); 220 219 else 221 221 - group_add_window(new_window->vscr->current_group, new_window); 220 220 + vscreen_add_window(new_window->vscr, new_window); 222 221 223 222 PRINT_DEBUG(("frame_num: %d\n", frame_num)); 224 223 if (frame_num >= 0) ··· 283 282 rp_window_elem *cur; 284 283 285 284 if (!exact_match) { 286 286 - list_for_each_entry(cur, &rp_current_group->mapped_windows, 285 285 + list_for_each_entry(cur, &rp_current_vscreen->mapped_windows, 287 286 node) { 288 287 if (str_comp(name, window_name(cur->win), strlen(name))) 289 288 return cur->win; 290 289 } 291 290 } else { 292 292 - list_for_each_entry(cur, &rp_current_group->mapped_windows, 291 291 + list_for_each_entry(cur, &rp_current_vscreen->mapped_windows, 293 292 node) { 294 293 if (!strcmp(name, window_name(cur->win))) 295 294 return cur->win; ··· 300 299 return NULL; 301 300 } 302 301 302 302 + /* TODO: remove this */ 303 303 rp_window * 304 304 find_window_other(rp_vscreen *vscreen) 305 305 { 306 306 - return group_last_window(vscreen->current_group); 306 306 + return vscreen_last_window(vscreen); 307 307 } 308 308 309 309 /* ··· 530 530 sbuf_clear(buffer); 531 531 find_window_other(rp_current_vscreen); 532 532 533 533 - list_for_each_entry(we, &rp_current_group->mapped_windows, node) { 533 533 + list_for_each_entry(we, &rp_current_vscreen->mapped_windows, node) { 534 534 if (we->win != current_window()) 535 535 continue; 536 536 ··· 555 555 sbuf_clear(buffer); 556 556 find_window_other(rp_current_vscreen); 557 557 558 558 - /* We only loop through the current group to look for windows. */ 559 559 - list_for_each_entry(we, &rp_current_group->mapped_windows, node) { 558 558 + /* We only loop through the current vscreen to look for windows. */ 559 559 + list_for_each_entry(we, &rp_current_vscreen->mapped_windows, node) { 560 560 PRINT_DEBUG(("%d-%s\n", we->number, window_name(we->win))); 561 561 562 562 if (we->win == current_window()) ··· 582 582 * Only put the delimiter between the windows, and not after 583 583 * the the last window. 584 584 */ 585 585 - if (delim && we->node.next != &rp_current_group->mapped_windows) 585 585 + if (delim && we->node.next != &rp_current_vscreen->mapped_windows) 586 586 sbuf_concat(buffer, delim); 587 587 588 588 if (we->win == current_window()) { ··· 609 609 610 610 list_for_each_safe_entry(cur, iter, tmp, &rp_unmapped_window, node) { 611 611 list_del(&cur->node); 612 612 - groups_del_window(cur); 612 612 + vscreen_del_window(cur->vscr, cur); 613 613 free_window(cur); 614 614 } 615 615 616 616 list_for_each_safe_entry(cur, iter, tmp, &rp_mapped_window, node) { 617 617 list_del(&cur->node); 618 618 - groups_unmap_window(cur); 619 619 - groups_del_window(cur); 618 618 + vscreen_unmap_window(cur->vscr, cur); 619 619 + vscreen_del_window(cur->vscr, cur); 620 620 free_window(cur); 621 621 } 622 622