← Back to branch summary

~ubuntu-branches/debian/squeeze/erlang/squeeze

« back to all changes in this revision

Viewing changes to lib/tv/src/tv_main.erl

  • Committer: Bazaar Package Importer
  • Author(s): Erlang Packagers, Sergei Golovan
  • Date: 2006-12-03 17:07:44 UTC
  • mfrom: (2.1.11 feisty)
  • Revision ID: james.westby@ubuntu.com-20061203170744-rghjwupacqlzs6kv
Tags: 1:11.b.2-4
[ Sergei Golovan ]
Fixed erlang-base and erlang-base-hipe prerm scripts.

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/tv/src/tv_main.erl
84
84
    
85
85
get_ets_tables(SysTabHidden) ->
86
86
    Tables = ets:all(),
87
 
    TablesWInfo = get_ets_table_info(Tables, 
88
 
                                     hidden_tables(ets, SysTabHidden) ++ 
89
 
                                     current_mnesia_tables(SysTabHidden),
90
 
                                     owners_to_hide(ets, SysTabHidden),
91
 
                                     []).
 
87
    get_ets_table_info(Tables, 
 
88
                       hidden_tables(ets, SysTabHidden) ++ 
 
89
                       current_mnesia_tables(SysTabHidden),
 
90
                       owners_to_hide(ets, SysTabHidden),
 
91
                       []).
92
92
    
93
93
    
94
94
 
95
95
get_mnesia_tables(SysTabHidden) ->
96
96
    Tables = mnesia:system_info(tables),
97
 
    TablesWInfo = get_mnesia_table_info(Tables -- hidden_tables(mnesia, SysTabHidden), 
98
 
                                        owners_to_hide(mnesia, SysTabHidden),
99
 
                                        []).
 
97
    get_mnesia_table_info(Tables -- hidden_tables(mnesia, SysTabHidden), 
 
98
                          owners_to_hide(mnesia, SysTabHidden),
 
99
                          []).
100
100
    
101
101
 
102
102
 
114
114
 
115
115
 
116
116
 
117
 
get_mnesia_table_info([], OwnersToHide, Acc) ->
 
117
get_mnesia_table_info([], _OwnersToHide, Acc) ->
118
118
    lists:keysort(?NAME_ELEM, Acc);
119
119
get_mnesia_table_info([TabId | Tail], OwnersToHide, Acc) ->
120
120
    case catch get_mnesia_owner_size(TabId) of
121
 
        {'EXIT', Reason} ->  
 
121
        {'EXIT', _Reason} ->  
122
122
               %% Ignore tables ceasing to exist. 
123
123
               %% Nodedown errors caught above!
124
124
            get_mnesia_table_info(Tail, OwnersToHide, Acc);
201
201
 
202
202
 
203
203
 
204
 
get_ets_table_info([], TablesToHide, OwnersToHide, Acc) ->
 
204
get_ets_table_info([], _TablesToHide, _OwnersToHide, Acc) ->
205
205
    lists:keysort(?ID_ELEM, Acc);
206
206
get_ets_table_info([TabId | Tail], TablesToHide, OwnersToHide, Acc) ->
207
207
    case catch get_ets_name_owner_protection(TabId) of
208
 
        {'EXIT', Reason} ->  
 
208
        {'EXIT', _Reason} ->  
209
209
               %% Ignore tables ceasing to exist. 
210
210
               %% Nodedown errors caught above!
211
211
            get_ets_table_info(Tail, TablesToHide, OwnersToHide, Acc);
297
297
 
298
298
analyze_error(Cause, Node, Table) ->
299
299
    case Cause of
300
 
        {badrpc, {'EXIT', {badarg,Reason}}} ->
 
300
        {badrpc, {'EXIT', {badarg,_Reason}}} ->
301
301
            done;  %% Table has ceased to exist.
302
 
        {'EXIT', {badarg, {ets,local_info,Args}}} ->  
 
302
        {'EXIT', {badarg, {ets,local_info,_Args}}} ->  
303
303
            done;
304
304
        
305
305
        {badrpc, nodedown} ->
313
313
            handle_error(mnesia_not_started, Node, Table);
314
314
        {badrpc, {'EXIT', {aborted, {node_not_running,_ErrNode}}}} ->
315
315
            handle_error(mnesia_not_started, Node, Table);
316
 
        {'EXIT', {undef, {mnesia,Fcn,Args}}} ->
 
316
        {'EXIT', {undef, {mnesia,_Fcn,_Args}}} ->
