]> git.r.bdr.sh - rbdr/captura/blob - Captura/Presentation/Windows/RecordingWindow.swift
Add license and contributing
[rbdr/captura] / Captura / Presentation / Windows / RecordingWindow.swift
1 /*
2 Copyright (C) 2024 Rubén Beltrán del Río
3
4 This program is free software: you can redistribute it and/or modify
5 it under the terms of the GNU General Public License as published by
6 the Free Software Foundation, either version 3 of the License, or
7 (at your option) any later version.
8
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 GNU General Public License for more details.
13
14 You should have received a copy of the GNU General Public License
15 along with this program. If not, see https://captura.tranquil.systems.
16 */
17 import Cocoa
18 import Combine
19
20 class RecordingWindow: NSWindow {
21
22 var pixelDensity: CGFloat {
23 self.screen?.backingScaleFactor ?? 1.0
24 }
25
26 var recordingContentView: RecordingContentView {
27 self.contentView as! RecordingContentView
28 }
29
30 init(_ configuration: CaptureSessionConfiguration, _ button: NSRect?) {
31
32 let boundingBox = NSScreen.screenWithMouse?.frame ?? NSZeroRect
33
34 super.init(
35 contentRect: boundingBox,
36 styleMask: [.borderless],
37 backing: .buffered,
38 defer: false)
39
40
41 self.isReleasedWhenClosed = false
42 self.collectionBehavior = [.canJoinAllSpaces]
43 self.isMovableByWindowBackground = false
44 self.isMovable = false
45 self.canHide = false
46 self.titlebarAppearsTransparent = true
47 self.setFrame(boundingBox, display: true)
48 self.titleVisibility = .hidden
49 let recordingView = RecordingContentView(configuration, frame: boundingBox, button: button ?? NSZeroRect)
50 recordingView.frame = boundingBox
51 self.contentView = recordingView
52 self.backgroundColor = NSColor(white: 1.0, alpha: 0.001)
53 // uncomment below to debug window placement visually
54 // self.backgroundColor = NSColor(red: 1.0, green: 0.0, blue: 1.0, alpha: 0.5)
55 self.level = .screenSaver
56 self.isOpaque = false
57 self.hasShadow = false
58 }
59
60 // MARK: - Window Behavior Overrides
61
62 override func resetCursorRects() {
63 super.resetCursorRects()
64 let cursor = NSCursor.crosshair
65 self.contentView?.addCursorRect(self.contentView!.bounds, cursor: cursor)
66 }
67
68 override var canBecomeKey: Bool {
69 return true
70 }
71
72 override var canBecomeMain: Bool {
73 return true
74 }
75
76 override func resignMain() {
77 super.resignMain()
78 if (self.contentView as? RecordingContentView)?.state != .recording {
79 self.ignoresMouseEvents = false
80 }
81 }
82
83 override func becomeMain() {
84 super.becomeMain()
85 if (self.contentView as? RecordingContentView)?.state != .recording {
86 (self.contentView as? RecordingContentView)?.state = .idle
87 }
88 }
89 }
90
91 enum RecordingWindowState {
92 case passthrough, idle, drawing, moving, resizing, recording;
93 }
94
95 class RecordingContentView: NSView {
96
97 init(_ configuration: CaptureSessionConfiguration, frame: NSRect, button: NSRect) {
98 self.buttonSize = button.size
99 var buttonOffset = NSPoint()
100 for screen in NSScreen.screens {
101 if screen.frame.intersects(button) {
102 let relativeY = screen.frame.height - (button.minY - screen.frame.minY)
103 let relativeX = screen.frame.width - (button.minX - screen.frame.minX)
104 buttonOffset = NSPoint(x: relativeX, y: relativeY)
105 }
106 }
107 self.buttonOffset = buttonOffset
108 super.init(frame: frame)
109 preventResize = configuration.preventResize
110 preventMove = configuration.preventMove
111 autoStart = configuration.autoStart
112
113 self.bounds = frame
114 self.button = NSRect(x: frame.maxX - buttonOffset.x, y: frame.maxY - buttonOffset.y, width: buttonSize.width, height: buttonSize.height)
115
116 if configuration.x != nil || configuration.y != nil || configuration.width != nil || configuration.height != nil {
117 box = NSRect(
118 x: configuration.x ?? Int(frame.width / 2.0),
119 y: configuration.y ?? Int(frame.height / 2.0),
120 width: configuration.width ?? 400,
121 height: configuration.height ?? 400
122 )
123 }
124
125 if autoStart {
126 DispatchQueue.main.asyncAfter(deadline: .now() + 3.0) {
127 NotificationCenter.default.post(name: .startRecording, object: nil, userInfo: nil)
128 }
129 }
130 }
131
132 required init?(coder: NSCoder) {
133 fatalError("init(coder:) has not been implemented")
134 }
135
136 private let buttonSize: NSSize
137 private let buttonOffset: NSPoint
138 public var button: NSRect? = nil
139 @Published public var box: NSRect? = nil
140 public var state: RecordingWindowState = .idle
141 private var mouseLocation: NSPoint = NSPoint()
142 private var origin: NSPoint = NSPoint()
143 private var boxOrigin: NSPoint = NSPoint()
144 private var preventResize = false
145 private var preventMove = false
146 private var autoStart = false
147
148 private var resizeBox: NSRect? {
149 if let box {
150 return NSRect(x: box.maxX - 5, y: box.minY - 5, width: 10, height: 10)
151 }
152 return nil
153 }
154
155 private var shouldPassthrough: Bool {
156 state == .recording || state == .passthrough
157 }
158
159 // MARK: - State changing API
160
161 public func startRecording() {
162 state = .recording
163 window?.ignoresMouseEvents = true
164 }
165
166 public func stopRecording() {
167
168 }
169
170 public func reset() {
171 state = .idle
172 window?.ignoresMouseEvents = false
173 }
174
175 public func startPassthrough() {
176 state = .passthrough
177 window?.ignoresMouseEvents = true
178 }
179
180 public func stopPassthrough() {
181 state = .idle
182 window?.ignoresMouseEvents = false
183 }
184
185 // MARK: - View Behavior Overrides
186
187 override func updateTrackingAreas() {
188 super.updateTrackingAreas()
189
190 for trackingArea in self.trackingAreas {
191 self.removeTrackingArea(trackingArea)
192 }
193
194 let options: NSTrackingArea.Options = [.mouseEnteredAndExited, .activeInKeyWindow, .cursorUpdate, .mouseMoved]
195 let trackingArea = NSTrackingArea(rect: self.bounds, options: options, owner: self, userInfo: nil)
196 self.addTrackingArea(trackingArea)
197 }
198
199 override func mouseExited(with event: NSEvent) {
200 if state == .idle && box == nil {
201 self.moveWindow()
202 }
203 }
204
205 override func mouseMoved(with event: NSEvent) {
206
207 self.mouseLocation = self.convert(event.locationInWindow, from: nil)
208
209 if shouldPassthrough {
210 NSCursor.arrow.set()
211 } else {
212 if let box {
213 if resizeBox!.contains(mouseLocation) {
214 NSCursor.arrow.set()
215 } else {
216 if box.contains(mouseLocation) {
217 NSCursor.openHand.set()
218 } else {
219 NSCursor.crosshair.set()
220 }
221 }
222 if let button {
223 if button.contains(mouseLocation) {
224 NSCursor.arrow.set()
225 }
226 }
227 } else {
228 NSCursor.crosshair.set()
229 }
230 }
231
232 self.setNeedsDisplay(self.bounds)
233 }
234
235 override func mouseDragged(with event: NSEvent) {
236 self.mouseLocation = self.convert(event.locationInWindow, from: nil)
237 if state == .drawing {
238 box = NSRect(
239 x: round(min(origin.x, mouseLocation.x)),
240 y: round(min(origin.y, mouseLocation.y)),
241 width: round(abs(mouseLocation.x - origin.x)),
242 height: round(abs(mouseLocation.y - origin.y))
243 )
244 }
245
246 if box != nil {
247 if state == .moving {
248 NSCursor.closedHand.set()
249 box!.origin = NSPoint(
250 x: self.boxOrigin.x - self.origin.x + self.mouseLocation.x,
251 y: self.boxOrigin.y - self.origin.y + self.mouseLocation.y)
252 }
253
254 if state == .resizing {
255 box = NSRect(
256 x: round(min(origin.x, mouseLocation.x)),
257 y: round(min(origin.y, mouseLocation.y)),
258 width: round(abs(mouseLocation.x - origin.x)),
259 height: round(abs(mouseLocation.y - origin.y))
260 )
261 }
262 }
263 self.setNeedsDisplay(self.bounds)
264 }
265
266 override func cursorUpdate(with event: NSEvent) {
267 NSCursor.crosshair.set()
268 }
269
270 override func hitTest(_ point: NSPoint) -> NSView? {
271 return shouldPassthrough ? nil : self
272 }
273
274 override var acceptsFirstResponder: Bool {
275 return true
276 }
277
278 override func mouseDown(with event: NSEvent) {
279 self.origin = self.convert(event.locationInWindow, from: nil)
280 if let box {
281
282 if let button {
283 if button.contains(origin) {
284 NotificationCenter.default.post(name: .startRecording, object: nil, userInfo: nil)
285 return
286 }
287 }
288
289 if resizeBox!.contains(origin) && !preventResize {
290 self.origin = NSPoint(x: box.minX, y: box.maxY)
291 state = .resizing
292 return
293 }
294 if box.contains(origin) && !preventMove {
295 state = .moving
296 self.boxOrigin = NSPoint(x: box.origin.x, y: box.origin.y)
297 return
298 }
299 }
300
301 if preventResize || preventMove {
302 return
303 }
304
305 state = .drawing
306 }
307
308 override func mouseUp(with event: NSEvent) {
309 if state != .recording {
310 state = .idle
311 }
312 }
313
314 override func keyDown(with event: NSEvent) {
315 switch event.keyCode {
316 case 53: // Escape key
317 NotificationCenter.default.post(name: .reset, object: nil, userInfo: nil)
318 default:
319 super.keyDown(with: event)
320 }
321 }
322
323 override func flagsChanged(with event: NSEvent) {
324 if state == .idle {
325 if event.modifierFlags.contains(.shift) {
326 startPassthrough()
327 } else {
328 stopPassthrough()
329 }
330 }
331 }
332
333 override func draw(_ dirtyRect: NSRect) {
334 if shouldPassthrough {
335 NSColor.clear.setFill()
336 } else {
337 NSColor(white: 1.0, alpha: 0.001).setFill()
338 }
339 dirtyRect.fill()
340
341 let dashLength: CGFloat = 5.0
342 let lineWidth = 0.5
343
344 // Uncomment below to debug button placement visually
345 // if let button {
346 // let buttonPath = NSBezierPath()
347 // buttonPath.move(to: NSPoint(x: button.minX, y: button.minY))
348 // buttonPath.line(to: NSPoint(x: button.maxX, y: button.minY))
349 // buttonPath.line(to: NSPoint(x: button.maxX, y: button.maxY))
350 // buttonPath.line(to: NSPoint(x: button.minX, y: button.maxY))
351 // buttonPath.line(to: NSPoint(x: button.minX, y: button.minY))
352 // NSColor(red: 1, green: 0, blue: 1, alpha: 1).setFill()
353 // buttonPath.fill()
354 // }
355
356 if state == .idle && box == nil {
357 let blackLine = NSBezierPath()
358 blackLine.lineWidth = lineWidth
359 blackLine.setLineDash([dashLength, dashLength], count: 2, phase: 0)
360
361 // Vertical line (Black)
362 blackLine.move(to: NSPoint(x: self.mouseLocation.x, y: NSMinY(self.bounds)))
363 blackLine.line(to: NSPoint(x: self.mouseLocation.x, y: NSMaxY(self.bounds)))
364
365 // Horizontal line (Black)
366 blackLine.move(to: NSPoint(x: NSMinX(self.bounds), y: self.mouseLocation.y))
367 blackLine.line(to: NSPoint(x: NSMaxX(self.bounds), y: self.mouseLocation.y))
368
369 NSColor.black.setStroke()
370 blackLine.stroke()
371
372 let whiteLine = NSBezierPath()
373 whiteLine.lineWidth = lineWidth
374 whiteLine.setLineDash([dashLength, dashLength], count: 2, phase: dashLength)
375
376 // Vertical line (White)
377 whiteLine.move(to: NSPoint(x: self.mouseLocation.x, y: NSMinY(self.bounds)))
378 whiteLine.line(to: NSPoint(x: self.mouseLocation.x, y: NSMaxY(self.bounds)))
379
380 // Horizontal line (White)
381 whiteLine.move(to: NSPoint(x: NSMinX(self.bounds), y: self.mouseLocation.y))
382 whiteLine.line(to: NSPoint(x: NSMaxX(self.bounds), y: self.mouseLocation.y))
383
384 NSColor.white.setStroke()
385 whiteLine.stroke()
386 }
387
388 if let box {
389 let blackBox = NSBezierPath()
390 blackBox.lineWidth = lineWidth
391 blackBox.setLineDash([dashLength, dashLength], count: 2, phase: 0)
392 blackBox.move(to: NSPoint(x: box.minX, y: box.minY))
393 blackBox.line(to: NSPoint(x: box.maxX, y: box.minY))
394 blackBox.line(to: NSPoint(x: box.maxX, y: box.maxY))
395 blackBox.line(to: NSPoint(x: box.minX, y: box.maxY))
396 blackBox.line(to: NSPoint(x: box.minX, y: box.minY))
397 NSColor.black.setStroke()
398 blackBox.stroke()
399
400 let whiteBox = NSBezierPath()
401 whiteBox.lineWidth = lineWidth
402 whiteBox.setLineDash([dashLength, dashLength], count: 2, phase: dashLength)
403 whiteBox.move(to: NSPoint(x: box.minX, y: box.minY))
404 whiteBox.line(to: NSPoint(x: box.maxX, y: box.minY))
405 whiteBox.line(to: NSPoint(x: box.maxX, y: box.maxY))
406 whiteBox.line(to: NSPoint(x: box.minX, y: box.maxY))
407 whiteBox.line(to: NSPoint(x: box.minX, y: box.minY))
408 NSColor.white.setStroke()
409 whiteBox.stroke()
410
411 if state == .recording {
412 return
413 }
414
415 if let resizeBox {
416 let clearBox = NSBezierPath()
417 clearBox.move(to: NSPoint(x: resizeBox.minX, y: resizeBox.minY))
418 clearBox.line(to: NSPoint(x: resizeBox.maxX, y: resizeBox.minY))
419 clearBox.line(to: NSPoint(x: resizeBox.maxX, y: resizeBox.maxY))
420 clearBox.line(to: NSPoint(x: resizeBox.minX, y: resizeBox.maxY))
421 clearBox.line(to: NSPoint(x: resizeBox.minX, y: resizeBox.minY))
422 NSColor(white: 0, alpha: 0.2).setFill()
423 clearBox.fill()
424 }
425
426 if state == .moving {
427 let string = "\(Int(box.minX)), \(Int(box.maxY))" as NSString
428 drawText(string, NSPoint(
429 x: box.minX,
430 y: box.maxY
431 ), true)
432 }
433
434 if state == .resizing {
435 let string = "\(Int(mouseLocation.x)), \(Int(mouseLocation.y))" as NSString
436 drawText(string, mouseLocation)
437 }
438
439 if box.contains(mouseLocation) && state != .resizing {
440 return;
441 }
442 }
443
444 // Draw text
445
446 let string = "\(Int(mouseLocation.x)), \(Int(mouseLocation.y))" as NSString
447 drawText(string, mouseLocation)
448 }
449
450 // MARK: - Utilities
451
452 private func drawText(_ text: NSString, _ location: NSPoint, _ isBottomRight: Bool = false) {
453
454 let textAttributes = [
455 NSAttributedString.Key.font: NSFont(name: "Hiragino Mincho ProN", size: 12) ?? NSFont.systemFont(ofSize: 12),
456 NSAttributedString.Key.foregroundColor: NSColor.white,
457 ]
458 let offset = NSPoint(x: 10, y: 10)
459 let padding = NSPoint(x: 5, y: 2)
460 let size = text.size(withAttributes: textAttributes)
461 var rect = NSRect(x: location.x + offset.x, y: location.y + offset.y, width: size.width + 2 * padding.x, height: size.height + 2 * padding.y)
462 var textRect = NSRect(x: location.x + offset.x + padding.x, y: location.y + offset.y + padding.y, width: size.width, height: size.height)
463
464 if (isBottomRight) {
465 rect = rect.offsetBy(dx: -size.width - 2 * offset.x, dy: 0)
466 textRect = textRect.offsetBy(dx: -size.width - 2 * offset.x, dy: 0)
467 }
468
469 NSColor.black.set()
470 rect.fill()
471
472 text.draw(in: textRect, withAttributes: textAttributes)
473 }
474
475 private func moveWindow() {
476 let screen = NSScreen.screenWithMouse
477 if let currentScreen = self.window?.screen {
478 if currentScreen != screen {
479 let frame = screen?.frame ?? NSZeroRect
480 self.frame = CGRect(origin: NSZeroPoint, size: frame.size)
481 self.bounds = CGRect(origin: NSZeroPoint, size: frame.size)
482 self.updateTrackingAreas()
483
484 if let window = self.window {
485 self.bounds = frame
486 self.button = NSRect(x: frame.maxX - buttonOffset.x, y: frame.maxY - buttonOffset.y, width: buttonSize.width, height: buttonSize.height)
487 window.setFrame(frame, display: true, animate: false)
488 window.makeKeyAndOrderFront(nil)
489 window.orderFrontRegardless()
490 }
491 }
492 }
493 }
494 }