datetime.hpp

Go to the documentation of this file.

// Copyright (c) 2017 Kolya Kosenko
 
// Distributed under the Boost Software License, Version 1.0.
// See http://www.boost.org/LICENSE_1_0.txt
 
 
#ifndef BOOST_UI_DATETIME_HPP
#define BOOST_UI_DATETIME_HPP
 
#ifdef DOXYGEN
#define BOOST_UI_USE_DATE_TIME
#define BOOST_UI_USE_CHRONO
#endif
 
#include <boost/ui/config.hpp>
 
#ifdef BOOST_HAS_PRAGMA_ONCE
#pragma once
#endif
 
#include <boost/ui/widget.hpp>
#include <boost/cstdint.hpp>
 
#ifdef BOOST_UI_USE_DATE_TIME
#include <boost/date_time/gregorian/greg_date.hpp>
#include <boost/date_time/posix_time/posix_time.hpp>
#endif
 
#ifdef BOOST_UI_USE_CHRONO
#include <boost/chrono.hpp>
#endif
 
#ifndef BOOST_NO_CXX11_HDR_CHRONO
#include <chrono>
#endif
 
#include <ctime>
 
namespace boost {
namespace ui    {
 
 
class BOOST_UI_DECL date_picker : public widget
{
public:
    date_picker() {}
 
    explicit date_picker(widget& parent)
        { create(parent); }
    date_picker& create(widget& parent);
 
    std::time_t get_time_t() const;
 
    date_picker& set_time_t(std::time_t t);
 
    std::tm get_tm() const;
 
    date_picker& set_tm(const std::tm& t);
 
#ifdef BOOST_UI_USE_DATE_TIME
    boost::gregorian::date gregorian_date() const
    {
        int year = 0, month = 0, day = 0;
        ymd(year, month, day);
        return boost::gregorian::date(year, month, day);
    }
 
    date_picker& gregorian_date(const boost::gregorian::date& d)
    {
        set_ymd(d.year(), d.month(), d.day());
        return *this;
    }
#endif
 
#ifndef BOOST_NO_CXX11_HDR_CHRONO
    std::chrono::system_clock::time_point system_clock_time_point() const
    {
        return std::chrono::system_clock::from_time_t(get_time_t());
    }
 
    date_picker& system_clock_time_point(const std::chrono::system_clock::time_point& d)
    {
        set_time_t(std::chrono::system_clock::to_time_t(d));
        return *this;
    }
#endif
 
#ifdef BOOST_UI_USE_CHRONO
    boost::chrono::system_clock::time_point boost_system_clock_time_point() const
    {
        return boost::chrono::system_clock::from_time_t(get_time_t());
    }
 
    date_picker& system_clock_time_point(const boost::chrono::system_clock::time_point& d)
    {
        set_time_t(boost::chrono::system_clock::to_time_t(d));
        return *this;
    }
#endif
 
    BOOST_UI_DETAIL_HANDLER(change, date_picker);
 
#ifndef DOXYGEN
private:
    void ymd(int& year, int& month, int& day) const;
    void set_ymd(int year, int month, int day);
 
    void on_change_raw(const boost::function<void()>& handler);
 
    class detail_impl;
    detail_impl* get_impl();
    const detail_impl* get_impl() const;
#endif
};
 
 
class BOOST_UI_DECL time_picker : public widget
{
public:
    time_picker() {}
 
    explicit time_picker(widget& parent)
        { create(parent); }
    time_picker& create(widget& parent);
 
    std::time_t get_time_t() const;
 
    time_picker& set_time_t(std::time_t t);
 
    std::tm get_tm() const;
 
    time_picker& set_tm(const std::tm& t);
 
#ifdef BOOST_UI_USE_DATE_TIME
    boost::posix_time::time_duration posix_time_duration() const
    {
        int hours = 0, minutes = 0, seconds = 0;
        get_time_raw(&hours, &minutes, &seconds);
        return boost::posix_time::time_duration(hours, minutes, seconds);
    }
 
    time_picker& posix_time_duration(const boost::posix_time::time_duration& d)
    {
        set_time(d.hours(), d.minutes(), d.seconds());
        return *this;
    }
#endif
 
#ifdef BOOST_UI_USE_CHRONO
    template <class Rep, class Period>
    boost::chrono::duration<Rep, Period> boost_chrono_duration() const
    {
        return boost::chrono::seconds(get_seconds());
    }
 
    template <class Rep, class Period>
    time_picker& chrono_duration(const boost::chrono::duration<Rep, Period>& d)
    {
        set_seconds(boost::chrono::duration_cast<boost::chrono::seconds>(d).count());
        return *this;
    }
#endif
 
#ifndef BOOST_NO_CXX11_HDR_CHRONO
    template <class Rep, class Period>
    std::chrono::duration<Rep, Period> chrono_duration() const
    {
        return std::chrono::seconds(get_seconds());
    }
 
    template <class Rep, class Period>
    time_picker& chrono_duration(const std::chrono::duration<Rep, Period>& d)
    {
        set_seconds(std::chrono::duration_cast<std::chrono::seconds>(d).count());
        return *this;
    }
#endif
 
    template <class T>
    void get_time(T hours_ptr, T minutes_ptr, T seconds_ptr)
    {
        int hours = 0;
        int minutes = 0;
        int seconds = 0;
        get_time_raw(&hours, &minutes, &seconds);
        if ( hours_ptr )
            *hours_ptr = hours;
        if ( minutes_ptr )
            *minutes_ptr = minutes;
        if ( seconds_ptr )
            *seconds_ptr = seconds;
    }
 
    time_picker& set_time(int hours, int minutes, int seconds);
 
    BOOST_UI_DETAIL_HANDLER(change, time_picker);
 
private:
    void get_time_raw(int* hours_ptr, int* minutes_ptr, int* seconds_ptr) const;
    int get_seconds() const
    {
        int hours = 0, minutes = 0, seconds = 0;
        get_time_raw(&hours, &minutes, &seconds);
        return (hours * 60 + minutes) * 60 + seconds;
    }
    void set_seconds(boost::intmax_t seconds)
    {
        set_time(static_cast<int>(seconds / 3600), (seconds / 60) % 60, seconds % 60);
    }
 
    void on_change_raw(const boost::function<void()>& handler);
 
    class detail_impl;
    detail_impl* get_impl();
    const detail_impl* get_impl() const;
};
 
} // namespace ui
} // namespace boost
 
#endif // BOOST_UI_DATETIME_HPP