317
317
            handle_error(mnesia_not_started, Node, Table);
318
318
 
319
319
        {'EXIT', Reason} ->
334
334
                                                     "We wish to reach all data",
335
335
                                                     "But we never will."])
336
336
    end;
337
 
handle_error(no_table, Node, Table) ->
338
 
    gs:config(win, [beep]),
339
 
    case get(error_msg_mode) of
340
 
        normal ->
341
 
            tv_utils:notify(win, "TV Notification", ["The table no longer exists!"]);
342
 
        haiku ->
343
 
            Msg = ["A table that big?",
344
 
                   "It might be very useful.",
345
 
                   "But now it is gone."],
346
 
            tv_utils:notify(win, "TV Notification", Msg)
347
 
    end;
348
 
handle_error(nodedown, Node, Table) ->
 
337
handle_error(nodedown, _Node, _Table) ->
349
338
    gs:config(win, [beep]),
350
339
    case get(error_msg_mode) of
351
340
        normal ->
357
346
            tv_utils:notify(win, "TV Notification", Msg)
358
347
    end,
359
348
    self() ! nodedown;
360
 
handle_error({unexpected_error,Cause}, Node, Table) ->
 
349
handle_error({unexpected_error,Cause}, _Node, _Table) ->
361
350
    io:format("Unexpected error:  ~p~n", [Cause]),
362
351
    gs:config(win, [beep]).
363
352
 
368
357
     WinSize,Tables,Shortcuts,UnreadHidden,SysTabHidden,SortKey,Children) ->
369
358
    receive
370
359
 
371
 
        {gs, Gridline, click, {grid,Readable}, [Col,Row,Text | T]} when Text /= "" ->
 
360
        {gs, Gridline, click, {grid,Readable}, [Col,Row,Text | _]} when Text /= "" ->
372
361
            unmark_cell(MarkedCell, Tables),
373
362
            NewMarkedCell = mark_cell({Gridline, Col, Row}, MarkedCell, Readable),
374
363
            loop(KindOfTable,CurrNode,NewMarkedCell,GridLines,WinSize,Tables,Shortcuts,
375
364
                 UnreadHidden,SysTabHidden,SortKey,Children);
376
365
 
377
366
 
378
 
        {gs, Gridline, click, {grid,Readable}, [Col,Row,"" | T]} ->
 
367
        {gs, _Gridline, click, {grid,_Readable}, [_Col,_Row,"" | _]} ->
379
368
            NewMarkedCell = unmark_cell(MarkedCell, Tables),
380
369
            loop(KindOfTable,CurrNode,NewMarkedCell,GridLines,WinSize,Tables,Shortcuts,
381
370
                 UnreadHidden,SysTabHidden,SortKey,Children);
382
371
 
383
372
 
384
 
        {gs, Gridline, doubleclick, {grid,Data}, [?NAME_COL,Row,Text | T]} when Text /= "" ->
 
373
        {gs, Gridline, doubleclick, {grid,Data}, [?NAME_COL,Row,Text | _]} when Text /= "" ->
385
374
            unmark_cell(MarkedCell, Tables),        
386
375
            NewMarkedCell = mark_cell({Gridline, ?NAME_COL, Row}, undefined, Data),
387
376
            {Table, Name, Readable} = get_table_id(KindOfTable, Row, Tables),
398
387
            end;
399
388
            
400
389
 
401
 
        {gs, Gridline, doubleclick, {grid,Data}, [?ID_COL,Row,Text | T]} when Text /= "" ->
 
390
        {gs, Gridline, doubleclick, {grid,Data}, [?ID_COL,Row,Text | _]} when Text /= "" ->
402
391
            unmark_cell(MarkedCell, Tables),        
403
392
            NewMarkedCell = mark_cell({Gridline, ?ID_COL, Row}, undefined, Data),
404
393
            {Table, Name, Readable} = get_table_id(KindOfTable, Row, Tables),
415
404
            end;
416
405
            
417
406
 
418
 
        {gs, Gridline, doubleclick, {grid,Data}, [?INFO_COL,Row,Text | T]} when Text /= "" ->
 
407
        {gs, Gridline, doubleclick, {grid,Data}, [?INFO_COL,Row,Text | _]} when Text /= "" ->
419
408
            unmark_cell(MarkedCell, Tables),        
420
409
            NewMarkedCell = mark_cell({Gridline, ?INFO_COL, Row}, undefined, Data),
