Aplicativos

Cubo: timer flutuante para Mac com cores, transparência e alarme

Dificuldade: Não informada
Tempo de referência: Não informado

Crie com IA um timer que fica sobre as janelas do Mac. Use contagem regressiva ou cronômetro, escolha o aparelho branco ou preto e personalize o visor com dez cores ou uma cor…

Descrição completa

Crie com IA um timer que fica sobre as janelas do Mac. Use contagem regressiva ou cronômetro, escolha o aparelho branco ou preto e personalize o visor com dez cores ou uma cor própria. Ajuste a transparência e escolha entre oito alarmes, incluindo sons 8-bit, com vibração sincronizada ao terminar. Inclui código de referência para recriar o desenho e os comportamentos do Cubo.

macOS

Imagens da ideia

Clique na imagem para ampliar

Timer Cubo preto com visor menta marcando 25 minutos, ao lado do título Seu tempo, sempre à vista. — Cubo: seu tempo sempre à vista. Timer flutuante para Mac, personalizável e com alarme. Arte renderizada com os componentes do aplicativo.

Imagem 1 de 8Abrir original

Ver outras 7 imagens

Dois aparelhos Cubo, preto com visor menta e branco com visor azul, mostrando 25 e 10 minutos. — Escolha o aparelho branco ou preto e combine com a luz do visor. Arte renderizada com dados de exemplo.

Dez timers Cubo com as cores branco, menta, âmbar, azul, ciano, violeta, rosa, vermelho, laranja e lima. — Dez cores prontas para o visor, além do seletor de cor personalizada nos ajustes. Arte renderizada.

Cubo preto em contagem regressiva de 17 minutos e 42 segundos e Cubo branco com cronômetro em 3 minutos e 18 segundos. — Contagem regressiva para saber quanto falta e cronômetro para acompanhar o tempo decorrido. Arte renderizada; valores de exemplo.

Três timers com visor azul em diferentes níveis de transparência: sólido, 40% e 70%. — Ajuste a transparência de 0% a 80%. Ao aproximar o ponteiro, o Cubo recupera a nitidez total. Arte renderizada comparando 0%, 40% e 70% sobre o mesmo fundo.

Cubo preto com visor âmbar em 00:00 vibrando no ritmo de Arcade 8-bit, com botão Parar alarme. — Prévia animada da vibração no ritmo de Arcade 8-bit, renderizada com o mesmo envelope de notas e pausas do Cubo. GIF sem áudio.

Quatro etapas: copiar o prompt, colar na IA, compilar no Mac e personalizar. Requisitos macOS 14 ou posterior e Xcode com Swift 6. — Copie o prompt completo desta página, cole na IA de programação e compile no Mac. Depois personalize o seu Cubo. Arte explicativa.

Captura real do Cubo preto com visor branco em 00:00, indicação Tempo concluído e botão Parar alarme. — Ler legenda
Captura real do Cubo 1.3 em execução durante o teste de conclusão: tempo zerado e controle Parar alarme. A reprodução foi confirmada por software; a imagem não contém áudio.

Seu ponto de partida

Copie o texto e adapte na sua ferramenta de IA.

Prompt pronto para copiar

CRIE O CUBO 1.4.0 — TIMER FLUTUANTE PARA MAC
Em pasta nova cubo-mac, crie app nativo SwiftUI/AppKit macOS14+/Swift6. Preserve os oito arquivos e crie complementos. Sem rede/login/WidgetKit.

SwiftPM: tools6.0, swiftLanguageModes[.v5], target CuboCore em Core/, executável Cubo em App/ dependente de CuboCore e testes. NSApplication accessory com delegado/menu para janela, timer, ajustes/cor e sair.

Core público: CuboPreferences.swift com DisplayTint:String/Codable/CaseIterable/Identifiable com white,mint,amber,blue,cyan,violet,pink,red,orange,lime,custom; title português, id rawValue, presets sem custom. DeviceFinish black/white, title/id. CuboPreferences Codable: session=TimerSession(), sound=true,size=1,tint=.white,finish=.black,customHex="#BCE6FF",transparency=0,alarm=AlarmOptions(). Migre com decodeIfPresent, limite transparência0...0.8.

TimerStore @MainActor/@Observable: session:TimerSession, now:Date, soundEnabled,size,tint,finish,customHex,transparency,alarmOptions,settingsOpen=false, let alert=CompletionAlarmController(); callbacks onResize/onRefreshMenu/onRevealAlarm. Salve JSON cubo.preferences.v1 em UserDefaults. init(defaults:) restaura/sanitize sem aviso antigo; Timer0.25s enquanto running atualiza now, detecta finishIfNeeded uma vez e inicia aviso. toggle inicia/pausa/retoma; aviso ativo só para. reset,setDuration,setMode param aviso e zeram; refresh reconcilia; testAlarm prévia5s. Exponha seconds,progress,isRunning,largeMinutes,digits,spokenTime,actionTitle,statusTitle; minutos se pronta/múltipla60, senão MM:SS/HH:MM:SS; português.

CompletionAlarmController e AlarmVibration estão completos nos blocos. Preserve o relógio AVAudioPlayer.currentTime e o envelope compartilhado de AlarmTone: notas, pausas e loops comandam som e movimento. Não recrie um tremor periódico separado. Sem áudio, siga o ritmo pelo horário. Não reinicie a duração do aviso ao trocar som/volume.
Os blocos têm comentários/espaços opcionais removidos para caber no editor; preserve a implementação.

FloatingCubeController: NSPanel borderless/nonactivating transparente, canBecomeKey, floating/canJoinAllSpaces/fullScreenAuxiliary, CubeView base310×342 vezes size0.8/1/1.25. CubeDragSurface:NSViewRepresentable arrasta com mouseDown/Dragged/Up e salva posição limitada ao monitor. show/hide/openSettings; resize; ocultar mantém tempo.

