Page MenuHomePhorge
Files F4608

No OneTemporary
Actions

View Options

diff --git a/CHANGELOG b/CHANGELOG
--- a/CHANGELOG
+++ b/CHANGELOG
@@ -1,90 +1,92 @@
@%@~LICENSE:OK~@%@
+saw_060122_1 - [opeth] Ack tool cursors.
+
saw_053122_2 - [opeth] Ack: all tools basically working (no text or group yet).
saw_053122_1 - [opeth] Fixing ack tooling: color, rect, and ellipse so far.
saw_053022_1 - [kaczynski] Color palette for ack.
saw_052822_1 - [ledzeppelin] More ack work.
saw_052722_3 - [ledzeppelin] Ack copy/paste (requires xclip system utility).
saw_052722_2 - [gojira] Ack save.
saw_052722_1 - [bach] A little bit of cleanup in ack classes.
saw_052622_5 - [bach] Implement ack Rect and Ellipse tools and Delete function.
saw_052622_4 - [bach] Add some color choices to ack.
saw_052622_3 - [bach] Begin to implement tools and objects in ack.
saw_052622_2 - [beethoven] Now have working captions filter in player rack.
saw_052622_1 - [beethoven] Implement keywords and labels in player rack. Add
ability to hide labels globally.
saw_052522_3 - [labyrinth] Improved confirmation/error dialogs.
saw_052522_2 - [labyrinth] Implemented a "list all" function for HotKeys.
saw_052522_1 - [labyrinth] Finished HotKeys panel for player.
saw_052422_1 - [labyrinth] Starting to implement HotKeys panel.
saw_052322_2 - [polog] More work on player rack. Starting to implement ack
(blackboard). Minor UI tweaks such as new status modes and
cursors. Improved escape key handling.
saw_052322_1 - [polog] Starting to implement player rack.
saw_052122_2 - [yelawolf] Remove the UNIQUE constraint on caption start time
because some files are actually marked with multiple captions
occurring at the same time. Add some more deferred downloads.
saw_052122_1 - [yelawolf] Implemented deferred downloads and seeded the database
with some videos. Beginning of a label system for tagging videos.
Channels, videos, and labels added by the user now start at
id=1000 to leave room for seeded entries. Database now enforces
foreign key constraints and patches use transactions. We now
perform a VACUUM operation on the database after patching or
application exit. Player explicitly disables key repeat on key
press. Debug DIP switch has been changed to the plus sign (+).
saw_051622_2 - [nin] Partial implementation of full-screen mode without meta.
saw_051622_1 - [nin] Improve database performance. Moved audio extraction step
to the main video download routine so we no longer have to wait
for audio extraction upon first play.
saw_051522_1 - [nin] Add switch.py to easily start with DIP switches set.
saw_042422_1 - [controldenied] Beginning to get replay captures to play.
saw_042222_1 - [controldenied] Reworking the replay system so we can now
capture keyboard and mouse actions. The command-line options
(dip switches) should now be specified as the first option only
and without spaces.
saw_041222_1 - [theprodigy] Minor changes wrap up this series.
saw_040822_1 - [theprodigy] Just a little bit better.
saw_040722_1 - [theprodigy] Introducing: ImageEngine (imagine)! Add more
command-line options (see README). Status bar now with separate
UIManager (sui). Player NUM-pad key improvements. Get FPS/avg
score readouts with TAB key.
saw_040422_1 - We now have a working sequence/segment editor.
saw_040222_1 - Implemented replay system. Improved player performance.
saw_033022_2 - Fix kush prompt paint (cursor overlap problem).
saw_033022_1 - Migration to the media/fragment system and versioned database.
saw_032622_2 - Rename directories.
saw_032622_1 - First commit.
diff --git a/g/cursors.xcf b/g/cursors.xcf
new file mode 100644
index 0000000000000000000000000000000000000000..05dfc7dc95bd7654e17748666a46c112889f16e8
GIT binary patch
literal 7556
zc%1E7&2Jk;6d%ue<Iluvuj4q0lWZK5I;ou|EtIwwDoPJXh(j-&UB_|UI(B3yRdYbD
z_#=?`D}et2apA;~a}S)55JKY8YWcmHS$o#mHin2V(}{k1@BQ9*KHkoIo^_h7qhsf3
z{lIy$ySK;C?kaHLb07rRfC+3|c|I5nu6${`t_w3wZqFaRhu#FVED#2&Ku+n@Zyxvs
zm~CR#YQ1}O)aaZr<(zHTI-PF4?mVt``$SrzSL>+OY*d@Q*1p&At8)M3tle<-yQdG^
zjp}}_f4CJdA2jRTcDLu0g{bzL4{Oe@_}klp`(c24PyUhnY5%xZZ*`im;^i~lP<r*W
z(>iflo%&&;PyM?G2mQv0vrFAIU8?@h%-=%aNICPHl<}XXOua2-=82RGA4s|Qt(40#
zDGML6^UZr|^psNf+wInIzu|Pcy`x%N%%vUzJ+*bx-+LxL7F9g8n5Gvsy`brFO?Nas
zq3KCYpVjn~n$K$y<)iW6()yK1cjXD&&~)!mW&Jzn-vxw$E8mX+KH^=E92n18lwW5C
zj~WKAun@P55HCY!Axn^X$Q5S7A7xP^&TaOBqie*NV-dsUGl0!rasyh1k!1=d1es%`
zhlNdiUf2eZfj?|4u`mYb!lr%&Mt#Xn3wsr|n2b!raF`)YOL!f4X<kb>i*S;a6277s
zIVC(LcwVi~34N2%s{U$ylJ)58_wUTV>#>lG1#CQ?<MAGU9_OFe`6n9i*lF;PIvF7z
zQ5<a}FL-Yvd79$Nju`TkC6ygB<msCe_Ej#<q<fuNZiQvtGRwOqR&du@+>HWj@XY}$
zEaGN>Wj5pHfJGn=EC5S_Gu;9(53B-NBocz>+Rz;!107*@)6k261-%4}%M`E)%w1BZ
zUNOF<=1;5jWYqd>wce~+|Ge5yPVH|&?RQb_e_6$2Ma5@L#cLh0D<Otu#Ik~zUWd=t
z>j9O_S+8UsoVKT~U?!QbMP6uz7X(!>qxk?I@w*;5dBI#770Xp$p>(t&S=0(-Nh^*e
ztuStCMX@|e_wuM1ZVwB@_OJ+6R51yXRFrm9ak`AWXr7?81@A)Nr@ntZF8+A=BRLjk
zS(ujohN85JM01dIMI>Me$+(HcEF&SyNZ4&8?>3UHg2b#K!FQ1CBc#|a67}^+jeRDq
z#<JDe^J=aI%)5yBm$8l&tY;1Dnkey;4;uB8DZMBqn6D*%)eJ8ND({n4fRFgHM-I#^
zP63^aEp<XJl3`<wh2QA^m_FHaLT1yGMP>xSL?)U4V;LM5=C2`fQA4Kj=Ae&(X5G{b
zF9NE9SPuex#6R-LKVCuJ$jfK&zZ1-#L6J{d&1Sp7M#t&GG@>7Z{wrxzWxi&Asu^Aw
z)V}R60(``O?U94<4=l{_YAYVSceN`5lj-!C7%v!M+%q{38JusZJ16ydoi4|b_t9~k
zzH~O!9hLOr@QzBa+|JOFuhTO;<K0@hFo{kNZ?2GlrQKYqdunLYKnZmb_OV8Szr={#
z$4h-uPW)yu#)WYYj*oG4kB(`arMRfZrPcjAqH(s^@#vmTT+Wc!cvIsRjF6Bzx2V>9
z5tmo{xQGjyV?lc-kZY3%!2DC3JYfFuO|^H_Ejr40sSo2te)Al%;*K8`etNNgSHmrQ
zJKq+VfgXV*KI)pVw^+{IX7d79nT@-D0@-M~cQB3weJ<v{!{S5SgndhlJ2UKedpL(F
z=DQWJhC9q~qk5`RHOt)Vb^HCpTC3;Wb@pyl_HIy*X)0(Y^R@iP0Yys{wEUw0AMu}g
zWSp7&wm^u7fXm7qmV`|35@4{n_)Q|mLYnk=+3(t==auUp#JaQ>-?@1mcGwc$PYFpE
z>k!ffN{YWW;W#v}7F&8g_WQN^<7TgW+SzyN-QzQ7L;P!JnvP(M`P$O=0mm$)d_M*F
z(3XeCcwmXXo{z@2#zIKlrYU}5=4*v?K#WxU3e^A~@%KG)VEKIF$A?k;$Tdx&<ILAq
WKGF;?1S)hZhXFp~pLrxg7ycbrUbij)
diff --git a/g/ellipse_full.gif b/g/ellipse_full.gif
new file mode 100644
index 0000000000000000000000000000000000000000..48e8f5dc2b8bc3a0d8d83f7a97cc3ec80f7f3c87
GIT binary patch
literal 366
zc$@)l0g?VkNk%w1VL$*t0Kx+R0000ZC*yyAe<!aK|Ns9duM;P)6DO||A^r?(VQy}3
zV`Cs|EpKxGEC2ui06+jh000C27`hztu*pfQy$VLmyI&6gJYQ)};V7K!nUZbXy{l|n
z^sS?U2=72gPZbR2in}9nrfEWa&gQZaZHl1P+B7q~dPR!w_qR=nuYt3dJk36@ZY{OS
ziqqT-&0x>xYm!53Jbi?Pdx9>3auN@Qj)jOHN^_5ukc*OvgO;3rm`qTNouhr97?Td9
zs)r_%0;{m56-uwLv6+8Dwz0B|QmMPQEw#bIF2%OJILN!o6vWJ`&Z5!DCD7HR(|Os(
zGu^A(8Q|U**yNnz=jfH{?Ajjd?}qO4>GAgW-}&wM{Ey;*{Ua1m;6Oju4iZeL5FtZ_
z1;;gvC~+XgivKQRw5KeQ3%^K`KI)K{ts^ybCQ+bV(x@898!eH&1Qcv$k(i@wwt)a}
M!<Kk-P9y*TJ8(_0m;e9(
diff --git a/g/ellipse_normal.gif b/g/ellipse_normal.gif
new file mode 100644
index 0000000000000000000000000000000000000000..b93ced3903e0a4a9c028975b62a3b7be5cd9755b
GIT binary patch
literal 410
zc$@*60cHM2Nk%w1VL$*t0Kx+R0000ZC*yyAe<!aK|Ns9duM;P)6DO||A^r?(VQy}3
zV`Cs|EpKxGEC2ui06+jh000C27`hztu*pfQy$VLmyI&6gJYQ)};V7K!nUZbXy{l|n
z^sS?U2=72gPZbR2in}9nrfEWa&gQZaZHl1P+B7q~dPR!w_qR=nuYt3dJk36@ZY{OS
ziqqT-&0x>xYm!53Jbi?Pdx9>3auN@Qj)jOHN^_5ukc*OvgN_xCkr<O1oE?ss9H9b+
zCx)gMlc|I<kR?j6eK)fnPF%4%grAI34!t|SF}8b1#&x$#eXXFxMa#6!Q_m*I16u*q
zGuB(!lHk{V)qLCv;@{}$>gMdp?%nXG<l*(v?e6RP^8EQ+-79xU*Fa|haU4{ZumZAq
z^a>i>hfm_fe-#HnqwrWTT|avZeSHLpk)g$LA!Ut>w+-RRa}<lMyjaqPw?xuZ`q{{`
z=Bk@5w6$!JONY>*A6OMRiu6LMC5=W+@WfL_R7+Ta0m4cZA}_8xz0SFMNvqc^ED`_!
EJDyd-4*&oF
diff --git a/g/rect_full.gif b/g/rect_full.gif
new file mode 100644
index 0000000000000000000000000000000000000000..f979888c4b44859f6de7e3319660e678cac0cdcf
GIT binary patch
literal 333
zc$@)E0kZx_Nk%w1VL$*t0Kx+R0000ZC*yyAe<!aK|Ns9duM;P)6DO||A^r?(VQy}3
zV`Cs|EpKxGEC2ui06+jh000C27`hztu*pfQy$VLmyI&6gJYQ)};V7K!nUZbXy{l|n
z^sS?U2=72gPZbR2in}9nrfEWa&gQZaZHl1P+B7q~dPR!w_qR=nuYt3dJk36@Zf!X}
zq;HwfyG*Hf)#ZI9N_2#UQaFDg1B;A}j*pO$kAM<`l9!m7lvIfsnV+DHn+%qrrkA52
zhYqK$kf~f6imtSausF4~w-o}pw7V3&zOBG0!^AAY$DzfQ%cjj#&&<iwpwXn(pV+h7
zsMX%zF5%)P%H)&a=;`C@?B?$8g7J>rp7f&X`1Y*$w)*t=oeKyso<M*9+W9+(km16D
f?i}uexK1KLg%dGegx3p@B07r(lNlOGCjkIE2r;GA
diff --git a/g/rect_normal.gif b/g/rect_normal.gif
new file mode 100644
index 0000000000000000000000000000000000000000..224c9ddae5f72f127a62d41899e041ac54e3d0aa
GIT binary patch
literal 384
zc$@)%0e}8SNk%w1VL$*t0Kx+R0000ZC*yyAe<!aK|Ns9duM;P)6DO||A^r?(VQy}3
zV`Cs|EpKxGEC2ui06+jh000C27`hztu*pfQy$VLmyI&6gJYQ)};V7K!nUZbXy{l|n
z^sS?U2=72gPZbR2in}9nrfEWa&gQZaZHl1P+B7q~dPR!w_qR=nuYt3dJk36@Zf!X}
zq;HwfyG*Hf)#ZI9N_2#UQaFDg1B;A}j*pO$kAM<`l9!m7lvIfsnV+DHn+%qrrkA52
zhYqK$kf~f6ij7N-usDvjjkgs7xk$DwzO=x*!oNkqF33U3Cc})nqQ}I^#>>^s*U!vA
z&Vt=L-yhJ6(u=$l<pbvf=_uhk;~wkn@0Ia4^E3H2`yBO(O~V#VAUbLVtqtUs&D%C`
z4aGeq*H6Yj3;`7$BxpX)pgV*eHGbsC&f`5Q6=PhykWt%0hzVV8WEj)oONtTYO{C|l
e=S`kId!8f}R4B-zp@z;vYD#G=Lr~o$0029l<g!cv
diff --git a/g/wiggle.gif b/g/wiggle.gif
new file mode 100644
index 0000000000000000000000000000000000000000..932d00ea8b85c639fb87e386c97e06b5ddd60eac
GIT binary patch
literal 355
zc$@)a0i6CvNk%w1VL$*t0Kx(Q0000ZC*yyAe<!aK|NsAge}8{}e}8{}A^r?(VQy}3
zV`Cs|EpKxGEC2ui06+jh000C27`hztu*pfQy$VLmyI&6gJYQ)};V7K!nUZbXy{l|n
z^sS?U2=72gPZbR2in}9nrfEWa&gQZaZHl1P+B7q~dPR!w_qR=nuYt3dJk36@Zf!X}
zq;HwfyG*Hf)#VIQK!O!~fpmz77lt4L1CNlAl9QB_Y!ZxIm7AQEmsEcg51pi>pN9ZM
zJf*CjfS80riL-V%u~|kMevShheI=uir@yw5!^EPzkH^R;#?8Rb&>qUm(@c`D*P_|l
z+kuv_vA@B_PT|nit-aIb>)v|mmf72O<?!F&*7=LV{Qds^aWluP-6nk3<OLL{2^~W&
z@(_ND_z;w|iu%}L%qSso;>C^CI@bGG(cQ*|%S5INsj`{7f(e89!sz5=qhSdE06Wqu
Bvk(9P
diff --git a/k/ack/__init__.py b/k/ack/__init__.py
--- a/k/ack/__init__.py
+++ b/k/ack/__init__.py
@@ -1,409 +1,409 @@
from k.ui import *
import k.storage as media
from k.player.ui import PRECT
from .tool.color import Tool as Color
from .tool.wiggle import Tool as Wiggle
from .tool.rect import Tool as Rect
from .tool.ellipse import Tool as Ellipse
from .tool.adjust import Tool as Adjust
from .obj import Null, Image
from .obj.draw import Selector
from datetime import datetime
class Blackboard:
def __init__(self, k):
self.k = k
self.back_black = pygame.Surface((WIDTH, HEIGHT-STATUS-1))
self.back_black.fill(BLACK)
self.back_white = pygame.Surface((WIDTH, HEIGHT-STATUS-1))
self.back_white.fill(WHITE)
self.back = self.back_black
self.surf = pygame.Surface((WIDTH, HEIGHT-STATUS-1), pygame.SRCALPHA)
self.objects = [ ]
self.selects = [ ]
self.selecting = None
self.overlay = None
self.colors = [
None, # special "diverting" color
GRAY,
CYAN,
MAGENTA,
YELLOW,
RED,
GREEN,
BLUE,
WHITE,
BLACK,
]
self.tools = {
pygame.K_BACKQUOTE: Color(self),
pygame.K_w: Wiggle(self),
pygame.K_r: Rect(self),
pygame.K_e: Ellipse(self),
pygame.K_a: Adjust(self),
}
self.tool = None
self.tooling = None
self.tool_pick(self.tools[pygame.K_w])
self.start = None
self.pos = None
self.control = False
self.select = False
self.paint_back()
def add_obj(self, obj):
self.objects.append(obj)
if isinstance(obj, Selector):
if not self.selects:
self.selecting = [Clock(Selector.FPS), Selector.MAX, True, True]
self.selects.append(len(self.objects) - 1)
if self.back is self.back_black:
obj.key(BLACK)
obj.color(WHITE)
else:
obj.key(WHITE)
obj.color(BLACK)
return obj
def del_obj(self):
if not self.objects:
return None
obj = self.objects.pop()
if isinstance(obj, Selector):
self.selects.pop()
if not self.selects:
self.selecting = None
return obj
def set_obj(self, obj):
self.del_obj()
return self.add_obj(obj)
def obj(self):
if not self.objects:
return None
return self.objects[-1]
def tool_pick(self, tool, cancel=False):
print(f'tool_pick: {tool}')
if self.tooling:
if self.tool_stop() and cancel:
self.del_obj()
prev_tool = self.tool
self.tool = tool
prev_overlay = self.overlay
self.overlay = tool.pick(prev_tool)
if self.overlay:
self.paint_overlay()
elif prev_overlay:
self.paint_back()
self.paint_surf()
if self.tooling:
self.tool.start(self.start if cancel else self.pos)
def tool_start(self, pos):
self.start = pos
self.last_obj = self.obj()
self.tool.start(self.start)
def tool_stop(self):
self.tool.stop()
obj = self.obj()
if not obj or obj is self.last_obj:
return False
size = obj.size()
if size[0] < 1 or size[1] < 1:
self.del_obj()
return False
else:
return True
def tool_at(self, pos):
self.pos = pos
paint = self.tool.use(self.pos, self.tooling == pygame.BUTTON_MIDDLE)
if paint:
self.paint() #FIXME
else:
if self.overlay:
self.paint_back()
self.paint_surf()
#elif area is not None:
# self.paint_obj((area[0], area[1]), area)
# self.paint_surf((area[0], area[1]), area)
return paint
def paint(self):
#print('ack full paint')
if self.overlay:
self.paint_overlay()
else:
self.paint_back()
self.surf = pygame.Surface((WIDTH, HEIGHT-STATUS-1),
pygame.SRCALPHA)
self.paint_objects()
self.paint_surf()
def paint_back(self):
self.k.blit(self.back, (0, 0))
def paint_objects(self):
for obj in self.objects:
show = True
if isinstance(obj, Null):
show = False
elif isinstance(obj, Selector):
show = self.select or self.selecting[3]
if show:
# FIXME: use blits() here?
self.surf.blit(obj.surf, obj.pos)
#def paint_obj(self, pos=None, area=None):
# self.surf.blit(self.objects[-1][0], pos if pos else (0, 0), area)
#def paint_surf(self, pos=None, area=None):
# #print(f'paint_surf: {pos} -> {area}')
# self.k.blit(self.surf, pos if pos else (0, 0), area)
def paint_surf(self, area=None):
self.k.blit(self.surf, (0, 0), area)
def paint_overlay(self):
self.k.blit(self.overlay, (0, 0))
def tick(self):
if self.k.player.is_playing(True):
self.paint_surf((PRECT[0], PRECT[1]), PRECT)
#if not self.tooling and self.objects:
# for obj in self.objects:
# obj.surf.set_palette_at(9, CYAN)
if not self.tooling and self.selecting and self.selecting[3]:
clock = self.selecting[0]
clock.tick()
if clock.ready():
val = self.selecting[1]
rev = self.selecting[2]
if rev:
val -= Selector.STEP
if val < Selector.MIN:
val = Selector.MIN
rev = False
else:
val += Selector.STEP
if val > Selector.MAX:
val = Selector.MAX
rev = True
self.selecting[1] = val
self.selecting[2] = rev
for idx in self.selects:
self.objects[idx].alpha(val)
self.paint()
def kick(self, event):
#print(f'ack kick: {event}')
if event.type == pygame.WINDOWFOCUSGAINED \
or event.type == pygame.WINDOWEXPOSED:
self.paint()
elif event.type == pygame.MOUSEBUTTONDOWN:
if event.button == pygame.BUTTON_LEFT \
or event.button == pygame.BUTTON_MIDDLE:
if not self.tooling:
self.tooling = event.button
self.tool_start(event.pos)
self.tool_at(event.pos)
elif event.type == pygame.MOUSEBUTTONUP:
if event.button == self.tooling:
self.tool_stop()
self.tooling = None
if self.overlay:
self.paint_overlay()
else:
self.paint()
elif event.button == pygame.BUTTON_WHEELUP:
self.tool.up()
if self.tooling:
self.tool_at(event.pos)
elif event.button == pygame.BUTTON_WHEELDOWN:
self.tool.down()
if self.tooling:
self.tool_at(event.pos)
elif event.type == pygame.MOUSEMOTION:
if self.tooling:
self.tool_at(event.pos)
elif event.type == pygame.KEYDOWN:
if event.key == pygame.K_LCTRL or event.key == pygame.K_RCTRL:
self.control = True
self.tool.constraints()
if self.tooling:
self.tool_at(self.pos)
elif event.key == pygame.K_LSHIFT or event.key == pygame.K_RSHIFT:
self.select = True
self.tool.selector()
paint = True
if self.tooling:
if self.tool_at(self.pos):
paint = False
if paint:
self.paint()
elif event.type == pygame.KEYUP:
if event.key == pygame.K_LCTRL or event.key == pygame.K_RCTRL:
self.control = False
self.tool.constraints()
if self.tooling:
self.tool_at(self.pos)
elif event.key == pygame.K_LSHIFT or event.key == pygame.K_RSHIFT:
self.select = False
self.tool.selector()
paint = True
if self.tooling:
if self.tool_at(self.pos):
paint = False
if paint:
self.paint()
elif event.key in self.tools:
tool = self.tools[event.key]
if tool is self.tool:
tool = tool.toggle()
if tool:
self.tool_pick(tool)
if self.tooling:
self.tool_at(self.pos)
else:
self.tool_pick(tool, True)
if self.tooling:
self.tool_at(self.pos)
elif event.unicode >= '1' and event.unicode <= '9':
self.tool.choice(1 + ord(event.unicode) - ord('1'))
if self.tooling:
self.tool_at(self.pos)
- elif event.key == pygame.K_0:
- self.tool.choice(0)
- if self.tooling:
- self.tool_at(self.pos)
+ #elif event.key == pygame.K_0:
+ # self.tool.choice(0)
+ # if self.tooling:
+ # self.tool_at(self.pos)
elif event.key == pygame.K_b:
if self.back is self.back_black:
self.back = self.back_white
skey = WHITE
scolor = BLACK
else:
self.back = self.back_black
skey = BLACK
scolor = WHITE
for idx in self.selects:
obj = self.objects[idx]
obj.key(skey)
obj.color(scolor)
self.paint()
elif event.key == pygame.K_SPACE:
if self.selecting:
self.selecting[3] = not self.selecting[3]
self.paint()
elif event.key == pygame.K_d:
if self.objects:
self.del_obj()
self.paint()
elif event.key == pygame.K_s:
name = file_date_time(datetime.now())
print(f'saving: {name}')
media.save_ack_image(self.surf, name)
#FIXME: use subsurface here instead:
screen = pygame.Surface((WIDTH, HEIGHT-STATUS-1))
screen.blit(self.k.screen, (0, 0))
media.save_ack_image(screen, f'{name}_combined')
elif event.key == pygame.K_c:
obj = self.obj()
if obj:
#with BytesIO() as io:
# pygame.image.save(obj[0], io, 'png')
# try:
# pygame.scrap.put('image/png', io.getvalue())
#
# except pygame.error:
# fn = media.clipboard(io.getvalue())
# pygame.scrap.put('text/plain;charset=utf-8',
# bytes(f'file://{fn}', 'UTF-8'))
media.put_clipboard_image(obj.surf)
elif event.key == pygame.K_v:
print('clipboard contents:')
#for mtype in pygame.scrap.get_types():
# print(f' {mtype}')
# if 'text' in mtype:
# print(f' {pygame.scrap.get(mtype)}')
surf = media.get_clipboard_image()
if surf is not None:
self.add_obj(Image(surf))
self.paint()
def kill(self):
pass
diff --git a/k/ack/tool/__init__.py b/k/ack/tool/__init__.py
--- a/k/ack/tool/__init__.py
+++ b/k/ack/tool/__init__.py
@@ -1,107 +1,106 @@
from k.ui import *
from ..obj.draw import Drawing, Selector
from abc import ABC, abstractmethod
class Tool(ABC):
def __init__(self, ack):
self.ack = ack
@abstractmethod
def pick(self, prev):
pass
def toggle(self):
pass
def selector(self):
pass
def constraints(self):
pass
def choice(self, c):
pass
def up(self):
pass
def down(self):
pass
def start(self, pos):
pass
def stop(self):
pass
@abstractmethod
def use(self, pos, middle=False):
pass
class Draws(Tool, ABC):
def __init__(self, ack, choice=1, size=0):
self.ack = ack
-
+ self.size = size
self.choice(choice)
- self.size = size
def choice(self, c):
self.color = self.ack.colors[c]
def up(self):
self.size += 1
if self.size > WIDTH:
self.size = WIDTH
def down(self):
self.size -= 1
if self.size < 0:
self.size = 0
def draw_select(self, pos, middle_out, constrain=None):
x = self.ack.start[0]
y = self.ack.start[1]
w = pos[0] - x
h = pos[1] - y
self.flip_x = False
self.flip_y = False
if w < 0:
w = abs(w)
x -= w
self.flip_x = True
if h < 0:
h = abs(h)
y -= h
self.flip_y = True
if middle_out:
w *= 2
h *= 2
x = pos[0] if self.flip_x else pos[0] - w
y = pos[1] if self.flip_y else pos[1] - h
if constrain is None:
constrain = self.ack.control
if constrain:
normal = max(w, h)
if middle_out:
if w < h:
x -= (h - w)//2
elif h < w:
y -= (w - h)//2
w = normal
h = normal
return self.ack.set_obj(
Drawing((x, y), (w, h), self.color) \
if not self.ack.select else \
Selector((x, y), (w, h))
)
diff --git a/k/ack/tool/ellipse.py b/k/ack/tool/ellipse.py
--- a/k/ack/tool/ellipse.py
+++ b/k/ack/tool/ellipse.py
@@ -1,21 +1,52 @@
from k.ui import *
+import k.storage as media
from . import Draws
+from .color import divert
from ..obj import Null
class Tool(Draws):
def __init__(self, ack):
super().__init__(ack)
+ def cursor(self):
+ self.mouse = media.get_gfx('ellipse_' \
+ + ('normal' if self.size > 0 else 'full') + '.gif')
+ back = self.ack.back.get_at((9, 9))
+ self.mouse.set_palette_at(0, divert(divert(back, 3), 3))
+ self.mouse.set_palette_at(1, divert(back, 3))
+ self.mouse.set_colorkey(1)
+ self.mouse.set_palette_at(2, divert(self.color))
+ self.mouse.set_palette_at(3, self.color)
+
+ pygame.mouse.set_cursor(pygame.Cursor((13, 13), self.mouse))
+
def pick(self, prev):
- pygame.mouse.set_cursor(pygame.SYSTEM_CURSOR_CROSSHAIR)
+ #pygame.mouse.set_cursor(pygame.SYSTEM_CURSOR_CROSSHAIR)
+ self.cursor()
+
+ def choice(self, c):
+ super().choice(c)
+ self.cursor()
+
+ def up(self):
+ mouse = (self.size == 0)
+ super().up()
+ if mouse:
+ self.cursor()
+
+ def down(self):
+ mouse = (self.size > 0)
+ super().down()
+ if mouse and self.size == 0:
+ self.cursor()
def start(self, pos):
self.ack.add_obj(Null())
def use(self, pos, middle=False):
return self.draw_select(
pos, middle
).ellipse(self.size)
diff --git a/k/ack/tool/rect.py b/k/ack/tool/rect.py
--- a/k/ack/tool/rect.py
+++ b/k/ack/tool/rect.py
@@ -1,26 +1,57 @@
from k.ui import *
+import k.storage as media
from . import Draws
+from .color import divert
from ..obj import Null
class Tool(Draws):
def __init__(self, ack):
super().__init__(ack)
self.rounded = False
+ def cursor(self):
+ self.mouse = media.get_gfx('rect_' \
+ + ('normal' if self.size > 0 else 'full') + '.gif')
+ back = self.ack.back.get_at((9, 9))
+ self.mouse.set_palette_at(0, divert(divert(back, 3), 3))
+ self.mouse.set_palette_at(1, divert(back, 3))
+ self.mouse.set_colorkey(1)
+ self.mouse.set_palette_at(2, divert(self.color))
+ self.mouse.set_palette_at(3, self.color)
+
+ pygame.mouse.set_cursor(pygame.Cursor((13, 13), self.mouse))
+
def pick(self, prev):
- pygame.mouse.set_cursor(pygame.SYSTEM_CURSOR_CROSSHAIR)
+ #pygame.mouse.set_cursor(pygame.SYSTEM_CURSOR_CROSSHAIR)
+ self.cursor()
def toggle(self):
self.rounded = not self.rounded
+ def choice(self, c):
+ super().choice(c)
+ self.cursor()
+
+ def up(self):
+ mouse = (self.size == 0)
+ super().up()
+ if mouse:
+ self.cursor()
+
+ def down(self):
+ mouse = (self.size > 0)
+ super().down()
+ if mouse and self.size == 0:
+ self.cursor()
+
def start(self, pos):
self.ack.add_obj(Null())
def use(self, pos, middle=False):
return self.draw_select(
pos, middle
).rect(self.size, self.rounded)
diff --git a/k/ack/tool/wiggle.py b/k/ack/tool/wiggle.py
--- a/k/ack/tool/wiggle.py
+++ b/k/ack/tool/wiggle.py
@@ -1,76 +1,94 @@
from k.ui import *
+import k.storage as media
from . import Draws
+from .color import divert
from ..obj import Null
from ..obj.draw import Drawing, Selector
class Tool(Draws):
def __init__(self, ack):
super().__init__(ack, size=4)
self.rounded = True
+ def cursor(self):
+ self.mouse = media.get_gfx('wiggle.gif')
+ back = self.ack.back.get_at((9, 9))
+ self.mouse.set_palette_at(0, divert(divert(back, 3), 3))
+ self.mouse.set_palette_at(1, divert(back, 3))
+ self.mouse.set_colorkey(1)
+ self.mouse.set_palette_at(2, divert(self.color))
+ self.mouse.set_palette_at(3, self.color)
+
+ pygame.mouse.set_cursor(pygame.Cursor((13, 13), self.mouse))
+
def pick(self, prev):
- pygame.mouse.set_cursor(pygame.SYSTEM_CURSOR_CROSSHAIR)
+ #pygame.mouse.set_cursor(pygame.SYSTEM_CURSOR_CROSSHAIR)
+ self.cursor()
def toggle(self):
self.rounded = not self.rounded
def selector(self):
if self.ack.tooling:
obj = self.ack.obj()
size = obj.size()
return self.ack.set_obj(
Drawing(obj.pos, size, self.color) \
if not self.ack.select else \
Selector(obj.pos, size)
).blit(obj)
def constraints(self):
if self.ack.tooling:
if self.ack.control:
self.ack.add_obj(Null())
else:
size = (WIDTH, HEIGHT-STATUS-1)
self.ack.add_obj(
Drawing((0, 0), size, self.color) \
if not self.ack.select else \
Selector((0, 0), size)
)
+ def choice(self, c):
+ super().choice(c)
+ self.cursor()
+
def down(self):
super().down()
if self.size < 1:
self.size = 1
def start(self, pos):
self.constraints()
if not self.ack.control:
self.ack.obj().blot(pos, self.size, self.rounded)
def use(self, pos, middle=False):
if pos != self.ack.start:
if self.ack.control:
obj = self.draw_select(pos, middle, False)
size = obj.size()
obj.line(
(size[0] if self.flip_x else 0,
size[1] if self.flip_y else 0),
(size[0] if not self.flip_x else 0,
size[1] if not self.flip_y else 0),
self.size)
else:
obj = self.ack.obj()
obj.line(self.ack.start, pos, self.size)
self.ack.start = pos
return obj
def stop(self):
self.ack.obj().blot(self.ack.pos, self.size, self.rounded)
diff --git a/k/keys/ack.py b/k/keys/ack.py
--- a/k/keys/ack.py
+++ b/k/keys/ack.py
@@ -1,100 +1,101 @@
from .base import *
class Panel(Keys):
def __init__(self, panel, anchors, container):
super().__init__(panel, anchors, container)
self.key(pygame.K_ESCAPE, 'Esc', size=KEY_TOP,
info='Close the blackboard.')
self.nop(pygame.K_F1, 'F1', (KEY[0], 0), KEY_TOP, left=pygame.K_ESCAPE)
self.nop(pygame.K_F2, 'F2', size=KEY_TOP, left=pygame.K_F1)
self.nop(pygame.K_F3, 'F3', size=KEY_TOP, left=pygame.K_F2)
self.nop(pygame.K_F4, 'F4', size=KEY_TOP, left=pygame.K_F3)
self.nop(pygame.K_F5, 'F5', (KEY[0]//2, 0), KEY_TOP, left=pygame.K_F4)
self.nop(pygame.K_F6, 'F6', size=KEY_TOP, left=pygame.K_F5)
self.nop(pygame.K_F7, 'F7', size=KEY_TOP, left=pygame.K_F6)
self.key(pygame.K_BACKQUOTE, '`', (0, GAP_TOP), top=pygame.K_ESCAPE,
info='Use the Color tool (toggle palette).')
self.key(pygame.K_1, '1', (0, GAP_TOP), left=pygame.K_BACKQUOTE,
info='Choose color #1.')
self.key(pygame.K_2, '2', (0, GAP_TOP), left=pygame.K_1,
info='Choose color #2.')
self.key(pygame.K_3, '3', (0, GAP_TOP), left=pygame.K_2,
info='Choose color #3.')
self.key(pygame.K_4, '4', (0, GAP_TOP), left=pygame.K_3,
info='Choose color #4.')
self.key(pygame.K_5, '5', (0, GAP_TOP), left=pygame.K_4,
info='Choose color #5.')
self.key(pygame.K_6, '6', (0, GAP_TOP), left=pygame.K_5,
info='Choose color #6.')
self.key(pygame.K_7, '7', (0, GAP_TOP), left=pygame.K_6,
info='Choose color #7.')
self.key(pygame.K_8, '8', (0, GAP_TOP), left=pygame.K_7,
info='Choose color #8.')
self.key(pygame.K_9, '9', (0, GAP_TOP), left=pygame.K_8,
info='Choose color #9.')
self.nop(pygame.K_TAB, 'Tab', size=KEY[0]//2, top=pygame.K_BACKQUOTE)
self.key(pygame.K_q, 'Q', left=pygame.K_TAB,
info='Use the Queue&Query tool.')
self.key(pygame.K_w, 'W', left=pygame.K_q,
info='Use the Wiggle tool.')
self.key(pygame.K_e, 'E', left=pygame.K_w,
info='Use the Ellipse tool.')
self.key(pygame.K_r, 'R', left=pygame.K_e,
info='Use the Rectangle tool.')
self.key(pygame.K_t, 'T', left=pygame.K_r,
info='Use the Text tool.')
self.nop(pygame.K_y, 'Y', left=pygame.K_t)
self.nop(pygame.K_u, 'U', left=pygame.K_y)
self.nop(pygame.K_i, 'I', left=pygame.K_u)
self.nop(pygame.K_CAPSLOCK, 'CapsLock', size=KEY[0]//2+15,
top=pygame.K_TAB)
self.key(pygame.K_a, 'A', left=pygame.K_CAPSLOCK,
info='Use the Adjuster tool.')
self.key(pygame.K_s, 'S', left=pygame.K_a,
info='Save drawing.')
self.key(pygame.K_d, 'D', left=pygame.K_s,
info='Delete object.')
self.key(pygame.K_f, 'F', left=pygame.K_d,
info='Use the Fill tool.')
self.key(pygame.K_g, 'G', left=pygame.K_f,
info='Group.')
self.nop(pygame.K_h, 'H', left=pygame.K_g)
self.nop(pygame.K_j, 'J', left=pygame.K_h)
self.nop(pygame.K_k, 'K', left=pygame.K_j)
self.key(pygame.K_LSHIFT, 'Shift', size=KEY[0]+15,
top=pygame.K_CAPSLOCK, info=INFO_MOD)
self.key(pygame.K_z, 'Z', left=pygame.K_LSHIFT,
info='Undo.')
self.combo((pygame.K_LSHIFT, pygame.K_z),
info='Redo.')
self.combo((pygame.K_LCTRL, pygame.K_z),
info='Redo all.')
self.key(pygame.K_x, 'X', left=pygame.K_z,
info='Cut.')
self.key(pygame.K_c, 'C', left=pygame.K_x,
info='Copy object to clipboard.')
self.key(pygame.K_v, 'V', left=pygame.K_c,
info='Paste clipboard contents as new object.')
self.key(pygame.K_b, 'B', left=pygame.K_v,
info='Background toggle.')
self.nop(pygame.K_n, 'N', left=pygame.K_b)
self.nop(pygame.K_m, 'M', left=pygame.K_n)
self.key(pygame.K_LCTRL, 'Ctrl', size=KEY[0]//2, top=pygame.K_LSHIFT,
info=INFO_MOD)
self.nop(pygame.K_LSUPER, 'Win', size=15, left=pygame.K_LCTRL)
self.nop(pygame.K_LALT, 'Alt', size=15, left=pygame.K_LSUPER)
- self.nop(pygame.K_SPACE, 'Space', size=KEY[0]*5, left=pygame.K_LALT)
+ self.key(pygame.K_SPACE, 'Space', size=KEY[0]*5, left=pygame.K_LALT,
+ info='Toggle selectors.')
def title(self):
return 'ACK'
def descr(self):
return 'These keys apply when "ack" (blackboard) is active.'
diff --git a/version.py b/version.py
--- a/version.py
+++ b/version.py
@@ -1,8 +1,8 @@
-VVHEN="5.31 opeth 22+29/2"
+VVHEN="6.01 opeth 01+02/2"
THEY="yahoo.com"
SAW="LANNOCC"
ME="shawn"
print(VVHEN+' --'+SAW)
'''can you help?'''

File Metadata

Mime Type
text/x-diff
Expires
Thu, Sep 17, 9:33 AM (4 d, 5 h ago)
Storage Engine
blob
Storage Format
Raw Data
Storage Handle
3758
Default Alt Text
(35 KB)

Event Timeline