421
410
            {Table, _Name, _Readable} = get_table_id(KindOfTable, Row, Tables),
432
421
            end;
433
422
 
434
423
 
435
 
        {gs, Gridline, doubleclick, {grid,Data}, [?PID_COL,Row,Text | T]} when Text /= "" ->
 
424
        {gs, Gridline, doubleclick, {grid,Data}, [?PID_COL,Row,Text | _]} when Text /= "" ->
436
425
            unmark_cell(MarkedCell, Tables),        
437
426
            NewMarkedCell = mark_cell({Gridline, ?PID_COL, Row}, undefined, Data),
438
427
            OwnerPid = element(?PID_ELEM, lists:nth(Row, Tables)),
441
430
                 UnreadHidden,SysTabHidden,SortKey, NewChildren);
442
431
 
443
432
 
444
 
        {gs, Gridline, doubleclick, {grid,Data}, [?PROCNAME_COL,Row,Text | T]} when Text /= "" ->
 
433
        {gs, Gridline, doubleclick, {grid,Data}, [?PROCNAME_COL,Row,Text | _]} when Text /= "" ->
445
434
            unmark_cell(MarkedCell, Tables),        
446
435
            NewMarkedCell = mark_cell({Gridline, ?PROCNAME_COL, Row}, undefined, Data),
447
436
            OwnerPid = element(?PID_ELEM, lists:nth(Row, Tables)),
450
439
                 UnreadHidden,SysTabHidden,SortKey, NewChildren);
451
440
 
452
441
 
453
 
        {gs, win, configure, _Data, [Width, Height | T]} when {Width,Height} /= WinSize ->
 
442
%%      {gs, win, configure, _Data, [Width, Height | _]} when {Width,Height} /= WinSize ->
 
443
        Msg0 = {gs, win, configure, _Data, [Width0, Height0 | _]} 
 
444
        when {Width0,Height0} /= WinSize ->
 
445
            {gs, win, configure, _, [Width,Height|_]} = flush_msgs(Msg0),
 
446
 
454
447
            NewSize = resize_window(Width, Height, length(Tables)),
455
448
            loop(KindOfTable,CurrNode,MarkedCell,GridLines,NewSize,Tables,Shortcuts,
456
449
                 UnreadHidden,SysTabHidden,SortKey,Children);
642
635
            
643
636
 
644
637
        {gs, _Id, click, help_button, _Args} ->
645
 
            HelpFile = filename:join(code:priv_dir(tv), "../doc/index.html"),
646
 
            tool_utils:open_help(gs:start([{kernel, true}]), HelpFile),
 
638
            HelpFile = filename:join([code:lib_dir(tv), "doc", "html", "index.html"]),
 
639
            tool_utils:open_help(win, HelpFile),
647
640
            loop(KindOfTable,CurrNode,MarkedCell,GridLines,WinSize,Tables,Shortcuts,
648
641
                 UnreadHidden,SysTabHidden,SortKey,Children);
649
642
 
650
643
 
651
644
        {gs, _Id, click, otp_help_button, _Args} ->
652
 
            IndexFile = filename:join(code:root_dir(), "doc/index.html"),
653
 
            tool_utils:open_help(gs:start([{kernel, true}]), IndexFile),
 
645
            IndexFile = filename:join([code:root_dir(), "doc", "index.html"]),
 
646
            tool_utils:open_help(win, IndexFile),
654
647
            loop(KindOfTable,CurrNode,MarkedCell,GridLines,WinSize,Tables,Shortcuts,
655
648
                 UnreadHidden,SysTabHidden,SortKey,Children);
656
649
 
664
657
            lists:foreach(
665
658
              fun({Pid,pman,_OP}) ->
666
659
                      exit(Pid,kill);
667
 
                 (H) ->
 
660
                 (_) ->
668
661
                      done
669
662
              end, 
670
663
              Children),
719
712
            lists:foreach(
720
713
              fun({Pid,pman,_OP}) ->
721
714
                      exit(Pid,kill);
722
 
                 (H) ->
 
715
                 (_) ->
723
716
                      done
724
717
              end, 
725
718
              Children),
726
719
            exit(normal);
727
720
 
728
721
 
729
 
        {gs, win, keypress, _Data, [Key, _, _, 1 | T]} ->
 
722
        {gs, win, keypress, _Data, [Key, _, _, 1 | _]} ->
730
723
            case lists:keysearch(Key, 1, Shortcuts) of
731
724
                {value, {Key, Value}} ->