CubeSettingsView: abas Timer/Aparência/Alarme, modos/min/s/presets5/10/25/50, aparelho/tamanho/cores/transparência0...80%, som/volume/vibração/intensidade/duração/teste. Use CustomColorPicker(store:store), NÃO ColorPicker SwiftUI. DisplayAppearance está completo. Ofereça oito sons: Digital, Sino, Pulso, Arcade 8-bit, Power-up 8-bit, Alerta retrô, Cristais e Radar.

script/build_and_run.sh cria dist/Cubo.app com local.cubo.mac/LSUIElement, ícone e assinatura ad hoc. Compile/teste relógio/aviso/cor/reabertura. Preserve dados; relate testes reais.

ARQUIVOS CANÔNICOS:

ARQUIVO: Core/TimerSession.swift
````swift
import Foundation
public enum TimerMode:String,Codable,CaseIterable,Sendable{
case countdown,stopwatch
}
public enum TimerPhase:String,Codable,Sendable{
case ready,running,paused,finished
}
public struct TimerSession:Codable,Equatable,Sendable{
public private(set) var mode:TimerMode
public private(set) var phase:TimerPhase = .ready
public private(set) var duration:TimeInterval
public private(set) var accumulated:TimeInterval = 0
public private(set) var startedAt:Date?
public init(mode:TimerMode = .countdown,duration:TimeInterval = 600){
self.mode = mode
self.duration = Self.validDuration(duration)
}
public func elapsed(at now:Date) -> TimeInterval{
let active = phase == .running ? max(0,now.timeIntervalSince(startedAt ?? now)):0
let total = accumulated + active
return mode == .countdown ? min(duration,total):total
}
public func remaining(at now:Date) -> TimeInterval{
max(0,duration - elapsed(at:now))
}
public func displayedSeconds(at now:Date) -> Int{
let value = mode == .countdown ? ceil(remaining(at:now)):floor(elapsed(at:now))
return Int(min(359_999,max(0,value)))
}
public func progress(at now:Date) -> Double{
mode == .countdown ? min(1,max(0,elapsed(at:now) / duration)):0
}
public mutating func start(at now:Date){
guard phase != .running else{return}
if phase == .finished{accumulated = 0}
startedAt = now
phase = .running
}
public mutating func pause(at now:Date){
guard phase == .running else{return}
if finishIfNeeded(at:now){return}
accumulated = elapsed(at:now)
startedAt = nil
phase = .paused
}
public mutating func reset(){
accumulated = 0
startedAt = nil
phase = .ready
}
public mutating func configure(mode:TimerMode,duration:TimeInterval? = nil){
self.mode = mode
if let duration{self.duration = Self.validDuration(duration)}
reset()
}
@discardableResult
public mutating func finishIfNeeded(at now:Date) -> Bool{
guard mode == .countdown,phase == .running,remaining(at:now) <= 0 else{return false}
accumulated = duration
startedAt = nil
phase = .finished
return true
}
public mutating func sanitize(){
duration = Self.validDuration(duration)
accumulated = accumulated.isFinite ? max(0,accumulated):0
if mode == .countdown{accumulated = min(duration,accumulated)}
if phase == .running && startedAt == nil{phase = accumulated > 0 ? .paused:.ready}
if phase != .running{startedAt = nil}
if mode == .stopwatch && phase == .finished{phase = .paused}
}
private static func validDuration(_ value:TimeInterval) -> TimeInterval{
value.isFinite ? min(86_399,max(1,value)):600
}
}
````

ARQUIVO: Core/AlarmOptions.swift
````swift
import Foundation
public enum AlarmSound:String,Codable,CaseIterable,Identifiable,Sendable{
case digital,bell,pulse,arcade,powerUp,retroAlert,crystals,radar
public var id:String{rawValue}
public var title:String{
switch self{
case .digital:"Digital"
case .bell:"Sino"
case .pulse:"Pulso"
case .arcade:"Arcade 8-bit"
case .powerUp:"Power-up 8-bit"
case .retroAlert:"Alerta retrô"
case .crystals:"Cristais"
case .radar:"Radar"
}
}
}
public enum VibrationStrength:String,Codable,CaseIterable,Identifiable,Sendable{
case soft,medium,strong
public var id:String{rawValue}
public var title:String{switch self{case .soft:"Suave";case .medium:"Média";case .strong:"Forte"}}
public var amplitude:Double{switch self{case .soft:2;case .medium:4;case .strong:6}}
}
public enum AlarmDuration:Int,Codable,CaseIterable,Identifiable,Sendable{
case five = 5,fifteen = 15,thirty = 30,sixty = 60,untilStopped = 0
public var id:Int{rawValue}
public var title:String{self == .untilStopped ? "Até eu parar":self == .sixty ? "1 minuto":"\(rawValue) segundos"}
}
public struct AlarmOptions:Codable,Equatable,Sendable{
public var sound:AlarmSound
public var volume:Double
public var vibrationEnabled:Bool
public var strength:VibrationStrength
public var duration:AlarmDuration
public init(sound:AlarmSound = .digital,volume:Double = 0.6,vibrationEnabled:Bool = true,
strength:VibrationStrength = .medium,duration:AlarmDuration = .fifteen){
self.sound = sound;self.volume = Self.validVolume(volume)
self.vibrationEnabled = vibrationEnabled;self.strength = strength;self.duration = duration
}
private enum CodingKeys:String,CodingKey{case sound,volume,vibrationEnabled,strength,duration}
public init(from decoder:Decoder) throws{
let fields = try decoder.container(keyedBy:CodingKeys.self)
sound = AlarmSound(rawValue:try fields.decodeIfPresent(String.self,forKey:.sound) ?? "") ?? .digital
volume = Self.validVolume(try fields.decodeIfPresent(Double.self,forKey:.volume) ?? 0.6)
vibrationEnabled = try fields.decodeIfPresent(Bool.self,forKey:.vibrationEnabled) ?? true
strength = VibrationStrength(rawValue:try fields.decodeIfPresent(String.self,forKey:.strength) ?? "") ?? .medium
duration = AlarmDuration(rawValue:try fields.decodeIfPresent(Int.self,forKey:.duration) ?? 15) ?? .fifteen
}
private static func validVolume(_ value:Double) -> Double{value.isFinite ? min(1,max(0,value)):0.6}
}
public struct AlarmRun:Equatable,Sendable{
public let startedAt:Date
public let isPreview:Bool
public init(at date:Date,preview:Bool){startedAt = date;isPreview = preview}
public func expired(at date:Date,duration:AlarmDuration) -> Bool{
if isPreview{return date.timeIntervalSince(startedAt) >= 5}
return duration != .untilStopped && date.timeIntervalSince(startedAt) >= Double(duration.rawValue)
}
}
public struct AlarmPose:Equatable,Sendable{
public var x:Double = 0
public var y:Double = 0
public var rotation:Double = 0
public init(x:Double = 0,y:Double = 0,rotation:Double = 0){self.x = x;self.y = y;self.rotation = rotation}
public static func vibration(elapsed:Double,strength:VibrationStrength,sound:AlarmSound = .digital) -> AlarmPose{
guard elapsed.isFinite else{return AlarmPose()}
let t = max(0,elapsed)
let amplitude = strength.amplitude * AlarmTone.envelope(at:t,for:sound)
return AlarmPose(x:sin(t * .pi * 26) * amplitude,
y:sin(t * .pi * 34) * amplitude * 0.22,
rotation:sin(t * .pi * 20) * amplitude * 0.12)
}
}
````

