The R13B03 release.OTP_R13B03

1 files changed, 787 insertions, 0 deletions

diff --git a/lib/pman/src/pman_main.erl b/lib/pman/src/pman_main.erl
new file mode 100644
index 0000000000..b68da1d2c3
--- /dev/null
+++ b/lib/pman/src/pman_main.erl
@@ -0,0 +1,787 @@
+%%
+%% %CopyrightBegin%
+%% 
+%% Copyright Ericsson AB 1997-2009. All Rights Reserved.
+%% 
+%% The contents of this file are subject to the Erlang Public License,
+%% Version 1.1, (the "License"); you may not use this file except in
+%% compliance with the License. You should have received a copy of the
+%% Erlang Public License along with this software. If not, it can be
+%% retrieved online at http://www.erlang.org/.
+%% 
+%% Software distributed under the License is distributed on an "AS IS"
+%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
+%% the License for the specific language governing rights and limitations
+%% under the License.
+%% 
+%% %CopyrightEnd%
+%%
+-module(pman_main).
+
+%% Main process and window
+
+-export([init/2]).
+
+-record(state, {win,		     % GS top window
+		frame,	             % GS top frame
+		grid,		     % GS process info grid
+
+		size,                % int() No. of displayed procs
+		w,                   % int() Window width
+		h,                   % int() Window height
+
+		hide_system=false,   % bool() Auto-hide system procs
+		hide_new=false,      % bool() Auto-hide new processes
+
+		hide_modules,        % ordset() Excluded modules
+
+		hide_all=[],         % [{node(), bool()}] Hide all
+		hide_pids=[],        % [{node(), Ordset}] Processes
+				     %  explicitly to hide, per node
+		show_pids=[],        % [{node(), Ordset}] Processes
+				     %  explicitly to show, per node
+
+		shown_pids=[],       % [{node(), Ordset}] Processes
+		                     %  actually shown, per node
+
+		node,		     % node() Current node
+		nodes=[],            % [node()] All known nodes
+
+		focus=1,	     % int() Grid line with focus
+		focus_pid=undefined, % pid() | undefined Proc in focus
+
+		noshell,	     % bool() Noshell mode on
+
+		options}).           % term() Trace options settings
+
+
+-include("pman_win.hrl").
+
+-define(REFRESH_TIME,5000).
+
+-define(REQUIRES_FOCUS,		     % List of menus that should
+	['Trace Process',	     % be disabled if no process
+	 'Kill',		     % is in focus
+	 'Hide Selected Process',
+	 'Module']).
+
+%%--Process init and loop-----------------------------------------------
+
+init(PidCaller, OSModuleExcluded) ->
+    process_flag(trap_exit, true),
+
+    %% Monitor all nodes in a distributed system
+    case is_alive() of
+
+	%% We have a distributed system
+	true -> net_kernel:monitor_nodes(true);
+
+	%% No distribution
+	false -> ignore
+    end,
+    Nodes = [node()|nodes()],
+
+    %% Create the main window
+    %% For some extremely strange reason, the frame must be resized
+    %% or the grid won't be visible...
+    GridSize = length(processes()) + 61,
+    {Window, Grid, Frame, Visible, W, H}  =
+	pman_win:pman_window(GridSize, OSModuleExcluded, Nodes),
+    gse:resize(Frame, ?WIN_WIDTH, ?WIN_HEIGHT-?MENU_HEIGHT),
+
+    Noshell = case pman_shell:find_shell() of
+		  noshell -> true;
+		  _ -> false
+	      end,
+
+    State1 = #state{win=Window, frame=Frame, grid=Grid,
+		    size=Visible,
+		    w=W, h=H,
+		    hide_modules=OSModuleExcluded,
+		    node=node(),
+		    noshell=Noshell},
+
+    State2 = lists:foldl(fun(Node, State) -> add_node(Node, State) end,
+			 State1,
+			 Nodes),
+
+    State3 = refresh(State2),
+
+    %% Notify caller that the process appears
+    %% to have been started.
+    PidCaller ! {initialization_complete, self()},
+
+    %% Initiate a 'catch all' trace pattern so call tracing works
+    erlang:trace_pattern({'_', '_', '_'}, true, [local]),
+
+    %% Read default options file
+    Options = restore_options(State3),
+
+    loop(State3#state{options=Options}).
+
+add_node(Node, State) ->
+    pman_win:add_menu(node, [Node], "Show"),
+    State#state{hide_all=nl_update(Node, false, State#state.hide_all),
+		hide_pids=nl_update(Node, [], State#state.hide_pids),
+		show_pids=nl_update(Node, [], State#state.show_pids),
+		shown_pids=nl_update(Node, [], State#state.shown_pids),
+		nodes=[Node|State#state.nodes]}.
+
+%% Restore saved options from default file
+restore_options(State)->
+    File = options_file(),
+    case pman_options:read_from_file(File) of
+	{ok, Options} ->
+	    Options;
+	{error, ReasonStr, DefOptions} ->
+	    Parent = State#state.win,
+	    Msg = io_lib:format(
+		    "Problems reading default option file~n~s:~n~s",
+		    [File, ReasonStr]),
+	    tool_utils:notify(Parent, Msg),
+	    DefOptions
+    end.
+
+options_file() ->
+    {ok, [[Home]]} = init:get_argument(home),
+    filename:join([Home, ".erlang_tools", "pman.opts"]).
+
+loop(State) ->
+    receive
+	{nodeup, Node} ->
+	    case nl_exists(Node, State#state.hide_all) of
+		true ->
+		    pman_win:add_menu(node, [Node], "Show"),
+		    loop(State#state{nodes=[Node|State#state.nodes]});
+		false ->
+		    loop(add_node(Node, State))
+	    end;
+
+	{nodedown, Node} ->
+	    pman_win:remove_menu([Node]),
+
+	    Msg = io_lib:format("Node~n~p~ndown.", [Node]),
+	    spawn_link(tool_utils, notify, [State#state.win, Msg]),
+
+	    %% We remove Node from the list of nodes but not from
+	    %% the other lists of State, in case Node reappears later
+	    Nodes = lists:delete(Node, State#state.nodes),
+	    State2 = State#state{nodes=Nodes},
+
+	    %% If it was the shown node that went down,
+	    %% change overview to this node
+	    if
+		Node==State#state.node ->
+		    State3 = execute_cmd({node,node()}, State2, [], []),
+		    loop(State3);
+		true ->
+		    loop(State2)
+	    end;
+
+	%% Ignore EXIT signals from help processes
+	{'EXIT', _Pid, _Reason} ->
+	    loop(State);
+
+	%% GS events
+	{gs, _Obj, _Event, _Data, _Args} = Cmd ->
+	    case gs_cmd(Cmd, State) of
+		stop ->
+		    exit(topquit);
+		State2 ->
+		    loop(State2)
+	    end
+
+    after ?REFRESH_TIME ->
+	    State2 = refresh(State),
+	    loop(State2)
+    end.
+
+%% gs_cmd(Event, State) -> stop | State'
+gs_cmd(Event, State) ->
+    case Event of
+
+	%% --- Window manager commands ---
+
+	%% Window is moved or resized
+        {gs, _, configure, _Data, Args} ->
+	    configure(Args, State);
+
+	%% Window closed, stop Pman
+        {gs, _, destroy, _, _} ->
+	    stop;
+
+	%% --- Dynamic commands ---
+
+	%% Click in any object where the GS Data field is a 2-tuple
+	{gs, _, click, Data, Args} when is_tuple(Data), size(Data)==2 ->
+	    execute_cmd(Data, State, [], Args);
+
+	%% Single click in the grid sets focus to selected process
+	{gs, _, click, {pidfunc,_,_}, [_,Row|_]} when is_integer(Row) ->
+	    focus(Row, State);
+
+	%% Double click in the grid starts tracing of selected process
+	{gs, _, doubleclick, {pidfunc,_,_}, [_Col,Row| _]} when is_integer(Row) ->
+	    execute_cmd('Trace Process', State, [], []);
+
+	%% Click in named GS objects
+        {gs, Cmd, click, Data, Args} when is_atom(Cmd);
+					  is_atom(element(1, Cmd)) ->
+	    execute_cmd(Cmd, State, Data, Args);
+
+        %% --- Keyboard accelerator commands ---
+
+	%% Move focus up and down
+	{gs, _, keypress, [], ['Up',_,0,0]} ->
+	    execute_cmd(focus_previous, State, [], []);
+	{gs, _, keypress, [], ['Down',_,0,0]} ->
+	    execute_cmd(focus_next, State, [], []);
+
+	%% Other keyboard shortcuts
+	{gs, _, keypress, [], ['Return',_,0,0]} ->
+	    execute_cmd('Trace Process', State, [], []);
+        {gs, _, keypress, [], [Key,_,0,1]} ->
+	    execute_cmd(shortcut(Key), State, [], []);
+
+	%% Ignore all other GS events
+     	_Other ->
+	    State
+    end.
+
+%% Keyboard shortcuts
+
+%% File menu
+shortcut(o) -> 'Default Options';
+shortcut(e) -> 'Exit';
+shortcut(z) -> 'Exit';
+
+%% View menu
+shortcut(i) -> 'Hide All';
+shortcut(u) -> 'Hide Modules';
+shortcut(d) -> 'Hide Selected Process';
+shortcut(m) -> 'Module';
+shortcut(r) -> 'Refresh';
+
+%% Trace menu
+shortcut(k) -> 'Kill';
+shortcut(t) -> 'Trace Process';
+shortcut(s) -> 'Trace Shell';
+
+%% Help menu
+shortcut(h) -> 'Help';
+
+%% Keyboard command only
+shortcut(l) -> 'All Links';
+
+%% Process grid traversal
+shortcut(p) -> focus_previous;
+shortcut(n) -> focus_next;
+shortcut(_) -> dummy.
+
+%% configure([W,H,X,Y|_], State) -> State'
+%% Window has been moved or resized
+configure([W,H|_], State) ->
+    if
+	W==State#state.w, H==State#state.h ->
+	    ignore;
+
+	true ->
+	    gse:resize(State#state.frame, W, H-?MENU_HEIGHT),
+
+	    Grid = State#state.grid,
+	    case abs(W - gs:read(Grid,width) - 6) of
+		0 ->
+		    ok;   %% Avoid refreshing width if possible
+		_Anything ->
+		    Cols = pman_win:calc_columnwidths(W-6),
+		    gs:config(Grid, Cols)
+	    end,
+	    pman_win:configwin(Grid, W, H)
+    end,
+    State.
+
+%% focus(Row, State) -> State'
+%%   Row = int()  Grid row
+%% User has selected a row in the grid.
+%% Row==1 means header row.
+focus(Row, State) ->
+
+    Pid = case get_pid_in_focus(Row, State#state.grid) of
+	      {true, {pidfunc,Pid0,_}} ->
+		  pman_win:change_colour(State#state.grid,
+					 State#state.focus, Row),
+		  enable_pid_actions(),
+		  Pid0;
+	      false ->
+		  disable_pid_actions(),
+		  undefined
+	  end,
+
+    State#state{focus=Row, focus_pid=Pid}.
+
+%% get_pid_in_focus(Row, Grid) -> {true, Data} | false
+%%   Data = {pidfunc, Pid, Func}
+%%     Func = {Mod,Name,Arity} | term()
+%% Return the data associated with the process in focus if there is one,
+get_pid_in_focus(1, _Grid) ->
+    false;
+get_pid_in_focus(Row, Grid) ->
+    case gs:read(Grid, {obj_at_row,Row}) of
+	undefined -> false;
+	GridLine ->
+	    Data = gs:read(GridLine, data),
+	    {true, Data}
+    end.
+
+%% execute_cmd(Cmd, State, Data, Args) -> stop | State'
+
+%% Checkbutton "Hide System Processes"
+execute_cmd('Hide System', State, _Data, Args) ->
+    [_Text, _Group, Bool|_Rest] = Args,
+    State2 = State#state{hide_system=Bool},
+    refresh(State2);
+
+%% Checkbutton "Auto-Hide New"
+execute_cmd('Auto Hide New', State, _Data, Args ) ->
+    [_Text, _Group, Bool|_Rest] = Args,
+    refresh(State#state{hide_new=Bool});
+
+%% File->Options...
+execute_cmd('Default Options', State, _Data, _Args) ->
+    OldOptions = State#state.options,
+    NewOptions = pman_options:dialog(State#state.win,
+				     "Default Trace Options",
+				     OldOptions),
+    case NewOptions of
+	{error, _Reason} ->
+	    State;
+	Options ->
+	    State#state{options=Options}
+    end;
+
+%% File->Save Options
+%% Save the set default options to the user's option file
+execute_cmd('Save Options', State, _Data, _Args)->
+    Options = State#state.options,
+    File = options_file(),
+    Parent = State#state.win,
+
+    case pman_options:save_to_file(Options, File) of
+	ok ->
+	    tool_utils:notify(Parent, "Options saved to\n" ++ File);
+	{error, ReasonStr} ->
+	    Msg = io_lib:format("Could not save options to~n~s:~n~s",
+				[File, ReasonStr]),
+	    tool_utils:notify(Parent, Msg)
+    end,
+    State;
+
+%% File->Exit
+%% Exit the application
+execute_cmd('Exit', _State, _Data, _Args) ->
+    stop;
+
+%% View->Hide All Processes
+execute_cmd('Hide All', State, _Data, _Args) ->
+    Node = State#state.node,
+    HideAll = nl_update(Node, true, State#state.hide_all),
+    ShowPids = nl_del_all(State#state.node, State#state.show_pids),
+    State2 = State#state{hide_all=HideAll, show_pids=ShowPids},
+    refresh(State2, true);
+
+%% View->Hide modules...
+%% Opens a dialog where the user can select from a list of 
+%% the loaded modules.
+%% The selected module is added to the list of hidden modules.
+execute_cmd('Hide Modules', State, _Data, _Args) ->
+
+    %% Get all loaded modules that are not already hidden
+    AllModules = lists:map(fun({Module, _File}) -> Module end,
+			   code:all_loaded()),
+    ModulesSet = ordsets:subtract(ordsets:from_list(AllModules),
+				  State#state.hide_modules),
+
+    %% Let the user select which of the loaded modules to exclude from
+    %% the process overview
+    Title = "Module selection",
+    case pman_tool:select(State#state.win, Title, ModulesSet) of
+	Modules when is_list(Modules) ->
+	    HideModules = ordsets:union(State#state.hide_modules,
+					ordsets:from_list(Modules)),
+	    refresh(State#state{hide_modules=HideModules});
+	cancelled -> State
+    end;
+
+%% View->Hide Selected Process
+%% The process in focus should explicitly be hidden
+execute_cmd('Hide Selected Process', State, _Data, _Args) ->
+    case State#state.focus_pid of
+	undefined -> State;
+	Pid ->
+	    Node = State#state.node,
+	    HidePids = nl_add(Node, Pid, State#state.hide_pids),
+	    ShowPids = nl_del(Node, Pid, State#state.show_pids),
+	    refresh(State#state{hide_pids=HidePids, show_pids=ShowPids})
+    end;
+
+%% View->Module Info...
+%% Open window with module information.
+execute_cmd('Module', State, _Data, _Args) ->
+    case get_pid_in_focus(State#state.focus, State#state.grid) of
+	{true, {pidfunc, _Pid, {Module,_Name,_Arity}}} ->
+	    pman_module_info:start(Module);
+	_ -> % false | {true, {pidfunc, Pid, Other}}
+	    ignore
+    end,
+    State;
+
+%% View->Refresh
+%% Refresh the main window. 
+%% (Called automatically every ?REFRESH_TIME millisecond)
+execute_cmd('Refresh', State, _Data, _Args) ->
+    refresh(State);
+
+%% View->Show All Processes
+%% Makes all processes visible except system processes and new
+%% processes, if those buttons are checked.
+%% Note: Also un-hides all hidden modules!
+execute_cmd('Show All', State, _Data, _Args) ->
+    Node = State#state.node,
+    HideAll = nl_update(Node, false, State#state.hide_all),
+    HidePids = nl_del_all(State#state.node, State#state.hide_pids),
+    ShowPids = nl_del_all(State#state.node, State#state.show_pids),
+    State2 = State#state{hide_modules=ordsets:new(), hide_all=HideAll,
+			 hide_pids=HidePids, show_pids=ShowPids},
+    refresh(State2, true);
+
+%% View->Show Processes...
+%% Open a list of all hidden processes, if the user selects one this
+%% process should explicitly be shown
+execute_cmd('Show Selected', State, _Data, _Args) ->
+    Node = State#state.node,
+
+    All = pman_process:r_processes(Node),
+    Hidden = case nl_lookup(Node, State#state.hide_all) of
+		 true ->
+		     All;
+		 false ->
+		     Shown = nl_lookup(Node, State#state.shown_pids),
+		     ordsets:subtract(All, Shown)
+	     end,
+
+    %% Selection window
+    Title = "Select Processes to Show",
+    Tuples =
+	lists:map(fun(Pid) ->
+			  {M,F,A} = pman_process:function_info(Pid),
+			  Str = case pman_process:get_name(Pid) of
+				    " " ->
+					io_lib:format("~p:~p/~p",
+						      [M, F, A]);
+				    Name ->
+					io_lib:format("[~p] ~p:~p/~p",
+						      [Name, M, F, A])
+				end,
+			  {Pid, Str}
+		  end,
+		  Hidden),
+    case pman_tool:select(State#state.win, Title, Tuples) of
+	Pids when is_list(Pids) ->
+	    HidePids = nl_del(Node, Pids, State#state.hide_pids),
+	    ShowPids = nl_add(Node, Pids, State#state.show_pids),
+	    refresh(State#state{hide_pids=HidePids,show_pids=ShowPids});
+	cancelled -> State
+    end;
+
+%% Trace->Kill
+execute_cmd('Kill', State, _Data, _Args) ->
+    case State#state.focus_pid of
+	Pid when is_pid(Pid) ->
+	    exit(Pid, kill);
+	undefined ->
+	    ignore
+    end,
+    State;
+
+%% Trace->Selected Process
+execute_cmd('Trace Process', State, _Data, _Args) ->
+    case State#state.focus_pid of
+	Pid when is_pid(Pid) ->
+	    pman_shell:start({Pid,self()}, State#state.options);
+	undefined ->
+	    ignore
+    end,
+    State;
+
+%% Trace->Shell Process
+execute_cmd('Trace Shell', State, _Data, _Args) ->
+    case pman_shell:find_shell() of
+	noshell ->
+	    State;
+	Shell -> 
+	    pman_shell:start({{shell,Shell},self()},
+			     State#state.options),
+	    State#state{noshell=false}
+    end;
+
+%% Nodes->Show <Node>
+%% Change shown node
+execute_cmd({node,Node}, State, _Data, _Args) ->
+    gse:config(State#state.win,
+	       [{title,lists:concat(["Pman: Overview on ", Node])}]),
+    gse:disable(Node),
+    catch gse:enable(State#state.node), % Menu may not exist any more
+    refresh(State#state{node=Node}, true);
+
+%% Help->Help
+execute_cmd('Help', State, _Data, _Args)  ->
+    Win = State#state.win,
+    HelpFile =
+	filename:join([code:lib_dir(pman),"doc","html","index.html"]),
+    tool_utils:open_help(Win, HelpFile),
+    State;
+
+%% Keyboard shortcut Ctrl-l
+execute_cmd('All Links', State, _Data, _Args) ->
+    case State#state.focus_pid of
+	Pid when is_pid(Pid) ->
+	    case process_info(Pid, links) of
+		{links, Pids} ->
+		    pman_shell:start_list(Pids, self(),
+					  State#state.options);
+		undefined ->
+		    ignore
+	    end;
+	undefined -> ignore
+    end,
+    State;
+
+%% Keyboard shortcuts for process grid traversal
+execute_cmd(focus_previous, State, _Data, _Args) ->
+    focus(previous_row(State), State);
+execute_cmd(focus_next, State, _Data, _Args) ->
+    focus(next_row(State), State);
+
+%% Keyboard combinations that are not shortcuts
+execute_cmd(dummy, State, _Data, _Args) ->
+    State.
+
+%% Convenience functions for disabling/enabling menu items that require
+%% that a process is selected.
+disable_pid_actions() ->
+    lists:foreach(fun(X) -> gse:disable(X) end, ?REQUIRES_FOCUS).
+
+enable_pid_actions()  ->
+    lists:foreach(fun(X) -> gse:enable(X) end, ?REQUIRES_FOCUS).
+
+%% refresh(State) -> State'
+%% refresh(State, ForceP) -> State'
+%% Refreshes the main window.
+refresh(State) ->
+    refresh(State, false).
+refresh(#state{node=Node} = State, ForceP) ->
+
+    %% Update shown processes
+
+    %% First, get an ordset of all processes running at the current node
+    All = pman_process:r_processes(Node),
+
+    Shown = nl_lookup(Node, State#state.shown_pids),
+    ExpShown = nl_lookup(Node, State#state.show_pids),
+
+    {Show, State2} =
+	case nl_lookup(Node, State#state.hide_all) of
+
+	    %% If the user has selected "Hide All Processes", only
+	    %% explicitly selected processes which still exist should
+	    %% be shown
+	    true ->
+		{ordsets:intersection(ExpShown, All), State};
+
+	    false ->
+		%% Compute which processes should be hidden according
+		%% to the flags/menu items selected
+		Hidden = hidden_pids(All, State),
+
+		NotHidden = ordsets:subtract(All, Hidden),
+
+		Show0 = case State#state.hide_new of
+			    %% If the user has selected "Auto-Hide New",
+			    %% then only those processes in NotHidden
+			    %% which are already shown, should be shown,
+			    %% together with explicitly selected
+			    %% processes which still exist
+			    true ->
+				ordsets:union(
+				  ordsets:intersection(NotHidden,Shown),
+				  ordsets:intersection(ExpShown, All));
+
+			    %% Otherwise, show all processes in
+			    %% NotHidden, together with explicitly
+			    %% selected processes which still exist
+			    false ->
+				ordsets:union(
+				  NotHidden,
+				  ordsets:intersection(ExpShown, All))
+			end,
+
+		ShownPids = nl_update(Node, Show0,
+				      State#state.shown_pids),
+		{Show0, State#state{shown_pids=ShownPids}}
+	end,
+
+    NoOfHidden = length(All) - length(Show),
+
+    if
+	Show==Shown, not ForceP ->
+	    pman_win:update(NoOfHidden),
+	    State;
+
+	true ->
+	    ShowInfo = display_info(Show),
+	    pman_win:update(State#state.grid, ShowInfo, NoOfHidden),
+	    
+	    %% Set the focus appropriately
+	    State3 = case State2#state.focus_pid of
+			 undefined ->
+			     disable_pid_actions(),
+			     State2;
+			 Pid ->
+			     Row = get_row(Pid, Show),
+			     focus(Row, State2)
+		     end,
+
+	    trace_shell_possible(State3),
+
+	    Size = length(Show),
+	    case Size of
+		1 -> gse:disable('Hide All');
+		_ -> gse:enable('Hide All')
+	    end,
+
+	    State3#state{size=Size}
+    end.
+
+%% hidden_pids(All, State) -> Hidden
+hidden_pids(All, State) ->
+
+    %% Processes hidden because they are system processes
+    HideSys = case State#state.hide_system of
+		  true ->
+		      lists:filter(
+			fun(Pid) ->
+				pman_process:is_system_process(Pid)
+			end,
+			All);
+		  false ->
+		      []
+	      end,
+	    
+    %% Process hidden because they are executing code in a hidden module
+    Mods = State#state.hide_modules,
+    HideMod =
+	lists:filter(fun(Pid) ->
+			     pman_process:is_hidden_by_module(Pid, Mods)
+		     end,
+		     All),
+
+    %% Explicitly hidden processes
+    HideExp = nl_lookup(State#state.node, State#state.hide_pids),
+
+    %% All hidden processes
+    ordsets:union([HideSys, HideMod, HideExp]).
+
+display_info(Pids) ->
+    lists:map(fun(Pid) ->
+		      Func = pman_process:function_info(Pid),
+		      Name = pman_process:get_name(Pid),
+		      Msgs = pman_process:msg(Pid),
+		      Reds = pman_process:reds(Pid),
+		      Size = pman_process:psize(Pid),
+		      {Pid, Func, Name, Msgs, Reds, Size}
+	      end,
+	      Pids).
+
+get_row(Pid, List) ->
+    get_row(Pid, List, length(List)+1).
+
+get_row(Pid, [Pid | _], Row) ->
+    Row;
+get_row(Pid, [_ | T], Row) ->
+    get_row(Pid, T, Row-1);
+get_row(_Pid, [], _Row) ->
+    1.
+
+next_row(#state{size=Size, focus=Row}) ->
+    check_row(Row+1, Size).
+
+previous_row(#state{size=Size, focus=Row}) ->
+    check_row(Row-1, Size).
+
+check_row(1, Size) ->
+    Size+1;
+check_row(Row, Size) when Row==Size+2 ->
+    2;
+check_row(Row, _Size) ->
+    Row.
+
+%% Check if node is running in noshell mode and if so disable the
+%% 'Trace Shell' menu option.
+trace_shell_possible(#state{noshell=true}) ->
+    gse:disable('Trace Shell');
+trace_shell_possible(_) ->
+    ok.
+
+%% -- Functions for manipulating {Node, Data} lists --
+
+%% nl_add(Node, Elem|Elems, NList) -> NList'
+nl_add(Node, Elems, [{Node, Ordset} | T]) when is_list(Elems) ->
+    [{Node, ordsets:union(Elems, Ordset)} | T];
+nl_add(Node, Elem, [{Node, Ordset} | T]) ->
+    [{Node, ordsets:add_element(Elem, Ordset)} | T];
+nl_add(Node, Elem, [H | T]) ->
+    [H | nl_add(Node, Elem, T)];
+nl_add(Node, Elems, []) when is_list(Elems) ->
+    [{Node, Elems}];
+nl_add(Node, Elem, []) ->
+    [{Node, ordsets:add_element(Elem, ordsets:new())}].
+
+%% nl_del(Node, Elem|Elems, NList) -> NList'
+nl_del(Node, Elems, [{Node, Ordset} | T]) when is_list(Elems) ->
+    [{Node, ordsets:subtract(Ordset, Elems)} | T];
+nl_del(Node, Elem, [{Node, Ordset} | T]) ->
+    [{Node, ordsets:del_element(Elem, Ordset)} | T];
+nl_del(Node, Elem, [H | T]) ->
+    [H | nl_del(Node, Elem, T)];
+nl_del(_Node, _Elem, []) ->
+    [].
+
+%% nl_del_all(Node, NList) -> NList'
+nl_del_all(Node, [{Node, _Ordset} | T]) ->
+    [{Node, ordsets:new()} | T];
+nl_del_all(Node, [H | T]) ->
+    [H | nl_del_all(Node, T)];
+nl_del_all(_Node, []) ->
+    [].
+
+%% nl_update(Node, Val, NList) -> NList'
+nl_update(Node, Val, [{Node, _OldVal} | T]) ->
+    [{Node, Val} | T];
+nl_update(Node, Val, [H | T]) ->
+    [H | nl_update(Node, Val, T)];
+nl_update(Node, Val, []) ->
+    [{Node, Val}].
+
+%% nl_lookup(Node, NList) -> Val
+nl_lookup(Node, NList) ->
+    {value, {_Node,Val}} = lists:keysearch(Node, 1, NList),
+    Val.
+
+%% nl_exists(Node, NList) -> bool()
+nl_exists(Node, NList) ->
+    case lists:keysearch(Node, 1, NList) of
+	{value, _Val} ->
+	    true;
+	false ->
+	    false
+    end.