732
725
                    handle_keypress(Value,KindOfTable,CurrNode,MarkedCell,
776
769
            end;
777
770
 
778
771
 
779
 
        {tv_update_infowin, Table, Node, Type} ->
 
772
        {tv_update_infowin, Table, Node, _Type} ->
780
773
            case get_tv_info_pid(Table, Node, Children) of
781
774
                undefined ->
782
775
                    done;
787
780
                 Tables,Shortcuts,UnreadHidden,SysTabHidden,SortKey,Children);
788
781
            
789
782
 
790
 
        {tv_new_table, NewTabWinPid, Node, Name, Options, KindOfTableToCreate, Readable, false} ->
 
783
        {tv_new_table, NewTabWinPid, Node, Name, Options, KindOfTableToCreate, _Readable, false} ->
791
784
            case create_table(KindOfTableToCreate, Node, Node == node(), Name, Options, 
792
785
                              NewTabWinPid) of
793
786
                error ->
794
787
                    loop(KindOfTable,CurrNode,MarkedCell,GridLines,WinSize, 
795
788
                         Tables,Shortcuts,UnreadHidden,SysTabHidden,SortKey,Children);
796
 
                TabId ->
 
789
                _TabId ->
797
790
                    case KindOfTable of
798
791
                        mnesia ->
799
792
                            done;
840
833
        
841
834
 
842
835
        
843
 
        {'EXIT', Pid, Reason} ->
 
836
        {'EXIT', Pid, _Reason} ->
844
837
            case lists:keysearch(Pid, 1, Children) of
845
838
                false ->