ARQUIVO: Core/AlarmTone.swift
````swift
import Foundation
public enum AlarmTone{
public static let sampleRate = 22_050
private enum Voice{case sine,bell,square,triangle}
private struct Note{
let start:Double,frequency:Double,length:Double
var voice:Voice = .sine
var gain:Double = 1
func envelope(_ time:Double) -> Double{
let t = time - start
guard t >= 0,t < length else{return 0}
let decay = voice == .bell ? exp(-t * 5):voice == .triangle ? exp(-t * 2.5):1
return min(1,t / 0.008) * min(1,(length - t) / 0.02) * decay * gain
}
func sample(_ time:Double) -> Double{
let level = envelope(time)
guard level > 0 else{return 0}
let a = 2 * Double.pi * frequency * (time - start)
let wave:Double
switch voice{
case .sine:wave = sin(a) * 0.78 + sin(2 * a) * 0.12
case .bell:wave = sin(a) * 0.7 + sin(2 * a) * 0.2 + sin(3 * a) * 0.07
case .square:wave = (sin(a) + sin(3 * a) / 3 + sin(5 * a) / 5) * 0.75
case .triangle:wave = (sin(a) - sin(3 * a) / 9 + sin(5 * a) / 25) * 0.86
}
return level * wave
}
}
private struct Score{let period:Double;let notes:[Note]}
private static func score(_ sound:AlarmSound) -> Score{
switch sound{
case .digital:
Score(period:1.6,notes:[Note(start:0,frequency:880,length:0.18),Note(start:0.29,frequency:1174.66,length:0.18),Note(start:0.58,frequency:880,length:0.18)])
case .bell:
Score(period:2,notes:[Note(start:0,frequency:740,length:1.16,voice:.bell),Note(start:0.82,frequency:740,length:1.16,voice:.bell,gain:0.8)])
case .pulse:
Score(period:1.6,notes:[Note(start:0,frequency:660,length:0.24),Note(start:0.37,frequency:880,length:0.24)])
case .arcade:
Score(period:1.8,notes:[523.25,659.25,783.99,1046.5].enumerated().map{Note(start:Double($0.offset) * 0.16,frequency:$0.element,length:$0.offset == 3 ? 0.3:0.14,voice:.square,gain:0.8)})
case .powerUp:
Score(period:2,notes:[440.0,554.37,659.25,880,1108.73,1318.51].enumerated().map{Note(start:Double($0.offset) * 0.11,frequency:$0.element,length:$0.offset == 5 ? 0.32:0.105,voice:.square,gain:0.8)})
case .retroAlert:
Score(period:1.6,notes:[392.0,784,392,784].enumerated().map{Note(start:Double($0.offset) * 0.21,frequency:$0.element,length:0.16,voice:.square,gain:0.8)})
case .crystals:
Score(period:2.4,notes:[1174.66,1567.98,2093].enumerated().map{Note(start:Double($0.offset) * 0.23,frequency:$0.element,length:$0.offset == 2 ? 0.66:0.42,voice:.triangle,gain:0.8)})
case .radar:
Score(period:2,notes:[Note(start:0,frequency:1100,length:0.13),Note(start:0.28,frequency:1450,length:0.24)])
}
}
public static func duration(for sound:AlarmSound) -> Double{score(sound).period}
public static func envelope(at time:Double,for sound:AlarmSound) -> Double{
guard time.isFinite,time >= 0 else{return 0}
let s = score(sound),t = time.truncatingRemainder(dividingBy:s.period)
return min(1,s.notes.reduce(0){$0 + $1.envelope(t)})
}
public static func waveData(for sound:AlarmSound) -> Data{
let s = score(sound),count = Int((Double(sampleRate) * s.period).rounded())
var samples = Data(capacity:count * 2)
for index in 0..<count{
let t = Double(index) / Double(sampleRate)
let value = s.notes.reduce(0){$0 + $1.sample(t)}
let sample = Int16((min(1,max(-1,value)) * 26_000).rounded())
append16(UInt16(bitPattern:sample),to:&samples)
}
var wave = Data("RIFF".utf8)
append32(UInt32(36 + samples.count),to:&wave)
wave.append(Data("WAVEfmt ".utf8))
append32(16,to:&wave);append16(1,to:&wave);append16(1,to:&wave)
append32(UInt32(sampleRate),to:&wave);append32(UInt32(sampleRate * 2),to:&wave)
append16(2,to:&wave);append16(16,to:&wave)
wave.append(Data("data".utf8));append32(UInt32(samples.count),to:&wave)
wave.append(samples)
return wave
}
private static func append16(_ value:UInt16,to data:inout Data){
data.append(UInt8(value & 255));data.append(UInt8((value >> 8) & 255))
}
private static func append32(_ value:UInt32,to data:inout Data){
for shift in stride(from:0,to:32,by:8){data.append(UInt8((value >> shift) & 255))}
}
}
````

