src/session/history.c

   1 /** Visited URL history managment - NOT dialog_goto_url() history!
   2  * @file */
   3
   4 #ifdef HAVE_CONFIG_H
   5 #include "config.h"
   6 #endif
   7
   8 #include <string.h>
   9
  10 #include "elinks.h"
  11
  12 #include "cache/cache.h"
  13 #include "config/options.h"
  14 #include "dialogs/status.h"
  15 #include "network/connection.h"
  16 #include "protocol/uri.h"
  17 #include "session/history.h"
  18 #include "session/location.h"
  19 #include "session/session.h"
  20 #include "session/task.h"
  21 #include "util/memory.h"
  22 #include "util/string.h"
  23 #include "viewer/text/view.h"
  24 #include "viewer/text/vs.h"
  25
  26
  27 static inline void
  28 free_history(LIST_OF(struct location) *history)
  29 {
  30         while (!list_empty(*history)) {
  31                 struct location *loc = history->next;
  32
  33                 del_from_list(loc);
  34                 destroy_location(loc);
  35         }
  36 }
  37
  38
  39 /** @relates ses_history */
  40 void
  41 create_history(struct ses_history *history)
  42 {
  43         init_list(history->history);
  44         history->current = NULL;
  45 }
  46
  47 /** @relates ses_history */
  48 void
  49 destroy_history(struct ses_history *history)
  50 {
  51         free_history(&history->history);
  52         history->current = NULL;
  53 }
  54
  55 /** @relates ses_history */
  56 void
  57 clean_unhistory(struct ses_history *history)
  58 {
  59         if (!history->current) return;
  60
  61         while (list_has_next(history->history, history->current)) {
  62                 struct location *loc = history->current->next;
  63
  64                 del_from_list(loc);
  65                 destroy_location(loc);
  66         }
  67 }
  68
  69 /** @relates ses_history */
  70 void
  71 add_to_history(struct ses_history *history, struct location *loc)
  72 {
  73         if (!history->current) {
  74                 add_to_list(history->history, loc);
  75         } else {
  76                 add_at_pos(history->current, loc);
  77         }
  78
  79         history->current = loc;
  80 }
  81
  82 /** @relates ses_history */
  83 void
  84 del_from_history(struct ses_history *history, struct location *loc)
  85 {
  86         if (history->current == loc)
  87                 history->current = loc->prev;
  88
  89         if (history->current == (struct location *) &history->history)
  90                 history->current = loc->next;
  91
  92         if (history->current == (struct location *) &history->history)
  93                 history->current = NULL;
  94         del_from_list(loc);
  95 }
  96
  97
  98 void
  99 ses_history_move(struct session *ses)
 100 {
 101         struct location *loc;
 102
 103         /* Prepare. */
 104
 105         free_files(ses);
 106         mem_free_set(&ses->search_word, NULL);
 107
 108         /* Does it make sense? */
 109
 110         if (!have_location(ses) || !ses->task.target.location)
 111                 return;
 112
 113         if (ses->task.target.location
 114             == (struct location *) &ses->history.history)
 115                 return;
 116
 117         /* Move. */
 118
 119         ses->history.current = ses->task.target.location;
 120
 121         loc = cur_loc(ses);
 122
 123         /* There can be only one ... */
 124         if (compare_uri(loc->vs.uri, ses->loading_uri, 0))
 125                 return;
 126
 127         /* Remake that location. */
 128
 129         del_from_history(&ses->history, loc);
 130         destroy_location(loc);
 131         ses_forward(ses, 0);
 132
 133         /* Maybe trash the unhistory. */
 134
 135         if (get_opt_bool("document.history.keep_unhistory"))
 136                 clean_unhistory(&ses->history);
 137 }
 138
 139
 140 void
 141 go_history(struct session *ses, struct location *loc)
 142 {
 143         ses->reloadlevel = CACHE_MODE_NORMAL;
 144
 145         if (ses->task.type) {
 146                 abort_loading(ses, 0);
 147                 print_screen_status(ses);
 148                 reload(ses, CACHE_MODE_NORMAL);
 149                 return;
 150         }
 151
 152         if (!have_location(ses)
 153             || loc == (struct location *) &ses->history.history) {
 154                 /* There's no history, at most only the current location. */
 155                 return;
 156         }
 157
 158         abort_loading(ses, 0);
 159
 160         set_session_referrer(ses, NULL);
 161
 162         ses_goto(ses, loc->vs.uri, NULL, loc,
 163                  CACHE_MODE_ALWAYS, TASK_HISTORY, 0);
 164 }
 165
 166 void
 167 go_history_by_n(struct session *ses, int n)
 168 {
 169         struct location *loc = cur_loc(ses);
 170
 171         if (!loc) return;
 172
 173         if (n > 0) {
 174                 while (n-- && list_has_next(ses->history.history, loc))
 175                         loc = loc->next;
 176         } else {
 177                 while (n++ && list_has_prev(ses->history.history, loc))
 178                         loc = loc->prev;
 179         }
 180
 181         go_history(ses, loc);
 182 }
 183
 184 /** Go backward in the history.  See go_history() description regarding
 185  * unpredictable effects on cur_loc() by this function. */
 186 void
 187 go_back(struct session *ses)
 188 {
 189         go_history_by_n(ses, -1);
 190 }
 191
 192 /** Go forward in the history.  See go_history() description regarding
 193  * unpredictable effects on cur_loc() by this function. */
 194 void
 195 go_unback(struct session *ses)
 196 {
 197         go_history_by_n(ses, 1);
 198 }