846
839
                    loop(KindOfTable,CurrNode,MarkedCell,GridLines,WinSize, 
864
857
    end.
865
858
 
866
859
 
867
 
 
868
 
 
 
860
flush_msgs(Msg0 = {gs, Win, Op, _, _}) ->
 
861
    receive Msg = {gs, Win,Op,_,_} ->
 
862
            flush_msgs(Msg)
 
863
    after 100 ->
 
864
            Msg0
 
865
    end.
869
866
 
870
867
handle_keypress(open_table,KindOfTable,CurrNode,MarkedCell,GridLines,
871
868
                WinSize,Tables,Shortcuts,UnreadHidden,SysTabHidden,SortKey,Children) ->
1013
1010
 
1014
1011
handle_keypress(help_button,KindOfTable,CurrNode,MarkedCell,GridLines,
1015
1012
                WinSize,Tables,Shortcuts,UnreadHidden,SysTabHidden,SortKey,Children) ->
1016
 
    HelpFile = filename:join(code:priv_dir(tv), "../doc/index.html"),
1017
 
    tool_utils:open_help(gs:start([{kernel, true}]), HelpFile),
 
1013
    HelpFile = filename:join([code:lib_dir(tv), "doc", "html", "index.html"]),
 
1014
    tool_utils:open_help(win, HelpFile),
1018
1015
    loop(KindOfTable,CurrNode,MarkedCell,GridLines,WinSize,Tables,Shortcuts,
1019
1016
         UnreadHidden,SysTabHidden,SortKey,Children);
1020
1017
 
1021
 
handle_keypress(exit_button,KindOfTable,CurrNode,MarkedCell,GridLines,
1022
 
                WinSize,Tables,Shortcuts,UnreadHidden,SysTabHidden,SortKey,Children) ->
 
1018
handle_keypress(exit_button,_KindOfTable,_CurrNode,_MarkedCell,_GridLines,
 
1019
                _WinSize,_Tables,_Shortcuts,_UnreadHidden,_SysTabHidden,_SortKey,Children) ->
1023
1020
    lists:foreach(
1024
1021
      fun({Pid,pman,_OP}) ->
1025
1022
              exit(Pid,kill);
1026
 
         (H) ->
 
1023
         (_) ->
1027
1024
              done
1028
1025
      end, 
1029
1026
      Children),
1074
1071
replace_node_name('nonode@nohost', 'nonode@nohost') ->
1075
1072
       %% Still undistributed...
1076
1073
    false;
1077
 
replace_node_name(Node, _OldNode) when node() == 'nonode@nohost' ->
 
1074
replace_node_name(_Node, _OldNode) when node() == 'nonode@nohost' ->
1078
1075
       %% No longer distributed, but previously was!
1079
1076
    true;
1080
 
replace_node_name(Node, 'nonode@nohost') ->
 
1077
replace_node_name(_Node, 'nonode@nohost') ->
1081
1078
       %% The system has been distributed!
1082
1079
    true;
1083
1080
replace_node_name(_Node, _OldNode) ->
1123
1120
    Sender = self(),
1124
1121
    lists:foreach(fun({Pid,tv_info,{_Table,_Node}}) ->
1125
1122
                          Pid ! #info_update_table_info{sender=Sender};
1126
 
                     (H) ->
 
1123
                     (_) ->
1127
1124
                          done
1128
1125
                  end,
1129
1126
                  Children).
1133
1130
update_tv_browser(Children) ->
1134
1131
    lists:foreach(fun({Pid,tv_browser,{_Table,_Node}}) ->
1135
1132
                          Pid ! check_node;
1136
 
                     (H) ->
 
1133
                     (_) ->
1137
1134
                          done
1138
1135
                  end,
1139
1136
                  Children).
1143
1140
get_tv_info_pid(TabId,Node,Children) ->
1144
1141
    TvInfoChildren = [X || X <- Children, element(2,X) == tv_info],
1145
1142
    case lists:keysearch({TabId,Node}, 3, TvInfoChildren) of
1146
 
        {value, {Pid, tv_info, {Table,Node}}} ->
 
1143
        {value, {Pid, tv_info, {_Table,Node}}} ->
1147
1144
            Pid;
1148
1145
        _Other ->
1149
1146
            undefined
1151
1148
 
1152
1149
 
1153
1150
 
1154
 
start_tv_browser(Tab,Node,Name,KindOfTable,false,Children) ->
 
1151
start_tv_browser(Tab,Node,_Name,KindOfTable,false,Children) ->
1155
1152
    gs:config(win, [beep]),
1156
1153
    case get(error_msg_mode) of
1157
1154
        normal ->
1165
1162
            tv_utils:notify(win, "TV Notification", Msg)
1166
1163
    end,
1167
1164
    start_tv_info(Tab, Node, Node == node(), KindOfTable, Children);
1168
 
start_tv_browser(Table,Node,Name,KindOfTable,Readable,Children) ->
 
1165
start_tv_browser(Table,Node,Name,KindOfTable,_Readable,Children) ->
1169
1166
    TvBrowserChildren = [X || X <- Children, element(2,X) == tv_browser],
1170
1167
    case lists:keysearch({Table,Node}, 3, TvBrowserChildren) of
1171
1168
        {value, {BPid,tv_browser,{Table,Node}}} ->
1259
1256
 
1260
1257
 
1261
1258
 
1262
 
create_table(mnesia, Node, LocalNode, TabName, Options, NewTabWinPid) ->
 
1259
create_table(mnesia, _Node, _LocalNode, _TabName, _Options, _NewTabWinPid) ->
1263
1260
    error;
1264
1261
create_table(ets, Node, LocalNode, TabName, Options, NewTabWinPid) ->
1265
1262
    case tv_table_owner:create(ets, Node, LocalNode, TabName, Options) of
1327
1324
 
1328
1325
 
1329
1326
 
1330
 
mark_cell({Id,Col,Row}, {Id,Col,Row}, Readable) ->
 
1327
mark_cell({Id,Col,Row}, {Id,Col,Row}, _Readable) ->
1331
1328
    {undefined, undefined, undefined};
1332
1329
mark_cell({Id,Col,Row}, _Any, Readable) ->
1333
1330
    case lists:member(Col, ?POSSIBLE_MARK_COLS) of
1498
1495
 
1499
1496
 
1500
1497
 
1501
 
create_header_labels([], []) ->
1502
 
    done;
1503
1498
create_header_labels(ColWidths, Text) ->
1504
1499
    create_header_labels(ColWidths, Text, 1, ?GRID_XPOS).
1505
1500
 
1659
1654
 
1660
1655
 
1661
1656
 
1662
 
create_menulist([], Menu) ->
1663
 
    [];
1664
1657
create_menulist(List, Menu) ->
1665
1658
    MaxLength = get_length_of_longest_menu_text(List, 0),
1666
1659
    create_menulist(List, Menu, MaxLength).
1668
1661
 
1669
1662
 
1670
1663
 
1671
 
create_menulist([], Menu, MaxLength) ->
 
1664
create_menulist([], _Menu, _MaxLength) ->
1672
1665
    [];
1673
1666
create_menulist([{Text, Type, Data, AccCharPos, ShortcutChar} | Rest], Menu, MaxLength) ->
1674
1667
    ShortcutCapitalChar =