ARQUIVO: App/DotDisplay.swift
````swift
import SwiftUI
import CuboCore
struct DotDisplay:View{
let text:String
var color:Color = .white
private static let glyphs:[Character:[String]] = [
"0":["01110","10001","10001","10001","10001","10001","01110"],
"1":["00100","01100","00100","00100","00100","00100","01110"],
"2":["01110","10001","00001","00010","00100","01000","11111"],
"3":["11110","00001","00001","01110","00001","00001","11110"],
"4":["00010","00110","01010","10010","11111","00010","00010"],
"5":["11111","10000","10000","11110","00001","00001","11110"],
"6":["01110","10000","10000","11110","10001","10001","01110"],
"7":["11111","00001","00010","00100","01000","01000","01000"],
"8":["01110","10001","10001","01110","10001","10001","01110"],
"9":["01110","10001","10001","01111","00001","00001","01110"],
":":["0","0","1","0","1","0","0"]
]
var body:some View{
Canvas{context,size in
let characters = Array(text)
let widths = characters.map{$0 == ":" ? 1:5}
let columns = widths.reduce(0,+) + max(0,characters.count - 1)
let cell = min(size.width / CGFloat(max(1,columns)),size.height / 7)
let pixel = cell * 0.76
var x = (size.width - CGFloat(columns) * cell) / 2
let y = (size.height - cell * 7) / 2
for character in characters{
let glyph = Self.glyphs[character] ?? Self.glyphs["0"]!
for (row,line) in glyph.enumerated(){
for (column,dot) in line.enumerated() where dot == "1"{
let box = CGRect(x:x + CGFloat(column) * cell + (cell - pixel) / 2,
y:y + CGFloat(row) * cell + (cell - pixel) / 2,
width:pixel,height:pixel)
context.fill(Path(roundedRect:box,cornerRadius:pixel * 0.14),with:.color(color))
}
}
x += CGFloat(character == ":" ? 2:6) * cell
}
}
.accessibilityHidden(true)
}
}
extension DisplayTint{
var color:Color{
switch self{
case .white:Color(red:0.94,green:0.98,blue:0.97)
case .mint:Color(red:0.57,green:0.97,blue:0.79)
case .amber:Color(red:1,green:0.77,blue:0.39)
case .blue:Color(red:0.49,green:0.7,blue:1)
case .cyan:Color(red:0.39,green:0.92,blue:1)
case .violet:Color(red:0.76,green:0.63,blue:1)
case .pink:Color(red:1,green:0.59,blue:0.8)
case .red:Color(red:1,green:0.43,blue:0.45)
case .orange:Color(red:1,green:0.63,blue:0.33)
case .lime:Color(red:0.8,green:0.98,blue:0.4)
case .custom:.white
}
}
}
````

ARQUIVO: App/AlarmVibration.swift
````swift
import SwiftUI
import CuboCore
struct AlarmVibration:ViewModifier{
let alarm:CompletionAlarmController
let strength:VibrationStrength
let enabled:Bool
func body(content:Content) -> some View{
TimelineView(.animation(minimumInterval:1.0 / 30.0,paused:!enabled || !alarm.isActive)){context in
let pose = enabled ? alarm.vibration(at:context.date,strength:strength):AlarmPose()
content.offset(x:pose.x,y:pose.y).rotationEffect(.degrees(pose.rotation))
}
}
}
````

