Line data Source code
1 : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 : /*
3 : * This file is part of the LibreOffice project.
4 : *
5 : * This Source Code Form is subject to the terms of the Mozilla Public
6 : * License, v. 2.0. If a copy of the MPL was not distributed with this
7 : * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 : *
9 : * This file incorporates work covered by the following license notice:
10 : *
11 : * Licensed to the Apache Software Foundation (ASF) under one or more
12 : * contributor license agreements. See the NOTICE file distributed
13 : * with this work for additional information regarding copyright
14 : * ownership. The ASF licenses this file to you under the Apache
15 : * License, Version 2.0 (the "License"); you may not use this file
16 : * except in compliance with the License. You may obtain a copy of
17 : * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 : */
19 :
20 : #include <sal/config.h>
21 :
22 : #include "boost/noncopyable.hpp"
23 : #include "osl/process.h"
24 : #include "rtl/ustring.hxx"
25 : #include "rtl/string.hxx"
26 : #include "rtl/strbuf.hxx"
27 :
28 : #include "osl/thread.h"
29 : #include <osl/diagnose.h>
30 : #include "recently_used_file.hxx"
31 :
32 : #include "internal/xml_parser.hxx"
33 : #include "internal/i_xml_parser_event_handler.hxx"
34 :
35 : #include <map>
36 : #include <vector>
37 : #include <algorithm>
38 : #include <functional>
39 : #include <string.h>
40 : #include <time.h>
41 :
42 : namespace /* private */ {
43 : typedef std::vector<string_t> string_container_t;
44 :
45 : #define TAG_RECENT_FILES "RecentFiles"
46 : #define TAG_RECENT_ITEM "RecentItem"
47 : #define TAG_URI "URI"
48 : #define TAG_MIME_TYPE "Mime-Type"
49 : #define TAG_TIMESTAMP "Timestamp"
50 : #define TAG_PRIVATE "Private"
51 : #define TAG_GROUPS "Groups"
52 : #define TAG_GROUP "Group"
53 :
54 :
55 : // compare two string_t's case insensitive, may also be done
56 : // by specifying special traits for the string type but in this
57 : // case it's easier to do it this way
58 : struct str_icase_cmp :
59 : public std::binary_function<string_t, string_t, bool>
60 : {
61 0 : bool operator() (const string_t& s1, const string_t& s2) const
62 0 : { return (0 == strcasecmp(s1.c_str(), s2.c_str())); }
63 : };
64 :
65 :
66 0 : struct recently_used_item
67 : {
68 0 : recently_used_item()
69 : : timestamp_(-1)
70 0 : , is_private_(false)
71 0 : {}
72 :
73 0 : recently_used_item(
74 : const string_t& uri,
75 : const string_t& mime_type,
76 : const string_container_t& groups,
77 : bool is_private = false) :
78 : uri_(uri),
79 : mime_type_(mime_type),
80 : is_private_(is_private),
81 0 : groups_(groups)
82 : {
83 0 : timestamp_ = time(NULL);
84 0 : }
85 :
86 0 : void set_uri(const string_t& character)
87 0 : { uri_ = character; }
88 :
89 0 : void set_mime_type(const string_t& character)
90 0 : { mime_type_ = character; }
91 :
92 0 : void set_timestamp(const string_t& character)
93 : {
94 : time_t t;
95 0 : if (sscanf(character.c_str(), "%ld", &t) != 1)
96 0 : timestamp_ = -1;
97 : else
98 0 : timestamp_ = t;
99 0 : }
100 :
101 0 : void set_is_private(SAL_UNUSED_PARAMETER const string_t& /*character*/)
102 0 : { is_private_ = true; }
103 :
104 0 : void set_groups(const string_t& character)
105 0 : { groups_.push_back(character); }
106 :
107 0 : void set_nothing(SAL_UNUSED_PARAMETER const string_t& /*character*/)
108 0 : {}
109 :
110 0 : bool has_groups() const
111 : {
112 0 : return !groups_.empty();
113 : }
114 :
115 0 : bool has_group(const string_t& name) const
116 : {
117 0 : string_container_t::const_iterator iter_end = groups_.end();
118 0 : return (has_groups() &&
119 0 : iter_end != std::find_if(
120 : groups_.begin(), iter_end,
121 0 : std::bind2nd(str_icase_cmp(), name)));
122 : }
123 :
124 0 : void write_xml(const recently_used_file& file) const
125 : {
126 0 : write_xml_start_tag(TAG_RECENT_ITEM, file, true);
127 0 : write_xml_tag(TAG_URI, uri_, file);
128 0 : write_xml_tag(TAG_MIME_TYPE, mime_type_, file);
129 :
130 0 : OString ts = OString::number(timestamp_);
131 0 : write_xml_tag(TAG_TIMESTAMP, ts.getStr(), file);
132 :
133 0 : if (is_private_)
134 0 : write_xml_tag(TAG_PRIVATE, file);
135 :
136 0 : if (has_groups())
137 : {
138 0 : write_xml_start_tag(TAG_GROUPS, file, true);
139 :
140 0 : string_container_t::const_iterator iter = groups_.begin();
141 0 : string_container_t::const_iterator iter_end = groups_.end();
142 :
143 0 : for ( ; iter != iter_end; ++iter)
144 0 : write_xml_tag(TAG_GROUP, (*iter), file);
145 :
146 0 : write_xml_end_tag(TAG_GROUPS, file);
147 : }
148 0 : write_xml_end_tag(TAG_RECENT_ITEM, file);
149 0 : }
150 :
151 0 : static OString escape_content(const string_t &text)
152 : {
153 0 : OStringBuffer aBuf;
154 0 : for (size_t i = 0; i < text.length(); i++)
155 : {
156 0 : switch (text[i])
157 : {
158 0 : case '&': aBuf.append("&"); break;
159 0 : case '<': aBuf.append("<"); break;
160 0 : case '>': aBuf.append(">"); break;
161 0 : case '\'': aBuf.append("'"); break;
162 0 : case '"': aBuf.append("""); break;
163 0 : default: aBuf.append(text[i]); break;
164 : }
165 : }
166 0 : return aBuf.makeStringAndClear();
167 : }
168 :
169 0 : void write_xml_tag(const string_t& name, const string_t& value, const recently_used_file& file) const
170 : {
171 0 : write_xml_start_tag(name, file);
172 0 : OString escaped = escape_content (value);
173 0 : file.write(escaped.getStr(), escaped.getLength());
174 0 : write_xml_end_tag(name, file);
175 0 : }
176 :
177 0 : void write_xml_tag(const string_t& name, const recently_used_file& file) const
178 : {
179 0 : file.write("<", 1);
180 0 : file.write(name.c_str(), name.length());
181 0 : file.write("/>\n", 3);
182 0 : }
183 :
184 0 : void write_xml_start_tag(const string_t& name, const recently_used_file& file, bool linefeed = false) const
185 : {
186 0 : file.write("<", 1);
187 0 : file.write(name.c_str(), name.length());
188 0 : if (linefeed)
189 0 : file.write(">\n", 2);
190 : else
191 0 : file.write(">", 1);
192 0 : }
193 :
194 0 : void write_xml_end_tag(const string_t& name, const recently_used_file& file) const
195 : {
196 0 : file.write("</", 2);
197 0 : file.write(name.c_str(), name.length());
198 0 : file.write(">\n", 2);
199 0 : }
200 :
201 : string_t uri_;
202 : string_t mime_type_;
203 : time_t timestamp_;
204 : bool is_private_;
205 : string_container_t groups_;
206 : };
207 :
208 : typedef std::vector<recently_used_item*> recently_used_item_list_t;
209 : typedef void (recently_used_item::* SET_COMMAND)(const string_t&);
210 :
211 : // thrown if we encounter xml tags that we do not know
212 : class unknown_xml_format_exception {};
213 :
214 0 : class recently_used_file_filter:
215 : public i_xml_parser_event_handler, private boost::noncopyable
216 : {
217 : public:
218 0 : recently_used_file_filter(recently_used_item_list_t& item_list) :
219 : item_(NULL),
220 0 : item_list_(item_list)
221 : {
222 0 : named_command_map_[TAG_RECENT_FILES] = &recently_used_item::set_nothing;
223 0 : named_command_map_[TAG_RECENT_ITEM] = &recently_used_item::set_nothing;
224 0 : named_command_map_[TAG_URI] = &recently_used_item::set_uri;
225 0 : named_command_map_[TAG_MIME_TYPE] = &recently_used_item::set_mime_type;
226 0 : named_command_map_[TAG_TIMESTAMP] = &recently_used_item::set_timestamp;
227 0 : named_command_map_[TAG_PRIVATE] = &recently_used_item::set_is_private;
228 0 : named_command_map_[TAG_GROUPS] = &recently_used_item::set_nothing;
229 0 : named_command_map_[TAG_GROUP] = &recently_used_item::set_groups;
230 0 : }
231 :
232 0 : virtual void start_element(
233 : const string_t& /*raw_name*/,
234 : const string_t& local_name,
235 : const xml_tag_attribute_container_t& /*attributes*/) SAL_OVERRIDE
236 : {
237 0 : if ((local_name == TAG_RECENT_ITEM) && (NULL == item_))
238 0 : item_ = new recently_used_item;
239 0 : }
240 :
241 0 : virtual void end_element(const string_t& /*raw_name*/, const string_t& local_name) SAL_OVERRIDE
242 : {
243 : // check for end tags w/o start tag
244 0 : if( local_name != TAG_RECENT_FILES && NULL == item_ )
245 0 : return; // will result in an XML parser error anyway
246 :
247 0 : if (named_command_map_.find(local_name) != named_command_map_.end())
248 0 : (item_->*named_command_map_[local_name])(current_element_);
249 : else
250 : {
251 0 : delete item_;
252 0 : throw unknown_xml_format_exception();
253 : }
254 :
255 0 : if (local_name == TAG_RECENT_ITEM)
256 : {
257 0 : item_list_.push_back(item_);
258 0 : item_ = NULL;
259 : }
260 0 : current_element_.clear();
261 : }
262 :
263 0 : virtual void characters(const string_t& character) SAL_OVERRIDE
264 : {
265 0 : if (character != "\n")
266 0 : current_element_ += character;
267 0 : }
268 :
269 0 : virtual void start_document() SAL_OVERRIDE {}
270 0 : virtual void end_document() SAL_OVERRIDE {}
271 :
272 0 : virtual void ignore_whitespace(const string_t& /*whitespaces*/) SAL_OVERRIDE
273 0 : {}
274 :
275 0 : virtual void processing_instruction(
276 : const string_t& /*target*/, const string_t& /*data*/) SAL_OVERRIDE
277 0 : {}
278 :
279 0 : virtual void comment(const string_t& /*comment*/) SAL_OVERRIDE
280 0 : {}
281 : private:
282 : recently_used_item* item_;
283 : std::map<string_t, SET_COMMAND> named_command_map_;
284 : string_t current_element_;
285 : recently_used_item_list_t& item_list_;
286 : };
287 :
288 :
289 0 : void read_recently_used_items(
290 : recently_used_file& file,
291 : recently_used_item_list_t& item_list)
292 : {
293 0 : xml_parser xparser;
294 0 : recently_used_file_filter ruff(item_list);
295 :
296 0 : xparser.set_document_handler(&ruff);
297 :
298 : char buff[16384];
299 0 : while (!file.eof())
300 : {
301 0 : if (size_t length = file.read(buff, sizeof(buff)))
302 0 : xparser.parse(buff, length, file.eof());
303 0 : }
304 0 : }
305 :
306 :
307 : // The file ~/.recently_used shall not contain more than 500
308 : // entries (see www.freedesktop.org)
309 : const int MAX_RECENTLY_USED_ITEMS = 500;
310 :
311 : class recent_item_writer
312 : {
313 : public:
314 0 : recent_item_writer(
315 : recently_used_file& file,
316 : int max_items_to_write = MAX_RECENTLY_USED_ITEMS) :
317 : file_(file),
318 : max_items_to_write_(max_items_to_write),
319 0 : items_written_(0)
320 0 : {}
321 :
322 0 : void operator() (const recently_used_item* item)
323 : {
324 0 : if (items_written_++ < max_items_to_write_)
325 0 : item->write_xml(file_);
326 0 : }
327 : private:
328 : recently_used_file& file_;
329 : int max_items_to_write_;
330 : int items_written_;
331 : };
332 :
333 :
334 : const char* XML_HEADER = "<?xml version=\"1.0\"?>\n<RecentFiles>\n";
335 : const char* XML_FOOTER = "</RecentFiles>";
336 :
337 :
338 : // assumes that the list is ordered decreasing
339 0 : void write_recently_used_items(
340 : recently_used_file& file,
341 : recently_used_item_list_t& item_list)
342 : {
343 0 : if (!item_list.empty())
344 : {
345 0 : file.truncate();
346 0 : file.reset();
347 :
348 0 : file.write(XML_HEADER, strlen(XML_HEADER));
349 :
350 : std::for_each(
351 : item_list.begin(),
352 : item_list.end(),
353 0 : recent_item_writer(file));
354 :
355 0 : file.write(XML_FOOTER, strlen(XML_FOOTER));
356 : }
357 0 : }
358 :
359 :
360 : struct delete_recently_used_item
361 : {
362 0 : void operator() (const recently_used_item* item) const
363 0 : { delete item; }
364 : };
365 :
366 :
367 0 : void recently_used_item_list_clear(recently_used_item_list_t& item_list)
368 : {
369 : std::for_each(
370 : item_list.begin(),
371 : item_list.end(),
372 0 : delete_recently_used_item());
373 0 : item_list.clear();
374 0 : }
375 :
376 :
377 0 : class find_item_predicate
378 : {
379 : public:
380 0 : find_item_predicate(const string_t& uri) :
381 0 : uri_(uri)
382 0 : {}
383 :
384 0 : bool operator() (const recently_used_item* item) const
385 0 : { return (item->uri_ == uri_); }
386 : private:
387 : string_t uri_;
388 : };
389 :
390 :
391 : struct greater_recently_used_item
392 : {
393 0 : bool operator ()(const recently_used_item* lhs, const recently_used_item* rhs) const
394 0 : { return (lhs->timestamp_ > rhs->timestamp_); }
395 : };
396 :
397 :
398 : const char* GROUP_OOO = "openoffice.org";
399 : const char* GROUP_STAR_OFFICE = "staroffice";
400 : const char* GROUP_STAR_SUITE = "starsuite";
401 :
402 :
403 0 : void recently_used_item_list_add(
404 : recently_used_item_list_t& item_list, const OUString& file_url, const OUString& mime_type)
405 : {
406 0 : OString f = OUStringToOString(file_url, RTL_TEXTENCODING_UTF8);
407 :
408 : recently_used_item_list_t::iterator iter =
409 : std::find_if(
410 : item_list.begin(),
411 : item_list.end(),
412 0 : find_item_predicate(f.getStr()));
413 :
414 0 : if (iter != item_list.end())
415 : {
416 0 : (*iter)->timestamp_ = time(NULL);
417 :
418 0 : if (!(*iter)->has_group(GROUP_OOO))
419 0 : (*iter)->groups_.push_back(GROUP_OOO);
420 0 : if (!(*iter)->has_group(GROUP_STAR_OFFICE))
421 0 : (*iter)->groups_.push_back(GROUP_STAR_OFFICE);
422 0 : if (!(*iter)->has_group(GROUP_STAR_SUITE))
423 0 : (*iter)->groups_.push_back(GROUP_STAR_SUITE);
424 : }
425 : else
426 : {
427 0 : string_container_t groups;
428 0 : groups.push_back(GROUP_OOO);
429 0 : groups.push_back(GROUP_STAR_OFFICE);
430 0 : groups.push_back(GROUP_STAR_SUITE);
431 :
432 0 : string_t uri(f.getStr());
433 0 : string_t mimetype(OUStringToOString(mime_type, osl_getThreadTextEncoding()).getStr());
434 :
435 0 : if (mimetype.length() == 0)
436 0 : mimetype = "application/octet-stream";
437 :
438 0 : item_list.push_back(new recently_used_item(uri, mimetype, groups));
439 : }
440 :
441 : // sort decreasing after the timestamp
442 : // so that the newest items appear first
443 : std::sort(
444 : item_list.begin(),
445 : item_list.end(),
446 0 : greater_recently_used_item());
447 0 : }
448 :
449 :
450 : struct cleanup_guard
451 : {
452 0 : cleanup_guard(recently_used_item_list_t& item_list) :
453 0 : item_list_(item_list)
454 0 : {}
455 0 : ~cleanup_guard()
456 0 : { recently_used_item_list_clear(item_list_); }
457 :
458 : recently_used_item_list_t& item_list_;
459 : };
460 :
461 : } // namespace private
462 :
463 : /*
464 : example (see http::www.freedesktop.org):
465 : <?xml version="1.0"?>
466 : <RecentFiles>
467 : <RecentItem>
468 : <URI>file:///home/federico/gedit.txt</URI>
469 : <Mime-Type>text/plain</Mime-Type>
470 : <Timestamp>1046485966</Timestamp>
471 : <Groups>
472 : <Group>gedit</Group>
473 : </Groups>
474 : </RecentItem>
475 : <RecentItem>
476 : <URI>file:///home/federico/gedit-2.2.0.tar.bz2</URI>
477 : <Mime-Type>application/x-bzip</Mime-Type>
478 : <Timestamp>1046209851</Timestamp>
479 : <Private/>
480 : <Groups>
481 : </Groups>
482 : </RecentItem>
483 : </RecentFiles>
484 : */
485 :
486 : extern "C" SAL_DLLPUBLIC_EXPORT
487 0 : void add_to_recently_used_file_list(const OUString& file_url,
488 : const OUString& mime_type)
489 : {
490 : try
491 : {
492 0 : recently_used_file ruf;
493 0 : recently_used_item_list_t item_list;
494 0 : cleanup_guard guard(item_list);
495 :
496 0 : read_recently_used_items(ruf, item_list);
497 0 : recently_used_item_list_add(item_list, file_url, mime_type);
498 0 : write_recently_used_items(ruf, item_list);
499 : }
500 0 : catch(const char* ex)
501 : {
502 : OSL_FAIL(ex);
503 : }
504 0 : catch(const xml_parser_exception&)
505 : {
506 : OSL_FAIL("XML parser error");
507 : }
508 0 : catch(const unknown_xml_format_exception&)
509 : {
510 : OSL_FAIL("XML format unknown");
511 : }
512 0 : }
513 :
514 :
515 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
