blob: 61f499243b7f215d8c959f8844bb0864414d311f [file] [log] [blame]
// Copyright 2014 PDFium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
// Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
#include "xfa/fwl/cfwl_monthcalendar.h"
#include <algorithm>
#include <memory>
#include <utility>
#include "third_party/base/check.h"
#include "third_party/base/notreached.h"
#include "third_party/base/stl_util.h"
#include "xfa/fde/cfde_textout.h"
#include "xfa/fwl/cfwl_datetimepicker.h"
#include "xfa/fwl/cfwl_messagemouse.h"
#include "xfa/fwl/cfwl_notedriver.h"
#include "xfa/fwl/cfwl_themebackground.h"
#include "xfa/fwl/cfwl_themetext.h"
#include "xfa/fwl/ifwl_themeprovider.h"
#define MONTHCAL_HSEP_HEIGHT 1
#define MONTHCAL_HMARGIN 3
#define MONTHCAL_VMARGIN 2
#define MONTHCAL_ROWS 9
#define MONTHCAL_COLUMNS 7
#define MONTHCAL_HEADER_BTN_VMARGIN 7
#define MONTHCAL_HEADER_BTN_HMARGIN 5
namespace {
WideString GetAbbreviatedDayOfWeek(int day) {
switch (day) {
case 0:
return L"Sun";
case 1:
return L"Mon";
case 2:
return L"Tue";
case 3:
return L"Wed";
case 4:
return L"Thu";
case 5:
return L"Fri";
case 6:
return L"Sat";
default:
NOTREACHED();
return L"";
}
}
WideString GetMonth(int month) {
switch (month) {
case 0:
return L"January";
case 1:
return L"February";
case 2:
return L"March";
case 3:
return L"April";
case 4:
return L"May";
case 5:
return L"June";
case 6:
return L"July";
case 7:
return L"August";
case 8:
return L"September";
case 9:
return L"October";
case 10:
return L"November";
case 11:
return L"December";
default:
NOTREACHED();
return L"";
}
}
} // namespace
CFWL_MonthCalendar::CFWL_MonthCalendar(CFWL_App* app,
const Properties& properties,
CFWL_Widget* pOuter)
: CFWL_Widget(app, properties, pOuter) {}
CFWL_MonthCalendar::~CFWL_MonthCalendar() = default;
FWL_Type CFWL_MonthCalendar::GetClassID() const {
return FWL_Type::MonthCalendar;
}
CFX_RectF CFWL_MonthCalendar::GetAutosizedWidgetRect() {
CFX_SizeF fs = CalcSize();
CFX_RectF rect(0, 0, fs.width, fs.height);
InflateWidgetRect(rect);
return rect;
}
void CFWL_MonthCalendar::Update() {
if (IsLocked())
return;
if (!m_bInitialized) {
InitDate();
m_bInitialized = true;
}
ClearDateItem();
ResetDateItem();
Layout();
}
void CFWL_MonthCalendar::DrawWidget(CFGAS_GEGraphics* pGraphics,
const CFX_Matrix& matrix) {
if (!pGraphics)
return;
if (HasBorder())
DrawBorder(pGraphics, CFWL_Part::Border, matrix);
DrawBackground(pGraphics, &matrix);
DrawHeadBK(pGraphics, &matrix);
DrawLButton(pGraphics, &matrix);
DrawRButton(pGraphics, &matrix);
DrawSeparator(pGraphics, &matrix);
DrawDatesInBK(pGraphics, &matrix);
DrawDatesInCircle(pGraphics, &matrix);
DrawCaption(pGraphics, &matrix);
DrawWeek(pGraphics, &matrix);
DrawDatesIn(pGraphics, &matrix);
DrawDatesOut(pGraphics, &matrix);
DrawToday(pGraphics, &matrix);
}
void CFWL_MonthCalendar::SetSelect(int32_t iYear,
int32_t iMonth,
int32_t iDay) {
ChangeToMonth(iYear, iMonth);
AddSelDay(iDay);
}
void CFWL_MonthCalendar::DrawBackground(CFGAS_GEGraphics* pGraphics,
const CFX_Matrix* pMatrix) {
CFWL_ThemeBackground params;
params.m_pWidget = this;
params.m_iPart = CFWL_Part::Background;
params.m_pGraphics = pGraphics;
params.m_dwStates = CFWL_PartState_Normal;
params.m_PartRect = m_ClientRect;
if (pMatrix)
params.m_matrix.Concat(*pMatrix);
GetThemeProvider()->DrawBackground(params);
}
void CFWL_MonthCalendar::DrawHeadBK(CFGAS_GEGraphics* pGraphics,
const CFX_Matrix* pMatrix) {
CFWL_ThemeBackground params;
params.m_pWidget = this;
params.m_iPart = CFWL_Part::Header;
params.m_pGraphics = pGraphics;
params.m_dwStates = CFWL_PartState_Normal;
params.m_PartRect = m_HeadRect;
if (pMatrix)
params.m_matrix.Concat(*pMatrix);
GetThemeProvider()->DrawBackground(params);
}
void CFWL_MonthCalendar::DrawLButton(CFGAS_GEGraphics* pGraphics,
const CFX_Matrix* pMatrix) {
CFWL_ThemeBackground params;
params.m_pWidget = this;
params.m_iPart = CFWL_Part::LBtn;
params.m_pGraphics = pGraphics;
params.m_dwStates = m_iLBtnPartStates;
params.m_PartRect = m_LBtnRect;
if (pMatrix)
params.m_matrix.Concat(*pMatrix);
GetThemeProvider()->DrawBackground(params);
}
void CFWL_MonthCalendar::DrawRButton(CFGAS_GEGraphics* pGraphics,
const CFX_Matrix* pMatrix) {
CFWL_ThemeBackground params;
params.m_pWidget = this;
params.m_iPart = CFWL_Part::RBtn;
params.m_pGraphics = pGraphics;
params.m_dwStates = m_iRBtnPartStates;
params.m_PartRect = m_RBtnRect;
if (pMatrix)
params.m_matrix.Concat(*pMatrix);
GetThemeProvider()->DrawBackground(params);
}
void CFWL_MonthCalendar::DrawCaption(CFGAS_GEGraphics* pGraphics,
const CFX_Matrix* pMatrix) {
CFWL_ThemeText textParam;
textParam.m_pWidget = this;
textParam.m_iPart = CFWL_Part::Caption;
textParam.m_dwStates = CFWL_PartState_Normal;
textParam.m_pGraphics = pGraphics;
textParam.m_wsText = GetHeadText(m_iCurYear, m_iCurMonth);
m_HeadSize = CalcTextSize(textParam.m_wsText, false);
CalcHeadSize();
textParam.m_PartRect = m_HeadTextRect;
textParam.m_dwTTOStyles.single_line_ = true;
textParam.m_iTTOAlign = FDE_TextAlignment::kCenter;
if (pMatrix)
textParam.m_matrix.Concat(*pMatrix);
GetThemeProvider()->DrawText(textParam);
}
void CFWL_MonthCalendar::DrawSeparator(CFGAS_GEGraphics* pGraphics,
const CFX_Matrix* pMatrix) {
CFWL_ThemeBackground params;
params.m_pWidget = this;
params.m_iPart = CFWL_Part::HSeparator;
params.m_pGraphics = pGraphics;
params.m_dwStates = CFWL_PartState_Normal;
params.m_PartRect = m_HSepRect;
if (pMatrix)
params.m_matrix.Concat(*pMatrix);
GetThemeProvider()->DrawBackground(params);
}
void CFWL_MonthCalendar::DrawDatesInBK(CFGAS_GEGraphics* pGraphics,
const CFX_Matrix* pMatrix) {
CFWL_ThemeBackground params;
params.m_pWidget = this;
params.m_iPart = CFWL_Part::DateInBK;
params.m_pGraphics = pGraphics;
if (pMatrix)
params.m_matrix.Concat(*pMatrix);
IFWL_ThemeProvider* pTheme = GetThemeProvider();
int32_t iCount = pdfium::CollectionSize<int32_t>(m_DateArray);
for (int32_t j = 0; j < iCount; j++) {
DATEINFO* pDataInfo = m_DateArray[j].get();
if (pDataInfo->dwStates & FWL_ITEMSTATE_MCD_Selected) {
params.m_dwStates |= CFWL_PartState_Selected;
if (pDataInfo->dwStates & FWL_ITEMSTATE_MCD_Flag) {
params.m_dwStates |= CFWL_PartState_Flagged;
}
} else if (j == m_iHovered - 1) {
params.m_dwStates |= CFWL_PartState_Hovered;
} else if (pDataInfo->dwStates & FWL_ITEMSTATE_MCD_Flag) {
params.m_dwStates = CFWL_PartState_Flagged;
pTheme->DrawBackground(params);
}
params.m_PartRect = pDataInfo->rect;
pTheme->DrawBackground(params);
params.m_dwStates = 0;
}
}
void CFWL_MonthCalendar::DrawWeek(CFGAS_GEGraphics* pGraphics,
const CFX_Matrix* pMatrix) {
CFWL_ThemeText params;
params.m_pWidget = this;
params.m_iPart = CFWL_Part::Week;
params.m_pGraphics = pGraphics;
params.m_dwStates = CFWL_PartState_Normal;
params.m_iTTOAlign = FDE_TextAlignment::kCenter;
params.m_dwTTOStyles.single_line_ = true;
if (pMatrix)
params.m_matrix.Concat(*pMatrix);
IFWL_ThemeProvider* pTheme = GetThemeProvider();
CFX_RectF rtDayOfWeek;
for (int32_t i = 0; i < 7; ++i) {
rtDayOfWeek = CFX_RectF(
m_WeekRect.left + i * (m_CellSize.width + MONTHCAL_HMARGIN * 2),
m_WeekRect.top, m_CellSize);
params.m_PartRect = rtDayOfWeek;
params.m_wsText = GetAbbreviatedDayOfWeek(i);
pTheme->DrawText(params);
}
}
void CFWL_MonthCalendar::DrawToday(CFGAS_GEGraphics* pGraphics,
const CFX_Matrix* pMatrix) {
CFWL_ThemeText params;
params.m_pWidget = this;
params.m_iPart = CFWL_Part::Today;
params.m_pGraphics = pGraphics;
params.m_dwStates = CFWL_PartState_Normal;
params.m_iTTOAlign = FDE_TextAlignment::kCenterLeft;
params.m_wsText = GetTodayText(m_iYear, m_iMonth, m_iDay);
m_TodaySize = CalcTextSize(params.m_wsText, false);
CalcTodaySize();
params.m_PartRect = m_TodayRect;
params.m_dwTTOStyles.single_line_ = true;
if (pMatrix)
params.m_matrix.Concat(*pMatrix);
GetThemeProvider()->DrawText(params);
}
void CFWL_MonthCalendar::DrawDatesIn(CFGAS_GEGraphics* pGraphics,
const CFX_Matrix* pMatrix) {
CFWL_ThemeText params;
params.m_pWidget = this;
params.m_iPart = CFWL_Part::DatesIn;
params.m_pGraphics = pGraphics;
params.m_dwStates = CFWL_PartState_Normal;
params.m_iTTOAlign = FDE_TextAlignment::kCenter;
if (pMatrix)
params.m_matrix.Concat(*pMatrix);
IFWL_ThemeProvider* pTheme = GetThemeProvider();
int32_t iCount = pdfium::CollectionSize<int32_t>(m_DateArray);
for (int32_t j = 0; j < iCount; j++) {
DATEINFO* pDataInfo = m_DateArray[j].get();
params.m_wsText = pDataInfo->wsDay;
params.m_PartRect = pDataInfo->rect;
params.m_dwStates = pDataInfo->dwStates;
if (j + 1 == m_iHovered)
params.m_dwStates |= CFWL_PartState_Hovered;
params.m_dwTTOStyles.single_line_ = true;
pTheme->DrawText(params);
}
}
void CFWL_MonthCalendar::DrawDatesOut(CFGAS_GEGraphics* pGraphics,
const CFX_Matrix* pMatrix) {
CFWL_ThemeText params;
params.m_pWidget = this;
params.m_iPart = CFWL_Part::DatesOut;
params.m_pGraphics = pGraphics;
params.m_dwStates = CFWL_PartState_Normal;
params.m_iTTOAlign = FDE_TextAlignment::kCenter;
if (pMatrix)
params.m_matrix.Concat(*pMatrix);
GetThemeProvider()->DrawText(params);
}
void CFWL_MonthCalendar::DrawDatesInCircle(CFGAS_GEGraphics* pGraphics,
const CFX_Matrix* pMatrix) {
if (m_iMonth != m_iCurMonth || m_iYear != m_iCurYear)
return;
if (m_iDay < 1 || m_iDay > pdfium::CollectionSize<int32_t>(m_DateArray))
return;
DATEINFO* pDate = m_DateArray[m_iDay - 1].get();
if (!pDate)
return;
CFWL_ThemeBackground params;
params.m_pWidget = this;
params.m_iPart = CFWL_Part::DateInCircle;
params.m_pGraphics = pGraphics;
params.m_PartRect = pDate->rect;
params.m_dwStates = CFWL_PartState_Normal;
if (pMatrix)
params.m_matrix.Concat(*pMatrix);
GetThemeProvider()->DrawBackground(params);
}
CFX_SizeF CFWL_MonthCalendar::CalcSize() {
float fMaxWeekW = 0.0f;
float fMaxWeekH = 0.0f;
for (int i = 0; i < 7; ++i) {
CFX_SizeF sz = CalcTextSize(GetAbbreviatedDayOfWeek(i), false);
fMaxWeekW = (fMaxWeekW >= sz.width) ? fMaxWeekW : sz.width;
fMaxWeekH = (fMaxWeekH >= sz.height) ? fMaxWeekH : sz.height;
}
float fDayMaxW = 0.0f;
float fDayMaxH = 0.0f;
for (int day = 10; day <= 31; day++) {
CFX_SizeF sz = CalcTextSize(WideString::Format(L"%d", day), false);
fDayMaxW = (fDayMaxW >= sz.width) ? fDayMaxW : sz.width;
fDayMaxH = (fDayMaxH >= sz.height) ? fDayMaxH : sz.height;
}
m_CellSize.width =
static_cast<int>(0.5 + (fMaxWeekW >= fDayMaxW ? fMaxWeekW : fDayMaxW));
m_CellSize.height = fMaxWeekH >= fDayMaxH ? fMaxWeekH : fDayMaxH;
CFX_SizeF fs;
fs.width = m_CellSize.width * MONTHCAL_COLUMNS +
MONTHCAL_HMARGIN * MONTHCAL_COLUMNS * 2 +
MONTHCAL_HEADER_BTN_HMARGIN * 2;
float fMonthMaxW = 0.0f;
float fMonthMaxH = 0.0f;
for (int i = 0; i < 12; ++i) {
CFX_SizeF sz = CalcTextSize(GetMonth(i), false);
fMonthMaxW = (fMonthMaxW >= sz.width) ? fMonthMaxW : sz.width;
fMonthMaxH = (fMonthMaxH >= sz.height) ? fMonthMaxH : sz.height;
}
CFX_SizeF szYear = CalcTextSize(GetHeadText(m_iYear, m_iMonth), false);
fMonthMaxH = std::max(fMonthMaxH, szYear.height);
m_HeadSize = CFX_SizeF(fMonthMaxW + szYear.width, fMonthMaxH);
fMonthMaxW =
m_HeadSize.width + MONTHCAL_HEADER_BTN_HMARGIN * 2 + m_CellSize.width * 2;
fs.width = std::max(fs.width, fMonthMaxW);
m_wsToday = GetTodayText(m_iYear, m_iMonth, m_iDay);
m_TodaySize = CalcTextSize(m_wsToday, false);
m_TodaySize.height = (m_TodaySize.height >= m_CellSize.height)
? m_TodaySize.height
: m_CellSize.height;
fs.height = m_CellSize.width + m_CellSize.height * (MONTHCAL_ROWS - 2) +
m_TodaySize.height + MONTHCAL_VMARGIN * MONTHCAL_ROWS * 2 +
MONTHCAL_HEADER_BTN_VMARGIN * 4;
return fs;
}
void CFWL_MonthCalendar::CalcHeadSize() {
float fHeadHMargin = (m_ClientRect.width - m_HeadSize.width) / 2;
float fHeadVMargin = (m_CellSize.width - m_HeadSize.height) / 2;
m_HeadTextRect = CFX_RectF(m_ClientRect.left + fHeadHMargin,
m_ClientRect.top + MONTHCAL_HEADER_BTN_VMARGIN +
MONTHCAL_VMARGIN + fHeadVMargin,
m_HeadSize);
}
void CFWL_MonthCalendar::CalcTodaySize() {
m_TodayFlagRect = CFX_RectF(
m_ClientRect.left + MONTHCAL_HEADER_BTN_HMARGIN + MONTHCAL_HMARGIN,
m_DatesRect.bottom() + MONTHCAL_HEADER_BTN_VMARGIN + MONTHCAL_VMARGIN,
m_CellSize.width, m_TodaySize.height);
m_TodayRect = CFX_RectF(
m_ClientRect.left + MONTHCAL_HEADER_BTN_HMARGIN + m_CellSize.width +
MONTHCAL_HMARGIN * 2,
m_DatesRect.bottom() + MONTHCAL_HEADER_BTN_VMARGIN + MONTHCAL_VMARGIN,
m_TodaySize);
}
void CFWL_MonthCalendar::Layout() {
m_ClientRect = GetClientRect();
m_HeadRect = CFX_RectF(
m_ClientRect.left + MONTHCAL_HEADER_BTN_HMARGIN, m_ClientRect.top,
m_ClientRect.width - MONTHCAL_HEADER_BTN_HMARGIN * 2,
m_CellSize.width + (MONTHCAL_HEADER_BTN_VMARGIN + MONTHCAL_VMARGIN) * 2);
m_WeekRect = CFX_RectF(m_ClientRect.left + MONTHCAL_HEADER_BTN_HMARGIN,
m_HeadRect.bottom(),
m_ClientRect.width - MONTHCAL_HEADER_BTN_HMARGIN * 2,
m_CellSize.height + MONTHCAL_VMARGIN * 2);
m_LBtnRect = CFX_RectF(m_ClientRect.left + MONTHCAL_HEADER_BTN_HMARGIN,
m_ClientRect.top + MONTHCAL_HEADER_BTN_VMARGIN,
m_CellSize.width, m_CellSize.width);
m_RBtnRect = CFX_RectF(m_ClientRect.left + m_ClientRect.width -
MONTHCAL_HEADER_BTN_HMARGIN - m_CellSize.width,
m_ClientRect.top + MONTHCAL_HEADER_BTN_VMARGIN,
m_CellSize.width, m_CellSize.width);
m_HSepRect = CFX_RectF(
m_ClientRect.left + MONTHCAL_HEADER_BTN_HMARGIN + MONTHCAL_HMARGIN,
m_WeekRect.bottom() - MONTHCAL_VMARGIN,
m_ClientRect.width - (MONTHCAL_HEADER_BTN_HMARGIN + MONTHCAL_HMARGIN) * 2,
MONTHCAL_HSEP_HEIGHT);
m_DatesRect = CFX_RectF(m_ClientRect.left + MONTHCAL_HEADER_BTN_HMARGIN,
m_WeekRect.bottom(),
m_ClientRect.width - MONTHCAL_HEADER_BTN_HMARGIN * 2,
m_CellSize.height * (MONTHCAL_ROWS - 3) +
MONTHCAL_VMARGIN * (MONTHCAL_ROWS - 3) * 2);
CalDateItem();
}
void CFWL_MonthCalendar::CalDateItem() {
bool bNewWeek = false;
int32_t iWeekOfMonth = 0;
float fLeft = m_DatesRect.left;
float fTop = m_DatesRect.top;
for (const auto& pDateInfo : m_DateArray) {
if (bNewWeek) {
iWeekOfMonth++;
bNewWeek = false;
}
pDateInfo->rect = CFX_RectF(
fLeft +
pDateInfo->iDayOfWeek * (m_CellSize.width + (MONTHCAL_HMARGIN * 2)),
fTop + iWeekOfMonth * (m_CellSize.height + (MONTHCAL_VMARGIN * 2)),
m_CellSize.width + (MONTHCAL_HMARGIN * 2),
m_CellSize.height + (MONTHCAL_VMARGIN * 2));
if (pDateInfo->iDayOfWeek >= 6)
bNewWeek = true;
}
}
void CFWL_MonthCalendar::InitDate() {
CFX_DateTime now = CFX_DateTime::Now();
m_iYear = now.GetYear();
m_iMonth = now.GetMonth();
m_iDay = now.GetDay();
m_iCurYear = m_iYear;
m_iCurMonth = m_iMonth;
m_wsToday = GetTodayText(m_iYear, m_iMonth, m_iDay);
m_wsHead = GetHeadText(m_iCurYear, m_iCurMonth);
m_dtMin = DATE(1500, 12, 1);
m_dtMax = DATE(2200, 1, 1);
}
void CFWL_MonthCalendar::ClearDateItem() {
m_DateArray.clear();
}
void CFWL_MonthCalendar::ResetDateItem() {
int32_t iDays = FX_DaysInMonth(m_iCurYear, m_iCurMonth);
int32_t iDayOfWeek =
CFX_DateTime(m_iCurYear, m_iCurMonth, 1, 0, 0, 0, 0).GetDayOfWeek();
for (int32_t i = 0; i < iDays; i++) {
if (iDayOfWeek >= 7)
iDayOfWeek = 0;
uint32_t dwStates = 0;
if (m_iYear == m_iCurYear && m_iMonth == m_iCurMonth && m_iDay == (i + 1))
dwStates |= FWL_ITEMSTATE_MCD_Flag;
if (pdfium::Contains(m_SelDayArray, i + 1))
dwStates |= FWL_ITEMSTATE_MCD_Selected;
CFX_RectF rtDate;
m_DateArray.push_back(std::make_unique<DATEINFO>(
i + 1, iDayOfWeek, dwStates, rtDate, WideString::Format(L"%d", i + 1)));
iDayOfWeek++;
}
}
void CFWL_MonthCalendar::NextMonth() {
int32_t iYear = m_iCurYear;
int32_t iMonth = m_iCurMonth;
if (iMonth >= 12) {
iMonth = 1;
iYear++;
} else {
iMonth++;
}
DATE dt(m_iCurYear, m_iCurMonth, 1);
if (!(dt < m_dtMax))
return;
m_iCurYear = iYear, m_iCurMonth = iMonth;
ChangeToMonth(m_iCurYear, m_iCurMonth);
}
void CFWL_MonthCalendar::PrevMonth() {
int32_t iYear = m_iCurYear;
int32_t iMonth = m_iCurMonth;
if (iMonth <= 1) {
iMonth = 12;
iYear--;
} else {
iMonth--;
}
DATE dt(m_iCurYear, m_iCurMonth, 1);
if (!(dt > m_dtMin))
return;
m_iCurYear = iYear, m_iCurMonth = iMonth;
ChangeToMonth(m_iCurYear, m_iCurMonth);
}
void CFWL_MonthCalendar::ChangeToMonth(int32_t iYear, int32_t iMonth) {
m_iCurYear = iYear;
m_iCurMonth = iMonth;
m_iHovered = -1;
ClearDateItem();
ResetDateItem();
CalDateItem();
m_wsHead = GetHeadText(m_iCurYear, m_iCurMonth);
}
void CFWL_MonthCalendar::RemoveSelDay() {
int32_t iDatesCount = pdfium::CollectionSize<int32_t>(m_DateArray);
for (int32_t iSelDay : m_SelDayArray) {
if (iSelDay <= iDatesCount)
m_DateArray[iSelDay - 1]->dwStates &= ~FWL_ITEMSTATE_MCD_Selected;
}
m_SelDayArray.clear();
}
void CFWL_MonthCalendar::AddSelDay(int32_t iDay) {
DCHECK(iDay > 0);
if (!pdfium::Contains(m_SelDayArray, iDay))
return;
RemoveSelDay();
if (iDay <= pdfium::CollectionSize<int32_t>(m_DateArray))
m_DateArray[iDay - 1]->dwStates |= FWL_ITEMSTATE_MCD_Selected;
m_SelDayArray.push_back(iDay);
}
void CFWL_MonthCalendar::JumpToToday() {
if (m_iYear != m_iCurYear || m_iMonth != m_iCurMonth) {
m_iCurYear = m_iYear;
m_iCurMonth = m_iMonth;
ChangeToMonth(m_iYear, m_iMonth);
AddSelDay(m_iDay);
return;
}
if (!pdfium::Contains(m_SelDayArray, m_iDay))
AddSelDay(m_iDay);
}
WideString CFWL_MonthCalendar::GetHeadText(int32_t iYear, int32_t iMonth) {
DCHECK(iMonth > 0);
DCHECK(iMonth < 13);
static const wchar_t* const pMonth[] = {L"January", L"February", L"March",
L"April", L"May", L"June",
L"July", L"August", L"September",
L"October", L"November", L"December"};
return WideString::Format(L"%ls, %d", pMonth[iMonth - 1], iYear);
}
WideString CFWL_MonthCalendar::GetTodayText(int32_t iYear,
int32_t iMonth,
int32_t iDay) {
return WideString::Format(L"Today, %d/%d/%d", iDay, iMonth, iYear);
}
int32_t CFWL_MonthCalendar::GetDayAtPoint(const CFX_PointF& point) const {
int i = 1; // one-based day values.
for (const auto& pDateInfo : m_DateArray) {
if (pDateInfo->rect.Contains(point))
return i;
++i;
}
return -1;
}
CFX_RectF CFWL_MonthCalendar::GetDayRect(int32_t iDay) {
if (iDay <= 0 || iDay > pdfium::CollectionSize<int32_t>(m_DateArray))
return CFX_RectF();
DATEINFO* pDateInfo = m_DateArray[iDay - 1].get();
return pDateInfo ? pDateInfo->rect : CFX_RectF();
}
void CFWL_MonthCalendar::OnProcessMessage(CFWL_Message* pMessage) {
switch (pMessage->GetType()) {
case CFWL_Message::Type::kSetFocus:
case CFWL_Message::Type::kKillFocus:
GetOuter()->GetDelegate()->OnProcessMessage(pMessage);
break;
case CFWL_Message::Type::kKey:
break;
case CFWL_Message::Type::kMouse: {
CFWL_MessageMouse* pMouse = static_cast<CFWL_MessageMouse*>(pMessage);
switch (pMouse->m_dwCmd) {
case FWL_MouseCommand::LeftButtonDown:
OnLButtonDown(pMouse);
break;
case FWL_MouseCommand::LeftButtonUp:
OnLButtonUp(pMouse);
break;
case FWL_MouseCommand::Move:
OnMouseMove(pMouse);
break;
case FWL_MouseCommand::Leave:
OnMouseLeave(pMouse);
break;
default:
break;
}
break;
}
default:
break;
}
// Dst target could be |this|, continue only if not destroyed by above.
if (pMessage->GetDstTarget())
CFWL_Widget::OnProcessMessage(pMessage);
}
void CFWL_MonthCalendar::OnDrawWidget(CFGAS_GEGraphics* pGraphics,
const CFX_Matrix& matrix) {
DrawWidget(pGraphics, matrix);
}
void CFWL_MonthCalendar::OnLButtonDown(CFWL_MessageMouse* pMsg) {
if (m_LBtnRect.Contains(pMsg->m_pos)) {
m_iLBtnPartStates = CFWL_PartState_Pressed;
PrevMonth();
RepaintRect(m_ClientRect);
} else if (m_RBtnRect.Contains(pMsg->m_pos)) {
m_iRBtnPartStates |= CFWL_PartState_Pressed;
NextMonth();
RepaintRect(m_ClientRect);
} else if (m_TodayRect.Contains(pMsg->m_pos)) {
JumpToToday();
RepaintRect(m_ClientRect);
}
}
void CFWL_MonthCalendar::OnLButtonUp(CFWL_MessageMouse* pMsg) {
if (m_LBtnRect.Contains(pMsg->m_pos)) {
m_iLBtnPartStates = 0;
RepaintRect(m_LBtnRect);
return;
}
if (m_RBtnRect.Contains(pMsg->m_pos)) {
m_iRBtnPartStates = 0;
RepaintRect(m_RBtnRect);
return;
}
if (m_TodayRect.Contains(pMsg->m_pos))
return;
int32_t iOldSel = 0;
if (!m_SelDayArray.empty())
iOldSel = m_SelDayArray[0];
int32_t iCurSel = GetDayAtPoint(pMsg->m_pos);
if (iCurSel > 0) {
DATEINFO* lpDatesInfo = m_DateArray[iCurSel - 1].get();
CFX_RectF rtInvalidate(lpDatesInfo->rect);
if (iOldSel > 0 &&
iOldSel <= pdfium::CollectionSize<int32_t>(m_DateArray)) {
lpDatesInfo = m_DateArray[iOldSel - 1].get();
rtInvalidate.Union(lpDatesInfo->rect);
}
AddSelDay(iCurSel);
CFWL_DateTimePicker* pDateTime =
static_cast<CFWL_DateTimePicker*>(GetOuter());
pDateTime->ProcessSelChanged(m_iCurYear, m_iCurMonth, iCurSel);
pDateTime->ShowMonthCalendar(false);
}
}
void CFWL_MonthCalendar::OnMouseMove(CFWL_MessageMouse* pMsg) {
bool bRepaint = false;
CFX_RectF rtInvalidate;
if (m_DatesRect.Contains(pMsg->m_pos)) {
int32_t iHover = GetDayAtPoint(pMsg->m_pos);
bRepaint = m_iHovered != iHover;
if (bRepaint) {
if (m_iHovered > 0)
rtInvalidate = GetDayRect(m_iHovered);
if (iHover > 0) {
CFX_RectF rtDay = GetDayRect(iHover);
if (rtInvalidate.IsEmpty())
rtInvalidate = rtDay;
else
rtInvalidate.Union(rtDay);
}
}
m_iHovered = iHover;
} else {
bRepaint = m_iHovered > 0;
if (bRepaint)
rtInvalidate = GetDayRect(m_iHovered);
m_iHovered = -1;
}
if (bRepaint && !rtInvalidate.IsEmpty())
RepaintRect(rtInvalidate);
}
void CFWL_MonthCalendar::OnMouseLeave(CFWL_MessageMouse* pMsg) {
if (m_iHovered <= 0)
return;
CFX_RectF rtInvalidate = GetDayRect(m_iHovered);
m_iHovered = -1;
if (!rtInvalidate.IsEmpty())
RepaintRect(rtInvalidate);
}
CFWL_MonthCalendar::DATEINFO::DATEINFO(int32_t day,
int32_t dayofweek,
uint32_t dwSt,
CFX_RectF rc,
const WideString& wsday)
: iDay(day),
iDayOfWeek(dayofweek),
dwStates(dwSt),
rect(rc),
wsDay(wsday) {}
CFWL_MonthCalendar::DATEINFO::~DATEINFO() = default;