ARQUIVO: App/CubeView.swift
````swift
import SwiftUI
import CuboCore
struct CubeView:View{
let store:TimerStore
var onHide:() -> Void
var onMoveEnd:() -> Void
var rendersStaticArtwork = false
@Environment(\.accessibilityReduceMotion) private var reduceMotion
@State private var hovering = false
private var controlsVisible:Bool{hovering || store.settingsOpen}
private var surfaceOpacity:Double{hovering || store.alert.isActive ? 1:1 - store.transparency}
var body:some View{
ZStack(alignment:.topLeading){
CubeShell(finish:store.finish,finished:store.session.phase == .finished || store.alert.isActive,accent:store.displayColor)
.allowsHitTesting(false)
if !rendersStaticArtwork{
CubeDragSurface(onMoveEnd:onMoveEnd)
.frame(width:280,height:278).offset(x:15,y:8)
.accessibilityLabel("Arrastar Cubo")
}
face.frame(width:194,height:197).offset(x:58,y:55)
quickTimes.offset(x:60,y:286)
.opacity(controlsVisible ? 1:0)
.allowsHitTesting(controlsVisible)
.accessibilityHidden(!controlsVisible)
}
.frame(width:310,height:342,alignment:.topLeading)
.modifier(AlarmVibration(alarm:store.alert,strength:store.alarmOptions.strength,
enabled:store.alarmOptions.vibrationEnabled && !reduceMotion && !hovering && !rendersStaticArtwork))
.compositingGroup()
.opacity(surfaceOpacity)
.animation(reduceMotion ? nil:.easeOut(duration:0.18),value:controlsVisible)
.scaleEffect(store.size,anchor:.topLeading)
.frame(width:310 * store.size,height:342 * store.size,alignment:.topLeading)
.onHover{hovering = $0}
.popover(isPresented:settingsBinding,arrowEdge:.trailing){
CubeSettingsView(store:store,onHide:onHide)
}
.contextMenu{
Button(store.actionTitle){store.toggle()}
Button("Zerar"){store.reset()}
Divider()
Button("Ajustar Cubo…"){store.settingsOpen = true}
Button("Ocultar Cubo",action:onHide)
Button("Sair do Cubo"){NSApp.terminate(nil)}
}
}
private var settingsBinding:Binding<Bool>{
Binding(get:{store.settingsOpen},set:{store.settingsOpen = $0})
}
private var quickTimes:some View{
HStack(spacing:9){
ForEach([5,10,25,50],id:\.self){minutes in presetButton(minutes)}
}
.padding(5)
.background(store.finish == .white ? Color(white:0.96):Color(white:0.11),in:Capsule())
.overlay(Capsule().strokeBorder((store.finish == .white ? Color.black:.white).opacity(0.08)))
.shadow(color:.black.opacity(0.14),radius:8,y:3)
}
private func presetButton(_ minutes:Int) -> some View{
let selected = store.session.mode == .countdown && Int(store.session.duration) == minutes * 60
let ink:Color = store.finish == .white ? .black:.white
let foreground:Color = selected ? store.accentTextColor:ink.opacity(0.65)
let background:Color = selected ? store.displayColor:.clear
return Button{store.setDuration(Double(minutes * 60))} label:{
Text("\(minutes)m").font(.system(size:10,weight:.semibold,design:.rounded))
.foregroundStyle(foreground)
.frame(width:38,height:25)
.background(background,in:Capsule())
}.buttonStyle(.plain)
.accessibilityLabel("Definir \(minutes) minutos")
.help("Definir \(minutes) minutos e zerar a contagem")
}
private var face:some View{
VStack(spacing:0){
HStack(spacing:5){
Image(systemName:store.session.mode == .countdown ? "timer":"stopwatch")
.font(.system(size:9)).accessibilityHidden(true)
Text(store.session.mode == .countdown ? "Timer":"Cronômetro")
.font(.system(size:9,weight:.medium,design:.rounded))
Circle().fill(store.isRunning ? store.displayColor:.clear).frame(width:3,height:3)
Spacer()
Button(action:onHide){
Image(systemName:"minus").font(.system(size:10,weight:.medium))
.frame(width:23,height:20)
.background(.white.opacity(0.045),in:Capsule())
}.buttonStyle(.plain).accessibilityLabel("Ocultar Cubo")
.help("Ocultar; reabra pelo ícone na barra superior")
}.foregroundStyle(.white.opacity(0.42))
Spacer(minLength:9)
Button{store.toggle()} label:{
DotDisplay(text:store.digits,color:store.displayColor)
.frame(width:190,height:store.largeMinutes ? 84:65)
.shadow(color:store.displayColor.opacity(0.13),radius:6)
.contentShape(Rectangle())
}.buttonStyle(.plain)
.accessibilityLabel("\(store.actionTitle). \(store.spokenTime)")
.help("Clique no visor para \(store.actionTitle.lowercased())")
Text(store.statusTitle)
.font(.system(size:7.5,weight:.medium,design:.monospaced)).tracking(1)
.foregroundStyle(.white.opacity(0.4)).padding(.top,8)
Spacer(minLength:10)
GeometryReader{geometry in
Capsule().fill(.white.opacity(0.065))
.overlay(alignment:.leading){
Capsule().fill(store.displayColor.opacity(0.8)).frame(width:geometry.size.width * store.progress)
}
}.frame(height:2).padding(.horizontal,4)
.opacity(store.session.mode == .countdown ? 1:0)
.accessibilityLabel("Progresso")
.accessibilityValue("\(Int(store.progress * 100)) por cento")
HStack(spacing:12){
iconButton("arrow.counterclockwise",title:"Zerar contagem"){store.reset()}
Button{store.toggle()} label:{
HStack(spacing:6){
Image(systemName:store.alert.isActive ? "stop.fill":store.isRunning ? "pause.fill":"play.fill").font(.system(size:8))
Text(store.actionTitle).font(.system(size:10.5,weight:.semibold,design:.rounded))
}.foregroundStyle(store.displayColor).frame(width:100,height:32)
.background(store.displayColor.opacity(0.09),in:RoundedRectangle(cornerRadius:11))
.overlay(RoundedRectangle(cornerRadius:11).strokeBorder(store.displayColor.opacity(0.16),lineWidth:0.75))
}.buttonStyle(.plain).accessibilityLabel(store.actionTitle)
iconButton("slider.horizontal.3",title:"Ajustar Cubo"){store.settingsOpen.toggle()}
}.padding(.top,12)
}
}
private func iconButton(_ symbol:String,title:String,action:@escaping () -> Void) -> some View{
Button(action:action){
Image(systemName:symbol).font(.system(size:11,weight:.medium))
.foregroundStyle(.white.opacity(0.52)).frame(width:33,height:32)
.background(.white.opacity(0.035),in:RoundedRectangle(cornerRadius:10))
}.buttonStyle(.plain).accessibilityLabel(title).help(title)
}
}
struct CubeShell:View{
var finish:DeviceFinish = .black
var finished = false
var accent = Color.white
private var rear:[Color]{
finish == .white ? [Color(white:0.86),Color(white:0.72)]:[Color(white:0.27),Color(white:0.13)]
}
private var casing:[Color]{
finish == .white ? [Color(white:0.99),Color(white:0.92),Color(white:0.85)]:[Color(white:0.27),Color(white:0.16),Color(white:0.105)]
}
private var edge:[Color]{
finish == .white ? [.white,.black.opacity(0.12)]:[.white.opacity(0.23),.black.opacity(0.5)]
}
var body:some View{
ZStack(alignment:.topLeading){
Ellipse().fill(.black.opacity(finish == .white ? 0.15:0.23))
.frame(width:222,height:12).blur(radius:12).offset(x:44,y:269)
RoundedRectangle(cornerRadius:46,style:.continuous)
.fill(LinearGradient(colors:rear,startPoint:.top,endPoint:.bottom))
.frame(width:250,height:250).offset(x:30,y:18)
RoundedRectangle(cornerRadius:45,style:.continuous)
.fill(LinearGradient(colors:casing,startPoint:.topLeading,endPoint:.bottomTrailing))
.overlay(RoundedRectangle(cornerRadius:45,style:.continuous)
.strokeBorder(LinearGradient(colors:edge,startPoint:.topLeading,endPoint:.bottomTrailing),lineWidth:0.85))
.frame(width:250,height:250).offset(x:30,y:24)
RoundedRectangle(cornerRadius:38,style:.continuous)
.fill(Color(red:0.009,green:0.014,blue:0.02))
.frame(width:234,height:234).offset(x:38,y:32)
RoundedRectangle(cornerRadius:35,style:.continuous)
.fill(LinearGradient(colors:[Color(red:0.07,green:0.085,blue:0.10),Color(red:0.027,green:0.034,blue:0.044)],startPoint:.topLeading,endPoint:.bottomTrailing))
.overlay(RoundedRectangle(cornerRadius:35,style:.continuous)
.strokeBorder(LinearGradient(colors:[.white.opacity(0.105),.clear,.white.opacity(0.035)],startPoint:.topLeading,endPoint:.bottomTrailing),lineWidth:0.75))
.frame(width:226,height:226).offset(x:42,y:36)
RoundedRectangle(cornerRadius:45,style:.continuous)
.strokeBorder(accent.opacity(finished ? 0.5:0),lineWidth:1)
.shadow(color:accent.opacity(finished ? 0.23:0),radius:8)
.frame(width:250,height:250).offset(x:30,y:24)
}.frame(width:310,height:290,alignment:.topLeading)
}
}
````

