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