780 lines
20 KiB
Go
780 lines
20 KiB
Go
//go:build windows
|
|
|
|
package main
|
|
|
|
import (
|
|
"fmt"
|
|
"os"
|
|
"path/filepath"
|
|
"regexp"
|
|
"sort"
|
|
"strings"
|
|
"syscall"
|
|
"time"
|
|
"unsafe"
|
|
)
|
|
|
|
type historyCalendarCell struct {
|
|
Date time.Time
|
|
Rect winRect
|
|
Count int
|
|
Selected bool
|
|
InRange bool
|
|
}
|
|
|
|
type historyDetailRow struct {
|
|
Key string
|
|
Rect winRect
|
|
WorldLabel string
|
|
Start time.Time
|
|
End time.Time
|
|
Users []string
|
|
Lines []string
|
|
Selected bool
|
|
Current bool
|
|
}
|
|
|
|
type historyEventRecord struct {
|
|
At time.Time
|
|
Kind string
|
|
Name string
|
|
Raw string
|
|
}
|
|
|
|
type historyVisitRecord struct {
|
|
Key string
|
|
WorldLabel string
|
|
WorldID string
|
|
InstanceID string
|
|
Start time.Time
|
|
End time.Time
|
|
Current bool
|
|
}
|
|
|
|
type historyQuery struct {
|
|
Pattern *regexp.Regexp
|
|
From time.Time
|
|
To time.Time
|
|
HasFrom bool
|
|
HasTo bool
|
|
}
|
|
|
|
func ensureHistoryState(app *guiApp) {
|
|
if app == nil {
|
|
return
|
|
}
|
|
if app.historySelectedKeys == nil {
|
|
app.historySelectedKeys = map[string]bool{}
|
|
}
|
|
if app.historySelectedDate.IsZero() {
|
|
if latest := latestHistoryDate(); !latest.IsZero() {
|
|
app.historySelectedDate = latest
|
|
} else {
|
|
app.historySelectedDate = time.Now()
|
|
}
|
|
}
|
|
if app.historyMonth.IsZero() {
|
|
app.historyMonth = time.Date(app.historySelectedDate.Year(), app.historySelectedDate.Month(), 1, 0, 0, 0, 0, app.historySelectedDate.Location())
|
|
}
|
|
app.historySelectedDate = clampHistoryDate(app.historySelectedDate, historyQueryFromApp(app))
|
|
app.historyMonth = time.Date(app.historySelectedDate.Year(), app.historySelectedDate.Month(), 1, 0, 0, 0, 0, app.historySelectedDate.Location())
|
|
}
|
|
|
|
func historyQueryFromApp(app *guiApp) historyQuery {
|
|
q := historyQuery{}
|
|
if app == nil {
|
|
return q
|
|
}
|
|
if s := strings.TrimSpace(app.historyRegex); s != "" {
|
|
if re, err := regexp.Compile(s); err == nil {
|
|
q.Pattern = re
|
|
}
|
|
}
|
|
if s := strings.TrimSpace(app.historyFromDate); s != "" {
|
|
if t, err := time.ParseInLocation("2006-01-02", s, time.Local); err == nil {
|
|
q.From = t
|
|
q.HasFrom = true
|
|
}
|
|
}
|
|
if s := strings.TrimSpace(app.historyToDate); s != "" {
|
|
if t, err := time.ParseInLocation("2006-01-02", s, time.Local); err == nil {
|
|
q.To = t.AddDate(0, 0, 1)
|
|
q.HasTo = true
|
|
}
|
|
}
|
|
return q
|
|
}
|
|
|
|
func historyInQueryRange(day time.Time, q historyQuery) bool {
|
|
start, end := historyDayBounds(day)
|
|
if q.HasFrom && end.Before(q.From) {
|
|
return false
|
|
}
|
|
if q.HasTo && !start.Before(q.To) {
|
|
return false
|
|
}
|
|
return true
|
|
}
|
|
|
|
func historyDayBounds(day time.Time) (time.Time, time.Time) {
|
|
loc := day.Location()
|
|
if loc == nil {
|
|
loc = time.Local
|
|
}
|
|
start := time.Date(day.Year(), day.Month(), day.Day(), 0, 0, 0, 0, loc)
|
|
return start, start.AddDate(0, 0, 1)
|
|
}
|
|
|
|
func clampHistoryDate(day time.Time, q historyQuery) time.Time {
|
|
if day.IsZero() {
|
|
return day
|
|
}
|
|
start, end := historyDayBounds(day)
|
|
if q.HasFrom && start.Before(q.From) {
|
|
return q.From
|
|
}
|
|
if q.HasTo && !start.Before(q.To) {
|
|
return q.To.AddDate(0, 0, -1)
|
|
}
|
|
if q.HasFrom && q.HasTo {
|
|
if end.Before(q.From) {
|
|
return q.From
|
|
}
|
|
}
|
|
return day
|
|
}
|
|
|
|
func latestHistoryDate() time.Time {
|
|
visits := historyVisitSource()
|
|
var latest time.Time
|
|
for _, v := range visits {
|
|
at := v.End
|
|
if at.IsZero() {
|
|
at = v.Start
|
|
}
|
|
if at.After(latest) {
|
|
latest = at
|
|
}
|
|
}
|
|
if latest.IsZero() {
|
|
if world, since, ok := currentWorldVisitInfo(); ok && strings.TrimSpace(world) != "" && !since.IsZero() {
|
|
return since
|
|
}
|
|
}
|
|
return latest
|
|
}
|
|
|
|
func historyVisitSource() []historyVisitRecord {
|
|
records := make([]historyVisitRecord, 0, len(readWorldHistory())+1)
|
|
for _, visit := range readWorldHistory() {
|
|
records = append(records, historyVisitRecord{
|
|
Key: historyVisitKey(visit.WorldLabel, visit.StartedAt, visit.EndedAt, visit.WorldID, visit.InstanceID, false),
|
|
WorldLabel: visit.WorldLabel,
|
|
WorldID: visit.WorldID,
|
|
InstanceID: visit.InstanceID,
|
|
Start: visit.StartedAt,
|
|
End: visit.EndedAt,
|
|
})
|
|
}
|
|
if label, since, ok := currentWorldVisitInfo(); ok && strings.TrimSpace(label) != "" && !since.IsZero() {
|
|
records = append(records, historyVisitRecord{
|
|
Key: historyVisitKey(label, since, time.Time{}, "", "", true),
|
|
WorldLabel: label,
|
|
Start: since,
|
|
Current: true,
|
|
})
|
|
}
|
|
sort.SliceStable(records, func(i, j int) bool {
|
|
ti := records[i].End
|
|
if ti.IsZero() {
|
|
ti = records[i].Start
|
|
}
|
|
tj := records[j].End
|
|
if tj.IsZero() {
|
|
tj = records[j].Start
|
|
}
|
|
if ti.Equal(tj) {
|
|
return strings.ToLower(records[i].WorldLabel) < strings.ToLower(records[j].WorldLabel)
|
|
}
|
|
return ti.After(tj)
|
|
})
|
|
return records
|
|
}
|
|
|
|
func historyVisitKey(label string, start, end time.Time, worldID, instanceID string, current bool) string {
|
|
key := strings.TrimSpace(label)
|
|
if worldID != "" {
|
|
key = worldID
|
|
if instanceID != "" {
|
|
key += ":" + instanceID
|
|
}
|
|
}
|
|
if !start.IsZero() {
|
|
key += "|" + start.UTC().Format(time.RFC3339Nano)
|
|
}
|
|
if !end.IsZero() {
|
|
key += "|" + end.UTC().Format(time.RFC3339Nano)
|
|
}
|
|
if current {
|
|
key += "|current"
|
|
}
|
|
return key
|
|
}
|
|
|
|
func historyEventsFromLog() []historyEventRecord {
|
|
p := filepath.Join(runtimeDir(), "join_leave.log")
|
|
b, err := os.ReadFile(p)
|
|
if err != nil || len(b) == 0 {
|
|
return nil
|
|
}
|
|
out := make([]historyEventRecord, 0, 128)
|
|
var currentAt time.Time
|
|
for _, raw := range strings.Split(string(b), "\n") {
|
|
line := strings.TrimSpace(strings.TrimRight(raw, "\r"))
|
|
if line == "" {
|
|
continue
|
|
}
|
|
if strings.Contains(line, "VRC JOIN/LEAVE") {
|
|
if at, ok := parseRuntimeTime(line); ok {
|
|
currentAt = at
|
|
}
|
|
continue
|
|
}
|
|
m := joinLeaveBodyPattern.FindStringSubmatch(line)
|
|
if len(m) != 4 {
|
|
continue
|
|
}
|
|
out = append(out, historyEventRecord{
|
|
At: currentAt,
|
|
Kind: m[1],
|
|
Name: strings.TrimSpace(m[2]),
|
|
Raw: line,
|
|
})
|
|
}
|
|
return out
|
|
}
|
|
|
|
func historyVisitsForDay(app *guiApp, day time.Time) []historyDetailRow {
|
|
q := historyQueryFromApp(app)
|
|
if !historyInQueryRange(day, q) {
|
|
return nil
|
|
}
|
|
dayStart, dayEnd := historyDayBounds(day)
|
|
events := historyEventsFromLog()
|
|
visits := historyVisitSource()
|
|
rows := make([]historyDetailRow, 0, len(visits))
|
|
for _, visit := range visits {
|
|
visitStart := visit.Start
|
|
if visitStart.IsZero() {
|
|
continue
|
|
}
|
|
visitEnd := visit.End
|
|
if visitEnd.IsZero() {
|
|
visitEnd = time.Now()
|
|
}
|
|
if !visitStart.Before(dayEnd) || !visitEnd.After(dayStart) {
|
|
continue
|
|
}
|
|
segmentStart := visitStart
|
|
if segmentStart.Before(dayStart) {
|
|
segmentStart = dayStart
|
|
}
|
|
segmentEnd := visitEnd
|
|
if segmentEnd.After(dayEnd) {
|
|
segmentEnd = dayEnd
|
|
}
|
|
lines, users, matched := historyVisitLinesForSegment(visit.WorldLabel, segmentStart, segmentEnd, events, q)
|
|
if q.Pattern != nil && !matched {
|
|
continue
|
|
}
|
|
rows = append(rows, historyDetailRow{
|
|
Key: visit.Key,
|
|
WorldLabel: visit.WorldLabel,
|
|
Start: segmentStart,
|
|
End: segmentEnd,
|
|
Users: users,
|
|
Lines: lines,
|
|
Current: visit.Current,
|
|
})
|
|
}
|
|
sort.SliceStable(rows, func(i, j int) bool {
|
|
if rows[i].Start.Equal(rows[j].Start) {
|
|
return strings.ToLower(rows[i].WorldLabel) < strings.ToLower(rows[j].WorldLabel)
|
|
}
|
|
return rows[i].Start.Before(rows[j].Start)
|
|
})
|
|
return rows
|
|
}
|
|
|
|
func historyVisitLinesForSegment(worldLabel string, start, end time.Time, events []historyEventRecord, q historyQuery) ([]string, []string, bool) {
|
|
if end.Before(start) {
|
|
end = start
|
|
}
|
|
lines := make([]string, 0, 16)
|
|
users := make([]string, 0, 8)
|
|
seenUsers := map[string]struct{}{}
|
|
matched := false
|
|
if q.Pattern != nil && q.Pattern.MatchString(worldLabel) {
|
|
matched = true
|
|
}
|
|
for _, ev := range events {
|
|
if ev.At.IsZero() || ev.At.Before(start) || !ev.At.Before(end) {
|
|
continue
|
|
}
|
|
raw := fmt.Sprintf("[%s] %s %s", ev.At.Format("15:04"), ev.Kind, ev.Name)
|
|
if q.Pattern != nil {
|
|
if !(q.Pattern.MatchString(worldLabel) || q.Pattern.MatchString(ev.Name) || q.Pattern.MatchString(raw)) {
|
|
continue
|
|
}
|
|
}
|
|
matched = true
|
|
lines = append(lines, raw)
|
|
if _, ok := seenUsers[ev.Name]; !ok {
|
|
seenUsers[ev.Name] = struct{}{}
|
|
users = append(users, ev.Name)
|
|
}
|
|
}
|
|
if q.Pattern == nil {
|
|
matched = true
|
|
}
|
|
sort.Strings(users)
|
|
return lines, users, matched
|
|
}
|
|
|
|
func historyCalendarCellsForMonth(app *guiApp) []historyCalendarCell {
|
|
ensureHistoryState(app)
|
|
q := historyQueryFromApp(app)
|
|
monthStart := app.historyMonth
|
|
if monthStart.IsZero() {
|
|
monthStart = time.Now()
|
|
}
|
|
monthStart = time.Date(monthStart.Year(), monthStart.Month(), 1, 0, 0, 0, 0, monthStart.Location())
|
|
counts := map[string]int{}
|
|
daysInMonth := monthStart.AddDate(0, 1, -1).Day()
|
|
for day := 1; day <= daysInMonth; day++ {
|
|
date := time.Date(monthStart.Year(), monthStart.Month(), day, 0, 0, 0, 0, monthStart.Location())
|
|
counts[date.Format("2006-01-02")] = len(historyVisitsForDay(app, date))
|
|
}
|
|
firstWeekday := int(monthStart.Weekday())
|
|
out := make([]historyCalendarCell, 0, 42)
|
|
for i := 0; i < firstWeekday; i++ {
|
|
out = append(out, historyCalendarCell{})
|
|
}
|
|
for day := 1; day <= daysInMonth; day++ {
|
|
date := time.Date(monthStart.Year(), monthStart.Month(), day, 0, 0, 0, 0, monthStart.Location())
|
|
cell := historyCalendarCell{
|
|
Date: date,
|
|
Count: counts[date.Format("2006-01-02")],
|
|
InRange: historyInQueryRange(date, q),
|
|
}
|
|
if sameDay(date, app.historySelectedDate) {
|
|
cell.Selected = true
|
|
}
|
|
out = append(out, cell)
|
|
}
|
|
for len(out)%7 != 0 {
|
|
out = append(out, historyCalendarCell{})
|
|
}
|
|
return out
|
|
}
|
|
|
|
func sameDay(a, b time.Time) bool {
|
|
if a.IsZero() || b.IsZero() {
|
|
return false
|
|
}
|
|
ay, am, ad := a.Date()
|
|
by, bm, bd := b.Date()
|
|
return ay == by && am == bm && ad == bd
|
|
}
|
|
|
|
func exportHistoryDay(app *guiApp, day time.Time, selected map[string]bool) (string, error) {
|
|
rows := historyVisitsForDay(app, day)
|
|
if len(rows) == 0 {
|
|
return "", nil
|
|
}
|
|
if len(selected) > 0 {
|
|
filtered := rows[:0]
|
|
for _, row := range rows {
|
|
if selected[row.Key] {
|
|
filtered = append(filtered, row)
|
|
}
|
|
}
|
|
rows = append([]historyDetailRow(nil), filtered...)
|
|
}
|
|
if len(rows) == 0 {
|
|
return "", nil
|
|
}
|
|
var b strings.Builder
|
|
b.WriteString("Date: ")
|
|
b.WriteString(day.Format("2006-01-02"))
|
|
b.WriteString("\n")
|
|
if q := historyQueryFromApp(app); q.Pattern != nil {
|
|
b.WriteString("Filter: ")
|
|
b.WriteString(strings.TrimSpace(app.historyRegex))
|
|
b.WriteString("\n")
|
|
}
|
|
b.WriteString("\n")
|
|
for _, row := range rows {
|
|
b.WriteString("\nWorld: ")
|
|
b.WriteString(strings.TrimSpace(row.WorldLabel))
|
|
b.WriteString("\n")
|
|
b.WriteString("Time: ")
|
|
b.WriteString(row.Start.Format("15:04"))
|
|
b.WriteString(" - ")
|
|
b.WriteString(row.End.Format("15:04"))
|
|
b.WriteString("\n")
|
|
if len(row.Users) > 0 {
|
|
b.WriteString("Users: ")
|
|
b.WriteString(strings.Join(row.Users, ", "))
|
|
b.WriteString("\n")
|
|
}
|
|
if len(row.Lines) == 0 {
|
|
b.WriteString("(no matches)\n")
|
|
continue
|
|
}
|
|
for _, line := range row.Lines {
|
|
b.WriteString(line)
|
|
b.WriteString("\n")
|
|
}
|
|
}
|
|
path := filepath.Join(runtimeDir(), "visit_"+day.Format("20060102")+".log")
|
|
if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
|
|
return "", err
|
|
}
|
|
if err := os.WriteFile(path, []byte(b.String()), 0o644); err != nil {
|
|
return "", err
|
|
}
|
|
return path, nil
|
|
}
|
|
|
|
func paintHistoryCalendarPane(hwnd uintptr, app *guiApp) uintptr {
|
|
if app == nil {
|
|
return 0
|
|
}
|
|
ensureHistoryState(app)
|
|
hdc, done := beginPanePaint(hwnd)
|
|
if hdc == 0 {
|
|
return 0
|
|
}
|
|
defer done()
|
|
|
|
var rc winRect
|
|
getClientRectProc.Call(hwnd, uintptr(unsafe.Pointer(&rc)))
|
|
fillSolid(hdc, rc, clrPaneBg)
|
|
drawPaneText(hdc, 18, 18, "履歴カレンダー", app.joinBoldHFont, clrAccentGreen)
|
|
monthLabel := app.historyMonth.Format("2006年01月")
|
|
drawPaneText(hdc, 18, 42, monthLabel, app.hFont, clrText)
|
|
|
|
app.historyPrevMonthRect = winRect{Left: rc.Right - 108, Top: 14, Right: rc.Right - 58, Bottom: 42}
|
|
app.historyNextMonthRect = winRect{Left: rc.Right - 54, Top: 14, Right: rc.Right - 14, Bottom: 42}
|
|
drawSettingsBox(hdc, app.historyPrevMonthRect, 0x0038281a, clrPaneBorder)
|
|
drawSettingsBox(hdc, app.historyNextMonthRect, 0x0038281a, clrPaneBorder)
|
|
drawCenteredPaneText(hdc, app.historyPrevMonthRect, "<", app.hFont, clrText)
|
|
drawCenteredPaneText(hdc, app.historyNextMonthRect, ">", app.hFont, clrText)
|
|
|
|
weekdays := []string{"日", "月", "火", "水", "木", "金", "土"}
|
|
cellW := (rc.Right - 24) / 7
|
|
if cellW < 48 {
|
|
cellW = 48
|
|
}
|
|
cellH := int32(56)
|
|
startX := int32(12)
|
|
startY := int32(80)
|
|
for i, wd := range weekdays {
|
|
x := startX + int32(i)*cellW
|
|
drawPaneText(hdc, x+6, startY-18, wd, app.hFont, clrMutedText)
|
|
}
|
|
|
|
cells := historyCalendarCellsForMonth(app)
|
|
app.historyCalendarCells = app.historyCalendarCells[:0]
|
|
for i, cell := range cells {
|
|
if cell.Date.IsZero() {
|
|
continue
|
|
}
|
|
col := i % 7
|
|
row := i / 7
|
|
rect := winRect{
|
|
Left: startX + int32(col)*cellW,
|
|
Top: startY + int32(row)*cellH,
|
|
Right: startX + int32(col+1)*cellW - 4,
|
|
Bottom: startY + int32(row+1)*cellH - 4,
|
|
}
|
|
cell.Rect = rect
|
|
app.historyCalendarCells = append(app.historyCalendarCells, cell)
|
|
fill := uint32(0x00261a11)
|
|
border := uint32(clrPaneBorder)
|
|
textColor := uint32(clrText)
|
|
if !cell.InRange {
|
|
fill = 0x001b140d
|
|
textColor = uint32(clrMutedText)
|
|
}
|
|
if cell.Count > 0 {
|
|
fill = 0x00321f12
|
|
border = clrAccentGreen
|
|
}
|
|
if cell.Selected {
|
|
fill = 0x003d2a14
|
|
border = clrAccentBlue
|
|
}
|
|
drawSettingsBox(hdc, rect, fill, border)
|
|
drawPaneText(hdc, rect.Left+6, rect.Top+6, fmt.Sprintf("%d", cell.Date.Day()), app.hFont, textColor)
|
|
if cell.Count > 0 {
|
|
drawPaneText(hdc, rect.Right-24, rect.Bottom-18, fmt.Sprintf("%d", cell.Count), app.hFont, clrAccentGreen)
|
|
}
|
|
}
|
|
|
|
if app.historyStatus != "" {
|
|
drawPaneText(hdc, 18, rc.Bottom-26, app.historyStatus, app.hFont, clrMutedText)
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func paintHistoryDetailPane(hwnd uintptr, app *guiApp) uintptr {
|
|
if app == nil {
|
|
return 0
|
|
}
|
|
ensureHistoryState(app)
|
|
hdc, done := beginPanePaint(hwnd)
|
|
if hdc == 0 {
|
|
return 0
|
|
}
|
|
defer done()
|
|
|
|
var rc winRect
|
|
getClientRectProc.Call(hwnd, uintptr(unsafe.Pointer(&rc)))
|
|
fillSolid(hdc, rc, clrPaneBgAlt)
|
|
|
|
rows := historyVisitsForDay(app, app.historySelectedDate)
|
|
app.historyDetailRows = app.historyDetailRows[:0]
|
|
|
|
title := app.historySelectedDate.Format("2006年01月02日")
|
|
drawPaneText(hdc, 18, 18, title, app.joinBoldHFont, clrAccentGreen)
|
|
summary := fmt.Sprintf("%d件", len(rows))
|
|
drawPaneText(hdc, 18, 44, summary, app.hFont, clrMutedText)
|
|
if strings.TrimSpace(app.historyRegex) != "" {
|
|
drawPaneText(hdc, 96, 44, "grep: "+app.historyRegex, app.hFont, clrMutedText)
|
|
}
|
|
if strings.TrimSpace(app.historyFromDate) != "" || strings.TrimSpace(app.historyToDate) != "" {
|
|
rangeLabel := strings.TrimSpace(app.historyFromDate)
|
|
if rangeLabel == "" {
|
|
rangeLabel = "..."
|
|
}
|
|
rangeLabel += " - "
|
|
if to := strings.TrimSpace(app.historyToDate); to != "" {
|
|
rangeLabel += to
|
|
} else {
|
|
rangeLabel += "..."
|
|
}
|
|
drawPaneText(hdc, 260, 44, rangeLabel, app.hFont, clrMutedText)
|
|
}
|
|
|
|
app.historyExportRect = winRect{Left: rc.Right - 132, Top: 14, Right: rc.Right - 16, Bottom: 42}
|
|
drawSettingsBox(hdc, app.historyExportRect, 0x0038281a, clrAccentGreen)
|
|
drawCenteredPaneText(hdc, app.historyExportRect, "Export", app.hFont, clrText)
|
|
if app.historyStatus != "" {
|
|
drawPaneText(hdc, 18, rc.Bottom-26, app.historyStatus, app.hFont, clrMutedText)
|
|
}
|
|
|
|
pageHeight := rc.Bottom - rc.Top
|
|
contentHeight := historyDetailContentHeight(hwnd, app)
|
|
maxPos := scrollMax(contentHeight, pageHeight)
|
|
if app.historyScrollPos > maxPos {
|
|
app.historyScrollPos = maxPos
|
|
}
|
|
applyPaneScroll(hwnd, app.historyScrollPos, contentHeight, pageHeight)
|
|
|
|
y := int32(82 - app.historyScrollPos)
|
|
for _, row := range rows {
|
|
rowHeight := historyDetailRowHeight(row)
|
|
row.Rect = winRect{Left: 14, Top: y, Right: rc.Right - 14, Bottom: y + rowHeight - 4}
|
|
app.historyDetailRows = append(app.historyDetailRows, row)
|
|
if row.Rect.Bottom < 72 {
|
|
y += rowHeight
|
|
continue
|
|
}
|
|
if row.Rect.Top > rc.Bottom-40 {
|
|
break
|
|
}
|
|
selected := app.historySelectedKeys != nil && app.historySelectedKeys[row.Key]
|
|
fill := uint32(0x00271b12)
|
|
border := uint32(clrPaneBorder)
|
|
if selected {
|
|
fill = 0x00331f11
|
|
border = clrAccentBlue
|
|
} else if row.Current {
|
|
border = clrAccentGreen
|
|
}
|
|
drawSettingsBox(hdc, row.Rect, fill, border)
|
|
drawPaneText(hdc, row.Rect.Left+12, y+6, row.Start.Format("15:04")+" - "+row.End.Format("15:04"), app.hFont, clrMutedText)
|
|
drawPaneText(hdc, row.Rect.Left+122, y+6, humanDurationLabel(row.Start, row.End, row.Current), app.hFont, clrMutedText)
|
|
label := ellipsizeTextToWidth(hdc, row.WorldLabel, row.Rect.Right-row.Rect.Left-150, app.joinBoldHFont)
|
|
if label == "" {
|
|
label = "(unknown)"
|
|
}
|
|
drawPaneText(hdc, row.Rect.Left+12, y+24, label, app.joinBoldHFont, clrText)
|
|
if len(row.Users) > 0 {
|
|
users := "Users: " + strings.Join(row.Users, ", ")
|
|
drawPaneText(hdc, row.Rect.Left+12, y+44, ellipsizeTextToWidth(hdc, users, row.Rect.Right-row.Rect.Left-24, app.hFont), app.hFont, clrMutedText)
|
|
}
|
|
lineY := y + 62
|
|
showLines := row.Lines
|
|
if len(showLines) > 3 {
|
|
showLines = append([]string(nil), showLines[:3]...)
|
|
showLines = append(showLines, fmt.Sprintf("... +%d more", len(row.Lines)-3))
|
|
}
|
|
for _, line := range showLines {
|
|
drawPaneText(hdc, row.Rect.Left+18, lineY, ellipsizeTextToWidth(hdc, line, row.Rect.Right-row.Rect.Left-40, app.hFont), app.hFont, clrText)
|
|
lineY += 18
|
|
}
|
|
y += rowHeight
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func historyDetailContentHeight(hwnd uintptr, app *guiApp) int32 {
|
|
if app == nil || getClientRectProc == nil {
|
|
return 0
|
|
}
|
|
var rc winRect
|
|
getClientRectProc.Call(hwnd, uintptr(unsafe.Pointer(&rc)))
|
|
rows := historyVisitsForDay(app, app.historySelectedDate)
|
|
height := int32(90)
|
|
for _, row := range rows {
|
|
height += historyDetailRowHeight(row) + 6
|
|
}
|
|
if height < 120 {
|
|
height = 120
|
|
}
|
|
return height
|
|
}
|
|
|
|
func historyDetailRowHeight(row historyDetailRow) int32 {
|
|
lines := len(row.Lines)
|
|
if lines > 3 {
|
|
lines = 4
|
|
}
|
|
height := int32(72 + lines*18)
|
|
if len(row.Users) > 0 {
|
|
height += 18
|
|
}
|
|
if height < 84 {
|
|
height = 84
|
|
}
|
|
if height > 160 {
|
|
height = 160
|
|
}
|
|
return height
|
|
}
|
|
|
|
func handleHistoryPaneClick(app *guiApp, hwnd uintptr, x, y int32, setWindowText *syscall.LazyProc) bool {
|
|
if app == nil {
|
|
return false
|
|
}
|
|
ensureHistoryState(app)
|
|
switch hwnd {
|
|
case app.leftHwnd:
|
|
if pointInRect(x, y, app.historyPrevMonthRect) {
|
|
historyShiftMonth(app, -1)
|
|
return true
|
|
}
|
|
if pointInRect(x, y, app.historyNextMonthRect) {
|
|
historyShiftMonth(app, 1)
|
|
return true
|
|
}
|
|
for _, cell := range app.historyCalendarCells {
|
|
if cell.Date.IsZero() || !pointInRect(x, y, cell.Rect) {
|
|
continue
|
|
}
|
|
historySelectDate(app, cell.Date)
|
|
return true
|
|
}
|
|
case app.rightHwnd:
|
|
if pointInRect(x, y, app.historyExportRect) {
|
|
path, err := exportHistoryDay(app, app.historySelectedDate, app.historySelectedKeys)
|
|
if err != nil {
|
|
app.historyStatus = "export failed: " + err.Error()
|
|
} else if path != "" {
|
|
app.historyStatus = "exported: " + filepath.Base(path)
|
|
} else {
|
|
app.historyStatus = "exported: nothing selected"
|
|
}
|
|
invalidateHistoryPanes(app)
|
|
return true
|
|
}
|
|
for _, row := range app.historyDetailRows {
|
|
if row.Key == "" || !pointInRect(x, y, row.Rect) {
|
|
continue
|
|
}
|
|
if app.historySelectedKeys == nil {
|
|
app.historySelectedKeys = map[string]bool{}
|
|
}
|
|
if app.historySelectedKeys[row.Key] {
|
|
delete(app.historySelectedKeys, row.Key)
|
|
} else {
|
|
app.historySelectedKeys[row.Key] = true
|
|
}
|
|
invalidateHistoryPanes(app)
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
func historyShiftMonth(app *guiApp, delta int) {
|
|
if app == nil || delta == 0 {
|
|
return
|
|
}
|
|
ensureHistoryState(app)
|
|
base := app.historyMonth
|
|
if base.IsZero() {
|
|
base = app.historySelectedDate
|
|
}
|
|
if base.IsZero() {
|
|
base = time.Now()
|
|
}
|
|
nextMonth := time.Date(base.Year(), base.Month(), 1, 0, 0, 0, 0, base.Location()).AddDate(0, delta, 0)
|
|
if nextMonth.IsZero() {
|
|
return
|
|
}
|
|
day := app.historySelectedDate.Day()
|
|
lastDay := nextMonth.AddDate(0, 1, -1).Day()
|
|
if day > lastDay {
|
|
day = lastDay
|
|
}
|
|
nextDate := time.Date(nextMonth.Year(), nextMonth.Month(), day, 0, 0, 0, 0, nextMonth.Location())
|
|
historySelectDate(app, nextDate)
|
|
invalidateHistoryPanes(app)
|
|
}
|
|
|
|
func historySelectDate(app *guiApp, day time.Time) {
|
|
if app == nil || day.IsZero() {
|
|
return
|
|
}
|
|
ensureHistoryState(app)
|
|
q := historyQueryFromApp(app)
|
|
day = clampHistoryDate(day, q)
|
|
if day.IsZero() {
|
|
return
|
|
}
|
|
app.historySelectedDate = time.Date(day.Year(), day.Month(), day.Day(), 0, 0, 0, 0, day.Location())
|
|
app.historyMonth = time.Date(day.Year(), day.Month(), 1, 0, 0, 0, 0, day.Location())
|
|
app.historySelectedKeys = map[string]bool{}
|
|
app.historyStatus = ""
|
|
app.historyScrollPos = 0
|
|
invalidateHistoryPanes(app)
|
|
}
|
|
|
|
func invalidateHistoryPanes(app *guiApp) {
|
|
if invalidateRectProc == nil {
|
|
return
|
|
}
|
|
if app != nil {
|
|
if app.leftHwnd != 0 {
|
|
invalidateRectProc.Call(app.leftHwnd, 0, 1)
|
|
}
|
|
if app.rightHwnd != 0 {
|
|
invalidateRectProc.Call(app.rightHwnd, 0, 1)
|
|
}
|
|
}
|
|
}
|