ARQUIVO: App/DisplayAppearance.swift
````swift
import AppKit
import SwiftUI
import CuboCore
@MainActor final class CustomColorPanel:NSObject{
static let shared = CustomColorPanel()
private weak var store:TimerStore?
@discardableResult
func configure(for store:TimerStore) -> NSColorPanel{
self.store = store
store.tint = .custom
let panel = NSColorPanel.shared
panel.setTarget(nil)
panel.setAction(nil)
panel.color = NSColor(store.customColor)
panel.showsAlpha = false
panel.isContinuous = true
panel.title = "Cor do visor — Cubo"
panel.hidesOnDeactivate = false
panel.setTarget(self)
panel.setAction(#selector(colorDidChange(_:)))
return panel
}
func show(for store:TimerStore){
let panel = configure(for:store)
NSApp.activate(ignoringOtherApps:true)
panel.makeKeyAndOrderFront(nil)
}
@objc func colorDidChange(_ sender:NSColorPanel){
store?.customColor = Color(nsColor:sender.color)
}
}
struct CustomColorPicker:View{
let store:TimerStore
var body:some View{
Button{CustomColorPanel.shared.show(for:store)} label:{
HStack{
Text("Cor personalizada")
Spacer()
Text(store.customHex).font(.system(.caption,design:.monospaced)).foregroundStyle(.secondary)
RoundedRectangle(cornerRadius:5).fill(store.customColor)
.frame(width:30,height:20)
.overlay(RoundedRectangle(cornerRadius:5).strokeBorder(.primary.opacity(0.2)))
}.contentShape(Rectangle())
}.buttonStyle(.plain)
.accessibilityLabel("Escolher cor personalizada")
.accessibilityValue("\(store.customHex), \(store.tint == .custom ? "selecionada" : "salva")")
}
}
extension TimerStore{
var displayColor:Color{tint == .custom ? customColor:tint.color}
var customColor:Color{
get{
let hex = customHex.trimmingCharacters(in:CharacterSet(charactersIn:"#"))
guard hex.count == 6,let value = UInt32(hex,radix:16) else{return .white}
return Color(red:Double((value >> 16) & 255) / 255,
green:Double((value >> 8) & 255) / 255,
blue:Double(value & 255) / 255)
}
set{
guard let rgb = NSColor(newValue).usingColorSpace(.sRGB) else{return}
func channel(_ value:CGFloat) -> Int{Int((min(1,max(0,value)) * 255).rounded())}
customHex = String(format:"#%02X%02X%02X",channel(rgb.redComponent),
channel(rgb.greenComponent),channel(rgb.blueComponent))
tint = .custom
}
}
var accentTextColor:Color{
guard let rgb = NSColor(displayColor).usingColorSpace(.sRGB) else{return .black}
return 0.2126 * rgb.redComponent + 0.7152 * rgb.greenComponent + 0.0722 * rgb.blueComponent > 0.55 ? .black:.white
}
}
````

ARQUIVO: App/CompletionAlarmController.swift
````swift
import AppKit
import AVFoundation
import Observation
import OSLog
import CuboCore
@MainActor @Observable
final class CompletionAlarmController{
private(set) var run:AlarmRun?
private(set) var playbackError:String?
@ObservationIgnored var onChange:(() -> Void)?
@ObservationIgnored private var player:AVAudioPlayer?
@ObservationIgnored private var playingSound:AlarmSound?
@ObservationIgnored private var rhythmStartedAt = Date()
@ObservationIgnored private var options = AlarmOptions()
@ObservationIgnored private var expiryTimer:Timer?
@ObservationIgnored private let logger = Logger(subsystem:Bundle.main.bundleIdentifier ?? "local.cubo.mac",category:"Alarm")
var isActive:Bool{run != nil}
var isPreview:Bool{run?.isPreview ?? false}
var isAudioPlaying:Bool{player?.isPlaying ?? false}
func rhythmTime(at date:Date) -> TimeInterval{
if let player,player.isPlaying{return max(0,player.currentTime)}
return max(0,date.timeIntervalSince(rhythmStartedAt))
}
func vibration(at date:Date,strength:VibrationStrength) -> AlarmPose{
guard isActive else{return AlarmPose()}
return AlarmPose.vibration(elapsed:rhythmTime(at:date),strength:strength,sound:options.sound)
}
func start(options:AlarmOptions,soundEnabled:Bool,preview:Bool = false){
stop()
playbackError = nil
guard soundEnabled || options.vibrationEnabled else{return}
self.options = options
run = AlarmRun(at:Date(),preview:preview)
rhythmStartedAt = run!.startedAt
logger.info("alarm-start preview=\(preview, privacy: .public) duration=\(options.duration.rawValue, privacy: .public) vibration=\(options.vibrationEnabled, privacy: .public)")
updateAudio(soundEnabled:soundEnabled,restartRhythm:true)
let timer = Timer(timeInterval:0.15,repeats:true){[weak self] _ in
Task{@MainActor [weak self] in self?.checkExpiry()}
}
timer.tolerance = 0.03
RunLoop.main.add(timer,forMode:.common)
expiryTimer = timer
onChange?()
}
func update(options:AlarmOptions,soundEnabled:Bool){
let newTone = self.options.sound != options.sound
self.options = options
guard isActive else{return}
if !soundEnabled && !options.vibrationEnabled{stop();return}
if newTone{rhythmStartedAt = Date()}
updateAudio(soundEnabled:soundEnabled,restartRhythm:newTone)
checkExpiry()
}
func stop(){
let wasActive = isActive
expiryTimer?.invalidate();expiryTimer = nil
player?.stop();player = nil;playingSound = nil
run = nil
if wasActive{logger.info("alarm-stopped");onChange?()}
}
private func checkExpiry(){
if run?.expired(at:Date(),duration:options.duration) == true{stop()}
}
private func updateAudio(soundEnabled:Bool,restartRhythm:Bool = false){
guard soundEnabled,options.volume > 0 else{
if !restartRhythm,let player,player.isPlaying{
rhythmStartedAt = Date().addingTimeInterval(-player.currentTime)
}
player?.stop();player = nil;playingSound = nil
return
}
if player == nil || playingSound != options.sound{
player?.stop()
do{
let sound = try AVAudioPlayer(data:AlarmTone.waveData(for:options.sound))
sound.numberOfLoops = -1
sound.volume = Float(options.volume)
sound.prepareToPlay()
if !restartRhythm{
sound.currentTime = rhythmTime(at:Date()).truncatingRemainder(dividingBy:sound.duration)
}
guard sound.play() else{throw AlarmPlaybackError.unavailable}
player = sound;playingSound = options.sound;playbackError = nil
rhythmStartedAt = Date().addingTimeInterval(-sound.currentTime)
logger.info("audio-playing tone=\(self.options.sound.rawValue, privacy: .public) playing=\(sound.isPlaying, privacy: .public) volume=\(sound.volume, privacy: .public) loops=\(sound.numberOfLoops, privacy: .public)")
} catch{
player = nil;playingSound = nil
playbackError = "Não foi possível reproduzir o alarme. Confira a saída de áudio do Mac."
logger.error("audio-playback-failed: \(error.localizedDescription, privacy: .public)")
}
} else{
player?.volume = Float(options.volume)
}
}
}
private enum AlarmPlaybackError:Error{case unavailable}
````

A cópia inclui todo o texto, com os campos que você preencheu.

Antes de começar

Um Mac com macOS 14 ou posterior e Xcode com Swift 6 e as ferramentas de linha de comando selecionadas. A IA precisa gerar um projeto nativo para Mac. Uma ferramenta que só responde por texto pode fornecer os arquivos; a compilação e a execução precisam acontecer no Mac.

Resultado esperado

Um aplicativo chamado Cubo, com uma pequena janela transparente e arrastável sobre as janelas normais do Mac. Contagem regressiva, cronômetro, cores, transparência e alarme são controlados pelo próprio aparelho e por um menu na barra superior. Os dados ficam salvos localmente.

Dicas para esta ideia

ATUALIZAÇÃO 1.4.0 — ALARMES 8-BIT E VIBRAÇÃO NO RITMO
Agora são oito sons: Digital, Sino, Pulso, Arcade 8-bit, Power-up 8-bit, Alerta retrô, Cristais e Radar. Em Alarme, escolha o som e clique em Testar alarme para uma prévia de cinco segundos.

Som e movimento seguem as mesmas notas e pausas. A vibração acompanha o andamento da reprodução; com o som desligado, mantém o ritmo do alarme escolhido. Ela continua respeitando a intensidade, a pausa ao aproximar o mouse e Reduzir Movimento. Trocar o som ou volume não prolonga o prazo do aviso.

O prompt inclui oito arquivos canônicos, inclusive o controlador de áudio, com comentários e espaços opcionais compactados para caber no editor. O projeto de referência passou em 25 testes. O GIF demonstra o ritmo de Arcade 8-bit, sem áudio.

ATUALIZAÇÃO 1.3.1 — COR PERSONALIZADA
Corrigido o vínculo do seletor nativo: ele continua conectado ao aplicativo depois que os ajustes fecham. Abrir o seletor também reativa a cor personalizada salva, mesmo sem mudar o RGB. O prompt agora inclui DisplayAppearance.swift com a correção completa.

Eu queria um timer pequeno que continuasse por perto enquanto eu estivesse trabalhando, estudando ou criando alguma coisa no Mac. Foi assim que surgiu o Cubo: um cronômetro flutuante inspirado na ideia de um aparelho de mesa, com visor de pontos luminosos e controles simples.

Você pode colocá-lo em um canto da tela e acompanhar o tempo sem trocar de aplicativo. Clique no visor para iniciar ou pausar, aproxime o ponteiro para revelar os tempos rápidos ou abra os ajustes para personalizar. O aparelho pode ser branco ou preto, com a cor de visor que você preferir.

Ao terminar a contagem regressiva, ele chama a atenção com uma animação de vibração e um som de alarme. Você escolhe o som, o volume, a intensidade e por quanto tempo quer receber o aviso. A ideia deste projeto é compartilhar o prompt e o código de referência para que outras pessoas também possam criar e adaptar o seu Cubo usando IA.

COMO USAR O PROMPT
1. Copie o prompt desta página por inteiro, incluindo os oito blocos de código de referência.
2. Cole no Codex, no Claude ou em outra IA de programação. Peça para criar o projeto em uma pasta nova chamada cubo-mac.
3. Preserve os arquivos canônicos que acompanham o prompt. Eles definem o desenho do aparelho, os números, o relógio, a vibração e os sons. A IA deve criar os arquivos complementares conforme as instruções.
4. Peça para compilar o projeto, executar os testes e abrir o aplicativo no Mac. Se a ferramenta apenas responder por texto, salve os arquivos nos caminhos indicados e siga as instruções de compilação.
5. Experimente os controles e personalize o seu Cubo. Instalar em Aplicativos pode ser um passo posterior, quando você quiser.

A versão de referência foi construída e testada em um Mac Apple Silicon. A compilação usa assinatura local ad hoc e não exige uma conta de desenvolvedor para esse uso local. Distribuição pública do aplicativo compilado e notarização são etapas separadas.

COMO USAR O CUBO
1. Abra o aplicativo. O Cubo aparece flutuando sobre as janelas normais do Mac.
2. Arraste pelas bordas ou pelo topo para colocá-lo onde preferir. A posição fica salva.
3. Clique nos números ou em Iniciar. Durante a contagem, o mesmo controle permite pausar e retomar.
4. Aproxime o ponteiro para revelar os atalhos de 5, 10, 25 e 50 minutos. Escolher um novo tempo zera a contagem atual.
5. Clique no ícone de ajustes. Em Timer, escolha a contagem regressiva ou o cronômetro e, quando quiser, defina minutos e segundos personalizados.
6. Em Aparência, escolha o aparelho branco ou preto, o tamanho, a cor do visor e a transparência. Clique em Cor personalizada para abrir o seletor do macOS. A cor atualiza o visor e fica salva, mesmo quando os ajustes fecham. Também é possível abrir o seletor pelo menu do Cubo na barra superior.
7. Em Alarme, ajuste os avisos. Use Testar alarme para uma prévia de cinco segundos sem mudar a contagem.
8. Ao terminar, clique em Parar alarme no Cubo ou no menu da barra superior. Depois, Repetir inicia outra contagem com a mesma duração.
9. Para ocultar e reabrir, use o ícone de cubo na barra superior. Para encerrar o aplicativo, escolha Sair do Cubo.

FUNCIONALIDADES
• Janela pequena, sem moldura de sistema e com fundo transparente, sobre as janelas normais dos outros aplicativos.
• Arraste para posicionar, com posição salva e ajuste quando a configuração dos monitores muda.
• Contagem regressiva de 1 segundo até 23 horas, 59 minutos e 59 segundos.
• Cronômetro crescente, com exibição até 99 horas, 59 minutos e 59 segundos.
• Iniciar, pausar, retomar e zerar, clicando no visor ou nos controles.
• Tempos rápidos de 5, 10, 25 e 50 minutos, visíveis ao aproximar o ponteiro.
• Aparelho branco ou preto e três tamanhos: pequeno, médio e grande.
• Dez cores prontas para o visor: branco, menta, âmbar, azul, ciano, violeta, rosa, vermelho, laranja e lima, além de uma cor personalizada.
• Transparência de 0% a 80%, com prévia durante o ajuste. Ao passar o mouse sobre o Cubo, ele volta à nitidez total para facilitar a interação.
• Alarme sonoro com oito opções: Digital, Sino, Pulso, Arcade 8-bit, Power-up 8-bit, Alerta retrô, Cristais e Radar, com volume de 0% a 100%.
• Vibração visual de intensidade suave, média ou forte. Ela pausa ao aproximar o ponteiro e respeita Reduzir Movimento do macOS.
• Som e vibração ligados ou desligados separadamente.
• Aviso de 5, 15, 30 ou 60 segundos, ou até você clicar para parar.
• Botão de teste de cinco segundos, sem alterar o timer.
• O Cubo reaparece se estava oculto e fica nítido durante o aviso.
• Contagem calculada pelo horário, com estado salvo localmente, incluindo pausa e retomada.
• Menu na barra superior para mostrar, ocultar, controlar o tempo, abrir ajustes e sair.

SOBRE O FUNCIONAMENTO
A vibração é uma animação visual do aparelho na tela. Ela não altera a posição que você salvou. Os números, a moldura e os controles são desenhados em SwiftUI; os sons são gerados localmente. O aplicativo funciona sem conta, servidor ou IA em execução.

O uso de IA está na criação e na adaptação do código. Para ouvir o alarme, mantenha o Cubo em execução e a saída de áudio do Mac disponível. Ao reabrir o app depois de uma contagem já expirada, ele mostra a conclusão sem tocar um aviso antigo.

SOBRE AS IMAGENS
As artes foram renderizadas com os mesmos componentes SwiftUI usados no aplicativo. Tempos, cores e estados mostrados nas artes são exemplos. A imagem identificada como captura real mostra o aplicativo de teste em execução.

O projeto de referência foi reconstruído a partir do código integral, compilado em Release e aprovado em 25 testes. Este prompt preserva oito arquivos canônicos; a IA deve implementar os complementos descritos, que podem variar entre ferramentas.