id int64 0 458k | file_name stringlengths 4 119 | file_path stringlengths 14 227 | content stringlengths 24 9.96M | size int64 24 9.96M | language stringclasses 1 value | extension stringclasses 14 values | total_lines int64 1 219k | avg_line_length float64 2.52 4.63M | max_line_length int64 5 9.91M | alphanum_fraction float64 0 1 | repo_name stringlengths 7 101 | repo_stars int64 100 139k | repo_forks int64 0 26.4k | repo_open_issues int64 0 2.27k | repo_license stringclasses 12 values | repo_extraction_date stringclasses 433 values |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
26,600 | loop.py | kovidgoyal_calibre/src/calibre/srv/loop.py | #!/usr/bin/env python
__license__ = 'GPL v3'
__copyright__ = '2015, Kovid Goyal <kovid at kovidgoyal.net>'
import ipaddress
import os
import select
import socket
import ssl
import traceback
from contextlib import suppress
from functools import lru_cache, partial
from io import BytesIO
from typing import Union
from calibre import as_unicode
from calibre.constants import iswindows
from calibre.ptempfile import TemporaryDirectory
from calibre.srv.errors import JobQueueFull
from calibre.srv.jobs import JobsManager
from calibre.srv.opts import Options
from calibre.srv.pool import PluginPool, ThreadPool
from calibre.srv.utils import (
DESIRED_SEND_BUFFER_SIZE,
HandleInterrupt,
create_sock_pair,
socket_errors_eintr,
socket_errors_nonblocking,
socket_errors_socket_closed,
start_cork,
stop_cork,
)
from calibre.utils.localization import _
from calibre.utils.logging import ThreadSafeLog
from calibre.utils.mdns import get_external_ip
from calibre.utils.monotonic import monotonic
from calibre.utils.network import get_fallback_server_addr
from calibre.utils.socket_inheritance import set_socket_inherit
from polyglot.builtins import iteritems
from polyglot.queue import Empty, Full
READ, WRITE, RDWR, WAIT = 'READ', 'WRITE', 'RDWR', 'WAIT'
WAKEUP, JOB_DONE = b'\0', b'\x01'
IPPROTO_IPV6 = getattr(socket, "IPPROTO_IPV6", 41)
class ReadBuffer: # {{{
' A ring buffer used to speed up the readline() implementation by minimizing recv() calls '
__slots__ = ('ba', 'buf', 'read_pos', 'write_pos', 'full_state')
def __init__(self, size=4096):
self.ba = bytearray(size)
self.buf = memoryview(self.ba)
self.read_pos = 0
self.write_pos = 0
self.full_state = WRITE
@property
def has_data(self):
return self.read_pos != self.write_pos or self.full_state is READ
@property
def has_space(self):
return self.read_pos != self.write_pos or self.full_state is WRITE
def read(self, size):
# Read from this buffer, retuning the read bytes as a bytestring
if self.read_pos == self.write_pos and self.full_state is WRITE:
return b''
if self.read_pos < self.write_pos:
sz = min(self.write_pos - self.read_pos, size)
npos = self.read_pos + sz
ans = self.buf[self.read_pos:npos].tobytes()
self.read_pos = npos
if self.read_pos == self.write_pos:
self.full_state = WRITE
else:
sz = min(size, len(self.buf) - self.read_pos)
ans = self.buf[self.read_pos:self.read_pos + sz].tobytes()
self.read_pos = (self.read_pos + sz) % len(self.buf)
if self.read_pos == self.write_pos:
self.full_state = WRITE
if size > sz and self.read_pos < self.write_pos:
ans += self.read(size - len(ans))
return ans
def recv_from(self, socket):
# Write into this buffer from socket, return number of bytes written
if self.read_pos == self.write_pos and self.full_state is READ:
return 0
if self.write_pos < self.read_pos:
num = socket.recv_into(self.buf[self.write_pos:self.read_pos])
self.write_pos += num
else:
num = socket.recv_into(self.buf[self.write_pos:])
self.write_pos = (self.write_pos + num) % len(self.buf)
if self.write_pos == self.read_pos:
self.full_state = READ
return num
def readline(self):
# Return whatever is in the buffer up to (and including) the first \n
# If no \n is present, returns everything
if self.read_pos == self.write_pos and self.full_state is WRITE:
return b''
if self.read_pos < self.write_pos:
pos = self.ba.find(b'\n', self.read_pos, self.write_pos)
if pos < 0:
pos = self.write_pos - 1
ans = self.buf[self.read_pos:pos + 1].tobytes()
self.read_pos = (pos + 1) % len(self.buf)
if self.read_pos == self.write_pos:
self.full_state = WRITE
else:
pos = self.ba.find(b'\n', self.read_pos)
if pos < 0:
pos = self.ba.find(b'\n', 0, self.write_pos)
if pos < 0:
pos = self.write_pos - 1
ans = self.buf[self.read_pos:].tobytes() + self.buf[:pos+1].tobytes()
self.read_pos = (pos + 1) % len(self.buf)
if self.read_pos == self.write_pos:
self.full_state = WRITE
else:
ans = self.buf[self.read_pos:pos + 1].tobytes()
self.read_pos = (pos + 1) % len(self.buf)
if self.read_pos == self.write_pos:
self.full_state = WRITE
return ans
# }}}
class BadIPSpec(ValueError):
pass
def parse_trusted_ips(spec):
for part in as_unicode(spec).split(','):
part = part.strip()
try:
if '/' in part:
yield ipaddress.ip_network(part)
else:
yield ipaddress.ip_address(part)
except Exception as e:
raise BadIPSpec(_('{0} is not a valid IP address/network, with error: {1}').format(part, e))
def is_ip_trusted(remote_addr, trusted_ips):
remote_addr = getattr(remote_addr, 'ipv4_mapped', None) or remote_addr
for tip in trusted_ips:
if hasattr(tip, 'hosts'):
if remote_addr in tip:
return True
else:
if tip == remote_addr:
return True
return False
def is_local_address(addr: Union[ipaddress.IPv4Address, ipaddress.IPv6Address, None]):
if addr is None:
return False
if addr.is_loopback:
return True
ipv4_mapped = getattr(addr, 'ipv4_mapped', None)
return getattr(ipv4_mapped, 'is_loopback', False)
class Connection: # {{{
def __init__(self, socket, opts, ssl_context, tdir, addr, pool, log, access_log, wakeup):
self.opts, self.pool, self.log, self.wakeup, self.access_log = opts, pool, log, wakeup, access_log
try:
self.remote_addr = addr[0]
self.remote_port = addr[1]
self.parsed_remote_addr = ipaddress.ip_address(as_unicode(self.remote_addr))
except Exception:
# In case addr is None, which can occasionally happen
self.remote_addr = self.remote_port = self.parsed_remote_addr = None
self.is_trusted_ip = bool(self.opts.local_write and is_local_address(self.parsed_remote_addr))
if not self.is_trusted_ip and self.opts.trusted_ips and self.parsed_remote_addr is not None:
self.is_trusted_ip = is_ip_trusted(self.parsed_remote_addr, parsed_trusted_ips(self.opts.trusted_ips))
self.orig_send_bufsize = self.send_bufsize = 4096
self.tdir = tdir
self.wait_for = READ
self.response_started = False
self.read_buffer = ReadBuffer()
self.handle_event = None
self.ssl_context = ssl_context
self.ssl_handshake_done = False
self.ssl_terminated = False
if self.ssl_context is not None:
self.ready = False
self.socket = self.ssl_context.wrap_socket(socket, server_side=True, do_handshake_on_connect=False)
self.set_state(RDWR, self.do_ssl_handshake)
else:
self.socket = socket
self.connection_ready()
self.last_activity = monotonic()
self.ready = True
def optimize_for_sending_packet(self):
start_cork(self.socket)
self.orig_send_bufsize = self.send_bufsize = self.socket.getsockopt(socket.SOL_SOCKET, socket.SO_SNDBUF)
if self.send_bufsize < DESIRED_SEND_BUFFER_SIZE:
try:
self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_SNDBUF, DESIRED_SEND_BUFFER_SIZE)
except OSError:
pass
else:
self.send_bufsize = self.socket.getsockopt(socket.SOL_SOCKET, socket.SO_SNDBUF)
def end_send_optimization(self):
stop_cork(self.socket)
if self.send_bufsize != self.orig_send_bufsize:
self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_SNDBUF, self.orig_send_bufsize)
def set_state(self, wait_for, func, *args, **kwargs):
self.wait_for = wait_for
if args or kwargs:
pfunc = partial(func, *args, **kwargs)
pfunc.__name__ = func.__name__
func = pfunc
self.handle_event = func
def do_ssl_handshake(self, event):
try:
self.socket._sslobj.do_handshake()
except ssl.SSLWantReadError:
self.set_state(READ, self.do_ssl_handshake)
except ssl.SSLWantWriteError:
self.set_state(WRITE, self.do_ssl_handshake)
else:
self.ssl_handshake_done = True
self.connection_ready()
def send(self, data):
try:
ret = self.socket.send(data) if self.ssl_context is None else self.socket.write(data)
self.last_activity = monotonic()
return ret
except ssl.SSLWantWriteError:
return 0
except OSError as e:
if e.errno in socket_errors_nonblocking or e.errno in socket_errors_eintr:
return 0
elif e.errno in socket_errors_socket_closed:
self.log.error('Failed to send all data in state:', self.state_description, 'with error:', e)
self.ready = False
return 0
raise
def recv(self, amt):
# If there is data in the read buffer we have to return only that,
# since we dont know if the socket has signalled it is ready for
# reading
if self.read_buffer.has_data:
return self.read_buffer.read(amt)
# read buffer is empty, so read directly from socket
try:
data = self.socket.recv(amt)
self.last_activity = monotonic()
if not data:
# a closed connection is indicated by signaling
# a read condition, and having recv() return 0.
self.ready = False
return b''
return data
except ssl.SSLWantReadError:
return b''
except OSError as e:
if e.errno in socket_errors_nonblocking or e.errno in socket_errors_eintr:
return b''
if e.errno in socket_errors_socket_closed:
self.ready = False
return b''
raise
def recv_into(self, buf, amt=0):
amt = amt or len(buf)
if self.read_buffer.has_data:
data = self.read_buffer.read(amt)
buf[0:len(data)] = data
return len(data)
try:
bytes_read = self.socket.recv_into(buf, amt)
self.last_activity = monotonic()
if bytes_read == 0:
# a closed connection is indicated by signaling
# a read condition, and having recv() return 0.
self.ready = False
return 0
return bytes_read
except ssl.SSLWantReadError:
return 0
except OSError as e:
if e.errno in socket_errors_nonblocking or e.errno in socket_errors_eintr:
return 0
if e.errno in socket_errors_socket_closed:
self.ready = False
return 0
raise
def fill_read_buffer(self):
try:
num = self.read_buffer.recv_from(self.socket)
self.last_activity = monotonic()
if not num:
# a closed connection is indicated by signaling
# a read condition, and having recv() return 0.
self.ready = False
except ssl.SSLWantReadError:
return
except OSError as e:
if e.errno in socket_errors_nonblocking or e.errno in socket_errors_eintr:
return
if e.errno in socket_errors_socket_closed:
self.ready = False
return
raise
def drain_ssl_buffer(self):
try:
self.read_buffer.recv_from(self.socket)
except ssl.SSLWantReadError:
return
except ssl.SSLError as e:
self.log.error('Error while reading SSL data from client: %s' % as_unicode(e))
self.ready = False
return
except OSError as e:
if e.errno in socket_errors_nonblocking or e.errno in socket_errors_eintr:
return
if e.errno in socket_errors_socket_closed:
self.ready = False
return
raise
def close(self):
self.ready = False
self.handle_event = None # prevent reference cycles
try:
self.socket.shutdown(socket.SHUT_WR)
except OSError:
pass
try:
self.socket.close()
except OSError:
pass
def queue_job(self, func, *args):
if args:
func = partial(func, *args)
try:
self.pool.put_nowait(self.socket.fileno(), func)
except Full:
raise JobQueueFull()
self.set_state(WAIT, self._job_done)
def _job_done(self, event):
self.job_done(*event)
def job_done(self, ok, result):
raise NotImplementedError()
@property
def state_description(self):
return ''
def report_unhandled_exception(self, e, formatted_traceback):
pass
def report_busy(self):
pass
def connection_ready(self):
raise NotImplementedError()
def handle_timeout(self):
return False
# }}}
@lru_cache(maxsize=2)
def parsed_trusted_ips(raw):
return tuple(parse_trusted_ips(raw)) if raw else ()
class ServerLoop:
LISTENING_MSG = 'calibre server listening on'
def __init__(
self,
handler,
opts=None,
plugins=(),
# A calibre logging object. If None, a default log that logs to
# stdout is used
log=None,
# A calibre logging object for access logging, by default no access
# logging is performed
access_log=None
):
self.ready = False
self.handler = handler
self.opts = opts or Options()
self.log = log or ThreadSafeLog(level=ThreadSafeLog.DEBUG)
self.jobs_manager = JobsManager(self.opts, self.log)
self.access_log = access_log
ba = (self.opts.listen_on, int(self.opts.port))
if not ba[0]:
# AI_PASSIVE does not work with host of '' or None
ba = (get_fallback_server_addr(), ba[1])
self.bind_address = ba
self.bound_address = None
self.connection_map = {}
self.ssl_context = None
if self.opts.ssl_certfile is not None and self.opts.ssl_keyfile is not None:
self.ssl_context = ssl.create_default_context(ssl.Purpose.CLIENT_AUTH)
self.ssl_context.load_cert_chain(certfile=self.opts.ssl_certfile, keyfile=self.opts.ssl_keyfile)
self.ssl_context.set_servername_callback(self.on_ssl_servername)
self.pre_activated_socket = None
self.socket_was_preactivated = False
if self.opts.allow_socket_preallocation:
from calibre.srv.pre_activated import pre_activated_socket
self.pre_activated_socket = pre_activated_socket()
if self.pre_activated_socket is not None:
set_socket_inherit(self.pre_activated_socket, False)
self.bind_address = self.pre_activated_socket.getsockname()
self.create_control_connection()
self.pool = ThreadPool(self.log, self.job_completed, count=self.opts.worker_count)
self.plugin_pool = PluginPool(self, plugins)
def on_ssl_servername(self, socket, server_name, ssl_context):
c = self.connection_map.get(socket.fileno())
if getattr(c, 'ssl_handshake_done', False):
c.ready = False
c.ssl_terminated = True
# We do not allow client initiated SSL renegotiation
return ssl.ALERT_DESCRIPTION_NO_RENEGOTIATION
def create_control_connection(self):
if iswindows:
self.control_in, self.control_out = create_sock_pair()
else:
r, w = os.pipe()
os.set_blocking(r, False)
os.set_blocking(w, True)
self.control_in = open(w, 'wb')
self.control_out = open(r, 'rb')
def close_control_connection(self):
with suppress(Exception):
self.control_in.close()
with suppress(Exception):
self.control_out.close()
def __str__(self):
return f"{self.__class__.__name__}({self.bind_address!r})"
__repr__ = __str__
@property
def num_active_connections(self):
return len(self.connection_map)
def do_bind(self):
# Get the correct address family for our host (allows IPv6 addresses)
host, port = self.bind_address
try:
info = socket.getaddrinfo(
host, port, socket.AF_UNSPEC,
socket.SOCK_STREAM, 0, socket.AI_PASSIVE)
except socket.gaierror:
if ':' in host:
info = [(socket.AF_INET6, socket.SOCK_STREAM,
0, "", self.bind_address + (0, 0))]
else:
info = [(socket.AF_INET, socket.SOCK_STREAM,
0, "", self.bind_address)]
self.socket = None
msg = "No socket could be created"
for res in info:
af, socktype, proto, canonname, sa = res
try:
self.bind(af, socktype, proto)
except OSError as serr:
msg = f"{msg} -- ({sa}: {as_unicode(serr)})"
if self.socket:
self.socket.close()
self.socket = None
continue
break
if not self.socket:
raise OSError(msg)
def initialize_socket(self):
if self.pre_activated_socket is None:
self.socket_was_preactivated = False
try:
self.do_bind()
except OSError as err:
if not self.opts.fallback_to_detected_interface:
raise
ip = get_external_ip()
if ip == self.bind_address[0]:
raise
self.log.warn('Failed to bind to {} with error: {}. Trying to bind to the default interface: {} instead'.format(
self.bind_address[0], as_unicode(err), ip))
self.bind_address = (ip, self.bind_address[1])
self.do_bind()
else:
self.socket = self.pre_activated_socket
self.socket_was_preactivated = True
self.pre_activated_socket = None
self.setup_socket()
def serve(self):
from calibre.utils.network import format_addr_for_url
self.connection_map = {}
if not self.socket_was_preactivated:
self.socket.listen(min(socket.SOMAXCONN, 128))
self.bound_address = ba = self.socket.getsockname()
ba_str = ''
if isinstance(ba, tuple):
addr = format_addr_for_url(str(ba[0]))
ba_str = f'{addr}:{ba[1]}'
self.pool.start()
with TemporaryDirectory(prefix='srv-') as tdir:
self.tdir = tdir
if self.LISTENING_MSG:
self.log(self.LISTENING_MSG, ba_str)
self.plugin_pool.start()
self.ready = True
while self.ready:
try:
self.tick()
except SystemExit:
self.shutdown()
raise
except KeyboardInterrupt:
break
except:
self.log.exception('Error in ServerLoop.tick')
self.shutdown()
def serve_forever(self):
""" Listen for incoming connections. """
self.initialize_socket()
self.serve()
def setup_socket(self):
self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
self.socket.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
# If listening on the IPV6 any address ('::' = IN6ADDR_ANY),
# activate dual-stack.
if (hasattr(socket, 'AF_INET6') and self.socket.family == socket.AF_INET6 and
self.bind_address[0] in ('::', '::0', '::0.0.0.0')):
try:
self.socket.setsockopt(IPPROTO_IPV6, socket.IPV6_V6ONLY, 0)
except (AttributeError, OSError):
# Apparently, the socket option is not available in
# this machine's TCP stack
pass
self.socket.setblocking(0)
def bind(self, family, atype, proto=0):
'''Create (or recreate) the actual socket object.'''
self.socket = socket.socket(family, atype, proto)
set_socket_inherit(self.socket, False)
self.setup_socket()
self.socket.bind(self.bind_address)
def tick(self):
now = monotonic()
read_needed, write_needed, readable, remove, close_needed = [], [], [], [], []
has_ssl = self.ssl_context is not None
for s, conn in iteritems(self.connection_map):
if now - conn.last_activity > self.opts.timeout:
if conn.handle_timeout():
conn.last_activity = now
else:
remove.append((s, conn))
continue
wf = conn.wait_for
if wf is READ or wf is RDWR:
if wf is RDWR:
write_needed.append(s)
if conn.read_buffer.has_data:
readable.append(s)
else:
if has_ssl:
conn.drain_ssl_buffer()
if conn.ready:
(readable if conn.read_buffer.has_data else read_needed).append(s)
else:
close_needed.append((s, conn))
else:
read_needed.append(s)
elif wf is WRITE:
write_needed.append(s)
for s, conn in remove:
self.log('Closing connection because of extended inactivity: %s' % conn.state_description)
self.close(s, conn)
for x, conn in close_needed:
self.close(s, conn)
if readable:
writable = []
else:
try:
readable, writable, _ = select.select([self.socket.fileno(), self.control_out.fileno()] + read_needed, write_needed, [], self.opts.timeout)
except ValueError: # self.socket.fileno() == -1
self.ready = False
self.log.error('Listening socket was unexpectedly terminated')
return
except OSError as e:
# select.error has no errno attribute. errno is instead
# e.args[0]
if getattr(e, 'errno', e.args[0]) in socket_errors_eintr:
return
for s, conn in tuple(iteritems(self.connection_map)):
try:
select.select([s], [], [], 0)
except OSError as e:
if getattr(e, 'errno', e.args[0]) not in socket_errors_eintr:
self.close(s, conn) # Bad socket, discard
return
if not self.ready:
return
ignore = set()
for s, conn, event in self.get_actions(readable, writable):
if s in ignore:
continue
try:
conn.handle_event(event)
if not conn.ready:
self.close(s, conn)
except JobQueueFull:
self.log.exception('Server busy handling request: %s' % conn.state_description)
if conn.ready:
if conn.response_started:
self.close(s, conn)
else:
try:
conn.report_busy()
except Exception:
self.close(s, conn)
except Exception as e:
ignore.add(s)
ssl_terminated = getattr(conn, 'ssl_terminated', False)
if ssl_terminated:
self.log.warn('Client tried to initiate SSL renegotiation, closing connection')
self.close(s, conn)
else:
self.log.exception('Unhandled exception in state: %s' % conn.state_description)
if conn.ready:
if conn.response_started:
self.close(s, conn)
else:
try:
conn.report_unhandled_exception(e, traceback.format_exc())
except Exception:
self.close(s, conn)
else:
self.log.error('Error in SSL handshake, terminating connection: %s' % as_unicode(e))
self.close(s, conn)
def write_to_control(self, what):
if iswindows:
self.control_in.sendall(what)
else:
self.control_in.write(what)
self.control_in.flush()
def wakeup(self):
self.write_to_control(WAKEUP)
def job_completed(self):
self.write_to_control(JOB_DONE)
def dispatch_job_results(self):
while True:
try:
s, ok, result = self.pool.get_nowait()
except Empty:
break
conn = self.connection_map.get(s)
if conn is not None:
yield s, conn, (ok, result)
def close(self, s, conn):
self.connection_map.pop(s, None)
conn.close()
def get_actions(self, readable, writable):
listener = self.socket.fileno()
control = self.control_out.fileno()
for s in readable:
if s == listener:
sock, addr = self.accept()
if sock is not None:
s = sock.fileno()
if s > -1:
self.connection_map[s] = conn = self.handler(
sock, self.opts, self.ssl_context, self.tdir, addr, self.pool, self.log, self.access_log, self.wakeup)
if self.ssl_context is not None:
yield s, conn, RDWR
elif s == control:
f = self.control_out.recv if iswindows else self.control_out.read
try:
c = f(1)
except OSError as e:
if not self.ready:
return
self.log.error('Control connection raised an error:', e)
raise
if c == JOB_DONE:
for s, conn, event in self.dispatch_job_results():
yield s, conn, event
elif c == WAKEUP:
pass
elif not c:
if not self.ready:
return
self.log.error('Control connection failed to read after signalling ready')
raise Exception('Control connection failed to read, something bad happened')
else:
yield s, self.connection_map[s], READ
for s in writable:
try:
conn = self.connection_map[s]
except KeyError:
continue # Happens if connection was closed during read phase
yield s, conn, WRITE
def accept(self):
try:
sock, addr = self.socket.accept()
set_socket_inherit(sock, False), sock.setblocking(False)
return sock, addr
except OSError:
return None, None
def stop(self):
self.ready = False
self.wakeup()
def shutdown(self):
self.jobs_manager.shutdown()
with suppress(socket.error):
if getattr(self, 'socket', None):
self.socket.close()
self.socket = None
for s, conn in tuple(iteritems(self.connection_map)):
self.close(s, conn)
wait_till = monotonic() + self.opts.shutdown_timeout
for pool in (self.plugin_pool, self.pool):
pool.stop(wait_till)
if pool.workers:
self.log.warn('Failed to shutdown %d workers in %s cleanly' % (len(pool.workers), pool.__class__.__name__))
self.jobs_manager.wait_for_shutdown(wait_till)
class EchoLine(Connection): # {{{
bye_after_echo = False
def connection_ready(self):
self.rbuf = BytesIO()
self.set_state(READ, self.read_line)
def read_line(self, event):
data = self.recv(1)
if data:
self.rbuf.write(data)
if b'\n' == data:
if self.rbuf.tell() < 3:
# Empty line
self.rbuf = BytesIO(b'bye' + self.rbuf.getvalue())
self.bye_after_echo = True
self.set_state(WRITE, self.echo)
self.rbuf.seek(0)
def echo(self, event):
pos = self.rbuf.tell()
self.rbuf.seek(0, os.SEEK_END)
left = self.rbuf.tell() - pos
self.rbuf.seek(pos)
sent = self.send(self.rbuf.read(512))
if sent == left:
self.rbuf = BytesIO()
self.set_state(READ, self.read_line)
if self.bye_after_echo:
self.ready = False
else:
self.rbuf.seek(pos + sent)
# }}}
def main():
print('Starting Echo server')
s = ServerLoop(EchoLine)
with HandleInterrupt(s.stop):
s.serve_forever()
if __name__ == '__main__':
main()
| 30,201 | Python | .py | 732 | 29.239071 | 155 | 0.559523 | kovidgoyal/calibre | 19,243 | 2,250 | 4 | GPL-3.0 | 9/5/2024, 5:13:50 PM (Europe/Amsterdam) |
26,601 | render_book.py | kovidgoyal_calibre/src/calibre/srv/render_book.py | #!/usr/bin/env python
# License: GPLv3 Copyright: 2016, Kovid Goyal <kovid at kovidgoyal.net>
import json
import os
import sys
from collections import defaultdict
from concurrent.futures import ThreadPoolExecutor
from datetime import datetime
from functools import partial
from itertools import count
from lxml.etree import Comment
from calibre import detect_ncpus, force_unicode, prepare_string_for_xml
from calibre.customize.ui import plugin_for_input_format
from calibre.ebooks.oeb.base import EPUB, OEB_DOCS, OEB_STYLES, OPF, SMIL, XHTML, XHTML_NS, XLINK, rewrite_links, urlunquote
from calibre.ebooks.oeb.base import XPath as _XPath
from calibre.ebooks.oeb.iterator.book import extract_book
from calibre.ebooks.oeb.polish.container import Container as ContainerBase
from calibre.ebooks.oeb.polish.cover import find_cover_image, find_cover_image_in_page, find_cover_page
from calibre.ebooks.oeb.polish.toc import from_xpaths, get_landmarks, get_toc
from calibre.ebooks.oeb.polish.utils import guess_type
from calibre.srv.metadata import encode_datetime
from calibre.utils.date import EPOCH
from calibre.utils.logging import default_log
from calibre.utils.serialize import json_dumps, json_loads, msgpack_loads
from calibre.utils.short_uuid import uuid4
from calibre_extensions.fast_css_transform import transform_properties
from polyglot.binary import as_base64_unicode as encode_component
from polyglot.binary import from_base64_bytes
from polyglot.binary import from_base64_unicode as decode_component
from polyglot.builtins import as_bytes
from polyglot.urllib import quote, urlparse
try:
from calibre_extensions.speedup import get_num_of_significant_chars
except ImportError: # running from source without updated binary
def get_num_of_significant_chars(elem):
return len(getattr(elem, 'text', '') or '') + len(getattr(elem, 'tail', '') or '')
RENDER_VERSION = 1
BLANK_JPEG = b'\xff\xd8\xff\xdb\x00C\x00\x03\x02\x02\x02\x02\x02\x03\x02\x02\x02\x03\x03\x03\x03\x04\x06\x04\x04\x04\x04\x04\x08\x06\x06\x05\x06\t\x08\n\n\t\x08\t\t\n\x0c\x0f\x0c\n\x0b\x0e\x0b\t\t\r\x11\r\x0e\x0f\x10\x10\x11\x10\n\x0c\x12\x13\x12\x10\x13\x0f\x10\x10\x10\xff\xc9\x00\x0b\x08\x00\x01\x00\x01\x01\x01\x11\x00\xff\xcc\x00\x06\x00\x10\x10\x05\xff\xda\x00\x08\x01\x01\x00\x00?\x00\xd2\xcf \xff\xd9' # noqa
class Spineless(ValueError):
pass
def XPath(expr):
ans = XPath.cache.get(expr)
if ans is None:
ans = XPath.cache[expr] = _XPath(expr)
return ans
XPath.cache = {}
def encode_url(name, frag=''):
name = encode_component(name)
if frag:
name += '#' + frag
return name
def decode_url(x):
parts = x.split('#', 1)
return decode_component(parts[0]), (parts[1] if len(parts) > 1 else '')
def create_link_replacer(container, link_uid, changed):
resource_template = link_uid + '|{}|'
def link_replacer(base, url):
if url.startswith('#'):
frag = urlunquote(url[1:])
changed.add(base)
if not frag:
return link_uid
return resource_template.format(encode_url(base, frag))
try:
purl = urlparse(url)
except Exception:
return url
if purl.netloc or purl.query:
return url
if purl.scheme and purl.scheme != 'file':
return url
if not purl.path or purl.path.startswith('/'):
return url
url, frag = purl.path, purl.fragment
name = container.href_to_name(url, base)
if name:
if container.has_name_and_is_not_empty(name):
frag = urlunquote(frag)
url = resource_template.format(encode_url(name, frag))
else:
if isinstance(name, str):
name = name.encode('utf-8')
url = 'missing:' + force_unicode(quote(name), 'utf-8')
changed.add(base)
return url
return link_replacer
def check_for_maths(root):
for x in root.iterdescendants('{*}math'):
return True
for s in root.iterdescendants(XHTML('script')):
if s.get('type') == 'text/x-mathjax-config':
return True
return False
def has_ancestor(elem, q):
while elem is not None:
elem = elem.getparent()
if elem is q:
return True
return False
def anchor_map(root):
ans = []
seen = set()
for elem in root.xpath('//*[@id or @name]'):
eid = elem.get('id')
if not eid and elem.tag.endswith('}a'):
eid = elem.get('name')
if eid:
elem.set('id', eid)
if eid and eid not in seen:
ans.append(eid)
seen.add(eid)
return ans
def get_length(root):
ans = 0
for body in root.iterchildren(XHTML('body')):
ans += get_num_of_significant_chars(body)
for elem in body.iterdescendants():
ans += get_num_of_significant_chars(elem)
return ans
def toc_anchor_map(toc):
ans = defaultdict(list)
seen_map = defaultdict(set)
def process_node(node):
name = node['dest']
if name and node['id'] not in seen_map[name]:
ans[name].append({'id':node['id'], 'frag':node['frag']})
seen_map[name].add(node['id'])
for i in node['children']:
process_node(i)
process_node(toc)
return dict(ans)
def pagelist_anchor_map(page_list):
ans = defaultdict(list)
seen_map = defaultdict(set)
for i, x in enumerate(page_list):
x['id'] = i + 1
name = x['dest']
frag = x['frag']
if name and frag not in seen_map[name]:
ans[name].append({'id': x['id'], 'pagenum': x['pagenum'], 'frag':frag})
seen_map[name].add(frag)
return dict(ans)
class SimpleContainer(ContainerBase):
tweak_mode = True
def find_epub_cover(container):
cover_image = find_cover_image(container)
marked_title_page = find_cover_page(container)
cover_image_in_first_page = None
try:
first_page_name = next(container.spine_names)[0]
except StopIteration:
return None, None
if not marked_title_page:
cover_image_in_first_page = find_cover_image_in_page(container, first_page_name)
has_epub_cover = cover_image or marked_title_page or cover_image_in_first_page
if not has_epub_cover:
return None, None
if marked_title_page and cover_image:
return marked_title_page, cover_image
if marked_title_page:
if cover_image:
return marked_title_page, cover_image
cover_image = find_cover_image_in_page(container, marked_title_page)
if cover_image:
return marked_title_page, cover_image
return None, None
if cover_image_in_first_page:
return first_page_name, cover_image_in_first_page
return None, None
def create_cover_page(container, input_fmt, is_comic, book_metadata=None):
templ = '''
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en">
<head><style>
html, body, img { height: 100vh; display: block; margin: 0; padding: 0; border-width: 0; }
img {
width: 100%%; height: 100%%;
object-fit: contain;
margin-left: auto; margin-right: auto;
max-width: 100vw; max-height: 100vh;
top: 50vh; transform: translateY(-50%%);
position: relative;
}
body.cover-fill img { object-fit: fill; }
</style></head><body><img src="%s"/></body></html>
'''
def generic_cover():
if book_metadata is not None:
from calibre.ebooks.covers import create_cover
mi = book_metadata
return create_cover(mi.title, mi.authors, mi.series, mi.series_index)
return BLANK_JPEG
if input_fmt == 'epub':
titlepage_name, raster_cover_name = find_epub_cover(container)
if raster_cover_name and titlepage_name:
raw = templ % prepare_string_for_xml(container.name_to_href(raster_cover_name, titlepage_name), True)
with container.open(titlepage_name, 'wb') as f:
f.write(raw.encode('utf-8'))
else:
raster_cover_name = find_cover_image(container, strict=True)
if raster_cover_name is None:
return None, None
if is_comic:
return raster_cover_name, None
item = container.generate_item(name='titlepage.html', id_prefix='titlepage')
titlepage_name = container.href_to_name(item.get('href'), container.opf_name)
raw = templ % prepare_string_for_xml(container.name_to_href(raster_cover_name, titlepage_name), True)
with container.open(titlepage_name, 'wb') as f:
f.write(raw.encode('utf-8'))
spine = container.opf_xpath('//opf:spine')[0]
ref = spine.makeelement(OPF('itemref'), idref=item.get('id'))
container.insert_into_xml(spine, ref, index=0)
return raster_cover_name, titlepage_name
def transform_style_sheet(container, name, link_uid, virtualize_resources, virtualized_names):
changed = False
link_replacer = None
if virtualize_resources:
changed_names = set()
link_replacer = partial(create_link_replacer(container, link_uid, changed_names), name)
raw = container.raw_data(name, decode=True)
nraw = transform_properties(raw, is_declaration=False, url_callback=link_replacer)
if virtualize_resources:
if name in changed_names:
changed = True
virtualized_names.add(name)
if nraw != raw:
changed = True
raw = nraw
raw = raw.lstrip()
if not raw.startswith('@charset'):
raw = '@charset "UTF-8";\n' + raw
changed = True
if changed:
with container.open(name, 'wb') as f:
f.write(raw.encode('utf-8'))
def transform_svg_image(container, name, link_uid, virtualize_resources, virtualized_names):
if not virtualize_resources:
return
link_replacer = create_link_replacer(container, link_uid, set())
xlink = XLINK('href')
altered = False
xlink_xpath = XPath('//*[@xl:href]')
for elem in xlink_xpath(container.parsed(name)):
href = elem.get(xlink)
if not href.startswith('#'):
elem.set(xlink, link_replacer(name, href))
altered = True
if altered:
virtualized_names.add(name)
container.dirty(name)
container.commit_item(name)
def parse_smil_time(x):
# https://www.w3.org/TR/SMIL3/smil-timing.html#q22
parts = x.split(':')
seconds = 0
if len(parts) == 3:
hours, minutes, seconds = int(parts[0]), int(parts[1]), float(parts[2])
seconds = abs(hours) * 3600 + max(0, min(abs(minutes), 59)) * 60 + max(0, min(abs(seconds), 59))
elif len(parts) == 2:
minutes, seconds = int(parts[0]), float(parts[1])
seconds = max(0, min(abs(minutes), 59)) * 60 + max(0, min(abs(seconds), 59))
elif len(parts) == 1:
if x.endswith('s'):
seconds = float(x[:-1])
elif x.endswith('ms'):
seconds = float(x[:-2]) * 0.001
elif x.endswith('min'):
seconds = float(x[:-3]) * 60
elif x.endswith('h'):
seconds = float(x[:-1]) * 3600
else:
raise ValueError(f'Malformed SMIL time: {x}')
else:
raise ValueError(f'Malformed SMIL time: {x}')
return seconds
def transform_smil(container, name, link_uid, virtualize_resources, virtualized_names, smil_map):
root = container.parsed(name)
text_tag, audio_tag = SMIL('text'), SMIL('audio')
body_tag, seq_tag, par_tag = SMIL('body'), SMIL('seq'), SMIL('par')
type_attr, textref_attr = EPUB('type'), EPUB('textref')
parnum = 0
def make_par(par, target):
nonlocal parnum
parnum += 1
ans = {'num': parnum}
t = par.get(type_attr)
if t:
ans['type'] = t
for child in par.iterchildren('*'):
if child.tag == text_tag:
src = child.get('src')
if src:
q = container.href_to_name(src, name)
if q != target:
return {} # the par must match the textref of the parent seq
ans['anchor'] = src.partition('#')[2]
elif child.tag == audio_tag:
src = child.get('src')
if src:
ans['audio'] = container.href_to_name(src, name)
b, e = child.get('clipBegin'), child.get('clipEnd')
if b:
ans['start'] = parse_smil_time(b)
if e:
ans['end'] = parse_smil_time(e)
return ans
def process_seq(seq_xml_element, tref, parent_seq=None):
target = container.href_to_name(tref, name)
seq = {'textref': [target, tref.partition('#')[2]], 'par': [], 'seq': []}
t = seq_xml_element.get(type_attr)
if t:
seq['type'] = t
if parent_seq is None:
parent_seq = smil_map.get(target)
if parent_seq is None:
smil_map[target] = parent_seq = {'textref': [target, ''], 'par':[], 'seq':[], 'type': 'root'}
else:
if parent_seq['textref'][0] != target:
return # child seqs must be in the same HTML file as parent
parent_seq['seq'].append(seq)
for child in seq_xml_element.iterchildren('*'):
if child.tag == par_tag:
p = make_par(child, target)
if p.get('audio'):
seq['par'].append(p)
elif child.tag == seq_tag:
tref = child.get(textref_attr)
if tref:
process_seq(child, tref, seq)
if not seq['par']:
del seq['par']
if not seq['seq']:
del seq['seq']
for child in root.iterchildren('*'):
if child.tag == body_tag:
tref = child.get(textref_attr)
if tref:
process_seq(child, tref)
else:
for gc in child.iterchildren('*'):
if gc.tag == seq_tag:
tref = gc.get(textref_attr)
if tref:
process_seq(gc, tref)
def transform_inline_styles(container, name, transform_sheet, transform_style):
root = container.parsed(name)
changed = False
for style in root.xpath('//*[local-name()="style"]'):
if style.text and (style.get('type') or 'text/css').lower() == 'text/css':
nraw = transform_sheet(style.text)
if nraw != style.text:
changed = True
style.text = nraw
for elem in root.xpath('//*[@style]'):
text = elem.get('style', None)
if text:
ntext = transform_style(text)
if ntext != text:
changed = True
elem.set('style', ntext)
return changed
def transform_html(container, name, virtualize_resources, link_uid, link_to_map, virtualized_names):
link_xpath = XPath('//h:*[@href and (self::h:a or self::h:area)]')
svg_link_xpath = XPath('//svg:a')
img_xpath = XPath('//h:img[@src]')
svg_img_xpath = XPath('//svg:image[@xl:href]')
res_link_xpath = XPath('//h:link[@href]')
root = container.parsed(name)
changed_names = set()
link_replacer = create_link_replacer(container, link_uid, changed_names)
# Used for viewing images
for img in img_xpath(root):
img_name = container.href_to_name(img.get('src'), name)
if img_name:
img.set('data-calibre-src', img_name)
for img in svg_img_xpath(root):
img_name = container.href_to_name(img.get(XLINK('href')), name)
if img_name:
img.set('data-calibre-src', img_name)
# Disable non-stylesheet link tags. This link will not be loaded by the
# browser anyway and will causes the resource load check to hang
for link in res_link_xpath(root):
ltype = (link.get('type') or 'text/css').lower()
rel = (link.get('rel') or 'stylesheet').lower()
if ltype != 'text/css' or rel != 'stylesheet':
link.attrib.clear()
# URLs in the inline CSS will be replaced in virtualize_html
def transform_sheet(sheet_text):
ans = transform_properties(sheet_text, is_declaration=False)
if name in changed_names:
virtualized_names.add(name)
return ans
def transform_declaration(decl_text):
ans = transform_properties(decl_text, is_declaration=True)
if name in changed_names:
virtualized_names.add(name)
return ans
# Transform <style> and style=""
transform_inline_styles(container, name, transform_sheet=transform_sheet, transform_style=transform_declaration)
if virtualize_resources:
virtualize_html(container, name, link_uid, link_to_map, virtualized_names)
else:
def handle_link(a, attr='href'):
href = a.get(attr)
if href:
href = link_replacer(name, href)
elif attr in a.attrib:
a.set(attr, 'javascript:void(0)')
if href and href.startswith(link_uid):
a.set(attr, 'javascript:void(0)')
parts = href.split('|')
if len(parts) > 1:
parts = decode_url(parts[1])
lname, lfrag = parts[0], parts[1]
link_to_map.setdefault(lname, {}).setdefault(lfrag or '', set()).add(name)
a.set('data-' + link_uid, json.dumps({'name':lname, 'frag':lfrag}, ensure_ascii=False))
for a in link_xpath(root):
handle_link(a)
xhref = XLINK('href')
for a in svg_link_xpath(root):
handle_link(a, xhref)
shtml = html_as_json(root)
with container.open(name, 'wb') as f:
f.write(shtml)
def virtualize_html(container, name, link_uid, link_to_map, virtualized_names):
changed = set()
link_xpath = XPath('//h:*[@href and (self::h:a or self::h:area)]')
svg_link_xpath = XPath('//svg:a')
link_replacer = create_link_replacer(container, link_uid, changed)
virtualized_names.add(name)
root = container.parsed(name)
rewrite_links(root, partial(link_replacer, name))
def handle_link(a, attr='href'):
href = a.get(attr) or ''
if href.startswith(link_uid):
a.set(attr, 'javascript:void(0)')
try:
parts = decode_url(href.split('|')[1])
except IndexError:
pass
else:
lname, lfrag = parts[0], parts[1]
link_to_map.setdefault(lname, {}).setdefault(lfrag or '', set()).add(name)
a.set('data-' + link_uid, json.dumps({'name':lname, 'frag':lfrag}, ensure_ascii=False))
elif href:
a.set('target', '_blank')
a.set('rel', 'noopener noreferrer')
elif attr in a.attrib:
a.set(attr, 'javascript:void(0)')
for a in link_xpath(root):
handle_link(a)
xhref = XLINK('href')
for a in svg_link_xpath(root):
handle_link(a, xhref)
return name in changed
__smil_file_names__ = ''
def process_book_files(names, container_dir, opfpath, virtualize_resources, link_uid, data_for_clone=None, container=None):
if container is None:
container = SimpleContainer(container_dir, opfpath, default_log, clone_data=data_for_clone)
container.cloned = False
link_to_map = {}
html_data = {}
smil_map = {__smil_file_names__: []}
virtualized_names = set()
for name in names:
if name is None:
continue
mt = container.mime_map[name].lower()
if mt in OEB_DOCS:
root = container.parsed(name)
html_data[name] = {
'length': get_length(root),
'has_maths': check_for_maths(root),
'anchor_map': anchor_map(root)
}
transform_html(container, name, virtualize_resources, link_uid, link_to_map, virtualized_names)
elif mt in OEB_STYLES:
transform_style_sheet(container, name, link_uid, virtualize_resources, virtualized_names)
elif mt == 'image/svg+xml':
transform_svg_image(container, name, link_uid, virtualize_resources, virtualized_names)
elif mt in ('application/smil', 'application/smil+xml'):
smil_map[__smil_file_names__].append(name)
transform_smil(container, name, link_uid, virtualize_resources, virtualized_names, smil_map)
return link_to_map, html_data, virtualized_names, smil_map
def calculate_number_of_workers(names, in_process_container, max_workers):
num_workers = min(detect_ncpus(), len(names))
if max_workers:
num_workers = min(num_workers, max_workers)
if num_workers > 1:
if len(names) < 3 or sum(os.path.getsize(in_process_container.name_path_map[n]) for n in names) < 128 * 1024:
num_workers = 1
return num_workers
def process_exploded_book(
book_fmt, opfpath, input_fmt, tdir, log=None, book_hash=None, save_bookmark_data=False,
book_metadata=None, virtualize_resources=True, max_workers=1
):
log = log or default_log
container = SimpleContainer(tdir, opfpath, log)
input_plugin = plugin_for_input_format(input_fmt)
is_comic = bool(getattr(input_plugin, 'is_image_collection', False))
def needs_work(mt):
return mt in OEB_STYLES or mt in OEB_DOCS or mt in ('image/svg+xml', 'application/smil', 'application/smil+xml')
bookmark_data = None
if save_bookmark_data:
bm_file = 'META-INF/calibre_bookmarks.txt'
if container.exists(bm_file):
with container.open(bm_file, 'rb') as f:
bookmark_data = f.read()
# We do not add zero byte sized files as the IndexedDB API in the
# browser has no good way to distinguish between zero byte files and
# load failures.
excluded_names = {
name for name, mt in container.mime_map.items() if
name == container.opf_name or mt == guess_type('a.ncx') or name.startswith('META-INF/') or
name == 'mimetype' or not container.has_name_and_is_not_empty(name)}
raster_cover_name, titlepage_name = create_cover_page(container, input_fmt.lower(), is_comic, book_metadata)
tocobj = get_toc(container, verify_destinations=False)
page_list = tocobj.page_list or []
toc = tocobj.to_dict(count())
if not toc or not toc.get('children'):
toc = from_xpaths(container, ['//h:h1', '//h:h2', '//h:h3']).to_dict(count())
spine = [name for name, is_linear in container.spine_names]
spineq = frozenset(spine)
landmarks = [l for l in get_landmarks(container) if l['dest'] in spineq]
if not spineq:
raise Spineless('Book is empty, no content in spine')
page_progression_direction = None
try:
page_progression_direction = container.opf_xpath('//opf:spine/@page-progression-direction')[0]
except IndexError:
pass
book_render_data = {
'version': RENDER_VERSION,
'toc':toc,
'book_format': book_fmt,
'spine':spine,
'link_uid': uuid4(),
'book_hash': book_hash,
'is_comic': is_comic,
'raster_cover_name': raster_cover_name,
'title_page_name': titlepage_name,
'has_maths': False,
'total_length': 0,
'spine_length': 0,
'toc_anchor_map': toc_anchor_map(toc),
'landmarks': landmarks,
'link_to_map': {},
'page_progression_direction': page_progression_direction,
'page_list': page_list,
'page_list_anchor_map': pagelist_anchor_map(page_list),
}
names_that_need_work = tuple(n for n, mt in container.mime_map.items() if needs_work(mt))
num_workers = calculate_number_of_workers(names_that_need_work, container, max_workers)
results = []
if num_workers < 2:
results.append(process_book_files(names_that_need_work, tdir, opfpath, virtualize_resources, book_render_data['link_uid'], container=container))
else:
with ThreadPoolExecutor(max_workers=num_workers) as executor:
futures = tuple(
executor.submit(process_book_files, (name,), tdir, opfpath, virtualize_resources, book_render_data['link_uid'], container=container)
for name in names_that_need_work)
for future in futures:
results.append(future.result())
ltm = book_render_data['link_to_map']
html_data = {}
virtualized_names = set()
def merge_ltm(dest, src):
for k, v in src.items():
if k in dest:
dest[k] |= v
else:
dest[k] = v
final_smil_map = {}
def merge_smil_map(smil_map):
for n in smil_map.pop(__smil_file_names__):
excluded_names.add(n)
for n, d in smil_map.items():
if d:
# This assumes all smil data for a spine item is in a single
# smil file, which is required per the spec
final_smil_map[n] = d
for link_to_map, hdata, vnames, smil_map in results:
html_data.update(hdata)
virtualized_names |= vnames
merge_smil_map(smil_map)
for k, v in link_to_map.items():
if k in ltm:
merge_ltm(ltm[k], v)
else:
ltm[k] = v
book_render_data['has_smil'] = bool(final_smil_map)
def manifest_data(name):
mt = (container.mime_map.get(name) or 'application/octet-stream').lower()
ans = {
'size':os.path.getsize(container.name_path_map[name]),
'is_virtualized': name in virtualized_names,
'mimetype':mt,
'is_html': mt in OEB_DOCS,
}
if ans['is_html']:
data = html_data[name]
ans['length'] = l = data['length']
book_render_data['total_length'] += l
if name in book_render_data['spine']:
book_render_data['spine_length'] += l
ans['has_maths'] = hm = data['has_maths']
if hm:
book_render_data['has_maths'] = True
ans['anchor_map'] = data['anchor_map']
smil_map = final_smil_map.get(name)
if smil_map:
ans['smil_map'] = smil_map
return ans
book_render_data['files'] = {name:manifest_data(name) for name in set(container.name_path_map) - excluded_names}
container.commit()
for name in excluded_names:
os.remove(container.name_path_map[name])
ltm = book_render_data['link_to_map']
for name, amap in ltm.items():
for k, v in tuple(amap.items()):
amap[k] = tuple(v) # needed for JSON serialization
data = as_bytes(json.dumps(book_render_data, ensure_ascii=False))
with open(os.path.join(container.root, 'calibre-book-manifest.json'), 'wb') as f:
f.write(data)
return container, bookmark_data
def split_name(name):
l, r = name.partition('}')[::2]
if r:
return l[1:], r
return None, l
known_tags = ('img', 'script', 'link', 'image', 'style')
discarded_tags = ('meta', 'base')
def ensure_body(root):
# Make sure we have only a single <body>
bodies = list(root.iterchildren(XHTML('body')))
if len(bodies) != 1:
if not bodies:
root.append(root.makeelement(XHTML('body')))
return
body = bodies[0]
for b in bodies[1:]:
div = root.makeelement(XHTML('div'))
div.attrib.update(b.attrib)
div.text = b.text
for child in b:
div.append(child)
body.append(div)
def html_as_json(root):
from calibre_extensions.html_as_json import serialize
ns, name = split_name(root.tag)
if ns not in (None, XHTML_NS):
raise ValueError('HTML tag must be in empty or XHTML namespace')
ensure_body(root)
for child in tuple(root.iterchildren('*')):
if child.tag.partition('}')[-1] not in ('head', 'body'):
root.remove(child)
root.text = root.tail = None
return serialize(root, Comment)
def serialize_datetimes(d):
for k in tuple(d):
v = d[k]
if isinstance(v, datetime):
v = encode_datetime(v)
d[k] = v
EPUB_FILE_TYPE_MAGIC = b'encoding=json+base64:\n'
def get_stored_annotations(container, bookmark_data):
raw = bookmark_data or b''
if not raw:
return
if raw.startswith(EPUB_FILE_TYPE_MAGIC):
raw = raw[len(EPUB_FILE_TYPE_MAGIC):].replace(b'\n', b'')
yield from json_loads(from_base64_bytes(raw))
return
from calibre.ebooks.oeb.iterator.bookmarks import parse_bookmarks
for bm in parse_bookmarks(raw):
if bm['type'] == 'cfi' and isinstance(bm['pos'], str):
spine_index = (1 + bm['spine']) * 2
epubcfi = 'epubcfi(/{}/{})'.format(spine_index, bm['pos'].lstrip('/'))
title = bm.get('title')
if title and title != 'calibre_current_page_bookmark':
yield {'type': 'bookmark', 'title': title, 'pos': epubcfi, 'pos_type': 'epubcfi', 'timestamp': EPOCH}
else:
yield {'type': 'last-read', 'pos': epubcfi, 'pos_type': 'epubcfi', 'timestamp': EPOCH}
def render(pathtoebook, output_dir, book_hash=None, serialize_metadata=False, extract_annotations=False, virtualize_resources=True, max_workers=0):
pathtoebook = os.path.abspath(pathtoebook)
mi = None
if serialize_metadata:
from calibre.customize.ui import quick_metadata
from calibre.ebooks.metadata.meta import get_metadata
with open(pathtoebook, 'rb') as f, quick_metadata:
mi = get_metadata(f, os.path.splitext(pathtoebook)[1][1:].lower())
book_fmt, opfpath, input_fmt = extract_book(pathtoebook, output_dir, log=default_log)
container, bookmark_data = process_exploded_book(
book_fmt, opfpath, input_fmt, output_dir, max_workers=max_workers,
book_hash=book_hash, save_bookmark_data=extract_annotations,
book_metadata=mi, virtualize_resources=virtualize_resources
)
if serialize_metadata:
from calibre.ebooks.metadata.book.serialize import metadata_as_dict
d = metadata_as_dict(mi)
d.pop('cover_data', None)
serialize_datetimes(d), serialize_datetimes(d.get('user_metadata', {}))
with open(os.path.join(output_dir, 'calibre-book-metadata.json'), 'wb') as f:
f.write(json_dumps(d))
if extract_annotations:
annotations = None
if bookmark_data:
annotations = json_dumps(tuple(get_stored_annotations(container, bookmark_data)))
if annotations:
with open(os.path.join(output_dir, 'calibre-book-annotations.json'), 'wb') as f:
f.write(annotations)
def render_for_viewer(path, out_dir, book_hash):
return render(
path, out_dir, book_hash=book_hash, serialize_metadata=True,
extract_annotations=True, virtualize_resources=False
)
def viewer_main():
stdin = getattr(sys.stdin, 'buffer', sys.stdin)
args = msgpack_loads(stdin.read())
render_for_viewer(*args)
class Profiler:
def __init__(self):
try:
import cProfile as profile
except ImportError:
import profile
self.profile = profile.Profile()
def __enter__(self):
self.profile.enable()
def __exit__(self, *a):
self.profile.disable()
self.profile.create_stats()
import pstats
stats = pstats.Stats(self.profile)
stats.sort_stats('cumulative')
stats.print_stats(.05)
def profile():
from calibre.ptempfile import TemporaryDirectory
path = sys.argv[-1]
with TemporaryDirectory() as tdir, Profiler():
return render(
path, tdir, serialize_metadata=True,
extract_annotations=True, virtualize_resources=False, max_workers=1
)
def develop():
from calibre.ptempfile import TemporaryDirectory
path = sys.argv[-1]
with TemporaryDirectory() as tdir:
render(
path, tdir, serialize_metadata=True,
extract_annotations=True, virtualize_resources=True, max_workers=1
)
print('Extracted to:', tdir)
input('Press Enter to quit')
if __name__ == '__main__':
develop()
| 32,525 | Python | .py | 755 | 34.287417 | 417 | 0.611584 | kovidgoyal/calibre | 19,243 | 2,250 | 4 | GPL-3.0 | 9/5/2024, 5:13:50 PM (Europe/Amsterdam) |
26,602 | routes.py | kovidgoyal_calibre/src/calibre/srv/routes.py | #!/usr/bin/env python
__license__ = 'GPL v3'
__copyright__ = '2015, Kovid Goyal <kovid at kovidgoyal.net>'
import inspect
import json as jsonlib
import numbers
import re
import sys
import textwrap
import time
from operator import attrgetter
from calibre.srv.errors import HTTPNotFound, HTTPSimpleResponse, RouteError
from calibre.srv.utils import http_date
from calibre.utils.serialize import MSGPACK_MIME, json_dumps, msgpack_dumps
from polyglot import http_client
from polyglot.builtins import iteritems, itervalues
from polyglot.urllib import quote as urlquote
default_methods = frozenset(('HEAD', 'GET'))
def json(ctx, rd, endpoint, output):
rd.outheaders.set('Content-Type', 'application/json; charset=UTF-8', replace_all=True)
if isinstance(output, bytes) or hasattr(output, 'fileno'):
ans = output # Assume output is already UTF-8 encoded json
else:
ans = json_dumps(output)
return ans
def msgpack(ctx, rd, endpoint, output):
rd.outheaders.set('Content-Type', MSGPACK_MIME, replace_all=True)
if isinstance(output, bytes) or hasattr(output, 'fileno'):
ans = output # Assume output is already msgpack encoded
else:
ans = msgpack_dumps(output)
return ans
def msgpack_or_json(ctx, rd, endpoint, output):
accept = rd.inheaders.get('Accept', all=True)
func = msgpack if MSGPACK_MIME in accept else json
return func(ctx, rd, endpoint, output)
json.loads, json.dumps = jsonlib.loads, jsonlib.dumps
def route_key(route):
return route.partition('{')[0].rstrip('/')
def endpoint(route,
methods=default_methods,
types=None,
auth_required=True,
android_workaround=False,
# Manage the HTTP caching
# Set to None or 'no-cache' to prevent caching of this endpoint
# Set to a number to cache for at most number hours
# Set to a tuple (cache_type, max_age) to explicitly set the
# Cache-Control header
cache_control=False,
# The HTTP code to be used when no error occurs. By default it is
# 200 for GET and HEAD and 201 for POST
ok_code=None,
postprocess=None,
# Needs write access to the calibre database
needs_db_write=False
):
from calibre.srv.handler import Context
from calibre.srv.http_response import RequestData
def annotate(f):
f.route = route.rstrip('/') or '/'
f.route_key = route_key(f.route)
f.types = types or {}
f.methods = methods
f.auth_required = auth_required
f.android_workaround = android_workaround
f.cache_control = cache_control
f.postprocess = postprocess
f.ok_code = ok_code
f.is_endpoint = True
f.needs_db_write = needs_db_write
argspec = inspect.getfullargspec(f)
if len(argspec.args) < 2:
raise TypeError('The endpoint %r must take at least two arguments' % f.route)
f.__annotations__ = {
argspec.args[0]: Context,
argspec.args[1]: RequestData,
}
f.__doc__ = textwrap.dedent(f.__doc__ or '') + '\n\n' + (
(':type %s: calibre.srv.handler.Context\n' % argspec.args[0]) +
(':type %s: calibre.srv.http_response.RequestData\n' % argspec.args[1])
)
return f
return annotate
class Route:
var_pat = None
def __init__(self, endpoint_):
if self.var_pat is None:
Route.var_pat = self.var_pat = re.compile(r'{(.+?)}')
self.endpoint = endpoint_
del endpoint_
if not self.endpoint.route.startswith('/'):
raise RouteError('A route must start with /, %s does not' % self.endpoint.route)
parts = list(filter(None, self.endpoint.route.split('/')))
matchers = self.matchers = []
self.defaults = {}
found_optional_part = False
self.soak_up_extra = False
self.type_checkers = self.endpoint.types.copy()
def route_error(msg):
return RouteError(f'{self.endpoint.route} is not valid: {msg}')
for i, p in enumerate(parts):
if p[0] == '{':
if p[-1] != '}':
raise route_error('Invalid route, variable components must be in a {}')
name = p[1:-1]
is_sponge = name.startswith('+')
if is_sponge:
if p is not parts[-1]:
raise route_error('Can only specify + in the last component')
name = name[1:]
if '=' in name:
found_optional_part = i
name, default = name.partition('=')[::2]
if '{' in default or '}' in default:
raise route_error('The characters {} are not allowed in default values')
default = self.defaults[name] = eval(default)
if isinstance(default, numbers.Number):
self.type_checkers[name] = type(default)
if is_sponge and not isinstance(default, str):
raise route_error('Soak up path component must have a default value of string type')
else:
if found_optional_part is not False:
raise route_error('Cannot have non-optional path components after optional ones')
if is_sponge:
self.soak_up_extra = name
matchers.append((name, True))
else:
if found_optional_part is not False:
raise route_error('Cannot have non-optional path components after optional ones')
matchers.append((None, p.__eq__))
self.names = [n for n, m in matchers if n is not None]
self.all_names = frozenset(self.names)
self.required_names = self.all_names - frozenset(self.defaults)
argspec = inspect.getfullargspec(self.endpoint)
if len(self.names) + 2 != len(argspec.args) - len(argspec.defaults or ()):
raise route_error('Function must take %d non-default arguments' % (len(self.names) + 2))
if argspec.args[2:len(self.names)+2] != self.names:
raise route_error('Function\'s argument names do not match the variable names in the route')
if not frozenset(self.type_checkers).issubset(frozenset(self.names)):
raise route_error('There exist type checkers that do not correspond to route variables: %r' % (set(self.type_checkers) - set(self.names)))
self.min_size = found_optional_part if found_optional_part is not False else len(matchers)
self.max_size = sys.maxsize if self.soak_up_extra else len(matchers)
def matches(self, path):
args_map = self.defaults.copy()
num = 0
for component, (name, matched) in zip(path, self.matchers):
num += 1
if matched is True:
args_map[name] = component
elif not matched(component):
return False
if self.soak_up_extra and num < len(path):
args_map[self.soak_up_extra] += '/' + '/'.join(path[num:])
num = len(path)
if num < len(path):
return False
def check(tc, val):
try:
return tc(val)
except Exception:
raise HTTPNotFound('Argument of incorrect type')
for name, tc in iteritems(self.type_checkers):
args_map[name] = check(tc, args_map[name])
return (args_map[name] for name in self.names)
def url_for(self, **kwargs):
names = frozenset(kwargs)
not_spec = self.required_names - names
if not_spec:
raise RouteError('The required variable(s) {} were not specified for the route: {}'.format(','.join(not_spec), self.endpoint.route))
unknown = names - self.all_names
if unknown:
raise RouteError('The variable(s) {} are not part of the route: {}'.format(','.join(unknown), self.endpoint.route))
def quoted(x):
if not isinstance(x, (str, bytes)):
x = str(x)
if isinstance(x, str):
x = x.encode('utf-8')
return urlquote(x, '')
args = {k:'' for k in self.defaults}
args.update(kwargs)
args = {k:quoted(v) for k, v in iteritems(args)}
route = self.var_pat.sub(lambda m:'{%s}' % m.group(1).partition('=')[0].lstrip('+'), self.endpoint.route)
return route.format(**args).rstrip('/')
def __str__(self):
return self.endpoint.route
__unicode__ = __repr__ = __str__
class Router:
def __init__(self, endpoints=None, ctx=None, url_prefix=None, auth_controller=None):
self.routes = {}
self.url_prefix = (url_prefix or '').rstrip('/')
self.strip_path = None
if self.url_prefix:
if not self.url_prefix.startswith('/'):
self.url_prefix = '/' + self.url_prefix
self.strip_path = tuple(self.url_prefix[1:].split('/'))
self.ctx = ctx
self.auth_controller = auth_controller
self.init_session = getattr(ctx, 'init_session', lambda ep, data:None)
self.finalize_session = getattr(ctx, 'finalize_session', lambda ep, data, output:None)
self.endpoints = set()
if endpoints is not None:
self.load_routes(endpoints)
self.finalize()
def add(self, endpoint):
if endpoint in self.endpoints:
return
key = endpoint.route_key
if key in self.routes:
raise RouteError(f'A route with the key: {key} already exists as: {self.routes[key]}')
self.routes[key] = Route(endpoint)
self.endpoints.add(endpoint)
def load_routes(self, items):
for item in items:
if getattr(item, 'is_endpoint', False) is True:
self.add(item)
def __iter__(self):
return itervalues(self.routes)
def finalize(self):
try:
lsz = max(len(r.matchers) for r in self)
except ValueError:
lsz = 0
self.min_size_map = {sz:frozenset(r for r in self if r.min_size <= sz) for sz in range(lsz + 1)}
self.max_size_map = {sz:frozenset(r for r in self if r.max_size >= sz) for sz in range(lsz + 1)}
self.soak_routes = sorted(frozenset(r for r in self if r.soak_up_extra), key=attrgetter('min_size'), reverse=True)
def find_route(self, path):
if self.strip_path is not None and path[:len(self.strip_path)] == self.strip_path:
path = path[len(self.strip_path):]
size = len(path)
# routes for which min_size <= size <= max_size
routes = self.max_size_map.get(size, set()) & self.min_size_map.get(size, set())
for route in sorted(routes, key=attrgetter('max_size'), reverse=True):
args = route.matches(path)
if args is not False:
return route.endpoint, args
for route in self.soak_routes:
if route.min_size <= size:
args = route.matches(path)
if args is not False:
return route.endpoint, args
raise HTTPNotFound()
def read_cookies(self, data):
data.cookies = c = {}
for cval in data.inheaders.get('Cookie', all=True):
if isinstance(cval, bytes):
cval = cval.decode('utf-8', 'replace')
for x in cval.split(';'):
x = x.strip()
if x:
k, v = x.partition('=')[::2]
if k:
# Since we only set simple hex encoded cookies, we dont
# need more sophisticated value parsing
c[k] = v.strip('"')
def dispatch(self, data):
endpoint_, args = self.find_route(data.path)
if data.method not in endpoint_.methods:
raise HTTPSimpleResponse(http_client.METHOD_NOT_ALLOWED)
self.read_cookies(data)
if endpoint_.auth_required and self.auth_controller is not None:
self.auth_controller(data, endpoint_)
if endpoint_.ok_code is not None:
data.status_code = endpoint_.ok_code
self.init_session(endpoint_, data)
if endpoint_.needs_db_write:
self.ctx.check_for_write_access(data)
ans = endpoint_(self.ctx, data, *args)
self.finalize_session(endpoint_, data, ans)
outheaders = data.outheaders
pp = endpoint_.postprocess
if pp is not None:
ans = pp(self.ctx, data, endpoint_, ans)
cc = endpoint_.cache_control
if cc is not False and 'Cache-Control' not in data.outheaders:
if cc is None or cc == 'no-cache':
outheaders['Expires'] = http_date(10000.0) # A date in the past
outheaders['Cache-Control'] = 'no-cache, must-revalidate'
outheaders['Pragma'] = 'no-cache'
elif isinstance(cc, numbers.Number):
cc = int(60 * 60 * cc)
outheaders['Cache-Control'] = 'public, max-age=%d' % cc
if cc == 0:
cc -= 100000
outheaders['Expires'] = http_date(cc + time.time())
else:
ctype, max_age = cc
max_age = int(60 * 60 * max_age)
outheaders['Cache-Control'] = '%s, max-age=%d' % (ctype, max_age)
if max_age == 0:
max_age -= 100000
outheaders['Expires'] = http_date(max_age + time.time())
return ans
def url_for(self, route, **kwargs):
if route is None:
return self.url_prefix or '/'
route = getattr(route, 'route_key', route)
return self.url_prefix + self.routes[route].url_for(**kwargs)
| 13,957 | Python | .py | 298 | 35.765101 | 150 | 0.582464 | kovidgoyal/calibre | 19,243 | 2,250 | 4 | GPL-3.0 | 9/5/2024, 5:13:50 PM (Europe/Amsterdam) |
26,603 | auto_reload.py | kovidgoyal_calibre/src/calibre/srv/auto_reload.py | #!/usr/bin/env python
__license__ = 'GPL v3'
__copyright__ = '2015, Kovid Goyal <kovid at kovidgoyal.net>'
import errno
import os
import signal
import socket
import ssl
import subprocess
import sys
import time
from threading import Lock, Thread
from calibre.constants import islinux, ismacos, iswindows
from calibre.srv.http_response import create_http_handler
from calibre.srv.loop import ServerLoop
from calibre.srv.opts import Options
from calibre.srv.standalone import create_option_parser
from calibre.srv.utils import create_sock_pair
from calibre.srv.web_socket import DummyHandler
from calibre.utils.monotonic import monotonic
from polyglot.builtins import error_message, itervalues, native_string_type
from polyglot.queue import Empty, Queue
MAX_RETRIES = 10
class NoAutoReload(EnvironmentError):
pass
# Filesystem watcher {{{
class WatcherBase:
EXTENSIONS_TO_WATCH = frozenset('py pyj svg'.split())
BOUNCE_INTERVAL = 2 # seconds
def __init__(self, worker, log):
self.worker, self.log = worker, log
fpath = os.path.abspath(__file__)
d = os.path.dirname
self.base = d(d(d(d(fpath))))
self.last_restart_time = monotonic()
def handle_modified(self, modified):
if modified:
if monotonic() - self.last_restart_time > self.BOUNCE_INTERVAL:
modified = {os.path.relpath(x, self.base) if x.startswith(self.base) else x for x in modified if x}
changed = os.pathsep.join(sorted(modified))
self.log('')
self.log.warn('Restarting server because of changed files:', changed)
self.log('')
self.worker.restart()
self.last_restart_time = monotonic()
def force_restart(self):
self.worker.restart(forced=True)
self.last_restart_time = monotonic()
def file_is_watched(self, fname):
return fname and fname.rpartition('.')[-1] in self.EXTENSIONS_TO_WATCH
if islinux:
import select
from calibre.utils.inotify import INotifyTreeWatcher
class Watcher(WatcherBase):
def __init__(self, root_dirs, worker, log):
WatcherBase.__init__(self, worker, log)
self.client_sock, self.srv_sock = create_sock_pair()
self.fd_map = {}
for d in frozenset(root_dirs):
w = INotifyTreeWatcher(d, self.ignore_event)
self.fd_map[w._inotify_fd] = w
def loop(self):
while True:
r = select.select([self.srv_sock] + list(self.fd_map), [], [])[0]
modified = set()
for fd in r:
if fd is self.srv_sock:
self.srv_sock.recv(1000)
self.force_restart()
continue
w = self.fd_map[fd]
modified |= w()
self.handle_modified(modified)
def ignore_event(self, path, name):
return not self.file_is_watched(name)
def wakeup(self):
self.client_sock.sendall(b'w')
elif iswindows:
from calibre.srv.utils import HandleInterrupt
from calibre_extensions import winutil
class TreeWatcher(Thread):
def __init__(self, path_to_watch, modified_queue):
Thread.__init__(self, name='TreeWatcher', daemon=True)
self.modified_queue = modified_queue
self.path_to_watch = path_to_watch
def run(self):
dir_handle = winutil.create_file(
self.path_to_watch,
winutil.FILE_LIST_DIRECTORY,
winutil.FILE_SHARE_READ,
winutil.OPEN_EXISTING,
winutil.FILE_FLAG_BACKUP_SEMANTICS,
)
try:
buffer = b'0' * 8192
while True:
try:
results = winutil.read_directory_changes(
dir_handle, buffer,
True, # Watch sub-directories as well
winutil.FILE_NOTIFY_CHANGE_FILE_NAME |
winutil.FILE_NOTIFY_CHANGE_DIR_NAME |
winutil.FILE_NOTIFY_CHANGE_ATTRIBUTES |
winutil.FILE_NOTIFY_CHANGE_SIZE |
winutil.FILE_NOTIFY_CHANGE_LAST_WRITE |
winutil.FILE_NOTIFY_CHANGE_SECURITY,
)
for action, filename in results:
if self.file_is_watched(filename):
self.modified_queue.put(os.path.join(self.path_to_watch, filename))
except OverflowError:
pass # the buffer overflowed, there are unknown changes
except Exception:
import traceback
traceback.print_exc()
class Watcher(WatcherBase):
def __init__(self, root_dirs, worker, log):
WatcherBase.__init__(self, worker, log)
self.watchers = []
self.modified_queue = Queue()
for d in frozenset(root_dirs):
self.watchers.append(TreeWatcher(d, self.modified_queue))
def wakeup(self):
self.modified_queue.put(True)
def loop(self):
for w in self.watchers:
w.start()
with HandleInterrupt(lambda : self.modified_queue.put(None)):
while True:
path = self.modified_queue.get()
if path is None:
break
if path is True:
self.force_restart()
else:
self.handle_modified({path})
elif ismacos:
from fsevents import Observer, Stream
class Watcher(WatcherBase):
def __init__(self, root_dirs, worker, log):
WatcherBase.__init__(self, worker, log)
self.stream = Stream(self.notify, *(x.encode('utf-8') for x in root_dirs), file_events=True)
self.wait_queue = Queue()
def wakeup(self):
self.wait_queue.put(True)
def loop(self):
observer = Observer()
observer.schedule(self.stream)
observer.daemon = True
observer.start()
try:
while True:
try:
# Cannot use blocking get() as it is not interrupted by
# Ctrl-C
if self.wait_queue.get(10000) is True:
self.force_restart()
except Empty:
pass
finally:
observer.unschedule(self.stream)
observer.stop()
def notify(self, ev):
name = ev.name
if isinstance(name, bytes):
name = name.decode('utf-8')
if self.file_is_watched(name):
self.handle_modified({name})
else:
Watcher = None
def find_dirs_to_watch(fpath, dirs, add_default_dirs):
dirs = {os.path.abspath(x) for x in dirs}
def add(x):
if os.path.isdir(x):
dirs.add(x)
if add_default_dirs:
d = os.path.dirname
srv = d(fpath)
add(srv)
base = d(d(d(srv)))
add(os.path.join(base, 'resources', 'server'))
add(os.path.join(base, 'src', 'calibre', 'db'))
add(os.path.join(base, 'src', 'pyj'))
add(os.path.join(base, 'imgsrc', 'srv'))
return dirs
# }}}
def join_process(p, timeout=5):
t = Thread(target=p.wait, name='JoinProcess')
t.daemon = True
t.start()
t.join(timeout)
return p.poll()
class Worker:
def __init__(self, cmd, log, server, timeout=5):
self.cmd = cmd
self.log = log
self.server = server
self.p = None
self.wakeup = None
self.timeout = timeout
cmd = self.cmd
if 'calibre-debug' in cmd[0].lower():
try:
idx = cmd.index('--')
except ValueError:
cmd = ['srv']
else:
cmd = ['srv'] + cmd[idx+1:]
opts = create_option_parser().parse_args(cmd)[0]
self.port = opts.port
self.uses_ssl = bool(opts.ssl_certfile and opts.ssl_keyfile)
self.connection_timeout = opts.timeout
self.retry_count = 0
t = Thread(name='PingThread', target=self.ping_thread)
t.daemon = True
t.start()
def ping_thread(self):
while True:
self.server.ping()
time.sleep(30)
def __enter__(self):
self.restart()
return self
def __exit__(self, *args):
if self.p and self.p.poll() is None:
# SIGINT will already have been sent to the child process
self.clean_kill(send_signal=False)
def clean_kill(self, send_signal=True):
if self.p is not None:
if send_signal:
self.p.send_signal(getattr(signal, 'CTRL_BREAK_EVENT', signal.SIGINT))
if join_process(self.p) is None:
self.p.kill()
self.p.wait()
self.log('Killed server process %d with return code: %d' % (self.p.pid, self.p.returncode))
self.p = None
def restart(self, forced=False):
from calibre.utils.rapydscript import CompileFailure, compile_srv
self.clean_kill()
if forced:
self.retry_count += 1
else:
self.retry_count = 0
try:
compile_srv()
except OSError as e:
# Happens if the editor deletes and replaces a file being edited
if e.errno != errno.ENOENT or not getattr(e, 'filename', False):
raise
st = monotonic()
while not os.path.exists(e.filename) and monotonic() - st < 3:
time.sleep(0.01)
compile_srv()
except CompileFailure as e:
self.log.error(error_message(e))
time.sleep(0.1 * self.retry_count)
if self.retry_count < MAX_RETRIES and self.wakeup is not None:
self.wakeup() # Force a restart
return
self.retry_count = 0
self.p = subprocess.Popen(self.cmd, creationflags=getattr(subprocess, 'CREATE_NEW_PROCESS_GROUP', 0))
self.wait_for_listen()
self.server.notify_reload()
def wait_for_listen(self):
st = monotonic()
while monotonic() - st < 5:
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.settimeout(5)
try:
if self.uses_ssl:
s = ssl.wrap_socket(s)
s.connect(('localhost', self.port))
return
except OSError:
time.sleep(0.01)
finally:
s.close()
self.log.error('Restarted server did not start listening on:', self.port)
# WebSocket reload notifier {{{
class ReloadHandler(DummyHandler):
def __init__(self, *args, **kw):
DummyHandler.__init__(self, *args, **kw)
self.connections = {}
self.conn_lock = Lock()
def handle_websocket_upgrade(self, connection_id, connection_ref, inheaders):
with self.conn_lock:
self.connections[connection_id] = connection_ref
def handle_websocket_close(self, connection_id):
with self.conn_lock:
self.connections.pop(connection_id, None)
def notify_reload(self):
with self.conn_lock:
for connref in itervalues(self.connections):
conn = connref()
if conn is not None and conn.ready:
conn.send_websocket_message('reload')
def ping(self):
with self.conn_lock:
for connref in itervalues(self.connections):
conn = connref()
if conn is not None and conn.ready:
conn.send_websocket_message('ping')
class ReloadServer(Thread):
daemon = True
def __init__(self, listen_on):
Thread.__init__(self, name='ReloadServer')
self.reload_handler = ReloadHandler()
self.loop = ServerLoop(
create_http_handler(websocket_handler=self.reload_handler),
opts=Options(shutdown_timeout=0.1, listen_on=(listen_on or '127.0.0.1'), port=0))
self.loop.LISTENING_MSG = None
self.notify_reload = self.reload_handler.notify_reload
self.ping = self.reload_handler.ping
self.start()
def run(self):
try:
self.loop.serve_forever()
except KeyboardInterrupt:
pass
def __enter__(self):
while not self.loop.ready and self.is_alive():
time.sleep(0.01)
self.address = self.loop.bound_address[:2]
os.environ['CALIBRE_AUTORELOAD_PORT'] = native_string_type(self.address[1])
return self
def __exit__(self, *args):
self.loop.stop()
self.join(self.loop.opts.shutdown_timeout)
# }}}
def auto_reload(log, dirs=frozenset(), cmd=None, add_default_dirs=True, listen_on=None):
if Watcher is None:
raise NoAutoReload('Auto-reload is not supported on this operating system')
fpath = os.path.abspath(__file__)
if not os.access(fpath, os.R_OK):
raise NoAutoReload('Auto-reload can only be used when running from source')
if cmd is None:
cmd = list(sys.argv)
cmd.remove('--auto-reload')
if os.path.basename(cmd[0]) == 'run-local':
cmd.insert(1, 'calibre-server')
dirs = find_dirs_to_watch(fpath, dirs, add_default_dirs)
log('Auto-restarting server on changes press Ctrl-C to quit')
log('Watching %d directory trees for changes' % len(dirs))
with ReloadServer(listen_on) as server, Worker(cmd, log, server) as worker:
w = Watcher(dirs, worker, log)
worker.wakeup = w.wakeup
try:
w.loop()
except KeyboardInterrupt:
pass
| 14,074 | Python | .py | 350 | 28.777143 | 115 | 0.566657 | kovidgoyal/calibre | 19,243 | 2,250 | 4 | GPL-3.0 | 9/5/2024, 5:13:50 PM (Europe/Amsterdam) |
26,604 | ajax.py | kovidgoyal_calibre/src/calibre/srv/ajax.py | #!/usr/bin/env python
__license__ = 'GPL v3'
__copyright__ = '2015, Kovid Goyal <kovid at kovidgoyal.net>'
from functools import partial
from itertools import cycle
from calibre import force_unicode
from calibre.db.view import sanitize_sort_field_name
from calibre.ebooks.metadata import title_sort
from calibre.ebooks.metadata.book.json_codec import JsonCodec
from calibre.library.field_metadata import category_icon_map
from calibre.srv.content import get as get_content
from calibre.srv.content import icon as get_icon
from calibre.srv.errors import BookNotFound, HTTPNotFound
from calibre.srv.routes import endpoint, json
from calibre.srv.utils import custom_fields_to_display, decode_name, encode_name, get_db, http_date
from calibre.utils.config import prefs, tweaks
from calibre.utils.date import isoformat, timestampfromdt
from calibre.utils.icu import numeric_sort_key as sort_key
from calibre.utils.localization import _
from polyglot.builtins import iteritems, itervalues, string_or_bytes
def ensure_val(x, *allowed):
if x not in allowed:
x = allowed[0]
return x
def get_pagination(query, num=100, offset=0):
try:
num = int(query.get('num', num))
except:
raise HTTPNotFound("Invalid num")
try:
offset = int(query.get('offset', offset))
except:
raise HTTPNotFound("Invalid offset")
return num, offset
def category_icon(category, meta): # {{{
if category in category_icon_map:
icon = category_icon_map[category]
elif meta['is_custom']:
icon = category_icon_map['custom:']
elif meta['kind'] == 'user':
icon = category_icon_map['user:']
else:
icon = 'blank.png'
return icon
# }}}
# Book metadata {{{
def book_to_json(ctx, rd, db, book_id,
get_category_urls=True, device_compatible=False, device_for_template=None):
mi = db.get_metadata(book_id, get_cover=False)
codec = JsonCodec(db.field_metadata)
if not device_compatible:
try:
mi.rating = mi.rating/2.
except Exception:
mi.rating = 0.0
data = codec.encode_book_metadata(mi)
for x in ('publication_type', 'size', 'db_id', 'lpath', 'mime',
'rights', 'book_producer'):
data.pop(x, None)
get = partial(ctx.url_for, get_content, book_id=book_id, library_id=db.server_library_id)
data['cover'] = get(what='cover')
data['thumbnail'] = get(what='thumb')
if not device_compatible:
mi.format_metadata = {k.lower():dict(v) for k, v in
iteritems(mi.format_metadata)}
for v in itervalues(mi.format_metadata):
mtime = v.get('mtime', None)
if mtime is not None:
v['mtime'] = isoformat(mtime, as_utc=True)
data['format_metadata'] = mi.format_metadata
fmts = {x.lower() for x in mi.format_metadata}
pf = prefs['output_format'].lower()
other_fmts = list(fmts)
try:
fmt = pf if pf in fmts else other_fmts[0]
except:
fmt = None
if fmts and fmt:
other_fmts = [x for x in fmts if x != fmt]
data['formats'] = sorted(fmts)
if fmt:
data['main_format'] = {fmt:get(what=fmt)}
else:
data['main_format'] = None
data['other_formats'] = {fmt:get(what=fmt) for fmt in other_fmts}
if get_category_urls:
category_urls = data['category_urls'] = {}
all_cats = ctx.get_categories(rd, db)
for key in mi.all_field_keys():
fm = mi.metadata_for_field(key)
if (fm and fm['is_category'] and not fm['is_csp'] and
key != 'formats' and fm['datatype'] != 'rating'):
categories = mi.get(key) or []
if isinstance(categories, string_or_bytes):
categories = [categories]
category_urls[key] = dbtags = {}
for category in categories:
for tag in all_cats.get(key, ()):
if tag.original_name == category:
dbtags[category] = ctx.url_for(
books_in,
encoded_category=encode_name(tag.category if tag.category else key),
encoded_item=encode_name(tag.original_name if tag.id is None else str(tag.id)),
library_id=db.server_library_id
)
break
else:
series = data.get('series', None) or ''
if series:
tsorder = tweaks['save_template_title_series_sorting']
series = title_sort(series, order=tsorder)
data['_series_sort_'] = series
if device_for_template:
import posixpath
from calibre.customize.ui import device_plugins
from calibre.devices.utils import create_upload_path
from calibre.utils.filenames import ascii_filename as sanitize
for device_class in device_plugins():
if device_class.__class__.__name__ == device_for_template:
template = device_class.save_template()
data['_filename_'] = create_upload_path(mi, str(book_id),
template, sanitize, path_type=posixpath)
break
return data, mi.last_modified
@endpoint('/ajax/book/{book_id}/{library_id=None}', postprocess=json)
def book(ctx, rd, book_id, library_id):
'''
Return the metadata of the book as a JSON dictionary.
Query parameters: ?category_urls=true&id_is_uuid=false&device_for_template=None
If category_urls is true the returned dictionary also contains a
mapping of category (field) names to URLs that return the list of books in the
given category.
If id_is_uuid is true then the book_id is assumed to be a book uuid instead.
'''
db = get_db(ctx, rd, library_id)
with db.safe_read_lock:
id_is_uuid = rd.query.get('id_is_uuid', 'false')
oid = book_id
if id_is_uuid == 'true':
book_id = db.lookup_by_uuid(book_id)
else:
try:
book_id = int(book_id)
if not db.has_id(book_id):
book_id = None
except Exception:
book_id = None
if book_id is None or not ctx.has_id(rd, db, book_id):
raise BookNotFound(oid, db)
category_urls = rd.query.get('category_urls', 'true').lower()
device_compatible = rd.query.get('device_compatible', 'false').lower()
device_for_template = rd.query.get('device_for_template', None)
data, last_modified = book_to_json(ctx, rd, db, book_id,
get_category_urls=category_urls == 'true',
device_compatible=device_compatible == 'true',
device_for_template=device_for_template)
rd.outheaders['Last-Modified'] = http_date(timestampfromdt(last_modified))
return data
@endpoint('/ajax/books/{library_id=None}', postprocess=json)
def books(ctx, rd, library_id):
'''
Return the metadata for the books as a JSON dictionary.
Query parameters: ?ids=all&category_urls=true&id_is_uuid=false&device_for_template=None
If category_urls is true the returned dictionary also contains a
mapping of category (field) names to URLs that return the list of books in the
given category.
If id_is_uuid is true then the book_id is assumed to be a book uuid instead.
'''
db = get_db(ctx, rd, library_id)
with db.safe_read_lock:
id_is_uuid = rd.query.get('id_is_uuid', 'false')
ids = rd.query.get('ids')
if ids is None or ids == 'all':
ids = db.all_book_ids()
else:
ids = ids.split(',')
if id_is_uuid == 'true':
ids = {db.lookup_by_uuid(x) for x in ids}
ids.discard(None)
else:
try:
ids = {int(x) for x in ids}
except Exception:
raise HTTPNotFound('ids must a comma separated list of integers')
last_modified = None
category_urls = rd.query.get('category_urls', 'true').lower() == 'true'
device_compatible = rd.query.get('device_compatible', 'false').lower() == 'true'
device_for_template = rd.query.get('device_for_template', None)
ans = {}
allowed_book_ids = ctx.allowed_book_ids(rd, db)
for book_id in ids:
if book_id not in allowed_book_ids:
ans[book_id] = None
continue
data, lm = book_to_json(
ctx, rd, db, book_id, get_category_urls=category_urls,
device_compatible=device_compatible, device_for_template=device_for_template)
last_modified = lm if last_modified is None else max(lm, last_modified)
ans[book_id] = data
if last_modified is not None:
rd.outheaders['Last-Modified'] = http_date(timestampfromdt(last_modified))
return ans
# }}}
# Categories (Tag Browser) {{{
@endpoint('/ajax/categories/{library_id=None}', postprocess=json)
def categories(ctx, rd, library_id):
'''
Return the list of top-level categories as a list of dictionaries. Each
dictionary is of the form::
{
'name': Display Name,
'url':URL that gives the JSON object corresponding to all entries in this category,
'icon': URL to icon of this category,
'is_category': False for the All Books and Newest categories, True for everything else
}
'''
db = get_db(ctx, rd, library_id)
with db.safe_read_lock:
ans = {}
categories = ctx.get_categories(rd, db, vl=rd.query.get('vl') or '')
category_meta = db.field_metadata
library_id = db.server_library_id
def getter(x):
return category_meta[x]['name']
displayed_custom_fields = custom_fields_to_display(db)
for category in sorted(categories, key=lambda x: sort_key(getter(x))):
if len(categories[category]) == 0:
continue
if category in ('formats', 'identifiers'):
continue
meta = category_meta.get(category, None)
if meta is None:
continue
if category_meta.is_ignorable_field(category) and \
category not in displayed_custom_fields:
continue
display_name = meta['name']
if category.startswith('@'):
category = category.partition('.')[0]
display_name = category[1:]
url = force_unicode(category)
icon = category_icon(category, meta)
ans[url] = (display_name, icon)
ans = [{'url':k, 'name':v[0], 'icon':v[1], 'is_category':True}
for k, v in iteritems(ans)]
ans.sort(key=lambda x: sort_key(x['name']))
for name, url, icon in [
(_('All books'), 'allbooks', 'book.png'),
(_('Newest'), 'newest', 'forward.png'),
]:
ans.insert(0, {'name':name, 'url':url, 'icon':icon,
'is_category':False})
for c in ans:
c['url'] = ctx.url_for(globals()['category'], encoded_name=encode_name(c['url']), library_id=library_id)
c['icon'] = ctx.url_for(get_icon, which=c['icon'])
return ans
@endpoint('/ajax/category/{encoded_name}/{library_id=None}', postprocess=json)
def category(ctx, rd, encoded_name, library_id):
'''
Return a dictionary describing the category specified by name. The
Optional: ?num=100&offset=0&sort=name&sort_order=asc
The dictionary looks like::
{
'category_name': Category display name,
'base_url': Base URL for this category,
'total_num': Total numberof items in this category,
'offset': The offset for the items returned in this result,
'num': The number of items returned in this result,
'sort': How the returned items are sorted,
'sort_order': asc or desc
'subcategories': List of sub categories of this category.
'items': List of items in this category,
}
Each subcategory is a dictionary of the same form as those returned by
/ajax/categories
Each item is a dictionary of the form::
{
'name': Display name,
'average_rating': Average rating for books in this item,
'count': Number of books in this item,
'url': URL to get list of books in this item,
'has_children': If True this item contains sub categories, look
for an entry corresponding to this item in subcategories int he
main dictionary,
}
:param sort: How to sort the returned items. Choices are: name, rating,
popularity
:param sort_order: asc or desc
To learn how to create subcategories see
https://manual.calibre-ebook.com/sub_groups.html
'''
db = get_db(ctx, rd, library_id)
with db.safe_read_lock:
num, offset = get_pagination(rd.query)
sort, sort_order = rd.query.get('sort'), rd.query.get('sort_order')
sort = ensure_val(sort, 'name', 'rating', 'popularity')
sort_order = ensure_val(sort_order, 'asc', 'desc')
try:
dname = decode_name(encoded_name)
except:
raise HTTPNotFound('Invalid encoding of category name %r'%encoded_name)
base_url = ctx.url_for(globals()['category'], encoded_name=encoded_name, library_id=db.server_library_id)
if dname in ('newest', 'allbooks'):
sort, sort_order = 'timestamp', 'desc'
rd.query['sort'], rd.query['sort_order'] = sort, sort_order
return books_in(ctx, rd, encoded_name, encode_name('0'), library_id)
fm = db.field_metadata
categories = ctx.get_categories(rd, db)
hierarchical_categories = db.pref('categories_using_hierarchy', ())
subcategory = dname
toplevel = subcategory.partition('.')[0]
if toplevel == subcategory:
subcategory = None
if toplevel not in categories or toplevel not in fm:
raise HTTPNotFound('Category %r not found'%toplevel)
# Find items and sub categories
subcategories = []
meta = fm[toplevel]
item_names = {}
children = set()
if meta['kind'] == 'user':
fullname = ((toplevel + '.' + subcategory) if subcategory is not
None else toplevel)
try:
# User categories cannot be applied to books, so this is the
# complete set of items, no need to consider sub categories
items = categories[fullname]
except:
raise HTTPNotFound('User category %r not found'%fullname)
parts = fullname.split('.')
for candidate in categories:
cparts = candidate.split('.')
if len(cparts) == len(parts)+1 and cparts[:-1] == parts:
subcategories.append({'name':cparts[-1],
'url':candidate,
'icon':category_icon(toplevel, meta)})
category_name = toplevel[1:].split('.')
# When browsing by user categories we ignore hierarchical normal
# columns, so children can be empty
elif toplevel in hierarchical_categories:
items = []
category_names = [x.original_name.split('.') for x in categories[toplevel] if
'.' in x.original_name]
if subcategory is None:
children = {x[0] for x in category_names}
category_name = [meta['name']]
items = [x for x in categories[toplevel] if '.' not in x.original_name]
else:
subcategory_parts = subcategory.split('.')[1:]
category_name = [meta['name']] + subcategory_parts
lsp = len(subcategory_parts)
children = {'.'.join(x) for x in category_names if len(x) ==
lsp+1 and x[:lsp] == subcategory_parts}
items = [x for x in categories[toplevel] if x.original_name in
children]
item_names = {x:x.original_name.rpartition('.')[-1] for x in
items}
# Only mark the subcategories that have children themselves as
# subcategories
children = {'.'.join(x[:lsp+1]) for x in category_names if len(x) >
lsp+1 and x[:lsp] == subcategory_parts}
subcategories = [{'name':x.rpartition('.')[-1],
'url':toplevel+'.'+x,
'icon':category_icon(toplevel, meta)} for x in children]
else:
items = categories[toplevel]
category_name = meta['name']
for x in subcategories:
x['url'] = ctx.url_for(globals()['category'], encoded_name=encode_name(x['url']), library_id=db.server_library_id)
x['icon'] = ctx.url_for(get_icon, which=x['icon'])
x['is_category'] = True
sort_keygen = {
'name': lambda x: sort_key(x.sort if x.sort else x.original_name),
'popularity': lambda x: x.count,
'rating': lambda x: x.avg_rating
}
items.sort(key=sort_keygen[sort], reverse=sort_order == 'desc')
total_num = len(items)
items = items[offset:offset+num]
items = [{
'name':item_names.get(x, x.original_name),
'average_rating': x.avg_rating,
'count': x.count,
'url': ctx.url_for(books_in, encoded_category=encode_name(x.category if x.category else toplevel),
encoded_item=encode_name(x.original_name if x.id is None else str(x.id)),
library_id=db.server_library_id
),
'has_children': x.original_name in children,
} for x in items]
return {
'category_name': category_name,
'base_url': base_url,
'total_num': total_num,
'offset':offset, 'num':len(items), 'sort':sort,
'sort_order':sort_order,
'subcategories':subcategories,
'items':items,
}
@endpoint('/ajax/books_in/{encoded_category}/{encoded_item}/{library_id=None}', postprocess=json)
def books_in(ctx, rd, encoded_category, encoded_item, library_id):
'''
Return the books (as list of ids) present in the specified category.
Optional: ?num=100&offset=0&sort=title&sort_order=asc&get_additional_fields=
'''
db = get_db(ctx, rd, library_id)
with db.safe_read_lock:
try:
dname, ditem = map(decode_name, (encoded_category, encoded_item))
except:
raise HTTPNotFound(f'Invalid encoded param: {encoded_category!r} ({encoded_item!r})')
num, offset = get_pagination(rd.query)
sort, sort_order = rd.query.get('sort', 'title'), rd.query.get('sort_order')
sort_order = ensure_val(sort_order, 'asc', 'desc')
sfield = sanitize_sort_field_name(db.field_metadata, sort)
if sfield not in db.field_metadata.sortable_field_keys():
raise HTTPNotFound('%s is not a valid sort field'%sort)
if dname in ('allbooks', 'newest'):
ids = ctx.allowed_book_ids(rd, db)
elif dname == 'search':
try:
ids = ctx.search(rd, db, 'search:"%s"'%ditem)
except Exception:
raise HTTPNotFound('Search: %r not understood'%ditem)
else:
try:
cid = int(ditem)
except Exception:
raise HTTPNotFound('Category id %r not an integer'%ditem)
if dname == 'news':
dname = 'tags'
ids = db.get_books_for_category(dname, cid) & ctx.allowed_book_ids(rd, db)
ids = db.multisort(fields=[(sfield, sort_order == 'asc')], ids_to_sort=ids)
total_num = len(ids)
ids = ids[offset:offset+num]
result = {
'total_num': total_num, 'sort_order':sort_order,
'offset':offset, 'num':len(ids), 'sort':sort,
'base_url':ctx.url_for(books_in, encoded_category=encoded_category, encoded_item=encoded_item, library_id=db.server_library_id),
'book_ids':ids
}
get_additional_fields = rd.query.get('get_additional_fields')
if get_additional_fields:
additional_fields = {}
for field in get_additional_fields.split(','):
field = field.strip()
if field:
flist = additional_fields[field] = []
for id_ in ids:
flist.append(db.field_for(field, id_, default_value=None))
if additional_fields:
result['additional_fields'] = additional_fields
return result
# }}}
# Search {{{
def search_result(ctx, rd, db, query, num, offset, sort, sort_order, vl=''):
multisort = [(sanitize_sort_field_name(db.field_metadata, s), ensure_val(o, 'asc', 'desc') == 'asc')
for s, o in zip(sort.split(','), cycle(sort_order.split(',')))]
skeys = db.field_metadata.sortable_field_keys()
for sfield, sorder in multisort:
if sfield not in skeys:
raise HTTPNotFound('%s is not a valid sort field'%sort)
ids, parse_error = ctx.search(rd, db, query, vl=vl, report_restriction_errors=True)
ids = db.multisort(fields=multisort, ids_to_sort=ids)
total_num = len(ids)
ids = ids[offset:offset+num]
num_books = db.number_of_books_in_virtual_library(vl) if query else total_num
ans = {
'total_num': total_num, 'sort_order':sort_order,
'num_books_without_search': num_books,
'offset':offset, 'num':len(ids), 'sort':sort,
'base_url':ctx.url_for(search, library_id=db.server_library_id),
'query': query,
'library_id': db.server_library_id,
'book_ids':ids,
'vl': vl,
}
if parse_error is not None:
ans['bad_restriction'] = str(parse_error)
return ans
@endpoint('/ajax/search/{library_id=None}', postprocess=json)
def search(ctx, rd, library_id):
'''
Return the books matching the specified search query.
The returned object is a dict with the field book_ids which
is a list of matched book ids. For all the other fields in the object, see
:func:`search_result`.
Optional: ?num=100&offset=0&sort=title&sort_order=asc&query=&vl=
'''
db = get_db(ctx, rd, library_id)
query = rd.query.get('query')
num, offset = get_pagination(rd.query)
with db.safe_read_lock:
return search_result(ctx, rd, db, query, num, offset, rd.query.get('sort', 'title'), rd.query.get('sort_order', 'asc'), rd.query.get('vl') or '')
# }}}
@endpoint('/ajax/library-info', postprocess=json)
def library_info(ctx, rd):
' Return info about available libraries '
library_map, default_library = ctx.library_info(rd)
return {'library_map':library_map, 'default_library':default_library}
| 23,532 | Python | .py | 499 | 36.124248 | 153 | 0.584775 | kovidgoyal/calibre | 19,243 | 2,250 | 4 | GPL-3.0 | 9/5/2024, 5:13:50 PM (Europe/Amsterdam) |
26,605 | fts.py | kovidgoyal_calibre/src/calibre/srv/fts.py | #!/usr/bin/env python
# License: GPL v3 Copyright: 2022, Kovid Goyal <kovid at kovidgoyal.net>
import re
from calibre.ebooks.metadata import authors_to_string
from calibre.srv.errors import HTTPBadRequest, HTTPPreconditionRequired, HTTPUnprocessableEntity
from calibre.srv.routes import endpoint, json
from calibre.srv.utils import get_library_data
@endpoint('/fts/search', postprocess=json)
def fts_search(ctx, rd):
'''
Perform the specified full text query.
Optional: ?query=<search query>&library_id=<default library>&use_stemming=<y or n>&query_id=arbitrary&restriction=arbitrary
'''
db = get_library_data(ctx, rd)[0]
if not db.is_fts_enabled():
raise HTTPPreconditionRequired('Full text searching is not enabled on this library')
metadata_cache = {}
l, t = db.fts_indexing_progress()[:2]
ans = {'metadata': metadata_cache, 'indexing_status': {'left': l, 'total': t}}
use_stemming = rd.query.get('use_stemming', 'y') == 'y'
query = rd.query.get('query' '')
if not query:
raise HTTPBadRequest('No search query specified')
qid = rd.query.get('query_id')
if qid:
ans['query_id'] = qid
book_ids = None
if rd.query.get('restriction'):
book_ids = db.search('', restriction=rd.query.get('restriction'))
def add_metadata(result):
result.pop('id', None)
result.pop('text', None)
bid = result['book_id']
if bid not in metadata_cache:
with db.safe_read_lock:
metadata_cache[bid] = {'title': db._field_for('title', bid), 'authors': authors_to_string(db._field_for('authors', bid))}
return result
from calibre.db import FTSQueryError
try:
ans['results'] = tuple(db.fts_search(
query, use_stemming=use_stemming, return_text=False, process_each_result=add_metadata, restrict_to_book_ids=book_ids,
))
except FTSQueryError as e:
raise HTTPUnprocessableEntity(str(e))
return ans
@endpoint('/fts/disable', needs_db_write=True)
def fts_disable(ctx, rd):
db = get_library_data(ctx, rd)[0]
if db.is_fts_enabled():
db.enable_fts(enabled=False)
return ''
@endpoint('/fts/reindex', needs_db_write=True, methods=('POST',))
def fts_reindex(ctx, rd):
db = get_library_data(ctx, rd)[0]
if not db.is_fts_enabled():
raise HTTPPreconditionRequired('Full text searching is not enabled on this library')
data = rd.request_body_file.read()
try:
book_ids = json.loads(data)
except Exception:
raise HTTPBadRequest('Invalid book ids')
if book_ids == 'all':
db.reindex_fts()
else:
for book_id, fmts in book_ids.items():
db.reindex_fts_book(int(book_id), *fmts)
return ''
@endpoint('/fts/indexing', needs_db_write=True, methods=('POST',))
def fts_indexing(ctx, rd):
data = rd.request_body_file.read()
try:
enable = json.loads(data)
except Exception:
raise HTTPBadRequest('Invalid boolean')
if not isinstance(enable, bool):
raise HTTPBadRequest('Invalid boolean')
db = get_library_data(ctx, rd)[0]
db.enable_fts(enable)
return ''
@endpoint('/fts/snippets/{book_ids}', postprocess=json)
def fts_snippets(ctx, rd, book_ids):
'''
Perform the specified full text query and return the results with snippets restricted to the specified book ids.
Optional: ?query=<search query>&library_id=<default library>&use_stemming=<y or n>
&query_id=arbitrary&snippet_size=32&highlight_start=\x1c&highlight_end=\x1e
'''
db = get_library_data(ctx, rd)[0]
if not db.is_fts_enabled():
raise HTTPPreconditionRequired('Full text searching is not enabled on this library')
use_stemming = rd.query.get('use_stemming', 'y') == 'y'
query = rd.query.get('query' '')
if not query:
raise HTTPBadRequest('No search query specified')
try:
bids = frozenset(map(int, book_ids.split(',')))
except Exception:
raise HTTPBadRequest('Invalid list of book ids')
try:
ssz = int(rd.query.get('snippet_size', 32))
except Exception:
raise HTTPBadRequest('Invalid snippet size')
snippets = {bid:{} for bid in bids}
ans = {}
qid = rd.query.get('query_id')
if qid:
ans['query_id'] = qid
from calibre.db import FTSQueryError
sanitize_pat = re.compile(r'\s+')
try:
for x in db.fts_search(
query, use_stemming=use_stemming, return_text=True,
highlight_start=rd.query.get('highlight_start', '\x1c'), highlight_end=rd.query.get('highlight_end', '\x1e'),
restrict_to_book_ids=bids, snippet_size=ssz,
):
r = snippets[x['book_id']]
q = sanitize_pat.sub('', x['text'])
r.setdefault(q, {'formats': [], 'text': x['text'],})['formats'].append(x['format'])
except FTSQueryError as e:
raise HTTPUnprocessableEntity(str(e))
ans['snippets'] = {bid: tuple(v.values()) for bid, v in snippets.items()}
return ans
| 5,054 | Python | .py | 121 | 35.454545 | 137 | 0.653439 | kovidgoyal/calibre | 19,243 | 2,250 | 4 | GPL-3.0 | 9/5/2024, 5:13:50 PM (Europe/Amsterdam) |
26,606 | embedded.py | kovidgoyal_calibre/src/calibre/srv/embedded.py | #!/usr/bin/env python
# License: GPLv3 Copyright: 2017, Kovid Goyal <kovid at kovidgoyal.net>
import errno
import json
import os
from contextlib import suppress
from threading import Thread
from calibre import as_unicode
from calibre.constants import cache_dir, config_dir, is_running_from_develop
from calibre.srv.bonjour import BonJour
from calibre.srv.handler import Handler
from calibre.srv.http_response import create_http_handler
from calibre.srv.loop import ServerLoop
from calibre.srv.opts import server_config
from calibre.srv.utils import RotatingLog
def log_paths():
return os.path.join(cache_dir(), 'server-log.txt'), os.path.join(
cache_dir(), 'server-access-log.txt'
)
def read_json(path):
try:
with open(path, 'rb') as f:
raw = f.read()
except OSError as err:
if err.errno != errno.ENOENT:
raise
return
with suppress(json.JSONDecodeError):
return json.loads(raw)
def custom_list_template():
return read_json(custom_list_template.path)
def search_the_net_urls():
return read_json(search_the_net_urls.path)
custom_list_template.path = os.path.join(config_dir, 'server-custom-list-template.json')
search_the_net_urls.path = os.path.join(config_dir, 'server-search-the-net.json')
class Server:
loop = current_thread = exception = None
state_callback = start_failure_callback = None
def __init__(self, library_broker, notify_changes):
opts = server_config()
lp, lap = log_paths()
try:
os.makedirs(cache_dir())
except OSError as err:
if err.errno != errno.EEXIST:
raise
log_size = opts.max_log_size * 1024 * 1024
log = RotatingLog(lp, max_size=log_size)
access_log = RotatingLog(lap, max_size=log_size)
self.handler = Handler(library_broker, opts, notify_changes=notify_changes)
plugins = self.plugins = []
if opts.use_bonjour:
plugins.append(BonJour(wait_for_stop=max(0, opts.shutdown_timeout - 0.2)))
self.opts = opts
self.log, self.access_log = log, access_log
self.handler.set_log(self.log)
self.handler.router.ctx.custom_list_template = custom_list_template()
self.handler.router.ctx.search_the_net_urls = search_the_net_urls()
@property
def ctx(self):
return self.handler.router.ctx
@property
def user_manager(self):
return self.handler.router.ctx.user_manager
def start(self):
if self.current_thread is None:
try:
self.loop = ServerLoop(
create_http_handler(self.handler.dispatch),
opts=self.opts,
log=self.log,
access_log=self.access_log,
plugins=self.plugins
)
self.loop.initialize_socket()
except Exception as e:
self.loop = None
self.exception = e
if self.start_failure_callback is not None:
try:
self.start_failure_callback(as_unicode(e))
except Exception:
pass
return
self.handler.set_jobs_manager(self.loop.jobs_manager)
self.current_thread = t = Thread(
name='EmbeddedServer', target=self.serve_forever
)
t.daemon = True
t.start()
def serve_forever(self):
self.exception = None
from calibre.srv.content import reset_caches
try:
if is_running_from_develop:
from calibre.utils.rapydscript import compile_srv
compile_srv()
except BaseException as e:
self.exception = e
if self.start_failure_callback is not None:
try:
self.start_failure_callback(as_unicode(e))
except Exception:
pass
return
if self.state_callback is not None:
try:
self.state_callback(True)
except Exception:
pass
reset_caches() # we reset the cache as the server tdir has changed
try:
self.loop.serve_forever()
except BaseException as e:
self.exception = e
if self.state_callback is not None:
try:
self.state_callback(False)
except Exception:
pass
def stop(self):
if self.loop is not None:
self.loop.stop()
self.loop = None
def exit(self):
if self.current_thread is not None:
self.stop()
self.current_thread.join()
self.current_thread = None
@property
def is_running(self):
return self.current_thread is not None and self.current_thread.is_alive()
| 4,946 | Python | .py | 132 | 27.318182 | 88 | 0.600835 | kovidgoyal/calibre | 19,243 | 2,250 | 4 | GPL-3.0 | 9/5/2024, 5:13:50 PM (Europe/Amsterdam) |
26,607 | changes.py | kovidgoyal_calibre/src/calibre/srv/changes.py | #!/usr/bin/env python
# License: GPLv3 Copyright: 2017, Kovid Goyal <kovid at kovidgoyal.net>
class ChangeEvent:
def __init__(self):
pass
def __repr__(self):
return '{}(book_ids={})'.format(
self.__class__.__name__, ','.join(sorted(map(str, self.book_ids)))
)
class BooksAdded(ChangeEvent):
def __init__(self, book_ids):
ChangeEvent.__init__(self)
self.book_ids = frozenset(book_ids)
class BooksDeleted(ChangeEvent):
def __init__(self, book_ids):
ChangeEvent.__init__(self)
self.book_ids = frozenset(book_ids)
class FormatsAdded(ChangeEvent):
def __init__(self, formats_map):
ChangeEvent.__init__(self)
self.formats_map = formats_map
@property
def book_ids(self):
return frozenset(self.formats_map)
class FormatsRemoved(ChangeEvent):
def __init__(self, formats_map):
ChangeEvent.__init__(self)
self.formats_map = formats_map
@property
def book_ids(self):
return frozenset(self.formats_map)
class MetadataChanged(ChangeEvent):
def __init__(self, book_ids):
ChangeEvent.__init__(self)
self.book_ids = frozenset(book_ids)
class SavedSearchesChanged(ChangeEvent):
def __init__(self, added=(), removed=()):
ChangeEvent.__init__(self)
self.added = frozenset(added)
self.removed = frozenset(removed)
def __repr__(self):
return '{}(added={}, removed={})'.format(
self.__class__.__name__,
sorted(map(str, self.added)), sorted(map(str, self.removed))
)
books_added = BooksAdded
formats_added = FormatsAdded
formats_removed = FormatsRemoved
books_deleted = BooksDeleted
metadata = MetadataChanged
saved_searches = SavedSearchesChanged
| 1,799 | Python | .py | 51 | 28.882353 | 78 | 0.643812 | kovidgoyal/calibre | 19,243 | 2,250 | 4 | GPL-3.0 | 9/5/2024, 5:13:50 PM (Europe/Amsterdam) |
26,608 | web_socket.py | kovidgoyal_calibre/src/calibre/srv/web_socket.py | #!/usr/bin/env python
# License: GPLv3 Copyright: 2015, Kovid Goyal <kovid at kovidgoyal.net>
import os
import socket
import weakref
from collections import deque
from hashlib import sha1
from struct import error as struct_error
from struct import pack, unpack_from
from threading import Lock
from calibre import as_unicode
from calibre.srv.http_response import HTTPConnection, create_http_handler
from calibre.srv.loop import RDWR, READ, WRITE, Connection, HandleInterrupt, ServerLoop
from calibre.srv.utils import DESIRED_SEND_BUFFER_SIZE
from calibre.utils.speedups import ReadOnlyFileBuffer
from calibre_extensions.speedup import utf8_decode
from calibre_extensions.speedup import websocket_mask as fast_mask
from polyglot import http_client
from polyglot.binary import as_base64_unicode
from polyglot.queue import Empty, Queue
HANDSHAKE_STR = (
"HTTP/1.1 101 Switching Protocols\r\n"
"Upgrade: WebSocket\r\n"
"Connection: Upgrade\r\n"
"Sec-WebSocket-Accept: %s\r\n\r\n"
)
GUID_STR = '258EAFA5-E914-47DA-95CA-C5AB0DC85B11'
CONTINUATION = 0x0
TEXT = 0x1
BINARY = 0x2
CLOSE = 0x8
PING = 0x9
PONG = 0xA
CONTROL_CODES = (CLOSE, PING, PONG)
ALL_CODES = CONTROL_CODES + (CONTINUATION, TEXT, BINARY)
CHUNK_SIZE = 16 * 1024
SEND_CHUNK_SIZE = DESIRED_SEND_BUFFER_SIZE - 16
NORMAL_CLOSE = 1000
SHUTTING_DOWN = 1001
PROTOCOL_ERROR = 1002
UNSUPPORTED_DATA = 1003
INCONSISTENT_DATA = 1007
POLICY_VIOLATION = 1008
MESSAGE_TOO_BIG = 1009
UNEXPECTED_ERROR = 1011
RESERVED_CLOSE_CODES = (1004,1005,1006,)
class ReadFrame: # {{{
def __init__(self):
self.header_buf = bytearray(14)
self.rbuf = bytearray(CHUNK_SIZE)
self.empty = memoryview(b'')
self.reset()
def reset(self):
self.header_view = memoryview(self.header_buf)[:6]
self.state = self.read_header
def __call__(self, conn):
return self.state(conn)
def read_header(self, conn):
num_bytes = conn.recv_into(self.header_view)
if num_bytes == 0:
return
read_bytes = 6 - len(self.header_view) + num_bytes
if read_bytes > 2:
b1, b2 = self.header_buf[0], self.header_buf[1]
self.fin = bool(b1 & 0b10000000)
if b1 & 0b01110000:
conn.log.error('RSV bits set in frame from client')
conn.websocket_close(PROTOCOL_ERROR, 'RSV bits set')
return
self.opcode = b1 & 0b1111
self.is_control = self.opcode in CONTROL_CODES
if self.opcode not in ALL_CODES:
conn.log.error('Unknown OPCODE from client: %r' % self.opcode)
conn.websocket_close(PROTOCOL_ERROR, 'Unknown OPCODE: %r' % self.opcode)
return
if not self.fin and self.is_control:
conn.log.error('Fragmented control frame from client')
conn.websocket_close(PROTOCOL_ERROR, 'Fragmented control frame')
return
mask = b2 & 0b10000000
if not mask:
conn.log.error('Unmasked packet from client')
conn.websocket_close(PROTOCOL_ERROR, 'Unmasked packet not allowed')
self.reset()
return
self.payload_length = l = b2 & 0b01111111
if self.is_control and l > 125:
conn.log.error('Too large control frame from client')
conn.websocket_close(PROTOCOL_ERROR, 'Control frame too large')
self.reset()
return
header_len = 6 + (0 if l < 126 else 2 if l == 126 else 8)
if header_len <= read_bytes:
self.process_header(conn)
else:
self.header_view = memoryview(self.header_buf)[read_bytes:header_len]
self.state = self.finish_reading_header
else:
self.header_view = self.header_view[num_bytes:]
def finish_reading_header(self, conn):
num_bytes = conn.recv_into(self.header_view)
if num_bytes == 0:
return
if num_bytes >= len(self.header_view):
self.process_header(conn)
else:
self.header_view = self.header_view[num_bytes:]
def process_header(self, conn):
if self.payload_length < 126:
self.mask = memoryview(self.header_buf)[2:6]
elif self.payload_length == 126:
self.payload_length, = unpack_from(b'!H', self.header_buf, 2)
self.mask = memoryview(self.header_buf)[4:8]
else:
self.payload_length, = unpack_from(b'!Q', self.header_buf, 2)
self.mask = memoryview(self.header_buf)[10:14]
self.frame_starting = True
self.bytes_received = 0
if self.payload_length <= CHUNK_SIZE:
if self.payload_length == 0:
conn.ws_data_received(self.empty, self.opcode, True, True, self.fin)
self.reset()
else:
self.rview = memoryview(self.rbuf)[:self.payload_length]
self.state = self.read_packet
else:
self.rview = memoryview(self.rbuf)
self.state = self.read_payload
def read_packet(self, conn):
num_bytes = conn.recv_into(self.rview)
if num_bytes == 0:
return
if num_bytes >= len(self.rview):
data = memoryview(self.rbuf)[:self.payload_length]
fast_mask(data, self.mask)
conn.ws_data_received(data, self.opcode, True, True, self.fin)
self.reset()
else:
self.rview = self.rview[num_bytes:]
def read_payload(self, conn):
num_bytes = conn.recv_into(self.rview, min(len(self.rview), self.payload_length - self.bytes_received))
if num_bytes == 0:
return
data = memoryview(self.rbuf)[:num_bytes]
fast_mask(data, self.mask, self.bytes_received)
self.bytes_received += num_bytes
frame_finished = self.bytes_received >= self.payload_length
conn.ws_data_received(data, self.opcode, self.frame_starting, frame_finished, self.fin)
self.frame_starting = False
if frame_finished:
self.reset()
# }}}
# Sending frames {{{
def create_frame(fin, opcode, payload, mask=None, rsv=0):
if isinstance(payload, str):
payload = payload.encode('utf-8')
l = len(payload)
header_len = 2 + (0 if l < 126 else 2 if 126 <= l <= 65535 else 8) + (0 if mask is None else 4)
frame = bytearray(header_len + l)
if l > 0:
frame[-l:] = payload
frame[0] = (opcode & 0b1111) | (0b10000000 if fin else 0) | (rsv & 0b01110000)
if l < 126:
frame[1] = l
elif 126 <= l <= 65535:
frame[2:4] = pack(b'!H', l)
frame[1] = 126
else:
frame[2:10] = pack(b'!Q', l)
frame[1] = 127
if mask is not None:
frame[1] |= 0b10000000
frame[header_len-4:header_len] = mask
if l > 0:
fast_mask(memoryview(frame)[-l:], mask)
return memoryview(frame)
class MessageWriter:
def __init__(self, buf, mask=None, chunk_size=None):
self.buf, self.data_type, self.mask = buf, BINARY, mask
if isinstance(buf, str):
self.buf, self.data_type = ReadOnlyFileBuffer(buf.encode('utf-8')), TEXT
elif isinstance(buf, bytes):
self.buf = ReadOnlyFileBuffer(buf)
buf = self.buf
self.chunk_size = chunk_size or SEND_CHUNK_SIZE
try:
pos = buf.tell()
buf.seek(0, os.SEEK_END)
self.size = buf.tell() - pos
buf.seek(pos)
except Exception:
self.size = None
self.first_frame_created = self.exhausted = False
def create_frame(self):
if self.exhausted:
return None
buf = self.buf
raw = buf.read(self.chunk_size)
has_more = True if self.size is None else self.size > buf.tell()
fin = 0 if has_more and raw else 1
opcode = 0 if self.first_frame_created else self.data_type
self.first_frame_created, self.exhausted = True, bool(fin)
return ReadOnlyFileBuffer(create_frame(fin, opcode, raw, self.mask))
# }}}
conn_id = 0
class UTF8Decoder: # {{{
def __init__(self):
self.reset()
def __call__(self, data):
ans, self.state, self.codep = utf8_decode(data, self.state, self.codep)
return ans
def reset(self):
self.state = 0
self.codep = 0
# }}}
class WebSocketConnection(HTTPConnection):
# Internal API {{{
in_websocket_mode = False
websocket_handler = None
def __init__(self, *args, **kwargs):
global conn_id
HTTPConnection.__init__(self, *args, **kwargs)
self.sendq = Queue()
self.control_frames = deque()
self.cf_lock = Lock()
self.sending = None
self.send_buf = None
self.frag_decoder = UTF8Decoder()
self.ws_close_received = self.ws_close_sent = False
conn_id += 1
self.websocket_connection_id = conn_id
self.stop_reading = False
def finalize_headers(self, inheaders):
upgrade = inheaders.get('Upgrade', '')
key = inheaders.get('Sec-WebSocket-Key', None)
conn = {x.strip().lower() for x in inheaders.get('Connection', '').split(',')}
if key is None or upgrade.lower() != 'websocket' or 'upgrade' not in conn:
return HTTPConnection.finalize_headers(self, inheaders)
ver = inheaders.get('Sec-WebSocket-Version', 'Unknown')
try:
ver_ok = int(ver) >= 13
except Exception:
ver_ok = False
if not ver_ok:
return self.simple_response(http_client.BAD_REQUEST, 'Unsupported WebSocket protocol version: %s' % ver)
if self.method != 'GET':
return self.simple_response(http_client.BAD_REQUEST, 'Invalid WebSocket method: %s' % self.method)
response = HANDSHAKE_STR % as_base64_unicode(sha1((key + GUID_STR).encode('utf-8')).digest())
self.optimize_for_sending_packet()
self.socket.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
self.set_state(WRITE, self.upgrade_connection_to_ws, ReadOnlyFileBuffer(response.encode('ascii')), inheaders)
def upgrade_connection_to_ws(self, buf, inheaders, event):
if self.write(buf):
if self.websocket_handler is None:
self.websocket_handler = DummyHandler()
self.read_frame, self.current_recv_opcode = ReadFrame(), None
self.in_websocket_mode = True
try:
self.websocket_handler.handle_websocket_upgrade(self.websocket_connection_id, weakref.ref(self), inheaders)
except Exception as err:
self.log.exception('Error in WebSockets upgrade handler:')
self.websocket_close(UNEXPECTED_ERROR, 'Unexpected error in handler: %r' % as_unicode(err))
self.handle_event = self.ws_duplex
self.set_ws_state()
self.end_send_optimization()
def set_ws_state(self):
if self.ws_close_sent or self.ws_close_received:
if self.ws_close_sent:
self.ready = False
else:
self.wait_for = WRITE
return
if self.send_buf is not None or self.sending is not None:
self.wait_for = RDWR
else:
try:
self.sending = self.sendq.get_nowait()
except Empty:
with self.cf_lock:
if self.control_frames:
self.wait_for = RDWR
else:
self.wait_for = READ
else:
self.wait_for = RDWR
if self.stop_reading:
if self.wait_for is READ:
self.ready = False
elif self.wait_for is RDWR:
self.wait_for = WRITE
def ws_duplex(self, event):
if event is READ:
self.ws_read()
elif event is WRITE:
self.ws_write()
self.set_ws_state()
def ws_read(self):
if not self.stop_reading:
self.read_frame(self)
def ws_data_received(self, data, opcode, frame_starting, frame_finished, is_final_frame_of_message):
if opcode in CONTROL_CODES:
return self.ws_control_frame(opcode, data)
message_starting = self.current_recv_opcode is None
if message_starting:
if opcode == CONTINUATION:
self.log.error('Client sent continuation frame with no message to continue')
self.websocket_close(PROTOCOL_ERROR, 'Continuation frame without any message to continue')
return
self.current_recv_opcode = opcode
elif frame_starting and opcode != CONTINUATION:
self.log.error('Client sent continuation frame with non-zero opcode')
self.websocket_close(PROTOCOL_ERROR, 'Continuation frame with non-zero opcode')
return
message_finished = frame_finished and is_final_frame_of_message
if self.current_recv_opcode == TEXT:
if message_starting:
self.frag_decoder.reset()
empty_data = len(data) == 0
try:
data = self.frag_decoder(data)
except ValueError:
self.frag_decoder.reset()
self.log.error('Client sent undecodeable UTF-8')
return self.websocket_close(INCONSISTENT_DATA, 'Not valid UTF-8')
if message_finished:
if (not data and not empty_data) or self.frag_decoder.state:
self.frag_decoder.reset()
self.log.error('Client sent undecodeable UTF-8')
return self.websocket_close(INCONSISTENT_DATA, 'Not valid UTF-8')
if message_finished:
self.current_recv_opcode = None
self.frag_decoder.reset()
try:
self.handle_websocket_data(data, message_starting, message_finished)
except Exception as err:
self.log.exception('Error in WebSockets data handler:')
self.websocket_close(UNEXPECTED_ERROR, 'Unexpected error in handler: %r' % as_unicode(err))
def ws_control_frame(self, opcode, data):
if opcode in (PING, CLOSE):
rcode = PONG if opcode == PING else CLOSE
if opcode == CLOSE:
self.ws_close_received = True
self.stop_reading = True
if data:
try:
close_code = unpack_from(b'!H', data)[0]
except struct_error:
data = pack(b'!H', PROTOCOL_ERROR) + b'close frame data must be at least two bytes'
else:
try:
utf8_decode(data[2:])
except ValueError:
data = pack(b'!H', PROTOCOL_ERROR) + b'close frame data must be valid UTF-8'
else:
if close_code < 1000 or close_code in RESERVED_CLOSE_CODES or (1011 < close_code < 3000):
data = pack(b'!H', PROTOCOL_ERROR) + b'close code reserved'
else:
close_code = NORMAL_CLOSE
data = pack(b'!H', close_code)
f = ReadOnlyFileBuffer(create_frame(1, rcode, data))
f.is_close_frame = opcode == CLOSE
with self.cf_lock:
self.control_frames.append(f)
elif opcode == PONG:
try:
self.websocket_handler.handle_websocket_pong(self.websocket_connection_id, data)
except Exception:
self.log.exception('Error in PONG handler:')
self.set_ws_state()
def websocket_close(self, code=NORMAL_CLOSE, reason=b''):
if isinstance(reason, str):
reason = reason.encode('utf-8')
self.stop_reading = True
reason = reason[:123]
if code is None and not reason:
f = ReadOnlyFileBuffer(create_frame(1, CLOSE, b''))
else:
f = ReadOnlyFileBuffer(create_frame(1, CLOSE, pack(b'!H', code) + reason))
f.is_close_frame = True
with self.cf_lock:
self.control_frames.append(f)
self.set_ws_state()
def ws_write(self):
if self.ws_close_sent:
return
if self.send_buf is not None:
if self.write(self.send_buf):
self.end_send_optimization()
if getattr(self.send_buf, 'is_close_frame', False):
self.ws_close_sent = True
self.send_buf = None
else:
with self.cf_lock:
try:
self.send_buf = self.control_frames.popleft()
except IndexError:
if self.sending is not None:
self.send_buf = self.sending.create_frame()
if self.send_buf is None:
self.sending = None
if self.send_buf is not None:
self.optimize_for_sending_packet()
def close(self):
if self.in_websocket_mode:
try:
self.websocket_handler.handle_websocket_close(self.websocket_connection_id)
except Exception:
self.log.exception('Error in WebSocket close handler')
# Try to write a close frame, just once
try:
if self.send_buf is None and not self.ws_close_sent:
self.websocket_close(SHUTTING_DOWN, 'Shutting down')
with self.cf_lock:
self.write(self.control_frames.pop())
except Exception:
pass
Connection.close(self)
else:
HTTPConnection.close(self)
# }}}
def send_websocket_message(self, buf, wakeup=True):
''' Send a complete message. This class will take care of splitting it
into appropriate frames automatically. `buf` must be a file like object. '''
self.sendq.put(MessageWriter(buf))
self.wait_for = RDWR
if wakeup:
self.wakeup()
def send_websocket_frame(self, data, is_first=True, is_last=True):
''' Useful for streaming handlers that want to break up messages into
frames themselves. Note that these frames will be interleaved with
control frames, so they should not be too large. '''
opcode = (TEXT if isinstance(data, str) else BINARY) if is_first else CONTINUATION
fin = 1 if is_last else 0
frame = create_frame(fin, opcode, data)
with self.cf_lock:
self.control_frames.append(ReadOnlyFileBuffer(frame))
def send_websocket_ping(self, data=b''):
''' Send a PING to the remote client, it should reply with a PONG which
will be sent to the handle_websocket_pong callback in your handler. '''
if isinstance(data, str):
data = data.encode('utf-8')
frame = create_frame(True, PING, data)
with self.cf_lock:
self.control_frames.append(ReadOnlyFileBuffer(frame))
def handle_websocket_data(self, data, message_starting, message_finished):
''' Called when some data is received from the remote client. In
general the data may not constitute a complete "message", use the
message_starting and message_finished flags to re-assemble it into a
complete message in the handler. Note that for binary data, data is a
mutable object. If you intend to keep it around after this method
returns, create a bytestring from it, using tobytes(). '''
self.websocket_handler.handle_websocket_data(self.websocket_connection_id, data, message_starting, message_finished)
class DummyHandler:
def handle_websocket_upgrade(self, connection_id, connection_ref, inheaders):
conn = connection_ref()
conn.websocket_close(NORMAL_CLOSE, 'No WebSocket handler available')
def handle_websocket_data(self, connection_id, data, message_starting, message_finished):
pass
def handle_websocket_pong(self, connection_id, data):
pass
def handle_websocket_close(self, connection_id):
pass
# Testing {{{
# Run this file with calibre-debug and use wstest to run the Autobahn test
# suite
class EchoHandler:
def __init__(self, *args, **kwargs):
self.ws_connections = {}
def conn(self, cid):
ans = self.ws_connections.get(cid)
if ans is not None:
ans = ans()
return ans
def handle_websocket_upgrade(self, connection_id, connection_ref, inheaders):
self.ws_connections[connection_id] = connection_ref
def handle_websocket_data(self, connection_id, data, message_starting, message_finished):
self.conn(connection_id).send_websocket_frame(data, message_starting, message_finished)
def handle_websocket_pong(self, connection_id, data):
pass
def handle_websocket_close(self, connection_id):
self.ws_connections.pop(connection_id, None)
def run_echo_server():
s = ServerLoop(create_http_handler(websocket_handler=EchoHandler()))
with HandleInterrupt(s.wakeup):
s.serve_forever()
if __name__ == '__main__':
# import cProfile
# cProfile.runctx('r()', {'r':run_echo_server}, {}, filename='stats.profile')
run_echo_server()
# }}}
| 21,546 | Python | .py | 490 | 33.473469 | 124 | 0.602155 | kovidgoyal/calibre | 19,243 | 2,250 | 4 | GPL-3.0 | 9/5/2024, 5:13:50 PM (Europe/Amsterdam) |
26,609 | handler.py | kovidgoyal_calibre/src/calibre/srv/handler.py | #!/usr/bin/env python
# License: GPLv3 Copyright: 2015, Kovid Goyal <kovid at kovidgoyal.net>
import json
from functools import partial
from importlib import import_module
from threading import Lock
from calibre.srv.auth import AuthController
from calibre.srv.errors import HTTPForbidden
from calibre.srv.library_broker import LibraryBroker, path_for_db
from calibre.srv.routes import Router
from calibre.srv.users import UserManager
from calibre.utils.date import utcnow
from calibre.utils.search_query_parser import ParseException
from polyglot.builtins import itervalues
class Context:
log = None
url_for = None
jobs_manager = None
CATEGORY_CACHE_SIZE = 25
SEARCH_CACHE_SIZE = 100
def __init__(self, libraries, opts, testing=False, notify_changes=None):
self.opts = opts
self.library_broker = libraries if isinstance(libraries, LibraryBroker) else LibraryBroker(libraries)
self.testing = testing
self.lock = Lock()
self.user_manager = UserManager(opts.userdb)
self.ignored_fields = frozenset(filter(None, (x.strip() for x in (opts.ignored_fields or '').split(','))))
self.displayed_fields = frozenset(filter(None, (x.strip() for x in (opts.displayed_fields or '').split(','))))
self._notify_changes = notify_changes
def notify_changes(self, library_path, change_event):
if self._notify_changes is not None:
self._notify_changes(library_path, change_event)
def start_job(self, name, module, func, args=(), kwargs=None, job_done_callback=None, job_data=None):
return self.jobs_manager.start_job(name, module, func, args, kwargs, job_done_callback, job_data)
def job_status(self, job_id):
return self.jobs_manager.job_status(job_id)
def abort_job(self, job_id):
return self.jobs_manager.abort_job(job_id)
def is_field_displayable(self, field):
if self.displayed_fields and field not in self.displayed_fields:
return False
return field not in self.ignored_fields
def init_session(self, endpoint, data):
pass
def finalize_session(self, endpoint, data, output):
pass
def get_library(self, request_data, library_id=None):
if not request_data.username:
return self.library_broker.get(library_id)
lf = partial(self.user_manager.allowed_library_names, request_data.username)
allowed_libraries = self.library_broker.allowed_libraries(lf)
if not allowed_libraries:
raise HTTPForbidden(f'The user {request_data.username} is not allowed to access any libraries on this server')
library_id = library_id or next(iter(allowed_libraries))
if library_id in allowed_libraries:
return self.library_broker.get(library_id)
raise HTTPForbidden(f'The user {request_data.username} is not allowed to access the library {library_id}')
def library_info(self, request_data):
if not request_data.username:
return self.library_broker.library_map, self.library_broker.default_library
lf = partial(self.user_manager.allowed_library_names, request_data.username)
allowed_libraries = self.library_broker.allowed_libraries(lf)
if not allowed_libraries:
raise HTTPForbidden(f'The user {request_data.username} is not allowed to access any libraries on this server')
return dict(allowed_libraries), next(iter(allowed_libraries))
def restriction_for(self, request_data, db):
return self.user_manager.library_restriction(request_data.username, path_for_db(db))
def has_id(self, request_data, db, book_id):
restriction = self.restriction_for(request_data, db)
if restriction:
try:
return book_id in db.search('', restriction=restriction)
except ParseException:
return False
return db.has_id(book_id)
def newest_book_ids(self, request_data, db, count=5):
restriction = self.restriction_for(request_data, db)
allowed_book_ids = None
if restriction:
allowed_book_ids = db.search('', restriction=restriction)
return db.newly_added_book_ids(count=count, book_ids=allowed_book_ids)
def get_allowed_book_ids_from_restriction(self, request_data, db):
restriction = self.restriction_for(request_data, db)
return frozenset(db.search('', restriction=restriction)) if restriction else None
def allowed_book_ids(self, request_data, db):
try:
ans = self.get_allowed_book_ids_from_restriction(request_data, db)
except ParseException:
return frozenset()
if ans is None:
ans = db.all_book_ids()
return ans
def check_for_write_access(self, request_data):
if not request_data.username:
if request_data.is_trusted_ip:
return
raise HTTPForbidden('Anonymous users are not allowed to make changes')
if self.user_manager.is_readonly(request_data.username):
raise HTTPForbidden(f'The user {request_data.username} does not have permission to make changes')
def get_effective_book_ids(self, db, request_data, vl, report_parse_errors=False):
try:
return db.books_in_virtual_library(vl, self.restriction_for(request_data, db))
except ParseException:
if report_parse_errors:
raise
return frozenset()
def get_categories(self, request_data, db, sort='name', first_letter_sort=True,
vl='', report_parse_errors=False):
restrict_to_ids = self.get_effective_book_ids(db, request_data, vl,
report_parse_errors=report_parse_errors)
key = restrict_to_ids, sort, first_letter_sort
with self.lock:
cache = self.library_broker.category_caches[db.server_library_id]
old = cache.pop(key, None)
if old is None or old[0] <= db.last_modified():
categories = db.get_categories(book_ids=restrict_to_ids, sort=sort, first_letter_sort=first_letter_sort)
cache[key] = old = (utcnow(), categories)
if len(cache) > self.CATEGORY_CACHE_SIZE:
cache.popitem(last=False)
else:
cache[key] = old
return old[1]
def get_tag_browser(self, request_data, db, opts, render, vl=''):
restrict_to_ids = self.get_effective_book_ids(db, request_data, vl)
key = restrict_to_ids, opts
with self.lock:
cache = self.library_broker.category_caches[db.server_library_id]
old = cache.pop(key, None)
if old is None or old[0] <= db.last_modified():
categories = db.get_categories(book_ids=restrict_to_ids, sort=opts.sort_by, first_letter_sort=opts.collapse_model == 'first letter')
data = json.dumps(render(db, categories), ensure_ascii=False)
if isinstance(data, str):
data = data.encode('utf-8')
cache[key] = old = (utcnow(), data)
if len(cache) > self.CATEGORY_CACHE_SIZE:
cache.popitem(last=False)
else:
cache[key] = old
return old[1]
def search(self, request_data, db, query, vl='', report_restriction_errors=False):
try:
restrict_to_ids = self.get_effective_book_ids(db, request_data, vl, report_parse_errors=report_restriction_errors)
except ParseException:
try:
self.get_allowed_book_ids_from_restriction(request_data, db)
except ParseException as e:
return frozenset(), e
return frozenset(), None
query = query or ''
key = query, restrict_to_ids
with self.lock:
cache = self.library_broker.search_caches[db.server_library_id]
old = cache.pop(key, None)
if old is None or old[0] < db.clear_search_cache_count:
matches = db.search(query, book_ids=restrict_to_ids)
cache[key] = old = (db.clear_search_cache_count, matches)
if len(cache) > self.SEARCH_CACHE_SIZE:
cache.popitem(last=False)
else:
cache[key] = old
if report_restriction_errors:
return old[1], None
return old[1]
SRV_MODULES = ('ajax', 'books', 'cdb', 'code', 'content', 'legacy', 'opds', 'users_api', 'convert', 'fts')
class Handler:
def __init__(self, libraries, opts, testing=False, notify_changes=None):
ctx = Context(libraries, opts, testing=testing, notify_changes=notify_changes)
self.auth_controller = None
if opts.auth:
has_ssl = opts.ssl_certfile is not None and opts.ssl_keyfile is not None
prefer_basic_auth = {'auto':has_ssl, 'basic':True}.get(opts.auth_mode, False)
self.auth_controller = AuthController(
user_credentials=ctx.user_manager, prefer_basic_auth=prefer_basic_auth, ban_time_in_minutes=opts.ban_for, ban_after=opts.ban_after)
self.router = Router(ctx=ctx, url_prefix=opts.url_prefix, auth_controller=self.auth_controller)
for module in SRV_MODULES:
module = import_module('calibre.srv.' + module)
self.router.load_routes(itervalues(vars(module)))
self.router.finalize()
self.router.ctx.url_for = self.router.url_for
self.dispatch = self.router.dispatch
def set_log(self, log):
self.router.ctx.log = log
if self.auth_controller is not None:
self.auth_controller.log = log
def set_jobs_manager(self, jobs_manager):
self.router.ctx.jobs_manager = jobs_manager
def close(self):
self.router.ctx.library_broker.close()
@property
def ctx(self):
return self.router.ctx
| 9,991 | Python | .py | 191 | 42.115183 | 148 | 0.647414 | kovidgoyal/calibre | 19,243 | 2,250 | 4 | GPL-3.0 | 9/5/2024, 5:13:50 PM (Europe/Amsterdam) |
26,610 | jobs.py | kovidgoyal_calibre/src/calibre/srv/jobs.py | #!/usr/bin/env python
# License: GPLv3 Copyright: 2016, Kovid Goyal <kovid at kovidgoyal.net>
import os
import time
from collections import deque, namedtuple
from functools import partial
from itertools import count
from threading import Event, RLock, Thread
from calibre import detect_ncpus, force_unicode
from calibre.utils.ipc.simple_worker import WorkerError, fork_job
from calibre.utils.monotonic import monotonic
from polyglot.builtins import iteritems, itervalues
from polyglot.queue import Empty, Queue
StartEvent = namedtuple('StartEvent', 'job_id name module function args kwargs callback data')
DoneEvent = namedtuple('DoneEvent', 'job_id')
class Job(Thread):
daemon = True
def __init__(self, start_event, events_queue):
Thread.__init__(self, name='JobsMonitor%s' % start_event.job_id)
self.abort_event = Event()
self.events_queue = events_queue
self.job_name = start_event.name
self.job_id = start_event.job_id
self.func = partial(fork_job, start_event.module, start_event.function, start_event.args, start_event.kwargs, abort=self.abort_event)
self.data, self.callback = start_event.data, start_event.callback
self.result = self.traceback = None
self.done = False
self.start_time = monotonic()
self.end_time = self.log_path = None
self.wait_for_end = Event()
self.start()
def run(self):
func, self.func = self.func, None
try:
result = func()
except WorkerError as err:
import traceback
self.traceback = err.orig_tb or traceback.format_exc()
self.log_path = getattr(err, 'log_path', None)
else:
self.result, self.log_path = result['result'], result['stdout_stderr']
self.done = True
self.end_time = monotonic()
self.wait_for_end.set()
self.events_queue.put(DoneEvent(self.job_id))
@property
def was_aborted(self):
return self.done and self.result is None and self.abort_event.is_set()
@property
def failed(self):
return bool(self.traceback) or self.was_aborted
def remove_log(self):
lp, self.log_path = self.log_path, None
if lp:
try:
os.remove(lp)
except OSError:
pass
def read_log(self):
ans = ''
if self.log_path is not None:
try:
with open(self.log_path, 'rb') as f:
ans = f.read()
except OSError:
pass
if isinstance(ans, bytes):
ans = force_unicode(ans, 'utf-8')
return ans
class JobsManager:
def __init__(self, opts, log):
mj = opts.max_jobs
if mj < 1:
mj = detect_ncpus()
self.log = log
self.max_jobs = max(1, mj)
self.max_job_time = max(0, opts.max_job_time * 60)
self.lock = RLock()
self.jobs = {}
self.finished_jobs = {}
self.events = Queue()
self.job_id = count()
self.waiting_job_ids = set()
self.waiting_jobs = deque()
self.max_block = None
self.shutting_down = False
self.event_loop = None
def start_job(self, name, module, func, args=(), kwargs=None, job_done_callback=None, job_data=None):
with self.lock:
if self.shutting_down:
return None
if self.event_loop is None:
self.event_loop = t = Thread(name='JobsEventLoop', target=self.run)
t.daemon = True
t.start()
job_id = next(self.job_id)
self.events.put(StartEvent(job_id, name, module, func, args, kwargs or {}, job_done_callback, job_data))
self.waiting_job_ids.add(job_id)
return job_id
def job_status(self, job_id):
with self.lock:
if not self.shutting_down:
if job_id in self.finished_jobs:
job = self.finished_jobs[job_id]
return 'finished', job.result, job.traceback, job.was_aborted
if job_id in self.jobs:
return 'running', None, None, None
if job_id in self.waiting_job_ids:
return 'waiting', None, None, None
return None, None, None, None
def abort_job(self, job_id):
job = self.jobs.get(job_id)
if job is not None:
job.abort_event.set()
def wait_for_running_job(self, job_id, timeout=None):
job = self.jobs.get(job_id)
if job is not None:
job.wait_for_end.wait(timeout)
if not job.done:
return False
while job_id not in self.finished_jobs:
time.sleep(0.001)
return True
def shutdown(self, timeout=5.0):
with self.lock:
self.shutting_down = True
for job in itervalues(self.jobs):
job.abort_event.set()
self.events.put(False)
def wait_for_shutdown(self, wait_till):
for job in itervalues(self.jobs):
delta = wait_till - monotonic()
if delta > 0:
job.join(delta)
if self.event_loop is not None:
delta = wait_till - monotonic()
if delta > 0:
self.event_loop.join(delta)
# Internal API {{{
def run(self):
while not self.shutting_down:
if self.max_block is None:
ev = self.events.get()
else:
try:
ev = self.events.get(block=True, timeout=self.max_block)
except Empty:
ev = None
if self.shutting_down:
break
if ev is None:
self.abort_hanging_jobs()
elif isinstance(ev, StartEvent):
self.waiting_jobs.append(ev)
self.start_waiting_jobs()
elif isinstance(ev, DoneEvent):
self.job_finished(ev.job_id)
elif ev is False:
break
def start_waiting_jobs(self):
with self.lock:
while self.waiting_jobs and len(self.jobs) < self.max_jobs:
ev = self.waiting_jobs.popleft()
self.jobs[ev.job_id] = Job(ev, self.events)
self.waiting_job_ids.discard(ev.job_id)
self.update_max_block()
def update_max_block(self):
with self.lock:
mb = None
now = monotonic()
for job in itervalues(self.jobs):
if not job.done and not job.abort_event.is_set():
delta = self.max_job_time - (now - job.start_time)
if delta <= 0:
self.max_block = 0
return
if mb is None:
mb = delta
else:
mb = min(mb, delta)
self.max_block = mb
def abort_hanging_jobs(self):
now = monotonic()
found = False
for job in itervalues(self.jobs):
if not job.done and not job.abort_event.is_set():
delta = self.max_job_time - (now - job.start_time)
if delta <= 0:
job.abort_event.set()
found = True
if found:
self.update_max_block()
def job_finished(self, job_id):
with self.lock:
self.finished_jobs[job_id] = job = self.jobs.pop(job_id)
if job.callback is not None:
try:
job.callback(job)
except Exception:
import traceback
self.log.error(f'Error running callback for job: {job.name}:\n{traceback.format_exc()}')
self.prune_finished_jobs()
if job.traceback and not job.was_aborted:
logdata = job.read_log()
self.log.error(f'The job: {job.job_name} failed:\n{logdata}\n{job.traceback}')
job.remove_log()
self.start_waiting_jobs()
def prune_finished_jobs(self):
with self.lock:
remove = []
now = monotonic()
for job_id, job in iteritems(self.finished_jobs):
if now - job.end_time > 3600:
remove.append(job_id)
for job_id in remove:
del self.finished_jobs[job_id]
# }}}
def sleep_test(x):
time.sleep(x)
return x
def error_test():
raise Exception('a testing error')
| 8,590 | Python | .py | 222 | 27.310811 | 141 | 0.553569 | kovidgoyal/calibre | 19,243 | 2,250 | 4 | GPL-3.0 | 9/5/2024, 5:13:50 PM (Europe/Amsterdam) |
26,611 | content.py | kovidgoyal_calibre/src/calibre/srv/tests/content.py | #!/usr/bin/env python
__license__ = 'GPL v3'
__copyright__ = '2015, Kovid Goyal <kovid at kovidgoyal.net>'
import json
import os
import time
import zlib
from io import BytesIO
from calibre.ebooks.metadata.epub import get_metadata
from calibre.ebooks.metadata.opf2 import OPF
from calibre.srv.tests.base import LibraryBaseTest
from calibre.utils.imghdr import identify
from calibre.utils.resources import get_image_path as I
from calibre.utils.resources import get_path as P
from calibre.utils.shared_file import share_open
from polyglot import http_client
from polyglot.binary import from_hex_unicode
def setUpModule():
# Needed for cover generation
from calibre.gui2 import ensure_app, load_builtin_fonts
ensure_app(), load_builtin_fonts()
class ContentTest(LibraryBaseTest):
def test_static(self): # {{{
'Test serving of static content'
with self.create_server() as server:
conn = server.connect()
def missing(url, body=b''):
conn.request('GET', url)
r = conn.getresponse()
self.ae(r.status, http_client.NOT_FOUND)
self.ae(r.read(), body)
for prefix in ('static', 'icon'):
missing('/%s/missing.xxx' % prefix)
missing('/%s/../out.html' % prefix, b'Naughty, naughty!')
missing('/%s/C:/out.html' % prefix, b'Naughty, naughty!')
def test_response(r):
self.assertIn('max-age=', r.getheader('Cache-Control'))
self.assertIn('public', r.getheader('Cache-Control'))
self.assertIsNotNone(r.getheader('Expires'))
self.assertIsNotNone(r.getheader('ETag'))
self.assertIsNotNone(r.getheader('Content-Type'))
def test(src, url, sz=None):
raw = P(src, data=True)
conn.request('GET', url)
r = conn.getresponse()
self.ae(r.status, http_client.OK)
data = r.read()
if sz is None:
self.ae(data, raw)
else:
self.ae(sz, identify(data)[1])
test_response(r)
conn.request('GET', url, headers={'If-None-Match':r.getheader('ETag')})
r = conn.getresponse()
self.ae(r.status, http_client.NOT_MODIFIED)
self.ae(b'', r.read())
test('content-server/empty.html', '/static/empty.html')
test('images/lt.png', '/favicon.png')
test('images/lt.png', '/icon/lt.png?sz=full')
test('images/lt.png', '/icon/lt.png', sz=48)
test('images/lt.png', '/icon/lt.png?sz=16', sz=16)
# }}}
def test_get(self): # {{{
'Test /get'
with self.create_server() as server:
db = server.handler.router.ctx.library_broker.get(None)
conn = server.connect()
def get(what, book_id, library_id=None, q=''):
q = ('?' + q) if q else q
conn.request('GET', f'/get/{what}/{book_id}' + (('/' + library_id) if library_id else '') + q)
r = conn.getresponse()
return r, r.read()
# Test various invalid parameters
def bad(*args):
r, data = get(*args)
self.ae(r.status, http_client.NOT_FOUND)
bad('xxx', 1)
bad('fmt1', 10)
bad('fmt1', 1, 'zzzz')
bad('fmt1', 'xx')
# Test simple fetching of format without metadata update
r, data = get('fmt1', 1, db.server_library_id)
self.ae(data, db.format(1, 'fmt1'))
self.assertIsNotNone(r.getheader('Content-Disposition'))
self.ae(r.getheader('Used-Cache'), 'no')
r, data = get('fmt1', 1)
self.ae(data, db.format(1, 'fmt1'))
self.ae(r.getheader('Used-Cache'), 'yes')
# Test fetching of format with metadata update
raw = P('quick_start/eng.epub', data=True)
r, data = get('epub', 1)
self.ae(r.status, http_client.OK)
etag = r.getheader('ETag')
self.assertIsNotNone(etag)
self.ae(r.getheader('Used-Cache'), 'no')
self.assertTrue(data.startswith(b'PK'))
self.assertGreaterEqual(len(data), len(raw))
db.set_field('title', {1:'changed'})
r, data = get('epub', 1)
self.assertNotEqual(r.getheader('ETag'), etag)
etag = r.getheader('ETag')
self.ae(r.getheader('Used-Cache'), 'no')
mi = get_metadata(BytesIO(data), extract_cover=False)
self.ae(mi.title, 'changed')
r, data = get('epub', 1)
self.ae(r.getheader('Used-Cache'), 'yes')
# Test plugboards
import calibre.library.save_to_disk as c
orig, c.DEBUG = c.DEBUG, False
try:
db.set_pref('plugboards', {'epub': {'content_server': [['changed, {title}', 'title']]}})
# this is needed as the cache is not invalidated for plugboard changes
db.set_field('title', {1:'again'})
r, data = get('epub', 1)
self.assertNotEqual(r.getheader('ETag'), etag)
etag = r.getheader('ETag')
self.ae(r.getheader('Used-Cache'), 'no')
mi = get_metadata(BytesIO(data), extract_cover=False)
self.ae(mi.title, 'changed, again')
finally:
c.DEBUG = orig
# Test the serving of covers
def change_cover(count, book_id=2):
cpath = db.format_abspath(book_id, '__COVER_INTERNAL__')
db.set_cover({2:I('lt.png', data=True)})
t = time.time() + 1 + count
# Ensure mtime changes, needed on OS X where HFS+ has a 1s
# mtime resolution
os.utime(cpath, (t, t))
r, data = get('cover', 1)
self.ae(r.status, http_client.OK)
self.ae(data, db.cover(1))
self.ae(r.getheader('Used-Cache'), 'no')
self.ae(r.getheader('Content-Type'), 'image/jpeg')
r, data = get('cover', 1)
self.ae(r.status, http_client.OK)
self.ae(data, db.cover(1))
self.ae(r.getheader('Used-Cache'), 'yes')
r, data = get('cover', 3)
self.ae(r.status, http_client.OK) # Auto generated cover
r, data = get('thumb', 1)
self.ae(r.status, http_client.OK)
self.ae(identify(data), ('jpeg', 60, 60))
self.ae(r.getheader('Used-Cache'), 'no')
r, data = get('thumb', 1)
self.ae(r.status, http_client.OK)
self.ae(r.getheader('Used-Cache'), 'yes')
r, data = get('thumb', 1, q='sz=100')
self.ae(r.status, http_client.OK)
self.ae(identify(data), ('jpeg', 100, 100))
self.ae(r.getheader('Used-Cache'), 'no')
r, data = get('thumb', 1, q='sz=100x100')
self.ae(r.status, http_client.OK)
self.ae(r.getheader('Used-Cache'), 'yes')
change_cover(1, 1)
r, data = get('thumb', 1, q='sz=100')
self.ae(r.status, http_client.OK)
self.ae(identify(data), ('jpeg', 100, 100))
self.ae(r.getheader('Used-Cache'), 'no')
# Test file sharing in cache
r, data = get('cover', 2)
self.ae(r.status, http_client.OK)
self.ae(data, db.cover(2))
self.ae(r.getheader('Used-Cache'), 'no')
path = from_hex_unicode(r.getheader('Tempfile'))
f, fdata = share_open(path, 'rb'), data
# Now force an update
change_cover(1)
r, data = get('cover', 2)
self.ae(r.status, http_client.OK)
self.ae(data, db.cover(2))
self.ae(r.getheader('Used-Cache'), 'no')
path = from_hex_unicode(r.getheader('Tempfile'))
f2, f2data = share_open(path, 'rb'), data
# Do it again
change_cover(2)
r, data = get('cover', 2)
self.ae(r.status, http_client.OK)
self.ae(data, db.cover(2))
self.ae(r.getheader('Used-Cache'), 'no')
self.ae(f.read(), fdata)
self.ae(f2.read(), f2data)
# Test serving of metadata as opf
r, data = get('opf', 1)
self.ae(r.status, http_client.OK)
self.ae(r.getheader('Content-Type'), 'application/oebps-package+xml; charset=UTF-8')
self.assertIsNotNone(r.getheader('Last-Modified'))
opf = OPF(BytesIO(data), populate_spine=False, try_to_guess_cover=False)
self.ae(db.field_for('title', 1), opf.title)
self.ae(db.field_for('authors', 1), tuple(opf.authors))
conn.request('GET', '/get/opf/1', headers={'Accept-Encoding':'gzip'})
r = conn.getresponse()
self.ae(r.status, http_client.OK), self.ae(r.getheader('Content-Encoding'), 'gzip')
raw = r.read()
self.ae(zlib.decompress(raw, 16+zlib.MAX_WBITS), data)
# Test serving metadata as json
r, data = get('json', 1)
self.ae(r.status, http_client.OK)
self.ae(db.field_for('title', 1), json.loads(data)['title'])
conn.request('GET', '/get/json/1', headers={'Accept-Encoding':'gzip'})
r = conn.getresponse()
self.ae(r.status, http_client.OK), self.ae(r.getheader('Content-Encoding'), 'gzip')
raw = r.read()
self.ae(zlib.decompress(raw, 16+zlib.MAX_WBITS), data)
# }}}
def test_char_count(self): # {{{
from calibre.ebooks.oeb.parse_utils import html5_parse
from calibre.srv.render_book import get_length
root = html5_parse('<p>a b\nc\td\re')
self.ae(get_length(root), 5)
root = html5_parse('<script>xyz</script>a<iMg>b')
self.ae(get_length(root), 1002)
root = html5_parse('<p><!-- abc -->m')
self.ae(get_length(root), 1)
# }}}
def test_html_as_json(self): # {{{
from calibre.ebooks.oeb.parse_utils import html5_parse
from calibre.srv.render_book import html_as_json
def t(html, body_children, nsmap=('http://www.w3.org/1999/xhtml',)):
root = html5_parse(html)
raw = html_as_json(root)
# print(raw.decode('utf-8'))
data = json.loads(raw)
self.ae(data['version'], 1)
self.ae(tuple(data['ns_map']), nsmap)
bc = data['tree']['c'][1]['c']
self.ae(bc, body_children)
t('<p>a<!--c-->t</p>l', [{"n":"p","x":"a","l":"l","c":[{"s":"c","x":"c","l":"t"}]}])
t('<p class="foo" id="bar">a', [{"n":"p","x":"a","a":[['class','foo'],['id','bar']]}])
t(
'<svg xlink:href="h"></svg>', [{'n': 'svg', 's': 1, 'a': [['href', 'h', 2]]}],
('http://www.w3.org/1999/xhtml', 'http://www.w3.org/2000/svg', 'http://www.w3.org/1999/xlink')
)
text = 'üêà\n\t\\m≈´s"'
t(f"<p id='{text}'>Peña", [{"n":"p","x":"Peña","a":[['id',text]]}])
text = 'a' * (127 * 1024)
t('<p>{0}<p>{0}'.format(text), [{"n":"p","x":text}, {'n':'p','x':text}])
# }}}
def test_last_read_cache(self): # {{{
from calibre.srv.last_read import last_read_cache, path_cache
path_cache.clear()
lrc = last_read_cache(':memory:')
epoch = lrc.add_last_read_position('lib', 1, 'FMT', 'user', 'epubcfi(/)', 0.1, 'tt')
expected = {'library_id': 'lib', 'book_id': 1, 'format': 'FMT', 'cfi': 'epubcfi(/)', 'epoch': epoch, 'pos_frac': 0.1, 'tooltip': 'tt'}
self.ae(lrc.get_recently_read('user'), [expected])
epoch = lrc.add_last_read_position('lib', 1, 'FMT', 'user', 'epubcfi(/)', 0.2, 'tt')
expected['epoch'], expected['pos_frac'] = epoch, 0.2
self.ae(lrc.get_recently_read('user'), [expected])
for book_id in range(2, 7):
lrc.add_last_read_position('lib', book_id, 'FMT', 'user', 'epubcfi(/)', 0.1, 'tt')
self.ae(len(lrc.get_recently_read('user')), lrc.limit)
# }}}
| 12,298 | Python | .py | 252 | 36.738095 | 142 | 0.530548 | kovidgoyal/calibre | 19,243 | 2,250 | 4 | GPL-3.0 | 9/5/2024, 5:13:50 PM (Europe/Amsterdam) |
26,612 | fast_css_transform.py | kovidgoyal_calibre/src/calibre/srv/tests/fast_css_transform.py | #!/usr/bin/env python
# License: GPL v3 Copyright: 2021, Kovid Goyal <kovid at kovidgoyal.net>
import ast
from calibre.srv.tests.base import SimpleTest
from calibre_extensions.fast_css_transform import parse_css_number, transform_properties
class TestTransform(SimpleTest):
def test_counting_chars_in_elems(self):
from lxml import etree
from calibre.ebooks.oeb.polish.parsing import parse
from calibre.srv.render_book import get_length
def t(html, expected):
root = parse(html, force_html5_parse=True)
self.assertEqual(expected, get_length(root), etree.tostring(root, encoding=str))
t('<p>abc<span>def</span>x yz<svg>howdy', 1014)
t('<p>abc<span>def</span>x yz', 9)
t('<p>abc<span>def</span><script>x yz', 6)
t('<p>abc<span>def</span><style>x yz', 6)
t('<p>abc<span>def</span>x yz<img>howdy', 1014)
t('<p>abc<span>def</span>x yz<img><!-- howdy -->howdy', 1014)
def test_number_parsing(self):
for x in '.314 -.314 0.314 0 2 +2 -1 1e2 -3.14E+2 2e-2'.split():
self.ae(parse_css_number(x), ast.literal_eval(x))
self.ae(parse_css_number('2em'), 2)
self.ae(parse_css_number('.3em'), 0.3)
self.ae(parse_css_number('3x3'), 3)
def test_basic_css_transforms(self):
def d(src, expected, is_declaration=True, url_callback=None):
self.ae(transform_properties(src, is_declaration=is_declaration, url_callback=url_callback), expected)
def upper_case(val):
return val.upper()
def u(src, expected, is_declaration=True, url_callback=upper_case):
return d(src, expected, url_callback=url_callback, is_declaration=is_declaration)
def s(src, expected, url_callback=upper_case):
return d(src, expected, url_callback=url_callback, is_declaration=False)
s('.c { page-break-after: 1 always }', '.c { break-after: 1 always ; -webkit-column-break-after: 1 always }')
s('.c { page-break-after: always\ncolor:red }', '.c { break-after: always; -webkit-column-break-after: always\ncolor:red }')
s('.c { page-break-after: always\n}', '.c { break-after: always; -webkit-column-break-after: always\n}')
s('.c { page-break-after: always;color:red }', '.c { break-after: always; -webkit-column-break-after: always;color:red }')
s('.c { page-break-after: /**/always }', '.c { break-after: always ; -webkit-column-break-after: always }')
s('.c { page-break-after: always !important }', '.c { break-after: always !important ; -webkit-column-break-after: always !important }')
s('.c { page-break-after: always;}', '.c { break-after: always; -webkit-column-break-after: always;}')
s('.c{x:url(y)}', '.c{x:url("Y")}')
s('@im/* c */port "x.y";', '@import "X.Y";')
s('@import url("narrow.css") supports(display: flex) handheld and (max-width: 400px);',
'@import url("NARROW.CSS") supports(display: flex) handheld and (max-width: 400px);')
s('@import url( x/*a*/.y);', '@import url("X.Y");')
u('background: url( te st.gif ) 12; src: url(x)', 'background: url("TE ST.GIF") 12; src: url("X")')
u('background: url(te/**/st.gif); xxx: url()', 'background: url("TEST.GIF"); xxx: url()')
u(r'background: uRl(t\)e/st.gif)', 'background: url("T)E/ST.GIF")')
u('a:url( "( )" /**/ )', 'a:url("( )")')
u('a:url( "(/*)" )', 'a:url( "(/*)" )', url_callback=lambda x: x)
d('font-size: 197583965730245.28px', 'font-size: 1.2349e+13rem')
d('font-size: 19.28px', 'font-size: 1.205rem')
d('font-size:+19.28px', 'font-size:1.205rem')
d('font-size: .28in', 'font-size: 1.68rem')
d('font-size: +.28in', 'font-size: 1.68rem')
d(r'f\ont-s\69z\65 : 16\px', 'font-size: 1rem')
d('font -size: 16px', 'font -size: 16px')
d('font-/* */size: 1/*x*/6/**/p/**/x !important', 'font-size: 1rem !important')
d('fOnt-size :16px', 'fOnt-size :1rem')
d('fönt-size :16px', 'fönt-size :16px')
d('font-size:2%', 'font-size:2%')
d('font-size: 72pt; margin: /*here*/ 20px; font-size: 2in', 'font-size: 6rem; margin: /*here*/ 20px; font-size: 12rem')
d(r'''font: "some 'name" 32px''', 'font: "some \'name" 2rem')
d(r'''font: 'some "name' 32px''', 'font: \'some "name\' 2rem')
d(r'''font: 'some \n ame' 32px''', 'font: "some n ame" 2rem')
d('''font: 'some \\\nname' 32px''', 'font: "some name" 2rem')
d('font: sans-serif 16px/3', 'font: sans-serif 1rem/3')
d('font: sans-serif small/17', 'font: sans-serif 0.8rem/17')
d('-epub-writing-mode: a; -web/* */kit-writing-mode: b; writing-mode: c', 'writing-mode: a; writing-mode: b; writing-mode: c')
d('xxx:yyy', 'xxx:yyy')
d('page-break-before: always', 'break-before: always; -webkit-column-break-before: always')
sheet = '''
@import "b/loc.test";
@media screen {
font: 16px calc(20vw - 30rem);
.cls {
color: red;
font-size: 16px;
background: url("b/loc.test")
}
#moo.cat {
x: url("b/loc.test")
}
@zoo {
not(.woo) and why {
font: 16px "something something" 16;
page-break-before: avoid
}
}
}
.why { font: 16px}
'''
s(sheet, sheet.replace('16px', '1rem').replace('b/loc.test', 'B/LOC.TEST').replace('page-', 'break-before: avoid; -webkit-column-'))
| 5,500 | Python | .py | 94 | 50.234043 | 144 | 0.588039 | kovidgoyal/calibre | 19,243 | 2,250 | 4 | GPL-3.0 | 9/5/2024, 5:13:50 PM (Europe/Amsterdam) |
26,613 | auth.py | kovidgoyal_calibre/src/calibre/srv/tests/auth.py | #!/usr/bin/env python
__license__ = 'GPL v3'
__copyright__ = '2015, Kovid Goyal <kovid at kovidgoyal.net>'
import os
import shutil
import subprocess
import time
from collections import namedtuple
from calibre.constants import ismacos
from calibre.ptempfile import TemporaryDirectory
from calibre.srv.errors import HTTPForbidden
from calibre.srv.routes import Router, endpoint
from calibre.srv.tests.base import BaseTest, TestServer
from polyglot import http_client
from polyglot.binary import as_base64_bytes
from polyglot.builtins import iteritems, itervalues
from polyglot.http_cookie import CookieJar
from polyglot.urllib import HTTPBasicAuthHandler, HTTPCookieProcessor, HTTPDigestAuthHandler, HTTPError, build_opener
REALM = 'calibre-test'
is_ci = os.environ.get('CI', '').lower() == 'true'
@endpoint('/open', auth_required=False)
def noauth(ctx, data):
return 'open'
@endpoint('/closed', auth_required=True)
def auth(ctx, data):
return 'closed'
@endpoint('/android', auth_required=True, android_workaround=True)
def android(ctx, data):
return 'android'
@endpoint('/android2', auth_required=True, android_workaround=True)
def android2(ctx, data):
return 'android2'
def router(prefer_basic_auth=False, ban_for=0, ban_after=5):
from calibre.srv.auth import AuthController
return Router(itervalues(globals()), auth_controller=AuthController(
{'testuser':'testpw', '!@#$%^&*()-=_+':'!@#$%^&*()-=_+'},
ban_time_in_minutes=ban_for, ban_after=ban_after,
prefer_basic_auth=prefer_basic_auth, realm=REALM, max_age_seconds=1))
def urlopen(server, path='/closed', un='testuser', pw='testpw', method='digest'):
auth_handler = HTTPBasicAuthHandler() if method == 'basic' else HTTPDigestAuthHandler()
url = 'http://localhost:%d%s' % (server.address[1], path)
auth_handler.add_password(realm=REALM, uri=url, user=un, passwd=pw)
return build_opener(auth_handler).open(url)
def digest(un, pw, nonce=None, uri=None, method='GET', nc=1, qop='auth', realm=REALM, cnonce=None, algorithm='MD5', body=b'', modify=lambda x:None):
'Create the payload for a digest based Authorization header'
from calibre.srv.auth import DigestAuth
templ = ('username="{un}", realm="{realm}", qop={qop}, method="{method}",'
' nonce="{nonce}", uri="{uri}", nc={nc}, algorithm="{algorithm}", cnonce="{cnonce}", response="{response}"')
h = templ.format(un=un, realm=realm, qop=qop, uri=uri, method=method, nonce=nonce, nc=nc, cnonce=cnonce, algorithm=algorithm, response=None)
da = DigestAuth(h)
modify(da)
pw = getattr(da, 'pw', pw)
class Data:
def __init__(self):
self.method = method
def peek(self):
return body
response = da.request_digest(pw, Data())
return ('Digest ' + templ.format(
un=un, realm=realm, qop=qop, uri=uri, method=method, nonce=nonce, nc=nc, cnonce=cnonce, algorithm=algorithm, response=response)).encode('ascii')
class TestAuth(BaseTest):
def test_basic_auth(self): # {{{
'Test HTTP Basic auth'
r = router(prefer_basic_auth=True)
with TestServer(r.dispatch) as server:
r.auth_controller.log = server.log
conn = server.connect()
conn.request('GET', '/open')
r = conn.getresponse()
self.ae(r.status, http_client.OK)
self.ae(r.read(), b'open')
conn.request('GET', '/closed')
r = conn.getresponse()
self.ae(r.status, http_client.UNAUTHORIZED)
self.ae(r.getheader('WWW-Authenticate'), 'Basic realm="%s"' % REALM)
self.assertFalse(r.read())
conn.request('GET', '/closed', headers={'Authorization': b'Basic ' + as_base64_bytes(b'testuser:testpw')})
r = conn.getresponse()
self.ae(r.read(), b'closed')
self.ae(r.status, http_client.OK)
self.ae(b'closed', urlopen(server, method='basic').read())
self.ae(b'closed', urlopen(server, un='!@#$%^&*()-=_+', pw='!@#$%^&*()-=_+', method='basic').read())
def request(un='testuser', pw='testpw'):
conn.request('GET', '/closed', headers={'Authorization': b'Basic ' + as_base64_bytes(f'{un}:{pw}')})
r = conn.getresponse()
return r.status, r.read()
warnings = []
server.loop.log.warn = lambda *args, **kwargs: warnings.append(' '.join(args))
self.ae((http_client.OK, b'closed'), request())
self.ae((http_client.UNAUTHORIZED, b''), request('x', 'y'))
self.ae((http_client.BAD_REQUEST, b'The username or password was empty'), request('', ''))
self.ae(1, len(warnings))
self.ae((http_client.UNAUTHORIZED, b''), request('testuser', 'y'))
self.ae((http_client.BAD_REQUEST, b'The username or password was empty'), request('testuser', ''))
self.ae((http_client.BAD_REQUEST, b'The username or password was empty'), request(''))
self.ae((http_client.UNAUTHORIZED, b''), request('asf', 'testpw'))
# }}}
def test_library_restrictions(self): # {{{
from calibre.db.legacy import create_backend
from calibre.srv.handler import Handler
from calibre.srv.opts import Options
opts = Options(userdb=':memory:')
Data = namedtuple('Data', 'username')
with TemporaryDirectory() as base:
l1, l2, l3 = map(lambda x: os.path.join(base, 'l' + x), '123')
for l in (l1, l2, l3):
create_backend(l).close()
ctx = Handler((l1, l2, l3), opts).router.ctx
um = ctx.user_manager
def get_library(username=None, library_id=None):
ans = ctx.get_library(Data(username), library_id=library_id)
return os.path.basename(ans.backend.library_path)
def library_info(username=None):
lmap, defaultlib = ctx.library_info(Data(username))
lmap = {k:os.path.basename(v) for k, v in iteritems(lmap)}
return lmap, defaultlib
self.assertEqual(get_library(), 'l1')
self.assertEqual(library_info()[0], {'l%d'%i:'l%d'%i for i in range(1, 4)})
self.assertEqual(library_info()[1], 'l1')
self.assertRaises(HTTPForbidden, get_library, 'xxx')
um.add_user('a', 'a')
self.assertEqual(library_info('a')[0], {'l%d'%i:'l%d'%i for i in range(1, 4)})
um.update_user_restrictions('a', {'blocked_library_names': ['L2']})
self.assertEqual(library_info('a')[0], {'l%d'%i:'l%d'%i for i in range(1, 4) if i != 2})
um.update_user_restrictions('a', {'allowed_library_names': ['l3']})
self.assertEqual(library_info('a')[0], {'l%d'%i:'l%d'%i for i in range(1, 4) if i == 3})
self.assertEqual(library_info('a')[1], 'l3')
self.assertRaises(HTTPForbidden, get_library, 'a', 'l1')
self.assertRaises(HTTPForbidden, get_library, 'xxx')
# }}}
def test_digest_auth(self): # {{{
'Test HTTP Digest auth'
from calibre.srv.http_request import normalize_header_name
from calibre.srv.utils import parse_http_dict
r = router()
with TestServer(r.dispatch) as server:
r.auth_controller.log = server.log
def test(conn, path, headers={}, status=http_client.OK, body=b'', request_body=b''):
conn.request('GET', path, request_body, headers)
r = conn.getresponse()
self.ae(r.status, status)
self.ae(r.read(), body)
return {normalize_header_name(k):v for k, v in r.getheaders()}
conn = server.connect()
test(conn, '/open', body=b'open')
auth = parse_http_dict(test(conn, '/closed', status=http_client.UNAUTHORIZED)['WWW-Authenticate'].partition(' ')[2])
nonce = auth['nonce']
auth = parse_http_dict(test(conn, '/closed', status=http_client.UNAUTHORIZED)['WWW-Authenticate'].partition(' ')[2])
self.assertNotEqual(nonce, auth['nonce'], 'nonce was re-used')
self.ae(auth['realm'], REALM)
self.ae(auth['algorithm'], 'MD5')
self.ae(auth['qop'], 'auth')
self.assertNotIn('stale', auth)
args = auth.copy()
args['un'], args['pw'], args['uri'] = 'testuser', 'testpw', '/closed'
def ok_test(conn, dh, **args):
args['body'] = args.get('body', b'closed')
return test(conn, '/closed', headers={'Authorization':dh}, **args)
ok_test(conn, digest(**args))
# Check that server ignores repeated nc values
ok_test(conn, digest(**args))
warnings = []
server.loop.log.warn = lambda *args, **kwargs: warnings.append(' '.join(args))
# Check stale nonces
orig, r.auth_controller.max_age_seconds = r.auth_controller.max_age_seconds, -1
auth = parse_http_dict(test(conn, '/closed', headers={
'Authorization':digest(**args)},status=http_client.UNAUTHORIZED)['WWW-Authenticate'].partition(' ')[2])
self.assertIn('stale', auth)
r.auth_controller.max_age_seconds = orig
ok_test(conn, digest(**args))
def fail_test(conn, modify, **kw):
kw['body'] = kw.get('body', b'')
kw['status'] = kw.get('status', http_client.UNAUTHORIZED)
args['modify'] = modify
return test(conn, '/closed', headers={'Authorization':digest(**args)}, **kw)
# Check modified nonce fails
fail_test(conn, lambda da:setattr(da, 'nonce', 'xyz'))
fail_test(conn, lambda da:setattr(da, 'nonce', 'x' + da.nonce))
# Check mismatched uri fails
fail_test(conn, lambda da:setattr(da, 'uri', '/'))
fail_test(conn, lambda da:setattr(da, 'uri', '/closed2'))
fail_test(conn, lambda da:setattr(da, 'uri', '/closed/2'))
# Check that incorrect user/password fails
fail_test(conn, lambda da:setattr(da, 'pw', '/'))
fail_test(conn, lambda da:setattr(da, 'username', '/'))
fail_test(conn, lambda da:setattr(da, 'username', ''))
fail_test(conn, lambda da:setattr(da, 'pw', ''))
fail_test(conn, lambda da:(setattr(da, 'pw', ''), setattr(da, 'username', '')))
# Check against python's stdlib
self.ae(urlopen(server).read(), b'closed')
# Check using curl
curl = shutil.which('curl')
if curl and not (is_ci and ismacos): # curl mysteriously returns b'' in CI with no errors
def docurl(data, *args):
cmd = [curl, '--silent'] + list(args) + ['http://localhost:%d/closed' % server.address[1]]
p = subprocess.Popen(cmd, stdin=subprocess.DEVNULL, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
stdout, stderr = p.communicate()
p.wait()
self.ae(stdout, data, f'stderr:\n{stderr.decode(errors="replace")}')
docurl(b'')
docurl(b'', '--digest', '--user', 'xxxx:testpw')
docurl(b'', '--digest', '--user', 'testuser:xtestpw')
docurl(b'closed', '--digest', '--user', 'testuser:testpw')
# }}}
def test_fail_ban(self): # {{{
ban_for = 0.5/60.0
r = router(prefer_basic_auth=True, ban_for=ban_for, ban_after=2)
with TestServer(r.dispatch) as server:
r.auth_controller.log = server.log
conn = server.connect()
def request(un='testuser', pw='testpw'):
conn.request('GET', '/closed', headers={'Authorization': b'Basic ' + as_base64_bytes(f'{un}:{pw}')})
r = conn.getresponse()
return r.status, r.read()
warnings = []
server.loop.log.warn = lambda *args, **kwargs: warnings.append(' '.join(args))
self.ae((http_client.OK, b'closed'), request())
self.ae((http_client.UNAUTHORIZED, b''), request('x', 'y'))
self.ae((http_client.UNAUTHORIZED, b''), request('x', 'y'))
self.ae(http_client.FORBIDDEN, request('x', 'y')[0])
self.ae(http_client.FORBIDDEN, request()[0])
time.sleep(ban_for * 60 + 0.01)
self.ae((http_client.OK, b'closed'), request())
# }}}
def test_android_auth_workaround(self): # {{{
'Test authentication workaround for Android'
r = router()
with TestServer(r.dispatch) as server:
r.auth_controller.log = server.log
conn = server.connect()
# First check that unauth access fails
conn.request('GET', '/android')
r = conn.getresponse()
self.ae(r.status, http_client.UNAUTHORIZED)
auth_handler = HTTPDigestAuthHandler()
url = 'http://localhost:%d%s' % (server.address[1], '/android')
auth_handler.add_password(realm=REALM, uri=url, user='testuser', passwd='testpw')
cj = CookieJar()
cookie_handler = HTTPCookieProcessor(cj)
r = build_opener(auth_handler, cookie_handler).open(url)
self.ae(r.getcode(), http_client.OK)
cookies = tuple(cj)
self.ae(len(cookies), 1)
cookie = cookies[0]
self.assertIn(':', cookie.value)
self.ae(cookie.path, '/android')
r = build_opener(cookie_handler).open(url)
self.ae(r.getcode(), http_client.OK)
self.ae(r.read(), b'android')
# Test that a replay attack against a different URL does not work
try:
build_opener(cookie_handler).open(url+'2')
assert ('Replay attack succeeded')
except HTTPError as e:
self.ae(e.code, http_client.UNAUTHORIZED)
# }}}
| 14,053 | Python | .py | 256 | 43.914063 | 152 | 0.587589 | kovidgoyal/calibre | 19,243 | 2,250 | 4 | GPL-3.0 | 9/5/2024, 5:13:50 PM (Europe/Amsterdam) |
26,614 | base.py | kovidgoyal_calibre/src/calibre/srv/tests/base.py | #!/usr/bin/env python
__license__ = 'GPL v3'
__copyright__ = '2011, Kovid Goyal <kovid@kovidgoyal.net>'
__docformat__ = 'restructuredtext en'
import atexit
import gc
import os
import shutil
import tempfile
import time
import unittest
from functools import partial
from io import BytesIO
from threading import Thread
from calibre.srv.utils import ServerLog
from calibre.utils.resources import get_image_path as I
from calibre.utils.resources import get_path as P
from polyglot import http_client
rmtree = partial(shutil.rmtree, ignore_errors=True)
class SimpleTest(unittest.TestCase):
longMessage = True
maxDiff = None
ae = unittest.TestCase.assertEqual
class BaseTest(SimpleTest):
def run(self, result=None):
# we retry failing server tests since they are flaky on CI
if result is None:
result = self.defaultTestResult()
max_retries = 1
for i in range(max_retries + 1):
failures_before = len(result.failures)
errors_before = len(result.errors)
ret = super().run(result=result)
if len(result.failures) == failures_before and len(result.errors) == errors_before:
return ret
print(f'Retrying test {self._testMethodName} after failure/error')
if i < max_retries:
q = result.failures if len(result.failures) > failures_before else result.errors
q.pop(-1)
time.sleep(1)
class LibraryBaseTest(BaseTest):
def setUp(self):
from calibre.utils.recycle_bin import nuke_recycle
nuke_recycle()
self.library_path = self.mkdtemp()
self.create_db(self.library_path)
def tearDown(self):
from calibre.utils.recycle_bin import restore_recyle
restore_recyle()
gc.collect(), gc.collect()
try:
shutil.rmtree(self.library_path)
except OSError:
# Try again in case something transient has a file lock on windows
gc.collect(), gc.collect()
time.sleep(2)
shutil.rmtree(self.library_path)
def mkdtemp(self):
ans = tempfile.mkdtemp(prefix='db_test_')
atexit.register(rmtree, ans)
return ans
def create_db(self, library_path):
from calibre.db.cache import Cache
from calibre.db.legacy import create_backend
d = os.path.dirname
src = os.path.join(d(d(d(os.path.abspath(__file__)))), 'db', 'tests', 'metadata.db')
dest = os.path.join(library_path, 'metadata.db')
shutil.copy2(src, dest)
db = Cache(create_backend(library_path))
db.init()
db.set_cover({1:I('lt.png', data=True), 2:I('polish.png', data=True)})
db.add_format(1, 'FMT1', BytesIO(b'book1fmt1'), run_hooks=False)
with open(P('quick_start/eng.epub'), 'rb') as src:
db.add_format(1, 'EPUB', src, run_hooks=False)
db.add_format(1, 'FMT2', BytesIO(b'book1fmt2'), run_hooks=False)
db.add_format(2, 'FMT1', BytesIO(b'book2fmt1'), run_hooks=False)
db.backend.conn.close()
return dest
def create_server(self, *args, **kwargs):
args = (self.library_path ,) + args
return LibraryServer(*args, **kwargs)
class TestServer(Thread):
daemon = True
def __init__(self, handler, plugins=(), **kwargs):
Thread.__init__(self, name='ServerMain')
from calibre.srv.http_response import create_http_handler
from calibre.srv.loop import ServerLoop
from calibre.srv.opts import Options
self.setup_defaults(kwargs)
self.loop = ServerLoop(
create_http_handler(handler),
opts=Options(**kwargs),
plugins=plugins,
log=ServerLog(level=ServerLog.DEBUG),
)
self.log = self.loop.log
def setup_defaults(self, kwargs):
kwargs['shutdown_timeout'] = kwargs.get('shutdown_timeout', 0.1)
kwargs['listen_on'] = kwargs.get('listen_on', 'localhost')
kwargs['port'] = kwargs.get('port', 0)
kwargs['userdb'] = kwargs.get('userdb', ':memory:')
def run(self):
try:
self.loop.serve_forever()
except KeyboardInterrupt:
pass
def __enter__(self):
self.start()
while not self.loop.ready and self.is_alive():
time.sleep(0.01)
self.address = self.loop.bound_address[:2]
return self
def __exit__(self, *args):
try:
self.loop.stop()
except Exception as e:
self.log.error('Failed to stop server with error:', e)
self.join(self.loop.opts.shutdown_timeout)
self.loop.close_control_connection()
self.log.close()
def connect(self, timeout=None, interface=None):
if timeout is None:
timeout = self.loop.opts.timeout
if interface is None:
interface = self.address[0]
ans = http_client.HTTPConnection(interface, self.address[1], timeout=timeout)
ans.connect()
return ans
def change_handler(self, handler):
from calibre.srv.http_response import create_http_handler
self.loop.handler = create_http_handler(handler)
class LibraryServer(TestServer):
def __init__(self, library_path, libraries=(), plugins=(), **kwargs):
Thread.__init__(self, name='ServerMain')
from calibre.srv.handler import Handler
from calibre.srv.http_response import create_http_handler
from calibre.srv.loop import ServerLoop
from calibre.srv.opts import Options
self.setup_defaults(kwargs)
opts = Options(**kwargs)
self.libraries = libraries or (library_path,)
self.handler = Handler(self.libraries, opts, testing=True)
self.loop = ServerLoop(
create_http_handler(self.handler.dispatch),
opts=opts,
plugins=plugins,
log=ServerLog(level=ServerLog.DEBUG),
)
self.log = self.loop.log
self.handler.set_log(self.log)
def __exit__(self, *args):
try:
self.loop.stop()
except Exception as e:
self.log.error('Failed to stop server with error:', e)
self.handler.close()
self.join(self.loop.opts.shutdown_timeout)
self.loop.close_control_connection()
| 6,357 | Python | .py | 158 | 31.759494 | 96 | 0.632825 | kovidgoyal/calibre | 19,243 | 2,250 | 4 | GPL-3.0 | 9/5/2024, 5:13:50 PM (Europe/Amsterdam) |
26,615 | loop.py | kovidgoyal_calibre/src/calibre/srv/tests/loop.py | #!/usr/bin/env python
__license__ = 'GPL v3'
__copyright__ = '2015, Kovid Goyal <kovid at kovidgoyal.net>'
import os
import socket
import ssl
import time
from collections import namedtuple
from glob import glob
from threading import Event
from unittest import skipIf
from calibre.ptempfile import TemporaryDirectory
from calibre.srv.pre_activated import has_preactivated_support
from calibre.srv.tests.base import BaseTest, TestServer
from calibre.utils.certgen import create_server_cert
from calibre.utils.monotonic import monotonic
from polyglot import http_client
is_ci = os.environ.get('CI', '').lower() == 'true'
class LoopTest(BaseTest):
def test_log_rotation(self):
'Test log rotation'
from calibre.ptempfile import TemporaryDirectory
from calibre.srv.utils import RotatingLog
with TemporaryDirectory() as tdir:
fname = os.path.join(tdir, 'log')
l = RotatingLog(fname, max_size=100)
def history():
return {int(x.rpartition('.')[-1]) for x in glob(fname + '.*')}
def log_size():
ssize = l.outputs[0].stream.tell()
self.ae(ssize, os.path.getsize(fname))
return ssize
self.ae(log_size(), 0)
l('a' * 99)
self.ae(log_size(), 100)
l('b'), l('c')
self.ae(log_size(), 2)
self.ae(history(), {1})
for i in 'abcdefg':
l(i * 101)
self.assertLessEqual(log_size(), 100)
self.ae(history(), {1,2,3,4,5})
def test_plugins(self):
'Test plugin semantics'
class Plugin:
def __init__(self):
self.running = Event()
self.event = Event()
self.port = None
def start(self, loop):
self.running.set()
self.port = loop.bound_address[1]
self.event.wait()
self.running.clear()
def stop(self):
self.event.set()
plugin = Plugin()
with TestServer(lambda data:'xxx', plugins=(plugin,)) as server:
self.assertTrue(plugin.running.wait(0.2))
self.ae(plugin.port, server.address[1])
self.assertTrue(plugin.event.wait(5))
self.assertFalse(plugin.running.is_set())
def test_workers(self):
' Test worker semantics '
with TestServer(lambda data:(data.path[0] + data.read()), worker_count=3) as server:
self.ae(3, sum(int(w.is_alive()) for w in server.loop.pool.workers))
self.ae(0, sum(int(w.is_alive()) for w in server.loop.pool.workers))
# Test shutdown with hung worker
block = Event()
with TestServer(lambda data:block.wait(), worker_count=3, shutdown_timeout=0.1, timeout=0.1) as server:
pool = server.loop.pool
self.ae(3, sum(int(w.is_alive()) for w in pool.workers))
conn = server.connect()
conn.request('GET', '/')
with self.assertRaises(socket.timeout):
res = conn.getresponse()
if int(res.status) == int(http_client.REQUEST_TIMEOUT):
raise socket.timeout('Timeout')
raise Exception('Got unexpected response: code: {} {} headers: {!r} data: {!r}'.format(
res.status, res.reason, res.getheaders(), res.read()))
self.ae(pool.busy, 1)
self.ae(1, sum(int(w.is_alive()) for w in pool.workers))
block.set()
for w in pool.workers:
w.join()
self.ae(0, sum(int(w.is_alive()) for w in server.loop.pool.workers))
def test_fallback_interface(self):
'Test falling back to default interface'
with TestServer(lambda data:(data.path[0] + data.read()), listen_on='1.1.1.1', fallback_to_detected_interface=True) as server:
self.assertNotEqual('1.1.1.1', server.address[0])
@skipIf(True, 'Disabled as it is failing on the build server, need to investigate')
def test_bonjour(self):
'Test advertising via BonJour'
from zeroconf import Zeroconf
from calibre.srv.bonjour import BonJour
b = BonJour(wait_for_stop=False)
with TestServer(lambda data:(data.path[0] + data.read()), plugins=(b,), shutdown_timeout=5) as server:
self.assertTrue(b.started.wait(5), 'BonJour not started')
self.ae(b.advertised_port, server.address[1])
service = b.services[0]
self.ae(service.type, '_calibre._tcp.local.')
r = Zeroconf()
info = r.get_service_info(service.type, service.name)
self.assertIsNotNone(info)
self.ae(info.text, b'\npath=/opds')
self.assertTrue(b.stopped.wait(5), 'BonJour not stopped')
def test_dual_stack(self):
from calibre.srv.loop import IPPROTO_IPV6
with TestServer(lambda data:(data.path[0] + data.read().decode('utf-8')), listen_on='::') as server:
self.ae(server.address[0], '::')
self.ae(server.loop.socket.getsockopt(IPPROTO_IPV6, socket.IPV6_V6ONLY), 0)
conn = server.connect(interface='127.0.0.1')
conn.request('GET', '/test', 'body')
r = conn.getresponse()
self.ae(r.status, http_client.OK)
self.ae(r.read(), b'testbody')
def test_ring_buffer(self):
'Test the ring buffer used for reads'
class FakeSocket:
def __init__(self, data):
self.data = data
def recv_into(self, mv):
sz = min(len(mv), len(self.data))
mv[:sz] = self.data[:sz]
return sz
from calibre.srv.loop import READ, WRITE, ReadBuffer
buf = ReadBuffer(100)
def write(data):
return buf.recv_from(FakeSocket(data))
def set(data, rpos, wpos, state):
buf.ba = bytearray(data)
buf.buf = memoryview(buf.ba)
buf.read_pos, buf.write_pos, buf.full_state = rpos, wpos, state
self.ae(b'', buf.read(10))
self.assertTrue(buf.has_space), self.assertFalse(buf.has_data)
self.ae(write(b'a'*50), 50)
self.ae(write(b'a'*50), 50)
self.ae(write(b'a'*50), 0)
self.ae(buf.read(1000), bytes(buf.ba))
self.ae(b'', buf.read(10))
self.ae(write(b'a'*10), 10)
numbers = bytes(bytearray(range(10)))
set(numbers, 1, 3, READ)
self.ae(buf.read(1), b'\x01')
self.ae(buf.read(10), b'\x02')
self.ae(buf.full_state, WRITE)
set(numbers, 3, 1, READ)
self.ae(buf.read(1), b'\x03')
self.ae(buf.read(10), b'\x04\x05\x06\x07\x08\x09\x00')
set(numbers, 1, 3, READ)
self.ae(buf.readline(), b'\x01\x02')
set(b'123\n', 0, 3, READ)
self.ae(buf.readline(), b'123')
set(b'123\n', 0, 0, READ)
self.ae(buf.readline(), b'123\n')
self.ae(buf.full_state, WRITE)
set(b'1\n2345', 2, 2, READ)
self.ae(buf.readline(), b'23451\n')
self.ae(buf.full_state, WRITE)
set(b'1\n2345', 1, 1, READ)
self.ae(buf.readline(), b'\n')
set(b'1\n2345', 4, 1, READ)
self.ae(buf.readline(), b'451')
set(b'1\n2345', 4, 2, READ)
self.ae(buf.readline(), b'451\n')
set(b'123456\n7', 4, 2, READ)
self.ae(buf.readline(), b'56\n')
def test_ssl(self):
'Test serving over SSL'
address = '127.0.0.1'
with TemporaryDirectory('srv-test-ssl') as tdir:
cert_file, key_file, ca_file = map(lambda x:os.path.join(tdir, x), 'cka')
create_server_cert(address, ca_file, cert_file, key_file, key_size=2048)
ctx = ssl.create_default_context(cafile=ca_file)
ctx.verify_flags |= ssl.VERIFY_X509_STRICT
with TestServer(
lambda data:(data.path[0] + data.read().decode('utf-8')),
ssl_certfile=cert_file, ssl_keyfile=key_file, listen_on=address, port=0) as server:
conn = http_client.HTTPSConnection(address, server.address[1], context=ctx)
conn.request('GET', '/test', 'body')
r = conn.getresponse()
self.ae(r.status, http_client.OK)
self.ae(r.read(), b'testbody')
cert = conn.sock.getpeercert()
subject = dict(x[0] for x in cert['subject'])
self.ae(subject['commonName'], address)
@skipIf(not has_preactivated_support, 'pre_activated_socket not available')
def test_socket_activation(self):
'Test socket activation'
os.closerange(3, 4) # Ensure the socket gets fileno == 3
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM, 0)
s.bind(('localhost', 0))
s.listen() # pre-activated sockets are already listening
port = s.getsockname()[1]
self.ae(s.fileno(), 3)
os.environ['LISTEN_PID'] = str(os.getpid())
os.environ['LISTEN_FDS'] = '1'
with TestServer(lambda data:(data.path[0].encode('utf-8') + data.read()), allow_socket_preallocation=True) as server:
conn = server.connect()
conn.request('GET', '/test', 'body')
r = conn.getresponse()
self.ae(r.status, http_client.OK)
self.ae(r.read(), b'testbody')
self.ae(server.loop.bound_address[1], port)
def test_monotonic(self):
'Test the monotonic() clock'
a = monotonic()
b = monotonic()
self.assertGreaterEqual(b, a)
a = monotonic()
time.sleep(0.1)
b = monotonic()
self.assertGreaterEqual(b, a)
self.assertGreaterEqual(b - a, 0.09)
self.assertLessEqual(b - a, 0.4)
def test_jobs_manager(self):
'Test the jobs manager'
from calibre.srv.jobs import JobsManager
O = namedtuple('O', 'max_jobs max_job_time')
class FakeLog(list):
def error(self, *args):
self.append(' '.join(args))
s = ('waiting', 'running')
jm = JobsManager(O(1, 5), FakeLog())
def job_status(jid):
return jm.job_status(jid)[0]
# Start jobs
job_id1 = jm.start_job('simple test', 'calibre.srv.jobs', 'sleep_test', args=(1.0,))
job_id2 = jm.start_job('t2', 'calibre.srv.jobs', 'sleep_test', args=(3,))
job_id3 = jm.start_job('err test', 'calibre.srv.jobs', 'error_test')
# Job 1
job_id = job_id1
status = jm.job_status(job_id)[0]
self.assertIn(status, s)
for jid in (job_id2, job_id3):
self.assertEqual(job_status(jid), 'waiting')
while job_status(job_id) in s:
time.sleep(0.01)
status, result, tb, was_aborted = jm.job_status(job_id)
self.assertEqual(status, 'finished')
self.assertFalse(was_aborted)
self.assertFalse(tb)
self.assertEqual(result, 1.0)
# Job 2
job_id = job_id2
while job_status(job_id) == 'waiting':
time.sleep(0.01)
self.assertEqual('running', job_status(job_id))
jm.abort_job(job_id)
self.assertIn(jm.wait_for_running_job(job_id), (True, None))
status, result, tb, was_aborted = jm.job_status(job_id)
self.assertEqual('finished', status)
self.assertTrue(was_aborted)
# Job 3
job_id = job_id3
while job_status(job_id) == 'waiting':
time.sleep(0.01)
self.assertIn(jm.wait_for_running_job(job_id), (True, None))
status, result, tb, was_aborted = jm.job_status(job_id)
self.assertEqual(status, 'finished')
self.assertFalse(was_aborted)
self.assertTrue(tb)
self.assertIn('a testing error', tb)
jm.start_job('simple test', 'calibre.srv.jobs', 'sleep_test', args=(1.0,))
jm.shutdown(), jm.wait_for_shutdown(monotonic() + 1)
def find_tests():
import unittest
return unittest.defaultTestLoader.loadTestsFromTestCase(LoopTest)
| 12,073 | Python | .py | 268 | 34.701493 | 134 | 0.58118 | kovidgoyal/calibre | 19,243 | 2,250 | 4 | GPL-3.0 | 9/5/2024, 5:13:50 PM (Europe/Amsterdam) |
26,616 | routes.py | kovidgoyal_calibre/src/calibre/srv/tests/routes.py | #!/usr/bin/env python
__license__ = 'GPL v3'
__copyright__ = '2015, Kovid Goyal <kovid at kovidgoyal.net>'
import os
from tempfile import TemporaryDirectory
from calibre.srv.tests.base import BaseTest
from polyglot.builtins import itervalues
class TestRouter(BaseTest):
def test_library_id_construction(self):
from calibre.srv.library_broker import correct_case_of_last_path_component, db_matches, library_id_from_path
self.ae(library_id_from_path('as'), 'as')
self.ae(library_id_from_path('as/'), 'as')
self.ae(library_id_from_path('as////'), 'as')
self.ae(library_id_from_path('/as/'), 'as')
if os.sep == '\\':
self.ae(library_id_from_path('as/' + os.sep), 'as')
self.ae(library_id_from_path('X:' + os.sep), 'X')
class MockDB:
def __init__(self, base):
self.new_api = self
self.server_library_id = 'lid'
self.dbpath = os.path.join(base, 'metadata.db')
with TemporaryDirectory() as tdir:
path = os.path.join(tdir, 'Test')
os.mkdir(path)
self.ae(correct_case_of_last_path_component(os.path.join(tdir, 'test')), path)
self.ae(correct_case_of_last_path_component(os.path.join(tdir, 'Test')), path)
db = MockDB(tdir)
self.assertTrue(db_matches(db, db.server_library_id, None))
self.assertTrue(db_matches(db, db.server_library_id.upper(), tdir))
def test_route_construction(self):
' Test route construction '
from calibre.srv.routes import Route, RouteError, endpoint
def makeroute(route, func=lambda c,d:None, **kwargs):
return Route(endpoint(route, **kwargs)(func))
r = makeroute('/')
self.ae(r.matchers, [])
self.assertFalse(r.required_names)
r = makeroute('/slash/')
self.ae(r.endpoint.route, '/slash')
def emr(route):
self.assertRaises(RouteError, makeroute, route)
emr('no_start')
emr('/{xxx')
emr('/{+all}/{other}')
emr('/{t=}}')
emr('/{+all=1}')
emr('/{d=1}/no')
emr('/x/{a=1}')
self.assertRaises(RouteError, makeroute, '/a/b', lambda c,d,b,a:None)
def test_route_finding(self):
'Test route finding'
from calibre.srv.routes import HTTPNotFound, Router, endpoint
router = Router()
def find(path):
path = list(filter(None, path.split('/')))
ep, args = router.find_route(path)
args = list(args)
return ep, args
@endpoint('/')
def root(ctx, data):
pass
@endpoint('/defval/{a=1}')
def defval(ctx, data, a):
pass
@endpoint('/varpath/{a}/{b}')
def varpath(ctx, data, a, b):
pass
@endpoint('/soak/{+rest}')
def soak(ctx, dest, rest):
pass
@endpoint('/soak_opt/{+rest="xxx"}')
def soak_opt(ctx, dest, rest):
pass
@endpoint('/needs quoting/{x}')
def quoting(ctx, dest, x):
pass
@endpoint('/get/{a}/{b=None}')
def get(ctx, dest, a, b):
pass
for x in itervalues(locals()):
if getattr(x, 'is_endpoint', False):
router.add(x)
router.finalize()
ep, args = find('/')
self.ae(ep, root), self.assertFalse(args)
ep, args = find('/defval')
self.ae(ep, defval), self.ae(args, [1])
ep, args = find('/defval/2')
self.ae(ep, defval), self.ae(args, [2])
self.assertRaises(HTTPNotFound, find, '/defval/a') # a must be an integer
self.assertRaises(HTTPNotFound, find, '/varpath')
self.assertRaises(HTTPNotFound, find, '/varpath/x')
self.assertRaises(HTTPNotFound, find, '/varpath/x/y/z')
self.assertRaises(HTTPNotFound, find, '/soak')
ep, args = find('/varpath/x/y')
self.ae(ep, varpath), self.ae(args, ['x', 'y'])
ep, args = find('/soak/x')
self.ae(ep, soak), self.ae(args, ['x'])
self.ae(router.routes['/soak'].soak_up_extra, 'rest')
ep, args = find('/soak/x/y/z')
self.ae(ep, soak), self.ae(args, ['x/y/z'])
ep, args = find('/soak_opt')
self.ae(ep, soak_opt), self.ae(args, ['xxx'])
ep, args = find('/soak_opt/a/b')
self.ae(ep, soak_opt), self.ae(args, ['a/b'])
self.ae(router.url_for('/needs quoting', x='a/b c'), '/needs quoting/a%2Fb%20c')
self.ae(router.url_for(None), '/')
self.ae(router.url_for('/get', a='1', b='xxx'), '/get/1/xxx')
| 4,671 | Python | .py | 109 | 33.137615 | 116 | 0.558862 | kovidgoyal/calibre | 19,243 | 2,250 | 4 | GPL-3.0 | 9/5/2024, 5:13:50 PM (Europe/Amsterdam) |
26,617 | ajax.py | kovidgoyal_calibre/src/calibre/srv/tests/ajax.py | #!/usr/bin/env python
__license__ = 'GPL v3'
__copyright__ = '2015, Kovid Goyal <kovid at kovidgoyal.net>'
import json
import os
import zlib
from functools import partial
from io import BytesIO
from calibre.ebooks.metadata.meta import get_metadata
from calibre.srv.tests.base import LibraryBaseTest
from calibre.utils.localization import _
from polyglot.binary import as_base64_bytes
from polyglot.http_client import FORBIDDEN, NOT_FOUND, OK
from polyglot.urllib import quote, urlencode
def make_request(conn, url, headers={}, prefix='/ajax', username=None, password=None, method='GET', data=None):
if username and password:
headers[b'Authorization'] = b'Basic ' + as_base64_bytes(username + ':' + password)
conn.request(method, prefix + url, headers=headers, body=data)
r = conn.getresponse()
data = r.read()
if r.status == OK and data and data[0] in b'{[':
data = json.loads(data)
return r, data
class ContentTest(LibraryBaseTest):
def test_ajax_book(self): # {{{
'Test /ajax/book'
with self.create_server() as server:
db = server.handler.router.ctx.library_broker.get(None)
conn = server.connect()
request = partial(make_request, conn, prefix='/ajax/book')
r, data = request('/x')
self.ae(r.status, NOT_FOUND)
r, onedata = request('/1')
self.ae(r.status, OK)
self.ae(request('/1/' + db.server_library_id)[1], onedata)
self.ae(request('/%s?id_is_uuid=true' % db.field_for('uuid', 1))[1], onedata)
r, data = request('s')
self.ae(set(data), set(map(str, db.all_book_ids())))
r, zdata = request('s', headers={'Accept-Encoding':'gzip'})
self.ae(r.getheader('Content-Encoding'), 'gzip')
self.ae(json.loads(zlib.decompress(zdata, 16+zlib.MAX_WBITS)), data)
r, data = request('s?ids=1,2')
self.ae(set(data), {'1', '2'})
# }}}
def test_ajax_categories(self): # {{{
'Test /ajax/categories and /ajax/search'
with self.create_server() as server:
db = server.handler.router.ctx.library_broker.get(None)
db.set_pref('virtual_libraries', {'1':'title:"=Title One"'})
conn = server.connect()
request = partial(make_request, conn)
r, data = request('/categories')
self.ae(r.status, OK)
r, xdata = request('/categories/' + db.server_library_id)
self.ae(r.status, OK)
self.ae(data, xdata)
names = {x['name']:x['url'] for x in data}
for q in (_('Newest'), _('All books'), _('Tags'), _('Authors'), _('Enum'), _('Composite Tags')):
self.assertIn(q, names)
r, data = request(names[_('Tags')], prefix='')
self.ae(r.status, OK)
names = {x['name']:x['url'] for x in data['items']}
self.ae(set(names), set('Tag One,Tag Two,News'.split(',')))
r, data = request(names['Tag One'], prefix='')
self.ae(r.status, OK)
self.ae(set(data['book_ids']), {1, 2})
r, data = request('/search?' + urlencode({'query': 'tags:"=Tag One"'}))
self.ae(r.status, OK)
self.ae(set(data['book_ids']), {1, 2})
r, data = request('/search?' + urlencode({'query': 'tags:"=Tag One"', 'vl':'1'}))
self.ae(set(data['book_ids']), {2})
# }}}
def test_srv_restrictions(self): # {{{
' Test that virtual lib. + search restriction works on all end points'
with self.create_server(auth=True, auth_mode='basic') as server:
db = server.handler.router.ctx.library_broker.get(None)
db.set_pref('virtual_libraries', {'1':'id:1', '12':'id:1 or id:2'})
db.set_field('tags', {1: ['present'], 3: ['missing']})
self.assertTrue(db.has_id(3))
server.handler.ctx.user_manager.add_user('12', 'test', restriction={
'library_restrictions':{os.path.basename(db.backend.library_path): 'id:1 or id:2'}})
server.handler.ctx.user_manager.add_user('inv', 'test', restriction={
'library_restrictions':{os.path.basename(db.backend.library_path): '"1'}})
conn = server.connect()
def url_for(path, **kw):
p, q = path.partition('?')[::2]
ans = server.handler.router.url_for(p, **kw)
if q:
ans += '?' + q
return ans
ae = self.assertEqual
def r(path, status=OK, method='GET'):
r, data = make_request(conn, path, username='12', password='test', prefix='', method=method)
ae(status, r.status)
if status == NOT_FOUND:
p = data.partition(b':')[0]
ae(p, b'No book with id')
return data
ok = r
nf = partial(r, status=NOT_FOUND)
# ajax.py
ok(url_for('/ajax/book', book_id=1))
nf(url_for('/ajax/book', book_id=3))
data = ok(url_for('/ajax/books'))
self.assertIsNone(data['3'])
for i in '12':
self.assertIsNotNone(data[i])
ae(set(r(url_for('/ajax/search'))['book_ids']), {1,2})
ae(set(r(url_for('/ajax/search?query=id:2'))['book_ids']), {2})
ae(set(r(url_for('/ajax/search?vl=1'))['book_ids']), {1})
data = make_request(conn, '/ajax/search', username='inv', password='test', prefix='', method='GET')[1]
ae(data['bad_restriction'], _('Invalid syntax. Expected a lookup name or a word'))
# books.py
nf(url_for('/book-manifest', book_id=3, fmt='TXT'))
nf(url_for('/book-file', book_id=3, fmt='TXT', size=1, mtime=1, name='x'))
data = ok(url_for('/book-get-last-read-position', library_id=db.server_library_id, which='1-TXT_3-TXT'))
ae(set(data), {'1:TXT'})
nf(url_for('/book-set-last-read-position', book_id=3, library_id=db.server_library_id, fmt='TXT'), method='POST')
# cdb.py
r(url_for('/cdb/cmd', which='list'), status=FORBIDDEN)
r(url_for('/cdb/add-book', job_id=1, add_duplicates='n', filename='test.epub'), status=FORBIDDEN)
r(url_for('/cdb/delete-books', book_ids='1'), status=FORBIDDEN)
# code.py
def sr(path, **k):
return set(ok(url_for(path, **k))['search_result']['book_ids'])
for q in 'books-init init get-books'.split():
ae(sr('/interface-data/' + q), {1, 2})
ae(sr('/interface-data/get-books?vl=1'), {1})
ok(url_for('/interface-data/book-metadata', book_id=1))
nf(url_for('/interface-data/book-metadata', book_id=3))
# content.py
ok(url_for('/get', what='thumb', book_id=1))
nf(url_for('/get', what='thumb', book_id=3))
# Not going test legacy and opds as they are too painful
# }}}
def test_srv_add_book(self): # {{{
with self.create_server(auth=True, auth_mode='basic') as server:
server.handler.ctx.user_manager.add_user('12', 'test')
server.handler.ctx.user_manager.add_user('ro', 'test', readonly=True)
conn = server.connect()
ae = self.assertEqual
def a(filename, data=None, status=OK, method='POST', username='12', add_duplicates='n', job_id=1):
r, data = make_request(conn, '/cdb/add-book/{}/{}/{}'.format(job_id, add_duplicates, quote(filename.encode('utf-8'))),
username=username, password='test', prefix='', method=method, data=data)
ae(status, r.status)
return data
def d(book_ids, username='12', status=OK):
book_ids = ','.join(map(str, book_ids))
r, data = make_request(conn, f'/cdb/delete-books/{book_ids}',
username=username, password='test', prefix='', method='POST')
ae(status, r.status)
return data
a('test.epub', None, username='ro', status=FORBIDDEN)
content = b'content'
filename = 'test add - XXX.txt'
data = a(filename, content)
s = BytesIO(content)
s.name = filename
mi = get_metadata(s, stream_type='txt')
ae(data, {'title': mi.title, 'book_id': data['book_id'], 'authors': mi.authors, 'languages': mi.languages, 'id': '1', 'filename': filename})
r, q = make_request(conn, '/get/txt/{}'.format(data['book_id']), username='12', password='test', prefix='')
ae(r.status, OK)
ae(q, content)
d((1,), username='ro', status=FORBIDDEN)
d((1, data['book_id']))
# }}}
| 8,943 | Python | .py | 166 | 41.76506 | 153 | 0.546016 | kovidgoyal/calibre | 19,243 | 2,250 | 4 | GPL-3.0 | 9/5/2024, 5:13:50 PM (Europe/Amsterdam) |
26,618 | web_sockets.py | kovidgoyal_calibre/src/calibre/srv/tests/web_sockets.py | #!/usr/bin/env python
# License: GPLv3 Copyright: 2015, Kovid Goyal <kovid at kovidgoyal.net>
import errno
import numbers
import os
import socket
import struct
from collections import deque, namedtuple
from functools import partial
from hashlib import sha1
from calibre.srv.tests.base import BaseTest, TestServer
from calibre.srv.web_socket import (
BINARY,
CLOSE,
CONTINUATION,
CONTROL_CODES,
GUID_STR,
INCONSISTENT_DATA,
NORMAL_CLOSE,
PING,
PONG,
PROTOCOL_ERROR,
TEXT,
MessageWriter,
create_frame,
)
from calibre.utils.monotonic import monotonic
from calibre.utils.socket_inheritance import set_socket_inherit
from polyglot.binary import as_base64_unicode
HANDSHAKE_STR = '''\
GET / HTTP/1.1\r
Upgrade: websocket\r
Connection: Upgrade\r
Sec-WebSocket-Key: {}\r
Sec-WebSocket-Version: 13\r
''' + '\r\n'
Frame = namedtuple('Frame', 'fin opcode payload')
class WSClient:
def __init__(self, port, timeout=5):
self.timeout = timeout
self.socket = socket.create_connection(('localhost', port), timeout)
set_socket_inherit(self.socket, False)
self.key = as_base64_unicode(os.urandom(8))
self.socket.sendall(HANDSHAKE_STR.format(self.key).encode('ascii'))
self.read_buf = deque()
self.read_upgrade_response()
self.mask = memoryview(os.urandom(4))
self.frames = []
def read_upgrade_response(self):
from calibre.srv.http_request import read_headers
st = monotonic()
buf, idx = b'', -1
while idx == -1:
data = self.socket.recv(1024)
if not data:
raise ValueError('Server did not respond with a valid HTTP upgrade response')
buf += data
if len(buf) > 4096:
raise ValueError('Server responded with too much data to HTTP upgrade request')
if monotonic() - st > self.timeout:
raise ValueError('Timed out while waiting for server response to HTTP upgrade')
idx = buf.find(b'\r\n\r\n')
response, rest = buf[:idx+4], buf[idx+4:]
if rest:
self.read_buf.append(rest)
lines = (x + b'\r\n' for x in response.split(b'\r\n')[:-1])
rl = next(lines)
if rl != b'HTTP/1.1 101 Switching Protocols\r\n':
raise ValueError('Server did not respond with correct switching protocols line')
headers = read_headers(partial(next, lines))
key = as_base64_unicode(sha1((self.key + GUID_STR).encode('ascii')).digest())
if headers.get('Sec-WebSocket-Accept') != key:
raise ValueError('Server did not respond with correct key in Sec-WebSocket-Accept: {} != {}'.format(
key, headers.get('Sec-WebSocket-Accept')))
def recv(self, max_amt):
if self.read_buf:
data = self.read_buf.popleft()
if len(data) <= max_amt:
return data
self.read_buf.appendleft(data[max_amt+1:])
return data[:max_amt + 1]
try:
return self.socket.recv(max_amt)
except OSError as err:
if err.errno != errno.ECONNRESET:
raise
return b''
def read_size(self, size):
ans = b''
while len(ans) < size:
d = self.recv(size - len(ans))
if not d:
return None
ans += d
return ans
def read_frame(self):
x = self.read_size(2)
if x is None:
return None
b1, b2 = bytearray(x)
fin = bool(b1 & 0b10000000)
opcode = b1 & 0b1111
masked = b2 & 0b10000000
if masked:
raise ValueError('Got a frame with mask bit set from the server')
payload_length = b2 & 0b01111111
if payload_length == 126:
payload_length = struct.unpack(b'!H', self.read_size(2))[0]
elif payload_length == 127:
payload_length = struct.unpack(b'!Q', self.read_size(8))[0]
return Frame(fin, opcode, self.read_size(payload_length))
def read_messages(self):
messages, control_frames = [], []
msg_buf, opcode = [], None
while True:
frame = self.read_frame()
if frame is None or frame.payload is None:
break
if frame.opcode in CONTROL_CODES:
control_frames.append((frame.opcode, frame.payload))
else:
if opcode is None:
opcode = frame.opcode
msg_buf.append(frame.payload)
if frame.fin:
data = b''.join(msg_buf)
if opcode == TEXT:
data = data.decode('utf-8', 'replace')
messages.append((opcode, data))
msg_buf, opcode = [], None
return messages, control_frames
def write_message(self, msg, chunk_size=None):
if isinstance(msg, tuple):
opcode, msg = msg
if isinstance(msg, str):
msg = msg.encode('utf-8')
return self.write_frame(1, opcode, msg)
w = MessageWriter(msg, self.mask, chunk_size)
while True:
frame = w.create_frame()
if frame is None:
break
self.socket.sendall(frame.getvalue())
def write_frame(self, fin=1, opcode=CLOSE, payload=b'', rsv=0, mask=True):
frame = create_frame(fin, opcode, payload, rsv=(rsv << 4), mask=self.mask if mask else None)
self.socket.sendall(frame)
def write_close(self, code, reason=b''):
if isinstance(reason, str):
reason = reason.encode('utf-8')
self.write_frame(1, CLOSE, struct.pack(b'!H', code) + reason)
def __enter__(self):
return self
def __exit__(self, *a):
self.socket.close()
class WSTestServer(TestServer):
def __init__(self, handler):
TestServer.__init__(self, None, shutdown_timeout=5)
from calibre.srv.http_response import create_http_handler
self.loop.handler = create_http_handler(websocket_handler=handler())
@property
def ws_handler(self):
return self.loop.handler.websocket_handler
def connect(self):
return WSClient(self.address[1])
class WebSocketTest(BaseTest):
def simple_test(self, server, msgs, expected=(), close_code=NORMAL_CLOSE, send_close=True, close_reason=b'NORMAL CLOSE', ignore_send_failures=False):
with server.connect() as client:
for msg in msgs:
try:
if isinstance(msg, dict):
client.write_frame(**msg)
else:
client.write_message(msg)
except Exception:
if not ignore_send_failures:
raise
expected_messages, expected_controls = [], []
for ex in expected:
if isinstance(ex, str):
ex = TEXT, ex
elif isinstance(ex, bytes):
ex = BINARY, ex
elif isinstance(ex, numbers.Integral):
ex = ex, b''
if ex[0] in CONTROL_CODES:
expected_controls.append(ex)
else:
expected_messages.append(ex)
if send_close:
client.write_close(close_code, close_reason)
try:
messages, control_frames = client.read_messages()
except ConnectionAbortedError:
if expected_messages or expected_controls or send_close:
raise
return
self.ae(expected_messages, messages)
self.assertGreaterEqual(len(control_frames), 1)
self.ae(expected_controls, control_frames[:-1])
self.ae(control_frames[-1][0], CLOSE)
self.ae(close_code, struct.unpack_from(b'!H', control_frames[-1][1], 0)[0])
def test_websocket_basic(self):
'Test basic interaction with the websocket server'
from calibre.srv.web_socket import EchoHandler
with WSTestServer(EchoHandler) as server:
simple_test = partial(self.simple_test, server)
for q in ('', '*' * 125, '*' * 126, '*' * 127, '*' * 128, '*' * 65535, '*' * 65536, "Hello-µ@ßöäüàá-UTF-8!!"):
simple_test([q], [q])
for q in (b'', b'\xfe' * 125, b'\xfe' * 126, b'\xfe' * 127, b'\xfe' * 128, b'\xfe' * 65535, b'\xfe' * 65536):
simple_test([q], [q])
for payload in [b'', b'ping', b'\x00\xff\xfe\xfd\xfc\xfb\x00\xff', b"\xfe" * 125]:
simple_test([(PING, payload)], [(PONG, payload)])
simple_test([(PING, 'a'*126)], close_code=PROTOCOL_ERROR, send_close=False)
for payload in (b'', b'pong'):
simple_test([(PONG, payload)], [])
fragments = 'Hello-µ@ßöä üàá-UTF-8!!'.split()
nc = struct.pack(b'!H', NORMAL_CLOSE)
# It can happen that the server detects bad data and closes the
# connection before the client has finished sending all
# messages, so ignore failures to send packets.
isf_test = partial(simple_test, ignore_send_failures=True)
for rsv in range(1, 7):
isf_test([{'rsv':rsv, 'opcode':BINARY}], [], close_code=PROTOCOL_ERROR, send_close=False)
for opcode in (3, 4, 5, 6, 7, 11, 12, 13, 14, 15):
isf_test([{'opcode':opcode}], [], close_code=PROTOCOL_ERROR, send_close=False)
for opcode in (PING, PONG):
isf_test([
{'opcode':opcode, 'payload':'f1', 'fin':0}, {'opcode':opcode, 'payload':'f2'}
], close_code=PROTOCOL_ERROR, send_close=False)
isf_test([(CLOSE, nc + b'x'*124)], send_close=False, close_code=PROTOCOL_ERROR)
for fin in (0, 1):
isf_test([{'opcode':0, 'fin': fin, 'payload':b'non-continuation frame'}, 'some text'], close_code=PROTOCOL_ERROR, send_close=False)
isf_test([
{'opcode':TEXT, 'payload':fragments[0], 'fin':0}, {'opcode':CONTINUATION, 'payload':fragments[1]}, {'opcode':0, 'fin':0}
], [''.join(fragments)], close_code=PROTOCOL_ERROR, send_close=False)
isf_test([
{'opcode':TEXT, 'payload':fragments[0], 'fin':0}, {'opcode':TEXT, 'payload':fragments[1]},
], close_code=PROTOCOL_ERROR, send_close=False)
frags = []
for payload in (b'\xce\xba\xe1\xbd\xb9\xcf\x83\xce\xbc\xce\xb5', b'\xed\xa0\x80', b'\x80\x65\x64\x69\x74\x65\x64'):
frags.append({'opcode':(CONTINUATION if frags else TEXT), 'fin':1 if len(frags) == 2 else 0, 'payload':payload})
isf_test(frags, close_code=INCONSISTENT_DATA, send_close=False)
frags, q = [], b'\xce\xba\xe1\xbd\xb9\xcf\x83\xce\xbc\xce\xb5\xed\xa0\x80\x80\x65\x64\x69\x74\x65\x64'
for i in range(len(q)):
b = q[i:i+1]
frags.append({'opcode':(TEXT if i == 0 else CONTINUATION), 'fin':1 if i == len(q)-1 else 0, 'payload':b})
isf_test(frags, close_code=INCONSISTENT_DATA, send_close=False, ignore_send_failures=True)
for q in (b'\xce', b'\xce\xba\xe1'):
isf_test([{'opcode':TEXT, 'payload':q}], close_code=INCONSISTENT_DATA, send_close=False)
simple_test([
{'opcode':TEXT, 'payload':fragments[0], 'fin':0}, {'opcode':CONTINUATION, 'payload':fragments[1]}
], [''.join(fragments)])
simple_test([
{'opcode':TEXT, 'payload':fragments[0], 'fin':0}, (PING, b'pong'), {'opcode':CONTINUATION, 'payload':fragments[1]}
], [(PONG, b'pong'), ''.join(fragments)])
fragments = '12345'
simple_test([
{'opcode':TEXT, 'payload':fragments[0], 'fin':0}, {'opcode':CONTINUATION, 'payload':fragments[1], 'fin':0},
(PING, b'1'),
{'opcode':CONTINUATION, 'payload':fragments[2], 'fin':0}, {'opcode':CONTINUATION, 'payload':fragments[3], 'fin':0},
(PING, b'2'),
{'opcode':CONTINUATION, 'payload':fragments[4]}
], [(PONG, b'1'), (PONG, b'2'), fragments])
simple_test([
{'opcode':TEXT, 'fin':0}, {'opcode':CONTINUATION, 'fin':0}, {'opcode':CONTINUATION},], [''])
simple_test([
{'opcode':TEXT, 'fin':0}, {'opcode':CONTINUATION, 'fin':0, 'payload':'x'}, {'opcode':CONTINUATION},], ['x'])
for q in (b'\xc2\xb5', b'\xce\xba\xe1\xbd\xb9\xcf\x83\xce\xbc\xce\xb5', "Hello-µ@ßöäüàá-UTF-8!!".encode()):
frags = []
for i in range(len(q)):
b = q[i:i+1]
frags.append({'opcode':(TEXT if i == 0 else CONTINUATION), 'fin':1 if i == len(q)-1 else 0, 'payload':b})
simple_test(frags, [q.decode('utf-8')])
simple_test([(CLOSE, nc), (CLOSE, b'\x01\x01')], send_close=False)
simple_test([(CLOSE, nc), (PING, b'ping')], send_close=False)
simple_test([(CLOSE, nc), 'xxx'], send_close=False)
simple_test([{'opcode':TEXT, 'payload':'xxx', 'fin':0}, (CLOSE, nc), {'opcode':CONTINUATION, 'payload':'yyy'}], send_close=False)
simple_test([(CLOSE, b'')], send_close=False)
simple_test([(CLOSE, b'\x01')], send_close=False, close_code=PROTOCOL_ERROR)
simple_test([(CLOSE, nc + b'x'*123)], send_close=False)
simple_test([(CLOSE, nc + b'a\x80\x80')], send_close=False, close_code=PROTOCOL_ERROR)
for code in (1000,1001,1002,1003,1007,1008,1009,1010,1011,3000,3999,4000,4999):
simple_test([(CLOSE, struct.pack(b'!H', code))], send_close=False, close_code=code)
for code in (0,999,1004,1005,1006,1012,1013,1014,1015,1016,1100,2000,2999):
simple_test([(CLOSE, struct.pack(b'!H', code))], send_close=False, close_code=PROTOCOL_ERROR)
def test_websocket_perf(self):
from calibre.srv.web_socket import EchoHandler
with WSTestServer(EchoHandler) as server:
simple_test = partial(self.simple_test, server)
for sz in (64, 256, 1024, 4096, 8192, 16384):
sz *= 1024
t, b = 'a'*sz, b'a'*sz
simple_test([t, b], [t, b])
def find_tests():
import unittest
return unittest.defaultTestLoader.loadTestsFromTestCase(WebSocketTest)
| 14,614 | Python | .py | 296 | 37.601351 | 153 | 0.56472 | kovidgoyal/calibre | 19,243 | 2,250 | 4 | GPL-3.0 | 9/5/2024, 5:13:50 PM (Europe/Amsterdam) |
26,619 | main.py | kovidgoyal_calibre/src/calibre/srv/tests/main.py | #!/usr/bin/env python
__license__ = 'GPL v3'
__copyright__ = '2015, Kovid Goyal <kovid at kovidgoyal.net>'
from calibre.utils.run_tests import find_tests_in_package, run_tests
def find_tests():
return find_tests_in_package('calibre.srv.tests')
if __name__ == '__main__':
try:
import init_calibre # noqa
except ImportError:
pass
run_tests(find_tests)
| 390 | Python | .py | 12 | 28.25 | 68 | 0.671159 | kovidgoyal/calibre | 19,243 | 2,250 | 4 | GPL-3.0 | 9/5/2024, 5:13:50 PM (Europe/Amsterdam) |
26,620 | http.py | kovidgoyal_calibre/src/calibre/srv/tests/http.py | #!/usr/bin/env python
__license__ = 'GPL v3'
__copyright__ = '2015, Kovid Goyal <kovid at kovidgoyal.net>'
import hashlib
import os
import string
import time
import zlib
from io import BytesIO
from tempfile import NamedTemporaryFile
from calibre import guess_type
from calibre.srv.tests.base import BaseTest, TestServer
from calibre.srv.utils import eintr_retry_call
from calibre.utils.monotonic import monotonic
from calibre.utils.resources import get_path as P
from polyglot import http_client
from polyglot.builtins import iteritems
is_ci = os.environ.get('CI', '').lower() == 'true'
class TestHTTP(BaseTest):
def test_header_parsing(self): # {{{
'Test parsing of HTTP headers'
from calibre.srv.http_request import HTTPHeaderParser
def test(name, *lines, **kwargs):
p = HTTPHeaderParser()
p.push(*lines)
self.assertTrue(p.finished)
self.assertSetEqual(set(p.hdict.items()), {(k.replace('_', '-').title(), v) for k, v in iteritems(kwargs)}, name + ' failed')
test('Continuation line parsing',
b'a: one',
b'b: two',
b' 2',
b'\t3',
b'c:three',
b'\r\n', a='one', b='two 2 3', c='three')
test('Non-ascii headers parsing',
'a:mūs\r'.encode(), b'\r\n', a='mūs')
test('Comma-separated parsing',
b'Accept-Encoding: one',
b'accept-Encoding: two',
b'\r\n', accept_encoding='one, two')
def parse(*lines):
lines = list(lines)
lines.append(b'\r\n')
self.assertRaises(ValueError, HTTPHeaderParser().push, *lines)
parse('Connection:mūs\r\n'.encode('utf-16'))
parse(b'Connection\r\n')
parse(b'Connection:a\r\n', b'\r\n')
parse(b' Connection:a\n')
parse(b':a\n')
# }}}
def test_accept_encoding(self): # {{{
'Test parsing of Accept-Encoding'
from calibre.srv.http_response import acceptable_encoding
def test(name, val, ans, allowed={'gzip'}):
self.ae(acceptable_encoding(val, allowed), ans, name + ' failed')
test('Empty field', '', None)
test('Simple', 'gzip', 'gzip')
test('Case insensitive', 'GZIp', 'gzip')
test('Multiple', 'gzip, identity', 'gzip')
test('Priority', '1;q=0.5, 2;q=0.75, 3;q=1.0', '3', {'1', '2', '3'})
# }}}
def test_accept_language(self): # {{{
'Test parsing of Accept-Language'
from calibre.srv.http_response import preferred_lang
def test(name, val, ans):
self.ae(preferred_lang(val, lambda x:(True, x, None)), ans, name + ' failed')
test('Empty field', '', 'en')
test('Simple', 'de', 'de')
test('Case insensitive', 'Es', 'es')
test('Multiple', 'fr, es', 'fr')
test('Priority', 'en;q=0.1, de;q=0.7, fr;q=0.5', 'de')
try:
self.do_accept_language()
except Exception:
# this test is flaky on the Linux CI machines
time.sleep(3)
self.do_accept_language()
def do_accept_language(self):
from calibre.utils.localization import get_translator
def handler(data):
return data.lang_code + data._('Unknown')
with TestServer(handler, timeout=1) as server:
conn = server.connect()
def test(al, q):
conn.request('GET', '/', headers={'Accept-Language': al})
r = conn.getresponse()
self.ae(r.status, http_client.OK)
q += get_translator(q)[-1].gettext('Unknown')
self.ae(r.read(), q.encode('utf-8'))
test('en', 'en')
test('eng', 'en')
test('es', 'es')
# }}}
def test_range_parsing(self): # {{{
'Test parsing of Range header'
from calibre.srv.http_response import get_ranges
def test(val, *args):
pval = get_ranges(val, 100)
if len(args) == 1 and args[0] is None:
self.assertIsNone(pval, val)
else:
self.assertListEqual([tuple(x) for x in pval], list(args), val)
test('crap', None)
test('crap=', None)
test('crap=1', None)
test('crap=1-2', None)
test('bytes=a-2')
test('bytes=0-99', (0, 99, 100))
test('bytes=0-0,-1', (0, 0, 1), (99, 99, 1))
test('bytes=-5', (95, 99, 5))
test('bytes=95-', (95, 99, 5))
test('bytes=-200', (0, 99, 100))
# }}}
def test_http_basic(self): # {{{
'Test basic HTTP protocol conformance'
try:
self.do_http_basic()
except Exception:
# this test is a little flaky on the windows CI machine.
time.sleep(3)
self.do_http_basic()
def do_http_basic(self):
from calibre.srv.errors import HTTPNotFound, HTTPRedirect
body = 'Requested resource not found'
def handler(data):
raise HTTPNotFound(body)
def raw_send(conn, raw):
conn.send(raw)
conn._HTTPConnection__state = http_client._CS_REQ_SENT
return conn.getresponse()
base_timeout = 0.5 if is_ci else 0.1
with TestServer(handler, timeout=base_timeout, max_header_line_size=100./1024, max_request_body_size=100./(1024*1024)) as server:
conn = server.connect()
r = raw_send(conn, b'hello\n')
self.ae(r.status, http_client.BAD_REQUEST)
self.ae(r.read(), b'HTTP requires CRLF line terminators')
r = raw_send(conn, b'\r\nGET /index.html HTTP/1.1\r\n\r\n')
self.ae(r.status, http_client.NOT_FOUND), self.ae(r.read(), b'Requested resource not found')
r = raw_send(conn, b'\r\n\r\nGET /index.html HTTP/1.1\r\n\r\n')
self.ae(r.status, http_client.BAD_REQUEST)
self.ae(r.read(), b'Multiple leading empty lines not allowed')
r = raw_send(conn, b'hello world\r\n')
self.ae(r.status, http_client.BAD_REQUEST)
self.ae(r.read(), b'Malformed Request-Line')
r = raw_send(conn, b'x' * 200)
self.ae(r.status, http_client.BAD_REQUEST)
self.ae(r.read(), b'')
r = raw_send(conn, b'XXX /index.html HTTP/1.1\r\n\r\n')
self.ae(r.status, http_client.BAD_REQUEST), self.ae(r.read(), b'Unknown HTTP method')
# Test 404
conn.request('HEAD', '/moose')
r = conn.getresponse()
self.ae(r.status, http_client.NOT_FOUND)
self.assertIsNotNone(r.getheader('Date', None))
self.ae(r.getheader('Content-Length'), str(len(body)))
self.ae(r.getheader('Content-Type'), 'text/plain; charset=UTF-8')
self.ae(len(r.getheaders()), 3)
self.ae(r.read(), b'')
conn.request('GET', '/choose')
r = conn.getresponse()
self.ae(r.status, http_client.NOT_FOUND)
self.ae(r.read(), b'Requested resource not found')
# Test 500
server.change_handler(lambda data:1/0)
conn = server.connect()
conn.request('GET', '/test/')
r = conn.getresponse()
self.ae(r.status, http_client.INTERNAL_SERVER_ERROR)
# Test 301
def handler(data):
raise HTTPRedirect('/somewhere-else')
server.change_handler(handler)
conn = server.connect()
conn.request('GET', '/')
r = conn.getresponse()
self.ae(r.status, http_client.MOVED_PERMANENTLY)
self.ae(r.getheader('Location'), '/somewhere-else')
self.ae(b'', r.read())
server.change_handler(lambda data:data.path[0] + data.read().decode('ascii'))
conn = server.connect(timeout=base_timeout * 5)
# Test simple GET
conn.request('GET', '/test/')
r = conn.getresponse()
self.ae(r.status, http_client.OK)
self.ae(r.read(), b'test')
# Test TRACE
lines = ['TRACE /xxx HTTP/1.1', 'Test: value', 'Xyz: abc, def', '', '']
r = raw_send(conn, ('\r\n'.join(lines)).encode('ascii'))
self.ae(r.status, http_client.OK)
self.ae(r.read().decode('utf-8'), '\n'.join(lines[:-2]))
# Test POST with simple body
conn.request('POST', '/test', 'body')
r = conn.getresponse()
self.ae(r.status, http_client.OK)
self.ae(r.read(), b'testbody')
# Test POST with chunked transfer encoding
conn.request('POST', '/test', headers={'Transfer-Encoding': 'chunked'})
conn.send(b'4\r\nbody\r\na\r\n1234567890\r\n0\r\n\r\n')
r = conn.getresponse()
self.ae(r.status, http_client.OK)
self.ae(r.read(), b'testbody1234567890')
conn.request('GET', '/test' + ('a' * 200))
r = conn.getresponse()
self.ae(r.status, http_client.BAD_REQUEST)
conn = server.connect()
conn.request('GET', '/test', ('a' * 200))
r = conn.getresponse()
self.ae(r.status, http_client.REQUEST_ENTITY_TOO_LARGE)
conn = server.connect()
conn.request('POST', '/test', headers={'Transfer-Encoding': 'chunked'})
conn.send(b'x\r\nbody\r\n0\r\n\r\n')
r = conn.getresponse()
self.ae(r.status, http_client.BAD_REQUEST)
self.assertIn(b'not a valid chunk size', r.read())
conn.request('POST', '/test', headers={'Transfer-Encoding': 'chunked'})
conn.send(b'4\r\nbody\r\n200\r\n\r\n')
r = conn.getresponse()
self.ae(r.status, http_client.REQUEST_ENTITY_TOO_LARGE)
conn.request('POST', '/test', body='a'*200)
r = conn.getresponse()
self.ae(r.status, http_client.REQUEST_ENTITY_TOO_LARGE)
conn = server.connect()
conn.request('POST', '/test', headers={'Transfer-Encoding': 'chunked'})
conn.send(b'3\r\nbody\r\n0\r\n\r\n')
r = conn.getresponse()
self.ae(r.status, http_client.BAD_REQUEST), self.ae(r.read(), b'Chunk does not have trailing CRLF')
conn = server.connect(timeout=base_timeout * 5)
conn.request('POST', '/test', headers={'Transfer-Encoding': 'chunked'})
conn.send(b'30\r\nbody\r\n0\r\n\r\n')
r = conn.getresponse()
self.ae(r.status, http_client.REQUEST_TIMEOUT)
self.assertIn(b'', r.read())
conn = server.connect()
# Test closing
server.loop.opts.timeout = 10 # ensure socket is not closed because of timeout
conn.request('GET', '/close', headers={'Connection':'close'})
r = conn.getresponse()
self.ae(r.status, 200), self.ae(r.read(), b'close')
server.loop.wakeup()
num = 10
while num and server.loop.num_active_connections != 0:
time.sleep(0.01)
num -= 1
self.ae(server.loop.num_active_connections, 0)
self.assertIsNone(conn.sock)
# Test timeout
server.loop.opts.timeout = 0.1
conn = server.connect(timeout=1)
conn.request('GET', '/something')
r = conn.getresponse()
self.ae(r.status, 200), self.ae(r.read(), b'something')
self.assertIn(b'Request Timeout', eintr_retry_call(conn.sock.recv, 500))
# }}}
def test_http_response(self): # {{{
'Test HTTP protocol responses'
from calibre.srv.http_response import parse_multipart_byterange
def handler(conn):
return conn.generate_static_output('test', lambda : ''.join(conn.path))
with NamedTemporaryFile(suffix='test.epub') as f, open(P('localization/locales.zip'), 'rb') as lf, \
TestServer(handler, timeout=1, compress_min_size=0) as server:
fdata = (string.ascii_letters * 100).encode('ascii')
f.write(fdata), f.seek(0)
# Test ETag
conn = server.connect()
conn.request('GET', '/an_etagged_path')
r = conn.getresponse()
self.ae(r.status, http_client.OK), self.ae(r.read(), b'an_etagged_path')
etag = r.getheader('ETag')
self.ae(etag, '"%s"' % hashlib.sha1(b'an_etagged_path').hexdigest())
conn.request('GET', '/an_etagged_path', headers={'If-None-Match':etag})
r = conn.getresponse()
self.ae(r.status, http_client.NOT_MODIFIED)
self.ae(r.read(), b'')
# Test gzip
raw = b'a'*20000
server.change_handler(lambda conn: raw)
conn = server.connect()
conn.request('GET', '/an_etagged_path', headers={'Accept-Encoding':'gzip'})
r = conn.getresponse()
self.ae(str(len(raw)), r.getheader('Calibre-Uncompressed-Length'))
self.ae(r.status, http_client.OK), self.ae(zlib.decompress(r.read(), 16+zlib.MAX_WBITS), raw)
# Test dynamic etagged content
num_calls = [0]
def edfunc():
num_calls[0] += 1
return b'data'
server.change_handler(lambda conn:conn.etagged_dynamic_response("xxx", edfunc))
conn = server.connect()
conn.request('GET', '/an_etagged_path')
r = conn.getresponse()
self.ae(r.status, http_client.OK), self.ae(r.read(), b'data')
etag = r.getheader('ETag')
self.ae(etag, '"xxx"')
self.ae(r.getheader('Content-Length'), '4')
conn.request('GET', '/an_etagged_path', headers={'If-None-Match':etag})
r = conn.getresponse()
self.ae(r.status, http_client.NOT_MODIFIED)
self.ae(r.read(), b'')
self.ae(num_calls[0], 1)
# Test getting a filesystem file
for use_sendfile in (True, False):
server.change_handler(lambda conn: f)
server.loop.opts.use_sendfile = use_sendfile
conn = server.connect()
conn.request('GET', '/test')
r = conn.getresponse()
etag = str(r.getheader('ETag'))
self.assertTrue(etag)
self.ae(r.getheader('Content-Type'), guess_type(f.name)[0])
self.ae(str(r.getheader('Accept-Ranges')), 'bytes')
self.ae(int(r.getheader('Content-Length')), len(fdata))
self.ae(r.status, http_client.OK), self.ae(r.read(), fdata)
conn.request('GET', '/test', headers={'Range':'bytes=2-25'})
r = conn.getresponse()
self.ae(r.status, http_client.PARTIAL_CONTENT)
self.ae(str(r.getheader('Accept-Ranges')), 'bytes')
self.ae(str(r.getheader('Content-Range')), 'bytes 2-25/%d' % len(fdata))
self.ae(int(r.getheader('Content-Length')), 24)
self.ae(r.read(), fdata[2:26])
conn.request('GET', '/test', headers={'Range':'bytes=100000-'})
r = conn.getresponse()
self.ae(r.status, http_client.REQUESTED_RANGE_NOT_SATISFIABLE)
self.ae(str(r.getheader('Content-Range')), 'bytes */%d' % len(fdata))
conn.request('GET', '/test', headers={'Range':'bytes=25-50', 'If-Range':etag})
r = conn.getresponse()
self.ae(r.status, http_client.PARTIAL_CONTENT), self.ae(r.read(), fdata[25:51])
self.ae(int(r.getheader('Content-Length')), 26)
conn.request('GET', '/test', headers={'Range':'bytes=0-1000000'})
r = conn.getresponse()
self.ae(r.status, http_client.PARTIAL_CONTENT), self.ae(r.read(), fdata)
conn.request('GET', '/test', headers={'Range':'bytes=25-50', 'If-Range':'"nomatch"'})
r = conn.getresponse()
self.ae(r.status, http_client.OK), self.ae(r.read(), fdata)
self.assertFalse(r.getheader('Content-Range'))
self.ae(int(r.getheader('Content-Length')), len(fdata))
conn.request('GET', '/test', headers={'Range':'bytes=0-25,26-50'})
r = conn.getresponse()
self.ae(r.status, http_client.PARTIAL_CONTENT)
clen = int(r.getheader('Content-Length'))
data = r.read()
self.ae(clen, len(data))
buf = BytesIO(data)
self.ae(parse_multipart_byterange(buf, r.getheader('Content-Type')), [(0, fdata[:26]), (26, fdata[26:51])])
# Test sending of larger file
start_time = monotonic()
lf.seek(0)
data = lf.read()
server.change_handler(lambda conn: lf)
conn = server.connect(timeout=1)
conn.request('GET', '/test')
r = conn.getresponse()
self.ae(r.status, http_client.OK)
rdata = r.read()
self.ae(len(data), len(rdata))
self.ae(hashlib.sha1(data).hexdigest(), hashlib.sha1(rdata).hexdigest())
self.ae(data, rdata)
time_taken = monotonic() - start_time
self.assertLess(time_taken, 1, 'Large file transfer took too long')
# }}}
def test_static_generation(self): # {{{
'Test static generation'
nums = list(map(str, range(10)))
def handler(conn):
return conn.generate_static_output('test', nums.pop)
with TestServer(handler) as server:
conn = server.connect()
conn.request('GET', '/an_etagged_path')
r = conn.getresponse()
data = r.read()
for i in range(5):
conn.request('GET', '/an_etagged_path')
r = conn.getresponse()
self.assertEqual(data, r.read())
# }}}
| 18,165 | Python | .py | 374 | 36.18984 | 137 | 0.546819 | kovidgoyal/calibre | 19,243 | 2,250 | 4 | GPL-3.0 | 9/5/2024, 5:13:50 PM (Europe/Amsterdam) |
26,621 | qt_file_dialogs.py | kovidgoyal_calibre/src/calibre/gui2/qt_file_dialogs.py | #!/usr/bin/env python
# License: GPLv3 Copyright: 2017, Kovid Goyal <kovid at kovidgoyal.net>
import os
from qt.core import QDialog, QFileDialog, QObject
from calibre.gui2.linux_file_dialogs import dialog_name, image_extensions
from polyglot.builtins import string_or_bytes
from polyglot.urllib import unquote
def select_initial_dir(q):
while q:
c = os.path.dirname(q)
if c == q:
break
if os.path.exists(c):
return c
q = c
return os.path.expanduser('~')
class Dummy:
def __enter__(self):
pass
def __exit__(self, *a):
pass
class FileDialog(QObject):
def __init__(
self, title=_('Choose files'),
filters=[],
add_all_files_filter=True,
parent=None,
modal=True,
name='',
mode=QFileDialog.FileMode.ExistingFiles,
default_dir='~',
no_save_dir=False,
combine_file_and_saved_dir=False
):
from calibre.gui2 import dynamic, sanitize_env_vars
from calibre.gui2.ui import get_gui
gui = get_gui()
adapt_menubar = gui.bars_manager.adapt_menu_bar_for_dialog if gui is not None else Dummy()
QObject.__init__(self)
ftext = ''
has_long_filter = False
if filters:
for filter in filters:
text, extensions = filter
if not extensions or (len(extensions) == 1 and extensions[0] == '*'):
extensions = ['*']
else:
extensions = ['*'+(i if i.startswith('.') else '.'+i) for i in
extensions]
etext = '%s (%s);;'%(text, ' '.join(extensions))
if len(etext) > 72:
has_long_filter = True
ftext += etext
if add_all_files_filter or not ftext:
ftext += 'All files (*)'
if ftext.endswith(';;'):
ftext = ftext[:-2]
self.dialog_name = dialog_name(name, title)
self.selected_files = None
self.fd = None
if combine_file_and_saved_dir:
bn = os.path.basename(default_dir)
prev = dynamic.get(self.dialog_name,
os.path.expanduser('~'))
if os.path.exists(prev):
if os.path.isfile(prev):
prev = os.path.dirname(prev)
else:
if os.path.exists(os.path.dirname(prev)):
prev = os.path.dirname(prev)
else:
prev = os.path.expanduser('~')
initial_dir = os.path.join(prev, bn)
elif no_save_dir:
initial_dir = os.path.expanduser(default_dir)
else:
initial_dir = dynamic.get(self.dialog_name,
os.path.expanduser(default_dir))
if not isinstance(initial_dir, string_or_bytes):
initial_dir = os.path.expanduser(default_dir)
if not initial_dir or (not os.path.exists(initial_dir) and not (
mode == QFileDialog.FileMode.AnyFile and (no_save_dir or combine_file_and_saved_dir))):
initial_dir = select_initial_dir(initial_dir)
self.selected_files = []
use_native_dialog = 'CALIBRE_NO_NATIVE_FILEDIALOGS' not in os.environ
def create_dialog(title, ftext='', for_saving=False):
from calibre.gui2 import file_icon_provider
ans = QFileDialog(parent, title, initial_dir)
if ftext:
ans.setNameFilter(ftext)
ans.setOptions(opts)
ans.setFileMode(mode)
ans.setSupportedSchemes(('file',))
ans.setIconProvider(file_icon_provider())
if for_saving:
ans.setAcceptMode(QFileDialog.AcceptMode.AcceptSave)
ret = ans.exec()
ans.setParent(None)
if ret != QDialog.DialogCode.Accepted:
return ()
def c(url):
if url.isLocalFile() or url.isEmpty():
return url.toLocalFile()
return url.toString()
return tuple(c(url) for url in ans.selectedUrls())
with sanitize_env_vars(), adapt_menubar:
opts = QFileDialog.Option(0)
if not use_native_dialog:
opts |= QFileDialog.Option.DontUseNativeDialog
if has_long_filter:
opts |= QFileDialog.Option.HideNameFilterDetails
if mode == QFileDialog.FileMode.AnyFile:
if use_native_dialog:
f = QFileDialog.getSaveFileName(parent, title, initial_dir, ftext, "", opts)
else:
f = create_dialog(title, ftext, for_saving=True)
if f and f[0]:
self.selected_files.append(f[0])
elif mode == QFileDialog.FileMode.ExistingFile:
if use_native_dialog:
f = QFileDialog.getOpenFileName(parent, title, initial_dir, ftext, "", opts)
else:
f = create_dialog(title, ftext)
if f and f[0] and os.path.exists(f[0]):
self.selected_files.append(f[0])
elif mode == QFileDialog.FileMode.ExistingFiles:
if use_native_dialog:
fs = QFileDialog.getOpenFileNames(parent, title, initial_dir, ftext, "", opts)
else:
fs = create_dialog(title, ftext), True
if fs and fs[0]:
for f in fs[0]:
f = str(f)
if not f:
continue
if not os.path.exists(f):
# QFileDialog for some reason quotes spaces
# on linux if there is more than one space in a row
f = unquote(f)
if f and os.path.exists(f):
self.selected_files.append(f)
else:
if mode == QFileDialog.FileMode.Directory:
opts |= QFileDialog.Option.ShowDirsOnly
if use_native_dialog:
f = str(QFileDialog.getExistingDirectory(parent, title, initial_dir, opts))
else:
f = create_dialog(title)
f = f[0] if f else ''
if f and os.path.exists(f):
self.selected_files.append(f)
if self.selected_files:
self.selected_files = [str(q) for q in self.selected_files]
saved_loc = self.selected_files[0]
if os.path.isfile(saved_loc):
saved_loc = os.path.dirname(saved_loc)
if not no_save_dir:
dynamic[self.dialog_name] = saved_loc
self.accepted = bool(self.selected_files)
def get_files(self):
if self.selected_files is None:
return tuple(os.path.abspath(str(i)) for i in self.fd.selectedFiles())
return tuple(self.selected_files)
def choose_dir(window, name, title, default_dir='~', no_save_dir=False):
fd = FileDialog(title=title, filters=[], add_all_files_filter=False,
parent=window, name=name, mode=QFileDialog.FileMode.Directory,
default_dir=default_dir, no_save_dir=no_save_dir)
dir = fd.get_files()
fd.setParent(None)
if dir:
return dir[0]
def choose_files(window, name, title,
filters=[], all_files=True, select_only_single_file=False, default_dir='~', no_save_dir=False):
'''
Ask user to choose a bunch of files.
:param name: Unique dialog name used to store the opened directory
:param title: Title to show in dialogs titlebar
:param filters: list of allowable extensions. Each element of the list
must be a 2-tuple with first element a string describing
the type of files to be filtered and second element a list
of extensions.
:param all_files: If True add All files to filters.
:param select_only_single_file: If True only one file can be selected
'''
mode = QFileDialog.FileMode.ExistingFile if select_only_single_file else QFileDialog.FileMode.ExistingFiles
fd = FileDialog(title=title, name=name, filters=filters, default_dir=default_dir,
parent=window, add_all_files_filter=all_files, mode=mode, no_save_dir=no_save_dir,
)
fd.setParent(None)
if fd.accepted:
return fd.get_files()
return None
def choose_save_file(window, name, title, filters=[], all_files=True, initial_path=None, initial_filename=None):
'''
Ask user to choose a file to save to. Can be a non-existent file.
:param filters: list of allowable extensions. Each element of the list
must be a 2-tuple with first element a string describing
the type of files to be filtered and second element a list
of extensions.
:param all_files: If True add All files to filters.
:param initial_path: The initially selected path (does not need to exist). Cannot be used with initial_filename.
:param initial_filename: If specified, the initially selected path is this filename in the previously used directory. Cannot be used with initial_path.
'''
kwargs = dict(title=title, name=name, filters=filters,
parent=window, add_all_files_filter=all_files, mode=QFileDialog.FileMode.AnyFile)
if initial_path is not None:
kwargs['no_save_dir'] = True
kwargs['default_dir'] = initial_path
elif initial_filename is not None:
kwargs['combine_file_and_saved_dir'] = True
kwargs['default_dir'] = initial_filename
fd = FileDialog(**kwargs)
fd.setParent(None)
ans = None
if fd.accepted:
ans = fd.get_files()
if ans:
ans = ans[0]
return ans
def choose_images(window, name, title, select_only_single_file=True, formats=None):
mode = QFileDialog.FileMode.ExistingFile if select_only_single_file else QFileDialog.FileMode.ExistingFiles
if formats is None:
formats = image_extensions()
fd = FileDialog(title=title, name=name,
filters=[(_('Images'), list(formats))],
parent=window, add_all_files_filter=False, mode=mode,
)
fd.setParent(None)
if fd.accepted:
return fd.get_files()
return None
| 10,497 | Python | .py | 231 | 33.103896 | 155 | 0.576033 | kovidgoyal/calibre | 19,243 | 2,250 | 4 | GPL-3.0 | 9/5/2024, 5:13:50 PM (Europe/Amsterdam) |
26,622 | splash_screen.py | kovidgoyal_calibre/src/calibre/gui2/splash_screen.py | #!/usr/bin/env python
# License: GPLv3 Copyright: 2016, Kovid Goyal <kovid at kovidgoyal.net>
from qt.core import QApplication, QBrush, QColor, QFont, QFontMetrics, QPainter, QPen, QPixmap, QSplashScreen, Qt
from calibre.constants import __appname__, numeric_version
from calibre.utils.monotonic import monotonic
from calibre.utils.resources import get_image_path as I
class SplashScreen(QSplashScreen):
TITLE_SIZE = 20 # pt
BODY_SIZE = 12 # pt
FOOTER_SIZE = 9 # pt
LOGO_SIZE = 96 # px
WIDTH = 550 # px
def __init__(self, develop=False):
self.drawn_once = False
self.develop = develop
self.title_font = f = QFont()
f.setPointSize(self.TITLE_SIZE)
f.setBold(True)
self.title_height = QFontMetrics(f).lineSpacing() + 2
self.body_font = f = QFont()
f.setPointSize(self.BODY_SIZE)
self.line_height = QFontMetrics(f).lineSpacing()
self.total_height = max(self.LOGO_SIZE, self.title_height + 3 * self.line_height)
self.num_font = f = QFont()
f.setPixelSize(self.total_height)
f.setItalic(True), f.setBold(True)
f = QFontMetrics(f)
self.num_ch = str(max(3, numeric_version[0]))
self.footer_font = f = QFont()
f.setPointSize(self.FOOTER_SIZE)
f.setItalic(True)
self.dpr = QApplication.instance().devicePixelRatio()
self.pmap = QPixmap(I('library.png', allow_user_override=False))
self.pmap.setDevicePixelRatio(self.dpr)
self.pmap = self.pmap.scaled(int(self.dpr * self.LOGO_SIZE), int(self.dpr * self.LOGO_SIZE), transformMode=Qt.TransformationMode.SmoothTransformation)
self.light_brush = QBrush(QColor('#F6F3E9'))
self.dark_brush = QBrush(QColor('#39322B'))
pmap = QPixmap(int(self.WIDTH * self.dpr), int(self.total_height * self.dpr))
pmap.setDevicePixelRatio(self.dpr)
pmap.fill(Qt.GlobalColor.transparent)
QSplashScreen.__init__(self, pmap)
self.setWindowTitle(__appname__)
def drawContents(self, painter):
self.drawn_once = True
painter.save()
painter.setRenderHint(QPainter.RenderHint.TextAntialiasing, True)
painter.setRenderHint(QPainter.RenderHint.Antialiasing, True)
pw = self.LOGO_SIZE
height = max(pw, self.total_height)
width = self.width()
# Draw frame
y = (self.height() - height) // 2
bottom = y + height
painter.fillRect(0, y, width, height, self.light_brush)
painter.fillRect(0, y, width, self.title_height, self.dark_brush)
painter.fillRect(0, y, pw, height, self.dark_brush)
dy = (height - self.LOGO_SIZE) // 2
painter.drawPixmap(0, y + dy, self.pmap)
# Draw number
painter.setFont(self.num_font)
num_width = painter.boundingRect(0, 0, 0, 0, Qt.AlignmentFlag.AlignCenter | Qt.TextFlag.TextSingleLine, self.num_ch).width() + 12
num_x = width - num_width
painter.setPen(QPen(QColor('#d6b865')))
painter.drawText(num_x, y, num_width, height, Qt.AlignmentFlag.AlignCenter | Qt.TextFlag.TextSingleLine, self.num_ch)
# Draw title
x = pw + 10
width -= num_width + 5 + x
painter.setFont(self.title_font)
painter.drawText(x, y, width, self.title_height, Qt.AlignmentFlag.AlignLeft | Qt.AlignmentFlag.AlignVCenter | Qt.TextFlag.TextSingleLine, "CALIBRE")
# Draw starting up message
y += self.title_height + 5
painter.setPen(QPen(self.dark_brush.color()))
painter.setFont(self.body_font)
br = painter.drawText(x, y, width, self.line_height, Qt.AlignmentFlag.AlignLeft | Qt.AlignmentFlag.AlignVCenter | Qt.TextFlag.TextSingleLine, _(
'Starting up, please wait...'))
starting_up_bottom = br.bottom()
# Draw footer
m = self.message()
if m and m.strip():
painter.setFont(self.footer_font)
b = max(starting_up_bottom + 5, bottom - self.line_height)
painter.drawText(x, b, width, self.line_height, Qt.AlignmentFlag.AlignLeft | Qt.AlignmentFlag.AlignTop | Qt.TextFlag.TextSingleLine, m)
painter.restore()
def show_message(self, msg):
self.showMessage(msg)
self.wait_for_draw()
def wait_for_draw(self):
# Without this the splash screen is not painted on linux and windows
self.drawn_once = False
st = monotonic()
while not self.drawn_once and (monotonic() - st < 0.1):
QApplication.instance().processEvents()
def keyPressEvent(self, ev):
if not self.develop:
return QSplashScreen.keyPressEvent(self, ev)
ev.accept()
QApplication.instance().exit()
def main():
from calibre.gui2 import Application
app = Application([])
spl = SplashScreen(develop=True)
spl.show()
spl.show_message('Testing the splash screen message...')
app.exec()
if __name__ == '__main__':
main()
| 5,016 | Python | .py | 106 | 39.216981 | 158 | 0.651053 | kovidgoyal/calibre | 19,243 | 2,250 | 4 | GPL-3.0 | 9/5/2024, 5:13:50 PM (Europe/Amsterdam) |
26,623 | font_family_chooser.py | kovidgoyal_calibre/src/calibre/gui2/font_family_chooser.py | #!/usr/bin/env python
__license__ = 'GPL v3'
__copyright__ = '2012, Kovid Goyal <kovid at kovidgoyal.net>'
__docformat__ = 'restructuredtext en'
import os
import shutil
from qt.core import (
QAbstractItemView,
QDialog,
QDialogButtonBox,
QFont,
QFontComboBox,
QFontDatabase,
QFontInfo,
QFontMetrics,
QGridLayout,
QHBoxLayout,
QIcon,
QLabel,
QLineEdit,
QListView,
QPen,
QPushButton,
QRawFont,
QSize,
QSizePolicy,
QStringListModel,
QStyle,
QStyledItemDelegate,
Qt,
QToolButton,
QVBoxLayout,
QWidget,
pyqtSignal,
)
from calibre.constants import config_dir
from calibre.gui2 import choose_files, empty_index, error_dialog, info_dialog
from calibre.utils.icu import lower as icu_lower
def add_fonts(parent):
files = choose_files(parent, 'add fonts to calibre',
_('Select font files'), filters=[(_('TrueType/OpenType Fonts'),
['ttf', 'otf', 'woff', 'woff2'])], all_files=False)
if not files:
return
families = set()
for f in files:
r = QRawFont()
r.loadFromFile(f, 11.0, QFont.HintingPreference.PreferDefaultHinting)
if r.isValid():
families.add(r.familyName())
else:
error_dialog(parent, _('Corrupt font'),
_('Failed to load font from the file: {}').format(f), show=True)
return
families = sorted(families)
dest = os.path.join(config_dir, 'fonts')
for f in files:
shutil.copyfile(f, os.path.join(dest, os.path.basename(f)))
return families
def writing_system_for_font(font):
has_latin = True
systems = QFontDatabase.writingSystems(font.family())
# this just confuses the algorithm below. Vietnamese is Latin with lots of
# special chars
try:
systems.remove(QFontDatabase.WritingSystem.Vietnamese)
except ValueError:
pass
system = QFontDatabase.WritingSystem.Any
if (QFontDatabase.WritingSystem.Latin not in systems):
has_latin = False
# we need to show something
if systems:
system = systems[-1]
else:
systems.remove(QFontDatabase.WritingSystem.Latin)
if not systems:
return system, has_latin
if (len(systems) == 1 and systems[0].value > QFontDatabase.WritingSystem.Cyrillic.value):
return systems[0], has_latin
if (len(systems) <= 2 and
systems[-1].value > QFontDatabase.WritingSystem.Armenian.value and
systems[-1].value < QFontDatabase.WritingSystem.Vietnamese.value):
return systems[-1], has_latin
if (len(systems) <= 5 and
systems[-1].value >= QFontDatabase.WritingSystem.SimplifiedChinese.value and
systems[-1].value <= QFontDatabase.WritingSystem.Korean.value):
system = systems[-1]
return system, has_latin
class FontFamilyDelegate(QStyledItemDelegate):
def sizeHint(self, option, index):
try:
return self.do_size_hint(option, index)
except:
return QSize(300, 50)
def do_size_hint(self, option, index):
text = index.data(Qt.ItemDataRole.DisplayRole) or ''
font = QFont(option.font)
font.setPointSizeF(QFontInfo(font).pointSize() * 1.5)
m = QFontMetrics(font)
return QSize(m.width(text), m.height())
def paint(self, painter, option, index):
QStyledItemDelegate.paint(self, painter, option, empty_index)
painter.save()
try:
self.do_paint(painter, option, index)
except:
import traceback
traceback.print_exc()
painter.restore()
def do_paint(self, painter, option, index):
text = str(index.data(Qt.ItemDataRole.DisplayRole) or '')
font = QFont(option.font)
font.setPointSizeF(QFontInfo(font).pointSize() * 1.5)
font2 = QFont(font)
font2.setFamily(text)
system, has_latin = writing_system_for_font(font2)
if has_latin:
font = font2
r = option.rect
color = option.palette.text()
if option.state & QStyle.StateFlag.State_Selected:
color = option.palette.highlightedText()
painter.setPen(QPen(color, 0))
if (option.direction == Qt.LayoutDirection.RightToLeft):
r.setRight(r.right() - 4)
else:
r.setLeft(r.left() + 4)
painter.setFont(font)
painter.drawText(r, Qt.AlignmentFlag.AlignVCenter|Qt.AlignmentFlag.AlignLeading|Qt.TextFlag.TextSingleLine, text)
if (system != QFontDatabase.WritingSystem.Any):
w = painter.fontMetrics().horizontalAdvance(text + " ")
painter.setFont(font2)
sample = QFontDatabase.writingSystemSample(system)
if (option.direction == Qt.LayoutDirection.RightToLeft):
r.setRight(r.right() - w)
else:
r.setLeft(r.left() + w)
painter.drawText(r, Qt.AlignmentFlag.AlignVCenter|Qt.AlignmentFlag.AlignLeading|Qt.TextFlag.TextSingleLine, sample)
class Typefaces(QLabel):
def __init__(self, parent=None):
QLabel.__init__(self, parent)
self.setMinimumWidth(400)
self.base_msg = '<h3>'+_('Choose a font family')+'</h3>'
self.setText(self.base_msg)
self.setWordWrap(True)
def show_family(self, family, faces):
if not family:
self.setText(self.base_msg)
return
msg = '''
<h3>%s</h3>
<dl style="font-size: smaller">
{0}
</dl>
'''%(_('Available faces for %s')%family)
entries = []
for font in faces:
sf = (font['wws_subfamily_name'] or font['preferred_subfamily_name'] or
font['subfamily_name'])
entries.append('''
<dt><b>{sf}</b></dt>
<dd>font-stretch: <i>{width}</i> font-weight: <i>{weight}</i> font-style:
<i>{style}</i></dd>
'''.format(sf=sf, width=font['font-stretch'],
weight=font['font-weight'], style=font['font-style']))
msg = msg.format('\n\n'.join(entries))
self.setText(msg)
class FontsView(QListView):
changed = pyqtSignal()
def __init__(self, parent):
QListView.__init__(self, parent)
self.setSelectionMode(QAbstractItemView.SelectionMode.SingleSelection)
self.setAlternatingRowColors(True)
self.d = FontFamilyDelegate(self)
self.setItemDelegate(self.d)
def currentChanged(self, current, previous):
self.changed.emit()
QListView.currentChanged(self, current, previous)
class FontFamilyDialog(QDialog):
def __init__(self, current_family, parent=None):
QDialog.__init__(self, parent)
self.setWindowTitle(_('Choose font family'))
self.setWindowIcon(QIcon.ic('font.png'))
from calibre.utils.fonts.scanner import font_scanner
self.font_scanner = font_scanner
self.m = QStringListModel(self)
self.build_font_list()
self.l = l = QGridLayout()
self.setLayout(l)
self.view = FontsView(self)
self.view.setModel(self.m)
self.view.setCurrentIndex(self.m.index(0))
if current_family:
for i, val in enumerate(self.families):
if icu_lower(val) == icu_lower(current_family):
self.view.setCurrentIndex(self.m.index(i))
break
self.view.doubleClicked.connect(self.accept, type=Qt.ConnectionType.QueuedConnection)
self.view.changed.connect(self.current_changed,
type=Qt.ConnectionType.QueuedConnection)
self.faces = Typefaces(self)
self.bb = QDialogButtonBox(QDialogButtonBox.StandardButton.Ok|QDialogButtonBox.StandardButton.Cancel)
self.bb.accepted.connect(self.accept)
self.bb.rejected.connect(self.reject)
self.add_fonts_button = afb = self.bb.addButton(_('Add &fonts'),
QDialogButtonBox.ButtonRole.ActionRole)
afb.setIcon(QIcon.ic('plus.png'))
afb.clicked.connect(self.add_fonts)
self.ml = QLabel(_('Choose a font family from the list below:'))
self.search = QLineEdit(self)
self.search.setPlaceholderText(_('Search'))
self.search.returnPressed.connect(self.find)
self.nb = QToolButton(self)
self.nb.setIcon(QIcon.ic('arrow-down.png'))
self.nb.setToolTip(_('Find next'))
self.pb = QToolButton(self)
self.pb.setIcon(QIcon.ic('arrow-up.png'))
self.pb.setToolTip(_('Find previous'))
self.nb.clicked.connect(self.find_next)
self.pb.clicked.connect(self.find_previous)
l.addWidget(self.ml, 0, 0, 1, 4)
l.addWidget(self.search, 1, 0, 1, 1)
l.addWidget(self.nb, 1, 1, 1, 1)
l.addWidget(self.pb, 1, 2, 1, 1)
l.addWidget(self.view, 2, 0, 1, 3)
l.addWidget(self.faces, 1, 3, 2, 1)
l.addWidget(self.bb, 3, 0, 1, 4)
l.setAlignment(self.faces, Qt.AlignmentFlag.AlignTop)
self.resize(800, 600)
def set_current(self, i):
self.view.setCurrentIndex(self.m.index(i))
def keyPressEvent(self, e):
if e.key() == Qt.Key.Key_Return:
return
return QDialog.keyPressEvent(self, e)
def find(self, backwards=False):
i = self.view.currentIndex().row()
if i < 0:
i = 0
q = icu_lower(str(self.search.text())).strip()
if not q:
return
r = (range(i-1, -1, -1) if backwards else range(i+1,
len(self.families)))
for j in r:
f = self.families[j]
if q in icu_lower(f):
self.set_current(j)
return
def find_next(self):
self.find()
def find_previous(self):
self.find(backwards=True)
def build_font_list(self):
try:
self.families = list(self.font_scanner.find_font_families())
except:
self.families = []
print('WARNING: Could not load fonts')
import traceback
traceback.print_exc()
self.families.insert(0, _('None'))
self.m.setStringList(self.families)
def add_fonts(self):
families = add_fonts(self)
if not families:
return
self.font_scanner.do_scan()
self.m.beginResetModel()
self.build_font_list()
self.m.endResetModel()
self.view.setCurrentIndex(self.m.index(0))
if families:
for i, val in enumerate(self.families):
if icu_lower(val) == icu_lower(families[0]):
self.view.setCurrentIndex(self.m.index(i))
break
info_dialog(self, _('Added fonts'),
_('Added font families: %s')%(
', '.join(families)), show=True)
@property
def font_family(self):
idx = self.view.currentIndex().row()
if idx == 0:
return None
return self.families[idx]
def current_changed(self):
fam = self.font_family
self.faces.show_family(fam, self.font_scanner.fonts_for_family(fam)
if fam else None)
class FontFamilyChooser(QWidget):
family_changed = pyqtSignal(object)
def __init__(self, parent=None):
QWidget.__init__(self, parent)
self.l = l = QHBoxLayout()
l.setContentsMargins(0, 0, 0, 0)
self.setLayout(l)
self.button = QPushButton(self)
self.button.setIcon(QIcon.ic('font.png'))
self.button.setSizePolicy(QSizePolicy.Policy.Fixed, QSizePolicy.Policy.Fixed)
l.addWidget(self.button)
self.default_text = _('Choose &font family')
self.font_family = None
self.button.clicked.connect(self.show_chooser)
self.clear_button = QToolButton(self)
self.clear_button.setIcon(QIcon.ic('clear_left.png'))
self.clear_button.clicked.connect(self.clear_family)
l.addWidget(self.clear_button)
self.setToolTip = self.button.setToolTip
self.toolTip = self.button.toolTip
self.clear_button.setToolTip(_('Clear the font family'))
l.addStretch(1)
def clear_family(self):
self.font_family = None
@property
def font_family(self):
return self._current_family
@font_family.setter
def font_family(self, val):
if not val:
val = None
self._current_family = val
self.button.setText(val or self.default_text)
self.family_changed.emit(val)
def show_chooser(self):
d = FontFamilyDialog(self.font_family, self)
if d.exec() == QDialog.DialogCode.Accepted:
self.font_family = d.font_family
def test():
from calibre.gui2 import Application
app = Application([])
app
d = QDialog()
d.setLayout(QVBoxLayout())
d.layout().addWidget(FontFamilyChooser(d))
d.layout().addWidget(QFontComboBox(d))
d.exec()
if __name__ == '__main__':
test()
| 13,081 | Python | .py | 340 | 29.688235 | 127 | 0.61845 | kovidgoyal/calibre | 19,243 | 2,250 | 4 | GPL-3.0 | 9/5/2024, 5:13:50 PM (Europe/Amsterdam) |
26,624 | book_details.py | kovidgoyal_calibre/src/calibre/gui2/book_details.py | #!/usr/bin/env python
# License: GPLv3 Copyright: 2010, Kovid Goyal <kovid at kovidgoyal.net>
import os
import re
from collections import namedtuple
from contextlib import suppress
from functools import lru_cache, partial
from qt.core import (
QAction,
QApplication,
QClipboard,
QColor,
QDialog,
QEasingCurve,
QIcon,
QKeySequence,
QMenu,
QMimeData,
QPainter,
QPalette,
QPen,
QPixmap,
QPropertyAnimation,
QRect,
QSize,
QSizePolicy,
QSplitter,
Qt,
QTimer,
QUrl,
QWidget,
pyqtProperty,
pyqtSignal,
)
from calibre import fit_image, sanitize_file_name
from calibre.constants import config_dir, iswindows
from calibre.db.constants import DATA_DIR_NAME, DATA_FILE_PATTERN, RESOURCE_URL_SCHEME
from calibre.ebooks import BOOK_EXTENSIONS
from calibre.ebooks.metadata.book.base import Metadata, field_metadata
from calibre.ebooks.metadata.book.render import mi_to_html
from calibre.ebooks.metadata.search_internet import all_author_searches, all_book_searches, name_for, url_for_author_search, url_for_book_search
from calibre.gui2 import (
NO_URL_FORMATTING,
choose_save_file,
clip_border_radius,
config,
default_author_link,
gprefs,
pixmap_to_data,
question_dialog,
rating_font,
safe_open_url,
)
from calibre.gui2.dialogs.confirm_delete import confirm
from calibre.gui2.dialogs.confirm_delete import confirm as confirm_delete
from calibre.gui2.dnd import dnd_get_files, dnd_get_image, dnd_has_extension, dnd_has_image, image_extensions
from calibre.gui2.widgets2 import HTMLDisplay
from calibre.startup import connect_lambda
from calibre.utils.config import tweaks
from calibre.utils.img import blend_image, image_from_x
from calibre.utils.localization import is_rtl, langnames_to_langcodes
from calibre.utils.resources import get_path as P
from calibre.utils.serialize import json_loads
from polyglot.binary import from_hex_bytes
InternetSearch = namedtuple('InternetSearch', 'author where')
def db_for_mi(mi):
from calibre.gui2.ui import get_gui
lp = getattr(mi, 'external_library_path', None)
if lp:
return get_gui().library_broker.get_library(lp), True
return get_gui().current_db, False
def set_html(mi, html, text_browser):
book_id = getattr(mi, 'id', None)
search_paths = []
db, _ = db_for_mi(mi)
if db and book_id is not None:
path = db.abspath(book_id, index_is_id=True)
if path:
search_paths = [path]
text_browser.setSearchPaths(search_paths)
text_browser.setHtml(html)
def css(reset=False):
if reset:
del css.ans
if not hasattr(css, 'ans'):
val = P('templates/book_details.css', data=True).decode('utf-8')
css.ans = re.sub(r'/\*.*?\*/', '', val, flags=re.DOTALL)
if iswindows:
# On Windows the default monospace font family is Courier which is ugly
css.ans = 'pre { font-family: "Segoe UI Mono", "Consolas", monospace; }\n\n' + css.ans
return css.ans
def resolve_colors(css):
app = QApplication.instance()
col = app.palette().color(QPalette.ColorRole.PlaceholderText).name() if app.is_dark_theme else '#666'
return css.replace('palette(placeholder-text)', col)
def resolved_css():
return resolve_colors(css())
def copy_all(text_browser):
mf = getattr(text_browser, 'details', text_browser)
c = QApplication.clipboard()
md = QMimeData()
html = mf.toHtml()
md.setHtml(html)
from html5_parser import parse
from lxml import etree
root = parse(html)
tables = tuple(root.iterdescendants('table'))
for tag in root.iterdescendants(('table', 'tr', 'tbody')):
tag.tag = 'div'
parent = root
is_vertical = getattr(text_browser, 'vertical', True)
if not is_vertical:
parent = tables[1]
for tag in parent.iterdescendants('td'):
for child in tag.iterdescendants('br'):
child.tag = 'span'
child.text = '\ue000'
tt = etree.tostring(tag, method='text', encoding='unicode')
tag.tag = 'span'
for child in tuple(tag):
tag.remove(child)
tag.text = tt.strip()
if not is_vertical:
for tag in root.iterdescendants('td'):
tag.tag = 'div'
for tag in root.iterdescendants('a'):
tag.attrib.pop('href', None)
from calibre.utils.html2text import html2text
simplified_html = etree.tostring(root, encoding='unicode')
txt = html2text(simplified_html, single_line_break=True).strip()
txt = txt.replace('\ue000', '\n\t')
if iswindows:
txt = os.linesep.join(txt.splitlines())
# print(simplified_html)
# print(txt)
md.setText(txt)
c.setMimeData(md)
def create_search_internet_menu(callback, author=None):
m = QMenu(
_('Search the internet for the author {}').format(author)
if author is not None else
_('Search the internet for this book')
)
m.menuAction().setIcon(QIcon.ic('search.png'))
items = all_book_searches() if author is None else all_author_searches()
for k in sorted(items, key=lambda k: name_for(k).lower()):
m.addAction(QIcon.ic('search.png'), name_for(k), partial(callback, InternetSearch(author, k)))
return m
def is_category(field):
from calibre.db.categories import find_categories
from calibre.gui2.ui import get_gui
gui = get_gui()
fm = gui.current_db.field_metadata
return field in {x[0] for x in find_categories(fm) if fm.is_custom_field(x[0])}
def is_boolean(field):
from calibre.gui2.ui import get_gui
gui = get_gui()
fm = gui.current_db.field_metadata
return fm.get(field, {}).get('datatype') == 'bool'
def escape_for_menu(x):
return x.replace('&', '&&')
def init_manage_action(ac, field, value):
from calibre.library.field_metadata import category_icon_map
ic = category_icon_map.get(field) or 'blank.png'
ac.setIcon(QIcon.ic(ic))
ac.setText(_('Manage %s') % escape_for_menu(value))
ac.current_fmt = field, value
return ac
def add_notes_context_menu_actions(menu, book_info, field, value):
from calibre.gui2.ui import get_gui
db = get_gui().current_db.new_api
if db.field_supports_notes(field):
item_id = db.get_item_id(field, value)
if item_id is not None:
val = escape_for_menu(value)
def edit_note():
gui = get_gui()
from calibre.gui2.dialogs.edit_category_notes import EditNoteDialog
d = EditNoteDialog(field, item_id, gui.current_db.new_api, parent=book_info)
if d.exec() == QDialog.DialogCode.Accepted:
gui.do_field_item_value_changed()
ac = menu.addAction(_('Edit note for {}').format(val))
ac.triggered.connect(edit_note)
ac.setIcon(QIcon.ic('edit_input.png'))
def delete_note():
gui = get_gui()
if question_dialog(gui, _('Are you sure?'),
_('Are you sure you want to delete the note for {} from this library? '
'There is no undo.').format(val),
skip_dialog_name='book_details_delete_note_context_menu'):
db = gui.current_db.new_api
db.set_notes_for(field, item_id, '')
gui.do_field_item_value_changed()
ac = menu.addAction(_('Delete note for {}').format(escape_for_menu(value)))
ac.triggered.connect(delete_note)
ac.setIcon(QIcon.ic('trash.png'))
def init_find_in_tag_browser(menu, ac, field, value):
from calibre.gui2.ui import get_gui
hidden_cats = get_gui().tags_view.model().hidden_categories
if field not in hidden_cats:
ac.setIcon(QIcon.ic('search.png'))
ac.setText(_('Find %s in the Tag browser') % escape_for_menu(value))
ac.current_fmt = field, value
menu.addAction(ac)
def get_icon_path(f, prefix):
from calibre.library.field_metadata import category_icon_map
custom_icons = gprefs['tags_browser_category_icons']
ci = custom_icons.get(prefix + f, '')
if ci:
icon_path = os.path.join(config_dir, 'tb_icons', ci)
elif prefix:
icon_path = category_icon_map['gst']
else:
icon_path = category_icon_map.get(f, 'search.png')
return icon_path
def init_find_in_grouped_search(menu, field, value, book_info):
from calibre.gui2.ui import get_gui
db = get_gui().current_db
fm = db.field_metadata
field_name = fm.get(field, {}).get('name', None)
if field_name is None:
# I don't think this can ever happen, but ...
return
gsts = db.prefs.get('grouped_search_terms', {})
gsts_to_show = []
for v in gsts:
fk = fm.search_term_to_field_key(v)
if field in fk:
gsts_to_show.append(v)
if gsts_to_show:
m = QMenu((_('Search calibre for %s') + '...')%escape_for_menu(value), menu)
m.setIcon(QIcon.ic('search.png'))
menu.addMenu(m)
m.addAction(QIcon.ic(get_icon_path(field, '')),
_('in category %s')%escape_for_menu(field_name),
lambda g=field: book_info.search_requested(
'{}:"={}"'.format(g, value.replace('"', r'\"')), ''))
for gst in gsts_to_show:
icon_path = get_icon_path(gst, '@')
m.addAction(QIcon.ic(icon_path),
_('in grouped search %s')%gst,
lambda g=gst: book_info.search_requested(
'{}:"={}"'.format(g, value.replace('"', r'\"')), ''))
else:
menu.addAction(QIcon.ic('search.png'),
_('Search calibre for {val} in category {name}').format(
val=escape_for_menu(value), name=escape_for_menu(field_name)),
lambda g=field: book_info.search_requested(
'{}:"={}"'.format(g, value.replace('"', r'\"')), ''))
@lru_cache(maxsize=2)
def comments_pat():
return re.compile(r'<!--.*?-->', re.DOTALL)
def render_html(mi, vertical, widget, all_fields=False, render_data_func=None,
pref_name='book_display_fields',
pref_value=None): # {{{
db, is_external = db_for_mi(mi)
show_links = not is_external
func = render_data_func or partial(render_data,
vertical_fields=db.prefs.get('book_details_vertical_categories') or ())
try:
table, comment_fields = func(mi, all_fields=all_fields, show_links=show_links,
use_roman_numbers=config['use_roman_numerals_for_series_number'], pref_name=pref_name)
except TypeError:
table, comment_fields = func(mi, all_fields=all_fields, show_links=show_links,
use_roman_numbers=config['use_roman_numerals_for_series_number'])
def color_to_string(col):
ans = '#000000'
if col.isValid():
col = col.toRgb()
if col.isValid():
ans = str(col.name())
return ans
comments = ''
if comment_fields:
comments = '\n'.join('<div>%s</div>' % x for x in comment_fields)
# Comments cause issues with rendering in QTextBrowser
comments = comments_pat().sub('', comments)
html = render_parts(table, comments, vertical)
return html, table, comments
def render_parts(table, comments, vertical):
templ = '''\
<html>
<head></head>
<body class="%s">
%%s
</body>
<html>
'''%('vertical' if vertical else 'horizontal')
right_pane = comments
if vertical:
ans = templ%(table+right_pane)
else:
ans = templ % (
'<table><tr><td valign="top" width="40%">{}</td><td valign="top" width="60%">{}</td></tr></table>'.format(
table, right_pane))
return ans
def get_field_list(fm, use_defaults=False, pref_name='book_display_fields', mi=None):
db, _ = db_for_mi(mi)
if use_defaults:
src = db.prefs.defaults
else:
old_val = gprefs.get(pref_name, None)
if old_val is not None and not db.prefs.has_setting(pref_name):
src = gprefs
else:
src = db.prefs
fieldlist = list(src[pref_name])
names = frozenset(x[0] for x in fieldlist)
available = frozenset(fm.displayable_field_keys())
for field in available - names:
fieldlist.append((field, True))
return [(f, d) for f, d in fieldlist if f in available]
def render_data(mi, use_roman_numbers=True, all_fields=False, pref_name='book_display_fields',
vertical_fields=(), show_links=True):
field_list = get_field_list(getattr(mi, 'field_metadata', field_metadata),
pref_name=pref_name, mi=mi)
field_list = [(x, all_fields or display) for x, display in field_list]
db, _ = db_for_mi(mi)
db = db.new_api
field_maps = {}
def item_id_if_has_note(field, item_val):
if db.field_supports_notes(field):
nmap = field_maps.get(field)
if nmap is None:
nmap = field_maps[field] = db.get_item_name_map(field)
item_id = nmap.get(item_val)
if item_id is not None:
if db.notes_for(field, item_id):
return item_id
return mi_to_html(
mi, field_list=field_list, use_roman_numbers=use_roman_numbers, rtl=is_rtl(),
rating_font=rating_font(), default_author_link=default_author_link(),
comments_heading_pos=gprefs['book_details_comments_heading_pos'], for_qt=True,
vertical_fields=vertical_fields, show_links=show_links, item_id_if_has_note=item_id_if_has_note
)
# }}}
# Context menu {{{
def add_format_entries(menu, data, book_info, copy_menu, search_menu):
from calibre.ebooks.oeb.polish.main import SUPPORTED
from calibre.gui2.ui import get_gui
book_id = int(data['book_id'])
fmt = data['fmt']
init_find_in_tag_browser(search_menu, book_info.find_in_tag_browser_action, 'formats', fmt)
init_find_in_grouped_search(search_menu, 'formats', fmt, book_info)
db = get_gui().current_db.new_api
ofmt = fmt.upper() if fmt.startswith('ORIGINAL_') else 'ORIGINAL_' + fmt
nfmt = ofmt[len('ORIGINAL_'):]
fmts = {x.upper() for x in db.formats(book_id)}
for a, t in [
('remove', _('Delete the %s format')),
('save', _('Save the %s format to disk')),
('restore', _('Restore the %s format')),
('compare', ''),
('set_cover', _('Set the book cover from the %s file')),
]:
if a == 'restore' and not fmt.startswith('ORIGINAL_'):
continue
if a == 'compare':
if ofmt not in fmts or nfmt not in SUPPORTED:
continue
t = _('Compare to the %s format') % (fmt[9:] if fmt.startswith('ORIGINAL_') else ofmt)
else:
t = t % fmt
ac = getattr(book_info, '%s_format_action'%a)
ac.current_fmt = (book_id, fmt)
ac.setText(t)
menu.addAction(ac)
if not fmt.upper().startswith('ORIGINAL_'):
from calibre.gui2.open_with import edit_programs, populate_menu
m = QMenu(_('Open %s with...') % fmt.upper())
def connect_action(ac, entry):
connect_lambda(ac.triggered, book_info, lambda book_info: book_info.open_with(book_id, fmt, entry))
populate_menu(m, connect_action, fmt)
if len(m.actions()) == 0:
menu.addAction(_('Open %s with...') % fmt.upper(), partial(book_info.choose_open_with, book_id, fmt))
else:
m.addSeparator()
m.addAction(_('Add other application for %s files...') % fmt.upper(), partial(book_info.choose_open_with, book_id, fmt))
m.addAction(_('Edit Open with applications...'), partial(edit_programs, fmt, book_info))
menu.addMenu(m)
menu.ow = m
if fmt.upper() in SUPPORTED:
menu.addSeparator()
menu.addAction(_('Edit %s format') % fmt.upper(), partial(book_info.edit_fmt, book_id, fmt))
path = data['path']
if path:
if data.get('fname'):
path = os.path.join(path, data['fname'] + '.' + data['fmt'].lower())
ac = book_info.copy_link_action
ac.current_url = path
ac.setText(_('Path to file'))
copy_menu.addAction(ac)
if db.is_fts_enabled():
menu.addSeparator()
menu.addAction(
_('Re-index the {} format for full text searching').format(fmt.upper()), partial(book_info.reindex_fmt, book_id, fmt)).setIcon(
QIcon.ic('fts.png'))
def add_link_submenu(menu: QMenu, link, book_info, field='', item_name=''):
if field and item_name:
m = menu.addMenu(QIcon.ic('external-link'), _('Associated link'))
m.addAction(QIcon.ic('reference'), _('Open: {}').format(link), lambda : book_info.link_clicked.emit(link))
m.addAction(QIcon.ic('minus'), _('Remove the link').format(link), lambda : book_info.link_removal_requested.emit(field, item_name))
else:
menu.addAction(QIcon.ic('external-link'), _('Open associated link').format(link), lambda : book_info.link_clicked.emit(link))
def add_item_specific_entries(menu, data, book_info, copy_menu, search_menu):
from calibre.gui2.ui import get_gui
search_internet_added = False
find_action = book_info.find_in_tag_browser_action
dt = data['type']
def add_copy_action(name):
copy_menu.addAction(QIcon.ic('edit-copy.png'), _('The text: {}').format(name), lambda: QApplication.instance().clipboard().setText(name))
if dt == 'format':
add_format_entries(menu, data, book_info, copy_menu, search_menu)
data['reindex_fmt_added'] = True
elif dt == 'author':
author = data['name']
if data['url'] != 'calibre':
ac = book_info.copy_link_action
ac.current_url = data['url']
ac.setText(_('&Author link'))
copy_menu.addAction(ac)
add_copy_action(author)
init_find_in_tag_browser(search_menu, find_action, 'authors', author)
init_find_in_grouped_search(search_menu, 'authors', author, book_info)
menu.addAction(init_manage_action(book_info.manage_action, 'authors', author))
add_notes_context_menu_actions(menu, book_info, 'authors', author)
if hasattr(book_info, 'search_internet'):
search_menu.addSeparator()
search_menu.sim = create_search_internet_menu(book_info.search_internet, author)
for ac in search_menu.sim.actions():
search_menu.addAction(ac)
ac.setText(_('Search {0} for {1}').format(ac.text(), author))
search_internet_added = True
if hasattr(book_info, 'remove_item_action'):
ac = book_info.remove_item_action
book_id = get_gui().library_view.current_id
ac.data = ('authors', author, book_id)
ac.setText(_('Remove %s from this book') % escape_for_menu(author))
menu.addAction(ac)
# See if we need to add a click associated link menu line for the author
link_map = get_gui().current_db.new_api.get_all_link_maps_for_book(data.get('book_id', -1))
link = link_map.get("authors", {}).get(author)
if link:
add_link_submenu(menu, link, book_info, 'authors', author)
elif dt in ('path', 'devpath'):
path = data['loc']
ac = book_info.copy_link_action
if isinstance(path, int):
path = get_gui().library_view.model().db.abspath(path, index_is_id=True)
ac.current_url = path
ac.setText(_('The location of the book'))
copy_menu.addAction(ac)
elif dt == 'data-path':
path = data['loc']
ac = book_info.copy_link_action
path = get_gui().library_view.model().db.abspath(data['loc'], index_is_id=True)
if path:
path = os.path.join(path, DATA_DIR_NAME)
ac.current_url = path
ac.setText(_('The location of the book\'s data files'))
copy_menu.addAction(ac)
else:
field = data.get('field')
if field is not None:
book_id = int(data['book_id'])
value = remove_value = data['value']
remove_name = ''
if field == 'identifiers':
ac = book_info.copy_link_action
ac.current_url = value
ac.setText(_('&Identifier'))
copy_menu.addAction(ac)
if data.get('url'):
book_info.copy_identifiers_url_action.current_url = data['url']
copy_menu.addAction(book_info.copy_identifiers_url_action)
remove_value = data['id_type']
init_find_in_tag_browser(search_menu, find_action, field, remove_value)
init_find_in_grouped_search(search_menu, field, remove_value, book_info)
menu.addAction(book_info.edit_identifiers_action)
remove_name = data.get('name') or value
elif field in ('tags', 'series', 'publisher') or is_category(field):
add_copy_action(value)
init_find_in_tag_browser(search_menu, find_action, field, value)
init_find_in_grouped_search(search_menu, field, value, book_info)
menu.addAction(init_manage_action(book_info.manage_action, field, value))
add_notes_context_menu_actions(menu, book_info, field, value)
elif field == 'languages':
remove_value = langnames_to_langcodes((value,)).get(value, 'Unknown')
init_find_in_tag_browser(search_menu, find_action, field, value)
init_find_in_grouped_search(search_menu, field, value, book_info)
else:
v = data.get('original_value') or data.get('value')
copy_menu.addAction(QIcon.ic('edit-copy.png'), _('The text: {}').format(v),
lambda: QApplication.instance().clipboard().setText(v))
if field != 'size':
ac = book_info.remove_item_action
ac.data = (field, remove_value, book_id)
ac.setText(_('Remove %s from this book') % escape_for_menu(remove_name or data.get('original_value') or value))
menu.addAction(ac)
# See if we need to add a click associated link menu line
link_map = get_gui().current_db.new_api.get_all_link_maps_for_book(data.get('book_id', -1))
link = link_map.get(field, {}).get(value)
if link:
add_link_submenu(menu, link, book_info, field, value)
else:
v = data.get('original_value') or data.get('value')
if v:
copy_menu.addAction(QIcon.ic('edit-copy.png'), _('The text: {}').format(v),
lambda: QApplication.instance().clipboard().setText(v))
return search_internet_added
def create_copy_links(menu, data=None):
from calibre.gui2.ui import get_gui
db = get_gui().current_db.new_api
library_id = getattr(db, 'server_library_id', None)
if not library_id:
return
library_id = '_hex_-' + library_id.encode('utf-8').hex()
book_id = get_gui().library_view.current_id
def copy_to_clipboard_action(menu_text, value_text, before_action=None):
def doit():
QApplication.instance().clipboard().setText(value_text)
if before_action is not None:
action = QWidget(menu).addAction(QIcon.ic('edit-copy.png'), menu_text, doit)
menu.insertAction(before_action, action)
else:
menu.addAction(QIcon.ic('edit-copy.png'), menu_text, doit)
all_links = []
def link_action(text, url):
nonlocal all_links
all_links.append(url)
copy_to_clipboard_action(text, url)
sep = menu.addSeparator() # Note: separators are really actions
link_action(_('Link to show book in calibre'), f'calibre://show-book/{library_id}/{book_id}')
link_action(_('Link to show book details in a popup window'),
f'calibre://book-details/{library_id}/{book_id}')
mi = db.new_api.get_proxy_metadata(book_id)
if mi and mi.path:
with suppress(Exception):
data_files = db.new_api.list_extra_files(book_id, use_cache=True, pattern=DATA_FILE_PATTERN)
if data_files:
data_path = os.path.join(db.backend.library_path, mi.path, DATA_DIR_NAME)
link_action(_("Link to open book's data files folder"),
bytes(QUrl.fromLocalFile(data_path).toEncoded()).decode('utf-8'))
if data:
if data.get('kind', '') == 'notes':
field = data['field']
item_id = data['item_id']
note_data = db.notes_data_for(field, item_id)
if note_data is not None:
copy_to_clipboard_action(_('HTML for note'), note_data['doc'], sep)
copy_to_clipboard_action(_('Text for note'),
note_data['searchable_text'].partition('\n')[2], sep)
if field.startswith('#'):
field = '_' + field[1:]
url = f"calibre://show-note/{library_id}/{field}/id_{item_id}"
link_action(_('Link to show note in calibre'), url)
else:
field = data.get('field')
if data['type'] == 'author':
field = 'authors'
if field and field in ('tags', 'series', 'publisher', 'authors') or is_category(field):
name = data['name' if data['type'] == 'author' else 'value']
eq = f'{field}:"={name}"'.encode().hex()
link_action(_('Link to show books matching {} in calibre').format(name),
f'calibre://search/{library_id}?eq={eq}')
for fmt in db.formats(book_id):
fmt = fmt.upper()
link_action(_('Link to view {} format of book').format(fmt.upper()),
f'calibre://view-book/{library_id}/{book_id}/{fmt}')
if all_links:
menu.addSeparator()
all_links.insert(0, '')
all_links.insert(0, mi.get('title') + ' - ' + ' & '.join(mi.get('authors')))
link_action(_('Copy all the above links'), '\n'.join(all_links))
def details_context_menu_event(view, ev, book_info, add_popup_action=False, edit_metadata=None):
url = view.anchorAt(ev.pos())
menu = QMenu(view)
copy_menu = menu.addMenu(QIcon.ic('edit-copy.png'), _('Copy'))
copy_menu.addAction(QIcon.ic('edit-copy.png'), _('All book details'), partial(copy_all, view))
if view.textCursor().hasSelection():
copy_menu.addAction(QIcon.ic('edit-copy.png'), _('Selected text'), view.copy)
copy_menu.addSeparator()
copy_links_added = False
search_internet_added = False
search_menu = QMenu(_('Search'), menu)
search_menu.setIcon(QIcon.ic('search.png'))
reindex_fmt_added = False
if url:
def get_data():
kind, _, rest = url.partition(':')
data = json_loads(from_hex_bytes(rest))
data['kind'] = kind
return data
if url.startswith('action:'):
data = get_data()
search_internet_added = add_item_specific_entries(menu, data, book_info, copy_menu, search_menu)
create_copy_links(copy_menu, data)
copy_links_added = True
reindex_fmt_added = 'reindex_fmt_added' in data
elif url.startswith('notes:'):
data = get_data()
create_copy_links(copy_menu, data)
copy_links_added = True
search_internet_added = True
add_notes_context_menu_actions(menu, view, data['field'], data['value'])
elif not url.startswith('#'):
ac = book_info.copy_link_action
ac.current_url = url
ac.setText(_('Copy link location'))
menu.addAction(ac)
add_link_submenu(menu, url, book_info)
if not copy_links_added:
create_copy_links(copy_menu)
if not search_internet_added and hasattr(book_info, 'search_internet'):
sim = create_search_internet_menu(book_info.search_internet)
if search_menu.isEmpty():
search_menu = sim
else:
search_menu.addSeparator()
for ac in sim.actions():
search_menu.addAction(ac)
ac.setText(_('Search {0} for this book').format(ac.text()))
if not search_menu.isEmpty():
menu.addMenu(search_menu)
for ac in tuple(menu.actions()):
if not ac.isEnabled():
menu.removeAction(ac)
menu.addSeparator()
from calibre.gui2.ui import get_gui
if add_popup_action:
menu.addMenu(get_gui().iactions['Show Book Details'].qaction.menu())
else:
# We can't open edit metadata from a locked window because EM expects to
# be editing the current book, which this book probably isn't
if edit_metadata is not None:
ema = get_gui().iactions['Edit Metadata'].menuless_qaction
menu.addAction(_('Open the Edit metadata window') + '\t' + ema.shortcut().toString(QKeySequence.SequenceFormat.NativeText), edit_metadata)
if not reindex_fmt_added:
menu.addSeparator()
menu.addAction(_(
'Re-index this book for full text searching'), partial(book_info.reindex_fmt, get_gui().library_view.current_id, '')).setIcon(
QIcon.ic('fts.png'))
if len(menu.actions()) > 0:
menu.exec(ev.globalPos())
# }}}
def create_open_cover_with_menu(self, parent_menu):
from calibre.gui2.open_with import edit_programs, populate_menu
m = QMenu(_('Open cover with...'))
def connect_action(ac, entry):
connect_lambda(ac.triggered, self, lambda self: self.open_with(entry))
populate_menu(m, connect_action, 'cover_image')
if len(m.actions()) == 0:
parent_menu.addAction(_('Open cover with...'), self.choose_open_with)
else:
m.addSeparator()
m.addAction(_('Add another application to open cover with...'), self.choose_open_with)
m.addAction(_('Edit Open with applications...'), partial(edit_programs, 'cover_image', self))
parent_menu.ocw = m
parent_menu.addMenu(m)
return m
class CoverView(QWidget): # {{{
cover_changed = pyqtSignal(object, object)
cover_removed = pyqtSignal(object)
open_cover_with = pyqtSignal(object, object)
search_internet = pyqtSignal(object)
def __init__(self, vertical, parent=None):
QWidget.__init__(self, parent)
self._current_pixmap_size = QSize(120, 120)
self.change_layout(vertical)
self.animation = QPropertyAnimation(self, b'current_pixmap_size', self)
self.animation.setEasingCurve(QEasingCurve(QEasingCurve.Type.OutExpo))
self.animation.setDuration(1000)
self.animation.setStartValue(QSize(0, 0))
self.animation.valueChanged.connect(self.value_changed)
self.default_pixmap = QApplication.instance().cached_qpixmap('default_cover.png', device_pixel_ratio=self.devicePixelRatio())
self.pixmap = self.default_pixmap
self.pwidth = self.pheight = None
self.data = {}
self.last_trim_id = self.last_trim_pixmap = None
self.do_layout()
def change_layout(self, vertical):
self.vertical = vertical
self.setSizePolicy(
QSizePolicy.Policy.Expanding if vertical else QSizePolicy.Policy.Minimum,
QSizePolicy.Policy.Expanding)
def value_changed(self, val):
self.update()
def setCurrentPixmapSize(self, val):
self._current_pixmap_size = val
def minimumSizeHint(self):
return QSize(100, 100)
def do_layout(self):
if self.rect().width() == 0 or self.rect().height() == 0:
return
pixmap = self.pixmap
pwidth, pheight = pixmap.width(), pixmap.height()
try:
self.pwidth, self.pheight = fit_image(pwidth, pheight,
self.rect().width(), self.rect().height())[1:]
except:
self.pwidth, self.pheight = self.rect().width()-1, \
self.rect().height()-1
self.current_pixmap_size = QSize(self.pwidth, self.pheight)
self.animation.setEndValue(self.current_pixmap_size)
def show_data(self, data):
self.animation.stop()
same_item = getattr(data, 'id', True) == self.data.get('id', False)
self.data = {'id':data.get('id', None)}
if data.cover_data[1]:
self.pixmap = QPixmap.fromImage(data.cover_data[1])
if self.pixmap.isNull() or self.pixmap.width() < 5 or \
self.pixmap.height() < 5:
self.pixmap = self.default_pixmap
else:
self.pixmap = self.default_pixmap
self.do_layout()
self.update()
if (not same_item and not config['disable_animations'] and
self.isVisible()):
self.animation.start()
def paintEvent(self, event):
canvas_size = self.rect()
width = self.current_pixmap_size.width()
extrax = canvas_size.width() - width
if extrax < 0:
extrax = 0
x = int(extrax//2)
height = self.current_pixmap_size.height()
extray = canvas_size.height() - height
if extray < 0:
extray = 0
y = int(extray//2)
target = QRect(x, y, width, height)
p = QPainter(self)
p.setRenderHints(QPainter.RenderHint.Antialiasing | QPainter.RenderHint.SmoothPixmapTransform)
try:
dpr = self.devicePixelRatioF()
except AttributeError:
dpr = self.devicePixelRatio()
spmap = self.pixmap.scaled(target.size() * dpr, Qt.AspectRatioMode.KeepAspectRatio, Qt.TransformationMode.SmoothTransformation)
spmap.setDevicePixelRatio(dpr)
with clip_border_radius(p, target):
p.drawPixmap(target, spmap)
if gprefs['bd_overlay_cover_size']:
sztgt = target.adjusted(0, 0, 0, -4)
f = p.font()
f.setBold(True)
p.setFont(f)
sz = '\u00a0%d x %d\u00a0'%(self.pixmap.width(), self.pixmap.height())
flags = Qt.AlignmentFlag.AlignBottom|Qt.AlignmentFlag.AlignRight|Qt.TextFlag.TextSingleLine
szrect = p.boundingRect(sztgt, flags, sz)
p.fillRect(szrect.adjusted(0, 0, 0, 4), QColor(0, 0, 0, 200))
p.setPen(QPen(QColor(255,255,255)))
p.drawText(sztgt, flags, sz)
p.end()
current_pixmap_size = pyqtProperty('QSize',
fget=lambda self: self._current_pixmap_size,
fset=setCurrentPixmapSize
)
def contextMenuEvent(self, ev):
cm = QMenu(self)
paste = cm.addAction(QIcon.ic('edit-paste.png'), _('Paste cover'))
copy = cm.addAction(QIcon.ic('edit-copy.png'), _('Copy cover'))
save = cm.addAction(QIcon.ic('save.png'), _('Save cover to disk'))
remove = cm.addAction(QIcon.ic('trash.png'), _('Remove cover'))
gc = cm.addAction(QIcon.ic('default_cover.png'), _('Generate cover from metadata'))
cm.addSeparator()
if self.pixmap is not self.default_pixmap and self.data.get('id'):
book_id = self.data['id']
cm.tc = QMenu(_('Trim cover'))
cm.tc.addAction(QIcon.ic('trim.png'), _('Automatically trim borders'), self.trim_cover)
cm.tc.addAction(_('Trim borders manually'), self.manual_trim_cover)
cm.tc.addSeparator()
cm.tc.addAction(QIcon.ic('edit-undo.png'), _('Undo last trim'), self.undo_last_trim).setEnabled(self.last_trim_id == book_id)
cm.addMenu(cm.tc)
cm.addSeparator()
if not QApplication.instance().clipboard().mimeData().hasImage():
paste.setEnabled(False)
copy.triggered.connect(self.copy_to_clipboard)
paste.triggered.connect(self.paste_from_clipboard)
remove.triggered.connect(self.remove_cover)
gc.triggered.connect(self.generate_cover)
save.triggered.connect(self.save_cover)
create_open_cover_with_menu(self, cm)
cm.si = m = create_search_internet_menu(self.search_internet.emit)
cm.addMenu(m)
cm.exec(ev.globalPos())
def trim_cover(self):
book_id = self.data.get('id')
if not book_id:
return
from calibre.utils.img import remove_borders_from_image
img = image_from_x(self.pixmap)
nimg = remove_borders_from_image(img)
if nimg is not img:
self.last_trim_id = book_id
self.last_trim_pixmap = self.pixmap
self.update_cover(QPixmap.fromImage(nimg))
def manual_trim_cover(self):
book_id = self.data.get('id')
if not book_id:
return
from calibre.gui2.dialogs.trim_image import TrimImage
from calibre.utils.img import image_to_data
cdata = image_to_data(image_from_x(self.pixmap), fmt='PNG', png_compression_level=1)
d = TrimImage(cdata, parent=self)
if d.exec() == QDialog.DialogCode.Accepted and d.image_data is not None:
self.last_trim_id = book_id
self.last_trim_pixmap = self.pixmap
self.update_cover(cdata=d.image_data)
def undo_last_trim(self):
book_id = self.data.get('id')
if not book_id or book_id != self.last_trim_id:
return
pmap = self.last_trim_pixmap
self.last_trim_pixmap = self.last_trim_id = None
self.update_cover(pmap)
def open_with(self, entry):
id_ = self.data.get('id', None)
if id_ is not None:
self.open_cover_with.emit(id_, entry)
def choose_open_with(self):
from calibre.gui2.open_with import choose_program
entry = choose_program('cover_image', self)
if entry is not None:
self.open_with(entry)
def copy_to_clipboard(self):
QApplication.instance().clipboard().setPixmap(self.pixmap)
def paste_from_clipboard(self, pmap=None):
if not isinstance(pmap, QPixmap):
cb = QApplication.instance().clipboard()
pmap = cb.pixmap()
if pmap.isNull() and cb.supportsSelection():
pmap = cb.pixmap(QClipboard.Mode.Selection)
if not pmap.isNull():
self.update_cover(pmap)
def save_cover(self):
from calibre.gui2.ui import get_gui
book_id = self.data.get('id')
db = get_gui().current_db.new_api
path = choose_save_file(
self, 'save-cover-from-book-details', _('Choose cover save location'),
filters=[(_('JPEG images'), ['jpg', 'jpeg'])], all_files=False,
initial_filename='{}.jpeg'.format(sanitize_file_name(db.field_for('title', book_id, default_value='cover')))
)
if path:
db.copy_cover_to(book_id, path)
def update_cover(self, pmap=None, cdata=None):
if pmap is None:
pmap = QPixmap()
pmap.loadFromData(cdata)
if pmap.isNull():
return
if pmap.hasAlphaChannel():
pmap = QPixmap.fromImage(blend_image(image_from_x(pmap)))
self.pixmap = pmap
self.do_layout()
self.update()
self.update_tooltip(getattr(self.parent(), 'current_path', ''))
if not config['disable_animations']:
self.animation.start()
id_ = self.data.get('id', None)
if id_ is not None:
self.cover_changed.emit(id_, cdata or pixmap_to_data(pmap))
def generate_cover(self, *args):
book_id = self.data.get('id')
if book_id is None:
return
from calibre.gui2.ui import get_gui
mi = get_gui().current_db.new_api.get_metadata(book_id)
if not mi.has_cover or confirm(
_('Are you sure you want to replace the cover? The existing cover will be permanently lost.'), 'book_details_generate_cover'):
from calibre.ebooks.covers import generate_cover
cdata = generate_cover(mi)
self.update_cover(cdata=cdata)
def remove_cover(self):
if not confirm_delete(
_('Are you sure you want to delete the cover permanently?'),
'book-details-confirm-cover-remove', parent=self):
return
id_ = self.data.get('id', None)
self.pixmap = self.default_pixmap
self.do_layout()
self.update()
if id_ is not None:
self.cover_removed.emit(id_)
def update_tooltip(self, current_path):
try:
sz = self.pixmap.size()
except:
sz = QSize(0, 0)
self.setToolTip(
'<p>'+_('Double click to open the Book details window') +
'<br><br>' + _('Path') + ': ' + current_path +
'<br><br>' + _('Cover size: %(width)d x %(height)d pixels')%dict(
width=sz.width(), height=sz.height())
)
# }}}
# Book Info {{{
class BookInfo(HTMLDisplay):
link_clicked = pyqtSignal(object)
link_removal_requested = pyqtSignal(object, object)
remove_format = pyqtSignal(int, object)
remove_item = pyqtSignal(int, object, object)
save_format = pyqtSignal(int, object)
restore_format = pyqtSignal(int, object)
compare_format = pyqtSignal(int, object)
set_cover_format = pyqtSignal(int, object)
copy_link = pyqtSignal(object)
manage_category = pyqtSignal(object, object)
open_fmt_with = pyqtSignal(int, object, object)
edit_book = pyqtSignal(int, object)
edit_identifiers = pyqtSignal()
find_in_tag_browser = pyqtSignal(object, object)
notes_resource_scheme = RESOURCE_URL_SCHEME
def __init__(self, vertical, parent=None):
HTMLDisplay.__init__(self, parent=parent, save_resources_in_document=False)
self.vertical = vertical
self.last_rendered_html = '', '', ''
self.base_url_for_current_book = None
self.anchor_clicked.connect(self.link_activated)
for x, icon in [
('remove_format', 'trash.png'), ('save_format', 'save.png'),
('restore_format', 'edit-undo.png'), ('copy_link','edit-copy.png'),
('compare_format', 'diff.png'),
('set_cover_format', 'default_cover.png'),
('find_in_tag_browser', 'search.png')
]:
ac = QAction(QIcon.ic(icon), '', self)
ac.current_fmt = None
ac.current_url = None
ac.triggered.connect(getattr(self, '%s_triggerred'%x))
setattr(self, '%s_action'%x, ac)
self.manage_action = QAction(self)
self.manage_action.current_fmt = self.manage_action.current_url = None
self.manage_action.triggered.connect(self.manage_action_triggered)
self.edit_identifiers_action = QAction(QIcon.ic('identifiers.png'), _('Edit identifiers for this book'), self)
self.edit_identifiers_action.triggered.connect(self.edit_identifiers)
self.remove_item_action = ac = QAction(QIcon.ic('minus.png'), '...', self)
ac.data = (None, None, None)
ac.triggered.connect(self.remove_item_triggered)
self.copy_identifiers_url_action = ac = QAction(QIcon.ic('edit-copy.png'), _('Identifier &URL'), self)
ac.triggered.connect(self.copy_id_url_triggerred)
ac.current_url = ac.current_fmt = None
self.setFocusPolicy(Qt.FocusPolicy.NoFocus)
self.setDefaultStyleSheet(css())
if iswindows and not QApplication.instance().using_calibre_style:
# workaround Qt bug that causes selected text to be invisible on
# windows when using system theme
bg = self.palette().color(QPalette.ColorRole.Highlight).name()
fg = self.palette().color(QPalette.ColorRole.HighlightedText).name()
self.setStyleSheet(f'QTextBrowser {{ selection-color: {fg}; selection-background-color: {bg}; }}')
def change_layout(self, vertical):
if vertical != self.vertical:
self.vertical = vertical
if self.last_rendered_html[0]:
html = render_parts(self.last_rendered_html[1], self.last_rendered_html[2], self.vertical)
self.last_rendered_html = html, self.last_rendered_html[1], self.last_rendered_html[2]
self.setHtml(html)
def refresh_css(self):
self.setDefaultStyleSheet(css(True))
def remove_item_triggered(self):
field, value, book_id = self.remove_item_action.data
if field and confirm(_('Are you sure you want to delete <b>{}</b> from the book?').format(value), 'book_details_remove_item'):
self.remove_item.emit(book_id, field, value)
def context_action_triggered(self, which):
f = getattr(self, '%s_action'%which).current_fmt
url = getattr(self, '%s_action'%which).current_url
if f and 'format' in which:
book_id, fmt = f
getattr(self, which).emit(book_id, fmt)
if url and 'link' in which:
getattr(self, which).emit(url)
def remove_format_triggerred(self):
self.context_action_triggered('remove_format')
def save_format_triggerred(self):
self.context_action_triggered('save_format')
def restore_format_triggerred(self):
self.context_action_triggered('restore_format')
def compare_format_triggerred(self):
self.context_action_triggered('compare_format')
def set_cover_format_triggerred(self):
self.context_action_triggered('set_cover_format')
def copy_link_triggerred(self):
self.context_action_triggered('copy_link')
def copy_id_url_triggerred(self):
if self.copy_identifiers_url_action.current_url:
self.copy_link.emit(self.copy_identifiers_url_action.current_url)
def find_in_tag_browser_triggerred(self):
if self.find_in_tag_browser_action.current_fmt:
self.find_in_tag_browser.emit(*self.find_in_tag_browser_action.current_fmt)
def manage_action_triggered(self):
if self.manage_action.current_fmt:
self.manage_category.emit(*self.manage_action.current_fmt)
def link_activated(self, link):
if str(link.scheme()) in ('http', 'https'):
return safe_open_url(link)
link = str(link.toString(NO_URL_FORMATTING))
self.link_clicked.emit(link)
def show_data(self, mi):
html, table, comments = self.last_rendered_html = render_html(mi, self.vertical, self.parent())
path = getattr(mi, 'path', None)
self.base_url_for_current_book = QUrl.fromLocalFile(os.path.join(path, 'metadata.opf')) if path else None
set_html(mi, html, self)
def get_base_qurl(self):
return self.base_url_for_current_book
def process_external_css(self, css):
return resolve_colors(css)
def mouseDoubleClickEvent(self, ev):
v = self.viewport()
if v.rect().contains(self.mapFromGlobal(ev.globalPos())):
ev.ignore()
else:
return HTMLDisplay.mouseDoubleClickEvent(self, ev)
def contextMenuEvent(self, ev):
details_context_menu_event(self, ev, self, True)
def open_with(self, book_id, fmt, entry):
self.open_fmt_with.emit(book_id, fmt, entry)
def choose_open_with(self, book_id, fmt):
from calibre.gui2.open_with import choose_program
entry = choose_program(fmt, self)
if entry is not None:
self.open_with(book_id, fmt, entry)
def edit_fmt(self, book_id, fmt):
self.edit_book.emit(book_id, fmt)
def reindex_fmt(self, book_id, fmt):
from calibre.gui2.ui import get_gui
db = get_gui().current_db.new_api
if fmt:
db.reindex_fts_book(book_id, fmt)
else:
db.reindex_fts_book(book_id)
# }}}
class DetailsLayout(QSplitter): # {{{
def __init__(self, vertical, parent):
orientation = Qt.Orientation.Vertical if vertical else Qt.Orientation.Horizontal
super().__init__(orientation, parent)
self.vertical = vertical
self._children = []
self.setContentsMargins(0, 0, 0, 0)
self.splitterMoved.connect(self.do_splitter_moved,
type=Qt.ConnectionType.QueuedConnection)
self.resize_timer = QTimer()
self.resize_timer.setSingleShot(True)
self.resize_timer.setInterval(5)
self.resize_timer.timeout.connect(self.do_resize)
def change_layout(self, vertical):
self.vertical = vertical
self.restore_splitter_state()
def do_resize(self, *args):
super().resizeEvent(self._resize_ev)
self.do_layout(self.rect())
def resizeEvent(self, ev):
if self.resize_timer.isActive():
self.resize_timer.stop()
self._resize_ev = ev
self.resize_timer.start()
def minimumSize(self):
return QSize(190, 200) if self.vertical else QSize(120, 120)
def addWidget(self, child):
if len(self._children) > 2:
raise ValueError('This layout can only manage two children')
self._children.append(child)
def count(self):
return len(self._children)
def sizeHint(self):
return self.minimumSize()
@property
def splitter_state_pref_name(self):
return 'book_details_widget_splitter_state_' + ('vertical' if self.vertical else 'horizontal')
def restore_splitter_state(self):
s = gprefs.get(self.splitter_state_pref_name)
if s is None:
s = gprefs.get('book_details_widget_splitter_state')
if s is None:
# Without this on first start the splitter is rendered over the cover
self.setSizes([20, 80])
else:
self.restoreState(s)
self.setOrientation(Qt.Orientation.Vertical if self.vertical else Qt.Orientation.Horizontal)
def setGeometry(self, *a):
super().setGeometry(*a)
self.do_layout(self.geometry())
def do_splitter_moved(self, *args):
gprefs[self.splitter_state_pref_name] = bytearray(self.saveState())
self._children[0].do_layout()
def cover_height(self, r):
if not self._children[0].isVisible():
return 0
mh = min(int(r.height()//2), int(4/3 * r.width())+1)
try:
ph = self._children[0].pixmap.height()
except:
ph = 0
if ph > 0:
mh = min(mh, ph)
return mh
def cover_width(self, r):
if not self._children[0].isVisible():
return 0
mw = 1 + int(3/4 * r.height())
try:
pw = self._children[0].pixmap.width()
except:
pw = 0
if pw > 0:
mw = min(mw, pw)
return mw
def do_layout(self, rect):
if len(self._children) != 2:
return
cm = self.contentsMargins()
left = cm.left()
top = cm.top()
right = cm.right()
bottom = cm.top()
r = rect.adjusted(+left, +top, -right, -bottom)
x = r.x()
y = r.y()
cover, details = self._children
if self.vertical:
ch = self.cover_height(r)
cover.setGeometry(QRect(x, y, r.width(), ch))
y += ch + 5
details.setGeometry(QRect(x, y, r.width(), r.height()-ch-5))
else:
cw = self.cover_width(r)
cover.setGeometry(QRect(x, y, cw, r.height()))
x += cw + 5
details.setGeometry(QRect(x, y, r.width() - cw - 5, r.height()))
self.restore_splitter_state() # only required on first call to do_layout, but ...
cover.do_layout()
# }}}
# Drag 'n drop {{{
class DropMixin:
files_dropped = pyqtSignal(object, object)
remote_file_dropped = pyqtSignal(object, object)
def __init__(self):
self.setAcceptDrops(True)
def dragEnterEvent(self, event):
md = event.mimeData()
if dnd_has_extension(md, image_extensions() + BOOK_EXTENSIONS, allow_all_extensions=True, allow_remote=True) or \
dnd_has_image(md):
event.acceptProposedAction()
def dropEvent(self, event):
event.setDropAction(Qt.DropAction.CopyAction)
md = event.mimeData()
image_exts = set(image_extensions()) - set(tweaks['cover_drop_exclude'])
x, y = dnd_get_image(md, image_exts)
if x is not None:
# We have an image, set cover
event.accept()
if y is None:
# Local image
self.cover_view.paste_from_clipboard(x)
self.update_layout()
else:
self.remote_file_dropped.emit(x, y)
# We do not support setting cover *and* adding formats for
# a remote drop, anyway, so return
return
# Now look for ebook files
urls, filenames = dnd_get_files(md, BOOK_EXTENSIONS, allow_all_extensions=True, filter_exts=image_exts)
if not urls:
# Nothing found
return
if not filenames:
# Local files
self.files_dropped.emit(event, urls)
else:
# Remote files, use the first file
self.remote_file_dropped.emit(urls[0], filenames[0])
event.accept()
def dragMoveEvent(self, event):
event.acceptProposedAction()
# }}}
class BookDetails(DetailsLayout, DropMixin): # {{{
show_book_info = pyqtSignal()
open_containing_folder = pyqtSignal(int)
open_data_folder = pyqtSignal(int)
view_specific_format = pyqtSignal(int, object)
search_requested = pyqtSignal(object, object)
remove_specific_format = pyqtSignal(int, object)
remove_metadata_item = pyqtSignal(int, object, object)
save_specific_format = pyqtSignal(int, object)
restore_specific_format = pyqtSignal(int, object)
set_cover_from_format = pyqtSignal(int, object)
compare_specific_format = pyqtSignal(int, object)
copy_link = pyqtSignal(object)
cover_changed = pyqtSignal(object, object)
open_cover_with = pyqtSignal(object, object)
cover_removed = pyqtSignal(object)
view_device_book = pyqtSignal(object)
manage_category = pyqtSignal(object, object)
edit_identifiers = pyqtSignal()
open_fmt_with = pyqtSignal(int, object, object)
edit_book = pyqtSignal(int, object)
find_in_tag_browser = pyqtSignal(object, object)
def __init__(self, vertical, parent=None):
super().__init__(vertical, parent)
DropMixin.__init__(self)
self.last_data = {}
self._layout = self
self.current_path = ''
self.cover_view = CoverView(vertical, self)
self.cover_view.search_internet.connect(self.search_internet)
self.cover_view.cover_changed.connect(self.cover_changed.emit)
self.cover_view.open_cover_with.connect(self.open_cover_with.emit)
self.cover_view.cover_removed.connect(self.cover_removed.emit)
self._layout.addWidget(self.cover_view)
self.book_info = BookInfo(vertical, self)
self.book_info.show_book_info = self.show_book_info
self.book_info.search_internet = self.search_internet
self.book_info.search_requested = self.search_requested.emit
self._layout.addWidget(self.book_info)
self.book_info.link_clicked.connect(self.handle_click)
self.book_info.link_removal_requested.connect(self.remove_link)
self.book_info.remove_format.connect(self.remove_specific_format)
self.book_info.remove_item.connect(self.remove_metadata_item)
self.book_info.open_fmt_with.connect(self.open_fmt_with)
self.book_info.edit_book.connect(self.edit_book)
self.book_info.save_format.connect(self.save_specific_format)
self.book_info.restore_format.connect(self.restore_specific_format)
self.book_info.set_cover_format.connect(self.set_cover_from_format)
self.book_info.compare_format.connect(self.compare_specific_format)
self.book_info.copy_link.connect(self.copy_link)
self.book_info.manage_category.connect(self.manage_category)
self.book_info.find_in_tag_browser.connect(self.find_in_tag_browser)
self.book_info.edit_identifiers.connect(self.edit_identifiers)
self.setCursor(Qt.CursorShape.PointingHandCursor)
def change_layout(self, vertical):
if vertical != self.vertical:
super().change_layout(vertical)
self.cover_view.change_layout(vertical)
self.book_info.change_layout(vertical)
self.do_layout(self.rect())
def search_internet(self, data):
if self.last_data:
if data.author is None:
url = url_for_book_search(data.where, title=self.last_data['title'], author=self.last_data['authors'][0])
else:
url = url_for_author_search(data.where, author=data.author)
safe_open_url(url)
def handle_click_from_popup(self, link, parent=None):
parent = parent or self
typ, val = link.partition(':')[::2]
from calibre.gui2.ui import get_gui
db = get_gui().current_db.new_api
def search_term(field, val):
append = ''
mods = QApplication.instance().keyboardModifiers()
if mods & Qt.KeyboardModifier.ControlModifier:
append = 'AND' if mods & Qt.KeyboardModifier.ShiftModifier else 'OR'
fmt = '{}:{}' if is_boolean(field) else '{}:"={}"'
self.search_requested.emit(
fmt.format(field, val.replace('"', '\\"')),
append
)
def browse(url):
if url.startswith(DATA_DIR_NAME + '/') and self.last_data.get('book_id'):
base = get_gui().current_db.abspath(self.last_data['book_id'], index_is_id=True)
path = os.path.join(base, url)
qurl = QUrl.fromLocalFile(path)
else:
qurl = QUrl(url, QUrl.ParsingMode.TolerantMode)
try:
safe_open_url(qurl)
except Exception:
import traceback
traceback.print_exc()
if typ == 'action':
data = json_loads(from_hex_bytes(val))
dt = data['type']
if dt == 'search':
field = data.get('field')
search_term(data['term'], data['value'])
elif dt == 'author':
url = data['url']
if url == 'calibre':
search_term('authors', data['name'])
else:
browse(url)
elif dt == 'format':
book_id, fmt = data['book_id'], data['fmt']
self.view_specific_format.emit(int(book_id), fmt)
elif dt == 'identifier':
if data['url']:
browse(data['url'])
elif dt == 'path':
self.open_containing_folder.emit(int(data['loc']))
elif dt == 'data-path':
self.open_data_folder.emit(int(data['loc']))
elif dt == 'devpath':
self.view_device_book.emit(data['loc'])
elif typ == 'notes':
data = json_loads(from_hex_bytes(val))
field = data.get('field')
# It shouldn't be possible for the field to be invalid or the
# note not to exist, but ...
if field and db.field_supports_notes(field):
item_id = data['item_id']
if item_id is not None and db.notes_for(field, item_id):
return self.show_notes(field, item_id, parent)
else:
browse(link)
def handle_click(self, link):
self.handle_click_from_popup(link)
def remove_link(self, field, item_value):
from calibre.gui2.ui import get_gui
gui = get_gui()
db = gui.current_db.new_api
db.set_link_map(field, {item_value: ''})
m = gui.library_view.model()
current = gui.library_view.currentIndex()
m.current_changed(current, current)
gui.tags_view.recount()
def show_notes(self, field, item_id, parent=None):
from calibre.gui2.dialogs.show_category_note import ShowNoteDialog
from calibre.gui2.ui import get_gui
ShowNoteDialog(field, item_id, get_gui().current_db.new_api, parent=parent or self).show()
def mouseDoubleClickEvent(self, ev):
ev.accept()
self.show_book_info.emit()
def show_data(self, data):
try:
self.last_data = {'title':data.title, 'authors':data.authors, 'book_id': getattr(data, 'id', None)}
except Exception:
self.last_data = {}
self.book_info.show_data(data)
self.cover_view.show_data(data)
self.current_path = getattr(data, 'path', '')
self.update_layout()
def update_layout(self):
self.cover_view.setVisible(gprefs['bd_show_cover'])
self._layout.do_layout(self.rect())
self.cover_view.update_tooltip(self.current_path)
def reset_info(self):
self.show_data(Metadata(_('Unknown')))
# }}}
| 61,456 | Python | .py | 1,339 | 36.322629 | 150 | 0.609761 | kovidgoyal/calibre | 19,243 | 2,250 | 4 | GPL-3.0 | 9/5/2024, 5:13:50 PM (Europe/Amsterdam) |
26,625 | ui.py | kovidgoyal_calibre/src/calibre/gui2/ui.py | #!/usr/bin/env python
__license__ = 'GPL v3'
__copyright__ = '2009, Kovid Goyal <kovid@kovidgoyal.net>'
__docformat__ = 'restructuredtext en'
'''The main GUI'''
import errno
import gc
import os
import re
import sys
import textwrap
import time
from collections import OrderedDict, deque
from io import BytesIO
import apsw
from qt.core import QAction, QApplication, QDialog, QEvent, QFont, QIcon, QMenu, QSystemTrayIcon, Qt, QTimer, QUrl, pyqtSignal
from calibre import detect_ncpus, force_unicode, prints
from calibre.constants import DEBUG, __appname__, config_dir, filesystem_encoding, ismacos, iswindows
from calibre.customize import PluginInstallationType
from calibre.customize.ui import available_store_plugins, interface_actions
from calibre.db.legacy import LibraryDatabase
from calibre.gui2 import (
Dispatcher,
GetMetadata,
config,
error_dialog,
gprefs,
info_dialog,
max_available_height,
open_url,
question_dialog,
timed_print,
warning_dialog,
)
from calibre.gui2.auto_add import AutoAdder
from calibre.gui2.changes import handle_changes
from calibre.gui2.cover_flow import CoverFlowMixin
from calibre.gui2.device import DeviceMixin
from calibre.gui2.dialogs.message_box import JobError
from calibre.gui2.ebook_download import EbookDownloadMixin
from calibre.gui2.email import EmailMixin
from calibre.gui2.extra_files_watcher import ExtraFilesWatcher
from calibre.gui2.init import LayoutMixin, LibraryViewMixin
from calibre.gui2.job_indicator import Pointer
from calibre.gui2.jobs import JobManager, JobsButton, JobsDialog
from calibre.gui2.keyboard import Manager
from calibre.gui2.layout import MainWindowMixin
from calibre.gui2.listener import Listener
from calibre.gui2.main_window import MainWindow
from calibre.gui2.open_with import register_keyboard_shortcuts
from calibre.gui2.proceed import ProceedQuestion
from calibre.gui2.search_box import SavedSearchBoxMixin, SearchBoxMixin
from calibre.gui2.search_restriction_mixin import SearchRestrictionMixin
from calibre.gui2.tag_browser.ui import TagBrowserMixin
from calibre.gui2.update import UpdateMixin
from calibre.gui2.widgets import BusyCursor, ProgressIndicator
from calibre.library import current_library_name
from calibre.srv.library_broker import GuiLibraryBroker, db_matches
from calibre.utils.config import dynamic, prefs
from calibre.utils.ipc.pool import Pool
from calibre.utils.resources import get_image_path as I
from calibre.utils.resources import get_path as P
from polyglot.builtins import string_or_bytes
from polyglot.queue import Empty, Queue
def get_gui():
return getattr(get_gui, 'ans', None)
def add_quick_start_guide(library_view, refresh_cover_browser=None):
from calibre.ebooks.covers import calibre_cover2
from calibre.ebooks.metadata.meta import get_metadata
from calibre.ptempfile import PersistentTemporaryFile
from calibre.utils.localization import canonicalize_lang, get_lang
from calibre.utils.zipfile import safe_replace
l = canonicalize_lang(get_lang()) or 'eng'
gprefs['quick_start_guide_added'] = True
imgbuf = BytesIO(calibre_cover2(_('Quick Start Guide'), ''))
try:
with open(P('quick_start/%s.epub' % l), 'rb') as src:
buf = BytesIO(src.read())
except OSError as err:
if err.errno != errno.ENOENT:
raise
with open(P('quick_start/eng.epub'), 'rb') as src:
buf = BytesIO(src.read())
safe_replace(buf, 'images/cover.jpg', imgbuf)
buf.seek(0)
mi = get_metadata(buf, 'epub')
with PersistentTemporaryFile('.epub') as tmp:
tmp.write(buf.getvalue())
library_view.model().add_books([tmp.name], ['epub'], [mi])
os.remove(tmp.name)
library_view.model().books_added(1)
if refresh_cover_browser is not None:
refresh_cover_browser()
if library_view.model().rowCount(None) < 3:
library_view.resizeColumnsToContents()
class Main(MainWindow, MainWindowMixin, DeviceMixin, EmailMixin, # {{{
TagBrowserMixin, CoverFlowMixin, LibraryViewMixin, SearchBoxMixin,
SavedSearchBoxMixin, SearchRestrictionMixin, LayoutMixin, UpdateMixin,
EbookDownloadMixin
):
'The main GUI'
proceed_requested = pyqtSignal(object, object)
book_converted = pyqtSignal(object, object)
enter_key_pressed_in_book_list = pyqtSignal(object) # used by action chains plugin
event_in_db = pyqtSignal(object, object, object) # (db, event_type, event_data)
shutdown_started = pyqtSignal()
shutdown_completed = pyqtSignal()
shutting_down = False
def __init__(self, opts, parent=None, gui_debug=None):
MainWindow.__init__(self, opts, parent=parent, disable_automatic_gc=True)
self.setVisible(False)
self.setWindowIcon(QApplication.instance().windowIcon())
self.extra_files_watcher = ExtraFilesWatcher(self)
self.jobs_pointer = Pointer(self)
self.proceed_requested.connect(self.do_proceed,
type=Qt.ConnectionType.QueuedConnection)
self.proceed_question = ProceedQuestion(self)
self.job_error_dialog = JobError(self)
self.keyboard = Manager(self)
get_gui.ans = self
self.opts = opts
self.device_connected = None
self.gui_debug = gui_debug
self.iactions = OrderedDict()
# Actions
for action in interface_actions():
if opts.ignore_plugins \
and action.installation_type is not PluginInstallationType.BUILTIN:
continue
try:
ac = self.init_iaction(action)
except Exception:
# Ignore errors in loading user supplied plugins
import traceback
try:
traceback.print_exc()
except Exception:
if action.plugin_path:
print('Failed to load Interface Action plugin:', action.plugin_path, file=sys.stderr)
if action.installation_type is PluginInstallationType.BUILTIN:
raise
continue
ac.plugin_path = action.plugin_path
ac.interface_action_base_plugin = action
self.add_iaction(ac)
self.load_store_plugins()
def init_iaction(self, action):
ac = action.load_actual_plugin(self)
ac.plugin_path = action.plugin_path
ac.interface_action_base_plugin = action
ac.installation_type = action.installation_type
action.actual_iaction_plugin_loaded = True
return ac
def add_iaction(self, ac):
acmap = self.iactions
if ac.name in acmap:
if ac.priority >= acmap[ac.name].priority:
acmap[ac.name] = ac
else:
acmap[ac.name] = ac
def load_store_plugins(self):
from calibre.gui2.store.loader import Stores
self.istores = Stores()
for store in available_store_plugins():
if self.opts.ignore_plugins \
and store.installation_type is not PluginInstallationType.BUILTIN:
continue
try:
st = self.init_istore(store)
self.add_istore(st)
except:
# Ignore errors in loading user supplied plugins
import traceback
traceback.print_exc()
if store.installation_type is PluginInstallationType.BUILTIN:
raise
continue
self.istores.builtins_loaded()
def init_istore(self, store):
st = store.load_actual_plugin(self)
st.plugin_path = store.plugin_path
st.installation_type = store.installation_type
st.base_plugin = store
store.actual_istore_plugin_loaded = True
return st
def add_istore(self, st):
stmap = self.istores
if st.name in stmap:
if st.priority >= stmap[st.name].priority:
stmap[st.name] = st
else:
stmap[st.name] = st
def add_db_listener(self, callback):
self.library_broker.start_listening_for_db_events()
self.event_in_db.connect(callback)
def remove_db_listener(self, callback):
self.event_in_db.disconnect(callback)
def initialize(self, library_path, db, actions, show_gui=True):
opts = self.opts
self.preferences_action, self.quit_action = actions
self.library_path = library_path
self.library_broker = GuiLibraryBroker(db)
self.content_server = None
self.server_change_notification_timer = t = QTimer(self)
self.server_changes = Queue()
t.setInterval(1000), t.timeout.connect(self.handle_changes_from_server_debounced), t.setSingleShot(True)
self._spare_pool = None
self.must_restart_before_config = False
for ac in self.iactions.values():
try:
ac.do_genesis()
except Exception:
# Ignore errors in third party plugins
import traceback
traceback.print_exc()
if getattr(ac, 'installation_type', None) is PluginInstallationType.BUILTIN:
raise
self.donate_action = QAction(QIcon.ic('donate.png'),
_('&Donate to support calibre'), self)
for st in self.istores.values():
st.do_genesis()
MainWindowMixin.init_main_window_mixin(self)
# Jobs Button {{{
self.job_manager = JobManager()
self.jobs_dialog = JobsDialog(self, self.job_manager)
self.jobs_button = JobsButton(parent=self)
self.jobs_button.initialize(self.jobs_dialog, self.job_manager)
# }}}
LayoutMixin.init_layout_mixin(self)
DeviceMixin.init_device_mixin(self)
self.progress_indicator = ProgressIndicator(self)
self.progress_indicator.pos = (0, 20)
self.verbose = opts.verbose
self.get_metadata = GetMetadata()
self.upload_memory = {}
self.metadata_dialogs = []
self.default_thumbnail = None
self.tb_wrapper = textwrap.TextWrapper(width=40)
self.viewers = deque()
self.system_tray_icon = None
do_systray = config['systray_icon'] or opts.start_in_tray
if do_systray and QSystemTrayIcon.isSystemTrayAvailable():
self.system_tray_icon = QSystemTrayIcon(self)
self.system_tray_icon.setIcon(QIcon(I('lt.png', allow_user_override=False)))
if not (iswindows or ismacos):
self.system_tray_icon.setIcon(QIcon.fromTheme('calibre-tray', self.system_tray_icon.icon()))
self.system_tray_icon.setToolTip(self.jobs_button.tray_tooltip())
self.system_tray_icon.setVisible(True)
self.jobs_button.tray_tooltip_updated.connect(self.system_tray_icon.setToolTip)
elif do_systray:
prints('Failed to create system tray icon, your desktop environment probably'
' does not support the StatusNotifier spec https://www.freedesktop.org/wiki/Specifications/StatusNotifierItem/',
file=sys.stderr, flush=True)
self.system_tray_menu = QMenu(self)
self.toggle_to_tray_action = self.system_tray_menu.addAction(QIcon.ic('page.png'), '')
self.toggle_to_tray_action.triggered.connect(self.system_tray_icon_activated)
self.system_tray_menu.addAction(self.donate_action)
self.eject_action = self.system_tray_menu.addAction(
QIcon.ic('eject.png'), _('&Eject connected device'))
self.eject_action.setEnabled(False)
self.addAction(self.quit_action)
self.system_tray_menu.addAction(self.quit_action)
self.keyboard.register_shortcut('quit calibre', _('Quit calibre'),
default_keys=('Ctrl+Q',), action=self.quit_action)
if self.system_tray_icon is not None:
self.system_tray_icon.setContextMenu(self.system_tray_menu)
self.system_tray_icon.activated.connect(self.system_tray_icon_activated)
self.quit_action.triggered[bool].connect(self.quit)
self.donate_action.triggered[bool].connect(self.donate)
self.minimize_action = QAction(_('Minimize the calibre window'), self)
self.addAction(self.minimize_action)
self.keyboard.register_shortcut('minimize calibre', self.minimize_action.text(),
default_keys=(), action=self.minimize_action)
self.minimize_action.triggered.connect(self.showMinimized)
self.esc_action = QAction(self)
self.addAction(self.esc_action)
self.keyboard.register_shortcut('clear current search',
_('Clear the current search'), default_keys=('Esc',),
action=self.esc_action)
self.esc_action.triggered.connect(self.esc)
self.shift_esc_action = QAction(self)
self.addAction(self.shift_esc_action)
self.keyboard.register_shortcut('focus book list',
_('Focus the book list'), default_keys=('Shift+Esc',),
action=self.shift_esc_action)
self.shift_esc_action.triggered.connect(self.shift_esc)
self.ctrl_esc_action = QAction(self)
self.addAction(self.ctrl_esc_action)
self.keyboard.register_shortcut('clear virtual library',
_('Clear the Virtual library'), default_keys=('Ctrl+Esc',),
action=self.ctrl_esc_action)
self.ctrl_esc_action.triggered.connect(self.ctrl_esc)
self.alt_esc_action = QAction(self)
self.addAction(self.alt_esc_action)
self.keyboard.register_shortcut('clear additional restriction',
_('Clear the additional restriction'), default_keys=('Alt+Esc',),
action=self.alt_esc_action)
self.alt_esc_action.triggered.connect(self.clear_additional_restriction)
# ###################### Start spare job server ########################
QTimer.singleShot(1000, self.create_spare_pool)
# ###################### Location Manager ########################
self.location_manager.location_selected.connect(self.location_selected)
self.location_manager.unmount_device.connect(self.device_manager.umount_device)
self.location_manager.configure_device.connect(self.configure_connected_device)
self.location_manager.update_device_metadata.connect(self.update_metadata_on_device)
self.eject_action.triggered.connect(self.device_manager.umount_device)
# ################### Update notification ###################
UpdateMixin.init_update_mixin(self, opts)
# ###################### Search boxes ########################
SearchRestrictionMixin.init_search_restriction_mixin(self)
SavedSearchBoxMixin.init_saved_seach_box_mixin(self)
# ###################### Library view ########################
LibraryViewMixin.init_library_view_mixin(self, db)
SearchBoxMixin.init_search_box_mixin(self) # Requires current_db
self.library_view.model().count_changed_signal.connect(
self.iactions['Choose Library'].count_changed)
if not gprefs.get('quick_start_guide_added', False):
try:
add_quick_start_guide(self.library_view)
except:
import traceback
traceback.print_exc()
for view in ('library', 'memory', 'card_a', 'card_b'):
v = getattr(self, '%s_view' % view)
v.selectionModel().selectionChanged.connect(self.update_status_bar)
v.model().count_changed_signal.connect(self.update_status_bar)
self.library_view.model().count_changed()
self.bars_manager.database_changed(self.library_view.model().db)
self.library_view.model().database_changed.connect(self.bars_manager.database_changed,
type=Qt.ConnectionType.QueuedConnection)
# ########################## Tags Browser ##############################
TagBrowserMixin.init_tag_browser_mixin(self, db)
self.library_view.model().database_changed.connect(self.populate_tb_manage_menu, type=Qt.ConnectionType.QueuedConnection)
# ######################## Search Restriction ##########################
if db.new_api.pref('virtual_lib_on_startup'):
self.apply_virtual_library(db.new_api.pref('virtual_lib_on_startup'))
self.rebuild_vl_tabs()
# ########################## Cover Flow ################################
CoverFlowMixin.__init__(self)
self._calculated_available_height = min(max_available_height()-15,
self.height())
self.resize(self.width(), self._calculated_available_height)
self.build_context_menus()
for ac in self.iactions.values():
try:
ac.gui_layout_complete()
except:
import traceback
traceback.print_exc()
if ac.installation_type is PluginInstallationType.BUILTIN:
raise
if config['autolaunch_server']:
self.start_content_server()
do_hide_windows = False
if self.system_tray_icon is not None and self.system_tray_icon.isVisible() and opts.start_in_tray:
do_hide_windows = True
show_gui = False
setattr(self, '__systray_minimized', True)
if do_hide_windows:
self.hide_windows()
self.layout_container.relayout()
QTimer.singleShot(0, self.post_initialize_actions)
self.read_settings()
self.finalize_layout()
self.bars_manager.start_animation()
self.set_window_title()
if show_gui:
timed_print('GUI main window shown')
self.show()
for ac in self.iactions.values():
try:
ac.initialization_complete()
except:
import traceback
traceback.print_exc()
if ac.installation_type is PluginInstallationType.BUILTIN:
raise
self.set_current_library_information(current_library_name(), db.library_id,
db.field_metadata)
register_keyboard_shortcuts()
self.keyboard.finalize()
self.auto_adder = AutoAdder(gprefs['auto_add_path'], self)
self.listener = Listener(parent=self)
self.listener.message_received.connect(self.message_from_another_instance)
QApplication.instance().shutdown_signal_received.connect(self.quit)
if show_gui and self.gui_debug is not None:
QTimer.singleShot(10, self.show_gui_debug_msg)
self.iactions['Connect Share'].check_smartdevice_menus()
QTimer.singleShot(100, self.update_toggle_to_tray_action)
def post_initialize_actions(self):
# Various post-initialization actions after an event loop tick
if self.layout_container.is_visible.quick_view or self.iactions['Quickview'].needs_show_on_startup():
self.iactions['Quickview'].show_on_startup()
self.listener.start_listening()
self.start_smartdevice()
# Collect cycles now
gc.collect()
self.focus_library_view()
def show_gui_debug_msg(self):
info_dialog(self, _('Debug mode'), '<p>' +
_('You have started calibre in debug mode. After you '
'quit calibre, the debug log will be available in '
'the file: %s<p>The '
'log will be displayed automatically.')%self.gui_debug, show=True)
def esc(self, *args):
self.search.clear()
def focus_current_view(self):
view = self.current_view()
if view is self.library_view:
self.focus_library_view()
else:
view.setFocus(Qt.FocusReason.OtherFocusReason)
shift_esc = focus_current_view
def focus_library_view(self):
self.library_view.alternate_views.current_view.setFocus(Qt.FocusReason.OtherFocusReason)
def ctrl_esc(self):
self.apply_virtual_library()
self.focus_current_view()
def start_smartdevice(self):
message = None
if self.device_manager.get_option('smartdevice', 'autostart'):
timed_print('Starting the smartdevice driver')
with BusyCursor():
try:
message = self.device_manager.start_plugin('smartdevice')
timed_print('Finished starting smartdevice')
except Exception as e:
message = str(e)
timed_print(f'Starting smartdevice driver failed: {message}')
import traceback
traceback.print_exc()
if message:
if not self.device_manager.is_running('Wireless Devices'):
error_dialog(self, _('Problem starting the wireless device'),
_('The wireless device driver had problems starting. '
'It said "%s"')%message, show=True)
self.iactions['Connect Share'].set_smartdevice_action_state()
def start_content_server(self, check_started=True):
from calibre.srv.embedded import Server
if not gprefs.get('server3_warning_done', False):
gprefs.set('server3_warning_done', True)
if os.path.exists(os.path.join(config_dir, 'server.py')):
try:
os.remove(os.path.join(config_dir, 'server.py'))
except OSError:
pass
warning_dialog(self, _('Content server changed!'), _(
'calibre 3 comes with a completely re-written Content server.'
' As such any custom configuration you have for the content'
' server no longer applies. You should check and refresh your'
' settings in Preferences->Sharing->Sharing over the net'), show=True)
self.content_server = Server(self.library_broker, Dispatcher(self.handle_changes_from_server))
self.content_server.state_callback = Dispatcher(
self.iactions['Connect Share'].content_server_state_changed)
if check_started:
self.content_server.start_failure_callback = \
Dispatcher(self.content_server_start_failed)
self.content_server.start()
def handle_changes_from_server(self, library_path, change_event):
if DEBUG:
prints(f'Received server change event: {change_event} for {library_path}')
if self.library_broker.is_gui_library(library_path):
self.server_changes.put((library_path, change_event))
self.server_change_notification_timer.start()
def handle_changes_from_server_debounced(self):
if self.shutting_down:
return
changes = []
while True:
try:
library_path, change_event = self.server_changes.get_nowait()
except Empty:
break
if self.library_broker.is_gui_library(library_path):
changes.append(change_event)
if changes:
handle_changes(changes, self)
def content_server_start_failed(self, msg):
self.content_server = None
error_dialog(self, _('Failed to start Content server'),
_('Could not start the Content server. Error:\n\n%s')%msg,
show=True)
def resizeEvent(self, ev):
MainWindow.resizeEvent(self, ev)
self.search.setMaximumWidth(self.width()-150)
def create_spare_pool(self, *args):
if self._spare_pool is None:
num = min(detect_ncpus(), config['worker_limit']//2)
self._spare_pool = Pool(max_workers=num, name='GUIPool')
def spare_pool(self):
ans, self._spare_pool = self._spare_pool, None
QTimer.singleShot(1000, self.create_spare_pool)
return ans
def do_proceed(self, func, payload):
if callable(func):
func(payload)
def no_op(self, *args):
pass
def system_tray_icon_activated(self, r=False):
if r in (QSystemTrayIcon.ActivationReason.Trigger, QSystemTrayIcon.ActivationReason.MiddleClick, False):
if self.isVisible():
if self.isMinimized():
self.showNormal()
else:
self.hide_windows()
else:
self.show_windows()
if self.isMinimized():
self.showNormal()
@property
def is_minimized_to_tray(self):
return getattr(self, '__systray_minimized', False)
def ask_a_yes_no_question(self, title, msg, det_msg='',
show_copy_button=False, ans_when_user_unavailable=True,
skip_dialog_name=None, skipped_value=True):
if self.is_minimized_to_tray:
return ans_when_user_unavailable
return question_dialog(self, title, msg, det_msg=det_msg,
show_copy_button=show_copy_button,
skip_dialog_name=skip_dialog_name,
skip_dialog_skipped_value=skipped_value)
def update_toggle_to_tray_action(self, *args):
if hasattr(self, 'toggle_to_tray_action'):
self.toggle_to_tray_action.setText(
_('Hide main window') if self.isVisible() else _('Show main window'))
def hide_windows(self):
for window in QApplication.topLevelWidgets():
if isinstance(window, (MainWindow, QDialog)) and \
window.isVisible():
window.hide()
setattr(window, '__systray_minimized', True)
self.update_toggle_to_tray_action()
def show_windows(self, *args):
for window in QApplication.topLevelWidgets():
if getattr(window, '__systray_minimized', False):
window.show()
setattr(window, '__systray_minimized', False)
self.update_toggle_to_tray_action()
def changeEvent(self, ev):
# Handle bug in Qt 6 that causes the window to be shown as blank if it was first
# maximized and then closed to system tray, when remote desktop is
# reconnected: https://bugreports.qt.io/browse/QTBUG-124177
if (
iswindows and ev.type() == QEvent.Type.ActivationChange and self.is_minimized_to_tray and self.isMaximized() and
self.isActiveWindow() and not self.isVisible()
):
QTimer.singleShot(0, self.show_windows)
return super().changeEvent(ev)
def test_server(self, *args):
if self.content_server is not None and \
self.content_server.exception is not None:
error_dialog(self, _('Failed to start Content server'),
str(self.content_server.exception)).exec()
@property
def current_db(self):
return self.library_view.model().db
def refresh_all(self):
m = self.library_view.model()
m.db.data.refresh(clear_caches=False, do_search=False)
self.saved_searches_changed(recount=False)
m.resort()
m.research()
self.tags_view.recount()
def handle_cli_args(self, args):
from urllib.parse import parse_qs, unquote, urlparse
if isinstance(args, string_or_bytes):
args = [args]
files, urls = [], []
for p in args:
if p.startswith('calibre://'):
try:
purl = urlparse(p)
if purl.scheme == 'calibre':
action = purl.netloc
path = unquote(purl.path)
query = parse_qs(unquote(purl.query))
urls.append((action, path, query))
except Exception:
prints('Ignoring malformed URL:', p, file=sys.stderr)
continue
elif p.startswith('file://'):
try:
purl = urlparse(p)
if purl.scheme == 'file':
path = unquote(purl.path)
a = os.path.abspath(path)
if not os.path.isdir(a) and os.access(a, os.R_OK):
files.append(a)
except Exception:
prints('Ignoring malformed URL:', p, file=sys.stderr)
continue
else:
a = os.path.abspath(p)
if not os.path.isdir(a) and os.access(a, os.R_OK):
files.append(a)
if files:
self.iactions['Add Books'].add_filesystem_book(files)
if urls:
def doit():
for action, path, query in urls:
self.handle_url_action(action, path, query)
QTimer.singleShot(10, doit)
def handle_url_action(self, action, path, query):
import posixpath
def decode_library_id(x):
if x == '_':
return getattr(self.current_db.new_api, 'server_library_id', None) or '_'
if x.startswith('_hex_-'):
return bytes.fromhex(x[6:]).decode('utf-8')
return x
def get_virtual_library(query):
vl = None
if query.get('encoded_virtual_library'):
vl = bytes.fromhex(query.get('encoded_virtual_library')[0]).decode('utf-8')
elif query.get('virtual_library'):
vl = query.get('virtual_library')[0]
if vl == '-':
vl = None
return vl
if action == 'switch-library':
library_id = decode_library_id(posixpath.basename(path))
library_path = self.library_broker.path_for_library_id(library_id)
if not db_matches(self.current_db, library_id, library_path):
self.library_moved(library_path)
elif action == 'book-details':
parts = tuple(filter(None, path.split('/')))
if len(parts) != 2:
return
library_id, book_id = parts
library_id = decode_library_id(library_id)
library_path = self.library_broker.path_for_library_id(library_id)
if library_path is None:
prints('Ignoring unknown library id', library_id, file=sys.stderr)
return
try:
book_id = int(book_id)
except Exception:
prints('Ignoring invalid book id', book_id, file=sys.stderr)
return
details = self.iactions['Show Book Details']
details.show_book_info(library_id=library_id, library_path=library_path, book_id=book_id)
elif action == 'show-note':
parts = tuple(filter(None, path.split('/')))
if len(parts) != 3:
return
library_id, field, itemx = parts
library_id = decode_library_id(library_id)
library_path = self.library_broker.path_for_library_id(library_id)
if library_path is None:
prints('Ignoring unknown library id', library_id, file=sys.stderr)
return
if field.startswith('_'):
field = '#' + field[1:]
item_id = item_val = None
if itemx.startswith('id_'):
try:
item_id = int(itemx[3:])
except Exception:
prints('Ignoring invalid item id', itemx, file=sys.stderr)
return
elif itemx.startswith('hex_'):
try:
item_val = bytes.fromhex(itemx[4:]).decode('utf-8')
except Exception:
prints('Ignoring invalid item hexval', itemx, file=sys.stderr)
return
elif itemx.startswith('val_'):
item_val = itemx[4:]
else:
prints('Ignoring invalid item hexval', itemx, file=sys.stderr)
return
def doit():
nonlocal item_id, item_val
db = self.current_db.new_api
if item_id is None:
item_id = db.get_item_id(field, item_val)
if item_id is None:
prints('The item named:', item_val, 'was not found', file=sys.stderr)
return
if db.notes_for(field, item_id):
from calibre.gui2.dialogs.show_category_note import ShowNoteDialog
ShowNoteDialog(field, item_id, db, parent=self).show()
else:
prints(f'No notes available for {field}:{itemx}', file=sys.stderr)
self.perform_url_action(library_id, library_path, doit)
elif action == 'show-book':
parts = tuple(filter(None, path.split('/')))
if len(parts) != 2:
return
library_id, book_id = parts
library_id = decode_library_id(library_id)
try:
book_id = int(book_id)
except Exception:
prints('Ignoring invalid book id', book_id, file=sys.stderr)
return
library_path = self.library_broker.path_for_library_id(library_id)
if library_path is None:
return
vl = get_virtual_library(query)
def doit():
# To maintain compatibility, don't change the VL if it isn't specified.
if vl is not None and vl != '_':
self.apply_virtual_library(vl)
rows = self.library_view.select_rows((book_id,))
if not rows:
self.search.set_search_string('')
rows = self.library_view.select_rows((book_id,))
db = self.current_db
if not rows and (db.data.get_base_restriction_name() or db.data.get_search_restriction_name()):
self.apply_virtual_library()
self.apply_named_search_restriction()
self.library_view.select_rows((book_id,))
self.perform_url_action(library_id, library_path, doit)
elif action == 'view-book':
parts = tuple(filter(None, path.split('/')))
if len(parts) != 3:
return
library_id, book_id, fmt = parts
library_id = decode_library_id(library_id)
try:
book_id = int(book_id)
except Exception:
prints('Ignoring invalid book id', book_id, file=sys.stderr)
return
library_path = self.library_broker.path_for_library_id(library_id)
if library_path is None:
return
view = self.iactions['View']
def doit():
at = query.get('open_at') or None
if at:
at = at[0]
view.view_format_by_id(book_id, fmt.upper(), open_at=at)
self.perform_url_action(library_id, library_path, doit)
elif action == 'search':
parts = tuple(filter(None, path.split('/')))
if len(parts) != 1:
return
library_id = decode_library_id(parts[0])
library_path = self.library_broker.path_for_library_id(library_id)
if library_path is None:
return
sq = query.get('eq')
if sq:
sq = bytes.fromhex(sq[0]).decode('utf-8')
else:
sq = query.get('q')
if sq:
sq = sq[0]
sq = sq or ''
vl = get_virtual_library(query)
def doit():
if vl != '_':
self.apply_virtual_library(vl)
self.search.set_search_string(sq)
self.perform_url_action(library_id, library_path, doit)
def perform_url_action(self, library_id, library_path, func):
if not db_matches(self.current_db, library_id, library_path):
self.library_moved(library_path)
QTimer.singleShot(0, func)
else:
func()
def message_from_another_instance(self, msg):
if isinstance(msg, bytes):
msg = msg.decode('utf-8', 'replace')
if msg.startswith('launched:'):
import json
try:
argv = json.loads(msg[len('launched:'):])
except ValueError:
prints('Failed to decode message from other instance: %r' % msg)
if DEBUG:
error_dialog(self, 'Invalid message',
'Received an invalid message from other calibre instance.'
' Do you have multiple versions of calibre installed?',
det_msg='Invalid msg: %r' % msg, show=True)
argv = ()
if isinstance(argv, (list, tuple)) and len(argv) > 1:
self.handle_cli_args(argv[1:])
self.setWindowState(self.windowState() & ~Qt.WindowState.WindowMinimized|Qt.WindowState.WindowActive)
self.show_windows()
self.raise_and_focus()
self.activateWindow()
elif msg.startswith('shutdown:'):
self.quit(confirm_quit=False)
elif msg.startswith('bookedited:'):
parts = msg.split(':')[1:]
try:
book_id, fmt, library_id = parts[:3]
book_id = int(book_id)
m = self.library_view.model()
db = m.db.new_api
if m.db.library_id == library_id and db.has_id(book_id):
db.format_metadata(book_id, fmt, allow_cache=False, update_db=True)
db.reindex_fts_book(book_id, fmt)
db.update_last_modified((book_id,))
m.refresh_ids((book_id,))
db.event_dispatcher(db.EventType.book_edited, book_id, fmt)
except Exception:
import traceback
traceback.print_exc()
elif msg.startswith('web-store:'):
import json
try:
data = json.loads(msg[len('web-store:'):])
except ValueError:
prints('Failed to decode message from other instance: %r' % msg)
path = data['path']
if data['tags']:
before = self.current_db.new_api.all_book_ids()
self.iactions['Add Books'].add_filesystem_book([path], allow_device=False)
if data['tags']:
db = self.current_db.new_api
after = self.current_db.new_api.all_book_ids()
for book_id in after - before:
tags = list(db.field_for('tags', book_id))
tags += list(data['tags'])
self.current_db.new_api.set_field('tags', {book_id: tags})
else:
prints('Ignoring unknown message from other instance: %r' % msg[:20])
def current_view(self):
'''Convenience method that returns the currently visible view '''
try:
idx = self.stack.currentIndex()
except AttributeError:
return None # happens during startup
if idx == 0:
return self.library_view
if idx == 1:
return self.memory_view
if idx == 2:
return self.card_a_view
if idx == 3:
return self.card_b_view
def show_library_view(self):
self.location_manager.library_action.trigger()
def booklists(self):
return self.memory_view.model().db, self.card_a_view.model().db, self.card_b_view.model().db
def library_moved(self, newloc, copy_structure=False, allow_rebuild=False):
if newloc is None:
return
with self.library_broker:
default_prefs = None
try:
olddb = self.library_view.model().db
if copy_structure:
default_prefs = dict(olddb.prefs)
except:
olddb = None
if copy_structure and olddb is not None and default_prefs is not None:
default_prefs['field_metadata'] = olddb.new_api.field_metadata.all_metadata()
db = self.library_broker.prepare_for_gui_library_change(newloc)
if db is None:
try:
db = LibraryDatabase(newloc, default_prefs=default_prefs)
except apsw.Error:
if not allow_rebuild:
raise
import traceback
repair = question_dialog(self, _('Corrupted database'),
_('The library database at %s appears to be corrupted. Do '
'you want calibre to try and rebuild it automatically? '
'The rebuild may not be completely successful.')
% force_unicode(newloc, filesystem_encoding),
det_msg=traceback.format_exc()
)
if repair:
from calibre.gui2.dialogs.restore_library import repair_library_at
if repair_library_at(newloc, parent=self):
db = LibraryDatabase(newloc, default_prefs=default_prefs)
else:
return
else:
return
for action in self.iactions.values():
try:
action.library_about_to_change(olddb, db)
except Exception:
import traceback
traceback.print_exc()
self.library_path = newloc
self.extra_files_watcher.clear()
prefs['library_path'] = self.library_path
self.book_on_device(None, reset=True)
db.set_book_on_device_func(self.book_on_device)
self.library_view.set_database(db)
self.tags_view.set_database(db, self.alter_tb)
self.library_view.model().set_book_on_device_func(self.book_on_device)
self.status_bar.clear_message()
self.search.clear()
self.book_details.reset_info()
# self.library_view.model().count_changed()
db = self.library_view.model().db
self.iactions['Choose Library'].count_changed(db.count())
self.set_window_title()
self.apply_named_search_restriction('') # reset restriction to null
self.saved_searches_changed(recount=False) # reload the search restrictions combo box
if db.new_api.pref('virtual_lib_on_startup'):
self.apply_virtual_library(db.new_api.pref('virtual_lib_on_startup'))
self.rebuild_vl_tabs()
for action in self.iactions.values():
try:
action.library_changed(db)
except Exception:
import traceback
traceback.print_exc()
self.library_broker.gui_library_changed(db, olddb)
if self.device_connected:
self.set_books_in_library(self.booklists(), reset=True)
self.refresh_ondevice()
self.memory_view.reset()
self.card_a_view.reset()
self.card_b_view.reset()
self.set_current_library_information(current_library_name(), db.library_id,
db.field_metadata)
self.library_view.set_current_row(0)
# Run a garbage collection now so that it does not freeze the
# interface later
gc.collect()
def set_window_title(self):
db = self.current_db
restrictions = [x for x in (db.data.get_base_restriction_name(),
db.data.get_search_restriction_name()) if x]
restrictions = ' :: '.join(restrictions)
font = QFont()
if restrictions:
restrictions = ' :: ' + restrictions
font.setBold(True)
font.setItalic(True)
self.virtual_library.setFont(font)
title = '{} — || {}{} ||'.format(
__appname__, self.iactions['Choose Library'].library_name(), restrictions)
self.setWindowTitle(title)
def location_selected(self, location):
'''
Called when a location icon is clicked (e.g. Library)
'''
page = 0 if location == 'library' else 1 if location == 'main' else 2 if location == 'carda' else 3
self.stack.setCurrentIndex(page)
self.book_details.reset_info()
self.layout_container.tag_browser_button.setEnabled(location == 'library')
self.layout_container.cover_browser_button.setEnabled(location == 'library')
self.vl_tabs.update_visibility()
for action in self.iactions.values():
action.location_selected(location)
if location == 'library':
self.virtual_library_menu.setEnabled(True)
self.highlight_only_button.setEnabled(True)
self.vl_tabs.setEnabled(True)
else:
self.virtual_library_menu.setEnabled(False)
self.highlight_only_button.setEnabled(False)
self.vl_tabs.setEnabled(False)
# Reset the view in case something changed while it was invisible
self.current_view().reset()
self.current_view().refresh_book_details()
self.set_number_of_books_shown()
self.update_status_bar()
def job_exception(self, job, dialog_title=_('Conversion error'), retry_func=None):
if not hasattr(self, '_modeless_dialogs'):
self._modeless_dialogs = []
minz = self.is_minimized_to_tray
if self.isVisible():
for x in list(self._modeless_dialogs):
if not x.isVisible():
self._modeless_dialogs.remove(x)
try:
if 'calibre.ebooks.DRMError' in job.details:
if not minz:
from calibre.gui2.dialogs.drm_error import DRMErrorMessage
d = DRMErrorMessage(self, _('Cannot convert') + ' ' +
job.description.split(':')[-1].partition('(')[-1][:-1])
d.setModal(False)
d.show()
self._modeless_dialogs.append(d)
return
if 'calibre.ebooks.oeb.transforms.split.SplitError' in job.details:
title = job.description.split(':')[-1].partition('(')[-1][:-1]
msg = _('<p><b>Failed to convert: %s')%title
msg += '<p>'+_('''
Many older e-book reader devices are incapable of displaying
EPUB files that have internal components over a certain size.
Therefore, when converting to EPUB, calibre automatically tries
to split up the EPUB into smaller sized pieces. For some
files that are large undifferentiated blocks of text, this
splitting fails.
<p>You can <b>work around the problem</b> by either increasing the
maximum split size under <i>EPUB output</i> in the conversion dialog,
or by turning on Heuristic processing, also in the conversion
dialog. Note that if you make the maximum split size too large,
your e-book reader may have trouble with the EPUB.
''')
if not minz:
d = error_dialog(self, _('Conversion failed'), msg,
det_msg=job.details)
d.setModal(False)
d.show()
self._modeless_dialogs.append(d)
return
if 'calibre.ebooks.mobi.reader.mobi6.KFXError:' in job.details:
if not minz:
title = job.description.split(':')[-1].partition('(')[-1][:-1]
msg = _('<p><b>Failed to convert: %s') % title
idx = job.details.index('calibre.ebooks.mobi.reader.mobi6.KFXError:')
msg += '<p>' + re.sub(r'(https:\S+)', r'<a href="\1">{}</a>'.format(_('here')),
job.details[idx:].partition(':')[2].strip())
d = error_dialog(self, _('Conversion failed'), msg, det_msg=job.details)
d.setModal(False)
d.show()
self._modeless_dialogs.append(d)
return
if 'calibre.web.feeds.input.RecipeDisabled' in job.details:
if not minz:
msg = job.details
msg = msg[msg.find('calibre.web.feeds.input.RecipeDisabled:'):]
msg = msg.partition(':')[-1]
d = error_dialog(self, _('Recipe Disabled'),
'<p>%s</p>'%msg)
d.setModal(False)
d.show()
self._modeless_dialogs.append(d)
return
if 'calibre.ebooks.conversion.ConversionUserFeedBack:' in job.details:
if not minz:
import json
payload = job.details.rpartition(
'calibre.ebooks.conversion.ConversionUserFeedBack:')[-1]
payload = json.loads('{' + payload.partition('{')[-1])
d = {'info':info_dialog, 'warn':warning_dialog,
'error':error_dialog}.get(payload['level'],
error_dialog)
d = d(self, payload['title'],
'<p>%s</p>'%payload['msg'],
det_msg=payload['det_msg'])
d.setModal(False)
d.show()
self._modeless_dialogs.append(d)
return
except:
pass
if job.killed:
return
try:
prints(job.details, file=sys.stderr)
except:
pass
if not minz:
self.job_error_dialog.show_error(dialog_title,
_('<b>Failed</b>')+': '+str(job.description),
det_msg=job.details, retry_func=retry_func)
def read_settings(self):
self.restore_geometry(gprefs, 'calibre_main_window_geometry', get_legacy_saved_geometry=lambda: config['main_window_geometry'])
self.read_layout_settings()
def write_settings(self):
with gprefs: # Only write to gprefs once
self.save_geometry(gprefs, 'calibre_main_window_geometry')
dynamic.set('sort_history', self.library_view.model().sort_history)
self.save_layout_state()
self.tb_widget.save_state()
def quit(self, checked=True, restart=False, debug_on_restart=False,
confirm_quit=True, no_plugins_on_restart=False):
if self.shutting_down:
return
if confirm_quit and not self.confirm_quit():
return
try:
self.shutdown()
except:
import traceback
traceback.print_exc()
self.restart_after_quit = restart
self.debug_on_restart = debug_on_restart
self.no_plugins_on_restart = no_plugins_on_restart
if self.system_tray_icon is not None and self.restart_after_quit:
# Needed on windows to prevent multiple systray icons
self.system_tray_icon.setVisible(False)
QApplication.instance().exit()
def donate(self, *args):
from calibre.utils.localization import localize_website_link
open_url(QUrl(localize_website_link('https://calibre-ebook.com/donate')))
def confirm_quit(self):
if self.job_manager.has_jobs():
msg = _('There are active jobs. Are you sure you want to quit?')
if self.job_manager.has_device_jobs():
msg = '<p>'+__appname__ + \
_(''' is communicating with the device!<br>
Quitting may cause corruption on the device.<br>
Are you sure you want to quit?''')+'</p>'
if not question_dialog(self, _('Active jobs'), msg):
return False
if self.proceed_question.questions:
msg = _('There are library updates waiting. Are you sure you want to quit?')
if not question_dialog(self, _('Library updates waiting'), msg):
return False
return True
def shutdown(self, write_settings=True):
self.shutting_down = True
if hasattr(self.library_view, 'connect_to_book_display_timer'):
self.library_view.connect_to_book_display_timer.stop()
self.shutdown_started.emit()
self.show_shutdown_message()
self.server_change_notification_timer.stop()
self.extra_files_watcher.clear()
try:
self.event_in_db.disconnect()
except Exception:
pass
from calibre.customize.ui import has_library_closed_plugins
if has_library_closed_plugins():
self.show_shutdown_message(
_('Running database shutdown plugins. This could take a few seconds...'))
self.grid_view.shutdown()
db = None
try:
db = self.library_view.model().db
cf = db.clean
except:
pass
else:
cf()
# Save the current field_metadata for applications like calibre2opds
# Goes here, because if cf is valid, db is valid.
db.new_api.set_pref('field_metadata', db.field_metadata.all_metadata())
db.commit_dirty_cache()
db.prefs.write_serialized(prefs['library_path'])
for action in self.iactions.values():
action.shutting_down()
if write_settings:
self.write_settings()
if getattr(self, 'update_checker', None):
self.update_checker.shutdown()
self.listener.close()
self.job_manager.server.close()
self.job_manager.threaded_server.close()
self.device_manager.keep_going = False
self.auto_adder.stop()
# Do not report any errors that happen after the shutdown
# We cannot restore the original excepthook as that causes PyQt to
# call abort() on unhandled exceptions
import traceback
def eh(t, v, tb):
try:
traceback.print_exception(t, v, tb, file=sys.stderr)
except:
pass
sys.excepthook = eh
mb = self.library_view.model().metadata_backup
if mb is not None:
mb.stop()
self.library_view.model().close()
try:
try:
if self.content_server is not None:
# If the Content server has any sockets being closed then
# this can take quite a long time (minutes). Tell the user that it is
# happening.
self.show_shutdown_message(
_('Shutting down the Content server. This could take a while...'))
s = self.content_server
self.content_server = None
s.exit()
except:
pass
except KeyboardInterrupt:
pass
self.hide_windows()
if self._spare_pool is not None:
self._spare_pool.shutdown()
from calibre.scraper.simple import cleanup_overseers
wait_for_cleanup = cleanup_overseers()
from calibre.live import async_stop_worker
wait_for_stop = async_stop_worker()
time.sleep(2)
self.istores.join()
wait_for_cleanup()
wait_for_stop()
self.shutdown_completed.emit()
return True
def run_wizard(self, *args):
if self.confirm_quit():
self.run_wizard_b4_shutdown = True
self.restart_after_quit = True
try:
self.shutdown(write_settings=False)
except:
pass
QApplication.instance().quit()
def closeEvent(self, e):
if self.shutting_down:
return
self.write_settings()
if self.system_tray_icon is not None and self.system_tray_icon.isVisible():
if not dynamic['systray_msg'] and not ismacos:
info_dialog(self, 'calibre', 'calibre '+
_('will keep running in the system tray. To close it, '
'choose <b>Quit</b> in the context menu of the '
'system tray.'), show_copy_button=False).exec()
dynamic['systray_msg'] = True
self.hide_windows()
e.ignore()
else:
if self.confirm_quit():
try:
self.shutdown(write_settings=False)
except:
import traceback
traceback.print_exc()
e.accept()
else:
e.ignore()
# }}}
| 57,404 | Python | .py | 1,212 | 34.516502 | 135 | 0.579625 | kovidgoyal/calibre | 19,243 | 2,250 | 4 | GPL-3.0 | 9/5/2024, 5:13:50 PM (Europe/Amsterdam) |
26,626 | device.py | kovidgoyal_calibre/src/calibre/gui2/device.py | __license__ = 'GPL v3'
__copyright__ = '2008, Kovid Goyal <kovid at kovidgoyal.net>'
import io
# Imports {{{
import os
import re
import sys
import time
import traceback
import weakref
from threading import Event, Thread
from qt.core import QAction, QActionGroup, QCoreApplication, QDialog, QDialogButtonBox, QEventLoop, QIcon, QMenu, QObject, QTimer, QVBoxLayout, pyqtSignal
from calibre import as_unicode, force_unicode, preferred_encoding, prints, sanitize_file_name
from calibre.constants import DEBUG
from calibre.customize.ui import available_input_formats, available_output_formats, device_plugins, disabled_device_plugins
from calibre.devices.errors import (
BlacklistedDevice,
FreeSpaceError,
InitialConnectionError,
OpenActionNeeded,
OpenFailed,
OpenFeedback,
UserFeedback,
WrongDestinationError,
)
from calibre.devices.folder_device.driver import FOLDER_DEVICE
from calibre.devices.interface import DevicePlugin, currently_connected_device
from calibre.devices.scanner import DeviceScanner
from calibre.ebooks.covers import cprefs, generate_cover, override_prefs, scale_cover
from calibre.ebooks.metadata import authors_to_string
from calibre.gui2 import (
Dispatcher,
FunctionDispatcher,
choose_dir,
config,
dynamic,
error_dialog,
gprefs,
info_dialog,
question_dialog,
show_restart_warning,
warning_dialog,
)
from calibre.gui2.dialogs.choose_format_device import ChooseFormatDeviceDialog
from calibre.gui2.widgets import BusyCursor
from calibre.library.save_to_disk import find_plugboard
from calibre.prints import debug_print
from calibre.ptempfile import PersistentTemporaryFile
from calibre.ptempfile import force_unicode as filename_to_unicode
from calibre.startup import connect_lambda
from calibre.utils.config import device_prefs, tweaks
from calibre.utils.filenames import ascii_filename
from calibre.utils.img import scale_image
from calibre.utils.ipc.job import BaseJob
from calibre.utils.localization import ngettext
from polyglot import queue
from polyglot.builtins import string_or_unicode
# }}}
class DeviceJob(BaseJob): # {{{
def __init__(self, func, done, job_manager, args=[], kwargs={},
description=''):
BaseJob.__init__(self, description)
self.func = func
self.callback_on_done = done
if not isinstance(self.callback_on_done, (Dispatcher,
FunctionDispatcher)):
self.callback_on_done = FunctionDispatcher(self.callback_on_done)
self.args, self.kwargs = args, kwargs
self.exception = None
self.job_manager = job_manager
self._details = _('No details available.')
self._aborted = False
def start_work(self):
if DEBUG:
prints('Job:', self.id, self.description, 'started')
self.start_time = time.time()
self.job_manager.changed_queue.put(self)
def job_done(self):
self.duration = time.time() - self.start_time
self.percent = 1
if DEBUG:
prints('DeviceJob:', self.id, self.description,
'done, calling callback')
try:
self.callback_on_done(self)
except:
pass
if DEBUG:
prints('DeviceJob:', self.id, self.description,
'callback returned')
self.job_manager.changed_queue.put(self)
def report_progress(self, percent, msg=''):
self.notifications.put((percent, msg))
self.job_manager.changed_queue.put(self)
def run(self):
self.start_work()
try:
self.result = self.func(*self.args, **self.kwargs)
if self._aborted:
return
except (Exception, SystemExit) as err:
if self._aborted:
return
self.failed = True
ex = as_unicode(err)
self._details = ex + '\n\n' + \
force_unicode(traceback.format_exc())
self.exception = err
finally:
self.job_done()
def abort(self, err):
call_job_done = False
if self.run_state == self.WAITING:
self.start_work()
call_job_done = True
self._aborted = True
self.failed = True
self._details = str(err)
self.exception = err
if call_job_done:
self.job_done()
@property
def log_file(self):
return io.BytesIO(self._details.encode('utf-8'))
# }}}
def device_name_for_plugboards(device_class):
if hasattr(device_class, 'DEVICE_PLUGBOARD_NAME'):
return device_class.DEVICE_PLUGBOARD_NAME
return device_class.__class__.__name__
def convert_open_popup(opm, skip_key):
class OPM(OpenFeedback):
def __init__(self, opm):
super().__init__('placeholder')
self.opm = opm
self.skip_key = skip_key
def custom_dialog(self, parent):
from calibre.gui2.dialogs.message_box import MessageBox
class M(MessageBox):
def on_cd_finished(s):
gprefs.set(self.skip_key, not s.toggle_checkbox.isChecked())
m = M({
'info': MessageBox.INFO, 'information': MessageBox.INFO,
'warn': MessageBox.WARNING, 'warning': MessageBox.WARNING,
}[self.opm.level], self.opm.title, self.opm.message,
parent=parent
)
tc = m.toggle_checkbox
tc.setVisible(True)
tc.setText(_('Show this message again'))
tc.setChecked(not self.opm.skip_dialog_skip_precheck)
m.resize_needed.emit()
m.finished.connect(m.on_cd_finished)
return m
return OPM(opm)
class DeviceManager(Thread): # {{{
def __init__(self, connected_slot, job_manager, open_feedback_slot,
open_feedback_msg, allow_connect_slot,
after_callback_feedback_slot, sleep_time=2):
'''
:sleep_time: Time to sleep between device probes in secs
'''
Thread.__init__(self, name='DeviceManager', daemon=True)
# [Device driver, Showing in GUI, Ejected]
self.devices = list(device_plugins())
self.disabled_device_plugins = list(disabled_device_plugins())
self.managed_devices = [x for x in self.devices if
not x.MANAGES_DEVICE_PRESENCE]
self.unmanaged_devices = [x for x in self.devices if
x.MANAGES_DEVICE_PRESENCE]
self.sleep_time = sleep_time
self.connected_slot = connected_slot # see DeviceMixin.device_connected()
self.allow_connect_slot = allow_connect_slot
self.jobs = queue.Queue(0)
self.job_steps = queue.Queue(0)
self.keep_going = True
self.job_manager = job_manager
self.reported_errors = set()
self.shown_open_popups = set()
self.current_job = None
self.scanner = DeviceScanner()
self.connected_device = None
self.connected_device_kind = None
self.ejected_devices = set()
self.mount_connection_requests = queue.Queue(0)
self.open_feedback_slot = open_feedback_slot
self.open_feedback_only_once_seen = set()
self.after_callback_feedback_slot = after_callback_feedback_slot
self.open_feedback_msg = open_feedback_msg
self._device_information = None
self.current_library_uuid = None
self.call_shutdown_on_disconnect = False
self.devices_initialized = Event()
self.dynamic_plugins = {}
def report_progress(self, *args):
pass
@property
def is_device_connected(self):
return self.connected_device is not None
@property
def is_device_present(self):
return self.connected_device is not None and self.connected_device not in self.ejected_devices
@property
def device(self):
return self.connected_device
def do_connect(self, connected_devices, device_kind):
for dev, detected_device in connected_devices:
if dev.OPEN_FEEDBACK_MESSAGE is not None:
self.open_feedback_slot(dev.OPEN_FEEDBACK_MESSAGE)
opm = dev.get_open_popup_message()
if opm is not None:
skip_key = f'do_not_show_device_open_popup_message_{dev.__class__.__name__}'
if skip_key not in self.shown_open_popups and not gprefs.get(skip_key, False):
self.shown_open_popups.add(skip_key)
self.open_feedback_msg(dev.get_gui_name(), convert_open_popup(opm, skip_key))
try:
dev.reset(detected_device=detected_device,
report_progress=self.report_progress)
dev.open(detected_device, self.current_library_uuid)
except OpenFeedback as e:
if dev not in self.ejected_devices:
self.open_feedback_msg(dev.get_gui_name(), e)
self.ejected_devices.add(dev)
continue
except OpenFailed:
raise
except:
tb = traceback.format_exc()
if DEBUG or tb not in self.reported_errors:
self.reported_errors.add(tb)
prints('Unable to open device', str(dev))
prints(tb)
continue
self.after_device_connect(dev, device_kind)
return True
return False
def after_device_connect(self, dev, device_kind):
allow_connect = True
try:
uid = dev.get_device_uid()
except NotImplementedError:
uid = None
asked = gprefs.get('ask_to_manage_device', [])
if (dev.ASK_TO_ALLOW_CONNECT and uid and uid not in asked):
if not self.allow_connect_slot(dev.get_gui_name(), dev.icon):
allow_connect = False
asked.append(uid)
gprefs.set('ask_to_manage_device', asked)
if not allow_connect:
dev.ignore_connected_device(uid)
return
self.connected_device = currently_connected_device._device = dev
self.connected_device.specialize_global_preferences(device_prefs)
self.connected_device_kind = device_kind
self.connected_slot(True, device_kind)
def connected_device_removed(self):
while True:
try:
job = self.jobs.get_nowait()
job.abort(Exception(_('Device no longer connected.')))
except queue.Empty:
break
try:
self.connected_device.post_yank_cleanup()
except:
pass
if self.connected_device in self.ejected_devices:
self.ejected_devices.remove(self.connected_device)
call_connected_slot = False
else:
call_connected_slot = True
if self.call_shutdown_on_disconnect:
# The current device is an instance of a plugin class instantiated
# to handle this connection, probably as a mounted device. We are
# now abandoning the instance that we created, so we tell it that it
# is being shut down.
self.connected_device.shutdown()
self.call_shutdown_on_disconnect = False
device_prefs.set_overrides()
self.connected_device = currently_connected_device._device = None
self._device_information = None
if call_connected_slot:
self.connected_slot(False, None)
def detect_device(self):
self.scanner.scan()
if self.is_device_connected:
if self.connected_device.MANAGES_DEVICE_PRESENCE:
cd = self.connected_device.detect_managed_devices(self.scanner.devices)
if cd is None:
self.connected_device_removed()
else:
connected, detected_device = \
self.scanner.is_device_connected(self.connected_device,
only_presence=True)
if not connected:
if DEBUG:
# Allow the device subsystem to output debugging info about
# why it thinks the device is not connected. Used, e.g.
# in the can_handle() method of the T1 driver
self.scanner.is_device_connected(self.connected_device,
only_presence=True, debug=True)
self.connected_device_removed()
else:
for dev in self.unmanaged_devices:
try:
cd = dev.detect_managed_devices(self.scanner.devices)
except:
prints('Error during device detection for %s:'%dev)
traceback.print_exc()
else:
if cd is not None:
try:
dev.open(cd, self.current_library_uuid)
except BlacklistedDevice as e:
prints('Ignoring blacklisted device: %s'%
as_unicode(e))
except OpenActionNeeded as e:
if e.only_once_id not in self.open_feedback_only_once_seen:
self.open_feedback_only_once_seen.add(e.only_once_id)
self.open_feedback_msg(e.device_name, e)
except:
prints('Error while trying to open %s (Driver: %s)'%
(cd, dev))
traceback.print_exc()
else:
self.after_device_connect(dev, 'unmanaged-device')
return
try:
possibly_connected_devices = []
for device in self.managed_devices:
if device in self.ejected_devices:
continue
try:
possibly_connected, detected_device = \
self.scanner.is_device_connected(device)
except InitialConnectionError as e:
self.open_feedback_msg(device.get_gui_name(), e)
continue
if possibly_connected:
possibly_connected_devices.append((device, detected_device))
if possibly_connected_devices:
if not self.do_connect(possibly_connected_devices,
device_kind='device'):
if DEBUG:
prints('Connect to device failed, retrying in 5 seconds...')
time.sleep(5)
if not self.do_connect(possibly_connected_devices,
device_kind='device'):
if DEBUG:
prints('Device connect failed again, giving up')
except OpenFailed as e:
if e.show_me:
traceback.print_exc()
# Mount devices that don't use USB, such as the folder device
# This will be called on the GUI thread. Because of this, we must store
# information that the scanner thread will use to do the real work.
def mount_device(self, kls, kind, path):
self.mount_connection_requests.put((kls, kind, path))
# disconnect a device
def umount_device(self, *args):
if self.is_device_connected and not self.job_manager.has_device_jobs():
if self.connected_device_kind in {'unmanaged-device', 'device'}:
self.connected_device.eject()
if self.connected_device_kind != 'unmanaged-device':
self.ejected_devices.add(self.connected_device)
self.connected_slot(False, None)
elif hasattr(self.connected_device, 'unmount_device'):
# As we are on the wrong thread, this call must *not* do
# anything besides set a flag that the right thread will see.
self.connected_device.unmount_device()
def next_job(self):
if not self.job_steps.empty():
try:
return self.job_steps.get_nowait()
except queue.Empty:
pass
if not self.jobs.empty():
try:
return self.jobs.get_nowait()
except queue.Empty:
pass
def run_startup(self, dev):
name = 'unknown'
try:
name = dev.__class__.__name__
dev.startup()
except:
prints('Startup method for device %s threw exception'%name)
traceback.print_exc()
def run(self):
# Do any device-specific startup processing.
for d in self.devices:
self.run_startup(d)
n = d.is_dynamically_controllable()
if n:
self.dynamic_plugins[n] = d
self.devices_initialized.set()
while self.keep_going:
kls = None
while True:
try:
(kls,device_kind, folder_path) = \
self.mount_connection_requests.get_nowait()
except queue.Empty:
break
if kls is not None:
try:
dev = kls(folder_path)
# We just created a new device instance. Call its startup
# method and set the flag to call the shutdown method when
# it disconnects.
self.run_startup(dev)
self.call_shutdown_on_disconnect = True
self.do_connect([[dev, None],], device_kind=device_kind)
except:
prints('Unable to open %s as device (%s)'%(device_kind, folder_path))
traceback.print_exc()
else:
self.detect_device()
do_sleep = True
while True:
job = self.next_job()
if job is not None:
do_sleep = False
self.current_job = job
if self.device is not None:
self.device.set_progress_reporter(job.report_progress)
self.current_job.run()
self.current_job = None
feedback = getattr(self.device, 'user_feedback_after_callback', None)
if feedback is not None:
self.device.user_feedback_after_callback = None
self.after_callback_feedback_slot(feedback)
else:
break
if do_sleep:
time.sleep(self.sleep_time)
# We are exiting. Call the shutdown method for each plugin
for p in self.devices:
try:
p.shutdown()
except:
pass
def create_job_step(self, func, done, description, to_job, args=[], kwargs={}):
job = DeviceJob(func, done, self.job_manager,
args=args, kwargs=kwargs, description=description)
self.job_manager.add_job(job)
if (done is None or isinstance(done, FunctionDispatcher)) and \
(to_job is not None and to_job == self.current_job):
self.job_steps.put(job)
else:
self.jobs.put(job)
return job
def create_job(self, func, done, description, args=[], kwargs={}):
return self.create_job_step(func, done, description, None, args, kwargs)
def has_card(self):
try:
return bool(self.device.card_prefix())
except:
return False
def _debug_detection(self):
from calibre.devices import debug
raw = debug(plugins=self.devices,
disabled_plugins=self.disabled_device_plugins)
return raw
def debug_detection(self, done):
if self.is_device_connected:
raise ValueError('Device is currently detected in calibre, cannot'
' debug device detection')
self.create_job(self._debug_detection, done,
_('Debug device detection'))
def _get_device_information(self):
info = self.device.get_device_information(end_session=False)
if len(info) < 5:
info = tuple(list(info) + [{}])
info = [i.replace('\x00', '').replace('\x01', '') if isinstance(i, string_or_unicode) else i
for i in info]
cp = self.device.card_prefix(end_session=False)
fs = self.device.free_space()
self._device_information = {'info': info, 'prefixes': cp, 'freespace': fs}
return info, cp, fs
def get_device_information(self, done, add_as_step_to_job=None):
'''Get device information and free space on device'''
return self.create_job_step(self._get_device_information, done,
description=_('Get device information'), to_job=add_as_step_to_job)
def _set_library_information(self, library_name, library_uuid, field_metadata):
'''Give the device the current library information'''
self.device.set_library_info(library_name, library_uuid, field_metadata)
def set_library_information(self, done, library_name, library_uuid,
field_metadata, add_as_step_to_job=None):
'''Give the device the current library information'''
return self.create_job_step(self._set_library_information, done,
args=[library_name, library_uuid, field_metadata],
description=_('Set library information'), to_job=add_as_step_to_job)
def slow_driveinfo(self):
''' Update the stored device information with the driveinfo if the
device indicates that getting driveinfo is slow '''
info = self._device_information['info']
if (not info[4] and self.device.SLOW_DRIVEINFO):
info = list(info)
info[4] = self.device.get_driveinfo()
self._device_information['info'] = tuple(info)
def get_current_device_information(self):
return self._device_information if self.is_device_present else None
def _books(self):
'''Get metadata from device'''
mainlist = self.device.books(oncard=None, end_session=False)
cardalist = self.device.books(oncard='carda')
cardblist = self.device.books(oncard='cardb')
return (mainlist, cardalist, cardblist)
def books(self, done, add_as_step_to_job=None):
'''Return callable that returns the list of books on device as two booklists'''
return self.create_job_step(self._books, done,
description=_('Get list of books on device'), to_job=add_as_step_to_job)
def _prepare_addable_books(self, paths):
return self.device.prepare_addable_books(paths)
def prepare_addable_books(self, done, paths, add_as_step_to_job=None):
return self.create_job_step(self._prepare_addable_books, done, args=[paths],
description=_('Prepare files for transfer from device'),
to_job=add_as_step_to_job)
def _annotations(self, path_map):
return self.device.get_annotations(path_map)
def annotations(self, done, path_map, add_as_step_to_job=None):
'''Return mapping of ids to annotations. Each annotation is of the
form (type, location_info, content). path_map is a mapping of
ids to paths on the device.'''
return self.create_job_step(self._annotations, done, args=[path_map],
description=_('Get annotations from device'), to_job=add_as_step_to_job)
def _sync_booklists(self, booklists):
'''Sync metadata to device'''
self.device.sync_booklists(booklists, end_session=False)
return self.device.card_prefix(end_session=False), self.device.free_space()
def sync_booklists(self, done, booklists, plugboards, add_as_step_to_job=None):
if hasattr(self.connected_device, 'set_plugboards') and \
callable(self.connected_device.set_plugboards):
self.connected_device.set_plugboards(plugboards, find_plugboard)
return self.create_job_step(self._sync_booklists, done, args=[booklists],
description=_('Send metadata to device'), to_job=add_as_step_to_job)
def upload_collections(self, done, booklist, on_card, add_as_step_to_job=None):
return self.create_job_step(booklist.rebuild_collections, done,
args=[booklist, on_card],
description=_('Send collections to device'),
to_job=add_as_step_to_job)
def _upload_books(self, files, names, on_card=None, metadata=None, plugboards=None):
'''Upload books to device: '''
from calibre.ebooks.metadata.meta import set_metadata
if hasattr(self.connected_device, 'set_plugboards') and \
callable(self.connected_device.set_plugboards):
self.connected_device.set_plugboards(plugboards, find_plugboard)
if metadata and files and len(metadata) == len(files):
for f, mi in zip(files, metadata):
if isinstance(f, str):
ext = f.rpartition('.')[-1].lower()
cpb = find_plugboard(
device_name_for_plugboards(self.connected_device),
ext, plugboards)
if ext:
try:
if DEBUG:
prints('Setting metadata in:', mi.title, 'at:',
f, file=sys.__stdout__)
with open(f, 'r+b') as stream:
if cpb:
newmi = mi.deepcopy_metadata()
newmi.template_to_attribute(mi, cpb)
else:
newmi = mi
nuke_comments = getattr(self.connected_device,
'NUKE_COMMENTS', None)
if nuke_comments is not None:
mi.comments = nuke_comments
set_metadata(stream, newmi, stream_type=ext)
except:
if DEBUG:
prints(traceback.format_exc(), file=sys.__stdout__)
try:
return self.device.upload_books(files, names, on_card,
metadata=metadata, end_session=False)
finally:
if metadata:
for mi in metadata:
try:
if mi.cover:
os.remove(mi.cover)
except:
pass
def upload_books(self, done, files, names, on_card=None, titles=None,
metadata=None, plugboards=None, add_as_step_to_job=None):
desc = ngettext('Upload one book to the device', 'Upload {} books to the device', len(names)).format(len(names))
if titles:
desc += ': ' + ', '.join(titles)
return self.create_job_step(self._upload_books, done, to_job=add_as_step_to_job,
args=[files, names],
kwargs={'on_card':on_card,'metadata':metadata,'plugboards':plugboards}, description=desc)
def add_books_to_metadata(self, locations, metadata, booklists):
self.device.add_books_to_metadata(locations, metadata, booklists)
def _delete_books(self, paths):
'''Remove books from device'''
self.device.delete_books(paths, end_session=True)
def delete_books(self, done, paths, add_as_step_to_job=None):
return self.create_job_step(self._delete_books, done, args=[paths],
description=_('Delete books from device'),
to_job=add_as_step_to_job)
def remove_books_from_metadata(self, paths, booklists):
self.device.remove_books_from_metadata(paths, booklists)
def _save_books(self, paths, target):
'''Copy books from device to disk'''
for path in paths:
name = sanitize_file_name(os.path.basename(path))
dest = os.path.join(target, name)
if os.path.abspath(dest) != os.path.abspath(path):
with open(dest, 'wb') as f:
self.device.get_file(path, f)
def save_books(self, done, paths, target, add_as_step_to_job=None):
return self.create_job_step(self._save_books, done, args=[paths, target],
description=_('Download books from device'),
to_job=add_as_step_to_job)
def _view_book(self, path, target):
with open(target, 'wb') as f:
self.device.get_file(path, f)
return target
def view_book(self, done, path, target, add_as_step_to_job=None):
return self.create_job_step(self._view_book, done, args=[path, target],
description=_('View book on device'), to_job=add_as_step_to_job)
def set_current_library_uuid(self, uuid):
self.current_library_uuid = uuid
def set_driveinfo_name(self, location_code, name):
if self.connected_device:
self.connected_device.set_driveinfo_name(location_code, name)
# dynamic plugin interface
# This is a helper function that handles queueing with the device manager
def _call_request(self, name, method, *args, **kwargs):
d = self.dynamic_plugins.get(name, None)
if d:
return getattr(d, method)(*args, **kwargs)
return kwargs.get('default', None)
# The dynamic plugin methods below must be called on the GUI thread. They
# will switch to the device thread before calling the plugin.
def start_plugin(self, name):
return self._call_request(name, 'start_plugin')
def stop_plugin(self, name):
self._call_request(name, 'stop_plugin')
def get_option(self, name, opt_string, default=None):
return self._call_request(name, 'get_option', opt_string, default=default)
def set_option(self, name, opt_string, opt_value):
self._call_request(name, 'set_option', opt_string, opt_value)
def is_running(self, name):
if self._call_request(name, 'is_running'):
return True
return False
def is_enabled(self, name):
try:
d = self.dynamic_plugins.get(name, None)
if d:
return True
except:
pass
return False
# }}}
class DeviceAction(QAction): # {{{
a_s = pyqtSignal(object)
def __init__(self, dest, delete, specific, icon_path, text, parent=None):
QAction.__init__(self, QIcon.ic(icon_path), text, parent)
self.dest = dest
self.delete = delete
self.specific = specific
self.triggered.connect(self.emit_triggered)
def emit_triggered(self, *args):
self.a_s.emit(self)
def __repr__(self):
return self.__class__.__name__ + ':%s:%s:%s'%(self.dest, self.delete,
self.specific)
# }}}
class DeviceMenu(QMenu): # {{{
fetch_annotations = pyqtSignal()
disconnect_mounted_device = pyqtSignal()
sync = pyqtSignal(object, object, object)
def __init__(self, parent=None):
QMenu.__init__(self, parent)
self.group = QActionGroup(self)
self._actions = []
self._memory = []
self.set_default_menu = QMenu(_('Set default send to device action'))
self.set_default_menu.setIcon(QIcon.ic('config.png'))
basic_actions = [
('main:', False, False, 'reader.png',
_('Send to main memory')),
('carda:0', False, False, 'sd.png',
_('Send to storage card A')),
('cardb:0', False, False, 'sd.png',
_('Send to storage card B')),
]
delete_actions = [
('main:', True, False, 'reader.png',
_('Main memory')),
('carda:0', True, False, 'sd.png',
_('Storage card A')),
('cardb:0', True, False, 'sd.png',
_('Storage card B')),
]
specific_actions = [
('main:', False, True, 'reader.png',
_('Main memory')),
('carda:0', False, True, 'sd.png',
_('Storage card A')),
('cardb:0', False, True, 'sd.png',
_('Storage card B')),
]
later_menus = []
for menu in (self, self.set_default_menu):
for actions, desc in (
(basic_actions, ''),
(specific_actions, _('Send specific format to')),
(delete_actions, _('Send and delete from library')),
):
mdest = menu
if actions is not basic_actions:
mdest = QMenu(desc)
self._memory.append(mdest)
later_menus.append(mdest)
if menu is self.set_default_menu:
menu.addMenu(mdest)
menu.addSeparator()
for dest, delete, specific, icon, text in actions:
action = DeviceAction(dest, delete, specific, icon, text, self)
self._memory.append(action)
if menu is self.set_default_menu:
action.setCheckable(True)
action.setText(action.text())
self.group.addAction(action)
else:
action.a_s.connect(self.action_triggered)
self._actions.append(action)
mdest.addAction(action)
if actions is basic_actions:
menu.addSeparator()
da = config['default_send_to_device_action']
done = False
for action in self.group.actions():
if repr(action) == da:
action.setChecked(True)
done = True
break
if not done:
action = list(self.group.actions())[0]
action.setChecked(True)
config['default_send_to_device_action'] = repr(action)
self.group.triggered.connect(self.change_default_action)
self.addSeparator()
self.addMenu(later_menus[0])
self.addSeparator()
mitem = self.addAction(QIcon.ic('eject.png'), _('Eject device'))
mitem.setEnabled(False)
connect_lambda(mitem.triggered, self, lambda self, x: self.disconnect_mounted_device.emit())
self.disconnect_mounted_device_action = mitem
self.addSeparator()
self.addMenu(self.set_default_menu)
self.addSeparator()
self.addMenu(later_menus[1])
self.addSeparator()
annot = self.addAction(_('Fetch annotations (experimental)'))
annot.setEnabled(False)
connect_lambda(annot.triggered, self, lambda self, x: self.fetch_annotations.emit())
self.annotation_action = annot
self.enable_device_actions(False)
def change_default_action(self, action):
config['default_send_to_device_action'] = repr(action)
action.setChecked(True)
def action_triggered(self, action):
self.sync.emit(action.dest, action.delete, action.specific)
def trigger_default(self, *args):
r = config['default_send_to_device_action']
for action in self._actions:
if repr(action) == r:
self.action_triggered(action)
break
def enable_device_actions(self, enable, card_prefix=(None, None),
device=None):
for action in self._actions:
if action.dest in ('main:', 'carda:0', 'cardb:0'):
if not enable:
action.setEnabled(False)
else:
if action.dest == 'main:':
action.setEnabled(True)
elif action.dest == 'carda:0':
if card_prefix and card_prefix[0] is not None:
action.setEnabled(True)
else:
action.setEnabled(False)
elif action.dest == 'cardb:0':
if card_prefix and card_prefix[1] is not None:
action.setEnabled(True)
else:
action.setEnabled(False)
annot_enable = enable and getattr(device, 'SUPPORTS_ANNOTATIONS', False)
self.annotation_action.setEnabled(annot_enable)
# }}}
class DeviceSignals(QObject): # {{{
#: This signal is emitted once, after metadata is downloaded from the
#: connected device.
#: The sequence: gui.device_manager.is_device_connected will become True,
#: and the device_connection_changed signal will be emitted,
#: then sometime later gui.device_metadata_available will be signaled.
#: This does not mean that there are no more jobs running. Automatic metadata
#: management might have kicked off a sync_booklists to write new metadata onto
#: the device, and that job might still be running when the signal is emitted.
device_metadata_available = pyqtSignal()
#: This signal is emitted once when the device is detected and once when
#: it is disconnected. If the parameter is True, then it is a connection,
#: otherwise a disconnection. Device information is not available in either
# case. If you need device information when connecting then use the
# device_metadata_available signal.
device_connection_changed = pyqtSignal(object)
device_signals = DeviceSignals()
# }}}
class DeviceMixin: # {{{
def __init__(self, *args, **kwargs):
pass
def init_device_mixin(self):
self.device_error_dialog = error_dialog(self, _('Error'),
_('Error communicating with device'), ' ')
self.device_error_dialog.setModal(False)
self.device_manager = DeviceManager(FunctionDispatcher(self.device_detected),
self.job_manager, Dispatcher(self.status_bar.show_message),
Dispatcher(self.show_open_feedback),
FunctionDispatcher(self.allow_connect), Dispatcher(self.after_callback_feedback))
self.device_manager.start()
self.device_manager.devices_initialized.wait()
if tweaks['auto_connect_to_folder']:
self.connect_to_folder_named(tweaks['auto_connect_to_folder'])
def allow_connect(self, name, icon):
return question_dialog(self, _('Manage the %s?')%name,
_('Detected the <b>%s</b>. Do you want calibre to manage it?')%
name, show_copy_button=False,
override_icon=QIcon.ic(icon))
def after_callback_feedback(self, feedback):
title, msg, det_msg = feedback
info_dialog(self, feedback['title'], feedback['msg'], det_msg=feedback['det_msg']).show()
def debug_detection(self, done):
self.debug_detection_callback = weakref.ref(done)
self.device_manager.debug_detection(FunctionDispatcher(self.debug_detection_done))
def debug_detection_done(self, job):
d = self.debug_detection_callback()
if d is not None:
d(job)
def show_open_feedback(self, devname, e):
try:
self.__of_dev_mem__ = d = e.custom_dialog(self)
except NotImplementedError:
self.__of_dev_mem__ = d = info_dialog(self, devname, e.feedback_msg)
d.show()
def auto_convert_question(self, msg, autos):
autos = '\n'.join(map(str, map(force_unicode, autos)))
return self.ask_a_yes_no_question(
_('No suitable formats'), msg,
ans_when_user_unavailable=True,
det_msg=autos, skip_dialog_name='auto_convert_before_send'
)
def set_default_thumbnail(self, height):
ratio = height / float(cprefs['cover_height'])
self.default_thumbnail_prefs = prefs = override_prefs(cprefs)
scale_cover(prefs, ratio)
def connect_to_folder_named(self, folder):
if os.path.exists(folder) and os.path.isdir(folder):
self.device_manager.mount_device(kls=FOLDER_DEVICE, kind='folder',
path=folder)
def connect_to_folder(self):
dir = choose_dir(self, 'Select Device Folder',
_('Select folder to open as device'))
if dir is not None:
self.device_manager.mount_device(kls=FOLDER_DEVICE, kind='folder', path=dir)
# disconnect from folder devices
def disconnect_mounted_device(self):
self.device_manager.umount_device()
def configure_connected_device(self):
if not self.device_manager.is_device_connected:
return
if self.job_manager.has_device_jobs(queued_also=True):
return error_dialog(self, _('Running jobs'),
_('Cannot configure the device while there are running'
' device jobs.'), show=True)
dev = self.device_manager.connected_device
cw = dev.config_widget()
config_dialog = QDialog(self)
config_dialog.setWindowTitle(_('Configure %s')%dev.get_gui_name())
config_dialog.setWindowIcon(QIcon.ic('config.png'))
l = QVBoxLayout(config_dialog)
config_dialog.setLayout(l)
bb = QDialogButtonBox(QDialogButtonBox.StandardButton.Ok|QDialogButtonBox.StandardButton.Cancel)
bb.accepted.connect(config_dialog.accept)
bb.rejected.connect(config_dialog.reject)
l.addWidget(cw)
l.addWidget(bb)
# We do not save/restore the size of this dialog as different devices
# have very different size requirements
config_dialog.resize(config_dialog.sizeHint())
def validate():
if cw.validate():
QDialog.accept(config_dialog)
config_dialog.accept = validate
if config_dialog.exec() == QDialog.DialogCode.Accepted:
dev.save_settings(cw)
do_restart = show_restart_warning(_('Restart calibre for the changes to %s'
' to be applied.')%dev.get_gui_name(), parent=self)
if do_restart:
self.quit(restart=True)
def _sync_action_triggered(self, *args):
m = getattr(self, '_sync_menu', None)
if m is not None:
ids = self.library_view.get_selected_ids(as_set=True)
db = self.current_db.new_api
already_on_device = db.all_field_for('ondevice', ids, default_value='')
books_on_device = {book_id for book_id, val in already_on_device.items() if val}
if books_on_device:
if len(books_on_device) == 1:
if not question_dialog(self, _('Book already on device'), _(
'The book {} is already present on the device. Resending it might cause any'
' annotations/bookmarks on the device for this book to be lost. Are you sure?').format(
db.field_for('title', tuple(books_on_device)[0])), skip_dialog_name='confirm-resend-existing-books'
):
return
else:
title_sorts = db.all_field_for('sort', books_on_device)
titles = sorted(db.all_field_for('title', books_on_device).items(), key=lambda x: title_sorts[x[0]])
details = '\n'.join(title for book_id, title in titles)
if not question_dialog(self, _('Some books already on device'), _(
'Some of the selected books are already on the device. Resending them might cause any annotations/bookmarks on the'
' device for these books to be lost. Click "Show details" to see the books already on the device. Are you sure?'),
skip_dialog_name='confirm-resend-existing-books', det_msg=details
):
return
m.trigger_default()
def create_device_menu(self):
self._sync_menu = DeviceMenu(self)
self.iactions['Send To Device'].qaction.setMenu(self._sync_menu)
self.iactions['Connect Share'].build_email_entries()
self._sync_menu.sync.connect(self.dispatch_sync_event)
self._sync_menu.fetch_annotations.connect(
self.iactions['Fetch Annotations'].fetch_annotations)
self._sync_menu.disconnect_mounted_device.connect(self.disconnect_mounted_device)
self.iactions['Connect Share'].set_state(self.device_connected,
None)
if self.device_connected:
self._sync_menu.disconnect_mounted_device_action.setEnabled(True)
else:
self._sync_menu.disconnect_mounted_device_action.setEnabled(False)
def device_job_exception(self, job):
'''
Handle exceptions in threaded device jobs.
'''
if isinstance(getattr(job, 'exception', None), UserFeedback):
ex = job.exception
func = {UserFeedback.ERROR:error_dialog,
UserFeedback.WARNING:warning_dialog,
UserFeedback.INFO:info_dialog}[ex.level]
return func(self, _('Failed'), ex.msg, det_msg=ex.details if
ex.details else '', show=True)
try:
if 'Could not read 32 bytes on the control bus.' in \
str(job.details):
error_dialog(self, _('Error talking to device'),
_('There was a temporary error talking to the '
'device. Please unplug and reconnect the device '
'or reboot.')).show()
return
except:
pass
if getattr(job, 'exception', None).__class__.__name__ == 'MTPInvalidSendPathError':
try:
from calibre.gui2.device_drivers.mtp_config import SendError
return SendError(self, job.exception).exec()
except:
traceback.print_exc()
try:
prints(job.details, file=sys.stderr)
except:
pass
if not self.device_error_dialog.isVisible():
self.device_error_dialog.set_details(job.details)
self.device_error_dialog.show()
# Device connected {{{
def set_device_menu_items_state(self, connected):
self.iactions['Connect Share'].set_state(connected,
self.device_manager.device)
if connected:
self._sync_menu.disconnect_mounted_device_action.setEnabled(True)
self._sync_menu.enable_device_actions(True,
self.device_manager.device.card_prefix(),
self.device_manager.device)
self.eject_action.setEnabled(True)
else:
self._sync_menu.disconnect_mounted_device_action.setEnabled(False)
self._sync_menu.enable_device_actions(False)
self.eject_action.setEnabled(False)
def device_detected(self, connected, device_kind):
'''
Called when a device is connected to the computer.
If connected is False then device_kind is None.
'''
# This can happen as this function is called in a queued connection and
# the user could have yanked the device in the meantime
if connected and not self.device_manager.is_device_connected:
connected = False
self.set_device_menu_items_state(connected)
if connected:
self.device_connected = device_kind
self.device_manager.get_device_information(
FunctionDispatcher(self.info_read))
self.set_default_thumbnail(
self.device_manager.device.THUMBNAIL_HEIGHT)
self.status_bar.show_message(_('Device: ')+
self.device_manager.device.get_gui_name()+
_(' detected.'), 3000)
self.library_view.set_device_connected(self.device_connected)
self.refresh_ondevice(reset_only=True)
else:
self.device_connected = None
self.status_bar.device_disconnected()
dviews = (self.memory_view, self.card_a_view, self.card_b_view)
for v in dviews:
v.save_state()
if self.current_view() != self.library_view:
self.book_details.reset_info()
self.location_manager.update_devices()
self.bars_manager.update_bars(reveal_bar=True)
self.library_view.set_device_connected(self.device_connected)
# Empty any device view information
for v in dviews:
v.set_database([])
# Use a singleShot timer to ensure that the job event queue has
# emptied before the ondevice column is removed from the booklist.
# This deals with race conditions when repainting the booklist
# causing incorrect evaluation of the connected_device_name
# formatter function
QTimer.singleShot(0, self.refresh_ondevice)
device_signals.device_connection_changed.emit(connected)
def info_read(self, job):
'''
Called once device information has been read.
'''
if job.failed:
return self.device_job_exception(job)
info, cp, fs = job.result
self.location_manager.update_devices(cp, fs,
self.device_manager.device.icon)
self.bars_manager.update_bars(reveal_bar=True)
self.status_bar.device_connected(info[0])
db = self.current_db
self.device_manager.set_library_information(None, os.path.basename(db.library_path),
db.library_id, db.field_metadata,
add_as_step_to_job=job)
self.device_manager.books(FunctionDispatcher(self.metadata_downloaded),
add_as_step_to_job=job)
def metadata_downloaded(self, job):
'''
Called once metadata has been read for all books on the device.
'''
if job.failed:
self.device_job_exception(job)
return
self.device_manager.slow_driveinfo()
# set_books_in_library might schedule a sync_booklists job
debug_print('DeviceJob: metadata_downloaded: Starting set_books_in_library')
self.set_books_in_library(job.result, reset=True, add_as_step_to_job=job)
debug_print('DeviceJob: metadata_downloaded: updating views')
mainlist, cardalist, cardblist = job.result
self.memory_view.set_database(mainlist)
self.memory_view.set_editable(self.device_manager.device.CAN_SET_METADATA,
self.device_manager.device.BACKLOADING_ERROR_MESSAGE
is None)
self.card_a_view.set_database(cardalist)
self.card_a_view.set_editable(self.device_manager.device.CAN_SET_METADATA,
self.device_manager.device.BACKLOADING_ERROR_MESSAGE
is None)
self.card_b_view.set_database(cardblist)
self.card_b_view.set_editable(self.device_manager.device.CAN_SET_METADATA,
self.device_manager.device.BACKLOADING_ERROR_MESSAGE
is None)
debug_print('DeviceJob: metadata_downloaded: syncing')
self.sync_news()
self.sync_catalogs()
debug_print('DeviceJob: metadata_downloaded: refreshing ondevice')
self.refresh_ondevice()
debug_print('DeviceJob: metadata_downloaded: sending metadata_available signal')
device_signals.device_metadata_available.emit()
def refresh_ondevice(self, reset_only=False):
'''
Force the library view to refresh, taking into consideration new
device books information
'''
with self.library_view.preserve_state():
self.book_on_device(None, reset=True)
if reset_only:
return
self.library_view.model().refresh_ondevice()
# }}}
def remove_paths(self, paths):
return self.device_manager.delete_books(
FunctionDispatcher(self.books_deleted), paths)
def books_deleted(self, job):
'''
Called once deletion is done on the device
'''
cv, row = self.current_view(), -1
if cv is not self.library_view:
row = cv.currentIndex().row()
for view in (self.memory_view, self.card_a_view, self.card_b_view):
view.model().deletion_done(job, job.failed)
if job.failed:
self.device_job_exception(job)
return
dm = self.iactions['Remove Books'].delete_memory
if job in dm:
paths, model = dm.pop(job)
self.device_manager.remove_books_from_metadata(paths,
self.booklists())
model.paths_deleted(paths)
# Force recomputation the library's ondevice info. We need to call
# set_books_in_library even though books were not added because
# the deleted book might have been an exact match. Upload the booklists
# if set_books_in_library did not.
if not self.set_books_in_library(self.booklists(), reset=True,
add_as_step_to_job=job, do_device_sync=False):
self.upload_booklists(job)
# We need to reset the ondevice flags in the library. Use a big hammer,
# so we don't need to worry about whether some succeeded or not.
self.refresh_ondevice()
if row > -1:
cv.set_current_row(row)
try:
if not self.current_view().currentIndex().isValid():
self.current_view().set_current_row()
self.current_view().refresh_book_details()
except:
traceback.print_exc()
def dispatch_sync_event(self, dest, delete, specific):
rows = self.library_view.selectionModel().selectedRows()
if not rows or len(rows) == 0:
error_dialog(self, _('No books'), _('No books')+' '+
_('selected to send')).exec()
return
fmt = None
if specific:
if (not self.device_connected or not self.device_manager or
self.device_manager.device is None):
error_dialog(self, _('No device'),
_('No device connected'), show=True)
return
formats = []
aval_out_formats = available_output_formats()
format_count = {}
for row in rows:
fmts = self.library_view.model().db.formats(row.row())
if fmts:
for f in fmts.split(','):
f = f.lower()
if f in format_count:
format_count[f] += 1
else:
format_count[f] = 1
for f in self.device_manager.device.settings().format_map:
if f in format_count.keys():
formats.append((f, _('%(num)i of %(total)i books') % dict(
num=format_count[f], total=len(rows)),
True if f in aval_out_formats else False))
elif f in aval_out_formats:
formats.append((f, _('0 of %i books') % len(rows), True))
d = ChooseFormatDeviceDialog(self, _('Choose format to send to device'), formats)
if d.exec() != QDialog.DialogCode.Accepted:
return
if d.format():
fmt = d.format().lower()
dest, sub_dest = dest.partition(':')[0::2]
if dest in ('main', 'carda', 'cardb'):
if not self.device_connected or not self.device_manager:
error_dialog(self, _('No device'),
_('Cannot send: No device is connected')).exec()
return
if dest == 'carda' and not self.device_manager.has_card():
error_dialog(self, _('No card'),
_('Cannot send: Device has no storage card')).exec()
return
if dest == 'cardb' and not self.device_manager.has_card():
error_dialog(self, _('No card'),
_('Cannot send: Device has no storage card')).exec()
return
if dest == 'main':
on_card = None
else:
on_card = dest
self.sync_to_device(on_card, delete, fmt)
elif dest == 'mail':
sub_dest_parts = sub_dest.split(';')
while len(sub_dest_parts) < 3:
sub_dest_parts.append('')
to = sub_dest_parts[0]
fmts = sub_dest_parts[1]
subject = ';'.join(sub_dest_parts[2:])
fmts = [x.strip().lower() for x in fmts.split(',')]
self.send_by_mail(to, fmts, delete, subject=subject)
elif dest == 'choosemail':
from calibre.gui2.email import select_recipients
data = select_recipients(self)
if data:
self.send_multiple_by_mail(data, delete)
def cover_to_thumbnail(self, data):
if self.device_manager.device and \
hasattr(self.device_manager.device, 'THUMBNAIL_WIDTH'):
try:
return scale_image(data,
self.device_manager.device.THUMBNAIL_WIDTH,
self.device_manager.device.THUMBNAIL_HEIGHT,
preserve_aspect_ratio=False)
except:
pass
return
ht = self.device_manager.device.THUMBNAIL_HEIGHT \
if self.device_manager else DevicePlugin.THUMBNAIL_HEIGHT
try:
return scale_image(data, ht, ht,
compression_quality=self.device_manager.device.THUMBNAIL_COMPRESSION_QUALITY)
except:
pass
def sync_catalogs(self, send_ids=None, do_auto_convert=True):
if self.device_connected:
settings = self.device_manager.device.settings()
ids = list(dynamic.get('catalogs_to_be_synced', set())) if send_ids is None else send_ids
ids = [id for id in ids if self.library_view.model().db.has_id(id)]
with BusyCursor():
files, _auto_ids = self.library_view.model().get_preferred_formats_from_ids(
ids, settings.format_map,
exclude_auto=do_auto_convert)
auto = []
if do_auto_convert and _auto_ids:
for id in _auto_ids:
dbfmts = self.library_view.model().db.formats(id, index_is_id=True)
formats = [] if dbfmts is None else \
[f.lower() for f in dbfmts.split(',')]
if set(formats).intersection(available_input_formats()) \
and set(settings.format_map).intersection(available_output_formats()):
auto.append(id)
if auto:
format = None
for fmt in settings.format_map:
if fmt in list(set(settings.format_map).intersection(set(available_output_formats()))):
format = fmt
break
if format is not None:
autos = [self.library_view.model().db.title(id, index_is_id=True) for id in auto]
if self.auto_convert_question(
_('Auto convert the following books before uploading to '
'the device?'), autos):
self.iactions['Convert Books'].auto_convert_catalogs(auto, format)
files = [f for f in files if f is not None]
if not files:
dynamic.set('catalogs_to_be_synced', set())
return
metadata = self.library_view.model().metadata_for(ids)
names = []
for book_id, mi in zip(ids, metadata):
prefix = ascii_filename(mi.title)
if not isinstance(prefix, str):
prefix = prefix.decode(preferred_encoding, 'replace')
prefix = ascii_filename(prefix)
names.append('%s_%d%s'%(prefix, book_id,
os.path.splitext(files[-1])[1]))
self.update_thumbnail(mi)
dynamic.set('catalogs_to_be_synced', set())
if files:
remove = []
space = {self.location_manager.free[0] : None,
self.location_manager.free[1] : 'carda',
self.location_manager.free[2] : 'cardb'}
on_card = space.get(sorted(space.keys(), reverse=True)[0], None)
self.upload_books(files, names, metadata,
on_card=on_card,
memory=[files, remove])
self.status_bar.show_message(_('Sending catalogs to device.'), 5000)
@property
def news_to_be_synced(self):
'Set of ids to be sent to device'
ans = []
try:
ans = self.library_view.model().db.new_api.pref('news_to_be_synced',
[])
except:
import traceback
traceback.print_exc()
return set(ans)
@news_to_be_synced.setter
def news_to_be_synced(self, ids):
try:
self.library_view.model().db.new_api.set_pref('news_to_be_synced',
list(ids))
except:
import traceback
traceback.print_exc()
def sync_news(self, send_ids=None, do_auto_convert=True):
if self.device_connected:
del_on_upload = config['delete_news_from_library_on_upload']
settings = self.device_manager.device.settings()
ids = list(self.news_to_be_synced) if send_ids is None else send_ids
ids = [book_id for book_id in ids if self.library_view.model().db.has_id(book_id)]
with BusyCursor():
files, _auto_ids = self.library_view.model().get_preferred_formats_from_ids(
ids, settings.format_map,
exclude_auto=do_auto_convert)
auto = []
if do_auto_convert and _auto_ids:
for book_id in _auto_ids:
dbfmts = self.library_view.model().db.formats(book_id, index_is_id=True)
formats = [] if dbfmts is None else \
[f.lower() for f in dbfmts.split(',')]
if set(formats).intersection(available_input_formats()) \
and set(settings.format_map).intersection(available_output_formats()):
auto.append(book_id)
if auto:
format = None
for fmt in settings.format_map:
if fmt in list(set(settings.format_map).intersection(set(available_output_formats()))):
format = fmt
break
if format is not None:
autos = [self.library_view.model().db.title(book_id, index_is_id=True) for book_id in auto]
if self.auto_convert_question(
_('Auto convert the following books before uploading to '
'the device?'), autos):
self.iactions['Convert Books'].auto_convert_news(auto, format)
files = [f for f in files if f is not None]
if not files:
self.news_to_be_synced = set()
return
metadata = self.library_view.model().metadata_for(ids)
names = []
for book_id, mi in zip(ids, metadata):
prefix = ascii_filename(mi.title)
if not isinstance(prefix, str):
prefix = prefix.decode(preferred_encoding, 'replace')
prefix = ascii_filename(prefix)
names.append('%s_%d%s'%(prefix, book_id,
os.path.splitext(files[-1])[1]))
self.update_thumbnail(mi)
self.news_to_be_synced = set()
if config['upload_news_to_device'] and files:
remove = ids if del_on_upload else []
space = {self.location_manager.free[0] : None,
self.location_manager.free[1] : 'carda',
self.location_manager.free[2] : 'cardb'}
on_card = space.get(sorted(space.keys(), reverse=True)[0], None)
try:
total_size = sum(os.stat(f).st_size for f in files)
except:
try:
import traceback
traceback.print_exc()
except:
pass
total_size = self.location_manager.free[0]
loc = tweaks['send_news_to_device_location']
loc_index = {"carda": 1, "cardb": 2}.get(loc, 0)
if self.location_manager.free[loc_index] > total_size + (1024**2):
# Send news to main memory if enough space available
# as some devices like the Nook Color cannot handle
# periodicals on SD cards properly
on_card = loc if loc in ('carda', 'cardb') else None
self.upload_books(files, names, metadata,
on_card=on_card,
memory=[files, remove])
self.status_bar.show_message(_('Sending news to device.'), 5000)
def sync_to_device(self, on_card, delete_from_library,
specific_format=None, send_ids=None, do_auto_convert=True):
ids = [self.library_view.model().id(r)
for r in self.library_view.selectionModel().selectedRows()] \
if send_ids is None else send_ids
if not self.device_manager or not ids or len(ids) == 0 or \
not self.device_manager.is_device_connected:
return
settings = self.device_manager.device.settings()
with BusyCursor():
_files, _auto_ids = self.library_view.model().get_preferred_formats_from_ids(ids,
settings.format_map,
specific_format=specific_format,
exclude_auto=do_auto_convert)
if do_auto_convert:
ok_ids = list(set(ids).difference(_auto_ids))
ids = [i for i in ids if i in ok_ids]
else:
_auto_ids = []
metadata = self.library_view.model().metadata_for(ids)
ids = iter(ids)
for mi in metadata:
self.update_thumbnail(mi)
imetadata = iter(metadata)
bad, good, gf, names, remove_ids = [], [], [], [], []
for f in _files:
mi = next(imetadata)
id = next(ids)
if f is None:
bad.append(mi.title)
else:
remove_ids.append(id)
good.append(mi)
gf.append(f)
t = mi.title
if not t:
t = _('Unknown')
a = mi.format_authors()
if not a:
a = _('Unknown')
prefix = ascii_filename(t+' - '+a)
if not isinstance(prefix, str):
prefix = prefix.decode(preferred_encoding, 'replace')
prefix = ascii_filename(prefix)
names.append('%s_%d%s'%(prefix, id, os.path.splitext(f)[1]))
remove = remove_ids if delete_from_library else []
self.upload_books(gf, names, good, on_card, memory=(_files, remove))
self.status_bar.show_message(_('Sending books to device.'), 5000)
auto = []
if _auto_ids != []:
for id in _auto_ids:
if specific_format is None:
formats = self.library_view.model().db.formats(id, index_is_id=True)
formats = formats.split(',') if formats is not None else []
formats = [f.lower().strip() for f in formats]
if (list(set(formats).intersection(available_input_formats())) != [] and
list(set(settings.format_map).intersection(available_output_formats())) != []):
auto.append(id)
else:
bad.append(self.library_view.model().db.title(id, index_is_id=True))
else:
if specific_format in list(set(settings.format_map).intersection(set(available_output_formats()))):
auto.append(id)
else:
bad.append(self.library_view.model().db.title(id, index_is_id=True))
if auto != []:
format = specific_format if specific_format in \
list(set(settings.format_map).intersection(set(available_output_formats()))) \
else None
if not format:
for fmt in settings.format_map:
if fmt in list(set(settings.format_map).intersection(set(available_output_formats()))):
format = fmt
break
if not format:
bad += auto
else:
autos = [self.library_view.model().db.title(id, index_is_id=True) for id in auto]
if self.auto_convert_question(
_('Auto convert the following books before uploading to '
'the device?'), autos):
self.iactions['Convert Books'].auto_convert(auto, on_card, format)
if bad:
bad = '\n'.join('%s'%(i,) for i in bad)
d = warning_dialog(self, _('No suitable formats'),
_('Could not upload the following books to the device, '
'as no suitable formats were found. Convert the book(s) to a '
'format supported by your device first.'
), bad)
d.exec()
def upload_dirtied_booklists(self):
'''
Upload metadata to device.
'''
plugboards = self.library_view.model().db.new_api.pref('plugboards', {})
self.device_manager.sync_booklists(Dispatcher(lambda x: x),
self.booklists(), plugboards)
def upload_booklists(self, add_as_step_to_job=None):
'''
Upload metadata to device.
'''
plugboards = self.library_view.model().db.new_api.pref('plugboards', {})
self.device_manager.sync_booklists(FunctionDispatcher(self.metadata_synced),
self.booklists(), plugboards,
add_as_step_to_job=add_as_step_to_job)
def metadata_synced(self, job):
'''
Called once metadata has been uploaded.
'''
if job.failed:
self.device_job_exception(job)
return
cp, fs = job.result
self.location_manager.update_devices(cp, fs,
self.device_manager.device.icon)
# reset the views so that up-to-date info is shown. These need to be
# here because some drivers update collections in sync_booklists
cv, row = self.current_view(), -1
if cv is not self.library_view:
row = cv.currentIndex().row()
self.memory_view.reset()
self.card_a_view.reset()
self.card_b_view.reset()
if row > -1:
cv.set_current_row(row)
def _upload_collections(self, job):
if job.failed:
self.device_job_exception(job)
def upload_collections(self, booklist, view=None, oncard=None):
return self.device_manager.upload_collections(self._upload_collections,
booklist, oncard)
def upload_books(self, files, names, metadata, on_card=None, memory=None):
'''
Upload books to device.
:param files: List of either paths to files or file like objects
'''
titles = [i.title for i in metadata]
plugboards = self.library_view.model().db.new_api.pref('plugboards', {})
job = self.device_manager.upload_books(
FunctionDispatcher(self.books_uploaded),
files, names, on_card=on_card,
metadata=metadata, titles=titles, plugboards=plugboards
)
self.upload_memory[job] = (metadata, on_card, memory, files)
def books_uploaded(self, job):
'''
Called once books have been uploaded.
'''
metadata, on_card, memory, files = self.upload_memory.pop(job)
if job.exception is not None:
if isinstance(job.exception, FreeSpaceError):
where = 'in main memory.' if 'memory' in str(job.exception) \
else 'on the storage card.'
titles = '\n'.join(['<li>'+mi.title+'</li>'
for mi in metadata])
d = error_dialog(self, _('No space on device'),
_('<p>Cannot upload books to device there '
'is no more free space available ')+where+
'</p>\n<ul>%s</ul>'%(titles,))
d.exec()
elif isinstance(job.exception, WrongDestinationError):
error_dialog(self, _('Incorrect destination'),
str(job.exception), show=True)
else:
self.device_job_exception(job)
return
try:
self.device_manager.add_books_to_metadata(job.result,
metadata, self.booklists())
except:
traceback.print_exc()
raise
books_to_be_deleted = []
if memory and memory[1]:
books_to_be_deleted = memory[1]
self.library_view.model().delete_books_by_id(books_to_be_deleted)
# There are some cases where sending a book to the device overwrites a
# book already there with a different book. This happens frequently in
# news. When this happens, the book match indication will be wrong
# because the UUID changed. Force both the device and the library view
# to refresh the flags. Set_books_in_library could upload the booklists.
# If it does not, then do it here.
if not self.set_books_in_library(self.booklists(), reset=True,
add_as_step_to_job=job, do_device_sync=False):
self.upload_booklists(job)
self.refresh_ondevice()
view = self.card_a_view if on_card == 'carda' else \
self.card_b_view if on_card == 'cardb' else self.memory_view
view.model().resort(reset=False)
view.model().research()
if files:
for f in files:
# Remove temporary files
try:
rem = not getattr(
self.device_manager.device,
'KEEP_TEMP_FILES_AFTER_UPLOAD', False)
if rem and 'caltmpfmt.' in f:
os.remove(f)
except:
pass
def update_metadata_on_device(self):
self.set_books_in_library(self.booklists(), reset=True, force_send=True)
self.refresh_ondevice()
def set_current_library_information(self, library_name, library_uuid, field_metadata):
self.device_manager.set_current_library_uuid(library_uuid)
if self.device_manager.is_device_connected:
self.device_manager.set_library_information(None, library_name,
library_uuid, field_metadata)
def book_on_device(self, id, reset=False):
'''
Return an indication of whether the given book represented by its db id
is on the currently connected device. It returns a 5 element list. The
first three elements represent memory locations main, carda, and cardb,
and are true if the book is identifiably in that memory. The fourth
is a count of how many instances of the book were found across all
the memory locations. The fifth is a set of paths to the
matching books on the device.
'''
loc = [None, None, None, 0, set()]
if reset:
self.book_db_id_cache = None
self.book_db_id_counts = None
self.book_db_uuid_path_map = None
return
if not self.device_manager.is_device_connected or \
not hasattr(self, 'db_book_uuid_cache'):
return loc
if self.book_db_id_cache is None:
self.book_db_id_cache = []
self.book_db_id_counts = {}
self.book_db_uuid_path_map = {}
for i, l in enumerate(self.booklists()):
self.book_db_id_cache.append(set())
for book in l:
db_id = getattr(book, 'application_id', None)
if db_id is not None:
# increment the count of books on the device with this
# db_id.
self.book_db_id_cache[i].add(db_id)
if db_id not in self.book_db_uuid_path_map:
self.book_db_uuid_path_map[db_id] = set()
if getattr(book, 'lpath', False):
self.book_db_uuid_path_map[db_id].add(book.lpath)
c = self.book_db_id_counts.get(db_id, 0)
self.book_db_id_counts[db_id] = c + 1
for i, l in enumerate(self.booklists()):
if id in self.book_db_id_cache[i]:
loc[i] = True
loc[3] = self.book_db_id_counts.get(id, 0)
loc[4] |= self.book_db_uuid_path_map[id]
return loc
def update_thumbnail(self, book):
if book.cover and os.access(book.cover, os.R_OK):
with open(book.cover, 'rb') as f:
book.thumbnail = self.cover_to_thumbnail(f.read())
else:
cprefs = self.default_thumbnail_prefs
book.thumbnail = (cprefs['cover_width'], cprefs['cover_height'], generate_cover(book, prefs=cprefs))
def set_books_in_library(self, booklists, reset=False, add_as_step_to_job=None,
force_send=False, do_device_sync=True):
'''
Set the ondevice indications in the device database.
This method should be called before book_on_device is called, because
it sets the application_id for matched books. Book_on_device uses that
to both speed up matching and to count matches.
'''
if not self.device_manager.is_device_connected:
return False
# It might be possible to get here without having initialized the
# library view. In this case, simply give up
try:
db = self.library_view.model().db
except:
return False
# Define the cleaning function
string_pat = re.compile(r'(?u)\W|[_]')
def clean_string(x):
try:
# Convert to lowercase if x is not None or empty
x = x.lower() if x else ''
except Exception:
x = ''
# Perform regex substitution
return string_pat.sub('', x)
update_metadata = (
device_prefs['manage_device_metadata'] == 'on_connect' or force_send)
get_covers = False
desired_thumbnail_height = 0
if update_metadata and self.device_manager.is_device_connected:
if self.device_manager.device.WANTS_UPDATED_THUMBNAILS:
get_covers = True
desired_thumbnail_height = self.device_manager.device.THUMBNAIL_HEIGHT
# Force a reset if the caches are not initialized
if reset or not hasattr(self, 'db_book_title_cache'):
# Build a cache (map) of the library, so the search isn't On**2
db_book_title_cache = {}
db_book_uuid_cache = {}
for id_ in db.data.iterallids():
title = clean_string(db.title(id_, index_is_id=True))
if title not in db_book_title_cache:
db_book_title_cache[title] = \
{'authors':{}, 'author_sort':{}, 'db_ids':{}}
# If there are multiple books in the library with the same title
# and author, then remember the last one. That is OK, because as
# we can't tell the difference between the books, one is as good
# as another.
authors = clean_string(db.authors(id_, index_is_id=True))
if authors:
db_book_title_cache[title]['authors'][authors] = id_
if db.author_sort(id_, index_is_id=True):
aus = clean_string(db.author_sort(id_, index_is_id=True))
db_book_title_cache[title]['author_sort'][aus] = id_
db_book_title_cache[title]['db_ids'][id_] = id_
db_book_uuid_cache[db.uuid(id_, index_is_id=True)] = id_
self.db_book_title_cache = db_book_title_cache
self.db_book_uuid_cache = db_book_uuid_cache
book_ids_to_refresh = set()
book_formats_to_send = []
books_with_future_dates = []
first_call_to_synchronize_with_db = [True]
def update_book(id_, book) :
if not update_metadata:
return
mi = db.get_metadata(id_, index_is_id=True, get_cover=get_covers)
book.smart_update(mi, replace_metadata=True)
if get_covers and desired_thumbnail_height != 0:
self.update_thumbnail(book)
def updateq(id_, book):
try:
if not update_metadata:
return False
if do_device_sync and self.device_manager.device is not None:
set_of_ids, (fmt_name, date_bad) = \
self.device_manager.device.synchronize_with_db(db, id_, book,
first_call_to_synchronize_with_db[0])
first_call_to_synchronize_with_db[0] = False
if date_bad:
books_with_future_dates.append(book.title)
elif fmt_name is not None:
book_formats_to_send.append((id_, fmt_name))
if set_of_ids is not None:
book_ids_to_refresh.update(set_of_ids)
return True
return (db.metadata_last_modified(id_, index_is_id=True) !=
getattr(book, 'last_modified', None) or
(isinstance(getattr(book, 'thumbnail', None), (list, tuple)) and
max(book.thumbnail[0], book.thumbnail[1]) != desired_thumbnail_height
)
)
except:
return True
def get_by_author(book, d, author):
book_id = d['authors'].get(author)
if book_id is not None:
book.in_library = 'AUTHOR'
book.application_id = book_id
update_book(book_id, book)
return True
book_id = d['author_sort'].get(author)
if book_id is not None:
book.in_library = 'AUTH_SORT'
book.application_id = book_id
update_book(book_id, book)
return True
return False
# Now iterate through all the books on the device, setting the
# in_library field. If the UUID matches a book in the library, then
# do not consider that book for other matching. In all cases set
# the application_id to the db_id of the matching book. This value
# will be used by books_on_device to indicate matches. While we are
# going by, update the metadata for a book if automatic management is on
total_book_count = 0
for booklist in booklists:
for book in booklist:
if book:
total_book_count += 1
debug_print('DeviceJob: set_books_in_library: books to process=', total_book_count)
start_time = time.time()
with BusyCursor():
current_book_count = 0
for booklist in booklists:
for book in booklist:
if current_book_count % 100 == 0:
self.status_bar.show_message(
_('Analyzing books on the device: %d%% finished')%(
int((float(current_book_count)/total_book_count)*100.0)), show_notification=False)
# I am assuming that this sort-of multi-threading won't break
# anything. Reasons: excluding UI events prevents the user
# from explicitly changing anything, and (in theory) no
# changes are happening because of timers and the like.
# Why every tenth book? WAG balancing performance in the
# loop with preventing App Not Responding errors
if current_book_count % 10 == 0:
QCoreApplication.processEvents(
flags=QEventLoop.ProcessEventsFlag.ExcludeUserInputEvents|QEventLoop.ProcessEventsFlag.ExcludeSocketNotifiers)
current_book_count += 1
book.in_library = None
if getattr(book, 'uuid', None) in self.db_book_uuid_cache:
id_ = db_book_uuid_cache[book.uuid]
if updateq(id_, book):
update_book(id_, book)
book.in_library = 'UUID'
# ensure that the correct application_id is set
book.application_id = id_
continue
# No UUID exact match. Try metadata matching.
book_title = clean_string(book.title)
d = self.db_book_title_cache.get(book_title, None)
if d is not None:
# At this point we know that the title matches. The book
# will match if any of the db_id, author, or author_sort
# also match.
if getattr(book, 'application_id', None) in d['db_ids']:
id_ = getattr(book, 'application_id', None)
update_book(id_, book)
book.in_library = 'APP_ID'
# app_id already matches a db_id. No need to set it.
continue
# Sonys know their db_id independent of the application_id
# in the metadata cache. Check that as well.
if getattr(book, 'db_id', None) in d['db_ids']:
update_book(book.db_id, book)
book.in_library = 'DB_ID'
book.application_id = book.db_id
continue
# We now know that the application_id is not right. Set it
# to None to prevent book_on_device from accidentally
# matching on it. It will be set to a correct value below if
# the book is matched with one in the library
book.application_id = None
if book.authors:
# Compare against both author and author sort, because
# either can appear as the author
all_book_authors = clean_string(authors_to_string(book.authors))
if not get_by_author(book, d, all_book_authors):
for author in book.authors:
if get_by_author(book, d, clean_string(author)):
break
else:
# Book definitely not matched. Clear its application ID
book.application_id = None
# Set author_sort if it isn't already
asort = getattr(book, 'author_sort', None)
if not asort and book.authors:
book.author_sort = self.library_view.model().db.\
author_sort_from_authors(book.authors)
if update_metadata:
if self.device_manager.is_device_connected:
plugboards = self.library_view.model().db.new_api.pref('plugboards', {})
self.device_manager.sync_booklists(
FunctionDispatcher(self.metadata_synced), booklists,
plugboards, add_as_step_to_job)
if book_ids_to_refresh:
try:
prints('DeviceJob: set_books_in_library refreshing GUI for ',
len(book_ids_to_refresh), 'books')
self.library_view.model().refresh_ids(book_ids_to_refresh,
current_row=self.library_view.currentIndex().row())
except:
# This shouldn't ever happen, but just in case ...
traceback.print_exc()
# Sync books if necessary
try:
files, names, metadata = [], [], []
for id_, fmt_name in book_formats_to_send:
if DEBUG:
prints('DeviceJob: Syncing book. id:', id_, 'name from device', fmt_name)
ext = os.path.splitext(fmt_name)[1][1:]
fmt_info = db.new_api.format_metadata(id_, ext)
if fmt_info:
try:
pt = PersistentTemporaryFile(suffix='caltmpfmt.'+ext)
db.new_api.copy_format_to(id_, ext, pt)
pt.close()
files.append(filename_to_unicode(os.path.abspath(pt.name)))
names.append(fmt_name)
mi = db.new_api.get_metadata(id_, get_cover=True)
self.update_thumbnail(mi)
metadata.append(mi)
except:
prints('Problem creating temporary file for', fmt_name)
traceback.print_exc()
else:
if DEBUG:
prints("DeviceJob: book doesn't have that format")
if files:
self.upload_books(files, names, metadata)
except:
# Shouldn't ever happen, but just in case
traceback.print_exc()
# Inform user about future-dated books
try:
if books_with_future_dates:
d = error_dialog(self, _('Book format sync problem'),
_('Some book formats in your library cannot be '
'synced because they have dates in the future'),
det_msg='\n'.join(books_with_future_dates),
show=False,
show_copy_button=True)
d.show()
except:
traceback.print_exc()
debug_print('DeviceJob: set_books_in_library finished: time=', time.time() - start_time)
# The status line is reset when the job finishes
return update_metadata
# }}}
| 93,088 | Python | .py | 1,876 | 34.903518 | 154 | 0.554349 | kovidgoyal/calibre | 19,243 | 2,250 | 4 | GPL-3.0 | 9/5/2024, 5:13:50 PM (Europe/Amsterdam) |
26,627 | complete2.py | kovidgoyal_calibre/src/calibre/gui2/complete2.py | #!/usr/bin/env python
__license__ = 'GPL v3'
__copyright__ = '2012, Kovid Goyal <kovid@kovidgoyal.net>'
__docformat__ = 'restructuredtext en'
from contextlib import suppress
from qt.core import (
QAbstractItemView,
QAbstractListModel,
QApplication,
QComboBox,
QEvent,
QKeySequence,
QLineEdit,
QListView,
QModelIndex,
QObject,
QPoint,
QStyle,
QStyleOptionComboBox,
Qt,
QTimer,
pyqtProperty,
pyqtSignal,
sip,
)
from calibre.constants import ismacos
from calibre.gui2.widgets import EnComboBox, LineEditECM
from calibre.utils.config import tweaks
from calibre.utils.icu import primary_contains, primary_startswith, sort_key
def containsq(x, prefix):
return primary_contains(prefix, x)
class CompleteModel(QAbstractListModel): # {{{
def __init__(self, parent=None, sort_func=sort_key, strip_completion_entries=True):
QAbstractListModel.__init__(self, parent)
self.strip_completion_entries = strip_completion_entries
self.sort_func = sort_func
self.all_items = self.current_items = ()
self.current_prefix = ''
def set_items(self, items):
if self.strip_completion_entries:
items = (str(x).strip() for x in items if x)
else:
items = (str(x) for x in items if x)
items = tuple(sorted(items, key=self.sort_func))
self.beginResetModel()
self.all_items = self.current_items = items
self.current_prefix = ''
self.endResetModel()
def set_completion_prefix(self, prefix):
old_prefix = self.current_prefix
self.current_prefix = prefix
if prefix == old_prefix:
return
if not prefix:
self.beginResetModel()
self.current_items = self.all_items
self.endResetModel()
return
subset = prefix.startswith(old_prefix)
universe = self.current_items if subset else self.all_items
func = primary_startswith if tweaks['completion_mode'] == 'prefix' else containsq
self.beginResetModel()
self.current_items = tuple(x for x in universe if func(x, prefix))
self.endResetModel()
def rowCount(self, *args):
return len(self.current_items)
def data(self, index, role):
if role == Qt.ItemDataRole.DisplayRole:
with suppress(IndexError):
ans = self.current_items[index.row()].replace('\n', ' ')
if not self.strip_completion_entries:
ls = ans.lstrip()
if len(ls) < len(ans):
ans = '␣'*(len(ans) - len(ls)) + ls
rs = ans.rstrip()
if len(rs) < len(ans):
ans = rs + '␣'*(len(ans) - len(rs))
return ans
if role == Qt.ItemDataRole.UserRole:
with suppress(IndexError):
return self.current_items[index.row()]
def index_for_prefix(self, prefix):
for i, item in enumerate(self.current_items):
if primary_startswith(item, prefix):
return self.index(i)
# }}}
class Completer(QListView): # {{{
item_selected = pyqtSignal(object)
apply_current_text = pyqtSignal()
relayout_needed = pyqtSignal()
def __init__(self, completer_widget, max_visible_items=7, sort_func=sort_key, strip_completion_entries=True):
QListView.__init__(self, completer_widget)
self.disable_popup = False
self.setWindowFlags(Qt.WindowType.Popup)
self.max_visible_items = max_visible_items
self.setEditTriggers(QAbstractItemView.EditTrigger.NoEditTriggers)
self.setHorizontalScrollBarPolicy(Qt.ScrollBarPolicy.ScrollBarAlwaysOff)
self.setSelectionBehavior(QAbstractItemView.SelectionBehavior.SelectRows)
self.setSelectionMode(QAbstractItemView.SelectionMode.SingleSelection)
self.setUniformItemSizes(True)
self.setAlternatingRowColors(True)
self.setModel(CompleteModel(self, sort_func=sort_func, strip_completion_entries=strip_completion_entries))
self.setMouseTracking(True)
self.activated.connect(self.item_chosen)
self.pressed.connect(self.item_chosen)
self.installEventFilter(self)
self.setFocusPolicy(Qt.FocusPolicy.NoFocus)
self.tab_accepts_uncompleted_text = (tweaks['tab_accepts_uncompleted_text'] and
not tweaks['preselect_first_completion'])
def hide(self):
self.setCurrentIndex(QModelIndex())
QListView.hide(self)
def item_chosen(self, index):
if not self.isVisible():
return
self.hide()
text = self.model().data(index, Qt.ItemDataRole.UserRole)
self.item_selected.emit(str(text))
def set_items(self, items):
self.model().set_items(items)
if self.isVisible():
self.relayout_needed.emit()
def set_completion_prefix(self, prefix):
self.model().set_completion_prefix(prefix)
if self.isVisible():
self.relayout_needed.emit()
def next_match(self, previous=False):
c = self.currentIndex()
if c.isValid():
r = c.row()
else:
r = self.model().rowCount() if previous else -1
r = r + (-1 if previous else 1)
index = self.model().index(r % self.model().rowCount())
self.setCurrentIndex(index)
def scroll_to(self, orig):
if orig:
index = self.model().index_for_prefix(orig)
if index is not None and index.isValid():
self.setCurrentIndex(index)
def popup(self, select_first=True):
if self.disable_popup:
return
p = self
m = p.model()
widget = self.parent()
if widget is None:
return
screen = widget.screen().availableGeometry()
h = (p.sizeHintForRow(0) * min(self.max_visible_items, m.rowCount()) + 3) + 3
hsb = p.horizontalScrollBar()
if hsb and hsb.isVisible():
h += hsb.sizeHint().height()
rh = widget.height()
pos = widget.mapToGlobal(QPoint(0, widget.height() - 2))
w = min(widget.width(), screen.width())
if (pos.x() + w) > (screen.x() + screen.width()):
pos.setX(screen.x() + screen.width() - w)
if pos.x() < screen.x():
pos.setX(screen.x())
top = pos.y() - rh - screen.top() + 2
bottom = screen.bottom() - pos.y()
h = max(h, p.minimumHeight())
if h > bottom:
h = min(max(top, bottom), h)
if top > bottom:
pos.setY(pos.y() - h - rh + 2)
p.setGeometry(pos.x(), pos.y(), w, h)
if (tweaks['preselect_first_completion'] and select_first and not
self.currentIndex().isValid() and self.model().rowCount() > 0):
self.setCurrentIndex(self.model().index(0))
if not p.isVisible():
p.show()
def debug_event(self, ev):
from calibre.gui2 import event_type_name
print('Event:', event_type_name(ev))
if ev.type() in (QEvent.Type.KeyPress, QEvent.Type.ShortcutOverride, QEvent.Type.KeyRelease):
print('\tkey:', QKeySequence(ev.key()).toString())
def mouseMoveEvent(self, ev):
idx = self.indexAt(ev.pos())
if idx.isValid():
ci = self.currentIndex()
if idx.row() != ci.row():
self.setCurrentIndex(idx)
return QListView.mouseMoveEvent(self, ev)
def eventFilter(self, obj, e):
'Redirect key presses from the popup to the widget'
widget = self.parent()
if widget is None or sip.isdeleted(widget):
return False
etype = e.type()
if obj is not self:
return QObject.eventFilter(self, obj, e)
# self.debug_event(e)
if etype == QEvent.Type.KeyPress:
try:
key = e.key()
except AttributeError:
return QObject.eventFilter(self, obj, e)
if key == Qt.Key.Key_Escape:
self.hide()
e.accept()
return True
if key == Qt.Key.Key_F4 and e.modifiers() & Qt.KeyboardModifier.AltModifier:
self.hide()
e.accept()
return True
if key in (Qt.Key.Key_Enter, Qt.Key.Key_Return):
# We handle this explicitly because on OS X activated() is
# not emitted on pressing Enter.
idx = self.currentIndex()
if idx.isValid():
self.item_chosen(idx)
self.hide()
e.accept()
return True
if key == Qt.Key.Key_Tab:
idx = self.currentIndex()
if idx.isValid():
self.item_chosen(idx)
self.hide()
elif self.tab_accepts_uncompleted_text:
self.hide()
self.apply_current_text.emit()
elif self.model().rowCount() > 0:
self.next_match()
e.accept()
return True
if key in (Qt.Key.Key_PageUp, Qt.Key.Key_PageDown):
# Let the list view handle these keys
return False
if key in (Qt.Key.Key_Up, Qt.Key.Key_Down):
self.next_match(previous=key == Qt.Key.Key_Up)
e.accept()
return True
# Send to widget
widget.eat_focus_out = False
widget.keyPressEvent(e)
widget.eat_focus_out = True
if not widget.hasFocus():
# Widget lost focus hide the popup
self.hide()
if e.isAccepted():
return True
elif ismacos and etype == QEvent.Type.InputMethodQuery and e.queries() == (
Qt.InputMethodQuery.ImHints | Qt.InputMethodQuery.ImEnabled) and self.isVisible():
# In Qt 5 the Esc key causes this event and the line edit does not
# handle it, which causes the parent dialog to be closed
# See https://bugreports.qt-project.org/browse/QTBUG-41806
e.accept()
return True
elif etype == QEvent.Type.MouseButtonPress and hasattr(e, 'globalPos') and not self.rect().contains(self.mapFromGlobal(e.globalPos())):
# A click outside the popup, close it
if isinstance(widget, QComboBox):
# This workaround is needed to ensure clicking on the drop down
# arrow of the combobox closes the popup
opt = QStyleOptionComboBox()
widget.initStyleOption(opt)
sc = widget.style().hitTestComplexControl(QStyle.ComplexControl.CC_ComboBox, opt, widget.mapFromGlobal(e.globalPos()), widget)
if sc == QStyle.SubControl.SC_ComboBoxArrow:
QTimer.singleShot(0, self.hide)
e.accept()
return True
self.hide()
e.accept()
return True
elif etype in (QEvent.Type.InputMethod, QEvent.Type.ShortcutOverride):
QApplication.sendEvent(widget, e)
return False
# }}}
class LineEdit(QLineEdit, LineEditECM):
'''
A line edit that completes on multiple items separated by a
separator. Use the :meth:`update_items_cache` to set the list of
all possible completions. Separator can be controlled with the
:meth:`set_separator` and :meth:`set_space_before_sep` methods.
A call to self.set_separator(None) will allow this widget to be used
to complete non multiple fields as well.
'''
item_selected = pyqtSignal(object)
def __init__(self, parent=None, completer_widget=None, sort_func=sort_key, strip_completion_entries=True):
QLineEdit.__init__(self, parent)
self.setClearButtonEnabled(True)
self.sep = ','
self.space_before_sep = False
self.add_separator = True
self.original_cursor_pos = None
completer_widget = (self if completer_widget is None else
completer_widget)
self.mcompleter = Completer(completer_widget, sort_func=sort_func, strip_completion_entries=strip_completion_entries)
self.mcompleter.item_selected.connect(self.completion_selected,
type=Qt.ConnectionType.QueuedConnection)
self.mcompleter.apply_current_text.connect(self.apply_current_text,
type=Qt.ConnectionType.QueuedConnection)
self.mcompleter.relayout_needed.connect(self.relayout)
self.mcompleter.setFocusProxy(completer_widget)
self.textEdited.connect(self.text_edited)
self.no_popup = False
# Interface {{{
def set_sort_func(self, sort_func):
self.mcompleter.model().sort_func = sort_func
def update_items_cache(self, complete_items):
self.all_items = complete_items
def set_separator(self, sep):
self.sep = sep
def set_space_before_sep(self, space_before):
self.space_before_sep = space_before
def set_add_separator(self, what):
self.add_separator = bool(what)
@property
def all_items(self):
return self.mcompleter.model().all_items
@all_items.setter
def all_items(self, items):
self.mcompleter.model().set_items(items)
@property
def disable_popup(self):
return self.mcompleter.disable_popup
@disable_popup.setter
def disable_popup(self, val):
self.mcompleter.disable_popup = bool(val)
def set_elide_mode(self, val):
self.mcompleter.setTextElideMode(val)
# }}}
def event(self, ev):
# See https://bugreports.qt.io/browse/QTBUG-46911
try:
if ev.type() == QEvent.Type.ShortcutOverride and (
ev.key() in (Qt.Key.Key_Left, Qt.Key.Key_Right) and (
ev.modifiers() & ~Qt.KeyboardModifier.KeypadModifier) == Qt.KeyboardModifier.ControlModifier):
ev.accept()
except AttributeError:
pass
return QLineEdit.event(self, ev)
def complete(self, show_all=False, select_first=True):
orig = None
if show_all:
orig = self.mcompleter.model().current_prefix
self.mcompleter.set_completion_prefix('')
if not self.mcompleter.model().current_items:
self.mcompleter.hide()
return
self.mcompleter.popup(select_first=select_first)
self.setFocus(Qt.FocusReason.OtherFocusReason)
self.mcompleter.scroll_to(orig)
def relayout(self):
self.mcompleter.popup()
self.setFocus(Qt.FocusReason.OtherFocusReason)
def text_edited(self, *args):
if self.no_popup:
return
self.update_completions()
select_first = len(self.mcompleter.model().current_prefix) > 0
if not select_first:
self.mcompleter.setCurrentIndex(QModelIndex())
self.complete(select_first=select_first)
def update_completions(self):
' Update the list of completions '
self.original_cursor_pos = cpos = self.cursorPosition()
text = str(self.text())
prefix = text[:cpos]
complete_prefix = prefix.lstrip()
if self.sep:
complete_prefix = prefix.split(self.sep)[-1].lstrip()
self.mcompleter.set_completion_prefix(complete_prefix)
def get_completed_text(self, text):
'Get completed text in before and after parts'
if self.sep is None:
return text, ''
else:
cursor_pos = self.original_cursor_pos
if cursor_pos is None:
cursor_pos = self.cursorPosition()
self.original_cursor_pos = None
# Split text
curtext = str(self.text())
before_text = curtext[:cursor_pos]
after_text = curtext[cursor_pos:].rstrip()
# Remove the completion prefix from the before text
before_text = self.sep.join(before_text.split(self.sep)[:-1]).rstrip()
if before_text:
# Add the separator to the end of before_text
if self.space_before_sep:
before_text += ' '
before_text += self.sep + ' '
if self.add_separator or after_text:
# Add separator to the end of completed text
if self.space_before_sep:
text = text.rstrip() + ' '
completed_text = text + self.sep + ' '
else:
completed_text = text
return before_text + completed_text, after_text
def completion_selected(self, text):
before_text, after_text = self.get_completed_text(str(text))
self.setText(before_text + after_text)
self.setCursorPosition(len(before_text))
self.item_selected.emit(text)
def apply_current_text(self):
if self.sep is not None:
txt = str(self.text())
sep_pos = txt.rfind(self.sep)
if sep_pos:
ntxt = txt[sep_pos+1:].strip()
self.completion_selected(ntxt)
class EditWithComplete(EnComboBox):
item_selected = pyqtSignal(object)
def __init__(self, *args, **kwargs):
EnComboBox.__init__(self, *args)
self.setLineEdit(LineEdit(
self, completer_widget=self, sort_func=kwargs.get('sort_func', sort_key),
strip_completion_entries=kwargs.get('strip_completion_entries', False)))
self.lineEdit().item_selected.connect(self.item_selected)
self.setCompleter(None)
self.eat_focus_out = True
self.installEventFilter(self)
# Interface {{{
def set_sort_func(self, sort_func):
self.lineEdit().set_sort_func(sort_func)
def showPopup(self):
orig = self.disable_popup
self.disable_popup = False
try:
self.lineEdit().complete(show_all=True)
finally:
self.disable_popup = orig
def update_items_cache(self, complete_items):
self.lineEdit().update_items_cache(complete_items)
def set_separator(self, sep):
self.lineEdit().set_separator(sep)
def set_space_before_sep(self, space_before):
self.lineEdit().set_space_before_sep(space_before)
def set_add_separator(self, what):
self.lineEdit().set_add_separator(what)
def show_initial_value(self, what):
what = str(what) if what else ''
self.setText(what)
self.lineEdit().selectAll()
@property
def all_items(self):
return self.lineEdit().all_items
@all_items.setter
def all_items(self, val):
self.lineEdit().all_items = val
@property
def disable_popup(self):
return self.lineEdit().disable_popup
@disable_popup.setter
def disable_popup(self, val):
self.lineEdit().disable_popup = bool(val)
def set_elide_mode(self, val):
self.lineEdit().set_elide_mode(val)
def set_clear_button_enabled(self, val=True):
self.lineEdit().setClearButtonEnabled(bool(val))
# }}}
def text(self):
return self.lineEdit().text()
def set_current_text(self, text):
self.setText(text)
self.selectAll()
# Create a Qt user property for the current text so that when this widget
# is used as an edit widget in a table view it selects all text, as
# matching the behavior of all other Qt widgets.
current_text = pyqtProperty(str, fget=text, fset=set_current_text, user=True)
def selectAll(self):
self.lineEdit().selectAll()
def setText(self, val):
le = self.lineEdit()
le.no_popup = True
le.setText(val)
le.no_popup = False
def home(self, mark=False):
self.lineEdit().home(mark)
def setCursorPosition(self, *args):
self.lineEdit().setCursorPosition(*args)
@property
def textChanged(self):
return self.lineEdit().textChanged
def clear(self):
self.lineEdit().clear()
EnComboBox.clear(self)
def eventFilter(self, obj, e):
try:
c = self.lineEdit().mcompleter
except AttributeError:
return False
etype = e.type()
if self.eat_focus_out and self is obj and etype == QEvent.Type.FocusOut:
if c.isVisible():
return True
return EnComboBox.eventFilter(self, obj, e)
if __name__ == '__main__':
from qt.core import QDialog, QVBoxLayout
from calibre.gui2 import Application
app = Application([])
d = QDialog()
d.setLayout(QVBoxLayout())
le = EditWithComplete(d)
d.layout().addWidget(le)
items = ['oane\n line2\n line3', 'otwo', 'othree', 'ooone', 'ootwo', 'other', 'odd', 'over', 'orc', 'oven', 'owe',
'oothree', 'a1', 'a2','Edgas', 'Èdgar', 'Édgaq', 'Edgar', 'Édgar']
le.update_items_cache(items)
le.show_initial_value('')
d.exec()
| 21,143 | Python | .py | 504 | 31.797619 | 143 | 0.605385 | kovidgoyal/calibre | 19,243 | 2,250 | 4 | GPL-3.0 | 9/5/2024, 5:13:50 PM (Europe/Amsterdam) |
26,628 | save.py | kovidgoyal_calibre/src/calibre/gui2/save.py | #!/usr/bin/env python
__license__ = 'GPL v3'
__copyright__ = '2014, Kovid Goyal <kovid at kovidgoyal.net>'
import errno
import os
import shutil
import time
import traceback
from collections import defaultdict, namedtuple
from qt.core import QObject, Qt, pyqtSignal
from calibre import force_unicode, prints
from calibre.constants import DEBUG
from calibre.customize.ui import can_set_metadata
from calibre.db.constants import DATA_FILE_PATTERN
from calibre.db.errors import NoSuchFormat
from calibre.ebooks.metadata import authors_to_string
from calibre.ebooks.metadata.opf2 import metadata_to_opf
from calibre.gui2 import error_dialog, gprefs, open_local_file, warning_dialog
from calibre.gui2.dialogs.progress import ProgressDialog
from calibre.library.save_to_disk import find_plugboard, get_path_components, plugboard_save_to_disk_value, sanitize_args
from calibre.ptempfile import PersistentTemporaryDirectory, SpooledTemporaryFile
from calibre.utils.filenames import make_long_path_useable
from calibre.utils.ipc.pool import Failure, Pool
from polyglot.builtins import iteritems, itervalues
from polyglot.queue import Empty
BookId = namedtuple('BookId', 'title authors')
def ensure_unique_components(data): # {{{
cmap = defaultdict(set)
bid_map = {}
for book_id, (mi, components, fmts) in iteritems(data):
cmap[tuple(components)].add(book_id)
bid_map[book_id] = components
for book_ids in itervalues(cmap):
if len(book_ids) > 1:
for i, book_id in enumerate(sorted(book_ids)[1:]):
suffix = ' (%d)' % (i + 1)
components = bid_map[book_id]
components[-1] = components[-1] + suffix
# }}}
class SpooledFile(SpooledTemporaryFile): # {{{
def __init__(self, file_obj, max_size=50*1024*1024):
self._file_obj = file_obj
SpooledTemporaryFile.__init__(self, max_size)
def rollover(self):
if self._rolled:
return
orig = self._file
newfile = self._file = self._file_obj
del self._TemporaryFileArgs
newfile.write(orig.getvalue())
newfile.seek(orig.tell(), 0)
self._rolled = True
# }}}
class Saver(QObject):
do_one_signal = pyqtSignal()
def __init__(self, book_ids, db, opts, root, parent=None, pool=None):
QObject.__init__(self, parent)
self.db = db.new_api
self.plugboards = self.db.pref('plugboards', {})
self.template_functions = self.db.pref('user_template_functions', [])
self.library_id = self.db.library_id
# This call to load_user_template_functions isn't needed because
# __init__ is running on the GUI thread. It must be done in the separate
# process by the worker
# from calibre.gui2 import is_gui_thread
# print(f'Saver __init__ is_gui_thread: {is_gui_thread()}')
# load_user_template_functions('', self.template_functions)
self.collected_data = {}
self.errors = defaultdict(list)
self._book_id_data = {}
self.all_book_ids = frozenset(book_ids)
self.pd = ProgressDialog(_('Saving %d books...') % len(self.all_book_ids), _('Collecting metadata...'), min=0, max=0, parent=parent, icon='save.png')
self.do_one_signal.connect(self.tick, type=Qt.ConnectionType.QueuedConnection)
self.do_one = self.do_one_collect
self.ids_to_collect = iter(self.all_book_ids)
self.tdir = PersistentTemporaryDirectory('_save_to_disk')
self.pool = pool
self.pd.show()
self.root, self.opts, self.path_length = sanitize_args(root, opts)
self.do_one_signal.emit()
if DEBUG:
self.start_time = time.time()
def tick(self):
if self.pd.canceled:
self.pd.close()
self.pd.deleteLater()
self.break_cycles()
return
self.do_one()
def break_cycles(self):
shutil.rmtree(self.tdir, ignore_errors=True)
if self.pool is not None:
self.pool.shutdown()
self.setParent(None)
self.jobs = self.pool = self.plugboards = self.template_functions = self.library_id =\
self.collected_data = self.all_book_ids = self.pd = self.db = None # noqa
self.deleteLater()
def book_id_data(self, book_id):
ans = self._book_id_data.get(book_id)
if ans is None:
try:
ans = BookId(self.db.field_for('title', book_id), self.db.field_for('authors', book_id))
except Exception:
ans = BookId((_('Unknown') + ' (%d)' % book_id), (_('Unknown'),))
self._book_id_data[book_id] = ans
return ans
def do_one_collect(self):
try:
book_id = next(self.ids_to_collect)
except StopIteration:
self.collection_finished()
return
try:
self.collect_data(book_id)
except Exception:
self.errors[book_id].append(('critical', traceback.format_exc()))
self.do_one_signal.emit()
def collect_data(self, book_id):
mi = self.db.get_metadata(book_id)
self._book_id_data[book_id] = BookId(mi.title, mi.authors)
components = get_path_components(self.opts, mi, book_id, self.path_length)
self.collected_data[book_id] = (mi, components, {fmt.lower() for fmt in self.db.formats(book_id)})
def collection_finished(self):
self.do_one = self.do_one_write
ensure_unique_components(self.collected_data)
self.ids_to_write = iter(self.collected_data)
self.pd.title = _('Copying files and writing metadata...') if self.opts.update_metadata else _(
'Copying files...')
self.pd.max = len(self.collected_data)
self.pd.value = 0
if self.opts.update_metadata:
all_fmts = {fmt for data in itervalues(self.collected_data) for fmt in data[2]}
plugboards_cache = {fmt:find_plugboard(plugboard_save_to_disk_value, fmt, self.plugboards) for fmt in all_fmts}
self.pool = Pool(name='SaveToDisk') if self.pool is None else self.pool
try:
self.pool.set_common_data({'plugboard_cache': plugboards_cache,
'template_functions': self.template_functions,
'library_id': self.library_id})
except Failure as err:
error_dialog(self.pd, _('Critical failure'), _(
'Could not save books to disk, click "Show details" for more information'),
det_msg=force_unicode(err.failure_message) + '\n' + force_unicode(err.details), show=True)
self.pd.canceled = True
self.do_one_signal.emit()
def do_one_write(self):
try:
book_id = next(self.ids_to_write)
except StopIteration:
self.writing_finished()
return
if not self.opts.update_metadata:
self.pd.msg = self.book_id_data(book_id).title
self.pd.value += 1
try:
self.write_book(book_id, *self.collected_data[book_id])
except Exception:
self.errors[book_id].append(('critical', traceback.format_exc()))
self.consume_results()
self.do_one_signal.emit()
def consume_results(self):
if self.pool is not None:
while True:
try:
worker_result = self.pool.results.get_nowait()
except Empty:
break
book_id = worker_result.id
if worker_result.is_terminal_failure:
error_dialog(self.pd, _('Critical failure'), _(
'The update metadata worker process crashed while processing'
' the book %s. Saving is aborted.') % self.book_id_data(book_id).title, show=True)
self.pd.canceled = True
return
result = worker_result.result
self.pd.value += 1
self.pd.msg = self.book_id_data(book_id).title
if result.err is not None:
self.errors[book_id].append(('metadata', (None, result.err + '\n' + result.traceback)))
if result.value:
for fmt, tb in result.value:
self.errors[book_id].append(('metadata', (fmt, tb)))
def write_book(self, book_id, mi, components, fmts):
base_path = os.path.join(self.root, *components)
base_dir = os.path.dirname(base_path)
if self.opts.formats and self.opts.formats != 'all':
asked_formats = {x.lower().strip() for x in self.opts.formats.split(',')}
fmts = asked_formats.intersection(fmts)
if not fmts:
self.errors[book_id].append(('critical', _('Requested formats not available')))
return
extra_files = {}
if self.opts.save_extra_files:
extra_files = {}
for efx in self.db.new_api.list_extra_files(int(book_id), pattern=DATA_FILE_PATTERN):
extra_files[efx.relpath] = efx.file_path
if not fmts and not self.opts.write_opf and not self.opts.save_cover and not extra_files:
return
# On windows python incorrectly raises an access denied exception
# when trying to create the root of a drive, like C:\
if os.path.dirname(base_dir) != base_dir:
try:
os.makedirs(base_dir)
except OSError as err:
if err.errno != errno.EEXIST:
raise
if self.opts.update_metadata:
d = {}
d['last_modified'] = mi.last_modified.isoformat()
cdata = self.db.cover(book_id)
mi.cover, mi.cover_data = None, (None, None)
if cdata:
fname = None
if self.opts.save_cover:
fname = base_path + os.extsep + 'jpg'
mi.cover = os.path.basename(fname)
elif self.opts.update_metadata:
fname = os.path.join(self.tdir, '%d.jpg' % book_id)
if fname:
with open(fname, 'wb') as f:
f.write(cdata)
if self.opts.update_metadata:
d['cover'] = fname
fname = None
if self.opts.write_opf:
fname = base_path + os.extsep + 'opf'
elif self.opts.update_metadata:
fname = os.path.join(self.tdir, '%d.opf' % book_id)
if fname:
opf = metadata_to_opf(mi)
with open(fname, 'wb') as f:
f.write(opf)
if self.opts.update_metadata:
d['opf'] = fname
mi.cover, mi.cover_data = None, (None, None)
if self.opts.update_metadata:
d['fmts'] = []
if extra_files:
for relpath, src_path in extra_files.items():
src_path = make_long_path_useable(src_path)
if os.access(src_path, os.R_OK):
dest = make_long_path_useable(os.path.abspath(os.path.join(base_dir, relpath)))
try:
shutil.copy2(src_path, dest)
except FileNotFoundError:
os.makedirs(os.path.dirname(dest), exist_ok=True)
shutil.copy2(src_path, dest)
for fmt in fmts:
try:
fmtpath = self.write_fmt(book_id, fmt, base_path)
if fmtpath and self.opts.update_metadata and can_set_metadata(fmt):
d['fmts'].append(fmtpath)
except Exception:
self.errors[book_id].append(('fmt', (fmt, traceback.format_exc())))
if self.opts.update_metadata:
if d['fmts']:
try:
self.pool(book_id, 'calibre.library.save_to_disk', 'update_serialized_metadata', d)
except Failure as err:
error_dialog(self.pd, _('Critical failure'), _(
'Could not save books to disk, click "Show details" for more information'),
det_msg=str(err.failure_message) + '\n' + str(err.details), show=True)
self.pd.canceled = True
else:
self.pd.value += 1
self.pd.msg = self.book_id_data(book_id).title
def write_fmt(self, book_id, fmt, base_path):
fmtpath = base_path + os.extsep + fmt
written = False
with open(fmtpath, 'w+b') as f:
try:
self.db.copy_format_to(book_id, fmt, f)
written = True
except NoSuchFormat:
self.errors[book_id].append(('fmt', (fmt, _('No %s format file present') % fmt.upper())))
if not written:
os.remove(fmtpath)
if written:
return fmtpath
def writing_finished(self):
if not self.opts.update_metadata:
self.updating_metadata_finished()
else:
self.do_one = self.do_one_update
self.do_one_signal.emit()
def do_one_update(self):
self.consume_results()
try:
self.pool.wait_for_tasks(0.1)
except Failure as err:
error_dialog(self.pd, _('Critical failure'), _(
'Could not save books to disk, click "Show details" for more information'),
det_msg=str(err.failure_message) + '\n' + str(err.details), show=True)
self.pd.canceled = True
except RuntimeError:
pass # tasks not completed
else:
self.consume_results()
return self.updating_metadata_finished()
self.do_one_signal.emit()
def updating_metadata_finished(self):
if DEBUG:
prints('Saved %d books in %.1f seconds' % (len(self.all_book_ids), time.time() - self.start_time))
self.pd.close()
self.pd.deleteLater()
self.report()
self.break_cycles()
if gprefs['show_files_after_save']:
open_local_file(self.root)
def format_report(self):
report = []
a = report.append
def indent(text):
text = force_unicode(text)
return '\xa0\xa0\xa0\xa0' + '\n\xa0\xa0\xa0\xa0'.join(text.splitlines())
for book_id, errors in iteritems(self.errors):
types = {t for t, data in errors}
title, authors = self.book_id_data(book_id).title, authors_to_string(self.book_id_data(book_id).authors[:1])
if report:
a('\n' + ('_'*70) + '\n')
if 'critical' in types:
a(_('Failed to save: {0} by {1} to disk, with error:').format(title, authors))
for t, tb in errors:
if t == 'critical':
a(indent(tb))
else:
errs = defaultdict(list)
for t, data in errors:
errs[t].append(data)
for fmt, tb in errs['fmt']:
a(_('Failed to save the {2} format of: {0} by {1} to disk, with error:').format(title, authors, fmt.upper()))
a(indent(tb)), a('')
for fmt, tb in errs['metadata']:
if fmt:
a(_('Failed to update the metadata in the {2} format of: {0} by {1}, with error:').format(title, authors, fmt.upper()))
else:
a(_('Failed to update the metadata in all formats of: {0} by {1}, with error:').format(title, authors))
a(indent(tb)), a('')
return '\n'.join(report)
def report(self):
if not self.errors:
return
err_types = {e[0] for errors in itervalues(self.errors) for e in errors}
if err_types == {'metadata'}:
msg = _('Failed to update metadata in some books, click "Show details" for more information')
d = warning_dialog
elif len(self.errors) == len(self.all_book_ids):
msg = _('Failed to save any books to disk, click "Show details" for more information')
d = error_dialog
else:
msg = _('Failed to save some books to disk, click "Show details" for more information')
d = warning_dialog
d(self.parent(), _('Error while saving'), msg, det_msg=self.format_report(), show=True)
| 16,468 | Python | .py | 352 | 34.923295 | 157 | 0.572149 | kovidgoyal/calibre | 19,243 | 2,250 | 4 | GPL-3.0 | 9/5/2024, 5:13:50 PM (Europe/Amsterdam) |
26,629 | threaded_jobs.py | kovidgoyal_calibre/src/calibre/gui2/threaded_jobs.py | #!/usr/bin/env python
__license__ = 'GPL v3'
__copyright__ = '2011, Kovid Goyal <kovid@kovidgoyal.net>'
__docformat__ = 'restructuredtext en'
import json
import os
import tempfile
import time
from threading import Event, RLock, Thread
from calibre.ptempfile import base_dir
from calibre.utils.ipc.job import BaseJob
from calibre.utils.logging import GUILog
from polyglot.queue import Queue
class ThreadedJob(BaseJob):
def __init__(self,
type_, description,
func, args, kwargs,
callback,
max_concurrent_count=1,
killable=True,
log=None):
'''
A job that is run in its own thread in the calibre main process
:param type_: The type of this job (a string). The type is used in
conjunction with max_concurrent_count to prevent too many jobs of the
same type from running
:param description: A user viewable job description
:func: The function that actually does the work. This function *must*
accept at least three keyword arguments: abort, log and notifications. abort is
An Event object. func should periodically check abort.is_set() and if
it is True, it should stop processing as soon as possible. notifications
is a Queue. func should put progress notifications into it in the form
of a tuple (frac, msg). frac is a number between 0 and 1 indicating
progress and msg is a string describing the progress. log is a Log
object which func should use for all debugging output. func should
raise an Exception to indicate failure. This exception is stored in
job.exception and can thus be used to pass arbitrary information to
callback.
:param args,kwargs: These are passed to func when it is called
:param callback: A callable that is called on completion of this job.
Note that it is not called if the user kills the job. Check job.failed
to see if the job succeeded or not. And use job.log to get the job log.
:param killable: If False the GUI won't let the user kill this job
:param log: Must be a subclass of GUILog or None. If None a default
GUILog is created.
'''
BaseJob.__init__(self, description)
self.type = type_
self.max_concurrent_count = max_concurrent_count
self.killable = killable
self.callback = callback
self.abort = Event()
self.exception = None
kwargs['notifications'] = self.notifications
kwargs['abort'] = self.abort
self.log = GUILog() if log is None else log
kwargs['log'] = self.log
self.func, self.args, self.kwargs = func, args, kwargs
self.consolidated_log = None
def start_work(self):
self.start_time = time.time()
self.log('Starting job:', self.description)
try:
self.result = self.func(*self.args, **self.kwargs)
except Exception as e:
self.exception = e
self.failed = True
self.log.exception('Job: "%s" failed with error:'%self.description)
self.log.debug('Called with args:', self.args, self.kwargs)
self.duration = time.time() - self.start_time
try:
self.callback(self)
except:
import traceback
traceback.print_exc()
self._cleanup()
def _cleanup(self):
try:
self.consolidate_log()
except:
if self.log is not None:
self.log.exception('Log consolidation failed')
# No need to keep references to these around anymore
self.func = self.args = self.kwargs = self.notifications = None
# We can't delete self.callback as it might be a Dispatch object and if
# it is garbage collected it won't work
def kill(self):
if self.start_time is None:
self.start_time = time.time()
self.duration = 0.0001
else:
self.duration = time.time() - self.start_time
self.abort.set()
self.log('Aborted job:', self.description)
self.killed = True
self.failed = True
self._cleanup()
def consolidate_log(self):
logs = [self.log.html, self.log.plain_text]
bdir = base_dir()
log_dir = os.path.join(bdir, 'threaded_job_logs')
if not os.path.exists(log_dir):
os.makedirs(log_dir)
fd, path = tempfile.mkstemp(suffix='.json', prefix='log-', dir=log_dir)
data = json.dumps(logs, ensure_ascii=False, indent=2)
if not isinstance(data, bytes):
data = data.encode('utf-8')
with os.fdopen(fd, 'wb') as f:
f.write(data)
self.consolidated_log = path
self.log = None
def read_consolidated_log(self):
with open(self.consolidated_log, 'rb') as f:
return json.loads(f.read().decode('utf-8'))
@property
def details(self):
if self.consolidated_log is None:
return self.log.plain_text
return self.read_consolidated_log()[1]
@property
def html_details(self):
if self.consolidated_log is None:
return self.log.html
return self.read_consolidated_log()[0]
class ThreadedJobWorker(Thread):
def __init__(self, job):
Thread.__init__(self)
self.daemon = True
self.job = job
def run(self):
try:
self.job.start_work()
except:
import traceback
from calibre import prints
prints('Job had unhandled exception:', self.job.description)
traceback.print_exc()
class ThreadedJobServer(Thread):
def __init__(self):
Thread.__init__(self)
self.daemon = True
self.lock = RLock()
self.queued_jobs = []
self.running_jobs = set()
self.changed_jobs = Queue()
self.keep_going = True
def close(self):
self.keep_going = False
def add_job(self, job):
with self.lock:
self.queued_jobs.append(job)
if not self.is_alive():
self.start()
def run(self):
while self.keep_going:
try:
self.run_once()
except:
import traceback
traceback.print_exc()
time.sleep(0.1)
def run_once(self):
with self.lock:
remove = set()
for worker in self.running_jobs:
if worker.is_alive():
# Get progress notifications
if worker.job.consume_notifications():
self.changed_jobs.put(worker.job)
else:
remove.add(worker)
self.changed_jobs.put(worker.job)
for worker in remove:
self.running_jobs.remove(worker)
jobs = self.get_startable_jobs()
for job in jobs:
w = ThreadedJobWorker(job)
w.start()
self.running_jobs.add(w)
self.changed_jobs.put(job)
self.queued_jobs.remove(job)
def kill_job(self, job):
with self.lock:
if job in self.queued_jobs:
self.queued_jobs.remove(job)
elif job in self.running_jobs:
self.running_jobs.remove(job)
job.kill()
self.changed_jobs.put(job)
def running_jobs_of_type(self, type_):
return len([w for w in self.running_jobs if w.job.type == type_])
def get_startable_jobs(self):
queued_types = []
ans = []
for job in self.queued_jobs:
num = self.running_jobs_of_type(job.type)
num += queued_types.count(job.type)
if num < job.max_concurrent_count:
queued_types.append(job.type)
ans.append(job)
return ans
| 7,977 | Python | .py | 201 | 29.60199 | 87 | 0.597851 | kovidgoyal/calibre | 19,243 | 2,250 | 4 | GPL-3.0 | 9/5/2024, 5:13:50 PM (Europe/Amsterdam) |
26,630 | markdown_syntax_highlighter.py | kovidgoyal_calibre/src/calibre/gui2/markdown_syntax_highlighter.py | #!/usr/bin/env python
# License: GPLv3 Copyright: 2023, Kovid Goyal <kovid at kovidgoyal.net>
import re
from qt.core import QApplication, QBrush, QColor, QFont, QSyntaxHighlighter, QTextCharFormat, QTextCursor, QTextLayout
from calibre.gui2.palette import dark_link_color, light_link_color
class MarkdownHighlighter(QSyntaxHighlighter):
MARKDOWN_KEYS_REGEX = {
'Bold': re.compile(r'(?<!\\)(?P<delim>\*\*)(?P<text>.+?)(?P=delim)'),
'Italic': re.compile(r'(?<![\*\\])(?P<delim>\*)(?!\*)(?P<text>([^\*]{2,}?|[^\*]))(?<![\*\\])(?P=delim)'),
'BoldItalic': re.compile(r'(?<!\\)(?P<delim>\*\*\*)(?P<text>([^\*]{2,}?|[^\*]))(?<!\\)(?P=delim)'),
'uBold': re.compile(r'(?<!\\)(?P<delim>__)(?P<text>.+?)(?P=delim)'),
'uItalic': re.compile(r'(?<![_\\])(?P<delim>_)(?!_)(?P<text>([^_]{2,}?|[^_]))(?<![_\\])(?P=delim)'),
'uBoldItalic': re.compile(r'(?<!\\)(?P<delim>___)(?P<text>([^_]{2,}?|[^_]))(?<!\\)(?P=delim)'),
'Link': re.compile(r'(?<![!\\]])\[.*?(?<!\\)\](\[.+?(?<!\\)\]|\(.+?(?<!\\)\))'),
'Image': re.compile(r'(?<!\\)!\[.*?(?<!\\)\](\[.+?(?<!\\)\]|\(.+?(?<!\\)\))'),
'LinkRef': re.compile(r'(?u)^\s*\[.*?\]:\s*[^\s].*'),
'Header': re.compile(r'^#{1,6}.*'),
'UnorderedList': re.compile(r'(?u)^\s*(\*|\+|-)[ \t]\s*'),
'UnorderedListStar': re.compile(r'(?u)^\s*\*[ \t]\s*'),
'OrderedList': re.compile(r'(?u)^\s*\d+\.[ \t]\s*'),
'BlockQuote': re.compile(r'^[ ]{0,3}>+[ \t]?'),
'CodeBlock': re.compile(r'^([ ]{4,}|[ ]*\t).*'),
'CodeSpan': re.compile(r'(?<!\\)(?P<delim>`+).+?(?P=delim)'),
'HeaderLine': re.compile(r'(?u)^(-|=)+\s*$'),
'HR': re.compile(r'(?u)^(\s*(\*|-|_)\s*){3,}$'),
'Html': re.compile(r'(?u)</?[^/\s].*?(?<!\\)>'),
'Entity': re.compile(r'&([A-z]{2,7}|#\d{1,7}|#x[\dA-Fa-f]{1,6});'),
}
key_theme_maps = {
'Bold': "bold",
'Italic': "emphasis",
'BoldItalic': "boldemphasis",
'uBold': "bold",
'uItalic': "emphasis",
'uBoldItalic': "boldemphasis",
'Link': "link",
'Image': "image",
'LinkRef': "link",
'Header': "header",
'HeaderLine': "header",
'CodeBlock': "codeblock",
'UnorderedList': "unorderedlist",
'UnorderedListStar': "unorderedlist",
'OrderedList': "orderedlist",
'BlockQuote': "blockquote",
'CodeSpan': "codespan",
'HR': "line",
'Html': "html",
'Entity': "entity",
}
light_theme = {
"bold": {"font-weight":"bold"},
"emphasis": {"font-style":"italic"},
"boldemphasis": {"font-weight":"bold", "font-style":"italic"},
"link": {"color":light_link_color.name(), "font-weight":"normal", "font-style":"normal"},
"image": {"color":"#cb4b16", "font-weight":"normal", "font-style":"normal"},
"header": {"color":"#2aa198", "font-weight":"bold", "font-style":"normal"},
"unorderedlist": {"color":"red", "font-weight":"normal", "font-style":"normal"},
"orderedlist": {"color":"red", "font-weight":"normal", "font-style":"normal"},
"blockquote": {"color":"red", "font-weight":"bold", "font-style":"normal"},
"codespan": {"color":"#ff5800", "font-weight":"normal", "font-style":"normal"},
"codeblock": {"color":"#ff5800", "font-weight":"normal", "font-style":"normal"},
"line": {"color":"#2aa198", "font-weight":"normal", "font-style":"normal"},
"html": {"color":"#c000c0", "font-weight":"normal", "font-style":"normal"},
"entity": {"color":"#006496"},
}
dark_theme = {
"bold": {"font-weight":"bold"},
"emphasis": {"font-style":"italic"},
"boldemphasis": {"font-weight":"bold", "font-style":"italic"},
"link": {"color":dark_link_color.name(), "font-weight":"normal", "font-style":"normal"},
"image": {"color":"#cb4b16", "font-weight":"normal", "font-style":"normal"},
"header": {"color":"#2aa198", "font-weight":"bold", "font-style":"normal"},
"unorderedlist": {"color":"yellow", "font-weight":"normal", "font-style":"normal"},
"orderedlist": {"color":"yellow", "font-weight":"normal", "font-style":"normal"},
"blockquote": {"color":"yellow", "font-weight":"bold", "font-style":"normal"},
"codespan": {"color":"#90ee90", "font-weight":"normal", "font-style":"normal"},
"codeblock": {"color":"#ff9900", "font-weight":"normal", "font-style":"normal"},
"line": {"color":"#2aa198", "font-weight":"normal", "font-style":"normal"},
"html": {"color":"#f653a6", "font-weight":"normal", "font-style":"normal"},
"entity": {"color":"#ff82ac"},
}
def __init__(self, parent):
super().__init__(parent)
theme = self.dark_theme if QApplication.instance().is_dark_theme else self.light_theme
self.setTheme(theme)
def setTheme(self, theme):
self.theme = theme
self.MARKDOWN_KWS_FORMAT = {}
for k in ['Bold', 'Italic','BoldItalic']:
# generate dynamically keys and theme for EntityBold, EntityItalic, EntityBoldItalic
t = self.key_theme_maps[k]
newtheme = theme['entity'].copy()
newtheme.update(theme[t])
newthemekey = 'entity'+t
newmapkey = 'Entity'+k
theme[newthemekey] = newtheme
self.key_theme_maps[newmapkey] = newthemekey
for k,t in self.key_theme_maps.items():
subtheme = theme[t]
format = QTextCharFormat()
if 'color' in subtheme:
format.setForeground(QBrush(QColor(subtheme['color'])))
format.setFontWeight(QFont.Weight.Bold if subtheme.get('font-weight') == 'bold' else QFont.Weight.Normal)
format.setFontItalic(subtheme.get('font-style') == 'italic')
self.MARKDOWN_KWS_FORMAT[k] = format
self.rehighlight()
def highlightBlock(self, text):
self.offset = 0
self.highlightMarkdown(text)
self.highlightHtml(text)
def highlightMarkdown(self, text):
cursor = QTextCursor(self.document())
bf = cursor.blockFormat()
#Block quotes can contain all elements so process it first, internally process recursively and return
if self.highlightBlockQuote(text, cursor, bf):
return
#If empty line no need to check for below elements just return
if self.highlightEmptyLine(text, cursor, bf):
return
#If horizontal line, look at pevious line to see if its a header, process and return
if self.highlightHorizontalLine(text, cursor, bf):
return
if self.highlightHeader(text, cursor, bf):
return
self.highlightList(text, cursor, bf)
self.highlightBoldEmphasis(text, cursor, bf)
self.highlightLink(text, cursor, bf)
self.highlightImage(text, cursor, bf)
self.highlightEntity(text, cursor, bf)
self.highlightCodeSpan(text, cursor, bf)
self.highlightCodeBlock(text, cursor, bf)
def highlightBlockQuote(self, text, cursor, bf):
found = False
mo = re.match(self.MARKDOWN_KEYS_REGEX['BlockQuote'],text)
if mo:
self.setFormat(self.offset+ mo.start(), mo.end() - mo.start(), self.MARKDOWN_KWS_FORMAT['BlockQuote'])
self.offset += mo.end()
unquote = text[mo.end():]
self.highlightMarkdown(unquote)
found = True
return found
def highlightEmptyLine(self, text, cursor, bf):
textAscii = str(text.replace('\u2029','\n'))
if textAscii.strip():
return False
else:
return True
def highlightHorizontalLine(self, text, cursor, bf):
found = False
for mo in re.finditer(self.MARKDOWN_KEYS_REGEX['HeaderLine'],text):
prevBlock = self.currentBlock().previous()
prevCursor = QTextCursor(prevBlock)
prev = prevBlock.text()
prevAscii = str(prev.replace('\u2029','\n'))
if self.offset == 0 and prevAscii.strip():
#print "Its a header"
prevCursor.select(QTextCursor.SelectionType.LineUnderCursor)
#prevCursor.setCharFormat(self.MARKDOWN_KWS_FORMAT['Header'])
formatRange = QTextLayout.FormatRange()
formatRange.format = self.MARKDOWN_KWS_FORMAT['Header']
formatRange.length = prevCursor.block().length()
formatRange.start = 0
prevCursor.block().layout().setFormats([formatRange])
self.setFormat(self.offset+ mo.start(), mo.end() - mo.start(), self.MARKDOWN_KWS_FORMAT['HeaderLine'])
return True
for mo in re.finditer(self.MARKDOWN_KEYS_REGEX['HR'],text):
self.setFormat(self.offset+ mo.start(), mo.end() - mo.start(), self.MARKDOWN_KWS_FORMAT['HR'])
found = True
return found
def highlightHeader(self, text, cursor, bf):
found = False
for mo in re.finditer(self.MARKDOWN_KEYS_REGEX['Header'],text):
#bf.setBackground(QBrush(QColor(7,54,65)))
#cursor.movePosition(QTextCursor.End)
#cursor.mergeBlockFormat(bf)
self.setFormat(self.offset+ mo.start(), mo.end() - mo.start(), self.MARKDOWN_KWS_FORMAT['Header'])
found = True
return found
def highlightList(self, text, cursor, bf):
found = False
for mo in re.finditer(self.MARKDOWN_KEYS_REGEX['UnorderedList'],text):
self.setFormat(self.offset+ mo.start(), mo.end() - mo.start(), self.MARKDOWN_KWS_FORMAT['UnorderedList'])
found = True
for mo in re.finditer(self.MARKDOWN_KEYS_REGEX['OrderedList'],text):
self.setFormat(self.offset+ mo.start(), mo.end() - mo.start(), self.MARKDOWN_KWS_FORMAT['OrderedList'])
found = True
return found
def highlightLink(self, text, cursor, bf):
found = False
for mo in re.finditer(self.MARKDOWN_KEYS_REGEX['Link'],text):
self.setFormat(self.offset+ mo.start(), mo.end() - mo.start(), self.MARKDOWN_KWS_FORMAT['Link'])
found = True
for mo in re.finditer(self.MARKDOWN_KEYS_REGEX['LinkRef'],text):
self.setFormat(self.offset+ mo.start(), mo.end() - mo.start(), self.MARKDOWN_KWS_FORMAT['LinkRef'])
found = True
return found
def highlightImage(self, text, cursor, bf):
found = False
for mo in re.finditer(self.MARKDOWN_KEYS_REGEX['Image'],text):
self.setFormat(self.offset+ mo.start(), mo.end() - mo.start(), self.MARKDOWN_KWS_FORMAT['Image'])
found = True
return found
def highlightCodeSpan(self, text, cursor, bf):
found = False
for mo in re.finditer(self.MARKDOWN_KEYS_REGEX['CodeSpan'],text):
self.setFormat(self.offset+ mo.start(), mo.end() - mo.start(), self.MARKDOWN_KWS_FORMAT['CodeSpan'])
found = True
return found
def highlightBoldEmphasis(self, text, cursor, bf):
mo = re.match(self.MARKDOWN_KEYS_REGEX['UnorderedListStar'], text)
if mo:
offset = mo.end()
else:
offset = 0
return self._highlightBoldEmphasis(text[offset:], cursor, bf, offset, False, False)
def _highlightBoldEmphasis(self, text, cursor, bf, offset, bold, emphasis):
#detect and apply imbricated Bold/Emphasis
found = False
def apply(match, bold, emphasis):
if bold and emphasis:
self.setFormat(self.offset+offset+ match.start(), match.end() - match.start(), self.MARKDOWN_KWS_FORMAT['BoldItalic'])
elif bold:
self.setFormat(self.offset+offset+ match.start(), match.end() - match.start(), self.MARKDOWN_KWS_FORMAT['Bold'])
elif emphasis:
self.setFormat(self.offset+offset+ match.start(), match.end() - match.start(), self.MARKDOWN_KWS_FORMAT['Italic'])
def recusive(match, extra_offset, bold, emphasis):
apply(match, bold, emphasis)
if bold and emphasis:
return # max deep => return, do not process extra Bold/Italic
sub_txt = text[match.start()+extra_offset : match.end()-extra_offset]
sub_offset = offset + extra_offset + mo.start()
self._highlightBoldEmphasis(sub_txt, cursor, bf, sub_offset, bold, emphasis)
for mo in re.finditer(self.MARKDOWN_KEYS_REGEX['Italic'],text):
recusive(mo, 1, bold, True)
found = True
for mo in re.finditer(self.MARKDOWN_KEYS_REGEX['uItalic'],text):
recusive(mo, 1, bold, True)
found = True
for mo in re.finditer(self.MARKDOWN_KEYS_REGEX['Bold'],text):
recusive(mo, 2, True, emphasis)
found = True
for mo in re.finditer(self.MARKDOWN_KEYS_REGEX['uBold'],text):
recusive(mo, 2, True, emphasis)
found = True
for mo in re.finditer(self.MARKDOWN_KEYS_REGEX['BoldItalic'],text):
apply(mo, True, True)
found = True
for mo in re.finditer(self.MARKDOWN_KEYS_REGEX['uBoldItalic'],text):
apply(mo, True, True)
found = True
return found
def highlightCodeBlock(self, text, cursor, bf):
found = False
for mo in re.finditer(self.MARKDOWN_KEYS_REGEX['CodeBlock'],text):
stripped = text.lstrip()
if stripped[0] not in ('*','-','+') and not re.match(self.MARKDOWN_KEYS_REGEX['OrderedList'], stripped):
self.setFormat(self.offset+ mo.start(), mo.end() - mo.start(), self.MARKDOWN_KWS_FORMAT['CodeBlock'])
found = True
return found
def highlightEntity(self, text, cursor, bf):
found = False
for mo in re.finditer(self.MARKDOWN_KEYS_REGEX['Entity'],text):
charformat = self.format(self.offset+ mo.start())
charbold = charformat.fontWeight() == QFont.Weight.Bold
charitalic = charformat.fontItalic()
if charbold and charitalic:
format = self.MARKDOWN_KWS_FORMAT['EntityBoldItalic']
elif charbold and not charitalic:
format = self.MARKDOWN_KWS_FORMAT['EntityBold']
elif not charbold and charitalic:
format = self.MARKDOWN_KWS_FORMAT['EntityItalic']
else:
format = self.MARKDOWN_KWS_FORMAT['Entity']
self.setFormat(self.offset+ mo.start(), mo.end() - mo.start(), format)
found = True
return found
def highlightHtml(self, text):
for mo in re.finditer(self.MARKDOWN_KEYS_REGEX['Html'], text):
self.setFormat(mo.start(), mo.end() - mo.start(), self.MARKDOWN_KWS_FORMAT['Html'])
| 14,924 | Python | .py | 280 | 42.857143 | 134 | 0.578125 | kovidgoyal/calibre | 19,243 | 2,250 | 4 | GPL-3.0 | 9/5/2024, 5:13:50 PM (Europe/Amsterdam) |
26,631 | throbber.py | kovidgoyal_calibre/src/calibre/gui2/throbber.py | #!/usr/bin/env python
__license__ = 'GPL v3'
__copyright__ = '2010, Kovid Goyal <kovid@kovidgoyal.net>'
__docformat__ = 'restructuredtext en'
from qt.core import (
QAbstractAnimation,
QIcon,
QMetaObject,
QPainter,
QPropertyAnimation,
QSize,
QSizePolicy,
QStyle,
QStyleOptionToolButton,
Qt,
QToolButton,
QWidget,
pyqtProperty,
)
from calibre.gui2 import config
class ThrobbingButton(QToolButton):
@pyqtProperty(int)
def icon_size(self):
return self._icon_size
@icon_size.setter
def icon_size(self, value):
self._icon_size = value
def __init__(self, *args):
QToolButton.__init__(self, *args)
# vertically size policy must be expanding for it to align inside a
# toolbar
self.setSizePolicy(QSizePolicy.Policy.Preferred, QSizePolicy.Policy.Expanding)
self._icon_size = -1
QToolButton.setIcon(self, QIcon.ic('donate.png'))
self.setText('\xa0')
self.animation = QPropertyAnimation(self, b'icon_size', self)
self.animation.setDuration(int(60/72.*1000))
self.animation.setLoopCount(4)
self.animation.valueChanged.connect(self.value_changed)
self.setCursor(Qt.CursorShape.PointingHandCursor)
self.animation.finished.connect(self.animation_finished)
def animation_finished(self):
self.icon_size = self.iconSize().width()
def enterEvent(self, ev):
self.start_animation()
def leaveEvent(self, ev):
self.stop_animation()
def value_changed(self, val):
self.update()
def start_animation(self):
if config['disable_animations']:
return
if self.animation.state() != QAbstractAnimation.State.Stopped or not self.isVisible():
return
size = self.iconSize().width()
if size < 1:
size = max(0, self.width() - 4)
smaller = int(0.7 * size)
self.animation.setStartValue(smaller)
self.animation.setEndValue(size)
QMetaObject.invokeMethod(self.animation, 'start', Qt.ConnectionType.QueuedConnection)
def stop_animation(self):
self.animation.stop()
self.animation_finished()
def paintEvent(self, ev):
size = self._icon_size if self._icon_size > 10 else self.iconSize().width()
size = size or max(0, self.width() - 4)
p = QPainter(self)
opt = QStyleOptionToolButton()
self.initStyleOption(opt)
s = self.style()
opt.iconSize = QSize(size, size)
s.drawComplexControl(QStyle.ComplexControl.CC_ToolButton, opt, p, self)
if __name__ == '__main__':
from qt.core import QApplication, QHBoxLayout
app = QApplication([])
w = QWidget()
w.setLayout(QHBoxLayout())
b = ThrobbingButton()
b.setIcon(QIcon.ic('donate.png'))
w.layout().addWidget(b)
w.show()
b.set_normal_icon_size(64, 64)
b.start_animation()
app.exec()
| 2,972 | Python | .py | 85 | 28.129412 | 94 | 0.653296 | kovidgoyal/calibre | 19,243 | 2,250 | 4 | GPL-3.0 | 9/5/2024, 5:13:50 PM (Europe/Amsterdam) |
26,632 | css_transform_rules.py | kovidgoyal_calibre/src/calibre/gui2/css_transform_rules.py | #!/usr/bin/env python
# License: GPLv3 Copyright: 2016, Kovid Goyal <kovid at kovidgoyal.net>
from qt.core import QComboBox, QDialogButtonBox, QHBoxLayout, QLabel, QLineEdit, QMenu, QPushButton, QSize, QTextCursor, QVBoxLayout, QWidget, pyqtSignal
from calibre.ebooks.css_transform_rules import (
ACTION_MAP,
MATCH_TYPE_MAP,
compile_rules,
export_rules,
import_rules,
safe_parser,
transform_sheet,
validate_rule,
)
from calibre.gui2 import choose_files, choose_save_file, elided_text, error_dialog
from calibre.gui2.tag_mapper import RuleEdit as RE
from calibre.gui2.tag_mapper import RuleEditDialog as RuleEditDialogBase
from calibre.gui2.tag_mapper import RuleItem as RuleItemBase
from calibre.gui2.tag_mapper import Rules as RulesBase
from calibre.gui2.tag_mapper import RulesDialog as RulesDialogBase
from calibre.gui2.tag_mapper import SaveLoadMixin
from calibre.gui2.widgets2 import Dialog
from calibre.utils.config import JSONConfig
from calibre.utils.localization import localize_user_manual_link
from polyglot.builtins import iteritems
class RuleEdit(QWidget): # {{{
MSG = _('Create the rule below, the rule can be used to transform style properties')
def __init__(self, parent=None):
QWidget.__init__(self, parent)
self.l = l = QVBoxLayout(self)
self.h = h = QHBoxLayout()
self.la = la = QLabel(self.MSG)
la.setWordWrap(True)
l.addWidget(la)
l.addLayout(h)
english_sentence = '{preamble} {property} {match_type} {query}'
sentence = _('{preamble} {property} {match_type} {query}')
if set(sentence.split()) != set(english_sentence.split()):
sentence = english_sentence
parts = sentence.split()
for clause in parts:
if clause == '{preamble}':
self.preamble = w = QLabel(_('If the &property:'))
elif clause == '{property}':
self.property = w = QLineEdit(self)
w.setToolTip(_('The name of a CSS property, for example: font-size\n'
'Do not use shorthand properties, they will not work.\n'
'For instance use margin-top, not margin.'))
elif clause == '{match_type}':
self.match_type = w = QComboBox(self)
for action, text in iteritems(MATCH_TYPE_MAP):
w.addItem(text, action)
w.currentIndexChanged.connect(self.update_state)
elif clause == '{query}':
self.query = w = QLineEdit(self)
h.addWidget(w)
if clause is not parts[-1]:
h.addWidget(QLabel('\xa0'))
self.preamble.setBuddy(self.property)
self.h2 = h = QHBoxLayout()
l.addLayout(h)
english_sentence = '{action} {action_data}'
sentence = _('{action} {action_data}')
if set(sentence.split()) != set(english_sentence.split()):
sentence = english_sentence
parts = sentence.split()
for clause in parts:
if clause == '{action}':
self.action = w = QComboBox(self)
for action, text in iteritems(ACTION_MAP):
w.addItem(text, action)
w.currentIndexChanged.connect(self.update_state)
elif clause == '{action_data}':
self.action_data = w = QLineEdit(self)
h.addWidget(w)
if clause is not parts[-1]:
h.addWidget(QLabel('\xa0'))
self.regex_help = la = QLabel('<p>' + RE.REGEXP_HELP_TEXT % localize_user_manual_link(
'https://manual.calibre-ebook.com/regexp.html'))
la.setOpenExternalLinks(True)
la.setWordWrap(True)
l.addWidget(la)
l.addStretch(10)
self.update_state()
def sizeHint(self):
a = QWidget.sizeHint(self)
a.setHeight(a.height() + 75)
a.setWidth(a.width() + 100)
return a
def update_state(self):
r = self.rule
self.action_data.setVisible(r['action'] != 'remove')
tt = _('The CSS property value')
mt = r['match_type']
self.query.setVisible(mt != '*')
if 'matches' in mt:
tt = _('A regular expression')
elif mt in '< > <= >='.split():
tt = _('Either a CSS length, such as 10pt or a unit less number. If a unit less'
' number is used it will be compared with the CSS value using whatever unit'
' the value has. Note that comparison automatically converts units, except'
' for relative units like percentage or em, for which comparison fails'
' if the units are different.')
self.query.setToolTip(tt)
tt = ''
ac = r['action']
if ac == 'append':
tt = _('CSS properties to add to the rule that contains the matching style. You'
' can specify more than one property, separated by semi-colons, for example:'
' color:red; font-weight: bold')
elif ac in '+=*/':
tt = _('A number')
self.action_data.setToolTip(tt)
self.regex_help.setVisible('matches' in mt)
@property
def rule(self):
return {
'property':self.property.text().strip().lower(),
'match_type': self.match_type.currentData(),
'query': self.query.text().strip(),
'action': self.action.currentData(),
'action_data': self.action_data.text().strip(),
}
@rule.setter
def rule(self, rule):
def sc(name):
c = getattr(self, name)
idx = c.findData(str(rule.get(name, '')))
if idx < 0:
idx = 0
c.setCurrentIndex(idx)
sc('action'), sc('match_type')
self.property.setText(str(rule.get('property', '')).strip())
self.query.setText(str(rule.get('query', '')).strip())
self.action_data.setText(str(rule.get('action_data', '')).strip())
self.update_state()
def validate(self):
rule = self.rule
title, msg = validate_rule(rule)
if msg is not None and title is not None:
error_dialog(self, title, msg, show=True)
return False
return True
# }}}
class RuleEditDialog(RuleEditDialogBase): # {{{
PREFS_NAME = 'edit-css-transform-rule'
DIALOG_TITLE = _('Edit rule')
RuleEditClass = RuleEdit
# }}}
class RuleItem(RuleItemBase): # {{{
@staticmethod
def text_from_rule(rule, parent):
try:
query = elided_text(rule['query'], font=parent.font(), width=200, pos='right')
text = _(
'If the property <i>{property}</i> <b>{match_type}</b> <b>{query}</b><br>{action}').format(
property=rule['property'], action=ACTION_MAP[rule['action']],
match_type=MATCH_TYPE_MAP[rule['match_type']], query=query)
if rule['action_data']:
ad = elided_text(rule['action_data'], font=parent.font(), width=200, pos='right')
text += ' <code>%s</code>' % ad
except Exception:
import traceback
traceback.print_exc()
text = _('This rule is invalid, please remove it')
return text
# }}}
class Rules(RulesBase): # {{{
RuleItemClass = RuleItem
RuleEditDialogClass = RuleEditDialog
MSG = _('You can specify rules to transform styles here. Click the "Add rule" button'
' below to get started.')
# }}}
class Tester(Dialog): # {{{
DIALOG_TITLE = _('Test style transform rules')
PREFS_NAME = 'test-style-transform-rules'
LABEL = _('Enter a CSS stylesheet below and click the "Test" button')
SYNTAX = 'css'
RESULTS = '/* %s */\n\n' % _('Resulting stylesheet')
def __init__(self, rules, parent=None):
self.rules = self.compile_rules(rules)
Dialog.__init__(self, self.DIALOG_TITLE, self.PREFS_NAME, parent=parent)
def compile_rules(self, rules):
return compile_rules(rules)
def setup_ui(self):
from calibre.gui2.tweak_book.editor.text import TextEdit
self.l = l = QVBoxLayout(self)
self.bb.setStandardButtons(QDialogButtonBox.StandardButton.Close)
self.la = la = QLabel(self.LABEL)
l.addWidget(la)
self.css = t = TextEdit(self)
t.load_text('', self.SYNTAX)
la.setBuddy(t)
c = t.textCursor()
c.movePosition(QTextCursor.MoveOperation.End)
t.setTextCursor(c)
self.h = h = QHBoxLayout()
l.addLayout(h)
h.addWidget(t)
self.test_button = b = QPushButton(_('&Test'), self)
b.clicked.connect(self.do_test)
h.addWidget(b)
self.result = la = TextEdit(self)
la.setReadOnly(True)
l.addWidget(la)
l.addWidget(self.bb)
@property
def value(self):
return self.css.toPlainText()
def do_test(self):
decl = safe_parser().parseString(self.value)
transform_sheet(self.rules, decl)
css = decl.cssText
if isinstance(css, bytes):
css = css.decode('utf-8')
self.set_result(css)
def set_result(self, css):
self.result.load_text(self.RESULTS + css, self.SYNTAX)
def sizeHint(self):
return QSize(800, 600)
# }}}
class RulesDialog(RulesDialogBase): # {{{
DIALOG_TITLE = _('Edit style transform rules')
PREFS_NAME = 'edit-style-transform-rules'
PREFS_OBJECT_NAME = 'style-transform-rules'
RulesClass = Rules
TesterClass = Tester
def __init__(self, *args, **kw):
# This has to be loaded on instantiation as it can be shared by
# multiple processes
self.PREFS_OBJECT = JSONConfig(self.PREFS_OBJECT_NAME)
RulesDialogBase.__init__(self, *args, **kw)
# }}}
class RulesWidget(QWidget, SaveLoadMixin): # {{{
changed = pyqtSignal()
PREFS_NAME = 'style-transform-rules'
INITIAL_FILE_NAME = 'css-rules.txt'
DIR_SAVE_NAME = 'export-style-transform-rules'
export_func = export_rules
import_func = import_rules
TesterClass = Tester
RulesClass = Rules
def __init__(self, parent=None):
self.loaded_ruleset = None
QWidget.__init__(self, parent)
self.PREFS_OBJECT = JSONConfig(self.PREFS_NAME)
l = QVBoxLayout(self)
self.rules_widget = w = self.RulesClass(self)
w.changed.connect(self.changed.emit)
l.addWidget(w)
self.h = h = QHBoxLayout()
l.addLayout(h)
self.export_button = b = QPushButton(_('E&xport'), self)
b.setToolTip(_('Export these rules to a file'))
b.clicked.connect(self.export_rules)
h.addWidget(b)
self.import_button = b = QPushButton(_('&Import'), self)
b.setToolTip(_('Import previously exported rules'))
b.clicked.connect(self.import_rules)
h.addWidget(b)
self.test_button = b = QPushButton(_('&Test rules'), self)
b.clicked.connect(self.test_rules)
h.addWidget(b)
h.addStretch(10)
self.save_button = b = QPushButton(_('&Save'), self)
b.setToolTip(_('Save this ruleset for later re-use'))
b.clicked.connect(self.save_ruleset)
h.addWidget(b)
self.load_button = b = QPushButton(_('&Load'), self)
self.load_menu = QMenu(self)
b.setMenu(self.load_menu)
b.setToolTip(_('Load a previously saved ruleset'))
b.clicked.connect(self.load_ruleset)
h.addWidget(b)
self.build_load_menu()
def export_rules(self):
rules = self.rules_widget.rules
if not rules:
return error_dialog(self, _('No rules'), _(
'There are no rules to export'), show=True)
path = choose_save_file(self, self.DIR_SAVE_NAME, _('Choose file for exported rules'), initial_filename=self.INITIAL_FILE_NAME)
if path:
f = self.__class__.export_func
raw = f(rules)
with open(path, 'wb') as f:
f.write(raw)
def import_rules(self):
paths = choose_files(self, self.DIR_SAVE_NAME, _('Choose file to import rules from'), select_only_single_file=True)
if paths:
func = self.__class__.import_func
with open(paths[0], 'rb') as f:
rules = func(f.read())
self.rules_widget.rules = list(rules) + list(self.rules_widget.rules)
self.changed.emit()
def load_ruleset(self, name):
SaveLoadMixin.load_ruleset(self, name)
self.changed.emit()
def test_rules(self):
self.TesterClass(self.rules_widget.rules, self).exec()
@property
def rules(self):
return self.rules_widget.rules
@rules.setter
def rules(self, val):
try:
self.rules_widget.rules = val or []
except Exception:
import traceback
traceback.print_exc()
self.rules_widget.rules = []
# }}}
if __name__ == '__main__':
from calibre.gui2 import Application
app = Application([])
d = RulesDialog()
d.rules = [
{'property':'color', 'match_type':'*', 'query':'', 'action':'change', 'action_data':'green'},
]
d.exec()
from pprint import pprint
pprint(d.rules)
del d, app
| 13,366 | Python | .py | 321 | 32.538941 | 153 | 0.599477 | kovidgoyal/calibre | 19,243 | 2,250 | 4 | GPL-3.0 | 9/5/2024, 5:13:50 PM (Europe/Amsterdam) |
26,633 | gestures.py | kovidgoyal_calibre/src/calibre/gui2/gestures.py | #!/usr/bin/env python
# License: GPLv3 Copyright: 2017, Kovid Goyal <kovid at kovidgoyal.net>
import os
from functools import lru_cache
from qt.core import QApplication, QEvent, QInputDevice, QMouseEvent, QObject, QPointF, QScroller, Qt, pyqtSignal
from calibre.startup import connect_lambda
from calibre.utils.monotonic import monotonic
from polyglot.builtins import itervalues
HOLD_THRESHOLD = 1.0 # seconds
TAP_THRESHOLD = 50 # manhattan pixels
Tap, TapAndHold, Flick = 'Tap', 'TapAndHold', 'Flick'
Left, Right, Up, Down = 'Left', 'Right', 'Up', 'Down'
@lru_cache(maxsize=2)
def touch_supported():
if 'CALIBRE_NO_TOUCH' in os.environ:
return False
for dev in QInputDevice.devices():
if dev.type() == QInputDevice.DeviceType.TouchScreen:
return True
return False
class TouchPoint:
def __init__(self, tp):
self.creation_time = self.last_update_time = self.time_of_last_move = monotonic()
self.start_screen_position = self.current_screen_position = self.previous_screen_position = QPointF(tp.globalPosition())
self.time_since_last_update = -1
self.total_movement = 0
self.start_position = self.current_position = tp.position()
self.extra_data = None
def update(self, tp):
self.current_position = tp.position()
now = monotonic()
self.time_since_last_update = now - self.last_update_time
self.last_update_time = now
self.previous_screen_position, self.current_screen_position = self.current_screen_position, QPointF(tp.globalPosition())
movement = (self.current_screen_position - self.previous_screen_position).manhattanLength()
self.total_movement += movement
if movement > 5:
self.time_of_last_move = now
class State(QObject):
tapped = pyqtSignal(object)
flicking = pyqtSignal(object, object)
tap_hold_started = pyqtSignal(object)
tap_hold_updated = pyqtSignal(object)
tap_hold_finished = pyqtSignal(object)
def __init__(self):
QObject.__init__(self)
self.clear()
def clear(self):
self.possible_gestures = set()
self.touch_points = {}
self.hold_started = False
self.hold_data = None
def start(self):
self.clear()
self.possible_gestures = {Tap, TapAndHold, Flick}
def update(self, ev, boundary='update'):
if boundary == 'cancel':
self.clear()
return
if boundary == 'start':
self.start()
for tp in ev.points():
tpid = tp.id()
if tpid not in self.touch_points:
self.touch_points[tpid] = TouchPoint(tp)
else:
self.touch_points[tpid].update(tp)
if len(self.touch_points) > 1:
self.possible_gestures.clear()
if boundary == 'end':
self.check_for_holds()
self.finalize()
self.clear()
else:
self.check_for_holds()
if Flick in self.possible_gestures:
tp = next(itervalues(self.touch_points))
self.flicking.emit(tp, False)
def check_for_holds(self):
if not {TapAndHold} & self.possible_gestures:
return
now = monotonic()
tp = next(itervalues(self.touch_points))
if now - tp.time_of_last_move < HOLD_THRESHOLD:
return
if self.hold_started:
if TapAndHold in self.possible_gestures:
self.tap_hold_updated.emit(tp)
else:
self.possible_gestures &= {TapAndHold}
if tp.total_movement > TAP_THRESHOLD:
self.possible_gestures.clear()
else:
self.possible_gestures = {TapAndHold}
self.hold_started = True
self.hold_data = now
self.tap_hold_started.emit(tp)
def finalize(self):
if Tap in self.possible_gestures:
tp = next(itervalues(self.touch_points))
if tp.total_movement <= TAP_THRESHOLD:
self.tapped.emit(tp)
return
if Flick in self.possible_gestures:
tp = next(itervalues(self.touch_points))
self.flicking.emit(tp, True)
if not self.hold_started:
return
if TapAndHold in self.possible_gestures:
tp = next(itervalues(self.touch_points))
self.tap_hold_finished.emit(tp)
return
def send_click(view, pos, button=Qt.MouseButton.LeftButton, double_click=False):
mods = QApplication.keyboardModifiers()
if double_click:
ev = QMouseEvent(QEvent.Type.MouseButtonDblClick, pos, button, button, mods)
QApplication.postEvent(view.viewport(), ev)
return
ev = QMouseEvent(QEvent.Type.MouseButtonPress, pos, button, button, mods)
QApplication.postEvent(view.viewport(), ev)
ev = QMouseEvent(QEvent.Type.MouseButtonRelease, pos, button, button, mods)
QApplication.postEvent(view.viewport(), ev)
class GestureManager(QObject):
def __init__(self, view):
QObject.__init__(self, view)
if touch_supported():
view.viewport().setAttribute(Qt.WidgetAttribute.WA_AcceptTouchEvents)
self.state = State()
self.last_touch_event_device_id = None
self.state.tapped.connect(
self.handle_tap,
type=Qt.ConnectionType.QueuedConnection) # has to be queued otherwise QApplication.keyboardModifiers() does not work
self.state.flicking.connect(self.handle_flicking)
connect_lambda(self.state.tap_hold_started, self, lambda self, tp: self.handle_tap_hold('start', tp))
connect_lambda(self.state.tap_hold_updated, self, lambda self, tp: self.handle_tap_hold('update', tp))
connect_lambda(self.state.tap_hold_finished, self, lambda self, tp: self.handle_tap_hold('end', tp))
self.evmap = {QEvent.Type.TouchBegin: 'start', QEvent.Type.TouchUpdate: 'update', QEvent.Type.TouchEnd: 'end', QEvent.Type.TouchCancel: 'cancel'}
self.last_tap_at = 0
if touch_supported():
self.scroller = QScroller.scroller(view.viewport())
def handle_event(self, ev):
if not touch_supported():
return
etype = ev.type()
if etype in (QEvent.Type.MouseButtonPress, QEvent.Type.MouseMove, QEvent.Type.MouseButtonRelease, QEvent.Type.MouseButtonDblClick):
if self.last_touch_event_device_id is not None and self.last_touch_event_device_id == ev.pointingDevice().uniqueId():
# swallow fake mouse events generated by the same device as the last touch event
ev.ignore()
return False
self.scroller.stop()
return
if etype == QEvent.Type.Wheel and self.scroller.state() != QScroller.State.Inactive:
ev.ignore()
return False
boundary = self.evmap.get(etype)
if boundary is None or ev.deviceType() != QInputDevice.DeviceType.TouchScreen:
return
self.last_touch_event_device_id = ev.pointingDevice().uniqueId()
self.state.update(ev, boundary=boundary)
ev.accept()
return True
def close_open_menu(self):
m = getattr(self.parent(), 'context_menu', None)
if m is not None and hasattr(m, 'isVisible') and m.isVisible():
m.close()
return True
def handle_flicking(self, touch_point, is_end):
if is_end:
it = QScroller.Input.InputRelease
else:
it = QScroller.Input.InputPress if touch_point.extra_data is None else QScroller.Input.InputMove
touch_point.extra_data = True
self.scroller.handleInput(it, touch_point.current_position, int(touch_point.last_update_time * 1000))
def handle_tap(self, tp):
self.scroller.stop()
last_tap_at, self.last_tap_at = self.last_tap_at, monotonic()
if self.close_open_menu():
return
interval = QApplication.instance().doubleClickInterval() / 1000
double_tap = self.last_tap_at - last_tap_at < interval
send_click(self.parent(), tp.start_position, double_click=double_tap)
def handle_tap_hold(self, action, tp):
self.scroller.stop()
if action == 'end':
send_click(self.parent(), tp.start_position, button=Qt.MouseButton.RightButton)
| 8,427 | Python | .py | 185 | 36.113514 | 153 | 0.638147 | kovidgoyal/calibre | 19,243 | 2,250 | 4 | GPL-3.0 | 9/5/2024, 5:13:50 PM (Europe/Amsterdam) |
26,634 | search_box.py | kovidgoyal_calibre/src/calibre/gui2/search_box.py | #!/usr/bin/env python
__license__ = 'GPL v3'
__copyright__ = '2009, Kovid Goyal <kovid@kovidgoyal.net>'
__docformat__ = 'restructuredtext en'
import re
import time
from functools import partial
from qt.core import QAction, QApplication, QComboBox, QCompleter, QDialog, QEvent, QIcon, QKeyEvent, QKeySequence, QLineEdit, Qt, QTimer, pyqtSignal, pyqtSlot
from calibre.gui2 import QT_HIDDEN_CLEAR_ACTION, config, gprefs, question_dialog
from calibre.gui2.dialogs.saved_search_editor import SavedSearchEditor
from calibre.gui2.dialogs.search import SearchDialog
from calibre.gui2.widgets import stylesheet_for_lineedit
from calibre.utils.icu import primary_sort_key
from calibre.utils.localization import pgettext
from polyglot.builtins import native_string_type, string_or_bytes
class AsYouType(str):
def __new__(cls, text):
self = str.__new__(cls, text)
self.as_you_type = True
return self
class SearchLineEdit(QLineEdit): # {{{
key_pressed = pyqtSignal(object)
clear_history = pyqtSignal()
select_on_mouse_press = None
as_url = None
def keyPressEvent(self, event):
self.key_pressed.emit(event)
QLineEdit.keyPressEvent(self, event)
def dropEvent(self, ev):
self.parent().normalize_state()
return QLineEdit.dropEvent(self, ev)
def contextMenuEvent(self, ev):
self.parent().normalize_state()
menu = self.createStandardContextMenu()
menu.setAttribute(Qt.WidgetAttribute.WA_DeleteOnClose)
ac = menu.addAction(_('Paste and &search'))
ac.setEnabled(bool(QApplication.clipboard().text()))
ac.setIcon(QIcon.ic('search.png'))
ac.triggered.connect(self.paste_and_search)
for action in menu.actions():
if action.text().startswith(_('&Paste') + '\t'):
menu.insertAction(action, ac)
break
else:
menu.addAction(ac)
menu.addSeparator()
ac = menu.addAction(_('Invert current search'))
ac.setEnabled(bool(self.text().strip()))
ac.setIcon(QIcon.ic('search.png'))
ac.triggered.connect(self.invert_search)
menu.addAction(ac)
menu.addSeparator()
if self.as_url is not None:
url = self.as_url(self.text())
if url:
menu.addAction(_('Copy search as URL'), lambda : QApplication.clipboard().setText(url))
menu.addAction(_('&Clear search history')).triggered.connect(self.clear_history)
menu.exec(ev.globalPos())
def invert_search(self):
q = self.text().strip()
if q:
if q.startswith('NOT ( ') and q.endswith(' )'):
q = q[6:-2]
else:
q = f'NOT ( {q} )'
self.setText(q)
ev = QKeyEvent(QEvent.Type.KeyPress, Qt.Key.Key_Enter, Qt.KeyboardModifier.NoModifier)
self.keyPressEvent(ev)
def paste_and_search(self):
self.paste()
ev = QKeyEvent(QEvent.Type.KeyPress, Qt.Key.Key_Enter, Qt.KeyboardModifier.NoModifier)
self.keyPressEvent(ev)
@pyqtSlot()
def paste(self, *args):
self.parent().normalize_state()
return QLineEdit.paste(self)
def focusInEvent(self, ev):
self.select_on_mouse_press = time.time()
return QLineEdit.focusInEvent(self, ev)
def mousePressEvent(self, ev):
QLineEdit.mousePressEvent(self, ev)
if self.select_on_mouse_press is not None and abs(time.time() - self.select_on_mouse_press) < 0.2:
self.selectAll()
self.select_on_mouse_press = None
# }}}
class SearchBox2(QComboBox): # {{{
'''
To use this class:
* Call initialize()
* Connect to the search() and cleared() signals from this widget.
* Connect to the changed() signal to know when the box content changes
* Connect to focus_to_library() signal to be told to manually change focus
* Call search_done() after every search is complete
* Call set_search_string() to perform a search programmatically
* You can use the current_text property to get the current search text
Be aware that if you are using it in a slot connected to the
changed() signal, if the connection is not queued it will not be
accurate.
'''
INTERVAL = 1500 #: Time to wait before emitting search signal
MAX_COUNT = 25
search = pyqtSignal(object)
cleared = pyqtSignal()
changed = pyqtSignal()
focus_to_library = pyqtSignal()
def __init__(self, parent=None, add_clear_action=True, as_url=None):
QComboBox.__init__(self, parent)
self.line_edit = SearchLineEdit(self)
self.line_edit.as_url = as_url
self.setLineEdit(self.line_edit)
self.line_edit.clear_history.connect(self.clear_history)
if add_clear_action:
self.lineEdit().setClearButtonEnabled(True)
ac = self.findChild(QAction, QT_HIDDEN_CLEAR_ACTION)
if ac is not None:
ac.triggered.connect(self.clear_clicked)
c = self.line_edit.completer()
c.setCompletionMode(QCompleter.CompletionMode.PopupCompletion)
c.highlighted[native_string_type].connect(self.completer_used)
self.line_edit.key_pressed.connect(self.key_pressed, type=Qt.ConnectionType.DirectConnection)
# QueuedConnection as workaround for https://bugreports.qt-project.org/browse/QTBUG-40807
self.textActivated.connect(self.history_selected, type=Qt.ConnectionType.QueuedConnection)
self.setEditable(True)
self.as_you_type = True
self.timer = QTimer()
self.timer.setSingleShot(True)
self.timer.timeout.connect(self.timer_event, type=Qt.ConnectionType.QueuedConnection)
self.setInsertPolicy(QComboBox.InsertPolicy.NoInsert)
self.setMaxCount(self.MAX_COUNT)
self.setSizeAdjustPolicy(QComboBox.SizeAdjustPolicy.AdjustToMinimumContentsLengthWithIcon)
self.setMinimumContentsLength(25)
self._in_a_search = False
self.tool_tip_text = self.toolTip()
self.parse_error_action = None
def add_action(self, icon, position=QLineEdit.ActionPosition.TrailingPosition):
if not isinstance(icon, QIcon):
icon = QIcon.ic(icon)
return self.lineEdit().addAction(icon, position)
def initialize(self, opt_name, colorize=False, help_text=_('Search'), as_you_type=None):
self.as_you_type = config['search_as_you_type'] if as_you_type is None else as_you_type
self.opt_name = opt_name
items = []
for item in config[opt_name]:
if item not in items:
items.append(item)
self.addItems(items)
self.line_edit.setPlaceholderText(help_text)
self.clear()
def clear_history(self):
config[self.opt_name] = []
super().clear()
self.clear()
clear_search_history = clear_history
def hide_completer_popup(self):
try:
self.lineEdit().completer().popup().setVisible(False)
except:
pass
def normalize_state(self):
self.setToolTip(self.tool_tip_text)
self.setStyleSheet('')
self.show_parse_error_action(False)
def text(self):
return self.currentText()
def clear(self, emit_search=True):
self.show_parse_error_action(False)
self.normalize_state()
self.setEditText('')
if emit_search:
self.search.emit('')
self._in_a_search = False
self.cleared.emit()
def clear_clicked(self, *args):
self.clear()
self.setFocus(Qt.FocusReason.OtherFocusReason)
def show_parse_error_action(self, to_show, tooltip=''):
if self.parse_error_action is not None:
self.parse_error_action.setVisible(to_show)
self.parse_error_action.setToolTip(tooltip)
def search_done(self, ok):
if isinstance(ok, string_or_bytes):
self.setToolTip(ok)
self.show_parse_error_action(True, tooltip=ok)
ok = False
if not str(self.currentText()).strip():
self.setStyleSheet('')
self.clear(emit_search=False)
return
self._in_a_search = ok
if self.parse_error_action is not None and not ok:
self.setStyleSheet(stylesheet_for_lineedit(bool(ok), 'QComboBox'))
else:
self.setStyleSheet('')
# Comes from the lineEdit control
def key_pressed(self, event):
k = event.key()
if k in (Qt.Key.Key_Left, Qt.Key.Key_Right, Qt.Key.Key_Up, Qt.Key.Key_Down,
Qt.Key.Key_Home, Qt.Key.Key_End, Qt.Key.Key_PageUp, Qt.Key.Key_PageDown,
Qt.Key.Key_unknown):
return
self.normalize_state()
if self._in_a_search:
self.changed.emit()
self._in_a_search = False
if event.key() in (Qt.Key.Key_Return, Qt.Key.Key_Enter):
self.do_search()
self.focus_to_library.emit()
elif self.as_you_type and str(event.text()):
self.timer.start(1500)
# Comes from the combobox itself
def keyPressEvent(self, event):
self.show_parse_error_action(False)
k = event.key()
if k in (Qt.Key.Key_Enter, Qt.Key.Key_Return):
return self.do_search()
if k not in (Qt.Key.Key_Up, Qt.Key.Key_Down):
return QComboBox.keyPressEvent(self, event)
self.blockSignals(True)
self.normalize_state()
if k == Qt.Key.Key_Down and self.currentIndex() == 0 and not self.lineEdit().text():
self.setCurrentIndex(1), self.setCurrentIndex(0)
event.accept()
else:
QComboBox.keyPressEvent(self, event)
self.blockSignals(False)
def completer_used(self, text):
self.timer.stop()
self.normalize_state()
def timer_event(self):
self._do_search(as_you_type=True)
# since this is an automatic search keep focus
self.setFocus(Qt.FocusReason.OtherFocusReason)
def history_selected(self, text):
self.changed.emit()
self.do_search()
def _do_search(self, store_in_history=True, as_you_type=False):
self.hide_completer_popup()
text = str(self.currentText()).strip()
if not text:
return self.clear()
if as_you_type:
text = AsYouType(text)
self.search.emit(text)
if store_in_history:
idx = self.findText(text, Qt.MatchFlag.MatchFixedString|Qt.MatchFlag.MatchCaseSensitive)
self.block_signals(True)
if idx < 0:
self.insertItem(0, text)
else:
t = self.itemText(idx)
self.removeItem(idx)
self.insertItem(0, t)
self.setCurrentIndex(0)
self.block_signals(False)
history = [str(self.itemText(i)) for i in
range(self.count())]
config[self.opt_name] = history
def do_search(self, *args):
self._do_search()
self.timer.stop()
def block_signals(self, yes):
self.blockSignals(yes)
self.line_edit.blockSignals(yes)
def set_search_string(self, txt, store_in_history=False, emit_changed=True):
if not store_in_history:
self.textActivated.disconnect()
try:
self.setFocus(Qt.FocusReason.OtherFocusReason)
if not txt:
self.clear()
else:
self.normalize_state()
# must turn on case sensitivity here so that tag browser strings
# are not case-insensitively replaced from history
self.line_edit.completer().setCaseSensitivity(Qt.CaseSensitivity.CaseSensitive)
self.setEditText(txt)
self.line_edit.end(False)
if emit_changed:
self.changed.emit()
self._do_search(store_in_history=store_in_history)
self.line_edit.completer().setCaseSensitivity(Qt.CaseSensitivity.CaseInsensitive)
self.focus_to_library.emit()
finally:
if not store_in_history:
# QueuedConnection as workaround for https://bugreports.qt-project.org/browse/QTBUG-40807
self.textActivated.connect(self.history_selected, type=Qt.ConnectionType.QueuedConnection)
def search_as_you_type(self, enabled):
self.as_you_type = enabled
def in_a_search(self):
return self._in_a_search
@property
def current_text(self):
return str(self.lineEdit().text())
# }}}
class SearchBoxMixin: # {{{
def __init__(self, *args, **kwargs):
pass
def init_search_box_mixin(self):
self.search.initialize('main_search_history',
help_text=_('Search (For advanced search click the gear icon to the left)'))
self.search.cleared.connect(self.search_box_cleared)
# Queued so that search.current_text will be correct
self.search.changed.connect(self.search_box_changed,
type=Qt.ConnectionType.QueuedConnection)
self.search.focus_to_library.connect(self.focus_to_library)
self.advanced_search_toggle_action.triggered.connect(self.do_advanced_search)
self.search.clear()
self.search.setMaximumWidth(self.width()-150)
self.action_focus_search = QAction(self)
shortcuts = list(
map(lambda x:str(x.toString(QKeySequence.SequenceFormat.PortableText)),
QKeySequence.keyBindings(QKeySequence.StandardKey.Find)))
shortcuts += ['/', 'Alt+S']
self.keyboard.register_shortcut('start search', _('Start search'),
default_keys=shortcuts, action=self.action_focus_search)
self.action_focus_search.triggered.connect(self.focus_search_box)
self.addAction(self.action_focus_search)
self.search.setStatusTip(re.sub(r'<\w+>', ' ',
str(self.search.toolTip())))
self.set_highlight_only_button_icon()
self.highlight_only_button.clicked.connect(self.highlight_only_clicked)
tt = _('Enable or disable search highlighting.') + '<br><br>'
tt += config.help('highlight_search_matches')
self.highlight_only_button.setToolTip(tt)
self.highlight_only_action = ac = QAction(self)
self.addAction(ac), ac.triggered.connect(self.highlight_only_clicked)
self.keyboard.register_shortcut('highlight search results', _('Highlight search results'), action=self.highlight_only_action)
self.refresh_search_bar_widgets()
def refresh_search_bar_widgets(self):
self.set_highlight_only_button_icon()
if gprefs['search_tool_bar_shows_text']:
self.search_bar.search_button.setText(_('Search'))
self.search_bar.search_button.setToolButtonStyle(Qt.ToolButtonStyle.ToolButtonTextBesideIcon)
else:
self.search_bar.search_button.setText(None)
self.search_bar.search_button.setToolButtonStyle(Qt.ToolButtonStyle.ToolButtonIconOnly)
def highlight_only_clicked(self, state):
if not config['highlight_search_matches'] and not question_dialog(self, _('Are you sure?'),
_('This will change how searching works. When you search, instead of showing only the '
'matching books, all books will be shown with the matching books highlighted. '
'Are you sure this is what you want?'), skip_dialog_name='confirm_search_highlight_toggle'):
return
config['highlight_search_matches'] = not config['highlight_search_matches']
self.set_highlight_only_button_icon()
self.search.do_search()
self.focus_to_library()
def set_highlight_only_button_icon(self):
b = self.highlight_only_button
if config['highlight_search_matches']:
b.setIcon(QIcon.ic('highlight_only_on.png'))
if gprefs['search_tool_bar_shows_text']:
b.setText(_('Filter'))
b.setToolButtonStyle(Qt.ToolButtonStyle.ToolButtonTextBesideIcon)
else:
b.setText(None)
b.setToolButtonStyle(Qt.ToolButtonStyle.ToolButtonIconOnly)
else:
b.setIcon(QIcon.ic('highlight_only_off.png'))
if gprefs['search_tool_bar_shows_text']:
b.setText(pgettext('mark books matching search result instead of filtering them', 'Highlight'))
b.setToolButtonStyle(Qt.ToolButtonStyle.ToolButtonTextBesideIcon)
else:
b.setText(None)
b.setToolButtonStyle(Qt.ToolButtonStyle.ToolButtonIconOnly)
self.highlight_only_button.setVisible(gprefs['show_highlight_toggle_button'])
self.library_view.model().set_highlight_only(config['highlight_search_matches'])
def focus_search_box(self, *args):
self.search.setFocus(Qt.FocusReason.OtherFocusReason)
self.search.lineEdit().selectAll()
def search_box_cleared(self):
self.tags_view.clear()
self.set_number_of_books_shown()
def search_box_changed(self):
self.tags_view.conditional_clear(self.search.current_text)
def do_advanced_search(self, *args):
d = SearchDialog(self, self.library_view.model().db)
if d.exec() == QDialog.DialogCode.Accepted:
self.search.set_search_string(d.search_string(), store_in_history=True)
def do_search_button(self):
self.search.do_search()
self.focus_to_library()
def focus_to_library(self):
self.current_view().setFocus(Qt.FocusReason.OtherFocusReason)
# }}}
class SavedSearchBoxMixin: # {{{
def __init__(self, *args, **kwargs):
pass
def init_saved_seach_box_mixin(self):
pass
def add_saved_searches_to_menu(self, menu, db, add_action_func=None):
def add_action(current_menu, whole_name, last_component, func=None):
if add_action_func is None:
return current_menu.addAction(last_component, func)
return add_action_func(current_menu, whole_name, last_component)
folder_icon = QIcon.ic('folder_saved_search.png')
search_icon = QIcon.ic('search.png')
use_hierarchy = 'search' in db.new_api.pref('categories_using_hierarchy', [])
submenus = {}
for name in sorted(db.saved_search_names(), key=lambda x: primary_sort_key(x.strip())):
display_name = name.replace('&', '&&')
current_menu = menu
if use_hierarchy:
components = tuple(n.strip() for n in name.split('.'))
hierarchy = components[:-1]
last = components[-1]
# Walk the hierarchy, creating submenus as needed
for i,c in enumerate(hierarchy, start=1):
hierarchical_prefix = '.'.join(hierarchy[:i])
if hierarchical_prefix not in submenus:
current_menu = current_menu.addMenu(c.replace('&', '&&'))
current_menu.setIcon(folder_icon)
submenus[hierarchical_prefix] = current_menu
else:
current_menu = submenus[hierarchical_prefix]
ac = add_action(current_menu, display_name, last.replace('&', '&&'),
partial(self.search.set_search_string, 'search:"='+name+'"'))
else:
ac = add_action(current_menu, display_name, display_name,
partial(self.search.set_search_string, 'search:"='+name+'"'))
if ac.icon().isNull():
ac.setIcon(search_icon)
def populate_add_saved_search_menu(self, to_menu):
m = to_menu
m.clear()
m.addAction(QIcon.ic('search_add_saved.png'), _('Add Saved search'), self.add_saved_search)
m.addAction(QIcon.ic('search_copy_saved.png'), _('Get Saved search expression'),
self.get_saved_search_text)
m.addAction(QIcon.ic('folder_saved_search.png'), _('Manage Saved searches'),
partial(self.do_saved_search_edit, None))
m.addSeparator()
self.add_saved_searches_to_menu(m, self.current_db)
def saved_searches_changed(self, set_restriction=None, recount=True):
self.build_search_restriction_list()
if recount:
self.tags_view.recount()
if set_restriction: # redo the search restriction if there was one
self.apply_named_search_restriction(set_restriction)
def do_saved_search_edit(self, search):
d = SavedSearchEditor(self, search)
d.exec()
if d.result() == QDialog.DialogCode.Accepted:
self.do_rebuild_saved_searches()
def do_rebuild_saved_searches(self):
self.saved_searches_changed()
def add_saved_search(self):
from calibre.gui2.dialogs.saved_search_editor import AddSavedSearch
d = AddSavedSearch(parent=self, search=self.search.current_text)
if d.exec() == QDialog.DialogCode.Accepted:
self.current_db.new_api.ensure_has_search_category(fail_on_existing=False)
self.do_rebuild_saved_searches()
def get_saved_search_text(self, search_name=None):
db = self.current_db
try:
current_search = search_name if search_name else self.search.currentText()
if not current_search.startswith('search:'):
raise ValueError()
# This strange expression accounts for the four ways a search can be written:
# search:fff, search:"fff", search:"=fff". and search:="fff"
current_search = current_search[7:].lstrip('=').strip('"').lstrip('=')
current_search = db.saved_search_lookup(current_search)
if not current_search:
raise ValueError()
self.search.set_search_string(current_search)
except:
from calibre.gui2.ui import get_gui
get_gui().status_bar.show_message(_('Current search is not a saved search'), 3000)
# }}}
| 22,248 | Python | .py | 467 | 37.368308 | 158 | 0.632724 | kovidgoyal/calibre | 19,243 | 2,250 | 4 | GPL-3.0 | 9/5/2024, 5:13:50 PM (Europe/Amsterdam) |
26,635 | layout_menu.py | kovidgoyal_calibre/src/calibre/gui2/layout_menu.py | #!/usr/bin/env python
# License: GPLv3 Copyright: 2017, Kovid Goyal <kovid at kovidgoyal.net>
from qt.core import QFontMetrics, QHBoxLayout, QIcon, QMenu, QPushButton, QSize, QSizePolicy, QStyle, QStyleOption, QStylePainter, Qt, QWidget
ICON_SZ = 64
class LayoutItem(QWidget):
mouse_over = False
def __init__(self, button, parent=None):
QWidget.__init__(self, parent)
self.setSizePolicy(QSizePolicy.Policy.Fixed, QSizePolicy.Policy.Fixed)
self.button = button
self.text = button.label
self.setCursor(Qt.CursorShape.PointingHandCursor)
self.fm = QFontMetrics(self.font())
self._bi = self._di = None
def update_tips(self):
self.setToolTip(self.button.toolTip())
self.setStatusTip(self.button.statusTip())
@property
def bright_icon(self):
if self._bi is None:
self._bi = self.button.icon().pixmap(ICON_SZ, ICON_SZ)
return self._bi
@property
def dull_icon(self):
if self._di is None:
self._di = self.button.icon().pixmap(ICON_SZ, ICON_SZ, mode=QIcon.Mode.Disabled)
return self._di
def enterEvent(self, ev):
super().enterEvent(ev)
if not self.mouse_over:
self.mouse_over = True
self.update()
def leaveEvent(self, ev):
super().leaveEvent(ev)
if self.mouse_over:
self.mouse_over = False
self.update()
def sizeHint(self):
br = self.fm.boundingRect(self.text)
w = max(br.width(), ICON_SZ) + 10
h = 2 * self.fm.lineSpacing() + ICON_SZ + 8
return QSize(w, h)
def paintEvent(self, ev):
shown = self.button.isChecked()
ls = self.fm.lineSpacing()
painter = QStylePainter(self)
if self.mouse_over:
tool = QStyleOption()
tool.initFrom(self)
tool.rect = self.rect()
tool.state = QStyle.StateFlag.State_Raised | QStyle.StateFlag.State_Active | QStyle.StateFlag.State_MouseOver
painter.drawPrimitive(QStyle.PrimitiveElement.PE_PanelButtonTool, tool)
painter.drawText(
0, 0,
self.width(),
ls, Qt.AlignmentFlag.AlignCenter | Qt.TextFlag.TextSingleLine, self.text)
text = _('Hide') if shown else _('Show')
f = self.font()
f.setBold(True)
painter.setFont(f)
painter.drawText(
0, self.height() - ls,
self.width(),
ls, Qt.AlignmentFlag.AlignCenter | Qt.TextFlag.TextSingleLine, text)
x = (self.width() - ICON_SZ) // 2
y = ls + (self.height() - ICON_SZ - 2 * ls) // 2
pmap = self.bright_icon if shown else self.dull_icon
painter.drawPixmap(x, y, pmap)
painter.end()
class LayoutMenu(QMenu):
def __init__(self, parent=None):
QMenu.__init__(self, parent)
self.l = l = QHBoxLayout(self)
l.setSpacing(20)
self.items = []
if parent is None:
buttons = [
QPushButton(QIcon.ic(i + '.png'), i, self)
for i in 'search tags cover_flow grid book'.split()]
for b in buttons:
b.setVisible(False), b.setCheckable(True), b.setChecked(b.text() in 'tags grid')
b.label = b.text().capitalize()
else:
buttons = parent.layout_buttons
for b in buttons:
self.items.append(LayoutItem(b, self))
l.addWidget(self.items[-1])
self.aboutToShow.connect(self.about_to_show)
self.current_item = None
def about_to_show(self):
for x in self.items:
x.update_tips()
def sizeHint(self):
return QWidget.sizeHint(self)
def paintEvent(self, ev):
return QWidget.paintEvent(self, ev)
def item_for_ev(self, ev):
for item in self.items:
if item.geometry().contains(ev.pos()):
return item
def mousePressEvent(self, ev):
if ev.button() != Qt.MouseButton.LeftButton:
ev.ignore()
return
if (ev.pos().isNull() and not ev.screenPos().isNull()) or not self.rect().contains(ev.pos()):
self.hide()
self.current_item = self.item_for_ev(ev)
if self.current_item is not None:
ev.accept()
else:
ev.ignore()
def mouseReleaseEvent(self, ev):
if ev.button() != Qt.MouseButton.LeftButton:
ev.ignore()
return
item = self.item_for_ev(ev)
if item is not None and item is self.current_item:
ev.accept()
self.hide()
item.button.click()
if __name__ == '__main__':
from calibre.gui2 import Application
app = Application([])
w = LayoutMenu()
w.show()
w.exec()
| 4,830 | Python | .py | 126 | 28.880952 | 142 | 0.587091 | kovidgoyal/calibre | 19,243 | 2,250 | 4 | GPL-3.0 | 9/5/2024, 5:13:50 PM (Europe/Amsterdam) |
26,636 | publisher_mapper.py | kovidgoyal_calibre/src/calibre/gui2/publisher_mapper.py | #!/usr/bin/env python
# License: GPL v3 Copyright: 2018, Kovid Goyal <kovid at kovidgoyal.net>
from collections import OrderedDict
from calibre.ebooks.metadata.tag_mapper import map_tags
from calibre.gui2 import Application, elided_text
from calibre.gui2.tag_mapper import RuleEdit as RuleEditBase
from calibre.gui2.tag_mapper import RuleEditDialog as RuleEditDialogBase
from calibre.gui2.tag_mapper import RuleItem as RuleItemBase
from calibre.gui2.tag_mapper import Rules as RulesBase
from calibre.gui2.tag_mapper import RulesDialog as RulesDialogBase
from calibre.gui2.tag_mapper import Tester as TesterBase
from calibre.utils.config import JSONConfig
publisher_maps = JSONConfig('publisher-mapping-rules')
class RuleEdit(RuleEditBase):
ACTION_MAP = OrderedDict((
('replace', _('Change')),
('capitalize', _('Capitalize')),
('titlecase', _('Title-case')),
('lower', _('Lower-case')),
('upper', _('Upper-case')),
))
MATCH_TYPE_MAP = OrderedDict((
('one_of', _('is one of')),
('not_one_of', _('is not one of')),
('has', _('contains')),
('matches', _('matches regex pattern')),
('not_matches', _('does not match regex pattern')),
))
MSG = _('Create the rule below, the rule can be used to modify publishers')
SUBJECT = _('the publisher, if the publisher name')
VALUE_ERROR = _('You must provide a value for the publisher name to match')
REPLACE_TEXT = _('with the name:')
SINGLE_EDIT_FIELD_NAME = 'publisher'
@property
def can_use_tag_editor(self):
return False
def update_state(self):
a = self.action.currentData()
replace = a == 'replace'
self.la3.setVisible(replace), self.replace.setVisible(replace)
m = self.match_type.currentData()
is_match = 'matches' in m
self.regex_help.setVisible(is_match)
@property
def rule(self):
return {
'action': self.action.currentData(),
'match_type': self.match_type.currentData(),
'query': self.query.text().strip(),
'replace': self.replace.text().strip(),
}
@rule.setter
def rule(self, rule):
def sc(name):
c = getattr(self, name)
idx = c.findData(str(rule.get(name, '')))
if idx < 0:
idx = 0
c.setCurrentIndex(idx)
sc('match_type'), sc('action')
self.query.setText(str(rule.get('query', '')).strip())
self.replace.setText(str(rule.get('replace', '')).strip())
class RuleEditDialog(RuleEditDialogBase):
PREFS_NAME = 'edit-publisher-mapping-rule'
RuleEditClass = RuleEdit
class RuleItem(RuleItemBase):
@staticmethod
def text_from_rule(rule, parent):
query = elided_text(rule['query'], font=parent.font(), width=200, pos='right')
text = _(
'<b>{action}</b> the publisher name, if it <i>{match_type}</i>: <b>{query}</b>').format(
action=RuleEdit.ACTION_MAP[rule['action']], match_type=RuleEdit.MATCH_TYPE_MAP[rule['match_type']], query=query)
if rule['action'] == 'replace':
text += '<br>' + _('to the name') + ' <b>%s</b>' % rule['replace']
return '<div style="white-space: nowrap">' + text + '</div>'
class Rules(RulesBase):
RuleItemClass = RuleItem
RuleEditDialogClass = RuleEditDialog
MSG = _('You can specify rules to manipulate publisher names here.'
' Click the "Add Rule" button'
' below to get started. The rules will be processed in order for every publisher.')
class Tester(TesterBase):
DIALOG_TITLE = _('Test publisher mapping rules')
PREFS_NAME = 'test-publisher-mapping-rules'
LABEL = _('Enter a publisher name to test:')
PLACEHOLDER = _('Enter publisher and click the "Test" button')
EMPTY_RESULT = '<p> </p>'
def do_test(self):
publisher = self.value.strip()
ans = map_tags([publisher], self.rules)
self.result.setText((ans or ('',))[0])
class RulesDialog(RulesDialogBase):
DIALOG_TITLE = _('Edit publisher mapping rules')
PREFS_NAME = 'edit-publisher-mapping-rules'
RulesClass = Rules
TesterClass = Tester
PREFS_OBJECT = publisher_maps
if __name__ == '__main__':
app = Application([])
d = RulesDialog()
d.rules = [
{'action':'replace', 'query':'alice Bob', 'match_type':'one_of', 'replace':'Alice Bob'},
]
d.exec()
from pprint import pprint
pprint(d.rules)
del d, app
| 4,551 | Python | .py | 107 | 35.672897 | 128 | 0.636075 | kovidgoyal/calibre | 19,243 | 2,250 | 4 | GPL-3.0 | 9/5/2024, 5:13:50 PM (Europe/Amsterdam) |
26,637 | extra_files_watcher.py | kovidgoyal_calibre/src/calibre/gui2/extra_files_watcher.py | #!/usr/bin/env python
# License: GPLv3 Copyright: 2023, Kovid Goyal <kovid at kovidgoyal.net>
from time import monotonic
from typing import NamedTuple, Tuple
from qt.core import QObject, QTimer
from calibre.db.constants import DATA_FILE_PATTERN
class ExtraFile(NamedTuple):
relpath: str
mtime: float
size: int
class ExtraFiles(NamedTuple):
last_changed_at: float
files: Tuple[ExtraFile, ...]
class ExtraFilesWatcher(QObject):
WATCH_FOR = 300 # seconds
TICK_INTERVAL = 1 # seconds
def __init__(self, parent=None):
super().__init__(parent)
self.watched_book_ids = {}
self.timer = QTimer(self)
self.timer.setInterval(int(self.TICK_INTERVAL * 1000))
self.timer.timeout.connect(self.check_registered_books)
def clear(self):
self.watched_book_ids.clear()
self.timer.stop()
def watch_book(self, book_id):
if book_id not in self.watched_book_ids:
try:
self.watched_book_ids[book_id] = ExtraFiles(monotonic(), self.get_extra_files(book_id))
except Exception:
import traceback
traceback.print_exc()
return
self.timer.start()
@property
def gui(self):
ans = self.parent()
if hasattr(ans, 'current_db'):
return ans
from calibre.gui2.ui import get_gui
return get_gui()
def get_extra_files(self, book_id):
db = self.gui.current_db.new_api
return tuple(ExtraFile(ef.relpath, ef.stat_result.st_mtime, ef.stat_result.st_size) for
ef in db.list_extra_files(book_id, pattern=DATA_FILE_PATTERN))
def check_registered_books(self):
changed = {}
remove = set()
now = monotonic()
for book_id, extra_files in self.watched_book_ids.items():
try:
ef = self.get_extra_files(book_id)
except Exception:
# book probably deleted
remove.add(book_id)
continue
if ef != extra_files.files:
changed[book_id] = ef
elif now - extra_files.last_changed_at > self.WATCH_FOR:
remove.add(book_id)
if changed:
self.refresh_gui(changed)
for book_id, files in changed.items():
self.watched_book_ids[book_id] = self.watched_book_ids[book_id]._replace(files=files, last_changed_at=now)
for book_id in remove:
self.watched_book_ids.pop(book_id, None)
if not self.watched_book_ids:
self.timer.stop()
def refresh_gui(self, book_ids):
lv = self.gui.library_view
lv.model().refresh_ids(frozenset(book_ids), current_row=lv.currentIndex().row())
| 2,789 | Python | .py | 71 | 29.84507 | 122 | 0.61 | kovidgoyal/calibre | 19,243 | 2,250 | 4 | GPL-3.0 | 9/5/2024, 5:13:50 PM (Europe/Amsterdam) |
26,638 | keyboard.py | kovidgoyal_calibre/src/calibre/gui2/keyboard.py | #!/usr/bin/env python
__license__ = 'GPL v3'
__copyright__ = '2011, Kovid Goyal <kovid@kovidgoyal.net>'
__docformat__ = 'restructuredtext en'
from collections import OrderedDict
from functools import partial
from qt.core import (
QAbstractItemDelegate,
QAbstractItemModel,
QAbstractItemView,
QApplication,
QEvent,
QFrame,
QGridLayout,
QHBoxLayout,
QIcon,
QItemSelectionModel,
QKeyCombination,
QKeySequence,
QLabel,
QMenu,
QModelIndex,
QObject,
QPushButton,
QRadioButton,
QRectF,
QSize,
QStyle,
QStyledItemDelegate,
Qt,
QTextDocument,
QToolButton,
QTreeView,
QVBoxLayout,
QWidget,
pyqtSignal,
sip,
)
from calibre import prepare_string_for_xml, prints
from calibre.constants import DEBUG
from calibre.gui2 import error_dialog, info_dialog
from calibre.gui2.search_box import SearchBox2
from calibre.utils.config import JSONConfig
from calibre.utils.icu import lower, sort_key
from calibre.utils.localization import pgettext
from calibre.utils.search_query_parser import ParseException, SearchQueryParser
from polyglot.builtins import iteritems, itervalues
ROOT = QModelIndex()
class NameConflict(ValueError):
pass
def keysequence_from_event(ev): # {{{
k, mods = ev.keyCombination().key(), ev.modifiers()
if k in (
0, Qt.Key.Key_unknown, Qt.Key.Key_Shift, Qt.Key.Key_Control, Qt.Key.Key_Alt,
Qt.Key.Key_Meta, Qt.Key.Key_AltGr, Qt.Key.Key_CapsLock, Qt.Key.Key_NumLock,
Qt.Key.Key_ScrollLock):
return
letter = QKeySequence(k).toString(QKeySequence.SequenceFormat.PortableText)
if mods & Qt.KeyboardModifier.ShiftModifier and letter.lower() == letter.upper():
# Something like Shift+* or Shift+> we have to remove the shift,
# since it is included in keycode.
mods = mods & ~Qt.KeyboardModifier.ShiftModifier
return QKeySequence(QKeyCombination(mods, k))
# }}}
def finalize(shortcuts, custom_keys_map={}): # {{{
'''
Resolve conflicts and assign keys to every action in shortcuts, which must
be a OrderedDict. User specified mappings of unique names to keys (as a
list of strings) should be passed in custom_keys_map. Return a mapping
of unique names to resolved keys. Also sets the set_to_default member
correctly for each shortcut.
'''
seen, keys_map = {}, {}
for unique_name, shortcut in iteritems(shortcuts):
custom_keys = custom_keys_map.get(unique_name, None)
if custom_keys is None:
candidates = shortcut['default_keys']
shortcut['set_to_default'] = True
else:
candidates = custom_keys
shortcut['set_to_default'] = False
keys = []
for x in candidates:
ks = QKeySequence(x, QKeySequence.SequenceFormat.PortableText)
x = str(ks.toString(QKeySequence.SequenceFormat.PortableText))
if x in seen:
if DEBUG:
prints('Key %r for shortcut %s is already used by'
' %s, ignoring'%(x, shortcut['name'], seen[x]['name']))
keys_map[unique_name] = ()
continue
seen[x] = shortcut
keys.append(ks)
keys = tuple(keys)
keys_map[unique_name] = keys
ac = shortcut['action']
if ac is None or sip.isdeleted(ac):
if ac is not None and DEBUG:
prints('Shortcut %r has a deleted action' % unique_name)
continue
ac.setShortcuts(list(keys))
return keys_map
# }}}
class Manager(QObject): # {{{
def __init__(self, parent=None, config_name='shortcuts/main'):
QObject.__init__(self, parent)
self.config = JSONConfig(config_name)
self.shortcuts = OrderedDict()
self.keys_map = {}
self.groups = {}
def register_shortcut(self, unique_name, name, default_keys=(),
description=None, action=None, group=None, persist_shortcut=False):
'''
Register a shortcut with calibre. calibre will manage the shortcut,
automatically resolving conflicts and allowing the user to customize
it.
:param unique_name: A string that uniquely identifies this shortcut
:param name: A user visible name describing the action performed by
this shortcut
:param default_keys: A tuple of keys that trigger this shortcut. Each
key must be a string. For example: ('Ctrl+A', 'Alt+B', 'C',
'Shift+Meta+D'). These keys will be assigned to the
shortcut unless there is a conflict.
:param action: A QAction object. The shortcut will cause this QAction
to be triggered. Connect to its triggered signal in your code to
respond to the shortcut.
:param group: A string describing what "group" this shortcut belongs
to. This is used to organize the list of shortcuts when the user is
customizing them.
:persist_shortcut: Shortcuts for actions that don't always
appear, or are library dependent, may disappear when other
keyboard shortcuts are edited unless ```persist_shortcut``` is
set True.
'''
if unique_name in self.shortcuts:
name = self.shortcuts[unique_name]['name']
raise NameConflict('Shortcut for %r already registered by %s'%(
unique_name, name))
shortcut = {'name':name, 'desc':description, 'action': action,
'default_keys':tuple(default_keys),
'persist_shortcut':persist_shortcut}
self.shortcuts[unique_name] = shortcut
group = group if group else pgettext('keyboard shortcuts', _('Miscellaneous'))
self.groups[group] = self.groups.get(group, []) + [unique_name]
def unregister_shortcut(self, unique_name):
'''
Remove a registered shortcut. You need to call finalize() after you are
done unregistering.
'''
self.shortcuts.pop(unique_name, None)
for group in itervalues(self.groups):
try:
group.remove(unique_name)
except ValueError:
pass
def finalize(self):
custom_keys_map = {un:tuple(keys) for un, keys in iteritems(self.config.get(
'map', {}))}
self.keys_map = finalize(self.shortcuts, custom_keys_map=custom_keys_map)
def replace_action(self, unique_name, new_action):
'''
Replace the action associated with a shortcut.
Once you're done calling replace_action() for all shortcuts you want
replaced, call finalize() to have the shortcuts assigned to the replaced
actions.
'''
sc = self.shortcuts[unique_name]
sc['action'] = new_action
# }}}
# Model {{{
class Node:
def __init__(self, group_map, shortcut_map, name=None, shortcut=None):
self.data = name if name is not None else shortcut
self.is_shortcut = shortcut is not None
self.children = []
if name is not None:
self.children = [Node(None, None, shortcut=shortcut_map[uname])
for uname in group_map[name]]
def __len__(self):
return len(self.children)
def __getitem__(self, row):
return self.children[row]
def __iter__(self):
yield from self.children
class ConfigModel(SearchQueryParser, QAbstractItemModel):
def __init__(self, keyboard, parent=None):
QAbstractItemModel.__init__(self, parent)
SearchQueryParser.__init__(self, ['all'])
self.keyboard = keyboard
groups = sorted(keyboard.groups, key=sort_key)
shortcut_map = {k:v.copy() for k, v in
iteritems(self.keyboard.shortcuts)}
for un, s in iteritems(shortcut_map):
s['keys'] = tuple(self.keyboard.keys_map.get(un, ()))
s['unique_name'] = un
s['group'] = [g for g, names in iteritems(self.keyboard.groups) if un in
names][0]
group_map = {group:sorted(names, key=lambda x:
sort_key(shortcut_map[x]['name'])) for group, names in
iteritems(self.keyboard.groups)}
self.data = [Node(group_map, shortcut_map, group) for group in groups]
@property
def all_shortcuts(self):
for group in self.data:
yield from group
def rowCount(self, parent=ROOT):
ip = parent.internalPointer()
if ip is None:
return len(self.data)
return len(ip)
def columnCount(self, parent=ROOT):
return 1
def index(self, row, column, parent=ROOT):
ip = parent.internalPointer()
if ip is None:
ip = self.data
try:
return self.createIndex(row, column, ip[row])
except:
pass
return ROOT
def parent(self, index):
ip = index.internalPointer()
if ip is None or not ip.is_shortcut:
return ROOT
group = ip.data['group']
for i, g in enumerate(self.data):
if g.data == group:
return self.index(i, 0)
return ROOT
def data(self, index, role=Qt.ItemDataRole.DisplayRole):
ip = index.internalPointer()
if ip is not None and role == Qt.ItemDataRole.UserRole:
return ip
return None
def flags(self, index):
ans = QAbstractItemModel.flags(self, index)
ip = index.internalPointer()
if getattr(ip, 'is_shortcut', False):
ans |= Qt.ItemFlag.ItemIsEditable
return ans
def restore_defaults(self):
shortcut_map = {}
for node in self.all_shortcuts:
sc = node.data
shortcut_map[sc['unique_name']] = sc
shortcuts = OrderedDict([(un, shortcut_map[un]) for un in
self.keyboard.shortcuts])
keys_map = finalize(shortcuts)
for node in self.all_shortcuts:
s = node.data
s['keys'] = tuple(keys_map[s['unique_name']])
for r in range(self.rowCount()):
group = self.index(r, 0)
num = self.rowCount(group)
if num > 0:
self.dataChanged.emit(self.index(0, 0, group),
self.index(num-1, 0, group))
def commit(self):
kmap = {}
# persist flags not in map for back compat
# not *just* persist flag for forward compat
options_map = {}
options_map.update(self.keyboard.config.get('options_map', {}))
# keep mapped keys that are marked persistent.
for un, keys in iteritems(self.keyboard.config.get('map', {})):
if options_map.get(un, {}).get('persist_shortcut',False):
kmap[un] = keys
for node in self.all_shortcuts:
sc = node.data
un = sc['unique_name']
if sc['set_to_default']:
if un in kmap:
del kmap[un]
if un in options_map:
del options_map[un]
else:
if sc['persist_shortcut']:
options_map[un] = options_map.get(un, {})
options_map[un]['persist_shortcut'] = sc['persist_shortcut']
keys = [str(k.toString(QKeySequence.SequenceFormat.PortableText)) for k in sc['keys']]
kmap[un] = keys
with self.keyboard.config:
self.keyboard.config['map'] = kmap
self.keyboard.config['options_map'] = options_map
def universal_set(self):
ans = set()
for i, group in enumerate(self.data):
ans.add((i, -1))
for j, sc in enumerate(group.children):
ans.add((i, j))
return ans
def get_matches(self, location, query, candidates=None):
if candidates is None:
candidates = self.universal_set()
ans = set()
if not query:
return ans
query = lower(query)
for c, p in candidates:
if p < 0:
if query in lower(self.data[c].data):
ans.add((c, p))
else:
try:
sc = self.data[c].children[p].data
except:
continue
if query in lower(sc['name']):
ans.add((c, p))
return ans
def find(self, query):
query = query.strip()
if not query:
return ROOT
matches = self.parse(query)
if not matches:
return ROOT
matches = list(sorted(matches))
c, p = matches[0]
cat_idx = self.index(c, 0)
if p == -1:
return cat_idx
return self.index(p, 0, cat_idx)
def find_next(self, idx, query, backwards=False):
query = query.strip()
if not query:
return idx
matches = self.parse(query)
if not matches:
return idx
if idx.parent().isValid():
loc = (idx.parent().row(), idx.row())
else:
loc = (idx.row(), -1)
if loc not in matches:
return self.find(query)
if len(matches) == 1:
return ROOT
matches = list(sorted(matches))
i = matches.index(loc)
if backwards:
ans = i - 1 if i - 1 >= 0 else len(matches)-1
else:
ans = i + 1 if i + 1 < len(matches) else 0
ans = matches[ans]
return (self.index(ans[0], 0) if ans[1] < 0 else
self.index(ans[1], 0, self.index(ans[0], 0)))
def index_for_group(self, name):
for i in range(self.rowCount()):
node = self.data[i]
if node.data == name:
return self.index(i, 0)
@property
def group_names(self):
for i in range(self.rowCount()):
node = self.data[i]
yield node.data
# }}}
class Editor(QFrame): # {{{
editing_done = pyqtSignal(object)
def __init__(self, parent=None):
QFrame.__init__(self, parent)
self.setFocusPolicy(Qt.FocusPolicy.StrongFocus)
self.setAutoFillBackground(True)
self.capture = 0
self.setFrameShape(QFrame.Shape.StyledPanel)
self.setFrameShadow(QFrame.Shadow.Raised)
self._layout = l = QGridLayout(self)
self.setLayout(l)
self.header = QLabel('')
l.addWidget(self.header, 0, 0, 1, 2)
self.use_default = QRadioButton('')
self.use_custom = QRadioButton(_('&Custom'))
l.addWidget(self.use_default, 1, 0, 1, 3)
l.addWidget(self.use_custom, 2, 0, 1, 3)
self.use_custom.toggled.connect(self.custom_toggled)
off = 2
for which in (1, 2):
text = _('&Shortcut:') if which == 1 else _('&Alternate shortcut:')
la = QLabel(text)
la.setStyleSheet('QLabel { margin-left: 1.5em }')
l.addWidget(la, off+which, 0, 1, 3)
setattr(self, 'label%d'%which, la)
button = QPushButton(_('None'), self)
button.setObjectName(_('None'))
button.clicked.connect(partial(self.capture_clicked, which=which))
button.installEventFilter(self)
setattr(self, 'button%d'%which, button)
clear = QToolButton(self)
clear.setIcon(QIcon.ic('clear_left.png'))
clear.clicked.connect(partial(self.clear_clicked, which=which))
setattr(self, 'clear%d'%which, clear)
l.addWidget(button, off+which, 1, 1, 1)
l.addWidget(clear, off+which, 2, 1, 1)
la.setBuddy(button)
self.done_button = doneb = QPushButton(_('Done'), self)
l.addWidget(doneb, 0, 2, 1, 1)
doneb.clicked.connect(lambda : self.editing_done.emit(self))
l.setColumnStretch(0, 100)
self.custom_toggled(False)
def initialize(self, shortcut, all_shortcuts):
self.header.setText('<b>%s: %s</b>'%(_('Customize'), shortcut['name']))
self.all_shortcuts = all_shortcuts
self.shortcut = shortcut
self.default_keys = [QKeySequence(k, QKeySequence.SequenceFormat.PortableText) for k
in shortcut['default_keys']]
self.current_keys = list(shortcut['keys'])
default = ', '.join([str(k.toString(QKeySequence.SequenceFormat.NativeText)) for k in
self.default_keys])
if not default:
default = _('None')
current = ', '.join([str(k.toString(QKeySequence.SequenceFormat.NativeText)) for k in
self.current_keys])
if not current:
current = _('None')
self.use_default.setText(_('&Default: %(deflt)s [Currently not conflicting: %(curr)s]')%
dict(deflt=default, curr=current))
if shortcut['set_to_default']:
self.use_default.setChecked(True)
else:
self.use_custom.setChecked(True)
for key, which in zip(self.current_keys, [1,2]):
button = getattr(self, 'button%d'%which)
ns = key.toString(QKeySequence.SequenceFormat.NativeText)
button.setText(ns.replace('&', '&&'))
button.setObjectName(ns)
def custom_toggled(self, checked):
for w in ('1', '2'):
for o in ('label', 'button', 'clear'):
getattr(self, o+w).setEnabled(checked)
def capture_clicked(self, which=1):
self.capture = which
button = getattr(self, 'button%d'%which)
button.setText(_('Press a key...'))
button.setFocus(Qt.FocusReason.OtherFocusReason)
button.setStyleSheet('QPushButton { font-weight: bold}')
def clear_clicked(self, which=0):
button = getattr(self, 'button%d'%which)
button.setText(_('None'))
button.setObjectName(_('None'))
def eventFilter(self, obj, event):
if self.capture and obj in (self.button1, self.button2):
t = event.type()
if t == QEvent.Type.ShortcutOverride:
event.accept()
return True
if t == QEvent.Type.KeyPress:
self.key_press_event(event, 1 if obj is self.button1 else 2)
return True
return QFrame.eventFilter(self, obj, event)
def key_press_event(self, ev, which=0):
if self.capture == 0:
return QWidget.keyPressEvent(self, ev)
sequence = keysequence_from_event(ev)
if sequence is None:
return QWidget.keyPressEvent(self, ev)
ev.accept()
button = getattr(self, 'button%d'%which)
button.setStyleSheet('QPushButton { font-weight: normal}')
ns = sequence.toString(QKeySequence.SequenceFormat.NativeText)
button.setText(ns.replace('&', '&&'))
button.setObjectName(ns)
self.capture = 0
dup_desc = self.dup_check(sequence)
if dup_desc is not None:
error_dialog(self, _('Already assigned'),
str(sequence.toString(QKeySequence.SequenceFormat.NativeText)) + ' ' + _(
'already assigned to') + ' ' + dup_desc, show=True)
self.clear_clicked(which=which)
def dup_check(self, sequence):
for sc in self.all_shortcuts:
if sc is self.shortcut:
continue
for k in sc['keys']:
if k == sequence:
return sc['name']
@property
def custom_keys(self):
if self.use_default.isChecked():
return None
ans = []
for which in (1, 2):
button = getattr(self, 'button%d'%which)
t = button.objectName()
if not t or t == _('None'):
continue
ks = QKeySequence(t, QKeySequence.SequenceFormat.NativeText)
if not ks.isEmpty():
ans.append(ks)
return tuple(ans)
# }}}
class Delegate(QStyledItemDelegate): # {{{
changed_signal = pyqtSignal()
def __init__(self, parent=None):
QStyledItemDelegate.__init__(self, parent)
self.editing_index = None
self.closeEditor.connect(self.editing_done)
def to_doc(self, index):
data = index.data(Qt.ItemDataRole.UserRole)
if data is None:
html = _('<b>This shortcut no longer exists</b>')
elif data.is_shortcut:
shortcut = data.data
# Shortcut
keys = [str(k.toString(QKeySequence.SequenceFormat.NativeText)) for k in shortcut['keys']]
if not keys:
keys = _('None')
else:
keys = ', '.join(keys)
html = '<b>%s</b><br>%s: %s'%(
prepare_string_for_xml(shortcut['name']), _('Shortcuts'), prepare_string_for_xml(keys))
else:
# Group
html = data.data
doc = QTextDocument()
doc.setHtml(html)
return doc
def sizeHint(self, option, index):
if index == self.editing_index:
return QSize(200, 200)
ans = self.to_doc(index).size().toSize()
return ans
def paint(self, painter, option, index):
painter.save()
painter.setClipRect(QRectF(option.rect))
if hasattr(QStyle, 'CE_ItemViewItem'):
QApplication.style().drawControl(QStyle.ControlElement.CE_ItemViewItem, option, painter)
elif option.state & QStyle.StateFlag.State_Selected:
painter.fillRect(option.rect, option.palette.highlight())
painter.translate(option.rect.topLeft())
self.to_doc(index).drawContents(painter)
painter.restore()
def createEditor(self, parent, option, index):
w = Editor(parent=parent)
w.editing_done.connect(self.editor_done)
self.editing_index = index
self.current_editor = w
self.sizeHintChanged.emit(index)
return w
def accept_changes(self):
self.editor_done(self.current_editor)
def editor_done(self, editor):
self.commitData.emit(editor)
def setEditorData(self, editor, index):
all_shortcuts = [x.data for x in index.model().all_shortcuts]
shortcut = index.internalPointer().data
editor.initialize(shortcut, all_shortcuts)
def setModelData(self, editor, model, index):
self.closeEditor.emit(editor, QAbstractItemDelegate.EndEditHint.NoHint)
custom_keys = editor.custom_keys
sc = index.data(Qt.ItemDataRole.UserRole).data
if custom_keys is None:
candidates = []
for ckey in sc['default_keys']:
ckey = QKeySequence(ckey, QKeySequence.SequenceFormat.PortableText)
matched = False
for s in editor.all_shortcuts:
if s is editor.shortcut:
continue
for k in s['keys']:
if k == ckey:
matched = True
break
if not matched:
candidates.append(ckey)
candidates = tuple(candidates)
sc['set_to_default'] = True
else:
sc['set_to_default'] = False
candidates = custom_keys
sc['keys'] = candidates
self.changed_signal.emit()
def updateEditorGeometry(self, editor, option, index):
editor.setGeometry(option.rect)
def editing_done(self, *args):
self.current_editor = None
idx = self.editing_index
self.editing_index = None
if idx is not None:
self.sizeHintChanged.emit(idx)
# }}}
class ShortcutConfig(QWidget): # {{{
changed_signal = pyqtSignal()
def __init__(self, parent=None):
QWidget.__init__(self, parent)
self._layout = l = QVBoxLayout(self)
self.header = QLabel(_('Double click on any entry to change the'
' keyboard shortcuts associated with it'))
l.addWidget(self.header)
self.view = QTreeView(self)
self.view.setAlternatingRowColors(True)
self.view.setHeaderHidden(True)
self.view.setAnimated(True)
self.view.setContextMenuPolicy(Qt.ContextMenuPolicy.CustomContextMenu)
self.view.customContextMenuRequested.connect(self.show_context_menu)
l.addWidget(self.view)
self.delegate = Delegate()
self.view.setItemDelegate(self.delegate)
self.delegate.sizeHintChanged.connect(self.editor_opened,
type=Qt.ConnectionType.QueuedConnection)
self.delegate.changed_signal.connect(self.changed_signal)
self.search = SearchBox2(self)
self.search.initialize('shortcuts_search_history',
help_text=_('Search for a shortcut by name'))
self.search.search.connect(self.find)
self._h = h = QHBoxLayout()
l.addLayout(h)
h.addWidget(self.search)
self.nb = QPushButton(QIcon.ic('arrow-down.png'), _('&Next'), self)
self.pb = QPushButton(QIcon.ic('arrow-up.png'), _('&Previous'), self)
self.nb.clicked.connect(self.find_next)
self.pb.clicked.connect(self.find_previous)
h.addWidget(self.nb), h.addWidget(self.pb)
h.setStretch(0, 100)
def show_context_menu(self, pos):
menu = QMenu(self)
menu.addAction(QIcon.ic('plus.png'), _('Expand all'), self.view.expandAll)
menu.addAction(QIcon.ic('minus.png'), _('Collapse all'), self.view.collapseAll)
menu.exec(self.view.mapToGlobal(pos))
def restore_defaults(self):
self._model.restore_defaults()
self.changed_signal.emit()
def commit(self):
if self.view.state() == QAbstractItemView.State.EditingState:
self.delegate.accept_changes()
self._model.commit()
def initialize(self, keyboard):
self._model = ConfigModel(keyboard, parent=self)
self.view.setModel(self._model)
def editor_opened(self, index):
self.view.scrollTo(index, QAbstractItemView.ScrollHint.EnsureVisible)
@property
def is_editing(self):
return self.view.state() == QAbstractItemView.State.EditingState
def find(self, query):
if not query:
return
try:
idx = self._model.find(query)
except ParseException:
self.search.search_done(False)
return
self.search.search_done(True)
if not idx.isValid():
info_dialog(self, _('No matches'),
_('Could not find any shortcuts matching <i>{}</i>').format(prepare_string_for_xml(query)),
show=True, show_copy_button=False)
return
self.highlight_index(idx)
def highlight_index(self, idx):
self.view.scrollTo(idx)
self.view.selectionModel().select(idx, QItemSelectionModel.SelectionFlag.ClearAndSelect)
self.view.setCurrentIndex(idx)
self.view.setFocus(Qt.FocusReason.OtherFocusReason)
def find_next(self, *args):
idx = self.view.currentIndex()
if not idx.isValid():
idx = self._model.index(0, 0)
idx = self._model.find_next(idx,
str(self.search.currentText()))
self.highlight_index(idx)
def find_previous(self, *args):
idx = self.view.currentIndex()
if not idx.isValid():
idx = self._model.index(0, 0)
idx = self._model.find_next(idx,
str(self.search.currentText()), backwards=True)
self.highlight_index(idx)
def highlight_group(self, group_name):
idx = self.view.model().index_for_group(group_name)
if idx is not None:
self.view.expand(idx)
self.view.scrollTo(idx, QAbstractItemView.ScrollHint.PositionAtTop)
self.view.selectionModel().select(idx, QItemSelectionModel.SelectionFlag.ClearAndSelect)
self.view.setCurrentIndex(idx)
self.view.setFocus(Qt.FocusReason.OtherFocusReason)
# }}}
| 28,052 | Python | .py | 678 | 31.280236 | 111 | 0.597124 | kovidgoyal/calibre | 19,243 | 2,250 | 4 | GPL-3.0 | 9/5/2024, 5:13:50 PM (Europe/Amsterdam) |
26,639 | open_with.py | kovidgoyal_calibre/src/calibre/gui2/open_with.py | #!/usr/bin/env python
__license__ = 'GPL v3'
__copyright__ = '2015, Kovid Goyal <kovid at kovidgoyal.net>'
import os
import uuid
from contextlib import suppress
from functools import partial
from threading import Thread
from qt.core import (
QAction,
QBuffer,
QByteArray,
QDialogButtonBox,
QIcon,
QInputDialog,
QIODevice,
QKeySequence,
QLabel,
QListWidget,
QListWidgetItem,
QPixmap,
QSize,
QStackedLayout,
Qt,
QVBoxLayout,
QWidget,
pyqtSignal,
)
from calibre import as_unicode
from calibre.constants import ismacos, iswindows
from calibre.gui2 import Application, choose_files, choose_images, choose_osx_app, elided_text, error_dialog, sanitize_env_vars
from calibre.gui2.progress_indicator import ProgressIndicator
from calibre.gui2.widgets2 import Dialog
from calibre.utils.config import JSONConfig
from calibre.utils.icu import numeric_sort_key as sort_key
from calibre.utils.resources import get_image_path as I
from polyglot.builtins import iteritems, string_or_bytes
ENTRY_ROLE = Qt.ItemDataRole.UserRole
def pixmap_to_data(pixmap):
ba = QByteArray()
buf = QBuffer(ba)
buf.open(QIODevice.OpenModeFlag.WriteOnly)
pixmap.save(buf, 'PNG')
return bytearray(ba.data())
def run_program(entry, path, parent):
import subprocess
cmdline = entry_to_cmdline(entry, path)
print('Running Open With commandline:', repr(cmdline))
try:
with sanitize_env_vars():
process = subprocess.Popen(cmdline)
except Exception as err:
return error_dialog(
parent, _('Failed to run'), _(
'Failed to run program, click "Show details" for more information'),
det_msg='Command line: %r\n%s' %(cmdline, as_unicode(err)))
t = Thread(name='WaitProgram', target=process.wait)
t.daemon = True
t.start()
def entry_to_icon_text(entry, only_text=False):
if only_text:
return entry.get('name', entry.get('Name')) or _('Unknown')
data = entry.get('icon_data')
if isinstance(data, str):
with suppress(Exception):
from base64 import standard_b64decode
data = bytearray(standard_b64decode(data))
if not isinstance(data, (bytearray, bytes)):
icon = QIcon.ic('blank.png')
else:
pmap = QPixmap()
pmap.loadFromData(bytes(data))
if pmap.isNull():
icon = QIcon.ic('blank.png')
else:
icon = QIcon(pmap)
return icon, entry.get('name', entry.get('Name')) or _('Unknown')
if iswindows:
# Windows {{{
import subprocess
from calibre.utils.open_with.windows import load_icon_for_cmdline, load_icon_resource
from calibre.utils.winreg.default_programs import find_programs, friendly_app_name
from calibre_extensions import winutil
oprefs = JSONConfig('windows_open_with')
def entry_sort_key(entry):
return sort_key(entry.get('name') or '')
def icon_for_entry(entry, delete_icon_resource=False, as_data=False):
res = entry.pop('icon_resource', None) if delete_icon_resource else entry.get('icon_resource')
if res is None:
return load_icon_for_cmdline(entry['cmdline'], as_data=as_data)
try:
return load_icon_resource(res, as_data=as_data)
except Exception:
import traceback
traceback.print_exc()
return load_icon_for_cmdline(entry['cmdline'], as_data=as_data)
def finalize_entry(entry):
try:
data = icon_for_entry(entry, delete_icon_resource=True, as_data=True)
except Exception:
data = None
import traceback
traceback.print_exc()
if isinstance(data, (bytes, bytearray)) or data is None:
entry['icon_data'] = data
return entry
def change_name_in_entry(entry, newname):
entry['name'] = newname
def entry_to_item(entry, parent):
try:
icon = icon_for_entry(entry)
except Exception:
icon = None
import traceback
traceback.print_exc()
if not icon:
icon = entry_to_icon_text(entry)[0]
ans = QListWidgetItem(QIcon(icon), entry.get('name') or _('Unknown'), parent)
ans.setData(ENTRY_ROLE, entry)
ans.setToolTip(_('Command line:') + '\n' + entry['cmdline'])
def choose_manually(filetype, parent):
ans = choose_files(
parent, 'choose-open-with-program-manually-win',
_('Choose a program to open %s files') % filetype.upper(),
filters=[(_('Executable files'), ['exe', 'bat', 'com', 'cmd'])], select_only_single_file=True)
if ans:
ans = os.path.abspath(ans[0])
if not os.access(ans, os.X_OK):
error_dialog(parent, _('Cannot execute'), _(
'The program %s is not an executable file') % ans, show=True)
return
qans = ans.replace('"', r'\"')
name = friendly_app_name(exe=ans) or os.path.splitext(os.path.basename(ans))[0]
return {'cmdline':'"%s" "%%1"' % qans, 'name':name}
def entry_to_cmdline(entry, path):
cmdline = entry['cmdline']
qpath = path.replace('"', r'\"')
return cmdline.replace('%1', qpath)
del run_program
def run_program(entry, path, parent): # noqa
import re
cmdline = entry_to_cmdline(entry, path)
flags = subprocess.CREATE_DEFAULT_ERROR_MODE | subprocess.CREATE_NEW_PROCESS_GROUP
if re.match(r'"[^"]+?(.bat|.cmd|.com)"', cmdline, flags=re.I):
flags |= subprocess.CREATE_NO_WINDOW
console = ' (console)'
else:
flags |= subprocess.DETACHED_PROCESS
console = ''
print('Running Open With commandline%s:' % console, repr(entry['cmdline']), ' |==> ', repr(cmdline))
try:
with sanitize_env_vars():
winutil.run_cmdline(cmdline, flags, 2000)
except Exception as err:
return error_dialog(
parent, _('Failed to run'), _(
'Failed to run program, click "Show details" for more information'),
det_msg='Command line: %r\n%s' %(cmdline, as_unicode(err)))
# }}}
elif ismacos:
# macOS {{{
oprefs = JSONConfig('osx_open_with')
from calibre.utils.open_with.osx import entry_to_cmdline, find_programs, get_bundle_data, get_icon
def entry_sort_key(entry):
return sort_key(entry.get('name') or '')
def finalize_entry(entry):
entry['extensions'] = tuple(entry.get('extensions', ()))
data = get_icon(entry.pop('icon_file', None), as_data=True, pixmap_to_data=pixmap_to_data)
if data:
entry['icon_data'] = data
return entry
def change_name_in_entry(entry, newname):
entry['name'] = newname
def entry_to_item(entry, parent):
icon = get_icon(entry.get('icon_file'), as_data=False)
if icon is None:
icon = entry_to_icon_text(entry)[0]
else:
icon = QPixmap.fromImage(icon)
ans = QListWidgetItem(QIcon(icon), entry.get('name') or _('Unknown'), parent)
ans.setData(ENTRY_ROLE, entry)
ans.setToolTip(_('Application path:') + '\n' + entry['path'])
def choose_manually(filetype, parent):
ans = choose_osx_app(parent, 'choose-open-with-program-manually', _('Choose a program to open %s files') % filetype.upper())
if ans:
ans = ans[0]
if os.path.isdir(ans):
app = get_bundle_data(ans)
if app is None:
error_dialog(parent, _('Invalid application'), _(
'%s is not a valid macOS application bundle.') % ans, show=True)
return
return app
if not os.access(ans, os.X_OK):
error_dialog(parent, _('Cannot execute'), _(
'The program %s is not an executable file') % ans, show=True)
return
return {'path':ans, 'name': os.path.basename(ans)}
# }}}
else:
# XDG {{{
oprefs = JSONConfig('xdg_open_with')
from calibre.utils.open_with.linux import entry_sort_key, entry_to_cmdline, find_programs
def change_name_in_entry(entry, newname):
entry['Name'] = newname
def entry_to_item(entry, parent):
icon_path = entry.get('Icon') or I('blank.png')
if not isinstance(icon_path, string_or_bytes):
icon_path = I('blank.png')
ans = QListWidgetItem(QIcon(icon_path), entry.get('Name') or _('Unknown'), parent)
ans.setData(ENTRY_ROLE, entry)
comment = (entry.get('Comment') or '')
if comment:
comment += '\n'
ans.setToolTip(comment + _('Command line:') + '\n' + (' '.join(entry['Exec'])))
def choose_manually(filetype, parent):
dd = '/usr/bin' if os.path.isdir('/usr/bin') else '~'
ans = choose_files(parent, 'choose-open-with-program-manually', _('Choose a program to open %s files') % filetype.upper(),
select_only_single_file=True, default_dir=dd)
if ans:
ans = ans[0]
if not os.access(ans, os.X_OK):
error_dialog(parent, _('Cannot execute'), _(
'The program %s is not an executable file') % ans, show=True)
return
return {'Exec':[ans, '%f'], 'Name':os.path.basename(ans)}
def finalize_entry(entry):
icon_path = entry.get('Icon')
if icon_path:
ic = QIcon(icon_path)
if not ic.isNull():
pmap = ic.pixmap(48, 48)
if not pmap.isNull():
entry['icon_data'] = pixmap_to_data(pmap)
try:
entry['MimeType'] = tuple(entry['MimeType'])
except KeyError:
entry['MimeType'] = ()
return entry
# }}}
class ChooseProgram(Dialog): # {{{
found = pyqtSignal()
def __init__(self, file_type='jpeg', parent=None, prefs=oprefs):
self.file_type = file_type
self.programs = self.find_error = self.selected_entry = None
self.select_manually = False
Dialog.__init__(self, _('Choose a program'), 'choose-open-with-program-dialog', parent=parent, prefs=prefs)
self.found.connect(self.programs_found, type=Qt.ConnectionType.QueuedConnection)
self.pi.startAnimation()
t = Thread(target=self.find_programs)
t.daemon = True
t.start()
def setup_ui(self):
self.stacks = s = QStackedLayout(self)
self.w = w = QWidget(self)
self.w.l = l = QVBoxLayout(w)
self.pi = pi = ProgressIndicator(self, 256)
l.addStretch(1), l.addWidget(pi, alignment=Qt.AlignmentFlag.AlignHCenter), l.addSpacing(10)
w.la = la = QLabel(_('Gathering data, please wait...'))
f = la.font()
f.setBold(True), f.setPointSize(28), la.setFont(f)
l.addWidget(la, alignment=Qt.AlignmentFlag.AlignHCenter), l.addStretch(1)
s.addWidget(w)
self.w2 = w = QWidget(self)
self.l = l = QVBoxLayout(w)
s.addWidget(w)
self.la = la = QLabel(_('Choose a program to open %s files') % self.file_type.upper())
self.plist = pl = QListWidget(self)
pl.doubleClicked.connect(self.accept)
pl.setIconSize(QSize(48, 48)), pl.setSpacing(5)
pl.doubleClicked.connect(self.accept)
l.addWidget(la), l.addWidget(pl)
la.setBuddy(pl)
b = self.bb.addButton(_('&Browse computer for program'), QDialogButtonBox.ButtonRole.ActionRole)
b.clicked.connect(self.manual)
l.addWidget(self.bb)
def sizeHint(self):
return QSize(600, 500)
def find_programs(self):
try:
self.programs = find_programs(self.file_type.split())
except Exception:
import traceback
self.find_error = traceback.print_exc()
self.found.emit()
def programs_found(self):
if self.find_error is not None:
error_dialog(self, _('Error finding programs'), _(
'Failed to find programs on your computer, click "Show details" for'
' more information'), det_msg=self.find_error, show=True)
self.select_manually = True
return self.reject()
if not self.programs:
self.select_manually = True
return self.reject()
for entry in self.programs:
entry_to_item(entry, self.plist)
self.stacks.setCurrentIndex(1)
def accept(self):
ci = self.plist.currentItem()
if ci is not None:
self.selected_entry = ci.data(ENTRY_ROLE)
return Dialog.accept(self)
def manual(self):
self.select_manually = True
self.reject()
oprefs.defaults['entries'] = {}
def choose_program(file_type='jpeg', parent=None, prefs=oprefs):
oft = file_type = file_type.lower()
file_type = {'cover_image':'jpeg'}.get(oft, oft)
d = ChooseProgram(file_type, parent, prefs)
d.exec()
entry = choose_manually(file_type, parent) if d.select_manually else d.selected_entry
if entry is not None:
entry = finalize_entry(entry)
entry['uuid'] = str(uuid.uuid4())
entries = oprefs['entries']
if oft not in entries:
entries[oft] = []
entries[oft].append(entry)
entries[oft].sort(key=entry_sort_key)
oprefs['entries'] = entries
register_keyboard_shortcuts(finalize=True)
return entry
def populate_menu(menu, connect_action, file_type):
file_type = file_type.lower()
for entry in oprefs['entries'].get(file_type, ()):
icon, text = entry_to_icon_text(entry)
text = elided_text(text, pos='right')
sa = registered_shortcuts.get(entry['uuid'])
if sa is not None:
text += '\t' + sa.shortcut().toString(QKeySequence.SequenceFormat.NativeText)
ac = menu.addAction(icon, text)
connect_action(ac, entry)
return menu
# }}}
class EditPrograms(Dialog): # {{{
def __init__(self, file_type='jpeg', parent=None):
self.file_type = file_type.lower()
Dialog.__init__(self, _('Edit the applications used for %s files') % file_type.upper(), 'edit-open-with-programs', parent=parent)
def setup_ui(self):
self.l = l = QVBoxLayout(self)
self.plist = pl = QListWidget(self)
pl.setIconSize(QSize(48, 48)), pl.setSpacing(5)
l.addWidget(pl)
self.bb.clear(), self.bb.setStandardButtons(QDialogButtonBox.StandardButton.Close)
self.rb = b = self.bb.addButton(_('&Remove'), QDialogButtonBox.ButtonRole.ActionRole)
b.clicked.connect(self.remove), b.setIcon(QIcon.ic('list_remove.png'))
self.cb = b = self.bb.addButton(_('Change &icon'), QDialogButtonBox.ButtonRole.ActionRole)
b.clicked.connect(self.change_icon), b.setIcon(QIcon.ic('icon_choose.png'))
self.cb = b = self.bb.addButton(_('Change &name'), QDialogButtonBox.ButtonRole.ActionRole)
b.clicked.connect(self.change_name), b.setIcon(QIcon.ic('modified.png'))
l.addWidget(self.bb)
self.populate()
def sizeHint(self):
return QSize(600, 400)
def populate(self):
self.plist.clear()
for entry in oprefs['entries'].get(self.file_type, ()):
entry_to_item(entry, self.plist)
def change_icon(self):
ci = self.plist.currentItem()
if ci is None:
return error_dialog(self, _('No selection'), _(
'No application selected'), show=True)
paths = choose_images(self, 'choose-new-icon-for-open-with-program', _(
'Choose new icon'))
if paths:
ic = QIcon(paths[0])
if ic.isNull():
return error_dialog(self, _('Invalid icon'), _(
'Could not load image from %s') % paths[0], show=True)
pmap = ic.pixmap(48, 48)
if not pmap.isNull():
entry = ci.data(ENTRY_ROLE)
entry['icon_data'] = pixmap_to_data(pmap)
ci.setData(ENTRY_ROLE, entry)
self.update_stored_config()
ci.setIcon(ic)
def change_name(self):
ci = self.plist.currentItem()
if ci is None:
return error_dialog(self, _('No selection'), _(
'No application selected'), show=True)
name = ci.data(Qt.ItemDataRole.DisplayRole)
name, ok = QInputDialog.getText(self, _('Enter new name'), _('New name for {}').format(name), text=name)
if ok and name:
entry = ci.data(ENTRY_ROLE)
change_name_in_entry(entry, name)
ci.setData(ENTRY_ROLE, entry)
self.update_stored_config()
ci.setData(Qt.ItemDataRole.DisplayRole, name)
def remove(self):
ci = self.plist.currentItem()
if ci is None:
return error_dialog(self, _('No selection'), _(
'No application selected'), show=True)
row = self.plist.row(ci)
self.plist.takeItem(row)
self.update_stored_config()
register_keyboard_shortcuts(finalize=True)
def update_stored_config(self):
entries = [self.plist.item(i).data(ENTRY_ROLE) for i in range(self.plist.count())]
oprefs['entries'][self.file_type] = entries
oprefs['entries'] = oprefs['entries']
def edit_programs(file_type, parent):
d = EditPrograms(file_type, parent)
d.exec()
# }}}
registered_shortcuts = {}
def register_keyboard_shortcuts(gui=None, finalize=False):
if gui is None:
from calibre.gui2.ui import get_gui
gui = get_gui()
if gui is None:
return
for unique_name, action in iteritems(registered_shortcuts):
gui.keyboard.unregister_shortcut(unique_name)
gui.removeAction(action)
registered_shortcuts.clear()
for filetype, applications in iteritems(oprefs['entries']):
for application in applications:
text = entry_to_icon_text(application, only_text=True)
t = _('cover image') if filetype.upper() == 'COVER_IMAGE' else filetype.upper()
name = _('Open {0} files with {1}').format(t, text)
ac = QAction(gui)
unique_name = application['uuid']
func = partial(gui.open_with_action_triggerred, filetype, application)
ac.triggered.connect(func)
gui.keyboard.register_shortcut(unique_name, name, action=ac, group=_('Open with'))
gui.addAction(ac)
registered_shortcuts[unique_name] = ac
if finalize:
gui.keyboard.finalize()
if __name__ == '__main__':
from pprint import pprint
app = Application([])
pprint(choose_program('pdf'))
del app
| 18,890 | Python | .py | 439 | 33.972665 | 137 | 0.608883 | kovidgoyal/calibre | 19,243 | 2,250 | 4 | GPL-3.0 | 9/5/2024, 5:13:50 PM (Europe/Amsterdam) |
26,640 | trash.py | kovidgoyal_calibre/src/calibre/gui2/trash.py | #!/usr/bin/env python
# License: GPLv3 Copyright: 2023, Kovid Goyal <kovid at kovidgoyal.net>
import time
import traceback
from operator import attrgetter
from typing import Iterator, List
from qt.core import (
QAbstractItemView,
QDialogButtonBox,
QHBoxLayout,
QIcon,
QLabel,
QListWidget,
QListWidgetItem,
QMenu,
QPainter,
QPalette,
QPixmap,
QRectF,
QSize,
QSpinBox,
QStyle,
QStyledItemDelegate,
Qt,
QTabWidget,
QVBoxLayout,
pyqtSignal,
)
from calibre import fit_image
from calibre.db.constants import DEFAULT_TRASH_EXPIRY_TIME_SECONDS, TrashEntry
from calibre.gui2 import choose_dir, choose_save_file, error_dialog
from calibre.gui2.dialogs.confirm_delete import confirm
from calibre.gui2.widgets import BusyCursor
from calibre.gui2.widgets2 import Dialog
THUMBNAIL_SIZE = 60, 80
MARGIN_SIZE = 8
def time_spec(mtime: float) -> str:
delta = time.time() - mtime
if delta <= 86400:
if delta <= 3600:
return _('less than an hour ago')
return _('{} hours ago').format(int(delta) // 3600)
else:
return _('{} days ago').format(int(delta) // 86400)
class TrashItemDelegate(QStyledItemDelegate):
def __init__(self, parent):
super().__init__(parent)
self.pixmap_cache = {}
def sizeHint(self, option, index):
return QSize(THUMBNAIL_SIZE[0] + MARGIN_SIZE + 256, THUMBNAIL_SIZE[1] + MARGIN_SIZE)
def paint(self, painter: QPainter, option, index):
super().paint(painter, option, index)
painter.save()
entry: TrashEntry = index.data(Qt.ItemDataRole.UserRole)
if option is not None and option.state & QStyle.StateFlag.State_Selected:
p = option.palette
group = (QPalette.ColorGroup.Active if option.state & QStyle.StateFlag.State_Active else
QPalette.ColorGroup.Inactive)
c = p.color(group, QPalette.ColorRole.HighlightedText)
painter.setPen(c)
text = entry.title + '\n' + entry.author + '\n' + _('Deleted: {when}').format(when=time_spec(entry.mtime))
if entry.formats:
text += '\n' + ', '.join(sorted(entry.formats))
r = QRectF(option.rect)
if entry.cover_path:
dp = self.parent().devicePixelRatioF()
p = self.pixmap_cache.get(entry.cover_path)
if p is None:
p = QPixmap()
p.load(entry.cover_path)
scaled, w, h = fit_image(p.width(), p.height(), int(THUMBNAIL_SIZE[0] * dp), int(THUMBNAIL_SIZE[1] * dp))
if scaled:
p = p.scaled(w, h, transformMode=Qt.TransformationMode.SmoothTransformation)
p.setDevicePixelRatio(self.parent().devicePixelRatioF())
self.pixmap_cache[entry.cover_path] = p
w, h = p.width() / dp, p.height() / dp
width, height = THUMBNAIL_SIZE[0] + MARGIN_SIZE, THUMBNAIL_SIZE[1] + MARGIN_SIZE
pos = r.topLeft()
if width > w:
pos.setX(pos.x() + (width - w) / 2)
if height > h:
pos.setY(pos.y() + (height - h) / 2)
painter.drawPixmap(pos, p)
r.adjust(THUMBNAIL_SIZE[0] + MARGIN_SIZE, 0, 0, 0)
painter.drawText(r, Qt.TextFlag.TextWordWrap | Qt.AlignmentFlag.AlignTop, text)
painter.restore()
class TrashList(QListWidget):
restore_item = pyqtSignal(object, object)
def __init__(self, entries: List[TrashEntry], parent: 'TrashView', is_books: bool):
super().__init__(parent)
self.is_books = is_books
self.db = parent.db
self.delegate = TrashItemDelegate(self)
self.setItemDelegate(self.delegate)
self.setSelectionMode(QAbstractItemView.SelectionMode.ExtendedSelection)
for entry in sorted(entries, key=attrgetter('mtime'), reverse=True):
i = QListWidgetItem(self)
i.setData(Qt.ItemDataRole.UserRole, entry)
self.addItem(i)
self.itemDoubleClicked.connect(self.double_clicked)
self.setContextMenuPolicy(Qt.ContextMenuPolicy.CustomContextMenu)
self.customContextMenuRequested.connect(self.show_context_menu)
@property
def selected_entries(self) -> Iterator[TrashEntry]:
for i in self.selectedItems():
yield i.data(Qt.ItemDataRole.UserRole)
def double_clicked(self, item):
self.restore_item.emit(self, item)
def show_context_menu(self, pos):
item = self.itemAt(pos)
if item is None:
return
m = QMenu(self)
entry = item.data(Qt.ItemDataRole.UserRole)
m.addAction(QIcon.ic('save.png'), _('Save "{}" to disk').format(entry.title)).triggered.connect(self.save_current_item)
m.exec(self.mapToGlobal(pos))
def save_current_item(self):
item = self.currentItem()
if item is not None:
self.save_entry(item.data(Qt.ItemDataRole.UserRole))
def save_entry(self, entry: TrashEntry):
if self.is_books:
dest = choose_dir(self, 'save-trash-book', _('Choose a location to save: {}').format(entry.title))
if not dest:
return
self.db.copy_book_from_trash(entry.book_id, dest)
else:
for fmt in entry.formats:
dest = choose_save_file(self, 'save-trash-format', _('Choose a location to save: {}').format(
entry.title +'.' + fmt.lower()), initial_filename=entry.title + '.' + fmt.lower())
if dest:
self.db.copy_format_from_trash(entry.book_id, fmt, dest)
class TrashView(Dialog):
books_restored = pyqtSignal(object)
def __init__(self, db, parent=None):
self.db = db.new_api
self.expire_on_close = False
self.formats_restored = set()
super().__init__(_('Recently deleted books'), 'trash-view-for-library', parent=parent, default_buttons=QDialogButtonBox.StandardButton.Close)
self.finished.connect(self.expire_old_trash)
def setup_ui(self):
self.l = l = QVBoxLayout(self)
self.setWindowIcon(QIcon.ic('trash.png'))
with BusyCursor():
books, formats = self.db.list_trash_entries()
self.books = TrashList(books, self, True)
self.books.restore_item.connect(self.restore_item)
self.formats = TrashList(formats, self, False)
self.formats.restore_item.connect(self.restore_item)
self.tabs = t = QTabWidget(self)
l.addWidget(t)
t.addTab(self.books, QIcon.ic('book.png'), 'books')
t.addTab(self.formats, QIcon.ic('mimetypes/zero.png'), 'formats')
la = QLabel(_('&Permanently delete after:'))
self.auto_delete = ad = QSpinBox(self)
ad.setMinimum(0)
ad.setMaximum(365)
ad.setSpecialValueText(_('on close'))
ad.setValue(int(self.db.pref('expire_old_trash_after', DEFAULT_TRASH_EXPIRY_TIME_SECONDS) / 86400))
ad.setSuffix(_(' days'))
ad.setToolTip(_(
'Deleted items are permanently deleted automatically after the specified number of days.\n'
'If set to "on close" they are deleted whenever the library is closed, that is when switching to another library or exiting calibre.'
))
ad.valueChanged.connect(self.trash_expiry_time_changed)
h = QHBoxLayout()
h.addWidget(la), h.addWidget(ad), h.addStretch(10)
la.setBuddy(ad)
l.addLayout(h)
h = QHBoxLayout()
l.addWidget(self.bb)
self.restore_button = b = self.bb.addButton(_('&Restore selected'), QDialogButtonBox.ButtonRole.ActionRole)
b.clicked.connect(self.restore_selected)
b.setIcon(QIcon.ic('edit-undo.png'))
self.delete_button = b = self.bb.addButton(_('Permanently &delete selected'), QDialogButtonBox.ButtonRole.ActionRole)
b.setToolTip(_('Remove the selected entries from the trash bin, thereby deleting them permanently'))
b.setIcon(QIcon.ic('edit-clear.png'))
b.clicked.connect(self.delete_selected)
self.clear_button = b = self.bb.addButton(_('&Clear'), QDialogButtonBox.ButtonRole.ResetRole)
b.clicked.connect(self.clear_all)
b.setIcon(QIcon.ic('dialog_warning.png'))
self.update_titles()
self.bb.button(QDialogButtonBox.StandardButton.Close).setFocus(Qt.FocusReason.OtherFocusReason)
def clear_all(self):
if not confirm('<p>'+_('All books and formats will be <b>permanently deleted</b>! Are you sure?'), 'clear_trash_bin', self):
return
self.db.clear_trash_bin()
self.books.clear()
self.formats.clear()
self.update_titles()
def update_titles(self):
self.tabs.setTabText(0, _('&Books ({})').format(self.books.count()))
self.tabs.setTabText(1, _('&Formats ({})').format(self.formats.count()))
def trash_expiry_time_changed(self, val):
self.db.set_pref('expire_old_trash_after', 86400 * self.auto_delete.value())
self.expire_on_close = True
def expire_old_trash(self):
if self.expire_on_close:
self.db.expire_old_trash()
def sizeHint(self):
return QSize(530, 650)
def do_operation_on_selected(self, func):
ok_items, failed_items = [], []
for i in self.tabs.currentWidget().selectedItems():
entry = i.data(Qt.ItemDataRole.UserRole)
try:
func(entry)
except Exception as e:
failed_items.append((entry, e, traceback.format_exc()))
else:
ok_items.append(i)
return ok_items, failed_items
@property
def books_tab_is_selected(self):
return self.tabs.currentWidget() is self.books
def restore_item(self, which, item):
is_books = which is self.books
entry = item.data(Qt.ItemDataRole.UserRole)
if is_books:
self.db.move_book_from_trash(entry.book_id)
self.books_restored.emit({entry.book_id})
else:
self.formats_restored.add(entry.book_id)
for fmt in entry.formats:
self.db.move_format_from_trash(entry.book_id, fmt)
self.remove_entries([item])
def restore_selected(self):
is_books = self.books_tab_is_selected
done = set()
def f(entry):
if is_books:
self.db.move_book_from_trash(entry.book_id)
done.add(entry.book_id)
else:
self.formats_restored.add(entry.book_id)
for fmt in entry.formats:
self.db.move_format_from_trash(entry.book_id, fmt)
ok, failed = self.do_operation_on_selected(f)
if done:
self.books_restored.emit(done)
self.remove_entries(ok)
self.show_failures(failed, _('restore'))
def remove_entries(self, remove):
w = self.tabs.currentWidget()
for i in remove:
w.takeItem(w.row(i))
self.update_titles()
def delete_selected(self):
category = 'b' if self.books_tab_is_selected else 'f'
def f(entry):
self.db.delete_trash_entry(entry.book_id, category)
ok, failed = self.do_operation_on_selected(f)
self.remove_entries(ok)
self.show_failures(failed, _('delete'))
def show_failures(self, failures, operation):
if not failures:
return
det_msg = []
for (entry, exc, tb) in failures:
det_msg.append(_('Failed for the book {} with error:').format(entry.title))
det_msg.append(tb)
det_msg.append('-' * 40)
det_msg.append('')
det_msg = det_msg[:-2]
entry_type = _('Books') if self.books_tab_is_selected else _('Formats')
error_dialog(
self, _('Failed to process some {}').format(entry_type),
_('Could not {0} some {1}. Click "Show details" for details.').format(operation, entry_type),
det_msg='\n'.join(det_msg), show=True)
if __name__ == '__main__':
from calibre.gui2 import Application
from calibre.library import db
app = Application([])
TrashView(db()).exec()
del app
| 12,258 | Python | .py | 275 | 35.294545 | 149 | 0.622507 | kovidgoyal/calibre | 19,243 | 2,250 | 4 | GPL-3.0 | 9/5/2024, 5:13:50 PM (Europe/Amsterdam) |
26,641 | layout.py | kovidgoyal_calibre/src/calibre/gui2/layout.py | #!/usr/bin/env python
__license__ = 'GPL v3'
__copyright__ = '2010, Kovid Goyal <kovid@kovidgoyal.net>'
__docformat__ = 'restructuredtext en'
from functools import partial
from qt.core import (
QActionGroup,
QApplication,
QCoreApplication,
QFrame,
QHBoxLayout,
QIcon,
QLabel,
QLineEdit,
QMenu,
QObject,
QSizePolicy,
Qt,
QToolButton,
QVBoxLayout,
QWidget,
pyqtSignal,
)
from calibre import human_readable
from calibre.constants import __appname__
from calibre.gui2.bars import BarsManager
from calibre.gui2.search_box import SearchBox2
from calibre.utils.config_base import tweaks
from calibre.utils.localization import pgettext
class LocationManager(QObject): # {{{
locations_changed = pyqtSignal()
unmount_device = pyqtSignal()
location_selected = pyqtSignal(object)
configure_device = pyqtSignal()
update_device_metadata = pyqtSignal()
def __init__(self, parent=None):
QObject.__init__(self, parent)
self.free = [-1, -1, -1]
self.count = 0
self.location_actions = QActionGroup(self)
self.location_actions.setExclusive(True)
self.current_location = 'library'
self._mem = []
self.tooltips = {}
self.all_actions = []
def ac(name, text, icon, tooltip):
icon = QIcon.ic(icon)
ac = self.location_actions.addAction(icon, text)
setattr(self, 'location_'+name, ac)
ac.setAutoRepeat(False)
ac.setCheckable(True)
receiver = partial(self._location_selected, name)
ac.triggered.connect(receiver)
self.tooltips[name] = tooltip
m = QMenu(parent)
self._mem.append(m)
a = m.addAction(icon, tooltip)
a.triggered.connect(receiver)
if name != 'library':
self._mem.append(a)
a = m.addAction(QIcon.ic('eject.png'), _('Eject this device'))
a.triggered.connect(self._eject_requested)
self._mem.append(a)
a = m.addAction(QIcon.ic('config.png'), _('Configure this device'))
a.triggered.connect(self._configure_requested)
self._mem.append(a)
a = m.addAction(QIcon.ic('sync.png'), _('Update cached metadata on device'))
a.triggered.connect(lambda x : self.update_device_metadata.emit())
self._mem.append(a)
else:
ac.setToolTip(tooltip)
ac.setMenu(m)
ac.calibre_name = name
self.all_actions.append(ac)
return ac
self.library_action = ac('library', _('Library'), 'lt.png',
_('Show books in calibre library'))
ac('main', _('Device'), 'reader.png',
_('Show books in the main memory of the device'))
ac('carda', _('Card A'), 'sd.png',
_('Show books in storage card A'))
ac('cardb', _('Card B'), 'sd.png',
_('Show books in storage card B'))
def set_switch_actions(self, quick_actions, rename_actions, delete_actions,
switch_actions, choose_action):
self.switch_menu = self.library_action.menu()
if self.switch_menu:
self.switch_menu.addSeparator()
else:
self.switch_menu = QMenu()
self.switch_menu.addAction(choose_action)
self.cs_menus = []
for t, acs in [(_('Quick switch'), quick_actions),
(_('Rename library'), rename_actions),
(_('Delete library'), delete_actions)]:
if acs:
self.cs_menus.append(QMenu(t))
for ac in acs:
self.cs_menus[-1].addAction(ac)
self.switch_menu.addMenu(self.cs_menus[-1])
self.switch_menu.addSeparator()
for ac in switch_actions:
self.switch_menu.addAction(ac)
if self.switch_menu != self.library_action.menu():
self.library_action.setMenu(self.switch_menu)
def _location_selected(self, location, *args):
if location != self.current_location and hasattr(self,
'location_'+location):
self.current_location = location
self.location_selected.emit(location)
getattr(self, 'location_'+location).setChecked(True)
def _eject_requested(self, *args):
self.unmount_device.emit()
def _configure_requested(self):
self.configure_device.emit()
def update_devices(self, cp=(None, None), fs=[-1, -1, -1], icon=None):
self.location_main.setIcon(QIcon.ic(icon or 'reader.png'))
had_device = self.has_device
if cp is None:
cp = (None, None)
if isinstance(cp, (bytes, str)):
cp = (cp, None)
if len(fs) < 3:
fs = list(fs) + [0]
self.free[0] = fs[0]
self.free[1] = fs[1]
self.free[2] = fs[2]
cpa, cpb = cp
self.free[1] = fs[1] if fs[1] is not None and cpa is not None else -1
self.free[2] = fs[2] if fs[2] is not None and cpb is not None else -1
self.update_tooltips()
if self.has_device != had_device:
self.location_library.setChecked(True)
self.locations_changed.emit()
if not self.has_device:
self.location_library.trigger()
def update_tooltips(self):
for i, loc in enumerate(('main', 'carda', 'cardb')):
t = self.tooltips[loc]
if self.free[i] > -1:
t += '\n\n%s '%human_readable(self.free[i]) + _('available')
ac = getattr(self, 'location_'+loc)
ac.setToolTip(t)
ac.setWhatsThis(t)
ac.setStatusTip(t)
@property
def has_device(self):
return max(self.free) > -1
@property
def available_actions(self):
ans = [self.location_library]
for i, loc in enumerate(('main', 'carda', 'cardb')):
if self.free[i] > -1:
ans.append(getattr(self, 'location_'+loc))
return ans
# }}}
def search_as_url(text):
if text:
from calibre.gui2.ui import get_gui
db = get_gui().current_db
lid = db.new_api.server_library_id
lid = lid.encode('utf-8').hex()
eq = text.encode('utf-8').hex()
vl = db.data.get_base_restriction_name()
ans = f'calibre://search/_hex_-{lid}?eq={eq}'
if vl:
vl = vl.encode('utf-8').hex()
ans += '&encoded_virtual_library=' + vl
return ans
class SearchBar(QFrame): # {{{
def __init__(self, parent):
QFrame.__init__(self, parent)
self.setFrameStyle(QFrame.Shape.NoFrame)
self.setObjectName('search_bar')
self._layout = l = QHBoxLayout(self)
l.setContentsMargins(0, 4, 0, 4)
x = parent.virtual_library = QToolButton(self)
x.setCursor(Qt.CursorShape.PointingHandCursor)
x.setPopupMode(QToolButton.ToolButtonPopupMode.InstantPopup)
x.setText(_('Virtual library'))
x.setAutoRaise(True)
x.setIcon(QIcon.ic('vl.png'))
x.setObjectName("virtual_library")
x.setToolButtonStyle(Qt.ToolButtonStyle.ToolButtonTextBesideIcon)
l.addWidget(x)
x = QToolButton(self)
x.setToolButtonStyle(Qt.ToolButtonStyle.ToolButtonTextBesideIcon)
x.setAutoRaise(True)
x.setIcon(QIcon.ic('minus.png'))
x.setObjectName('clear_vl')
l.addWidget(x)
x.setVisible(False)
x.setToolTip(_('Close the Virtual library'))
parent.clear_vl = x
parent.sort_button = self.sort_button = sb = QToolButton(self)
sb.setToolButtonStyle(Qt.ToolButtonStyle.ToolButtonTextBesideIcon)
sb.setToolTip(_('Change how the displayed books are sorted'))
sb.setCursor(Qt.CursorShape.PointingHandCursor)
sb.setPopupMode(QToolButton.ToolButtonPopupMode.InstantPopup)
sb.setAutoRaise(True)
sb.setText(_('Sort'))
sb.setIcon(QIcon.ic('sort.png'))
sb.setMenu(QMenu(sb))
sb.menu().aboutToShow.connect(self.populate_sort_menu)
sb.setVisible(False)
l.addWidget(sb)
x = parent.search = SearchBox2(self, as_url=search_as_url)
x.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Minimum)
x.setObjectName("search")
x.setToolTip(_("<p>Search the list of books by title, author, publisher, "
"tags, comments, etc.<br><br>Words separated by spaces are ANDed"))
x.setMinimumContentsLength(10)
l.addWidget(x)
parent.full_text_search_action = ac = parent.search.add_action('fts.png', QLineEdit.ActionPosition.LeadingPosition)
ac.setToolTip('<p>' + _('Search the full text of all books in the library, not just their metadata'))
ac.triggered.connect(self.do_fts)
parent.advanced_search_toggle_action = ac = parent.search.add_action('gear.png', QLineEdit.ActionPosition.LeadingPosition)
parent.addAction(ac)
ac.setToolTip(_('Advanced search'))
parent.keyboard.register_shortcut('advanced search toggle',
_('Advanced search'), default_keys=("Shift+Ctrl+F",),
action=ac)
# This error icon will be placed after the clear button icon
parent.search.parse_error_action = ac = parent.search.add_action('dialog_error.png', QLineEdit.ActionPosition.TrailingPosition)
parent.addAction(ac)
ac.setVisible(False)
self.search_button = QToolButton()
self.search_button.setToolButtonStyle(Qt.ToolButtonStyle.ToolButtonTextOnly)
self.search_button.setIcon(QIcon.ic('search.png'))
self.search_button.setToolButtonStyle(Qt.ToolButtonStyle.ToolButtonTextBesideIcon)
self.search_button.setText(_('Search'))
self.search_button.setAutoRaise(True)
self.search_button.setCursor(Qt.CursorShape.PointingHandCursor)
l.addWidget(self.search_button)
self.search_button.setSizePolicy(QSizePolicy.Policy.Minimum,
QSizePolicy.Policy.Minimum)
self.search_button.clicked.connect(parent.do_search_button)
self.search_button.setToolTip(
_('Do quick search (you can also press the Enter key)'))
x = parent.highlight_only_button = QToolButton(self)
x.setAutoRaise(True)
x.setText(pgettext('mark books matching search result instead of filtering them', 'Highlight'))
x.setCursor(Qt.CursorShape.PointingHandCursor)
x.setToolButtonStyle(Qt.ToolButtonStyle.ToolButtonTextBesideIcon)
x.setIcon(QIcon.ic('arrow-down.png'))
l.addWidget(x)
# Add the searchbar tool buttons to the bar
l.addLayout(self.parent().bars_manager.search_tool_bar)
def populate_sort_menu(self):
from calibre.gui2.ui import get_gui
get_gui().iactions['Sort By'].update_menu(self.sort_button.menu())
def do_fts(self):
from calibre.gui2.ui import get_gui
get_gui().iactions['Full Text Search'].show_fts()
# }}}
class Spacer(QWidget): # {{{
def __init__(self, parent):
QWidget.__init__(self, parent)
self.l = QHBoxLayout()
self.setLayout(self.l)
self.l.addStretch(10)
# }}}
class MainWindowMixin: # {{{
def __init__(self, *args, **kwargs):
pass
def init_main_window_mixin(self):
self.setObjectName('MainWindow')
self.setWindowIcon(QIcon.ic('lt.png'))
self.setWindowTitle(__appname__)
self.setContextMenuPolicy(Qt.ContextMenuPolicy.NoContextMenu)
self.centralwidget = QWidget(self)
self.setCentralWidget(self.centralwidget)
self._central_widget_layout = l = QVBoxLayout(self.centralwidget)
l.setContentsMargins(0, 0, 0, 0)
l.setSpacing(0)
self.resize(1012, 740)
self.location_manager = LocationManager(self)
self.iactions['Fetch News'].init_scheduler()
self.bars_manager = BarsManager(self.donate_action,
self.location_manager, self)
# instantiating SearchBar must happen after setting bars manager
self.search_bar = SearchBar(self)
for bar in self.bars_manager.main_bars:
self.addToolBar(Qt.ToolBarArea.TopToolBarArea, bar)
bar.setStyleSheet('QToolBar { border: 0px }')
for bar in self.bars_manager.child_bars:
self.addToolBar(Qt.ToolBarArea.BottomToolBarArea, bar)
bar.setStyleSheet('QToolBar { border: 0px }')
self.bars_manager.update_bars()
# This is disabled because it introduces various toolbar related bugs
# The width of the toolbar becomes the sum of both toolbars
if tweaks['unified_title_toolbar_on_osx']:
try:
self.setUnifiedTitleAndToolBarOnMac(True)
except AttributeError:
pass # PyQt seems to be missing this property
# And now, start adding the real widgets
l.addWidget(self.search_bar)
# Add in the widget for the shutdown messages. It is invisible until a
# message is shown
smw = self.shutdown_message_widget = QLabel(self)
smw.setAlignment(Qt.AlignmentFlag.AlignCenter)
smw.setVisible(False)
smw.setAutoFillBackground(True)
def show_shutdown_message(self, message=''):
smw = self.shutdown_message_widget
bg, fg = 200, 'black'
if QApplication.instance().is_dark_theme:
bg, fg = 30, 'lightgray'
smw.setStyleSheet(f'QLabel {{ background-color: rgba({bg}, {bg}, {bg}, 200); color: {fg} }}')
smw.setGeometry(0, 0, self.width(), self.height())
smw.setVisible(True)
smw.raise_()
smw.setText(_('<h2>Shutting down</h2><div>') + message)
# Force processing the events needed to show the message
QCoreApplication.processEvents()
# }}}
| 13,999 | Python | .py | 317 | 34.567823 | 135 | 0.621872 | kovidgoyal/calibre | 19,243 | 2,250 | 4 | GPL-3.0 | 9/5/2024, 5:13:50 PM (Europe/Amsterdam) |
26,642 | custom_column_widgets.py | kovidgoyal_calibre/src/calibre/gui2/custom_column_widgets.py | #!/usr/bin/env python
__license__ = 'GPL v3'
__copyright__ = '2010, Kovid Goyal <kovid@kovidgoyal.net>'
__docformat__ = 'restructuredtext en'
import os
from collections import OrderedDict
from functools import partial
from qt.core import (
QApplication,
QCheckBox,
QComboBox,
QDialog,
QDoubleSpinBox,
QGridLayout,
QGroupBox,
QHBoxLayout,
QIcon,
QLabel,
QLineEdit,
QMessageBox,
QPlainTextEdit,
QSizePolicy,
QSpacerItem,
QSpinBox,
QStyle,
Qt,
QToolButton,
QUrl,
QVBoxLayout,
QWidget,
)
from calibre.ebooks.metadata import title_sort
from calibre.gui2 import UNDEFINED_QDATETIME, elided_text, error_dialog, gprefs
from calibre.gui2.comments_editor import Editor as CommentsEditor
from calibre.gui2.complete2 import EditWithComplete as EWC
from calibre.gui2.dialogs.tag_editor import TagEditor
from calibre.gui2.library.delegates import ClearingDoubleSpinBox, ClearingSpinBox
from calibre.gui2.markdown_editor import Editor as MarkdownEditor
from calibre.gui2.widgets2 import DateTimeEdit as DateTimeEditBase
from calibre.gui2.widgets2 import RatingEditor
from calibre.library.comments import comments_to_html
from calibre.utils.config import tweaks
from calibre.utils.date import as_local_time, as_utc, internal_iso_format_string, is_date_undefined, now, qt_from_dt, qt_to_dt
from calibre.utils.icu import lower as icu_lower
from calibre.utils.icu import sort_key
class EditWithComplete(EWC):
def __init__(self, *a, **kw):
super().__init__(*a, **kw)
self.set_clear_button_enabled(False)
def safe_disconnect(signal):
try:
signal.disconnect()
except Exception:
pass
def label_string(txt):
if txt:
try:
if txt[0].isalnum():
return '&' + txt
except:
pass
return txt
def get_tooltip(col_metadata, add_index=False):
key = col_metadata['label'] + ('_index' if add_index else '')
label = col_metadata['name'] + (_(' index') if add_index else '')
description = col_metadata.get('display', {}).get('description', '')
return '{} (#{}){} {}'.format(
label, key, ':' if description else '', description).strip()
class Base:
def __init__(self, db, col_id, parent=None):
self.db, self.col_id = db, col_id
self.book_id = None
self.col_metadata = db.custom_column_num_map[col_id]
self.initial_val = self.widgets = None
self.signals_to_disconnect = []
self.setup_ui(parent)
description = get_tooltip(self.col_metadata)
try:
self.widgets[0].setToolTip(description)
self.widgets[1].setToolTip(description)
except:
try:
self.widgets[1].setToolTip(description)
except:
pass
def finish_ui_setup(self, parent, edit_widget):
self.was_none = False
w = QWidget(parent)
self.widgets.append(w)
l = QHBoxLayout()
l.setContentsMargins(0, 0, 0, 0)
w.setLayout(l)
self.editor = editor = edit_widget(parent)
l.addWidget(editor)
self.clear_button = QToolButton(parent)
self.clear_button.setIcon(QIcon.ic('trash.png'))
self.clear_button.clicked.connect(self.set_to_undefined)
self.clear_button.setToolTip(_('Clear {0}').format(self.col_metadata['name']))
l.addWidget(self.clear_button)
def initialize(self, book_id):
self.book_id = book_id
val = self.db.get_custom(book_id, num=self.col_id, index_is_id=True)
val = self.normalize_db_val(val)
self.setter(val)
self.initial_val = self.current_val # self.current_val might be different from val thanks to normalization
@property
def current_val(self):
return self.normalize_ui_val(self.gui_val)
@property
def gui_val(self):
return self.getter()
def commit(self, book_id, notify=False):
val = self.current_val
if val != self.initial_val:
return self.db.set_custom(book_id, val, num=self.col_id,
notify=notify, commit=False, allow_case_change=True)
else:
return set()
def apply_to_metadata(self, mi):
mi.set('#' + self.col_metadata['label'], self.current_val)
def normalize_db_val(self, val):
return val
def normalize_ui_val(self, val):
return val
def break_cycles(self):
self.db = self.widgets = self.initial_val = None
for signal in self.signals_to_disconnect:
safe_disconnect(signal)
self.signals_to_disconnect = []
def connect_data_changed(self, slot):
pass
def values_changed(self):
return self.getter() != self.initial_val and (self.getter() or self.initial_val)
def edit(self):
if self.values_changed():
d = _save_dialog(self.parent, _('Values changed'),
_('You have changed the values. In order to use this '
'editor, you must either discard or apply these '
'changes. Apply changes?'))
if d == QMessageBox.StandardButton.Cancel:
return
if d == QMessageBox.StandardButton.Yes:
self.commit(self.book_id)
self.db.commit()
self.initial_val = self.current_val
else:
self.setter(self.initial_val)
from calibre.gui2.ui import get_gui
get_gui().do_tags_list_edit(None, self.key)
self.initialize(self.book_id)
class SimpleText(Base):
def setup_ui(self, parent):
self.widgets = [QLabel(label_string(self.col_metadata['name']), parent),]
self.finish_ui_setup(parent, QLineEdit)
def set_to_undefined(self):
self.editor.setText('')
def setter(self, val):
self.editor.setText(str(val or ''))
def getter(self):
return self.editor.text().strip()
def connect_data_changed(self, slot):
self.editor.textChanged.connect(slot)
self.signals_to_disconnect.append(self.editor.textChanged)
class LongText(Base):
def setup_ui(self, parent):
self._box = QGroupBox(parent)
self._box.setTitle(label_string(self.col_metadata['name']))
self._layout = QVBoxLayout()
self._tb = QPlainTextEdit(self._box)
self._tb.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Minimum)
self._layout.addWidget(self._tb)
self._box.setLayout(self._layout)
self.widgets = [self._box]
def setter(self, val):
self._tb.setPlainText(str(val or ''))
def getter(self):
return self._tb.toPlainText()
def connect_data_changed(self, slot):
self._tb.textChanged.connect(slot)
self.signals_to_disconnect.append(self._tb.textChanged)
class Bool(Base):
def setup_ui(self, parent):
name = self.col_metadata['name']
self.widgets = [QLabel(label_string(name), parent)]
w = QWidget(parent)
self.widgets.append(w)
l = QHBoxLayout()
l.setContentsMargins(0, 0, 0, 0)
w.setLayout(l)
self.combobox = QComboBox(parent)
l.addWidget(self.combobox)
c = QToolButton(parent)
c.setIcon(QIcon.ic('ok.png'))
c.setToolTip(_('Set {} to yes').format(name))
l.addWidget(c)
c.clicked.connect(self.set_to_yes)
c = QToolButton(parent)
c.setIcon(QIcon.ic('list_remove.png'))
c.setToolTip(_('Set {} to no').format(name))
l.addWidget(c)
c.clicked.connect(self.set_to_no)
if self.db.new_api.pref('bools_are_tristate'):
c = QToolButton(parent)
c.setIcon(QIcon.ic('trash.png'))
c.setToolTip(_('Clear {}').format(name))
l.addWidget(c)
c.clicked.connect(self.set_to_cleared)
w = self.combobox
items = [_('Yes'), _('No'), _('Undefined')]
icons = ['ok.png', 'list_remove.png', 'blank.png']
if not self.db.new_api.pref('bools_are_tristate'):
items = items[:-1]
icons = icons[:-1]
for icon, text in zip(icons, items):
w.addItem(QIcon.ic(icon), text)
def setter(self, val):
val = {None: 2, False: 1, True: 0}[val]
if not self.db.new_api.pref('bools_are_tristate') and val == 2:
val = 1
self.combobox.setCurrentIndex(val)
def getter(self):
val = self.combobox.currentIndex()
return {2: None, 1: False, 0: True}[val]
def set_to_yes(self):
self.combobox.setCurrentIndex(0)
def set_to_no(self):
self.combobox.setCurrentIndex(1)
def set_to_cleared(self):
self.combobox.setCurrentIndex(2)
def connect_data_changed(self, slot):
self.combobox.currentTextChanged.connect(slot)
self.signals_to_disconnect.append(self.combobox.currentTextChanged)
class Int(Base):
def setup_ui(self, parent):
self.widgets = [QLabel(label_string(self.col_metadata['name']), parent)]
self.finish_ui_setup(parent, ClearingSpinBox)
self.editor.setRange(-1000000, 100000000)
def finish_ui_setup(self, parent, edit_widget):
Base.finish_ui_setup(self, parent, edit_widget)
self.editor.setSpecialValueText(_('Undefined'))
self.editor.setSingleStep(1)
self.editor.valueChanged.connect(self.valueChanged)
def setter(self, val):
if val is None:
val = self.editor.minimum()
self.editor.setValue(val)
self.was_none = val == self.editor.minimum()
def getter(self):
val = self.editor.value()
if val == self.editor.minimum():
val = None
return val
def valueChanged(self, to_what):
if self.was_none and to_what == -999999:
self.setter(0)
self.was_none = to_what == self.editor.minimum()
def connect_data_changed(self, slot):
self.editor.valueChanged.connect(slot)
self.signals_to_disconnect.append(self.editor.valueChanged)
def set_to_undefined(self):
self.editor.setValue(-1000000)
class Float(Int):
def setup_ui(self, parent):
self.widgets = [QLabel(label_string(self.col_metadata['name']), parent)]
self.finish_ui_setup(parent, ClearingDoubleSpinBox)
self.editor.setRange(-1000000., float(100000000))
self.editor.setDecimals(int(self.col_metadata['display'].get('decimals', 2)))
class Rating(Base):
def setup_ui(self, parent):
allow_half_stars = self.col_metadata['display'].get('allow_half_stars', False)
self.widgets = [QLabel(label_string(self.col_metadata['name']), parent)]
self.finish_ui_setup(parent, partial(RatingEditor, is_half_star=allow_half_stars))
def set_to_undefined(self):
self.editor.setCurrentIndex(0)
def setter(self, val):
val = max(0, min(int(val or 0), 10))
self.editor.rating_value = val
def getter(self):
return self.editor.rating_value or None
def connect_data_changed(self, slot):
self.editor.currentTextChanged.connect(slot)
self.signals_to_disconnect.append(self.editor.currentTextChanged)
class DateTimeEdit(DateTimeEditBase):
def focusInEvent(self, x):
self.setSpecialValueText('')
DateTimeEditBase.focusInEvent(self, x)
def focusOutEvent(self, x):
self.setSpecialValueText(_('Undefined'))
DateTimeEditBase.focusOutEvent(self, x)
def set_to_today(self):
self.setDateTime(qt_from_dt(now()))
def set_to_clear(self):
self.setDateTime(UNDEFINED_QDATETIME)
class DateTime(Base):
def setup_ui(self, parent):
cm = self.col_metadata
self.widgets = [QLabel(label_string(cm['name']), parent)]
w = QWidget(parent)
self.widgets.append(w)
l = QHBoxLayout()
l.setContentsMargins(0, 0, 0, 0)
w.setLayout(l)
self.dte = dte = DateTimeEdit(parent)
format_ = cm['display'].get('date_format','')
if not format_:
format_ = 'dd MMM yyyy hh:mm'
elif format_ == 'iso':
format_ = internal_iso_format_string()
dte.setDisplayFormat(format_)
dte.setCalendarPopup(True)
dte.setMinimumDateTime(UNDEFINED_QDATETIME)
dte.setSpecialValueText(_('Undefined'))
l.addWidget(dte)
self.today_button = QToolButton(parent)
self.today_button.setText(_('Today'))
self.today_button.clicked.connect(dte.set_to_today)
l.addWidget(self.today_button)
self.clear_button = QToolButton(parent)
self.clear_button.setIcon(QIcon.ic('trash.png'))
self.clear_button.clicked.connect(dte.set_to_clear)
self.clear_button.setToolTip(_('Clear {0}').format(self.col_metadata['name']))
l.addWidget(self.clear_button)
self.connect_data_changed(self.set_tooltip)
def set_tooltip(self, val):
if is_date_undefined(val):
self.dte.setToolTip(get_tooltip(self.col_metadata, False))
else:
self.dte.setToolTip(get_tooltip(self.col_metadata, False) + '\n' +
_('Exact time: {}').format(as_local_time(qt_to_dt(val))))
def setter(self, val):
if val is None:
val = self.dte.minimumDateTime()
else:
val = qt_from_dt(val)
self.dte.setDateTime(val)
def getter(self):
val = self.dte.dateTime()
if is_date_undefined(val):
val = None
else:
val = qt_to_dt(val)
return val
def normalize_db_val(self, val):
return as_local_time(val) if val is not None else None
def normalize_ui_val(self, val):
return as_utc(val) if val is not None else None
def connect_data_changed(self, slot):
self.dte.dateTimeChanged.connect(slot)
self.signals_to_disconnect.append(self.dte.dateTimeChanged)
class Comments(Base):
def setup_ui(self, parent):
self._box = QGroupBox(parent)
self._box.setTitle(label_string(self.col_metadata['name']))
self._layout = QVBoxLayout()
self._tb = CommentsEditor(self._box, toolbar_prefs_name='metadata-comments-editor-widget-hidden-toolbars')
self._tb.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Minimum)
# self._tb.setTabChangesFocus(True)
self._layout.addWidget(self._tb)
self._box.setLayout(self._layout)
self.widgets = [self._box]
def initialize(self, book_id):
path = self.db.abspath(book_id, index_is_id=True)
if path:
self._tb.set_base_url(QUrl.fromLocalFile(os.path.join(path, 'metadata.html')))
return Base.initialize(self, book_id)
def setter(self, val):
if not val or not val.strip():
val = ''
else:
val = comments_to_html(val)
self._tb.html = val
self._tb.wyswyg_dirtied()
def getter(self):
val = str(self._tb.html).strip()
if not val:
val = None
return val
@property
def tab(self):
return self._tb.tab
@tab.setter
def tab(self, val):
self._tb.tab = val
def connect_data_changed(self, slot):
self._tb.data_changed.connect(slot)
self.signals_to_disconnect.append(self._tb.data_changed)
class Markdown(Base):
def setup_ui(self, parent):
self._box = QGroupBox(parent)
self._box.setTitle(label_string(self.col_metadata['name']))
self._layout = QVBoxLayout()
self._tb = MarkdownEditor(self._box)
self._tb.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Minimum)
# self._tb.setTabChangesFocus(True)
self._layout.addWidget(self._tb)
self._box.setLayout(self._layout)
self.widgets = [self._box]
def initialize(self, book_id):
path = self.db.abspath(book_id, index_is_id=True)
if path:
self._tb.set_base_url(QUrl.fromLocalFile(os.path.join(path, 'metadata.html')))
return super().initialize(book_id)
def setter(self, val):
self._tb.markdown = str(val or '').strip()
def getter(self):
val = self._tb.markdown.strip()
if not val:
val = None
return val
@property
def tab(self):
return self._tb.tab
@tab.setter
def tab(self, val):
self._tb.tab = val
def connect_data_changed(self, slot):
self._tb.editor.textChanged.connect(slot)
self.signals_to_disconnect.append(self._tb.editor.textChanged)
class MultipleWidget(QWidget):
def __init__(self, parent, only_manage_items=False, widget=EditWithComplete, name=None):
QWidget.__init__(self, parent)
layout = QHBoxLayout()
layout.setSpacing(5)
layout.setContentsMargins(0, 0, 0, 0)
self.edit_widget = widget(parent)
layout.addWidget(self.edit_widget, stretch=1000)
self.editor_button = QToolButton(self)
if name is None:
name = _('items')
if only_manage_items:
self.editor_button.setToolTip(_('Open the Manage {} window').format(name))
else:
self.editor_button.setToolTip(_('Open the {0} editor. If Ctrl or Shift '
'is pressed, open the Manage {0} window').format(name))
self.editor_button.setIcon(QIcon.ic('chapters.png'))
layout.addWidget(self.editor_button)
self.setLayout(layout)
def get_editor_button(self):
return self.editor_button
def update_items_cache(self, values):
self.edit_widget.update_items_cache(values)
def clear(self):
self.edit_widget.clear()
def setEditText(self):
self.edit_widget.setEditText()
def addItem(self, itm):
self.edit_widget.addItem(itm)
def set_separator(self, sep):
self.edit_widget.set_separator(sep)
def set_add_separator(self, sep):
self.edit_widget.set_add_separator(sep)
def set_space_before_sep(self, v):
self.edit_widget.set_space_before_sep(v)
def setSizePolicy(self, v1, v2):
self.edit_widget.setSizePolicy(v1, v2)
def setText(self, v):
self.edit_widget.setText(v)
def text(self):
return self.edit_widget.text()
def _save_dialog(parent, title, msg, det_msg=''):
d = QMessageBox(parent)
d.setWindowTitle(title)
d.setText(msg)
d.setStandardButtons(QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No | QMessageBox.StandardButton.Cancel)
return d.exec()
class Text(Base):
def setup_ui(self, parent):
self.sep = self.col_metadata['multiple_seps']
self.key = self.db.field_metadata.label_to_key(self.col_metadata['label'],
prefer_custom=True)
self.parent = parent
if self.col_metadata['is_multiple']:
w = MultipleWidget(parent, name=self.col_metadata['name'])
w.set_separator(self.sep['ui_to_list'])
if self.sep['ui_to_list'] == '&':
w.set_space_before_sep(True)
w.set_add_separator(tweaks['authors_completer_append_separator'])
w.get_editor_button().clicked.connect(self.edit)
else:
w = MultipleWidget(parent, only_manage_items=True, name=self.col_metadata['name'])
w.set_separator(None)
w.get_editor_button().clicked.connect(super().edit)
w.setSizePolicy(QSizePolicy.Policy.Minimum, QSizePolicy.Policy.Fixed)
self.set_to_undefined = w.clear
self.widgets = [QLabel(label_string(self.col_metadata['name']), parent)]
self.finish_ui_setup(parent, lambda parent: w)
def initialize(self, book_id):
values = list(self.db.all_custom(num=self.col_id))
values.sort(key=sort_key)
self.book_id = book_id
self.editor.clear()
self.editor.update_items_cache(values)
val = self.db.get_custom(book_id, num=self.col_id, index_is_id=True)
if isinstance(val, list):
if not self.col_metadata.get('display', {}).get('is_names', False):
val.sort(key=sort_key)
val = self.normalize_db_val(val)
if self.col_metadata['is_multiple']:
self.setter(val)
else:
self.editor.setText(val)
self.initial_val = self.current_val
def setter(self, val):
if self.col_metadata['is_multiple']:
if not val:
val = []
self.editor.setText(self.sep['list_to_ui'].join(val))
def getter(self):
val = str(self.editor.text()).strip()
if self.col_metadata['is_multiple']:
ans = [x.strip() for x in val.split(self.sep['ui_to_list']) if x.strip()]
if not ans:
ans = None
return ans
if not val:
val = None
return val
def edit(self):
ctrl_or_shift_pressed = (QApplication.keyboardModifiers() &
(Qt.KeyboardModifier.ControlModifier | Qt.KeyboardModifier.ShiftModifier))
if (self.getter() != self.initial_val and (self.getter() or self.initial_val)):
d = _save_dialog(self.parent, _('Values changed'),
_('You have changed the values. In order to use this '
'editor, you must either discard or apply these '
'changes. Apply changes?'))
if d == QMessageBox.StandardButton.Cancel:
return
if d == QMessageBox.StandardButton.Yes:
self.commit(self.book_id)
self.db.commit()
self.initial_val = self.current_val
else:
self.setter(self.initial_val)
if ctrl_or_shift_pressed:
from calibre.gui2.ui import get_gui
get_gui().do_tags_list_edit(None, self.key)
self.initialize(self.book_id)
else:
d = TagEditor(self.parent, self.db, self.book_id, self.key)
if d.exec() == QDialog.DialogCode.Accepted:
self.setter(d.tags)
def connect_data_changed(self, slot):
s = self.editor.edit_widget.currentTextChanged
s.connect(slot)
self.signals_to_disconnect.append(s)
class Series(Base):
def setup_ui(self, parent):
self.parent = parent
self.key = self.db.field_metadata.label_to_key(self.col_metadata['label'],
prefer_custom=True)
w = MultipleWidget(parent, only_manage_items=True, name=self.col_metadata['name'])
w.get_editor_button().clicked.connect(self.edit)
w.setSizePolicy(QSizePolicy.Policy.Minimum, QSizePolicy.Policy.Fixed)
self.set_to_undefined = w.clear
w.set_separator(None)
self.name_widget = w.edit_widget
self.widgets = [QLabel(label_string(self.col_metadata['name']), parent)]
self.finish_ui_setup(parent, lambda parent: w)
self.name_widget.editTextChanged.connect(self.series_changed)
w = QLabel(label_string(self.col_metadata['name'])+_(' index'), parent)
w.setToolTip(get_tooltip(self.col_metadata, add_index=True))
self.widgets.append(w)
w = QDoubleSpinBox(parent)
w.setRange(-10000., float(100000000))
w.setDecimals(2)
w.setSingleStep(1)
self.idx_widget=w
w.setToolTip(get_tooltip(self.col_metadata, add_index=True))
self.widgets.append(w)
def set_to_undefined(self):
self.name_widget.clearEditText()
self.idx_widget.setValue(1.0)
def initialize(self, book_id):
self.book_id = book_id
values = list(self.db.all_custom(num=self.col_id))
values.sort(key=sort_key)
val = self.db.get_custom(book_id, num=self.col_id, index_is_id=True)
s_index = self.db.get_custom_extra(book_id, num=self.col_id, index_is_id=True)
try:
s_index = float(s_index)
except (ValueError, TypeError):
s_index = 1.0
self.idx_widget.setValue(s_index)
val = self.normalize_db_val(val)
self.name_widget.blockSignals(True)
self.name_widget.update_items_cache(values)
self.name_widget.setText(val)
self.name_widget.blockSignals(False)
self.initial_val, self.initial_index = self.current_val
def getter(self):
n = str(self.name_widget.currentText()).strip()
i = self.idx_widget.value()
return n, i
def series_changed(self, val):
val, s_index = self.gui_val
if tweaks['series_index_auto_increment'] == 'no_change':
pass
elif tweaks['series_index_auto_increment'] == 'const':
s_index = 1.0
else:
s_index = self.db.get_next_cc_series_num_for(val,
num=self.col_id)
self.idx_widget.setValue(s_index)
def values_changed(self):
val, s_index = self.current_val
return val != self.initial_val or s_index != self.initial_index
@property
def current_val(self):
val, s_index = self.gui_val
val = self.normalize_ui_val(val)
return val, s_index
def commit(self, book_id, notify=False):
val, s_index = self.current_val
if val != self.initial_val or s_index != self.initial_index:
if not val:
val = s_index = None
return self.db.set_custom(book_id, val, extra=s_index, num=self.col_id,
notify=notify, commit=False, allow_case_change=True)
else:
return set()
def apply_to_metadata(self, mi):
val, s_index = self.current_val
mi.set('#' + self.col_metadata['label'], val, extra=s_index)
def connect_data_changed(self, slot):
for s in self.name_widget.editTextChanged, self.idx_widget.valueChanged:
s.connect(slot)
self.signals_to_disconnect.append(s)
class Enumeration(Base):
def setup_ui(self, parent):
self.parent = parent
self.key = self.db.field_metadata.label_to_key(self.col_metadata['label'],
prefer_custom=True)
w = MultipleWidget(parent, only_manage_items=True, widget=QComboBox, name=self.col_metadata['name'])
w.get_editor_button().clicked.connect(self.edit)
w.setSizePolicy(QSizePolicy.Policy.Minimum, QSizePolicy.Policy.Fixed)
self.set_to_undefined = w.clear
self.name_widget = w.edit_widget
self.widgets = [QLabel(label_string(self.col_metadata['name']), parent)]
self.finish_ui_setup(parent, lambda parent: w)
self.editor = self.name_widget
vals = self.col_metadata['display']['enum_values']
self.editor.addItem('')
for v in vals:
self.editor.addItem(v)
def initialize(self, book_id):
self.book_id = book_id
val = self.db.get_custom(book_id, num=self.col_id, index_is_id=True)
val = self.normalize_db_val(val)
idx = self.editor.findText(val)
if idx < 0:
error_dialog(self.parent, '',
_('The enumeration "{0}" contains an invalid value '
'that will be set to the default').format(
self.col_metadata['name']),
show=True, show_copy_button=False)
idx = 0
self.editor.setCurrentIndex(idx)
self.initial_val = val
def setter(self, val):
self.editor.setCurrentIndex(self.editor.findText(val))
def getter(self):
return str(self.editor.currentText())
def normalize_db_val(self, val):
if val is None:
val = ''
return val
def normalize_ui_val(self, val):
if not val:
val = None
return val
def set_to_undefined(self):
self.editor.setCurrentIndex(0)
def connect_data_changed(self, slot):
self.editor.currentIndexChanged.connect(slot)
self.signals_to_disconnect.append(self.editor.currentIndexChanged)
def comments_factory(db, key, parent):
fm = db.custom_column_num_map[key]
ctype = fm.get('display', {}).get('interpret_as', 'html')
if ctype == 'short-text':
return SimpleText(db, key, parent)
if ctype == 'long-text':
return LongText(db, key, parent)
if ctype == 'markdown':
return Markdown(db, key, parent)
return Comments(db, key, parent)
widgets = {
'bool' : Bool,
'rating' : Rating,
'int': Int,
'float': Float,
'datetime': DateTime,
'text' : Text,
'comments': comments_factory,
'series': Series,
'enumeration': Enumeration
}
def field_sort_key(y, fm=None):
m1 = fm[y]
name = icu_lower(m1['name'])
n1 = 'zzzzz' + name if column_is_comments(y, fm) else name
return sort_key(n1)
def column_is_comments(key, fm):
return (fm[key]['datatype'] == 'comments' and
fm[key].get('display', {}).get('interpret_as') != 'short-text')
def get_field_list(db, use_defaults=False, pref_data_override=None):
fm = db.field_metadata
fields = fm.custom_field_keys(include_composites=False)
if pref_data_override is not None:
displayable = pref_data_override
else:
displayable = db.prefs.get('edit_metadata_custom_columns_to_display', None)
if use_defaults or displayable is None:
fields.sort(key=partial(field_sort_key, fm=fm))
return [(k, True) for k in fields]
else:
field_set = set(fields)
result = OrderedDict({k:v for k,v in displayable if k in field_set})
for k in fields:
if k not in result:
result[k] = True
return [(k,v) for k,v in result.items()]
def get_custom_columns_to_display_in_editor(db):
return list([k[0] for k in
get_field_list(db, use_defaults=db.prefs['edit_metadata_ignore_display_order']) if k[1]])
def populate_metadata_page(layout, db, book_id, bulk=False, two_column=False, parent=None):
def widget_factory(typ, key):
if bulk:
w = bulk_widgets[typ](db, key, parent)
else:
w = widgets[typ](db, key, parent)
if book_id is not None:
w.initialize(book_id)
return w
fm = db.field_metadata
# Get list of all non-composite custom fields. We must make widgets for these
cols = get_custom_columns_to_display_in_editor(db)
# This deals with the historical behavior where comments fields go to the
# bottom, starting on the left hand side. If a comment field is moved to
# somewhere else then it isn't moved to either side.
comments_at_end = 0
for k in cols[::-1]:
if not column_is_comments(k, fm):
break
comments_at_end += 1
comments_not_at_end = len([k for k in cols if column_is_comments(k, fm)]) - comments_at_end
count = len(cols)
layout_rows_for_comments = 9
if two_column:
turnover_point = int(((count - comments_at_end + 1) +
int(comments_not_at_end*(layout_rows_for_comments-1)))/2)
else:
# Avoid problems with multi-line widgets
turnover_point = count + 1000
ans = []
column = row = base_row = max_row = 0
label_width = 0
do_elision = gprefs['edit_metadata_elide_labels']
elide_pos = gprefs['edit_metadata_elision_point']
elide_pos = elide_pos if elide_pos in {'left', 'middle', 'right'} else 'right'
# make room on the right side for the scrollbar
sb_width = QApplication.instance().style().pixelMetric(QStyle.PixelMetric.PM_ScrollBarExtent)
layout.setContentsMargins(0, 0, sb_width, 0)
for key in cols:
if not fm[key]['is_editable']:
continue # The job spy plugin can change is_editable
dt = fm[key]['datatype']
if dt == 'composite' or (bulk and dt == 'comments'):
continue
is_comments = column_is_comments(key, fm)
w = widget_factory(dt, fm[key]['colnum'])
ans.append(w)
if two_column and is_comments:
# Here for compatibility with old layout. Comments always started
# in the left column
comments_not_at_end -= 1
# no special processing if the comment field was named in the tweak
if comments_not_at_end < 0 and comments_at_end > 0:
# Force a turnover, adding comments widgets below max_row.
# Save the row to return to if we turn over again
column = 0
row = max_row
base_row = row
turnover_point = row + int((comments_at_end * layout_rows_for_comments)/2)
comments_at_end = 0
l = QGridLayout()
if is_comments:
layout.addLayout(l, row, column, layout_rows_for_comments, 1)
layout.setColumnStretch(column, 100)
row += layout_rows_for_comments
else:
layout.addLayout(l, row, column, 1, 1)
layout.setColumnStretch(column, 100)
row += 1
for c in range(0, len(w.widgets), 2):
if not is_comments:
# Set the label column width to a fixed size. Elide labels that
# don't fit
wij = w.widgets[c]
if label_width == 0:
font_metrics = wij.fontMetrics()
colon_width = font_metrics.horizontalAdvance(':')
if bulk:
label_width = (font_metrics.averageCharWidth() *
gprefs['edit_metadata_bulk_cc_label_length']) - colon_width
else:
label_width = (font_metrics.averageCharWidth() *
gprefs['edit_metadata_single_cc_label_length']) - colon_width
wij.setMaximumWidth(label_width)
if c == 0:
wij.setSizePolicy(QSizePolicy.Policy.Maximum, QSizePolicy.Policy.Preferred)
l.setColumnMinimumWidth(0, label_width)
wij.setAlignment(Qt.AlignmentFlag.AlignRight|Qt.AlignmentFlag.AlignVCenter)
t = str(wij.text())
if t:
if do_elision:
wij.setText(elided_text(t, font=font_metrics,
width=label_width, pos=elide_pos) + ':')
else:
wij.setText(t + ':')
wij.setWordWrap(True)
wij.setBuddy(w.widgets[c+1])
l.addWidget(wij, c, 0)
l.addWidget(w.widgets[c+1], c, 1)
else:
l.addWidget(w.widgets[0], 0, 0, 1, 2)
max_row = max(max_row, row)
if row >= turnover_point:
column = 1
turnover_point = count + 1000
row = base_row
items = []
if len(ans) > 0:
items.append(QSpacerItem(10, 10, QSizePolicy.Policy.Minimum,
QSizePolicy.Policy.Expanding))
layout.addItem(items[-1], layout.rowCount(), 0, 1, 1)
layout.setRowStretch(layout.rowCount()-1, 100)
return ans, items
class BulkBase(Base):
@property
def gui_val(self):
if not hasattr(self, '_cached_gui_val_'):
self._cached_gui_val_ = self.getter()
return self._cached_gui_val_
def get_initial_value(self, book_ids):
values = set()
for book_id in book_ids:
val = self.db.get_custom(book_id, num=self.col_id, index_is_id=True)
if isinstance(val, list):
val = frozenset(val)
values.add(val)
if len(values) > 1:
break
ans = None
if len(values) == 1:
ans = next(iter(values))
if isinstance(ans, frozenset):
ans = list(ans)
return ans
def finish_ui_setup(self, parent, is_bool=False, add_edit_tags_button=(False,)):
self.was_none = False
l = self.widgets[1].layout()
if not is_bool or self.bools_are_tristate:
self.clear_button = QToolButton(parent)
self.clear_button.setIcon(QIcon.ic('trash.png'))
self.clear_button.setToolTip(_('Clear {0}').format(self.col_metadata['name']))
self.clear_button.clicked.connect(self.set_to_undefined)
l.insertWidget(1, self.clear_button)
if is_bool:
self.set_no_button = QToolButton(parent)
self.set_no_button.setIcon(QIcon.ic('list_remove.png'))
self.set_no_button.clicked.connect(lambda:self.main_widget.setCurrentIndex(1))
self.set_no_button.setToolTip(_('Set {0} to No').format(self.col_metadata['name']))
l.insertWidget(1, self.set_no_button)
self.set_yes_button = QToolButton(parent)
self.set_yes_button.setIcon(QIcon.ic('ok.png'))
self.set_yes_button.clicked.connect(lambda:self.main_widget.setCurrentIndex(0))
self.set_yes_button.setToolTip(_('Set {0} to Yes').format(self.col_metadata['name']))
l.insertWidget(1, self.set_yes_button)
if add_edit_tags_button[0]:
self.edit_tags_button = QToolButton(parent)
self.edit_tags_button.setToolTip(_('Open Item editor'))
self.edit_tags_button.setIcon(QIcon.ic('chapters.png'))
self.edit_tags_button.clicked.connect(add_edit_tags_button[1])
l.insertWidget(1, self.edit_tags_button)
l.insertStretch(2)
def initialize(self, book_ids):
self.initial_val = val = self.get_initial_value(book_ids)
val = self.normalize_db_val(val)
self.setter(val)
def commit(self, book_ids, notify=False):
if not self.a_c_checkbox.isChecked():
return
val = self.gui_val
val = self.normalize_ui_val(val)
self.db.set_custom_bulk(book_ids, val, num=self.col_id, notify=notify)
def make_widgets(self, parent, main_widget_class):
w = QWidget(parent)
self.widgets = [QLabel(label_string(self.col_metadata['name']), w), w]
l = QHBoxLayout()
l.setContentsMargins(0, 0, 0, 0)
w.setLayout(l)
self.main_widget = main_widget_class(w)
l.addWidget(self.main_widget)
l.setStretchFactor(self.main_widget, 10)
self.a_c_checkbox = QCheckBox(_('Apply changes'), w)
l.addWidget(self.a_c_checkbox)
self.ignore_change_signals = True
# connect to the various changed signals so we can auto-update the
# apply changes checkbox
if hasattr(self.main_widget, 'editTextChanged'):
# editable combobox widgets
self.main_widget.editTextChanged.connect(self.a_c_checkbox_changed)
if hasattr(self.main_widget, 'textChanged'):
# lineEdit widgets
self.main_widget.textChanged.connect(self.a_c_checkbox_changed)
if hasattr(self.main_widget, 'currentIndexChanged'):
# combobox widgets
self.main_widget.currentIndexChanged.connect(self.a_c_checkbox_changed)
if hasattr(self.main_widget, 'valueChanged'):
# spinbox widgets
self.main_widget.valueChanged.connect(self.a_c_checkbox_changed)
if hasattr(self.main_widget, 'dateTimeChanged'):
# dateEdit widgets
self.main_widget.dateTimeChanged.connect(self.a_c_checkbox_changed)
def a_c_checkbox_changed(self):
if not self.ignore_change_signals:
self.a_c_checkbox.setChecked(True)
class BulkBool(BulkBase, Bool):
def get_initial_value(self, book_ids):
value = None
for book_id in book_ids:
val = self.db.get_custom(book_id, num=self.col_id, index_is_id=True)
if not self.db.new_api.pref('bools_are_tristate') and val is None:
val = False
if value is not None and value != val:
return None
value = val
return value
def setup_ui(self, parent):
self.make_widgets(parent, QComboBox)
items = [_('Yes'), _('No')]
self.bools_are_tristate = self.db.new_api.pref('bools_are_tristate')
if not self.bools_are_tristate:
items.append('')
else:
items.append(_('Undefined'))
icons = ['ok.png', 'list_remove.png', 'blank.png']
self.main_widget.blockSignals(True)
for icon, text in zip(icons, items):
self.main_widget.addItem(QIcon.ic(icon), text)
self.main_widget.blockSignals(False)
self.finish_ui_setup(parent, is_bool=True)
def set_to_undefined(self):
# Only called if bools are tristate
self.main_widget.setCurrentIndex(2)
def getter(self):
val = self.main_widget.currentIndex()
if not self.bools_are_tristate:
return {2: False, 1: False, 0: True}[val]
else:
return {2: None, 1: False, 0: True}[val]
def setter(self, val):
val = {None: 2, False: 1, True: 0}[val]
self.main_widget.setCurrentIndex(val)
self.ignore_change_signals = False
def commit(self, book_ids, notify=False):
if not self.a_c_checkbox.isChecked():
return
val = self.gui_val
val = self.normalize_ui_val(val)
if not self.bools_are_tristate and val is None:
val = False
self.db.set_custom_bulk(book_ids, val, num=self.col_id, notify=notify)
def a_c_checkbox_changed(self):
if not self.ignore_change_signals:
if not self.bools_are_tristate and self.main_widget.currentIndex() == 2:
self.a_c_checkbox.setChecked(False)
else:
self.a_c_checkbox.setChecked(True)
class BulkInt(BulkBase):
def setup_ui(self, parent):
self.make_widgets(parent, QSpinBox)
self.main_widget.setRange(-1000000, 100000000)
self.finish_ui_setup(parent)
def finish_ui_setup(self, parent):
BulkBase.finish_ui_setup(self, parent)
self.main_widget.setSpecialValueText(_('Undefined'))
self.main_widget.setSingleStep(1)
self.main_widget.valueChanged.connect(self.valueChanged)
def setter(self, val):
if val is None:
val = self.main_widget.minimum()
self.main_widget.setValue(val)
self.ignore_change_signals = False
self.was_none = val == self.main_widget.minimum()
def getter(self):
val = self.main_widget.value()
if val == self.main_widget.minimum():
val = None
return val
def valueChanged(self, to_what):
if self.was_none and to_what == -999999:
self.setter(0)
self.was_none = to_what == self.main_widget.minimum()
def set_to_undefined(self):
self.main_widget.setValue(-1000000)
class BulkFloat(BulkInt):
def setup_ui(self, parent):
self.make_widgets(parent, QDoubleSpinBox)
self.main_widget.setRange(-1000000., float(100000000))
self.main_widget.setDecimals(int(self.col_metadata['display'].get('decimals', 2)))
self.finish_ui_setup(parent)
def set_to_undefined(self):
self.main_widget.setValue(-1000000.)
class BulkRating(BulkBase):
def setup_ui(self, parent):
allow_half_stars = self.col_metadata['display'].get('allow_half_stars', False)
self.make_widgets(parent, partial(RatingEditor, is_half_star=allow_half_stars))
self.finish_ui_setup(parent)
def set_to_undefined(self):
self.main_widget.setCurrentIndex(0)
def setter(self, val):
val = max(0, min(int(val or 0), 10))
self.main_widget.rating_value = val
self.ignore_change_signals = False
def getter(self):
return self.main_widget.rating_value or None
class BulkDateTime(BulkBase):
def setup_ui(self, parent):
cm = self.col_metadata
self.make_widgets(parent, DateTimeEdit)
l = self.widgets[1].layout()
self.today_button = QToolButton(parent)
self.today_button.setText(_('Today'))
l.insertWidget(1, self.today_button)
self.clear_button = QToolButton(parent)
self.clear_button.setIcon(QIcon.ic('trash.png'))
self.clear_button.setToolTip(_('Clear {0}').format(self.col_metadata['name']))
l.insertWidget(2, self.clear_button)
l.insertStretch(3)
w = self.main_widget
format_ = cm['display'].get('date_format','')
if not format_:
format_ = 'dd MMM yyyy'
elif format_ == 'iso':
format_ = internal_iso_format_string()
w.setDisplayFormat(format_)
w.setCalendarPopup(True)
w.setMinimumDateTime(UNDEFINED_QDATETIME)
w.setSpecialValueText(_('Undefined'))
self.today_button.clicked.connect(w.set_to_today)
self.clear_button.clicked.connect(w.set_to_clear)
def setter(self, val):
if val is None:
val = self.main_widget.minimumDateTime()
else:
val = qt_from_dt(val)
self.main_widget.setDateTime(val)
self.ignore_change_signals = False
def getter(self):
val = self.main_widget.dateTime()
if is_date_undefined(val):
val = None
else:
val = qt_to_dt(val)
return val
def normalize_db_val(self, val):
return as_local_time(val) if val is not None else None
def normalize_ui_val(self, val):
return as_utc(val) if val is not None else None
class BulkSeries(BulkBase):
def setup_ui(self, parent):
self.make_widgets(parent, partial(EditWithComplete, sort_func=title_sort))
values = self.all_values = list(self.db.all_custom(num=self.col_id))
values.sort(key=sort_key)
self.main_widget.setSizeAdjustPolicy(QComboBox.SizeAdjustPolicy.AdjustToMinimumContentsLengthWithIcon)
self.main_widget.setMinimumContentsLength(25)
self.widgets.append(QLabel('', parent))
w = QWidget(parent)
layout = QHBoxLayout(w)
layout.setContentsMargins(0, 0, 0, 0)
self.remove_series = QCheckBox(parent)
self.remove_series.setText(_('Clear series'))
layout.addWidget(self.remove_series)
self.idx_widget = QCheckBox(parent)
self.idx_widget.setText(_('Automatically number books'))
self.idx_widget.setToolTip('<p>' + _(
'If not checked, the series number for the books will be set to 1. '
'If checked, selected books will be automatically numbered, '
'in the order you selected them. So if you selected '
'Book A and then Book B, Book A will have series number 1 '
'and Book B series number 2.') + '</p>')
layout.addWidget(self.idx_widget)
self.force_number = QCheckBox(parent)
self.force_number.setText(_('Force numbers to start with '))
self.force_number.setToolTip('<p>' + _(
'Series will normally be renumbered from the highest '
'number in the database for that series. Checking this '
'box will tell calibre to start numbering from the value '
'in the box') + '</p>')
layout.addWidget(self.force_number)
self.series_start_number = QDoubleSpinBox(parent)
self.series_start_number.setMinimum(0.0)
self.series_start_number.setMaximum(9999999.0)
self.series_start_number.setProperty("value", 1.0)
layout.addWidget(self.series_start_number)
self.series_increment = QDoubleSpinBox(parent)
self.series_increment.setMinimum(0.00)
self.series_increment.setMaximum(99999.0)
self.series_increment.setProperty("value", 1.0)
self.series_increment.setToolTip('<p>' + _(
'The amount by which to increment the series number '
'for successive books. Only applicable when using '
'force series numbers.') + '</p>')
self.series_increment.setPrefix('+')
layout.addWidget(self.series_increment)
layout.addItem(QSpacerItem(20, 10, QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Minimum))
self.widgets.append(w)
self.idx_widget.stateChanged.connect(self.a_c_checkbox_changed)
self.force_number.stateChanged.connect(self.a_c_checkbox_changed)
self.series_start_number.valueChanged.connect(self.a_c_checkbox_changed)
self.series_increment.valueChanged.connect(self.a_c_checkbox_changed)
self.remove_series.stateChanged.connect(self.a_c_checkbox_changed)
self.main_widget
self.ignore_change_signals = False
def a_c_checkbox_changed(self):
def disable_numbering_checkboxes(idx_widget_enable):
if idx_widget_enable:
self.idx_widget.setEnabled(True)
else:
self.idx_widget.setChecked(False)
self.idx_widget.setEnabled(False)
self.force_number.setChecked(False)
self.force_number.setEnabled(False)
self.series_start_number.setEnabled(False)
self.series_increment.setEnabled(False)
if self.ignore_change_signals:
return
self.ignore_change_signals = True
apply_changes = False
if self.remove_series.isChecked():
self.main_widget.setText('')
self.main_widget.setEnabled(False)
disable_numbering_checkboxes(idx_widget_enable=False)
apply_changes = True
elif self.main_widget.text():
self.remove_series.setEnabled(False)
self.idx_widget.setEnabled(True)
apply_changes = True
else: # no text, no clear. Basically reinitialize
self.main_widget.setEnabled(True)
self.remove_series.setEnabled(True)
disable_numbering_checkboxes(idx_widget_enable=False)
apply_changes = False
self.force_number.setEnabled(self.idx_widget.isChecked())
self.series_start_number.setEnabled(self.force_number.isChecked())
self.series_increment.setEnabled(self.force_number.isChecked())
self.ignore_change_signals = False
self.a_c_checkbox.setChecked(apply_changes)
def initialize(self, book_id):
self.idx_widget.setChecked(False)
self.main_widget.set_separator(None)
self.main_widget.update_items_cache(self.all_values)
self.main_widget.setEditText('')
self.a_c_checkbox.setChecked(False)
def getter(self):
n = str(self.main_widget.currentText()).strip()
autonumber = self.idx_widget.isChecked()
force = self.force_number.isChecked()
start = self.series_start_number.value()
remove = self.remove_series.isChecked()
increment = self.series_increment.value()
return n, autonumber, force, start, remove, increment
def commit(self, book_ids, notify=False):
if not self.a_c_checkbox.isChecked():
return
val, update_indices, force_start, at_value, clear, increment = self.gui_val
val = None if clear else self.normalize_ui_val(val)
if clear or val != '':
extras = []
for book_id in book_ids:
if clear:
extras.append(None)
continue
if update_indices:
if force_start:
s_index = at_value
at_value += increment
elif tweaks['series_index_auto_increment'] != 'const':
s_index = self.db.get_next_cc_series_num_for(val, num=self.col_id)
else:
s_index = 1.0
else:
s_index = self.db.get_custom_extra(book_id, num=self.col_id,
index_is_id=True)
extras.append(s_index)
self.db.set_custom_bulk(book_ids, val, extras=extras,
num=self.col_id, notify=notify)
class BulkEnumeration(BulkBase, Enumeration):
def get_initial_value(self, book_ids):
value = None
first = True
dialog_shown = False
for book_id in book_ids:
val = self.db.get_custom(book_id, num=self.col_id, index_is_id=True)
if val and val not in self.col_metadata['display']['enum_values']:
if not dialog_shown:
error_dialog(self.parent, '',
_('The enumeration "{0}" contains invalid values '
'that will not appear in the list').format(
self.col_metadata['name']),
show=True, show_copy_button=False)
dialog_shown = True
if first:
value = val
first = False
elif value != val:
value = None
if not value:
self.ignore_change_signals = False
return value
def setup_ui(self, parent):
self.parent = parent
self.make_widgets(parent, QComboBox)
self.finish_ui_setup(parent)
vals = self.col_metadata['display']['enum_values']
self.main_widget.blockSignals(True)
self.main_widget.addItem('')
self.main_widget.addItems(vals)
self.main_widget.blockSignals(False)
def set_to_undefined(self):
self.main_widget.setCurrentIndex(0)
def getter(self):
return str(self.main_widget.currentText())
def setter(self, val):
if val is None:
self.main_widget.setCurrentIndex(0)
else:
self.main_widget.setCurrentIndex(self.main_widget.findText(val))
self.ignore_change_signals = False
class RemoveTags(QWidget):
def __init__(self, parent, values):
QWidget.__init__(self, parent)
layout = QHBoxLayout()
layout.setSpacing(5)
layout.setContentsMargins(0, 0, 0, 0)
self.tags_box = EditWithComplete(parent)
self.tags_box.update_items_cache(values)
layout.addWidget(self.tags_box, stretch=3)
self.remove_tags_button = QToolButton(parent)
self.remove_tags_button.setToolTip(_('Open Item editor'))
self.remove_tags_button.setIcon(QIcon.ic('chapters.png'))
layout.addWidget(self.remove_tags_button)
self.checkbox = QCheckBox(_('Remove all tags'), parent)
layout.addWidget(self.checkbox)
layout.addStretch(1)
self.setLayout(layout)
self.checkbox.stateChanged[int].connect(self.box_touched)
def box_touched(self, state):
if state:
self.tags_box.setText('')
self.tags_box.setEnabled(False)
else:
self.tags_box.setEnabled(True)
class BulkText(BulkBase):
def setup_ui(self, parent):
values = self.all_values = list(self.db.all_custom(num=self.col_id))
values.sort(key=sort_key)
is_tags = False
if self.col_metadata['is_multiple']:
is_tags = not self.col_metadata['display'].get('is_names', False)
self.make_widgets(parent, EditWithComplete)
self.main_widget.setSizePolicy(QSizePolicy.Policy.Minimum, QSizePolicy.Policy.Preferred)
self.adding_widget = self.main_widget
if is_tags:
w = RemoveTags(parent, values)
w.remove_tags_button.clicked.connect(self.edit_remove)
l = QLabel(label_string(self.col_metadata['name'])+': ' +
_('tags to remove'), parent)
tt = get_tooltip(self.col_metadata) + ': ' + _('tags to remove')
l.setToolTip(tt)
self.widgets.append(l)
w.setToolTip(tt)
self.widgets.append(w)
self.removing_widget = w
self.main_widget.set_separator(',')
w.tags_box.textChanged.connect(self.a_c_checkbox_changed)
w.checkbox.stateChanged.connect(self.a_c_checkbox_changed)
else:
self.main_widget.set_separator('&')
self.main_widget.set_space_before_sep(True)
self.main_widget.set_add_separator(
tweaks['authors_completer_append_separator'])
else:
self.make_widgets(parent, EditWithComplete)
self.main_widget.set_separator(None)
self.main_widget.setSizeAdjustPolicy(
QComboBox.SizeAdjustPolicy.AdjustToMinimumContentsLengthWithIcon)
self.main_widget.setMinimumContentsLength(25)
self.ignore_change_signals = False
self.parent = parent
self.finish_ui_setup(parent, add_edit_tags_button=(is_tags,self.edit_add))
def set_to_undefined(self):
self.main_widget.clearEditText()
def initialize(self, book_ids):
self.main_widget.update_items_cache(self.all_values)
if not self.col_metadata['is_multiple']:
val = self.get_initial_value(book_ids)
self.initial_val = val = self.normalize_db_val(val)
self.ignore_change_signals = True
self.main_widget.blockSignals(True)
self.main_widget.setText(val)
self.main_widget.blockSignals(False)
self.ignore_change_signals = False
def commit(self, book_ids, notify=False):
if not self.a_c_checkbox.isChecked():
return
if self.col_metadata['is_multiple']:
ism = self.col_metadata['multiple_seps']
if self.col_metadata['display'].get('is_names', False):
val = self.gui_val
add = [v.strip() for v in val.split(ism['ui_to_list']) if v.strip()]
self.db.set_custom_bulk(book_ids, add, num=self.col_id)
else:
remove_all, adding, rtext = self.gui_val
remove = set()
if remove_all:
remove = set(self.db.all_custom(num=self.col_id))
else:
txt = rtext
if txt:
remove = {v.strip() for v in txt.split(ism['ui_to_list'])}
txt = adding
if txt:
add = {v.strip() for v in txt.split(ism['ui_to_list'])}
else:
add = set()
self.db.set_custom_bulk_multiple(book_ids, add=add,
remove=remove, num=self.col_id)
else:
val = self.gui_val
val = self.normalize_ui_val(val)
self.db.set_custom_bulk(book_ids, val, num=self.col_id, notify=notify)
def getter(self):
if self.col_metadata['is_multiple']:
if not self.col_metadata['display'].get('is_names', False):
return self.removing_widget.checkbox.isChecked(), \
str(self.adding_widget.text()), \
str(self.removing_widget.tags_box.text())
return str(self.adding_widget.text())
val = str(self.main_widget.currentText()).strip()
if not val:
val = None
return val
def edit_remove(self):
self.edit(widget=self.removing_widget.tags_box)
def edit_add(self):
self.edit(widget=self.main_widget)
def edit(self, widget):
if widget.text():
d = _save_dialog(self.parent, _('Values changed'),
_('You have entered values. In order to use this '
'editor you must first discard them. '
'Discard the values?'))
if d == QMessageBox.StandardButton.Cancel or d == QMessageBox.StandardButton.No:
return
widget.setText('')
d = TagEditor(self.parent, self.db, key=('#'+self.col_metadata['label']))
if d.exec() == QDialog.DialogCode.Accepted:
val = d.tags
if not val:
val = []
widget.setText(self.col_metadata['multiple_seps']['list_to_ui'].join(val))
bulk_widgets = {
'bool' : BulkBool,
'rating' : BulkRating,
'int': BulkInt,
'float': BulkFloat,
'datetime': BulkDateTime,
'text' : BulkText,
'series': BulkSeries,
'enumeration': BulkEnumeration,
}
| 60,743 | Python | .py | 1,383 | 33.614606 | 126 | 0.60779 | kovidgoyal/calibre | 19,243 | 2,250 | 4 | GPL-3.0 | 9/5/2024, 5:13:50 PM (Europe/Amsterdam) |
26,643 | listener.py | kovidgoyal_calibre/src/calibre/gui2/listener.py | #!/usr/bin/env python
# License: GPL v3 Copyright: 2020, Kovid Goyal <kovid at kovidgoyal.net>
import errno
import os
import socket
from contextlib import closing
from functools import partial
from itertools import count
from qt.core import QAbstractSocket, QByteArray, QLocalServer, QLocalSocket, pyqtSignal
from calibre.utils.ipc import gui_socket_address
def unix_socket(timeout=10):
ans = socket.socket(socket.AF_UNIX)
ans.settimeout(timeout)
return ans
class Listener(QLocalServer):
message_received = pyqtSignal(object)
def __init__(self, address=None, parent=None):
QLocalServer.__init__(self, parent)
self.address = address or gui_socket_address()
self.uses_filesystem = self.address[0] not in '\0\\'
self.setSocketOptions(QLocalServer.SocketOption.UserAccessOption)
self.newConnection.connect(self.on_new_connection)
self.connection_id = count()
self.pending_messages = {}
def start_listening(self):
if self.address.startswith('\0'):
s = unix_socket()
s.bind(self.address)
s.listen(16)
if not self.listen(s.detach()):
raise OSError(f'Could not start Listener for IPC at address @{self.address[1:]} with error: {self.errorString()}')
else:
if not self.listen(self.address):
if self.serverError() == QAbstractSocket.SocketError.AddressInUseError and self.uses_filesystem:
self.removeServer(self.address)
if self.listen(self.address):
return
code = self.serverError()
if code == QAbstractSocket.SocketError.AddressInUseError:
raise OSError(errno.EADDRINUSE, os.strerror(errno.EADDRINUSE), self.address)
raise OSError(f'Could not start Listener for IPC at address {self.address} with error: {self.errorString()}')
def on_new_connection(self):
while True:
s = self.nextPendingConnection()
if s is None:
break
cid = next(self.connection_id)
self.pending_messages[cid] = b''
s.readyRead.connect(partial(self.on_ready_read, cid, s))
s.disconnected.connect(partial(self.on_disconnect, cid, s))
def on_ready_read(self, connection_id, q_local_socket):
num = q_local_socket.bytesAvailable()
if num > 0:
self.pending_messages[connection_id] += bytes(q_local_socket.readAll())
def on_disconnect(self, connection_id, q_local_socket):
self.on_ready_read(connection_id, q_local_socket)
q_local_socket.close()
q_local_socket.readyRead.disconnect()
q_local_socket.disconnected.disconnect()
q_local_socket.deleteLater()
self.message_received.emit(self.pending_messages.pop(connection_id, b''))
def send_message_in_process(msg, address=None, timeout=5):
address = address or gui_socket_address()
if isinstance(msg, str):
msg = msg.encode('utf-8')
s = QLocalSocket()
qt_timeout = int(timeout * 1000)
if address.startswith('\0'):
ps = unix_socket(timeout)
ps.connect(address)
s.setSocketDescriptor(ps.detach())
else:
s.connectToServer(address)
if not s.waitForConnected(qt_timeout):
raise OSError(f'Failed to connect to Listener at: {address} with error: {s.errorString()}')
data = QByteArray(msg)
while True:
written = s.write(data)
if not s.waitForBytesWritten(qt_timeout):
raise OSError(f'Failed to write data to address: {s.serverName()} with error: {s.errorString()}')
if written >= len(data):
break
data = data.right(len(data) - written)
def send_message_via_worker(msg, address=None, timeout=5, wait_till_sent=False):
# On Windows sending a message in a process that also is listening on the
# same named pipe in a different thread deadlocks, so we do the actual sending in
# a simple worker process
import json
import subprocess
from calibre.startup import get_debug_executable
cmd = get_debug_executable() + [
'-c', 'from calibre.gui2.listener import *; import sys, json;'
'send_message_implementation(sys.stdin.buffer.read(), address=json.loads(sys.argv[-2]), timeout=int(sys.argv[-1]))',
json.dumps(address), str(timeout)]
p = subprocess.Popen(cmd, stdin=subprocess.PIPE)
if isinstance(msg, str):
msg = msg.encode('utf-8')
with closing(p.stdin):
p.stdin.write(msg)
if wait_till_sent:
return p.wait(timeout=timeout) == 0
def test():
from qt.core import QApplication, QLabel, QTimer
app = QApplication([])
l = QLabel()
l.setText('Waiting for message...')
def show_message(msg):
print(msg)
l.setText(msg.decode('utf-8'))
def send():
send_message_via_worker('hello!', wait_till_sent=False)
QTimer.singleShot(1000, send)
s = Listener(parent=l)
s.start_listening()
print('Listening at:', s.serverName(), s.isListening())
s.message_received.connect(show_message)
l.show()
app.exec()
del app
if __name__ == '__main__':
test()
| 5,269 | Python | .py | 121 | 35.487603 | 130 | 0.65326 | kovidgoyal/calibre | 19,243 | 2,250 | 4 | GPL-3.0 | 9/5/2024, 5:13:50 PM (Europe/Amsterdam) |
26,644 | covers.py | kovidgoyal_calibre/src/calibre/gui2/covers.py | #!/usr/bin/env python
# License: GPLv3 Copyright: 2014, Kovid Goyal <kovid at kovidgoyal.net>
import os
from collections import OrderedDict
from contextlib import suppress
from copy import deepcopy
from qt.core import (
QCheckBox,
QColor,
QColorDialog,
QDialog,
QDialogButtonBox,
QFormLayout,
QFrame,
QGridLayout,
QHBoxLayout,
QIcon,
QInputDialog,
QLabel,
QLineEdit,
QListWidget,
QListWidgetItem,
QMenu,
QPixmap,
QPushButton,
QSize,
QSizePolicy,
QSpinBox,
Qt,
QTabWidget,
QTimer,
QToolButton,
QVBoxLayout,
QWidget,
pyqtSignal,
)
from calibre.constants import config_dir
from calibre.ebooks.covers import all_styles, cprefs, default_color_themes, generate_cover, override_prefs
from calibre.gui2 import error_dialog, gprefs
from calibre.gui2.font_family_chooser import FontFamilyChooser
from calibre.startup import connect_lambda
from calibre.utils.date import now
from calibre.utils.filenames import make_long_path_useable
from calibre.utils.icu import primary_sort_key, sort_key
from polyglot.builtins import iteritems, itervalues
class Preview(QLabel):
def __init__(self, parent=None):
QLabel.__init__(self, parent)
self.setSizePolicy(QSizePolicy.Policy.Fixed, QSizePolicy.Policy.Minimum)
def sizeHint(self):
return QSize(300, 400)
class ColorButton(QToolButton):
def __init__(self, color, parent=None):
QToolButton.__init__(self, parent)
self.setIconSize(QSize(50, 25))
self.pix = QPixmap(self.iconSize())
self._color = QColor('#' + color)
self.pix.fill(self._color)
self.setIcon(QIcon(self.pix))
self.clicked.connect(self.choose_color)
@property
def color(self):
return self._color.name(QColor.NameFormat.HexRgb)[1:]
@color.setter
def color(self, val):
self._color = QColor('#' + val)
def update_display(self):
self.pix.fill(self._color)
self.setIcon(QIcon(self.pix))
def choose_color(self):
c = QColorDialog.getColor(self._color, self, _('Choose color'))
if c.isValid():
self._color = c
self.update_display()
class CreateColorScheme(QDialog):
def __init__(self, scheme_name, scheme, existing_names, edit_scheme=False, parent=None):
QDialog.__init__(self, parent)
self.existing_names, self.is_editing, self.scheme_name = existing_names, edit_scheme, scheme_name
self.l = l = QFormLayout(self)
self.setLayout(l)
self.setWindowTitle(scheme_name)
self.name = n = QLineEdit(self)
n.setText(scheme_name if edit_scheme else '#' +('My Color Scheme'))
l.addRow(_('&Name:'), self.name)
for x in 'color1 color2 contrast_color1 contrast_color2'.split():
setattr(self, x, ColorButton(scheme[x], self))
l.addRow(_('Color &1:'), self.color1)
l.addRow(_('Color &2:'), self.color2)
l.addRow(_('Contrast color &1 (mainly for text):'), self.contrast_color1)
l.addRow(_('Contrast color &2 (mainly for text):'), self.contrast_color2)
self.bb = bb = QDialogButtonBox(QDialogButtonBox.StandardButton.Ok | QDialogButtonBox.StandardButton.Cancel)
bb.accepted.connect(self.accept)
bb.rejected.connect(self.reject)
l.addRow(bb)
@property
def data(self):
return self.name.text(), {x:getattr(self, x).color for x in 'color1 color2 contrast_color1 contrast_color2'.split()}
def accept(self):
name = self.name.text()
if not name or len(name) < 2 or not name.startswith('#'):
return error_dialog(self, _('Invalid name'), _(
'The color scheme name "%s" is invalid. It must start with a # and be at least two characters long.') % name, show=True)
if name in self.existing_names:
if not self.is_editing or name != self.scheme_name:
return error_dialog(self, _('Invalid name'), _(
'A color scheme with the name "%s" already exists.') % name, show=True)
QDialog.accept(self)
class CoverSettingsWidget(QWidget):
changed = pyqtSignal()
def __init__(self, mi=None, prefs=None, parent=None, for_global_prefs=False):
QWidget.__init__(self, parent)
self.ignore_changed = False
self.for_global_prefs = for_global_prefs
self.l = l = QHBoxLayout(self)
l.setContentsMargins(0, 0, 0, 0)
self.setLayout(l)
self.settings_tabs = st = QTabWidget(self)
l.addWidget(st)
self.preview_label = la = Preview(self)
l.addWidget(la)
if prefs is None:
prefs = cprefs
self.original_prefs = prefs
self.mi = mi or self.default_mi()
self.colors_page = cp = QWidget(st)
st.addTab(cp, _('&Colors'))
cp.l = l = QGridLayout()
cp.setLayout(l)
if for_global_prefs:
msg = _('When generating covers, a color scheme for the cover is chosen at random from the'
' color schemes below. You can prevent an individual scheme from being selected by'
' unchecking it. The preview on the right shows the currently selected color scheme.')
else:
msg = _('Choose a color scheme to be used for this generated cover.') + '<p>' + _(
'In normal cover generation, the color scheme is chosen at random from the list of color schemes below. You'
' can prevent an individual color scheme from being chosen by unchecking it here.')
cp.la = la = QLabel('<p>' + msg)
la.setWordWrap(True)
l.addWidget(la, 0, 0, 1, -1)
self.colors_list = cl = QListWidget(cp)
l.addWidget(cl, 1, 0, 1, -1)
self.colors_map = OrderedDict()
self.ncs = ncs = QPushButton(QIcon.ic('plus.png'), _('&New color scheme'), cp)
ncs.clicked.connect(self.create_color_scheme)
l.addWidget(ncs)
self.ecs = ecs = QPushButton(QIcon.ic('format-fill-color.png'), _('&Edit color scheme'), cp)
ecs.clicked.connect(self.edit_color_scheme)
l.addWidget(ecs, l.rowCount()-1, 1)
self.rcs = rcs = QPushButton(QIcon.ic('minus.png'), _('&Remove color scheme'), cp)
rcs.clicked.connect(self.remove_color_scheme)
l.addWidget(rcs, l.rowCount()-1, 2)
self.styles_page = sp = QWidget(st)
st.addTab(sp, _('&Styles'))
sp.l = l = QVBoxLayout()
sp.setLayout(l)
if for_global_prefs:
msg = _('When generating covers, a style for the cover is chosen at random from the'
' styles below. You can prevent an individual style from being selected by'
' unchecking it. The preview on the right shows the currently selected style.')
else:
msg = _('Choose a style to be used for this generated cover.') + '<p>' + _(
'In normal cover generation, the style is chosen at random from the list of styles below. You'
' can prevent an individual style from being chosen by unchecking it here.')
sp.la = la = QLabel('<p>' + msg)
la.setWordWrap(True)
l.addWidget(la)
self.styles_list = sl = QListWidget(sp)
l.addWidget(sl)
self.style_map = OrderedDict()
self.font_page = fp = QWidget(st)
st.addTab(fp, _('&Fonts and sizes'))
fp.l = l = QFormLayout()
fp.setLayout(l)
fp.f = []
def add_hline():
f = QFrame()
fp.f.append(f)
f.setFrameShape(QFrame.Shape.HLine)
l.addRow(f)
for x, label, size_label in (
('title', _('&Title font family:'), _('&Title font size:')),
('subtitle', _('&Subtitle font family:'), _('&Subtitle font size:')),
('footer', _('&Footer font family:'), _('&Footer font size:')),
):
attr = '%s_font_family' % x
ff = FontFamilyChooser(fp)
setattr(self, attr, ff)
l.addRow(label, ff)
ff.family_changed.connect(self.emit_changed)
attr = '%s_font_size' % x
fs = QSpinBox(fp)
setattr(self, attr, fs)
fs.setMinimum(8), fs.setMaximum(200), fs.setSuffix(' px')
fs.setValue(prefs[attr])
fs.valueChanged.connect(self.emit_changed)
l.addRow(size_label, fs)
add_hline()
self.changed_timer = t = QTimer(self)
t.setSingleShot(True), t.setInterval(500), t.timeout.connect(self.emit_changed)
def create_sz(label):
ans = QSpinBox(self)
ans.setSuffix(' px'), ans.setMinimum(100), ans.setMaximum(10000)
l.addRow(label, ans)
ans.valueChanged.connect(self.changed_timer.start)
return ans
self.cover_width = create_sz(_('Cover &width:'))
self.cover_height = create_sz(_('Cover &height:'))
fp.cla = la = QLabel(_(
'Note that the preview to the side is of fixed aspect ratio, so changing the cover'
' width above will not have any effect. If you change the height, you should also change the width nevertheless'
' as it will be used in actual cover generation.'))
la.setWordWrap(True)
l.addRow(la)
self.templates_page = tp = QWidget(st)
st.addTab(tp, _('&Text'))
tp.l = l = QVBoxLayout()
tp.setLayout(l)
tp.la = la = QLabel(_(
'The text on the generated cover is taken from the metadata of the book.'
' This is controlled via templates. You can use the <b>, <i> and <br> tags'
' in the templates for bold, italic and line breaks, respectively. The'
' default templates use the title, series and authors. You can change them to use'
' whatever metadata you like.'))
la.setWordWrap(True), la.setTextFormat(Qt.TextFormat.PlainText)
l.addWidget(la)
def create_template_widget(title, which, button):
attr = which + '_template'
heading = QLabel('<h2>' + title)
setattr(tp, attr + '_heading', heading)
l.addWidget(heading)
la = QLabel()
setattr(self, attr, la)
l.addWidget(la), la.setTextFormat(Qt.TextFormat.PlainText), la.setStyleSheet('QLabel {font-family: monospace}')
la.setWordWrap(True)
b = QPushButton(button)
b.setSizePolicy(QSizePolicy.Policy.Fixed, QSizePolicy.Policy.Fixed)
connect_lambda(b.clicked, self, lambda self: self.change_template(which))
setattr(self, attr + '_button', b)
l.addWidget(b)
if which != 'footer':
f = QFrame(tp)
setattr(tp, attr + '_sep', f), f.setFrameShape(QFrame.Shape.HLine)
l.addWidget(f)
l.addSpacing(10)
create_template_widget(_('The title template'), 'title', _('Change the &title template'))
create_template_widget(_('The sub-title template'), 'subtitle', _('Change the &sub-title template'))
create_template_widget(_('The footer template'), 'footer', _('Change the &footer template'))
l.addStretch(2)
self.apply_prefs(prefs)
self.changed.connect(self.update_preview)
self.styles_list.itemSelectionChanged.connect(self.update_preview)
self.colors_list.itemSelectionChanged.connect(self.update_preview)
self.update_preview()
def __enter__(self):
self.ignore_changed = True
def __exit__(self, *args):
self.ignore_changed = False
def emit_changed(self):
if not self.ignore_changed:
self.changed.emit()
def apply_prefs(self, prefs):
with self:
self._apply_prefs(prefs)
def _apply_prefs(self, prefs):
for x in ('title', 'subtitle', 'footer'):
attr = '%s_font_family' % x
getattr(self, attr).font_family = prefs[attr]
attr = '%s_font_size' % x
getattr(self, attr).setValue(prefs[attr])
for x in ('title', 'subtitle', 'footer'):
x += '_template'
getattr(self, x).setText(prefs[x])
for x in ('width', 'height'):
x = 'cover_' + x
getattr(self, x).setValue(prefs[x])
color_themes = prefs['color_themes'].copy()
color_themes.update(default_color_themes)
disabled = set(prefs['disabled_color_themes'])
self.colors_list.clear()
self.colors_map = {}
for name in sorted(color_themes, key=sort_key):
self.colors_map[name] = li = QListWidgetItem(name, self.colors_list)
li.setFlags(li.flags() | Qt.ItemFlag.ItemIsUserCheckable)
li.setCheckState(Qt.CheckState.Unchecked if name in disabled else Qt.CheckState.Checked)
li.setData(Qt.ItemDataRole.UserRole, color_themes[name])
lu = prefs.get('last_used_colors')
if not self.for_global_prefs and lu in self.colors_map and self.colors_map[lu].checkState() == Qt.CheckState.Checked:
self.colors_map[lu].setSelected(True)
else:
for name, li in iteritems(self.colors_map):
if li.checkState() == Qt.CheckState.Checked:
li.setSelected(True)
break
else:
next(itervalues(self.colors_map)).setSelected(True)
disabled = set(prefs['disabled_styles'])
self.styles_list.clear()
self.style_map.clear()
for name in sorted(all_styles(), key=sort_key):
self.style_map[name] = li = QListWidgetItem(name, self.styles_list)
li.setFlags(li.flags() | Qt.ItemFlag.ItemIsUserCheckable)
li.setCheckState(Qt.CheckState.Unchecked if name in disabled else Qt.CheckState.Checked)
lu = prefs.get('last_used_style')
if not self.for_global_prefs and lu in self.style_map and self.style_map[lu].checkState() == Qt.CheckState.Checked:
self.style_map[lu].setSelected(True)
else:
for name, li in iteritems(self.style_map):
if li.checkState() == Qt.CheckState.Checked:
li.setSelected(True)
break
else:
next(itervalues(self.style_map)).setSelected(True)
@property
def current_colors(self):
for name, li in self.colors_map.items():
if li.isSelected():
return name
@property
def disabled_colors(self):
for name, li in iteritems(self.colors_map):
if li.checkState() == Qt.CheckState.Unchecked:
yield name
@property
def custom_colors(self):
ans = {}
for name, li in iteritems(self.colors_map):
if name.startswith('#'):
ans[name] = li.data(Qt.ItemDataRole.UserRole)
return ans
@property
def current_style(self):
for name, li in iteritems(self.style_map):
if li.isSelected():
return name
@property
def disabled_styles(self):
for name, li in iteritems(self.style_map):
if li.checkState() == Qt.CheckState.Unchecked:
yield name
@property
def current_prefs(self):
prefs = {k:self.original_prefs[k] for k in self.original_prefs.defaults}
for x in ('title', 'subtitle', 'footer'):
attr = '%s_font_family' % x
prefs[attr] = getattr(self, attr).font_family
attr = '%s_font_size' % x
prefs[attr] = getattr(self, attr).value()
prefs['color_themes'] = self.custom_colors
prefs['disabled_styles'] = list(self.disabled_styles)
prefs['disabled_color_themes'] = list(self.disabled_colors)
for x in ('title', 'subtitle', 'footer'):
x += '_template'
prefs[x] = getattr(self, x).text()
for x in ('width', 'height'):
x = 'cover_' + x
prefs[x] = getattr(self, x).value()
return prefs
def insert_scheme(self, name, li):
with self:
self.colors_list.insertItem(0, li)
cm = OrderedDict()
cm[name] = li
for k, v in iteritems(self.colors_map):
cm[k] = v
self.colors_map = cm
li.setSelected(True)
for i in range(1, self.colors_list.count()):
self.colors_list.item(i).setSelected(False)
def create_color_scheme(self):
cs = self.current_colors
if cs is None:
cs = tuple(self.colors_map.keys())[0]
scheme = self.colors_map[cs].data(Qt.ItemDataRole.UserRole)
d = CreateColorScheme('#' + _('My Color Scheme'), scheme, set(self.colors_map), parent=self)
if d.exec() == QDialog.DialogCode.Accepted:
name, scheme = d.data
li = QListWidgetItem(name)
li.setData(Qt.ItemDataRole.UserRole, scheme), li.setFlags(li.flags() | Qt.ItemFlag.ItemIsUserCheckable), li.setCheckState(Qt.CheckState.Checked)
self.insert_scheme(name, li)
self.emit_changed()
self.original_prefs['color_themes'] = self.current_prefs['color_themes']
def edit_color_scheme(self):
cs = self.current_colors
if cs is None or not cs.startswith('#'):
return error_dialog(self, _('Cannot edit'), _(
'Cannot edit a builtin color scheme. Create a new'
' color scheme instead.'), show=True)
li = self.colors_map[cs]
d = CreateColorScheme(cs, li.data(Qt.ItemDataRole.UserRole), set(self.colors_map), edit_scheme=True, parent=self)
if d.exec() == QDialog.DialogCode.Accepted:
name, scheme = d.data
li.setText(name)
li.setData(Qt.ItemDataRole.UserRole, scheme)
if name != cs:
self.colors_map.pop(cs, None)
self.insert_scheme(name, li)
self.emit_changed()
self.original_prefs['color_themes'] = self.current_prefs['color_themes']
def remove_color_scheme(self):
cs = self.current_colors
if cs is None or not cs.startswith('#'):
return error_dialog(self, _('Cannot remove'), _(
'Cannot remove a builtin color scheme.'), show=True)
for i in range(self.colors_list.count()):
item = self.colors_list.item(i)
if item.isSelected():
with self:
del self.colors_map[item.text()]
self.colors_list.takeItem(i)
i = i % self.colors_list.count()
self.colors_list.item(i).setSelected(True)
self.emit_changed()
self.original_prefs['color_themes'] = self.current_prefs['color_themes']
return
def change_template(self, which):
from calibre.gui2.dialogs.template_dialog import TemplateDialog
from calibre.gui2.ui import get_gui
gui = get_gui()
if gui is None:
from calibre.ebooks.metadata.book.base import field_metadata
else:
field_metadata = gui.current_db.new_api.field_metadata
attr = which + '_template'
templ = getattr(self, attr).text()
d = TemplateDialog(self, templ, mi=self.mi, fm=field_metadata)
if d.exec() == QDialog.DialogCode.Accepted:
templ = d.rule[1]
getattr(self, attr).setText(templ)
self.emit_changed()
@property
def prefs_for_rendering(self):
prefs = self.current_prefs
prefs = override_prefs(prefs, override_style=self.current_style, override_color_theme=self.current_colors)
return prefs
def update_preview(self):
if self.ignore_changed:
return
dpr = getattr(self, 'devicePixelRatioF', self.devicePixelRatio)()
w, h = int(dpr * self.preview_label.sizeHint().width()), int(dpr * self.preview_label.sizeHint().height())
prefs = self.prefs_for_rendering
hr = h / prefs['cover_height']
for x in ('title', 'subtitle', 'footer'):
attr = '%s_font_size' % x
prefs[attr] = int(prefs[attr] * hr)
prefs['cover_width'], prefs['cover_height'] = w, h
img = generate_cover(self.mi, prefs=prefs, as_qimage=True)
img.setDevicePixelRatio(dpr)
self.preview_label.setPixmap(QPixmap.fromImage(img))
def default_mi(self):
from calibre.ebooks.metadata.book.base import Metadata
mi = Metadata(_('A sample book'), [_('Author One'), _('Author Two')])
mi.series = _('A series of samples')
mi.series_index = 4
mi.tags = [_('Tag One'), _('Tag Two')]
mi.publisher = _('Some publisher')
mi.rating = 4
mi.identifiers = {'isbn':'123456789', 'url': 'https://calibre-ebook.com'}
mi.languages = ['eng', 'fra']
mi.pubdate = mi.timestamp = now()
return mi
def restore_defaults(self):
defaults = self.original_prefs.defaults.copy()
# Dont delete custom color themes when restoring defaults
defaults['color_themes'] = self.custom_colors
self.apply_prefs(defaults)
self.update_preview()
def save_state(self):
self.original_prefs.set('last_used_colors', self.current_colors)
self.original_prefs.set('last_used_style', self.current_style)
def save_as_prefs(self):
with self.original_prefs:
for k, v in iteritems(self.current_prefs):
self.original_prefs[k] = v
@property
def serialized_prefs(self) -> bytes:
from calibre.utils.serialize import json_dumps
c = dict(deepcopy(self.original_prefs))
c.update(self.current_prefs)
return json_dumps(c, indent=2)
@serialized_prefs.setter
def serialized_prefs(self, val: bytes) -> None:
from calibre.utils.serialize import json_loads
prefs = json_loads(val)
self.apply_prefs(prefs)
self.update_preview()
class CoverSettingsDialog(QDialog):
def __init__(self, mi=None, prefs=None, parent=None):
QDialog.__init__(self, parent)
self.setWindowTitle(_('Cover generation settings'))
self.l = l = QVBoxLayout(self)
self.setLayout(l)
self.settings = CoverSettingsWidget(mi=mi, prefs=prefs, parent=self)
l.addWidget(self.settings)
self.save_settings = ss = QCheckBox(_('Save these settings as the &defaults for future use'))
ss.setChecked(gprefs.get('cover_generation_save_settings_for_future', True))
l.addWidget(ss)
self.bb = bb = QDialogButtonBox(QDialogButtonBox.StandardButton.Ok | QDialogButtonBox.StandardButton.Cancel)
l.addWidget(bb)
bb.accepted.connect(self.accept), bb.rejected.connect(self.reject)
bb.b = b = bb.addButton(_('Restore &defaults'), QDialogButtonBox.ButtonRole.ActionRole)
b.clicked.connect(self.restore_defaults)
bb.ld = b = bb.addButton(_('&Save'), QDialogButtonBox.ButtonRole.ActionRole)
b.clicked.connect(self.export_settings)
b.setToolTip(_('Save the current cover generation settings for later re-use'))
bb.sd = b = bb.addButton(_('&Load'), QDialogButtonBox.ButtonRole.ActionRole)
self.load_menu = QMenu(b)
self.load_menu.aboutToShow.connect(self.populate_load_menu)
b.setMenu(self.load_menu)
b.setToolTip(_('Load previously saved cover generation settings'))
ss.setToolTip('<p>' + _(
'Save the current settings as the settings to use always instead of just this time. Remember that'
' for styles and colors the actual style or color used is chosen at random from'
' the list of checked styles/colors.'))
self.resize(self.sizeHint())
self.restore_geometry(gprefs, 'cover_settings_dialog_geom')
self.prefs_for_rendering = None
def restore_defaults(self):
self.settings.restore_defaults()
self.settings.save_as_prefs()
def export_settings(self):
name, ok = QInputDialog.getText(self, _('Name for these settings'), _('Theme name:'), text=_('My cover style'))
if ok:
base = os.path.join(config_dir, 'cover-generation-themes')
os.makedirs(base, exist_ok=True)
path = make_long_path_useable(os.path.join(base, name + '.json'))
raw = self.settings.serialized_prefs
with open(path, 'wb') as f:
f.write(raw)
def populate_load_menu(self):
m = self.load_menu
m.clear()
base = os.path.join(config_dir, 'cover-generation-themes')
entries = ()
with suppress(FileNotFoundError):
entries = sorted((x.rpartition('.')[0] for x in os.listdir(base) if x.endswith('.json')), key=primary_sort_key)
for name in entries:
m.addAction(name, self.import_settings)
def import_settings(self):
fname = self.sender().text() + '.json'
base = os.path.join(config_dir, 'cover-generation-themes')
with open(os.path.join(base, fname), 'rb') as f:
raw = f.read()
self.settings.serialized_prefs = raw
def _save_settings(self):
gprefs.set('cover_generation_save_settings_for_future', self.save_settings.isChecked())
self.save_geometry(gprefs, 'cover_settings_dialog_geom')
self.settings.save_state()
def accept(self):
self._save_settings()
self.prefs_for_rendering = self.settings.prefs_for_rendering
if self.save_settings.isChecked():
self.settings.save_as_prefs()
QDialog.accept(self)
def reject(self):
self._save_settings()
QDialog.reject(self)
if __name__ == '__main__':
from calibre.gui2 import Application
app = Application([])
d = CoverSettingsDialog()
d.show()
app.exec()
del d
del app
| 26,051 | Python | .py | 564 | 36.301418 | 156 | 0.610468 | kovidgoyal/calibre | 19,243 | 2,250 | 4 | GPL-3.0 | 9/5/2024, 5:13:50 PM (Europe/Amsterdam) |
26,645 | widgets2.py | kovidgoyal_calibre/src/calibre/gui2/widgets2.py | #!/usr/bin/env python
# License: GPLv3 Copyright: 2013, Kovid Goyal <kovid at kovidgoyal.net>
import weakref
from qt.core import (
QApplication,
QBrush,
QByteArray,
QCalendarWidget,
QCheckBox,
QColor,
QColorDialog,
QComboBox,
QDate,
QDateTime,
QDateTimeEdit,
QDialog,
QDialogButtonBox,
QFont,
QFontInfo,
QFontMetrics,
QFrame,
QIcon,
QKeySequence,
QLabel,
QLayout,
QMenu,
QMimeData,
QPainter,
QPalette,
QPixmap,
QPoint,
QPushButton,
QRect,
QScrollArea,
QSize,
QSizePolicy,
QStyle,
QStyledItemDelegate,
QStyleOptionToolButton,
QStylePainter,
Qt,
QTabWidget,
QTextBrowser,
QTextCursor,
QTextDocument,
QTimer,
QToolButton,
QUndoCommand,
QUndoStack,
QUrl,
QWidget,
pyqtSignal,
)
from calibre import prepare_string_for_xml
from calibre.constants import builtin_colors_dark, builtin_colors_light
from calibre.ebooks.metadata import rating_to_stars
from calibre.gui2 import UNDEFINED_QDATETIME, gprefs, local_path_for_resource, rating_font
from calibre.gui2.complete2 import EditWithComplete, LineEdit
from calibre.gui2.widgets import history
from calibre.utils.config_base import tweaks
from calibre.utils.date import UNDEFINED_DATE
from calibre.utils.localization import _
from polyglot.functools import lru_cache
class HistoryMixin:
max_history_items = None
min_history_entry_length = 3
def __init__(self, *args, **kwargs):
pass
@property
def store_name(self):
return 'lineedit_history_'+self._name
def initialize(self, name):
self._name = name
self.history = self.load_history()
self.set_separator(None)
self.update_items_cache(self.history)
self.setText('')
try:
self.editingFinished.connect(self.save_history)
except AttributeError:
self.lineEdit().editingFinished.connect(self.save_history)
def load_history(self):
return history.get(self.store_name, [])
def save_history(self):
ct = str(self.text())
if len(ct) >= self.min_history_entry_length:
try:
self.history.remove(ct)
except ValueError:
pass
self.history.insert(0, ct)
if self.max_history_items is not None:
del self.history[self.max_history_items:]
history.set(self.store_name, self.history)
self.update_items_cache(self.history)
def clear_history(self):
self.history = []
history.set(self.store_name, self.history)
self.update_items_cache(self.history)
class HistoryLineEdit2(LineEdit, HistoryMixin):
def __init__(self, parent=None, completer_widget=None, sort_func=lambda x:b''):
LineEdit.__init__(self, parent=parent, completer_widget=completer_widget, sort_func=sort_func)
def set_uniform_item_sizes(self, on=False):
if hasattr(self.mcompleter, 'setUniformItemSizes'):
self.mcompleter.setUniformItemSizes(on)
class HistoryComboBox(EditWithComplete, HistoryMixin):
def __init__(self, parent=None, strip_completion_entries=True):
EditWithComplete.__init__(self, parent, sort_func=lambda x:b'', strip_completion_entries=strip_completion_entries)
def set_uniform_item_sizes(self, on=False):
self.lineEdit().mcompleter.setUniformItemSizes(on)
class ColorButton(QPushButton):
color_changed = pyqtSignal(object)
def __init__(self, initial_color=None, parent=None, choose_text=None):
QPushButton.__init__(self, parent)
self._color = None
self.choose_text = choose_text or _('Choose &color')
self.color = initial_color
self.clicked.connect(self.choose_color)
@property
def color(self):
return self._color
@color.setter
def color(self, val):
val = str(val or '')
col = QColor(val)
orig = self._color
if col.isValid():
self._color = val
self.setText(val)
p = QPixmap(self.iconSize())
p.fill(col)
self.setIcon(QIcon(p))
else:
self._color = None
self.setText(self.choose_text)
self.setIcon(QIcon())
if orig != col:
self.color_changed.emit(self._color)
def choose_color(self):
col = QColorDialog.getColor(QColor(self._color or Qt.GlobalColor.white), self, _('Choose a color'))
if col.isValid():
self.color = str(col.name())
def access_key(k):
'Return shortcut text suitable for adding to a menu item'
if QKeySequence.keyBindings(k):
return '\t' + QKeySequence(k).toString(QKeySequence.SequenceFormat.NativeText)
return ''
def populate_standard_spinbox_context_menu(spinbox, menu, add_clear=False, use_self_for_copy_actions=False):
m = menu
le = spinbox.lineEdit()
ca = spinbox if use_self_for_copy_actions else le
m.addAction(_('Cu&t') + access_key(QKeySequence.StandardKey.Cut), ca.cut).setEnabled(not le.isReadOnly() and le.hasSelectedText())
m.addAction(_('&Copy') + access_key(QKeySequence.StandardKey.Copy), ca.copy).setEnabled(le.hasSelectedText())
m.addAction(_('&Paste') + access_key(QKeySequence.StandardKey.Paste), ca.paste).setEnabled(not le.isReadOnly())
m.addAction(_('Delete') + access_key(QKeySequence.StandardKey.Delete), le.del_).setEnabled(not le.isReadOnly() and le.hasSelectedText())
m.addSeparator()
m.addAction(_('Select &all') + access_key(QKeySequence.StandardKey.SelectAll), spinbox.selectAll)
m.addSeparator()
m.addAction(_('&Step up'), spinbox.stepUp)
m.addAction(_('Step &down'), spinbox.stepDown)
m.setAttribute(Qt.WidgetAttribute.WA_DeleteOnClose)
class RightClickButton(QToolButton):
def mousePressEvent(self, ev):
if ev.button() == Qt.MouseButton.RightButton and self.menu() is not None:
self.showMenu()
ev.accept()
return
return QToolButton.mousePressEvent(self, ev)
class CenteredToolButton(RightClickButton):
def __init__(self, icon, text, parent=None):
super().__init__(parent)
self.setText(text)
self.setIcon(icon)
self.setSizePolicy(QSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Fixed))
self.setToolButtonStyle(Qt.ToolButtonStyle.ToolButtonTextBesideIcon)
self.text_flags = Qt.TextFlag.TextSingleLine | Qt.AlignmentFlag.AlignCenter
def paintEvent(self, ev):
painter = QStylePainter(self)
opt = QStyleOptionToolButton()
self.initStyleOption(opt)
text = opt.text
opt.text = ''
opt.icon = QIcon()
s = painter.style()
painter.drawComplexControl(QStyle.ComplexControl.CC_ToolButton, opt)
if s.styleHint(QStyle.StyleHint.SH_UnderlineShortcut, opt, self):
flags = self.text_flags | Qt.TextFlag.TextShowMnemonic
else:
flags = self.text_flags | Qt.TextFlag.TextHideMnemonic
fw = s.pixelMetric(QStyle.PixelMetric.PM_DefaultFrameWidth, opt, self)
opt.rect.adjust(fw, fw, -fw, -fw)
w = opt.iconSize.width()
text_rect = opt.rect.adjusted(w, 0, 0, 0)
painter.drawItemText(text_rect, flags, opt.palette, self.isEnabled(), text)
fm = QFontMetrics(opt.font)
text_rect = s.itemTextRect(fm, text_rect, flags, self.isEnabled(), text)
left = text_rect.left() - w - 4
pixmap_rect = QRect(left, opt.rect.top(), opt.iconSize.width(), opt.rect.height())
painter.drawItemPixmap(pixmap_rect, Qt.AlignmentFlag.AlignLeft | Qt.AlignmentFlag.AlignVCenter, self.icon().pixmap(opt.iconSize))
class Dialog(QDialog):
'''
An improved version of Qt's QDialog class. This automatically remembers the
last used size, automatically connects the signals for QDialogButtonBox,
automatically sets the window title and if the dialog has an object named
splitter, automatically saves the splitter state.
In order to use it, simply subclass an implement setup_ui(). You can also
implement sizeHint() to give the dialog a different default size when shown
for the first time.
'''
def __init__(
self, title,
name, parent=None, prefs=gprefs,
default_buttons=QDialogButtonBox.StandardButton.Ok | QDialogButtonBox.StandardButton.Cancel
):
QDialog.__init__(self, parent)
self.prefs_for_persistence = prefs
self.setWindowTitle(title)
self.name = name
self.bb = QDialogButtonBox(default_buttons)
self.bb.accepted.connect(self.accept)
self.bb.rejected.connect(self.reject)
self.setup_ui()
self.restore_geometry(self.prefs_for_persistence, self.name + '-geometry')
if hasattr(self, 'splitter'):
state = self.prefs_for_persistence.get(self.name + '-splitter-state', None)
if state is not None:
self.splitter.restoreState(state)
def accept(self):
self.save_geometry(self.prefs_for_persistence, self.name + '-geometry')
if hasattr(self, 'splitter'):
self.prefs_for_persistence.set(self.name + '-splitter-state', bytearray(self.splitter.saveState()))
QDialog.accept(self)
def reject(self):
self.save_geometry(self.prefs_for_persistence, self.name + '-geometry')
if hasattr(self, 'splitter'):
self.prefs_for_persistence.set(self.name + '-splitter-state', bytearray(self.splitter.saveState()))
QDialog.reject(self)
def setup_ui(self):
raise NotImplementedError('You must implement this method in Dialog subclasses')
class UndoCommand(QUndoCommand):
def __init__(self, widget, val):
QUndoCommand.__init__(self)
self.widget = weakref.ref(widget)
self.undo_val = widget.rating_value
self.redo_val = val
def undo(self):
w = self.widget()
w.setCurrentIndex(self.undo_val)
def redo(self):
w = self.widget()
w.setCurrentIndex(self.redo_val)
@lru_cache(maxsize=16)
def stars(num, is_half_star=False):
return rating_to_stars(num, is_half_star)
class RatingItemDelegate(QStyledItemDelegate):
def initStyleOption(self, option, index):
QStyledItemDelegate.initStyleOption(self, option, index)
option.font = QApplication.instance().font() if index.row() <= 0 else self.parent().rating_font
option.fontMetrics = QFontMetrics(option.font)
class RatingEditor(QComboBox):
def __init__(self, parent=None, is_half_star=False):
QComboBox.__init__(self, parent)
self.addItem(_('Not rated'))
if is_half_star:
[self.addItem(stars(x, True)) for x in range(1, 11)]
else:
[self.addItem(stars(x)) for x in (2, 4, 6, 8, 10)]
self.rating_font = QFont(rating_font())
self.undo_stack = QUndoStack(self)
self.undo, self.redo = self.undo_stack.undo, self.undo_stack.redo
self.allow_undo = False
self.is_half_star = is_half_star
self.delegate = RatingItemDelegate(self)
self.view().setItemDelegate(self.delegate)
self.view().setStyleSheet('QListView { background: palette(window) }\nQListView::item { padding: 6px }')
self.setMaxVisibleItems(self.count())
self.currentIndexChanged.connect(self.update_font)
@property
def null_text(self):
return self.itemText(0)
@null_text.setter
def null_text(self, val):
self.setItemtext(0, val)
def update_font(self):
if self.currentIndex() == 0:
self.setFont(QApplication.instance().font())
else:
self.setFont(self.rating_font)
def clear_to_undefined(self):
self.setCurrentIndex(0)
@property
def rating_value(self):
' An integer from 0 to 10 '
ans = self.currentIndex()
if not self.is_half_star:
ans *= 2
return ans
@rating_value.setter
def rating_value(self, val):
val = max(0, min(int(val or 0), 10))
if self.allow_undo:
cmd = UndoCommand(self, val)
self.undo_stack.push(cmd)
else:
self.undo_stack.clear()
if not self.is_half_star:
val //= 2
self.setCurrentIndex(val)
def keyPressEvent(self, ev):
if ev == QKeySequence.StandardKey.Undo:
self.undo()
return ev.accept()
if ev == QKeySequence.StandardKey.Redo:
self.redo()
return ev.accept()
k = ev.key()
num = {getattr(Qt, 'Key_%d'%i):i for i in range(6)}.get(k)
if num is None:
return QComboBox.keyPressEvent(self, ev)
ev.accept()
if self.is_half_star:
num *= 2
self.setCurrentIndex(num)
@staticmethod
def test():
q = RatingEditor(is_half_star=True)
q.rating_value = 7
return q
class FlowLayout(QLayout): # {{{
''' A layout that lays out items left-to-right wrapping onto a second line if needed '''
def __init__(self, parent=None):
QLayout.__init__(self, parent)
self.items = []
def addItem(self, item):
self.items.append(item)
def itemAt(self, idx):
try:
return self.items[idx]
except IndexError:
pass
def takeAt(self, idx):
try:
return self.items.pop(idx)
except IndexError:
pass
def count(self):
return len(self.items)
__len__ = count
def hasHeightForWidth(self):
return True
def heightForWidth(self, width):
return self.do_layout(QRect(0, 0, width, 0), apply_geometry=False)
def setGeometry(self, rect):
QLayout.setGeometry(self, rect)
self.do_layout(rect, apply_geometry=True)
def expandingDirections(self):
return Qt.Orientation(0)
def minimumSize(self):
size = QSize()
for item in self.items:
size = size.expandedTo(item.minimumSize())
left, top, right, bottom = self.getContentsMargins()
return size + QSize(left + right, top + bottom)
sizeHint = minimumSize
def smart_spacing(self, horizontal=True):
p = self.parent()
if p is None:
return -1
if p.isWidgetType():
which = QStyle.PixelMetric.PM_LayoutHorizontalSpacing if horizontal else QStyle.PixelMetric.PM_LayoutVerticalSpacing
return p.style().pixelMetric(which, None, p)
return p.spacing()
def do_layout(self, rect, apply_geometry=False):
left, top, right, bottom = self.getContentsMargins()
erect = rect.adjusted(left, top, -right, -bottom)
x, y = erect.x(), erect.y()
line_height = 0
def layout_spacing(wid, horizontal=True):
ans = self.smart_spacing(horizontal)
if ans != -1:
return ans
if wid is None:
return 0
return wid.style().layoutSpacing(
QSizePolicy.ControlType.PushButton,
QSizePolicy.ControlType.PushButton,
Qt.Orientation.Horizontal if horizontal else Qt.Orientation.Vertical)
lines, current_line = [], []
gmap = {}
for item in self.items:
isz, wid = item.sizeHint(), item.widget()
hs, vs = layout_spacing(wid), layout_spacing(wid, False)
next_x = x + isz.width() + hs
if next_x - hs > erect.right() and line_height > 0:
x = erect.x()
y = y + line_height + vs
next_x = x + isz.width() + hs
lines.append((line_height, current_line))
current_line = []
line_height = 0
if apply_geometry:
gmap[item] = x, y, isz
x = next_x
line_height = max(line_height, isz.height())
current_line.append((item, isz.height()))
lines.append((line_height, current_line))
if apply_geometry:
for line_height, items in lines:
for item, item_height in items:
x, wy, isz = gmap[item]
if item_height < line_height:
wy += (line_height - item_height) // 2
item.setGeometry(QRect(QPoint(x, wy), isz))
return y + line_height - rect.y() + bottom
@staticmethod
def test():
w = QWidget()
l = FlowLayout(w)
la = QLabel('Some text in a label')
l.addWidget(la)
c = QCheckBox('A checkboxy widget')
l.addWidget(c)
cb = QComboBox()
cb.addItems(['Item one'])
l.addWidget(cb)
return w
# }}}
class Separator(QWidget): # {{{
''' Vertical separator lines usable in FlowLayout '''
def __init__(self, parent, widget_for_height=None):
'''
You must provide a widget in the layout either here or with setBuddy.
The height of the separator is computed using this widget,
'''
QWidget.__init__(self, parent)
self.bcol = QApplication.instance().palette().color(QPalette.ColorRole.Text)
self.update_brush()
self.widget_for_height = widget_for_height
self.setSizePolicy(QSizePolicy.Policy.Fixed, QSizePolicy.Policy.MinimumExpanding)
def update_brush(self):
self.brush = QBrush(self.bcol)
self.update()
def setBuddy(self, widget_for_height):
''' See __init__. This is repurposed to support Qt Designer .ui files. '''
self.widget_for_height = widget_for_height
def sizeHint(self):
return QSize(1, 1 if self.widget_for_height is None else self.widget_for_height.height())
def paintEvent(self, ev):
painter = QPainter(self)
# Purely subjective: shorten the line a bit to look 'better'
r = ev.rect()
r.setTop(r.top() + 3)
r.setBottom(r.bottom() - 3)
painter.fillRect(r, self.brush)
painter.end()
# }}}
class HTMLDisplay(QTextBrowser):
anchor_clicked = pyqtSignal(object)
notes_resource_scheme = '' # set to scheme to use to load resources for notes from the current db
def __init__(self, parent=None, save_resources_in_document=True):
QTextBrowser.__init__(self, parent)
self.save_resources_in_document = save_resources_in_document
self.last_set_html = ''
self.default_css = self.external_css = ''
app = QApplication.instance()
app.palette_changed.connect(self.palette_changed)
self.palette_changed()
font = self.font()
f = QFontInfo(font)
delta = tweaks['change_book_details_font_size_by'] + 1
if delta:
font.setPixelSize(int(f.pixelSize() + delta))
self.setFont(font)
self.setFrameShape(QFrame.Shape.NoFrame)
self.setOpenLinks(False)
self.setAttribute(Qt.WidgetAttribute.WA_OpaquePaintEvent, False)
palette = self.palette()
palette.setBrush(QPalette.ColorRole.Base, Qt.GlobalColor.transparent)
self.setPalette(palette)
self.setAcceptDrops(False)
self.anchorClicked.connect(self.on_anchor_clicked)
def get_base_qurl(self):
return None
def setHtml(self, html):
self.last_set_html = html
QTextBrowser.setHtml(self, html)
def setDefaultStyleSheet(self, css=''):
self.external_css = css
self.document().setDefaultStyleSheet(self.default_css + self.process_external_css(self.external_css))
def palette_changed(self):
app = QApplication.instance()
if app.is_dark_theme:
pal = app.palette()
col = pal.color(QPalette.ColorRole.Link)
self.default_css = 'a { color: %s }\n\n' % col.name(QColor.NameFormat.HexRgb)
else:
self.default_css = ''
self.document().setDefaultStyleSheet(self.default_css + self.process_external_css(self.external_css))
self.setHtml(self.last_set_html)
def process_external_css(self, css):
return css
def on_anchor_clicked(self, qurl):
if not qurl.scheme() and qurl.hasFragment() and qurl.toString().startswith('#'):
frag = qurl.fragment(QUrl.ComponentFormattingOption.FullyDecoded)
if frag:
self.scrollToAnchor(frag)
return
self.anchor_clicked.emit(qurl)
def load_local_file_resource(self, rtype, qurl, path):
from calibre.utils.filenames import make_long_path_useable
try:
with open(make_long_path_useable(path), 'rb') as f:
data = f.read()
except OSError:
if path.rpartition('.')[-1].lower() in {'jpg', 'jpeg', 'gif', 'png', 'bmp', 'webp'}:
r = QByteArray(bytearray.fromhex(
'89504e470d0a1a0a0000000d49484452'
'000000010000000108060000001f15c4'
'890000000a49444154789c6300010000'
'0500010d0a2db40000000049454e44ae'
'426082'))
if self.save_resources_in_document:
self.document().addResource(rtype, qurl, r)
return r
else:
r = QByteArray(data)
if self.save_resources_in_document:
self.document().addResource(rtype, qurl, r)
return r
return super().loadResource(rtype, qurl)
def loadResource(self, rtype, qurl):
path = local_path_for_resource(qurl, base_qurl=self.get_base_qurl())
if path:
return self.load_local_file_resource(rtype, qurl, path)
if qurl.scheme() == 'calibre-icon':
r = QIcon.icon_as_png(qurl.path().lstrip('/'), as_bytearray=True)
self.document().addResource(rtype, qurl, r)
return r
if self.notes_resource_scheme and qurl.scheme() == self.notes_resource_scheme and int(rtype) == int(QTextDocument.ResourceType.ImageResource):
from calibre.gui2.ui import get_gui
gui = get_gui()
if gui is not None:
db = gui.current_db.new_api
resource = db.get_notes_resource(f'{qurl.host()}:{qurl.path()[1:]}')
if resource is not None:
r = QByteArray(resource['data'])
if self.save_resources_in_document:
self.document().addResource(rtype, qurl, r)
return r
else:
return super().loadResource(rtype, qurl)
def anchorAt(self, pos):
# Anchors in a document can be "focused" with the tab key.
# Unfortunately, the focus point that Qt provides when using the context
# menu key can be 1 pixel out of the anchor's focus rectangle. We
# correct for that here by checking if there is an anchor under the
# point, moving the point a pixel one direction then the other if there
# isn't. This process also slightly dejitters the mouse FWIW.
url = super().anchorAt(pos)
if not url:
url = super().anchorAt(QPoint(pos.x()-1, pos.y()-1))
if not url:
url = super().anchorAt(QPoint(pos.x()+1, pos.y()+1))
return url
class ScrollingTabWidget(QTabWidget):
def __init__(self, parent=None):
QTabWidget.__init__(self, parent)
def wrap_widget(self, page):
sw = QScrollArea(self)
pl = page.layout()
if pl is not None:
cm = pl.contentsMargins()
# For some reasons designer insists on setting zero margins for
# widgets added to a tab widget, which looks horrible.
if (cm.left(), cm.top(), cm.right(), cm.bottom()) == (0, 0, 0, 0):
pl.setContentsMargins(9, 9, 9, 9)
name = f'STW{abs(id(self))}'
sw.setObjectName(name)
sw.setWidget(page)
sw.setWidgetResizable(True)
page.setAutoFillBackground(False)
sw.setStyleSheet('#%s { background: transparent }' % name)
return sw
def indexOf(self, page):
for i in range(self.count()):
t = self.widget(i)
if t.widget() is page:
return i
return -1
def currentWidget(self):
return QTabWidget.currentWidget(self).widget()
def addTab(self, page, *args):
return QTabWidget.addTab(self, self.wrap_widget(page), *args)
PARAGRAPH_SEPARATOR = '\u2029'
def to_plain_text(self):
# QPlainTextEdit's toPlainText implementation replaces nbsp with normal
# space, so we re-implement it using QTextCursor, which does not do
# that
c = self.textCursor()
c.clearSelection()
c.movePosition(QTextCursor.MoveOperation.Start)
c.movePosition(QTextCursor.MoveOperation.End, QTextCursor.MoveMode.KeepAnchor)
ans = c.selectedText().replace(PARAGRAPH_SEPARATOR, '\n')
# QTextCursor pads the return value of selectedText with null bytes if
# non BMP characters such as 0x1f431 are present.
return ans.rstrip('\0')
class CalendarWidget(QCalendarWidget):
def showEvent(self, ev):
if self.selectedDate().year() == UNDEFINED_DATE.year:
self.setSelectedDate(QDate.currentDate())
class DateTimeEdit(QDateTimeEdit):
MIME_TYPE = 'application/x-calibre-datetime-value'
def __init__(self, parent=None):
QDateTimeEdit.__init__(self, parent)
self.setMinimumDateTime(UNDEFINED_QDATETIME)
self.setCalendarPopup(True)
self.cw = CalendarWidget(self)
if tweaks['calendar_start_day_of_week'] != 'Default':
try:
dow = Qt.DayOfWeek[tweaks['calendar_start_day_of_week']]
self.cw.setFirstDayOfWeek(dow)
except Exception:
print(f"Bad value for tweak calendar_start_day_of_week: {tweaks['calendar_start_day_of_week']}")
self.cw.setVerticalHeaderFormat(QCalendarWidget.VerticalHeaderFormat.NoVerticalHeader)
self.setCalendarWidget(self.cw)
self.setSpecialValueText(_('Undefined'))
@property
def mime_data_for_copy(self):
md = QMimeData()
text = self.lineEdit().selectedText()
md.setText(text or self.dateTime().toString())
md.setData(self.MIME_TYPE, self.dateTime().toString(Qt.DateFormat.ISODate).encode('ascii'))
return md
def copy(self):
QApplication.instance().clipboard().setMimeData(self.mime_data_for_copy)
def cut(self):
md = self.mime_data_for_copy
self.lineEdit().cut()
QApplication.instance().clipboard().setMimeData(md)
def paste(self):
md = QApplication.instance().clipboard().mimeData()
if md.hasFormat(self.MIME_TYPE):
self.setDateTime(QDateTime.fromString(md.data(self.MIME_TYPE).data().decode('ascii'), Qt.DateFormat.ISODate))
else:
self.lineEdit().paste()
def create_context_menu(self):
m = QMenu(self)
m.addAction(_('Set date to undefined') + '\t' + QKeySequence(Qt.Key.Key_Minus).toString(QKeySequence.SequenceFormat.NativeText),
self.clear_date)
m.addAction(_('Set date to today') + '\t' + QKeySequence(Qt.Key.Key_Equal).toString(QKeySequence.SequenceFormat.NativeText),
self.today_date)
m.addSeparator()
populate_standard_spinbox_context_menu(self, m, use_self_for_copy_actions=True)
return m
def contextMenuEvent(self, ev):
m = self.create_context_menu()
m.popup(ev.globalPos())
def today_date(self):
self.setDateTime(QDateTime.currentDateTime())
def clear_date(self):
self.setDateTime(UNDEFINED_QDATETIME)
def keyPressEvent(self, ev):
if ev.key() == Qt.Key.Key_Minus:
ev.accept()
self.clear_date()
elif ev.key() == Qt.Key.Key_Equal:
self.today_date()
ev.accept()
elif ev.matches(QKeySequence.StandardKey.Copy):
self.copy()
ev.accept()
elif ev.matches(QKeySequence.StandardKey.Cut):
self.cut()
ev.accept()
elif ev.matches(QKeySequence.StandardKey.Paste):
self.paste()
ev.accept()
else:
return QDateTimeEdit.keyPressEvent(self, ev)
class MessagePopup(QLabel):
undo_requested = pyqtSignal(object)
OFFSET_FROM_TOP = 25
def __init__(self, parent):
QLabel.__init__(self, parent)
self.setFocusPolicy(Qt.FocusPolicy.NoFocus)
self.undo_data = None
if QApplication.instance().is_dark_theme:
c = builtin_colors_dark['green']
else:
c = builtin_colors_light['green']
self.color = self.palette().color(QPalette.ColorRole.WindowText).name()
bg = QColor(c).getRgb()
self.setStyleSheet(f'''QLabel {{
background-color: rgba({bg[0]}, {bg[1]}, {bg[2]}, 0.85);
border-radius: 4px;
color: {self.color};
padding: 0.5em;
}}'''
)
self.linkActivated.connect(self.link_activated)
self.close_timer = t = QTimer()
t.setSingleShot(True)
t.timeout.connect(self.hide)
self.setMouseTracking(True)
self.hide()
def mouseMoveEvent(self, ev):
self.close_timer.start()
return super().mouseMoveEvent(ev)
def link_activated(self, link):
self.hide()
if link.startswith('undo://'):
self.undo_requested.emit(self.undo_data)
def __call__(self, text='Testing message popup', show_undo=True, timeout=5000, has_markup=False):
text = '<p>' + (text if has_markup else prepare_string_for_xml(text))
if show_undo:
self.undo_data = show_undo
text += '\xa0\xa0<a style="text-decoration: none" href="undo://me.com">{}</a>'.format(_('Undo'))
text += f'\xa0\xa0<a style="text-decoration: none; color: {self.color}" href="close://me.com">✖</a>'
self.setText(text)
self.resize(self.sizeHint())
self.position_in_parent()
self.show()
self.raise_without_focus()
self.close_timer.start(timeout)
def position_in_parent(self):
p = self.parent()
self.move((p.width() - self.width()) // 2, self.OFFSET_FROM_TOP)
if __name__ == '__main__':
from calibre.gui2 import Application
app = Application([])
app.load_builtin_fonts()
w = RatingEditor.test()
w.show()
app.exec()
| 30,684 | Python | .py | 734 | 32.803815 | 150 | 0.628264 | kovidgoyal/calibre | 19,243 | 2,250 | 4 | GPL-3.0 | 9/5/2024, 5:13:50 PM (Europe/Amsterdam) |
26,646 | languages.py | kovidgoyal_calibre/src/calibre/gui2/languages.py | #!/usr/bin/env python
__license__ = 'GPL v3'
__copyright__ = '2011, Kovid Goyal <kovid@kovidgoyal.net>'
__docformat__ = 'restructuredtext en'
from qt.core import QComboBox
from calibre.gui2 import gui_prefs
from calibre.gui2.complete2 import EditWithComplete
from calibre.utils.icu import lower, sort_key
from calibre.utils.localization import lang_map_for_ui
from polyglot.builtins import iteritems, itervalues
class LanguagesEdit(EditWithComplete):
def __init__(self, parent=None, db=None, prefs=None):
self.prefs = prefs or gui_prefs()
self.refresh_recently_used()
EditWithComplete.__init__(self, parent, sort_func=self.sort_language_items_key)
self.setSizeAdjustPolicy(QComboBox.SizeAdjustPolicy.AdjustToMinimumContentsLengthWithIcon)
self.setMinimumContentsLength(20)
self._lang_map = lang_map_for_ui()
self.names_with_commas = [x for x in itervalues(self._lang_map) if ',' in x]
self.comma_map = {k:k.replace(',', '|') for k in self.names_with_commas}
self.comma_rmap = {v:k for k, v in iteritems(self.comma_map)}
self._rmap = {lower(v):k for k,v in iteritems(self._lang_map)}
self.init_langs(db)
self.item_selected.connect(self.update_recently_used)
def init_langs(self, db):
self.update_items_cache(itervalues(self._lang_map))
def refresh_recently_used(self):
recently_used = self.prefs.get('recently_used_languages') or ()
self.recently_used = {x:i for i, x in enumerate(recently_used) if x}
def update_recently_used(self):
recently_used = self.prefs.get('recently_used_languages') or []
vals = self.vals
for x in vals:
if x:
if x in recently_used:
recently_used.remove(x)
recently_used.insert(0, x)
self.prefs.set('recently_used_languages', recently_used[:5])
def sort_language_items_key(self, val):
idx = self.recently_used.get(val, 100000)
return (idx, sort_key(val))
@property
def vals(self):
raw = str(self.lineEdit().text())
for k, v in iteritems(self.comma_map):
raw = raw.replace(k, v)
parts = [x.strip() for x in raw.split(',')]
return [self.comma_rmap.get(x, x) for x in parts]
@property
def lang_codes(self):
vals = self.vals
ans = []
for name in vals:
if name:
code = self._rmap.get(lower(name), None)
if code is not None:
ans.append(code)
return ans
@lang_codes.setter
def lang_codes(self, lang_codes):
self.set_lang_codes(lang_codes, allow_undo=False)
def set_lang_codes(self, lang_codes, allow_undo=True):
ans = []
for lc in lang_codes:
name = self._lang_map.get(lc, None)
if name is not None:
ans.append(name)
ans = ', '.join(ans)
if allow_undo:
orig, self.disable_popup = self.disable_popup, True
try:
self.lineEdit().selectAll(), self.lineEdit().insert(ans)
finally:
self.disable_popup = orig
else:
self.setEditText(ans)
def validate(self):
vals = self.vals
bad = []
for name in vals:
if name:
code = self._rmap.get(lower(name), None)
if code is None:
bad.append(name)
return bad
| 3,515 | Python | .py | 85 | 32.047059 | 98 | 0.605803 | kovidgoyal/calibre | 19,243 | 2,250 | 4 | GPL-3.0 | 9/5/2024, 5:13:50 PM (Europe/Amsterdam) |
26,647 | central.py | kovidgoyal_calibre/src/calibre/gui2/central.py | #!/usr/bin/env python
# License: GPLv3 Copyright: 2023, Kovid Goyal <kovid at kovidgoyal.net>
from contextlib import suppress
from copy import copy
from dataclasses import asdict, dataclass, fields
from enum import Enum, auto
from qt.core import (
QAction,
QDialog,
QHBoxLayout,
QIcon,
QKeySequence,
QLabel,
QMainWindow,
QPalette,
QPointF,
QSize,
QSizePolicy,
QStyle,
QStyleOption,
QStylePainter,
Qt,
QToolButton,
QVBoxLayout,
QWidget,
pyqtSignal,
)
from calibre.gui2 import Application, config, gprefs
from calibre.gui2.cover_flow import MIN_SIZE
HIDE_THRESHOLD = 10
SHOW_THRESHOLD = 50
def migrate_settings(width=-1, height=-1):
if width < 100:
width = 1200
if height < 100:
height = 600
wd, nd = WideDesires(), NarrowDesires()
ans = {
'layout': config['gui_layout'],
'wide_visibility': Visibility().serialize(),
'narrow_visibility': Visibility().serialize(),
'wide_desires': wd.serialize(),
'narrow_desires': nd.serialize(),
}
sizes = {
'wide': {
'tag_browser': int(width * wd.tag_browser_width),
'book_details': int(width * wd.book_details_width),
'cover_browser': int(height * wd.cover_browser_height),
'quick_view': int(height * wd.quick_view_height),
},
'narrow': {
'tag_browser': int(width * nd.tag_browser_width),
'book_details': int(height * nd.book_details_height),
'cover_browser': int(width * nd.cover_browser_width),
'quick_view': int(height * nd.quick_view_height),
}
}
for which, hor_is_wide in {
'tag_browser': True,
'book_details': True,
'cover_browser': False,
}.items():
key = 'wide' if hor_is_wide else 'narrow'
val = gprefs.get(f'{which}_splitter_horizontal_state')
if val:
with suppress(Exception):
ans[f'{key}_visibility'][which] = bool(val[0])
sizes[key][which] = val[1]
key = 'narrow' if hor_is_wide else 'wide'
val = gprefs.get(f'{which}_splitter_vertical_state')
if val:
with suppress(Exception):
ans[f'{key}_visibility'][which] = bool(val[0])
sizes[key][which] = val[1]
if gprefs.get('quickview visible'):
ans['wide_visibility']['quick_view'] = ans['narrow_visibility']['quick_view'] = True
qdh = gprefs.get('quickview_dialog_heights') or (int(2*height/3), int(height/3))
# Migrate wide sizes
s, a = sizes['wide'], ans['wide_desires']
a['tag_browser_width'] = min(0.45, s['tag_browser'] / width)
a['book_details_width'] = min(0.45, s['book_details'] / width)
theight = s['cover_browser'] + qdh[0] + qdh[1]
if theight == s['cover_browser']:
theight *= 3
a['cover_browser_height'] = s['cover_browser'] / theight
a['quick_view_height'] = qdh[1] / theight
# Migrate narrow sizes
s, a = sizes['narrow'], ans['narrow_desires']
a['tag_browser_width'] = min(0.45, s['tag_browser'] / width)
a['cover_browser_width'] = min(0.45, s['cover_browser'] / width)
theight = s['book_details'] + qdh[0] + qdh[1]
if theight == s['book_details']:
theight *= 3
a['book_details_height'] = s['book_details'] / theight
a['quick_view_height'] = qdh[1] / theight
return ans
class Placeholder(QLabel):
backgrounds = 'yellow', 'lightgreen', 'grey', 'cyan', 'magenta'
bgcount = 0
def __init__(self, text, parent=None):
super().__init__(text, parent)
bg = self.backgrounds[Placeholder.bgcount]
Placeholder.bgcount = (Placeholder.bgcount + 1) % len(self.backgrounds)
self.setStyleSheet(f'QLabel {{ background: {bg};\nborder: 1px solid red; }}')
class LayoutButton(QToolButton):
on_action_trigger = pyqtSignal(bool)
def __init__(self, name: str, icon: str, label: str, central: 'CentralContainer', shortcut=None):
super().__init__(central)
self.central = central
self.label = label
self.name = name
self.shortcut = shortcut
self.setIcon(QIcon.ic(icon))
self.setCheckable(True)
self.setChecked(self.is_visible)
self.setCursor(Qt.CursorShape.PointingHandCursor)
if isinstance(central, CentralContainer):
self.toggled.connect(central.layout_button_toggled)
def initialize_with_gui(self, gui):
if self.shortcut is not None:
self.action_toggle = QAction(self.icon(), _('Toggle') + ' ' + self.label, self)
self.action_toggle.changed.connect(self.update_shortcut)
self.action_toggle.triggered.connect(self.toggle)
gui.addAction(self.action_toggle)
gui.keyboard.register_shortcut(
f'toggle_central_panel_{self.name}', self.action_toggle.text(), group=_('Main window layout'),
default_keys=(self.shortcut,), action=self.action_toggle)
@property
def is_visible(self):
return getattr(self.central.is_visible, self.name)
def update_shortcut(self, action_toggle=None):
if not isinstance(action_toggle, QAction):
action_toggle = getattr(self, 'action_toggle', None)
if action_toggle:
sc = ', '.join(sc.toString(QKeySequence.SequenceFormat.NativeText)
for sc in action_toggle.shortcuts())
self.shortcut = sc or ''
self.update_text()
def update_text(self):
t = _('Hide {}') if self.isChecked() else _('Show {}')
t = t.format(self.label)
if self.shortcut:
t += f' [{self.shortcut}]'
self.setText(t), self.setToolTip(t), self.setStatusTip(t)
def set_state_to_show(self, *args):
self.setChecked(False)
self.update_text()
def set_state_to_hide(self, *args):
self.setChecked(True)
self.update_text()
def update_state(self, *args):
self.set_state_to_show() if self.is_visible else self.set_state_to_hide()
def mouseReleaseEvent(self, ev):
if ev.button() == Qt.MouseButton.RightButton:
from calibre.gui2.ui import get_gui
gui = get_gui()
if self.name == 'search':
gui.iactions['Preferences'].do_config(initial_plugin=('Interface', 'Search'), close_after_initial=True)
ev.accept()
return
tab_name = {'book_details':'book_details', 'cover_grid':'cover_grid', 'cover_browser':'cover_browser',
'tag_browser':'tag_browser', 'quick_view':'quickview'}.get(self.name)
if tab_name:
if gui is not None:
gui.iactions['Preferences'].do_config(initial_plugin=('Interface', 'Look & Feel', tab_name+'_tab'), close_after_initial=True)
ev.accept()
return
return QToolButton.mouseReleaseEvent(self, ev)
class HandleState(Enum):
both_visible = auto()
only_main_visible = auto()
only_side_visible = auto()
class SplitterHandle(QWidget):
dragged_to = pyqtSignal(QPointF)
toggle_requested = pyqtSignal()
drag_start = None
COLLAPSED_SIZE = 2 # pixels
def __init__(self, parent: QWidget=None, orientation: Qt.Orientation = Qt.Orientation.Vertical):
super().__init__(parent)
self.set_orientation(orientation)
def set_orientation(self, orientation):
self.orientation = orientation
if orientation is Qt.Orientation.Vertical:
self.setCursor(Qt.CursorShape.SplitHCursor)
else:
self.setCursor(Qt.CursorShape.SplitVCursor)
@property
def state(self) -> HandleState:
p = self.parent()
if p is not None:
try:
return p.handle_state(self)
except AttributeError as err:
raise Exception(str(err)) from err
return HandleState.both_visible
def mousePressEvent(self, ev):
super().mousePressEvent(ev)
if ev.button() is Qt.MouseButton.LeftButton:
self.drag_start = ev.position()
def mouseReleaseEvent(self, ev):
super().mouseReleaseEvent(ev)
if ev.button() is Qt.MouseButton.LeftButton:
self.drag_start = None
def mouseDoubleClickEvent(self, ev):
if ev.button() == Qt.MouseButton.LeftButton:
self.toggle_requested.emit()
ev.accept()
return
return super().mouseDoubleClickEvent(ev)
def mouseMoveEvent(self, ev):
super().mouseMoveEvent(ev)
if self.drag_start is not None:
pos = ev.position() - self.drag_start
self.dragged_to.emit(self.mapToParent(pos))
def paintEvent(self, ev):
p = QStylePainter(self)
opt = QStyleOption()
opt.initFrom(self)
if self.orientation is Qt.Orientation.Vertical:
opt.state |= QStyle.StateFlag.State_Horizontal
if min(opt.rect.width(), opt.rect.height()) == self.COLLAPSED_SIZE:
p.fillRect(opt.rect, opt.palette.color(QPalette.ColorRole.Window))
else:
p.drawControl(QStyle.ControlElement.CE_Splitter, opt)
p.end()
class Layout(Enum):
wide = auto()
narrow = auto()
@dataclass
class WideDesires:
tag_browser_width: float = 0.3
book_details_width: float = 0.3
cover_browser_height: float = 0.4
quick_view_height: float = 0.2
def serialize(self):
return {k: v for k, v in asdict(self).items() if v > 0}
def unserialize(self, x):
for field in fields(self):
v = x.get(field.name, 0)
if isinstance(v, (int, float)) and 0 < v <= 1:
setattr(self, field.name, v)
def reset_to_defaults(self):
c = type(self)
for f in fields(self):
setattr(self, f.name, getattr(c, f.name))
@dataclass
class NarrowDesires:
book_details_height: int = 0.3
quick_view_height: int = 0.2
tag_browser_width: int = 0.25
cover_browser_width: int = 0.35
def serialize(self):
return {k: v for k, v in asdict(self).items() if v > 0}
def unserialize(self, x):
for field in fields(self):
v = x.get(field.name, 0)
if isinstance(v, (int, float)) and 0 < v <= 1:
setattr(self, field.name, v)
def reset_to_defaults(self):
c = type(self)
for f in fields(self):
setattr(self, f.name, getattr(c, f.name))
@dataclass
class Visibility:
tag_browser: bool = True
book_details: bool = True
book_list: bool = True
cover_browser: bool = False
quick_view: bool = False
def serialize(self):
return asdict(self)
def unserialize(self, x):
for f in fields(self):
v = x.get(f.name)
if isinstance(v, bool):
setattr(self, f.name, v)
def reset_to_defaults(self):
c = type(self)
for f in fields(self):
setattr(self, f.name, getattr(c, f.name))
class CentralContainer(QWidget):
layout: Layout = Layout.wide
def __init__(self, parent=None, prefs_name='main_window_central_widget_state', separate_cover_browser=None, for_develop=False):
self.separate_cover_browser = config['separate_cover_flow'] if separate_cover_browser is None else separate_cover_browser
self.prefs_name = prefs_name
self.wide_desires = WideDesires()
self.narrow_desires = NarrowDesires()
self.wide_is_visible = Visibility()
self.narrow_is_visible = Visibility()
self._last_cb_position = self.gui = None
super().__init__(parent)
self.action_toggle_layout = QAction(self)
self.action_toggle_layout.triggered.connect(self.toggle_layout)
self.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Expanding)
if for_develop:
self.tag_browser = Placeholder('tag browser', self)
self.book_list = Placeholder('book list', self)
self.cover_browser = Placeholder('cover browser', self)
self.book_details = Placeholder('book details', self)
self.quick_view = Placeholder('quick view', self)
else:
self.tag_browser = QWidget(self)
self.book_list = QWidget(self)
self.cover_browser = QWidget(self)
self.book_details = QWidget(self)
self.quick_view = QWidget(self)
self.cover_browser.setMinimumSize(MIN_SIZE)
self.ignore_button_toggles = False
self.tag_browser_button = LayoutButton('tag_browser', 'tags.png', _('Tag browser'), self, 'Shift+Alt+T')
self.book_details_button = LayoutButton('book_details', 'book.png', _('Book details'), self, 'Shift+Alt+D')
self.cover_browser_button = LayoutButton('cover_browser', 'cover_flow.png', _('Cover browser'), self, 'Shift+Alt+B')
self.quick_view_button = LayoutButton('quick_view', 'quickview.png', _('Quickview'), self)
self.setMinimumSize(MIN_SIZE + QSize(200, 100))
def h(orientation: Qt.Orientation = Qt.Orientation.Vertical):
ans = SplitterHandle(self, orientation)
ans.dragged_to.connect(self.splitter_handle_dragged)
ans.toggle_requested.connect(self.toggle_handle)
return ans
self.left_handle = h()
self.right_handle = h()
self.top_handle = h(Qt.Orientation.Horizontal)
self.bottom_handle = h(Qt.Orientation.Horizontal)
@property
def narrow_cb_on_top(self):
p = self._last_cb_position = gprefs['cover_browser_narrow_view_position']
if p == 'automatic':
gui = self.gui or self
ratio = gui.width() / gui.height()
return ratio <= 1.4
return p == 'on_top'
@property
def cb_on_top_changed(self):
return (self._last_cb_position is None or
gprefs['cover_browser_narrow_view_position'] != self._last_cb_position)
@property
def is_visible(self):
return self.wide_is_visible if self.layout is Layout.wide else self.narrow_is_visible
def set_widget(self, which, w):
existing = getattr(self, which)
existing.setVisible(False)
existing.setParent(None)
setattr(self, which, w)
w.setParent(self)
def initialize_with_gui(self, gui, book_list_widget):
self.gui = gui
self.tag_browser_button.initialize_with_gui(gui)
self.book_details_button.initialize_with_gui(gui)
self.cover_browser_button.initialize_with_gui(gui)
self.quick_view_button.initialize_with_gui(gui)
self.set_widget('book_details', gui.book_details)
self.set_widget('tag_browser', gui.tb_widget)
self.set_widget('book_list', book_list_widget)
gui.keyboard.register_shortcut(
'toggle_layout_type', _('Toggle layout between wide and narrow'), group=_('Main window layout'),
default_keys=('Alt+Shift+L',), action=self.action_toggle_layout)
gui.addAction(self.action_toggle_layout)
# cover browser is set in CoverFlowMixin
# Quickview is set in quickview.py code
@property
def is_wide(self):
return self.layout is Layout.wide
def change_layout(self, gui, is_wide):
layout = Layout.wide if is_wide else Layout.narrow
if layout is self.layout and not self.cb_on_top_changed:
return False
ss = self.serialized_settings()
before = ss[self.layout.name + '_visibility']
after = ss[layout.name + '_visibility']
gui.book_details.change_layout(is_wide)
self.layout = layout
self.write_settings()
# apply visibility changes by clicking buttons to ensure button
# state is correct and also deals with the case of the QV widget not
# being initialised
changes = set()
if before != after:
for k in before:
if before[k] != after[k]:
changes.add(k)
setattr(self.is_visible, k, before[k])
if changes:
for k in changes:
button = getattr(self, k + '_button')
button.click()
else:
self.relayout()
return True
def serialized_settings(self):
return {
'layout': self.layout.name,
'wide_visibility': self.wide_is_visible.serialize(),
'narrow_visibility': self.narrow_is_visible.serialize(),
'wide_desires': self.wide_desires.serialize(),
'narrow_desires': self.narrow_desires.serialize()
}
def layout_button_toggled(self):
if not self.ignore_button_toggles:
b = self.sender()
if b.name == 'quick_view':
return
self.set_visibility_of(b.name, b.isChecked())
self.relayout()
def unserialize_settings(self, s):
l = s.get('layout')
self.layout = Layout.narrow if l == 'narrow' else Layout.wide
self.wide_is_visible.unserialize(s.get('wide_visibility') or {})
self.narrow_is_visible.unserialize(s.get('narrow_visibility') or {})
self.wide_desires.unserialize(s.get('wide_desires') or {})
self.narrow_desires.unserialize(s.get('narrow_desires') or {})
def write_settings(self):
gprefs.set(self.prefs_name, self.serialized_settings())
def read_settings(self):
before = self.serialized_settings()
# sadly self.size() doesnt always return sensible values so look at
# the size of the main window which works perfectly for width, not so
# perfectly for height
sz = self.size()
p = self.parent()
while p is not None and not isinstance(p, QMainWindow):
p = p.parent()
if p is not None:
psz = p.size()
sz = QSize(max(sz.width(), psz.width()), max(sz.height(), psz.height() - 50))
settings = gprefs.get(self.prefs_name) or migrate_settings(sz.width(), sz.height())
self.unserialize_settings(settings)
if self.serialized_settings() != before:
self.update_button_states_from_visibility()
self.relayout()
return True
return False
def reset_to_defaults(self):
before = self.serialized_settings()
self.layout = Layout.wide
self.is_visible.reset_to_defaults()
self.wide_desires.reset_to_defaults()
self.narrow_desires.reset_to_defaults()
if self.serialized_settings() != before:
self.update_button_states_from_visibility()
self.relayout()
def toggle_panel(self, which):
was_visible = getattr(self.is_visible, which)
self.set_visibility_of(which, was_visible ^ True)
self.relayout()
def set_visibility_of(self, which, visible):
was_visible = getattr(self.is_visible, which)
setattr(self.is_visible, which, visible)
if not was_visible:
if self.layout is Layout.wide:
self.size_panel_on_initial_show_wide(which)
else:
self.size_panel_on_initial_show_narrow(which)
self.update_button_states_from_visibility()
def show_panel(self, which):
if not getattr(self.is_visible, which):
self.set_visibility_of(which, True)
self.relayout()
def hide_panel(self, which):
if getattr(self.is_visible, which):
self.set_visibility_of(which, False)
self.relayout()
def panel_name_for_handle(self, handle):
return self.panel_name_for_handle_wide(handle) if self.layout is Layout.wide else self.panel_name_for_handle_narrow(handle)
def toggle_handle(self):
panel = self.panel_name_for_handle(self.sender())
self.set_visibility_of(panel, getattr(self.is_visible, panel) ^ True)
self.relayout()
def update_button_states_from_visibility(self):
orig = self.ignore_button_toggles
self.ignore_button_toggles = True
try:
self.tag_browser_button.setChecked(self.is_visible.tag_browser)
self.book_details_button.setChecked(self.is_visible.book_details)
self.cover_browser_button.setChecked(self.is_visible.cover_browser)
self.quick_view_button.setChecked(self.is_visible.quick_view)
finally:
self.ignore_button_toggles = orig
def toggle_tag_browser(self):
self.toggle_panel('tag_browser')
def toggle_book_details(self):
self.toggle_panel('book_details')
def toggle_cover_browser(self):
self.toggle_panel('cover_browser')
def toggle_quick_view(self):
self.toggle_panel('quick_view')
def handle_state(self, handle):
if self.layout is Layout.wide:
return self.wide_handle_state(handle)
return self.narrow_handle_state(handle)
def splitter_handle_dragged(self, pos):
handle = self.sender()
bv = copy(self.is_visible)
if self.layout is Layout.wide:
bd = copy(self.wide_desires)
self.wide_move_splitter_handle_to(handle, pos)
ad = self.wide_desires
else:
bd = copy(self.narrow_desires)
self.narrow_move_splitter_handle_to(handle, pos)
ad = self.narrow_desires
if (bv, bd) != (self.is_visible, ad):
if bv != self.is_visible:
self.update_button_states_from_visibility()
self.relayout()
def resizeEvent(self, ev):
super().resizeEvent(ev)
self.relayout()
def relayout(self):
self.tag_browser.setVisible(self.is_visible.tag_browser)
self.book_details.setVisible(self.is_visible.book_details)
self.cover_browser.setVisible(self.is_visible.cover_browser and not self.separate_cover_browser)
self.book_list.setVisible(self.is_visible.book_list)
self.quick_view.setVisible(self.is_visible.quick_view)
if self.layout is Layout.wide:
self.right_handle.set_orientation(Qt.Orientation.Vertical)
self.do_wide_layout()
else:
self.right_handle.set_orientation(Qt.Orientation.Horizontal if self.narrow_cb_on_top else Qt.Orientation.Vertical)
self.do_narrow_layout()
self.update()
def toggle_layout(self):
if self.gui:
self.change_layout(self.gui, self.layout is Layout.narrow)
else:
self.layout = Layout.narrow if self.layout is Layout.wide else Layout.wide
self.relayout()
def button_for(self, which):
return getattr(self, which + '_button')
def sizeHint(self):
return QSize(800, 600)
# Wide {{{
def wide_handle_state(self, handle):
if handle is self.left_handle:
return HandleState.both_visible if self.is_visible.tag_browser else HandleState.only_main_visible
if handle is self.right_handle:
return HandleState.both_visible if self.is_visible.book_details else HandleState.only_main_visible
if handle is self.top_handle:
if self.is_visible.cover_browser and not self.separate_cover_browser:
return HandleState.both_visible if self.is_visible.book_list else HandleState.only_side_visible
return HandleState.only_main_visible
if handle is self.bottom_handle:
return HandleState.both_visible if self.is_visible.quick_view else HandleState.only_main_visible
def min_central_width_wide(self):
return max(200, self.cover_browser.minimumWidth())
def do_wide_layout(self):
s = self.style()
normal_handle_width = int(s.pixelMetric(QStyle.PixelMetric.PM_SplitterWidth, widget=self))
available_width = self.width()
for h in (self.left_handle, self.right_handle):
width = h.COLLAPSED_SIZE
hs = h.state
if hs is HandleState.both_visible or hs is HandleState.only_side_visible:
width = normal_handle_width
h.resize(int(width), int(self.height()))
available_width -= width
tb = int(self.width() * self.wide_desires.tag_browser_width) if self.is_visible.tag_browser else 0
bd = int(self.width() * self.wide_desires.book_details_width) if self.is_visible.book_details else 0
min_central_width = self.min_central_width_wide()
if tb + bd > available_width - min_central_width:
width_to_share = max(0, available_width - min_central_width)
tb = int(tb * width_to_share / (tb + bd))
bd = max(0, width_to_share - tb)
central_width = available_width - (tb + bd)
if self.is_visible.tag_browser:
self.tag_browser.setGeometry(0, 0, int(tb), int(self.height()))
self.left_handle.move(tb, 0)
central_x = self.left_handle.x() + self.left_handle.width()
self.right_handle.move(tb + central_width + self.left_handle.width(), 0)
if self.is_visible.book_details:
self.book_details.setGeometry(int(self.right_handle.x() + self.right_handle.width()), 0, int(bd), int(self.height()))
available_height = self.height()
for h in (self.top_handle, self.bottom_handle):
height = h.COLLAPSED_SIZE
hs = h.state
if hs is HandleState.both_visible or hs is HandleState.only_side_visible:
height = normal_handle_width
if hs is HandleState.only_main_visible and h is self.bottom_handle or (h is self.top_handle and self.separate_cover_browser):
height = 0
h.resize(int(central_width), int(height))
available_height -= height
cb = max(self.cover_browser.minimumHeight(), int(self.wide_desires.cover_browser_height * self.height()))
if not self.is_visible.cover_browser or self.separate_cover_browser:
cb = 0
qv = bl = 0
if cb >= available_height:
cb = available_height
else:
available_height -= cb
min_bl_height = 50
if available_height <= min_bl_height:
bl = available_height
elif self.is_visible.quick_view:
qv = min(available_height - min_bl_height, int(self.wide_desires.quick_view_height * self.height()))
if qv < HIDE_THRESHOLD:
qv = 0
bl = available_height - qv
else:
bl = available_height
if self.is_visible.cover_browser and not self.separate_cover_browser:
self.cover_browser.setGeometry(int(central_x), 0, int(central_width), int(cb))
self.top_handle.move(central_x, cb)
if self.is_visible.book_list:
self.book_list.setGeometry(int(central_x), int(self.top_handle.y() + self.top_handle.height()), int(central_width), int(bl))
self.bottom_handle.move(central_x, self.book_list.y() + self.book_list.height())
if self.is_visible.quick_view:
self.quick_view.setGeometry(int(central_x), int(self.bottom_handle.y() + self.bottom_handle.height()), int(central_width), int(qv))
def wide_move_splitter_handle_to(self, handle: SplitterHandle, pos: QPointF):
if handle is self.left_handle:
x = int(pos.x())
self.is_visible.tag_browser = True
if x < HIDE_THRESHOLD:
self.is_visible.tag_browser = False
self.wide_desires.tag_browser_width = 0
else:
self.wide_desires.tag_browser_width = x / self.width()
elif handle is self.right_handle:
x = int(pos.x())
self.is_visible.book_details = True
w = self.width() - x
if w < HIDE_THRESHOLD:
self.is_visible.book_details = False
self.wide_desires.book_details_width = 0
else:
self.wide_desires.book_details_width = w / self.width()
elif handle is self.top_handle:
y = int(pos.y())
self.is_visible.cover_browser = True
if y < max(self.cover_browser.minimumHeight(), HIDE_THRESHOLD):
self.is_visible.cover_browser = False
self.wide_desires.cover_browser_height = 0
else:
self.wide_desires.cover_browser_height = max(y, self.cover_browser.minimumHeight()) / self.height()
elif handle is self.bottom_handle:
y = int(pos.y())
h = self.height() - y - self.bottom_handle.height()
if h < HIDE_THRESHOLD:
self.is_visible.quick_view = False
self.wide_desires.quick_view_height = 0
else:
available_height = max(0, self.height() - self.top_handle.height() - self.bottom_handle.height() - self.cover_browser.minimumHeight() - 50)
self.wide_desires.quick_view_height = max(HIDE_THRESHOLD, min(h, available_height)) / self.height()
def size_panel_on_initial_show_wide(self, which):
if which in ('tag_browser', 'book_details'):
which += '_width'
current = int(getattr(self.wide_desires, which) * self.width())
if current < SHOW_THRESHOLD:
setattr(self.wide_desires, which, getattr(WideDesires, which))
elif which == 'cover_browser':
self.wide_desires.cover_browser_height = max(int(self.height() * self.wide_desires.cover_browser_height),
self.cover_browser.minimumHeight()) / self.height()
else:
self.wide_desires.quick_view_height = max(int(self.height() * self.wide_desires.quick_view_height), 150) / self.height()
def panel_name_for_handle_wide(self, handle):
return {self.left_handle: 'tag_browser', self.right_handle: 'book_details', self.top_handle: 'cover_browser', self.bottom_handle: 'quick_view'}[handle]
# }}}
# Narrow {{{
def narrow_handle_state(self, handle):
if handle is self.left_handle:
return HandleState.both_visible if self.is_visible.tag_browser else HandleState.only_main_visible
if handle is self.right_handle:
if self.is_visible.cover_browser and not self.separate_cover_browser:
return HandleState.both_visible if self.is_visible.book_list else HandleState.only_side_visible
return HandleState.only_main_visible
if handle is self.top_handle:
return HandleState.both_visible if self.is_visible.quick_view else HandleState.only_main_visible
if handle is self.bottom_handle:
return HandleState.both_visible if self.is_visible.book_details else HandleState.only_main_visible
def min_central_width_narrow(self):
return 200
def min_central_height_narrow(self):
return max(150, self.cover_browser.minimumHeight())
def do_narrow_layout_with_cb_on_top(self):
s = self.style()
normal_handle_width = int(s.pixelMetric(QStyle.PixelMetric.PM_SplitterWidth, widget=self))
available_height = self.height()
for handle in (self.bottom_handle, self.right_handle):
hs = handle.state
height = self.bottom_handle.COLLAPSED_SIZE
if hs is HandleState.both_visible or hs is HandleState.only_side_visible:
height = normal_handle_width
handle.resize(self.width(), height)
available_height -= height
bd = int(self.narrow_desires.book_details_height * self.height()) if self.is_visible.book_details else 0
bd = max(0, min(bd, max(0, available_height - self.min_central_height_narrow() - 40)))
central_height = available_height - bd + self.right_handle.height()
self.bottom_handle.move(0, central_height - self.bottom_handle.height())
if self.is_visible.book_details:
self.book_details.setGeometry(0, self.bottom_handle.y() + self.bottom_handle.height(), self.width(), bd)
available_width = self.width()
hs = self.left_handle.state
width = self.left_handle.COLLAPSED_SIZE
if hs is HandleState.both_visible or hs is HandleState.only_side_visible:
width = normal_handle_width
self.left_handle.resize(width, central_height)
available_width -= width
tb = int(self.narrow_desires.tag_browser_width * self.width()) if self.is_visible.tag_browser else 0
self.left_handle.move(tb, 0)
if self.is_visible.tag_browser:
self.tag_browser.setGeometry(0, 0, tb, central_height)
central_x = self.left_handle.x() + self.left_handle.width()
central_width = self.width() - central_x
central_height -= self.right_handle.height()
cb = min(max(0, central_height - 80), int(self.height() * self.narrow_desires.cover_browser_width)) if self.is_visible.cover_browser else 0
if cb and cb < self.cover_browser.minimumHeight():
cb = min(self.cover_browser.minimumHeight(), central_height)
if self.is_visible.cover_browser:
self.cover_browser.setGeometry(central_x, 0, central_width, cb)
self.right_handle.resize(central_width, self.right_handle.height())
self.right_handle.move(central_x, cb)
central_top = self.right_handle.y() + self.right_handle.height()
central_height = self.bottom_handle.y() - central_top
self.top_handle.resize(central_width, normal_handle_width if self.is_visible.quick_view else 0)
available_height = central_height - self.top_handle.height()
qv = int(self.height() * self.narrow_desires.quick_view_height) if self.is_visible.quick_view else 0
qv = min(qv, max(0, available_height - 80))
bl = max(0, available_height - qv)
self.book_list.setGeometry(central_x, central_top, central_width, bl)
self.top_handle.move(central_x, self.book_list.y() + self.book_list.height())
if self.is_visible.quick_view:
self.quick_view.setGeometry(central_x, self.top_handle.y() + self.top_handle.height(), central_width, qv)
def do_narrow_layout(self):
if self.narrow_cb_on_top:
return self.do_narrow_layout_with_cb_on_top()
s = self.style()
normal_handle_width = int(s.pixelMetric(QStyle.PixelMetric.PM_SplitterWidth, widget=self))
available_height = self.height()
hs = self.bottom_handle.state
height = self.bottom_handle.COLLAPSED_SIZE
if hs is HandleState.both_visible or hs is HandleState.only_side_visible:
height = normal_handle_width
self.bottom_handle.resize(int(self.width()), int(height))
available_height -= height
bd = int(self.narrow_desires.book_details_height * self.height()) if self.is_visible.book_details else 0
central_height = max(self.min_central_height_narrow(), available_height - bd)
bd = available_height - central_height
self.bottom_handle.move(0, central_height)
if self.is_visible.book_details:
self.book_details.setGeometry(0, int(central_height + self.bottom_handle.height()), int(self.width()), int(bd))
available_width = self.width()
for h in (self.left_handle, self.right_handle):
width = h.COLLAPSED_SIZE
hs = h.state
if hs is HandleState.both_visible or hs is HandleState.only_side_visible:
width = normal_handle_width
if h is self.right_handle and self.separate_cover_browser:
width = 0
h.resize(int(width), int(central_height))
available_width -= width
tb = int(self.narrow_desires.tag_browser_width * self.width()) if self.is_visible.tag_browser else 0
cb = max(self.cover_browser.minimumWidth(),
int(self.narrow_desires.cover_browser_width * self.width())) if self.is_visible.cover_browser and not self.separate_cover_browser else 0
min_central_width = self.min_central_width_narrow()
if tb + cb > max(0, available_width - min_central_width):
width_to_share = max(0, available_width - min_central_width)
cb = int(cb * width_to_share / (tb + cb))
cb = max(self.cover_browser.minimumWidth(), cb)
if cb > width_to_share:
cb = 0
tb = max(0, width_to_share - cb)
central_width = available_width - (tb + cb)
if self.is_visible.tag_browser:
self.tag_browser.setGeometry(0, 0, int(tb), int(central_height))
self.left_handle.move(tb, 0)
central_x = self.left_handle.x() + self.left_handle.width()
self.right_handle.move(tb + central_width + self.left_handle.width(), 0)
if self.is_visible.cover_browser and not self.separate_cover_browser:
self.cover_browser.setGeometry(int(self.right_handle.x() + self.right_handle.width()), 0, int(cb), int(central_height))
self.top_handle.resize(int(central_width), int(normal_handle_width if self.is_visible.quick_view else 0))
central_height -= self.top_handle.height()
qv = 0
if self.is_visible.quick_view:
qv = int(self.narrow_desires.quick_view_height * self.height())
qv = max(0, min(qv, central_height - 50))
self.book_list.setGeometry(int(central_x), 0, int(central_width), int(max(0, central_height - qv)))
self.top_handle.move(central_x, self.book_list.y() + self.book_list.height())
if self.is_visible.quick_view:
self.quick_view.setGeometry(int(central_x), int(self.top_handle.y() + self.top_handle.height()), int(central_width), int(qv))
def narrow_move_splitter_handle_to(self, handle: SplitterHandle, pos: QPointF):
if handle is self.left_handle:
x = int(pos.x())
available_width = self.width() - self.left_handle.width() - self.right_handle.width() - self.min_central_width_narrow()
if self.narrow_cb_on_top:
available_width += self.right_handle.width()
self.is_visible.tag_browser = True
if x < HIDE_THRESHOLD:
self.is_visible.tag_browser = False
self.narrow_desires.tag_browser_width = 0
else:
self.narrow_desires.tag_browser_width = min(available_width, x) / self.width()
elif handle is self.right_handle:
if self.narrow_cb_on_top:
y = int(pos.y())
self.is_visible.cover_browser = True
if y < max(self.cover_browser.minimumHeight(), HIDE_THRESHOLD):
self.is_visible.cover_browser = False
self.narrow_desires.cover_browser_width = 0
else:
self.narrow_desires.cover_browser_width = max(y, self.cover_browser.minimumHeight()) / self.height()
else:
x = int(pos.x())
available_width = self.width() - self.left_handle.width() - self.right_handle.width() - self.min_central_width_narrow()
self.is_visible.cover_browser = True
w = min(available_width, self.width() - x - self.right_handle.width())
if w < HIDE_THRESHOLD:
self.is_visible.cover_browser = False
self.narrow_desires.book_details_width = 0
else:
self.narrow_desires.cover_browser_width = max(self.cover_browser.minimumWidth(), w) / self.width()
elif handle is self.bottom_handle:
y = int(pos.y())
h = self.height() - y - self.bottom_handle.height()
if h < HIDE_THRESHOLD:
self.is_visible.book_details = False
self.narrow_desires.book_details_height = 0
else:
self.is_visible.book_details = True
available_height = max(0, self.height() - self.bottom_handle.height() - self.min_central_height_narrow())
self.narrow_desires.book_details_height = max(HIDE_THRESHOLD, min(h, available_height)) / self.height()
elif handle is self.top_handle:
y = int(pos.y())
available_height = self.bottom_handle.y() if self.is_visible.book_details else self.height()
available_height -= self.top_handle.height()
h = available_height - y
if h < HIDE_THRESHOLD or available_height < 5:
self.is_visible.quick_view = False
self.narrow_desires.quick_view_height = 0
else:
self.is_visible.quick_view = True
self.narrow_desires.quick_view_height = max(0, available_height - y) / self.height()
def size_panel_on_initial_show_narrow(self, which):
if which == 'tag_browser':
current = self.narrow_desires.tag_browser_width * self.width()
if current < SHOW_THRESHOLD:
self.narrow_desires.tag_browser_width = NarrowDesires.tag_browser_width
elif which == 'cover_browser':
d = self.height() if self.narrow_cb_on_top else self.width()
current = self.narrow_desires.cover_browser_width * d
if current < SHOW_THRESHOLD:
self.narrow_desires.cover_browser_width = NarrowDesires.cover_browser_width
elif which == 'book_details':
current = self.height() * self.narrow_desires.book_details_height
if current < SHOW_THRESHOLD:
self.narrow_desires.book_details_height = NarrowDesires.book_details_height
else:
current = self.height() * self.narrow_desires.quick_view_height
if current < SHOW_THRESHOLD:
self.narrow_desires.quick_view_height = NarrowDesires.quick_view_height
def panel_name_for_handle_narrow(self, handle):
return {self.left_handle: 'tag_browser', self.right_handle: 'cover_browser', self.top_handle: 'quick_view', self.bottom_handle: 'book_details'}[handle]
# }}}
# develop {{{
def develop():
app = Application([])
class d(QDialog):
def __init__(self):
super().__init__()
l = QVBoxLayout(self)
l.setContentsMargins(0, 0, 0, 0)
h = QHBoxLayout()
l.addLayout(h)
self.central = CentralContainer(self, for_develop=True, prefs_name='develop_central_layout_widget_state', separate_cover_browser=False)
h.addWidget(self.central.tag_browser_button)
h.addWidget(self.central.book_details_button)
h.addWidget(self.central.cover_browser_button)
h.addWidget(self.central.quick_view_button)
l.addWidget(self.central)
self.resize(self.sizeHint())
def keyPressEvent(self, ev):
if ev.key() == Qt.Key.Key_Q:
self.central.toggle_quick_view()
elif ev.key() == Qt.Key.Key_T:
self.central.toggle_tag_browser()
elif ev.key() == Qt.Key.Key_C:
self.central.toggle_cover_browser()
elif ev.key() == Qt.Key.Key_D:
self.central.toggle_book_details()
elif ev.key() == Qt.Key.Key_L:
self.central.toggle_layout()
elif ev.key() == Qt.Key.Key_R:
self.central.reset_to_defaults()
elif ev.key() == Qt.Key.Key_Escape:
self.reject()
d = d()
d.central.read_settings()
d.show()
app.exec()
d.central.write_settings()
if __name__ == '__main__':
develop()
# }}}
| 43,712 | Python | .py | 890 | 38.824719 | 159 | 0.619814 | kovidgoyal/calibre | 19,243 | 2,250 | 4 | GPL-3.0 | 9/5/2024, 5:13:50 PM (Europe/Amsterdam) |
26,648 | tag_mapper.py | kovidgoyal_calibre/src/calibre/gui2/tag_mapper.py | #!/usr/bin/env python
# License: GPLv3 Copyright: 2015, Kovid Goyal <kovid at kovidgoyal.net>
import textwrap
from collections import OrderedDict
from qt.core import (
QAbstractItemView,
QComboBox,
QDialog,
QDialogButtonBox,
QHBoxLayout,
QIcon,
QInputDialog,
QItemSelectionModel,
QLabel,
QLineEdit,
QListWidget,
QListWidgetItem,
QMenu,
QPalette,
QPushButton,
QSize,
QStaticText,
QStyle,
QStyledItemDelegate,
Qt,
QToolButton,
QVBoxLayout,
QWidget,
pyqtSignal,
)
from calibre.ebooks.metadata.tag_mapper import compile_pat, map_tags
from calibre.gui2 import Application, error_dialog, question_dialog
from calibre.gui2.complete2 import EditWithComplete
from calibre.gui2.ui import get_gui
from calibre.gui2.widgets2 import Dialog
from calibre.startup import connect_lambda
from calibre.utils.config import JSONConfig
from calibre.utils.localization import localize_user_manual_link
from polyglot.builtins import iteritems
tag_maps = JSONConfig('tag-map-rules')
def intelligent_strip(action, val):
ans = val.strip()
if not ans and action == 'split':
ans = ' '
return ans
class QueryEdit(QLineEdit):
def contextMenuEvent(self, ev):
menu = self.createStandardContextMenu()
self.parent().specialise_context_menu(menu)
menu.exec(ev.globalPos())
class SingleTagEdit(EditWithComplete):
def __init__(self, parent):
super().__init__(parent)
self.set_separator(None)
gui = get_gui()
if gui:
self.update_items_cache(gui.current_db.new_api.all_field_names(getattr(parent, 'SINGLE_EDIT_FIELD_NAME', 'tags')))
class RuleEdit(QWidget):
ACTION_MAP = OrderedDict((
('remove', _('Remove')),
('replace', _('Replace')),
('keep', _('Keep')),
('capitalize', _('Capitalize')),
('titlecase', _('Title-case')),
('lower', _('Lower-case')),
('upper', _('Upper-case')),
('split', _('Split')),
))
MATCH_TYPE_MAP = OrderedDict((
('one_of', _('is one of')),
('not_one_of', _('is not one of')),
('matches', _('matches pattern')),
('not_matches', _('does not match pattern')),
('has', _('contains')),
))
MSG = _('Create the rule below, the rule can be used to remove or replace tags')
SUBJECT = _('the tag, if it')
VALUE_ERROR = _('You must provide a value for the tag to match')
REPLACE_TEXT = _('with the tag:')
SPLIT_TEXT = _('on the character:')
SPLIT_TOOLTIP = _(
'The character on which to split tags. Note that technically you can specify'
' a sub-string, not just a single character. Then splitting will happen on the sub-string.')
REPLACE_TOOLTIP = _(
'What to replace the tag with. Note that if you use a pattern to match'
' tags, you can replace with parts of the matched pattern. See '
' the User Manual on how to use regular expressions for details.')
REGEXP_HELP_TEXT = _('For help with regex pattern matching, see the <a href="%s">User Manual</a>')
SINGLE_EDIT_FIELD_NAME = 'tags'
def __init__(self, parent=None):
QWidget.__init__(self, parent)
self.l = l = QVBoxLayout(self)
self.h = h = QHBoxLayout()
self.la = la = QLabel(self.MSG)
la.setWordWrap(True)
l.addWidget(la)
l.addLayout(h)
self.action = a = QComboBox(self)
h.addWidget(a)
for action, text in iteritems(self.ACTION_MAP):
a.addItem(text, action)
a.currentIndexChanged.connect(self.update_state)
self.la1 = la = QLabel('\xa0' + self.SUBJECT + '\xa0')
h.addWidget(la)
self.match_type = q = QComboBox(self)
h.addWidget(q)
for action, text in iteritems(self.MATCH_TYPE_MAP):
q.addItem(text, action)
q.currentIndexChanged.connect(self.update_state)
self.la2 = la = QLabel(':\xa0')
h.addWidget(la)
self.query = q = QueryEdit(self)
h.addWidget(q)
self.tag_editor_button = b = QToolButton(self)
b.setIcon(QIcon.ic('chapters.png'))
b.setToolTip(_('Edit the list of tags with the Tag editor'))
h.addWidget(b), b.clicked.connect(self.edit_tags)
b.setVisible(self.can_use_tag_editor)
self.h2 = h = QHBoxLayout()
l.addLayout(h)
self.la3 = la = QLabel(self.REPLACE_TEXT + '\xa0')
h.addWidget(la)
self.replace = r = SingleTagEdit(self)
h.addWidget(r)
self.regex_help = la = QLabel('<p>' + self.REGEXP_HELP_TEXT % localize_user_manual_link(
'https://manual.calibre-ebook.com/regexp.html'))
la.setOpenExternalLinks(True)
la.setWordWrap(True)
l.addWidget(la)
la.setVisible(False)
l.addStretch(10)
self.la3.setVisible(False), self.replace.setVisible(False)
self.update_state()
def sizeHint(self):
a = QWidget.sizeHint(self)
a.setHeight(a.height() + 75)
a.setWidth(a.width() + 100)
return a
@property
def can_use_tag_editor(self):
return self.SUBJECT is RuleEdit.SUBJECT and 'matches' not in self.match_type.currentData() and get_gui() is not None
def update_state(self):
a = self.action.currentData()
replace = a == 'replace'
split = a == 'split'
self.la3.setVisible(replace or split), self.replace.setVisible(replace or split)
tt = _('A comma separated list of tags')
m = self.match_type.currentData()
is_match = 'matches' in m
self.tag_editor_button.setVisible(self.can_use_tag_editor)
if is_match:
tt = _('A regular expression')
elif m == 'has':
tt = _('Tags that contain this string will match')
self.regex_help.setVisible(is_match)
self.la3.setText((self.SPLIT_TEXT if split else self.REPLACE_TEXT) + '\xa0')
self.query.setToolTip(tt)
self.replace.setToolTip(textwrap.fill(self.SPLIT_TOOLTIP if split else self.REPLACE_TOOLTIP))
def specialise_context_menu(self, menu):
if self.can_use_tag_editor:
menu.addAction(_('Use the Tag editor to edit the list of tags'), self.edit_tags)
def edit_tags(self):
from calibre.gui2.dialogs.tag_editor import TagEditor
d = TagEditor(self, get_gui().current_db, current_tags=list(filter(None, [x.strip() for x in self.query.text().split(',')])))
if d.exec() == QDialog.DialogCode.Accepted:
self.query.setText(', '.join(d.tags))
@property
def rule(self):
ac = self.action.currentData()
return {
'action': ac,
'match_type': self.match_type.currentData(),
'query': intelligent_strip(ac, self.query.text()),
'replace': intelligent_strip(ac, self.replace.text()),
}
@rule.setter
def rule(self, rule):
def sc(name):
c = getattr(self, name)
idx = c.findData(str(rule.get(name, '')))
if idx < 0:
idx = 0
c.setCurrentIndex(idx)
sc('action'), sc('match_type')
ac = self.action.currentData()
self.query.setText(intelligent_strip(ac, str(rule.get('query', ''))))
self.replace.setText(intelligent_strip(ac, str(rule.get('replace', ''))))
def validate(self):
rule = self.rule
if not rule['query']:
error_dialog(self, _('Query required'), self.VALUE_ERROR, show=True)
return False
if 'matches' in rule['match_type']:
try:
compile_pat(rule['query'])
except Exception:
error_dialog(self, _('Query invalid'), _(
'%s is not a valid regular expression') % rule['query'], show=True)
return False
return True
class RuleEditDialog(Dialog):
PREFS_NAME = 'edit-tag-mapper-rule'
DIALOG_TITLE = _('Edit rule')
RuleEditClass = RuleEdit
def __init__(self, parent=None):
Dialog.__init__(self, self.DIALOG_TITLE, self.PREFS_NAME, parent=None)
def setup_ui(self):
self.l = l = QVBoxLayout(self)
self.edit_widget = w = self.RuleEditClass(self)
l.addWidget(w)
l.addWidget(self.bb)
def accept(self):
if self.edit_widget.validate():
Dialog.accept(self)
DATA_ROLE = Qt.ItemDataRole.UserRole
RENDER_ROLE = DATA_ROLE + 1
class RuleItem(QListWidgetItem):
@staticmethod
def text_from_rule(rule, parent):
query = rule['query']
text = _(
'<b>{action}</b> the tag, if it <i>{match_type}</i>: <b>{query}</b>').format(
action=RuleEdit.ACTION_MAP[rule['action']], match_type=RuleEdit.MATCH_TYPE_MAP[rule['match_type']], query=query)
if rule['action'] == 'replace':
text += '<br>' + _('with the tag:') + ' <b>%s</b>' % rule['replace']
if rule['action'] == 'split':
text += '<br>' + _('on the character:') + ' <b>%s</b>' % rule['replace']
return '<div style="white-space: nowrap">' + text + '</div>'
def __init__(self, rule, parent):
QListWidgetItem.__init__(self, '', parent)
st = self.text_from_rule(rule, parent)
self.setData(RENDER_ROLE, st)
self.setData(DATA_ROLE, rule)
class Delegate(QStyledItemDelegate):
MARGIN = 16
def sizeHint(self, option, index):
st = QStaticText(index.data(RENDER_ROLE))
st.prepare(font=self.parent().font())
width = max(option.rect.width(), self.parent().width() - 50)
if width and width != st.textWidth():
st.setTextWidth(width)
br = st.size()
return QSize(int(br.width() + self.MARGIN), int(br.height() + self.MARGIN))
def paint(self, painter, option, index):
QStyledItemDelegate.paint(self, painter, option, index)
pal = option.palette
color = pal.color(QPalette.ColorRole.HighlightedText if option.state & QStyle.StateFlag.State_Selected else QPalette.ColorRole.Text).name()
text = f'<div style="color:{color}">{index.data(RENDER_ROLE)}</div>'
st = QStaticText(text)
st.setTextWidth(option.rect.width())
painter.drawStaticText(option.rect.left() + self.MARGIN // 2, option.rect.top() + self.MARGIN // 2, st)
class Rules(QWidget):
RuleItemClass = RuleItem
RuleEditDialogClass = RuleEditDialog
changed = pyqtSignal()
ACTION_KEY = 'action'
MSG = _('You can specify rules to filter/transform tags here. Click the "Add rule" button'
' below to get started. The rules will be processed in order for every tag until either a'
' "remove" or a "keep" rule matches.')
def __init__(self, parent=None):
QWidget.__init__(self, parent)
self.l = l = QVBoxLayout(self)
self.msg_label = la = QLabel(
'<p>' + self.MSG + '<p>' + _(
'You can <b>change an existing rule</b> by double clicking it')
)
la.setWordWrap(True)
l.addWidget(la)
self.h = h = QHBoxLayout()
l.addLayout(h)
self.add_button = b = QPushButton(QIcon.ic('plus.png'), _('&Add rule'), self)
b.clicked.connect(self.add_rule)
h.addWidget(b)
self.remove_button = b = QPushButton(QIcon.ic('minus.png'), _('&Remove rule(s)'), self)
b.clicked.connect(self.remove_rules)
h.addWidget(b)
self.h3 = h = QHBoxLayout()
l.addLayout(h)
self.rule_list = r = QListWidget(self)
self.delegate = Delegate(self)
r.setSelectionMode(QAbstractItemView.SelectionMode.ExtendedSelection)
r.setItemDelegate(self.delegate)
r.doubleClicked.connect(self.edit_rule)
h.addWidget(r)
r.setDragEnabled(True)
r.viewport().setAcceptDrops(True)
r.setDropIndicatorShown(True)
r.setDragDropMode(QAbstractItemView.DragDropMode.InternalMove)
r.setDefaultDropAction(Qt.DropAction.MoveAction)
self.l2 = l = QVBoxLayout()
h.addLayout(l)
self.up_button = b = QToolButton(self)
b.setIcon(QIcon.ic('arrow-up.png')), b.setToolTip(_('Move current rule up'))
b.clicked.connect(self.move_up)
l.addWidget(b)
self.down_button = b = QToolButton(self)
b.setIcon(QIcon.ic('arrow-down.png')), b.setToolTip(_('Move current rule down'))
b.clicked.connect(self.move_down)
l.addStretch(10), l.addWidget(b)
def sizeHint(self):
return QSize(800, 600)
def add_rule(self):
d = self.RuleEditDialogClass(self)
if d.exec() == QDialog.DialogCode.Accepted:
i = self.RuleItemClass(d.edit_widget.rule, self.rule_list)
self.rule_list.scrollToItem(i)
self.changed.emit()
def edit_rule(self):
i = self.rule_list.currentItem()
if i is not None:
d = self.RuleEditDialogClass(self)
d.edit_widget.rule = i.data(Qt.ItemDataRole.UserRole)
if d.exec() == QDialog.DialogCode.Accepted:
rule = d.edit_widget.rule
i.setData(DATA_ROLE, rule)
i.setData(RENDER_ROLE, self.RuleItemClass.text_from_rule(rule, self.rule_list))
self.changed.emit()
def remove_rules(self):
changed = False
for item in self.rule_list.selectedItems():
self.rule_list.takeItem(self.rule_list.row(item))
changed = True
if changed:
self.changed.emit()
def move_selected(self, delta=-1):
current_item = self.rule_list.currentItem()
items = self.rule_list.selectedItems()
if current_item is None or not items or not len(items):
return
row_map = {id(item): self.rule_list.row(item) for item in items}
items.sort(key=lambda item: row_map[id(item)])
num = self.rule_list.count()
for item in items:
row = row_map[id(item)]
nrow = (row + delta + num) % num
self.rule_list.takeItem(row)
self.rule_list.insertItem(nrow, item)
sm = self.rule_list.selectionModel()
for item in items:
sm.select(self.rule_list.indexFromItem(item), QItemSelectionModel.SelectionFlag.Select)
sm.setCurrentIndex(self.rule_list.indexFromItem(current_item), QItemSelectionModel.SelectionFlag.Current)
self.changed.emit()
def move_up(self):
self.move_selected()
def move_down(self):
self.move_selected(1)
@property
def rules(self):
ans = []
for r in range(self.rule_list.count()):
ans.append(self.rule_list.item(r).data(DATA_ROLE))
return ans
@rules.setter
def rules(self, rules):
self.rule_list.clear()
for rule in (rules or ()):
if self.ACTION_KEY in rule and 'match_type' in rule and 'query' in rule:
self.RuleItemClass(rule, self.rule_list)
class Tester(Dialog):
DIALOG_TITLE = _('Test tag mapper rules')
PREFS_NAME = 'test-tag-mapper-rules'
LABEL = _('Enter a comma separated list of &tags to test:')
PLACEHOLDER = _('Enter tags and click the "Test" button')
EMPTY_RESULT = '<p> <br> </p>'
def __init__(self, rules, parent=None):
self.rules = rules
Dialog.__init__(self, self.DIALOG_TITLE, self.PREFS_NAME, parent=parent)
def setup_ui(self):
self.l = l = QVBoxLayout(self)
self.bb.setStandardButtons(QDialogButtonBox.StandardButton.Close)
self.la = la = QLabel(self.LABEL)
l.addWidget(la)
self.tags = t = QLineEdit(self)
la.setBuddy(t)
t.setPlaceholderText(self.PLACEHOLDER)
self.h = h = QHBoxLayout()
l.addLayout(h)
h.addWidget(t)
self.test_button = b = QPushButton(_('&Test'), self)
b.clicked.connect(self.do_test)
h.addWidget(b)
self.result = la = QLabel(self)
la.setWordWrap(True)
la.setText(self.EMPTY_RESULT)
l.addWidget(la)
l.addWidget(self.bb)
@property
def value(self):
return self.tags.text()
def do_test(self):
tags = [x.strip() for x in self.value.split(',')]
tags = map_tags(tags, self.rules)
self.result.setText(_('<b>Resulting tags:</b> %s') % ', '.join(tags))
def sizeHint(self):
ans = Dialog.sizeHint(self)
ans.setWidth(ans.width() + 150)
return ans
class SaveLoadMixin:
ruleset_changed = pyqtSignal()
base_window_title = ''
def save_ruleset(self):
if not self.rules:
error_dialog(self, _('No rules'), _(
'Cannot save as no rules have been created'), show=True)
return
text, ok = QInputDialog.getText(self, _('Save ruleset as'), _(
'Enter a name for this ruleset:'), text=self.loaded_ruleset or '')
if ok and text:
if self.loaded_ruleset and text == self.loaded_ruleset:
if not question_dialog(self, _('Are you sure?'), _(
'A ruleset with the name "%s" already exists, do you want to replace it?') % text):
return
self.loaded_ruleset = text
rules = self.rules
if rules:
self.PREFS_OBJECT[text] = self.rules
self.loaded_ruleset = text
self.ruleset_changed.emit()
elif text in self.PREFS_OBJECT: # Don't think we can get here because 'if rules:' is always True
del self.PREFS_OBJECT[text]
if self.loaded_ruleset == text:
self.loaded_ruleset = ''
self.ruleset_changed.emit()
self.build_load_menu()
def build_load_menu(self):
self.load_menu.clear()
if len(self.PREFS_OBJECT):
for name, rules in iteritems(self.PREFS_OBJECT):
ac = self.load_menu.addAction(name)
ac.setObjectName(name)
connect_lambda(ac.triggered, self, lambda self: self.load_ruleset(self.sender().objectName()))
self.load_menu.addSeparator()
m = self.load_menu.addMenu(_('Delete saved rulesets'))
for name, rules in iteritems(self.PREFS_OBJECT):
ac = m.addAction(name)
ac.setObjectName(name)
connect_lambda(ac.triggered, self, lambda self: self.delete_ruleset(self.sender().objectName()))
else:
self.load_menu.addAction(_('No saved rulesets available'))
def load_ruleset(self, name):
self.rules = self.PREFS_OBJECT[name]
self.loaded_ruleset = name
self.ruleset_changed.emit()
def delete_ruleset(self, name):
del self.PREFS_OBJECT[name]
if self.loaded_ruleset == name:
self.loaded_ruleset = ''
self.ruleset_changed.emit()
self.build_load_menu()
class RulesDialog(Dialog, SaveLoadMixin):
DIALOG_TITLE = _('Edit tag mapper rules')
PREFS_NAME = 'edit-tag-mapper-rules'
RulesClass = Rules
TesterClass = Tester
PREFS_OBJECT = tag_maps
def __init__(self, parent=None):
self.loaded_ruleset = None
Dialog.__init__(self, self.DIALOG_TITLE, self.PREFS_NAME, parent=parent)
def setup_ui(self):
self.l = l = QVBoxLayout(self)
self.edit_widget = w = self.RulesClass(self)
l.addWidget(w)
ebw = self.extra_bottom_widget()
if ebw is None:
l.addWidget(self.bb)
else:
self.h = h = QHBoxLayout()
l.addLayout(h)
h.addWidget(ebw), h.addStretch(10), h.addWidget(self.bb)
self.save_button = b = self.bb.addButton(_('&Save'), QDialogButtonBox.ButtonRole.ActionRole)
b.setToolTip(_('Save this ruleset for later re-use'))
b.clicked.connect(self.save_ruleset)
self.load_button = b = self.bb.addButton(_('&Load'), QDialogButtonBox.ButtonRole.ActionRole)
b.setToolTip(_('Load a previously saved ruleset'))
self.load_menu = QMenu(self)
b.setMenu(self.load_menu)
self.build_load_menu()
self.test_button = b = self.bb.addButton(_('&Test rules'), QDialogButtonBox.ButtonRole.ActionRole)
b.clicked.connect(self.test_rules)
self.ruleset_changed.connect(self.update_title_bar)
def update_title_bar(self):
if self.base_window_title:
if self.loaded_ruleset:
self.setWindowTitle(_('{base} - (ruleset: {name})').format(base=self.base_window_title, name=self.loaded_ruleset))
else:
self.setWindowTitle(self.base_window_title)
def exec(self):
self.base_window_title = self.windowTitle()
return super().exec()
def extra_bottom_widget(self):
pass
@property
def rules(self):
return self.edit_widget.rules
@rules.setter
def rules(self, rules):
self.edit_widget.rules = rules
def test_rules(self):
self.TesterClass(self.rules, self).exec()
def sizeHint(self):
ans = super().sizeHint()
ans.setWidth(ans.width() + 100)
return ans
if __name__ == '__main__':
app = Application([])
d = RulesDialog()
d.rules = [
{'action':'remove', 'query':'moose', 'match_type':'one_of', 'replace':''},
{'action':'replace', 'query':'moose,sfdg,sfdg,dfsg,dfgsh,sd,er,erg,egrer,ger,s,fgfsgfsga', 'match_type':'one_of', 'replace':'xxxx'},
{'action':'split', 'query':'/', 'match_type':'has', 'replace':'/'},
]
d.exec()
from pprint import pprint
pprint(d.rules)
del d, app
| 21,848 | Python | .py | 515 | 33.436893 | 147 | 0.607513 | kovidgoyal/calibre | 19,243 | 2,250 | 4 | GPL-3.0 | 9/5/2024, 5:13:50 PM (Europe/Amsterdam) |
26,649 | geometry.py | kovidgoyal_calibre/src/calibre/gui2/geometry.py | #!/usr/bin/env python
# License: GPL v3 Copyright: 2022, Kovid Goyal <kovid at kovidgoyal.net>
# See https://bugreports.qt.io/browse/QTBUG-69104 for why we need to implement
# our own restore geometry
from qt.core import QApplication, QRect, QScreen, QSize, Qt, QWidget
from calibre.constants import is_debugging as _is_debugging
from calibre.utils.config_base import tweaks
def geometry_pref_name(name):
return f'geometry-of-{name}'
def is_debugging():
return _is_debugging() and tweaks.get('show_geometry_debug_output')
def debug(*a, **kw):
if is_debugging():
from pprint import pformat
items = []
for x in a:
if not isinstance(x, str):
x = pformat(x)
items.append(x)
print(*items)
def size_as_dict(self: QSize):
return {'width': self.width(), 'height': self.height()}
def dict_as_size(x: dict) -> QSize:
return QSize(x['width'], x['height'])
def rect_as_dict(self: QRect):
return {'x': self.left(), 'y': self.top(), 'width': self.width(), 'height': self.height()}
def dict_as_rect(g: dict) -> QRect:
return QRect(g['x'], g['y'], g['width'], g['height'])
def screen_as_dict(self: QScreen):
try:
num = QApplication.instance().screens().index(self)
except Exception:
num = -1
return {
'name': self.name(),
'serial': self.serialNumber(),
'manufacturer': self.manufacturer(),
'model': self.model(),
'depth': self.depth(),
'device_pixel_ratio': self.devicePixelRatio(),
'size_in_logical_pixels': size_as_dict(self.size()),
'geometry_in_logical_pixels': rect_as_dict(self.geometry()),
'virtual_geometry': rect_as_dict(self.virtualGeometry()),
'index_in_screens_list': num,
}
def geometry_for_restore_as_dict(self: QWidget):
s = self.screen()
if s is None:
return {}
ans = {
'screen': screen_as_dict(s),
'geometry': rect_as_dict(self.geometry()),
'frame_geometry': rect_as_dict(self.frameGeometry()),
'normal_geometry': rect_as_dict(self.normalGeometry()),
'maximized': self.isMaximized(),
'full_screened': self.isFullScreen(),
}
return ans
def delete_geometry(prefs: dict, name: str):
prefs.pop(geometry_pref_name(name), None)
def save_geometry(self: QWidget, prefs: dict, name: str):
x = geometry_for_restore_as_dict(self)
if x:
if is_debugging():
debug('Saving geometry for:', name)
debug(x)
x['qt'] = bytearray(self.saveGeometry())
prefs.set(geometry_pref_name(name), x)
def find_matching_screen(screen_as_dict):
screens = QApplication.instance().screens()
size = dict_as_size(screen_as_dict['size_in_logical_pixels'])
vg = dict_as_rect(screen_as_dict['virtual_geometry'])
dpr = screen_as_dict['device_pixel_ratio']
screens_of_matching_size = tuple(
s for s in screens if s.size() == size and vg == s.virtualGeometry() and s.devicePixelRatio() == dpr)
if screen_as_dict['serial']:
for q in screens_of_matching_size:
if q.serialNumber() == screen_as_dict['serial']:
return q
def match(key, val):
v = screen_as_dict[key]
return bool(not v or v == val)
for q in screens_of_matching_size:
if match('name', q.name()) and match('manufacturer', q.manufacturer()) and match('model', q.model()):
return q
if len(screens_of_matching_size) == 1:
return screens_of_matching_size[0]
def _do_restore(self: QWidget, s: QScreen, geometry: QRect, saved_data: dict):
ws = self.windowState()
if ws & (Qt.WindowState.WindowFullScreen | Qt.WindowState.WindowMaximized):
debug('Not restoring geometry as widget is already maximized or fullscreen')
return True
if self.screen() is not s:
debug('Moving widget to saved screen')
self.setScreen(s)
debug('Setting widget geometry to:', rect_as_dict(geometry))
self.setGeometry(geometry)
if saved_data['full_screened']:
debug('Restoring widget to full screen')
self.setWindowState(Qt.WindowState.WindowFullScreen)
elif saved_data['maximized']:
debug('Restoring widget to maximized')
self.setWindowState(Qt.WindowState.WindowMaximized)
return True
def _restore_to_matching_screen(self: QWidget, s: QScreen, saved_data: dict) -> bool:
saved_geometry = dict_as_rect(saved_data['geometry'])
return _do_restore(self, s, saved_geometry, saved_data)
def _restore_to_new_screen(self: QWidget, s: QScreen, saved_data: dict) -> bool:
saved_geometry = dict_as_rect(saved_data['geometry'])
saved_frame_geometry = dict_as_rect(saved_data['frame_geometry'])
if not saved_geometry.isValid() or not saved_frame_geometry.isValid():
return False
frame_height = max(0, saved_frame_geometry.height() - saved_geometry.height())
frame_width = max(0, saved_frame_geometry.width() - saved_geometry.width())
available_geometry = s.availableGeometry()
available_size = QSize(available_geometry.width() - frame_width, available_geometry.height() - frame_height)
sz = QSize(min(saved_geometry.width(), available_size.width()), min(saved_geometry.height(), available_size.height()))
if not sz.isValid():
return False
left = available_geometry.left() + (available_size.width() - sz.width()) // 2
top = available_geometry.top() + (available_size.height() - sz.height()) // 2
geometry = QRect(left, top, sz.width(), sz.height())
return _do_restore(self, s, geometry, saved_data)
def _restore_geometry(self: QWidget, prefs: dict, name: str, get_legacy_saved_geometry: callable = None) -> bool:
x = prefs.get(geometry_pref_name(name))
if not x:
old = get_legacy_saved_geometry() if get_legacy_saved_geometry else prefs.get(name)
if old is not None:
return self.restoreGeometry(old)
return False
if is_debugging():
debug('Restoring geometry for:', name)
dx = x.copy()
del dx['qt']
debug(dx)
s = find_matching_screen(x['screen'])
debug('Matching screen:', screen_as_dict(s) if s else None)
if s is None:
if is_debugging():
debug('No screens matched saved screen. Available screens:', tuple(map(screen_as_dict, QApplication.instance().screens())))
p = self.nativeParentWidget()
if p is not None:
s = p.screen()
if s is None:
s = self.screen()
if s is None:
s = QApplication.instance().primaryScreen()
else:
return _restore_to_matching_screen(self, s, x)
if s is None:
return False
return _restore_to_new_screen(self, s, x)
screen_debug_has_been_output = False
def restore_geometry(self: QWidget, prefs: dict, name: str, get_legacy_saved_geometry: callable = None) -> bool:
global screen_debug_has_been_output
if not screen_debug_has_been_output:
screen_debug_has_been_output = True
debug('Screens currently in system:')
for screen in QApplication.instance().screens():
debug(screen_as_dict(screen))
if _restore_geometry(self, prefs, name, get_legacy_saved_geometry):
return True
sz = self.sizeHint()
if sz.isValid():
self.resize(self.sizeHint())
return False
QWidget.save_geometry = save_geometry
QWidget.restore_geometry = restore_geometry
| 7,507 | Python | .py | 168 | 37.845238 | 135 | 0.653002 | kovidgoyal/calibre | 19,243 | 2,250 | 4 | GPL-3.0 | 9/5/2024, 5:13:50 PM (Europe/Amsterdam) |
26,650 | init.py | kovidgoyal_calibre/src/calibre/gui2/init.py | #!/usr/bin/env python
__license__ = 'GPL v3'
__copyright__ = '2010, Kovid Goyal <kovid@kovidgoyal.net>'
__docformat__ = 'restructuredtext en'
import functools
from qt.core import (
QAction,
QApplication,
QDialog,
QEvent,
QIcon,
QLabel,
QMenu,
QPixmap,
QStackedWidget,
QStatusBar,
QStyle,
QStyleOption,
QStylePainter,
Qt,
QTabBar,
QTimer,
QToolButton,
QUrl,
)
from calibre.constants import get_appname_for_display, get_version, ismacos
from calibre.customize.ui import find_plugin
from calibre.gui2 import config, error_dialog, gprefs, open_local_file, open_url
from calibre.gui2.book_details import BookDetails
from calibre.gui2.central import CentralContainer, LayoutButton
from calibre.gui2.layout_menu import LayoutMenu
from calibre.gui2.library.alternate_views import GridView
from calibre.gui2.library.views import BooksView, DeviceBooksView
from calibre.gui2.notify import get_notifier
from calibre.gui2.tag_browser.ui import TagBrowserWidget
from calibre.utils.config import prefs
from calibre.utils.icu import sort_key
from calibre.utils.localization import localize_website_link, ngettext
_keep_refs = []
def partial(*args, **kwargs):
ans = functools.partial(*args, **kwargs)
_keep_refs.append(ans)
return ans
class LibraryViewMixin: # {{{
def __init__(self, *args, **kwargs):
pass
def init_library_view_mixin(self, db):
self.library_view.files_dropped.connect(self.iactions['Add Books'].files_dropped, type=Qt.ConnectionType.QueuedConnection)
self.library_view.books_dropped.connect(self.iactions['Edit Metadata'].books_dropped, type=Qt.ConnectionType.QueuedConnection)
self.library_view.add_column_signal.connect(partial(self.iactions['Preferences'].do_config,
initial_plugin=('Interface', 'Custom Columns'), close_after_initial=True),
type=Qt.ConnectionType.QueuedConnection)
for func, args in [
('connect_to_search_box', (self.search,
self.search_done)),
('connect_to_book_display',
(self.book_details.show_data,)),
]:
for view in (self.library_view, self.memory_view, self.card_a_view, self.card_b_view):
getattr(view, func)(*args)
self.memory_view.connect_dirtied_signal(self.upload_dirtied_booklists)
self.memory_view.connect_upload_collections_signal(
func=self.upload_collections, oncard=None)
self.card_a_view.connect_dirtied_signal(self.upload_dirtied_booklists)
self.card_a_view.connect_upload_collections_signal(
func=self.upload_collections, oncard='carda')
self.card_b_view.connect_dirtied_signal(self.upload_dirtied_booklists)
self.card_b_view.connect_upload_collections_signal(
func=self.upload_collections, oncard='cardb')
self.book_on_device(None, reset=True)
db.set_book_on_device_func(self.book_on_device)
self.library_view.set_database(db)
self.library_view.model().set_book_on_device_func(self.book_on_device)
prefs['library_path'] = self.library_path
for view in ('library', 'memory', 'card_a', 'card_b'):
view = getattr(self, view+'_view')
view.verticalHeader().sectionDoubleClicked.connect(self.iactions['View'].view_specific_book)
self.library_view.model().set_highlight_only(config['highlight_search_matches'])
def build_context_menus(self):
from calibre.gui2.bars import populate_menu
lm = QMenu(self)
populate_menu(lm, gprefs['action-layout-context-menu'], self.iactions)
dm = QMenu(self)
populate_menu(dm, gprefs['action-layout-context-menu-device'], self.iactions)
ec = self.iactions['Edit Collections'].qaction
self.library_view.set_context_menu(lm, ec)
sm = QMenu(self)
populate_menu(sm, gprefs['action-layout-context-menu-split'], self.iactions)
self.library_view.pin_view.set_context_menu(sm)
for v in (self.memory_view, self.card_a_view, self.card_b_view):
v.set_context_menu(dm, ec)
if hasattr(self.cover_flow, 'set_context_menu'):
cm = QMenu(self.cover_flow)
populate_menu(cm,
gprefs['action-layout-context-menu-cover-browser'], self.iactions)
self.cover_flow.set_context_menu(cm)
def search_done(self, view, ok):
if view is self.current_view():
self.search.search_done(ok)
self.set_number_of_books_shown()
if ok:
v = self.current_view()
if hasattr(v, 'set_current_row'):
v.set_current_row(0)
if v is self.library_view and v.row_count() == 0:
self.book_details.reset_info()
# }}}
class UpdateLabel(QLabel): # {{{
def __init__(self, *args, **kwargs):
QLabel.__init__(self, *args, **kwargs)
self.setCursor(Qt.CursorShape.PointingHandCursor)
def contextMenuEvent(self, e):
pass
# }}}
class VersionLabel(QLabel): # {{{
def __init__(self, parent):
QLabel.__init__(self, parent)
self.mouse_over = False
self.setCursor(Qt.CursorShape.PointingHandCursor)
self.setToolTip(_('See what\'s new in this calibre release'))
def mouseReleaseEvent(self, ev):
open_url(localize_website_link('https://calibre-ebook.com/whats-new'))
ev.accept()
return QLabel.mouseReleaseEvent(self, ev)
def event(self, ev):
m = None
et = ev.type()
if et == QEvent.Type.Enter:
m = True
elif et == QEvent.Type.Leave:
m = False
if m is not None and m != self.mouse_over:
self.mouse_over = m
self.update()
return QLabel.event(self, ev)
def paintEvent(self, ev):
if self.mouse_over:
p = QStylePainter(self)
tool = QStyleOption()
tool.initFrom(self)
tool.rect = self.rect()
tool.state = QStyle.StateFlag.State_Raised | QStyle.StateFlag.State_Active | QStyle.StateFlag.State_MouseOver
p.drawPrimitive(QStyle.PrimitiveElement.PE_PanelButtonTool, tool)
p.end()
return QLabel.paintEvent(self, ev)
# }}}
class StatusBar(QStatusBar): # {{{
def __init__(self, parent=None):
QStatusBar.__init__(self, parent)
self.version = get_version()
self.base_msg = f'{get_appname_for_display()} {self.version}'
self.device_string = ''
self.update_label = UpdateLabel('')
self.total = self.current = self.selected = self.library_total = 0
self.addPermanentWidget(self.update_label)
self.update_label.setVisible(False)
self.defmsg = VersionLabel(self)
self.addWidget(self.defmsg)
self.set_label()
def initialize(self, systray=None):
self.systray = systray
self.notifier = get_notifier(systray)
def device_connected(self, devname):
self.device_string = _('Connected ') + devname
self.set_label()
def update_state(self, library_total, total, current, selected):
self.library_total = library_total
self.total, self.current, self.selected = total, current, selected
self.set_label()
def set_label(self):
try:
self._set_label()
except:
import traceback
traceback.print_exc()
def _set_label(self):
msg = self.base_msg
if self.device_string:
msg += ' ..::.. ' + self.device_string
else:
msg += _(' %(created)s %(name)s') % dict(created=_('created by'), name='Kovid Goyal')
if self.total != self.current:
base = _('%(num)d of %(total)d books') % dict(num=self.current, total=self.total)
else:
base = ngettext('one book', '{} books', self.total).format(self.total)
if self.selected > 0:
base = ngettext('%(num)s, %(sel)d selected', '%(num)s, %(sel)d selected', self.selected) % dict(num=base, sel=self.selected)
if self.library_total != self.total:
base = _('{0}, {1} total').format(base, self.library_total)
self.defmsg.setText(f'\xa0{msg}\xa0\xa0\xa0\xa0[{base}] ')
self.clearMessage()
def device_disconnected(self):
self.device_string = ''
self.set_label()
def show_message(self, msg, timeout=0, show_notification=True):
self.showMessage(msg, timeout)
if self.notifier is not None and not config['disable_tray_notification'] and show_notification:
self.notifier(msg)
def clear_message(self):
self.clearMessage()
# }}}
class GridViewButton(LayoutButton): # {{{
def __init__(self, gui):
sc = 'Alt+Shift+G'
LayoutButton.__init__(self, 'cover_grid', 'grid.png', _('Cover grid'), gui, shortcut=sc)
self.set_state_to_show()
self.action_toggle = QAction(self.icon(), _('Toggle') + ' ' + self.label, self)
gui.addAction(self.action_toggle)
gui.keyboard.register_shortcut('grid view toggle' + self.label, str(self.action_toggle.text()),
default_keys=(sc,), action=self.action_toggle, group=_('Main window layout'))
self.action_toggle.triggered.connect(self.toggle)
self.action_toggle.changed.connect(self.update_shortcut)
self.toggled.connect(self.update_state)
@property
def is_visible(self):
return self.isChecked()
def update_state(self, checked):
if checked:
self.set_state_to_hide()
else:
self.set_state_to_show()
def save_state(self):
gprefs['grid view visible'] = bool(self.isChecked())
def restore_state(self):
if gprefs.get('grid view visible', False):
self.toggle()
# }}}
class SearchBarButton(LayoutButton): # {{{
def __init__(self, gui):
sc = 'Alt+Shift+F'
LayoutButton.__init__(self, 'search', 'search.png', _('Search bar'), gui, shortcut=sc)
self.set_state_to_hide()
self.action_toggle = QAction(self.icon(), _('Toggle') + ' ' + self.label, self)
gui.addAction(self.action_toggle)
gui.keyboard.register_shortcut('search bar toggle' + self.label, str(self.action_toggle.text()),
default_keys=(sc,), action=self.action_toggle, group=_('Main window layout'))
self.action_toggle.triggered.connect(self.toggle)
self.action_toggle.changed.connect(self.update_shortcut)
self.toggled.connect(self.update_state)
self.update_shortcut()
@property
def is_visible(self):
return self.isChecked()
def update_state(self, checked):
if checked:
self.set_state_to_hide()
else:
self.set_state_to_show()
def save_state(self):
gprefs['search bar visible'] = bool(self.isChecked())
def restore_state(self):
self.setChecked(bool(gprefs.get('search bar visible', True)))
# }}}
class VLTabs(QTabBar): # {{{
def __init__(self, parent):
QTabBar.__init__(self, parent)
self.setDocumentMode(True)
self.setDrawBase(False)
self.setMovable(True)
self.setTabsClosable(gprefs['vl_tabs_closable'])
self.gui = parent
self.ignore_tab_changed = False
self.currentChanged.connect(self.tab_changed)
self.tabMoved.connect(self.tab_moved, type=Qt.ConnectionType.QueuedConnection)
self.tabCloseRequested.connect(self.tab_close)
self.update_visibility()
self.next_action = a = QAction(self)
a.triggered.connect(partial(self.next_tab, delta=1)), self.gui.addAction(a)
self.previous_action = a = QAction(self)
a.triggered.connect(partial(self.next_tab, delta=-1)), self.gui.addAction(a)
self.gui.keyboard.register_shortcut(
'virtual-library-tab-bar-next', _('Next Virtual library'), action=self.next_action,
default_keys=('Ctrl+Right',),
description=_('Switch to the next Virtual library in the Virtual library tab bar')
)
self.gui.keyboard.register_shortcut(
'virtual-library-tab-bar-previous', _('Previous Virtual library'), action=self.previous_action,
default_keys=('Ctrl+Left',),
description=_('Switch to the previous Virtual library in the Virtual library tab bar')
)
def next_tab(self, delta=1):
if self.count() > 1 and self.isVisible():
idx = (self.currentIndex() + delta) % self.count()
self.setCurrentIndex(idx)
def update_visibility(self):
cv = self.gui.current_view()
self.setVisible(gprefs['show_vl_tabs'] and self.count() > 1 and (cv is self.gui.library_view or cv is None))
def enable_bar(self):
gprefs['show_vl_tabs'] = True
self.update_visibility()
self.gui.set_number_of_books_shown()
def disable_bar(self):
gprefs['show_vl_tabs'] = False
self.update_visibility()
self.gui.set_number_of_books_shown()
def lock_tab(self):
gprefs['vl_tabs_closable'] = False
self.setTabsClosable(False)
# Workaround for Qt bug where it doesnt recalculate the tab size after locking
for idx in range(self.count()):
self.setTabButton(idx, QTabBar.ButtonPosition.RightSide, None)
self.setTabButton(idx, QTabBar.ButtonPosition.LeftSide, None)
def unlock_tab(self):
gprefs['vl_tabs_closable'] = True
self.setTabsClosable(True)
# ensure no button on the All books tab since it is not closeable
for idx in range(self.count()):
if not self.tabData(idx):
try:
self.tabButton(idx, QTabBar.ButtonPosition.RightSide).setVisible(False)
except AttributeError:
try:
self.tabButton(idx, QTabBar.ButtonPosition.LeftSide).setVisible(False)
except AttributeError:
# On some OS X machines (using native style) the tab button is
# on the left
pass
break
def tab_changed(self, idx):
if self.ignore_tab_changed:
return
vl = str(self.tabData(idx) or '').strip() or None
self.gui.apply_virtual_library(vl, update_tabs=False)
def tab_moved(self, from_, to):
self.current_db.new_api.set_pref('virt_libs_order', [str(self.tabData(i) or '') for i in range(self.count())])
def tab_close(self, index):
vl = str(self.tabData(index) or '')
if vl: # Dont allow closing the All Books tab
self.current_db.new_api.set_pref('virt_libs_hidden', list(
self.current_db.new_api.pref('virt_libs_hidden', ())) + [vl])
self.removeTab(index)
@property
def current_db(self):
return self.gui.current_db
def rebuild(self):
self.ignore_tab_changed = True
try:
self._rebuild()
finally:
self.ignore_tab_changed = False
def _rebuild(self):
db = self.current_db
vl_map = db.new_api.pref('virtual_libraries', {})
virt_libs = frozenset(vl_map)
hidden = set(db.new_api.pref('virt_libs_hidden', ()))
if hidden - virt_libs:
hidden = hidden.intersection(virt_libs)
db.new_api.set_pref('virt_libs_hidden', list(hidden))
order = db.new_api.pref('virt_libs_order', ())
while self.count():
self.removeTab(0)
current_lib = db.data.get_base_restriction_name()
if current_lib in hidden:
hidden.discard(current_lib)
db.new_api.set_pref('virt_libs_hidden', list(hidden))
current_idx = all_idx = None
virt_libs = (set(virt_libs) - hidden) | {''}
order = {x:i for i, x in enumerate(order)}
for i, vl in enumerate(sorted(virt_libs, key=lambda x:(order.get(x, 0), sort_key(x)))):
self.addTab(vl.replace('&', '&&') or _('All books'))
sexp = vl_map.get(vl, None)
if sexp is not None:
self.setTabToolTip(i, _('Search expression for this Virtual library:') + '\n\n' + sexp)
self.setTabData(i, vl)
if vl == current_lib:
current_idx = i
if not vl:
all_idx = i
self.setCurrentIndex(all_idx if current_idx is None else current_idx)
if current_idx is None and current_lib:
self.setTabText(all_idx, current_lib)
try:
self.tabButton(all_idx, QTabBar.ButtonPosition.RightSide).setVisible(False)
except AttributeError:
try:
self.tabButton(all_idx, QTabBar.ButtonPosition.LeftSide).setVisible(False)
except AttributeError:
# On some OS X machines (using native style) the tab button is
# on the left
pass
self.update_visibility()
def update_current(self):
self.rebuild()
def contextMenuEvent(self, ev):
m = QMenu(self)
m.addAction(QIcon.ic('sort.png'), _('Sort tabs alphabetically'), self.sort_alphabetically)
hidden = self.current_db.new_api.pref('virt_libs_hidden')
if hidden:
s = m._s = m.addMenu(_('Restore hidden tabs'))
for x in hidden:
s.addAction(x, partial(self.restore, x))
m.addAction(_('Hide Virtual library tabs'), self.disable_bar)
if gprefs['vl_tabs_closable']:
m.addAction(QIcon.ic('drm-locked.png'), _('Lock Virtual library tabs'), self.lock_tab)
else:
m.addAction(QIcon.ic('drm-unlocked.png'), _('Unlock Virtual library tabs'), self.unlock_tab)
i = self.tabAt(ev.pos())
if i > -1:
vl = str(self.tabData(i) or '')
if vl:
vln = vl.replace('&', '&&')
m.addSeparator()
m.addAction(QIcon.ic('edit_input.png'), _('Edit "%s"') % vln, partial(self.gui.do_create_edit, name=vl))
m.addAction(QIcon.ic('trash.png'), _('Delete "%s"') % vln, partial(self.gui.remove_vl_triggered, name=vl))
m.exec(ev.globalPos())
def sort_alphabetically(self):
self.current_db.new_api.set_pref('virt_libs_order', ())
self.rebuild()
def restore(self, x):
h = self.current_db.new_api.pref('virt_libs_hidden', ())
self.current_db.new_api.set_pref('virt_libs_hidden', list(set(h) - {x}))
self.rebuild()
# }}}
class LayoutMixin: # {{{
def __init__(self, *args, **kwargs):
pass
def place_layout_buttons(self):
if getattr(self, 'layout_buttons', None):
for x in self.layout_buttons:
self.status_bar.removeWidget(x)
if self.layout_container.is_wide:
self.button_order = 'sb', 'tb', 'cb', 'gv', 'qv', 'bd'
else:
self.button_order = 'sb', 'tb', 'bd', 'gv', 'cb', 'qv'
self.layout_buttons = []
stylename = str(self.style().objectName())
for x in self.button_order:
if x == 'gv':
button = self.grid_view_button
elif x == 'sb':
button = self.search_bar_button
else:
button = self.layout_container.button_for({
'tb': 'tag_browser', 'bd': 'book_details', 'cb': 'cover_browser', 'qv': 'quick_view'
}[x])
self.layout_buttons.append(button)
button.setVisible(gprefs['show_layout_buttons'])
if ismacos and stylename != 'Calibre':
button.setStyleSheet('''
QToolButton { background: none; border:none; padding: 0px; }
QToolButton:checked { background: rgba(0, 0, 0, 25%); }
''')
for button in reversed(self.layout_buttons):
self.status_bar.insertPermanentWidget(2, button)
self.layout_button.setMenu(LayoutMenu(self))
self.layout_button.setVisible(not gprefs['show_layout_buttons'])
def init_layout_mixin(self):
self.vl_tabs = VLTabs(self)
self.centralwidget.layout().addWidget(self.vl_tabs)
self.layout_container = CentralContainer(self)
self.centralwidget.layout().addWidget(self.layout_container)
self.book_details = BookDetails(self.layout_container.is_wide, self)
self.stack = QStackedWidget(self)
self.library_view = BooksView(self)
self.library_view.setObjectName('library_view')
stack = QStackedWidget(self)
self.stack.addWidget(stack)
av = self.library_view.alternate_views
self.pin_container = av.set_stack(stack)
self.grid_view = GridView(self)
self.grid_view.setObjectName('grid_view')
av.add_view('grid', self.grid_view)
self.tb_widget = TagBrowserWidget(self)
self.memory_view = DeviceBooksView(self)
self.stack.addWidget(self.memory_view)
self.memory_view.setObjectName('memory_view')
self.card_a_view = DeviceBooksView(self)
self.stack.addWidget(self.card_a_view)
self.card_a_view.setObjectName('card_a_view')
self.card_b_view = DeviceBooksView(self)
self.stack.addWidget(self.card_b_view)
self.card_b_view.setObjectName('card_b_view')
# This must use the base method to find the plugin because it hasn't
# been fully initialized yet
self.qv = find_plugin('Quickview')
if self.qv and self.qv.actual_plugin_:
self.qv = self.qv.actual_plugin_
self.layout_container.initialize_with_gui(self, self.stack)
self.layout_container.tag_browser_button.toggled.connect(
self.tb_widget.set_pane_is_visible, Qt.ConnectionType.QueuedConnection)
self.status_bar = StatusBar(self)
self.grid_view_button = GridViewButton(self)
self.search_bar_button = SearchBarButton(self)
self.grid_view_button.toggled.connect(self.toggle_grid_view)
self.search_bar_button.toggled.connect(self.toggle_search_bar)
self.layout_button = b = QToolButton(self)
b.setAutoRaise(True), b.setCursor(Qt.CursorShape.PointingHandCursor)
b.setPopupMode(QToolButton.ToolButtonPopupMode.InstantPopup)
b.setToolButtonStyle(Qt.ToolButtonStyle.ToolButtonTextBesideIcon)
b.setText(_('Layout')), b.setIcon(QIcon.ic('layout.png'))
b.setToolTip(_(
'Show and hide various parts of the calibre main window'))
self.status_bar.addPermanentWidget(b)
self.status_bar.addPermanentWidget(self.jobs_button)
self.setStatusBar(self.status_bar)
self.status_bar.update_label.linkActivated.connect(self.update_link_clicked)
def finalize_layout(self):
self.status_bar.initialize(self.system_tray_icon)
self.book_details.show_book_info.connect(self.iactions['Show Book Details'].show_book_info)
self.book_details.files_dropped.connect(self.iactions['Add Books'].files_dropped_on_book)
self.book_details.cover_changed.connect(self.bd_cover_changed,
type=Qt.ConnectionType.QueuedConnection)
self.book_details.open_cover_with.connect(self.bd_open_cover_with,
type=Qt.ConnectionType.QueuedConnection)
self.book_details.open_fmt_with.connect(self.bd_open_fmt_with,
type=Qt.ConnectionType.QueuedConnection)
self.book_details.edit_book.connect(self.bd_edit_book,
type=Qt.ConnectionType.QueuedConnection)
self.book_details.cover_removed.connect(self.bd_cover_removed,
type=Qt.ConnectionType.QueuedConnection)
self.book_details.remote_file_dropped.connect(
self.iactions['Add Books'].remote_file_dropped_on_book,
type=Qt.ConnectionType.QueuedConnection)
self.book_details.open_containing_folder.connect(self.iactions['View'].view_folder_for_id)
self.book_details.open_data_folder.connect(self.iactions['View'].view_data_folder_for_id)
self.book_details.view_specific_format.connect(self.iactions['View'].view_format_by_id)
self.book_details.search_requested.connect(self.set_search_string_with_append)
self.book_details.remove_specific_format.connect(
self.iactions['Remove Books'].remove_format_by_id)
self.book_details.remove_metadata_item.connect(
self.iactions['Edit Metadata'].remove_metadata_item)
self.book_details.save_specific_format.connect(
self.iactions['Save To Disk'].save_library_format_by_ids)
self.book_details.restore_specific_format.connect(
self.iactions['Remove Books'].restore_format)
self.book_details.set_cover_from_format.connect(
self.iactions['Edit Metadata'].set_cover_from_format)
self.book_details.copy_link.connect(self.bd_copy_link,
type=Qt.ConnectionType.QueuedConnection)
self.book_details.view_device_book.connect(
self.iactions['View'].view_device_book)
self.book_details.manage_category.connect(self.manage_category_triggerred)
self.book_details.find_in_tag_browser.connect(self.find_in_tag_browser_triggered)
self.book_details.edit_identifiers.connect(self.edit_identifiers_triggerred)
self.book_details.compare_specific_format.connect(self.compare_format)
m = self.library_view.model()
if m.rowCount(None) > 0:
QTimer.singleShot(0, self.library_view.set_current_row)
m.current_changed(self.library_view.currentIndex(),
self.library_view.currentIndex())
self.library_view.setFocus(Qt.FocusReason.OtherFocusReason)
def show_panel(self, name):
if name == 'search_bar':
self.search_bar_button.setChecked(True)
return
self.layout_container.show_panel(name)
def hide_panel(self, name):
if name == 'search_bar':
self.search_bar_button.setChecked(False)
return
self.layout_container.hide_panel(name)
def set_search_string_with_append(self, expression, append=''):
current = self.search.text().strip()
if append:
expr = f'{current} {append} {expression}' if current else expression
else:
expr = expression
self.search.set_search_string(expr)
def edit_identifiers_triggerred(self):
book_id = self.library_view.current_book
db = self.current_db.new_api
identifiers = db.field_for('identifiers', book_id, default_value={})
from calibre.gui2.metadata.basic_widgets import Identifiers
d = Identifiers(identifiers, self)
if d.exec() == QDialog.DialogCode.Accepted:
identifiers = d.get_identifiers()
db.set_field('identifiers', {book_id: identifiers})
self.iactions['Edit Metadata'].refresh_books_after_metadata_edit({book_id})
def manage_category_triggerred(self, field, value):
if field and value:
if field == 'authors':
self.do_author_sort_edit(self, value, select_sort=False,
select_link=False, lookup_author=True)
elif field:
self.do_tags_list_edit(value, field)
def find_in_tag_browser_triggered(self, field, value):
if field and value:
tb = self.tb_widget
tb.set_focus_to_find_box()
tb.item_search.lineEdit().setText(field + ':=' + value)
tb.do_find()
def toggle_grid_view(self, show):
self.library_view.alternate_views.show_view('grid' if show else None)
self.sort_button.setVisible(show)
def toggle_search_bar(self, show):
self.search_bar.setVisible(show)
if show:
self.search.setFocus(Qt.FocusReason.OtherFocusReason)
def bd_cover_changed(self, id_, cdata):
self.library_view.model().db.set_cover(id_, cdata)
self.refresh_cover_browser()
def bd_open_cover_with(self, book_id, entry):
cpath = self.current_db.new_api.format_abspath(book_id, '__COVER_INTERNAL__')
if cpath:
if entry is None:
pm = QPixmap()
pm.load(cpath)
pm.setDevicePixelRatio(self.devicePixelRatioF())
if pm.isNull():
open_local_file(cpath)
else:
from calibre.gui2.image_popup import ImageView
iv = ImageView(QApplication.instance().focusWindow(), pm, QUrl.fromLocalFile(cpath), geom_name='book_details_image_view')
iv(use_exec=True)
return
from calibre.gui2.open_with import run_program
run_program(entry, cpath, self)
def bd_open_fmt_with(self, book_id, fmt, entry):
path = self.current_db.new_api.format_abspath(book_id, fmt)
if path:
from calibre.gui2.open_with import run_program
run_program(entry, path, self)
else:
fmt = fmt.upper()
error_dialog(self, _('No %s format') % fmt, _(
'The book {0} does not have the {1} format').format(
self.current_db.new_api.field_for('title', book_id, default_value=_('Unknown')),
fmt), show=True)
def bd_edit_book(self, book_id, fmt):
from calibre.gui2.widgets import BusyCursor
with BusyCursor():
self.iactions['Tweak ePub'].ebook_edit_format(book_id, fmt)
def open_with_action_triggerred(self, fmt, entry, *args):
book_id = self.library_view.current_book
if book_id is not None:
if fmt == 'cover_image':
self.bd_open_cover_with(book_id, entry)
else:
self.bd_open_fmt_with(book_id, fmt, entry)
def bd_cover_removed(self, id_):
self.library_view.model().db.remove_cover(id_, commit=True,
notify=False)
self.refresh_cover_browser()
def bd_copy_link(self, url):
if url:
QApplication.clipboard().setText(url)
def compare_format(self, book_id, fmt):
db = self.current_db.new_api
ofmt = fmt
if fmt.startswith('ORIGINAL_'):
fmt = fmt.partition('_')[-1]
else:
ofmt = 'ORIGINAL_' + fmt
path1, path2 = db.format_abspath(book_id, ofmt), db.format_abspath(book_id, fmt)
from calibre.gui2.tweak_book.diff.main import compare_books
compare_books(path1, path2, parent=self, revert_msg=_('Restore %s') % ofmt, revert_callback=partial(
self.iactions['Remove Books'].restore_format, book_id, ofmt), names=(ofmt, fmt))
def save_layout_state(self):
for x in ('library', 'memory', 'card_a', 'card_b'):
getattr(self, x+'_view').save_state()
self.layout_container.write_settings()
self.grid_view_button.save_state()
self.search_bar_button.save_state()
def read_layout_settings(self):
# View states are restored automatically when set_database is called
self.layout_container.read_settings()
self.book_details.change_layout(self.layout_container.is_wide)
self.place_layout_buttons()
self.grid_view_button.restore_state()
self.search_bar_button.restore_state()
def update_status_bar(self, *args):
v = self.current_view()
selected = len(v.selectionModel().selectedRows())
library_total, total, current = v.model().counts()
self.status_bar.update_state(library_total, total, current, selected)
# }}}
| 32,101 | Python | .py | 666 | 37.857357 | 141 | 0.621621 | kovidgoyal/calibre | 19,243 | 2,250 | 4 | GPL-3.0 | 9/5/2024, 5:13:50 PM (Europe/Amsterdam) |
26,651 | job_indicator.py | kovidgoyal_calibre/src/calibre/gui2/job_indicator.py | #!/usr/bin/env python
__license__ = 'GPL v3'
__copyright__ = '2012, Kovid Goyal <kovid at kovidgoyal.net>'
__docformat__ = 'restructuredtext en'
from qt.core import QAbstractAnimation, QBrush, QColor, QEasingCurve, QPainter, QPainterPath, QPalette, QPoint, QPointF, QPropertyAnimation, QRect, Qt, QWidget
from calibre.gui2 import config
class Pointer(QWidget):
def __init__(self, gui):
QWidget.__init__(self, gui)
self.setObjectName('jobs_pointer')
self.setVisible(False)
self.resize(100, 80)
self.animation = QPropertyAnimation(self, b"geometry", self)
self.animation.setDuration(750)
self.animation.setLoopCount(2)
self.animation.setEasingCurve(QEasingCurve.Type.Linear)
self.animation.finished.connect(self.hide)
taily, heady = 0, 55
self.arrow_path = QPainterPath(QPointF(40, taily))
self.arrow_path.lineTo(40, heady)
self.arrow_path.lineTo(20, heady)
self.arrow_path.lineTo(50, self.height())
self.arrow_path.lineTo(80, heady)
self.arrow_path.lineTo(60, heady)
self.arrow_path.lineTo(60, taily)
self.arrow_path.closeSubpath()
c = self.palette().color(QPalette.ColorGroup.Active, QPalette.ColorRole.WindowText)
self.color = QColor(c)
self.color.setAlpha(100)
self.brush = QBrush(self.color, Qt.BrushStyle.SolidPattern)
# from qt.core import QTimer
# QTimer.singleShot(1000, self.start)
@property
def gui(self):
return self.parent()
def point_at(self, frac):
return (self.path.pointAtPercent(frac).toPoint() -
QPoint(self.rect().center().x(), self.height()))
def rect_at(self, frac):
return QRect(self.point_at(frac), self.size())
def abspos(self, widget):
pos = widget.pos()
parent = widget.parent()
while parent is not self.gui:
pos += parent.pos()
parent = parent.parent()
return pos
def start(self):
if config['disable_animations']:
return
self.setVisible(True)
self.raise_()
end = self.abspos(self.gui.jobs_button)
end = QPointF(end.x() + self.gui.jobs_button.width()/3.0, end.y()+20)
start = QPointF(end.x(), end.y() - 0.5*self.height())
self.path = QPainterPath(QPointF(start))
self.path.lineTo(end)
self.path.closeSubpath()
self.animation.setStartValue(self.rect_at(0.0))
self.animation.setEndValue(self.rect_at(1.0))
self.animation.setDirection(QAbstractAnimation.Direction.Backward)
num_keys = 100
for i in range(1, num_keys):
i /= num_keys
self.animation.setKeyValueAt(i, self.rect_at(i))
self.animation.start()
def paintEvent(self, ev):
p = QPainter(self)
p.setRenderHints(QPainter.RenderHint.Antialiasing)
p.setBrush(self.brush)
p.setPen(Qt.PenStyle.NoPen)
p.drawPath(self.arrow_path)
p.end()
| 3,051 | Python | .py | 73 | 33.39726 | 159 | 0.639433 | kovidgoyal/calibre | 19,243 | 2,250 | 4 | GPL-3.0 | 9/5/2024, 5:13:50 PM (Europe/Amsterdam) |
26,652 | search_restriction_mixin.py | kovidgoyal_calibre/src/calibre/gui2/search_restriction_mixin.py | #!/usr/bin/env python
__license__ = 'GPL v3'
__copyright__ = '2013, Kovid Goyal <kovid at kovidgoyal.net>'
from functools import partial
from qt.core import (
QAbstractItemView,
QAction,
QComboBox,
QDialog,
QDialogButtonBox,
QFrame,
QGridLayout,
QIcon,
QLabel,
QLineEdit,
QListView,
QMenu,
QRadioButton,
QSize,
QSortFilterProxyModel,
QStringListModel,
Qt,
QTextBrowser,
QVBoxLayout,
)
from calibre.gui2 import error_dialog, gprefs, question_dialog
from calibre.gui2.dialogs.confirm_delete import confirm
from calibre.gui2.widgets import ComboBoxWithHelp
from calibre.utils.icu import sort_key
from calibre.utils.localization import localize_user_manual_link, ngettext, pgettext
from calibre.utils.search_query_parser import ParseException
class SelectNames(QDialog): # {{{
def __init__(self, names, txt, parent=None):
QDialog.__init__(self, parent)
self.l = l = QVBoxLayout(self)
self.setLayout(l)
self.la = la = QLabel(_('Create a Virtual library based on %s') % txt)
l.addWidget(la)
self.filter = f = QLineEdit(self)
f.setPlaceholderText(_('Filter {}').format(txt))
f.setClearButtonEnabled(True)
l.addWidget(f)
self.model = QStringListModel(sorted(names, key=sort_key))
self.pmodel = QSortFilterProxyModel(self)
self.pmodel.setFilterCaseSensitivity(Qt.CaseSensitivity.CaseInsensitive)
f.textChanged.connect(self.pmodel.setFilterFixedString)
self.pmodel.setSourceModel(self.model)
self._names = QListView(self)
self._names.setModel(self.pmodel)
self._names.setSelectionMode(QAbstractItemView.SelectionMode.MultiSelection)
l.addWidget(self._names)
self._or = QRadioButton(_('Match any of the selected %s')%txt)
self._and = QRadioButton(_('Match all of the selected %s')%txt)
self._or.setChecked(True)
l.addWidget(self._or)
l.addWidget(self._and)
self.bb = QDialogButtonBox(QDialogButtonBox.StandardButton.Ok | QDialogButtonBox.StandardButton.Cancel)
self.bb.accepted.connect(self.accept)
self.bb.rejected.connect(self.reject)
l.addWidget(self.bb)
self.resize(self.sizeHint())
@property
def names(self):
for index in self._names.selectedIndexes():
yield index.data(Qt.ItemDataRole.DisplayRole) or ''
@property
def match_type(self):
return ' and ' if self._and.isChecked() else ' or '
# }}}
MAX_VIRTUAL_LIBRARY_NAME_LENGTH = 40
def _build_full_search_string(gui):
search_templates = (
'',
'{cl}',
'{cr}',
'(({cl}) and ({cr}))',
'{sb}',
'(({cl}) and ({sb}))',
'(({cr}) and ({sb}))',
'(({cl}) and ({cr}) and ({sb}))'
)
sb = gui.search.current_text
db = gui.current_db
cr = db.data.get_search_restriction()
cl = db.data.get_base_restriction()
dex = 0
if sb:
dex += 4
if cr:
dex += 2
if cl:
dex += 1
template = search_templates[dex]
return template.format(cl=cl, cr=cr, sb=sb).strip()
class CreateVirtualLibrary(QDialog): # {{{
def __init__(self, gui, existing_names, editing=None):
QDialog.__init__(self, gui)
self.gui = gui
self.existing_names = existing_names
if editing:
self.setWindowTitle(_('Edit Virtual library'))
else:
self.setWindowTitle(_('Create Virtual library'))
self.setWindowIcon(QIcon.ic('lt.png'))
gl = QGridLayout()
self.setLayout(gl)
self.la1 = la1 = QLabel(_('Virtual library &name:'))
gl.addWidget(la1, 0, 0)
self.vl_name = QComboBox()
self.vl_name.setEditable(True)
self.vl_name.lineEdit().setMaxLength(MAX_VIRTUAL_LIBRARY_NAME_LENGTH)
self.vl_name.lineEdit().setClearButtonEnabled(True)
la1.setBuddy(self.vl_name)
gl.addWidget(self.vl_name, 0, 1)
self.editing = editing
self.saved_searches_label = sl = QTextBrowser(self)
sl.viewport().setAutoFillBackground(False)
gl.addWidget(sl, 2, 0, 1, 2)
self.la2 = la2 = QLabel(_('&Search expression:'))
gl.addWidget(la2, 1, 0)
self.vl_text = QLineEdit()
self.vl_text.setClearButtonEnabled(True)
self.vl_text.textChanged.connect(self.search_text_changed)
la2.setBuddy(self.vl_text)
gl.addWidget(self.vl_text, 1, 1)
# Trigger the textChanged signal to initialize the saved searches box
self.vl_text.setText(' ')
self.vl_text.setText(_build_full_search_string(self.gui))
self.sl = sl = QLabel('<p>'+_('Create a Virtual library based on: ')+
('<a href="author.{0}">{0}</a>, '
'<a href="tag.{1}">{1}</a>, '
'<a href="publisher.{2}">{2}</a>, '
'<a href="series.{3}">{3}</a>, '
'<a href="search.{4}">{4}</a>.').format(_('Authors'), _('Tags'),
_('Publishers'), ngettext('Series', 'Series', 2), _('Saved searches')))
sl.setWordWrap(True)
sl.setTextInteractionFlags(Qt.TextInteractionFlag.LinksAccessibleByMouse)
sl.linkActivated.connect(self.link_activated)
gl.addWidget(sl, 3, 0, 1, 2)
gl.setRowStretch(3,10)
self.hl = hl = QLabel(_('''
<h2>Virtual libraries</h2>
<p>With <i>Virtual libraries</i>, you can restrict calibre to only show
you books that match a search. When a Virtual library is in effect, calibre
behaves as though the library contains only the matched books. The Tag browser
display only the tags/authors/series/etc. that belong to the matched books and any searches
you do will only search within the books in the Virtual library. This
is a good way to partition your large library into smaller and easier to work with subsets.</p>
<p>For example you can use a Virtual library to only show you books with the tag <i>Unread</i>
or only books by <i>My favorite author</i> or only books in a particular series.</p>
<p>More information and examples are available in the
<a href="%s">User Manual</a>.</p>
''') % localize_user_manual_link('https://manual.calibre-ebook.com/virtual_libraries.html'))
hl.setWordWrap(True)
hl.setOpenExternalLinks(True)
hl.setFrameStyle(QFrame.Shape.StyledPanel)
gl.addWidget(hl, 0, 3, 4, 1)
bb = QDialogButtonBox(QDialogButtonBox.StandardButton.Ok | QDialogButtonBox.StandardButton.Cancel)
bb.accepted.connect(self.accept)
bb.rejected.connect(self.reject)
gl.addWidget(bb, 4, 0, 1, 0)
if editing:
db = self.gui.current_db
virt_libs = db.new_api.pref('virtual_libraries', {})
for dex,vl in enumerate(sorted(virt_libs.keys(), key=sort_key)):
self.vl_name.addItem(vl, virt_libs.get(vl, ''))
if vl == editing:
self.vl_name.setCurrentIndex(dex)
self.original_index = dex
self.original_search = virt_libs.get(editing, '')
self.vl_text.setText(self.original_search)
self.new_name = editing
self.vl_name.currentIndexChanged.connect(self.name_index_changed)
self.vl_name.lineEdit().textEdited.connect(self.name_text_edited)
self.resize(self.sizeHint()+QSize(150, 25))
self.restore_geometry(gprefs, 'create-virtual-library-dialog')
def search_text_changed(self, txt):
db = self.gui.current_db
searches = [_('Saved searches recognized in the expression:')]
txt = str(txt)
while txt:
p = txt.partition('search:')
if p[1]: # found 'search:'
possible_search = p[2]
if possible_search: # something follows the 'search:'
if possible_search[0] == '"': # strip any quotes
possible_search = possible_search[1:].partition('"')
else: # find end of the search name. Is EOL, space, rparen
sp = possible_search.find(' ')
pp = possible_search.find(')')
if pp < 0 or (sp > 0 and sp <= pp):
# space in string before rparen, or neither found
possible_search = possible_search.partition(' ')
else:
# rparen in string before space
possible_search = possible_search.partition(')')
txt = possible_search[2] # grab remainder of the string
search_name = possible_search[0]
if search_name.startswith('='):
search_name = search_name[1:]
if search_name in db.saved_search_names():
searches.append(search_name + '=' +
db.saved_search_lookup(search_name))
else:
txt = ''
else:
txt = ''
self.saved_searches_label.setPlainText('\n'.join(searches))
def name_text_edited(self, new_name):
self.new_name = str(new_name)
def name_index_changed(self, dex):
if self.editing and (self.vl_text.text() != self.original_search or
self.new_name != self.editing):
if not question_dialog(self.gui, _('Search text changed'),
_('The Virtual library name or the search text has changed. '
'Do you want to discard these changes?'),
default_yes=False):
self.vl_name.blockSignals(True)
self.vl_name.setCurrentIndex(self.original_index)
self.vl_name.lineEdit().setText(self.new_name)
self.vl_name.blockSignals(False)
return
self.new_name = self.editing = self.vl_name.currentText()
self.original_index = dex
self.original_search = str(self.vl_name.itemData(dex) or '')
self.vl_text.setText(self.original_search)
def link_activated(self, url):
db = self.gui.current_db
f, txt = str(url).partition('.')[0::2]
if f == 'search':
names = db.saved_search_names()
else:
names = getattr(db, 'all_%s_names'%f)()
d = SelectNames(names, txt, parent=self)
if d.exec() == QDialog.DialogCode.Accepted:
prefix = f+'s' if f in {'tag', 'author'} else f
if f == 'search':
search = ['(%s)'%(db.saved_search_lookup(x)) for x in d.names]
else:
search = ['%s:"=%s"'%(prefix, x.replace('"', '\\"')) for x in d.names]
if search:
if not self.editing:
self.vl_name.lineEdit().setText(next(d.names))
self.vl_name.lineEdit().setCursorPosition(0)
self.vl_text.setText(d.match_type.join(search))
self.vl_text.setCursorPosition(0)
def accept(self):
n = str(self.vl_name.currentText()).strip()
if not n:
error_dialog(self.gui, _('No name'),
_('You must provide a name for the new Virtual library'),
show=True)
return
if n.startswith('*'):
error_dialog(self.gui, _('Invalid name'),
_('A Virtual library name cannot begin with "*"'),
show=True)
return
if n in self.existing_names and n != self.editing:
if not question_dialog(self.gui, _('Name already in use'),
_('That name is already in use. Do you want to replace it '
'with the new search?'),
default_yes=False):
return
v = str(self.vl_text.text()).strip()
if not v:
error_dialog(self.gui, _('No search string'),
_('You must provide a search to define the new Virtual library'),
show=True)
return
try:
db = self.gui.library_view.model().db
recs = db.data.search_getting_ids('', v, use_virtual_library=False, sort_results=False)
except ParseException as e:
error_dialog(self.gui, _('Invalid search'),
_('The search in the search box is not valid'),
det_msg=e.msg, show=True)
return
if not recs and not question_dialog(
self.gui, _('Search found no books'),
_('The search found no books, so the Virtual library '
'will be empty. Do you really want to use that search?'),
default_yes=False):
return
self.library_name = n
self.library_search = v
self.save_geometry(gprefs, 'create-virtual-library-dialog')
QDialog.accept(self)
def reject(self):
self.save_geometry(gprefs, 'create-virtual-library-dialog')
QDialog.reject(self)
# }}}
class SearchRestrictionMixin:
no_restriction = '<' + _('None') + '>'
def __init__(self, *args, **kwargs):
pass
def init_search_restriction_mixin(self):
self.checked = QIcon.ic('ok.png')
self.empty = QIcon.ic('blank.png')
self.current_search_action = QAction(self.empty, _('*current search'), self)
self.current_search_action.triggered.connect(partial(self.apply_virtual_library, library='*'))
self.addAction(self.current_search_action)
self.keyboard.register_shortcut(
'vl-from-current-search', _('Virtual library from current search'), description=_(
'Create a temporary Virtual library from the current search'), group=pgettext('search restriction group name', 'Miscellaneous'),
default_keys=('Ctrl+*',), action=self.current_search_action)
self.search_based_vl_name = None
self.search_based_vl = None
self.virtual_library_menu = QMenu(self.virtual_library)
self.virtual_library.setMenu(self.virtual_library_menu)
self.virtual_library_menu.aboutToShow.connect(self.virtual_library_menu_about_to_show)
self.clear_vl.clicked.connect(lambda x: (self.apply_virtual_library(), self.clear_additional_restriction()))
self.virtual_library_tooltip = \
_('Use a "Virtual library" to show only a subset of the books present in this library')
self.virtual_library.setToolTip(self.virtual_library_tooltip)
self.search_restriction = ComboBoxWithHelp(self)
self.search_restriction.setVisible(False)
self.clear_vl.setText(_("(all books)"))
self.ar_menu = QMenu(_('Additional restriction'), self.virtual_library_menu)
self.edit_menu = QMenu(_('Edit Virtual library'), self.virtual_library_menu)
self.rm_menu = QMenu(_('Remove Virtual library'), self.virtual_library_menu)
self.search_restriction_list_built = False
def add_virtual_library(self, db, name, search):
virt_libs = db.new_api.pref('virtual_libraries', {})
virt_libs[name] = search
db.new_api.set_pref('virtual_libraries', virt_libs)
db.new_api.clear_search_caches()
self.library_view.model().refresh()
def do_create_edit(self, name=None):
db = self.library_view.model().db
virt_libs = db.new_api.pref('virtual_libraries', {})
cd = CreateVirtualLibrary(self, virt_libs.keys(), editing=name)
if cd.exec() == QDialog.DialogCode.Accepted:
if name:
self._remove_vl(name, reapply=False)
self.add_virtual_library(db, cd.library_name, cd.library_search)
if not name or name == db.data.get_base_restriction_name():
self.apply_virtual_library(cd.library_name)
self.rebuild_vl_tabs()
def build_virtual_library_menu(self, m, add_tabs_action=True):
m.clear()
a = m.addAction(QIcon.ic('plus.png'), _('Create Virtual library'))
a.triggered.connect(partial(self.do_create_edit, name=None))
db = self.current_db
virt_libs = db.new_api.pref('virtual_libraries', {})
a = self.edit_menu
self.build_virtual_library_list(a, self.do_create_edit)
if virt_libs:
m.addMenu(a).setIcon(QIcon.ic('edit_input.png'))
a = self.rm_menu
self.build_virtual_library_list(a, self.remove_vl_triggered)
if virt_libs:
m.addMenu(a).setIcon(QIcon.ic('minus.png'))
m.addAction(QIcon.ic('toc.png'), _('Quick select Virtual library'), self.choose_vl_triggerred)
if add_tabs_action:
if gprefs['show_vl_tabs']:
m.addAction(_('Hide Virtual library tabs'), self.vl_tabs.disable_bar)
else:
m.addAction(_('Show Virtual libraries as tabs'), self.vl_tabs.enable_bar)
m.addSeparator()
a = self.ar_menu
a.clear()
a.setIcon(self.checked if db.data.get_search_restriction_name() else self.empty)
self.build_search_restriction_list()
m.addMenu(a)
m.addSeparator()
current_lib = db.data.get_base_restriction_name()
if not current_lib:
a = m.addAction(self.checked, self.no_restriction)
else:
a = m.addAction(self.empty, self.no_restriction)
a.triggered.connect(partial(self.apply_virtual_library, library=''))
a = m.addAction(self.current_search_action)
if self.search_based_vl_name:
a = m.addAction(
self.checked if db.data.get_base_restriction_name().startswith('*') else self.empty,
self.search_based_vl_name)
a.triggered.connect(partial(self.apply_virtual_library,
library=self.search_based_vl_name))
m.addSeparator()
for vl in sorted(virt_libs.keys(), key=sort_key):
is_current = vl == current_lib
a = m.addAction(self.checked if is_current else self.empty, vl.replace('&', '&&'))
if is_current:
a.triggered.connect(self.apply_virtual_library)
else:
a.triggered.connect(partial(self.apply_virtual_library, library=vl))
def virtual_library_menu_about_to_show(self):
self.build_virtual_library_menu(self.virtual_library_menu)
def rebuild_vl_tabs(self):
self.vl_tabs.rebuild()
def apply_virtual_library(self, library=None, update_tabs=True):
db = self.library_view.model().db
virt_libs = db.new_api.pref('virtual_libraries', {})
if not library:
db.data.set_base_restriction('')
db.data.set_base_restriction_name('')
elif library == '*':
if not self.search.current_text:
# Clear the temporary VL if the search box is empty
db.data.set_base_restriction('')
db.data.set_base_restriction_name('')
else:
txt = _build_full_search_string(self)
try:
db.data.search_getting_ids('', txt, use_virtual_library=False)
except ParseException as e:
error_dialog(self, _('Invalid search'),
_('The search in the search box is not valid'),
det_msg=e.msg, show=True)
return
self.search_based_vl = txt
db.data.set_base_restriction(txt)
self.search_based_vl_name = self._trim_restriction_name('*' + txt)
db.data.set_base_restriction_name(self.search_based_vl_name)
elif library == self.search_based_vl_name:
db.data.set_base_restriction(self.search_based_vl)
db.data.set_base_restriction_name(self.search_based_vl_name)
elif library in virt_libs:
db.data.set_base_restriction(virt_libs[library])
db.data.set_base_restriction_name(library)
self.virtual_library.setToolTip(self.virtual_library_tooltip + '\n' +
db.data.get_base_restriction())
self._apply_search_restriction(db.data.get_search_restriction(),
db.data.get_search_restriction_name())
if update_tabs:
self.vl_tabs.update_current()
def build_virtual_library_list(self, menu, handler):
db = self.library_view.model().db
virt_libs = db.new_api.pref('virtual_libraries', {})
menu.clear()
menu.setIcon(self.empty)
def add_action(name, search):
a = menu.addAction(name.replace('&', '&&'))
a.triggered.connect(partial(handler, name=name))
a.setIcon(self.empty)
libs = sorted(virt_libs.keys(), key=sort_key)
if libs:
menu.setEnabled(True)
for n in libs:
add_action(n, virt_libs[n])
else:
menu.setEnabled(False)
def remove_vl_triggered(self, name=None):
if not confirm(
_('Are you sure you want to remove the Virtual library <b>{0}</b>?').format(name),
'confirm_vl_removal', parent=self):
return
self._remove_vl(name, reapply=True)
self.library_view.model().refresh()
def choose_vl_triggerred(self):
from calibre.gui2.tweak_book.widgets import QuickOpen, emphasis_style
db = self.library_view.model().db
virt_libs = db.new_api.pref('virtual_libraries', {})
if not virt_libs:
return error_dialog(self, _('No Virtual libraries'), _(
'No Virtual libraries present, create some first'), show=True)
example = '<pre>{0}S{1}ome {0}B{1}ook {0}C{1}ollection</pre>'.format(
'<span style="%s">' % emphasis_style(), '</span>')
chars = '<pre style="%s">sbc</pre>' % emphasis_style()
help_text = _('''<p>Quickly choose a Virtual library by typing in just a few characters from the library name into the field above.
For example, if want to choose the VL:
{example}
Simply type in the characters:
{chars}
and press Enter.''').format(example=example, chars=chars)
d = QuickOpen(
sorted(virt_libs.keys(), key=sort_key), parent=self, title=_('Choose Virtual library'),
name='vl-open', level1=' ', help_text=help_text)
if d.exec() == QDialog.DialogCode.Accepted and d.selected_result:
self.apply_virtual_library(library=d.selected_result)
def _remove_vl(self, name, reapply=True):
db = self.library_view.model().db
virt_libs = db.new_api.pref('virtual_libraries', {})
virt_libs.pop(name, None)
db.new_api.set_pref('virtual_libraries', virt_libs)
if reapply and db.data.get_base_restriction_name() == name:
self.apply_virtual_library('')
self.rebuild_vl_tabs()
def _trim_restriction_name(self, name):
name = name.strip()
if len(name) < MAX_VIRTUAL_LIBRARY_NAME_LENGTH or name.endswith('…'):
return name
return name[0:MAX_VIRTUAL_LIBRARY_NAME_LENGTH].strip() + '…'
def build_search_restriction_list(self):
self.search_restriction_list_built = True
m = self.ar_menu
m.clear()
current_restriction_text = None
if self.search_restriction.count() > 1:
txt = str(self.search_restriction.itemText(2))
if txt.startswith('*'):
current_restriction_text = txt
self.search_restriction.clear()
current_restriction = self.library_view.model().db.data.get_search_restriction_name()
m.setIcon(self.checked if current_restriction else self.empty)
dex = 0
def add_action(current_menu, name, last):
nonlocal dex
def compare_fix_amps(name1, name2):
return (self._trim_restriction_name(name1).replace('&&', '&') ==
self._trim_restriction_name(name2).replace('&&', '&'))
self.search_restriction.addItem(name)
txt = self._trim_restriction_name(last)
if compare_fix_amps(name, current_restriction):
a = current_menu.addAction(self.checked, txt if txt else self.no_restriction)
else:
a = current_menu.addAction(txt if txt else self.no_restriction)
a.triggered.connect(partial(self.search_restriction_triggered, action=a, index=dex))
dex += 1
return a
add_action(m, '', '')
add_action(m, _('*current search'), _('*current search'))
if current_restriction_text:
add_action(m, current_restriction_text, current_restriction_text)
self.add_saved_searches_to_menu(m, self.library_view.model().db, add_action)
def search_restriction_triggered(self, action=None, index=None):
self.search_restriction.setCurrentIndex(index)
self.apply_search_restriction(index)
def apply_named_search_restriction(self, name=None):
if not self.search_restriction_list_built:
self.build_search_restriction_list()
if not name:
r = 0
else:
r = self.search_restriction.findText(name)
if r < 0:
r = 0
self.search_restriction.setCurrentIndex(r)
self.apply_search_restriction(r)
def apply_text_search_restriction(self, search):
if not self.search_restriction_list_built:
self.build_search_restriction_list()
search = str(search)
if not search:
self.search_restriction.setCurrentIndex(0)
self._apply_search_restriction('', '')
else:
s = '*' + search
if self.search_restriction.count() > 1:
txt = str(self.search_restriction.itemText(2))
if txt.startswith('*'):
self.search_restriction.setItemText(2, s)
else:
self.search_restriction.insertItem(2, s)
else:
self.search_restriction.insertItem(2, s)
self.search_restriction.setCurrentIndex(2)
self._apply_search_restriction(search, self._trim_restriction_name(s))
def apply_search_restriction(self, i):
if not self.search_restriction_list_built:
self.build_search_restriction_list()
if i == 1:
self.apply_text_search_restriction(str(self.search.currentText()))
elif i == 2 and str(self.search_restriction.currentText()).startswith('*'):
self.apply_text_search_restriction(str(self.search_restriction.currentText())[1:])
else:
r = str(self.search_restriction.currentText()).replace('&&', '&')
if r is not None and r != '':
restriction = 'search:"%s"'%(r)
else:
restriction = ''
self._apply_search_restriction(restriction, r)
def clear_additional_restriction(self):
self.search_restriction.setCurrentIndex(0)
self._apply_search_restriction('', '')
def _apply_search_restriction(self, restriction, name):
# The order below is important. Set the restriction, force a '' search
# to apply it, reset the tag browser to take it into account, then set
# the book count.
self.library_view.model().db.data.set_search_restriction(restriction)
self.library_view.model().db.data.set_search_restriction_name(name)
self.search.clear(emit_search=True)
self.tags_view.recount()
self.set_number_of_books_shown()
self.current_view().setFocus(Qt.FocusReason.OtherFocusReason)
self.set_window_title()
v = self.current_view()
if not v.currentIndex().isValid():
v.set_current_row()
if not v.refresh_book_details():
self.book_details.reset_info()
def set_number_of_books_shown(self):
db = self.library_view.model().db
if self.current_view() == self.library_view and db is not None and \
db.data.search_restriction_applied():
restrictions = [x for x in (db.data.get_base_restriction_name(),
db.data.get_search_restriction_name()) if x]
t = ' :: '.join(restrictions)
if len(t) > 20:
t = t[:19] + '…'
self.clear_vl.setVisible(not gprefs['show_vl_tabs'])
else: # No restriction or not library view
t = ''
self.clear_vl.setVisible(False)
self.clear_vl.setText(t.replace('&', '&&'))
if __name__ == '__main__':
from calibre.gui2 import Application
from calibre.gui2.preferences import init_gui
app = Application([])
app
gui = init_gui()
d = CreateVirtualLibrary(gui, [])
d.exec()
| 29,335 | Python | .py | 604 | 36.945364 | 144 | 0.591503 | kovidgoyal/calibre | 19,243 | 2,250 | 4 | GPL-3.0 | 9/5/2024, 5:13:50 PM (Europe/Amsterdam) |
26,653 | comments_editor.py | kovidgoyal_calibre/src/calibre/gui2/comments_editor.py | #!/usr/bin/env python
# License: GPLv3 Copyright: 2010, Kovid Goyal <kovid at kovidgoyal.net>
import os
import re
import sys
import weakref
from collections import defaultdict
from contextlib import contextmanager
from functools import partial
from threading import Thread
from html5_parser import parse
from lxml import html
from qt.core import (
QAction,
QApplication,
QBrush,
QByteArray,
QCheckBox,
QColor,
QColorDialog,
QDialog,
QDialogButtonBox,
QFont,
QFontInfo,
QFontMetrics,
QFormLayout,
QHBoxLayout,
QIcon,
QKeySequence,
QLabel,
QLineEdit,
QMenu,
QPalette,
QPlainTextEdit,
QPointF,
QPushButton,
QSize,
QSpinBox,
QSyntaxHighlighter,
Qt,
QTabWidget,
QTextBlockFormat,
QTextCharFormat,
QTextCursor,
QTextDocument,
QTextEdit,
QTextFormat,
QTextFrameFormat,
QTextImageFormat,
QTextListFormat,
QTimer,
QToolButton,
QUrl,
QVBoxLayout,
QWidget,
pyqtSignal,
pyqtSlot,
)
from calibre import browser, fit_image, xml_replace_entities
from calibre.db.constants import DATA_DIR_NAME
from calibre.ebooks.chardet import xml_to_unicode
from calibre.gui2 import (
NO_URL_FORMATTING,
FunctionDispatcher,
choose_dir,
choose_files,
error_dialog,
gprefs,
is_dark_theme,
local_path_for_resource,
question_dialog,
safe_open_url,
)
from calibre.gui2.book_details import resolved_css
from calibre.gui2.dialogs.progress import ProgressDialog
from calibre.gui2.flow_toolbar import create_flow_toolbar
from calibre.gui2.widgets import LineEditECM
from calibre.gui2.widgets2 import to_plain_text
from calibre.startup import connect_lambda
from calibre.utils.cleantext import clean_xml_chars
from calibre.utils.config import tweaks
from calibre.utils.filenames import make_long_path_useable
from calibre.utils.imghdr import what
from polyglot.builtins import iteritems, itervalues
# Cleanup Qt markup {{{
OBJECT_REPLACEMENT_CHAR = '\ufffc'
def parse_style(style):
props = filter(None, (x.strip() for x in style.split(';')))
ans = {}
for prop in props:
try:
k, v = prop.split(':', 1)
except Exception:
continue
ans[k.strip().lower()] = v.strip()
return ans
liftable_props = ('font-style', 'font-weight', 'font-family', 'font-size')
def lift_styles(tag, style_map):
common_props = None
has_text = bool(tag.text)
child_styles = []
for child in tag.iterchildren('*'):
if child.tail and child.tail.strip():
has_text = True
style = style_map[child]
child_styles.append(style)
if not child.text and len(child) == 0:
continue
if common_props is None:
common_props = style.copy()
else:
for k, v in tuple(iteritems(common_props)):
if style.get(k) != v:
del common_props[k]
if not has_text and common_props:
lifted_props = []
tag_style = style_map[tag]
for k in liftable_props:
if k in common_props:
lifted_props.append(k)
tag_style[k] = common_props[k]
if lifted_props:
for style in child_styles:
for k in lifted_props:
style.pop(k, None)
def filter_qt_styles(style):
for k in tuple(style):
# -qt-paragraph-type is a hack used by Qt for empty paragraphs
if k.startswith('-qt-'):
del style[k]
def remove_margins(tag, style):
ml, mr, mt, mb = (style.pop('margin-' + k, None) for k in 'left right top bottom'.split())
is_blockquote = ml == mr and ml and ml != '0px' and (ml != mt or ml != mb)
if is_blockquote:
tag.tag = 'blockquote'
def remove_zero_indents(style):
ti = style.get('text-indent')
if ti == '0px':
del style['text-indent']
def remove_heading_font_styles(tag, style):
lvl = int(tag.tag[1:])
expected_size = (None, 'xx-large', 'x-large', 'large', None, 'small', 'x-small')[lvl]
if style.get('font-size', 1) == expected_size:
del style['font-size']
if style.get('font-weight') in ('0', '600', '700', 'bold'):
del style['font-weight']
def use_implicit_styling_for_span(span, style):
is_italic = style.get('font-style') == 'italic'
is_bold = style.get('font-weight') in ('600', '700', 'bold')
if is_italic and not is_bold:
del style['font-style']
span.tag = 'em'
elif is_bold and not is_italic:
del style['font-weight']
span.tag = 'strong'
if span.tag == 'span' and style.get('text-decoration') == 'underline':
span.tag = 'u'
del style['text-decoration']
if span.tag == 'span' and style.get('text-decoration') == 'line-through':
span.tag = 's'
del style['text-decoration']
if span.tag == 'span' and style.get('vertical-align') in ('sub', 'super'):
span.tag = 'sub' if style.pop('vertical-align') == 'sub' else 'sup'
def use_implicit_styling_for_a(a, style_map):
for span in a.iterchildren('span'):
style = style_map[span]
if style.get('text-decoration') == 'underline':
del style['text-decoration']
if style.get('color') == '#0000ff':
del style['color']
break
def merge_contiguous_links(root):
all_hrefs = set(root.xpath('//a/@href'))
for href in all_hrefs:
tags = root.xpath(f'//a[@href="{href}"]')
processed = set()
def insert_tag(parent, child):
parent.tail = child.tail
if child.text:
children = parent.getchildren()
if children:
children[-1].tail = (children[-1].tail or '') + child.text
else:
parent.text = (parent.text or '') + child.text
for gc in child.iterchildren('*'):
parent.append(gc)
for a in tags:
if a in processed or a.tail:
continue
processed.add(a)
n = a
remove = []
while not n.tail and n.getnext() is not None and getattr(n.getnext(), 'tag', None) == 'a' and n.getnext().get('href') == href:
n = n.getnext()
processed.add(n)
remove.append(n)
for n in remove:
insert_tag(a, n)
n.getparent().remove(n)
def convert_anchors_to_ids(root):
anchors = root.xpath('//a[@name]')
for a in anchors:
p = a.getparent()
if len(a.attrib) == 1 and not p.text and a is p[0] and not a.text and not p.get('id') and a.get('name') and len(a) == 0:
p.text = a.tail
p.set('id', a.get('name'))
p.remove(a)
def cleanup_qt_markup(root):
from calibre.ebooks.docx.cleanup import lift
style_map = defaultdict(dict)
for tag in root.xpath('//*[@style]'):
style_map[tag] = parse_style(tag.get('style'))
convert_anchors_to_ids(root)
block_tags = root.xpath('//body/*')
for tag in block_tags:
lift_styles(tag, style_map)
tag_style = style_map[tag]
remove_margins(tag, tag_style)
remove_zero_indents(tag_style)
if tag.tag.startswith('h') and tag.tag[1:] in '123456':
remove_heading_font_styles(tag, tag_style)
for child in tag.iterdescendants('a'):
use_implicit_styling_for_a(child, style_map)
for child in tag.iterdescendants('span'):
use_implicit_styling_for_span(child, style_map[child])
if tag.tag == 'p' and style_map[tag].get('-qt-paragraph-type') == 'empty':
del tag[:]
tag.text = '\xa0'
if tag.tag in ('ol', 'ul'):
for li in tag.iterdescendants('li'):
ts = style_map.get(li)
if ts:
remove_margins(li, ts)
remove_zero_indents(ts)
for img in root.xpath('//img[@style]'):
s = style_map.get(img)
if s:
if s == {'float': 'left'}:
s['margin-right'] = '0.5em'
elif s == {'float': 'right'}:
s['margin-left'] = '0.5em'
for style in itervalues(style_map):
filter_qt_styles(style)
fw = style.get('font-weight')
if fw in ('600', '700'):
style['font-weight'] = 'bold'
for tag, style in iteritems(style_map):
if style:
tag.set('style', '; '.join(f'{k}: {v}' for k, v in iteritems(style)))
else:
tag.attrib.pop('style', None)
for span in root.xpath('//span[not(@style)]'):
lift(span)
merge_contiguous_links(root)
# }}}
def fix_html(original_html, original_txt, remove_comments=True, callback=None):
raw = original_html
raw = xml_to_unicode(raw, strip_encoding_pats=True, resolve_entities=True)[0]
if remove_comments:
comments_pat = re.compile(r'<!--.*?-->', re.DOTALL)
raw = comments_pat.sub('', raw)
if not original_txt and '<img' not in raw.lower():
return ''
try:
root = parse(raw, maybe_xhtml=False, sanitize_names=True)
except Exception:
root = parse(clean_xml_chars(raw), maybe_xhtml=False, sanitize_names=True)
if root.xpath('//meta[@name="calibre-dont-sanitize"]'):
# Bypass cleanup if special meta tag exists
return original_html
try:
cleanup_qt_markup(root)
except Exception:
import traceback
traceback.print_exc()
if callback is not None:
callback(root, original_txt)
elems = []
for body in root.xpath('//body'):
if body.text:
elems.append(body.text)
elems += [html.tostring(x, encoding='unicode') for x in body if
x.tag not in ('script', 'style')]
if len(elems) > 1:
ans = '<div>%s</div>'%(''.join(elems))
else:
ans = ''.join(elems)
if not ans.startswith('<'):
ans = '<p>%s</p>'%ans
return xml_replace_entities(ans)
class EditorWidget(QTextEdit, LineEditECM): # {{{
data_changed = pyqtSignal()
insert_images_separately = False
can_store_images = False
@property
def readonly(self):
return self.isReadOnly()
@readonly.setter
def readonly(self, val):
self.setReadOnly(bool(val))
@contextmanager
def editing_cursor(self, set_cursor=True):
c = self.textCursor()
c.beginEditBlock()
yield c
c.endEditBlock()
if set_cursor:
self.setTextCursor(c)
self.focus_self()
def __init__(self, parent=None):
QTextEdit.__init__(self, parent)
self.setTabChangesFocus(True)
self.document().setDefaultStyleSheet(resolved_css() + '\n\nli { margin-top: 0.5ex; margin-bottom: 0.5ex; }')
font = self.font()
f = QFontInfo(font)
delta = tweaks['change_book_details_font_size_by'] + 1
if delta:
font.setPixelSize(int(f.pixelSize() + delta))
self.setFont(font)
f = QFontMetrics(self.font())
self.em_size = f.horizontalAdvance('m')
self.base_url = None
self._parent = weakref.ref(parent)
self.shortcut_map = {}
def r(name, icon, text, checkable=False, shortcut=None):
ac = QAction(QIcon.ic(icon + '.png'), text, self)
ac.setShortcutContext(Qt.ShortcutContext.WidgetWithChildrenShortcut)
if checkable:
ac.setCheckable(checkable)
setattr(self, 'action_'+name, ac)
ac.triggered.connect(getattr(self, 'do_' + name))
if shortcut is not None:
self.shortcut_map[shortcut] = ac
sc = shortcut if isinstance(shortcut, QKeySequence) else QKeySequence(shortcut)
ac.setShortcut(sc)
ac.setToolTip(text + f' [{sc.toString(QKeySequence.SequenceFormat.NativeText)}]')
self.addAction(ac)
r('bold', 'format-text-bold', _('Bold'), True, QKeySequence.StandardKey.Bold)
r('italic', 'format-text-italic', _('Italic'), True, QKeySequence.StandardKey.Italic)
r('underline', 'format-text-underline', _('Underline'), True, QKeySequence.StandardKey.Underline)
r('strikethrough', 'format-text-strikethrough', _('Strikethrough'), True)
r('superscript', 'format-text-superscript', _('Superscript'), True)
r('subscript', 'format-text-subscript', _('Subscript'), True)
r('ordered_list', 'format-list-ordered', _('Ordered list'), True)
r('unordered_list', 'format-list-unordered', _('Unordered list'), True)
r('align_left', 'format-justify-left', _('Align left'), True)
r('align_center', 'format-justify-center', _('Align center'), True)
r('align_right', 'format-justify-right', _('Align right'), True)
r('align_justified', 'format-justify-fill', _('Align justified'), True)
r('undo', 'edit-undo', _('Undo'), shortcut=QKeySequence.StandardKey.Undo)
r('redo', 'edit-redo', _('Redo'), shortcut=QKeySequence.StandardKey.Redo)
r('remove_format', 'edit-clear', _('Remove formatting'))
r('copy', 'edit-copy', _('Copy'), shortcut=QKeySequence.StandardKey.Copy)
r('paste', 'edit-paste', _('Paste'), shortcut=QKeySequence.StandardKey.Paste)
r('paste_and_match_style', 'edit-paste', _('Paste and match style'), shortcut=QKeySequence('ctrl+shift+v', QKeySequence.SequenceFormat.PortableText))
r('cut', 'edit-cut', _('Cut'), shortcut=QKeySequence.StandardKey.Cut)
r('indent', 'format-indent-more', _('Increase indentation'))
r('outdent', 'format-indent-less', _('Decrease indentation'))
r('select_all', 'edit-select-all', _('Select all'), shortcut=QKeySequence.StandardKey.SelectAll)
r('color', 'format-text-color', _('Foreground color'))
r('background', 'format-fill-color', _('Background color'))
r('insert_link', 'insert-link', _('Insert link') if self.insert_images_separately else _('Insert link or image'),
shortcut=QKeySequence('Ctrl+l', QKeySequence.SequenceFormat.PortableText))
r('insert_image', 'view-image', _('Insert image'), shortcut=QKeySequence('Ctrl+p', QKeySequence.SequenceFormat.PortableText))
r('insert_hr', 'format-text-hr', _('Insert separator'),)
r('clear', 'trash', _('Clear'))
self.action_block_style = QAction(QIcon.ic('format-text-heading.png'),
_('Style text block'), self)
self.action_block_style.setToolTip(
_('Style the selected text block'))
self.block_style_menu = QMenu(self)
self.action_block_style.setMenu(self.block_style_menu)
self.block_style_actions = []
h = _('Heading {0}')
for text, name in (
(_('Normal'), 'p'),
(h.format(1), 'h1'),
(h.format(2), 'h2'),
(h.format(3), 'h3'),
(h.format(4), 'h4'),
(h.format(5), 'h5'),
(h.format(6), 'h6'),
(_('Blockquote'), 'blockquote'),
):
ac = QAction(text, self)
self.block_style_menu.addAction(ac)
ac.block_name = name
ac.setCheckable(True)
self.block_style_actions.append(ac)
ac.triggered.connect(self.do_format_block)
self.setHtml('')
self.copyAvailable.connect(self.update_clipboard_actions)
self.update_clipboard_actions(False)
self.selectionChanged.connect(self.update_selection_based_actions)
self.update_selection_based_actions()
connect_lambda(self.undoAvailable, self, lambda self, yes: self.action_undo.setEnabled(yes))
connect_lambda(self.redoAvailable, self, lambda self, yes: self.action_redo.setEnabled(yes))
self.action_undo.setEnabled(False), self.action_redo.setEnabled(False)
self.textChanged.connect(self.update_cursor_position_actions)
self.cursorPositionChanged.connect(self.update_cursor_position_actions)
self.textChanged.connect(self.data_changed)
self.update_cursor_position_actions()
def update_clipboard_actions(self, copy_available):
self.action_copy.setEnabled(copy_available)
self.action_cut.setEnabled(copy_available)
def update_selection_based_actions(self):
pass
def update_cursor_position_actions(self):
c = self.textCursor()
tcf = c.charFormat()
ls = c.currentList()
self.action_ordered_list.setChecked(ls is not None and ls.format().style() == QTextListFormat.Style.ListDecimal)
self.action_unordered_list.setChecked(ls is not None and ls.format().style() == QTextListFormat.Style.ListDisc)
vert = tcf.verticalAlignment()
self.action_superscript.setChecked(vert == QTextCharFormat.VerticalAlignment.AlignSuperScript)
self.action_subscript.setChecked(vert == QTextCharFormat.VerticalAlignment.AlignSubScript)
self.action_bold.setChecked(tcf.fontWeight() == QFont.Weight.Bold)
self.action_italic.setChecked(tcf.fontItalic())
self.action_underline.setChecked(tcf.fontUnderline())
self.action_strikethrough.setChecked(tcf.fontStrikeOut())
bf = c.blockFormat()
a = bf.alignment()
self.action_align_left.setChecked(a == Qt.AlignmentFlag.AlignLeft)
self.action_align_right.setChecked(a == Qt.AlignmentFlag.AlignRight)
self.action_align_center.setChecked(a == Qt.AlignmentFlag.AlignHCenter)
self.action_align_justified.setChecked(a == Qt.AlignmentFlag.AlignJustify)
lvl = bf.headingLevel()
name = 'p'
if lvl == 0:
if bf.leftMargin() == bf.rightMargin() and bf.leftMargin() > 0:
name = 'blockquote'
else:
name = f'h{lvl}'
for ac in self.block_style_actions:
ac.setChecked(ac.block_name == name)
def set_readonly(self, what):
self.readonly = what
def focus_self(self):
self.setFocus(Qt.FocusReason.TabFocusReason)
def do_clear(self, *args):
c = self.textCursor()
c.beginEditBlock()
c.movePosition(QTextCursor.MoveOperation.Start, QTextCursor.MoveMode.MoveAnchor)
c.movePosition(QTextCursor.MoveOperation.End, QTextCursor.MoveMode.KeepAnchor)
c.removeSelectedText()
c.endEditBlock()
self.focus_self()
clear_text = do_clear
def do_bold(self):
with self.editing_cursor() as c:
fmt = QTextCharFormat()
fmt.setFontWeight(
QFont.Weight.Bold if c.charFormat().fontWeight() != QFont.Weight.Bold else QFont.Weight.Normal)
c.mergeCharFormat(fmt)
self.update_cursor_position_actions()
def do_italic(self):
with self.editing_cursor() as c:
fmt = QTextCharFormat()
fmt.setFontItalic(not c.charFormat().fontItalic())
c.mergeCharFormat(fmt)
self.update_cursor_position_actions()
def do_underline(self):
with self.editing_cursor() as c:
fmt = QTextCharFormat()
fmt.setFontUnderline(not c.charFormat().fontUnderline())
c.mergeCharFormat(fmt)
self.update_cursor_position_actions()
def do_strikethrough(self):
with self.editing_cursor() as c:
fmt = QTextCharFormat()
fmt.setFontStrikeOut(not c.charFormat().fontStrikeOut())
c.mergeCharFormat(fmt)
self.update_cursor_position_actions()
def do_vertical_align(self, which):
with self.editing_cursor() as c:
fmt = QTextCharFormat()
fmt.setVerticalAlignment(which)
c.mergeCharFormat(fmt)
self.update_cursor_position_actions()
def do_superscript(self):
self.do_vertical_align(QTextCharFormat.VerticalAlignment.AlignSuperScript)
def do_subscript(self):
self.do_vertical_align(QTextCharFormat.VerticalAlignment.AlignSubScript)
def do_list(self, fmt):
with self.editing_cursor() as c:
ls = c.currentList()
if ls is not None:
lf = ls.format()
if lf.style() == fmt:
c.setBlockFormat(QTextBlockFormat())
else:
lf.setStyle(fmt)
ls.setFormat(lf)
else:
ls = c.createList(fmt)
self.update_cursor_position_actions()
def do_ordered_list(self):
self.do_list(QTextListFormat.Style.ListDecimal)
def do_unordered_list(self):
self.do_list(QTextListFormat.Style.ListDisc)
def do_alignment(self, which):
with self.editing_cursor() as c:
c = self.textCursor()
fmt = QTextBlockFormat()
fmt.setAlignment(which)
c.mergeBlockFormat(fmt)
self.update_cursor_position_actions()
def do_align_left(self):
self.do_alignment(Qt.AlignmentFlag.AlignLeft)
def do_align_center(self):
self.do_alignment(Qt.AlignmentFlag.AlignHCenter)
def do_align_right(self):
self.do_alignment(Qt.AlignmentFlag.AlignRight)
def do_align_justified(self):
self.do_alignment(Qt.AlignmentFlag.AlignJustify)
def do_undo(self):
self.undo()
self.focus_self()
def do_redo(self):
self.redo()
self.focus_self()
def do_remove_format(self):
with self.editing_cursor() as c:
c.setBlockFormat(QTextBlockFormat())
c.setCharFormat(QTextCharFormat())
self.update_cursor_position_actions()
def keyPressEvent(self, ev):
for sc, ac in self.shortcut_map.items():
if isinstance(sc, QKeySequence.StandardKey) and ev.matches(sc):
ac.trigger()
return
return super().keyPressEvent(ev)
def do_copy(self):
self.copy()
self.focus_self()
def do_paste(self):
images_before = set()
for fmt in self.document().allFormats():
if fmt.isImageFormat():
images_before.add(fmt.toImageFormat().name())
self.paste()
if self.can_store_images:
added = set()
for fmt in self.document().allFormats():
if fmt.isImageFormat():
name = fmt.toImageFormat().name()
if name not in images_before and name.partition(':')[0] in ('https', 'http'):
added.add(name)
if added and question_dialog(
self, _('Download images'), _(
'Download all remote images in the pasted content?')):
self.download_images(added)
self.focus_self()
def download_images(self, urls):
from calibre.web import get_download_filename_from_response
br = browser()
d = self.document()
c = self.textCursor()
c.setPosition(0)
pos_map = {}
while True:
c = d.find(OBJECT_REPLACEMENT_CHAR, c, QTextDocument.FindFlag.FindCaseSensitively)
if c.isNull():
break
fmt = c.charFormat()
if fmt.isImageFormat():
name = fmt.toImageFormat().name()
if name in urls:
pos_map[name] = c.position()
pd = ProgressDialog(title=_('Downloading images...'), min=0, max=0, parent=self)
pd.canceled_signal.connect(pd.accept)
data_map = {}
error_map = {}
set_msg = FunctionDispatcher(pd.set_msg, parent=pd)
accept = FunctionDispatcher(pd.accept, parent=pd)
def do_download():
for url, pos in pos_map.items():
if pd.canceled:
return
set_msg(_('Downloading {}...').format(url))
try:
res = br.open_novisit(url, timeout=30)
fname = get_download_filename_from_response(res)
data = res.read()
except Exception as err:
error_map[url] = err
else:
data_map[url] = fname, data
accept()
Thread(target=do_download, daemon=True).start()
pd.exec()
if pd.canceled:
return
for url, pos in pos_map.items():
fname, data = data_map[url]
newname = self.commit_downloaded_image(data, fname)
c = self.textCursor()
c.setPosition(pos)
alignment = QTextFrameFormat.Position.InFlow
f = self.frame_for_cursor(c)
if f is not None:
alignment = f.frameFormat().position()
fmt = c.charFormat()
i = fmt.toImageFormat()
i.setName(newname)
c.deletePreviousChar()
c.insertImage(i, alignment)
if error_map:
m = '\n'.join(
_('Could not download {0} with error:').format(url) + '\n\t' + str(err) + '\n\n' for url, err in error_map.items())
error_dialog(self, _('Failed to download some images'), _(
'Some images could not be downloaded, click "Show details" to see which ones'), det_msg=m, show=True)
def do_paste_and_match_style(self):
text = QApplication.instance().clipboard().text()
if text:
self.setText(text)
def do_cut(self):
self.cut()
self.focus_self()
def indent_block(self, mult=1):
with self.editing_cursor() as c:
bf = c.blockFormat()
bf.setTextIndent(bf.textIndent() + 2 * self.em_size * mult)
c.setBlockFormat(bf)
self.update_cursor_position_actions()
def do_indent(self):
self.indent_block()
def do_outdent(self):
self.indent_block(-1)
def do_select_all(self):
with self.editing_cursor() as c:
c.movePosition(QTextCursor.MoveOperation.Start, QTextCursor.MoveMode.MoveAnchor)
c.movePosition(QTextCursor.MoveOperation.End, QTextCursor.MoveMode.KeepAnchor)
def level_for_block_type(self, name):
if name == 'blockquote':
return 0
return {q: i for i, q in enumerate('p h1 h2 h3 h4 h5 h6'.split())}[name]
def do_format_block(self):
name = self.sender().block_name
with self.editing_cursor() as c:
bf = QTextBlockFormat()
cf = QTextCharFormat()
bcf = c.blockCharFormat()
lvl = self.level_for_block_type(name)
wt = QFont.Weight.Bold if lvl else QFont.Weight.Normal
adjust = (0, 3, 2, 1, 0, -1, -1)[lvl]
pos = None
if not c.hasSelection():
pos = c.position()
c.movePosition(QTextCursor.MoveOperation.StartOfBlock, QTextCursor.MoveMode.MoveAnchor)
c.movePosition(QTextCursor.MoveOperation.EndOfBlock, QTextCursor.MoveMode.KeepAnchor)
# margin values are taken from qtexthtmlparser.cpp
hmargin = 0
if name == 'blockquote':
hmargin = 40
tmargin = bmargin = 12
if name == 'h1':
tmargin, bmargin = 18, 12
elif name == 'h2':
tmargin, bmargin = 16, 12
elif name == 'h3':
tmargin, bmargin = 14, 12
elif name == 'h4':
tmargin, bmargin = 12, 12
elif name == 'h5':
tmargin, bmargin = 12, 4
bf.setLeftMargin(hmargin), bf.setRightMargin(hmargin)
bf.setTopMargin(tmargin), bf.setBottomMargin(bmargin)
bf.setHeadingLevel(lvl)
bcf.setProperty(QTextFormat.Property.FontSizeAdjustment, adjust)
cf.setProperty(QTextFormat.Property.FontSizeAdjustment, adjust)
bcf.setFontWeight(wt)
cf.setFontWeight(wt)
c.setBlockCharFormat(bcf)
c.mergeCharFormat(cf)
c.mergeBlockFormat(bf)
if pos is not None:
c.setPosition(pos)
self.update_cursor_position_actions()
def do_color(self):
col = QColorDialog.getColor(Qt.GlobalColor.black, self,
_('Choose foreground color'), QColorDialog.ColorDialogOption.ShowAlphaChannel)
if col.isValid():
fmt = QTextCharFormat()
fmt.setForeground(QBrush(col))
with self.editing_cursor() as c:
c.mergeCharFormat(fmt)
def do_background(self):
col = QColorDialog.getColor(Qt.GlobalColor.white, self,
_('Choose background color'), QColorDialog.ColorDialogOption.ShowAlphaChannel)
if col.isValid():
fmt = QTextCharFormat()
fmt.setBackground(QBrush(col))
with self.editing_cursor() as c:
c.mergeCharFormat(fmt)
def do_insert_hr(self, *args):
with self.editing_cursor() as c:
c.movePosition(QTextCursor.MoveOperation.EndOfBlock, QTextCursor.MoveMode.MoveAnchor)
c.insertHtml('<hr>')
def do_insert_image(self):
from calibre.gui2 import choose_images
files = choose_images(self, 'choose-image-for-comments-editor', _('Choose image'), formats='png jpeg jpg gif svg webp'.split())
if files:
self.focus_self()
with self.editing_cursor() as c:
c.insertImage(files[0])
def do_insert_link(self, *args):
link, name, is_image = self.ask_link()
if not link:
return
url = self.parse_link(link)
if url.isValid():
if url.isLocalFile() and not os.path.isabs(url.toLocalFile()):
url = url.toLocalFile()
else:
url = url.toString(NO_URL_FORMATTING)
self.focus_self()
with self.editing_cursor() as c:
if is_image:
c.insertImage(url)
else:
oldfmt = QTextCharFormat(c.charFormat())
fmt = QTextCharFormat()
fmt.setAnchor(True)
fmt.setAnchorHref(url)
fmt.setForeground(QBrush(self.palette().color(QPalette.ColorRole.Link)))
if name or not c.hasSelection():
c.mergeCharFormat(fmt)
c.insertText(name or url)
else:
pos, anchor = c.position(), c.anchor()
start, end = min(pos, anchor), max(pos, anchor)
for i in range(start, end):
cur = self.textCursor()
cur.setPosition(i), cur.setPosition(i + 1, QTextCursor.MoveMode.KeepAnchor)
cur.mergeCharFormat(fmt)
c.setPosition(c.position())
c.setCharFormat(oldfmt)
else:
error_dialog(self, _('Invalid URL'),
_('The URL %r is invalid') % link, show=True)
def ask_link(self):
class Ask(QDialog):
def accept(self):
if self.treat_as_image.isChecked():
url = self.url.text()
if url.lower().split(':', 1)[0] in ('http', 'https'):
error_dialog(self, _('Remote images not supported'), _(
'You must download the image to your computer, URLs pointing'
' to remote images are not supported.'), show=True)
return
QDialog.accept(self)
d = Ask(self)
d.setWindowTitle(_('Create link'))
l = QFormLayout()
l.setFieldGrowthPolicy(QFormLayout.FieldGrowthPolicy.ExpandingFieldsGrow)
d.setLayout(l)
d.url = QLineEdit(d)
d.name = QLineEdit(d)
d.treat_as_image = QCheckBox(d)
d.setMinimumWidth(600)
d.bb = QDialogButtonBox(QDialogButtonBox.StandardButton.Ok|QDialogButtonBox.StandardButton.Cancel)
d.br = b = QPushButton(_('&File'))
base = os.path.dirname(self.base_url.toLocalFile()) if self.base_url else os.getcwd()
data_path = os.path.join(base, DATA_DIR_NAME)
if self.base_url:
os.makedirs(data_path, exist_ok=True)
def cf(data_dir=False):
filetypes = []
if d.treat_as_image.isChecked():
filetypes = [(_('Images'), 'png jpeg jpg gif'.split())]
if data_dir:
files = choose_files(
d, 'select link file', _('Choose file'), filetypes, select_only_single_file=True, no_save_dir=True,
default_dir=data_path)
else:
files = choose_files(d, 'select link file', _('Choose file'), filetypes, select_only_single_file=True)
if files:
path = files[0]
d.url.setText(path)
if path and os.path.exists(path):
with open(path, 'rb') as f:
q = what(f)
is_image = q in {'jpeg', 'png', 'gif', 'webp'}
d.treat_as_image.setChecked(is_image)
if data_dir:
path = os.path.relpath(path, base).replace(os.sep, '/')
d.url.setText(path)
b.clicked.connect(lambda: cf())
d.brdf = b = QPushButton(_('&Data file'))
b.clicked.connect(lambda: cf(True))
b.setToolTip(_('A relative link to a data file associated with this book'))
if not os.path.exists(data_path):
b.setVisible(False)
d.brd = b = QPushButton(_('F&older'))
def cd():
path = choose_dir(d, 'select link folder', _('Choose folder'))
if path:
d.url.setText(path)
b.clicked.connect(cd)
d.la = la = QLabel(_(
'Enter a URL. If you check the "Treat the URL as an image" box '
'then the URL will be added as an image reference instead of as '
'a link. You can also choose to create a link to a file on '
'your computer. '
'Note that if you create a link to a file on your computer, it '
'will stop working if the file is moved.'))
la.setWordWrap(True)
la.setStyleSheet('QLabel { margin-bottom: 1.5ex }')
l.setWidget(0, QFormLayout.ItemRole.SpanningRole, la)
l.addRow(_('Enter &URL:'), d.url)
l.addRow(_('Treat the URL as an &image'), d.treat_as_image)
l.addRow(_('Enter &name (optional):'), d.name)
h = QHBoxLayout()
h.addWidget(d.br), h.addWidget(d.brdf), h.addWidget(d.brd)
l.addRow(_('Choose a file on your computer:'), h)
l.addRow(d.bb)
d.bb.accepted.connect(d.accept)
d.bb.rejected.connect(d.reject)
d.resize(d.sizeHint())
link, name, is_image = None, None, False
if d.exec() == QDialog.DialogCode.Accepted:
link, name = str(d.url.text()).strip(), str(d.name.text()).strip()
is_image = d.treat_as_image.isChecked()
return link, name, is_image
def parse_link(self, link):
link = link.strip()
if link and os.path.exists(link):
return QUrl.fromLocalFile(link)
has_schema = re.match(r'^[a-zA-Z]+:', link)
if has_schema is not None:
url = QUrl(link, QUrl.ParsingMode.TolerantMode)
if url.isValid():
return url
else:
if self.base_url:
base = os.path.dirname(self.base_url.toLocalFile())
else:
base = os.getcwd()
candidate = os.path.join(base, link)
if os.path.exists(candidate):
return QUrl.fromLocalFile(link)
if os.path.exists(link):
return QUrl.fromLocalFile(link)
if has_schema is None:
first, _, rest = link.partition('.')
prefix = 'http'
if first == 'ftp':
prefix = 'ftp'
url = QUrl(prefix +'://'+link, QUrl.ParsingMode.TolerantMode)
if url.isValid():
return url
return QUrl(link, QUrl.ParsingMode.TolerantMode)
def sizeHint(self):
return QSize(150, 150)
@property
def html(self):
return fix_html(self.toHtml(), self.toPlainText().strip(), callback=self.get_html_callback)
def get_html_callback(self, root, text):
pass
@html.setter
def html(self, val):
self.setHtml(val)
def set_base_url(self, qurl):
self.base_url = qurl
@pyqtSlot(int, 'QUrl', result='QVariant')
def loadResource(self, rtype, qurl):
path = local_path_for_resource(qurl, base_qurl=self.base_url)
if path:
data = None
try:
with open(make_long_path_useable(path), 'rb') as f:
data = f.read()
except OSError:
if path.rpartition('.')[-1].lower() in {'jpg', 'jpeg', 'gif', 'png', 'bmp', 'webp'}:
data = bytearray.fromhex(
'89504e470d0a1a0a0000000d49484452'
'000000010000000108060000001f15c4'
'890000000a49444154789c6300010000'
'0500010d0a2db40000000049454e44ae'
'426082')
if data is not None:
r = QByteArray(data)
self.document().addResource(rtype, qurl, r)
return r
def set_html(self, val, allow_undo=True):
if not allow_undo or self.readonly:
self.html = val
return
with self.editing_cursor() as c:
c.movePosition(QTextCursor.MoveOperation.Start, QTextCursor.MoveMode.MoveAnchor)
c.movePosition(QTextCursor.MoveOperation.End, QTextCursor.MoveMode.KeepAnchor)
c.removeSelectedText()
c.insertHtml(val)
def text(self):
return self.textCursor().selectedText()
selectedText = text
def setText(self, text):
with self.editing_cursor() as c:
c.insertText(text)
insert = setText
def hasSelectedText(self):
c = self.textCursor()
return c.hasSelection()
def createMimeDataFromSelection(self):
ans = super().createMimeDataFromSelection()
html, txt = ans.html(), ans.text()
html = fix_html(html, txt, remove_comments=False)
# Qt has a bug where copying from the start of a paragraph does not
# include the paragraph definition in the fragment. Try to fix that
# by moving the StartFragment comment to before the paragraph when
# the selection starts at the start of a block
c = self.textCursor()
c2 = QTextCursor(c)
c2.setPosition(c.selectionStart())
if c2.atBlockStart():
html = re.sub(r'(<p.*?>)(<!--StartFragment-->)', r'\2\1', html, count=1)
ans.setHtml(html)
return ans
def remove_image_at(self, cursor_pos):
c = self.textCursor()
c.clearSelection()
c.setPosition(cursor_pos)
fmt = c.charFormat()
if fmt.isImageFormat():
c.deletePreviousChar()
def resize_image_at(self, cursor_pos):
c = self.textCursor()
c.clearSelection()
c.setPosition(cursor_pos)
c.movePosition(QTextCursor.MoveOperation.PreviousCharacter, QTextCursor.MoveMode.KeepAnchor)
fmt = c.charFormat()
if not fmt.isImageFormat():
return
fmt = fmt.toImageFormat()
from calibre.utils.img import image_from_data
img = image_from_data(self.loadResource(QTextDocument.ResourceType.ImageResource, QUrl(fmt.name())))
w, h = int(fmt.width()), int(fmt.height())
d = QDialog(self)
l = QVBoxLayout(d)
la = QLabel(_('Shrink image to fit within:'))
h = QHBoxLayout()
l.addLayout(h)
la = QLabel(_('&Width:'))
h.addWidget(la)
d.width = w = QSpinBox(self)
w.setRange(0, 10000), w.setSuffix(' px')
w.setValue(int(fmt.width()))
h.addWidget(w), la.setBuddy(w)
w.setSpecialValueText(' ')
la = QLabel(_('&Height:'))
h.addWidget(la)
d.height = w = QSpinBox(self)
w.setRange(0, 10000), w.setSuffix(' px')
w.setValue(int(fmt.height()))
h.addWidget(w), la.setBuddy(w)
w.setSpecialValueText(' ')
h.addStretch(10)
bb = QDialogButtonBox(QDialogButtonBox.StandardButton.Ok | QDialogButtonBox.StandardButton.Cancel)
bb.accepted.connect(d.accept), bb.rejected.connect(d.reject)
d.setWindowTitle(_('Enter new size for image'))
l.addWidget(bb)
d.resize(d.sizeHint())
if d.exec() == QDialog.DialogCode.Accepted:
page_width, page_height = (d.width.value() or sys.maxsize), (d.height.value() or sys.maxsize)
w, h = int(img.width()), int(img.height())
resized, nw, nh = fit_image(w, h, page_width, page_height)
if resized:
fmt.setWidth(nw), fmt.setHeight(nh)
else:
f = QTextImageFormat()
f.setName(fmt.name())
fmt = f
c.setCharFormat(fmt)
def align_image_at(self, cursor_pos, alignment):
c = self.textCursor()
c.clearSelection()
c.setPosition(cursor_pos)
fmt = c.charFormat()
if fmt.isImageFormat() and c.currentFrame():
f = self.frame_for_cursor(c)
if f is not None:
ff = f.frameFormat()
ff.setPosition(alignment)
f.setFrameFormat(ff)
self.document().markContentsDirty(cursor_pos-2, 5)
else:
c.deleteChar()
c.insertImage(fmt.toImageFormat(), alignment)
def first_image_replacement_char_position_for(self, image_name):
d = self.document()
c = self.textCursor()
c.setPosition(0)
while True:
c = d.find(OBJECT_REPLACEMENT_CHAR, c, QTextDocument.FindFlag.FindCaseSensitively)
if c.isNull():
break
fmt = c.charFormat()
if fmt.isImageFormat() and fmt.toImageFormat().name() == image_name:
return c.position()
return -1
def frame_for_cursor(self, c):
q = c.position()
for cf in c.currentFrame().childFrames():
a, b = cf.firstPosition(), cf.lastPosition()
a, b = min(a, b), max(a, b)
if a <= q <= b:
return cf
def open_link(self, link: str) -> None:
qurl = QUrl(link, QUrl.ParsingMode.TolerantMode)
if qurl.isRelative() and self.base_url:
qurl = QUrl.fromLocalFile(os.path.join(os.path.dirname(self.base_url.toLocalFile()), qurl.path()))
safe_open_url(qurl)
def contextMenuEvent(self, ev):
menu = QMenu(self)
img_name = self.document().documentLayout().imageAt(QPointF(ev.pos()))
if img_name:
pos = self.first_image_replacement_char_position_for(img_name)
if pos > -1:
c = self.textCursor()
c.clearSelection()
c.setPosition(pos)
pos = QTextFrameFormat.Position.InFlow
ff = self.frame_for_cursor(c)
if ff is not None:
pos = ff.frameFormat().position()
align_menu = menu.addMenu(QIcon.ic('view-image.png'), _('Image...'))
def a(text, epos):
ac = align_menu.addAction(text)
ac.setCheckable(True)
ac.triggered.connect(partial(self.align_image_at, c.position(), epos))
if pos == epos:
ac.setChecked(True)
cs = align_menu.addAction(QIcon.ic('resize.png'), _('Change size'))
cs.triggered.connect(partial(self.resize_image_at, c.position()))
align_menu.addSeparator()
a(_('Float to the left'), QTextFrameFormat.Position.FloatLeft)
a(_('Inline with text'), QTextFrameFormat.Position.InFlow)
a(_('Float to the right'), QTextFrameFormat.Position.FloatRight)
align_menu.addSeparator()
align_menu.addAction(QIcon.ic('trash.png'), _('Remove this image')).triggered.connect(partial(self.remove_image_at, c.position()))
link_name = self.document().documentLayout().anchorAt(QPointF(ev.pos()))
if link_name:
menu.addAction(QIcon.ic('insert-link.png'), _('Open link'), partial(self.open_link, link_name))
for ac in 'undo redo -- cut copy paste paste_and_match_style -- select_all'.split():
if ac == '--':
menu.addSeparator()
else:
ac = getattr(self, 'action_' + ac)
menu.addAction(ac)
st = self.text()
m = QMenu(_('Fonts'))
m.addAction(self.action_bold), m.addAction(self.action_italic), m.addAction(self.action_underline)
menu.addMenu(m)
if st and st.strip():
self.create_change_case_menu(menu)
parent = self._parent()
if hasattr(parent, 'toolbars_visible'):
vis = parent.toolbars_visible
menu.addAction(_('%s toolbars') % (_('Hide') if vis else _('Show')), parent.toggle_toolbars)
menu.addSeparator()
am = QMenu(_('Advanced'))
menu.addMenu(am)
am.addAction(self.action_block_style)
am.addAction(self.action_insert_link)
if self.insert_images_separately:
am.addAction(self.action_insert_image)
am.addAction(self.action_background)
am.addAction(self.action_color)
menu.addAction(_('Smarten punctuation'), parent.smarten_punctuation)
menu.exec(ev.globalPos())
# }}}
# Highlighter {{{
State_Text = -1
State_DocType = 0
State_Comment = 1
State_TagStart = 2
State_TagName = 3
State_InsideTag = 4
State_AttributeName = 5
State_SingleQuote = 6
State_DoubleQuote = 7
State_AttributeValue = 8
class Highlighter(QSyntaxHighlighter):
def __init__(self, doc):
QSyntaxHighlighter.__init__(self, doc)
self.colors = {}
self.colors['doctype'] = QColor(192, 192, 192)
self.colors['entity'] = QColor(128, 128, 128)
self.colors['comment'] = QColor(35, 110, 37)
if is_dark_theme():
from calibre.gui2.palette import dark_link_color
self.colors['tag'] = QColor(186, 78, 188)
self.colors['attrname'] = QColor(193, 119, 60)
self.colors['attrval'] = dark_link_color
else:
self.colors['tag'] = QColor(136, 18, 128)
self.colors['attrname'] = QColor(153, 69, 0)
self.colors['attrval'] = QColor(36, 36, 170)
def highlightBlock(self, text):
state = self.previousBlockState()
len_ = len(text)
start = 0
pos = 0
while pos < len_:
if state == State_Comment:
start = pos
while pos < len_:
if text[pos:pos+3] == "-->":
pos += 3
state = State_Text
break
else:
pos += 1
self.setFormat(start, pos - start, self.colors['comment'])
elif state == State_DocType:
start = pos
while pos < len_:
ch = text[pos]
pos += 1
if ch == '>':
state = State_Text
break
self.setFormat(start, pos - start, self.colors['doctype'])
# at '<' in e.g. "<span>foo</span>"
elif state == State_TagStart:
start = pos + 1
while pos < len_:
ch = text[pos]
pos += 1
if ch == '>':
state = State_Text
break
if not ch.isspace():
pos -= 1
state = State_TagName
break
# at 'b' in e.g "<blockquote>foo</blockquote>"
elif state == State_TagName:
start = pos
while pos < len_:
ch = text[pos]
pos += 1
if ch.isspace():
pos -= 1
state = State_InsideTag
break
if ch == '>':
state = State_Text
break
self.setFormat(start, pos - start, self.colors['tag'])
# anywhere after tag name and before tag closing ('>')
elif state == State_InsideTag:
start = pos
while pos < len_:
ch = text[pos]
pos += 1
if ch == '/':
continue
if ch == '>':
state = State_Text
self.setFormat(pos-1, 1, self.colors['tag'])
break
if not ch.isspace():
pos -= 1
state = State_AttributeName
break
# at 's' in e.g. <img src=bla.png/>
elif state == State_AttributeName:
start = pos
while pos < len_:
ch = text[pos]
pos += 1
if ch == '=':
state = State_AttributeValue
break
if ch in ('>', '/'):
state = State_InsideTag
break
self.setFormat(start, pos - start, self.colors['attrname'])
# after '=' in e.g. <img src=bla.png/>
elif state == State_AttributeValue:
start = pos
# find first non-space character
while pos < len_:
ch = text[pos]
pos += 1
# handle opening single quote
if ch == "'":
state = State_SingleQuote
self.setFormat(pos - 1, 1, self.colors['attrval'])
break
# handle opening double quote
if ch == '"':
state = State_DoubleQuote
self.setFormat(pos - 1, 1, self.colors['attrval'])
break
if not ch.isspace():
break
if state == State_AttributeValue:
# attribute value without quote
# just stop at non-space or tag delimiter
start = pos
while pos < len_:
ch = text[pos]
if ch.isspace():
break
if ch in ('>', '/'):
break
pos += 1
state = State_InsideTag
self.setFormat(start, pos - start, self.colors['attrval'])
# after the opening single quote in an attribute value
elif state == State_SingleQuote:
start = pos
while pos < len_:
ch = text[pos]
pos += 1
if ch == "'":
break
state = State_InsideTag
self.setFormat(start, pos - start, self.colors['attrval'])
# after the opening double quote in an attribute value
elif state == State_DoubleQuote:
start = pos
while pos < len_:
ch = text[pos]
pos += 1
if ch == '"':
break
state = State_InsideTag
self.setFormat(start, pos - start, self.colors['attrval'])
else:
# State_Text and default
while pos < len_:
ch = text[pos]
if ch == '<':
if text[pos:pos+4] == "<!--":
state = State_Comment
else:
if text[pos:pos+9].upper() == "<!DOCTYPE":
state = State_DocType
else:
state = State_TagStart
break
elif ch == '&':
start = pos
while pos < len_ and text[pos] != ';':
self.setFormat(start, pos - start,
self.colors['entity'])
pos += 1
else:
pos += 1
self.setCurrentBlockState(state)
# }}}
class Editor(QWidget): # {{{
toolbar_prefs_name = None
data_changed = pyqtSignal()
editor_class = EditorWidget
def __init__(self, parent=None, one_line_toolbar=False, toolbar_prefs_name=None):
QWidget.__init__(self, parent)
self.toolbar_prefs_name = toolbar_prefs_name or self.toolbar_prefs_name
self.toolbar = create_flow_toolbar(self, restrict_to_single_line=one_line_toolbar, icon_size=18)
self.editor = self.editor_class(self)
self.editor.data_changed.connect(self.data_changed)
self.set_base_url = self.editor.set_base_url
self.set_html = self.editor.set_html
self.tabs = QTabWidget(self)
self.tabs.setTabPosition(QTabWidget.TabPosition.South)
self.wyswyg = QWidget(self.tabs)
self.code_edit = QPlainTextEdit(self.tabs)
self.code_edit.setTabChangesFocus(True)
self.source_dirty = False
self.wyswyg_dirty = True
self._layout = QVBoxLayout(self)
self.wyswyg.layout = l = QVBoxLayout(self.wyswyg)
self.setLayout(self._layout)
l.setContentsMargins(0, 0, 0, 0)
l.addWidget(self.toolbar)
l.addWidget(self.editor)
self._layout.addWidget(self.tabs)
self.tabs.addTab(self.wyswyg, _('&Normal view'))
self.tabs.addTab(self.code_edit, _('&HTML source'))
self.tabs.currentChanged[int].connect(self.change_tab)
self.highlighter = Highlighter(self.code_edit.document())
self.layout().setContentsMargins(0, 0, 0, 0)
if self.toolbar_prefs_name is not None:
hidden = gprefs.get(self.toolbar_prefs_name)
if hidden:
self.hide_toolbars()
self.toolbar.add_action(self.editor.action_undo)
self.toolbar.add_action(self.editor.action_redo)
self.toolbar.add_action(self.editor.action_select_all)
self.toolbar.add_action(self.editor.action_remove_format)
self.toolbar.add_action(self.editor.action_clear)
self.toolbar.add_separator()
for x in ('copy', 'cut', 'paste'):
ac = getattr(self.editor, 'action_'+x)
self.toolbar.add_action(ac)
self.toolbar.add_separator()
self.toolbar.add_action(self.editor.action_background)
self.toolbar.add_action(self.editor.action_color)
self.toolbar.add_separator()
for x in ('', 'un'):
ac = getattr(self.editor, 'action_%sordered_list'%x)
self.toolbar.add_action(ac)
self.toolbar.add_separator()
for x in ('superscript', 'subscript', 'indent', 'outdent'):
self.toolbar.add_action(getattr(self.editor, 'action_' + x))
if x in ('subscript', 'outdent'):
self.toolbar.add_separator()
self.toolbar.add_action(self.editor.action_block_style, popup_mode=QToolButton.ToolButtonPopupMode.InstantPopup)
self.toolbar.add_action(self.editor.action_insert_link)
if self.editor.insert_images_separately:
self.toolbar.add_action(self.editor.action_insert_image)
self.toolbar.add_action(self.editor.action_insert_hr)
self.toolbar.add_separator()
for x in ('bold', 'italic', 'underline', 'strikethrough'):
ac = getattr(self.editor, 'action_'+x)
self.toolbar.add_action(ac)
self.addAction(ac)
self.toolbar.add_separator()
for x in ('left', 'center', 'right', 'justified'):
ac = getattr(self.editor, 'action_align_'+x)
self.toolbar.add_action(ac)
self.toolbar.add_separator()
QTimer.singleShot(0, self.toolbar.updateGeometry)
self.code_edit.textChanged.connect(self.code_dirtied)
self.editor.data_changed.connect(self.wyswyg_dirtied)
def set_minimum_height_for_editor(self, val):
self.editor.setMinimumHeight(val)
@property
def html(self):
self.tabs.setCurrentIndex(0)
return self.editor.html
@html.setter
def html(self, v):
self.editor.html = v
def change_tab(self, index):
# print 'reloading:', (index and self.wyswyg_dirty) or (not index and
# self.source_dirty)
if index == 1: # changing to code view
if self.wyswyg_dirty:
self.code_edit.setPlainText(self.editor.html)
self.wyswyg_dirty = False
elif index == 0: # changing to wyswyg
if self.source_dirty:
self.editor.html = to_plain_text(self.code_edit)
self.source_dirty = False
@property
def tab(self):
return 'code' if self.tabs.currentWidget() is self.code_edit else 'wyswyg'
@tab.setter
def tab(self, val):
self.tabs.setCurrentWidget(self.code_edit if val == 'code' else self.wyswyg)
def wyswyg_dirtied(self, *args):
self.wyswyg_dirty = True
def code_dirtied(self, *args):
self.source_dirty = True
def hide_toolbars(self):
self.toolbar.setVisible(False)
def show_toolbars(self):
self.toolbar.setVisible(True)
QTimer.singleShot(0, self.toolbar.updateGeometry)
def toggle_toolbars(self):
visible = self.toolbars_visible
getattr(self, ('hide' if visible else 'show') + '_toolbars')()
if self.toolbar_prefs_name is not None:
gprefs.set(self.toolbar_prefs_name, visible)
@property
def toolbars_visible(self):
return self.toolbar.isVisible()
@toolbars_visible.setter
def toolbars_visible(self, val):
getattr(self, ('show' if val else 'hide') + '_toolbars')()
def set_readonly(self, what):
self.editor.set_readonly(what)
def hide_tabs(self):
self.tabs.tabBar().setVisible(False)
def smarten_punctuation(self):
from calibre.ebooks.conversion.preprocess import smarten_punctuation
html = self.html
newhtml = smarten_punctuation(html)
if html != newhtml:
self.html = newhtml
# }}}
if __name__ == '__main__':
from calibre.gui2 import Application
app = Application([])
w = Editor(one_line_toolbar=False)
w.set_base_url(QUrl.fromLocalFile(os.getcwd()))
w.resize(800, 600)
w.setWindowFlag(Qt.WindowType.Dialog)
w.show()
w.html = '''<h1>Test Heading</h1><blockquote>Test blockquote</blockquote><p><span style="background-color: rgb(0, 255, 255); ">He hadn't
set <u>out</u> to have an <em>affair</em>, <span style="font-style:italic; background-color:red">
much</span> less a <s>long-term</s>, <b>devoted</b> one.</span><p>hello'''
w.html = '<div><p id="moo" align="justify">Testing <em>a</em> link.</p><p align="justify">\xa0</p><p align="justify">ss</p></div>'
i = 'file:///home/kovid/work/calibre/resources/images/'
w.html = f'<p>Testing <img src="{i}/donate.png"> img and another <img src="{i}/lt.png">file</p>'
app.exec()
# print w.html
| 60,348 | Python | .py | 1,402 | 31.509272 | 157 | 0.566412 | kovidgoyal/calibre | 19,243 | 2,250 | 4 | GPL-3.0 | 9/5/2024, 5:13:50 PM (Europe/Amsterdam) |
26,654 | linux_file_dialogs.py | kovidgoyal_calibre/src/calibre/gui2/linux_file_dialogs.py | #!/usr/bin/env python
# License: GPLv3 Copyright: 2017, Kovid Goyal <kovid at kovidgoyal.net>
import functools
import os
import subprocess
import sys
import time
from threading import Thread
from qt.core import QEventLoop
from calibre import force_unicode
from calibre.constants import DEBUG, filesystem_encoding, preferred_encoding
from calibre.utils.config import dynamic
from polyglot.builtins import reraise, string_or_bytes
def dialog_name(name, title):
return name or 'dialog_' + title
def get_winid(widget=None):
if widget is not None:
return widget.effectiveWinId()
def to_known_dialog_provider_name(q: str) -> str:
uq = q.upper()
if uq in ('KDE', 'LXQT', 'LXDE'):
return 'KDE'
if uq in ('GNOME', 'GNOME-FLASHBACK', 'GNOME-FLASHBACK:GNOME', 'MATE', 'XFCE'):
return 'GNOME'
return ''
def detect_desktop_environment():
de = os.getenv('XDG_CURRENT_DESKTOP')
if de:
for x in de.split(':'):
q = to_known_dialog_provider_name(x)
if q:
return q
if os.getenv('KDE_FULL_SESSION') == 'true':
return 'KDE'
if os.getenv('GNOME_DESKTOP_SESSION_ID'):
return 'GNOME'
ds = os.getenv('DESKTOP_SESSION')
if ds and ds.upper() in {'GNOME', 'XFCE'}:
return 'GNOME'
return ''
def is_executable_present(name):
PATH = os.getenv('PATH') or ''
for path in PATH.split(os.pathsep):
if os.access(os.path.join(path, name), os.X_OK):
return True
return False
def process_path(x):
if isinstance(x, bytes):
x = x.decode(filesystem_encoding)
return os.path.abspath(os.path.expanduser(x))
def ensure_dir(path, default='~'):
while path and path != '/' and not os.path.isdir(path):
path = os.path.dirname(path)
if path == '/':
path = os.path.expanduser(default)
return path or os.path.expanduser(default)
def get_initial_dir(name, title, default_dir, no_save_dir):
if no_save_dir:
return ensure_dir(process_path(default_dir))
key = dialog_name(name, title)
saved = dynamic.get(key)
if not isinstance(saved, string_or_bytes):
saved = None
if saved and os.path.isdir(saved):
return ensure_dir(process_path(saved))
return ensure_dir(process_path(default_dir))
def save_initial_dir(name, title, ans, no_save_dir, is_file=False):
if ans and not no_save_dir:
if is_file:
ans = os.path.dirname(os.path.abspath(ans))
key = dialog_name(name, title)
dynamic.set(key, ans)
def encode_arg(title):
if isinstance(title, str):
try:
title = title.encode(preferred_encoding)
except UnicodeEncodeError:
title = title.encode('utf-8')
return title
def image_extensions():
from calibre.gui2.dnd import image_extensions
return image_extensions()
def decode_output(raw):
raw = raw or b''
try:
return raw.decode(preferred_encoding)
except UnicodeDecodeError:
return force_unicode(raw, 'utf-8')
def run(cmd):
from calibre.gui2 import sanitize_env_vars
if DEBUG:
try:
print(cmd)
except Exception:
pass
with sanitize_env_vars():
p = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
stdout, stderr = p.communicate()
ret = p.wait()
return ret, decode_output(stdout), decode_output(stderr)
# KDE {{{
def kdialog_supports_desktopfile():
ans = getattr(kdialog_supports_desktopfile, 'ans', None)
if ans is None:
from calibre.gui2 import sanitize_env_vars
try:
with sanitize_env_vars():
raw = subprocess.check_output(['kdialog', '--help'])
except (subprocess.CalledProcessError, FileNotFoundError, OSError):
raw = b'--desktopfile'
ans = kdialog_supports_desktopfile.ans = b'--desktopfile' in raw
return ans
def kde_cmd(window, title, *rest):
ans = ['kdialog', '--title', title]
if kdialog_supports_desktopfile():
ans += ['--desktopfile', 'calibre-gui']
winid = get_winid(window)
if winid is not None:
ans += ['--attach', str(int(winid))]
return ans + list(rest)
def run_kde(cmd):
ret, stdout, stderr = run(cmd)
if ret == 1:
return # canceled
if ret != 0:
raise ValueError(f'KDE file dialog aborted with return code: {ret} and stderr: {stderr}')
ans = stdout.splitlines()
return ans
def kdialog_choose_dir(window, name, title, default_dir='~', no_save_dir=False):
initial_dir = get_initial_dir(name, title, default_dir, no_save_dir)
ans = run_kde(kde_cmd(window, title, '--getexistingdirectory', initial_dir))
ans = None if ans is None else ans[0]
save_initial_dir(name, title, ans, no_save_dir)
return ans
def kdialog_filters(filters, all_files=True):
ans = []
for name, exts in filters:
if not exts or (len(exts) == 1 and exts[0] == '*'):
ans.append(name + ' (*)')
else:
ans.append('{} ({})'.format(name, ' '.join('*.' + x for x in exts)))
if all_files:
ans.append(_('All files') + ' (*)')
return '\n'.join(ans)
def kdialog_choose_files(
window,
name,
title,
filters=[],
all_files=True,
select_only_single_file=False,
default_dir='~',
no_save_dir=False,
):
initial_dir = get_initial_dir(name, title, default_dir, no_save_dir)
args = []
if not select_only_single_file:
args += '--multiple --separate-output'.split()
args += ['--getopenfilename', initial_dir, kdialog_filters(filters, all_files)]
ans = run_kde(kde_cmd(window, title, *args))
if not no_save_dir:
save_initial_dir(name, title, ans[0] if ans else None, False, is_file=True)
return ans
def kdialog_choose_save_file(window, name, title, filters=[], all_files=True, initial_path=None, initial_filename=None):
if initial_path is not None:
initial_dir = initial_path
else:
initial_dir = get_initial_dir(name, title, '~', False)
if initial_filename:
initial_dir = os.path.join(initial_dir, initial_filename)
args = ['--getsavefilename', initial_dir, kdialog_filters(filters, all_files)]
ans = run_kde(kde_cmd(window, title, *args))
ans = None if ans is None else ans[0]
if initial_path is None:
save_initial_dir(name, title, ans, False, is_file=True)
return ans
def kdialog_choose_images(window, name, title, select_only_single_file=True, formats=None):
return kdialog_choose_files(
window, name, title, select_only_single_file=select_only_single_file, all_files=False,
filters=[(_('Images'), list(formats or image_extensions()))])
# }}}
# GTK {{{
def zenity_cmd(window, title, *rest):
ans = ['zenity', '--modal', '--file-selection', '--title=' + title, '--separator=\n']
winid = get_winid(window)
if winid is not None:
ans += ['--attach=%d' % int(winid)]
return ans + list(rest)
def run_zenity(cmd):
ret, stdout, stderr = run(cmd)
if ret == 1:
return # canceled
if ret != 0:
raise ValueError(f'GTK file dialog aborted with return code: {ret} and stderr: {stderr}')
ans = stdout.splitlines()
return ans
def zenity_choose_dir(window, name, title, default_dir='~', no_save_dir=False):
initial_dir = get_initial_dir(name, title, default_dir, no_save_dir)
ans = run_zenity(zenity_cmd(window, title, '--directory', '--filename', initial_dir))
ans = None if ans is None else ans[0]
save_initial_dir(name, title, ans, no_save_dir)
return ans
def zenity_filters(filters, all_files=True):
ans = []
for name, exts in filters:
if not exts or (len(exts) == 1 and exts[0] == '*'):
ans.append('--file-filter={} | {}'.format(name, '*'))
else:
ans.append('--file-filter={} | {}'.format(name, ' '.join('*.' + x for x in exts)))
if all_files:
ans.append('--file-filter={} | {}'.format(_('All files'), '*'))
return ans
def zenity_choose_files(
window,
name,
title,
filters=[],
all_files=True,
select_only_single_file=False,
default_dir='~',
no_save_dir=False,
):
initial_dir = get_initial_dir(name, title, default_dir, no_save_dir)
args = ['--filename=' + os.path.join(initial_dir, '.fgdfg.gdfhjdhf*&^839')]
args += zenity_filters(filters, all_files)
if not select_only_single_file:
args.append('--multiple')
ans = run_zenity(zenity_cmd(window, title, *args))
if not no_save_dir:
save_initial_dir(name, title, ans[0] if ans else None, False, is_file=True)
return ans
def zenity_choose_save_file(window, name, title, filters=[], all_files=True, initial_path=None, initial_filename=None):
if initial_path is not None:
initial_dir = initial_path
else:
initial_dir = get_initial_dir(name, title, '~', False)
initial_dir = os.path.join(initial_dir, initial_filename or _('File name'))
args = ['--filename=' + initial_dir, '--confirm-overwrite', '--save']
args += zenity_filters(filters, all_files)
ans = run_zenity(zenity_cmd(window, title, *args))
ans = None if ans is None else ans[0]
if initial_path is None:
save_initial_dir(name, title, ans, False, is_file=True)
return ans
def zenity_choose_images(window, name, title, select_only_single_file=True, formats=None):
return zenity_choose_files(
window, name, title, select_only_single_file=select_only_single_file, all_files=False,
filters=[(_('Images'), list(formats or image_extensions()))])
# }}}
def linux_native_dialog(name):
prefix = check_for_linux_native_dialogs()
func = globals()[f'{prefix}_choose_{name}']
@functools.wraps(func)
def looped(window, *args, **kwargs):
if hasattr(linux_native_dialog, 'native_failed'):
import importlib
m = importlib.import_module('calibre.gui2.qt_file_dialogs')
qfunc = getattr(m, 'choose_' + name)
return qfunc(window, *args, **kwargs)
try:
if window is None:
return func(window, *args, **kwargs)
ret = [None, None]
loop = QEventLoop(window)
def r():
try:
ret[0] = func(window, *args, **kwargs)
except:
ret[1] = sys.exc_info()
while not loop.isRunning():
time.sleep(0.001) # yield so that loop starts
loop.quit()
t = Thread(name='FileDialogHelper', target=r)
t.daemon = True
t.start()
loop.exec(QEventLoop.ProcessEventsFlag.ExcludeUserInputEvents)
if ret[1] is not None:
reraise(*ret[1])
return ret[0]
except Exception:
linux_native_dialog.native_failed = True
import traceback
traceback.print_exc()
return looped(window, *args, **kwargs)
return looped
def check_for_linux_native_dialogs():
ans = getattr(check_for_linux_native_dialogs, 'ans', None)
if ans is None:
de = detect_desktop_environment()
order = ('zenity', 'kdialog')
if de == 'GNOME':
order = ('zenity',)
elif de == 'KDE':
order = ('kdialog',)
for exe in order:
if is_executable_present(exe):
ans = exe
break
else:
ans = False
check_for_linux_native_dialogs.ans = ans
return ans
if __name__ == '__main__':
# print(repr(kdialog_choose_dir(None, 'testkddcd', 'Testing choose dir...')))
print(repr(kdialog_choose_files(None, 'testkddcf', 'Testing choose files...', select_only_single_file=False, filters=[
('moo', 'epub png'.split()), ('boo', 'docx'.split())], all_files=True)))
# print(repr(kdialog_choose_images(None, 'testkddci', 'Testing choose images...')))
# print(repr(kdialog_choose_save_file(None, 'testkddcs', 'Testing choose save file...', initial_filename='moo.x')))
# print(repr(zenity_choose_dir(None, 'testzcd', 'Testing choose dir...')))
# print(repr(zenity_choose_files(
# None, 'testzcf', 'Testing choose files...', select_only_single_file=False,
# filters=[('moo', 'epub png'.split()), ('boo', 'docx'.split())], all_files=True)))
# print(repr(kdialog_choose_images(None, 'testzi', 'Testing choose images...')))
# print(repr(zenity_choose_save_file(None, 'testzcs', 'Testing choose save file...', filters=[('x', 'epub'.split())])))
| 12,670 | Python | .py | 314 | 33.420382 | 123 | 0.624613 | kovidgoyal/calibre | 19,243 | 2,250 | 4 | GPL-3.0 | 9/5/2024, 5:13:50 PM (Europe/Amsterdam) |
26,655 | add.py | kovidgoyal_calibre/src/calibre/gui2/add.py | #!/usr/bin/env python
__license__ = 'GPL v3'
__copyright__ = '2014, Kovid Goyal <kovid at kovidgoyal.net>'
import os
import shutil
import sys
import tempfile
import time
import traceback
import weakref
from collections import OrderedDict
from io import BytesIO
from threading import Thread
from qt.core import QObject, Qt, pyqtSignal
from calibre import as_unicode, prints
from calibre.constants import DEBUG, filesystem_encoding, ismacos, iswindows
from calibre.customize.ui import run_plugins_on_postadd, run_plugins_on_postimport
from calibre.db.adding import compile_rule, find_books_in_directory
from calibre.db.utils import find_identical_books
from calibre.ebooks.metadata import authors_to_sort_string
from calibre.ebooks.metadata.book.base import Metadata
from calibre.ebooks.metadata.opf2 import OPF
from calibre.gui2 import error_dialog, gprefs, warning_dialog
from calibre.gui2.dialogs.duplicates import DuplicatesQuestion
from calibre.gui2.dialogs.progress import ProgressDialog
from calibre.ptempfile import PersistentTemporaryDirectory
from calibre.utils import join_with_timeout
from calibre.utils.config import prefs
from calibre.utils.filenames import make_long_path_useable
from calibre.utils.icu import lower as icu_lower
from calibre.utils.ipc.pool import Failure, Pool
from calibre.utils.localization import ngettext
from polyglot.builtins import iteritems, string_or_bytes
from polyglot.queue import Empty
def validate_source(source, parent=None): # {{{
if isinstance(source, string_or_bytes):
if not os.path.exists(source):
error_dialog(parent, _('Cannot add books'), _(
'The path %s does not exist') % source, show=True)
return False
if not os.access(source, os.X_OK|os.R_OK):
error_dialog(parent, _('Cannot add books'), _(
'You do not have permission to read %s') % source, show=True)
return False
else:
ok = False
for path in source:
if os.access(path, os.R_OK):
ok = True
break
if not ok:
error_dialog(parent, _('Cannot add books'), _(
'You do not have permission to read any of the selected files'),
det_msg='\n'.join(source), show=True)
return False
return True
# }}}
def resolve_windows_links(paths, hwnd=None):
from calibre_extensions.winutil import resolve_lnk
for x in paths:
if x.lower().endswith('.lnk'):
try:
if hwnd is None:
x = resolve_lnk(x)
else:
x = resolve_lnk(x, 0, hwnd)
except Exception as e:
print('Failed to resolve link', x, 'with error:', e, file=sys.stderr)
continue
yield x
class Adder(QObject):
do_one_signal = pyqtSignal()
def __init__(self, source, single_book_per_directory=True, db=None, parent=None, callback=None, pool=None, list_of_archives=False):
if isinstance(source, str):
source = make_long_path_useable(source)
else:
source = list(map(make_long_path_useable, source))
if not validate_source(source, parent):
return
QObject.__init__(self, parent)
self.author_map_rules = None
if gprefs.get('author_map_on_add_rules'):
from calibre.ebooks.metadata.author_mapper import compile_rules as acr
self.author_map_rules = acr(gprefs['author_map_on_add_rules'])
self.single_book_per_directory = single_book_per_directory
self.ignore_opf = False
self.list_of_archives = list_of_archives
self.callback = callback
self.add_formats_to_existing = prefs['add_formats_to_existing']
self.do_one_signal.connect(self.tick, type=Qt.ConnectionType.QueuedConnection)
self.pool = pool
self.pd = ProgressDialog(_('Adding books...'), _('Scanning for files...'), min=0, max=0, parent=parent, icon='add_book.png')
self.win_id = None
if parent is not None and hasattr(parent, 'effectiveWinId'):
self.win_id = parent.effectiveWinId()
if self.win_id is not None:
self.win_id = int(self.win_id)
self.db = getattr(db, 'new_api', None)
if self.db is not None:
self.dbref = weakref.ref(db)
self.source = source
self.tdir = PersistentTemporaryDirectory('_add_books')
self.scan_error = None
self.file_groups = OrderedDict()
self.abort_scan = False
self.duplicates = []
self.report = []
self.items = []
self.added_book_ids = set()
self.merged_formats_added_to = set()
self.merged_books = set()
self.added_duplicate_info = set()
self.pd.show()
self.scan_thread = Thread(target=self.scan, name='ScanBooks')
self.scan_thread.daemon = True
self.scan_thread.start()
self.do_one = self.monitor_scan
self.do_one_signal.emit()
if DEBUG:
self.start_time = time.time()
def break_cycles(self):
self.abort_scan = True
self.pd.close()
self.pd.deleteLater()
if self.pool is not None:
self.pool.shutdown()
if not self.items:
shutil.rmtree(self.tdir, ignore_errors=True)
self.setParent(None)
self.find_identical_books_data = self.merged_books = self.added_duplicate_info = self.pool = self.items = self.duplicates = self.pd = self.db = self.dbref = self.tdir = self.file_groups = self.scan_thread = None # noqa
self.deleteLater()
def tick(self):
if self.pd.canceled:
try:
if callable(self.callback):
self.callback(self)
finally:
self.break_cycles()
return
self.do_one()
# Filesystem scan {{{
def scan(self):
try:
compiled_rules = tuple(map(compile_rule, gprefs.get('add_filter_rules', ())))
except Exception:
compiled_rules = ()
import traceback
traceback.print_exc()
if iswindows or ismacos:
def find_files(root):
for dirpath, dirnames, filenames in os.walk(root):
for files in find_books_in_directory(dirpath, self.single_book_per_directory, compiled_rules=compiled_rules):
if self.abort_scan:
return
if iswindows:
files = list(resolve_windows_links(files, hwnd=self.win_id))
if files:
self.file_groups[len(self.file_groups)] = files
else:
def find_files(root):
if isinstance(root, str):
root = root.encode(filesystem_encoding)
for dirpath, dirnames, filenames in os.walk(root):
try:
dirpath = dirpath.decode(filesystem_encoding)
except UnicodeDecodeError:
prints('Ignoring non-decodable directory:', dirpath)
continue
for files in find_books_in_directory(dirpath, self.single_book_per_directory, compiled_rules=compiled_rules):
if self.abort_scan:
return
self.file_groups[len(self.file_groups)] = files
def extract(source):
tdir = tempfile.mkdtemp(suffix='_archive', dir=self.tdir)
if source.lower().endswith('.zip'):
from calibre.utils.zipfile import extractall
try:
extractall(source, tdir)
except Exception:
prints('Corrupt ZIP file, trying to use local headers')
from calibre.utils.localunzip import extractall
extractall(source, tdir)
elif source.lower().endswith('.rar'):
from calibre.utils.unrar import extract
extract(source, tdir)
elif source.lower().endswith('.7z'):
from calibre.utils.seven_zip import extract
extract(source, tdir)
return tdir
try:
if isinstance(self.source, string_or_bytes):
find_files(self.source)
self.ignore_opf = True
else:
unreadable_files = []
for path in self.source:
if self.abort_scan:
return
if os.access(path, os.R_OK):
if self.list_of_archives:
find_files(extract(path))
self.ignore_opf = True
else:
x = [path]
if iswindows:
x = list(resolve_windows_links(x, hwnd=self.win_id))
if x:
self.file_groups[len(self.file_groups)] = x
else:
unreadable_files.append(path)
else:
unreadable_files.append(path)
if unreadable_files:
if not self.file_groups:
m = ngettext('You do not have permission to read the selected file.',
'You do not have permission to read the selected files.', len(unreadable_files))
self.scan_error = m + '\n' + '\n'.join(unreadable_files)
else:
a = self.report.append
for f in unreadable_files:
a(_('Could not add %s as you do not have permission to read the file' % f))
a('')
except Exception:
self.scan_error = traceback.format_exc()
def monitor_scan(self):
self.scan_thread.join(0.05)
if self.scan_thread.is_alive():
self.do_one_signal.emit()
return
if self.scan_error is not None:
error_dialog(self.pd, _('Cannot add books'), _(
'Failed to add any books, click "Show details" for more information.'),
det_msg=self.scan_error, show=True)
self.break_cycles()
return
if not self.file_groups:
error_dialog(self.pd, _('Could not add'), _(
'No e-book files were found in %s') % self.source, show=True)
self.break_cycles()
return
self.pd.max = len(self.file_groups)
self.pd.title = ngettext(
'Reading metadata and adding to library (one book)...',
'Reading metadata and adding to library ({} books)...',
self.pd.max).format(self.pd.max)
self.pd.msg = ''
self.pd.value = 0
self.pool = Pool(name='AddBooks') if self.pool is None else self.pool
if self.db is not None:
if self.add_formats_to_existing:
self.find_identical_books_data = self.db.data_for_find_identical_books()
else:
try:
self.pool.set_common_data(self.db.data_for_has_book())
except Failure as err:
error_dialog(self.pd, _('Cannot add books'), _(
'Failed to add any books, click "Show details" for more information.'),
det_msg=as_unicode(err.failure_message) + '\n' + as_unicode(err.details), show=True)
self.pd.canceled = True
self.groups_to_add = iter(self.file_groups)
self.do_one = self.do_one_group
self.do_one_signal.emit()
# }}}
def do_one_group(self):
try:
group_id = next(self.groups_to_add)
except StopIteration:
self.do_one = self.monitor_pool
self.do_one_signal.emit()
return
try:
self.pool(group_id, 'calibre.ebooks.metadata.worker', 'read_metadata',
self.file_groups[group_id], group_id, self.tdir)
except Failure as err:
error_dialog(self.pd, _('Cannot add books'), _(
'Failed to add any books, click "Show details" for more information.'),
det_msg=as_unicode(err.failure_message) + '\n' + as_unicode(err.details), show=True)
self.pd.canceled = True
self.do_one_signal.emit()
def monitor_pool(self):
try:
worker_result = self.pool.results.get(True, 0.05)
self.pool.results.task_done()
except Empty:
try:
self.pool.wait_for_tasks(timeout=0.01)
except RuntimeError:
pass # Tasks still remaining
except Failure as err:
error_dialog(self.pd, _('Cannot add books'), _(
'Failed to add some books, click "Show details" for more information.'),
det_msg=str(err.failure_message) + '\n' + str(err.details), show=True)
self.pd.canceled = True
else:
# All tasks completed
try:
join_with_timeout(self.pool.results, 0.01)
except RuntimeError:
pass # There are results remaining
else:
# No results left
self.process_duplicates()
return
else:
group_id = worker_result.id
if worker_result.is_terminal_failure:
error_dialog(self.pd, _('Critical failure'), _(
'The read metadata worker process crashed while processing'
' some files. Adding of books is aborted. Click "Show details"'
' to see which files caused the problem.'), show=True,
det_msg='\n'.join(self.file_groups[group_id]))
self.pd.canceled = True
else:
try:
self.process_result(group_id, worker_result.result)
except Exception:
self.report_metadata_failure(group_id, traceback.format_exc())
self.pd.value += 1
self.do_one_signal.emit()
def report_metadata_failure(self, group_id, details):
a = self.report.append
paths = self.file_groups[group_id]
a(''), a('-' * 70)
m = ngettext('Failed to read metadata from the file:', 'Failed to read metadata from the files:', len(paths))
a(m)
[a('\t' + f) for f in paths]
a(_('With error:')), a(details)
mi = Metadata(_('Unknown'))
mi.read_metadata_failed = False
return mi
def process_result(self, group_id, result):
if result.err:
mi = self.report_metadata_failure(group_id, result.traceback)
paths = self.file_groups[group_id]
has_cover = False
duplicate_info = set() if self.add_formats_to_existing else False
else:
paths, opf, has_cover, duplicate_info = result.value
try:
mi = OPF(BytesIO(opf), basedir=self.tdir, populate_spine=False, try_to_guess_cover=False).to_book_metadata()
mi.read_metadata_failed = False
except Exception:
mi = self.report_metadata_failure(group_id, traceback.format_exc())
if mi.is_null('title'):
for path in paths:
mi.title = os.path.splitext(os.path.basename(path))[0]
break
if mi.application_id == '__calibre_dummy__':
mi.application_id = None
if gprefs.get('tag_map_on_add_rules'):
from calibre.ebooks.metadata.tag_mapper import map_tags
mi.tags = map_tags(mi.tags, gprefs['tag_map_on_add_rules'])
if self.author_map_rules:
from calibre.ebooks.metadata.author_mapper import map_authors
new_authors = map_authors(mi.authors, self.author_map_rules)
if new_authors != mi.authors:
mi.authors = new_authors
if self.db is None:
mi.author_sort = authors_to_sort_string(mi.authors)
else:
mi.author_sort = self.db.author_sort_from_authors(mi.authors)
self.pd.msg = mi.title
cover_path = os.path.join(self.tdir, '%s.cdata' % group_id) if has_cover else None
if self.db is None:
if paths:
self.items.append((mi, cover_path, paths))
return
if self.add_formats_to_existing:
identical_book_ids = find_identical_books(mi, self.find_identical_books_data)
if identical_book_ids:
try:
self.merge_books(mi, cover_path, paths, identical_book_ids)
except Exception:
a = self.report.append
a(''), a('-' * 70)
a(_('Failed to merge the book: ') + mi.title)
[a('\t' + f) for f in paths]
a(_('With error:')), a(traceback.format_exc())
else:
self.add_book(mi, cover_path, paths)
else:
if duplicate_info or icu_lower(mi.title or _('Unknown')) in self.added_duplicate_info:
self.duplicates.append((mi, cover_path, paths))
else:
self.add_book(mi, cover_path, paths)
def merge_books(self, mi, cover_path, paths, identical_book_ids):
self.merged_books.add((mi.title, ' & '.join(mi.authors)))
seen_fmts = set()
replace = gprefs['automerge'] == 'overwrite'
cover_removed = False
for identical_book_id in identical_book_ids:
ib_fmts = {fmt.upper() for fmt in self.db.formats(identical_book_id)}
seen_fmts |= ib_fmts
self.add_formats(identical_book_id, paths, mi, replace=replace)
self.merged_formats_added_to.add(identical_book_id)
if gprefs['automerge'] == 'new record':
incoming_fmts = {path.rpartition(os.extsep)[-1].upper() for path in paths}
if incoming_fmts.intersection(seen_fmts):
# There was at least one duplicate format so create a new
# record and put the incoming formats into it We should
# arguably put only the duplicate formats, but no real harm is
# done by having all formats
self.add_book(mi, cover_path, paths)
cover_removed = True
if not cover_removed and cover_path:
try:
os.remove(cover_path)
except Exception:
pass
def add_book(self, mi, cover_path, paths):
if DEBUG:
st = time.time()
try:
cdata = None
if cover_path:
with open(cover_path, 'rb') as f:
cdata = f.read()
try:
os.remove(cover_path)
except Exception:
pass
book_id = self.dbref().create_book_entry(mi, cover=cdata)
self.added_book_ids.add(book_id)
except Exception:
a = self.report.append
a(''), a('-' * 70)
a(_('Failed to add the book: ') + mi.title)
[a('\t' + f) for f in paths]
a(_('With error:')), a(traceback.format_exc())
return
self.add_formats(book_id, paths, mi, is_an_add=True)
try:
if self.add_formats_to_existing:
self.db.update_data_for_find_identical_books(book_id, self.find_identical_books_data)
else:
self.added_duplicate_info.add(icu_lower(mi.title or _('Unknown')))
except Exception:
# Ignore this exception since all it means is that duplicate
# detection/automerge will fail for this book.
traceback.print_exc()
if DEBUG:
prints('Added', mi.title, 'to db in: %.1f' % (time.time() - st))
def add_formats(self, book_id, paths, mi, replace=True, is_an_add=False):
fmap = {p.rpartition(os.path.extsep)[-1].lower():p for p in paths}
fmt_map = {}
for fmt, path in iteritems(fmap):
# The onimport plugins have already been run by the read metadata
# worker
if self.ignore_opf and fmt.lower() == 'opf':
continue
try:
if self.db.add_format(book_id, fmt, path, run_hooks=False, replace=replace):
run_plugins_on_postimport(self.dbref(), book_id, fmt)
fmt_map[fmt.lower()] = path
except Exception:
a = self.report.append
a(''), a('-' * 70)
a(_('Failed to add the file {0} to the book: {1}').format(path, mi.title))
a(_('With error:')), a(traceback.format_exc())
if is_an_add:
run_plugins_on_postadd(self.dbref(), book_id, fmt_map)
def process_duplicates(self):
if self.duplicates:
d = DuplicatesQuestion(self.dbref(), self.duplicates, self.pd)
duplicates = tuple(d.duplicates)
d.deleteLater()
if duplicates:
self.do_one = self.process_duplicate
self.duplicates_to_process = iter(duplicates)
self.pd.title = _('Adding duplicates')
self.pd.msg = ''
self.pd.max, self.pd.value = len(duplicates), 0
self.do_one_signal.emit()
return
self.finish()
def process_duplicate(self):
try:
mi, cover_path, paths = next(self.duplicates_to_process)
except StopIteration:
self.finish()
return
self.pd.value += 1
self.pd.msg = mi.title
self.add_book(mi, cover_path, paths)
self.do_one_signal.emit()
def finish(self):
if DEBUG:
prints(f'Added {len(self.added_book_ids or self.items)} books in {time.time() - self.start_time:.1f} seconds')
if self.report:
added_some = self.items or self.added_book_ids
d = warning_dialog if added_some else error_dialog
msg = _('There were problems adding some files, click "Show details" for more information') if added_some else _(
'Failed to add any books, click "Show details" for more information')
d(self.pd, _('Errors while adding'), msg, det_msg='\n'.join(self.report), show=True)
potentially_convertible = self.added_book_ids | self.merged_formats_added_to
if gprefs['manual_add_auto_convert'] and potentially_convertible and self.parent() is not None:
self.parent().iactions['Convert Books'].auto_convert_auto_add(potentially_convertible)
try:
if callable(self.callback):
self.callback(self)
finally:
self.break_cycles()
@property
def number_of_books_added(self):
return len(self.added_book_ids)
| 23,267 | Python | .py | 505 | 32.958416 | 227 | 0.560079 | kovidgoyal/calibre | 19,243 | 2,250 | 4 | GPL-3.0 | 9/5/2024, 5:13:50 PM (Europe/Amsterdam) |
26,656 | pyqt6_compat.py | kovidgoyal_calibre/src/calibre/gui2/pyqt6_compat.py | #!/usr/bin/env python
# License: GPL v3 Copyright: 2021, Kovid Goyal <kovid at kovidgoyal.net>
# Workaround a bunch of brain dead changes in PyQt6 that break backwards compat
# for no good reason. Since we have a huge body of poorly maintained third
# party plugin code, we NEED backward compat.
from qt.core import (
QAbstractItemView,
QAction,
QComboBox,
QCoreApplication,
QDialog,
QDialogButtonBox,
QDrag,
QDropEvent,
QEvent,
QEventLoop,
QFontMetrics,
QFormLayout,
QFrame,
QHoverEvent,
QImage,
QIODevice,
QLayout,
QLineEdit,
QMenu,
QMessageBox,
QModelIndex,
QPalette,
QSinglePointEvent,
QSizePolicy,
Qt,
QThread,
QToolButton,
)
from calibre_extensions import progress_indicator
# Restore removed functions from QMouseEvent
QSinglePointEvent.x = lambda self: int(self.position().x())
QSinglePointEvent.y = lambda self: int(self.position().y())
QSinglePointEvent.globalPos = lambda self: self.globalPosition().toPoint()
QSinglePointEvent.globalX = lambda self: self.globalPosition().toPoint().x()
QSinglePointEvent.globalY = lambda self: self.globalPosition().toPoint().y()
QSinglePointEvent.localPos = lambda self: self.position()
QSinglePointEvent.screenPos = lambda self: self.globalPosition()
QSinglePointEvent.windowPos = lambda self: self.scenePosition()
QDropEvent.pos = lambda self: self.position().toPoint()
QDropEvent.posF = lambda self: self.position()
QHoverEvent.pos = lambda self: self.position().toPoint()
QHoverEvent.posF = lambda self: self.position()
# Restore the removed exec_ method
def exec_(self, *args, **kwargs):
return self.exec(*args, **kwargs)
QDialog.exec_ = exec_
QMenu.exec_ = exec_
QDrag.exec_ = exec_
QEventLoop.exec_ = exec_
QThread.exec_ = exec_
QMessageBox.exec_ = exec_
QCoreApplication.exec_ = exec_
# Restore ability to associate a menu with an action
def set_menu(self, menu):
self.keep_menu_ref = menu
progress_indicator.set_menu_on_action(self, menu)
QAction.setMenu = set_menu
QAction.menu = lambda self: progress_indicator.menu_for_action(self)
# Restore QModelIndex::child
QModelIndex.child = lambda self, row, column: self.model().index(row, column, self)
# Restore QFontMetrics::width
QFontMetrics.width = lambda self, text: self.horizontalAdvance(text)
# Restore enum values to various classes
for cls in (
Qt, QDialog, QToolButton, QAbstractItemView, QDialogButtonBox, QFrame, QComboBox,
QLineEdit, QAction, QImage, QIODevice, QPalette, QFormLayout, QEvent, QMessageBox,
QSizePolicy, QLayout
):
for var in tuple(vars(cls).values()):
m = getattr(var, '__members__', {})
for k, v in m.items():
if not hasattr(cls, k):
setattr(cls, k, v)
| 2,783 | Python | .py | 79 | 31.721519 | 86 | 0.741623 | kovidgoyal/calibre | 19,243 | 2,250 | 4 | GPL-3.0 | 9/5/2024, 5:13:50 PM (Europe/Amsterdam) |
26,657 | __init__.py | kovidgoyal_calibre/src/calibre/gui2/__init__.py | __license__ = 'GPL v3'
__copyright__ = '2008, Kovid Goyal <kovid at kovidgoyal.net>'
""" The GUI """
import glob
import os
import signal
import sys
import threading
from contextlib import contextmanager, suppress
from functools import lru_cache
from threading import Lock, RLock
from qt.core import (
QApplication,
QBuffer,
QByteArray,
QColor,
QDateTime,
QDesktopServices,
QDialog,
QDialogButtonBox,
QEvent,
QFile,
QFileDialog,
QFileIconProvider,
QFileInfo,
QFont,
QFontDatabase,
QFontInfo,
QFontMetrics,
QGuiApplication,
QIcon,
QImageReader,
QImageWriter,
QIODevice,
QLocale,
QNetworkProxyFactory,
QObject,
QPainterPath,
QPalette,
QRectF,
QResource,
QSettings,
QSocketNotifier,
QStringListModel,
Qt,
QThread,
QTimer,
QTranslator,
QUrl,
QWidget,
pyqtSignal,
pyqtSlot,
)
import calibre.gui2.pyqt6_compat as pqc
from calibre import as_unicode, prints
from calibre.constants import (
DEBUG,
__version__,
builtin_colors_dark,
builtin_colors_light,
config_dir,
is_running_from_develop,
isbsd,
isfrozen,
islinux,
ismacos,
iswindows,
isxp,
numeric_version,
plugins_loc,
)
from calibre.constants import __appname__ as APP_UID
from calibre.ebooks.metadata import MetaInformation
from calibre.gui2.geometry import geometry_for_restore_as_dict
from calibre.gui2.linux_file_dialogs import check_for_linux_native_dialogs, linux_native_dialog
from calibre.gui2.palette import PaletteManager
from calibre.gui2.qt_file_dialogs import FileDialog
from calibre.ptempfile import base_dir
from calibre.utils.config import Config, ConfigProxy, JSONConfig, dynamic
from calibre.utils.config_base import tweaks
from calibre.utils.date import UNDEFINED_DATE
from calibre.utils.file_type_icons import EXT_MAP
from calibre.utils.img import set_image_allocation_limit
from calibre.utils.localization import get_lang
from calibre.utils.resources import get_image_path as I
from calibre.utils.resources import get_path as P
from calibre.utils.resources import user_dir
from polyglot import queue
from polyglot.builtins import iteritems, string_or_bytes
del pqc, geometry_for_restore_as_dict
NO_URL_FORMATTING = QUrl.UrlFormattingOption.None_
BOOK_DETAILS_DISPLAY_DEBOUNCE_DELAY = 100 # 100 ms is threshold for human visual response
class IconResourceManager:
def __init__(self):
self.override_icon_path = None
self.initialized = False
self.dark_theme_name = self.default_dark_theme_name = 'calibre-default-dark'
self.light_theme_name = self.default_light_theme_name = 'calibre-default-light'
self.user_any_theme_name = self.user_dark_theme_name = self.user_light_theme_name = None
self.registered_user_resource_files = ()
self.color_palette = 'light'
self.icon_cache = {}
def user_theme_resource_file(self, which):
return os.path.join(config_dir, f'icons-{which}.rcc')
def remove_user_theme(self, which):
path = self.user_theme_resource_file(which)
if path in self.registered_user_resource_files:
QResource.unregisterResource(path)
self.registered_user_resource_files = tuple(x for x in self.registered_user_resource_files if x != path)
with suppress(FileNotFoundError):
os.remove(path)
def register_user_resource_files(self):
self.user_icon_theme_metadata.cache_clear()
for x in self.registered_user_resource_files:
QResource.unregisterResource(x)
r = []
self.user_any_theme_name = self.user_dark_theme_name = self.user_light_theme_name = None
for x in ('any', 'light', 'dark'):
path = self.user_theme_resource_file(x)
if os.path.exists(path):
QResource.registerResource(path)
r.append(path)
setattr(self, f'user_{x}_theme_name', f'calibre-user-{x}')
self.registered_user_resource_files = tuple(r)
any_dark = (self.user_any_theme_name + '-dark') if self.user_any_theme_name else ''
any_light = (self.user_any_theme_name + '-light') if self.user_any_theme_name else ''
self.dark_theme_name = self.user_dark_theme_name or any_dark or self.default_dark_theme_name
self.light_theme_name = self.user_light_theme_name or any_light or self.default_light_theme_name
@lru_cache(maxsize=4)
def user_icon_theme_metadata(self, which):
path = self.user_theme_resource_file(which)
if path not in self.registered_user_resource_files:
return {}
f = QFile(f':/icons/calibre-user-{which}/metadata.json')
if not f.open(QIODevice.OpenModeFlag.ReadOnly):
return {}
try:
import json
return json.loads(bytes(f.readAll()))
finally:
f.close()
@property
def active_user_theme_metadata(self):
q = QIcon.themeName()
if q in (self.default_dark_theme_name, self.default_light_theme_name):
return {}
if q == self.user_dark_theme_name:
return self.user_icon_theme_metadata('dark')
if q == self.user_light_theme_name:
return self.user_icon_theme_metadata('light')
return self.user_icon_theme_metadata('any')
@property
def user_theme_title(self):
return self.active_user_theme_metadata.get('title', _('Default icons'))
@property
def user_theme_name(self):
return self.active_user_theme_metadata.get('name', 'default')
def initialize(self):
if self.initialized:
return
self.icon_cache = {}
self.initialized = True
QResource.registerResource(P('icons.rcc', allow_user_override=False))
QIcon.setFallbackSearchPaths([])
QIcon.setThemeSearchPaths([':/icons'])
self.override_icon_path = None
q = os.path.join(user_dir, 'images')
items = []
with suppress(Exception):
items = os.listdir(q)
if items:
self.override_icon_path = q
legacy_theme_metadata = os.path.join(q, 'icon-theme.json')
if os.path.exists(legacy_theme_metadata):
self.migrate_legacy_icon_theme(legacy_theme_metadata)
items = os.listdir(q)
self.override_items = {'': frozenset(items)}
for k in ('devices', 'mimetypes', 'plugins'):
items = frozenset()
with suppress(OSError):
items = frozenset(os.listdir(os.path.join(self.override_icon_path, k)))
self.override_items[k] = items
self.register_user_resource_files()
def migrate_legacy_icon_theme(self, legacy_theme_metadata):
import shutil
from calibre.utils.rcc import compile_icon_dir_as_themes
images = os.path.dirname(legacy_theme_metadata)
os.replace(legacy_theme_metadata, os.path.join(images, 'metadata.json'))
compile_icon_dir_as_themes(
images, self.user_theme_resource_file('any'), theme_name='calibre-user-any', inherits='calibre-default')
for x in os.listdir(images):
q = os.path.join(images, x)
if os.path.isdir(q) and q != 'textures':
shutil.rmtree(q)
else:
os.remove(q)
def overriden_icon_path(self, name):
parts = name.replace(os.sep, '/').split('/')
ans = os.path.join(self.override_icon_path, name)
if len(parts) == 1:
sq, ext = os.path.splitext(parts[0])
sq = f'{sq}-for-{self.color_palette}-theme{ext}'
if sq in self.override_items['']:
ans = os.path.join(self.override_icon_path, sq)
else:
subfolder = '/'.join(parts[:-1])
entries = self.override_items.get(subfolder)
if entries is None and self.override_icon_path:
try:
self.override_items[subfolder] = entries = frozenset(os.listdir(os.path.join(self.override_icon_path, subfolder)))
except OSError:
self.override_items[subfolder] = entries = frozenset()
if entries:
sq, ext = os.path.splitext(parts[-1])
sq = f'{sq}-for-{self.color_palette}-theme{ext}'
if sq in entries:
ans = os.path.join(self.override_icon_path, subfolder, sq)
return ans
def cached_icon(self, name=''):
'''
Keep these icons in a cache. This is intended to be used in dialogs like
manage categories where thousands of icon instances can be needed.
It is a new method to avoid breaking QIcon.ic() if names are reused
in different contexts. It isn't clear if this can ever happen.
'''
icon = self.icon_cache.get(name)
if icon is None:
icon = self.icon_cache[name] = self(name)
return icon
def __call__(self, name):
if isinstance(name, QIcon):
return name
if not name:
return QIcon()
if os.path.isabs(name):
return QIcon(name)
if self.override_icon_path:
qi = QIcon(self.overriden_icon_path(name))
if qi.is_ok():
return qi
icon_name = os.path.splitext(name.replace('\\', '__').replace('/', '__'))[0]
ans = QIcon.fromTheme(icon_name)
if not ans.is_ok():
if 'user-any' in QIcon.themeName():
q = QIcon(f':/icons/calibre-default-{self.color_palette}/images/{name}')
if q.is_ok():
ans = q
return ans
def icon_as_png(self, name, as_bytearray=False, compression_level=0):
ans = self(name)
ba = QByteArray()
if ans.availableSizes():
pmap = ans.pixmap(ans.availableSizes()[0])
buf = QBuffer(ba)
buf.open(QIODevice.OpenModeFlag.WriteOnly)
w = QImageWriter(buf, b'PNG')
cl = min(9, max(0, compression_level))
w.setQuality(10 * (9-cl))
w.setQuality(90)
w.write(pmap.toImage())
return ba if as_bytearray else ba.data()
def set_theme(self):
self.icon_cache = {}
current = QIcon.themeName()
is_dark = QApplication.instance().is_dark_theme
self.color_palette = 'dark' if is_dark else 'light'
new = self.dark_theme_name if is_dark else self.light_theme_name
if current == new and current not in (self.default_dark_theme_name, self.default_light_theme_name):
# force reload of user icons by first changing theme to default and
# then to user
QIcon.setThemeName(self.default_dark_theme_name if QApplication.instance().is_dark_theme else self.default_light_theme_name)
QIcon.setThemeName(new)
icon_resource_manager = IconResourceManager()
QIcon.ic = icon_resource_manager
QIcon.icon_as_png = icon_resource_manager.icon_as_png
QIcon.is_ok = lambda self: not self.isNull() and len(self.availableSizes()) > 0
QIcon.cached_icon = icon_resource_manager.cached_icon
# Setup gprefs {{{
gprefs = JSONConfig('gui')
native_menubar_defaults = {
'action-layout-menubar': (
'Add Books', 'Edit Metadata', 'Convert Books',
'Choose Library', 'Save To Disk', 'Preferences',
'Help',
),
'action-layout-menubar-device': (
'Add Books', 'Edit Metadata', 'Convert Books',
'Location Manager', 'Send To Device',
'Save To Disk', 'Preferences', 'Help',
)
}
def create_defs():
defs = gprefs.defaults
if ismacos:
defs['action-layout-menubar'] = native_menubar_defaults['action-layout-menubar']
defs['action-layout-menubar-device'] = native_menubar_defaults['action-layout-menubar-device']
defs['action-layout-toolbar'] = (
'Add Books', 'Edit Metadata', None, 'Convert Books', 'View', None,
'Choose Library', 'Donate', None, 'Fetch News', 'Store', 'Save To Disk',
'Connect Share', None, 'Remove Books', 'Tweak ePub'
)
defs['action-layout-toolbar-device'] = (
'Add Books', 'Edit Metadata', None, 'Convert Books', 'View',
'Send To Device', None, None, 'Location Manager', None, None,
'Fetch News', 'Store', 'Save To Disk', 'Connect Share', None,
'Remove Books',
)
else:
defs['action-layout-menubar'] = ()
defs['action-layout-menubar-device'] = ()
defs['action-layout-toolbar'] = (
'Add Books', 'Edit Metadata', None, 'Convert Books', 'View', None,
'Store', 'Donate', 'Fetch News', 'Help', None, 'Preferences',
'Remove Books', 'Choose Library', 'Save To Disk', 'Connect Share',
'Tweak ePub',
)
defs['action-layout-toolbar-device'] = (
'Add Books', 'Edit Metadata', None, 'Convert Books', 'View',
'Send To Device', None, None, 'Location Manager', None, None,
'Fetch News', 'Save To Disk', 'Store', 'Connect Share', None,
'Remove Books', None, 'Help', 'Preferences',
)
defs['action-layout-toolbar-child'] = ()
defs['action-layout-searchbar'] = ('Saved searches',)
defs['action-layout-context-menu'] = (
'Edit Metadata', 'Send To Device', 'Save To Disk',
'Connect Share', 'Copy To Library', None,
'Convert Books', 'View', 'Open Folder', 'Show Book Details',
'Similar Books', 'Tweak ePub', None, 'Remove Books',
)
defs['action-layout-context-menu-split'] = (
'Edit Metadata', 'Send To Device', 'Save To Disk',
'Connect Share', 'Copy To Library', None,
'Convert Books', 'View', 'Open Folder', 'Show Book Details',
'Similar Books', 'Tweak ePub', None, 'Remove Books',
)
defs['action-layout-context-menu-device'] = (
'View', 'Save To Disk', None, 'Remove Books', None,
'Add To Library', 'Edit Collections', 'Match Books',
'Show Matched Book In Library'
)
defs['action-layout-context-menu-cover-browser'] = (
'Edit Metadata', 'Send To Device', 'Save To Disk',
'Connect Share', 'Copy To Library', None,
'Convert Books', 'View', 'Open Folder', 'Show Book Details',
'Similar Books', 'Tweak ePub', None, 'Remove Books', None,
'Autoscroll Books'
)
defs['show_splash_screen'] = True
defs['toolbar_icon_size'] = 'medium'
defs['automerge'] = 'ignore'
defs['toolbar_text'] = 'always'
defs['font'] = None
defs['tags_browser_partition_method'] = 'first letter'
defs['tags_browser_collapse_at'] = 100
defs['tags_browser_collapse_fl_at'] = 5
defs['tag_browser_dont_collapse'] = []
defs['edit_metadata_single_layout'] = 'default'
defs['preserve_date_on_ctl'] = True
defs['manual_add_auto_convert'] = False
defs['auto_convert_same_fmt'] = False
defs['cb_fullscreen'] = False
defs['worker_max_time'] = 0
defs['show_files_after_save'] = True
defs['auto_add_path'] = None
defs['auto_add_check_for_duplicates'] = False
defs['blocked_auto_formats'] = []
defs['auto_add_auto_convert'] = True
defs['auto_add_everything'] = False
defs['ui_style'] = 'calibre' if iswindows or ismacos else 'system'
defs['color_palette'] = 'system'
defs['tag_browser_old_look'] = False
defs['tag_browser_hide_empty_categories'] = False
defs['tag_browser_always_autocollapse'] = False
defs['tag_browser_allow_keyboard_focus'] = False
defs['book_list_tooltips'] = True
defs['show_layout_buttons'] = False
defs['bd_show_cover'] = True
defs['bd_overlay_cover_size'] = False
defs['tags_browser_category_icons'] = {}
defs['cover_browser_reflections'] = True
defs['book_list_extra_row_spacing'] = 0
defs['refresh_book_list_on_bulk_edit'] = True
defs['cover_grid_width'] = 0
defs['cover_grid_height'] = 0
defs['cover_grid_spacing'] = 0
defs['cover_grid_color'] = (80, 80, 80)
defs['cover_grid_cache_size_multiple'] = 5
defs['cover_grid_disk_cache_size'] = 2500
defs['cover_grid_show_title'] = False
defs['cover_grid_texture'] = None
defs['cover_corner_radius'] = 0
defs['cover_corner_radius_unit'] = 'px'
defs['show_vl_tabs'] = False
defs['vl_tabs_closable'] = True
defs['show_highlight_toggle_button'] = False
defs['add_comments_to_email'] = False
defs['cb_preserve_aspect_ratio'] = False
defs['cb_double_click_to_activate'] = False
defs['gpm_template_editor_font_size'] = 10
defs['show_emblems'] = False
defs['emblem_size'] = 32
defs['emblem_position'] = 'left'
defs['metadata_diff_mark_rejected'] = False
defs['tag_browser_show_counts'] = True
defs['tag_browser_show_tooltips'] = True
defs['row_numbers_in_book_list'] = True
defs['tag_browser_item_padding'] = 0.5
defs['paste_isbn_prefixes'] = ['isbn', 'url', 'amazon', 'google']
defs['qv_respects_vls'] = True
defs['qv_dclick_changes_column'] = True
defs['qv_retkey_changes_column'] = True
defs['qv_follows_column'] = False
defs['book_details_comments_heading_pos'] = 'hide'
defs['book_list_split'] = False
defs['wrap_toolbar_text'] = False
defs['dnd_merge'] = True
defs['booklist_grid'] = False
defs['browse_annots_restrict_to_user'] = None
defs['browse_annots_restrict_to_type'] = None
defs['browse_annots_use_stemmer'] = True
defs['browse_notes_use_stemmer'] = True
defs['fts_library_use_stemmer'] = True
defs['fts_library_restrict_books'] = False
defs['annots_export_format'] = 'txt'
defs['books_autoscroll_time'] = 2.0
defs['edit_metadata_single_use_2_cols_for_custom_fields'] = True
defs['edit_metadata_elide_labels'] = True
defs['edit_metadata_elision_point'] = "right"
defs['edit_metadata_bulk_cc_label_length'] = 25
defs['edit_metadata_single_cc_label_length'] = 12
defs['edit_metadata_templates_only_F2_on_booklist'] = False
# JSON dumps converts integer keys to strings, so do it explicitly
defs['tb_search_order'] = {'0': 1, '1': 2, '2': 3, '3': 4, '4': 0}
defs['search_tool_bar_shows_text'] = True
defs['allow_keyboard_search_in_library_views'] = True
defs['show_links_in_tag_browser'] = False
defs['show_notes_in_tag_browser'] = False
defs['icons_on_right_in_tag_browser'] = True
defs['cover_browser_narrow_view_position'] = 'automatic'
defs['dark_palette_name'] = ''
defs['light_palette_name'] = ''
defs['dark_palettes'] = {}
defs['light_palettes'] = {}
defs['saved_layouts'] = {}
def migrate_tweak(tweak_name, pref_name):
# If the tweak has been changed then leave the tweak in the file so
# that the user can bounce between versions with and without the
# migration. For versions before the migration the tweak wins. For
# versions after the migration any changes win.
v = tweaks.get(tweak_name, None)
migrated_tweak_name = pref_name + '_tweak_migrated'
m = gprefs.get(migrated_tweak_name, None)
if m is None and v is not None:
gprefs[pref_name] = v
gprefs[migrated_tweak_name] = True
migrate_tweak('metadata_edit_elide_labels', 'edit_metadata_elide_labels')
migrate_tweak('metadata_edit_elision_point', 'edit_metadata_elision_point')
migrate_tweak('metadata_edit_bulk_cc_label_length', 'edit_metadata_bulk_cc_label_length')
migrate_tweak('metadata_edit_single_cc_label_length', 'edit_metadata_single_cc_label_length')
migrate_tweak('metadata_single_use_2_cols_for_custom_fields', 'edit_metadata_single_use_2_cols_for_custom_fields')
create_defs()
del create_defs
# }}}
UNDEFINED_QDATETIME = QDateTime(
UNDEFINED_DATE.year, UNDEFINED_DATE.month, UNDEFINED_DATE.day, UNDEFINED_DATE.hour, UNDEFINED_DATE.minute, UNDEFINED_DATE.second)
QT_HIDDEN_CLEAR_ACTION = '_q_qlineeditclearaction'
ALL_COLUMNS = ['title', 'ondevice', 'authors', 'size', 'timestamp', 'rating', 'publisher',
'tags', 'series', 'pubdate']
def _config(): # {{{
c = Config('gui', 'preferences for the calibre GUI')
c.add_opt('send_to_storage_card_by_default', default=False,
help=_('Send file to storage card instead of main memory by default'))
c.add_opt('confirm_delete', default=False,
help=_('Confirm before deleting'))
c.add_opt('main_window_geometry', default=None,
help=_('Main window geometry'))
c.add_opt('new_version_notification', default=True,
help=_('Notify when a new version is available'))
c.add_opt('use_roman_numerals_for_series_number', default=True,
help=_('Use Roman numerals for series number'))
c.add_opt('sort_tags_by', default='name',
help=_('Sort tags list by name, popularity, or rating'))
c.add_opt('match_tags_type', default='any',
help=_('Match tags by any or all.'))
c.add_opt('cover_flow_queue_length', default=6,
help=_('Number of covers to show in the cover browsing mode'))
c.add_opt('LRF_conversion_defaults', default=[],
help=_('Defaults for conversion to LRF'))
c.add_opt('LRF_ebook_viewer_options', default=None,
help=_('Options for the LRF e-book viewer'))
c.add_opt('internally_viewed_formats', default=['LRF', 'EPUB', 'LIT',
'MOBI', 'PRC', 'POBI', 'AZW', 'AZW3', 'HTML', 'FB2', 'FBZ', 'PDB', 'RB',
'SNB', 'HTMLZ', 'KEPUB'], help=_(
'Formats that are viewed using the internal viewer'))
c.add_opt('column_map', default=ALL_COLUMNS,
help=_('Columns to be displayed in the book list'))
c.add_opt('autolaunch_server', default=False, help=_('Automatically launch Content server on application startup'))
c.add_opt('oldest_news', default=60, help=_('Oldest news kept in database'))
c.add_opt('systray_icon', default=False, help=_('Show system tray icon'))
c.add_opt('upload_news_to_device', default=True,
help=_('Upload downloaded news to device'))
c.add_opt('delete_news_from_library_on_upload', default=False,
help=_('Delete news books from library after uploading to device'))
c.add_opt('separate_cover_flow', default=False,
help=_('Show the cover flow in a separate window instead of in the main calibre window'))
c.add_opt('disable_tray_notification', default=False,
help=_('Disable notifications from the system tray icon'))
c.add_opt('default_send_to_device_action', default=None,
help=_('Default action to perform when the "Send to device" button is '
'clicked'))
c.add_opt('asked_library_thing_password', default=False,
help='Asked library thing password at least once.')
c.add_opt('search_as_you_type', default=False,
help=_('Start searching as you type. If this is disabled then search will '
'only take place when the Enter key is pressed.'))
c.add_opt('highlight_search_matches', default=False,
help=_('When searching, show all books with search results '
'highlighted instead of showing only the matches. You can use the '
'N or F3 keys to go to the next match.'))
c.add_opt('save_to_disk_template_history', default=[],
help='Previously used Save to disk templates')
c.add_opt('send_to_device_template_history', default=[],
help='Previously used Send to Device templates')
c.add_opt('main_search_history', default=[],
help='Search history for the main GUI')
c.add_opt('viewer_search_history', default=[],
help='Search history for the e-book viewer')
c.add_opt('viewer_toc_search_history', default=[],
help='Search history for the ToC in the e-book viewer')
c.add_opt('lrf_viewer_search_history', default=[],
help='Search history for the LRF viewer')
c.add_opt('scheduler_search_history', default=[],
help='Search history for the recipe scheduler')
c.add_opt('plugin_search_history', default=[],
help='Search history for the plugin preferences')
c.add_opt('shortcuts_search_history', default=[],
help='Search history for the keyboard preferences')
c.add_opt('jobs_search_history', default=[],
help='Search history for the tweaks preferences')
c.add_opt('tweaks_search_history', default=[],
help='Search history for tweaks')
c.add_opt('worker_limit', default=6,
help=_(
'Maximum number of simultaneous conversion/news download jobs. '
'This number is twice the actual value for historical reasons.'))
c.add_opt('get_social_metadata', default=True,
help=_('Download social metadata (tags/rating/etc.)'))
c.add_opt('overwrite_author_title_metadata', default=True,
help=_('Overwrite author and title with new metadata'))
c.add_opt('auto_download_cover', default=False,
help=_('Automatically download the cover, if available'))
c.add_opt('enforce_cpu_limit', default=True,
help=_('Limit max simultaneous jobs to number of CPUs'))
c.add_opt('gui_layout', choices=['wide', 'narrow'],
help=_('The layout of the user interface. Wide has the '
'Book details panel on the right and narrow has '
'it at the bottom.'), default='wide')
c.add_opt('show_avg_rating', default=True,
help=_('Show the average rating per item indication in the Tag browser'))
c.add_opt('disable_animations', default=False,
help=_('Disable UI animations'))
# This option is no longer used. It remains for compatibility with upgrades
# so the value can be migrated
c.add_opt('tag_browser_hidden_categories', default=set(),
help=_('Tag browser categories not to display'))
c.add_opt
return ConfigProxy(c)
config = _config()
# }}}
QSettings.setPath(QSettings.Format.IniFormat, QSettings.Scope.UserScope, config_dir)
QSettings.setPath(QSettings.Format.IniFormat, QSettings.Scope.SystemScope, config_dir)
QSettings.setDefaultFormat(QSettings.Format.IniFormat)
def default_author_link():
from calibre.ebooks.metadata.book.render import DEFAULT_AUTHOR_LINK
ans = gprefs.get('default_author_link')
if ans == 'https://en.wikipedia.org/w/index.php?search={author}':
# The old default value for this setting
ans = DEFAULT_AUTHOR_LINK
return ans or DEFAULT_AUTHOR_LINK
def available_heights():
return tuple(s.availableSize().height() for s in QGuiApplication.screens())
def available_height():
return QApplication.instance().primaryScreen().availableSize().height()
def available_width():
return QApplication.instance().primaryScreen().availableSize().width()
def max_available_height():
return max(available_heights())
def min_available_height():
return min(available_heights())
def get_screen_dpi():
s = QApplication.instance().primaryScreen()
return s.logicalDotsPerInchX(), s.logicalDotsPerInchY()
_is_widescreen = None
def is_widescreen():
global _is_widescreen
if _is_widescreen is None:
try:
_is_widescreen = available_width()/available_height() > 1.4
except:
_is_widescreen = False
return _is_widescreen
def extension(path):
return os.path.splitext(path)[1][1:].lower()
def warning_dialog(parent, title, msg, det_msg='', show=False,
show_copy_button=True):
from calibre.gui2.dialogs.message_box import MessageBox
d = MessageBox(MessageBox.WARNING, _('WARNING:'
)+ ' ' + title, msg, det_msg, parent=parent,
show_copy_button=show_copy_button)
if show:
return d.exec()
return d
def error_dialog(parent, title, msg, det_msg='', show=False,
show_copy_button=True):
from calibre.gui2.dialogs.message_box import MessageBox
d = MessageBox(MessageBox.ERROR, _('ERROR:'
) + ' ' + title, msg, det_msg, parent=parent,
show_copy_button=show_copy_button)
if show:
return d.exec()
return d
class Aborted(Exception):
pass
def question_dialog(parent, title, msg, det_msg='', show_copy_button=False,
default_yes=True,
# Skippable dialogs
# Set skip_dialog_name to a unique name for this dialog
# Set skip_dialog_msg to a message displayed to the user
skip_dialog_name=None, skip_dialog_msg=_('Show this confirmation again'),
skip_dialog_skipped_value=True, skip_dialog_skip_precheck=True,
# Override icon (QIcon to be used as the icon for this dialog or string for QIcon.ic())
override_icon=None,
# Change the text/icons of the yes and no buttons.
# The icons must be QIcon objects or strings for QIcon.ic()
yes_text=None, no_text=None, yes_icon=None, no_icon=None,
# Add an Abort button which if clicked will cause this function to raise
# the Aborted exception
add_abort_button=False,
):
from calibre.gui2.dialogs.message_box import MessageBox
prefs = gui_prefs()
if not isinstance(skip_dialog_name, str):
skip_dialog_name = None
try:
auto_skip = set(prefs.get('questions_to_auto_skip', ()))
except Exception:
auto_skip = set()
if (skip_dialog_name is not None and skip_dialog_name in auto_skip):
return bool(skip_dialog_skipped_value)
d = MessageBox(MessageBox.QUESTION, title, msg, det_msg, parent=parent,
show_copy_button=show_copy_button, default_yes=default_yes,
q_icon=override_icon, yes_text=yes_text, no_text=no_text,
yes_icon=yes_icon, no_icon=no_icon, add_abort_button=add_abort_button)
if skip_dialog_name is not None and skip_dialog_msg:
tc = d.toggle_checkbox
tc.setVisible(True)
tc.setText(skip_dialog_msg)
tc.setChecked(bool(skip_dialog_skip_precheck))
d.resize_needed.emit()
ret = d.exec() == QDialog.DialogCode.Accepted
if add_abort_button and d.aborted:
raise Aborted()
if skip_dialog_name is not None and not d.toggle_checkbox.isChecked():
auto_skip.add(skip_dialog_name)
prefs.set('questions_to_auto_skip', list(auto_skip))
return ret
def info_dialog(parent, title, msg, det_msg='', show=False,
show_copy_button=True, only_copy_details=False):
from calibre.gui2.dialogs.message_box import MessageBox
d = MessageBox(MessageBox.INFO, title, msg, det_msg, parent=parent,
show_copy_button=show_copy_button, only_copy_details=only_copy_details)
if show:
return d.exec()
return d
def show_restart_warning(msg, parent=None):
d = warning_dialog(parent, _('Restart needed'), msg,
show_copy_button=False)
b = d.bb.addButton(_('&Restart calibre now'), QDialogButtonBox.ButtonRole.AcceptRole)
b.setIcon(QIcon.ic('lt.png'))
d.do_restart = False
def rf():
d.do_restart = True
b.clicked.connect(rf)
d.set_details('')
d.exec()
b.clicked.disconnect()
return d.do_restart
class Dispatcher(QObject):
'''
Convenience class to use Qt signals with arbitrary python callables.
By default, ensures that a function call always happens in the
thread this Dispatcher was created in.
Note that if you create the Dispatcher in a thread without an event loop of
its own, the function call will happen in the GUI thread (I think).
'''
dispatch_signal = pyqtSignal(object, object)
def __init__(self, func, queued=True, parent=None):
QObject.__init__(self, parent)
self.func = func
typ = Qt.ConnectionType.QueuedConnection
if not queued:
typ = Qt.ConnectionType.AutoConnection if queued is None else Qt.ConnectionType.DirectConnection
self.dispatch_signal.connect(self.dispatch, type=typ)
def __call__(self, *args, **kwargs):
self.dispatch_signal.emit(args, kwargs)
def dispatch(self, args, kwargs):
self.func(*args, **kwargs)
class FunctionDispatcher(QObject):
'''
Convenience class to use Qt signals with arbitrary python functions.
By default, ensures that a function call always happens in the
thread this FunctionDispatcher was created in.
Note that you must create FunctionDispatcher objects in the GUI thread.
'''
dispatch_signal = pyqtSignal(object, object, object)
def __init__(self, func, queued=True, parent=None):
global gui_thread
if gui_thread is None:
gui_thread = QThread.currentThread()
if not is_gui_thread():
raise ValueError(
'You can only create a FunctionDispatcher in the GUI thread')
QObject.__init__(self, parent)
self.func = func
typ = Qt.ConnectionType.QueuedConnection
if not queued:
typ = Qt.ConnectionType.AutoConnection if queued is None else Qt.ConnectionType.DirectConnection
self.dispatch_signal.connect(self.dispatch, type=typ)
self.q = queue.Queue()
self.lock = threading.Lock()
def __call__(self, *args, **kwargs):
if is_gui_thread():
return self.func(*args, **kwargs)
with self.lock:
self.dispatch_signal.emit(self.q, args, kwargs)
res = self.q.get()
return res
def dispatch(self, q, args, kwargs):
try:
res = self.func(*args, **kwargs)
except:
res = None
q.put(res)
class GetMetadata(QObject):
'''
Convenience class to ensure that metadata readers are used only in the
GUI thread. Must be instantiated in the GUI thread.
'''
edispatch = pyqtSignal(object, object, object)
idispatch = pyqtSignal(object, object, object)
metadataf = pyqtSignal(object, object)
metadata = pyqtSignal(object, object)
def __init__(self):
QObject.__init__(self)
self.edispatch.connect(self._get_metadata, type=Qt.ConnectionType.QueuedConnection)
self.idispatch.connect(self._from_formats, type=Qt.ConnectionType.QueuedConnection)
def __call__(self, id, *args, **kwargs):
self.edispatch.emit(id, args, kwargs)
def from_formats(self, id, *args, **kwargs):
self.idispatch.emit(id, args, kwargs)
def _from_formats(self, id, args, kwargs):
from calibre.ebooks.metadata.meta import metadata_from_formats
try:
mi = metadata_from_formats(*args, **kwargs)
except:
mi = MetaInformation('', [_('Unknown')])
self.metadataf.emit(id, mi)
def _get_metadata(self, id, args, kwargs):
from calibre.ebooks.metadata.meta import get_metadata
try:
mi = get_metadata(*args, **kwargs)
except:
mi = MetaInformation('', [_('Unknown')])
self.metadata.emit(id, mi)
class FileIconProvider(QFileIconProvider):
ICONS = EXT_MAP
def __init__(self):
super().__init__()
self.icons = {k:f'mimetypes/{v}.png' for k, v in self.ICONS.items()}
self.icons['calibre'] = I('lt.png', allow_user_override=False)
for i in ('dir', 'default', 'zero'):
self.icons[i] = QIcon.ic(self.icons[i])
def key_from_ext(self, ext):
key = ext if ext in self.icons else 'default'
if key == 'default' and '.' in ext:
ext = ext.rpartition('.')[2]
key = ext if ext in self.icons else 'default'
if key == 'default' and ext.startswith('original_'):
ext = ext.partition('_')[2]
key = ext if ext in self.icons else 'default'
if key == 'default':
key = ext
return key
def cached_icon(self, key):
candidate = self.icons.get(key)
if isinstance(candidate, QIcon):
return candidate
candidate = candidate or f'mimetypes/{key}.png'
icon = QIcon.ic(candidate)
if not icon.is_ok():
icon = self.icons['default']
self.icons[key] = icon
return icon
def icon_from_ext(self, ext):
key = self.key_from_ext(ext.lower() if ext else '')
return self.cached_icon(key)
def load_icon(self, fileinfo):
key = 'default'
if fileinfo.isSymLink():
if not fileinfo.exists():
return self.icons['zero']
fileinfo = QFileInfo(fileinfo.symLinkTarget())
if fileinfo.isDir():
key = 'dir'
else:
ext = str(fileinfo.completeSuffix()).lower()
key = self.key_from_ext(ext)
return self.cached_icon(key)
def icon(self, arg):
if isinstance(arg, QFileInfo):
return self.load_icon(arg)
if arg == QFileIconProvider.IconType.Folder:
return self.icons['dir']
if arg == QFileIconProvider.IconType.File:
return self.icons['default']
return QFileIconProvider.icon(self, arg)
_file_icon_provider = None
def initialize_file_icon_provider():
global _file_icon_provider
if _file_icon_provider is None:
_file_icon_provider = FileIconProvider()
def file_icon_provider():
global _file_icon_provider
initialize_file_icon_provider()
return _file_icon_provider
has_windows_file_dialog_helper = False
if iswindows and 'CALIBRE_NO_NATIVE_FILEDIALOGS' not in os.environ:
from calibre.gui2.win_file_dialogs import is_ok as has_windows_file_dialog_helper
has_windows_file_dialog_helper = has_windows_file_dialog_helper()
has_linux_file_dialog_helper = False
if not iswindows and not ismacos and 'CALIBRE_NO_NATIVE_FILEDIALOGS' not in os.environ and getattr(sys, 'frozen', False):
has_linux_file_dialog_helper = check_for_linux_native_dialogs()
if has_windows_file_dialog_helper:
from calibre.gui2.win_file_dialogs import choose_dir, choose_files, choose_images, choose_save_file
elif has_linux_file_dialog_helper:
choose_dir, choose_files, choose_save_file, choose_images = map(
linux_native_dialog, 'dir files save_file images'.split())
else:
from calibre.gui2.qt_file_dialogs import choose_dir, choose_files, choose_images, choose_save_file
choose_files, choose_images, choose_dir, choose_save_file
def choose_files_and_remember_all_files(
window, name, title, filters=[], select_only_single_file=False, default_dir='~'
):
pref_name = f'{name}-last-used-filter-spec-all-files'
lufs = dynamic.get(pref_name, False)
af = _('All files'), ['*']
filters = list(filters)
filters.insert(0, af) if lufs else filters.append(af)
paths = choose_files(window, name, title, list(filters), False, select_only_single_file, default_dir)
if paths:
ext = paths[0].rpartition(os.extsep)[-1].lower()
used_all_files = True
for i, (name, exts) in enumerate(filters):
if ext in exts:
used_all_files = False
break
dynamic.set(pref_name, used_all_files)
return paths
def is_dark_theme():
app = QApplication.instance()
if app is not None:
pal = QApplication.instance().palette()
return pal.is_dark_theme()
return False
def choose_osx_app(window, name, title, default_dir='/Applications'):
fd = FileDialog(title=title, parent=window, name=name, mode=QFileDialog.FileMode.ExistingFile,
default_dir=default_dir)
app = fd.get_files()
fd.setParent(None)
if app:
return app
def pixmap_to_data(pixmap, format='JPEG', quality=None):
'''
Return the QPixmap pixmap as a string saved in the specified format.
'''
if quality is None:
if format.upper() == "PNG":
# For some reason on windows with Qt 5.6 using a quality of 90
# generates invalid PNG data. Many other quality values work
# but we use -1 for the default quality which is most likely to
# work
quality = -1
else:
quality = 90
ba = QByteArray()
buf = QBuffer(ba)
buf.open(QIODevice.OpenModeFlag.WriteOnly)
pixmap.save(buf, format, quality=quality)
return ba.data()
def decouple(prefix):
' Ensure that config files used by utility code are not the same as those used by the main calibre GUI '
dynamic.decouple(prefix)
from calibre.gui2.widgets import history
history.decouple(prefix)
_gui_prefs = gprefs
def gui_prefs():
return _gui_prefs
def set_gui_prefs(prefs):
global _gui_prefs
_gui_prefs = prefs
class ResizableDialog(QDialog):
# This class is present only for backwards compat with third party plugins
# that might use it. Do not use it in new code.
def __init__(self, *args, **kwargs):
QDialog.__init__(self, *args)
self.setupUi(self)
geom = self.screen().availableSize()
nh, nw = max(550, geom.height()-25), max(700, geom.width()-10)
nh = min(self.height(), nh)
nw = min(self.width(), nw)
self.resize(nw, nh)
class Translator(QTranslator):
'''
Translator to load translations for strings in Qt from the calibre
translations. Does not support advanced features of Qt like disambiguation
and plural forms.
'''
def translate(self, *args, **kwargs):
try:
src = str(args[1])
except:
return ''
t = _
return t(src)
gui_thread = None
qt_app = None
def calibre_font_files():
return glob.glob(P('fonts/liberation/*.?tf')) + [P('fonts/calibreSymbols.otf')] + \
glob.glob(os.path.join(config_dir, 'fonts', '*.?tf'))
def load_builtin_fonts():
global _rating_font, builtin_fonts_loaded
# Load the builtin fonts and any fonts added to calibre by the user to
# Qt
if hasattr(load_builtin_fonts, 'done'):
return
load_builtin_fonts.done = True
for ff in calibre_font_files():
if ff.rpartition('.')[-1].lower() in {'ttf', 'otf'}:
with open(ff, 'rb') as s:
# Windows requires font files to be executable for them to be
# loaded successfully, so we use the in memory loader
fid = QFontDatabase.addApplicationFontFromData(s.read())
if fid > -1:
fam = QFontDatabase.applicationFontFamilies(fid)
fam = set(map(str, fam))
if 'calibre Symbols' in fam:
_rating_font = 'calibre Symbols'
def setup_gui_option_parser(parser):
if islinux:
parser.add_option('--detach', default=False, action='store_true',
help=_('Detach from the controlling terminal, if any (Linux only)'))
def show_temp_dir_error(err):
import traceback
extra = _('Click "Show details" for more information.')
if 'CALIBRE_TEMP_DIR' in os.environ:
extra = _('The %s environment variable is set. Try unsetting it.') % 'CALIBRE_TEMP_DIR'
error_dialog(None, _('Could not create temporary folder'), _(
'Could not create temporary folder, calibre cannot start.') + ' ' + extra, det_msg=traceback.format_exc(), show=True)
def setup_unix_signals(self):
if hasattr(os, 'pipe2'):
read_fd, write_fd = os.pipe2(os.O_CLOEXEC | os.O_NONBLOCK)
else:
import fcntl
read_fd, write_fd = os.pipe()
cloexec_flag = getattr(fcntl, 'FD_CLOEXEC', 1)
for fd in (read_fd, write_fd):
flags = fcntl.fcntl(fd, fcntl.F_GETFD)
if flags != -1:
fcntl.fcntl(fd, fcntl.F_SETFD, flags | cloexec_flag)
flags = fcntl.fcntl(fd, fcntl.F_GETFL)
if flags != -1:
fcntl.fcntl(fd, fcntl.F_SETFL, flags | os.O_NONBLOCK)
original_handlers = {}
for sig in (signal.SIGINT, signal.SIGTERM):
original_handlers[sig] = signal.signal(sig, lambda x, y: None)
signal.siginterrupt(sig, False)
signal.set_wakeup_fd(write_fd)
self.signal_notifier = QSocketNotifier(read_fd, QSocketNotifier.Type.Read, self)
self.signal_notifier.setEnabled(True)
self.signal_notifier.activated.connect(self.signal_received, type=Qt.ConnectionType.QueuedConnection)
return original_handlers
def setup_to_run_webengine():
# Allow import of webengine after construction of QApplication on new enough PyQt
QApplication.setAttribute(Qt.ApplicationAttribute.AA_ShareOpenGLContexts)
try:
# this import is needed to have Qt call qt_registerDefaultPlatformBackingStoreOpenGLSupport
from qt.core import QOpenGLWidget
del QOpenGLWidget
from qt.core import QQuickWindow, QSGRendererInterface
QQuickWindow.setGraphicsApi(QSGRendererInterface.GraphicsApi.OpenGL)
except ImportError:
# for people running from source
if numeric_version >= (6, 3):
raise
class Application(QApplication):
shutdown_signal_received = pyqtSignal()
palette_changed = pyqtSignal()
def __init__(self, args=(), force_calibre_style=False, override_program_name=None, headless=False, color_prefs=gprefs, windows_app_uid=None):
if not args:
args = sys.argv[:1]
args = [args[0]]
sys.excepthook = simple_excepthook
QNetworkProxyFactory.setUseSystemConfiguration(True)
setup_to_run_webengine()
if iswindows:
self.windows_app_uid = None
if windows_app_uid:
windows_app_uid = str(windows_app_uid)
if set_app_uid(windows_app_uid):
self.windows_app_uid = windows_app_uid
self.file_event_hook = None
if override_program_name:
args = [override_program_name] + args[1:]
self.palette_manager = PaletteManager(force_calibre_style, headless)
if headless:
args.extend(('-platformpluginpath', plugins_loc, '-platform', os.environ.get('CALIBRE_HEADLESS_PLATFORM', 'headless')))
else:
args.extend(self.palette_manager.args_to_qt)
self.headless = headless
from calibre_extensions import progress_indicator
self.pi = progress_indicator
self._file_open_paths = []
self._file_open_lock = RLock()
QApplication.setOrganizationName('calibre-ebook.com')
QApplication.setOrganizationDomain(QApplication.organizationName())
QApplication.setApplicationVersion(__version__)
QApplication.setApplicationName(APP_UID)
if override_program_name and hasattr(QApplication, 'setDesktopFileName'):
QApplication.setDesktopFileName(override_program_name)
QApplication.setAttribute(Qt.ApplicationAttribute.AA_ShareOpenGLContexts, True) # needed for webengine
QApplication.__init__(self, args)
set_image_allocation_limit()
self.palette_manager.initialize()
icon_resource_manager.initialize()
sh = self.styleHints()
if hasattr(sh, 'setShowShortcutsInContextMenus'):
sh.setShowShortcutsInContextMenus(True)
if ismacos:
from calibre_extensions.cocoa import disable_cocoa_ui_elements
disable_cocoa_ui_elements()
self.setAttribute(Qt.ApplicationAttribute.AA_SynthesizeTouchForUnhandledMouseEvents, False)
try:
base_dir()
except OSError as err:
if not headless:
show_temp_dir_error(err)
raise SystemExit('Failed to create temporary folder')
if DEBUG and not headless:
prints('QPA platform:', self.platformName())
prints('devicePixelRatio:', self.devicePixelRatio())
s = self.primaryScreen()
if s:
prints('logicalDpi:', s.logicalDotsPerInchX(), 'x', s.logicalDotsPerInchY())
prints('physicalDpi:', s.physicalDotsPerInchX(), 'x', s.physicalDotsPerInchY())
if not iswindows:
self.setup_unix_signals()
if islinux or isbsd:
self.setAttribute(Qt.ApplicationAttribute.AA_DontUseNativeMenuBar, 'CALIBRE_NO_NATIVE_MENUBAR' in os.environ)
self.palette_manager.setup_styles()
self.setup_ui_font()
fi = gprefs['font']
if fi is not None:
font = QFont(*(fi[:4]))
s = gprefs.get('font_stretch', None)
if s is not None:
font.setStretch(s)
QApplication.setFont(font)
if not ismacos and not iswindows:
# Qt 5.10.1 on Linux resets the global font on first event loop tick.
# So workaround it by setting the font once again in a timer.
font_from_prefs = self.font()
QTimer.singleShot(0, lambda : QApplication.setFont(font_from_prefs))
self.line_height = max(12, QFontMetrics(self.font()).lineSpacing())
dl = QLocale(get_lang())
if str(dl.bcp47Name()) != 'C':
QLocale.setDefault(dl)
global gui_thread, qt_app
gui_thread = QThread.currentThread()
self._translator = None
self.load_translations()
qt_app = self
if not ismacos:
# OS X uses a native color dialog that does not support custom
# colors
self.color_prefs = color_prefs
self.read_custom_colors()
self.lastWindowClosed.connect(self.save_custom_colors)
if isxp:
error_dialog(None, _('Windows XP not supported'), '<p>' + _(
'calibre versions newer than 2.0 do not run on Windows XP. This is'
' because the graphics toolkit calibre uses (Qt 5) crashes a lot'
' on Windows XP. We suggest you stay with <a href="%s">calibre 1.48</a>'
' which works well on Windows XP.') % 'https://download.calibre-ebook.com/1.48.0/', show=True)
raise SystemExit(1)
if iswindows:
# Prevent text copied to the clipboard from being lost on quit due to
# Qt 5 bug: https://bugreports.qt-project.org/browse/QTBUG-41125
self.aboutToQuit.connect(self.flush_clipboard)
if ismacos:
from calibre_extensions.cocoa import cursor_blink_time
cft = cursor_blink_time()
if cft >= 0:
self.setCursorFlashTime(int(cft))
@property
def using_calibre_style(self) -> bool:
return self.palette_manager.using_calibre_style
@property
def is_dark_theme(self):
return self.palette_manager.is_dark_theme
@property
def emphasis_window_background_color(self):
return (builtin_colors_dark if self.is_dark_theme else builtin_colors_light)['yellow']
@pyqtSlot(int, result=QIcon)
def get_qt_standard_icon(self, standard_pixmap):
return self.palette_manager.get_qt_standard_icon(standard_pixmap)
def safe_restore_geometry(self, widget, geom):
# See https://bugreports.qt.io/browse/QTBUG-77385
if not geom:
return
restored = widget.restoreGeometry(geom)
self.ensure_window_on_screen(widget)
return restored
def ensure_window_on_screen(self, widget):
screen_rect = widget.screen().availableGeometry()
g = widget.geometry()
w = min(screen_rect.width(), g.width())
h = min(screen_rect.height(), g.height())
if w != g.width() or h != g.height():
widget.resize(w, h)
if not widget.geometry().intersects(screen_rect):
w = min(widget.width(), screen_rect.width() - 10)
h = min(widget.height(), screen_rect.height() - 10)
widget.resize(w, h)
widget.move((screen_rect.width() - w) // 2, (screen_rect.height() - h) // 2)
def setup_ui_font(self):
f = QFont(QApplication.font())
q = (f.family(), f.pointSize())
if iswindows:
if q == ('MS Shell Dlg 2', 8): # Qt default setting
# Microsoft recommends the default font be Segoe UI at 9 pt
# https://msdn.microsoft.com/en-us/library/windows/desktop/dn742483(v=vs.85).aspx
f.setFamily('Segoe UI')
f.setPointSize(9)
QApplication.setFont(f)
else:
if q == ('Sans Serif', 9): # Hard coded Qt settings, no user preference detected
f.setPointSize(10)
QApplication.setFont(f)
f = QFontInfo(f)
self.original_font = (f.family(), f.pointSize(), f.weight(), f.italic(), 100)
def flush_clipboard(self):
try:
if self.clipboard().ownsClipboard():
import ctypes
ctypes.WinDLL('ole32.dll').OleFlushClipboard()
except Exception:
import traceback
traceback.print_exc()
def load_builtin_fonts(self, scan_for_fonts=False):
if scan_for_fonts:
from calibre.utils.fonts.scanner import font_scanner
# Start scanning the users computer for fonts
font_scanner
load_builtin_fonts()
@lru_cache(maxsize=256)
def cached_qimage(self, name, device_pixel_ratio=0):
return self.cached_qpixmap(name, device_pixel_ratio).toImage()
@lru_cache(maxsize=256)
def cached_qpixmap(self, name, device_pixel_ratio=0):
# get the actual size of the image since QIcon does not tell us this for
# icons loaded from a theme
path = I(name, allow_user_override=False)
r = QImageReader(path)
ic = QIcon.ic(name)
if not device_pixel_ratio:
device_pixel_ratio = self.devicePixelRatio()
ans = ic.pixmap(r.size())
ans.setDevicePixelRatio(device_pixel_ratio)
return ans
def _send_file_open_events(self):
with self._file_open_lock:
if self._file_open_paths:
if callable(self.file_event_hook):
self.file_event_hook(self._file_open_paths)
self._file_open_paths = []
def get_pending_file_open_events(self):
with self._file_open_lock:
ans = self._file_open_paths
self._file_open_paths = []
return ans
def load_translations(self):
if self._translator is not None:
self.removeTranslator(self._translator)
self._translator = Translator(self)
self.installTranslator(self._translator)
def event(self, e):
etype = e.type()
if etype == QEvent.Type.FileOpen:
added_event = False
qurl = e.url()
if qurl.isLocalFile():
with self._file_open_lock:
path = qurl.toLocalFile()
if os.access(path, os.R_OK):
self._file_open_paths.append(path)
added_event = True
elif qurl.isValid():
if qurl.scheme() == 'calibre':
url = qurl.toString(QUrl.ComponentFormattingOption.FullyEncoded)
with self._file_open_lock:
self._file_open_paths.append(url)
added_event = True
if added_event:
QTimer.singleShot(1000, self._send_file_open_events)
return True
else:
if etype == QEvent.Type.ApplicationPaletteChange:
self.palette_manager.on_qt_palette_change()
return QApplication.event(self, e)
@property
def current_custom_colors(self):
from qt.core import QColorDialog
return [col.getRgb() for col in
(QColorDialog.customColor(i) for i in range(QColorDialog.customCount()))]
@current_custom_colors.setter
def current_custom_colors(self, colors):
from qt.core import QColorDialog
num = min(len(colors), QColorDialog.customCount())
for i in range(num):
QColorDialog.setCustomColor(i, QColor(*colors[i]))
def read_custom_colors(self):
colors = self.color_prefs.get('custom_colors_for_color_dialog', None)
if colors is not None:
self.current_custom_colors = colors
def save_custom_colors(self):
# Qt 5 regression, it no longer saves custom colors
colors = self.current_custom_colors
if colors != self.color_prefs.get('custom_colors_for_color_dialog', None):
self.color_prefs.set('custom_colors_for_color_dialog', colors)
def __enter__(self):
self.setQuitOnLastWindowClosed(False)
def __exit__(self, *args):
self.setQuitOnLastWindowClosed(True)
def setup_unix_signals(self):
setup_unix_signals(self)
def signal_received(self):
try:
os.read(int(self.signal_notifier.socket()), 1024)
except OSError:
return
self.shutdown_signal_received.emit()
_store_app = None
@contextmanager
def sanitize_env_vars():
'''Unset various environment variables that calibre uses. This
is needed to prevent library conflicts when launching external utilities.'''
if islinux and isfrozen:
env_vars = {
'LD_LIBRARY_PATH':'/lib', 'OPENSSL_MODULES': '/lib/ossl-modules',
}
elif iswindows:
env_vars = {'OPENSSL_MODULES': None, 'QTWEBENGINE_DISABLE_SANDBOX': None}
if os.environ.get('CALIBRE_USE_SYSTEM_CERTIFICATES', '') != '1':
env_vars['SSL_CERT_FILE'] = None
elif ismacos:
env_vars = {k:None for k in (
'FONTCONFIG_FILE FONTCONFIG_PATH OPENSSL_ENGINES OPENSSL_MODULES').split()}
if os.environ.get('CALIBRE_USE_SYSTEM_CERTIFICATES', '') != '1':
env_vars['SSL_CERT_FILE'] = None
else:
env_vars = {}
originals = {x:os.environ.get(x, '') for x in env_vars}
changed = {x:False for x in env_vars}
for var, suffix in env_vars.items():
paths = [x for x in originals[var].split(os.pathsep) if x]
npaths = [] if suffix is None else [x for x in paths if x != (sys.frozen_path + suffix)]
if len(npaths) < len(paths):
if npaths:
os.environ[var] = os.pathsep.join(npaths)
else:
del os.environ[var]
changed[var] = True
try:
yield
finally:
for var, orig in originals.items():
if changed[var]:
if orig:
os.environ[var] = orig
elif var in os.environ:
del os.environ[var]
SanitizeLibraryPath = sanitize_env_vars # For old plugins
def open_url(qurl):
if isinstance(qurl, string_or_bytes):
qurl = QUrl(qurl)
scheme = qurl.scheme().lower() or 'file'
import fnmatch
opener = []
with suppress(Exception):
for scheme_pat, spec in tweaks['openers_by_scheme'].items():
if fnmatch.fnmatch(scheme, scheme_pat):
with suppress(Exception):
import shlex
opener = shlex.split(spec)
break
def run_cmd(cmd):
import subprocess
subprocess.Popen(cmd, stdin=subprocess.DEVNULL, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
with sanitize_env_vars():
if opener:
cmd = [x.replace('%u', qurl.toString()) for x in opener]
if DEBUG:
print('Running opener:', cmd)
run_cmd(cmd)
else:
# Qt 5 requires QApplication to be constructed before trying to use
# QDesktopServices::openUrl()
ensure_app()
cmd = ['xdg-open', qurl.toLocalFile() if qurl.isLocalFile() else qurl.toString(QUrl.ComponentFormattingOption.FullyEncoded)]
if isfrozen and QApplication.instance().platformName() == "wayland":
# See https://bugreports.qt.io/browse/QTBUG-119438
run_cmd(cmd)
ok = True
else:
ok = QDesktopServices.openUrl(qurl)
if not ok:
# this happens a lot with Qt 6.5.3. On Wayland, Qt requires
# BOTH a QApplication AND a top level window so it can use the
# xdg activation token system Wayland imposes.
print('QDesktopServices::openUrl() failed for url:', qurl, file=sys.stderr)
if islinux:
if DEBUG:
print('Opening with xdg-open:', cmd)
run_cmd(cmd)
def safe_open_url(qurl):
if isinstance(qurl, string_or_bytes):
qurl = QUrl(qurl)
if qurl.scheme() in ('', 'file'):
path = qurl.toLocalFile()
ext = os.path.splitext(path)[-1].lower()[1:]
if ext in ('exe', 'com', 'cmd', 'bat', 'sh', 'psh', 'ps1', 'vbs', 'js', 'wsf', 'vba', 'py', 'rb', 'pl', 'app'):
prints('Refusing to open file:', path, file=sys.stderr)
return
open_url(qurl)
def get_current_db():
'''
This method will try to return the current database in use by the user as
efficiently as possible, i.e. without constructing duplicate
LibraryDatabase objects.
'''
from calibre.gui2.ui import get_gui
gui = get_gui()
if gui is not None and gui.current_db is not None:
return gui.current_db
from calibre.library import db
return db()
def open_local_file(path):
if iswindows:
with sanitize_env_vars():
os.startfile(os.path.normpath(path))
else:
url = QUrl.fromLocalFile(path)
open_url(url)
_ea_lock = Lock()
def simple_excepthook(t, v, tb):
return sys.__excepthook__(t, v, tb)
def ensure_app(headless=True):
global _store_app
with _ea_lock:
if _store_app is None and QApplication.instance() is None:
args = sys.argv[:1]
has_headless = ismacos or islinux or isbsd
if headless and has_headless:
args += ['-platformpluginpath', plugins_loc, '-platform', os.environ.get('CALIBRE_HEADLESS_PLATFORM', 'headless')]
if ismacos:
os.environ['QT_MAC_DISABLE_FOREGROUND_APPLICATION_TRANSFORM'] = '1'
if headless and iswindows:
QApplication.setAttribute(Qt.ApplicationAttribute.AA_UseSoftwareOpenGL, True)
QApplication.setAttribute(Qt.ApplicationAttribute.AA_ShareOpenGLContexts)
_store_app = QApplication(args)
set_image_allocation_limit()
if headless and has_headless:
_store_app.headless = True
# This is needed because as of PyQt 5.4 if sys.execpthook ==
# sys.__excepthook__ PyQt will abort the application on an
# unhandled python exception in a slot or virtual method. Since ensure_app()
# is used in worker processes for background work like rendering html
# or running a headless browser, we circumvent this as I really
# dont feel like going through all the code and making sure no
# unhandled exceptions ever occur. All the actual GUI apps already
# override sys.excepthook with a proper error handler.
sys.excepthook = simple_excepthook
return _store_app
def destroy_app():
global _store_app
_store_app = None
def app_is_headless():
return getattr(_store_app, 'headless', False)
def must_use_qt(headless=True):
''' This function should be called if you want to use Qt for some non-GUI
task like rendering HTML/SVG or using a headless browser. It will raise a
RuntimeError if using Qt is not possible, which will happen if the current
thread is not the main GUI thread. On linux, it uses a special QPA headless
plugin, so that the X server does not need to be running. '''
global gui_thread
ensure_app(headless=headless)
if gui_thread is None:
gui_thread = QThread.currentThread()
if gui_thread is not QThread.currentThread():
raise RuntimeError('Cannot use Qt in non GUI thread')
def is_ok_to_use_qt():
try:
must_use_qt()
except RuntimeError:
return False
return True
def is_gui_thread():
global gui_thread
return gui_thread is QThread.currentThread()
_rating_font = 'Arial Unicode MS' if iswindows else 'sans-serif'
def rating_font():
global _rating_font
return _rating_font
def elided_text(text, font=None, width=300, pos='middle'):
''' Return a version of text that is no wider than width pixels when
rendered, replacing characters from the left, middle or right (as per pos)
of the string with an ellipsis. Results in a string much closer to the
limit than Qt's elidedText().'''
from qt.core import QApplication, QFontMetrics
if font is None:
font = QApplication.instance().font()
fm = (font if isinstance(font, QFontMetrics) else QFontMetrics(font))
delta = 4
ellipsis = '\u2026'
def remove_middle(x):
mid = len(x) // 2
return x[:max(0, mid - (delta//2))] + ellipsis + x[mid + (delta//2):]
chomp = {'middle':remove_middle, 'left':lambda x:(ellipsis + x[delta:]), 'right':lambda x:(x[:-delta] + ellipsis)}[pos]
while len(text) > delta and fm.horizontalAdvance(text) > width:
text = chomp(text)
return str(text)
if is_running_from_develop:
from calibre.build_forms import build_forms
build_forms(os.path.abspath(os.environ['CALIBRE_DEVELOP_FROM']), check_for_migration=True)
def event_type_name(ev_or_etype):
etype = ev_or_etype.type() if isinstance(ev_or_etype, QEvent) else ev_or_etype
for name, num in iteritems(vars(QEvent)):
if num == etype:
return name
return 'UnknownEventType'
empty_model = QStringListModel([''])
empty_index = empty_model.index(0)
def set_app_uid(val):
import ctypes
from ctypes import HRESULT, wintypes
try:
AppUserModelID = ctypes.windll.shell32.SetCurrentProcessExplicitAppUserModelID
except Exception: # Vista has no app uids
return False
AppUserModelID.argtypes = [wintypes.LPCWSTR]
AppUserModelID.restype = HRESULT
try:
AppUserModelID(str(val))
except Exception as err:
prints('Failed to set app uid with error:', as_unicode(err))
return False
return True
def add_to_recent_docs(path):
from calibre_extensions import winutil
app = QApplication.instance()
winutil.add_to_recent_docs(str(path), app.windows_app_uid)
def make_view_use_window_background(view):
p = view.palette()
p.setColor(QPalette.ColorRole.Base, p.color(QPalette.ColorRole.Window))
p.setColor(QPalette.ColorRole.AlternateBase, p.color(QPalette.ColorRole.Window))
view.setPalette(p)
return view
def timed_print(*a, **kw):
if not DEBUG:
return
from time import monotonic
if not hasattr(timed_print, 'startup_time'):
timed_print.startup_time = monotonic()
print(f'[{monotonic() - timed_print.startup_time:.2f}]', *a, **kw)
def local_path_for_resource(qurl: QUrl, base_qurl: 'QUrl | None' = None) -> str:
if base_qurl and qurl.isRelative():
qurl = base_qurl.resolved(qurl)
if qurl.isLocalFile():
return qurl.toLocalFile()
if qurl.isRelative(): # this means has no scheme
return qurl.path()
return ''
def raise_and_focus(self: QWidget) -> None:
self.raise_()
self.activateWindow()
def raise_without_focus(self: QWidget) -> None:
if QApplication.instance().platformName() == 'wayland':
# On fucking Wayland, we cant raise a dialog without also giving it
# keyboard focus. What a joke.
self.raise_and_focus()
else:
self.raise_()
QWidget.raise_and_focus = raise_and_focus
QWidget.raise_without_focus = raise_without_focus
@contextmanager
def clip_border_radius(painter, rect):
painter.save()
r = gprefs['cover_corner_radius']
if r > 0:
pp = QPainterPath()
pp.addRoundedRect(QRectF(rect), r, r, Qt.SizeMode.RelativeSize if gprefs['cover_corner_radius_unit'] == '%' else Qt.SizeMode.AbsoluteSize)
painter.setClipPath(pp)
try:
yield
finally:
painter.restore()
| 68,303 | Python | .py | 1,527 | 36.330059 | 146 | 0.638644 | kovidgoyal/calibre | 19,243 | 2,250 | 4 | GPL-3.0 | 9/5/2024, 5:13:50 PM (Europe/Amsterdam) |
26,658 | flow_toolbar.py | kovidgoyal_calibre/src/calibre/gui2/flow_toolbar.py | #!/usr/bin/env python
# License: GPL v3 Copyright: 2021, Kovid Goyal <kovid at kovidgoyal.net>
from qt.core import QPoint, QRect, QSize, QSizePolicy, QStyle, QStyleOption, QStylePainter, Qt, QToolBar, QToolButton, QWidget, pyqtSignal
class Separator(QWidget):
def __init__(self, icon_size, parent=None):
super().__init__(parent)
self.desired_height = icon_size.height() * 0.85
def style_option(self):
opt = QStyleOption()
opt.initFrom(self)
opt.state |= QStyle.StateFlag.State_Horizontal
return opt
def sizeHint(self):
width = self.style().pixelMetric(QStyle.PixelMetric.PM_ToolBarSeparatorExtent, self.style_option(), self)
return QSize(width, int(self.devicePixelRatioF() * self.desired_height))
def paintEvent(self, ev):
p = QStylePainter(self)
p.drawPrimitive(QStyle.PrimitiveElement.PE_IndicatorToolBarSeparator, self.style_option())
class Button(QToolButton):
layout_needed = pyqtSignal()
def __init__(self, action, parent=None):
super().__init__(parent)
self.action = action
self.setAutoRaise(True)
action.changed.connect(self.update_state)
self.update_state()
self.clicked.connect(self.action.trigger)
def update_state(self):
ac = self.action
self.setIcon(ac.icon())
self.setToolTip(ac.toolTip() or self.action.text())
self.setEnabled(ac.isEnabled())
self.setCheckable(ac.isCheckable())
self.setChecked(ac.isChecked())
self.setMenu(ac.menu())
old = self.isVisible()
self.setVisible(ac.isVisible())
if self.isVisible() != old:
self.layout_needed.emit()
def __repr__(self):
return f'Button({self.toolTip()})'
class SingleLineToolBar(QToolBar):
def __init__(self, parent=None, icon_size=18):
super().__init__(parent)
self.setIconSize(QSize(icon_size, icon_size))
def add_action(self, ac, popup_mode=QToolButton.ToolButtonPopupMode.DelayedPopup):
self.addAction(ac)
w = self.widgetForAction(ac)
w.setPopupMode(popup_mode)
def add_separator(self):
self.addSeparator()
class LayoutItem:
def __init__(self, w):
self.widget = w
self.sz = sz = w.sizeHint()
self.width = sz.width()
self.height = sz.height()
class Group:
def __init__(self, parent=None, leading_separator=None):
self.items = []
self.width = self.height = 0
self.parent = parent
self.leading_separator = leading_separator
def __bool__(self):
return bool(self.items)
def smart_spacing(self, horizontal=True):
p = self.parent
if p is None:
return -1
if p.isWidgetType():
which = QStyle.PixelMetric.PM_LayoutHorizontalSpacing if horizontal else QStyle.PixelMetric.PM_LayoutVerticalSpacing
return p.style().pixelMetric(which, None, p)
return p.spacing()
def layout_spacing(self, wid, horizontal=True):
ans = self.smart_spacing(horizontal)
if ans != -1:
return ans
return wid.style().layoutSpacing(
QSizePolicy.ControlType.ToolButton,
QSizePolicy.ControlType.ToolButton,
Qt.Orientation.Horizontal if horizontal else Qt.Orientation.Vertical)
def add_widget(self, w):
item = LayoutItem(w)
self.items.append(item)
hs, vs = self.layout_spacing(w), self.layout_spacing(w, False)
if self.items:
self.width += hs
self.width += item.width
self.height = max(vs + item.height, self.height)
class FlowToolBar(QWidget):
def __init__(self, parent=None, icon_size=18):
super().__init__(parent)
self.icon_size = QSize(icon_size, icon_size)
self.setSizePolicy(QSizePolicy.Policy.Preferred, QSizePolicy.Policy.Preferred)
self.items = []
self.button_map = {}
self.applied_geometry = QRect(0, 0, 0, 0)
def add_action(self, ac, popup_mode=QToolButton.ToolButtonPopupMode.DelayedPopup):
w = Button(ac, self)
w.setPopupMode(popup_mode)
w.setIconSize(self.icon_size)
self.button_map[ac] = w
self.items.append(w)
w.layout_needed.connect(self.updateGeometry)
self.updateGeometry()
def add_separator(self):
self.items.append(Separator(self.icon_size, self))
self.updateGeometry()
def hasHeightForWidth(self):
return True
def heightForWidth(self, width):
return self.do_layout(QRect(0, 0, width, 0), apply_geometry=False)
def minimumSize(self):
size = QSize()
for item in self.items:
size = size.expandedTo(item.minimumSize())
return size
sizeHint = minimumSize
def paintEvent(self, ev):
if self.applied_geometry != self.rect():
self.do_layout(self.rect(), apply_geometry=True)
super().paintEvent(ev)
def do_layout(self, rect, apply_geometry=False):
x, y = rect.x(), rect.y()
line_height = 0
def layout_spacing(wid, horizontal=True):
ans = self.smart_spacing(horizontal)
if ans != -1:
return ans
return wid.style().layoutSpacing(
QSizePolicy.ControlType.ToolButton,
QSizePolicy.ControlType.ToolButton,
Qt.Orientation.Horizontal if horizontal else Qt.Orientation.Vertical)
lines, current_line = [], []
gmap = {}
if apply_geometry:
for item in self.items:
if isinstance(item, Separator):
item.setGeometry(0, 0, 0, 0)
def commit_line():
while current_line and isinstance(current_line[-1], Separator):
current_line.pop()
if current_line:
lines.append((line_height, current_line))
groups = []
current_group = Group(self.parent())
for wid in self.items:
if not wid.isVisible() or (not current_group and isinstance(wid, Separator)):
continue
if isinstance(wid, Separator):
groups.append(current_group)
current_group = Group(self.parent(), wid)
else:
current_group.add_widget(wid)
if current_group:
groups.append(current_group)
x = rect.x()
y = 0
line_height = 0
vs = 0
for group in groups:
if current_line and x + group.width >= rect.right():
commit_line()
current_line = []
x = rect.x()
y += group.height
group.leading_separator = None
line_height = 0
if group.leading_separator:
current_line.append(group.leading_separator)
sz = group.leading_separator.sizeHint()
gmap[group.leading_separator] = x, y, sz
x += sz.width() + group.layout_spacing(group.leading_separator)
for item in group.items:
wid = item.widget
if not vs:
vs = group.layout_spacing(wid, False)
if apply_geometry:
gmap[wid] = x, y, item.sz
x += item.width + group.layout_spacing(wid)
current_line.append(wid)
line_height = group.height
commit_line()
if apply_geometry:
self.applied_geometry = rect
for line_height, items in lines:
for wid in items:
x, wy, isz = gmap[wid]
if isz.height() < line_height:
wy += (line_height - isz.height()) // 2
if wid.isVisible():
wid.setGeometry(QRect(QPoint(x, wy), isz))
return y + line_height - rect.y()
def create_flow_toolbar(parent=None, icon_size=18, restrict_to_single_line=False):
if restrict_to_single_line:
return SingleLineToolBar(parent, icon_size)
return FlowToolBar(parent, icon_size)
| 8,186 | Python | .py | 197 | 31.106599 | 138 | 0.598866 | kovidgoyal/calibre | 19,243 | 2,250 | 4 | GPL-3.0 | 9/5/2024, 5:13:50 PM (Europe/Amsterdam) |
26,659 | html_transform_rules.py | kovidgoyal_calibre/src/calibre/gui2/html_transform_rules.py | #!/usr/bin/env python
# License: GPLv3 Copyright: 2016, Kovid Goyal <kovid at kovidgoyal.net>
from qt.core import QComboBox, QFrame, QHBoxLayout, QIcon, QLabel, QLineEdit, QPushButton, QScrollArea, Qt, QToolButton, QVBoxLayout, QWidget, pyqtSignal
from calibre import prepare_string_for_xml
from calibre.ebooks.html_transform_rules import ACTION_MAP, MATCH_TYPE_MAP, export_rules, import_rules, transform_html, validate_rule
from calibre.gui2 import elided_text, error_dialog
from calibre.gui2.convert.xpath_wizard import XPathEdit
from calibre.gui2.css_transform_rules import RulesWidget as RulesWidgetBase
from calibre.gui2.css_transform_rules import Tester as TesterBase
from calibre.gui2.tag_mapper import RuleEditDialog as RuleEditDialogBase
from calibre.gui2.tag_mapper import RuleItem as RuleItemBase
from calibre.gui2.tag_mapper import Rules as RulesBase
from calibre.gui2.tag_mapper import RulesDialog as RulesDialogBase
# Classes for rule edit widget {{{
class TagAction(QWidget):
remove_action = pyqtSignal(object)
def __init__(self, parent=None):
super().__init__(parent)
self.l = l = QVBoxLayout(self)
self.h = h = QHBoxLayout()
l.addLayout(h)
english_sentence = '{action_type} {action_data}'
sentence = _('{action_type} {action_data}')
if set(sentence.split()) != set(english_sentence.split()):
sentence = english_sentence
parts = sentence.split()
for clause in parts:
if clause == '{action_data}':
self.action_data = w = QLineEdit(self)
w.setClearButtonEnabled(True)
elif clause == '{action_type}':
self.action_type = w = QComboBox(self)
for action, ac in ACTION_MAP.items():
w.addItem(ac.short_text, action)
w.currentIndexChanged.connect(self.update_state)
h.addWidget(w)
if clause is not parts[-1]:
h.addWidget(QLabel('\xa0'))
self.h2 = h = QHBoxLayout()
l.addLayout(h)
self.remove_button = b = QToolButton(self)
b.setToolTip(_('Remove this action')), b.setIcon(QIcon.ic('minus.png'))
b.clicked.connect(self.request_remove)
h.addWidget(b)
self.action_desc = la = QLabel('')
la.setWordWrap(True)
la.setTextFormat(Qt.TextFormat.RichText)
h.addWidget(la)
self.sep = sep = QFrame(self)
sep.setFrameShape(QFrame.Shape.HLine)
l.addWidget(sep)
self.update_state()
def request_remove(self):
self.remove_action.emit(self)
@property
def as_dict(self):
return {'type': self.action_type.currentData(), 'data': self.action_data.text()}
@as_dict.setter
def as_dict(self, val):
self.action_data.setText(val.get('data') or '')
at = val.get('type')
if at:
idx = self.action_type.findData(at)
if idx > -1:
self.action_type.setCurrentIndex(idx)
def update_state(self):
val = self.as_dict
ac = ACTION_MAP[val['type']]
self.action_desc.setText(ac.long_text)
if ac.placeholder:
self.action_data.setVisible(True)
self.action_data.setPlaceholderText(ac.placeholder)
else:
self.action_data.setVisible(False)
class ActionsContainer(QScrollArea):
def __init__(self, parent=None):
super().__init__(parent)
self.setWidgetResizable(True)
self.w = w = QWidget()
self.setWidget(w)
w.l = QVBoxLayout(w)
w.l.addStretch(1)
self.all_actions = []
self.new_action()
def new_action(self):
a = TagAction(self)
self.all_actions.append(a)
l = self.w.l
a.remove_action.connect(self.remove_action)
l.insertWidget(l.count() - 1, a)
a.action_type.setFocus(Qt.FocusReason.OtherFocusReason)
return a
def remove_action(self, ac):
if ac in self.all_actions:
self.w.l.removeWidget(ac)
del self.all_actions[self.all_actions.index(ac)]
ac.deleteLater()
def sizeHint(self):
ans = super().sizeHint()
ans.setHeight(ans.height() + 200)
return ans
@property
def as_list(self):
return [t.as_dict for t in self.all_actions]
@as_list.setter
def as_list(self, val):
for ac in tuple(self.all_actions):
self.remove_action(ac)
for entry in val:
self.new_action().as_dict = entry
class GenericEdit(QLineEdit):
def __init__(self, parent=None):
super().__init__(parent)
self.setClearButtonEnabled(True)
@property
def value(self):
return self.text()
@value.setter
def value(self, val):
self.setText(str(val))
class CSSEdit(QWidget):
def __init__(self, parent=None):
super().__init__(parent)
l = QHBoxLayout(self)
l.setContentsMargins(0, 0, 0, 0)
self.edit = le = GenericEdit(self)
l.addWidget(le)
l.addSpacing(5)
self.la = la = QLabel(_('<a href="{}">CSS selector help</a>').format('https://developer.mozilla.org/en-US/docs/Learn/CSS/Building_blocks/Selectors'))
la.setOpenExternalLinks(True)
l.addWidget(la)
self.setPlaceholderText = self.edit.setPlaceholderText
@property
def value(self):
return self.edit.value
@value.setter
def value(self, val):
self.edit.value = val
# }}}
class RuleEdit(QWidget): # {{{
MSG = _('Create the rule to transform HTML tags below')
def __init__(self, parent=None):
QWidget.__init__(self, parent)
self.l = l = QVBoxLayout(self)
self.h = h = QHBoxLayout()
self.la = la = QLabel(self.MSG)
la.setWordWrap(True)
l.addWidget(la)
l.addLayout(h)
english_sentence = '{preamble} {match_type}'
sentence = _('{preamble} {match_type}')
if set(sentence.split()) != set(english_sentence.split()):
sentence = english_sentence
parts = sentence.split()
for clause in parts:
if clause == '{preamble}':
self.preamble = w = QLabel(_('If the tag'))
elif clause == '{match_type}':
self.match_type = w = QComboBox(self)
for action, m in MATCH_TYPE_MAP.items():
w.addItem(m.text, action)
w.currentIndexChanged.connect(self.update_state)
h.addWidget(w)
if clause is not parts[-1]:
h.addWidget(QLabel('\xa0'))
h.addStretch(1)
self.generic_query = gq = GenericEdit(self)
self.css_query = cq = CSSEdit(self)
self.xpath_query = xq = XPathEdit(self, object_name='html_transform_rules_xpath', show_msg=False)
l.addWidget(gq), l.addWidget(cq), l.addWidget(xq)
self.thenl = QLabel(_('Then:'))
l.addWidget(self.thenl)
self.actions = a = ActionsContainer(self)
l.addWidget(a)
self.add_button = b = QPushButton(QIcon.ic('plus.png'), _('Add another action'))
b.clicked.connect(self.actions.new_action)
l.addWidget(b)
self.update_state()
def sizeHint(self):
a = QWidget.sizeHint(self)
a.setHeight(a.height() + 375)
a.setWidth(a.width() + 125)
return a
@property
def current_query_widget(self):
return {'css': self.css_query, 'xpath': self.xpath_query}.get(self.match_type.currentData(), self.generic_query)
def update_state(self):
r = self.rule
mt = r['match_type']
self.generic_query.setVisible(False), self.css_query.setVisible(False), self.xpath_query.setVisible(False)
self.current_query_widget.setVisible(True)
self.current_query_widget.setPlaceholderText(MATCH_TYPE_MAP[mt].placeholder)
@property
def rule(self):
try:
return {
'match_type': self.match_type.currentData(),
'query': self.current_query_widget.value,
'actions': self.actions.as_list,
}
except Exception:
import traceback
traceback.print_exc()
raise
@rule.setter
def rule(self, rule):
def sc(name):
c = getattr(self, name)
c.setCurrentIndex(max(0, c.findData(str(rule.get(name, '')))))
sc('match_type')
self.current_query_widget.value = str(rule.get('query', '')).strip()
self.actions.as_list = rule.get('actions') or []
self.update_state()
def validate(self):
rule = self.rule
title, msg = validate_rule(rule)
if msg is not None and title is not None:
error_dialog(self, title, msg, show=True)
return False
return True
# }}}
class RuleEditDialog(RuleEditDialogBase): # {{{
PREFS_NAME = 'edit-html-transform-rule'
DIALOG_TITLE = _('Edit rule')
RuleEditClass = RuleEdit
# }}}
class RuleItem(RuleItemBase): # {{{
@staticmethod
def text_from_rule(rule, parent):
try:
query = elided_text(rule['query'], font=parent.font(), width=200, pos='right')
text = _('If the tag <b>{match_type}</b> <b>{query}</b>').format(
match_type=MATCH_TYPE_MAP[rule['match_type']].text, query=prepare_string_for_xml(query))
for action in rule['actions']:
text += '<br>' + ACTION_MAP[action['type']].short_text
if action.get('data'):
ad = elided_text(action['data'], font=parent.font(), width=200, pos='right')
text += f' <code>{prepare_string_for_xml(ad)}</code>'
except Exception:
import traceback
traceback.print_exc()
text = _('This rule is invalid, please remove it')
return text
# }}}
class Rules(RulesBase): # {{{
RuleItemClass = RuleItem
RuleEditDialogClass = RuleEditDialog
ACTION_KEY = 'actions'
MSG = _('You can specify rules to transform HTML here. Click the "Add rule" button'
' below to get started.')
# }}}
class Tester(TesterBase): # {{{
DIALOG_TITLE = _('Test HTML transform rules')
PREFS_NAME = 'test-html-transform-rules'
LABEL = _('Enter an HTML document below and click the "Test" button')
SYNTAX = 'html'
RESULTS = '<!-- %s -->\n\n' % _('Resulting HTML')
def compile_rules(self, rules):
return rules
def do_test(self):
changed, html = transform_html('\n' + self.value + '\n', self.rules)
self.set_result(html)
# }}}
class RulesDialog(RulesDialogBase): # {{{
DIALOG_TITLE = _('Edit HTML transform rules')
PREFS_NAME = 'edit-html-transform-rules'
PREFS_OBJECT_NAME = 'html-transform-rules'
RulesClass = Rules
TesterClass = Tester
def extra_bottom_widget(self):
self.scope_cb = cb = QComboBox()
cb.addItem(_('Current HTML file'), 'current')
cb.addItem(_('All HTML files'), 'all')
cb.addItem(_('Open HTML files'), 'open')
cb.addItem(_('Selected HTML files'), 'selected')
return cb
@property
def transform_scope(self):
return self.scope_cb.currentData()
@transform_scope.setter
def transform_scope(self, val):
idx = self.scope_cb.findData(val)
self.scope_cb.setCurrentIndex(max(0, idx))
# }}}
class HtmlRulesWidget(RulesWidgetBase): # {{{
PREFS_NAME = 'html-transform-rules'
INITIAL_FILE_NAME = 'html-rules.txt'
DIR_SAVE_NAME = 'export-html-transform-rules'
export_func = export_rules
import_func = import_rules
TesterClass = Tester
RulesClass = Rules
# }}}
if __name__ == '__main__':
from calibre.gui2 import Application
app = Application([])
d = RulesDialog()
d.rules = [
{'match_type':'xpath', 'query':'//h:h2', 'actions':[{'type': 'remove'}]},
]
d.exec()
from pprint import pprint
pprint(d.rules)
del d, app
| 12,068 | Python | .py | 304 | 31.299342 | 157 | 0.611971 | kovidgoyal/calibre | 19,243 | 2,250 | 4 | GPL-3.0 | 9/5/2024, 5:13:50 PM (Europe/Amsterdam) |
26,660 | markdown_editor.py | kovidgoyal_calibre/src/calibre/gui2/markdown_editor.py | #!/usr/bin/env python
# License: GPLv3 Copyright: 2023, un_pogaz <un.pogaz@gmail.com>
import os
from qt.core import QDialog, QDialogButtonBox, QPlainTextEdit, QSize, Qt, QTabWidget, QUrl, QVBoxLayout, QWidget, pyqtSignal
from calibre.gui2 import gprefs, safe_open_url
from calibre.gui2.book_details import resolved_css
from calibre.gui2.widgets2 import HTMLDisplay
from calibre.library.comments import markdown as get_markdown
class Preview(HTMLDisplay):
def __init__(self, parent=None):
super().__init__(parent)
self.setDefaultStyleSheet(resolved_css())
self.setTabChangesFocus(True)
self.base_url = None
def loadResource(self, rtype, qurl):
if self.base_url is not None and qurl.isRelative():
qurl = self.base_url.resolved(qurl)
return super().loadResource(rtype, qurl)
class MarkdownEdit(QPlainTextEdit):
smarten_punctuation = pyqtSignal()
def __init__(self, parent=None):
super().__init__(parent)
from calibre.gui2.markdown_syntax_highlighter import MarkdownHighlighter
self.highlighter = MarkdownHighlighter(self.document())
def contextMenuEvent(self, ev):
m = self.createStandardContextMenu()
m.addSeparator()
m.addAction(_('Smarten punctuation'), self.smarten_punctuation.emit)
m.exec(ev.globalPos())
class MarkdownEditDialog(QDialog):
def __init__(self, parent, text, column_name=None, base_url=None):
QDialog.__init__(self, parent)
self.setObjectName("MarkdownEditDialog")
self.setWindowTitle(_("Edit Markdown"))
self.verticalLayout = l = QVBoxLayout(self)
self.textbox = editor = Editor(self)
editor.set_base_url(base_url)
self.buttonBox = bb = QDialogButtonBox(QDialogButtonBox.StandardButton.Ok | QDialogButtonBox.StandardButton.Cancel, self)
bb.accepted.connect(self.accept)
bb.rejected.connect(self.reject)
l.addWidget(editor)
l.addWidget(bb)
# Remove help icon on title bar
icon = self.windowIcon()
self.setWindowFlags(self.windowFlags()&(~Qt.WindowType.WindowContextHelpButtonHint))
self.setWindowIcon(icon)
self.textbox.markdown =text
# self.textbox.wyswyg_dirtied()
if column_name:
self.setWindowTitle(_('Edit "{0}"').format(column_name))
self.restore_geometry(gprefs, 'markdown_edit_dialog_geom')
def sizeHint(self):
return QSize(650, 600)
def accept(self):
self.save_geometry(gprefs, 'markdown_edit_dialog_geom')
QDialog.accept(self)
def reject(self):
self.save_geometry(gprefs, 'markdown_edit_dialog_geom')
QDialog.reject(self)
def closeEvent(self, ev):
self.save_geometry(gprefs, 'markdown_edit_dialog_geom')
return QDialog.closeEvent(self, ev)
@property
def text(self):
return self.textbox.markdown
@text.setter
def text(self, val):
self.textbox.markdown = val or ''
class Editor(QWidget): # {{{
def __init__(self, parent=None):
QWidget.__init__(self, parent)
self.base_url = None
self._layout = QVBoxLayout(self)
self.setLayout(self._layout)
self.tabs = QTabWidget(self)
self.tabs.setTabPosition(QTabWidget.TabPosition.South)
self._layout.addWidget(self.tabs)
self.editor = MarkdownEdit(self)
self.editor.smarten_punctuation.connect(self.smarten_punctuation)
self.preview = Preview(self)
self.preview.anchor_clicked.connect(self.link_clicked)
self.tabs.addTab(self.editor, _('&Markdown source'))
self.tabs.addTab(self.preview, _('&Preview'))
self.tabs.currentChanged[int].connect(self.change_tab)
self.layout().setContentsMargins(0, 0, 0, 0)
def link_clicked(self, qurl):
safe_open_url(qurl)
def set_base_url(self, qurl):
self.base_url = qurl
self.preview.base_url = self.base_url
def set_minimum_height_for_editor(self, val):
self.editor.setMinimumHeight(val)
@property
def markdown(self):
return self.editor.toPlainText().strip()
@markdown.setter
def markdown(self, v):
self.editor.setPlainText(str(v or ''))
if self.tab == 'preview':
self.update_preview()
def change_tab(self, index):
if index == 1: # changing to preview
self.update_preview()
def update_preview(self):
html = get_markdown(self.editor.toPlainText().strip())
val = f'''\
<html>
<head></head>
<body class="vertical">
<div>{html}</div>
</body>
<html>'''
self.preview.setHtml(val)
@property
def tab(self):
return 'code' if self.tabs.currentWidget() is self.editor else 'preview'
@tab.setter
def tab(self, val):
self.tabs.setCurrentWidget(self.preview if val == 'preview' else self.editor)
def set_readonly(self, val):
self.editor.setReadOnly(bool(val))
def hide_tabs(self):
self.tabs.tabBar().setVisible(False)
def smarten_punctuation(self):
from calibre.ebooks.conversion.preprocess import smarten_punctuation
markdown = self.markdown
newmarkdown = smarten_punctuation(markdown)
if markdown != newmarkdown:
self.markdown = newmarkdown
# }}}
if __name__ == '__main__':
from calibre.gui2 import Application
app = Application([])
w = Editor()
w.set_base_url(QUrl.fromLocalFile(os.getcwd()))
w.resize(800, 600)
w.setWindowFlag(Qt.WindowType.Dialog)
w.show()
w.markdown = '''\
normal& *italic&* **bold&** ***bold-italic*** `code` [link](https://calibre-ebook.com) <span style="font-weight: bold; color:red">span</span>
> Blockquotes
if '>'+' '*4 in string:
pre_block()
1. list 1
1. list 1.1
2. list 1.2
2. list 2
***
* list
- list
# Headers 1
## Headers 2
### Headers 3
#### Headers 4
##### Headers 5
###### Headers 6
'''
app.exec()
# print(w.markdown)
| 6,118 | Python | .py | 159 | 31.427673 | 156 | 0.657133 | kovidgoyal/calibre | 19,243 | 2,250 | 4 | GPL-3.0 | 9/5/2024, 5:13:50 PM (Europe/Amsterdam) |
26,661 | tools.py | kovidgoyal_calibre/src/calibre/gui2/tools.py | #!/usr/bin/env python
__license__ = 'GPL v3'
__copyright__ = '2008, Kovid Goyal kovid@kovidgoyal.net'
__docformat__ = 'restructuredtext en'
'''
Logic for setting up conversion jobs
'''
import os
from qt.core import QDialog, QProgressDialog, QTimer
from calibre.customize.conversion import OptionRecommendation
from calibre.ebooks.conversion.config import (
GuiRecommendations,
NoSupportedInputFormats,
get_input_format_for_book,
load_defaults,
load_specifics,
save_specifics,
)
from calibre.gui2 import question_dialog, warning_dialog
from calibre.gui2.convert import bulk_defaults_for_input_format
from calibre.gui2.convert.bulk import BulkConfig
from calibre.gui2.convert.metadata import create_cover_file, create_opf_file
from calibre.gui2.convert.single import Config as SingleConfig
from calibre.ptempfile import PersistentTemporaryFile
from calibre.utils.config import prefs
from polyglot.builtins import as_bytes
def convert_single_ebook(parent, db, book_ids, auto_conversion=False, # {{{
out_format=None, show_no_format_warning=True):
changed = False
jobs = []
bad = []
total = len(book_ids)
if total == 0:
return None, None, None
for i, book_id in enumerate(book_ids):
temp_files = []
try:
d = SingleConfig(parent, db, book_id, None, out_format)
if auto_conversion:
d.accept()
result = QDialog.DialogCode.Accepted
else:
result = d.exec()
if result == QDialog.DialogCode.Accepted:
# if not convert_existing(parent, db, [book_id], d.output_format):
# continue
mi = db.get_metadata(book_id, True)
in_file = PersistentTemporaryFile('.'+d.input_format)
with in_file:
input_fmt = db.original_fmt(book_id, d.input_format).lower()
same_fmt = input_fmt == d.output_format.lower()
db.copy_format_to(book_id, input_fmt, in_file,
index_is_id=True)
out_file = PersistentTemporaryFile('.' + d.output_format)
out_file.write(as_bytes(d.output_format))
out_file.close()
temp_files = [in_file]
try:
dtitle = str(mi.title)
except:
dtitle = repr(mi.title)
desc = _('Convert book %(num)d of %(total)d (%(title)s)') % \
{'num':i + 1, 'total':total, 'title':dtitle}
recs = d.recommendations
if d.opf_file is not None:
recs.append(('read_metadata_from_opf', d.opf_file.name,
OptionRecommendation.HIGH))
temp_files.append(d.opf_file)
if d.cover_file is not None:
recs.append(('cover', d.cover_file.name,
OptionRecommendation.HIGH))
temp_files.append(d.cover_file)
args = [in_file.name, out_file.name, recs]
temp_files.append(out_file)
func = 'gui_convert_override'
parts = []
if not auto_conversion and d.manually_fine_tune_toc:
parts.append('manually_fine_tune_toc')
if same_fmt:
parts.append('same_fmt')
if parts:
func += ':%s'%(';'.join(parts))
jobs.append((func, args, desc, d.output_format.upper(), book_id, temp_files))
changed = True
d.break_cycles()
except NoSupportedInputFormats as nsif:
bad.append((book_id, nsif.available_formats))
if bad and show_no_format_warning:
if len(bad) == 1 and not bad[0][1]:
title = db.title(bad[0][0], True)
warning_dialog(parent, _('Could not convert'), '<p>'+ _(
'Could not convert <b>%s</b> as it has no e-book files. If you '
'think it should have files, but calibre is not finding '
'them, that is most likely because you moved the book\'s '
'files around outside of calibre. You will need to find those files '
'and re-add them to calibre.')%title, show=True)
else:
res = []
for id, available_formats in bad:
title = db.title(id, True)
if available_formats:
msg = _('No supported formats (Available formats: %s)')%(
', '.join(available_formats))
else:
msg = _('This book has no actual e-book files')
res.append('%s - %s'%(title, msg))
msg = '%s' % '\n'.join(res)
warning_dialog(parent, _('Could not convert some books'),
(
_('Could not convert the book because no supported source format was found')
if len(res) == 1 else
_('Could not convert {num} of {tot} books, because no supported source formats were found.')
).format(num=len(res), tot=total),
msg).exec()
return jobs, changed, bad
# }}}
# Bulk convert {{{
def convert_bulk_ebook(parent, queue, db, book_ids, out_format=None, args=[]):
total = len(book_ids)
if total == 0:
return None, None, None
has_saved_settings = db.has_conversion_options(book_ids)
d = BulkConfig(parent, db, out_format,
has_saved_settings=has_saved_settings, book_ids=book_ids)
if d.exec() != QDialog.DialogCode.Accepted:
return None
output_format = d.output_format
user_recs = d.recommendations
book_ids = convert_existing(parent, db, book_ids, output_format)
use_saved_single_settings = d.opt_individual_saved_settings.isChecked()
return QueueBulk(parent, book_ids, output_format, queue, db, user_recs,
args, use_saved_single_settings=use_saved_single_settings)
class QueueBulk(QProgressDialog):
def __init__(self, parent, book_ids, output_format, queue, db, user_recs,
args, use_saved_single_settings=True):
QProgressDialog.__init__(self, '',
None, 0, len(book_ids), parent)
self.setWindowTitle(_('Queueing books for bulk conversion'))
self.book_ids, self.output_format, self.queue, self.db, self.args, self.user_recs = \
book_ids, output_format, queue, db, args, user_recs
self.parent = parent
self.use_saved_single_settings = use_saved_single_settings
self.i, self.bad, self.jobs, self.changed = 0, [], [], False
QTimer.singleShot(0, self.do_book)
self.exec()
def do_book(self):
if self.i >= len(self.book_ids):
return self.do_queue()
book_id = self.book_ids[self.i]
self.i += 1
temp_files = []
try:
input_format = get_input_format_for_book(self.db, book_id, None)[0]
input_fmt = self.db.original_fmt(book_id, input_format).lower()
same_fmt = input_fmt == self.output_format.lower()
mi, opf_file = create_opf_file(self.db, book_id)
in_file = PersistentTemporaryFile('.'+input_format)
with in_file:
self.db.copy_format_to(book_id, input_fmt, in_file,
index_is_id=True)
out_file = PersistentTemporaryFile('.' + self.output_format)
out_file.write(as_bytes(self.output_format))
out_file.close()
temp_files = [in_file]
combined_recs = GuiRecommendations()
default_recs = bulk_defaults_for_input_format(input_format)
for key in default_recs:
combined_recs[key] = default_recs[key]
if self.use_saved_single_settings:
specific_recs = load_specifics(self.db, book_id)
for key in specific_recs:
combined_recs[key] = specific_recs[key]
for item in self.user_recs:
combined_recs[item[0]] = item[1]
save_specifics(self.db, book_id, combined_recs)
lrecs = list(combined_recs.to_recommendations())
from calibre.customize.ui import plugin_for_output_format
op = plugin_for_output_format(self.output_format)
if op and op.recommendations:
prec = {x[0] for x in op.recommendations}
for i, r in enumerate(list(lrecs)):
if r[0] in prec:
lrecs[i] = (r[0], r[1], OptionRecommendation.HIGH)
cover_file = create_cover_file(self.db, book_id)
if opf_file is not None:
lrecs.append(('read_metadata_from_opf', opf_file.name,
OptionRecommendation.HIGH))
temp_files.append(opf_file)
if cover_file is not None:
lrecs.append(('cover', cover_file.name,
OptionRecommendation.HIGH))
temp_files.append(cover_file)
for x in list(lrecs):
if x[0] == 'debug_pipeline':
lrecs.remove(x)
try:
dtitle = str(mi.title)
except:
dtitle = repr(mi.title)
if len(dtitle) > 50:
dtitle = dtitle[:50].rpartition(' ')[0]+'...'
self.setLabelText(_('Queueing ')+dtitle)
desc = _('Convert book %(num)d of %(tot)d (%(title)s)') % dict(
num=self.i, tot=len(self.book_ids), title=dtitle)
args = [in_file.name, out_file.name, lrecs]
temp_files.append(out_file)
func = 'gui_convert_override'
if same_fmt:
func += ':same_fmt'
self.jobs.append((func, args, desc, self.output_format.upper(), book_id, temp_files))
self.changed = True
self.setValue(self.i)
except NoSupportedInputFormats:
self.bad.append(book_id)
QTimer.singleShot(0, self.do_book)
def do_queue(self):
self.hide()
if self.bad != []:
res = []
for id in self.bad:
title = self.db.title(id, True)
res.append('%s'%title)
msg = '%s' % '\n'.join(res)
warning_dialog(self.parent, _('Could not convert some books'),
_('Could not convert %(num)d of %(tot)d books, because no suitable '
'source format was found.') % dict(num=len(res), tot=len(self.book_ids)),
msg).exec()
self.parent = None
self.jobs.reverse()
self.queue(self.jobs, self.changed, self.bad, *self.args)
# }}}
def fetch_scheduled_recipe(arg): # {{{
fmt = prefs['output_format'].lower()
# Never use AZW3 for periodicals...
if fmt == 'azw3':
fmt = 'mobi'
pt = PersistentTemporaryFile(suffix='_recipe_out.%s'%fmt.lower())
pt.close()
recs = []
ps = load_defaults('page_setup')
if 'output_profile' in ps:
recs.append(('output_profile', ps['output_profile'],
OptionRecommendation.HIGH))
for edge in ('left', 'top', 'bottom', 'right'):
edge = 'margin_' + edge
if edge in ps:
recs.append((edge, ps[edge], OptionRecommendation.HIGH))
lf = load_defaults('look_and_feel')
if lf.get('base_font_size', 0.0) != 0.0:
recs.append(('base_font_size', lf['base_font_size'],
OptionRecommendation.HIGH))
recs.append(('keep_ligatures', lf.get('keep_ligatures', False),
OptionRecommendation.HIGH))
lr = load_defaults('lrf_output')
if lr.get('header', False):
recs.append(('header', True, OptionRecommendation.HIGH))
recs.append(('header_format', '%t', OptionRecommendation.HIGH))
epub = load_defaults('epub_output')
if epub.get('epub_flatten', False):
recs.append(('epub_flatten', True, OptionRecommendation.HIGH))
if fmt == 'pdf':
pdf = load_defaults('pdf_output')
from calibre.customize.ui import plugin_for_output_format
p = plugin_for_output_format('pdf')
for opt in p.options:
recs.append((opt.option.name, pdf.get(opt.option.name, opt.recommended_value), OptionRecommendation.HIGH))
args = [arg['urn'], pt.name, recs]
if arg['username'] is not None:
recs.append(('username', arg['username'], OptionRecommendation.HIGH))
if arg['password'] is not None:
recs.append(('password', arg['password'], OptionRecommendation.HIGH))
if arg.get('recipe_specific_options', None):
serialized = []
for name, val in arg['recipe_specific_options'].items():
serialized.append(f'{name}:{val}')
recs.append(('recipe_specific_option', serialized, OptionRecommendation.HIGH))
return 'gui_convert_recipe', args, _('Fetch news from %s')%arg['title'], fmt.upper(), [pt]
# }}}
def generate_catalog(parent, dbspec, ids, device_manager, db): # {{{
from calibre.gui2.dialogs.catalog import Catalog
# Build the Catalog dialog in gui2.dialogs.catalog
d = Catalog(parent, dbspec, ids, db)
if d.exec() != QDialog.DialogCode.Accepted:
return None
# Create the output file
out = PersistentTemporaryFile(suffix='_catalog_out.'+d.catalog_format.lower())
# Profile the connected device
# Parallel initialization in calibre.db.cli.cmd_catalog
connected_device = {
'is_device_connected': device_manager.is_device_present,
'kind': device_manager.connected_device_kind,
'name': None,
'save_template': None,
'serial': None,
'storage': None
}
if device_manager.is_device_present:
device = device_manager.device
connected_device['name'] = device.get_gui_name()
try:
storage = []
if device._main_prefix:
storage.append(os.path.join(device._main_prefix, device.EBOOK_DIR_MAIN))
if device._card_a_prefix:
storage.append(os.path.join(device._card_a_prefix, device.EBOOK_DIR_CARD_A))
if device._card_b_prefix:
storage.append(os.path.join(device._card_b_prefix, device.EBOOK_DIR_CARD_B))
connected_device['storage'] = storage
connected_device['serial'] = device.detected_device.serial if \
hasattr(device.detected_device,'serial') else None
connected_device['save_template'] = device.save_template()
except:
pass
# These args are passed inline to gui2.convert.gui_conversion:gui_catalog
args = [
d.catalog_format,
d.catalog_title,
dbspec,
ids,
out.name,
d.catalog_sync,
d.fmt_options,
connected_device
]
out.close()
# This returns to gui2.actions.catalog:generate_catalog()
# Which then calls gui2.convert.gui_conversion:gui_catalog() with the args inline
return 'gui_catalog', args, _('Generate catalog'), out.name, d.catalog_sync, \
d.catalog_title
# }}}
def convert_existing(parent, db, book_ids, output_format): # {{{
already_converted_ids = []
already_converted_titles = []
for book_id in book_ids:
if db.has_format(book_id, output_format, index_is_id=True):
already_converted_ids.append(book_id)
already_converted_titles.append(db.get_metadata(book_id, True).title)
if already_converted_ids:
if not question_dialog(parent, _('Convert existing'),
_('The following books have already been converted to the %s format. '
'Do you wish to reconvert them?') % output_format.upper(),
det_msg='\n'.join(already_converted_titles), skip_dialog_name='confirm_bulk_reconvert'):
book_ids = [x for x in book_ids if x not in already_converted_ids]
return book_ids
# }}}
| 16,209 | Python | .py | 345 | 35.292754 | 118 | 0.577352 | kovidgoyal/calibre | 19,243 | 2,250 | 4 | GPL-3.0 | 9/5/2024, 5:13:50 PM (Europe/Amsterdam) |
26,662 | ebook_download.py | kovidgoyal_calibre/src/calibre/gui2/ebook_download.py | __license__ = 'GPL 3'
__copyright__ = '2011, John Schember <john@nachtimwald.com>'
__docformat__ = 'restructuredtext en'
import os
import shutil
import time
from contextlib import closing
from mechanize import MozillaCookieJar
from calibre import browser
from calibre.ebooks import BOOK_EXTENSIONS
from calibre.gui2 import Dispatcher, gprefs
from calibre.gui2.dialogs.message_box import MessageBox
from calibre.gui2.threaded_jobs import ThreadedJob
from calibre.ptempfile import PersistentTemporaryDirectory
from calibre.utils.filenames import ascii_filename
from calibre.web import get_download_filename_from_response
from polyglot.builtins import as_unicode, string_or_bytes
class DownloadInfo(MessageBox):
def __init__(self, filename, parent=None):
MessageBox.__init__(
self, MessageBox.INFO, _('Downloading book'), _(
'The book {0} will be downloaded and added to your'
' calibre library automatically.').format(filename),
show_copy_button=False, parent=parent
)
self.toggle_checkbox.setChecked(True)
self.toggle_checkbox.setVisible(True)
self.toggle_checkbox.setText(_('Show this message again'))
self.toggle_checkbox.toggled.connect(self.show_again_changed)
self.resize_needed.emit()
def show_again_changed(self):
gprefs.set('show_get_books_download_info', self.toggle_checkbox.isChecked())
def show_download_info(filename, parent=None):
if not gprefs.get('show_get_books_download_info', True):
return
DownloadInfo(filename, parent).exec()
def get_download_filename(response):
filename = get_download_filename_from_response(response)
filename, ext = os.path.splitext(filename)
filename = filename[:60] + ext
filename = ascii_filename(filename)
return filename
def download_file(url, cookie_file=None, filename=None, create_browser=None):
if url.startswith('//'):
url = 'https:' + url
try:
br = browser() if create_browser is None else create_browser()
except NotImplementedError:
br = browser()
br.set_debug_http(True)
if cookie_file:
cj = MozillaCookieJar()
cj.load(cookie_file)
br.set_cookiejar(cj)
with closing(br.open(url)) as r:
if not filename:
filename = get_download_filename(r)
temp_path = os.path.join(PersistentTemporaryDirectory(), filename)
with open(temp_path, 'w+b') as tf:
shutil.copyfileobj(r, tf)
dfilename = tf.name
return dfilename
class EbookDownload:
def __call__(self, gui, cookie_file=None, url='', filename='', save_loc='', add_to_lib=True, tags=[], create_browser=None,
log=None, abort=None, notifications=None):
dfilename = ''
try:
dfilename = self._download(cookie_file, url, filename, save_loc, add_to_lib, create_browser)
self._add(dfilename, gui, add_to_lib, tags)
self._save_as(dfilename, save_loc)
finally:
try:
if dfilename:
os.remove(dfilename)
except:
pass
def _download(self, cookie_file, url, filename, save_loc, add_to_lib, create_browser):
if not url:
raise Exception(_('No file specified to download.'))
if not save_loc and not add_to_lib:
# Nothing to do.
return ''
return download_file(url, cookie_file, filename, create_browser=create_browser)
def _add(self, filename, gui, add_to_lib, tags):
if not add_to_lib or not filename:
return
from calibre.ebooks.metadata.meta import get_metadata
from calibre.ebooks.metadata.worker import run_import_plugins
from calibre.ptempfile import TemporaryDirectory
with TemporaryDirectory() as tdir:
path = run_import_plugins((filename,), time.monotonic_ns(), tdir)[0]
ext = os.path.splitext(path)[1][1:].lower()
if ext not in BOOK_EXTENSIONS:
raise Exception(_('{} is not a supported e-book format').format(ext.upper()))
with open(path, 'rb') as f:
mi = get_metadata(f, ext, force_read_metadata=True)
mi.tags.extend(tags)
db = gui.current_db
if gprefs.get('tag_map_on_add_rules'):
from calibre.ebooks.metadata.tag_mapper import map_tags
mi.tags = map_tags(mi.tags, gprefs['tag_map_on_add_rules'])
if gprefs.get('author_map_on_add_rules'):
from calibre.ebooks.metadata.author_mapper import compile_rules as acr
from calibre.ebooks.metadata.author_mapper import map_authors
author_map_rules = acr(gprefs['author_map_on_add_rules'])
new_authors = map_authors(mi.authors, author_map_rules)
if new_authors != mi.authors:
mi.authors = new_authors
mi.author_sort = db.new_api.author_sort_from_authors(mi.authors)
book_id = db.create_book_entry(mi)
db.new_api.add_format(book_id, ext.upper(), path)
gui.library_view.model().books_added(1)
gui.library_view.model().count_changed()
def _save_as(self, dfilename, save_loc):
if not save_loc or not dfilename:
return
shutil.copy(dfilename, save_loc)
gui_ebook_download = EbookDownload()
def start_ebook_download(callback, job_manager, gui, cookie_file=None, url='', filename='', save_loc='', add_to_lib=True, tags=[], create_browser=None):
description = _('Downloading %s') % as_unicode(filename or url, errors='replace')
job = ThreadedJob('ebook_download', description, gui_ebook_download, (
gui, cookie_file, url, filename, save_loc, add_to_lib, tags, create_browser), {},
callback, max_concurrent_count=2, killable=False)
job_manager.run_threaded_job(job)
class EbookDownloadMixin:
def __init__(self, *args, **kwargs):
pass
def download_ebook(self, url='', cookie_file=None, filename='', save_loc='', add_to_lib=True, tags=[], create_browser=None):
if tags:
if isinstance(tags, string_or_bytes):
tags = tags.split(',')
start_ebook_download(Dispatcher(self.downloaded_ebook), self.job_manager, self, cookie_file, url, filename, save_loc, add_to_lib, tags, create_browser)
self.status_bar.show_message(_('Downloading') + ' ' + as_unicode(filename or url, errors='replace'), 3000)
def downloaded_ebook(self, job):
if job.failed:
self.job_exception(job, dialog_title=_('Failed to download e-book'))
return
self.status_bar.show_message(job.description + ' ' + _('finished'), 5000)
| 6,817 | Python | .py | 138 | 40.318841 | 159 | 0.647811 | kovidgoyal/calibre | 19,243 | 2,250 | 4 | GPL-3.0 | 9/5/2024, 5:13:50 PM (Europe/Amsterdam) |
26,663 | cover_flow.py | kovidgoyal_calibre/src/calibre/gui2/cover_flow.py | #!/usr/bin/env python
__license__ = 'GPL v3'
__copyright__ = '2008, Kovid Goyal kovid@kovidgoyal.net'
__docformat__ = 'restructuredtext en'
'''
Module to implement the Cover Flow feature
'''
import os
import sys
import time
from qt.core import (
QAction,
QApplication,
QDialog,
QFont,
QImage,
QItemSelectionModel,
QKeySequence,
QLabel,
QSize,
QSizePolicy,
QStackedLayout,
Qt,
QTimer,
pyqtSignal,
)
from calibre.constants import islinux
from calibre.ebooks.metadata import authors_to_string, rating_to_stars
from calibre.gui2 import config, gprefs, rating_font
from calibre_extensions import pictureflow
MIN_SIZE = QSize(300, 150)
class EmptyImageList(pictureflow.FlowImages):
def __init__(self):
pictureflow.FlowImages.__init__(self)
class FileSystemImages(pictureflow.FlowImages):
def __init__(self, dirpath):
pictureflow.FlowImages.__init__(self)
self.images = []
self.captions = []
self.subtitles = []
for f in os.listdir(dirpath):
f = os.path.join(dirpath, f)
img = QImage(f)
if not img.isNull():
self.images.append(img)
self.captions.append(os.path.basename(f))
self.subtitles.append('%d bytes'%os.stat(f).st_size)
def count(self):
return len(self.images)
def image(self, index):
return self.images[index]
def caption(self, index):
return self.captions[index]
def subtitle(self, index):
return self.subtitles[index]
def currentChanged(self, index):
print('current changed:', index)
class DummyImageList(pictureflow.FlowImages):
def __init__(self):
pictureflow.FlowImages.__init__(self)
self.num = 40000
i1, i2 = QImage(300, 400, QImage.Format.Format_RGB32), QImage(300, 400, QImage.Format.Format_RGB32)
i1.fill(Qt.GlobalColor.green), i2.fill(Qt.GlobalColor.blue)
self.images = [i1, i2]
def count(self):
return self.num
def image(self, index):
return self.images[index%2]
def caption(self, index):
return 'Number: %d'%index
def subtitle(self, index):
return ''
class DatabaseImages(pictureflow.FlowImages):
def __init__(self, model, is_cover_browser_visible):
pictureflow.FlowImages.__init__(self)
self.model = model
self.is_cover_browser_visible = is_cover_browser_visible
self.model.modelReset.connect(self.reset, type=Qt.ConnectionType.QueuedConnection)
self.ignore_image_requests = True
self.template_inited = False
self.subtitle_error_reported = False
def init_template(self, db):
self.template_cache = {}
self.template_error_reported = False
self.template = db.pref('cover_browser_title_template', '{title}') or ''
self.template_is_title = self.template == '{title}'
self.template_is_empty = not self.template.strip()
def count(self):
return self.model.count()
def render_template(self, template, index, db):
book_id = self.model.id(index)
mi = db.get_proxy_metadata(book_id)
return mi.formatter.safe_format(template, mi, _('TEMPLATE ERROR'), mi, template_cache=self.template_cache)
def caption(self, index):
if self.ignore_image_requests:
return ''
ans = ''
try:
db = self.model.db.new_api
if not self.template_inited:
self.init_template(db)
if self.template_is_title:
ans = self.model.title(index)
elif self.template_is_empty:
ans = ''
else:
try:
ans = self.render_template(self.template, index, db)
except Exception:
if not self.template_error_reported:
self.template_error_reported = True
import traceback
traceback.print_exc()
ans = ''
ans = (ans or '').replace('&', '&&')
except Exception:
return ''
return ans
def subtitle(self, index):
try:
db = self.model.db.new_api
if not self.template_inited:
self.init_template(db)
field = db.pref('cover_browser_subtitle_field', 'rating')
if field and field != 'none':
book_id = self.model.id(index)
fm = db.field_metadata[field]
if fm['datatype'] == 'rating':
val = db.field_for(field, book_id, default_value=0)
if val:
return rating_to_stars(val, allow_half_stars=db.field_metadata[field]['display'].get('allow_half_stars'))
else:
if field == 'authors':
book_id = self.model.id(index)
val = db.field_for(field, book_id, default_value=0)
if val == (_('Unknown'),):
val = ''
elif val:
val = authors_to_string(val).replace('&', '&&')
else:
val = ''
return val
return self.render_template('{%s}' % field, index, db).replace('&', '&&')
except Exception:
if not self.subtitle_error_reported:
self.subtitle_error_reported = True
import traceback
traceback.print_exc()
return ''
def reset(self):
self.beginResetModel(), self.endResetModel()
def beginResetModel(self):
if self.is_cover_browser_visible():
self.dataChanged.emit()
def endResetModel(self):
pass
def image(self, index):
if self.ignore_image_requests:
return QImage()
return self.model.cover(index)
class CoverFlow(pictureflow.PictureFlow):
dc_signal = pyqtSignal()
context_menu_requested = pyqtSignal()
def __init__(self, parent=None):
pictureflow.PictureFlow.__init__(self, parent,
config['cover_flow_queue_length']+1)
self.created_at = time.monotonic()
self.setMinimumSize(MIN_SIZE)
self.setFocusPolicy(Qt.FocusPolicy.WheelFocus)
self.setSizePolicy(QSizePolicy(QSizePolicy.Policy.Expanding,
QSizePolicy.Policy.Expanding))
self.dc_signal.connect(self._data_changed,
type=Qt.ConnectionType.QueuedConnection)
self.context_menu = None
self.setContextMenuPolicy(Qt.ContextMenuPolicy.DefaultContextMenu)
self.setPreserveAspectRatio(gprefs['cb_preserve_aspect_ratio'])
if not gprefs['cover_browser_reflections']:
self.setShowReflections(False)
if gprefs['cb_double_click_to_activate']:
self.setActivateOnDoubleClick(True)
def one_auto_scroll(self):
if self.currentSlide() >= self.count() - 1:
self.setCurrentSlide(0)
else:
self.showNext()
def set_subtitle_font(self, for_ratings=True):
if for_ratings:
self.setSubtitleFont(QFont(rating_font()))
else:
self.setSubtitleFont(self.font())
def set_context_menu(self, cm):
self.context_menu = cm
def contextMenuEvent(self, event):
if self.context_menu is not None:
from calibre.gui2.main_window import clone_menu
self.context_menu_requested.emit()
m = clone_menu(self.context_menu) if islinux else self.context_menu
m.popup(event.globalPos())
event.accept()
def sizeHint(self):
return self.minimumSize()
def wheelEvent(self, ev):
if abs(ev.angleDelta().x()) > abs(ev.angleDelta().y()):
d = ev.angleDelta().x()
else:
d = ev.angleDelta().y()
if abs(d) > 0:
ev.accept()
(self.showNext if d < 0 else self.showPrevious)()
def dataChanged(self):
self.dc_signal.emit()
def _data_changed(self):
pictureflow.PictureFlow.dataChanged(self)
def setCurrentSlide(self, num):
pictureflow.PictureFlow.setCurrentSlide(self, num)
class CBDialog(QDialog):
closed = pyqtSignal()
def __init__(self, gui, cover_flow):
QDialog.__init__(self, gui)
self._layout = QStackedLayout()
self.setLayout(self._layout)
self.setWindowTitle(_('Browse by covers'))
self.layout().addWidget(cover_flow)
self.restore_geometry(gprefs, 'cover_browser_dialog_geometry')
self.action_fs_toggle = a = QAction(self)
self.addAction(a)
a.setShortcuts([QKeySequence(QKeySequence.StandardKey.FullScreen)])
a.triggered.connect(self.toggle_fullscreen)
self.action_esc_fs = a = QAction(self)
a.triggered.connect(self.show_normal)
self.addAction(a)
a.setShortcuts([QKeySequence('Esc', QKeySequence.SequenceFormat.PortableText)])
self.pre_fs_geom = None
cover_flow.setFocus(Qt.FocusReason.OtherFocusReason)
self.view_action = a = QAction(self)
iactions = gui.iactions
self.addAction(a)
a.setShortcuts(list(iactions['View'].menuless_qaction.shortcuts())+
[QKeySequence(Qt.Key.Key_Space)])
a.triggered.connect(iactions['View'].menuless_qaction.trigger)
self.auto_scroll_action = a = QAction(self)
a.setShortcuts(list(iactions['Autoscroll Books'].menuless_qaction.shortcuts()))
self.addAction(a)
a.triggered.connect(iactions['Autoscroll Books'].menuless_qaction.trigger)
self.sd_action = a = QAction(self)
self.addAction(a)
a.setShortcuts(list(iactions['Send To Device'].
menuless_qaction.shortcuts()))
a.triggered.connect(iactions['Send To Device'].menuless_qaction.trigger)
def sizeHint(self):
sz = self.screen().availableSize()
sz.setHeight(sz.height()-60)
sz.setWidth(int(sz.width()/1.5))
return sz
def closeEvent(self, *args):
if not self.isFullScreen():
self.save_geometry(gprefs, 'cover_browser_dialog_geometry')
self.closed.emit()
def show_normal(self):
self.showNormal()
if self.pre_fs_geom is not None:
QApplication.instance().safe_restore_geometry(self, self.pre_fs_geom)
self.pre_fs_geom = None
def show_fullscreen(self):
self.pre_fs_geom = bytearray(self.saveGeometry())
self.showFullScreen()
def toggle_fullscreen(self, *args):
if self.isFullScreen():
self.show_normal()
else:
self.show_fullscreen()
class CoverFlowMixin:
disable_cover_browser_refresh = False
@property
def cb_button(self):
return self.layout_container.cover_browser_button
def one_auto_scroll(self):
cb_visible = self.cover_flow is not None and self.cb_button.isChecked()
if cb_visible:
self.cover_flow.one_auto_scroll()
else:
self.library_view.show_next_book()
def toggle_auto_scroll(self):
if not hasattr(self, 'auto_scroll_timer'):
self.auto_scroll_timer = t = QTimer(self)
t.timeout.connect(self.one_auto_scroll)
if self.auto_scroll_timer.isActive():
self.auto_scroll_timer.stop()
else:
self.one_auto_scroll()
self.auto_scroll_timer.start(int(1000 * gprefs['books_autoscroll_time']))
def update_auto_scroll_timeout(self):
if hasattr(self, 'auto_scroll_timer') and self.auto_scroll_timer.isActive():
self.auto_scroll_timer.stop()
self.toggle_auto_scroll()
def __init__(self, *a, **kw):
self.cf_last_updated_at = None
self.cover_flow_syncing_enabled = False
self.cover_flow_sync_flag = True
self.separate_cover_browser = config['separate_cover_flow']
self.cover_flow = CoverFlow(parent=self)
self.cover_flow.currentChanged.connect(self.sync_listview_to_cf)
self.cover_flow.context_menu_requested.connect(self.cf_context_menu_requested)
self.library_view.selectionModel().currentRowChanged.connect(self.sync_cf_to_listview)
self.db_images = DatabaseImages(self.library_view.model(), self.is_cover_browser_visible)
self.cover_flow.setImages(self.db_images)
self.cover_flow.itemActivated.connect(self.iactions['View'].view_specific_book)
self.update_cover_flow_subtitle_font()
button = self.cb_button
if self.separate_cover_browser:
button.toggled.connect(self.toggle_cover_browser)
button.set_state_to_show()
self.cover_flow.stop.connect(self.hide_cover_browser)
self.cover_flow.setVisible(False)
else:
self.cover_flow.stop.connect(button.set_state_to_hide)
self.layout_container.set_widget('cover_browser', self.cover_flow)
button.toggled.connect(self.cover_browser_toggled, type=Qt.ConnectionType.QueuedConnection)
def update_cover_flow_subtitle_font(self):
db = self.current_db.new_api
field = db.pref('cover_browser_subtitle_field', 'rating')
try:
is_rating = db.field_metadata[field]['datatype'] == 'rating'
except Exception:
is_rating = False
if hasattr(self.cover_flow, 'set_subtitle_font'):
self.cover_flow.set_subtitle_font(is_rating)
def toggle_cover_browser(self, *args):
cbd = getattr(self, 'cb_dialog', None)
if cbd is not None:
self.hide_cover_browser()
else:
self.show_cover_browser()
def cover_browser_toggled(self, *args):
if self.cb_button.isChecked():
self.cover_browser_shown()
else:
self.cover_browser_hidden()
def cover_browser_shown(self):
self.cover_flow.setFocus(Qt.FocusReason.OtherFocusReason)
if self.db_images.ignore_image_requests:
self.db_images.ignore_image_requests = False
self.db_images.dataChanged.emit()
self.cover_flow.setCurrentSlide(self.library_view.currentIndex().row())
self.cover_flow_syncing_enabled = True
QTimer.singleShot(500, self.cover_flow_do_sync)
self.library_view.setCurrentIndex(
self.library_view.currentIndex())
self.library_view.scroll_to_row(self.library_view.currentIndex().row())
def cover_browser_hidden(self):
self.cover_flow_syncing_enabled = False
idx = self.library_view.model().index(self.cover_flow.currentSlide(), 0)
if idx.isValid():
sm = self.library_view.selectionModel()
sm.select(idx, QItemSelectionModel.SelectionFlag.ClearAndSelect|QItemSelectionModel.SelectionFlag.Rows)
self.library_view.setCurrentIndex(idx)
self.library_view.scroll_to_row(idx.row())
def show_cover_browser(self):
d = CBDialog(self, self.cover_flow)
d.addAction(self.cb_button.action_toggle)
self.cover_flow.setVisible(True)
self.cover_flow.setFocus(Qt.FocusReason.OtherFocusReason)
d.show_fullscreen() if gprefs['cb_fullscreen'] else d.show()
self.cb_button.set_state_to_hide()
d.closed.connect(self.cover_browser_closed)
self.cb_dialog = d
self.cb_button.set_state_to_hide()
def cover_browser_closed(self, *args):
self.cb_button.set_state_to_show()
def hide_cover_browser(self, *args):
cbd = getattr(self, 'cb_dialog', None)
if cbd is not None:
cbd.accept()
self.cb_dialog = None
self.cb_button.set_state_to_show()
def is_cover_browser_visible(self):
try:
if self.separate_cover_browser:
return self.cover_flow.isVisible()
except AttributeError:
return False # called before init_cover_flow_mixin
return self.cb_button.isChecked()
def refresh_cover_browser(self):
if self.disable_cover_browser_refresh:
return
try:
if self.is_cover_browser_visible() and not isinstance(self.cover_flow, QLabel):
self.db_images.ignore_image_requests = False
self.cover_flow.dataChanged()
except AttributeError:
pass # called before init_cover_flow_mixin
def sync_cf_to_listview(self, current, previous):
if (self.cover_flow_sync_flag and self.is_cover_browser_visible() and self.cover_flow.currentSlide() != current.row()):
self.cover_flow.setCurrentSlide(current.row())
self.cover_flow_sync_flag = True
def cf_context_menu_requested(self):
row = self.cover_flow.currentSlide()
m = self.library_view.model()
index = m.index(row, 0)
sm = self.library_view.selectionModel()
sm.select(index, QItemSelectionModel.SelectionFlag.ClearAndSelect|QItemSelectionModel.SelectionFlag.Rows)
self.library_view.setCurrentIndex(index)
def cover_flow_do_sync(self):
self.cover_flow_sync_flag = True
try:
if (self.is_cover_browser_visible() and self.cf_last_updated_at is not None and time.time() - self.cf_last_updated_at > 0.5):
self.cf_last_updated_at = None
row = self.cover_flow.currentSlide()
m = self.library_view.model()
index = m.index(row, 0)
if self.library_view.currentIndex().row() != row and index.isValid():
self.cover_flow_sync_flag = False
self.library_view.select_rows([row], using_ids=False)
except:
import traceback
traceback.print_exc()
if self.cover_flow_syncing_enabled:
QTimer.singleShot(500, self.cover_flow_do_sync)
def sync_listview_to_cf(self, row):
self.cf_last_updated_at = time.time()
def test():
from qt.core import QMainWindow
app = QApplication([])
w = QMainWindow()
cf = CoverFlow()
w.resize(cf.size()+QSize(30, 20))
model = DummyImageList()
cf.setImages(model)
cf.setCurrentSlide(39000)
w.setCentralWidget(cf)
w.show()
cf.setFocus(Qt.FocusReason.OtherFocusReason)
sys.exit(app.exec())
def main(args=sys.argv):
return 0
if __name__ == '__main__':
from qt.core import QMainWindow
app = QApplication([])
w = QMainWindow()
cf = CoverFlow()
w.resize(cf.size()+QSize(30, 20))
path = sys.argv[1]
model = FileSystemImages(sys.argv[1])
cf.currentChanged[int].connect(model.currentChanged)
cf.setImages(model)
w.setCentralWidget(cf)
w.show()
cf.setFocus(Qt.FocusReason.OtherFocusReason)
sys.exit(app.exec())
| 18,970 | Python | .py | 449 | 32.463252 | 137 | 0.622205 | kovidgoyal/calibre | 19,243 | 2,250 | 4 | GPL-3.0 | 9/5/2024, 5:13:50 PM (Europe/Amsterdam) |
26,664 | author_mapper.py | kovidgoyal_calibre/src/calibre/gui2/author_mapper.py | #!/usr/bin/env python
# License: GPL v3 Copyright: 2018, Kovid Goyal <kovid at kovidgoyal.net>
from collections import OrderedDict
from calibre.ebooks.metadata import authors_to_string, string_to_authors
from calibre.ebooks.metadata.author_mapper import compile_rules, map_authors
from calibre.gui2 import Application, elided_text
from calibre.gui2.tag_mapper import RuleEdit as RuleEditBase
from calibre.gui2.tag_mapper import RuleEditDialog as RuleEditDialogBase
from calibre.gui2.tag_mapper import RuleItem as RuleItemBase
from calibre.gui2.tag_mapper import Rules as RulesBase
from calibre.gui2.tag_mapper import RulesDialog as RulesDialogBase
from calibre.gui2.tag_mapper import Tester as TesterBase
from calibre.utils.config import JSONConfig
author_maps = JSONConfig('author-mapping-rules')
class RuleEdit(RuleEditBase):
ACTION_MAP = OrderedDict((
('replace', _('Change')),
('capitalize', _('Capitalize')),
('lower', _('Lower-case')),
('upper', _('Upper-case')),
))
MATCH_TYPE_MAP = OrderedDict((
('one_of', _('is one of')),
('not_one_of', _('is not one of')),
('has', _('contains')),
('matches', _('matches regex pattern')),
('not_matches', _('does not match regex pattern')),
))
MSG = _('Create the rule below, the rule can be used to add or ignore authors')
SUBJECT = _('the author, if the author name')
VALUE_ERROR = _('You must provide a value for the author name to match')
REPLACE_TEXT = _('with the name:')
SINGLE_EDIT_FIELD_NAME = 'authors'
@property
def can_use_tag_editor(self):
return False
def update_state(self):
a = self.action.currentData()
replace = a == 'replace'
self.la3.setVisible(replace), self.replace.setVisible(replace)
m = self.match_type.currentData()
is_match = 'matches' in m
self.regex_help.setVisible(is_match)
@property
def rule(self):
return {
'action': self.action.currentData(),
'match_type': self.match_type.currentData(),
'query': self.query.text().strip(),
'replace': self.replace.text().strip(),
}
@rule.setter
def rule(self, rule):
def sc(name):
c = getattr(self, name)
idx = c.findData(str(rule.get(name, '')))
if idx < 0:
idx = 0
c.setCurrentIndex(idx)
sc('match_type'), sc('action')
self.query.setText(str(rule.get('query', '')).strip())
self.replace.setText(str(rule.get('replace', '')).strip())
class RuleEditDialog(RuleEditDialogBase):
PREFS_NAME = 'edit-author-mapping-rule'
RuleEditClass = RuleEdit
class RuleItem(RuleItemBase):
@staticmethod
def text_from_rule(rule, parent):
query = elided_text(rule['query'], font=parent.font(), width=200, pos='right')
text = _(
'<b>{action}</b> the author name, if it <i>{match_type}</i>: <b>{query}</b>').format(
action=RuleEdit.ACTION_MAP[rule['action']], match_type=RuleEdit.MATCH_TYPE_MAP[rule['match_type']], query=query)
if rule['action'] == 'replace':
text += '<br>' + _('to the name') + ' <b>%s</b>' % rule['replace']
return '<div style="white-space: nowrap">' + text + '</div>'
class Rules(RulesBase):
RuleItemClass = RuleItem
RuleEditDialogClass = RuleEditDialog
MSG = _('You can specify rules to manipulate author names here.'
' Click the "Add Rule" button'
' below to get started. The rules will be processed in order for every author.')
class Tester(TesterBase):
DIALOG_TITLE = _('Test author mapping rules')
PREFS_NAME = 'test-author-mapping-rules'
LABEL = _('Enter an author name to test:')
PLACEHOLDER = _('Enter author and click the "Test" button')
EMPTY_RESULT = '<p> </p>'
def do_test(self):
authors = string_to_authors(self.value.strip())
ans = map_authors(authors, compile_rules(self.rules))
self.result.setText(authors_to_string(ans))
class RulesDialog(RulesDialogBase):
DIALOG_TITLE = _('Edit author mapping rules')
PREFS_NAME = 'edit-author-mapping-rules'
RulesClass = Rules
TesterClass = Tester
PREFS_OBJECT = author_maps
if __name__ == '__main__':
app = Application([])
d = RulesDialog()
d.rules = [
{'action':'replace', 'query':'alice B & alice bob', 'match_type':'one_of', 'replace':'Alice Bob'},
]
d.exec()
from pprint import pprint
pprint(d.rules)
del d, app
| 4,606 | Python | .py | 107 | 36.261682 | 128 | 0.641226 | kovidgoyal/calibre | 19,243 | 2,250 | 4 | GPL-3.0 | 9/5/2024, 5:13:50 PM (Europe/Amsterdam) |
26,665 | palette.py | kovidgoyal_calibre/src/calibre/gui2/palette.py | #!/usr/bin/env python
# License: GPL v3 Copyright: 2019, Kovid Goyal <kovid at kovidgoyal.net>
import os
import sys
from contextlib import contextmanager, suppress
from functools import lru_cache
from qt.core import QApplication, QByteArray, QColor, QDataStream, QIcon, QIODeviceBase, QObject, QPalette, QProxyStyle, QStyle, Qt
from calibre.constants import DEBUG, dark_link_color, ismacos, iswindows
dark_link_color = QColor(dark_link_color)
dark_color = QColor(45,45,45)
dark_text_color = QColor('#ddd')
light_color = QColor(0xf0, 0xf0, 0xf0)
light_text_color = QColor(0,0,0)
light_link_color = QColor(0, 0, 255)
class UseCalibreIcons(QProxyStyle):
def standardIcon(self, standard_pixmap, option=None, widget=None):
ic = QApplication.instance().get_qt_standard_icon(standard_pixmap)
if ic.isNull():
return super().standardIcon(standard_pixmap, option, widget)
return ic
def palette_is_dark(self):
col = self.color(QPalette.ColorRole.Window)
return max(col.getRgb()[:3]) < 115
def serialize_palette(self):
ba = QByteArray()
ds = QDataStream(ba, QIODeviceBase.OpenModeFlag.WriteOnly)
ds << self
return bytes(ba)
def unserialize_palette(self, data: bytes):
QDataStream(QByteArray(data)) >> self
def serialize_palette_as_python(self):
lines = []
for group in QPalette.ColorGroup:
if group in (QPalette.ColorGroup.All, QPalette.ColorGroup.NColorGroups):
continue
for role in QPalette.ColorRole:
if role == QPalette.ColorRole.NColorRoles:
continue
c = self.color(group, role)
lines.append(
f'self.setColor(QPalette.ColorGroup.{group.name}, QPalette.ColorRole.{role.name}, QColor({c.red()}, {c.green()}, {c.blue()}, {c.alpha()}))')
return '\n'.join(lines)
QPalette.is_dark_theme = palette_is_dark
QPalette.serialize_as_bytes = serialize_palette
QPalette.serialize_as_python = serialize_palette_as_python
QPalette.unserialize_from_bytes = unserialize_palette
def default_dark_palette():
p = QPalette()
disabled_color = QColor(127,127,127)
p.setColor(QPalette.ColorRole.Window, dark_color)
p.setColor(QPalette.ColorRole.WindowText, dark_text_color)
p.setColor(QPalette.ColorRole.PlaceholderText, disabled_color)
p.setColor(QPalette.ColorRole.Base, QColor(18,18,18))
p.setColor(QPalette.ColorRole.AlternateBase, dark_color)
p.setColor(QPalette.ColorRole.ToolTipBase, dark_color)
p.setColor(QPalette.ColorRole.ToolTipText, dark_text_color)
p.setColor(QPalette.ColorRole.Text, dark_text_color)
p.setColor(QPalette.ColorRole.Button, dark_color)
p.setColor(QPalette.ColorRole.ButtonText, dark_text_color)
p.setColor(QPalette.ColorRole.BrightText, Qt.GlobalColor.red)
p.setColor(QPalette.ColorRole.Link, dark_link_color)
p.setColor(QPalette.ColorRole.LinkVisited, Qt.GlobalColor.darkMagenta)
p.setColor(QPalette.ColorRole.Highlight, QColor(0x0b, 0x45, 0xc4))
p.setColor(QPalette.ColorRole.HighlightedText, dark_text_color)
p.setColor(QPalette.ColorGroup.Disabled, QPalette.ColorRole.ButtonText, disabled_color)
p.setColor(QPalette.ColorGroup.Disabled, QPalette.ColorRole.HighlightedText, disabled_color)
p.setColor(QPalette.ColorGroup.Disabled, QPalette.ColorRole.Text, disabled_color)
return p
def default_light_palette():
p = QPalette()
disabled_color = QColor(120,120,120)
p.setColor(QPalette.ColorRole.Window, light_color)
p.setColor(QPalette.ColorRole.WindowText, light_text_color)
p.setColor(QPalette.ColorRole.PlaceholderText, disabled_color)
p.setColor(QPalette.ColorRole.Base, Qt.GlobalColor.white)
p.setColor(QPalette.ColorRole.AlternateBase, QColor(245, 245, 245))
p.setColor(QPalette.ColorRole.ToolTipBase, QColor(0xff, 0xff, 0xdc))
p.setColor(QPalette.ColorRole.ToolTipText, light_text_color)
p.setColor(QPalette.ColorRole.Text, light_text_color)
p.setColor(QPalette.ColorRole.Button, light_color)
p.setColor(QPalette.ColorRole.ButtonText, light_text_color)
p.setColor(QPalette.ColorRole.BrightText, Qt.GlobalColor.red)
p.setColor(QPalette.ColorRole.Link, light_link_color)
p.setColor(QPalette.ColorRole.LinkVisited, Qt.GlobalColor.magenta)
p.setColor(QPalette.ColorRole.Highlight, QColor(48, 140, 198))
p.setColor(QPalette.ColorRole.HighlightedText, Qt.GlobalColor.white)
p.setColor(QPalette.ColorGroup.Disabled, QPalette.ColorRole.Text, disabled_color)
p.setColor(QPalette.ColorGroup.Disabled, QPalette.ColorRole.ButtonText, disabled_color)
p.setColor(QPalette.ColorGroup.Disabled, QPalette.ColorRole.HighlightedText, disabled_color)
return p
@lru_cache
def palette_colors():
return {
'WindowText': _('A general foreground color'),
'Text': _('The foreground color for text input widgets'),
'ButtonText': _('The foreground color for buttons'),
'PlaceholderText': _('Placeholder text in text input widgets'),
'ToolTipText': _('The foreground color for tool tips'),
'BrightText': _('A "bright" text color'),
'HighlightedText': _('The foreground color for highlighted items'),
'Window': _('A general background color'),
'Base': _('The background color for text input widgets'),
'Button': _('The background color for buttons'),
'AlternateBase': _('The background color for alternate rows in tables and lists'),
'ToolTipBase': _('The background color for tool tips'),
'Highlight': _('The background color for highlighted items'),
'Link': _('The color for links'),
'LinkVisited': _('The color for visited links'),
}
def is_foreground_color(key: str) -> bool:
return 'Text' in key
def palette_from_dict(data: dict[str, str], default_palette: QPalette) -> QPalette:
def s(key, group=QPalette.ColorGroup.All):
role = getattr(QPalette.ColorRole, key)
grp = ''
if group == QPalette.ColorGroup.Disabled:
grp = '-disabled'
c = QColor.fromString(data.get(key + grp, ''))
if c.isValid():
p.setColor(group, role, c)
p = QPalette()
for key in palette_colors():
s(key)
if is_foreground_color(key):
s(key, QPalette.ColorGroup.Disabled)
return p.resolve(default_palette)
def dark_palette():
from calibre.gui2 import gprefs
ans = default_dark_palette()
if gprefs['dark_palette_name']:
pdata = gprefs['dark_palettes'].get(gprefs['dark_palette_name'])
with suppress(Exception):
return palette_from_dict(pdata, ans)
return ans
def light_palette():
from calibre.gui2 import gprefs
ans = default_light_palette()
if gprefs['light_palette_name']:
pdata = gprefs['light_palettes'].get(gprefs['light_palette_name'])
with suppress(Exception):
return palette_from_dict(pdata, ans)
return ans
standard_pixmaps = { # {{{
QStyle.StandardPixmap.SP_DialogYesButton: 'ok.png',
QStyle.StandardPixmap.SP_DialogNoButton: 'window-close.png',
QStyle.StandardPixmap.SP_DialogCloseButton: 'close.png',
QStyle.StandardPixmap.SP_DialogOkButton: 'ok.png',
QStyle.StandardPixmap.SP_DialogCancelButton: 'window-close.png',
QStyle.StandardPixmap.SP_DialogHelpButton: 'help.png',
QStyle.StandardPixmap.SP_DialogOpenButton: 'document_open.png',
QStyle.StandardPixmap.SP_DialogSaveButton: 'save.png',
QStyle.StandardPixmap.SP_DialogApplyButton: 'ok.png',
QStyle.StandardPixmap.SP_DialogDiscardButton: 'trash.png',
QStyle.StandardPixmap.SP_MessageBoxInformation: 'dialog_information.png',
QStyle.StandardPixmap.SP_MessageBoxWarning: 'dialog_warning.png',
QStyle.StandardPixmap.SP_MessageBoxCritical: 'dialog_error.png',
QStyle.StandardPixmap.SP_MessageBoxQuestion: 'dialog_question.png',
QStyle.StandardPixmap.SP_BrowserReload: 'view-refresh.png',
QStyle.StandardPixmap.SP_LineEditClearButton: 'clear_left.png',
QStyle.StandardPixmap.SP_ToolBarHorizontalExtensionButton: 'v-ellipsis.png',
QStyle.StandardPixmap.SP_ToolBarVerticalExtensionButton: 'h-ellipsis.png',
QStyle.StandardPixmap.SP_FileDialogBack: 'back.png',
QStyle.StandardPixmap.SP_ArrowRight: 'forward.png',
QStyle.StandardPixmap.SP_ArrowLeft: 'back.png',
QStyle.StandardPixmap.SP_ArrowBack: 'back.png',
QStyle.StandardPixmap.SP_ArrowForward: 'forward.png',
QStyle.StandardPixmap.SP_ArrowUp: 'arrow-up.png',
QStyle.StandardPixmap.SP_ArrowDown: 'arrow-down.png',
QStyle.StandardPixmap.SP_FileDialogToParent: 'arrow-up.png',
QStyle.StandardPixmap.SP_FileDialogNewFolder: 'tb_folder.png',
QStyle.StandardPixmap.SP_FileDialogListView: 'format-list-unordered.png',
QStyle.StandardPixmap.SP_FileDialogDetailedView: 'format-list-ordered.png',
} # }}}
class PaletteManager(QObject):
color_palette: str
using_calibre_style: bool
is_dark_theme: bool
def __init__(self, force_calibre_style, headless):
from calibre.gui2 import gprefs
super().__init__()
self.color_palette = gprefs['color_palette']
ui_style = gprefs['ui_style']
self.is_dark_theme = False
self.ignore_palette_changes = False
if force_calibre_style:
self.using_calibre_style = True
else:
if iswindows or ismacos:
self.using_calibre_style = ui_style != 'system'
else:
self.using_calibre_style = os.environ.get('CALIBRE_USE_SYSTEM_THEME', '0') == '0'
args = []
self.args_to_qt = tuple(args)
if ismacos and not headless:
from calibre_extensions.cocoa import set_appearance
set_appearance(self.color_palette)
def initialize(self):
app = QApplication.instance()
self.setParent(app)
if not self.using_calibre_style and app.style().objectName() == 'fusion':
# Since Qt is using the fusion style anyway, specialize it
self.using_calibre_style = True
@property
def use_dark_palette(self):
app = QApplication.instance()
system_is_dark = app.styleHints().colorScheme() == Qt.ColorScheme.Dark
return self.color_palette == 'dark' or (self.color_palette == 'system' and system_is_dark)
def setup_styles(self):
if self.using_calibre_style:
app = QApplication.instance()
app.styleHints().colorSchemeChanged.connect(self.color_scheme_changed)
self.set_dark_mode_palette() if self.use_dark_palette else self.set_light_mode_palette()
QApplication.instance().setAttribute(Qt.ApplicationAttribute.AA_SetPalette, True)
if DEBUG:
print('Using calibre Qt style:', self.using_calibre_style, file=sys.stderr)
if self.using_calibre_style:
self.load_calibre_style()
else:
app = QApplication.instance()
self.native_proxy_style = UseCalibreIcons(app.style())
app.setStyle(self.native_proxy_style)
self.on_palette_change()
def get_qt_standard_icon(self, standard_pixmap):
from qt.core import QStyle
sp = QStyle.StandardPixmap(standard_pixmap)
val = standard_pixmaps.get(sp)
if val is None:
return QIcon()
return QIcon.ic(val)
def load_calibre_style(self):
transient_scroller = 0
if ismacos:
from calibre_extensions.cocoa import transient_scroller
transient_scroller = transient_scroller()
app = QApplication.instance()
from calibre_extensions.progress_indicator import CalibreStyle
self.calibre_style = style = CalibreStyle(transient_scroller)
app.setStyle(style)
def on_palette_change(self):
app = QApplication.instance()
app.cached_qimage.cache_clear()
app.cached_qpixmap.cache_clear()
self.is_dark_theme = app.palette().is_dark_theme()
QIcon.ic.set_theme()
app.setProperty('is_dark_theme', self.is_dark_theme)
if self.using_calibre_style:
ss = 'QTabBar::tab:selected { font-style: italic }\n\n'
if self.is_dark_theme:
ss += 'QMenu { border: 1px solid palette(shadow); }'
ss += '''
QTabBar::tab:selected {
background-color: palette(base);
border: 1px solid gray;
padding: 2px 8px;
margin-left: -4px;
margin-right: -4px;
}
QTabBar::tab:top:selected {
border-top-left-radius: 4px;
border-top-right-radius: 4px;
border-bottom-width: 0;
}
QTabBar::tab:bottom:selected {
border-bottom-left-radius: 4px;
border-bottom-right-radius: 4px;
border-top-width: 0;
}
QTabBar::tab:first:selected {
margin-left: 0; /* the first selected tab has nothing to overlap with on the left */
}
QTabBar::tab:last:selected {
margin-right: 0; /* the last selected tab has nothing to overlap with on the right */
}
QTabBar::tab:only-one {
margin: 0; /* if there is only one tab, we don't want overlapping margins */
}
'''
app.setStyleSheet(ss)
app.palette_changed.emit()
def set_dark_mode_palette(self):
self.set_palette(dark_palette())
def set_light_mode_palette(self):
self.set_palette(light_palette())
def color_scheme_changed(self, new_color_scheme):
if DEBUG:
print('System Color Scheme changed to:', new_color_scheme, file=sys.stderr)
if self.color_palette != 'system' or not self.using_calibre_style:
return
if new_color_scheme == Qt.ColorScheme.Dark:
self.set_dark_mode_palette()
elif new_color_scheme == Qt.ColorScheme.Light:
self.set_light_mode_palette()
elif new_color_scheme == Qt.ColorScheme.Unknown:
self.set_light_mode_palette()
self.on_palette_change()
@contextmanager
def changing_palette(self):
orig = self.ignore_palette_changes
self.ignore_palette_changes = True
try:
yield
finally:
self.ignore_palette_changes = orig
def set_palette(self, pal):
with self.changing_palette():
QApplication.instance().setPalette(pal)
def on_qt_palette_change(self):
if self.ignore_palette_changes:
if DEBUG:
print('ApplicationPaletteChange event ignored', file=sys.stderr)
else:
if DEBUG:
print('ApplicationPaletteChange event received', file=sys.stderr)
if self.using_calibre_style:
pal = dark_palette() if self.use_dark_palette else light_palette()
if QApplication.instance().palette().color(QPalette.ColorRole.Window) != pal.color(QPalette.ColorRole.Window):
if DEBUG:
print('Detected a spontaneous palette change by Qt, reverting it', file=sys.stderr)
self.set_palette(pal)
self.on_palette_change()
def refresh_palette(self):
from calibre.gui2 import gprefs
self.color_palette = gprefs['color_palette']
if ismacos:
from calibre_extensions.cocoa import set_appearance
set_appearance(self.color_palette)
system_is_dark = QApplication.instance().styleHints().colorScheme() == Qt.ColorScheme.Dark
is_dark = self.color_palette == 'dark' or (self.color_palette == 'system' and system_is_dark)
pal = dark_palette() if is_dark else light_palette()
self.set_palette(pal)
self.on_palette_change()
def tree_view_hover_style(self):
g1, g2 = '#e7effd', '#cbdaf1'
border_size = '1px'
if self.is_dark_theme:
c = QApplication.instance().palette().color(QPalette.ColorRole.Highlight)
c = c.lighter(180)
g1 = g2 = c.name()
border_size = '0px'
return f'''
QTreeView::item:hover {{
background: qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1, stop: 0 {g1}, stop: 1 {g2});
border: {border_size} solid #bfcde4;
border-radius: 6px;
}}
'''
| 16,211 | Python | .py | 346 | 39.242775 | 156 | 0.681985 | kovidgoyal/calibre | 19,243 | 2,250 | 4 | GPL-3.0 | 9/5/2024, 5:13:50 PM (Europe/Amsterdam) |
26,666 | proceed.py | kovidgoyal_calibre/src/calibre/gui2/proceed.py | #!/usr/bin/env python
__license__ = 'GPL v3'
__copyright__ = '2012, Kovid Goyal <kovid@kovidgoyal.net>'
__docformat__ = 'restructuredtext en'
from collections import namedtuple
from qt.core import (
QApplication,
QCheckBox,
QDialogButtonBox,
QEasingCurve,
QEvent,
QFontMetrics,
QHBoxLayout,
QIcon,
QImage,
QLabel,
QPainter,
QPainterPath,
QPalette,
QPixmap,
QPlainTextEdit,
QPropertyAnimation,
QRectF,
QSize,
QSizePolicy,
Qt,
QTimer,
QVBoxLayout,
QWidget,
pyqtProperty,
pyqtSignal,
sip,
)
from calibre.constants import __version__
from calibre.gui2.dialogs.message_box import ViewLog
Question = namedtuple('Question', 'payload callback cancel_callback '
'title msg html_log log_viewer_title log_is_file det_msg '
'show_copy_button checkbox_msg checkbox_checked action_callback '
'action_label action_icon focus_action show_det show_ok icon '
'log_viewer_unique_name auto_hide_after')
class Icon(QWidget):
@pyqtProperty(float)
def fraction(self):
return self._fraction
@fraction.setter
def fraction(self, val):
self._fraction = max(0, min(2, float(val)))
self.update()
def showEvent(self, ev):
self.animation.start()
return QWidget.showEvent(self, ev)
def hideEvent(self, ev):
self.animation.stop()
return QWidget.hideEvent(self, ev)
def __init__(self, parent):
QWidget.__init__(self, parent)
self.setSizePolicy(QSizePolicy.Policy.Fixed, QSizePolicy.Policy.Fixed)
self.set_icon('dialog_question.png')
self.default_icon = self.icon
self._fraction = 0.0
self.animation = a = QPropertyAnimation(self, b"fraction", self)
a.setDuration(2000), a.setEasingCurve(QEasingCurve.Type.Linear)
a.setStartValue(0.0), a.setEndValue(2.0), a.setLoopCount(10)
def set_icon(self, icon):
if isinstance(icon, QIcon):
self.icon = icon.pixmap(self.sizeHint())
elif icon is None:
self.icon = self.default_icon
else:
self.icon = QIcon.ic(icon).pixmap(self.sizeHint())
self.update()
def sizeHint(self):
return QSize(64, 64)
def paintEvent(self, ev):
p = QPainter(self)
p.setOpacity(min(1, abs(1 - self._fraction)))
p.drawPixmap(self.rect(), self.icon)
p.end()
class PlainTextEdit(QPlainTextEdit):
def sizeHint(self):
fm = QFontMetrics(self.font())
ans = QPlainTextEdit.sizeHint(self)
ans.setWidth(fm.averageCharWidth() * 50)
return ans
class ProceedQuestion(QWidget):
ask_question = pyqtSignal(object, object, object)
@pyqtProperty(float)
def show_fraction(self):
return self._show_fraction
@show_fraction.setter
def show_fraction(self, val):
self._show_fraction = max(0, min(1, float(val)))
self.update()
def __init__(self, parent):
QWidget.__init__(self, parent)
self.setVisible(False)
self.auto_hide_timer = None
parent.installEventFilter(self)
self._show_fraction = 0.0
self.show_animation = a = QPropertyAnimation(self, b"show_fraction", self)
a.setDuration(1000), a.setEasingCurve(QEasingCurve.Type.OutQuad)
a.setStartValue(0.0), a.setEndValue(1.0)
a.finished.connect(self.stop_show_animation)
self.rendered_pixmap = None
self.questions = []
self.icon = ic = Icon(self)
self.msg_label = msg = QLabel('some random filler text')
msg.setWordWrap(True)
self.bb = QDialogButtonBox()
self.bb.accepted.connect(self.accept)
self.bb.rejected.connect(self.reject)
self.log_button = self.bb.addButton(_('View log'), QDialogButtonBox.ButtonRole.ActionRole)
self.log_button.setIcon(QIcon.ic('debug.png'))
self.log_button.clicked.connect(self.show_log)
self.copy_button = self.bb.addButton(_('&Copy to clipboard'),
QDialogButtonBox.ButtonRole.ActionRole)
self.copy_button.clicked.connect(self.copy_to_clipboard)
self.action_button = self.bb.addButton('', QDialogButtonBox.ButtonRole.ActionRole)
self.action_button.clicked.connect(self.action_clicked)
self.show_det_msg = _('Show &details')
self.hide_det_msg = _('Hide &details')
self.det_msg_toggle = self.bb.addButton(self.show_det_msg, QDialogButtonBox.ButtonRole.ActionRole)
self.det_msg_toggle.clicked.connect(self.toggle_det_msg)
self.det_msg_toggle.setToolTip(
_('Show detailed information about this error'))
self.det_msg = PlainTextEdit(self)
self.det_msg.setReadOnly(True)
self.bb.setStandardButtons(
QDialogButtonBox.StandardButton.Yes | QDialogButtonBox.StandardButton.No | QDialogButtonBox.StandardButton.Ok)
self.bb.button(QDialogButtonBox.StandardButton.Yes).setDefault(True)
self.title_label = title = QLabel('A dummy title')
f = title.font()
f.setBold(True)
title.setFont(f)
self.checkbox = QCheckBox('', self)
self._l = l = QVBoxLayout(self)
self._h = h = QHBoxLayout()
self._v = v = QVBoxLayout()
v.addWidget(title), v.addWidget(msg)
h.addWidget(ic), h.addSpacing(10), h.addLayout(v), l.addLayout(h)
l.addSpacing(5)
l.addWidget(self.checkbox)
l.addWidget(self.det_msg)
l.addWidget(self.bb)
self.ask_question.connect(self.do_ask_question,
type=Qt.ConnectionType.QueuedConnection)
self.setFocusPolicy(Qt.FocusPolicy.NoFocus)
for child in self.findChildren(QWidget):
child.setFocusPolicy(Qt.FocusPolicy.NoFocus)
self.setFocusProxy(self.parent())
self.resize_timer = t = QTimer(self)
t.setSingleShot(True), t.setInterval(100), t.timeout.connect(self.parent_resized)
def eventFilter(self, obj, ev):
if ev.type() == QEvent.Type.Resize and self.isVisible():
self.resize_timer.start()
return False
def parent_resized(self):
if self.isVisible():
self.do_resize()
def copy_to_clipboard(self, *args):
QApplication.clipboard().setText(
'calibre, version %s\n%s: %s\n\n%s' %
(__version__, str(self.windowTitle()),
str(self.msg_label.text()),
str(self.det_msg.toPlainText())))
self.copy_button.setText(_('Copied'))
def action_clicked(self):
if self.questions:
q = self.questions[0]
self.questions[0] = q._replace(callback=q.action_callback)
self.accept()
def accept(self):
self.cancel_auto_hide()
if self.questions:
payload, callback, cancel_callback = self.questions[0][:3]
self.questions = self.questions[1:]
cb = None
if self.checkbox.isVisible():
cb = bool(self.checkbox.isChecked())
self.ask_question.emit(callback, payload, cb)
self.hide()
def reject(self):
self.cancel_auto_hide()
if self.questions:
payload, callback, cancel_callback = self.questions[0][:3]
self.questions = self.questions[1:]
cb = None
if self.checkbox.isVisible():
cb = bool(self.checkbox.isChecked())
self.ask_question.emit(cancel_callback, payload, cb)
self.hide()
def do_ask_question(self, callback, payload, checkbox_checked):
if callable(callback):
args = [payload]
if checkbox_checked is not None:
args.append(checkbox_checked)
callback(*args)
self.show_question()
def toggle_det_msg(self, *args):
vis = str(self.det_msg_toggle.text()) == self.hide_det_msg
self.det_msg_toggle.setText(self.show_det_msg if vis else
self.hide_det_msg)
self.det_msg.setVisible(not vis)
self.do_resize()
def do_resize(self):
sz = self.sizeHint()
sz.setWidth(min(self.parent().width(), sz.width()))
sb = self.parent().statusBar().height() + 10
sz.setHeight(min(self.parent().height() - sb, sz.height()))
self.resize(sz)
self.position_widget()
def cancel_auto_hide(self):
if self.auto_hide_timer is not None:
self.auto_hide_timer.stop()
self.auto_hide_timer = None
def show_question(self):
if not self.questions:
return
if not self.isVisible():
self.cancel_auto_hide()
question = self.questions[0]
self.msg_label.setText(question.msg)
self.icon.set_icon(question.icon)
self.title_label.setText(question.title)
self.log_button.setVisible(bool(question.html_log))
self.copy_button.setText(_('&Copy to clipboard'))
if question.action_callback is not None:
self.action_button.setText(question.action_label or '')
self.action_button.setIcon(
QIcon() if question.action_icon is None else question.action_icon)
# Force the button box to relayout its buttons, as button text
# might have changed
self.bb.setOrientation(Qt.Orientation.Vertical), self.bb.setOrientation(Qt.Orientation.Horizontal)
self.det_msg.setPlainText(question.det_msg or '')
self.det_msg.setVisible(False)
self.det_msg_toggle.setVisible(bool(question.det_msg))
self.det_msg_toggle.setText(self.show_det_msg)
self.checkbox.setVisible(question.checkbox_msg is not None)
if question.checkbox_msg is not None:
self.checkbox.setText(question.checkbox_msg)
self.checkbox.setChecked(question.checkbox_checked)
self.bb.button(QDialogButtonBox.StandardButton.Ok).setVisible(question.show_ok)
self.bb.button(QDialogButtonBox.StandardButton.Yes).setVisible(not question.show_ok)
self.bb.button(QDialogButtonBox.StandardButton.No).setVisible(not question.show_ok)
self.copy_button.setVisible(bool(question.show_copy_button))
self.action_button.setVisible(question.action_callback is not None)
self.toggle_det_msg() if question.show_det else self.do_resize()
self.show_widget()
button = self.action_button if question.focus_action and question.action_callback is not None else \
(self.bb.button(QDialogButtonBox.StandardButton.Ok) if question.show_ok else self.bb.button(QDialogButtonBox.StandardButton.Yes))
button.setDefault(True)
self.raise_without_focus()
self.start_show_animation()
if question.auto_hide_after > 0:
self.auto_hide_timer = t = QTimer(self)
t.setSingleShot(True)
t.timeout.connect(self.auto_hide)
t.start(1000 * question.auto_hide_after)
def auto_hide(self):
self.auto_hide_timer = None
if not sip.isdeleted(self) and self.isVisible():
self.reject()
def start_show_animation(self):
if self.rendered_pixmap is not None:
return
dpr = getattr(self, 'devicePixelRatioF', self.devicePixelRatio)()
p = QImage(dpr * self.size(), QImage.Format.Format_ARGB32_Premultiplied)
p.setDevicePixelRatio(dpr)
# For some reason, Qt scrolls the book view when rendering this widget,
# for the very first time, so manually preserve its position
pr = getattr(self.parent(), 'library_view', None)
if not hasattr(pr, 'preserve_state'):
self.render(p)
else:
with pr.preserve_state():
self.render(p)
self.rendered_pixmap = QPixmap.fromImage(p)
self.original_visibility = v = []
for child in self.findChildren(QWidget):
if child.isVisible():
child.setVisible(False)
v.append(child)
self.show_animation.start()
def stop_show_animation(self):
self.rendered_pixmap = None
[c.setVisible(True) for c in getattr(self, 'original_visibility', ())]
self.update()
for child in self.findChildren(QWidget):
child.update()
if hasattr(child, 'viewport'):
child.viewport().update()
def position_widget(self):
geom = self.parent().geometry()
x = geom.width() - self.width() - 5
sb = self.parent().statusBar()
if sb is None:
y = geom.height() - self.height()
else:
y = sb.geometry().top() - self.height()
self.move(x, y)
def show_widget(self):
self.show()
self.position_widget()
def dummy_question(self, action_label=None, auto_hide_after=0):
self(lambda *args:args, (), 'dummy log', 'Log Viewer', 'A Dummy Popup',
'This is a dummy popup to easily test things, with a long line of text that should wrap. '
'This is a dummy popup to easily test things, with a long line of text that should wrap',
checkbox_msg='A dummy checkbox', auto_hide_after=auto_hide_after,
action_callback=lambda *args: args, action_label=action_label or 'An action')
def __call__(
self, callback, payload, html_log, log_viewer_title, title,
msg, det_msg='', show_copy_button=False, cancel_callback=None,
log_is_file=False, checkbox_msg=None, checkbox_checked=False, auto_hide_after=0,
action_callback=None, action_label=None, action_icon=None, focus_action=False,
show_det=False, show_ok=False, icon=None, log_viewer_unique_name=None,
**kw
):
'''
A non modal popup that notifies the user that a background task has
been completed. This class guarantees that only a single popup is
visible at any one time. Other requests are queued and displayed after
the user dismisses the current popup.
:param callback: A callable that is called with payload if the user
asks to proceed. Note that this is always called in the GUI thread.
:param cancel_callback: A callable that is called with the payload if
the users asks not to proceed.
:param payload: Arbitrary object, passed to callback
:param html_log: An HTML or plain text log
:param log_viewer_title: The title for the log viewer window
:param title: The title for this popup
:param msg: The msg to display
:param det_msg: Detailed message
:param log_is_file: If True the html_log parameter is interpreted as
the path to a file on disk containing the log
encoded with utf-8
:param checkbox_msg: If not None, a checkbox is displayed in the
dialog, showing this message. The callback is
called with both the payload and the state of the
checkbox as arguments.
:param checkbox_checked: If True the checkbox is checked by default.
:param auto_hide_after: Number of seconds to automatically cancel this question after. Zero or less for no auto hide.
:param action_callback: If not None, an extra button is added, which
when clicked will cause action_callback to be called
instead of callback. action_callback is called in
exactly the same way as callback.
:param action_label: The text on the action button
:param action_icon: The icon for the action button, must be a QIcon object or None
:param focus_action: If True, the action button will be focused instead of the Yes button
:param show_det: If True, the Detailed message will be shown initially
:param show_ok: If True, OK will be shown instead of YES/NO
:param icon: The icon to be used for this popop (defaults to question mark). Can be either a QIcon or a string to be used with QIcon.ic()
:log_viewer_unique_name: If set, ViewLog will remember/reuse its size for this name in calibre.gui2.gprefs
'''
question = Question(
payload, callback, cancel_callback, title, msg, html_log,
log_viewer_title, log_is_file, det_msg, show_copy_button,
checkbox_msg, checkbox_checked, action_callback, action_label,
action_icon, focus_action, show_det, show_ok, icon, log_viewer_unique_name, auto_hide_after)
self.questions.append(question)
self.show_question()
def show_log(self):
if self.questions:
q = self.questions[0]
log = q.html_log
if q.log_is_file:
with open(log, 'rb') as f:
log = f.read().decode('utf-8')
self.log_viewer = ViewLog(q.log_viewer_title, log,
parent=self, unique_name=q.log_viewer_unique_name)
def paintEvent(self, ev):
painter = QPainter(self)
painter.setRenderHint(QPainter.RenderHint.Antialiasing, True)
painter.setRenderHint(QPainter.RenderHint.SmoothPixmapTransform, True)
try:
if self.rendered_pixmap is None:
self.paint_background(painter)
else:
self.animated_paint(painter)
finally:
painter.end()
def animated_paint(self, painter):
top = (1 - self._show_fraction) * self.height()
painter.drawPixmap(0, int(top), self.rendered_pixmap)
def paint_background(self, painter):
br = 12 # border_radius
bw = 1 # border_width
pal = self.palette()
c = pal.color(QPalette.ColorRole.Window)
c.setAlphaF(0.9)
p = QPainterPath()
p.addRoundedRect(QRectF(self.rect()), br, br)
painter.fillPath(p, c)
p.addRoundedRect(QRectF(self.rect()).adjusted(bw, bw, -bw, -bw), br, br)
painter.fillPath(p, pal.color(QPalette.ColorRole.WindowText))
def main():
from qt.core import QMainWindow, QStatusBar, QTimer
from calibre.gui2 import Application
app = Application([])
w = QMainWindow()
s = QStatusBar(w)
w.setStatusBar(s)
s.showMessage('Testing ProceedQuestion')
w.show()
p = ProceedQuestion(w)
def doit():
p(
lambda p:None, None, 'ass2', 'ass2', 'testing auto hide', 'this popup will auto hide after 2 seconds',
auto_hide_after=2,
)
p.dummy_question()
p.dummy_question(action_label='A very long button for testing relayout (indeed)')
p(
lambda p:None, None, 'ass2', 'ass2', 'testing2', 'testing2',
det_msg='details shown first, with a long line to test wrapping of text and width layout',
show_det=True, show_ok=True)
QTimer.singleShot(10, doit)
app.exec()
if __name__ == '__main__':
main()
| 19,218 | Python | .py | 419 | 35.911695 | 145 | 0.62947 | kovidgoyal/calibre | 19,243 | 2,250 | 4 | GPL-3.0 | 9/5/2024, 5:13:50 PM (Europe/Amsterdam) |
26,667 | pin_columns.py | kovidgoyal_calibre/src/calibre/gui2/pin_columns.py | #!/usr/bin/env python
# License: GPLv3 Copyright: 2018, Kovid Goyal <kovid at kovidgoyal.net>
from qt.core import QSplitter, QTableView
from calibre.gui2 import gprefs
from calibre.gui2.library import DEFAULT_SORT
class PinTableView(QTableView):
def __init__(self, books_view, parent=None):
QTableView.__init__(self, parent)
self.books_view = books_view
self.verticalHeader().close()
self.splitter = None
self.disable_save_state = False
@property
def column_map(self):
return self.books_view.column_map
def set_context_menu(self, menu):
self.context_menu = menu
def contextMenuEvent(self, event):
self.books_view.show_context_menu(self.context_menu, event)
def get_default_state(self):
old_state = {
'hidden_columns': ['last_modified', 'languages'],
'sort_history':[DEFAULT_SORT],
'column_positions': {},
'column_sizes': {},
}
h = self.column_header
cm = self.column_map
for i in range(h.count()):
name = cm[i]
old_state['column_positions'][name] = i
if name != 'ondevice':
old_state['column_sizes'][name] = \
min(350, max(self.sizeHintForColumn(i),
h.sectionSizeHint(i)))
if name in ('timestamp', 'last_modified'):
old_state['column_sizes'][name] += 12
return old_state
def apply_state(self, state):
self.disable_save_state = True # moveSection() can cause save_state() to be called
h = self.column_header
cmap = {}
hidden = state.get('hidden_columns', [])
for i, c in enumerate(self.column_map):
cmap[c] = i
if c != 'ondevice':
h.setSectionHidden(i, c in hidden)
positions = state.get('column_positions', {})
pmap = {}
for col, pos in positions.items():
if col in cmap:
pmap[pos] = col
for pos in sorted(pmap.keys()):
col = pmap[pos]
idx = cmap[col]
current_pos = h.visualIndex(idx)
if current_pos != pos:
h.moveSection(current_pos, pos)
# Because of a bug in Qt 5 we have to ensure that the header is actually
# relaid out by changing this value, without this sometimes ghost
# columns remain visible when changing libraries
for i in range(h.count()):
val = h.isSectionHidden(i)
h.setSectionHidden(i, not val)
h.setSectionHidden(i, val)
sizes = state.get('column_sizes', {})
for col, size in sizes.items():
if col in cmap:
sz = sizes[col]
if sz < 3:
sz = h.sectionSizeHint(cmap[col])
h.resizeSection(cmap[col], sz)
for i in range(h.count()):
if not h.isSectionHidden(i) and h.sectionSize(i) < 3:
sz = h.sectionSizeHint(i)
h.resizeSection(i, sz)
self.disable_save_state = False
def get_state(self):
h = self.column_header
cm = self.column_map
state = {}
state['hidden_columns'] = [cm[i] for i in range(h.count())
if h.isSectionHidden(i) and cm[i] != 'ondevice']
state['column_positions'] = {}
state['column_sizes'] = {}
for i in range(h.count()):
name = cm[i]
state['column_positions'][name] = h.visualIndex(i)
if name != 'ondevice':
state['column_sizes'][name] = h.sectionSize(i)
return state
def save_state(self):
db = getattr(self.model(), 'db', None)
if db is not None and not self.disable_save_state:
state = self.get_state()
db.new_api.set_pref('books view split pane state', state)
if self.splitter is not None:
self.splitter.save_state()
def restore_state(self):
db = getattr(self.model(), 'db', None)
if db is not None:
state = db.new_api.pref('books view split pane state', None)
if self.splitter is not None:
self.splitter.restore_state()
if state:
self.apply_state(state)
class PinContainer(QSplitter):
def __init__(self, books_view, parent=None):
super().__init__(parent)
self.setChildrenCollapsible(False)
self.books_view = books_view
self.addWidget(books_view)
self.addWidget(books_view.pin_view)
books_view.pin_view.splitter = self
@property
def splitter_state(self):
return bytearray(self.saveState())
@splitter_state.setter
def splitter_state(self, val):
if val is not None:
self.restoreState(val)
def save_state(self):
gprefs['book_list_pin_splitter_state'] = self.splitter_state
def restore_state(self):
val = gprefs.get('book_list_pin_splitter_state', None)
self.splitter_state = val
| 5,105 | Python | .py | 126 | 30.015873 | 91 | 0.571457 | kovidgoyal/calibre | 19,243 | 2,250 | 4 | GPL-3.0 | 9/5/2024, 5:13:50 PM (Europe/Amsterdam) |
26,668 | auto_add.py | kovidgoyal_calibre/src/calibre/gui2/auto_add.py | #!/usr/bin/env python
# License: GPLv3 Copyright: 2015, Kovid Goyal <kovid at kovidgoyal.net>
import os
import shutil
import tempfile
import time
from threading import Event, Thread
from qt.core import QApplication, QCursor, QFileSystemWatcher, QObject, Qt, QTimer, pyqtSignal
from calibre import prints
from calibre.db.adding import compile_rule, filter_filename
from calibre.ebooks import BOOK_EXTENSIONS
from calibre.gui2 import gprefs
from calibre.gui2.dialogs.duplicates import DuplicatesQuestion
from calibre.utils.filenames import make_long_path_useable
from calibre.utils.tdir_in_cache import tdir_in_cache
AUTO_ADDED = frozenset(BOOK_EXTENSIONS) - {'pdr', 'mbp', 'tan'}
class AllAllowed:
def __init__(self):
self.disallowed = frozenset(gprefs['blocked_auto_formats'])
def __contains__(self, x):
return x not in self.disallowed
def allowed_formats():
' Return an object that can be used to test if a format (lowercase) is allowed for auto-adding '
if gprefs['auto_add_everything']:
allowed = AllAllowed()
else:
allowed = AUTO_ADDED - frozenset(gprefs['blocked_auto_formats'])
return allowed
class Worker(Thread):
def __init__(self, path, callback):
Thread.__init__(self)
self.daemon = True
self.keep_running = True
self.wake_up = Event()
self.path, self.callback = path, callback
self.staging = set()
self.allowed = allowed_formats()
self.read_rules()
def read_rules(self):
try:
self.compiled_rules = tuple(map(compile_rule, gprefs.get('add_filter_rules', ())))
except Exception:
self.compiled_rules = ()
import traceback
traceback.print_exc()
def is_filename_allowed(self, filename):
allowed = filter_filename(self.compiled_rules, filename)
if allowed is None:
ext = os.path.splitext(filename)[1][1:].lower()
allowed = ext in self.allowed
return allowed
def run(self):
self.tdir = tdir_in_cache('aa')
try:
while self.keep_running:
self.wake_up.wait()
self.wake_up.clear()
if not self.keep_running:
break
try:
self.auto_add()
except:
import traceback
traceback.print_exc()
finally:
shutil.rmtree(self.tdir, ignore_errors=True)
def auto_add(self):
from calibre.ebooks.metadata.meta import metadata_from_filename
from calibre.ebooks.metadata.opf2 import metadata_to_opf
from calibre.utils.ipc.simple_worker import WorkerError, fork_job
def join(*x):
return make_long_path_useable(os.path.join(*x))
files = [x for x in os.listdir(join(self.path)) if
# Must not be in the process of being added to the db
x not in self.staging and
# Firefox creates 0 byte placeholder files when downloading
os.stat(join(self.path, x)).st_size > 0 and
# Must be a file
os.path.isfile(join(self.path, x)) and
# Must have read and write permissions
os.access(join(self.path, x), os.R_OK|os.W_OK) and
# Must be a known ebook file type
self.is_filename_allowed(x)
]
data = []
# Give any in progress copies time to complete
time.sleep(2)
def safe_mtime(x):
try:
return os.path.getmtime(join(self.path, x))
except OSError:
return time.time()
for fname in sorted(files, key=safe_mtime):
f = os.path.join(self.path, fname)
# Try opening the file for reading, if the OS prevents us, then at
# least on windows, it means the file is open in another
# application for writing. We will get notified by
# QFileSystemWatcher when writing is completed, so ignore for now.
try:
open(make_long_path_useable(f), 'rb').close()
except:
continue
tdir = tempfile.mkdtemp(dir=self.tdir)
try:
fork_job('calibre.ebooks.metadata.meta',
'forked_read_metadata', (f, tdir), no_output=True)
except WorkerError as e:
prints('Failed to read metadata from:', fname)
prints(e.orig_tb)
except:
import traceback
traceback.print_exc()
# Ensure that the pre-metadata file size is present. If it isn't,
# write 0 so that the file is rescanned
szpath = os.path.join(tdir, 'size.txt')
try:
with open(szpath, 'rb') as f:
int(f.read())
except:
with open(szpath, 'wb') as f:
f.write(b'0')
opfpath = os.path.join(tdir, 'metadata.opf')
try:
if os.stat(opfpath).st_size < 30:
raise Exception('metadata reading failed')
except:
mi = metadata_from_filename(fname)
with open(opfpath, 'wb') as f:
f.write(metadata_to_opf(mi))
self.staging.add(fname)
data.append((fname, tdir))
if data:
self.callback(data)
class AutoAdder(QObject):
metadata_read = pyqtSignal(object)
auto_convert = pyqtSignal(object)
def __init__(self, path, parent):
QObject.__init__(self, parent)
if path and os.path.isdir(path) and os.access(path, os.R_OK|os.W_OK):
self.watcher = QFileSystemWatcher(self)
self.worker = Worker(path, self.metadata_read.emit)
self.watcher.directoryChanged.connect(self.dir_changed,
type=Qt.ConnectionType.QueuedConnection)
self.metadata_read.connect(self.add_to_db,
type=Qt.ConnectionType.QueuedConnection)
QTimer.singleShot(2000, self.initialize)
self.auto_convert.connect(self.do_auto_convert,
type=Qt.ConnectionType.QueuedConnection)
elif path:
prints(path,
'is not a valid directory to watch for new ebooks, ignoring')
def read_rules(self):
if hasattr(self, 'worker'):
self.worker.read_rules()
def initialize(self):
try:
if os.listdir(self.worker.path):
self.dir_changed()
except:
pass
self.watcher.addPath(self.worker.path)
def dir_changed(self, *args):
if os.path.isdir(self.worker.path) and os.access(self.worker.path,
os.R_OK|os.W_OK):
if not self.worker.is_alive():
self.worker.start()
self.worker.wake_up.set()
def stop(self):
if hasattr(self, 'worker'):
self.worker.keep_running = False
self.worker.wake_up.set()
def wait(self):
if hasattr(self, 'worker'):
self.worker.join()
def __enter__(self):
QApplication.setOverrideCursor(QCursor(Qt.CursorShape.WaitCursor))
def __exit__(self, *args):
QApplication.restoreOverrideCursor()
def add_to_db(self, data):
with self:
self.do_add(data)
def do_add(self, data):
from calibre.ebooks.metadata.opf2 import OPF
gui = self.parent()
if gui is None:
return
m = gui.library_view.model()
count = 0
needs_rescan = False
duplicates = []
added_ids = set()
for fname, tdir in data:
path_to_remove = os.path.join(self.worker.path, fname)
paths = [path_to_remove]
fpath = os.path.join(tdir, 'file_changed_by_plugins')
if os.path.exists(fpath):
with open(fpath) as f:
paths[0] = f.read()
book_fmt = os.path.splitext(os.path.basename(paths[0]))[1][1:].upper()
sz = os.path.join(tdir, 'size.txt')
try:
with open(sz, 'rb') as f:
sz = int(f.read())
if sz != os.stat(make_long_path_useable(paths[0])).st_size:
raise Exception('Looks like the file was written to after'
' we tried to read metadata')
except:
needs_rescan = True
try:
self.worker.staging.remove(fname)
except KeyError:
pass
continue
mi = os.path.join(tdir, 'metadata.opf')
if not os.access(mi, os.R_OK):
continue
mi = OPF(open(mi, 'rb'), tdir, populate_spine=False).to_book_metadata()
if gprefs.get('tag_map_on_add_rules'):
from calibre.ebooks.metadata.tag_mapper import map_tags
mi.tags = map_tags(mi.tags, gprefs['tag_map_on_add_rules'])
if gprefs.get('author_map_on_add_rules'):
from calibre.ebooks.metadata.author_mapper import compile_rules, map_authors
new_authors = map_authors(mi.authors, compile_rules(gprefs['author_map_on_add_rules']))
if new_authors != mi.authors:
mi.authors = new_authors
mi.author_sort = gui.current_db.new_api.author_sort_from_authors(mi.authors)
mi = [mi]
dups, ids = m.add_books(paths, [book_fmt], mi, add_duplicates=not gprefs['auto_add_check_for_duplicates'], return_ids=True)
added_ids |= set(ids)
num = len(ids)
if dups:
path = dups[0][0]
with open(os.path.join(tdir, 'dup_cache.'+dups[1][0].lower()),
'wb') as dest, open(path, 'rb') as src:
shutil.copyfileobj(src, dest)
dups[0][0] = dest.name
duplicates.append(dups)
try:
os.remove(make_long_path_useable(path_to_remove))
self.worker.staging.remove(fname)
except:
import traceback
traceback.print_exc()
count += num
if duplicates:
paths, formats, metadata = [], [], []
for p, f, mis in duplicates:
paths.extend(p)
formats.extend(f)
metadata.extend(mis)
dups = [(mic, mic.cover, [p]) for mic, p in zip(metadata, paths)]
d = DuplicatesQuestion(m.db, dups, parent=gui)
dups = tuple(d.duplicates)
if dups:
paths, formats, metadata = [], [], []
for mi, cover, book_paths in dups:
paths.extend(book_paths)
formats.extend([p.rpartition('.')[-1] for p in book_paths])
metadata.extend([mi for i in book_paths])
ids = m.add_books(paths, formats, metadata,
add_duplicates=True, return_ids=True)[1]
added_ids |= set(ids)
num = len(ids)
count += num
for fname, tdir in data:
try:
shutil.rmtree(tdir)
except:
pass
if added_ids and gprefs['auto_add_auto_convert']:
self.auto_convert.emit(added_ids)
if count > 0:
m.books_added(count)
gui.status_bar.show_message(
(_('Added a book automatically from {src}') if count == 1 else _('Added {num} books automatically from {src}')).format(
num=count, src=self.worker.path), 2000)
gui.refresh_cover_browser()
if needs_rescan:
QTimer.singleShot(2000, self.dir_changed)
def do_auto_convert(self, added_ids):
gui = self.parent()
gui.iactions['Convert Books'].auto_convert_auto_add(added_ids)
| 12,153 | Python | .py | 282 | 30.361702 | 135 | 0.554475 | kovidgoyal/calibre | 19,243 | 2,250 | 4 | GPL-3.0 | 9/5/2024, 5:13:50 PM (Europe/Amsterdam) |
26,669 | widgets.py | kovidgoyal_calibre/src/calibre/gui2/widgets.py | __license__ = 'GPL v3'
__copyright__ = '2008, Kovid Goyal <kovid at kovidgoyal.net>'
'''
Miscellaneous widgets used in the GUI
'''
import os
import re
from qt.core import (
QApplication,
QClipboard,
QColor,
QComboBox,
QCompleter,
QCursor,
QEvent,
QFont,
QGraphicsPixmapItem,
QGraphicsScene,
QGraphicsView,
QIcon,
QLabel,
QLineEdit,
QListWidget,
QListWidgetItem,
QMenu,
QPageSize,
QPainter,
QPalette,
QPen,
QPixmap,
QPrinter,
QRect,
QSize,
QSplitterHandle,
QStringListModel,
QSyntaxHighlighter,
Qt,
QTextCharFormat,
QWidget,
pyqtSignal,
)
from calibre import fit_image, force_unicode, strftime
from calibre.constants import ismacos, iswindows
from calibre.ebooks import BOOK_EXTENSIONS
from calibre.gui2 import clip_border_radius, error_dialog, gprefs, pixmap_to_data, warning_dialog
from calibre.gui2.dnd import DownloadDialog, dnd_get_files, dnd_get_image, dnd_get_local_image_and_pixmap, dnd_has_extension, dnd_has_image, image_extensions
from calibre.gui2.filename_pattern_ui import Ui_Form
from calibre.gui2.progress_indicator import ProgressIndicator as _ProgressIndicator
from calibre.startup import connect_lambda
from calibre.utils.config import XMLConfig, prefs
from calibre.utils.localization import _, localize_user_manual_link
from polyglot.builtins import native_string_type
history = XMLConfig('history')
class ProgressIndicator(QWidget): # {{{
def __init__(self, *args):
QWidget.__init__(self, *args)
self.setGeometry(0, 0, 300, 350)
self.pi = _ProgressIndicator(self)
self.status = QLabel(self)
self.status.setWordWrap(True)
self.status.setAlignment(Qt.AlignmentFlag.AlignHCenter|Qt.AlignmentFlag.AlignTop)
self.setVisible(False)
self.pos = None
def start(self, msg=''):
view = self.parent()
pwidth, pheight = view.size().width(), view.size().height()
self.resize(pwidth, min(pheight, 250))
if self.pos is None:
self.move(0, int((pheight-self.size().height())/2))
else:
self.move(self.pos[0], self.pos[1])
self.pi.resize(self.pi.sizeHint())
self.pi.move(int((self.size().width()-self.pi.size().width())/2), 0)
self.status.resize(self.size().width(), self.size().height()-self.pi.size().height()-10)
self.status.move(0, self.pi.size().height()+10)
self.status.setText('<h1>'+msg+'</h1>')
self.setVisible(True)
self.pi.startAnimation()
def stop(self):
self.pi.stopAnimation()
self.setVisible(False)
# }}}
class FilenamePattern(QWidget, Ui_Form): # {{{
changed_signal = pyqtSignal()
def __init__(self, parent):
QWidget.__init__(self, parent)
self.setupUi(self)
try:
self.help_label.setText(self.help_label.text() % localize_user_manual_link(
'https://manual.calibre-ebook.com/regexp.html'))
except TypeError:
pass # link already localized
self.test_button.clicked.connect(self.do_test)
self.re.lineEdit().returnPressed[()].connect(self.do_test)
self.filename.returnPressed[()].connect(self.do_test)
connect_lambda(self.re.lineEdit().textChanged, self, lambda self, x: self.changed_signal.emit())
def initialize(self, defaults=False):
# Get all items in the combobox. If we are resetting
# to defaults we don't want to lose what the user
# has added.
val_hist = [str(self.re.lineEdit().text())] + [str(self.re.itemText(i)) for i in range(self.re.count())]
self.re.clear()
if defaults:
val = prefs.defaults['filename_pattern']
else:
val = prefs['filename_pattern']
self.re.lineEdit().setText(val)
val_hist += gprefs.get('filename_pattern_history', [
'(?P<title>.+)', r'(?P<author>[^_-]+) -?\s*(?P<series>[^_0-9-]*)(?P<series_index>[0-9]*)\s*-\s*(?P<title>[^_].+) ?'])
if val in val_hist:
del val_hist[val_hist.index(val)]
val_hist.insert(0, val)
for v in val_hist:
# Ensure we don't have duplicate items.
if v and self.re.findText(v) == -1:
self.re.addItem(v)
self.re.setCurrentIndex(0)
def do_test(self):
from calibre.ebooks.metadata import authors_to_string
from calibre.ebooks.metadata.meta import metadata_from_filename
fname = str(self.filename.text())
ext = os.path.splitext(fname)[1][1:].lower()
if ext not in BOOK_EXTENSIONS:
return warning_dialog(self, _('Test file name invalid'),
_('The file name <b>%s</b> does not appear to end with a'
' file extension. It must end with a file '
' extension like .epub or .mobi')%fname, show=True)
try:
pat = self.pattern()
except Exception as err:
error_dialog(self, _('Invalid regular expression'),
_('Invalid regular expression: %s')%err).exec()
return
mi = metadata_from_filename(fname, pat)
if mi.title:
self.title.setText(mi.title)
else:
self.title.setText(_('No match'))
if mi.authors:
self.authors.setText(authors_to_string(mi.authors))
else:
self.authors.setText(_('No match'))
if mi.series:
self.series.setText(mi.series)
else:
self.series.setText(_('No match'))
if mi.series_index is not None:
self.series_index.setText(str(mi.series_index))
else:
self.series_index.setText(_('No match'))
if mi.publisher:
self.publisher.setText(mi.publisher)
else:
self.publisher.setText(_('No match'))
if mi.pubdate:
self.pubdate.setText(strftime('%Y-%m-%d', mi.pubdate))
else:
self.pubdate.setText(_('No match'))
self.isbn.setText(_('No match') if mi.isbn is None else str(mi.isbn))
self.comments.setText(mi.comments if mi.comments else _('No match'))
def pattern(self):
pat = str(self.re.lineEdit().text())
return re.compile(pat)
def commit(self):
pat = self.pattern().pattern
prefs['filename_pattern'] = pat
history = []
history_pats = [str(self.re.lineEdit().text())] + [str(self.re.itemText(i)) for i in range(self.re.count())]
for p in history_pats[:24]:
# Ensure we don't have duplicate items.
if p and p not in history:
history.append(p)
gprefs['filename_pattern_history'] = history
return pat
# }}}
class FormatList(QListWidget): # {{{
DROPABBLE_EXTENSIONS = BOOK_EXTENSIONS
formats_dropped = pyqtSignal(object, object)
delete_format = pyqtSignal()
def dragEnterEvent(self, event):
md = event.mimeData()
if dnd_has_extension(md, self.DROPABBLE_EXTENSIONS, allow_all_extensions=True):
event.acceptProposedAction()
def dropEvent(self, event):
event.setDropAction(Qt.DropAction.CopyAction)
md = event.mimeData()
# Now look for ebook files
urls, filenames = dnd_get_files(md, self.DROPABBLE_EXTENSIONS, allow_all_extensions=True)
if not urls:
# Nothing found
return
if not filenames:
# Local files
self.formats_dropped.emit(event, urls)
else:
# Remote files, use the first file
d = DownloadDialog(urls[0], filenames[0], self)
d.start_download()
if d.err is None:
self.formats_dropped.emit(event, [d.fpath])
def dragMoveEvent(self, event):
event.acceptProposedAction()
def keyPressEvent(self, event):
if event.key() == Qt.Key.Key_Delete:
self.delete_format.emit()
else:
return QListWidget.keyPressEvent(self, event)
# }}}
class ImageDropMixin: # {{{
'''
Adds support for dropping images onto widgets and a context menu for
copy/pasting images.
'''
DROPABBLE_EXTENSIONS = None
def __init__(self):
self.setAcceptDrops(True)
def dragEnterEvent(self, event):
md = event.mimeData()
exts = self.DROPABBLE_EXTENSIONS or image_extensions()
if dnd_has_extension(md, exts) or \
dnd_has_image(md):
event.acceptProposedAction()
def dropEvent(self, event):
event.setDropAction(Qt.DropAction.CopyAction)
md = event.mimeData()
pmap, data = dnd_get_local_image_and_pixmap(md)
if pmap is not None:
self.handle_image_drop(pmap, data)
return
x, y = dnd_get_image(md)
if x is not None:
# We have an image, set cover
event.accept()
if y is None:
# Local image
self.handle_image_drop(x)
else:
# Remote files, use the first file
d = DownloadDialog(x, y, self)
d.start_download()
if d.err is None:
pmap = QPixmap()
with open(d.fpath, 'rb') as f:
data = f.read()
pmap.loadFromData(data)
if not pmap.isNull():
self.handle_image_drop(pmap, data=data)
def handle_image_drop(self, pmap, data=None):
self.set_pixmap(pmap)
self.cover_changed.emit(data or pixmap_to_data(pmap, format='PNG'))
def dragMoveEvent(self, event):
event.acceptProposedAction()
def get_pixmap(self):
return self.pixmap()
def set_pixmap(self, pmap):
self.setPixmap(pmap)
def build_context_menu(self):
cm = QMenu(self)
paste = cm.addAction(QIcon.ic('edit-paste.png'), _('Paste cover'))
copy = cm.addAction(QIcon.ic('edit-copy.png'), _('Copy cover'))
if not QApplication.instance().clipboard().mimeData().hasImage():
paste.setEnabled(False)
copy.triggered.connect(self.copy_to_clipboard)
paste.triggered.connect(self.paste_from_clipboard)
return cm
def contextMenuEvent(self, ev):
self.build_context_menu().exec(ev.globalPos())
def copy_to_clipboard(self):
QApplication.instance().clipboard().setPixmap(self.get_pixmap())
def paste_from_clipboard(self):
cb = QApplication.instance().clipboard()
pmap = cb.pixmap()
if pmap.isNull() and cb.supportsSelection():
pmap = cb.pixmap(QClipboard.Mode.Selection)
if not pmap.isNull():
self.set_pixmap(pmap)
self.cover_changed.emit(
pixmap_to_data(pmap, format='PNG'))
return True
return False
# }}}
# ImageView {{{
def draw_size(p, rect, w, h):
rect = rect.adjusted(0, 0, 0, -4)
f = p.font()
f.setBold(True)
p.setFont(f)
sz = '\u00a0%d x %d\u00a0'%(w, h)
flags = Qt.AlignmentFlag.AlignBottom|Qt.AlignmentFlag.AlignRight|Qt.TextFlag.TextSingleLine
szrect = p.boundingRect(rect, flags, sz)
p.fillRect(szrect.adjusted(0, 0, 0, 4), QColor(0, 0, 0, 200))
p.setPen(QPen(QColor(255,255,255)))
p.drawText(rect, flags, sz)
class ImageView(QWidget, ImageDropMixin):
BORDER_WIDTH = 1
cover_changed = pyqtSignal(object)
draw_empty_border = False
def __init__(self, parent=None, show_size_pref_name=None, default_show_size=False):
QWidget.__init__(self, parent)
self.show_size_pref_name = ('show_size_on_cover_' + show_size_pref_name) if show_size_pref_name else None
self._pixmap = QPixmap()
self.setMinimumSize(QSize(150, 200))
ImageDropMixin.__init__(self)
self.draw_border = True
self.show_size = False
if self.show_size_pref_name:
self.show_size = gprefs.get(self.show_size_pref_name, default_show_size)
def setPixmap(self, pixmap):
if not isinstance(pixmap, QPixmap):
raise TypeError('Must use a QPixmap')
self._pixmap = pixmap
self.updateGeometry()
self.update()
def build_context_menu(self):
m = ImageDropMixin.build_context_menu(self)
if self.show_size_pref_name:
text = _('Hide size in corner') if self.show_size else _('Show size in corner')
m.addAction(text, self.toggle_show_size)
return m
def toggle_show_size(self):
self.show_size ^= True
if self.show_size_pref_name:
gprefs[self.show_size_pref_name] = self.show_size
self.update()
def pixmap(self):
return self._pixmap
def sizeHint(self):
if self._pixmap.isNull():
return self.minimumSize()
return self._pixmap.size()
def paintEvent(self, event):
QWidget.paintEvent(self, event)
pmap = self._pixmap
p = QPainter(self)
p.setRenderHints(QPainter.RenderHint.Antialiasing | QPainter.RenderHint.SmoothPixmapTransform)
if pmap.isNull():
if self.draw_empty_border:
pen = QPen()
pen.setWidth(self.BORDER_WIDTH)
p.setPen(pen)
p.drawRect(self.rect())
p.end()
return
w, h = pmap.width(), pmap.height()
ow, oh = w, h
cw, ch = self.rect().width(), self.rect().height()
scaled, nw, nh = fit_image(w, h, cw, ch)
if scaled:
pmap = pmap.scaled(int(nw*pmap.devicePixelRatio()), int(nh*pmap.devicePixelRatio()), Qt.AspectRatioMode.IgnoreAspectRatio,
Qt.TransformationMode.SmoothTransformation)
w, h = int(pmap.width()/pmap.devicePixelRatio()), int(pmap.height()/pmap.devicePixelRatio())
x = int(abs(cw - w)/2)
y = int(abs(ch - h)/2)
target = QRect(x, y, w, h)
with clip_border_radius(p, target):
p.drawPixmap(target, pmap)
if self.draw_border:
pen = QPen()
pen.setWidth(self.BORDER_WIDTH)
p.setPen(pen)
p.drawRect(target)
if self.show_size:
draw_size(p, target, ow, oh)
# }}}
# CoverView {{{
class RoundedPixmap(QGraphicsPixmapItem):
def paint(self, painter, option, widget):
painter.setRenderHint(QPainter.RenderHint.Antialiasing, True)
target = self.boundingRect().toAlignedRect()
with clip_border_radius(painter, target):
painter.drawPixmap(target, self.pixmap())
class CoverView(QGraphicsView, ImageDropMixin):
cover_changed = pyqtSignal(object)
def __init__(self, *args, **kwargs):
self.show_size = kwargs.pop('show_size', False)
QGraphicsView.__init__(self, *args, **kwargs)
ImageDropMixin.__init__(self)
self.pixmap_size = 0, 0
if self.show_size:
self.setViewportUpdateMode(QGraphicsView.ViewportUpdateMode.FullViewportUpdate)
self.set_background()
def get_pixmap(self):
for item in self.scene.items():
if hasattr(item, 'pixmap'):
return item.pixmap()
def set_pixmap(self, pmap):
self.scene = QGraphicsScene()
self.scene.addItem(RoundedPixmap(pmap))
self.setScene(self.scene)
def set_background(self, brush=None):
self.setBackgroundBrush(brush or self.palette().color(QPalette.ColorRole.Window))
def paintEvent(self, ev):
QGraphicsView.paintEvent(self, ev)
if self.show_size:
v = self.viewport()
p = QPainter(v)
draw_size(p, v.rect(), *self.pixmap_size)
# }}}
# BasicList {{{
class BasicListItem(QListWidgetItem):
def __init__(self, text, user_data=None):
QListWidgetItem.__init__(self, text)
self.user_data = user_data
def __eq__(self, other):
if hasattr(other, 'text'):
return self.text() == other.text()
return False
class BasicList(QListWidget):
def add_item(self, text, user_data=None, replace=False):
item = BasicListItem(text, user_data)
for oitem in self.items():
if oitem == item:
if replace:
self.takeItem(self.row(oitem))
else:
raise ValueError('Item already in list')
self.addItem(item)
def remove_selected_items(self, *args):
for item in self.selectedItems():
self.takeItem(self.row(item))
def items(self):
for i in range(self.count()):
yield self.item(i)
# }}}
class LineEditECM: # {{{
'''
Extend the context menu of a QLineEdit to include more actions.
'''
def create_change_case_menu(self, menu):
case_menu = QMenu(_('Change case'), menu)
action_upper_case = case_menu.addAction(_('Upper case'))
action_lower_case = case_menu.addAction(_('Lower case'))
action_swap_case = case_menu.addAction(_('Swap case'))
action_title_case = case_menu.addAction(_('Title case'))
action_capitalize = case_menu.addAction(_('Capitalize'))
action_upper_case.triggered.connect(self.upper_case)
action_lower_case.triggered.connect(self.lower_case)
action_swap_case.triggered.connect(self.swap_case)
action_title_case.triggered.connect(self.title_case)
action_capitalize.triggered.connect(self.capitalize)
menu.addMenu(case_menu)
return case_menu
def contextMenuEvent(self, event):
menu = self.createStandardContextMenu()
menu.addSeparator()
self.create_change_case_menu(menu)
if callable(getattr(self, 'add_items_to_context_menu', None)):
menu = self.add_items_to_context_menu(self, menu)
menu.exec(event.globalPos())
def modify_case_operation(self, func):
has_selection = self.hasSelectedText()
text = self.selectedText() if has_selection else self.text()
ntext = func(text)
if ntext != text:
self.insert(ntext) if has_selection else self.setText(ntext)
def upper_case(self):
from calibre.utils.icu import upper
self.modify_case_operation(upper)
def lower_case(self):
from calibre.utils.icu import lower
self.modify_case_operation(lower)
def swap_case(self):
from calibre.utils.icu import swapcase
self.modify_case_operation(swapcase)
def title_case(self):
from calibre.utils.titlecase import titlecase
self.modify_case_operation(titlecase)
def capitalize(self):
from calibre.utils.icu import capitalize
self.modify_case_operation(capitalize)
# }}}
class EnLineEdit(LineEditECM, QLineEdit): # {{{
'''
Enhanced QLineEdit.
Includes an extended content menu.
'''
def event(self, ev):
# See https://bugreports.qt.io/browse/QTBUG-46911
if ev.type() == QEvent.Type.ShortcutOverride and (
hasattr(ev, 'key') and ev.key() in (Qt.Key.Key_Left, Qt.Key.Key_Right) and (
ev.modifiers() & ~Qt.KeyboardModifier.KeypadModifier) == Qt.KeyboardModifier.ControlModifier):
ev.accept()
return QLineEdit.event(self, ev)
# }}}
# LineEditIndicators {{{
def setup_status_actions(self: QLineEdit):
self.status_actions = (
self.addAction(QIcon.ic('ok.png'), QLineEdit.ActionPosition.TrailingPosition),
self.addAction(QIcon.ic('dialog_error.png'), QLineEdit.ActionPosition.TrailingPosition))
self.status_actions[0].setVisible(False)
self.status_actions[1].setVisible(False)
def stylesheet_for_lineedit(ok, selector='QLineEdit') -> str:
if ok is None:
return ''
col = '#50c878' if ok else '#FF2400'
return f'{selector} {{ border: 2px solid {col}; border-radius: 3px }}'
def update_status_actions(self: QLineEdit, ok, tooltip: str = ''):
self.status_actions[0].setVisible(bool(ok))
self.status_actions[1].setVisible(not ok)
if ok:
self.status_actions[0].setToolTip(tooltip)
elif ok is None:
self.status_actions[1].setVisible(False)
else:
self.status_actions[1].setToolTip(tooltip)
self.setStyleSheet(stylesheet_for_lineedit(ok))
class LineEditIndicators:
def setup_status_actions(self):
setup_status_actions(self)
def update_status_actions(self, ok, tooltip=''):
update_status_actions(self, ok, tooltip)
# }}}
class ItemsCompleter(QCompleter): # {{{
'''
A completer object that completes a list of tags. It is used in conjunction
with a CompleterLineEdit.
'''
def __init__(self, parent, all_items):
QCompleter.__init__(self, all_items, parent)
self.all_items = set(all_items)
def update(self, text_items, completion_prefix):
items = list(self.all_items.difference(text_items))
model = QStringListModel(items, self)
self.setModel(model)
self.setCompletionPrefix(completion_prefix)
if completion_prefix.strip():
self.complete()
def update_items_cache(self, items):
self.all_items = set(items)
model = QStringListModel(items, self)
self.setModel(model)
# }}}
class CompleteLineEdit(EnLineEdit): # {{{
'''
A QLineEdit that can complete parts of text separated by separator.
'''
def __init__(self, parent=0, complete_items=[], sep=',', space_before_sep=False):
EnLineEdit.__init__(self, parent)
self.separator = sep
self.space_before_sep = space_before_sep
self.textChanged.connect(self.text_changed)
self.completer = ItemsCompleter(self, complete_items)
self.completer.setCaseSensitivity(Qt.CaseSensitivity.CaseInsensitive)
self.completer.activated[native_string_type].connect(self.complete_text)
self.completer.setWidget(self)
def update_items_cache(self, complete_items):
self.completer.update_items_cache(complete_items)
def set_separator(self, sep):
self.separator = sep
def set_space_before_sep(self, space_before):
self.space_before_sep = space_before
def text_changed(self, text):
all_text = str(text)
text = all_text[:self.cursorPosition()]
prefix = text.split(self.separator)[-1].strip()
text_items = []
for t in all_text.split(self.separator):
t1 = str(t).strip()
if t1:
text_items.append(t)
text_items = list(set(text_items))
self.completer.update(text_items, prefix)
def complete_text(self, text):
cursor_pos = self.cursorPosition()
before_text = str(self.text())[:cursor_pos]
after_text = str(self.text())[cursor_pos:]
prefix_len = len(before_text.split(self.separator)[-1].lstrip())
if self.space_before_sep:
complete_text_pat = '%s%s %s %s'
len_extra = 3
else:
complete_text_pat = '%s%s%s %s'
len_extra = 2
self.setText(complete_text_pat % (before_text[:cursor_pos - prefix_len], text, self.separator, after_text))
self.setCursorPosition(cursor_pos - prefix_len + len(text) + len_extra)
# }}}
class EnComboBox(QComboBox): # {{{
'''
Enhanced QComboBox.
Includes an extended context menu.
'''
def __init__(self, *args):
QComboBox.__init__(self, *args)
self.setLineEdit(EnLineEdit(self))
self.completer().setCaseSensitivity(Qt.CaseSensitivity.CaseInsensitive)
self.setMinimumContentsLength(20)
def text(self):
return str(self.currentText())
def setText(self, text):
idx = self.findText(text, Qt.MatchFlag.MatchFixedString|Qt.MatchFlag.MatchCaseSensitive)
if idx == -1:
self.insertItem(0, text)
idx = 0
self.setCurrentIndex(idx)
# }}}
class CompleteComboBox(EnComboBox): # {{{
def __init__(self, *args):
EnComboBox.__init__(self, *args)
self.setLineEdit(CompleteLineEdit(self))
def update_items_cache(self, complete_items):
self.lineEdit().update_items_cache(complete_items)
def set_separator(self, sep):
self.lineEdit().set_separator(sep)
def set_space_before_sep(self, space_before):
self.lineEdit().set_space_before_sep(space_before)
# }}}
class HistoryLineEdit(QComboBox): # {{{
lost_focus = pyqtSignal()
def __init__(self, parent=None):
QComboBox.__init__(self, parent)
self.setEditable(True)
self.setInsertPolicy(QComboBox.InsertPolicy.NoInsert)
self.setMaxCount(10)
self.setClearButtonEnabled = self.lineEdit().setClearButtonEnabled
self.textChanged = self.editTextChanged
def setPlaceholderText(self, txt):
return self.lineEdit().setPlaceholderText(txt)
def contextMenuEvent(self, event):
menu = self.lineEdit().createStandardContextMenu()
menu.addSeparator()
menu.addAction(_('Clear history'), self.clear_history_default_impl)
menu.exec(event.globalPos())
def clear_history_default_impl(self):
self.clear()
history.set(self.store_name, [])
@property
def store_name(self):
return 'lineedit_history_'+self._name
def initialize(self, name):
self._name = name
self.addItems(history.get(self.store_name, []))
self.setEditText('')
self.lineEdit().editingFinished.connect(self.save_history)
def save_history(self):
items = []
ct = str(self.currentText())
if ct:
items.append(ct)
for i in range(self.count()):
item = str(self.itemText(i))
if item not in items:
items.append(item)
self.blockSignals(True)
self.clear()
self.addItems(items)
self.setEditText(ct)
self.blockSignals(False)
try:
history.set(self.store_name, items)
except ValueError:
from calibre.utils.cleantext import clean_ascii_chars
items = [clean_ascii_chars(force_unicode(x)) for x in items]
try:
history.set(self.store_name, items)
except ValueError:
pass
def setText(self, t):
self.setEditText(t)
self.lineEdit().setCursorPosition(0)
def text(self):
return self.currentText()
def focusOutEvent(self, e):
QComboBox.focusOutEvent(self, e)
if not (self.hasFocus() or self.view().hasFocus()):
self.lost_focus.emit()
# }}}
class ComboBoxWithHelp(QComboBox): # {{{
'''
A combobox where item 0 is help text. CurrentText will return '' for item 0.
Be sure to always fetch the text with currentText. Don't use the signals
that pass a string, because they will not correct the text.
'''
def __init__(self, parent=None):
QComboBox.__init__(self, parent)
self.currentIndexChanged.connect(self.index_changed)
self.help_text = ''
self.state_set = False
def initialize(self, help_text=_('Search')):
self.help_text = help_text
self.set_state()
def set_state(self):
if not self.state_set:
if self.currentIndex() == 0:
self.setItemText(0, self.help_text)
self.setStyleSheet('QComboBox { color: gray }')
else:
self.setItemText(0, '')
self.setStyleSheet('QComboBox { color: black }')
def index_changed(self, index):
self.state_set = False
self.set_state()
def currentText(self):
if self.currentIndex() == 0:
return ''
return QComboBox.currentText(self)
def itemText(self, idx):
if idx == 0:
return ''
return QComboBox.itemText(self, idx)
def showPopup(self):
self.setItemText(0, '')
QComboBox.showPopup(self)
def hidePopup(self):
QComboBox.hidePopup(self)
self.set_state()
# }}}
class EncodingComboBox(QComboBox): # {{{
'''
A combobox that holds text encodings support
by Python. This is only populated with the most
common and standard encodings. There is no good
way to programmatically list all supported encodings
using encodings.aliases.aliases.keys(). It
will not work.
'''
ENCODINGS = ['', 'cp1252', 'latin1', 'utf-8', '', 'ascii', 'big5', 'cp1250', 'cp1251', 'cp1253',
'cp1254', 'cp1255', 'cp1256', 'euc_jp', 'euc_kr', 'gb2312', 'gb18030',
'hz', 'iso2022_jp', 'iso2022_kr', 'iso8859_5', 'shift_jis',
]
def __init__(self, parent=None):
QComboBox.__init__(self, parent)
self.setEditable(True)
self.setLineEdit(EnLineEdit(self))
for item in self.ENCODINGS:
self.addItem(item)
# }}}
class PythonHighlighter(QSyntaxHighlighter): # {{{
Rules = ()
Formats = {}
KEYWORDS = ["and", "as", "assert", "break", "class", "continue", "def",
"del", "elif", "else", "except", "exec", "finally", "for", "from",
"global", "if", "import", "in", "is", "lambda", "not", "or",
"pass", "print", "raise", "return", "try", "while", "with",
"yield"]
BUILTINS = ["abs", "all", "any", "basestring", "bool", "callable", "chr",
"classmethod", "cmp", "compile", "complex", "delattr", "dict",
"dir", "divmod", "enumerate", "eval", "execfile", "exit", "file",
"filter", "float", "frozenset", "getattr", "globals", "hasattr",
"hex", "id", "int", "isinstance", "issubclass", "iter", "len",
"list", "locals", "long", "map", "max", "min", "object", "oct",
"open", "ord", "pow", "property", "range", "reduce", "repr",
"reversed", "round", "set", "setattr", "slice", "sorted",
"staticmethod", "str", "sum", "super", "tuple", "type", "unichr",
"unicode", "vars", "xrange", "zip"]
CONSTANTS = ["False", "True", "None", "NotImplemented", "Ellipsis"]
def __init__(self, parent=None):
super().__init__(parent)
if not self.Rules:
self.initialize_class_members()
@classmethod
def initialize_class_members(cls):
cls.initializeFormats()
r = []
def a(a, b):
r.append((a, b))
a(re.compile(
"|".join([r"\b%s\b" % keyword for keyword in cls.KEYWORDS])),
"keyword")
a(re.compile(
"|".join([r"\b%s\b" % builtin for builtin in cls.BUILTINS])),
"builtin")
a(re.compile(
"|".join([r"\b%s\b" % constant
for constant in cls.CONSTANTS])), "constant")
a(re.compile(
r"\b[+-]?[0-9]+[lL]?\b"
r"|\b[+-]?0[xX][0-9A-Fa-f]+[lL]?\b"
r"|\b[+-]?[0-9]+(?:\.[0-9]+)?(?:[eE][+-]?[0-9]+)?\b"),
"number")
a(re.compile(
r"\bPyQt6\b|\bQt?[A-Z][a-z]\w+\b"), "pyqt")
a(re.compile(r"\b@\w+\b"), "decorator")
stringRe = re.compile(r"""(?:'[^']*?'|"[^"]*?")""")
a(stringRe, "string")
cls.stringRe = re.compile(r"""(:?"["]".*?"["]"|'''.*?''')""")
a(cls.stringRe, "string")
cls.tripleSingleRe = re.compile(r"""'''(?!")""")
cls.tripleDoubleRe = re.compile(r'''"""(?!')''')
cls.Rules = tuple(r)
@classmethod
def initializeFormats(cls):
baseFormat = QTextCharFormat()
baseFormat.setFontFamilies(['monospace'])
p = QApplication.instance().palette()
is_dark = QApplication.instance().is_dark_theme
for name, color, bold, italic in (
("normal", None, False, False),
("keyword", p.color(QPalette.ColorRole.Link).name(), True, False),
("builtin", p.color(QPalette.ColorRole.Link).name(), False, False),
("constant", p.color(QPalette.ColorRole.Link).name(), False, False),
("decorator", "#0000E0", False, False),
("comment", '#00c700' if is_dark else "#007F00", False, True),
("string", '#b6b600' if is_dark else "#808000", False, False),
("number", '#d96d00' if is_dark else "#924900", False, False),
("error", "#FF0000", False, False),
("pyqt", "#50621A", False, False)):
fmt = QTextCharFormat(baseFormat)
if color is not None:
fmt.setForeground(QColor(color))
if bold:
fmt.setFontWeight(QFont.Weight.Bold)
if italic:
fmt.setFontItalic(italic)
cls.Formats[name] = fmt
def highlightBlock(self, text):
NORMAL, TRIPLESINGLE, TRIPLEDOUBLE, ERROR = range(4)
textLength = len(text)
prevState = self.previousBlockState()
self.setFormat(0, textLength,
self.Formats["normal"])
if text.startswith("Traceback") or text.startswith("Error: "):
self.setCurrentBlockState(ERROR)
self.setFormat(0, textLength,
self.Formats["error"])
return
if prevState == ERROR and \
not (text.startswith('>>>') or text.startswith("#")):
self.setCurrentBlockState(ERROR)
self.setFormat(0, textLength,
self.Formats["error"])
return
for regex, fmt in PythonHighlighter.Rules:
for m in regex.finditer(text):
self.setFormat(m.start(), m.end() - m.start(), self.Formats[fmt])
# Slow but good quality highlighting for comments. For more
# speed, comment this out and add the following to __init__:
# PythonHighlighter.Rules.append((re.compile(r"#.*"), "comment"))
if not text:
pass
elif text[0] == "#":
self.setFormat(0, len(text), self.Formats["comment"])
else:
stack = []
for i, c in enumerate(text):
if c in ('"', "'"):
if stack and stack[-1] == c:
stack.pop()
else:
stack.append(c)
elif c == "#" and len(stack) == 0:
self.setFormat(i, len(text), self.Formats["comment"])
break
self.setCurrentBlockState(NORMAL)
if self.stringRe.search(text) is not None:
return
# This is fooled by triple quotes inside single quoted strings
for m, state in (
(self.tripleSingleRe.search(text), TRIPLESINGLE),
(self.tripleDoubleRe.search(text), TRIPLEDOUBLE)
):
i = -1 if m is None else m.start()
if self.previousBlockState() == state:
if i == -1:
i = len(text)
self.setCurrentBlockState(state)
self.setFormat(0, i + 3,
self.Formats["string"])
elif i > -1:
self.setCurrentBlockState(state)
self.setFormat(i, len(text),
self.Formats["string"])
def rehighlight(self):
QApplication.setOverrideCursor(QCursor(Qt.CursorShape.WaitCursor))
super().rehighlight()
QApplication.restoreOverrideCursor()
# }}}
# Splitter {{{
class SplitterHandle(QSplitterHandle):
double_clicked = pyqtSignal(object)
def __init__(self, orientation, splitter):
super().__init__(orientation, splitter)
splitter.splitterMoved.connect(self.splitter_moved,
type=Qt.ConnectionType.QueuedConnection)
self.double_clicked.connect(splitter.double_clicked,
type=Qt.ConnectionType.QueuedConnection)
self.highlight = False
self.setToolTip(_('Drag to resize')+' '+splitter.label)
def splitter_moved(self, *args):
oh = self.highlight
self.highlight = 0 in self.splitter().sizes()
if oh != self.highlight:
self.update()
def mouseDoubleClickEvent(self, ev):
self.double_clicked.emit(self)
class PaperSizes(QComboBox): # {{{
system_default_paper_size = None
def initialize(self, choices=None):
from calibre.utils.icu import numeric_sort_key
if self.system_default_paper_size is None:
PaperSizes.system_default_paper_size = 'a4'
if iswindows or ismacos:
# On Linux, this can cause Qt to load the system cups plugin
# which can crash: https://bugs.launchpad.net/calibre/+bug/1861741
PaperSizes.system_default_paper_size = 'letter' if QPrinter().pageLayout().pageSize().id() == QPageSize.PageSizeId.Letter else 'a4'
if not choices:
from calibre.ebooks.conversion.plugins.pdf_output import PAPER_SIZES
choices = PAPER_SIZES
for a in sorted(choices, key=numeric_sort_key):
s = getattr(QPageSize.PageSizeId, a.capitalize())
sz = QPageSize.definitionSize(s)
unit = {QPageSize.Unit.Millimeter: 'mm', QPageSize.Unit.Inch: 'inch'}[QPageSize.definitionUnits(s)]
name = f'{QPageSize.name(s)} ({sz.width():g} x {sz.height():g} {unit})'
self.addItem(name, a)
@property
def get_value_for_config(self):
return self.currentData()
@get_value_for_config.setter
def set_value_for_config(self, val):
idx = self.findData(val or PaperSizes.system_default_paper_size)
if idx == -1:
idx = self.findData('a4')
self.setCurrentIndex(idx)
# }}}
class BusyCursor: # {{{
def __enter__(self):
QApplication.setOverrideCursor(QCursor(Qt.CursorShape.WaitCursor))
def __exit__(self, *args):
QApplication.restoreOverrideCursor()
# }}}
if __name__ == '__main__':
from qt.core import QTextEdit
app = QApplication([])
w = QTextEdit()
s = PythonHighlighter(w)
# w.setSyntaxHighlighter(s)
w.setText(open(__file__, 'rb').read().decode('utf-8'))
w.show()
app.exec()
| 38,325 | Python | .py | 928 | 32.040948 | 157 | 0.60283 | kovidgoyal/calibre | 19,243 | 2,250 | 4 | GPL-3.0 | 9/5/2024, 5:13:50 PM (Europe/Amsterdam) |
26,670 | email.py | kovidgoyal_calibre/src/calibre/gui2/email.py | #!/usr/bin/env python
__license__ = 'GPL v3'
__copyright__ = '2010, Kovid Goyal <kovid@kovidgoyal.net>'
__docformat__ = 'restructuredtext en'
import os
import socket
import textwrap
import time
from collections import defaultdict
from functools import partial
from itertools import repeat
from threading import Thread
from qt.core import QDialog, QDialogButtonBox, QGridLayout, QIcon, QLabel, QLineEdit, QListWidget, QListWidgetItem, QPushButton, Qt
from calibre.constants import preferred_encoding
from calibre.customize.ui import available_input_formats, available_output_formats
from calibre.ebooks.metadata import authors_to_string
from calibre.gui2 import Dispatcher, config, error_dialog, gprefs, warning_dialog
from calibre.gui2.threaded_jobs import ThreadedJob
from calibre.library.save_to_disk import get_components
from calibre.utils.config import prefs, tweaks
from calibre.utils.icu import primary_sort_key
from calibre.utils.resources import get_image_path as I
from calibre.utils.smtp import compose_mail, extract_email_address, sendmail
from calibre.utils.smtp import config as email_config
from polyglot.binary import from_hex_unicode
from polyglot.builtins import iteritems, itervalues
class Worker(Thread):
def __init__(self, func, args):
Thread.__init__(self)
self.daemon = True
self.exception = self.tb = None
self.func, self.args = func, args
def run(self):
# time.sleep(1000)
try:
self.func(*self.args)
except Exception as e:
import traceback
self.exception = e
self.tb = traceback.format_exc()
finally:
self.func = self.args = None
class Sendmail:
MAX_RETRIES = 1
TIMEOUT = 25 * 60 # seconds
def __init__(self):
self.calculate_rate_limit()
self.last_send_time = time.time() - self.rate_limit
def calculate_rate_limit(self):
self.rate_limit = 1
opts = email_config().parse()
rh = opts.relay_host
if rh:
for suffix in tweaks['public_smtp_relay_host_suffixes']:
if rh.lower().endswith(suffix):
self.rate_limit = tweaks['public_smtp_relay_delay']
break
def __call__(self, attachment, aname, to, subject, text, log=None,
abort=None, notifications=None):
try_count = 0
while True:
if try_count > 0:
log('\nRetrying in %d seconds...\n' %
self.rate_limit)
worker = Worker(self.sendmail,
(attachment, aname, to, subject, text, log))
worker.start()
start_time = time.time()
while worker.is_alive():
worker.join(0.2)
if abort.is_set():
log('Sending aborted by user')
return
if time.time() - start_time > self.TIMEOUT:
log('Sending timed out')
raise Exception(
'Sending email %r to %r timed out, aborting'% (subject,
to))
if worker.exception is None:
log('Email successfully sent')
return
log.error('\nSending failed...\n')
log.debug(worker.tb)
try_count += 1
if try_count > self.MAX_RETRIES:
raise worker.exception
def sendmail(self, attachment, aname, to, subject, text, log):
logged = False
while time.time() - self.last_send_time <= self.rate_limit:
if not logged and self.rate_limit > 0:
log('Waiting %s seconds before sending, to avoid being marked as spam.\nYou can control this delay via Preferences->Tweaks' % self.rate_limit)
logged = True
time.sleep(1)
try:
opts = email_config().parse()
from_ = opts.from_
if not from_:
from_ = 'calibre <calibre@'+socket.getfqdn()+'>'
with open(attachment, 'rb') as f:
msg = compose_mail(from_, to, text, subject, f, aname)
efrom = extract_email_address(from_)
eto = []
for x in to.split(','):
eto.append(extract_email_address(x.strip()))
def safe_debug(*args, **kwargs):
try:
return log.debug(*args, **kwargs)
except Exception:
pass
relay = opts.relay_host
if relay and relay == 'smtp.live.com':
# Microsoft changed the SMTP server
relay = 'smtp-mail.outlook.com'
sendmail(msg, efrom, eto, localhost=None,
verbose=1,
relay=relay,
username=opts.relay_username,
password=from_hex_unicode(opts.relay_password), port=opts.relay_port,
encryption=opts.encryption,
debug_output=safe_debug)
finally:
self.last_send_time = time.time()
gui_sendmail = Sendmail()
def is_for_kindle(to):
return isinstance(to, str) and ('@kindle.com' in to or '@kindle.cn' in to or '@free.kindle.com' in to or '@free.kindle.cn' in to)
def send_mails(jobnames, callback, attachments, to_s, subjects,
texts, attachment_names, job_manager):
for name, attachment, to, subject, text, aname in zip(jobnames,
attachments, to_s, subjects, texts, attachment_names):
description = _('Email %(name)s to %(to)s') % dict(name=name, to=to)
if isinstance(to, str) and (is_for_kindle(to) or '@pbsync.com' in to):
# The PocketBook service is a total joke. It cant handle
# non-ascii, filenames that are long enough to be split up, commas, and
# the good lord alone knows what else. So use a random filename
# containing only 22 English letters and numbers
#
# And since this email is only going to be processed by automated
# services, make the subject+text random too as at least the amazon
# service cant handle non-ascii text. I dont know what baboons
# these companies employ to write their code. It's the height of
# irony that they are called "tech" companies.
# https://bugs.launchpad.net/calibre/+bug/1989282
from calibre.utils.short_uuid import uuid4
if not is_for_kindle(to):
# Amazon nowadays reads metadata from attachment filename instead of
# file internal metadata so dont nuke the filename.
# https://www.mobileread.com/forums/showthread.php?t=349290
aname = f'{uuid4()}.' + aname.rpartition('.')[-1]
subject = uuid4()
text = uuid4()
job = ThreadedJob('email', description, gui_sendmail, (attachment, aname, to,
subject, text), {}, callback)
job_manager.run_threaded_job(job)
def email_news(mi, remove, get_fmts, done, job_manager):
opts = email_config().parse()
accounts = [(account, [x.strip().lower() for x in x[0].split(',')])
for account, x in opts.accounts.items() if x[1]]
sent_mails = []
for i, x in enumerate(accounts):
account, fmts = x
files = get_fmts(fmts)
files = [f for f in files if f is not None]
if not files:
continue
if opts.tags.get(account, False) and not ({t.strip() for t in opts.tags[account].split(',')} & set(mi.tags)):
continue
attachment = files[0]
to_s = [account]
subjects = [_('News:')+' '+mi.title]
texts = [_(
'Attached is the %s periodical downloaded by calibre.') % (mi.title,)]
attachment_names = [mi.title+os.path.splitext(attachment)[1]]
attachments = [attachment]
jobnames = [mi.title]
do_remove = []
if i == len(accounts) - 1:
do_remove = remove
send_mails(jobnames,
Dispatcher(partial(done, remove=do_remove)),
attachments, to_s, subjects, texts, attachment_names,
job_manager)
sent_mails.append(to_s[0])
return sent_mails
plugboard_email_value = 'email'
plugboard_email_formats = ['epub', 'mobi', 'azw3']
class SelectRecipients(QDialog): # {{{
def __init__(self, parent=None):
QDialog.__init__(self, parent)
self._layout = l = QGridLayout(self)
self.setLayout(l)
self.setWindowIcon(QIcon(I('mail.png')))
self.setWindowTitle(_('Select recipients'))
self.recipients = r = QListWidget(self)
l.addWidget(r, 0, 0, 1, -1)
self.la = la = QLabel(_('Add a new recipient:'))
la.setStyleSheet('QLabel { font-weight: bold }')
l.addWidget(la, l.rowCount(), 0, 1, -1)
self.labels = tuple(map(QLabel, (
_('&Address'), _('A&lias'), _('&Formats'), _('&Subject'))))
tooltips = (
_('The email address of the recipient'),
_('The optional alias (simple name) of the recipient'),
_('Formats to email. The first matching one will be sent (comma separated list)'),
_('The optional subject for email sent to this recipient'))
for i, name in enumerate(('address', 'alias', 'formats', 'subject')):
c = i % 2
row = l.rowCount() - c
self.labels[i].setText(str(self.labels[i].text()) + ':')
l.addWidget(self.labels[i], row, (2*c))
le = QLineEdit(self)
le.setToolTip(tooltips[i])
setattr(self, name, le)
self.labels[i].setBuddy(le)
l.addWidget(le, row, (2*c) + 1)
self.formats.setText(prefs['output_format'].upper())
self.add_button = b = QPushButton(QIcon(I('plus.png')), _('&Add recipient'), self)
b.clicked.connect(self.add_recipient)
l.addWidget(b, l.rowCount(), 0, 1, -1)
self.bb = bb = QDialogButtonBox(QDialogButtonBox.StandardButton.Ok|QDialogButtonBox.StandardButton.Cancel)
l.addWidget(bb, l.rowCount(), 0, 1, -1)
bb.accepted.connect(self.accept)
bb.rejected.connect(self.reject)
self.setMinimumWidth(500)
self.setMinimumHeight(400)
self.resize(self.sizeHint())
self.init_list()
def add_recipient(self):
to = str(self.address.text()).strip()
if not to:
return error_dialog(
self, _('Need address'), _('You must specify an address'), show=True)
from email.utils import parseaddr
if not parseaddr(to)[-1] or '@' not in to:
return error_dialog(
self, _('Invalid email address'), _('The address {} is invalid').format(to), show=True)
formats = ','.join([x.strip().upper() for x in str(self.formats.text()).strip().split(',') if x.strip()])
if not formats:
return error_dialog(
self, _('Need formats'), _('You must specify at least one format to send'), show=True)
opts = email_config().parse()
if to in opts.accounts:
return error_dialog(
self, _('Already exists'), _('The recipient %s already exists') % to, show=True)
acc = opts.accounts
acc[to] = [formats, False, False]
c = email_config()
c.set('accounts', acc)
alias = str(self.alias.text()).strip()
if alias:
opts.aliases[to] = alias
c.set('aliases', opts.aliases)
subject = str(self.subject.text()).strip()
if subject:
opts.subjects[to] = subject
c.set('subjects', opts.subjects)
self.create_item(alias or to, to, checked=True)
def create_item(self, alias, key, checked=False):
i = QListWidgetItem(alias, self.recipients)
i.setFlags(Qt.ItemFlag.ItemIsEnabled | Qt.ItemFlag.ItemIsUserCheckable)
i.setCheckState(Qt.CheckState.Checked if checked else Qt.CheckState.Unchecked)
i.setData(Qt.ItemDataRole.UserRole, key)
self.items.append(i)
def init_list(self):
opts = email_config().parse()
self.items = []
def sk(account):
return primary_sort_key(opts.aliases.get(account) or account)
for key in sorted(opts.accounts or (), key=sk):
self.create_item(opts.aliases.get(key, key), key)
def accept(self):
if not self.ans:
return error_dialog(self, _('No recipients'),
_('You must select at least one recipient'), show=True)
QDialog.accept(self)
@property
def ans(self):
opts = email_config().parse()
ans = []
for i in self.items:
if i.checkState() == Qt.CheckState.Checked:
to = str(i.data(Qt.ItemDataRole.UserRole) or '')
fmts = tuple(x.strip().upper() for x in (opts.accounts[to][0] or '').split(','))
subject = opts.subjects.get(to, '')
ans.append((to, fmts, subject))
return ans
def select_recipients(parent=None):
d = SelectRecipients(parent)
if d.exec() == QDialog.DialogCode.Accepted:
return d.ans
return ()
# }}}
class EmailMixin: # {{{
def __init__(self, *args, **kwargs):
pass
def send_multiple_by_mail(self, recipients, delete_from_library):
ids = {self.library_view.model().id(r) for r in self.library_view.selectionModel().selectedRows()}
if not ids:
return
db = self.current_db
db_fmt_map = {book_id:set((db.formats(book_id, index_is_id=True) or '').upper().split(',')) for book_id in ids}
ofmts = {x.upper() for x in available_output_formats()}
ifmts = {x.upper() for x in available_input_formats()}
bad_recipients = {}
auto_convert_map = defaultdict(list)
for to, fmts, subject in recipients:
rfmts = set(fmts)
ok_ids = {book_id for book_id, bfmts in iteritems(db_fmt_map) if bfmts.intersection(rfmts)}
convert_ids = ids - ok_ids
self.send_by_mail(to, fmts, delete_from_library, subject=subject, send_ids=ok_ids, do_auto_convert=False)
if not rfmts.intersection(ofmts):
bad_recipients[to] = (convert_ids, True)
continue
outfmt = tuple(f for f in fmts if f in ofmts)[0]
ok_ids = {book_id for book_id in convert_ids if db_fmt_map[book_id].intersection(ifmts)}
bad_ids = convert_ids - ok_ids
if bad_ids:
bad_recipients[to] = (bad_ids, False)
if ok_ids:
auto_convert_map[outfmt].append((to, subject, ok_ids))
if auto_convert_map:
titles = {book_id for x in itervalues(auto_convert_map) for data in x for book_id in data[2]}
titles = {db.title(book_id, index_is_id=True) for book_id in titles}
if self.auto_convert_question(
_('Auto convert the following books before sending via email?'), list(titles)):
for ofmt, data in iteritems(auto_convert_map):
ids = {bid for x in data for bid in x[2]}
data = [(to, subject) for to, subject, x in data]
self.iactions['Convert Books'].auto_convert_multiple_mail(ids, data, ofmt, delete_from_library)
if bad_recipients:
det_msg = []
titles = {book_id for x in itervalues(bad_recipients) for book_id in x[0]}
titles = {book_id:db.title(book_id, index_is_id=True) for book_id in titles}
for to, (ids, nooutput) in iteritems(bad_recipients):
msg = _('This recipient has no valid formats defined') if nooutput else \
_('These books have no suitable input formats for conversion')
det_msg.append(f'{to} - {msg}')
det_msg.extend('\t' + titles[bid] for bid in ids)
det_msg.append('\n')
warning_dialog(self, _('Could not send'),
_('Could not send books to some recipients. Click "Show details" for more information'),
det_msg='\n'.join(det_msg), show=True)
def send_by_mail(self, to, fmts, delete_from_library, subject='', send_ids=None,
do_auto_convert=True, specific_format=None):
ids = [self.library_view.model().id(r) for r in self.library_view.selectionModel().selectedRows()] if send_ids is None else send_ids
if not ids or len(ids) == 0:
return
modified_metadata = []
files, _auto_ids = self.library_view.model().get_preferred_formats_from_ids(
ids, fmts, set_metadata=True, specific_format=specific_format, exclude_auto=do_auto_convert,
use_plugboard=plugboard_email_value, plugboard_formats=plugboard_email_formats, modified_metadata=modified_metadata)
if do_auto_convert:
nids = list(set(ids).difference(_auto_ids))
ids = [i for i in ids if i in nids]
else:
_auto_ids = []
full_metadata = self.library_view.model().metadata_for(ids,
get_cover=False)
bad, remove_ids, jobnames = [], [], []
texts, subjects, attachments, attachment_names = [], [], [], []
for f, mi, id, newmi in zip(files, full_metadata, ids, modified_metadata):
if not newmi:
newmi = mi
t = mi.title or _('Unknown')
if f is None:
bad.append(t)
else:
remove_ids.append(id)
jobnames.append(t)
attachments.append(f)
if not subject:
subjects.append(_('E-book:')+ ' '+t)
else:
components = get_components(subject, mi, id)
if not components:
components = [mi.title]
subjects.append(os.path.join(*components))
a = authors_to_string(mi.authors or [_('Unknown')])
texts.append(_('Attached, you will find the e-book') +
'\n\n' + t + '\n\t' + _('by') + ' ' + a + '\n\n' +
_('in the %s format.') %
os.path.splitext(f)[1][1:].upper())
if mi.comments and gprefs['add_comments_to_email']:
from calibre.ebooks.metadata import fmt_sidx
from calibre.utils.html2text import html2text
if mi.series:
sidx=fmt_sidx(1.0 if mi.series_index is None else mi.series_index, use_roman=config['use_roman_numerals_for_series_number'])
texts[-1] += '\n\n' + _('{series_index} of {series}').format(series_index=sidx, series=mi.series)
texts[-1] += '\n\n' + _('About this book:') + '\n\n' + textwrap.fill(html2text(mi.comments))
if is_for_kindle(to):
prefix = str(newmi.title or t)
else:
prefix = f'{t} - {a}'
if not isinstance(prefix, str):
prefix = prefix.decode(preferred_encoding, 'replace')
attachment_names.append(prefix + os.path.splitext(f)[1])
remove = remove_ids if delete_from_library else []
to_s = list(repeat(to, len(attachments)))
if attachments:
send_mails(jobnames,
Dispatcher(partial(self.email_sent, remove=remove)),
attachments, to_s, subjects, texts, attachment_names,
self.job_manager)
self.status_bar.show_message(_('Sending email to')+' '+to, 3000)
auto = []
if _auto_ids != []:
for id in _auto_ids:
if specific_format is None:
dbfmts = self.library_view.model().db.formats(id, index_is_id=True)
formats = [f.lower() for f in (dbfmts.split(',') if dbfmts else
[])]
if set(formats).intersection(available_input_formats()) and set(fmts).intersection(available_output_formats()):
auto.append(id)
else:
bad.append(self.library_view.model().db.title(id, index_is_id=True))
else:
if specific_format in list(set(fmts).intersection(set(available_output_formats()))):
auto.append(id)
else:
bad.append(self.library_view.model().db.title(id, index_is_id=True))
if auto != []:
format = specific_format if specific_format in list(set(fmts).intersection(set(available_output_formats()))) else None
if not format:
for fmt in fmts:
if fmt in list(set(fmts).intersection(set(available_output_formats()))):
format = fmt
break
if format is None:
bad += auto
else:
autos = [self.library_view.model().db.title(id, index_is_id=True) for id in auto]
if self.auto_convert_question(
_('Auto convert the following books to %s before sending via '
'email?') % format.upper(), autos):
self.iactions['Convert Books'].auto_convert_mail(to, fmts, delete_from_library, auto, format, subject)
if bad:
bad = '\n'.join('%s'%(i,) for i in bad)
d = warning_dialog(self, _('No suitable formats'),
_('Could not email the following books '
'as no suitable formats were found:'), bad)
d.exec()
def email_sent(self, job, remove=[]):
if job.failed:
self.job_exception(job, dialog_title=_('Failed to email book'))
return
self.status_bar.show_message(job.description + ' ' + _('sent'),
5000)
if remove:
try:
next_id = self.library_view.next_id
self.library_view.model().delete_books_by_id(remove)
self.iactions['Remove Books'].library_ids_deleted2(remove,
next_id=next_id)
except:
import traceback
# Probably the user deleted the files, in any case, failing
# to delete the book is not catastrophic
traceback.print_exc()
def email_news(self, id_):
mi = self.library_view.model().db.get_metadata(id_,
index_is_id=True)
remove = [id_] if config['delete_news_from_library_on_upload'] \
else []
def get_fmts(fmts):
files, auto = self.library_view.model().\
get_preferred_formats_from_ids([id_], fmts,
set_metadata=True,
use_plugboard=plugboard_email_value,
plugboard_formats=plugboard_email_formats)
return files
sent_mails = email_news(mi, remove,
get_fmts, self.email_sent, self.job_manager)
if sent_mails:
self.status_bar.show_message(_('Sent news to')+' '+
', '.join(sent_mails), 3000)
# }}}
if __name__ == '__main__':
from qt.core import QApplication
app = QApplication([]) # noqa
print(select_recipients())
| 23,666 | Python | .py | 479 | 36.736952 | 158 | 0.563476 | kovidgoyal/calibre | 19,243 | 2,250 | 4 | GPL-3.0 | 9/5/2024, 5:13:50 PM (Europe/Amsterdam) |
26,671 | win_file_dialogs.py | kovidgoyal_calibre/src/calibre/gui2/win_file_dialogs.py | #!/usr/bin/env python
# License: GPLv3 Copyright: 2016, Kovid Goyal <kovid at kovidgoyal.net>
import os
import struct
import subprocess
import sys
from contextlib import suppress
from threading import Thread
from uuid import uuid4
from calibre.utils.localization import _
from polyglot.builtins import string_or_bytes
base = sys.extensions_location if hasattr(sys, 'new_app_layout') else os.path.dirname(sys.executable)
HELPER = os.path.join(base, 'calibre-file-dialog.exe')
current_app_uid = None
def set_app_uid(val=None):
global current_app_uid
current_app_uid = val
def is_ok():
return os.path.exists(HELPER)
try:
from calibre.utils.config import dynamic
except ImportError:
dynamic = {}
def get_hwnd(widget=None):
ewid = None
if widget is not None:
ewid = widget.effectiveWinId()
if ewid is None:
return None
return int(ewid)
def serialize_hwnd(hwnd):
if hwnd is None:
return b''
return struct.pack('=B4sQ', 4, b'HWND', int(hwnd))
def serialize_secret(secret):
return struct.pack('=B6s32s', 6, b'SECRET', secret)
def serialize_binary(key, val):
key = key.encode('ascii') if not isinstance(key, bytes) else key
return struct.pack('=B%ssB' % len(key), len(key), key, int(val))
def serialize_string(key, val):
key = key.encode('ascii') if not isinstance(key, bytes) else key
val = str(val).encode('utf-8')
if len(val) > 2**16 - 1:
raise ValueError('%s is too long' % key)
return struct.pack('=B%dsH%ds' % (len(key), len(val)), len(key), key, len(val), val)
def serialize_file_types(file_types):
key = b"FILE_TYPES"
buf = [struct.pack('=B%dsH' % len(key), len(key), key, len(file_types))]
def add(x):
x = x.encode('utf-8').replace(b'\0', b'')
buf.append(struct.pack('=H%ds' % len(x), len(x), x))
for name, extensions in file_types:
add(name or _('Files'))
if isinstance(extensions, string_or_bytes):
extensions = extensions.split()
add('; '.join('*.' + ext.lower() for ext in extensions))
return b''.join(buf)
class Helper(Thread):
def __init__(self, process, data, callback):
Thread.__init__(self, name='FileDialogHelper')
self.process = process
self.callback = callback
self.data = data
self.daemon = True
self.rc = 1
self.stdoutdata = self.stderrdata = b''
def run(self):
try:
self.stdoutdata, self.stderrdata = self.process.communicate(b''.join(self.data))
self.rc = self.process.wait()
finally:
self.callback()
def process_path(x):
if isinstance(x, bytes):
x = os.fsdecode(x)
return os.path.abspath(os.path.expanduser(x))
def select_initial_dir(q):
while q:
c = os.path.dirname(q)
if c == q:
break
if os.path.exists(c):
return c
q = c
return os.path.expanduser('~')
def run_file_dialog(
parent=None, title=None, initial_folder=None, filename=None, save_path=None,
allow_multiple=False, only_dirs=False, confirm_overwrite=True, save_as=False, no_symlinks=False,
file_types=(), default_ext=None, app_uid=None
):
from calibre.gui2 import sanitize_env_vars
secret = os.urandom(32).replace(b'\0', b' ')
pipename = '\\\\.\\pipe\\%s' % uuid4()
data = [serialize_string('PIPENAME', pipename), serialize_secret(secret)]
parent = parent or None
if parent is not None:
data.append(serialize_hwnd(get_hwnd(parent)))
if title:
data.append(serialize_string('TITLE', title))
if no_symlinks:
data.append(serialize_binary('NO_SYMLINKS', no_symlinks))
if save_as:
data.append(serialize_binary('SAVE_AS', save_as))
if confirm_overwrite:
data.append(serialize_binary('CONFIRM_OVERWRITE', confirm_overwrite))
if save_path is not None:
save_path = process_path(save_path)
if os.path.exists(save_path):
data.append(serialize_string('SAVE_PATH', save_path))
else:
if not initial_folder:
initial_folder = select_initial_dir(save_path)
if not filename:
filename = os.path.basename(save_path)
else:
if allow_multiple:
data.append(serialize_binary('MULTISELECT', allow_multiple))
if only_dirs:
data.append(serialize_binary('ONLY_DIRS', only_dirs))
if initial_folder is not None:
initial_folder = process_path(initial_folder)
if os.path.isdir(initial_folder):
data.append(serialize_string('FOLDER', initial_folder))
if filename:
if isinstance(filename, bytes):
filename = os.fsdecode(filename)
data.append(serialize_string('FILENAME', filename))
if only_dirs:
file_types = () # file types not allowed for dir only dialogs
elif not file_types:
file_types = [(_('All files'), ('*',))]
if file_types:
data.append(serialize_file_types(file_types))
if default_ext:
data.append(serialize_string('DEFAULT_EXTENSION', default_ext))
app_uid = app_uid or current_app_uid
if app_uid:
data.append(serialize_string('APP_UID', app_uid))
from qt.core import QEventLoop, Qt, pyqtSignal
class Loop(QEventLoop):
dialog_closed = pyqtSignal()
def __init__(self):
QEventLoop.__init__(self)
self.dialog_closed.connect(self.exit, type=Qt.ConnectionType.QueuedConnection)
loop = Loop()
server = PipeServer(pipename)
server.start()
with sanitize_env_vars():
h = Helper(subprocess.Popen(
[HELPER], stdout=subprocess.PIPE, stdin=subprocess.PIPE, stderr=subprocess.PIPE),
data, loop.dialog_closed.emit)
h.start()
loop.exec(QEventLoop.ProcessEventsFlag.ExcludeUserInputEvents)
def decode(x):
x = x or b''
try:
x = x.decode('utf-8')
except Exception:
x = repr(x)
return x
def get_errors():
return decode(h.stdoutdata) + ' ' + decode(h.stderrdata)
from calibre import prints
from calibre.constants import DEBUG
if DEBUG:
prints('stdout+stderr from file dialog helper:', str([h.stdoutdata, h.stderrdata]))
if h.rc != 0:
raise Exception(f'File dialog failed (return code {h.rc}): {get_errors()}')
server.join(2)
if server.is_alive():
raise Exception('Timed out waiting for read from pipe to complete')
if server.err_msg:
raise Exception(server.err_msg)
if not server.data:
return ()
parts = list(filter(None, server.data.split(b'\0')))
if DEBUG:
prints('piped data from file dialog helper:', str(parts))
if len(parts) < 2:
return ()
if parts[0] != secret:
raise Exception('File dialog failed, incorrect secret received: ' + get_errors())
from calibre_extensions.winutil import get_long_path_name
def fix_path(x):
u = os.path.abspath(x.decode('utf-8'))
with suppress(Exception):
try:
return get_long_path_name(u)
except FileNotFoundError:
base, fn = os.path.split(u)
return os.path.join(get_long_path_name(base), fn)
return u
ans = tuple(map(fix_path, parts[1:]))
return ans
def get_initial_folder(name, title, default_dir='~', no_save_dir=False):
name = name or 'dialog_' + title
if no_save_dir:
initial_folder = os.path.expanduser(default_dir)
else:
initial_folder = dynamic.get(name, os.path.expanduser(default_dir))
if not initial_folder or not os.path.isdir(initial_folder):
initial_folder = select_initial_dir(initial_folder)
return name, initial_folder
def choose_dir(window, name, title, default_dir='~', no_save_dir=False):
name, initial_folder = get_initial_folder(name, title, default_dir, no_save_dir)
ans = run_file_dialog(window, title, only_dirs=True, initial_folder=initial_folder)
if ans:
ans = ans[0]
if not no_save_dir:
dynamic.set(name, ans)
return ans
def choose_files(window, name, title,
filters=(), all_files=True, select_only_single_file=False, default_dir='~', no_save_dir=False):
name, initial_folder = get_initial_folder(name, title, default_dir, no_save_dir)
file_types = list(filters)
if all_files:
file_types.append((_('All files'), ['*']))
ans = run_file_dialog(window, title, allow_multiple=not select_only_single_file, initial_folder=initial_folder, file_types=file_types)
if ans and not no_save_dir:
dynamic.set(name, os.path.dirname(ans[0]))
return ans or None
def choose_images(window, name, title, select_only_single_file=True, formats=None):
if formats is None:
from calibre.gui2.dnd import image_extensions
formats = image_extensions()
file_types = [(_('Images'), list(formats))]
return choose_files(window, name, title, select_only_single_file=select_only_single_file, filters=file_types)
def choose_save_file(window, name, title, filters=[], all_files=True, initial_path=None, initial_filename=None):
no_save_dir = False
default_dir = '~'
filename = initial_filename
if initial_path is not None:
no_save_dir = True
default_dir = select_initial_dir(initial_path)
filename = os.path.basename(initial_path)
file_types = list(filters)
if all_files:
file_types.append((_('All files'), ['*']))
all_exts = []
for ftext, exts in file_types:
for ext in exts:
if '*' not in ext:
all_exts.append(ext.lower())
default_ext = all_exts[0] if all_exts else None
name, initial_folder = get_initial_folder(name, title, default_dir, no_save_dir)
ans = run_file_dialog(window, title, save_as=True, initial_folder=initial_folder, filename=filename, file_types=file_types, default_ext=default_ext)
if ans:
ans = ans[0]
if not no_save_dir:
dynamic.set(name, ans)
return ans
class PipeServer(Thread):
def __init__(self, pipename):
Thread.__init__(self, name='PipeServer', daemon=True)
from calibre_extensions import winutil
self.client_connected = False
self.pipe_handle = winutil.create_named_pipe(
pipename, winutil.PIPE_ACCESS_INBOUND | winutil.FILE_FLAG_FIRST_PIPE_INSTANCE,
winutil.PIPE_TYPE_BYTE | winutil.PIPE_READMODE_BYTE | winutil.PIPE_WAIT | winutil.PIPE_REJECT_REMOTE_CLIENTS,
1, 8192, 8192, 0)
winutil.set_handle_information(self.pipe_handle, winutil.HANDLE_FLAG_INHERIT, 0)
self.err_msg = None
self.data = b''
def run(self):
from calibre_extensions import winutil
try:
try:
winutil.connect_named_pipe(self.pipe_handle)
except Exception as err:
self.err_msg = f'ConnectNamedPipe failed: {err}'
return
self.client_connected = True
while True:
try:
data = winutil.read_file(self.pipe_handle, 64 * 1024)
except OSError as err:
if err.winerror == winutil.ERROR_BROKEN_PIPE:
break # pipe was closed at the other end
self.err_msg = f'ReadFile on pipe failed: {err}'
if not data:
break
self.data += data
finally:
self.pipe_handle = None
def test(helper=HELPER):
pipename = '\\\\.\\pipe\\%s' % uuid4()
echo = '\U0001f431 Hello world!'
secret = os.urandom(32).replace(b'\0', b' ')
data = serialize_string('PIPENAME', pipename) + serialize_string('ECHO', echo) + serialize_secret(secret)
server = PipeServer(pipename)
server.start()
p = subprocess.Popen([helper], stdout=subprocess.PIPE, stdin=subprocess.PIPE, stderr=subprocess.PIPE)
stdout, stderr = p.communicate(data)
if p.wait() != 0:
raise Exception('File dialog failed: ' + stdout.decode('utf-8') + ' ' + stderr.decode('utf-8'))
if server.err_msg is not None:
raise RuntimeError(server.err_msg)
server.join(2)
parts = list(filter(None, server.data.split(b'\0')))
if parts[0] != secret:
raise RuntimeError(f'Did not get back secret: {secret!r} != {parts[0]!r}')
q = parts[1].decode('utf-8')
if q != echo:
raise RuntimeError('Unexpected response: %r' % server.data)
if __name__ == '__main__':
from calibre.gui2 import Application
app = Application([])
print(choose_save_file(None, 'xxx', 'yyy'))
del app
| 12,817 | Python | .py | 309 | 33.711974 | 152 | 0.632382 | kovidgoyal/calibre | 19,243 | 2,250 | 4 | GPL-3.0 | 9/5/2024, 5:13:50 PM (Europe/Amsterdam) |
26,672 | webengine.py | kovidgoyal_calibre/src/calibre/gui2/webengine.py | #!/usr/bin/env python
# License: GPL v3 Copyright: 2018, Kovid Goyal <kovid at kovidgoyal.net>
from qt.core import Qt, pyqtSignal
from qt.webengine import QWebEnginePage, QWebEngineView
from calibre import prints
from calibre.utils.monotonic import monotonic
class RestartingWebEngineView(QWebEngineView):
render_process_restarted = pyqtSignal()
render_process_failed = pyqtSignal()
def __init__(self, parent=None):
QWebEngineView.__init__(self, parent)
self._last_reload_at = None
self.renderProcessTerminated.connect(self.render_process_terminated)
self.render_process_restarted.connect(self.reload, type=Qt.ConnectionType.QueuedConnection)
def render_process_terminated(self, termination_type, exit_code):
if termination_type == QWebEnginePage.RenderProcessTerminationStatus.NormalTerminationStatus:
return
self.webengine_crash_message = 'The Qt WebEngine Render process crashed with termination type: {} and exit code: {}'.format(
termination_type, exit_code)
prints(self.webengine_crash_message)
if self._last_reload_at is not None and monotonic() - self._last_reload_at < 2:
self.render_process_failed.emit()
prints('The Qt WebEngine Render process crashed too often')
else:
self._last_reload_at = monotonic()
self.render_process_restarted.emit()
prints('Restarting Qt WebEngine')
| 1,470 | Python | .py | 27 | 46.666667 | 132 | 0.717967 | kovidgoyal/calibre | 19,243 | 2,250 | 4 | GPL-3.0 | 9/5/2024, 5:13:50 PM (Europe/Amsterdam) |
26,673 | main_window.py | kovidgoyal_calibre/src/calibre/gui2/main_window.py | __license__ = 'GPL v3'
__copyright__ = '2008, Kovid Goyal <kovid at kovidgoyal.net>'
import gc
import os
import sys
import weakref
from qt.core import QAction, QIcon, QKeySequence, QMainWindow, QMenu, QMenuBar, QObject, Qt, QTimer, pyqtSignal
from calibre import as_unicode, prepare_string_for_xml, prints
from calibre.constants import iswindows
from calibre.gui2 import error_dialog
from calibre.utils.config import OptionParser
from polyglot.io import PolyglotStringIO
def option_parser(usage='''\
Usage: %prog [options]
Launch the Graphical User Interface
'''):
parser = OptionParser(usage)
return parser
class GarbageCollector(QObject):
'''
Disable automatic garbage collection and instead collect manually
every INTERVAL milliseconds.
This is done to ensure that garbage collection only happens in the GUI
thread, as otherwise Qt can crash.
'''
INTERVAL = 5000
def __init__(self, parent, debug=False):
QObject.__init__(self, parent)
self.debug = debug
self.timer = QTimer(self)
self.timer.timeout.connect(self.check)
self.threshold = gc.get_threshold()
gc.disable()
self.timer.start(self.INTERVAL)
# gc.set_debug(gc.DEBUG_SAVEALL)
def check(self):
# return self.debug_cycles()
l0, l1, l2 = gc.get_count()
if self.debug:
print('gc_check called:', l0, l1, l2)
if l0 > self.threshold[0]:
num = gc.collect(0)
if self.debug:
print('collecting gen 0, found:', num, 'unreachable')
if l1 > self.threshold[1]:
num = gc.collect(1)
if self.debug:
print('collecting gen 1, found:', num, 'unreachable')
if l2 > self.threshold[2]:
num = gc.collect(2)
if self.debug:
print('collecting gen 2, found:', num, 'unreachable')
def debug_cycles(self):
gc.collect()
for obj in gc.garbage:
print(obj, repr(obj), type(obj))
class ExceptionHandler:
def __init__(self, main_window):
self.wref = weakref.ref(main_window)
def __call__(self, type, value, tb):
mw = self.wref()
if mw is not None:
mw.display_unhandled_exception.emit(type, value, tb)
else:
sys.__excepthook__(type, value, tb)
class MainWindow(QMainWindow):
___menu_bar = None
___menu = None
__actions = []
display_unhandled_exception = pyqtSignal(object, object, object)
@classmethod
def create_application_menubar(cls):
if not cls.__actions:
mb = QMenuBar(None)
menu = QMenu()
for action in cls.get_menubar_actions():
menu.addAction(action)
cls.__actions.append(action)
mb.addMenu(menu)
cls.___menu_bar = mb
cls.___menu = menu
return cls.__actions
@classmethod
def get_menubar_actions(cls):
preferences_action = QAction(QIcon.ic('config.png'), _('&Preferences'), None)
quit_action = QAction(QIcon.ic('window-close.png'), _('&Quit'), None)
preferences_action.setMenuRole(QAction.MenuRole.PreferencesRole)
quit_action.setMenuRole(QAction.MenuRole.QuitRole)
return preferences_action, quit_action
@property
def native_menubar(self):
return self.___menu_bar
def __init__(self, opts=None, parent=None, disable_automatic_gc=False):
QMainWindow.__init__(self, parent)
self.display_unhandled_exception.connect(self.unhandled_exception, type=Qt.ConnectionType.QueuedConnection)
if disable_automatic_gc:
self._gc = GarbageCollector(self, debug=False)
def enable_garbage_collection(self, enabled=True):
if hasattr(self, '_gc'):
self._gc.timer.blockSignals(not enabled)
else:
gc.enable() if enabled else gc.disable()
def set_exception_handler(self):
sys.excepthook = ExceptionHandler(self)
def show_possible_sharing_violation(self, e: Exception, det_msg: str = '') -> bool:
if not iswindows or not isinstance(e, OSError):
return False
import errno
from calibre_extensions import winutil
if not (e.winerror == winutil.ERROR_SHARING_VIOLATION or e.errno == errno.EACCES or isinstance(e, PermissionError)):
return False
msg = getattr(e, 'locking_violation_msg', '')
if msg:
msg = msg.strip() + ' '
fname = e.filename
def no_processes_found() -> bool:
is_folder = fname and os.path.isdir(fname)
if e.winerror == winutil.ERROR_SHARING_VIOLATION:
if fname:
if is_folder:
dmsg = _('The folder "{}" is opened in another program, so calibre cannot access it.').format(fname)
else:
dmsg = _('The file "{}" is opened in another program, so calibre cannot access it.').format(fname)
else:
if is_folder:
dmsg = _('A folder is open in another program so calibre cannot access it.')
else:
dmsg = _('A file is open in another program so calibre cannot access it.')
if is_folder:
dmsg += _('This is usually caused by leaving Windows explorer or a similar file manager open'
' to a folder in the calibre library. Close Windows explorer and retry.')
else:
dmsg += _('This is usually caused by software such as antivirus or file sync (aka DropBox and similar)'
' accessing files in the calibre library folder at the same time as calibre. Try excluding'
' the calibre library folder from such software.')
error_dialog(self, _('Cannot open file or folder as it is in use'), msg + dmsg, det_msg=det_msg, show=True)
return True
if msg:
if fname:
dmsg = _('Permission was denied by the operating system when calibre tried to access the file: "{0}".').format(fname)
else:
dmsg = _('Permission was denied by the operating system when calibre tried to access a file.')
dmsg += ' ' + _('This means either that the permissions on the file or its parent folder are incorrect or the file is'
' open in another program.')
error_dialog(self, _('Cannot open file or folder'), msg + dmsg, det_msg=det_msg, show=True)
return True
return False
if not hasattr(winutil, 'get_processes_using_files'):
return no_processes_found() # running from source
if not e.filename and not e.filename2:
return no_processes_found()
if e.filename and isinstance(e.filename, str):
if os.path.isdir(e.filename):
return no_processes_found()
try:
p = winutil.get_processes_using_files(e.filename)
except OSError:
return no_processes_found()
if not p and e.filename2 and isinstance(e.filename2, str):
if os.path.isdir(e.filename2):
return no_processes_found()
try:
p = winutil.get_processes_using_files(e.filename2)
except OSError:
return no_processes_found()
fname = e.filename2
if not p:
return no_processes_found()
path_map = {x['path']: x for x in p}
is_folder = fname and os.path.isdir(fname)
if is_folder:
dmsg = _('Could not open the folder: "{}". It is already opened in the following programs:').format(fname)
else:
dmsg = _('Could not open the file: "{}". It is already opened in the following programs:').format(fname)
for path, x in path_map.items():
dmsg += '<div>' + prepare_string_for_xml(f'{x["app_name"]}: {path}')
msg = prepare_string_for_xml(msg)
error_dialog(self, _('Cannot open file or folder as it is in use'), '<p>' + msg + dmsg, det_msg=det_msg, show=True)
return True
def unhandled_exception(self, exc_type, value, tb):
if exc_type is KeyboardInterrupt:
return
import traceback
try:
sio = PolyglotStringIO(errors='replace')
try:
from calibre.debug import print_basic_debug_info
print_basic_debug_info(out=sio)
except:
pass
traceback.print_exception(exc_type, value, tb, file=sio)
if getattr(value, 'locking_debug_msg', None):
prints(value.locking_debug_msg, file=sio)
fe = sio.getvalue()
prints(fe, file=sys.stderr)
try:
if self.show_possible_sharing_violation(value, det_msg=fe):
return
except Exception:
traceback.print_exc()
msg = '<b>%s</b>:'%exc_type.__name__ + prepare_string_for_xml(as_unicode(value))
error_dialog(self, _('Unhandled exception'), msg, det_msg=fe,
show=True)
except BaseException:
pass
except:
pass
def clone_menu(menu):
# This is needed to workaround a bug in Qt 5.5+ and Unity. When the same
# QAction object is used in both a QMenuBar and a QMenu, sub-menus of the
# QMenu flicker when rendered under Unity.
def clone_action(ac, parent):
if ac.isSeparator():
ans = QAction(parent)
ans.setSeparator(True)
return ans
sc = ac.shortcut()
sc = '' if sc.isEmpty() else sc.toString(QKeySequence.SequenceFormat.NativeText)
text = ac.text()
if '\t' not in text:
text += '\t' + sc
ans = QAction(ac.icon(), text, parent)
ans.triggered.connect(ac.trigger)
ans.setEnabled(ac.isEnabled())
ans.setStatusTip(ac.statusTip())
ans.setVisible(ac.isVisible())
return ans
def clone_one_menu(m):
m.aboutToShow.emit()
ans = QMenu(m.parent())
for ac in m.actions():
cac = clone_action(ac, ans)
ans.addAction(cac)
m = ac.menu()
if m is not None:
cac.setMenu(clone_menu(m))
return ans
return clone_one_menu(menu)
| 10,648 | Python | .py | 238 | 33.546218 | 137 | 0.585342 | kovidgoyal/calibre | 19,243 | 2,250 | 4 | GPL-3.0 | 9/5/2024, 5:13:50 PM (Europe/Amsterdam) |
26,674 | add_filters.py | kovidgoyal_calibre/src/calibre/gui2/add_filters.py | #!/usr/bin/env python
# License: GPLv3 Copyright: 2015, Kovid Goyal <kovid at kovidgoyal.net>
from collections import OrderedDict
from calibre.db.adding import compile_glob, compile_rule, filter_filename
from calibre.gui2 import Application, elided_text, error_dialog
from calibre.gui2.tag_mapper import RuleEdit as RuleEditBase
from calibre.gui2.tag_mapper import RuleEditDialog as RuleEditDialogBase
from calibre.gui2.tag_mapper import RuleItem as RuleItemBase
from calibre.gui2.tag_mapper import Rules as RulesBase
from calibre.gui2.tag_mapper import RulesDialog as RulesDialogBase
from calibre.gui2.tag_mapper import Tester as TesterBase
from calibre.utils.config import JSONConfig
add_filters = JSONConfig('add-filter-rules')
class RuleEdit(RuleEditBase):
ACTION_MAP = OrderedDict((
('ignore', _('Ignore')),
('add', _('Add')),
))
MATCH_TYPE_MAP = OrderedDict((
('startswith', _('starts with')),
('not_startswith', _('does not start with')),
('endswith', _('ends with')),
('not_endswith', _('does not end with')),
('glob', _('matches glob pattern')),
('not_glob', _('does not match glob pattern')),
('matches', _('matches regex pattern')),
('not_matches', _('does not match regex pattern')),
))
MSG = _('Create the rule below, the rule can be used to add or ignore files')
SUBJECT = _('the file, if the filename')
VALUE_ERROR = _('You must provide a value for the filename to match')
def update_state(self):
tt = _('A comma separated list of tags')
q = self.match_type.currentData()
if 'with' in q:
tt = _('Matching is case-insensitive')
elif 'glob' in q:
tt = _('A case-insensitive filename pattern, for example: {0} or {1}').format('*.pdf', 'number-?.epub')
else:
tt = _('A regular expression')
self.regex_help.setVisible('matches' in q)
self.query.setToolTip(tt)
@property
def rule(self):
return {
'action': self.action.currentData(),
'match_type': self.match_type.currentData(),
'query': self.query.text().strip(),
}
@rule.setter
def rule(self, rule):
def sc(name):
c = getattr(self, name)
idx = c.findData(str(rule.get(name, '')))
if idx < 0:
idx = 0
c.setCurrentIndex(idx)
sc('action'), sc('match_type')
self.query.setText(str(rule.get('query', '')).strip())
def validate(self):
ans = super().validate()
if ans:
rule = self.rule
if 'glob' in rule['match_type']:
try:
compile_glob(rule['query'])
except Exception:
error_dialog(self, _('Query invalid'), _(
'%s is not a valid glob expression') % rule['query'], show=True)
return False
return ans
class RuleEditDialog(RuleEditDialogBase):
PREFS_NAME = 'edit-add-filter-rule'
RuleEditClass = RuleEdit
class RuleItem(RuleItemBase):
@staticmethod
def text_from_rule(rule, parent):
query = elided_text(rule['query'], font=parent.font(), width=200, pos='right')
text = _(
'<b>{action}</b> the file, if the filename <i>{match_type}</i>: <b>{query}</b>').format(
action=RuleEdit.ACTION_MAP[rule['action']], match_type=RuleEdit.MATCH_TYPE_MAP[rule['match_type']], query=query)
return text
class Rules(RulesBase):
RuleItemClass = RuleItem
RuleEditDialogClass = RuleEditDialog
MSG = _('You can specify rules to add/ignore files here. They will be used'
' when recursively adding files from folders/archives and also'
' when auto-adding. Click the "Add Rule" button'
' below to get started. The rules will be processed in order for every file until either an'
' "add" or an "ignore" rule matches. If no rules match, the file will be added only'
' if its file extension is of a known e-book type.')
class Tester(TesterBase):
DIALOG_TITLE = _('Test filename filter rules')
PREFS_NAME = 'test-file-filter-rules'
LABEL = _('Enter a filename to test:')
PLACEHOLDER = _('Enter filename and click the "Test" button')
EMPTY_RESULT = '<p> </p>'
def do_test(self):
filename = self.value.strip()
allowed = filter_filename(map(compile_rule, self.rules), filename)
if allowed is None:
self.result.setText(_('The filename %s did not match any rules') % filename)
else:
self.result.setText(_('The filename {0} will be {1}').format(filename, _('added' if allowed else 'ignored')))
class RulesDialog(RulesDialogBase):
DIALOG_TITLE = _('Edit file filter rules')
PREFS_NAME = 'edit-file-filter-rules'
RulesClass = Rules
TesterClass = Tester
PREFS_OBJECT = add_filters
if __name__ == '__main__':
app = Application([])
d = RulesDialog()
d.rules = [
{'action':'ignore', 'query':'ignore-me', 'match_type':'startswith'},
{'action':'add', 'query':'*.moose', 'match_type':'glob'},
]
d.exec()
from pprint import pprint
pprint(d.rules)
del d, app
| 5,317 | Python | .py | 121 | 35.942149 | 128 | 0.620136 | kovidgoyal/calibre | 19,243 | 2,250 | 4 | GPL-3.0 | 9/5/2024, 5:13:50 PM (Europe/Amsterdam) |
26,675 | notify.py | kovidgoyal_calibre/src/calibre/gui2/notify.py | #!/usr/bin/env python
__license__ = 'GPL v3'
__copyright__ = '2009, Kovid Goyal <kovid@kovidgoyal.net>'
__docformat__ = 'restructuredtext en'
import sys
from contextlib import suppress
from functools import lru_cache
from calibre.constants import DEBUG, __appname__, get_osx_version, islinux, ismacos
from calibre.utils.resources import get_image_path as I
class Notifier:
DEFAULT_TIMEOUT = 5000
def get_msg_parms(self, timeout, body, summary):
if summary is None:
summary = 'calibre'
if timeout == 0:
timeout = self.DEFAULT_TIMEOUT
return timeout, body, summary
def __call__(self, body, summary=None, replaces_id=None, timeout=0):
raise NotImplementedError('implement in subclass')
@lru_cache(maxsize=2)
def icon(data=False):
return I('lt.png', data=data)
class DBUSNotifier(Notifier):
def __init__(self):
self.initialized = False
def initialize(self):
from jeepney.io.blocking import open_dbus_connection
if self.initialized:
return
self.initialized = True
self.ok = False
try:
self.connection = open_dbus_connection(bus='SESSION')
except Exception:
return
with suppress(Exception):
self.ok = self.initialize_fdo()
if self.ok:
self.notify = self.fdo_notify
return
if DEBUG:
print('Failed to connect to FDO Notifications service', file=sys.stderr)
with suppress(Exception):
self.ok = self.initialize_portal()
if self.ok:
self.notify = self.portal_notify
else:
print('Failed to connect to Portal Notifications service', file=sys.stderr)
def initialize_fdo(self):
from jeepney import DBusAddress, MessageType, new_method_call
self.address = DBusAddress(
'/org/freedesktop/Notifications',
bus_name='org.freedesktop.Notifications',
interface='org.freedesktop.Notifications')
msg = new_method_call(self.address, 'GetCapabilities')
reply = self.connection.send_and_get_reply(msg)
return bool(reply and reply.header.message_type is MessageType.method_return)
def initialize_portal(self):
from jeepney import DBusAddress, MessageType, Properties
self.address = DBusAddress(
'/org/freedesktop/portal/desktop',
bus_name='org.freedesktop.portal.Desktop',
interface='org.freedesktop.portal.Notification')
p = Properties(self.address)
msg = p.get('version')
reply = self.connection.send_and_get_reply(msg)
return bool(reply and reply.header.message_type is MessageType.method_return and reply.body[0][1] >= 1)
def fdo_notify(self, body, summary=None, replaces_id=None, timeout=0):
from jeepney import new_method_call
timeout, body, summary = self.get_msg_parms(timeout, body, summary)
msg = new_method_call(
self.address, 'Notify', 'susssasa{sv}i',
(__appname__,
replaces_id or 0,
icon(),
summary,
body,
[], {}, # Actions, hints
timeout,
))
try:
self.connection.send(msg)
except Exception:
import traceback
traceback.print_exc()
def portal_notify(self, body, summary=None, replaces_id=None, timeout=0):
from jeepney import new_method_call
_, body, summary = self.get_msg_parms(timeout, body, summary)
# Note: This backend does not natively support the notion of timeouts
#
# While the effect may be emulated by manually withdrawing the notifi-
# cation from the Calibre side, this resulted in a less than optimal
# User Experience. Based on this, KG decided it to be better to not
# support timeouts at all for this backend.
#
# See discussion at https://github.com/kovidgoyal/calibre/pull/1268.
# For the icon: This should instead just send the themable icon name
#
# Doing that however, requires Calibre to first be converted to use
# its AppID everywhere and then we still need a fallback for portable
# installations.
msg = new_method_call(
self.address, 'AddNotification', 'sa{sv}', (
str(replaces_id or 0),
{
"title": ('s', summary),
"body": ('s', body),
"icon": (
'(sv)',
(
"bytes",
('ay', icon(data=True))
)
),
}))
try:
self.connection.send(msg)
except Exception:
import traceback
traceback.print_exc()
def __call__(self, body, summary=None, replaces_id=None, timeout=0):
self.initialize()
if not self.ok:
if DEBUG:
print('Failed to connect to any notification service', file=sys.stderr)
return
self.notify(body, summary, replaces_id, timeout)
class QtNotifier(Notifier):
def __init__(self, systray=None):
self.systray = systray
self.ok = self.systray is not None and self.systray.supportsMessages()
def __call__(self, body, summary=None, replaces_id=None, timeout=0):
timeout, body, summary = self.get_msg_parms(timeout, body, summary)
from qt.core import QSystemTrayIcon
if self.systray is not None:
try:
hide = False
try:
if not isinstance(body, str):
body = body.decode('utf-8')
if ismacos and not self.systray.isVisible():
self.systray.show()
hide = True
self.systray.showMessage(summary, body, QSystemTrayIcon.MessageIcon.Information,
timeout)
finally:
if hide:
self.systray.hide()
except Exception:
pass
class DummyNotifier(Notifier):
ok = True
def __call__(self, body, summary=None, replaces_id=None, timeout=0):
pass
class AppleNotifier(Notifier):
def __init__(self):
from calibre_extensions import cocoa
self.cocoa = cocoa
self.ok = True
def notify(self, body, summary):
if summary:
title, informative_text = summary, body
else:
title, informative_text = body, None
self.cocoa.send_notification(None, title, informative_text)
def __call__(self, body, summary=None, replaces_id=None, timeout=0):
timeout, body, summary = self.get_msg_parms(timeout, body, summary)
if self.ok:
try:
self.notify(body, summary)
except Exception:
import traceback
traceback.print_exc()
def get_notifier(systray=None):
ans = None
if islinux:
ans = DBUSNotifier()
elif ismacos:
if get_osx_version() >= (10, 8, 0):
ans = AppleNotifier()
if not ans.ok:
ans = DummyNotifier()
else:
# We dont use Qt's systray based notifier as it uses Growl and is
# broken with different versions of Growl
ans = DummyNotifier()
if ans is None:
ans = QtNotifier(systray)
if not ans.ok:
ans = None
return ans
def hello():
n = get_notifier()
n('hello')
if __name__ == '__main__':
hello()
| 7,725 | Python | .py | 196 | 28.852041 | 111 | 0.587151 | kovidgoyal/calibre | 19,243 | 2,250 | 4 | GPL-3.0 | 9/5/2024, 5:13:50 PM (Europe/Amsterdam) |
26,676 | main.py | kovidgoyal_calibre/src/calibre/gui2/main.py | #!/usr/bin/env python
# License: GPLv3 Copyright: 2015, Kovid Goyal <kovid at kovidgoyal.net>
import os
import re
import sys
import time
import traceback
import apsw
from qt.core import QCoreApplication, QIcon, QObject, QTimer
from calibre import force_unicode, prints
from calibre.constants import DEBUG, MAIN_APP_UID, __appname__, filesystem_encoding, get_portable_base, islinux, ismacos, iswindows
from calibre.gui2 import Application, choose_dir, error_dialog, gprefs, initialize_file_icon_provider, question_dialog, setup_gui_option_parser, timed_print
from calibre.gui2.listener import send_message_in_process
from calibre.gui2.main_window import option_parser as _option_parser
from calibre.gui2.splash_screen import SplashScreen
from calibre.utils.config import dynamic, prefs
from calibre.utils.lock import SingleInstance
from calibre.utils.monotonic import monotonic
from calibre.utils.resources import get_image_path as I
from polyglot.builtins import as_bytes, environ_item
after_quit_actions = {'debug_on_restart': False, 'restart_after_quit': False, 'no_plugins_on_restart': False}
if iswindows:
from calibre_extensions import winutil
class AbortInit(Exception):
pass
def option_parser():
parser = _option_parser(_('''\
%prog [options] [path_to_ebook or calibre url ...]
Launch the main calibre Graphical User Interface and optionally add the e-book at
path_to_ebook to the database. You can also specify calibre URLs to perform various
different actions, than just adding books. For example:
calibre://view-book/test_library/1842/epub
Will open the book with id 1842 in the EPUB format from the library
"test_library" in the calibre E-book viewer. Library names are the folder names of the
libraries with spaces replaced by underscores. A full description of the
various URL based actions is in the User Manual.
'''))
parser.add_option('--with-library', default=None, action='store',
help=_('Use the library located at the specified path.'))
parser.add_option('--start-in-tray', default=False, action='store_true',
help=_('Start minimized to system tray.'))
parser.add_option('-v', '--verbose', default=0, action='count',
help=_('Ignored, do not use. Present only for legacy reasons'))
parser.add_option('--no-update-check', default=False, action='store_true',
help=_('Do not check for updates'))
parser.add_option('--ignore-plugins', default=False, action='store_true',
help=_('Ignore custom plugins, useful if you installed a plugin'
' that is preventing calibre from starting'))
parser.add_option('-s', '--shutdown-running-calibre', default=False,
action='store_true',
help=_('Cause a running calibre instance, if any, to be'
' shutdown. Note that if there are running jobs, they '
'will be silently aborted, so use with care.'))
setup_gui_option_parser(parser)
return parser
def find_portable_library():
base = get_portable_base()
if base is None:
return
import glob
candidates = [os.path.basename(os.path.dirname(x)) for x in glob.glob(
os.path.join(base, '*%smetadata.db'%os.sep))]
if not candidates:
candidates = ['Calibre Library']
lp = prefs['library_path']
if not lp:
lib = os.path.join(base, candidates[0])
else:
lib = None
q = os.path.basename(lp)
for c in candidates:
c = c
if c.lower() == q.lower():
lib = os.path.join(base, c)
break
if lib is None:
lib = os.path.join(base, candidates[0])
if len(lib) > 74:
error_dialog(None, _('Path too long'),
_("Path to Calibre Portable (%s) "
'too long. It must be less than 59 characters.')%base, show=True)
raise AbortInit()
prefs.set('library_path', lib)
if not os.path.exists(lib):
os.mkdir(lib)
def init_qt(args):
parser = option_parser()
opts, args = parser.parse_args(args)
if os.environ.pop('CALIBRE_IGNORE_PLUGINS_ON_RESTART', '') == '1':
opts.ignore_plugins = True
find_portable_library()
if opts.with_library is not None:
libpath = os.path.expanduser(opts.with_library)
if not os.path.exists(libpath):
os.makedirs(libpath)
if os.path.isdir(libpath):
prefs.set('library_path', os.path.abspath(libpath))
prints('Using library at', prefs['library_path'])
override = 'calibre-gui' if islinux else None
app = Application(args, override_program_name=override, windows_app_uid=MAIN_APP_UID)
app.file_event_hook = EventAccumulator()
try:
is_x11 = app.platformName() == 'xcb'
except Exception:
import traceback
traceback.print_exc()
is_x11 = False
# Ancient broken VNC servers cannot handle icons of size greater than 256
# https://www.mobileread.com/forums/showthread.php?t=278447
ic = 'lt.png' if is_x11 else 'library.png'
app.setWindowIcon(QIcon(I(ic, allow_user_override=False)))
return app, opts, args
def get_default_library_path():
fname = _('Calibre Library')
if iswindows:
fname = 'Calibre Library'
if isinstance(fname, str):
try:
fname.encode(filesystem_encoding)
except Exception:
fname = 'Calibre Library'
x = os.path.expanduser(os.path.join('~', fname))
if not os.path.exists(x):
try:
os.makedirs(x)
except Exception:
x = os.path.expanduser('~')
return x
def try_other_known_library_paths():
stats = gprefs.get('library_usage_stats', {})
if stats:
for candidate in sorted(stats.keys(), key=stats.__getitem__, reverse=True):
candidate = os.path.abspath(candidate)
if os.path.exists(candidate):
return candidate
def get_library_path(gui_runner):
library_path = prefs['library_path']
if library_path is None: # Need to migrate to new database layout
base = os.path.expanduser('~')
if not base or not os.path.exists(base):
from qt.core import QDir
base = str(QDir.homePath()).replace('/', os.sep)
candidate = gui_runner.choose_dir(base)
if not candidate:
candidate = os.path.join(base, 'Calibre Library')
library_path = os.path.abspath(candidate)
elif not os.path.exists(library_path):
q = try_other_known_library_paths()
if q:
library_path = q
if not os.path.exists(library_path):
try:
os.makedirs(library_path)
except:
gui_runner.show_error(_('Failed to create library'),
_('Failed to create calibre library at: %r.\n'
'You will be asked to choose a new library location.')%library_path,
det_msg=traceback.format_exc())
library_path = gui_runner.choose_dir(get_default_library_path())
return library_path
def repair_library(library_path):
from calibre.gui2.dialogs.restore_library import repair_library_at
return repair_library_at(library_path)
def windows_repair(library_path=None):
import subprocess
from calibre.utils.serialize import json_dumps, json_loads
from polyglot.binary import as_hex_unicode, from_hex_bytes
if library_path:
library_path = as_hex_unicode(json_dumps(library_path))
winutil.prepare_for_restart()
os.environ['CALIBRE_REPAIR_CORRUPTED_DB'] = environ_item(library_path)
subprocess.Popen([sys.executable])
else:
try:
app = Application([])
from calibre.gui2.dialogs.restore_library import repair_library_at
library_path = json_loads(from_hex_bytes(os.environ.pop('CALIBRE_REPAIR_CORRUPTED_DB')))
done = repair_library_at(library_path, wait_time=4)
except Exception:
done = False
error_dialog(None, _('Failed to repair library'), _(
'Could not repair library. Click "Show details" for more information.'), det_msg=traceback.format_exc(), show=True)
if done:
subprocess.Popen([sys.executable])
app.quit()
class EventAccumulator:
def __init__(self):
self.events = []
def __call__(self, ev):
self.events.append(ev)
class GuiRunner(QObject):
'''Make sure an event loop is running before starting the main work of
initialization'''
def __init__(self, opts, args, actions, app, gui_debug=None):
self.startup_time = monotonic()
timed_print('Starting up...')
self.opts, self.args, self.app = opts, args, app
self.gui_debug = gui_debug
self.actions = actions
self.main = None
QObject.__init__(self)
self.splash_screen = None
self.timer = QTimer.singleShot(1, self.initialize)
def start_gui(self, db):
from calibre.gui2.ui import Main
timed_print('Constructing main UI...')
if self.splash_screen is not None:
self.splash_screen.show_message(_('Initializing user interface...'))
main = self.main = Main(self.opts, gui_debug=self.gui_debug)
try:
with gprefs: # Only write gui.json after initialization is complete
main.initialize(self.library_path, db, self.actions)
finally:
timed_print('main UI initialized...')
if self.splash_screen is not None:
timed_print('Hiding splash screen')
self.splash_screen.finish(main)
timed_print('splash screen hidden')
self.splash_screen = None
timed_print('Started up in %.2f seconds'%(monotonic() - self.startup_time), 'with', len(db.data), 'books')
main.set_exception_handler()
if len(self.args) > 1:
main.handle_cli_args(self.args[1:])
for event in self.app.file_event_hook.events:
main.handle_cli_args(event)
self.app.file_event_hook = main.handle_cli_args
def choose_dir(self, initial_dir):
self.hide_splash_screen()
return choose_dir(self.splash_screen, 'choose calibre library',
_('Choose a location for your new calibre e-book library'),
default_dir=initial_dir)
def show_error(self, title, msg, det_msg=''):
print(det_msg, file=sys.stderr)
self.hide_splash_screen()
with self.app:
error_dialog(self.splash_screen, title, msg, det_msg=det_msg, show=True)
def initialization_failed(self):
print('Catastrophic failure initializing GUI, bailing out...')
QCoreApplication.exit(1)
raise SystemExit(1)
def initialize_db_stage2(self, db, tb):
from calibre.db.legacy import LibraryDatabase
if db is None and tb is not None:
# DB Repair failed
self.show_error(_('Repairing failed'), _(
'The database repair failed. Starting with a new empty library.'),
det_msg=tb)
if db is None:
candidate = self.choose_dir(get_default_library_path())
if not candidate:
self.initialization_failed()
try:
self.library_path = candidate
db = LibraryDatabase(candidate)
except:
self.show_error(_('Bad database location'), _(
'Bad database location %r. calibre will now quit.')%self.library_path,
det_msg=traceback.format_exc())
self.initialization_failed()
timed_print('db initialized')
try:
self.start_gui(db)
except Exception:
try:
details = traceback.format_exc()
except Exception:
details = ''
self.show_error(_('Startup error'), _(
'There was an error during {0} startup. Parts of {0} may not function.'
' Click "Show details" to learn more.').format(__appname__), det_msg=details)
def initialize_db(self):
from calibre.db.legacy import LibraryDatabase
db = None
timed_print('Initializing db...')
try:
db = LibraryDatabase(self.library_path)
except apsw.Error:
with self.app:
self.hide_splash_screen()
repair = question_dialog(self.splash_screen, _('Corrupted database'),
_('The library database at %s appears to be corrupted. Do '
'you want calibre to try and rebuild it automatically? '
'The rebuild may not be completely successful. '
'If you say No, a new empty calibre library will be created.')
% force_unicode(self.library_path, filesystem_encoding),
det_msg=traceback.format_exc()
)
if repair:
if iswindows:
# On some windows systems the existing db file gets locked
# by something when running restore from the main process.
# So run the restore in a separate process.
import atexit
atexit.register(windows_repair, self.library_path)
self.app.quit()
return
if repair_library(self.library_path):
db = LibraryDatabase(self.library_path)
except:
self.show_error(_('Bad database location'),
_('Bad database location %r. Will start with '
' a new, empty calibre library')%self.library_path,
det_msg=traceback.format_exc())
self.initialize_db_stage2(db, None)
def show_splash_screen(self):
timed_print('Showing splash screen...')
self.splash_screen = SplashScreen()
self.splash_screen.show()
self.splash_screen.show_message(_('Starting %s: Loading books...') % __appname__)
timed_print('splash screen shown')
def hide_splash_screen(self):
if self.splash_screen is not None:
self.splash_screen.hide()
self.splash_screen = None
def initialize(self, *args):
if gprefs['show_splash_screen'] and not self.opts.start_in_tray:
self.show_splash_screen()
self.library_path = get_library_path(self)
if not self.library_path:
self.initialization_failed()
self.initialize_db()
def run_in_debug_mode():
import subprocess
import tempfile
from calibre.debug import run_calibre_debug
fd, logpath = tempfile.mkstemp('.txt')
os.close(fd)
run_calibre_debug(
'--gui-debug', logpath, stdout=open(logpath, 'wb'),
stderr=subprocess.STDOUT, stdin=open(os.devnull, 'rb'))
def run_gui(opts, args, app, gui_debug=None):
with SingleInstance('db') as si:
if not si:
ext = '.exe' if iswindows else ''
error_dialog(None, _('Cannot start calibre'), _(
'Another calibre program that can modify calibre libraries, such as,'
' {0} or {1} is already running. You must first shut it down, before'
' starting the main calibre program. If you are sure no such'
' program is running, try restarting your computer.').format(
'calibre-server' + ext, 'calibredb' + ext), show=True)
return 1
run_gui_(opts, args, app, gui_debug)
def run_gui_(opts, args, app, gui_debug=None):
initialize_file_icon_provider()
app.load_builtin_fonts(scan_for_fonts=True)
if not dynamic.get('welcome_wizard_was_run', False):
from calibre.gui2.wizard import wizard
wizard().exec()
dynamic.set('welcome_wizard_was_run', True)
from calibre.gui2.ui import Main
if ismacos:
actions = tuple(Main.create_application_menubar())
else:
actions = tuple(Main.get_menubar_actions())
runner = GuiRunner(opts, args, actions, app, gui_debug=gui_debug)
ret = app.exec()
if getattr(runner.main, 'run_wizard_b4_shutdown', False):
from calibre.gui2.wizard import wizard
wizard().exec()
if getattr(runner.main, 'restart_after_quit', False):
after_quit_actions['restart_after_quit'] = True
after_quit_actions['debug_on_restart'] = getattr(runner.main, 'debug_on_restart', False) or gui_debug is not None
after_quit_actions['no_plugins_on_restart'] = getattr(runner.main, 'no_plugins_on_restart', False)
else:
if iswindows:
try:
runner.main.system_tray_icon.hide()
except:
pass
if getattr(runner.main, 'gui_debug', None) is not None:
debugfile = runner.main.gui_debug
from calibre.gui2 import open_local_file
if iswindows:
# detach the stdout/stderr/stdin handles
winutil.prepare_for_restart()
with open(debugfile, 'r+b') as f:
raw = f.read()
raw = re.sub(b'(?<!\r)\n', b'\r\n', raw)
f.seek(0)
f.truncate()
f.write(raw)
open_local_file(debugfile)
return ret
singleinstance_name = 'GUI'
class FailedToCommunicate(Exception):
pass
def send_message(msg, retry_communicate=False):
try:
send_message_in_process(msg)
except Exception:
time.sleep(2)
try:
send_message_in_process(msg)
except Exception as err:
# can happen because the Qt local server pipe is shutdown before
# the single instance mutex is released
if retry_communicate:
raise FailedToCommunicate('retrying')
print(_('Failed to contact running instance of calibre'), file=sys.stderr, flush=True)
print(err, file=sys.stderr, flush=True)
if Application.instance():
error_dialog(None, _('Contacting calibre failed'), _(
'Failed to contact running instance of calibre, try restarting calibre'),
det_msg=str(err) + '\n\n' + repr(msg), show=True)
return False
return True
def shutdown_other():
if send_message('shutdown:'):
print(_('Shutdown command sent, waiting for shutdown...'), flush=True)
for i in range(50):
with SingleInstance(singleinstance_name) as si:
if si:
return
time.sleep(0.1)
raise SystemExit(_('Failed to shutdown running calibre instance'))
def communicate(opts, args, retry_communicate=False):
if opts.shutdown_running_calibre:
shutdown_other()
else:
if len(args) > 1:
args[1:] = [os.path.abspath(x) if os.path.exists(x) else x for x in args[1:]]
if opts.with_library and os.path.isdir(os.path.expanduser(opts.with_library)):
library_id = os.path.basename(opts.with_library).replace(' ', '_').encode('utf-8').hex()
args.insert(1, 'calibre://switch-library/_hex_-' + library_id)
import json
if not send_message(b'launched:'+as_bytes(json.dumps(args)), retry_communicate=retry_communicate):
raise SystemExit(_('Failed to contact running instance of calibre'))
raise SystemExit(0)
def restart_after_quit():
e = sys.executable if getattr(sys, 'frozen', False) else sys.argv[0]
is_calibre_debug_exe = os.path.splitext(e)[0].endswith('-debug')
if iswindows and not is_calibre_debug_exe:
# detach the stdout/stderr/stdin handles
winutil.prepare_for_restart()
if after_quit_actions['no_plugins_on_restart']:
os.environ['CALIBRE_IGNORE_PLUGINS_ON_RESTART'] = '1'
if after_quit_actions['debug_on_restart']:
run_in_debug_mode()
return
if hasattr(sys, 'frameworks_dir'):
app = os.path.dirname(os.path.dirname(os.path.realpath(sys.frameworks_dir)))
from calibre.debug import run_calibre_debug
prints('Restarting with:', app)
run_calibre_debug('-c', 'import sys, os, time; time.sleep(3); os.execlp("open", "open", sys.argv[-1])', app)
else:
import subprocess
if hasattr(sys, 'run_local'):
cmd = [sys.run_local]
if DEBUG:
cmd += ['calibre-debug', '-g']
else:
cmd.append('calibre')
else:
cmd = [e]
if is_calibre_debug_exe:
cmd.append('-g')
prints('Restarting with:', ' '.join(cmd))
subprocess.Popen(cmd)
def main(args=sys.argv):
if iswindows and 'CALIBRE_REPAIR_CORRUPTED_DB' in os.environ:
windows_repair()
return 0
gui_debug = None
if args[0] == '__CALIBRE_GUI_DEBUG__':
gui_debug = args[1]
args = ['calibre']
try:
app, opts, args = init_qt(args)
except AbortInit:
return 1
try:
with SingleInstance(singleinstance_name) as si:
if si and opts.shutdown_running_calibre:
return 0
run_main(app, opts, args, gui_debug, si, retry_communicate=True)
except FailedToCommunicate:
with SingleInstance(singleinstance_name) as si:
if si and opts.shutdown_running_calibre:
return 0
run_main(app, opts, args, gui_debug, si, retry_communicate=False)
if after_quit_actions['restart_after_quit']:
restart_after_quit()
def run_main(app, opts, args, gui_debug, si, retry_communicate=False):
if si:
return run_gui(opts, args, app, gui_debug=gui_debug)
communicate(opts, args, retry_communicate)
return 0
if __name__ == '__main__':
try:
sys.exit(main())
except Exception as err:
if not iswindows:
raise
tb = traceback.format_exc()
from qt.core import QErrorMessage
logfile = os.path.join(os.path.expanduser('~'), 'calibre.log')
if os.path.exists(logfile):
with open(logfile) as f:
log = f.read().decode('utf-8', 'ignore')
d = QErrorMessage()
d.showMessage(('<b>Error:</b>%s<br><b>Traceback:</b><br>'
'%s<b>Log:</b><br>%s')%(str(err),
str(tb).replace('\n', '<br>'),
log.replace('\n', '<br>')))
| 22,545 | Python | .py | 504 | 35.02381 | 156 | 0.616327 | kovidgoyal/calibre | 19,243 | 2,250 | 4 | GPL-3.0 | 9/5/2024, 5:13:50 PM (Europe/Amsterdam) |
26,677 | bars.py | kovidgoyal_calibre/src/calibre/gui2/bars.py | #!/usr/bin/env python
__license__ = 'GPL v3'
__copyright__ = '2011, Kovid Goyal <kovid@kovidgoyal.net>'
__docformat__ = 'restructuredtext en'
from functools import partial
from qt.core import (
QAction,
QEasingCurve,
QFrame,
QHBoxLayout,
QKeySequence,
QMenu,
QMenuBar,
QObject,
QPainter,
QPalette,
QPropertyAnimation,
QSize,
Qt,
QTimer,
QToolBar,
QToolButton,
QWidget,
pyqtProperty,
pyqtSignal,
sip,
)
from calibre.constants import ismacos
from calibre.gui2 import config, gprefs, native_menubar_defaults
from calibre.gui2.throbber import ThrobbingButton
from calibre.gui2.widgets2 import RightClickButton
from polyglot.builtins import itervalues
class RevealBar(QWidget): # {{{
def __init__(self, parent):
QWidget.__init__(self, parent)
self.setVisible(False)
self._animated_size = 1.0
self.animation = QPropertyAnimation(self, b'animated_size', self)
self.animation.setEasingCurve(QEasingCurve.Type.Linear)
self.animation.setDuration(1000), self.animation.setStartValue(0.0), self.animation.setEndValue(1.0)
self.animation.valueChanged.connect(self.animation_value_changed)
self.animation.finished.connect(self.animation_done)
@pyqtProperty(float)
def animated_size(self):
return self._animated_size
@animated_size.setter
def animated_size(self, val):
self._animated_size = val
def animation_value_changed(self, *args):
self.update()
def animation_done(self):
self.setVisible(False)
self.update()
def start(self, bar):
self.setGeometry(bar.geometry())
self.setVisible(True)
self.animation.start()
def paintEvent(self, ev):
if self._animated_size < 1.0:
rect = self.rect()
painter = QPainter(self)
pal = self.palette()
col = pal.color(QPalette.ColorRole.Button)
rect.setLeft(rect.left() + int(rect.width() * self._animated_size))
painter.setClipRect(rect)
painter.fillRect(self.rect(), col)
# }}}
MAX_TEXT_LENGTH = 10
connected_pairs = set()
def wrap_button_text(text, max_len=MAX_TEXT_LENGTH):
parts = text.split()
ans = ''
broken = False
for word in parts:
if broken:
ans += ' ' + word
else:
if len(ans) + len(word) < max_len:
if ans:
ans += ' ' + word
else:
ans = word
else:
if ans:
ans += '\n' + word
broken = True
else:
ans = word
if broken:
prefix, suffix = ans.split('\n', 1)
if len(suffix) > len(prefix) and len(suffix) > MAX_TEXT_LENGTH and len(prefix) < MAX_TEXT_LENGTH and suffix.count(' ') > 1:
word, rest = suffix.split(' ', 1)
if len(word) + len(prefix) <= len(rest):
ans = prefix + ' ' + word + '\n' + rest
else:
if ' ' in ans:
ans = '\n'.join(ans.split(' ', 1))
elif '/' in ans:
ans = '/\n'.join(ans.split('/', 1))
else:
ans += '\n\xa0'
return ans
def rewrap_button(w):
if not sip.isdeleted(w) and w.defaultAction() is not None:
w.setText(wrap_button_text(w.defaultAction().text()))
def wrap_all_button_texts(all_buttons):
if not all_buttons:
return
for w in all_buttons:
if hasattr(w, 'defaultAction'):
ac = w.defaultAction()
text = ac.text()
key = id(w), id(ac)
if key not in connected_pairs:
ac.changed.connect(partial(rewrap_button, w))
connected_pairs.add(key)
else:
text = w.text()
w.setText(wrap_button_text(text))
def create_donate_button(action):
ans = ThrobbingButton()
ans.setAutoRaise(True)
ans.setCursor(Qt.CursorShape.PointingHandCursor)
ans.clicked.connect(action.trigger)
ans.setToolTip(action.text().replace('&', ''))
ans.setIcon(action.icon())
ans.setStatusTip(ans.toolTip())
return ans
class ToolBar(QToolBar): # {{{
def __init__(self, donate_action, location_manager, parent):
QToolBar.__init__(self, parent)
self.setMovable(False)
self.setFloatable(False)
self.setOrientation(Qt.Orientation.Horizontal)
self.setAllowedAreas(Qt.ToolBarArea.TopToolBarArea|Qt.ToolBarArea.BottomToolBarArea)
self.setStyleSheet('QToolButton:checked { font-weight: bold }')
self.preferred_width = self.sizeHint().width()
self.gui = parent
self.donate_action = donate_action
self.donate_button = None
self.added_actions = []
self.location_manager = location_manager
self.setAcceptDrops(True)
self.showing_donate = False
def resizeEvent(self, ev):
QToolBar.resizeEvent(self, ev)
style = self.get_text_style()
self.setToolButtonStyle(style)
if self.showing_donate:
self.donate_button.setToolButtonStyle(style)
def get_text_style(self):
style = Qt.ToolButtonStyle.ToolButtonTextUnderIcon
s = gprefs['toolbar_icon_size']
if s != 'off':
p = gprefs['toolbar_text']
if p == 'never':
style = Qt.ToolButtonStyle.ToolButtonIconOnly
elif p == 'auto' and self.preferred_width > self.width()+15:
style = Qt.ToolButtonStyle.ToolButtonIconOnly
return style
def contextMenuEvent(self, ev):
ac = self.actionAt(ev.pos())
if ac is None:
return
ch = self.widgetForAction(ac)
sm = getattr(ch, 'showMenu', None)
if callable(sm):
ev.accept()
sm()
def update_lm_actions(self):
for ac in self.added_actions:
if ac in self.location_manager.all_actions:
ac.setVisible(ac in self.location_manager.available_actions)
def init_bar(self, actions):
self.showing_donate = False
for ac in self.added_actions:
m = ac.menu()
if m is not None:
m.setVisible(False)
self.clear()
self.added_actions = []
self.donate_button = None
self.all_widgets = []
for what in actions:
if what is None:
self.addSeparator()
elif what == 'Location Manager':
for ac in self.location_manager.all_actions:
self.addAction(ac)
self.added_actions.append(ac)
self.setup_tool_button(self, ac, QToolButton.ToolButtonPopupMode.MenuButtonPopup)
ac.setVisible(False)
elif what == 'Donate':
self.donate_button = create_donate_button(self.donate_action)
self.addWidget(self.donate_button)
self.donate_button.setIconSize(self.iconSize())
self.donate_button.setToolButtonStyle(self.toolButtonStyle())
self.showing_donate = True
elif what in self.gui.iactions:
action = self.gui.iactions[what]
self.addAction(action.qaction)
self.added_actions.append(action.qaction)
self.setup_tool_button(self, action.qaction, action.popup_type)
if gprefs['wrap_toolbar_text']:
wrap_all_button_texts(self.all_widgets)
self.preferred_width = self.sizeHint().width()
self.all_widgets = []
def setup_tool_button(self, bar, ac, menu_mode=None):
ch = bar.widgetForAction(ac)
if ch is None:
ch = self.child_bar.widgetForAction(ac)
ch.setCursor(Qt.CursorShape.PointingHandCursor)
if hasattr(ch, 'setText') and hasattr(ch, 'text'):
self.all_widgets.append(ch)
if hasattr(ch, 'setAutoRaise'): # is a QToolButton or similar
ch.setAutoRaise(True)
m = ac.menu()
if m is not None:
if menu_mode is not None:
ch.setPopupMode(QToolButton.ToolButtonPopupMode(menu_mode))
return ch
# support drag&drop from/to library, from/to reader/card, enabled plugins
def check_iactions_for_drag(self, event, md, func):
if self.added_actions:
pos = event.position().toPoint()
for iac in itervalues(self.gui.iactions):
if iac.accepts_drops:
aa = iac.qaction
w = self.widgetForAction(aa)
m = aa.menu()
if (((w is not None and w.geometry().contains(pos)) or (
m is not None and m.isVisible() and m.geometry().contains(pos))) and getattr(
iac, func)(event, md)):
return True
return False
def dragEnterEvent(self, event):
md = event.mimeData()
if md.hasFormat("application/calibre+from_library") or \
md.hasFormat("application/calibre+from_device"):
event.setDropAction(Qt.DropAction.CopyAction)
event.accept()
return
if self.check_iactions_for_drag(event, md, 'accept_enter_event'):
event.accept()
else:
event.ignore()
def dragMoveEvent(self, event):
allowed = False
md = event.mimeData()
# Drop is only allowed in the location manager widget's different from the selected one
for ac in self.location_manager.available_actions:
w = self.widgetForAction(ac)
if w is not None:
if (md.hasFormat(
"application/calibre+from_library") or md.hasFormat(
"application/calibre+from_device")) and \
w.geometry().contains(event.pos()) and \
isinstance(w, QToolButton) and not w.isChecked():
allowed = True
break
if allowed:
event.acceptProposedAction()
return
if self.check_iactions_for_drag(event, md, 'accept_drag_move_event'):
event.acceptProposedAction()
else:
event.ignore()
def dropEvent(self, event):
md = event.mimeData()
mime = 'application/calibre+from_library'
if md.hasFormat(mime):
ids = list(map(int, md.data(mime).data().split()))
tgt = None
for ac in self.location_manager.available_actions:
w = self.widgetForAction(ac)
if w is not None and w.geometry().contains(event.pos()):
tgt = ac.calibre_name
if tgt is not None:
if tgt == 'main':
tgt = None
self.gui.sync_to_device(tgt, False, send_ids=ids)
event.accept()
return
mime = 'application/calibre+from_device'
if md.hasFormat(mime):
paths = [str(u.toLocalFile()) for u in md.urls()]
if paths:
self.gui.iactions['Add Books'].add_books_from_device(
self.gui.current_view(), paths=paths)
event.accept()
return
# Give added_actions an opportunity to process the drag&drop event
if self.check_iactions_for_drag(event, md, 'drop_event'):
event.accept()
else:
event.ignore()
# }}}
class MenuAction(QAction): # {{{
def __init__(self, clone, parent):
QAction.__init__(self, clone.text(), parent)
self.clone = clone
clone.changed.connect(self.clone_changed)
def clone_changed(self):
self.setText(self.clone.text())
# }}}
# MenuBar {{{
if ismacos:
# On OS X we need special handling for the application global menu bar and
# the context menus, since Qt does not handle dynamic menus or menus in
# which the same action occurs in more than one place.
class CloneAction(QAction):
text_changed = pyqtSignal()
visibility_changed = pyqtSignal()
def __init__(self, clone, parent, is_top_level=False, clone_shortcuts=True):
QAction.__init__(self, clone.text().replace('&&', '&'), parent)
self.setMenuRole(QAction.MenuRole.NoRole) # ensure this action is not moved around by Qt
self.is_top_level = is_top_level
self.clone_shortcuts = clone_shortcuts
self.clone = clone
clone.changed.connect(self.clone_changed)
self.clone_changed()
self.triggered.connect(self.do_trigger)
def clone_menu(self):
m = self.menu()
m.clear()
for ac in QMenu.actions(self.clone.menu()):
if ac.isSeparator():
m.addSeparator()
else:
m.addAction(CloneAction(ac, self.parent(), clone_shortcuts=self.clone_shortcuts))
def clone_changed(self):
otext = self.text()
self.setText(self.clone.text())
if otext != self.text:
self.text_changed.emit()
ov = self.isVisible()
self.setVisible(self.clone.isVisible())
if ov != self.isVisible():
self.visibility_changed.emit()
self.setEnabled(self.clone.isEnabled())
self.setCheckable(self.clone.isCheckable())
self.setChecked(self.clone.isChecked())
self.setIcon(self.clone.icon())
if self.clone_shortcuts:
sc = self.clone.shortcut()
if sc and not sc.isEmpty():
self.setText(self.text() + '\t' + sc.toString(QKeySequence.SequenceFormat.NativeText))
if self.clone.menu() is None:
if not self.is_top_level:
self.setMenu(None)
else:
m = QMenu(self.text(), self.parent())
m.aboutToShow.connect(self.about_to_show)
self.setMenu(m)
self.clone_menu()
def about_to_show(self):
if sip.isdeleted(self.clone):
return
cm = self.clone.menu()
if cm is None:
return
before = list(QMenu.actions(cm))
cm.aboutToShow.emit()
after = list(QMenu.actions(cm))
if before != after:
self.clone_menu()
def do_trigger(self, checked=False):
if not sip.isdeleted(self.clone):
self.clone.trigger()
def populate_menu(m, items, iactions):
for what in items:
if what is None:
m.addSeparator()
elif what in iactions:
ia = iactions[what]
ac = ia.qaction
if not ac.menu() and hasattr(ia, 'shortcut_action_for_context_menu'):
ia.shortcut_action_for_context_menu.setIcon(ac.icon())
ac = ia.shortcut_action_for_context_menu
m.addAction(CloneAction(ac, m))
class MenuBar(QObject):
is_native_menubar = True
@property
def native_menubar(self):
mb = self.gui.native_menubar
if mb.parent() is None:
# Without this the menubar does not update correctly with Qt >=
# 5.6. See the last couple of lines in updateMenuBarImmediately
# in qcocoamenubar.mm
mb.setParent(self.gui)
return mb
def __init__(self, location_manager, parent):
QObject.__init__(self, parent)
self.gui = parent
self.location_manager = location_manager
self.added_actions = []
self.last_actions = []
self.donate_action = QAction(_('Donate'), self)
self.donate_menu = QMenu()
self.donate_menu.addAction(self.gui.donate_action)
self.donate_action.setMenu(self.donate_menu)
self.refresh_timer = t = QTimer(self)
t.setInterval(200), t.setSingleShot(True), t.timeout.connect(self.refresh_bar)
def adapt_for_dialog(self, enter):
def ac(text, key, role=QAction.MenuRole.TextHeuristicRole):
ans = QAction(text, self)
ans.setMenuRole(role)
ans.setShortcut(QKeySequence(key))
self.edit_menu.addAction(ans)
return ans
mb = self.native_menubar
if enter:
self.clear_bar(mb)
self.edit_menu = QMenu()
self.edit_action = QAction(_('Edit'), self)
self.edit_action.setMenu(self.edit_menu)
ac(_('Copy'), QKeySequence.StandardKey.Copy),
ac(_('Paste'), QKeySequence.StandardKey.Paste),
ac(_('Select all'), QKeySequence.StandardKey.SelectAll),
mb.addAction(self.edit_action)
self.added_actions = [self.edit_action]
else:
self.refresh_bar()
def clear_bar(self, mb):
for ac in self.added_actions:
m = ac.menu()
if m is not None:
m.setVisible(False)
for ac in self.added_actions:
mb.removeAction(ac)
if ac is not self.donate_action:
ac.setMenu(None)
ac.deleteLater()
self.added_actions = []
def init_bar(self, actions):
mb = self.native_menubar
self.last_actions = actions
self.clear_bar(mb)
for what in actions:
if what is None:
continue
elif what == 'Location Manager':
for ac in self.location_manager.available_actions:
self.build_menu(ac)
elif what == 'Donate':
mb.addAction(self.donate_action)
elif what in self.gui.iactions:
action = self.gui.iactions[what]
self.build_menu(action.qaction)
def build_menu(self, ac):
ans = CloneAction(ac, self.native_menubar, is_top_level=True)
if ans.menu() is None:
m = QMenu()
m.addAction(CloneAction(ac, self.native_menubar))
ans.setMenu(m)
# Qt (as of 5.3.0) does not update global menubar entries
# correctly, so we have to rebuild the global menubar.
# Without this the Choose Library action shows the text
# 'Untitled' and the Location Manager items do not work.
ans.text_changed.connect(self.refresh_timer.start)
ans.visibility_changed.connect(self.refresh_timer.start)
self.native_menubar.addAction(ans)
self.added_actions.append(ans)
return ans
def setVisible(self, yes):
pass # no-op on OS X since menu bar is always visible
def update_lm_actions(self):
pass # no-op as this is taken care of by init_bar()
def refresh_bar(self):
self.init_bar(self.last_actions)
else:
def populate_menu(m, items, iactions):
for what in items:
if what is None:
m.addSeparator()
elif what in iactions:
ia = iactions[what]
ac = ia.qaction
if not ac.menu() and hasattr(ia, 'shortcut_action_for_context_menu'):
ia.shortcut_action_for_context_menu.setIcon(ac.icon())
ac = ia.shortcut_action_for_context_menu
m.addAction(ac)
class MenuBar(QObject):
is_native_menubar = False
def __init__(self, location_manager, parent):
QObject.__init__(self, parent)
self.menu_bar = QMenuBar(parent)
self.menu_bar.is_native_menubar = False
parent.setMenuBar(self.menu_bar)
self.gui = parent
self.location_manager = location_manager
self.added_actions = []
self.donate_action = QAction(_('Donate'), self)
self.donate_menu = QMenu()
self.donate_menu.addAction(self.gui.donate_action)
self.donate_action.setMenu(self.donate_menu)
def addAction(self, *args):
self.menu_bar.addAction(*args)
def setVisible(self, visible):
self.menu_bar.setVisible(visible)
def clear(self):
self.menu_bar.clear()
def init_bar(self, actions):
for ac in self.added_actions:
m = ac.menu()
if m is not None:
m.setVisible(False)
self.clear()
self.added_actions = []
for what in actions:
if what is None:
continue
elif what == 'Location Manager':
for ac in self.location_manager.all_actions:
ac = self.build_menu(ac)
self.addAction(ac)
self.added_actions.append(ac)
ac.setVisible(False)
elif what == 'Donate':
self.addAction(self.donate_action)
elif what in self.gui.iactions:
action = self.gui.iactions[what]
ac = self.build_menu(action.qaction)
self.addAction(ac)
self.added_actions.append(ac)
def build_menu(self, action):
m = action.menu()
ac = MenuAction(action, self)
if m is None:
m = QMenu()
m.addAction(action)
ac.setMenu(m)
return ac
def update_lm_actions(self):
for ac in self.added_actions:
clone = getattr(ac, 'clone', None)
if clone is not None and clone in self.location_manager.all_actions:
ac.setVisible(clone in self.location_manager.available_actions)
# }}}
class AdaptMenuBarForDialog:
def __init__(self, menu_bar):
self.menu_bar = menu_bar
def __enter__(self):
if ismacos and self.menu_bar.is_native_menubar:
self.menu_bar.adapt_for_dialog(True)
def __exit__(self, *a):
if ismacos and self.menu_bar.is_native_menubar:
self.menu_bar.adapt_for_dialog(False)
class SearchToolBar(QHBoxLayout):
# Simulate an instance of the above Toolbar class using widgets instead of
# actions. The tool buttons are fixed size and the text is either gone or to
# the right.
def __init__(self, gui):
QHBoxLayout.__init__(self)
self.search_tool_bar_widgets = []
self.gui = gui
self.donate_button = None
def init_bar(self, actions):
for widget in self.search_tool_bar_widgets:
self.removeWidget(widget)
self.setContentsMargins(0, 0, 10, 0)
self.setSpacing(0)
self.search_tool_bar_widgets = []
self.search_tool_bar_actions = []
for what in gprefs['action-layout-searchbar']:
if what is None:
frame = QFrame()
frame.setFrameShape(QFrame.Shape.VLine)
frame.setFrameShadow(QFrame.Shadow.Sunken)
frame.setLineWidth(1)
frame.setContentsMargins(0, 5, 0, 5)
self.addWidget(frame)
self.search_tool_bar_widgets.append(frame)
self.search_tool_bar_actions.append(None)
elif what in self.gui.iactions:
act = self.gui.iactions[what]
qact = act.qaction
tb = RightClickButton()
tb.menu = qact.menu
tb.setContentsMargins(0, 0, 0, 0)
tb.setDefaultAction(qact)
if not gprefs['search_tool_bar_shows_text']:
tb.setText(None)
else:
tb.setToolButtonStyle(Qt.ToolButtonStyle.ToolButtonTextBesideIcon)
self.addWidget(tb)
self.search_tool_bar_widgets.append(tb)
self.search_tool_bar_actions.append(qact)
self.setup_tool_button(self, qact, act.popup_type)
def widgetForAction(self, action):
try:
dex = self.search_tool_bar_actions.index(action)
return self.search_tool_bar_widgets[dex]
except Exception:
return None
def setup_tool_button(self, bar, ac, menu_mode=None):
widget = self.widgetForAction(ac)
if widget is None:
return
widget.setCursor(Qt.CursorShape.PointingHandCursor)
if hasattr(widget, 'setAutoRaise'): # is a QToolButton or similar
widget.setAutoRaise(True)
m = ac.menu()
if m is not None:
if menu_mode is not None:
widget.setPopupMode(QToolButton.ToolButtonPopupMode(menu_mode))
return widget
def setIconSize(self, *args):
pass
def setToolButtonStyle(self, *args):
pass
def isVisible(self):
return True
def setVisible(self, toWhat):
pass
def update_lm_actions(self, *args):
pass
@property
def showing_donate(self):
return False
@property
def added_actions(self):
return self.search_tool_bar_actions
class BarsManager(QObject):
def __init__(self, donate_action, location_manager, parent):
self.gui = parent
QObject.__init__(self, parent)
self.location_manager = location_manager
bars = [ToolBar(donate_action, location_manager, parent) for i in range(3)]
self.main_bars = tuple(bars[:2])
self.child_bars = tuple(bars[2:])
self.reveal_bar = RevealBar(parent)
self.search_tool_bar = SearchToolBar(parent)
self.menu_bar = MenuBar(self.location_manager, self.parent())
is_native_menubar = self.menu_bar.is_native_menubar
self.adapt_menu_bar_for_dialog = AdaptMenuBarForDialog(self.menu_bar)
self.menubar_fallback = native_menubar_defaults['action-layout-menubar'] if is_native_menubar else ()
self.menubar_device_fallback = native_menubar_defaults['action-layout-menubar-device'] if is_native_menubar else ()
self.apply_settings()
self.search_tool_bar_actions = []
self.init_bars()
def database_changed(self, db):
pass
@property
def bars(self):
yield from self.main_bars + self.child_bars + (self.search_tool_bar, )
@property
def showing_donate(self):
for b in self.bars:
if b.isVisible() and b.showing_donate:
return True
return False
def start_animation(self):
for b in self.bars:
if b.isVisible() and b.showing_donate:
b.donate_button.start_animation()
return True
def init_bars(self):
self.bar_actions = tuple([
gprefs['action-layout-toolbar'+x] for x in ('', '-device')] + [
gprefs['action-layout-toolbar-child']] + [
gprefs['action-layout-menubar'] or self.menubar_fallback] + [
gprefs['action-layout-menubar-device'] or self.menubar_device_fallback
])
for bar, actions in zip(self.bars, self.bar_actions[:3]):
bar.init_bar(actions)
# Build the layout containing the buttons to go into the search bar
self.search_tool_bar.init_bar(gprefs['action-layout-searchbar'])
def update_bars(self, reveal_bar=False):
'''
This shows the correct main toolbar and rebuilds the menubar based on
whether a device is connected or not. Note that the toolbars are
explicitly not rebuilt, this is to workaround a Qt limitation with
QToolButton's popup menus and modal dialogs. If you want the toolbars
rebuilt, call init_bars().
'''
showing_device = self.location_manager.has_device
main_bar = self.main_bars[1 if showing_device else 0]
child_bar = self.child_bars[0]
for bar in self.bars:
bar.setVisible(False)
bar.update_lm_actions()
if main_bar.added_actions:
main_bar.setVisible(True)
if reveal_bar and not config['disable_animations']:
self.reveal_bar.start(main_bar)
if child_bar.added_actions:
child_bar.setVisible(True)
self.menu_bar.init_bar(self.bar_actions[4 if showing_device else 3])
self.menu_bar.update_lm_actions()
self.menu_bar.setVisible(bool(self.menu_bar.added_actions))
# No need to update the Searchbar
def apply_settings(self):
sz = gprefs['toolbar_icon_size']
sz = {'off':0, 'small':24, 'medium':48, 'large':64}[sz]
style = Qt.ToolButtonStyle.ToolButtonTextUnderIcon
if sz > 0 and gprefs['toolbar_text'] == 'never':
style = Qt.ToolButtonStyle.ToolButtonIconOnly
for bar in self.bars:
bar.setIconSize(QSize(sz, sz))
bar.setToolButtonStyle(style)
if bar.donate_button:
bar.donate_button.setIconSize(bar.iconSize())
bar.donate_button.setToolButtonStyle(style)
| 29,529 | Python | .py | 704 | 30.080966 | 131 | 0.574157 | kovidgoyal/calibre | 19,243 | 2,250 | 4 | GPL-3.0 | 9/5/2024, 5:13:50 PM (Europe/Amsterdam) |
26,678 | changes.py | kovidgoyal_calibre/src/calibre/gui2/changes.py | #!/usr/bin/env python
# License: GPLv3 Copyright: 2017, Kovid Goyal <kovid at kovidgoyal.net>
from calibre.srv.changes import BooksAdded, BooksDeleted, FormatsAdded, FormatsRemoved, MetadataChanged, SavedSearchesChanged
def handle_changes(changes, gui=None):
if not changes:
return
if gui is None:
from calibre.gui2.ui import get_gui
gui = get_gui()
if gui is None:
return
refresh_ids = set()
added, removed = set(), set()
ss_changed = False
for change in changes:
if isinstance(change, (FormatsAdded, FormatsRemoved, MetadataChanged)):
refresh_ids |= change.book_ids
elif isinstance(change, BooksAdded):
added |= change.book_ids
elif isinstance(change, BooksDeleted):
removed |= change.book_ids
elif isinstance(change, SavedSearchesChanged):
ss_changed = True
if added and removed:
gui.refresh_all()
return
refresh_ids -= added | removed
orig = gui.tags_view.disable_recounting, gui.disable_cover_browser_refresh
gui.tags_view.disable_recounting = gui.disable_cover_browser_refresh = True
position_based_recount = True
try:
if added:
gui.current_db.data.books_added(added)
gui.iactions['Add Books'].refresh_gui(len(added), recount=False)
position_based_recount = False
if removed:
next_id = gui.current_view().next_id
m = gui.library_view.model()
m.ids_deleted(removed)
gui.iactions['Remove Books'].library_ids_deleted2(removed, next_id=next_id)
if refresh_ids:
gui.iactions['Edit Metadata'].refresh_books_after_metadata_edit(refresh_ids)
if ss_changed:
gui.saved_searches_changed(recount=False)
gui.tags_view.disable_recounting = gui.disable_cover_browser_refresh = False
(gui.tags_view.recount_with_position_based_index if position_based_recount else gui.tags_view.recount)()
gui.refresh_cover_browser()
finally:
gui.tags_view.disable_recounting, gui.disable_cover_browser_refresh = orig
| 2,152 | Python | .py | 49 | 35.55102 | 125 | 0.666826 | kovidgoyal/calibre | 19,243 | 2,250 | 4 | GPL-3.0 | 9/5/2024, 5:13:50 PM (Europe/Amsterdam) |
26,679 | update.py | kovidgoyal_calibre/src/calibre/gui2/update.py | __license__ = 'GPL v3'
__copyright__ = '2008, Kovid Goyal <kovid at kovidgoyal.net>'
import re
import ssl
from threading import Event, Thread
from qt.core import QApplication, QCheckBox, QDialog, QDialogButtonBox, QGridLayout, QIcon, QLabel, QObject, Qt, QUrl, pyqtSignal
from calibre import as_unicode, prints
from calibre.constants import __appname__, __version__, ismacos, isportable, iswindows, numeric_version
from calibre.gui2 import config, dynamic, icon_resource_manager, open_url
from calibre.gui2.dialogs.plugin_updater import get_plugin_updates_available
from calibre.utils.config import prefs
from calibre.utils.https import get_https_resource_securely
from calibre.utils.localization import localize_website_link, ngettext
from calibre.utils.serialize import msgpack_dumps, msgpack_loads
from polyglot.binary import as_hex_unicode, from_hex_bytes
URL = 'https://code.calibre-ebook.com/latest'
# URL = 'http://localhost:8000/latest'
NO_CALIBRE_UPDATE = (0, 0, 0)
def get_download_url():
which = ('portable' if isportable else 'windows' if iswindows
else 'osx' if ismacos else 'linux')
return localize_website_link('https://calibre-ebook.com/download_' + which)
def get_newest_version():
icon_theme_name = icon_resource_manager.user_theme_name
if icon_theme_name == 'default':
icon_theme_name = ''
headers={
'CALIBRE-VERSION':__version__,
'CALIBRE-OS': ('win' if iswindows else 'osx' if ismacos else 'oth'),
'CALIBRE-INSTALL-UUID': prefs['installation_uuid'],
'CALIBRE-ICON-THEME': icon_theme_name,
}
try:
version = get_https_resource_securely(URL, headers=headers)
except ssl.SSLError as err:
if getattr(err, 'reason', None) != 'CERTIFICATE_VERIFY_FAILED':
raise
# certificate verification failed, since the version check contains no
# critical information, ignore and proceed
# We have to do this as if the calibre CA certificate ever
# needs to be revoked, then we won't be able to do version checks
version = get_https_resource_securely(URL, headers=headers, cacerts=None)
try:
version = version.decode('utf-8').strip()
except UnicodeDecodeError:
version = ''
ans = NO_CALIBRE_UPDATE
m = re.match(r'(\d+)\.(\d+).(\d+)$', version)
if m is not None:
ans = tuple(map(int, (m.group(1), m.group(2), m.group(3))))
return ans
class Signal(QObject):
update_found = pyqtSignal(object, object)
class CheckForUpdates(Thread):
INTERVAL = 24*60*60 # seconds
daemon = True
def __init__(self, parent):
Thread.__init__(self, name='CheckForUpdates')
self.shutdown_event = Event()
self.signal = Signal(parent)
def run(self):
while not self.shutdown_event.is_set():
calibre_update_version = NO_CALIBRE_UPDATE
plugins_update_found = 0
try:
version = get_newest_version()
if version[:2] > numeric_version[:2]:
calibre_update_version = version
except Exception as e:
prints('Failed to check for calibre update:', as_unicode(e))
try:
update_plugins = get_plugin_updates_available(raise_error=True)
if update_plugins is not None:
plugins_update_found = len(update_plugins)
except Exception as e:
prints('Failed to check for plugin update:', as_unicode(e))
if calibre_update_version != NO_CALIBRE_UPDATE or plugins_update_found > 0:
self.signal.update_found.emit(calibre_update_version, plugins_update_found)
self.shutdown_event.wait(self.INTERVAL)
def shutdown(self):
self.shutdown_event.set()
def version_key(calibre_version):
if isinstance(calibre_version, bytes):
calibre_version = calibre_version.decode('utf-8')
if calibre_version.count('.') > 1:
calibre_version = calibre_version.rpartition('.')[0]
return calibre_version
def is_version_notified(calibre_version):
key = version_key(calibre_version)
done = dynamic.get('notified-version-updates') or set()
return key in done
def save_version_notified(calibre_version):
done = dynamic.get('notified-version-updates') or set()
done.add(version_key(calibre_version))
dynamic.set('notified-version-updates', done)
class UpdateNotification(QDialog):
def __init__(self, calibre_version, plugin_updates, parent=None):
QDialog.__init__(self, parent)
self.setAttribute(Qt.WidgetAttribute.WA_QuitOnClose, False)
self.resize(400, 250)
self.l = QGridLayout()
self.setLayout(self.l)
self.logo = QLabel()
self.logo.setMaximumWidth(110)
self.logo.setPixmap(QIcon.ic('lt.png').pixmap(100, 100))
ver = calibre_version
if ver.endswith('.0'):
ver = ver[:-2]
self.label = QLabel('<p>'+ _(
'New version <b>{ver}</b> of {app} is available for download. '
'See the <a href="{url}">new features</a>.').format(
url=localize_website_link('https://calibre-ebook.com/whats-new'),
app=__appname__, ver=ver))
self.label.setOpenExternalLinks(True)
self.label.setWordWrap(True)
self.setWindowTitle(_('Update available!'))
self.setWindowIcon(QIcon.ic('lt.png'))
self.l.addWidget(self.logo, 0, 0)
self.l.addWidget(self.label, 0, 1)
self.cb = QCheckBox(
_('Show this notification for future updates'), self)
self.l.addWidget(self.cb, 1, 0, 1, -1)
self.cb.setChecked(config.get('new_version_notification'))
self.cb.stateChanged.connect(self.show_future)
self.bb = QDialogButtonBox(self)
b = self.bb.addButton(_('&Get update'), QDialogButtonBox.ButtonRole.AcceptRole)
b.setDefault(True)
b.setIcon(QIcon.ic('arrow-down.png'))
if plugin_updates > 0:
b = self.bb.addButton(_('Update &plugins'), QDialogButtonBox.ButtonRole.ActionRole)
b.setIcon(QIcon.ic('plugins/plugin_updater.png'))
b.clicked.connect(self.get_plugins, type=Qt.ConnectionType.QueuedConnection)
self.bb.addButton(QDialogButtonBox.StandardButton.Cancel)
self.l.addWidget(self.bb, 2, 0, 1, -1)
self.bb.accepted.connect(self.accept)
self.bb.rejected.connect(self.reject)
save_version_notified(calibre_version)
def get_plugins(self):
from calibre.gui2.dialogs.plugin_updater import FILTER_UPDATE_AVAILABLE, PluginUpdaterDialog
d = PluginUpdaterDialog(self.parent(),
initial_filter=FILTER_UPDATE_AVAILABLE)
d.exec()
if d.do_restart:
QDialog.accept(self)
from calibre.gui2.ui import get_gui
gui = get_gui()
if gui is not None:
gui.quit(restart=True)
def show_future(self, *args):
config.set('new_version_notification', bool(self.cb.isChecked()))
def accept(self):
open_url(QUrl(get_download_url()))
QDialog.accept(self)
class UpdateMixin:
def __init__(self, *args, **kw):
pass
def init_update_mixin(self, opts):
self.last_newest_calibre_version = NO_CALIBRE_UPDATE
if not opts.no_update_check:
self.update_checker = CheckForUpdates(self)
self.update_checker.signal.update_found.connect(self.update_found,
type=Qt.ConnectionType.QueuedConnection)
self.update_checker.start()
def recalc_update_label(self, number_of_plugin_updates):
self.update_found(self.last_newest_calibre_version, number_of_plugin_updates)
def update_found(self, calibre_version, number_of_plugin_updates, force=False, no_show_popup=False):
self.last_newest_calibre_version = calibre_version
has_calibre_update = calibre_version != NO_CALIBRE_UPDATE and calibre_version[0] > 0
has_plugin_updates = number_of_plugin_updates > 0
self.plugin_update_found(number_of_plugin_updates)
version_url = as_hex_unicode(msgpack_dumps((calibre_version, number_of_plugin_updates)))
calibre_version = '.'.join(map(str, calibre_version))
if not has_calibre_update and not has_plugin_updates:
self.status_bar.update_label.setVisible(False)
return
if has_calibre_update:
plt = ''
if has_plugin_updates:
plt = ngettext(' and one plugin update', ' and {} plugin updates', number_of_plugin_updates).format(number_of_plugin_updates)
green = 'darkgreen' if QApplication.instance().is_dark_theme else 'green'
msg = ('<span style="color:%s; font-weight: bold">%s: '
'<a href="update:%s">%s%s</a></span>') % (
green, _('Update available'), version_url, calibre_version, plt)
else:
plt = ngettext('plugin update available', 'plugin updates available', number_of_plugin_updates)
msg = ('<a href="update:%s">%d %s</a>')%(version_url, number_of_plugin_updates, plt)
self.status_bar.update_label.setText(msg)
self.status_bar.update_label.setVisible(True)
if has_calibre_update:
if (force or (config.get('new_version_notification') and not is_version_notified(calibre_version))):
if not no_show_popup:
self._update_notification__ = UpdateNotification(calibre_version,
number_of_plugin_updates, parent=self)
self._update_notification__.show()
elif has_plugin_updates:
if force:
self.show_plugin_update_dialog()
def show_plugin_update_dialog(self):
from calibre.gui2.dialogs.plugin_updater import FILTER_UPDATE_AVAILABLE, PluginUpdaterDialog
d = PluginUpdaterDialog(self, initial_filter=FILTER_UPDATE_AVAILABLE)
d.exec()
if d.do_restart:
self.quit(restart=True)
def plugin_update_found(self, number_of_updates):
# Change the plugin icon to indicate there are updates available
plugin = self.iactions.get('Plugin Updater', None)
if not plugin:
return
if number_of_updates:
plugin.qaction.setText(_('Plugin updates')+'*')
plugin.qaction.setIcon(QIcon.ic('plugins/plugin_updater_updates.png'))
plugin.qaction.setToolTip(
ngettext('A plugin update is available',
'There are {} plugin updates available', number_of_updates).format(number_of_updates))
else:
plugin.qaction.setText(_('Plugin updates'))
plugin.qaction.setIcon(QIcon.ic('plugins/plugin_updater.png'))
plugin.qaction.setToolTip(_('Install and configure user plugins'))
def update_link_clicked(self, url):
url = str(url)
if url.startswith('update:'):
calibre_version, number_of_plugin_updates = msgpack_loads(from_hex_bytes(url[len('update:'):]))
self.update_found(calibre_version, number_of_plugin_updates, force=True)
if __name__ == '__main__':
from calibre.gui2 import Application
app = Application([])
UpdateNotification('x.y.z', False).exec()
del app
| 11,407 | Python | .py | 228 | 40.736842 | 141 | 0.64793 | kovidgoyal/calibre | 19,243 | 2,250 | 4 | GPL-3.0 | 9/5/2024, 5:13:50 PM (Europe/Amsterdam) |
26,680 | dnd.py | kovidgoyal_calibre/src/calibre/gui2/dnd.py | #!/usr/bin/env python
__license__ = 'GPL v3'
__copyright__ = '2011, Kovid Goyal <kovid@kovidgoyal.net>'
__docformat__ = 'restructuredtext en'
import os
import posixpath
import re
from contextlib import suppress
from threading import Thread
from qt.core import QDialog, QDialogButtonBox, QImageReader, QLabel, QPixmap, QProgressBar, Qt, QTimer, QUrl, QVBoxLayout
from calibre import as_unicode, browser, prints
from calibre.constants import DEBUG, iswindows
from calibre.gui2 import error_dialog
from calibre.ptempfile import PersistentTemporaryFile
from calibre.utils.filenames import make_long_path_useable
from calibre.utils.imghdr import what
from polyglot.queue import Empty, Queue
from polyglot.urllib import unquote, urlparse
def image_extensions():
if not hasattr(image_extensions, 'ans'):
image_extensions.ans = [x.data().decode('utf-8') for x in QImageReader.supportedImageFormats()]
return image_extensions.ans
# This is present for compatibility with old plugins, do not use
IMAGE_EXTENSIONS = ['jpg', 'jpeg', 'gif', 'png', 'bmp']
class Worker(Thread): # {{{
def __init__(self, url, fpath, rq):
Thread.__init__(self)
self.url, self.fpath = url, fpath
self.daemon = True
self.rq = rq
self.err = self.tb = None
def run(self):
try:
br = browser()
br.retrieve(self.url, self.fpath, self.callback)
except Exception as e:
self.err = as_unicode(e)
import traceback
self.tb = traceback.format_exc()
def callback(self, a, b, c):
self.rq.put((a, b, c))
# }}}
class DownloadDialog(QDialog): # {{{
def __init__(self, url, fname, parent):
QDialog.__init__(self, parent)
self.setWindowTitle(_('Download %s')%fname)
self.l = QVBoxLayout(self)
self.purl = urlparse(url)
self.msg = QLabel(_('Downloading <b>%(fname)s</b> from %(url)s')%dict(
fname=fname, url=self.purl.netloc))
self.msg.setWordWrap(True)
self.l.addWidget(self.msg)
self.pb = QProgressBar(self)
self.pb.setMinimum(0)
self.pb.setMaximum(0)
self.l.addWidget(self.pb)
self.bb = QDialogButtonBox(QDialogButtonBox.StandardButton.Cancel, Qt.Orientation.Horizontal, self)
self.l.addWidget(self.bb)
self.bb.rejected.connect(self.reject)
sz = self.sizeHint()
self.resize(max(sz.width(), 400), sz.height())
fpath = PersistentTemporaryFile(os.path.splitext(fname)[1])
fpath.close()
self.fpath = fpath.name
self.worker = Worker(url, self.fpath, Queue())
self.rejected = False
def reject(self):
self.rejected = True
QDialog.reject(self)
def start_download(self):
self.worker.start()
QTimer.singleShot(50, self.update)
self.exec()
if self.worker.err is not None:
error_dialog(self.parent(), _('Download failed'),
_('Failed to download from %(url)r with error: %(err)s')%dict(
url=self.worker.url, err=self.worker.err),
det_msg=self.worker.tb, show=True)
def update(self):
if self.rejected:
return
try:
progress = self.worker.rq.get_nowait()
except Empty:
pass
else:
self.update_pb(progress)
if not self.worker.is_alive():
return self.accept()
QTimer.singleShot(50, self.update)
def update_pb(self, progress):
transferred, block_size, total = progress
if total == -1:
self.pb.setMaximum(0)
self.pb.setMinimum(0)
self.pb.setValue(0)
else:
so_far = transferred * block_size
self.pb.setMaximum(max(total, so_far))
self.pb.setValue(so_far)
@property
def err(self):
return self.worker.err
# }}}
def dnd_has_image(md):
# Chromium puts image data into application/octet-stream
return md.hasImage() or md.hasFormat('application/octet-stream') and what(None, bytes(md.data('application/octet-stream'))) in image_extensions()
def data_as_string(f, md):
raw = bytes(md.data(f))
if '/x-moz' in f:
try:
raw = raw.decode('utf-16')
except:
pass
return raw
remote_protocols = {'http', 'https', 'ftp'}
def urls_from_md(md):
ans = list(md.urls())
if md.hasText():
# Chromium returns the url as text/plain on drag and drop of image
text = md.text()
if text and text.lstrip().partition(':')[0] in remote_protocols:
u = QUrl(text.strip())
if u.isValid():
ans.append(u)
return ans
def path_from_qurl(qurl, allow_remote=False):
lf = qurl.toLocalFile()
if lf:
if iswindows:
from calibre_extensions.winutil import get_long_path_name
with suppress(OSError):
lf = get_long_path_name(lf)
lf = make_long_path_useable(lf)
return lf
if not allow_remote:
return ''
if qurl.scheme() in remote_protocols:
path = qurl.path()
if path and '.' in path:
return path.rpartition('.')[-1]
return ''
def remote_urls_from_qurl(qurls, allowed_exts):
for qurl in qurls:
if qurl.scheme() in remote_protocols and posixpath.splitext(
qurl.path())[1][1:].lower() in allowed_exts:
yield bytes(qurl.toEncoded()).decode('utf-8'), posixpath.basename(qurl.path())
def extension(path):
return path.rpartition('.')[-1].lower()
def dnd_has_extension(md, extensions, allow_all_extensions=False, allow_remote=False):
if DEBUG:
prints('\nDebugging DND event')
for f in md.formats():
f = str(f)
raw = data_as_string(f, md)
prints(f, len(raw), repr(raw[:300]), '\n')
print()
if has_firefox_ext(md, extensions):
return True
urls = urls_from_md(md)
paths = [path_from_qurl(u, allow_remote=allow_remote) for u in urls]
exts = frozenset(filter(None, (extension(u) for u in paths if u)))
if DEBUG:
repr_urls = [bytes(u.toEncoded()).decode('utf-8') for u in urls]
prints('URLS:', repr(repr_urls))
prints('Paths:', paths)
prints('Extensions:', exts)
if allow_all_extensions:
return bool(exts)
return bool(exts.intersection(frozenset(extensions)))
def dnd_get_local_image_and_pixmap(md, image_exts=None):
if md.hasImage():
for x in md.formats():
x = str(x)
if x.startswith('image/'):
cdata = bytes(md.data(x))
pmap = QPixmap()
pmap.loadFromData(cdata)
if not pmap.isNull():
return pmap, cdata
if md.hasFormat('application/octet-stream'):
cdata = bytes(md.data('application/octet-stream'))
pmap = QPixmap()
pmap.loadFromData(cdata)
if not pmap.isNull():
return pmap, cdata
if image_exts is None:
image_exts = image_extensions()
# No image, look for an URL pointing to an image
urls = urls_from_md(md)
paths = [path_from_qurl(u) for u in urls]
# Look for a local file
images = [xi for xi in paths if extension(xi) in image_exts]
images = [xi for xi in images if os.path.exists(xi)]
for path in images:
try:
with open(path, 'rb') as f:
cdata = f.read()
except Exception:
continue
p = QPixmap()
p.loadFromData(cdata)
if not p.isNull():
return p, cdata
return None, None
def dnd_get_image(md, image_exts=None):
'''
Get the image in the QMimeData object md.
:return: None, None if no image is found
QPixmap, None if an image is found, the pixmap is guaranteed not null
url, filename if a URL that points to an image is found
'''
if image_exts is None:
image_exts = image_extensions()
pmap, data = dnd_get_local_image_and_pixmap(md, image_exts)
if pmap is not None:
return pmap, None
# Look for a remote image
urls = urls_from_md(md)
# First, see if this is from Firefox
rurl, fname = get_firefox_rurl(md, image_exts)
if rurl and fname:
return rurl, fname
# Look through all remaining URLs
for remote_url, filename in remote_urls_from_qurl(urls, image_exts):
return remote_url, filename
return None, None
def dnd_get_files(md, exts, allow_all_extensions=False, filter_exts=()):
'''
Get the file in the QMimeData object md with an extension that is one of
the extensions in exts.
:return: None, None if no file is found
[paths], None if a local file is found
[urls], [filenames] if URLs that point to a files are found
'''
# Look for a URL pointing to a file
urls = urls_from_md(md)
# First look for a local file
local_files = [path_from_qurl(x) for x in urls]
def is_ok(path):
ext = extension(path)
if allow_all_extensions and ext and ext not in filter_exts:
return True
return ext in exts and ext not in filter_exts
local_files = [p for p in local_files if is_ok(unquote(p))]
local_files = [x for x in local_files if os.path.exists(x)]
if local_files:
return local_files, None
# No local files, look for remote ones
# First, see if this is from Firefox
rurl, fname = get_firefox_rurl(md, exts)
if rurl and fname:
return [rurl], [fname]
# Look through all remaining URLs
rurls, filenames = [], []
for rurl, fname in remote_urls_from_qurl(urls, exts):
rurls.append(rurl), filenames.append(fname)
if rurls:
return rurls, filenames
return None, None
def _get_firefox_pair(md, exts, url, fname):
url = bytes(md.data(url)).decode('utf-16')
fname = bytes(md.data(fname)).decode('utf-16')
while url.endswith('\x00'):
url = url[:-1]
while fname.endswith('\x00'):
fname = fname[:-1]
if not url or not fname:
return None, None
ext = posixpath.splitext(fname)[1][1:].lower()
# Weird firefox bug on linux
ext = {'jpe':'jpg', 'epu':'epub', 'mob':'mobi'}.get(ext, ext)
fname = os.path.splitext(fname)[0] + '.' + ext
if DEBUG:
prints('Firefox file promise:', url, fname)
if ext not in exts:
fname = url = None
return url, fname
def get_firefox_rurl(md, exts):
formats = frozenset(str(x) for x in md.formats())
url = fname = None
if 'application/x-moz-file-promise-url' in formats and \
'application/x-moz-file-promise-dest-filename' in formats:
try:
url, fname = _get_firefox_pair(md, exts,
'application/x-moz-file-promise-url',
'application/x-moz-file-promise-dest-filename')
except:
if DEBUG:
import traceback
traceback.print_exc()
if url is None and 'text/x-moz-url-data' in formats and \
'text/x-moz-url-desc' in formats:
try:
url, fname = _get_firefox_pair(md, exts,
'text/x-moz-url-data', 'text/x-moz-url-desc')
except:
if DEBUG:
import traceback
traceback.print_exc()
if url is None and '_NETSCAPE_URL' in formats:
try:
raw = bytes(md.data('_NETSCAPE_URL'))
raw = raw.decode('utf-8')
lines = raw.splitlines()
if len(lines) > 1 and re.match(r'[a-z]+://', lines[1]) is None:
url, fname = lines[:2]
ext = posixpath.splitext(fname)[1][1:].lower()
if ext not in exts:
fname = url = None
except:
if DEBUG:
import traceback
traceback.print_exc()
if DEBUG:
prints('Firefox rurl:', url, fname)
return url, fname
def has_firefox_ext(md, exts):
return bool(get_firefox_rurl(md, exts)[0])
| 12,173 | Python | .py | 319 | 29.846395 | 149 | 0.605685 | kovidgoyal/calibre | 19,243 | 2,250 | 4 | GPL-3.0 | 9/5/2024, 5:13:50 PM (Europe/Amsterdam) |
26,681 | image_popup.py | kovidgoyal_calibre/src/calibre/gui2/image_popup.py | #!/usr/bin/env python
__license__ = 'GPL v3'
__copyright__ = '2012, Kovid Goyal <kovid at kovidgoyal.net>'
__docformat__ = 'restructuredtext en'
from qt.core import (
QAction,
QApplication,
QCheckBox,
QDialog,
QDialogButtonBox,
QHBoxLayout,
QIcon,
QImage,
QKeySequence,
QLabel,
QMenu,
QPainter,
QPalette,
QPixmap,
QScrollArea,
QSize,
QSizePolicy,
Qt,
QTransform,
QUrl,
QVBoxLayout,
pyqtSignal,
)
from calibre import fit_image
from calibre.gui2 import NO_URL_FORMATTING, choose_save_file, gprefs, max_available_height
def render_svg(widget, path):
from qt.core import QSvgRenderer
img = QPixmap()
rend = QSvgRenderer()
if rend.load(path):
dpr = getattr(widget, 'devicePixelRatioF', widget.devicePixelRatio)()
sz = rend.defaultSize()
h = (max_available_height() - 50)
w = int(h * sz.height() / float(sz.width()))
pd = QImage(w * dpr, h * dpr, QImage.Format.Format_RGB32)
pd.fill(Qt.GlobalColor.white)
p = QPainter(pd)
rend.render(p)
p.end()
img = QPixmap.fromImage(pd)
img.setDevicePixelRatio(dpr)
return img
class Label(QLabel):
toggle_fit = pyqtSignal()
zoom_requested = pyqtSignal(bool)
def __init__(self, scrollarea):
super().__init__(scrollarea)
scrollarea.zoom_requested.connect(self.zoom_requested)
self.setBackgroundRole(QPalette.ColorRole.Text if QApplication.instance().is_dark_theme else QPalette.ColorRole.Base)
self.setSizePolicy(QSizePolicy.Policy.Ignored, QSizePolicy.Policy.Ignored)
self.setScaledContents(True)
self.default_cursor = self.cursor()
self.in_drag = False
self.prev_drag_position = None
self.scrollarea = scrollarea
@property
def is_pannable(self):
return self.scrollarea.verticalScrollBar().isVisible() or self.scrollarea.horizontalScrollBar().isVisible()
def mousePressEvent(self, ev):
if ev.button() == Qt.MouseButton.LeftButton and self.is_pannable:
self.setCursor(Qt.CursorShape.ClosedHandCursor)
self.in_drag = True
self.prev_drag_position = ev.globalPos()
return super().mousePressEvent(ev)
def mouseReleaseEvent(self, ev):
if ev.button() == Qt.MouseButton.LeftButton and self.in_drag:
self.setCursor(self.default_cursor)
self.in_drag = False
self.prev_drag_position = None
return super().mousePressEvent(ev)
def mouseMoveEvent(self, ev):
if self.prev_drag_position is not None:
p = self.prev_drag_position
self.prev_drag_position = pos = ev.globalPos()
self.dragged(pos.x() - p.x(), pos.y() - p.y())
return super().mouseMoveEvent(ev)
def dragged(self, dx, dy):
h = self.scrollarea.horizontalScrollBar()
if h.isVisible():
h.setValue(h.value() - dx)
v = self.scrollarea.verticalScrollBar()
if v.isVisible():
v.setValue(v.value() - dy)
class ScrollArea(QScrollArea):
toggle_fit = pyqtSignal()
zoom_requested = pyqtSignal(bool)
current_wheel_angle_delta = 0
def mouseDoubleClickEvent(self, ev):
if ev.button() == Qt.MouseButton.LeftButton:
self.toggle_fit.emit()
def wheelEvent(self, ev):
if ev.modifiers() == Qt.KeyboardModifier.ControlModifier:
ad = ev.angleDelta().y()
if ad * self.current_wheel_angle_delta < 0:
self.current_wheel_angle_delta = 0
self.current_wheel_angle_delta += ad
if abs(self.current_wheel_angle_delta) >= 120:
self.zoom_requested.emit(self.current_wheel_angle_delta < 0)
self.current_wheel_angle_delta = 0
ev.accept()
else:
super().wheelEvent(ev)
class ImageView(QDialog):
def __init__(self, parent, current_img, current_url, geom_name='viewer_image_popup_geometry', prefs=gprefs):
QDialog.__init__(self)
self.prefs = prefs
self.current_image_name = ''
self.maximized_at_last_fullscreen = False
self.setWindowFlag(Qt.WindowType.WindowMinimizeButtonHint)
self.setWindowFlag(Qt.WindowType.WindowMaximizeButtonHint)
self.avail_geom = self.screen().availableGeometry()
self.current_img = current_img
self.current_url = current_url
self.factor = 1.0
self.geom_name = geom_name
self.zoom_in_action = ac = QAction(QIcon.ic('plus.png'), _('Zoom &in'), self)
ac.triggered.connect(self.zoom_in)
ac.setShortcuts([QKeySequence(QKeySequence.StandardKey.ZoomIn), QKeySequence('+', QKeySequence.SequenceFormat.PortableText)])
self.addAction(ac)
self.zoom_out_action = ac = QAction(QIcon.ic('minus.png'), _('Zoom &out'), self)
ac.triggered.connect(self.zoom_out)
ac.setShortcuts([QKeySequence(QKeySequence.StandardKey.ZoomOut), QKeySequence('-', QKeySequence.SequenceFormat.PortableText)])
self.addAction(ac)
self.reset_zoom_action = ac = QAction(QIcon.ic('edit-undo.png'), _('Reset &zoom'), self)
ac.triggered.connect(self.reset_zoom)
ac.setShortcuts([QKeySequence('=', QKeySequence.SequenceFormat.PortableText)])
self.addAction(ac)
self.copy_action = ac = QAction(QIcon.ic('edit-copy.png'), _('&Copy'), self)
ac.setShortcuts([QKeySequence(QKeySequence.StandardKey.Copy)])
self.addAction(ac)
ac.triggered.connect(self.copy_image)
self.rotate_action = ac = QAction(QIcon.ic('rotate-right.png'), _('&Rotate'), self)
self.addAction(ac)
ac.triggered.connect(self.rotate_image)
self.scrollarea = sa = ScrollArea()
sa.setAlignment(Qt.AlignmentFlag.AlignHCenter | Qt.AlignmentFlag.AlignVCenter)
sa.setBackgroundRole(QPalette.ColorRole.Dark)
self.label = l = Label(sa)
l.zoom_requested.connect(self.zoom_requested)
sa.toggle_fit.connect(self.toggle_fit)
sa.setWidget(l)
self.bb = bb = QDialogButtonBox(QDialogButtonBox.StandardButton.Close)
bb.accepted.connect(self.accept)
bb.rejected.connect(self.reject)
self.zi_button = zi = bb.addButton(self.zoom_in_action.text(), QDialogButtonBox.ButtonRole.ActionRole)
self.zo_button = zo = bb.addButton(self.zoom_out_action.text(), QDialogButtonBox.ButtonRole.ActionRole)
self.save_button = so = bb.addButton(_('&Save as'), QDialogButtonBox.ButtonRole.ActionRole)
self.copy_button = co = bb.addButton(self.copy_action.text(), QDialogButtonBox.ButtonRole.ActionRole)
self.rotate_button = ro = bb.addButton(self.rotate_action.text(), QDialogButtonBox.ButtonRole.ActionRole)
self.fullscreen_button = fo = bb.addButton(_('F&ull screen'), QDialogButtonBox.ButtonRole.ActionRole)
zi.setIcon(self.zoom_in_action.icon())
zo.setIcon(self.zoom_out_action.icon())
so.setIcon(QIcon.ic('save.png'))
co.setIcon(self.copy_action.icon())
ro.setIcon(self.rotate_action.icon())
fo.setIcon(QIcon.ic('page.png'))
zi.clicked.connect(self.zoom_in_action.trigger)
zo.clicked.connect(self.zoom_out_action.trigger)
so.clicked.connect(self.save_image)
co.clicked.connect(self.copy_action.trigger)
ro.clicked.connect(self.rotate_image)
fo.setCheckable(True)
self.l = l = QVBoxLayout(self)
l.addWidget(sa)
self.h = h = QHBoxLayout()
h.setContentsMargins(0, 0, 0, 0)
l.addLayout(h)
self.fit_image = i = QCheckBox(_('&Fit image'))
i.setToolTip(_('Fit image inside the available space'))
i.setChecked(bool(self.prefs.get('image_popup_fit_image')))
i.stateChanged.connect(self.fit_changed)
self.remember_zoom = z = QCheckBox(_('Remember &zoom'))
z.setChecked(not i.isChecked() and bool(self.prefs.get('image_popup_remember_zoom', False)))
z.stateChanged.connect(self.remember_zoom_changed)
h.addWidget(i), h.addWidget(z), h.addStretch(), h.addWidget(bb)
if self.fit_image.isChecked():
self.set_to_viewport_size()
elif z.isChecked():
factor = self.prefs.get('image_popup_zoom_factor', self.factor)
if factor != self.factor and not self.fit_image.isChecked():
self.factor = factor
self.restore_geometry(self.prefs, self.geom_name)
fo.setChecked(self.isFullScreen())
fo.toggled.connect(self.toggle_fullscreen)
self.setContextMenuPolicy(Qt.ContextMenuPolicy.CustomContextMenu)
self.customContextMenuRequested.connect(self.context_menu)
def context_menu(self, pos):
m = QMenu(self)
m.addAction(self.reset_zoom_action)
m.addAction(self.zoom_in_action)
m.addAction(self.zoom_out_action)
m.addAction(self.copy_action)
m.addAction(self.rotate_action)
m.exec(self.mapToGlobal(pos))
def set_to_viewport_size(self):
page_size = self.scrollarea.size()
pw, ph = page_size.width() - 2, page_size.height() - 2
img_size = self.current_img.size()
iw, ih = img_size.width(), img_size.height()
scaled, nw, nh = fit_image(iw, ih, pw, ph)
if scaled:
self.factor = min(nw/iw, nh/ih)
img_size.setWidth(nw), img_size.setHeight(nh)
self.label.resize(img_size)
def resizeEvent(self, ev):
if self.fit_image.isChecked():
self.set_to_viewport_size()
def factor_from_fit(self):
scaled_height = self.label.size().height()
actual_height = self.current_img.size().height()
if actual_height:
return scaled_height / actual_height
return 1.0
def zoom_requested(self, zoom_out):
if (zoom_out and self.zo_button.isEnabled()) or (not zoom_out and self.zi_button.isEnabled()):
(self.zoom_out if zoom_out else self.zoom_in)()
def reset_zoom(self):
self.factor = 1.0
self.prefs.set('image_popup_zoom_factor', self.factor)
self.adjust_image(1.0)
def zoom_in(self):
if self.fit_image.isChecked():
factor = self.factor_from_fit()
self.fit_image.setChecked(False)
self.factor = factor
self.factor *= 1.25
self.prefs.set('image_popup_zoom_factor', self.factor)
self.adjust_image(1.25)
def zoom_out(self):
if self.fit_image.isChecked():
factor = self.factor_from_fit()
self.fit_image.setChecked(False)
self.factor = factor
self.factor *= 0.8
self.prefs.set('image_popup_zoom_factor', self.factor)
self.adjust_image(0.8)
def save_image(self):
filters=[('Images', ['png', 'jpeg', 'jpg'])]
f = choose_save_file(self, 'viewer image view save dialog',
_('Choose a file to save to'), filters=filters,
all_files=False, initial_filename=self.current_image_name or None)
if f:
from calibre.utils.img import save_image
save_image(self.current_img.toImage(), f)
def copy_image(self):
if self.current_img and not self.current_img.isNull():
QApplication.instance().clipboard().setPixmap(self.current_img)
def fit_changed(self):
fitted = bool(self.fit_image.isChecked())
self.prefs.set('image_popup_fit_image', fitted)
if self.fit_image.isChecked():
self.set_to_viewport_size()
self.remember_zoom.setChecked(False)
else:
self.factor = 1
self.prefs.set('image_popup_zoom_factor', self.factor)
self.adjust_image(1)
def remember_zoom_changed(self):
val = bool(self.remember_zoom.isChecked())
self.prefs.set('image_popup_remember_zoom', val)
def toggle_fit(self):
self.fit_image.toggle()
def adjust_image(self, factor):
if self.fit_image.isChecked():
self.set_to_viewport_size()
return
self.label.resize(self.factor * self.current_img.size())
self.zi_button.setEnabled(self.factor <= 3)
self.zo_button.setEnabled(self.factor >= 0.3333)
self.zoom_in_action.setEnabled(self.zi_button.isEnabled())
self.zoom_out_action.setEnabled(self.zo_button.isEnabled())
self.reset_zoom_action.setEnabled(self.factor != 1)
self.adjust_scrollbars(factor)
def adjust_scrollbars(self, factor):
for sb in (self.scrollarea.horizontalScrollBar(),
self.scrollarea.verticalScrollBar()):
sb.setValue(int(factor*sb.value()) + int((factor - 1) * sb.pageStep()/2))
def rotate_image(self):
pm = self.label.pixmap()
t = QTransform()
t.rotate(90)
pm = self.current_img = pm.transformed(t)
self.label.setPixmap(pm)
self.label.adjustSize()
if self.fit_image.isChecked():
self.set_to_viewport_size()
else:
self.factor = 1
self.prefs.set('image_popup_zoom_factor', self.factor)
for sb in (self.scrollarea.horizontalScrollBar(),
self.scrollarea.verticalScrollBar()):
sb.setValue(0)
def __call__(self, use_exec=False):
geom = self.avail_geom
self.label.setPixmap(self.current_img)
self.label.adjustSize()
self.resize(QSize(int(geom.width()/2.5), geom.height()-50))
self.restore_geometry(self.prefs, self.geom_name)
try:
self.current_image_name = str(self.current_url.toString(NO_URL_FORMATTING)).rpartition('/')[-1]
except AttributeError:
self.current_image_name = self.current_url
reso = ''
if self.current_img and not self.current_img.isNull():
if self.factor != 1:
self.adjust_image(self.factor)
reso = f'[{self.current_img.width()}x{self.current_img.height()}]'
title = _('Image: {name} {resolution}').format(name=self.current_image_name, resolution=reso)
self.setWindowTitle(title)
if use_exec:
self.exec()
else:
self.show()
def done(self, e):
self.save_geometry(self.prefs, self.geom_name)
return QDialog.done(self, e)
def toggle_fullscreen(self):
on = not self.isFullScreen()
if on:
self.maximized_at_last_fullscreen = self.isMaximized()
self.showFullScreen()
else:
if self.maximized_at_last_fullscreen:
self.showMaximized()
else:
self.showNormal()
class ImagePopup:
def __init__(self, parent, prefs=gprefs):
self.current_img = QPixmap()
self.current_url = QUrl()
self.parent = parent
self.dialogs = []
self.prefs = prefs
def __call__(self):
if self.current_img.isNull():
return
d = ImageView(self.parent, self.current_img, self.current_url, prefs=self.prefs)
self.dialogs.append(d)
d.finished.connect(self.cleanup, type=Qt.ConnectionType.QueuedConnection)
d()
def cleanup(self):
for d in tuple(self.dialogs):
if not d.isVisible():
self.dialogs.remove(d)
def show_image(path=None):
if path is None:
import sys
path = sys.argv[-1]
from calibre.gui2 import Application
app = Application([])
p = QPixmap()
p.load(path)
u = QUrl.fromLocalFile(path)
d = ImageView(None, p, u)
d()
app.exec()
if __name__ == '__main__':
show_image()
| 15,756 | Python | .py | 363 | 34.465565 | 134 | 0.633744 | kovidgoyal/calibre | 19,243 | 2,250 | 4 | GPL-3.0 | 9/5/2024, 5:13:50 PM (Europe/Amsterdam) |
26,682 | icon_theme.py | kovidgoyal_calibre/src/calibre/gui2/icon_theme.py | #!/usr/bin/env python
__license__ = 'GPL v3'
__copyright__ = '2015, Kovid Goyal <kovid at kovidgoyal.net>'
import bz2
import errno
import importlib
import json
import math
import os
import sys
import tempfile
from contextlib import suppress
from functools import lru_cache
from io import BytesIO
from itertools import count
from multiprocessing.pool import ThreadPool
from threading import Event, Thread
from xml.sax.saxutils import escape
from qt.core import (
QAbstractItemView,
QApplication,
QCheckBox,
QComboBox,
QDialog,
QDialogButtonBox,
QFormLayout,
QGroupBox,
QHBoxLayout,
QIcon,
QImage,
QImageReader,
QItemSelectionModel,
QLabel,
QLineEdit,
QListWidget,
QListWidgetItem,
QPen,
QPixmap,
QProgressDialog,
QSize,
QSpinBox,
QSplitter,
QStackedLayout,
QStaticText,
QStyle,
QStyledItemDelegate,
Qt,
QTabWidget,
QTextEdit,
QVBoxLayout,
QWidget,
pyqtSignal,
sip,
)
from calibre import detect_ncpus as cpu_count
from calibre import fit_image, human_readable, walk
from calibre.constants import cache_dir
from calibre.customize.ui import interface_actions
from calibre.gui2 import choose_dir, choose_save_file, empty_index, error_dialog, gprefs, icon_resource_manager, must_use_qt, safe_open_url
from calibre.gui2.dialogs.progress import ProgressDialog
from calibre.gui2.progress_indicator import ProgressIndicator
from calibre.gui2.widgets2 import Dialog
from calibre.utils.date import utcnow
from calibre.utils.filenames import ascii_filename, atomic_rename
from calibre.utils.https import HTTPError, get_https_resource_securely
from calibre.utils.icu import numeric_sort_key as sort_key
from calibre.utils.img import Canvas, image_from_data, optimize_jpeg, optimize_png
from calibre.utils.resources import get_image_path as I
from calibre.utils.resources import get_path as P
from calibre.utils.zipfile import ZIP_STORED, ZipFile
from polyglot import http_client
from polyglot.builtins import as_bytes, iteritems, reraise
from polyglot.queue import Empty, Queue
IMAGE_EXTENSIONS = {'png', 'jpg', 'jpeg'}
THEME_COVER = 'icon-theme-cover.jpg'
THEME_METADATA = 'metadata.json'
BASE_URL = 'https://code.calibre-ebook.com/icon-themes/'
# Theme creation {{{
COVER_SIZE = (340, 272)
def render_svg(filepath):
must_use_qt(headless=False)
pngpath = filepath[:-4] + '.png'
i = QImage(filepath)
i.save(pngpath)
def read_images_from_folder(path):
name_map = {}
path = os.path.abspath(path)
for filepath in walk(path):
name = os.path.relpath(filepath, path).replace(os.sep, '/')
ext = name.rpartition('.')[-1]
bname = os.path.basename(name)
if bname.startswith('.') or bname.startswith('_'):
continue
if ext == 'svg':
render_svg(filepath)
ext = 'png'
filepath = filepath[:-4] + '.png'
name = name[:-4] + '.png'
if ext in IMAGE_EXTENSIONS:
name_map[name] = filepath
return name_map
class Theme:
def __init__(self, title='', author='', version=-1, description='', license='Unknown', url=None, cover=None):
self.title, self.author, self.version, self.description = title, author, version, description
self.license, self.cover, self.url = license, cover, url
class Report:
def __init__(self, path, name_map, extra, missing, theme, number):
self.path, self.name_map, self.extra, self.missing, self.theme = path, name_map, extra, missing, theme
self.number = number
self.bad = {}
@property
def name(self):
return ascii_filename(self.theme.title).replace(' ', '_').replace('.', '_').lower()
def read_theme_from_folder(path):
path = os.path.abspath(path)
current_image_map = read_images_from_folder(P('images', allow_user_override=False))
name_map = read_images_from_folder(path)
name_map.pop(THEME_COVER, None)
name_map.pop('blank.png', None)
def canonical_name(x):
return x.replace('-for-dark-theme', '').replace('-for-light-theme', '')
current_names = set(map(canonical_name, current_image_map))
names = set(map(canonical_name, name_map))
extra = names - current_names
missing = current_names - names
missing.discard('blank.png')
number = len(names - extra)
try:
with open(os.path.join(path, THEME_METADATA), 'rb') as f:
metadata = json.load(f)
except OSError as e:
if e.errno != errno.ENOENT:
raise
metadata = {}
except ValueError:
# Corrupted metadata file
metadata = {}
def safe_int(x):
try:
return int(x)
except Exception:
return -1
def g(x, defval=''):
return metadata.get(x, defval)
theme = Theme(g('title'), g('author'), safe_int(g('version', -1)), g('description'), g('license', 'Unknown'), g('url', None))
ans = Report(path, name_map, extra, missing, theme, number)
try:
with open(os.path.join(path, THEME_COVER), 'rb') as f:
theme.cover = f.read()
except OSError as e:
if e.errno != errno.ENOENT:
raise
theme.cover = create_cover(ans)
return ans
def icon_for_action(name):
for plugin in interface_actions():
if plugin.name == name:
module, class_name = plugin.actual_plugin.partition(':')[::2]
mod = importlib.import_module(module)
cls = getattr(mod, class_name)
icon = cls.action_spec[1]
if icon:
return icon
def default_cover_icons(cols=5):
count = 0
for ac in gprefs.defaults['action-layout-toolbar']:
if ac:
icon = icon_for_action(ac)
if icon:
count += 1
yield icon
for x in 'user_profile plus minus series sync tags default_cover'.split():
yield x + '.png'
count += 1
extra = 'search donate cover_flow reader publisher back forward'.split()
while count < 15 or count % cols != 0:
yield extra[0] + '.png'
del extra[0]
count += 1
def create_cover(report=None, icons=(), cols=5, size=120, padding=16, darkbg=False):
icons = icons or tuple(default_cover_icons(cols))
rows = int(math.ceil(len(icons) / cols))
with Canvas(cols * (size + padding), rows * (size + padding), bgcolor='#444' if darkbg else '#eee') as canvas:
y = -size - padding // 2
x = 0
for i, icon in enumerate(icons):
if i % cols == 0:
y += padding + size
x = padding // 2
else:
x += size + padding
if report and icon in report.name_map:
ipath = os.path.join(report.path, report.name_map[icon])
else:
ipath = I(icon, allow_user_override=False)
with open(ipath, 'rb') as f:
img = image_from_data(f.read())
scaled, nwidth, nheight = fit_image(img.width(), img.height(), size, size)
img = img.scaled(int(nwidth), int(nheight), Qt.AspectRatioMode.IgnoreAspectRatio, Qt.TransformationMode.SmoothTransformation)
dx = (size - nwidth) // 2
canvas.compose(img, x + dx, y)
return canvas.export()
def verify_theme(report):
must_use_qt()
report.bad = bad = {}
for name, path in iteritems(report.name_map):
reader = QImageReader(os.path.join(report.path, path))
img = reader.read()
if img.isNull():
bad[name] = reader.errorString()
return bool(bad)
class ThemeCreateDialog(Dialog):
def __init__(self, parent, report):
self.report = report
Dialog.__init__(self, _('Create an icon theme'), 'create-icon-theme', parent)
def setup_ui(self):
self.splitter = QSplitter(self)
self.l = l = QVBoxLayout(self)
l.addWidget(self.splitter)
self.h = h = QHBoxLayout()
self.use_in_calibre = uic = QCheckBox(_('Use this theme in calibre'))
uic.setToolTip(_('Change the current calibre icon theme to this theme'))
uic.setChecked(bool(gprefs.get('use_created_icon_theme_in_calibre', True)))
uic.toggled.connect(lambda checked: gprefs.set('use_created_icon_theme_in_calibre', bool(checked)))
h.addWidget(uic), h.addStretch(), h.addWidget(self.bb)
l.addLayout(h)
self.w = w = QGroupBox(_('Theme Metadata'), self)
self.splitter.addWidget(w)
l = w.l = QFormLayout(w)
l.setFieldGrowthPolicy(QFormLayout.FieldGrowthPolicy.ExpandingFieldsGrow)
self.missing_icons_group = mg = QGroupBox(self)
self.missing_icons = mi = QListWidget(mg)
mi.setSelectionMode(QAbstractItemView.SelectionMode.NoSelection)
mg.l = QVBoxLayout(mg)
mg.l.addWidget(mi)
self.splitter.addWidget(mg)
self.title = QLineEdit(self)
l.addRow(_('&Title:'), self.title)
self.author = QLineEdit(self)
l.addRow(_('&Author:'), self.author)
self.version = v = QSpinBox(self)
v.setMinimum(1), v.setMaximum(1000000)
l.addRow(_('&Version:'), v)
self.license = lc = QLineEdit(self)
self.color_palette = cp = QComboBox(self)
cp.addItem(_('Light and Dark'), 'any')
cp.addItem(_('Light only'), 'light')
cp.addItem(_('Dark only'), 'dark')
cp.setToolTip(_('Specify the color palette this icon theme is suited for'))
l.addRow(_('&Color palette:'), cp)
l.addRow(_('&License:'), lc)
self.url = QLineEdit(self)
l.addRow(_('&URL:'), self.url)
lc.setText(_(
'The license for the icons in this theme. Common choices are'
' Creative Commons or Public Domain.'))
self.description = QTextEdit(self)
l.addRow(self.description)
self.refresh_button = rb = self.bb.addButton(_('&Refresh'), QDialogButtonBox.ButtonRole.ActionRole)
rb.setIcon(QIcon.ic('view-refresh.png'))
rb.clicked.connect(self.refresh)
self.apply_report()
def sizeHint(self):
return QSize(900, 670)
@property
def metadata(self):
self.report.theme.title = self.title.text().strip() # Needed for report.name to work
return {
'title': self.title.text().strip(),
'author': self.author.text().strip(),
'color_palette': self.color_palette.currentData(),
'version': self.version.value(),
'description': self.description.toPlainText().strip(),
'number': self.report.number,
'date': utcnow().date().isoformat(),
'name': self.report.name,
'license': self.license.text().strip() or 'Unknown',
'url': self.url.text().strip() or None,
}
def save_metadata(self):
data = json.dumps(self.metadata, indent=2)
if not isinstance(data, bytes):
data = data.encode('utf-8')
with open(os.path.join(self.report.path, THEME_METADATA), 'wb') as f:
f.write(data)
def refresh(self):
self.save_metadata()
self.report = read_theme_from_folder(self.report.path)
self.apply_report()
def apply_report(self):
theme = self.report.theme
self.title.setText((theme.title or '').strip())
self.author.setText((theme.author or '').strip())
self.version.setValue(theme.version or 1)
self.description.setText((theme.description or '').strip())
self.license.setText((theme.license or 'Unknown').strip())
self.url.setText((theme.url or '').strip())
if self.report.missing:
title = _('%d icons missing in this theme') % len(self.report.missing)
else:
title = _('No missing icons')
self.missing_icons_group.setTitle(title)
mi = self.missing_icons
mi.clear()
for name in sorted(self.report.missing):
QListWidgetItem(QIcon(I(name, allow_user_override=False)), name, mi)
def accept(self):
mi = self.metadata
if not mi.get('title'):
return error_dialog(self, _('No title specified'), _(
'You must specify a title for this icon theme'), show=True)
if not mi.get('author'):
return error_dialog(self, _('No author specified'), _(
'You must specify an author for this icon theme'), show=True)
return Dialog.accept(self)
class Compress(QProgressDialog):
update_signal = pyqtSignal(object, object)
def __init__(self, report, theme_metadata, parent=None):
total = 2 + len(report.name_map)
self.theme_metadata = theme_metadata
QProgressDialog.__init__(self, _('Losslessly optimizing images, please wait...'), _('&Abort'), 0, total, parent)
self.setWindowTitle(self.labelText())
self.setWindowIcon(QIcon.ic('lt.png'))
self.setMinimumDuration(0)
self.update_signal.connect(self.do_update, type=Qt.ConnectionType.QueuedConnection)
self.raw = self.prefix = None
self.abort = Event()
self.canceled.connect(self.abort.set)
self.t = Thread(name='CompressIcons', target=self.run_compress, args=(report,))
self.t.daemon = False
self.t.start()
def do_update(self, num, message):
if num < 0:
return self.onerror(_('Optimizing images failed, click "Show details" for more information'), message)
self.setValue(num)
self.setLabelText(message)
def onerror(self, msg, details):
error_dialog(self, _('Compression failed'), msg, det_msg=details, show=True)
self.close()
def onprogress(self, num, msg):
self.update_signal.emit(num, msg)
return not self.wasCanceled()
def run_compress(self, report):
try:
self.raw, self.prefix, self.icon_zip_data = create_themeball(report, self.theme_metadata, self.onprogress, self.abort)
except Exception:
import traceback
traceback.print_exc()
self.update_signal.emit(-1, traceback.format_exc())
else:
self.update_signal.emit(self.maximum(), '')
def create_themeball(report, theme_metadata, progress=None, abort=None):
pool = ThreadPool(processes=cpu_count())
buf = BytesIO()
num = count()
error_occurred = Event()
def optimize(name):
if abort is not None and abort.is_set():
return
if error_occurred.is_set():
return
try:
i = next(num)
if progress is not None:
progress(i, _('Optimizing %s') % name)
srcpath = os.path.join(report.path, name)
ext = srcpath.rpartition('.')[-1].lower()
if ext == 'png':
optimize_png(srcpath)
elif ext in ('jpg', 'jpeg'):
optimize_jpeg(srcpath)
except Exception:
return sys.exc_info()
errors = tuple(filter(None, pool.map(optimize, tuple(report.name_map))))
pool.close(), pool.join()
if abort is not None and abort.is_set():
return None, None, None
if errors:
e = errors[0]
reraise(*e)
if progress is not None:
progress(next(num), _('Creating theme file'))
with ZipFile(buf, 'w') as zf:
for name in report.name_map:
srcpath = os.path.join(report.path, name)
with open(srcpath, 'rb') as f:
zf.writestr(name, f.read(), compression=ZIP_STORED)
buf.seek(0)
icon_zip_data = buf
if abort is not None and abort.is_set():
return None, None, None
if progress is not None:
progress(next(num), _('Compressing theme file'))
import lzma
compressed = lzma.compress(icon_zip_data.getvalue(), format=lzma.FORMAT_XZ, preset=9)
buf = BytesIO()
prefix = report.name
if abort is not None and abort.is_set():
return None, None, None
with ZipFile(buf, 'w') as zf:
with open(os.path.join(report.path, THEME_METADATA), 'rb') as f:
zf.writestr(prefix + '/' + THEME_METADATA, f.read())
zf.writestr(prefix + '/' + THEME_COVER, create_cover(report, darkbg=theme_metadata.get('color_palette') == 'dark'))
zf.writestr(prefix + '/' + 'icons.zip.xz', compressed, compression=ZIP_STORED)
if progress is not None:
progress(next(num), _('Finished'))
return buf.getvalue(), prefix, icon_zip_data
def create_theme(folder=None, parent=None):
if folder is None:
folder = choose_dir(parent, 'create-icon-theme-folder', _(
'Choose a folder from which to read the icons'))
if not folder:
return
report = read_theme_from_folder(folder)
d = ThemeCreateDialog(parent, report)
if d.exec() != QDialog.DialogCode.Accepted:
return
use_in_calibre = d.use_in_calibre.isChecked()
theme = d.metadata
d.save_metadata()
d = Compress(d.report, theme, parent=parent)
d.exec()
if d.wasCanceled() or d.raw is None:
return
raw, prefix = d.raw, d.prefix
dest = choose_save_file(parent, 'create-icon-theme-dest', _(
'Choose destination for icon theme'),
[(_('ZIP files'), ['zip'])], initial_filename=prefix + '.zip')
if not dest:
return
with open(dest, 'wb') as f:
f.write(raw)
if use_in_calibre:
path = icon_resource_manager.user_theme_resource_file(theme['color_palette'])
install_icon_theme(theme, d.icon_zip_data, path, theme['color_palette'])
icon_resource_manager.register_user_resource_files()
icon_resource_manager.set_theme()
# }}}
# Choose Theme {{{
def download_cover(cover_url, etag=None, cached=b''):
url = BASE_URL + cover_url
headers = {}
if etag:
if etag[0] != '"':
etag = '"' + etag + '"'
headers['If-None-Match'] = etag
try:
response = get_https_resource_securely(url, headers=headers, get_response=True)
cached = response.read()
etag = response.getheader('ETag', None) or None
return cached, etag
except HTTPError as e:
if etag and e.code == http_client.NOT_MODIFIED:
return cached, etag
raise
def get_cover(metadata):
cdir = os.path.join(cache_dir(), 'icon-theme-covers')
try:
os.makedirs(cdir)
except OSError as e:
if e.errno != errno.EEXIST:
raise
def path(ext):
return os.path.join(cdir, metadata['name'] + '.' + ext)
etag_file, cover_file = map(path, 'etag jpg'.split())
def safe_read(path):
with suppress(FileNotFoundError):
with open(path, 'rb') as f:
return f.read()
return b''
etag, cached = safe_read(etag_file), safe_read(cover_file)
etag = etag.decode('utf-8')
cached, etag = download_cover(metadata['cover-url'], etag, cached)
if cached:
aname = cover_file + '.atomic'
with open(aname, 'wb') as f:
f.write(cached)
atomic_rename(aname, cover_file)
if etag:
with open(etag_file, 'wb') as f:
f.write(as_bytes(etag))
return cached or b''
def get_covers(themes, dialog, num_of_workers=8):
items = Queue()
for i in themes:
items.put(i)
def callback(metadata, x):
if not sip.isdeleted(dialog) and not dialog.dialog_closed:
dialog.cover_downloaded.emit(metadata, x)
def run():
while True:
try:
metadata = items.get_nowait()
except Empty:
return
try:
cdata = get_cover(metadata)
except Exception as e:
import traceback
traceback.print_exc()
callback(metadata, e)
else:
callback(metadata, cdata)
for w in range(num_of_workers):
t = Thread(name='IconThemeCover', target=run)
t.daemon = True
t.start()
class Delegate(QStyledItemDelegate):
SPACING = 10
def __init__(self, *a):
super().__init__(*a)
self.static_text_cache = {}
def sizeHint(self, option, index):
return QSize(COVER_SIZE[0] * 2, COVER_SIZE[1] + 2 * self.SPACING)
def paint(self, painter, option, index):
QStyledItemDelegate.paint(self, painter, option, empty_index)
theme = index.data(Qt.ItemDataRole.UserRole)
if not theme:
return
painter.save()
pixmap = index.data(Qt.ItemDataRole.DecorationRole)
if pixmap and not pixmap.isNull():
rect = option.rect.adjusted(0, self.SPACING, COVER_SIZE[0] - option.rect.width(), - self.SPACING)
painter.drawPixmap(rect, pixmap)
if option.state & QStyle.StateFlag.State_Selected:
painter.setPen(QPen(QApplication.instance().palette().highlightedText().color()))
bottom = option.rect.bottom() - 2
painter.drawLine(0, bottom, option.rect.right(), bottom)
visit = _('Right click to visit theme homepage') if theme.get('url') else ''
text = _('''\
<p><b><big>{title}</big></b><p>
<p>by <i>{author}</i> with <b>{number}</b> icons [{size}]</p>
<p>{description}</p>
<p>Version: {version} Number of users: {usage:n}</p>
<p><i>{visit}</i></p>
''').format(title=escape(theme.get('title') or _('Unknown')), author=escape(theme.get('author', _('Unknown'))),
number=theme.get('number', 0), description=escape(theme.get('description', '')),
size=human_readable(theme.get('compressed-size', 0)), version=theme.get('version', 1),
usage=theme.get('usage', 0), visit=escape(visit)
)
st = self.static_text_cache.get(text)
if st is None:
self.static_text_cache[text] = st = QStaticText(text)
painter.drawStaticText(COVER_SIZE[0] + self.SPACING, option.rect.top() + self.SPACING, st)
painter.restore()
class DownloadProgress(ProgressDialog):
ds = pyqtSignal(object)
acc = pyqtSignal()
rej = pyqtSignal()
def __init__(self, parent, size):
ProgressDialog.__init__(self, _('Downloading icons...'), _(
'Downloading icons, please wait...'), max=size, parent=parent, icon='download_metadata.png')
self.ds.connect(self.bar.setValue, type=Qt.ConnectionType.QueuedConnection)
self.acc.connect(self.accept, type=Qt.ConnectionType.QueuedConnection)
self.rej.connect(self.reject, type=Qt.ConnectionType.QueuedConnection)
def downloaded(self, byte_count):
self.ds.emit(byte_count)
def queue_accept(self):
self.acc.emit()
def queue_reject(self):
self.rej.emit()
@lru_cache(maxsize=2)
def default_theme():
dc = 0
for name in walk(P('images')):
if name.endswith('.png') and '/textures/' not in name.replace(os.sep, '/'):
dc += 1
p = QPixmap()
p.loadFromData(create_cover())
return {
'name': 'default', 'title': _('Default icons'), 'color_palette': 'any',
'user_msg': _('Use the calibre default icons'),
'usage': 3_000_000, 'author': 'Kovid Goyal', 'number': dc,
'cover-pixmap': p, 'compressed-size': os.path.getsize(P('icons.rcc', allow_user_override=False))
}
def is_default_theme(t):
return t.get('name') == default_theme()['name']
class ChooseThemeWidget(QWidget):
sync_sorts = pyqtSignal(int)
def __init__(self, for_theme='any', parent=None):
super().__init__(parent)
if parent:
self.sync_sorts.connect(parent.sync_sorts)
self.vl = vl = QVBoxLayout(self)
self.for_theme = for_theme
if self.for_theme == 'any':
msg = _('Choose an icon theme below. It will be used for both light and dark color'
' themes unless a color specific theme is chosen in one of the other tabs.')
elif self.for_theme == 'light':
msg = _('Choose an icon theme below. It will be used preferentially for light color themes.'
' If the default is chosen then the theme for "light and dark" will be used.')
elif self.for_theme == 'dark':
msg = _('Choose an icon theme below. It will be used preferentially for dark color themes.'
' If the default is chosen then the theme for "light and dark" will be used.')
self.currently_installed_theme_metadata = icon_resource_manager.user_icon_theme_metadata(for_theme)
self.currently_installed_theme_name = self.currently_installed_theme_metadata.get('name')
self.msg = la = QLabel(msg)
la.setWordWrap(True)
vl.addWidget(la)
self.sort_by = sb = QComboBox(self)
self.hl = hl = QHBoxLayout()
vl.addLayout(hl)
self.sl = sl = QLabel(_('&Sort by:'))
sl.setBuddy(sb)
hl.addWidget(sl), hl.addWidget(sb), hl.addStretch(10)
sb.addItems([_('Number of icons'), _('Popularity'), _('Name'),])
sb.setEditable(False), sb.setCurrentIndex(gprefs.get('choose_icon_theme_sort_by', 1))
sb.setFocusPolicy(Qt.FocusPolicy.NoFocus)
sb.currentIndexChanged.connect(self.sort_by_changed)
self.theme_list = tl = QListWidget(self)
vl.addWidget(tl)
tl.setVerticalScrollMode(QAbstractItemView.ScrollMode.ScrollPerPixel)
self.delegate = Delegate(tl)
tl.setItemDelegate(self.delegate)
tl.itemPressed.connect(self.item_clicked)
def sort_by_changed(self):
self.re_sort()
gprefs.set('choose_icon_theme_sort_by', self.sort_by.currentIndex())
self.sync_sorts.emit(self.sort_by.currentIndex())
def sync_sort(self, idx):
if self.sort_by.currentIndex() != idx:
self.blockSignals(True)
self.sort_by.setCurrentIndex(idx)
self.blockSignals(False)
def item_clicked(self, item):
if QApplication.mouseButtons() & Qt.MouseButton.RightButton:
theme = item.data(Qt.ItemDataRole.UserRole) or {}
url = theme.get('url')
if url:
safe_open_url(url)
@property
def sort_on(self):
return {0:'number', 1:'usage', 2:'title'}[self.sort_by.currentIndex()]
def __iter__(self):
for i in range(self.theme_list.count()):
yield self.theme_list.item(i)
def item_from_name(self, name):
for item in self:
if item.data(Qt.ItemDataRole.UserRole)['name'] == name:
return item
def set_cover(self, name, pixmap):
item = self.item_from_name(name)
if item is not None:
item.setData(Qt.ItemDataRole.DecorationRole, pixmap)
def show_themes(self, themes):
self.themes = [default_theme()] + [t for t in themes if t.get('color_palette', 'any') in (self.for_theme, 'any')]
self.re_sort()
self.set_current_theme(self.currently_installed_theme_name)
def re_sort(self):
ct = self.current_theme
self.themes.sort(key=lambda x:sort_key(x.get('title', '')))
field = self.sort_on
if field == 'number':
self.themes.sort(key=lambda x:x.get('number', 0), reverse=True)
elif field == 'usage':
self.themes.sort(key=lambda x:x.get('usage', 0), reverse=True)
self.theme_list.clear()
for theme in self.themes:
i = QListWidgetItem(theme.get('title', '') + ' {} {}'.format(theme.get('number'), theme.get('usage', 0)), self.theme_list)
i.setData(Qt.ItemDataRole.UserRole, theme)
if 'cover-pixmap' in theme:
i.setData(Qt.ItemDataRole.DecorationRole, theme['cover-pixmap'])
if ct:
self.set_current_theme(ct.get('name', ''))
@property
def current_theme(self):
ci = self.theme_list.currentItem()
if ci:
return ci.data(Qt.ItemDataRole.UserRole)
return default_theme()
def set_current_theme(self, name):
if not hasattr(self, "themes"):
return False
for i, t in enumerate(self.themes):
if t.get('name') == name:
self.theme_list.setCurrentRow(i, QItemSelectionModel.SelectionFlag.SelectCurrent | QItemSelectionModel.SelectionFlag.Clear)
self.theme_list.scrollToItem(self.theme_list.currentItem())
return True
return False
class ChooseTheme(Dialog):
cover_downloaded = pyqtSignal(object, object)
themes_downloaded = pyqtSignal()
def __init__(self, parent=None):
Dialog.__init__(self, _('Choose an icon theme'), 'choose-icon-theme-dialog', parent)
self.finished.connect(self.on_finish)
self.dialog_closed = False
self.themes_downloaded.connect(self.show_themes, type=Qt.ConnectionType.QueuedConnection)
self.cover_downloaded.connect(self.set_cover, type=Qt.ConnectionType.QueuedConnection)
self.keep_downloading = True
self.commit_changes = None
def on_finish(self):
self.dialog_closed = True
def sizeHint(self):
h = self.screen().availableSize().height()
return QSize(900, h - 75)
def setup_ui(self):
self.vl = vl = QVBoxLayout(self)
self.stack = l = QStackedLayout()
self.pi = pi = ProgressIndicator(self, 256)
vl.addLayout(l), vl.addWidget(self.bb)
self.restore_defs_button = b = self.bb.addButton(_('Restore &default icons'), QDialogButtonBox.ButtonRole.ActionRole)
b.clicked.connect(self.restore_defaults)
b.setIcon(QIcon.ic('view-refresh.png'))
self.c = c = QWidget(self)
self.c.v = v = QVBoxLayout(self.c)
v.addStretch(), v.addWidget(pi, 0, Qt.AlignmentFlag.AlignCenter)
self.wait_msg = m = QLabel(self)
v.addWidget(m, 0, Qt.AlignmentFlag.AlignCenter), v.addStretch()
f = m.font()
f.setBold(True), f.setPointSize(28), m.setFont(f)
self.start_spinner()
l.addWidget(c)
self.tabs = QTabWidget(self)
l.addWidget(self.tabs)
self.all_colors = ChooseThemeWidget(parent=self)
self.tabs.addTab(self.all_colors, _('For light and dark'))
self.light_colors = ChooseThemeWidget(for_theme='light', parent=self)
self.tabs.addTab(self.light_colors, _('For light only'))
self.dark_colors = ChooseThemeWidget(for_theme='dark', parent=self)
self.tabs.addTab(self.dark_colors, _('For dark only'))
self.tabs.setCurrentIndex(gprefs.get('choose_icon_theme_initial_tab', 0))
self.tabs.currentChanged.connect(lambda idx: gprefs.set('choose_icon_theme_initial_tab', idx))
t = Thread(name='GetIconThemes', target=self.get_themes)
t.daemon = True
t.start()
def sync_sorts(self, idx):
for tab in (self.tabs.widget(i) for i in range(self.tabs.count())):
tab.sync_sort(idx)
def start_spinner(self, msg=None):
self.pi.startAnimation()
self.stack.setCurrentIndex(0)
self.wait_msg.setText(msg or _('Downloading, please wait...'))
def end_spinner(self):
self.pi.stopAnimation()
self.stack.setCurrentIndex(1)
def get_themes(self):
self.usage = {}
def get_usage():
try:
self.usage = json.loads(bz2.decompress(get_https_resource_securely(BASE_URL + '/usage.json.bz2')))
except Exception:
import traceback
traceback.print_exc()
t = Thread(name='IconThemeUsage', target=get_usage)
t.daemon = True
t.start()
try:
self.themes = json.loads(bz2.decompress(get_https_resource_securely(BASE_URL + '/themes.json.bz2')))
except Exception:
import traceback
self.themes = traceback.format_exc()
t.join()
if not sip.isdeleted(self):
self.themes_downloaded.emit()
def show_themes(self):
self.end_spinner()
if not isinstance(self.themes, list):
error_dialog(self, _('Failed to download list of themes'), _(
'Failed to download list of themes, click "Show details" for more information'),
det_msg=self.themes, show=True)
self.reject()
return
self.setWindowTitle(_('Choose from {} available icon themes').format(len(self.themes)))
for theme in self.themes:
theme['usage'] = self.usage.get(theme['name'], 0)
for tab in (self.tabs.widget(i) for i in range(self.tabs.count())):
tab.show_themes(self.themes)
self.tabs.currentWidget().theme_list.setFocus(Qt.FocusReason.OtherFocusReason)
get_covers(self.themes, self)
def set_cover(self, theme, cdata):
theme['cover-pixmap'] = p = QPixmap()
dpr = self.devicePixelRatioF()
if isinstance(cdata, bytes):
p.loadFromData(cdata)
p.setDevicePixelRatio(dpr)
for tab in (self.tabs.widget(i) for i in range(self.tabs.count())):
tab.set_cover(theme['name'], p)
def restore_defaults(self):
for tab in (self.tabs.widget(i) for i in range(self.tabs.count())):
tab.set_current_theme(default_theme()['name'])
def accept(self):
themes_to_download = {}
themes_to_remove = set()
for tab in (self.tabs.widget(i) for i in range(self.tabs.count())):
t = tab.current_theme
if is_default_theme(t):
themes_to_remove.add(tab.for_theme)
else:
themes_to_download[t['name']] = t
t.setdefault('for_themes', []).append(tab.for_theme)
self.keep_downloading = True
self.err_traceback = None
def download():
dc = 0
for theme in themes_to_download.values():
buf = BytesIO()
try:
url = BASE_URL + theme['icons-url']
response = get_https_resource_securely(url, get_response=True)
while self.keep_downloading:
raw = response.read(1024)
if not raw:
break
buf.write(raw)
dc += len(raw)
d.downloaded(dc)
except Exception:
import traceback
self.err_traceback = traceback.format_exc()
d.queue_reject()
return
import lzma
data = lzma.decompress(buf.getvalue())
theme['buf'] = BytesIO(data)
d.queue_accept()
if themes_to_download:
size = sum(t['compressed-size'] for t in themes_to_download.values())
d = DownloadProgress(self, size)
d.canceled_signal.connect(lambda : setattr(self, 'keep_downloading', False))
t = Thread(name='DownloadIconTheme', target=download)
t.daemon = True
t.start()
ret = d.exec()
if self.err_traceback:
return error_dialog(self, _('Download failed'), _(
'Failed to download icon themes, click "Show details" for more information.'), show=True, det_msg=self.err_traceback)
if ret == QDialog.DialogCode.Rejected or not self.keep_downloading or d.canceled:
return
self.commit_changes = CommitChanges(tuple(themes_to_download.values()), themes_to_remove)
return super().accept()
@property
def new_theme_title(self):
if QApplication.instance().is_dark_theme:
order = 'dark', 'any', 'light'
else:
order = 'light', 'any', 'dark'
tm = {tab.for_theme: tab for tab in (self.tabs.widget(i) for i in range(self.tabs.count()))}
for x in order:
tab = tm[x]
t = tab.current_theme
if not is_default_theme(t):
return t['title']
# }}}
class CommitChanges:
def __init__(self, downloaded_themes, themes_to_remove):
self.downloaded_themes = downloaded_themes
self.themes_to_remove = themes_to_remove
def __call__(self):
for x in self.themes_to_remove:
icon_resource_manager.remove_user_theme(x)
for theme in self.downloaded_themes:
for x in theme['for_themes']:
icon_resource_manager.remove_user_theme(x)
path = icon_resource_manager.user_theme_resource_file(x)
t = {k: theme[k] for k in 'name title version'.split()}
t['color_palette'] = theme.get('color_palette', 'any')
install_icon_theme(t, theme['buf'], path, x)
icon_resource_manager.register_user_resource_files()
icon_resource_manager.set_theme()
def install_icon_theme(theme, f, rcc_path, for_theme):
from calibre.utils.rcc import compile_icon_dir_as_themes
with ZipFile(f) as zf, tempfile.TemporaryDirectory() as tdir:
zf.extractall(tdir)
with open(os.path.join(tdir, 'metadata.json'), 'w') as f:
json.dump(theme, f)
inherits = 'calibre-default' if for_theme == 'any' else f'calibre-default-{for_theme}'
compile_icon_dir_as_themes(
tdir, rcc_path, theme_name=f'calibre-user-{for_theme}', inherits=inherits, for_theme=for_theme)
if __name__ == '__main__':
from calibre.gui2 import Application
app = Application([])
create_theme(sys.argv[-1])
# d = ChooseTheme()
# if d.exec() == QDialog.DialogCode.Accepted and d.commit_changes is not None:
# d.commit_changes()
del app
| 37,834 | Python | .py | 876 | 34.192922 | 139 | 0.612428 | kovidgoyal/calibre | 19,243 | 2,250 | 4 | GPL-3.0 | 9/5/2024, 5:13:50 PM (Europe/Amsterdam) |
26,683 | jobs.py | kovidgoyal_calibre/src/calibre/gui2/jobs.py | #!/usr/bin/env python
__license__ = 'GPL v3'
__copyright__ = '2008, Kovid Goyal kovid@kovidgoyal.net'
__docformat__ = 'restructuredtext en'
'''
Job management.
'''
import time
from qt.core import (
QAbstractItemDelegate,
QAbstractTableModel,
QAction,
QApplication,
QByteArray,
QCoreApplication,
QDialog,
QDialogButtonBox,
QEvent,
QHBoxLayout,
QIcon,
QItemSelectionModel,
QLabel,
QModelIndex,
QPlainTextEdit,
QSize,
QSizePolicy,
QSortFilterProxyModel,
QStyle,
QStyleOption,
QStyleOptionProgressBar,
QStylePainter,
Qt,
QTextBrowser,
QTimer,
QToolTip,
QVBoxLayout,
QWidget,
pyqtSignal,
)
from calibre import __appname__, as_unicode, strftime
from calibre.constants import isbsd, islinux
from calibre.db.utils import human_readable_interval
from calibre.gui2 import Dispatcher, config, error_dialog, gprefs, question_dialog
from calibre.gui2.device import DeviceJob
from calibre.gui2.dialogs.jobs_ui import Ui_JobsDialog
from calibre.gui2.progress_indicator import ProgressIndicator
from calibre.gui2.threaded_jobs import ThreadedJob, ThreadedJobServer
from calibre.gui2.widgets2 import Dialog
from calibre.startup import connect_lambda
from calibre.utils.icu import lower
from calibre.utils.ipc.job import ParallelJob
from calibre.utils.ipc.server import Server
from calibre.utils.localization import ngettext
from calibre.utils.search_query_parser import ParseException, SearchQueryParser
from polyglot.queue import Empty, Queue
class AdaptSQP(SearchQueryParser):
def __init__(self, *args, **kwargs):
pass
class JobManager(QAbstractTableModel, AdaptSQP): # {{{
job_added = pyqtSignal(int)
job_done = pyqtSignal(int)
def __init__(self):
self.header_titles = _('Job'), _('Status'), _('Progress'), _('Running time'), _('Start time'),
QAbstractTableModel.__init__(self)
SearchQueryParser.__init__(self, ['all'])
self.wait_icon = (QIcon.ic('jobs.png'))
self.running_icon = (QIcon.ic('exec.png'))
self.error_icon = (QIcon.ic('dialog_error.png'))
self.done_icon = (QIcon.ic('ok.png'))
self.jobs = []
self.add_job = Dispatcher(self._add_job)
self.server = Server(limit=config['worker_limit']//2,
enforce_cpu_limit=config['enforce_cpu_limit'])
self.threaded_server = ThreadedJobServer()
self.changed_queue = Queue()
self.timer = QTimer(self)
self.timer.timeout.connect(self.update, type=Qt.ConnectionType.QueuedConnection)
self.timer.start(1000)
def columnCount(self, parent=QModelIndex()):
return 5
def rowCount(self, parent=QModelIndex()):
return len(self.jobs)
def headerData(self, section, orientation, role):
if role == Qt.ItemDataRole.DisplayRole:
if orientation == Qt.Orientation.Horizontal:
try:
return self.header_titles[section]
except Exception:
pass
return str(section + 1)
def show_tooltip(self, arg):
widget, pos = arg
QToolTip.showText(pos, self.get_tooltip())
def get_tooltip(self):
running_jobs = [j for j in self.jobs if j.run_state == j.RUNNING]
waiting_jobs = [j for j in self.jobs if j.run_state == j.WAITING]
lines = [ngettext('There is a running job:', 'There are {} running jobs:', len(running_jobs)).format(len(running_jobs))]
for job in running_jobs:
desc = job.description
if not desc:
desc = _('Unknown job')
p = 100. if job.is_finished else job.percent
lines.append('%s: %.0f%% done'%(desc, p))
l = ngettext('There is a waiting job', 'There are {} waiting jobs', len(waiting_jobs)).format(len(waiting_jobs))
lines.extend(['', l])
for job in waiting_jobs:
desc = job.description
if not desc:
desc = _('Unknown job')
lines.append(desc)
return '\n'.join(['calibre', '']+ lines)
def data(self, index, role):
try:
if role not in (Qt.ItemDataRole.DisplayRole, Qt.ItemDataRole.DecorationRole):
return None
row, col = index.row(), index.column()
job = self.jobs[row]
if role == Qt.ItemDataRole.DisplayRole:
if col == 0:
desc = job.description
if not desc:
desc = _('Unknown job')
return (desc)
if col == 1:
return (job.status_text)
if col == 2:
p = 100. if job.is_finished else job.percent
return (p)
if col == 3:
rtime = job.running_time
if rtime is None:
return None
return human_readable_interval(rtime)
if col == 4 and job.start_time is not None:
return (strftime('%H:%M -- %d %b', time.localtime(job.start_time)))
if role == Qt.ItemDataRole.DecorationRole and col == 0:
state = job.run_state
if state == job.WAITING:
return self.wait_icon
if state == job.RUNNING:
return self.running_icon
if job.killed or job.failed:
return self.error_icon
return self.done_icon
except:
import traceback
traceback.print_exc()
return None
def update(self):
try:
self._update()
except BaseException:
import traceback
traceback.print_exc()
def _update(self):
# Update running time
for i, j in enumerate(self.jobs):
if j.run_state == j.RUNNING:
idx = self.index(i, 3)
self.dataChanged.emit(idx, idx)
# Update parallel jobs
jobs = set()
while True:
try:
jobs.add(self.server.changed_jobs_queue.get_nowait())
except Empty:
break
# Update device jobs
while True:
try:
jobs.add(self.changed_queue.get_nowait())
except Empty:
break
# Update threaded jobs
while True:
try:
jobs.add(self.threaded_server.changed_jobs.get_nowait())
except Empty:
break
if jobs:
needs_reset = False
for job in jobs:
orig_state = job.run_state
job.update()
if orig_state != job.run_state:
needs_reset = True
if job.is_finished:
self.job_done.emit(len(self.unfinished_jobs()))
if needs_reset:
self.modelAboutToBeReset.emit()
self.jobs.sort()
self.modelReset.emit()
else:
for job in jobs:
idx = self.jobs.index(job)
self.dataChanged.emit(
self.index(idx, 0), self.index(idx, 3))
# Kill parallel jobs that have gone on too long
try:
wmax_time = gprefs['worker_max_time'] * 60
except:
wmax_time = 0
if wmax_time > 0:
for job in self.jobs:
if isinstance(job, ParallelJob):
rtime = job.running_time
if (rtime is not None and rtime > wmax_time and
job.duration is None):
job.timed_out = True
self.server.kill_job(job)
def _add_job(self, job):
self.modelAboutToBeReset.emit()
self.jobs.append(job)
self.jobs.sort()
self.job_added.emit(len(self.unfinished_jobs()))
self.modelReset.emit()
def done_jobs(self):
return [j for j in self.jobs if j.is_finished]
def unfinished_jobs(self):
return [j for j in self.jobs if not j.is_finished]
def row_to_job(self, row):
return self.jobs[row]
def rows_to_jobs(self, rows):
return [self.jobs[row] for row in rows]
def has_device_jobs(self, queued_also=False):
for job in self.jobs:
if isinstance(job, DeviceJob):
if job.duration is None: # Running or waiting
if (job.is_running or queued_also):
return True
return False
def has_jobs(self):
for job in self.jobs:
if job.is_running:
return True
return False
def run_job(self, done, name, args=[], kwargs={},
description='', core_usage=1):
job = ParallelJob(name, description, done, args=args, kwargs=kwargs)
job.core_usage = core_usage
self.add_job(job)
self.server.add_job(job)
return job
def run_threaded_job(self, job):
self.add_job(job)
self.threaded_server.add_job(job)
def launch_gui_app(self, name, args=(), kwargs=None, description=''):
job = ParallelJob(name, description, lambda x: x,
args=list(args), kwargs=kwargs or {})
self.server.run_job(job, gui=True, redirect_output=False)
def _kill_job(self, job):
if isinstance(job, ParallelJob):
self.server.kill_job(job)
elif isinstance(job, ThreadedJob):
self.threaded_server.kill_job(job)
else:
job.kill_on_start = True
def hide_jobs(self, rows):
for r in rows:
self.jobs[r].hidden_in_gui = True
for r in rows:
self.dataChanged.emit(self.index(r, 0), self.index(r, 0))
def show_hidden_jobs(self):
for j in self.jobs:
j.hidden_in_gui = False
for r in range(len(self.jobs)):
self.dataChanged.emit(self.index(r, 0), self.index(r, 0))
def kill_job(self, job, view):
if isinstance(job, DeviceJob):
return error_dialog(view, _('Cannot kill job'),
_('Cannot kill jobs that communicate with the device')).exec()
if job.duration is not None:
return error_dialog(view, _('Cannot kill job'),
_('Job has already run')).exec()
if not getattr(job, 'killable', True):
return error_dialog(view, _('Cannot kill job'),
_('This job cannot be stopped'), show=True)
self._kill_job(job)
def kill_multiple_jobs(self, jobs, view):
devjobs = [j for j in jobs if isinstance(j, DeviceJob)]
if devjobs:
error_dialog(view, _('Cannot kill job'),
_('Cannot kill jobs that communicate with the device')).exec()
jobs = [j for j in jobs if not isinstance(j, DeviceJob)]
jobs = [j for j in jobs if j.duration is None]
unkillable = [j for j in jobs if not getattr(j, 'killable', True)]
if unkillable:
names = '\n'.join(as_unicode(j.description) for j in unkillable)
error_dialog(view, _('Cannot kill job'),
_('Some of the jobs cannot be stopped. Click "Show details"'
' to see the list of unstoppable jobs.'), det_msg=names,
show=True)
jobs = [j for j in jobs if getattr(j, 'killable', True)]
jobs = [j for j in jobs if j.duration is None]
for j in jobs:
self._kill_job(j)
def kill_all_jobs(self):
for job in self.jobs:
if (isinstance(job, DeviceJob) or job.duration is not None or
not getattr(job, 'killable', True)):
continue
self._kill_job(job)
def terminate_all_jobs(self):
self.server.killall()
for job in self.jobs:
if (isinstance(job, DeviceJob) or job.duration is not None or
not getattr(job, 'killable', True)):
continue
if not isinstance(job, ParallelJob):
self._kill_job(job)
def universal_set(self):
return {i for i, j in enumerate(self.jobs) if not getattr(j,
'hidden_in_gui', False)}
def get_matches(self, location, query, candidates=None):
if candidates is None:
candidates = self.universal_set()
ans = set()
if not query:
return ans
query = lower(query)
for j in candidates:
job = self.jobs[j]
if job.description and query in lower(job.description):
ans.add(j)
return ans
def find(self, query):
query = query.strip()
rows = self.parse(query)
return rows
# }}}
class FilterModel(QSortFilterProxyModel): # {{{
search_done = pyqtSignal(object)
def __init__(self, parent):
QSortFilterProxyModel.__init__(self, parent)
self.search_filter = None
def filterAcceptsRow(self, source_row, source_parent):
if (self.search_filter is not None and source_row not in
self.search_filter):
return False
m = self.sourceModel()
try:
job = m.row_to_job(source_row)
except:
return False
return not getattr(job, 'hidden_in_gui', False)
def find(self, query):
ok = True
val = None
if query:
try:
val = self.sourceModel().parse(query)
except ParseException:
ok = False
self.search_filter = val
self.beginResetModel()
self.search_done.emit(ok)
self.endResetModel()
# }}}
# Jobs UI {{{
class ProgressBarDelegate(QAbstractItemDelegate): # {{{
def sizeHint(self, option, index):
return QSize(120, 30)
def paint(self, painter, option, index):
opts = QStyleOptionProgressBar()
opts.rect = option.rect
opts.minimum = 1
opts.maximum = 100
opts.textVisible = True
try:
percent = int(index.model().data(index, Qt.ItemDataRole.DisplayRole))
except (TypeError, ValueError):
percent = 0
opts.progress = percent
opts.text = (_('Unavailable') if percent == 0 else '%d%%'%percent)
QApplication.style().drawControl(QStyle.ControlElement.CE_ProgressBar, opts, painter)
# }}}
class DetailView(Dialog): # {{{
def __init__(self, parent, job):
self.job = job
self.html_view = hasattr(job, 'html_details') and not getattr(job, 'ignore_html_details', False)
Dialog.__init__(self, job.description, 'job-detail-view-dialog', parent)
def sizeHint(self):
return QSize(700, 500)
@property
def plain_text(self):
if self.html_view:
return self.tb.toPlainText()
return self.log.toPlainText()
def copy_to_clipboard(self):
QApplication.instance().clipboard().setText(self.plain_text)
def setup_ui(self):
self.l = l = QVBoxLayout(self)
if self.html_view:
self.tb = w = QTextBrowser(self)
else:
self.log = w = QPlainTextEdit(self)
w.setReadOnly(True), w.setLineWrapMode(QPlainTextEdit.LineWrapMode.NoWrap)
l.addWidget(w)
l.addWidget(self.bb)
self.bb.clear(), self.bb.setStandardButtons(QDialogButtonBox.StandardButton.Close)
self.copy_button = b = self.bb.addButton(_('&Copy to clipboard'), QDialogButtonBox.ButtonRole.ActionRole)
b.setIcon(QIcon.ic('edit-copy.png'))
b.clicked.connect(self.copy_to_clipboard)
self.next_pos = 0
self.update()
self.timer = QTimer(self)
self.timer.timeout.connect(self.update)
self.timer.start(1000)
if not self.html_view:
v = self.log.verticalScrollBar()
v.setValue(v.maximum())
def update(self):
if self.html_view:
html = self.job.html_details
if len(html) > self.next_pos:
self.next_pos = len(html)
self.tb.setHtml(
'<pre style="font-family:monospace">%s</pre>'%html)
else:
f = self.job.log_file
f.seek(self.next_pos)
more = f.read()
self.next_pos = f.tell()
if more:
v = self.log.verticalScrollBar()
atbottom = v.value() >= v.maximum() - 1
self.log.appendPlainText(more.decode('utf-8', 'replace'))
if atbottom:
v.setValue(v.maximum())
# }}}
class JobsButton(QWidget): # {{{
tray_tooltip_updated = pyqtSignal(object)
def __init__(self, parent=None):
QWidget.__init__(self, parent)
self.num_jobs = 0
self.mouse_over = False
self.pi = ProgressIndicator(self, self.style().pixelMetric(QStyle.PixelMetric.PM_ToolBarIconSize))
self.pi.setVisible(False)
self._jobs = QLabel('')
self._jobs.mouseReleaseEvent = self.mouseReleaseEvent
self.update_label()
self.shortcut = 'Alt+Shift+J'
self.l = l = QHBoxLayout(self)
l.setSpacing(3)
l.addWidget(self.pi)
l.addWidget(self._jobs)
m = self.style().pixelMetric(QStyle.PixelMetric.PM_DefaultFrameWidth)
self.layout().setContentsMargins(m, m, m, m)
self._jobs.setSizePolicy(QSizePolicy.Policy.Minimum, QSizePolicy.Policy.Minimum)
self.setCursor(Qt.CursorShape.PointingHandCursor)
b = _('Click to see list of jobs')
self.setToolTip(b + _(' [Alt+Shift+J]'))
self.action_toggle = QAction(b, parent)
parent.addAction(self.action_toggle)
self.action_toggle.triggered.connect(self.toggle)
if hasattr(parent, 'keyboard'):
parent.keyboard.register_shortcut('toggle jobs list', _('Show/hide the Jobs List'), default_keys=(self.shortcut,), action=self.action_toggle)
def update_label(self):
n = self.jobs()
prefix = '<b>' if n > 0 else ''
self._jobs.setText(prefix + ' ' + _('Jobs:') + f' {n} ')
def event(self, ev):
m = None
et = ev.type()
if et == QEvent.Type.Enter:
m = True
elif et == QEvent.Type.Leave:
m = False
if m is not None and m != self.mouse_over:
self.mouse_over = m
self.update()
return QWidget.event(self, ev)
def initialize(self, jobs_dialog, job_manager):
self.jobs_dialog = jobs_dialog
job_manager.job_added.connect(self.job_added)
job_manager.job_done.connect(self.job_done)
self.jobs_dialog.addAction(self.action_toggle)
def mouseReleaseEvent(self, event):
self.toggle()
def toggle(self, *args):
if self.jobs_dialog.isVisible():
self.jobs_dialog.hide()
else:
self.jobs_dialog.show()
@property
def is_running(self):
return self.pi.isAnimated()
def start(self):
self.pi.startAnimation()
self.pi.setVisible(True)
def stop(self):
self.pi.stopAnimation()
self.pi.setVisible(False)
def jobs(self):
return self.num_jobs
def tray_tooltip(self, num=0):
if num == 0:
text = _('No running jobs')
elif num == 1:
text = _('One running job')
else:
text = _('%d running jobs') % num
if not (islinux or isbsd):
text = 'calibre: ' + text
return text
def job_added(self, nnum):
self.num_jobs = nnum
self.update_label()
self.start()
self.tray_tooltip_updated.emit(self.tray_tooltip(nnum))
def job_done(self, nnum):
self.num_jobs = nnum
self.update_label()
if nnum == 0:
self.no_more_jobs()
self.tray_tooltip_updated.emit(self.tray_tooltip(nnum))
def no_more_jobs(self):
if self.is_running:
self.stop()
QCoreApplication.instance().alert(self, 5000)
def paintEvent(self, ev):
if self.mouse_over:
p = QStylePainter(self)
tool = QStyleOption()
tool.initFrom(self)
tool.rect = self.rect()
tool.state = QStyle.StateFlag.State_Raised | QStyle.StateFlag.State_Active | QStyle.StateFlag.State_MouseOver
p.drawPrimitive(QStyle.PrimitiveElement.PE_PanelButtonTool, tool)
p.end()
QWidget.paintEvent(self, ev)
# }}}
class JobsDialog(QDialog, Ui_JobsDialog):
def __init__(self, window, model):
QDialog.__init__(self, window)
Ui_JobsDialog.__init__(self)
self.setupUi(self)
self.model = model
self.proxy_model = FilterModel(self)
self.proxy_model.setSourceModel(self.model)
self.proxy_model.search_done.connect(self.search.search_done)
self.jobs_view.setModel(self.proxy_model)
self.setWindowModality(Qt.WindowModality.NonModal)
self.setWindowTitle(__appname__ + _(' - Jobs'))
self.details_button.clicked.connect(self.show_details)
self.kill_button.clicked.connect(self.kill_job)
self.stop_all_jobs_button.clicked.connect(self.kill_all_jobs)
self.pb_delegate = ProgressBarDelegate(self)
self.jobs_view.setItemDelegateForColumn(2, self.pb_delegate)
self.jobs_view.doubleClicked.connect(self.show_job_details)
self.jobs_view.horizontalHeader().setSectionsMovable(True)
self.hide_button.clicked.connect(self.hide_selected)
self.hide_all_button.clicked.connect(self.hide_all)
self.show_button.clicked.connect(self.show_hidden)
self.search.initialize('jobs_search_history',
help_text=_('Search for a job by name'))
self.search.search.connect(self.find)
connect_lambda(self.search_button.clicked, self, lambda self: self.find(self.search.current_text))
self.restore_state()
def restore_state(self):
try:
self.restore_geometry(gprefs, 'jobs_dialog_geometry')
state = gprefs.get('jobs view column layout3', None)
if state is not None:
self.jobs_view.horizontalHeader().restoreState(QByteArray(state))
except Exception:
import traceback
traceback.print_exc()
idx = self.jobs_view.model().index(0, 0)
if idx.isValid():
sm = self.jobs_view.selectionModel()
sm.select(idx, QItemSelectionModel.SelectionFlag.ClearAndSelect|QItemSelectionModel.SelectionFlag.Rows)
def save_state(self):
try:
with gprefs:
state = bytearray(self.jobs_view.horizontalHeader().saveState())
gprefs['jobs view column layout3'] = state
self.save_geometry(gprefs, 'jobs_dialog_geometry')
except Exception:
import traceback
traceback.print_exc()
def show_job_details(self, index):
index = self.proxy_model.mapToSource(index)
if index.isValid():
row = index.row()
job = self.model.row_to_job(row)
d = DetailView(self, job)
d.exec()
d.timer.stop()
def show_details(self, *args):
index = self.jobs_view.currentIndex()
if index.isValid():
self.show_job_details(index)
def kill_job(self, *args):
indices = [self.proxy_model.mapToSource(index) for index in
self.jobs_view.selectionModel().selectedRows()]
indices = [i for i in indices if i.isValid()]
jobs = self.model.rows_to_jobs([index.row() for index in indices])
if not jobs:
return error_dialog(self, _('No job'),
_('No job selected'), show=True)
if question_dialog(self, _('Are you sure?'),
ngettext('Do you really want to stop the selected job?',
'Do you really want to stop all the selected jobs?',
len(jobs))):
if len(jobs) > 1:
self.model.kill_multiple_jobs(jobs, self)
else:
self.model.kill_job(jobs[0], self)
def kill_all_jobs(self, *args):
if question_dialog(self, _('Are you sure?'),
_('Do you really want to stop all non-device jobs?')):
self.model.kill_all_jobs()
def hide_selected(self, *args):
indices = [self.proxy_model.mapToSource(index) for index in
self.jobs_view.selectionModel().selectedRows()]
indices = [i for i in indices if i.isValid()]
rows = [index.row() for index in indices]
if not rows:
return error_dialog(self, _('No job'),
_('No job selected'), show=True)
self.model.hide_jobs(rows)
self.proxy_model.beginResetModel(), self.proxy_model.endResetModel()
def hide_all(self, *args):
self.model.hide_jobs(list(range(0,
self.model.rowCount(QModelIndex()))))
self.proxy_model.beginResetModel(), self.proxy_model.endResetModel()
def show_hidden(self, *args):
self.model.show_hidden_jobs()
self.find(self.search.current_text)
def closeEvent(self, e):
self.save_state()
return QDialog.closeEvent(self, e)
def show(self, *args):
self.restore_state()
return QDialog.show(self, *args)
def hide(self, *args):
self.save_state()
return QDialog.hide(self, *args)
def reject(self):
self.save_state()
QDialog.reject(self)
def find(self, query):
self.proxy_model.find(query)
# }}}
| 25,927 | Python | .py | 644 | 29.781056 | 153 | 0.582926 | kovidgoyal/calibre | 19,243 | 2,250 | 4 | GPL-3.0 | 9/5/2024, 5:13:50 PM (Europe/Amsterdam) |
26,684 | __init__.py | kovidgoyal_calibre/src/calibre/gui2/wizard/__init__.py | #!/usr/bin/env python
__license__ = 'GPL v3'
__copyright__ = '2009, Kovid Goyal <kovid@kovidgoyal.net>'
__docformat__ = 'restructuredtext en'
import os
import re
import traceback
from contextlib import closing, suppress
from qt.core import QAbstractListModel, QDir, QIcon, QItemSelection, QItemSelectionModel, Qt, QWizard, QWizardPage, pyqtSignal
from calibre import __appname__
from calibre.constants import filesystem_encoding, isportable, iswindows
from calibre.gui2 import choose_dir, error_dialog
from calibre.gui2.wizard.device_ui import Ui_WizardPage as DeviceUI
from calibre.gui2.wizard.finish_ui import Ui_WizardPage as FinishUI
from calibre.gui2.wizard.kindle_ui import Ui_WizardPage as KindleUI
from calibre.gui2.wizard.library_ui import Ui_WizardPage as LibraryUI
from calibre.gui2.wizard.send_email import smtp_prefs
from calibre.gui2.wizard.stanza_ui import Ui_WizardPage as StanzaUI
from calibre.utils.config import dynamic, prefs
from calibre.utils.localization import _, localize_user_manual_link
from polyglot.builtins import iteritems
# Devices {{{
def gettext(name):
return name, __builtins__['_'](name)
class Device:
output_profile = 'generic_eink'
output_format = 'EPUB'
untranslated_name, name = gettext('Generic e-ink device')
manufacturer = 'Generic'
id = 'default'
supports_color = False
@classmethod
def set_output_profile(cls):
if cls.output_profile:
from calibre.ebooks.conversion.config import load_defaults, save_defaults
recs = load_defaults('page_setup')
recs['output_profile'] = cls.output_profile
save_defaults('page_setup', recs)
@classmethod
def set_output_format(cls):
if cls.output_format:
prefs.set('output_format', cls.output_format.lower())
@classmethod
def commit(cls):
cls.set_output_profile()
cls.set_output_format()
if cls.supports_color:
from calibre.ebooks.conversion.config import load_defaults, save_defaults
recs = load_defaults('comic_input')
recs['dont_grayscale'] = True
save_defaults('comic_input', recs)
class Smartphone(Device):
id = 'smartphone'
untranslated_name, name = gettext('Smartphone')
supports_color = True
class Tablet(Device):
id = 'tablet'
untranslated_name, name = gettext('iPad like tablet')
output_profile = 'tablet'
supports_color = True
class Kindle(Device):
output_profile = 'kindle'
output_format = 'MOBI'
untranslated_name, name = gettext('Kindle Basic (all models)')
manufacturer = 'Amazon'
id = 'kindle'
class JetBook(Device):
output_profile = 'jetbook5'
output_format = 'EPUB'
untranslated_name = name = 'JetBook'
manufacturer = 'Ectaco'
id = 'jetbook'
class JetBookMini(Device):
output_profile = 'jetbook5'
output_format = 'FB2'
untranslated_name = name = 'JetBook Mini'
manufacturer = 'Ectaco'
id = 'jetbookmini'
class KindleDX(Kindle):
output_profile = 'kindle_dx'
output_format = 'MOBI'
untranslated_name = name = 'Kindle DX'
id = 'kindledx'
class KindleFire(KindleDX):
untranslated_name, name = gettext('Kindle Fire and Fire HD')
id = 'kindle_fire'
output_profile = 'kindle_fire'
supports_color = True
class KindlePW(Kindle):
untranslated_name = name = 'Kindle PaperWhite'
id = 'kindle_pw'
output_profile = 'kindle_pw3'
class KindleVoyage(Kindle):
untranslated_name = name = 'Kindle Voyage/Oasis'
id = 'kindle_voyage'
output_profile = 'kindle_voyage'
class KindleScribe(Kindle):
untranslated_name = name = 'Kindle Scribe'
id = 'kindle_scribe'
output_profile = 'kindle_scribe'
class Sony505(Device):
output_profile = 'sony'
untranslated_name, name = gettext('All other SONY devices')
output_format = 'EPUB'
manufacturer = 'SONY'
id = 'prs505'
class Kobo(Device):
untranslated_name, name = gettext('Kobo and Kobo Touch Readers')
manufacturer = 'Kobo'
output_profile = 'kobo'
output_format = 'EPUB'
id = 'kobo'
class KoboVox(Kobo):
untranslated_name, name = gettext('Kobo Vox, Aura and Glo families')
output_profile = 'tablet'
id = 'kobo_vox'
class Booq(Device):
untranslated_name = name = 'bq Classic'
manufacturer = 'Booq'
output_profile = 'sony'
output_format = 'EPUB'
id = 'booq'
class TheBook(Device):
untranslated_name = name = 'The Book'
manufacturer = 'Augen'
output_profile = 'sony'
output_format = 'EPUB'
id = 'thebook'
class Avant(Booq):
untranslated_name = name = 'bq Avant'
class AvantXL(Booq):
untranslated_name = name = 'bq Avant XL'
output_profile = 'ipad'
class BooqPocketPlus(Booq):
untranslated_name = name = 'bq Pocket Plus'
output_profile = 'sony300'
class BooqCervantes(Booq):
untranslated_name = name = 'bq Cervantes'
class BOOX(Device):
untranslated_name, name = gettext('BOOX MAX, N96, i86, C67ML, M96, etc.')
manufacturer = 'Onyx'
output_profile = 'generic_eink_hd'
output_format = 'EPUB'
id = 'boox_eink'
class Sony300(Sony505):
untranslated_name = name = 'SONY Reader Pocket Edition'
id = 'prs300'
output_profile = 'sony300'
class Sony900(Sony505):
untranslated_name = name = 'SONY Reader Daily Edition'
id = 'prs900'
output_profile = 'sony900'
class SonyT3(Sony505):
untranslated_name = name = 'SONY Reader T3'
id = 'prst3'
output_profile = 'sonyt3'
class Nook(Sony505):
id = 'nook'
untranslated_name, name = gettext('Nook and Nook Simple Reader')
manufacturer = 'Barnes & Noble'
output_profile = 'nook'
class NookColor(Nook):
id = 'nook_color'
untranslated_name = name = 'Nook Color'
output_profile = 'nook_color'
supports_color = True
class NookTablet(NookColor):
id = 'nook_tablet'
untranslated_name = name = 'Nook Tablet/HD'
output_profile = 'nook_hd_plus'
class CybookG3(Device):
untranslated_name = name = 'Cybook Gen 3'
output_format = 'MOBI'
output_profile = 'cybookg3'
manufacturer = 'Bookeen'
id = 'cybookg3'
class CybookOpus(CybookG3):
untranslated_name = name = 'Cybook Opus'
output_format = 'EPUB'
output_profile = 'cybook_opus'
id = 'cybook_opus'
class CybookOrizon(CybookOpus):
untranslated_name = name = 'Cybook Orizon'
id = 'cybook_orizon'
class CybookOdyssey(CybookOpus):
untranslated_name = name = 'Cybook Odyssey'
id = 'cybook_odyssey'
class CybookMuse(CybookOpus):
untranslated_name = name = 'Cybook Muse'
id = 'cybook_muse'
output_profile = 'tablet'
class BookeenDiva(CybookOpus):
untranslated_name = name = 'Bookeen Diva HD'
id = 'bookeen_diva'
output_profile = 'tablet'
class PocketBook360(CybookOpus):
manufacturer = 'PocketBook'
untranslated_name, name = gettext('PocketBook 360 and newer models')
id = 'pocketbook360'
output_profile = 'cybook_opus'
class PocketBook(CybookG3):
manufacturer = 'PocketBook'
untranslated_name = name = 'PocketBook 301/302'
id = 'pocketbook'
output_profile = 'cybookg3'
class PocketBook900(PocketBook):
untranslated_name = name = 'PocketBook 900'
id = 'pocketbook900'
output_profile = 'pocketbook_900'
class PocketBookPro912(PocketBook):
untranslated_name = name = 'PocketBook Pro 912'
id = 'pocketbookpro912'
output_profile = 'pocketbook_pro_912'
class PocketBookLux(PocketBook):
untranslated_name, name = gettext('PocketBook Lux (1-5) and Basic 4')
id = 'pocketbooklux'
short_name = 'pocketbook_lux'
class PocketBookHD(PocketBook):
untranslated_name = name = 'PocketBook PocketBook HD Touch (1-3)'
id = 'pocketbookhd'
short_name = 'pocketbook_hd'
class PocketBookInkpad3(PocketBook):
untranslated_name, name = gettext('PocketBook Inkpad 3 (Pro) and X')
id = 'pocketbookinkpad3'
short_name = 'pocketbook_inkpad3'
class iPhone(Device):
untranslated_name = name = 'iPhone/iPad/iPod Touch'
output_format = 'EPUB'
manufacturer = 'Apple'
id = 'iphone'
supports_color = True
output_profile = 'ipad3'
class Android(Device):
untranslated_name, name = gettext('Android phone')
output_format = 'EPUB'
manufacturer = 'Android'
id = 'android'
supports_color = True
@classmethod
def commit(cls):
from calibre.customize.ui import device_plugins
super().commit()
for plugin in device_plugins(include_disabled=True):
if hasattr(plugin, 'configure_for_generic_epub_app'):
plugin.configure_for_generic_epub_app()
class AndroidTablet(Android):
untranslated_name, name = gettext('Android tablet')
id = 'android_tablet'
output_profile = 'tablet'
class AndroidPhoneWithKindle(Android):
untranslated_name, name = gettext('Android phone with Kindle reader')
output_format = 'MOBI'
id = 'android_phone_with_kindle'
output_profile = 'kindle'
@classmethod
def commit(cls):
from calibre.customize.ui import device_plugins
super(Android, cls).commit()
for plugin in device_plugins(include_disabled=True):
if hasattr(plugin, 'configure_for_kindle_app'):
plugin.configure_for_kindle_app()
class AndroidTabletWithKindle(AndroidPhoneWithKindle):
untranslated_name, name = gettext('Android tablet with Kindle reader')
id = 'android_tablet_with_kindle'
output_profile = 'kindle_fire'
class HanlinV3(Device):
untranslated_name = name = 'Hanlin V3'
output_format = 'EPUB'
output_profile = 'hanlinv3'
manufacturer = 'Jinke'
id = 'hanlinv3'
class HanlinV5(HanlinV3):
untranslated_name = name = 'Hanlin V5'
output_profile = 'hanlinv5'
id = 'hanlinv5'
class BeBook(HanlinV3):
untranslated_name = name = 'BeBook'
manufacturer = 'BeBook'
id = 'bebook'
class BeBookMini(HanlinV5):
untranslated_name = name = 'BeBook Mini'
manufacturer = 'BeBook'
id = 'bebook_mini'
class EZReader(HanlinV3):
untranslated_name = name = 'EZReader'
manufacturer = 'Astak'
id = 'ezreader'
class EZReaderPP(HanlinV5):
untranslated_name = name = 'EZReader Pocket Pro'
manufacturer = 'Astak'
id = 'ezreader_pp'
# }}}
def get_devices():
for x in globals().values():
if isinstance(x, type) and issubclass(x, Device):
yield x
def get_manufacturers():
mans = set()
for x in get_devices():
mans.add(x.manufacturer)
if Device.manufacturer in mans:
mans.remove(Device.manufacturer)
return [Device.manufacturer] + sorted(mans)
def get_devices_of(manufacturer):
ans = [d for d in get_devices() if d.manufacturer == manufacturer]
return sorted(ans, key=lambda x: x.name)
class ManufacturerModel(QAbstractListModel):
def __init__(self):
QAbstractListModel.__init__(self)
self.manufacturers = get_manufacturers()
def rowCount(self, p):
return len(self.manufacturers)
def columnCount(self, p):
return 1
def data(self, index, role):
if role == Qt.ItemDataRole.DisplayRole:
ans = self.manufacturers[index.row()]
if ans == Device.manufacturer:
ans = _('Generic')
return ans
if role == Qt.ItemDataRole.UserRole:
return self.manufacturers[index.row()]
return None
def index_of(self, man):
for i, x in enumerate(self.manufacturers):
if x == man:
return self.index(i)
class DeviceModel(QAbstractListModel):
def __init__(self, manufacturer):
QAbstractListModel.__init__(self)
self.devices = get_devices_of(manufacturer)
def rowCount(self, p):
return len(self.devices)
def columnCount(self, p):
return 1
def data(self, index, role):
if role == Qt.ItemDataRole.DisplayRole:
return (self.devices[index.row()].name)
if role == Qt.ItemDataRole.UserRole:
return self.devices[index.row()]
return None
def index_of(self, dev):
for i, device in enumerate(self.devices):
if device is dev:
return self.index(i)
class KindlePage(QWizardPage, KindleUI):
ID = 3
def __init__(self):
QWizardPage.__init__(self)
self.setupUi(self)
def initializePage(self):
opts = smtp_prefs().parse()
accs = []
has_default = False
for x, ac in iteritems(opts.accounts):
default = ac[2]
if x.strip().endswith('@kindle.com'):
accs.append((x, default))
if default:
has_default = True
if has_default:
accs = [x for x in accs if x[1]]
if accs:
self.to_address.setText(accs[0][0])
def x():
t = str(self.to_address.text())
if t.strip():
return t.strip()
self.send_email_widget.initialize(x)
def commit(self):
x = str(self.to_address.text()).strip()
parts = x.split('@')
if (len(parts) >= 2 and parts[0] and self.send_email_widget.set_email_settings(True)):
conf = smtp_prefs()
accounts = conf.parse().accounts
if not accounts:
accounts = {}
for y in accounts.values():
y[2] = False
accounts[x] = ['EPUB, TPZ', True, True]
conf.set('accounts', accounts)
def nextId(self):
return FinishPage.ID
def retranslateUi(self, widget):
KindleUI.retranslateUi(self, widget)
if hasattr(self, 'send_email_widget'):
self.send_email_widget.retranslateUi(self.send_email_widget)
class StanzaPage(QWizardPage, StanzaUI):
ID = 5
def __init__(self):
QWizardPage.__init__(self)
self.setupUi(self)
try:
self.instructions.setText(self.instructions.text() % localize_user_manual_link(
'https://manual.calibre-ebook.com/faq.html#how-do-i-use-calibre-with-my-ipad-iphone-ipod-touch'))
except TypeError:
pass # user manual link was already replaced
self.instructions.setOpenExternalLinks(True)
self.content_server.stateChanged[(int)].connect(self.set_port)
def initializePage(self):
from calibre.gui2 import config
yes = config['autolaunch_server']
self.content_server.setChecked(yes)
self.set_port()
def nextId(self):
return FinishPage.ID
def commit(self):
p = self.set_port()
if p is not None:
from calibre.srv.opts import change_settings
change_settings(port=p)
def set_port(self, *args):
if not self.content_server.isChecked():
return
import socket
s = socket.socket()
with closing(s):
for p in range(8080, 8100):
try:
s.bind(('0.0.0.0', p))
t = str(self.instructions.text())
t = re.sub(r':\d+', ':'+str(p), t)
self.instructions.setText(t)
return p
except:
continue
class DevicePage(QWizardPage, DeviceUI):
ID = 2
def __init__(self):
QWizardPage.__init__(self)
self.setupUi(self)
self.registerField("manufacturer", self.manufacturer_view)
self.registerField("device", self.device_view)
def initializePage(self):
self.label.setText(_('Choose your e-book device. If your device is'
' not in the list, choose a "Generic" device.'))
self.man_model = ManufacturerModel()
self.manufacturer_view.setModel(self.man_model)
previous = dynamic.get('welcome_wizard_device', False)
if previous:
previous = [x for x in get_devices() if x.id == previous]
if not previous:
previous = [Device]
previous = previous[0]
else:
previous = Device
idx = self.man_model.index_of(previous.manufacturer)
if idx is None:
idx = self.man_model.index_of(Device.manufacturer)
previous = Device
self.manufacturer_view.selectionModel().select(idx,
QItemSelectionModel.SelectionFlag.Select)
self.dev_model = DeviceModel(self.man_model.data(idx, Qt.ItemDataRole.UserRole))
idx = self.dev_model.index_of(previous)
self.device_view.setModel(self.dev_model)
self.device_view.selectionModel().select(idx,
QItemSelectionModel.SelectionFlag.Select)
self.manufacturer_view.selectionModel().selectionChanged[(QItemSelection, QItemSelection)].connect(self.manufacturer_changed)
def manufacturer_changed(self, current, previous):
new = list(current.indexes())[0]
man = self.man_model.data(new, Qt.ItemDataRole.UserRole)
self.dev_model = DeviceModel(man)
self.device_view.setModel(self.dev_model)
self.device_view.selectionModel().select(self.dev_model.index(0),
QItemSelectionModel.SelectionFlag.Select)
def commit(self):
idx = list(self.device_view.selectionModel().selectedIndexes())[0]
dev = self.dev_model.data(idx, Qt.ItemDataRole.UserRole)
dev.commit()
dynamic.set('welcome_wizard_device', dev.id)
def nextId(self):
idx = list(self.device_view.selectionModel().selectedIndexes())[0]
dev = self.dev_model.data(idx, Qt.ItemDataRole.UserRole)
if dev in (Kindle, KindleDX, KindleFire, KindlePW, KindleVoyage, KindleScribe):
return KindlePage.ID
if dev is iPhone:
return StanzaPage.ID
return FinishPage.ID
class LibraryPage(QWizardPage, LibraryUI):
ID = 1
retranslate = pyqtSignal()
def __init__(self):
QWizardPage.__init__(self)
self.made_dirs = []
self.initial_library_location = None
self.setupUi(self)
self.registerField('library_location', self.location)
self.button_change.clicked.connect(self.change)
self.init_languages()
self.language.currentIndexChanged.connect(self.change_language)
self.location.textChanged.connect(self.location_text_changed)
self.set_move_lib_label_text()
def makedirs(self, x):
self.made_dirs.append(x)
os.makedirs(x)
def location_text_changed(self, newtext):
self.completeChanged.emit()
def set_move_lib_label_text(self):
self.move_lib_label.setText(_(
'If you are moving calibre from an old computer to a new one,'
' please read <a href="{0}">the instructions</a>.').format(
localize_user_manual_link(
'https://manual.calibre-ebook.com/faq.html#how-do-i-move-my-calibre-data-from-one-computer-to-another')))
def retranslateUi(self, widget):
LibraryUI.retranslateUi(self, widget)
self.set_move_lib_label_text()
def init_languages(self):
self.language.blockSignals(True)
self.language.clear()
from calibre.utils.localization import available_translations, get_lang, get_language, get_lc_messages_path
lang = get_lang()
lang = get_lc_messages_path(lang) if lang else lang
if lang is None or lang not in available_translations():
lang = 'en'
def get_esc_lang(l):
if l == 'en':
return 'English'
return get_language(l)
self.language.addItem(get_esc_lang(lang), (lang))
items = [(l, get_esc_lang(l)) for l in available_translations()
if l != lang]
if lang != 'en':
items.append(('en', get_esc_lang('en')))
items.sort(key=lambda x: x[1])
for item in items:
self.language.addItem(item[1], (item[0]))
self.language.blockSignals(False)
prefs['language'] = str(self.language.itemData(self.language.currentIndex()) or '')
def change_language(self, idx):
prefs['language'] = str(self.language.itemData(self.language.currentIndex()) or '')
from polyglot.builtins import builtins
builtins.__dict__['_'] = lambda x: x
from calibre.ebooks.metadata.book.base import reset_field_metadata
from calibre.gui2 import qt_app
from calibre.utils.localization import set_translators
set_translators()
qt_app.load_translations()
self.retranslate.emit()
self.init_languages()
reset_field_metadata()
try:
lang = prefs['language'].lower()[:2]
metadata_plugins = {
'zh' : ('Douban Books',),
'fr' : ('Nicebooks',),
'ru' : ('OZON.ru',),
}.get(lang, [])
from calibre.customize.ui import enable_plugin
for name in metadata_plugins:
enable_plugin(name)
except:
pass
lp = self.location.text()
if lp == self.initial_library_location:
self.set_initial_library_location()
for x in globals().values():
if type(x) is type and hasattr(x, 'untranslated_name'):
x.name = __builtins__['_'](x.untranslated_name)
def is_library_dir_suitable(self, x):
from calibre.db.legacy import LibraryDatabase
try:
return LibraryDatabase.exists_at(x) or not os.listdir(x)
except:
return False
def validatePage(self):
newloc = str(self.location.text())
if not self.is_library_dir_suitable(newloc):
self.show_library_dir_error(newloc)
return False
return True
def change(self):
from calibre.db.legacy import LibraryDatabase
x = choose_dir(self, 'database location dialog',
_('Select location for books'))
if x:
if (iswindows and len(x) > LibraryDatabase.WINDOWS_LIBRARY_PATH_LIMIT):
return error_dialog(self, _('Too long'),
_('Path to library too long. It must be less than'
' %d characters.')%(LibraryDatabase.WINDOWS_LIBRARY_PATH_LIMIT),
show=True)
if not os.path.exists(x):
try:
self.makedirs(x)
except:
return error_dialog(self, _('Bad location'),
_('Failed to create a folder at %s')%x,
det_msg=traceback.format_exc(), show=True)
if self.is_library_dir_suitable(x):
self.location.setText(x)
else:
self.show_library_dir_error(x)
def show_library_dir_error(self, x):
if not isinstance(x, str):
try:
x = x.decode(filesystem_encoding)
except:
x = str(repr(x))
error_dialog(self, _('Bad location'),
_('You must choose an empty folder for '
'the calibre library. %s is not empty.')%x, show=True)
def set_initial_library_location(self):
lp = prefs['library_path']
self.default_library_name = None
if not lp:
fname = _('Calibre Library')
try:
base = os.path.expanduser('~')
except ValueError:
base = QDir.homePath().replace('/', os.sep)
lp = os.path.join(base, fname)
self.default_library_name = lp
if not os.path.exists(lp):
try:
self.makedirs(lp)
except:
traceback.print_exc()
try:
lp = os.path.expanduser('~')
except ValueError:
lp = QDir.homePath().replace('/', os.sep)
self.location.setText(lp)
self.initial_library_location = lp
def initializePage(self):
self.set_initial_library_location()
# Hide the library location settings if we are a portable install
for x in ('location', 'button_change', 'libloc_label1',
'libloc_label2'):
getattr(self, x).setVisible(not isportable)
def isComplete(self):
try:
lp = str(self.location.text())
ans = bool(lp) and os.path.exists(lp) and os.path.isdir(lp) and os.access(lp,
os.W_OK)
except:
ans = False
return ans
def commit(self):
newloc = str(self.location.text())
try:
dln = self.default_library_name
if (dln and os.path.exists(dln) and not os.listdir(dln) and newloc != dln):
os.rmdir(dln)
except Exception:
pass
# dont leave behind any empty dirs
for x in self.made_dirs:
with suppress(OSError):
os.rmdir(x)
if not os.path.exists(newloc):
os.makedirs(newloc)
prefs['library_path'] = newloc
def nextId(self):
return DevicePage.ID
class FinishPage(QWizardPage, FinishUI):
ID = 4
def __init__(self):
QWizardPage.__init__(self)
self.setupUi(self)
try:
self.um_label.setText(self.um_label.text() % localize_user_manual_link('https://manual.calibre-ebook.com'))
except TypeError:
pass # link already localized
def nextId(self):
return -1
def commit(self):
pass
class Wizard(QWizard):
BUTTON_TEXTS = {
'Next': '&Next >',
'Back': '< &Back',
'Cancel': 'Cancel',
'Finish': '&Finish',
'Commit': 'Commit'
}
# The latter is simply to mark the texts for translation
if False:
_('&Next >')
_('< &Back')
_('Cancel')
_('&Finish')
_('Commit')
def __init__(self, parent):
QWizard.__init__(self, parent)
self.setWindowTitle(__appname__+' '+_('Welcome wizard'))
self.setPixmap(QWizard.WizardPixmap.LogoPixmap, QIcon.ic('library.png').pixmap(48, 48))
self.setWizardStyle(QWizard.WizardStyle.ModernStyle)
self.device_page = DevicePage()
self.library_page = LibraryPage()
self.library_page.retranslate.connect(self.retranslate)
self.finish_page = FinishPage()
self.set_finish_text()
self.kindle_page = KindlePage()
self.stanza_page = StanzaPage()
self.setPage(self.library_page.ID, self.library_page)
self.setPage(self.device_page.ID, self.device_page)
self.setPage(self.finish_page.ID, self.finish_page)
self.setPage(self.kindle_page.ID, self.kindle_page)
self.setPage(self.stanza_page.ID, self.stanza_page)
self.device_extra_page = None
self.set_button_texts()
self.resize(600, 520)
def set_button_texts(self):
for but, text in iteritems(self.BUTTON_TEXTS):
self.setButtonText(getattr(QWizard.WizardButton, but+'Button'), _(text))
def retranslate(self):
for pid in self.pageIds():
page = self.page(pid)
page.retranslateUi(page)
self.set_button_texts()
self.set_finish_text()
def accept(self):
pages = map(self.page, self.visitedIds())
for page in pages:
page.commit()
QWizard.accept(self)
def set_finish_text(self, *args):
bt = str("<em>" + self.buttonText(QWizard.WizardButton.FinishButton) + "</em>").replace('&', '')
t = str(self.finish_page.finish_text.text())
if '%s' in t:
self.finish_page.finish_text.setText(t%bt)
def wizard(parent=None):
w = Wizard(parent)
return w
if __name__ == '__main__':
from calibre.gui2 import Application
app = Application([])
wizard().exec()
| 28,075 | Python | .py | 727 | 30.291609 | 133 | 0.627232 | kovidgoyal/calibre | 19,243 | 2,250 | 4 | GPL-3.0 | 9/5/2024, 5:13:50 PM (Europe/Amsterdam) |
26,685 | send_email.py | kovidgoyal_calibre/src/calibre/gui2/wizard/send_email.py | #!/usr/bin/env python
__license__ = 'GPL v3'
__copyright__ = '2009, Kovid Goyal <kovid@kovidgoyal.net>'
__docformat__ = 'restructuredtext en'
import sys
from functools import partial
from threading import Thread
from qt.core import (
QCheckBox,
QDialog,
QDialogButtonBox,
QGridLayout,
QHBoxLayout,
QIcon,
QLabel,
QLineEdit,
QPlainTextEdit,
QPushButton,
Qt,
QVBoxLayout,
QWidget,
pyqtSignal,
)
from calibre import prints
from calibre.gui2 import error_dialog, question_dialog
from calibre.gui2.wizard.send_email_ui import Ui_Form
from calibre.utils.localization import _
from calibre.utils.smtp import config as smtp_prefs
from polyglot.binary import as_hex_unicode, from_hex_unicode
from polyglot.io import PolyglotStringIO
class TestEmail(QDialog):
test_done = pyqtSignal(object)
def __init__(self, pa, parent):
QDialog.__init__(self, parent)
self.test_func = parent.test_email_settings
self.setWindowTitle(_("Test email settings"))
self.setWindowIcon(QIcon.ic('config.ui'))
l = QVBoxLayout(self)
opts = smtp_prefs().parse()
self.from_ = la = QLabel(_("Send test mail from %s to:")%opts.from_)
l.addWidget(la)
self.to = le = QLineEdit(self)
if pa:
self.to.setText(pa)
self.test_button = b = QPushButton(_('&Test'), self)
b.clicked.connect(self.start_test)
self.test_done.connect(self.on_test_done, type=Qt.ConnectionType.QueuedConnection)
self.h = h = QHBoxLayout()
h.addWidget(le), h.addWidget(b)
l.addLayout(h)
if opts.relay_host:
self.la = la = QLabel(_('Using: %(un)s:%(pw)s@%(host)s:%(port)s and %(enc)s encryption')%
dict(un=opts.relay_username, pw=from_hex_unicode(opts.relay_password),
host=opts.relay_host, port=opts.relay_port, enc=opts.encryption))
l.addWidget(la)
self.log = QPlainTextEdit(self)
l.addWidget(self.log)
self.bb = bb = QDialogButtonBox(QDialogButtonBox.StandardButton.Close)
bb.rejected.connect(self.reject), bb.accepted.connect(self.accept)
l.addWidget(bb)
def start_test(self, *args):
if not self.to.text().strip():
return error_dialog(self, _('No email address'), _(
'No email address to send mail to has been specified. You'
' must specify a To: address before running the test.'), show=True)
self.log.setPlainText(_('Sending email, please wait...'))
self.test_button.setEnabled(False)
t = Thread(target=self.run_test, name='TestEmailSending')
t.daemon = True
t.start()
def run_test(self):
from email.utils import parseaddr
q = self.to.text().strip()
addr = parseaddr(q)[-1]
if not addr or '@' not in q:
tb = f'{self.to.text().strip()} is not a valid email address'
else:
try:
tb = self.test_func(addr) or _('Email successfully sent')
except Exception:
import traceback
tb = traceback.format_exc()
self.test_done.emit(tb)
def on_test_done(self, txt):
if self.isVisible():
self.test_button.setEnabled(True)
self.log.setPlainText(txt)
class RelaySetup(QDialog):
def __init__(self, service, parent):
QDialog.__init__(self, parent)
self.l = l = QGridLayout()
self.setLayout(l)
self.bb = bb = QDialogButtonBox(QDialogButtonBox.StandardButton.Ok|QDialogButtonBox.StandardButton.Cancel)
bb.accepted.connect(self.accept)
bb.rejected.connect(self.reject)
self.tl = QLabel(('<p>'+_('Setup sending email using') +
' <b>{name}</b><p>' +
_('If you don\'t have an account, you can sign up for a free {name} email '
'account at <a href="https://{url}">{url}</a>. {extra}')).format(
**service))
l.addWidget(self.tl, 0, 0, 3, 0)
self.tl.setWordWrap(True)
self.tl.setOpenExternalLinks(True)
for name, label in (
['from_', _('Your %s &email address:')],
['password', _('Your %s &password:')],
):
la = QLabel(label%service['name'])
le = QLineEdit(self)
setattr(self, name, le)
setattr(self, name+'_label', la)
r = l.rowCount()
l.addWidget(la, r, 0)
l.addWidget(le, r, 1)
la.setBuddy(le)
if name == 'password':
self.ptoggle = QCheckBox(_('&Show password'), self)
l.addWidget(self.ptoggle, r, 2)
self.ptoggle.stateChanged.connect(
lambda s: self.password.setEchoMode(QLineEdit.EchoMode.Normal if s == Qt.CheckState.Checked else QLineEdit.EchoMode.Password))
self.password.setEchoMode(QLineEdit.EchoMode.Password)
self.bl = QLabel('<p>' + _(
'If you plan to use email to send books to your Kindle, remember to'
' add your %s email address to the allowed email addresses in your '
'Amazon.com Kindle management page.')%service['name'])
self.bl.setWordWrap(True)
l.addWidget(self.bl, l.rowCount(), 0, 3, 0)
l.addWidget(bb, l.rowCount(), 0, 3, 0)
self.setWindowTitle(_('Setup') + ' ' + service['name'])
self.resize(self.sizeHint())
self.service = service
@property
def service_username(self):
na = self.from_.text()
from email.utils import parseaddr
addr = parseaddr(na)[-1]
if not addr or '@' not in na:
return ''
return addr
def accept(self):
pw = self.password.text()
if not pw:
return error_dialog(self, _('No password'), _(
'You must specify a password'), show=True)
fr = self.from_.text().strip()
if not fr:
return error_dialog(self, _('No email address'), _(
'You must specify an email address'), show=True)
un = self.service_username
if not un:
return error_dialog(self, _('Incorrect email address'), _(
'The email address "{}" is not valid').format(self.from_.text()), show=True)
QDialog.accept(self)
class SendEmail(QWidget, Ui_Form):
changed_signal = pyqtSignal()
def __init__(self, parent=None):
QWidget.__init__(self, parent)
self.setupUi(self)
def initialize(self, preferred_to_address):
self.preferred_to_address = preferred_to_address
opts = smtp_prefs().parse()
self.smtp_opts = opts
if opts.from_:
self.email_from.setText(opts.from_)
self.email_from.textChanged.connect(self.changed)
if opts.relay_host:
self.relay_host.setText(opts.relay_host)
self.relay_host.textChanged.connect(self.changed)
self.relay_port.setValue(opts.relay_port)
self.relay_port.valueChanged.connect(self.changed)
if opts.relay_username:
self.relay_username.setText(opts.relay_username)
self.relay_username.textChanged.connect(self.changed)
if opts.relay_password:
self.relay_password.setText(from_hex_unicode(opts.relay_password))
self.relay_password.textChanged.connect(self.changed)
getattr(self, 'relay_'+opts.encryption.lower()).setChecked(True)
self.relay_tls.toggled.connect(self.changed)
for x in ('gmx',):
button = getattr(self, 'relay_use_'+x)
button.clicked.connect(partial(self.create_service_relay, x))
self.relay_show_password.stateChanged.connect(
lambda state : self.relay_password.setEchoMode(
QLineEdit.EchoMode.Password if
state == 0 else QLineEdit.EchoMode.Normal))
self.test_email_button.clicked.connect(self.test_email)
def changed(self, *args):
self.changed_signal.emit()
def test_email(self, *args):
pa = self.preferred_to_address()
to_set = pa is not None
if self.set_email_settings(to_set):
opts = smtp_prefs().parse()
if not opts.relay_password or question_dialog(self, _('OK to proceed?'),
_('This will display your email password on the screen'
'. Is it OK to proceed?'), show_copy_button=False):
TestEmail(pa, self).exec()
def test_email_settings(self, to):
opts = smtp_prefs().parse()
from calibre.utils.smtp import create_mail, sendmail
buf = PolyglotStringIO()
debug_out = partial(prints, file=buf)
oout, oerr = sys.stdout, sys.stderr
sys.stdout = sys.stderr = buf
tb = None
try:
msg = create_mail(opts.from_, to, 'Test mail from calibre',
'Test mail from calibre')
sendmail(msg, from_=opts.from_, to=[to],
verbose=3, timeout=30, relay=opts.relay_host,
username=opts.relay_username, debug_output=debug_out,
password=from_hex_unicode(opts.relay_password),
encryption=opts.encryption, port=opts.relay_port)
except:
import traceback
tb = traceback.format_exc()
tb += '\n\nLog:\n' + buf.getvalue()
finally:
sys.stdout, sys.stderr = oout, oerr
return tb
def create_service_relay(self, service, *args):
service = {
'gmx': {
'name': 'GMX',
'relay': 'mail.gmx.com',
'port': 587,
'username': '@gmx.com',
'url': 'www.gmx.com',
'extra': _('Before using this account to send mail, you must enable the'
' "Enable access to this account via POP3 and IMAP" option in GMX'
' under More > E-mail Settings > POP3 & IMAP.'),
'at_in_username': True,
},
'gmail': {
'name': 'Gmail',
'relay': 'smtp.gmail.com',
'port': 587,
'username': '@gmail.com',
'url': 'www.gmail.com',
'extra': _(
'Google recently deliberately broke their email sending protocol (SMTP) support in'
' an attempt to force everyone to use their web interface so they can'
' show you more ads. They are trying to claim that SMTP is insecure,'
' that is incorrect and simply an excuse. To use a Gmail account'
' you will need to "allow less secure apps" as described'
' <a href="https://support.google.com/accounts/answer/6010255">here</a>.'),
'at_in_username': True,
},
'hotmail': {
'name': 'Outlook',
'relay': 'smtp-mail.outlook.com',
'port': 587,
'username': '@outlook.com',
'url': 'outlook.live.com/owa/',
'extra': _('If you are setting up a new'
' Outlook account, Microsoft requires that you '
' verify your account periodically, before it'
' will let calibre send email.'),
'at_in_username': True,
}
}[service]
d = RelaySetup(service, self)
if d.exec() != QDialog.DialogCode.Accepted:
return
self.relay_username.setText(d.service_username)
self.relay_password.setText(d.password.text())
self.email_from.setText(d.from_.text())
self.relay_host.setText(service['relay'])
self.relay_port.setValue(service['port'])
self.relay_tls.setChecked(True)
def set_email_settings(self, to_set):
from_ = str(self.email_from.text()).strip()
if to_set and not from_:
error_dialog(self, _('Bad configuration'),
_('You must set the From email address')).exec()
return False
username = str(self.relay_username.text()).strip()
password = str(self.relay_password.text()).strip()
host = str(self.relay_host.text()).strip()
enc_method = ('TLS' if self.relay_tls.isChecked() else 'SSL'
if self.relay_ssl.isChecked() else 'NONE')
if host:
# Validate input
if ((username and not password) or (not username and password)):
error_dialog(self, _('Bad configuration'),
_('You must either set both the username <b>and</b> password for '
'the mail server or no username and no password at all.')).exec()
return False
if not (username and password) and not question_dialog(
self, _('Are you sure?'),
_('No username and password set for mailserver. Most '
' mailservers need a username and password. Are you sure?')):
return False
conf = smtp_prefs()
conf.set('from_', from_)
conf.set('relay_host', host if host else None)
conf.set('relay_port', self.relay_port.value())
conf.set('relay_username', username if username else None)
conf.set('relay_password', as_hex_unicode(password))
conf.set('encryption', enc_method)
return True
| 13,689 | Python | .py | 301 | 33.810631 | 150 | 0.571899 | kovidgoyal/calibre | 19,243 | 2,250 | 4 | GPL-3.0 | 9/5/2024, 5:13:50 PM (Europe/Amsterdam) |
26,686 | __init__.py | kovidgoyal_calibre/src/calibre/gui2/progress_indicator/__init__.py | #!/usr/bin/env python
# License: GPLv3 Copyright: 2015, Kovid Goyal <kovid at kovidgoyal.net>
from qt.core import QDialog, QLabel, QSizePolicy, QStackedLayout, QStackedWidget, Qt, QVBoxLayout, QWidget
from calibre_extensions.progress_indicator import QProgressIndicator as ProgressIndicator
from calibre_extensions.progress_indicator import SpinAnimator, draw_snake_spinner
draw_snake_spinner
class WaitPanel(QWidget):
def __init__(self, msg, parent=None, size=256, interval=10):
QWidget.__init__(self, parent)
self.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Expanding)
self.l = l = QVBoxLayout(self)
self.spinner = ProgressIndicator(self, size, interval)
self.start, self.stop = self.spinner.start, self.spinner.stop
l.addStretch(), l.addWidget(self.spinner, 0, Qt.AlignmentFlag.AlignCenter)
self.la = QLabel(msg)
f = self.la.font()
f.setPointSize(28)
self.la.setFont(f)
l.addWidget(self.la, 0, Qt.AlignmentFlag.AlignCenter), l.addStretch()
@property
def msg(self):
return self.la.text()
@msg.setter
def msg(self, val):
self.la.setText(val)
class WaitStack(QStackedWidget):
def __init__(self, msg, after=None, parent=None, size=256, interval=10):
QStackedWidget.__init__(self, parent)
self.wp = WaitPanel(msg, self, size, interval)
if after is None:
after = QWidget(self)
self.after = after
self.addWidget(self.wp)
self.addWidget(after)
def start(self):
self.setCurrentWidget(self.wp)
self.wp.start()
def stop(self):
self.wp.stop()
self.setCurrentWidget(self.after)
@property
def msg(self):
return self.wp.msg
@msg.setter
def msg(self, val):
self.wp.msg = val
class WaitLayout(QStackedLayout):
def __init__(self, msg, after=None, parent=None, size=256, interval=10):
QStackedLayout.__init__(self, parent)
self.wp = WaitPanel(msg, parent, size, interval)
if after is None:
after = QWidget(parent)
self.after = after
self.addWidget(self.wp)
self.addWidget(after)
def start(self):
self.setCurrentWidget(self.wp)
self.wp.start()
def stop(self):
self.wp.stop()
self.setCurrentWidget(self.after)
@property
def msg(self):
return self.wp.msg
@msg.setter
def msg(self, val):
self.wp.msg = val
def develop():
from qt.core import QPainter, QPalette
from calibre.gui2 import Application
class Widget(QWidget):
def __init__(self):
QWidget.__init__(self)
self.a = SpinAnimator(self)
self.a.updated.connect(self.update)
def paintEvent(self, ev):
p = QPainter(self)
pal = self.palette()
self.a.draw(p, self.rect(), pal.color(QPalette.ColorRole.WindowText))
p.end()
app = Application([])
d = QDialog()
d.resize(64, 64)
l = QVBoxLayout(d)
w = Widget()
l.addWidget(w)
w.a.start()
d.exec()
del d
del app
if __name__ == '__main__':
from calibre.gui2 import Application
app = Application([])
d = QDialog()
d.resize(64, 64)
w = ProgressIndicator(d)
l = QVBoxLayout(d)
l.addWidget(w)
w.start()
d.exec()
del d
del app
| 3,436 | Python | .py | 102 | 26.588235 | 106 | 0.637107 | kovidgoyal/calibre | 19,243 | 2,250 | 4 | GPL-3.0 | 9/5/2024, 5:13:50 PM (Europe/Amsterdam) |
26,687 | undo.py | kovidgoyal_calibre/src/calibre/gui2/tweak_book/undo.py | #!/usr/bin/env python
__license__ = 'GPL v3'
__copyright__ = '2013, Kovid Goyal <kovid at kovidgoyal.net>'
import shutil
from qt.core import (
QAbstractListModel,
QApplication,
QGridLayout,
QIcon,
QItemSelectionModel,
QListView,
QModelIndex,
QPushButton,
QStyledItemDelegate,
Qt,
QWidget,
pyqtSignal,
)
from calibre.gui2 import error_dialog
ROOT = QModelIndex()
MAX_SAVEPOINTS = 100
def cleanup(containers):
for container in containers:
try:
shutil.rmtree(container.root, ignore_errors=True)
except:
pass
class State:
def __init__(self, container):
self.container = container
self.message = None
self.rewind_message = None
class GlobalUndoHistory(QAbstractListModel):
def __init__(self, parent=None):
QAbstractListModel.__init__(self, parent)
self.states = []
self.pos = 0
def rowCount(self, parent=ROOT):
return len(self.states)
def data(self, index, role=Qt.ItemDataRole.DisplayRole):
if role == Qt.ItemDataRole.DisplayRole:
return self.label_for_row(index.row())
if role == Qt.ItemDataRole.FontRole and index.row() == self.pos:
f = QApplication.instance().font()
f.setBold(True)
return f
if role == Qt.ItemDataRole.UserRole:
return self.states[index.row()]
return None
def label_for_row(self, row):
msg = self.states[row].message
if self.pos == row:
msg = _('Current state') + ('' if not msg else _(' [was %s]') % msg)
elif not msg:
msg = _('[Unnamed state]')
else:
msg = msg
return msg
def label_for_container(self, container):
for i, state in enumerate(self.states):
if state.container is container:
return self.label_for_row(i)
@property
def current_container(self):
return self.states[self.pos].container
@property
def previous_container(self):
return self.states[self.pos - 1].container
def open_book(self, container):
self.beginResetModel()
self.states = [State(container)]
self.pos = 0
self.endResetModel()
def truncate(self):
extra = self.states[self.pos+1:]
if extra:
self.beginRemoveRows(ROOT, self.pos+1, len(self.states) - 1)
cleanup(extra)
self.states = self.states[:self.pos+1]
if extra:
self.endRemoveRows()
def add_savepoint(self, new_container, message):
try:
self.states[self.pos].rewind_message = self.states[self.pos].message
self.states[self.pos].message = message
except IndexError:
raise IndexError('The checkpoint stack has an incorrect position pointer.'
f' This should never happen: pos={self.pos!r}, len_states={len(self.states)=}')
self.truncate()
self.beginInsertRows(ROOT, self.pos+1, self.pos+1)
self.states.append(State(new_container))
self.pos += 1
self.endInsertRows()
self.dataChanged.emit(self.index(self.pos-1), self.index(self.pos))
if len(self.states) > MAX_SAVEPOINTS:
num = len(self.states) - MAX_SAVEPOINTS
self.beginRemoveRows(ROOT, 0, num - 1)
cleanup(self.states[:num])
self.states = self.states[num:]
self.pos -= num
self.endRemoveRows()
def rewind_savepoint(self):
''' Revert back to the last save point, should only be used immediately
after a call to add_savepoint. If there are intervening calls to undo
or redo, behavior is undefined. This is intended to be used in the case
where you create savepoint, perform some operation, operation fails, so
revert to state before creating savepoint. '''
if self.pos > 0 and self.pos == len(self.states) - 1:
self.beginRemoveRows(ROOT, self.pos, self.pos)
self.pos -= 1
cleanup([self.states.pop().container])
self.endRemoveRows()
self.dataChanged.emit(self.index(self.pos), self.index(self.pos))
ans = self.current_container
self.states[self.pos].message = self.states[self.pos].rewind_message
return ans
def undo(self):
if self.pos > 0:
self.pos -= 1
self.dataChanged.emit(self.index(self.pos), self.index(self.pos+1))
return self.current_container
def redo(self):
if self.pos < len(self.states) - 1:
self.pos += 1
self.dataChanged.emit(self.index(self.pos-1), self.index(self.pos))
return self.current_container
def revert_to(self, container):
for i, state in enumerate(self.states):
if state.container is container:
opos = self.pos
self.pos = i
for x in (i, opos):
self.dataChanged.emit(self.index(x), self.index(x))
return container
@property
def can_undo(self):
return self.pos > 0
@property
def can_redo(self):
return self.pos < len(self.states) - 1
@property
def undo_msg(self):
if not self.can_undo:
return ''
return self.states[self.pos - 1].message or ''
@property
def redo_msg(self):
if not self.can_redo:
return ''
return self.states[self.pos + 1].message or _('[Unnamed state]')
def update_path_to_ebook(self, path):
for state in self.states:
state.container.path_to_ebook = path
class SpacedDelegate(QStyledItemDelegate):
def sizeHint(self, *args):
ans = QStyledItemDelegate.sizeHint(self, *args)
ans.setHeight(ans.height() + 4)
return ans
class CheckpointView(QWidget):
revert_requested = pyqtSignal(object)
compare_requested = pyqtSignal(object)
def __init__(self, model, parent=None):
QWidget.__init__(self, parent)
self.l = l = QGridLayout(self)
self.setLayout(l)
self.setContentsMargins(0, 0, 0, 0)
self.view = v = QListView(self)
self.d = SpacedDelegate(v)
v.doubleClicked.connect(self.double_clicked)
v.setItemDelegate(self.d)
v.setModel(model)
l.addWidget(v, 0, 0, 1, -1)
model.dataChanged.connect(self.data_changed)
self.rb = b = QPushButton(QIcon.ic('edit-undo.png'), _('&Revert to'), self)
b.setToolTip(_('Revert the book to the selected checkpoint'))
b.clicked.connect(self.revert_clicked)
l.addWidget(b, 1, 1)
self.cb = b = QPushButton(QIcon.ic('diff.png'), _('&Compare'), self)
b.setToolTip(_('Compare the state of the book at the selected checkpoint with the current state'))
b.clicked.connect(self.compare_clicked)
l.addWidget(b, 1, 0)
def data_changed(self, *args):
self.view.clearSelection()
m = self.view.model()
sm = self.view.selectionModel()
sm.select(m.index(m.pos), QItemSelectionModel.SelectionFlag.ClearAndSelect)
self.view.setCurrentIndex(m.index(m.pos))
def double_clicked(self, index):
pass # Too much danger of accidental double click
def revert_clicked(self):
m = self.view.model()
row = self.view.currentIndex().row()
if row < 0:
return
if row == m.pos:
return error_dialog(self, _('Cannot revert'), _(
'Cannot revert to the current state'), show=True)
self.revert_requested.emit(m.states[row].container)
def compare_clicked(self):
m = self.view.model()
row = self.view.currentIndex().row()
if row < 0:
return
if row == m.pos:
return error_dialog(self, _('Cannot compare'), _(
'There is no point comparing the current state to itself'), show=True)
self.compare_requested.emit(m.states[row].container)
| 8,109 | Python | .py | 207 | 30.115942 | 108 | 0.611203 | kovidgoyal/calibre | 19,243 | 2,250 | 4 | GPL-3.0 | 9/5/2024, 5:13:50 PM (Europe/Amsterdam) |
26,688 | templates.py | kovidgoyal_calibre/src/calibre/gui2/tweak_book/templates.py | #!/usr/bin/env python
__license__ = 'GPL v3'
__copyright__ = '2013, Kovid Goyal <kovid at kovidgoyal.net>'
from calibre import prepare_string_for_xml
from calibre.gui2.tweak_book import current_container, tprefs
from polyglot.builtins import iteritems
DEFAULT_TEMPLATES = {
'html':
'''\
<?xml version='1.0' encoding='utf-8'?>
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<title>{TITLE}</title>
</head>
<body>
%CURSOR%
</body>
</html>
''',
'css':
'''\
@charset "utf-8";
/* Styles for {TITLE} */
%CURSOR%
''',
}
def raw_template_for(syntax):
return tprefs['templates'].get(syntax, DEFAULT_TEMPLATES.get(syntax, ''))
def template_for(syntax):
mi = current_container().mi
data = {
'TITLE':mi.title,
'AUTHOR': ' & '.join(mi.authors),
}
return raw_template_for(syntax).format(
**{k:prepare_string_for_xml(v, True) for k, v in iteritems(data)})
| 916 | Python | .py | 36 | 22.444444 | 77 | 0.658986 | kovidgoyal/calibre | 19,243 | 2,250 | 4 | GPL-3.0 | 9/5/2024, 5:13:50 PM (Europe/Amsterdam) |
26,689 | ui.py | kovidgoyal_calibre/src/calibre/gui2/tweak_book/ui.py | #!/usr/bin/env python
__license__ = 'GPL v3'
__copyright__ = '2013, Kovid Goyal <kovid at kovidgoyal.net>'
import os
from functools import partial
from itertools import product
from qt.core import (
QAction,
QDockWidget,
QEvent,
QHBoxLayout,
QIcon,
QLabel,
QMenu,
QMenuBar,
QSize,
QStackedWidget,
Qt,
QTabWidget,
QTimer,
QUrl,
QVBoxLayout,
QWidget,
pyqtSignal,
)
from calibre import prints
from calibre.constants import DEBUG, __appname__, get_version, ismacos
from calibre.customize.ui import find_plugin
from calibre.gui2 import elided_text, open_url
from calibre.gui2.keyboard import Manager as KeyboardManager
from calibre.gui2.main_window import MainWindow
from calibre.gui2.throbber import ThrobbingButton
from calibre.gui2.tweak_book import actions, capitalize, current_container, editors, toolbar_actions, tprefs, update_mark_text_action
from calibre.gui2.tweak_book.boss import Boss
from calibre.gui2.tweak_book.char_select import CharSelect
from calibre.gui2.tweak_book.check import Check
from calibre.gui2.tweak_book.check_links import CheckExternalLinks
from calibre.gui2.tweak_book.editor.insert_resource import InsertImage
from calibre.gui2.tweak_book.editor.widget import register_text_editor_actions
from calibre.gui2.tweak_book.file_list import FileListWidget
from calibre.gui2.tweak_book.function_replace import DebugOutput
from calibre.gui2.tweak_book.job import BlockingJob
from calibre.gui2.tweak_book.live_css import LiveCSS
from calibre.gui2.tweak_book.manage_fonts import ManageFonts
from calibre.gui2.tweak_book.plugin import create_plugin_actions, install_plugin
from calibre.gui2.tweak_book.preview import Preview
from calibre.gui2.tweak_book.reports import Reports
from calibre.gui2.tweak_book.search import SavedSearches, SearchPanel
from calibre.gui2.tweak_book.spell import SpellCheck
from calibre.gui2.tweak_book.text_search import TextSearch
from calibre.gui2.tweak_book.toc import TOCViewer
from calibre.gui2.tweak_book.undo import CheckpointView
from calibre.gui2.widgets2 import MessagePopup
from calibre.utils.icu import ord_string, sort_key
from calibre.utils.localization import localize_user_manual_link, localize_website_link, pgettext
from calibre.utils.unicode_names import character_name_from_code
from polyglot.builtins import iteritems, itervalues
def open_donate():
open_url(QUrl(localize_website_link('https://calibre-ebook.com/donate')))
class Central(QStackedWidget): # {{{
' The central widget, hosts the editors '
current_editor_changed = pyqtSignal()
close_requested = pyqtSignal(object)
def __init__(self, parent=None):
QStackedWidget.__init__(self, parent)
self.welcome = w = QLabel('<p>'+_(
'Double click a file in the left panel to start editing'
' it.'))
self.addWidget(w)
w.setWordWrap(True)
w.setAlignment(Qt.AlignmentFlag.AlignTop | Qt.AlignmentFlag.AlignHCenter)
self.container = c = QWidget(self)
self.addWidget(c)
l = c.l = QVBoxLayout(c)
c.setLayout(l)
l.setContentsMargins(0, 0, 0, 0)
self.editor_tabs = t = QTabWidget(c)
l.addWidget(t)
t.setDocumentMode(True)
t.setTabsClosable(True)
t.setMovable(True)
self.modified_icon = QIcon.ic('modified.png')
self.editor_tabs.currentChanged.connect(self.current_editor_changed)
self.editor_tabs.tabCloseRequested.connect(self._close_requested)
self.search_panel = SearchPanel(self)
l.addWidget(self.search_panel)
self.restore_state()
self.editor_tabs.tabBar().installEventFilter(self)
def _close_requested(self, index):
editor = self.editor_tabs.widget(index)
self.close_requested.emit(editor)
def add_editor(self, name, editor):
fname = name.rpartition('/')[2]
index = self.editor_tabs.addTab(editor, fname)
self.editor_tabs.setTabToolTip(index, _('Full path:') + ' ' + name)
editor.modification_state_changed.connect(self.editor_modified)
@property
def tab_order(self):
ans = []
rmap = {v:k for k, v in iteritems(editors)}
for i in range(self.editor_tabs.count()):
name = rmap.get(self.editor_tabs.widget(i))
if name is not None:
ans.append(name)
return ans
def rename_editor(self, editor, name):
for i in range(self.editor_tabs.count()):
if self.editor_tabs.widget(i) is editor:
fname = name.rpartition('/')[2]
self.editor_tabs.setTabText(i, fname)
self.editor_tabs.setTabToolTip(i, _('Full path:') + ' ' + name)
def show_editor(self, editor):
self.setCurrentIndex(1)
self.editor_tabs.setCurrentWidget(editor)
def close_editor(self, editor):
for i in range(self.editor_tabs.count()):
if self.editor_tabs.widget(i) is editor:
self.editor_tabs.removeTab(i)
if self.editor_tabs.count() == 0:
self.setCurrentIndex(0)
return True
return False
def editor_modified(self, *args):
tb = self.editor_tabs.tabBar()
for i in range(self.editor_tabs.count()):
editor = self.editor_tabs.widget(i)
modified = getattr(editor, 'is_modified', False)
tb.setTabIcon(i, self.modified_icon if modified else QIcon())
def close_current_editor(self):
ed = self.current_editor
if ed is not None:
self.close_requested.emit(ed)
def close_all_but_current_editor(self):
self.close_all_but(self.current_editor)
def close_to_right_of_current_editor(self):
self.close_to_right(self.current_editor)
def close_all_but(self, ed):
close = []
if ed is not None:
for i in range(self.editor_tabs.count()):
q = self.editor_tabs.widget(i)
if q is not None and q is not ed:
close.append(q)
for q in close:
self.close_requested.emit(q)
def close_to_right(self, ed):
close = []
if ed is not None:
found = False
for i in range(self.editor_tabs.count()):
q = self.editor_tabs.widget(i)
if found:
close.append(q)
elif q is ed:
found = True
for q in close:
self.close_requested.emit(q)
@property
def current_editor(self):
return self.editor_tabs.currentWidget()
def save_state(self):
tprefs.set('search-panel-visible', self.search_panel.isVisible())
self.search_panel.save_state()
for ed in itervalues(editors):
ed.save_state()
if self.current_editor is not None:
self.current_editor.save_state() # Ensure the current editor saves it state last
def restore_state(self):
self.search_panel.setVisible(tprefs.get('search-panel-visible', False))
self.search_panel.restore_state()
def show_find(self):
self.search_panel.show_panel()
def pre_fill_search(self, text):
self.search_panel.pre_fill(text)
def eventFilter(self, obj, event):
base = super()
if obj is not self.editor_tabs.tabBar() or event.type() != QEvent.Type.MouseButtonPress or event.button() not in (
Qt.MouseButton.RightButton, Qt.MouseButton.MiddleButton):
return base.eventFilter(obj, event)
index = self.editor_tabs.tabBar().tabAt(event.pos())
if index < 0:
return base.eventFilter(obj, event)
if event.button() == Qt.MouseButton.MiddleButton:
self._close_requested(index)
ed = self.editor_tabs.widget(index)
if ed is not None:
menu = QMenu(self)
menu.addAction(actions['close-current-tab'].icon(), _('Close tab'), partial(self.close_requested.emit, ed))
menu.addSeparator()
menu.addAction(actions['close-all-but-current-tab'].icon(), _('Close other tabs'), partial(self.close_all_but, ed))
menu.addAction(actions['close-tabs-to-right-of'].icon(), _('Close tabs to the right of this tab'), partial(self.close_to_right, ed))
menu.exec(self.editor_tabs.tabBar().mapToGlobal(event.pos()))
return True
# }}}
class CursorPositionWidget(QWidget): # {{{
def __init__(self, parent):
QWidget.__init__(self, parent)
self.l = QHBoxLayout(self)
self.setLayout(self.l)
self.la = QLabel('')
self.l.addWidget(self.la)
self.l.setContentsMargins(0, 0, 0, 0)
f = self.la.font()
f.setBold(False)
self.la.setFont(f)
def update_position(self, line=None, col=None, character=None):
if line is None:
self.la.setText('')
else:
try:
name = character_name_from_code(ord_string(character)[0]) if character and tprefs['editor_show_char_under_cursor'] else None
except Exception:
name = None
text = _('Line: {0} : {1}').format(line, col)
if not name:
name = {'\t':'TAB'}.get(character, None)
if name and tprefs['editor_show_char_under_cursor']:
text = name + ' : ' + text
self.la.setText(text)
# }}}
def install_new_plugins():
from calibre.utils.config import JSONConfig
prefs = JSONConfig('newly-installed-editor-plugins')
pl = prefs.get('newly_installed_plugins', ())
if pl:
for name in pl:
plugin = find_plugin(name)
if plugin is not None:
install_plugin(plugin)
prefs['newly_installed_plugins'] = []
class Main(MainWindow):
APP_NAME = _('Edit book')
STATE_VERSION = 0
undo_requested = pyqtSignal(object)
def __init__(self, opts, notify=None):
MainWindow.__init__(self, opts, disable_automatic_gc=True)
self.message_popup = MessagePopup(self)
self.message_popup.undo_requested.connect(self.undo_requested)
try:
install_new_plugins()
except Exception:
import traceback
traceback.print_exc()
self.setWindowTitle(self.APP_NAME)
self.boss = Boss(self, notify=notify)
self.setWindowIcon(QIcon.ic('tweak.png'))
self.opts = opts
self.path_to_ebook = None
self.container = None
self.current_metadata = None
self.blocking_job = BlockingJob(self)
self.keyboard = KeyboardManager(self, config_name='shortcuts/tweak_book')
self.central = Central(self)
self.setCentralWidget(self.central)
self.check_book = Check(self)
self.spell_check = SpellCheck(parent=self)
self.toc_view = TOCViewer(self)
self.text_search = TextSearch(self)
self.saved_searches = SavedSearches(self)
self.image_browser = InsertImage(self, for_browsing=True)
self.reports = Reports(self)
self.check_external_links = CheckExternalLinks(self)
self.insert_char = CharSelect(self)
self.manage_fonts = ManageFonts(self)
self.sr_debug_output = DebugOutput(self)
self.create_actions()
self.create_toolbars()
self.create_docks()
self.create_menubar()
self.status_bar = self.statusBar()
self.status_bar.addPermanentWidget(self.boss.save_manager.status_widget)
self.cursor_position_widget = CursorPositionWidget(self)
self.status_bar.addPermanentWidget(self.cursor_position_widget)
v = get_version()
self.status_bar_default_msg = la = QLabel(' ' + _('{0} {1} created by {2}').format(__appname__, v, 'Kovid Goyal'))
la.base_template = str(la.text())
la.editing_template = _('{appname} {version} editing: {{path}}').format(appname=__appname__, version=v)
self.status_bar.addWidget(la)
self.boss(self)
g = self.screen().availableSize()
self.resize(g.width()-50, g.height()-50)
self.apply_settings()
QTimer.singleShot(0, self.restore_state)
def apply_settings(self):
self.keyboard.finalize()
self.setDockNestingEnabled(tprefs['nestable_dock_widgets'])
for v, h in product(('top', 'bottom'), ('left', 'right')):
p = f'dock_{v}_{h}'
pref = tprefs[p] or tprefs.defaults[p]
area = getattr(Qt.DockWidgetArea, '%sDockWidgetArea' % capitalize({'vertical':h, 'horizontal':v}[pref]))
self.setCorner(getattr(Qt.Corner, '%s%sCorner' % tuple(map(capitalize, (v, h)))), area)
self.preview.apply_settings()
self.live_css.apply_theme()
for bar in (self.global_bar, self.tools_bar, self.plugins_bar):
bar.setIconSize(QSize(tprefs['toolbar_icon_size'], tprefs['toolbar_icon_size']))
def show_status_message(self, msg, timeout=5):
self.status_bar.showMessage(msg, int(timeout*1000))
def update_status_bar_default_message(self, path=''):
m = self.status_bar_default_msg
if path:
m.setText(m.editing_template.format(path=path))
else:
m.setText(m.base_template)
def elided_text(self, text, width=300):
return elided_text(text, font=self.font(), width=width)
@property
def editor_tabs(self):
return self.central.editor_tabs
def create_actions(self):
group = _('Global actions')
def reg(icon, text, target, sid, keys, description, toolbar_allowed=False):
if not isinstance(icon, QIcon):
icon = QIcon.ic(icon)
ac = actions[sid] = QAction(icon, text, self) if icon else QAction(text, self)
ac.setObjectName('action-' + sid)
if toolbar_allowed:
toolbar_actions[sid] = ac
if target is not None:
ac.triggered.connect(target)
if isinstance(keys, str):
keys = (keys,)
self.keyboard.register_shortcut(
sid, str(ac.text()).replace('&', ''), default_keys=keys, description=description, action=ac, group=group)
self.addAction(ac)
return ac
def treg(icon, text, target, sid, keys, description):
return reg(icon, text, target, sid, keys, description, toolbar_allowed=icon is not None)
self.action_new_file = treg('document-new.png', _('&New file (images/fonts/HTML/etc.)'), self.boss.add_file,
'new-file', (), _('Create a new file in the current book'))
self.action_import_files = treg('document-import.png', _('&Import files into book'), self.boss.add_files, 'new-files', (), _('Import files into book'))
self.action_open_book = treg('document_open.png', _('&Open book'), self.boss.open_book, 'open-book', 'Ctrl+O', _('Open a book'))
self.action_open_book_folder = treg('mimetypes/dir.png', _('Open &folder (unzipped EPUB) as book'), partial(self.boss.open_book, open_folder=True),
'open-folder-as-book', (), _('Open a folder (unzipped EPUB) as a book'))
self.action_edit_next_file = treg('arrow-down.png', _('Edit &next file'), partial(self.boss.edit_next_file, backwards=False),
'edit-next-file', 'Ctrl+Alt+Down', _('Edit the next file in the spine'))
self.action_edit_previous_file = treg('arrow-up.png', _('Edit &previous file'), partial(self.boss.edit_next_file, backwards=True),
'edit-previous-file', 'Ctrl+Alt+Up', _('Edit the previous file in the spine'))
# Qt does not generate shortcut overrides for cmd+arrow on os x which
# means these shortcuts interfere with editing
self.action_global_undo = treg('back.png', _('&Revert to before'), self.boss.do_global_undo, 'global-undo', () if ismacos else 'Ctrl+Left',
_('Revert book to before the last action (Undo)'))
self.action_global_redo = treg('forward.png', _('&Revert to after'), self.boss.do_global_redo, 'global-redo', () if ismacos else 'Ctrl+Right',
_('Revert book state to after the next action (Redo)'))
self.action_save = treg('save.png', _('&Save'), self.boss.save_book, 'save-book', 'Ctrl+S', _('Save book'))
self.action_save.setEnabled(False)
self.action_save_copy = treg('save.png', _('Save a ©'), self.boss.save_copy, 'save-copy', 'Ctrl+Alt+S', _('Save a copy of the book'))
self.action_save_copy_edit = treg('save.png', _('Save a © and edit in new window'), partial(self.boss._save_copy, 'edit'), 'save-copy-edit',
'Ctrl+Shift+S', _( 'Save a copy of the book and edit it in a new window'))
self.action_save_copy_replace = treg('save.png', _('Save a © and edit here'), partial(self.boss._save_copy, 'replace'),
'save-copy-replace', 'Ctrl+Alt+Shift+S', _('Save a copy of the book and edit it in this window'))
self.action_quit = treg('window-close.png', _('&Quit'), self.boss.quit, 'quit', 'Ctrl+Q', _('Quit'))
self.action_preferences = treg('config.png', _('&Preferences'), self.boss.preferences, 'preferences', 'Ctrl+P', _('Preferences'))
self.action_new_book = treg('plus.png', _('Create new, &empty book'), self.boss.new_book, 'new-book', (), _('Create a new, empty book'))
self.action_import_book = treg('add_book.png', _('&Import an HTML or DOCX file as a new book'),
self.boss.import_book, 'import-book', (), _('Import an HTML or DOCX file as a new book'))
self.action_quick_edit = treg('modified.png', _('&Quick open a file to edit'), self.boss.quick_open, 'quick-open', ('Ctrl+T'), _(
'Quickly open a file from the book to edit it'))
self.action_editor_toggle_wrap = treg(
'format-justify-fill.png', _('Toggle code line &wrapping'), self.boss.toggle_line_wrapping_in_all_editors, 'editor-toggle-wrap', (), _(
'Toggle line wrapping in all code editor tabs'))
# Editor actions
group = _('Editor actions')
self.action_editor_undo = reg('edit-undo.png', _('&Undo'), self.boss.do_editor_undo, 'editor-undo', 'Ctrl+Z',
_('Undo typing'))
self.action_editor_redo = reg('edit-redo.png', _('R&edo'), self.boss.do_editor_redo, 'editor-redo', 'Ctrl+Y',
_('Redo typing'))
self.action_editor_cut = reg('edit-cut.png', _('Cut &text'), self.boss.do_editor_cut, 'editor-cut', ('Ctrl+X', 'Shift+Delete', ),
_('Cut text'))
self.action_editor_copy = reg('edit-copy.png', _('&Copy to clipboard'), self.boss.do_editor_copy, 'editor-copy', ('Ctrl+C', 'Ctrl+Insert'),
_('Copy to clipboard'))
self.action_editor_paste = reg('edit-paste.png', _('P&aste from clipboard'), self.boss.do_editor_paste, 'editor-paste', ('Ctrl+V', 'Shift+Insert', ),
_('Paste from clipboard'))
self.action_editor_cut.setEnabled(False)
self.action_editor_copy.setEnabled(False)
self.action_editor_undo.setEnabled(False)
self.action_editor_redo.setEnabled(False)
# Tool actions
group = _('Tools')
self.action_toc = treg('toc.png', _('&Edit Table of Contents'), self.boss.edit_toc, 'edit-toc', (), _('Edit Table of Contents'))
self.action_inline_toc = treg('chapters.png', _('&Insert inline Table of Contents'),
self.boss.insert_inline_toc, 'insert-inline-toc', (), _('Insert inline Table of Contents'))
self.action_fix_html_current = reg('html-fix.png', _('&Fix HTML'), partial(self.boss.fix_html, True), 'fix-html-current', (),
_('Fix HTML in the current file'))
self.action_fix_html_all = treg('html-fix.png', _('&Fix HTML - all files'), partial(self.boss.fix_html, False), 'fix-html-all', (),
_('Fix HTML in all files'))
self.action_pretty_current = reg('beautify.png', _('&Beautify current file'), partial(self.boss.pretty_print, True), 'pretty-current', (),
_('Beautify current file'))
self.action_pretty_all = treg('beautify.png', _('&Beautify all files'), partial(self.boss.pretty_print, False), 'pretty-all', (),
_('Beautify all files'))
self.action_insert_char = treg('character-set.png', _('&Insert special character'), self.boss.insert_character, 'insert-character', (),
_('Insert special character'))
self.action_rationalize_folders = treg('mimetypes/dir.png', _('&Arrange into folders'), self.boss.rationalize_folders, 'rationalize-folders', (),
_('Arrange into folders'))
self.action_set_semantics = treg('tags.png', _('Set &semantics'), self.boss.set_semantics, 'set-semantics', (),
_('Set semantics'))
self.action_filter_css = treg('filter.png', _('&Filter style information'), self.boss.filter_css, 'filter-css', (),
_('Filter style information'))
self.action_manage_fonts = treg('font.png', _('&Manage fonts'), self.boss.manage_fonts, 'manage-fonts', (), _('Manage fonts in the book'))
self.action_add_cover = treg('default_cover.png', _('Add &cover'), self.boss.add_cover, 'add-cover', (), _('Add a cover to the book'))
self.action_reports = treg(
'reports.png', _('&Reports'), self.boss.show_reports, 'show-reports', ('Ctrl+Shift+R',), _('Show a report on various aspects of the book'))
self.action_check_external_links = treg('insert-link.png', _('Check &external links'), self.boss.check_external_links, 'check-external-links', (), _(
'Check external links in the book'))
self.action_compress_images = treg('compress-image.png', _('C&ompress images losslessly'), self.boss.compress_images, 'compress-images', (), _(
'Compress images losslessly'))
self.action_transform_styles = treg('wizard.png', _('Transform &styles'), self.boss.transform_styles, 'transform-styles', (), _(
'Transform styles used in the book'))
self.action_transform_html = treg('wizard.png', _('Transform &HTML'), self.boss.transform_html, 'transform-html', (), _(
'Transform HTML used in the book'))
self.action_get_ext_resources = treg('download-metadata.png', _('Download external &resources'),
self.boss.get_external_resources, 'get-external-resources', (), _(
'Download external resources in the book (images/stylesheets/etc/ that are not included in the book)'))
self.action_embed_tts = treg('bullhorn.png', _('Add Text-to-speech narration'), self.boss.embed_tts, 'embed-tts', (), _(
'Add audio narration for all the book text using Text-to-speech generation'))
def ereg(icon, text, target, sid, keys, description):
return reg(icon, text, partial(self.boss.editor_action, target), sid, keys, description)
register_text_editor_actions(ereg, self.palette())
# Polish actions
group = _('Polish book')
self.action_subset_fonts = treg(
'subset-fonts.png', _('&Subset embedded fonts'), partial(
self.boss.polish, 'subset', _('Subset fonts')), 'subset-fonts', (), _('Subset embedded fonts'))
self.action_embed_fonts = treg(
'embed-fonts.png', _('&Embed referenced fonts'), partial(
self.boss.polish, 'embed', _('Embed fonts')), 'embed-fonts', (), _('Embed referenced fonts'))
self.action_smarten_punctuation = treg(
'smarten-punctuation.png', _('&Smarten punctuation (works best for English)'), partial(
self.boss.polish, 'smarten_punctuation', _('Smarten punctuation')),
'smarten-punctuation', (), _('Smarten punctuation'))
self.action_remove_unused_css = treg(
'edit-clear.png', _('Remove &unused CSS rules'), partial(
self.boss.polish, 'remove_unused_css', _('Remove unused CSS rules')), 'remove-unused-css', (), _('Remove unused CSS rules'))
self.action_upgrade_book_internals = treg(
'arrow-up.png', _('&Upgrade book internals'), partial(
self.boss.polish, 'upgrade_book', _('Upgrade book internals')), 'upgrade-book', (), _('Upgrade book internals'))
# Preview actions
group = _('Preview')
self.action_auto_reload_preview = reg('auto-reload.png', _('Auto reload preview'), None, 'auto-reload-preview', (), _('Auto reload preview'))
self.action_auto_sync_preview = reg('sync-right.png', _('Sync preview position to editor position'), None, 'sync-preview-to-editor', (), _(
'Sync preview position to editor position'))
self.action_reload_preview = reg('view-refresh.png', _('Refresh preview'), None, 'reload-preview', ('F5',), _('Refresh preview'))
self.action_split_in_preview = reg('document-split.png', _('Split this file'), None, 'split-in-preview', (), _(
'Split file in the preview panel'))
self.action_find_next_preview = reg('arrow-down.png', _('Find next'), None, 'find-next-preview', (), _('Find next in preview'))
self.action_find_prev_preview = reg('arrow-up.png', _('Find previous'), None, 'find-prev-preview', (), _('Find previous in preview'))
# Search actions
group = _('Search')
self.action_find = treg('search.png', _('&Find/replace'), self.boss.show_find, 'find-replace', ('Ctrl+F',), _('Show the Find/replace panel'))
def sreg(name, text, action, overrides={}, keys=(), description=None, icon=None):
return reg(icon, text, partial(self.boss.search_action_triggered, action, overrides), name, keys, description or text.replace('&', ''))
self.action_find_next = sreg('find-next', _('Find &next'),
'find', {'direction':'down'}, ('F3', 'Ctrl+G'), _('Find next match'))
self.action_find_previous = sreg('find-previous', _('Find &previous'),
'find', {'direction':'up'}, ('Shift+F3', 'Shift+Ctrl+G'), _('Find previous match'))
self.action_replace = sreg('replace', _('&Replace'),
'replace', keys=('Ctrl+R'), description=_('Replace current match'))
self.action_replace_next = sreg('replace-next', _('Replace and find ne&xt'),
'replace-find', {'direction':'down'}, ('Ctrl+]'), _('Replace current match and find next'))
self.action_replace_previous = sreg('replace-previous', _('R&eplace and find previous'),
'replace-find', {'direction':'up'}, ('Ctrl+['), _('Replace current match and find previous'))
self.action_replace_all = sreg('replace-all', _('Replace &all'),
'replace-all', keys=('Ctrl+A'), description=_('Replace all matches'))
self.action_count = sreg('count-matches', _('&Count all'),
'count', keys=('Ctrl+N'), description=_('Count number of matches'))
self.action_mark = reg(None, _('&Mark selected text'), self.boss.mark_selected_text, 'mark-selected-text', ('Ctrl+Shift+M',),
_('Mark selected text or unmark already marked text'))
self.action_mark.default_text = self.action_mark.text()
self.action_go_to_line = reg(None, _('Go to &line'), self.boss.go_to_line_number, 'go-to-line-number', ('Ctrl+.',), _('Go to line number'))
self.action_saved_searches = treg('folder_saved_search.png', _('Sa&ved searches'),
self.boss.saved_searches, 'saved-searches', (), _('Show the saved searches dialog'))
self.action_text_search = treg('view.png', _('&Search ignoring HTML markup'),
self.boss.show_text_search, 'text-search', (), _('Show the text search panel'))
# Check Book actions
group = _('Check book')
self.action_check_book = treg('debug.png', _('C&heck book'), self.boss.check_requested, 'check-book', ('F7'), _('Check book for errors'))
self.action_spell_check_book = treg('spell-check.png', _('Check &spelling'), self.boss.spell_check_requested, 'spell-check-book', ('Alt+F7'), _(
'Check book for spelling errors'))
self.action_check_book_next = reg('forward.png', _('&Next error'), partial(
self.check_book.next_error, delta=1), 'check-book-next', ('Ctrl+F7'), _('Show next error'))
self.action_check_book_previous = reg('back.png', _('&Previous error'), partial(
self.check_book.next_error, delta=-1), 'check-book-previous', ('Ctrl+Shift+F7'), _('Show previous error'))
self.action_spell_check_next = reg('forward.png', _('&Next spelling mistake'),
self.boss.next_spell_error, 'spell-next', ('F8'), _('Go to next spelling mistake'))
# Miscellaneous actions
group = pgettext('edit book actions', 'Miscellaneous')
self.action_create_checkpoint = treg(
'marked.png', _('&Create checkpoint'), self.boss.create_checkpoint, 'create-checkpoint', (), _(
'Create a checkpoint with the current state of the book'))
self.action_close_current_tab = reg(
'window-close.png', _('&Close current tab'), self.central.close_current_editor, 'close-current-tab', 'Ctrl+W', _(
'Close the currently open tab'))
self.action_close_all_but_current_tab = reg(
'edit-clear.png', _('C&lose other tabs'), self.central.close_all_but_current_editor, 'close-all-but-current-tab', 'Ctrl+Alt+W', _(
'Close all tabs except the current tab'))
self.action_close_to_right = reg(
'edit-clear.png', _('Close tabs to the &right'), self.central.close_to_right_of_current_editor, 'close-tabs-to-right-of', 'Ctrl+Shift+W', _(
'Close tabs to the right of the current tab'))
self.action_help = treg(
'help.png', _('User &Manual'), lambda : open_url(QUrl(localize_user_manual_link(
'https://manual.calibre-ebook.com/edit.html'))), 'user-manual', 'F1', _(
'Show User Manual'))
self.action_browse_images = treg(
'view-image.png', _('&Browse images in book'), self.boss.browse_images, 'browse-images', (), _(
'Browse images in the books visually'))
self.action_multiple_split = treg(
'document-split.png', _('&Split at multiple locations'), self.boss.multisplit, 'multisplit', (), _(
'Split HTML file at multiple locations'))
self.action_compare_book = treg('diff.png', _('Compare to &another book'), self.boss.compare_book, 'compare-book', (), _(
'Compare to another book'))
self.action_manage_snippets = treg(
'snippets.png', _('Manage &Snippets'), self.boss.manage_snippets, 'manage-snippets', (), _(
'Manage user created Snippets'))
self.action_merge_files = treg(
'merge.png', _('&Merge files'), self.boss.merge_files, 'merge-files', 'Ctrl+M', _(
'Merge two or more selected files'))
self.plugin_menu_actions = []
create_plugin_actions(actions, toolbar_actions, self.plugin_menu_actions)
def create_menubar(self):
if ismacos:
p, q = self.create_application_menubar()
q.triggered.connect(self.action_quit.trigger)
p.triggered.connect(self.action_preferences.trigger)
b = QMenuBar(self)
self.setMenuBar(b)
b.is_native_menubar = False
f = b.addMenu(_('&File'))
f.addAction(self.action_new_file)
f.addAction(self.action_import_files)
f.addSeparator()
f.addAction(self.action_open_book)
f.addAction(self.action_new_book)
f.addAction(self.action_import_book)
f.addAction(self.action_open_book_folder)
self.recent_books_menu = f.addMenu(_('&Recently opened books'))
self.update_recent_books()
f.addSeparator()
f.addAction(self.action_save)
m = f.addMenu(_('Save a copy'))
m.addAction(self.action_save_copy)
m.addAction(self.action_save_copy_edit)
m.addAction(self.action_save_copy_replace)
f.addSeparator()
f.addAction(self.action_compare_book)
f.addAction(self.action_quit)
e = b.addMenu(_('&Edit'))
e.addAction(self.action_global_undo)
e.addAction(self.action_global_redo)
e.addAction(self.action_create_checkpoint)
e.addSeparator()
e.addAction(self.action_editor_undo)
e.addAction(self.action_editor_redo)
e.addSeparator()
e.addAction(self.action_editor_cut)
e.addAction(self.action_editor_copy)
e.addAction(self.action_editor_paste)
e.addAction(self.action_insert_char)
e.addSeparator()
e.addAction(self.action_quick_edit)
e.addAction(self.action_preferences)
e = b.addMenu(_('&Tools'))
tm = e.addMenu(_('Table of Contents'))
tm.addAction(self.action_toc)
tm.addAction(self.action_inline_toc)
e.addAction(self.action_manage_fonts)
e.addAction(self.action_embed_fonts)
e.addAction(self.action_subset_fonts)
e.addAction(self.action_compress_images)
e.addAction(self.action_smarten_punctuation)
e.addAction(self.action_remove_unused_css)
e.addAction(self.action_transform_styles)
e.addAction(self.action_transform_html)
e.addAction(self.action_fix_html_all)
e.addAction(self.action_embed_tts)
e.addAction(self.action_pretty_all)
e.addAction(self.action_rationalize_folders)
e.addAction(self.action_add_cover)
e.addAction(self.action_set_semantics)
e.addAction(self.action_filter_css)
e.addAction(self.action_spell_check_book)
er = e.addMenu(_('External &links'))
er.addAction(self.action_check_external_links)
er.addAction(self.action_get_ext_resources)
e.addAction(self.action_check_book)
e.addAction(self.action_reports)
e.addAction(self.action_upgrade_book_internals)
e = b.addMenu(_('&View'))
t = e.addMenu(_('Tool&bars'))
e.addSeparator()
for name in sorted(actions, key=lambda x:sort_key(actions[x].text())):
ac = actions[name]
if name.endswith('-dock'):
e.addAction(ac)
elif name.endswith('-bar'):
t.addAction(ac)
e.addAction(self.action_browse_images)
e.addSeparator()
e.addAction(self.action_close_current_tab)
e.addAction(self.action_close_all_but_current_tab)
e = b.addMenu(_('&Search'))
a = e.addAction
a(self.action_find)
e.addSeparator()
a(self.action_find_next)
a(self.action_find_previous)
e.addSeparator()
a(self.action_replace)
a(self.action_replace_next)
a(self.action_replace_previous)
a(self.action_replace_all)
e.addSeparator()
a(self.action_count)
e.addSeparator()
a(self.action_mark)
e.addSeparator()
a(self.action_go_to_line)
e.addSeparator()
a(self.action_saved_searches)
e.aboutToShow.connect(self.search_menu_about_to_show)
e.addSeparator()
a(self.action_text_search)
if self.plugin_menu_actions:
e = b.addMenu(_('&Plugins'))
for ac in sorted(self.plugin_menu_actions, key=lambda x:sort_key(str(x.text()))):
e.addAction(ac)
e = b.addMenu(_('&Help'))
a = e.addAction
a(self.action_help)
a(QIcon.ic('donate.png'), _('&Donate to support calibre development'), open_donate)
a(self.action_preferences)
def search_menu_about_to_show(self):
ed = self.central.current_editor
update_mark_text_action(ed)
def update_recent_books(self):
m = self.recent_books_menu
m.clear()
books = tprefs.get('recent-books', [])
for path in books:
m.addAction(self.elided_text(path, width=500), partial(self.boss.open_book, path=path))
def create_toolbars(self):
def create(text, name):
name += '-bar'
b = self.addToolBar(text)
b.setObjectName(name) # Needed for saveState
actions[name] = b.toggleViewAction()
b.setIconSize(QSize(tprefs['toolbar_icon_size'], tprefs['toolbar_icon_size']))
return b
self.global_bar = create(_('Book tool bar'), 'global')
self.tools_bar = create(_('Tools tool bar'), 'tools')
self.plugins_bar = create(_('Plugins tool bar'), 'plugins')
self.populate_toolbars(animate=True)
def populate_toolbars(self, animate=False):
self.global_bar.clear(), self.tools_bar.clear(), self.plugins_bar.clear()
def add(bar, ac):
if ac is None:
bar.addSeparator()
elif ac == 'donate':
self.donate_button = b = ThrobbingButton(self)
b.clicked.connect(open_donate)
b.setAutoRaise(True)
b.setToolTip(_('Donate to support calibre development'))
if animate:
QTimer.singleShot(10, b.start_animation)
bar.addWidget(b)
else:
try:
bar.addAction(actions[ac])
except KeyError:
if DEBUG:
prints(f'Unknown action for toolbar {str(bar.objectName())!r}: {ac!r}')
for x in tprefs['global_book_toolbar']:
add(self.global_bar, x)
for x in tprefs['global_tools_toolbar']:
add(self.tools_bar, x)
for x in tprefs['global_plugins_toolbar']:
add(self.plugins_bar, x)
self.plugins_bar.setVisible(bool(tprefs['global_plugins_toolbar']))
def create_docks(self):
def create(name, oname):
oname += '-dock'
d = QDockWidget(name, self)
d.setObjectName(oname) # Needed for saveState
ac = d.toggleViewAction()
desc = _('Toggle %s') % name.replace('&', '')
self.keyboard.register_shortcut(
oname, desc, description=desc, action=ac, group=_('Windows'))
actions[oname] = ac
setattr(self, oname.replace('-', '_'), d)
return d
d = create(_('File browser'), 'files-browser')
d.setAllowedAreas(Qt.DockWidgetArea.LeftDockWidgetArea | Qt.DockWidgetArea.RightDockWidgetArea)
self.file_list = FileListWidget(d)
d.setWidget(self.file_list)
self.addDockWidget(Qt.DockWidgetArea.LeftDockWidgetArea, d)
d = create(_('File preview'), 'preview')
d.setAllowedAreas(Qt.DockWidgetArea.LeftDockWidgetArea | Qt.DockWidgetArea.RightDockWidgetArea)
self.preview = Preview(d)
d.setWidget(self.preview)
self.addDockWidget(Qt.DockWidgetArea.RightDockWidgetArea, d)
d = create(_('Live CSS'), 'live-css')
d.setAllowedAreas(
Qt.DockWidgetArea.LeftDockWidgetArea | Qt.DockWidgetArea.RightDockWidgetArea |
Qt.DockWidgetArea.BottomDockWidgetArea | Qt.DockWidgetArea.TopDockWidgetArea)
self.live_css = LiveCSS(self.preview, parent=d)
d.setWidget(self.live_css)
self.addDockWidget(Qt.DockWidgetArea.RightDockWidgetArea, d)
d.close() # Hidden by default
d = create(_('Check book'), 'check-book')
d.setAllowedAreas(
Qt.DockWidgetArea.LeftDockWidgetArea | Qt.DockWidgetArea.RightDockWidgetArea |
Qt.DockWidgetArea.BottomDockWidgetArea | Qt.DockWidgetArea.TopDockWidgetArea)
d.setWidget(self.check_book)
self.addDockWidget(Qt.DockWidgetArea.TopDockWidgetArea, d)
d.close() # By default the check window is closed
d = create(_('Inspector'), 'inspector')
d.setAllowedAreas(
Qt.DockWidgetArea.LeftDockWidgetArea | Qt.DockWidgetArea.RightDockWidgetArea |
Qt.DockWidgetArea.BottomDockWidgetArea | Qt.DockWidgetArea.TopDockWidgetArea)
d.setWidget(self.preview.inspector)
self.preview.inspector.setParent(d)
self.addDockWidget(Qt.DockWidgetArea.BottomDockWidgetArea, d)
d.close() # By default the inspector window is closed
QTimer.singleShot(10, self.preview.inspector.connect_to_dock)
d = create(_('Table of Contents'), 'toc-viewer')
d.setAllowedAreas(
Qt.DockWidgetArea.LeftDockWidgetArea | Qt.DockWidgetArea.RightDockWidgetArea |
Qt.DockWidgetArea.BottomDockWidgetArea | Qt.DockWidgetArea.TopDockWidgetArea)
d.setWidget(self.toc_view)
self.addDockWidget(Qt.DockWidgetArea.LeftDockWidgetArea, d)
d.close() # Hidden by default
d = create(_('Text search'), 'text-search')
d.setAllowedAreas(
Qt.DockWidgetArea.LeftDockWidgetArea | Qt.DockWidgetArea.RightDockWidgetArea |
Qt.DockWidgetArea.BottomDockWidgetArea | Qt.DockWidgetArea.TopDockWidgetArea)
d.setWidget(self.text_search)
self.addDockWidget(Qt.DockWidgetArea.LeftDockWidgetArea, d)
d.close() # Hidden by default
d = create(_('Checkpoints'), 'checkpoints')
d.setAllowedAreas(
Qt.DockWidgetArea.LeftDockWidgetArea | Qt.DockWidgetArea.RightDockWidgetArea |
Qt.DockWidgetArea.BottomDockWidgetArea | Qt.DockWidgetArea.TopDockWidgetArea)
self.checkpoints = CheckpointView(self.boss.global_undo, parent=d)
d.setWidget(self.checkpoints)
self.addDockWidget(Qt.DockWidgetArea.LeftDockWidgetArea, d)
d.close() # Hidden by default
d = create(_('Saved searches'), 'saved-searches')
d.setAllowedAreas(
Qt.DockWidgetArea.LeftDockWidgetArea | Qt.DockWidgetArea.RightDockWidgetArea |
Qt.DockWidgetArea.BottomDockWidgetArea | Qt.DockWidgetArea.TopDockWidgetArea)
d.setWidget(self.saved_searches)
self.addDockWidget(Qt.DockWidgetArea.LeftDockWidgetArea, d)
d.close() # Hidden by default
def resizeEvent(self, ev):
self.blocking_job.resize(ev.size())
return super().resizeEvent(ev)
def update_window_title(self):
cc = current_container()
if cc is not None:
fname = os.path.basename(cc.path_to_ebook)
self.setWindowTitle(self.current_metadata.title + ' [%s] :: %s :: %s' %(cc.book_type_for_display, fname, self.APP_NAME))
else:
self.setWindowTitle(self.APP_NAME)
def closeEvent(self, e):
if self.boss.quit():
e.accept()
else:
e.ignore()
def save_state(self):
self.save_geometry(tprefs, 'main_window_geometry')
tprefs.set('main_window_state', bytearray(self.saveState(self.STATE_VERSION)))
self.central.save_state()
self.saved_searches.save_state()
self.check_book.save_state()
self.text_search.save_state()
def restore_state(self):
self.restore_geometry(tprefs, 'main_window_geometry')
state = tprefs.get('main_window_state', None)
if state is not None:
self.restoreState(state, self.STATE_VERSION)
self.central.restore_state()
self.saved_searches.restore_state()
def contextMenuEvent(self, ev):
ev.ignore()
| 44,176 | Python | .py | 782 | 45.553708 | 159 | 0.618354 | kovidgoyal/calibre | 19,243 | 2,250 | 4 | GPL-3.0 | 9/5/2024, 5:13:50 PM (Europe/Amsterdam) |
26,690 | jump_to_class.py | kovidgoyal_calibre/src/calibre/gui2/tweak_book/jump_to_class.py | #!/usr/bin/env python
# License: GPL v3 Copyright: 2021, Kovid Goyal <kovid at kovidgoyal.net>
from contextlib import suppress
from typing import List, NamedTuple, Optional, Tuple
from css_parser.css import CSSRule
from calibre.ebooks.oeb.parse_utils import barename
from calibre.ebooks.oeb.polish.container import get_container
from calibre.ebooks.oeb.polish.parsing import parse
from css_selectors import Select, SelectorError
class NoMatchingTagFound(KeyError):
pass
class NoMatchingRuleFound(KeyError):
pass
class RuleLocation(NamedTuple):
rule_address: List[int]
file_name: str
style_tag_address: Optional[Tuple[int, List[int]]] = None
def rule_matches_elem(rule, elem, select, class_name):
for selector in rule.selectorList:
if class_name in selector.selectorText:
with suppress(SelectorError):
if elem in select(selector.selectorText):
return True
return False
def find_first_rule_that_matches_elem(
container,
elem,
select,
class_name,
rules,
current_file_name,
recursion_level=0,
rule_address=None
):
# iterate over rules handling @import and @media rules returning a rule
# address for matching rule
if recursion_level > 16:
return None
rule_address = rule_address or []
num_comment_rules = 0
for i, rule in enumerate(rules):
if rule.type == CSSRule.STYLE_RULE:
if rule_matches_elem(rule, elem, select, class_name):
return RuleLocation(rule_address + [i - num_comment_rules], current_file_name)
elif rule.type == CSSRule.COMMENT:
num_comment_rules += 1
elif rule.type == CSSRule.MEDIA_RULE:
res = find_first_rule_that_matches_elem(
container, elem, select, class_name, rule.cssRules,
current_file_name, recursion_level + 1, rule_address + [i - num_comment_rules]
)
if res is not None:
return res
elif rule.type == CSSRule.IMPORT_RULE:
if not rule.href:
continue
sname = container.href_to_name(rule.href, current_file_name)
if sname:
try:
sheet = container.parsed(sname)
except Exception:
continue
if not hasattr(sheet, 'cssRules'):
continue
res = find_first_rule_that_matches_elem(
container, elem, select, class_name, sheet.cssRules, sname,
recursion_level + 1
)
if res is not None:
return res
return None
def find_first_matching_rule(
container, html_file_name, raw_html, class_data, lnum_attr='data-lnum'
):
lnum, tags = class_data['sourceline_address']
class_name = class_data['class']
root = parse(
raw_html,
decoder=lambda x: x.decode('utf-8'),
line_numbers=True,
linenumber_attribute=lnum_attr
)
tags_on_line = root.xpath(f'//*[@{lnum_attr}={lnum}]')
barenames = [barename(tag.tag) for tag in tags_on_line]
if barenames[:len(tags)] != tags:
raise NoMatchingTagFound(
f'No tag matching the specification was found in {html_file_name}'
)
target_elem = tags_on_line[len(tags) - 1]
select = Select(root, ignore_inappropriate_pseudo_classes=True)
for tag in root.iter('*'):
tn = barename(tag.tag)
if tn == 'style' and tag.text and tag.get('type', 'text/css') == 'text/css':
try:
sheet = container.parse_css(tag.text)
except Exception:
continue
res = find_first_rule_that_matches_elem(
container, target_elem, select, class_name, sheet.cssRules,
html_file_name
)
if res is not None:
return res._replace(style_tag_address=(int(tag.get(lnum_attr)), ['style']))
elif tn == 'link' and tag.get('href') and tag.get('rel', '').lower() == 'stylesheet':
sname = container.href_to_name(tag.get('href'), html_file_name)
try:
sheet = container.parsed(sname)
except Exception:
continue
if not hasattr(sheet, 'cssRules'):
continue
res = find_first_rule_that_matches_elem(
container, target_elem, select, class_name, sheet.cssRules, sname
)
if res is not None:
return res
raise NoMatchingRuleFound(
f'No CSS rules that apply to the specified tag in {html_file_name} with the class {class_name} found'
)
def develop():
container = get_container('/t/demo.epub', tweak_mode=True)
fname = 'index_split_002.html'
data = {'class': 'xxx', 'sourceline_address': (13, ['body'])}
print(
find_first_matching_rule(
container, fname,
container.open(fname).read(), data
)
)
| 5,057 | Python | .py | 129 | 29.666667 | 109 | 0.603543 | kovidgoyal/calibre | 19,243 | 2,250 | 4 | GPL-3.0 | 9/5/2024, 5:13:50 PM (Europe/Amsterdam) |
26,691 | download.py | kovidgoyal_calibre/src/calibre/gui2/tweak_book/download.py | #!/usr/bin/env python
# License: GPLv3 Copyright: 2016, Kovid Goyal <kovid at kovidgoyal.net>
from threading import Thread
from qt.core import (
QDialogButtonBox,
QGridLayout,
QIcon,
QLabel,
QListWidget,
QListWidgetItem,
QProgressBar,
QScrollArea,
QSize,
Qt,
QVBoxLayout,
QWidget,
pyqtSignal,
)
from calibre.ebooks.oeb.polish.download import download_external_resources, get_external_resources, replace_resources
from calibre.gui2 import error_dialog, info_dialog, warning_dialog
from calibre.gui2.progress_indicator import WaitStack
from calibre.gui2.tweak_book import current_container
from calibre.gui2.tweak_book.widgets import Dialog
from calibre.startup import connect_lambda
from calibre.utils.localization import ngettext
from polyglot.builtins import iteritems
class ChooseResources(QWidget):
def __init__(self, parent=None):
QWidget.__init__(self, parent)
self.l = l = QVBoxLayout(self)
self.la = la = QLabel(_('Choose the external resources to download'))
la.setWordWrap(True)
l.addWidget(la)
self.items = i = QListWidget(self)
l.addWidget(i)
def __iter__(self):
for i in range(self.items.count()):
yield self.items.item(i)
def select_none(self):
for item in self:
item.setCheckState(Qt.CheckState.Unchecked)
def select_all(self):
for item in self:
item.setCheckState(Qt.CheckState.Checked)
@property
def resources(self):
return {i.data(Qt.ItemDataRole.UserRole):self.original_resources[i.data(Qt.ItemDataRole.UserRole)]
for i in self if i.checkState() == Qt.CheckState.Checked}
@resources.setter
def resources(self, resources):
self.items.clear()
self.original_resources = resources
dc = 0
for url, matches in iteritems(resources):
text = url
num = len(matches)
if text.startswith('data:'):
dc += 1
text = _('Data URL #{}').format(dc)
text += ' ({})'.format(ngettext('one instance', '{} instances', num).format(num))
i = QListWidgetItem(text, self.items)
i.setData(Qt.ItemDataRole.UserRole, url)
i.setCheckState(Qt.CheckState.Checked)
i.setFlags(Qt.ItemFlag.ItemIsUserCheckable | Qt.ItemFlag.ItemIsEnabled)
class DownloadStatus(QScrollArea):
def __init__(self, parent=None):
QScrollArea.__init__(self, parent)
self.setWidgetResizable(True)
self.w = QWidget(self)
self.l = QGridLayout(self.w)
self.setWidget(self.w)
def __call__(self, resources):
self.url_map = {}
self.labels = []
for url in resources:
p = self.url_map[url] = QProgressBar(self.w)
p.setRange(0, 0)
self.l.addWidget(p, self.l.rowCount(), 0)
la = QLabel('\xa0' + url)
self.labels.append(la)
self.l.addWidget(la, self.l.rowCount()-1, 1)
self.l.addWidget(QLabel(''))
self.l.setRowStretch(self.l.rowCount()-1, 10)
def progress(self, url, done, total):
p = self.url_map.get(url)
if p is not None:
if total > 0:
p.setRange(0, total)
p.setValue(done)
else:
p.setRange(0, 0)
class DownloadResources(Dialog):
get_done = pyqtSignal(object, object)
progress = pyqtSignal(object, object, object)
download_done = pyqtSignal(object, object)
replace_done = pyqtSignal(object, object)
def __init__(self, parent=None):
self.resources_replaced = False
self.show_diff = False
Dialog.__init__(self, _('Download external resources'), 'download-external-resources', parent)
self.state = 0
self.get_done.connect(self._get_done)
self.download_done.connect(self._download_done)
self.replace_done.connect(self._replace_done)
self.progress.connect(self.download_status.progress, type=Qt.ConnectionType.QueuedConnection)
def setup_ui(self):
self.setWindowIcon(QIcon.ic('download-metadata.png'))
self.choose_resources = cr = ChooseResources(self)
self.download_status = ds = DownloadStatus(self)
self.success = s = QLabel('')
s.setWordWrap(True)
self.l = l = QVBoxLayout(self)
self.wait = WaitStack(_('Searching for external resources...'), cr, self)
self.wait.addWidget(ds), self.wait.addWidget(s)
self.wait.start()
for t, f in ((_('Select &none'), cr.select_none), (_('Select &all'), cr.select_all)):
b = self.bb.addButton(t, QDialogButtonBox.ButtonRole.ActionRole)
b.clicked.connect(f), b.setAutoDefault(False)
self.bb.setVisible(False)
l.addWidget(self.wait), l.addWidget(self.bb)
t = Thread(name='GetResources', target=self.get_resources)
t.daemon = True
t.start()
def get_resources(self):
tb = None
try:
ret = get_external_resources(current_container())
except Exception as err:
import traceback
ret, tb = err, traceback.format_exc()
self.get_done.emit(ret, tb)
def _get_done(self, x, tb):
if not self.isVisible():
return self.reject()
if tb is not None:
error_dialog(self, _('Scan failed'), _(
'Failed to scan for external resources, click "Show details" for more information.'),
det_msg=tb, show=True)
self.reject()
else:
self.wait.stop()
self.state = 1
resources = x
if not resources:
info_dialog(self, _('No external resources found'), _(
'No external resources were found in this book.'), show=True)
self.reject()
return
self.choose_resources.resources = resources
self.bb.setVisible(True)
def download_resources(self, resources):
tb = None
try:
ret = download_external_resources(current_container(), resources, progress_report=self.progress.emit)
except Exception as err:
import traceback
ret, tb = err, traceback.format_exc()
self.download_done.emit(ret, tb)
def _download_done(self, ret, tb):
if not self.isVisible():
return self.reject()
if tb is not None:
error_dialog(self, _('Download failed'), _(
'Failed to download external resources, click "Show details" for more information.'),
det_msg=tb, show=True)
self.reject()
else:
replacements, failures = ret
if failures:
tb = [f'{url}\n\t{err}\n' for url, err in iteritems(failures)]
if not replacements:
error_dialog(self, _('Download failed'), _(
'Failed to download external resources, click "Show details" for more information.'),
det_msg='\n'.join(tb), show=True)
self.reject()
return
else:
warning_dialog(self, _('Some downloads failed'), _(
'Failed to download some external resources, click "Show details" for more information.'),
det_msg='\n'.join(tb), show=True)
self.state = 2
self.wait.msg = _('Updating resources in book...')
self.wait.start()
t = ngettext(
'Successfully processed the external resource', 'Successfully processed {} external resources', len(replacements)).format(len(replacements))
if failures:
t += '<br>' + ngettext('Could not download one image', 'Could not download {} images', len(failures)).format(len(failures))
self.success.setText('<p style="text-align:center">' + t)
resources = self.choose_resources.resources
t = Thread(name='ReplaceResources', target=self.replace_resources, args=(resources, replacements))
t.daemon = True
t.start()
def replace_resources(self, resources, replacements):
tb = None
try:
ret = replace_resources(current_container(), resources, replacements)
except Exception as err:
import traceback
ret, tb = err, traceback.format_exc()
self.replace_done.emit(ret, tb)
def _replace_done(self, ret, tb):
if tb is not None:
error_dialog(self, _('Replace failed'), _(
'Failed to replace external resources, click "Show details" for more information.'),
det_msg=tb, show=True)
Dialog.reject(self)
else:
self.wait.setCurrentIndex(3)
self.state = 3
self.bb.clear()
self.resources_replaced = True
self.bb.setStandardButtons(QDialogButtonBox.StandardButton.Ok | QDialogButtonBox.StandardButton.Close)
b = self.bb.button(QDialogButtonBox.StandardButton.Ok)
b.setText(_('See what &changed'))
b.setIcon(QIcon.ic('diff.png'))
connect_lambda(b.clicked, self, lambda self: setattr(self, 'show_diff', True))
self.bb.setVisible(True)
def accept(self):
if self.state == 0:
return self.reject()
if self.state == 1:
resources = self.choose_resources.resources
self.download_status(resources)
self.wait.setCurrentIndex(2)
self.bb.setVisible(False)
t = Thread(name='DownloadResources', target=self.download_resources, args=(resources,))
t.daemon = True
t.start()
return
if self.state == 2:
return
self.wait.stop()
Dialog.accept(self)
def reject(self):
if self.state == 2:
return
self.wait.stop()
return Dialog.reject(self)
def sizeHint(self):
return QSize(800, 500)
if __name__ == '__main__':
import sys
from calibre.gui2 import Application
app = Application([])
from calibre.gui2.tweak_book import set_current_container
from calibre.gui2.tweak_book.boss import get_container
set_current_container(get_container(sys.argv[-1]))
d = DownloadResources()
d.exec()
print(d.show_diff)
del d, app
| 10,587 | Python | .py | 251 | 31.836653 | 156 | 0.600466 | kovidgoyal/calibre | 19,243 | 2,250 | 4 | GPL-3.0 | 9/5/2024, 5:13:50 PM (Europe/Amsterdam) |
26,692 | save.py | kovidgoyal_calibre/src/calibre/gui2/tweak_book/save.py | #!/usr/bin/env python
__license__ = 'GPL v3'
__copyright__ = '2013, Kovid Goyal <kovid at kovidgoyal.net>'
import errno
import os
import shutil
import stat
from threading import Thread
from qt.core import QHBoxLayout, QLabel, QObject, QSize, Qt, QWidget, pyqtSignal
from calibre.constants import iswindows
from calibre.gui2.progress_indicator import ProgressIndicator
from calibre.ptempfile import PersistentTemporaryFile
from calibre.utils import join_with_timeout
from calibre.utils.filenames import atomic_rename, format_permissions
from polyglot.queue import Empty, LifoQueue
def save_dir_container(container, path):
if not os.path.exists(path):
os.makedirs(path)
if not os.path.isdir(path):
raise ValueError('%s is not a folder, cannot save a directory based container to it' % path)
container.commit(path)
def save_container(container, path):
if container.is_dir:
return save_dir_container(container, path)
temp = PersistentTemporaryFile(
prefix=('_' if iswindows else '.'), suffix=os.path.splitext(path)[1], dir=os.path.dirname(path))
if hasattr(os, 'fchmod'):
# Ensure file permissions and owner information is preserved
fno = temp.fileno()
st = None
try:
st = os.stat(path)
except OSError as err:
if err.errno != errno.ENOENT:
raise
# path may not exist if we are saving a copy, in which case we use
# the metadata from the original book
try:
st = os.stat(container.path_to_ebook)
except OSError as err:
if err.errno != errno.ENOENT:
raise
# Somebody deleted the original file
if st is not None:
try:
os.fchmod(fno, st.st_mode | stat.S_IWUSR)
except OSError as err:
if err.errno != errno.EPERM:
raise
raise OSError('Failed to change permissions of {} to {} ({}), with error: {}. Most likely the {} directory has a restrictive umask'.format(
temp.name, oct(st.st_mode), format_permissions(st.st_mode), errno.errorcode[err.errno], os.path.dirname(temp.name)))
try:
os.fchown(fno, st.st_uid, st.st_gid)
except OSError as err:
if err.errno not in (errno.EPERM, errno.EACCES):
# ignore chown failure as user could be editing file belonging
# to a different user, in which case we really can't do anything
# about it short of making the file update non-atomic
raise
temp.close()
temp = temp.name
try:
container.commit(temp)
atomic_rename(temp, path)
finally:
if os.path.exists(temp):
os.remove(temp)
def send_message(msg=''):
if msg:
from calibre.gui2.listener import send_message_in_process
send_message_in_process('bookedited:'+msg)
def find_first_existing_ancestor(path):
while path and not os.path.exists(path):
npath = os.path.dirname(path)
if npath == path:
break
path = npath
return path
class SaveWidget(QWidget):
def __init__(self, parent=None):
QWidget.__init__(self, parent)
self.l = l = QHBoxLayout(self)
self.setLayout(l)
self.label = QLabel('')
self.pi = ProgressIndicator(self, 24)
l.addWidget(self.label)
l.addWidget(self.pi)
l.setContentsMargins(0, 0, 0, 0)
self.pi.setVisible(False)
self.stop()
def start(self):
self.pi.setDisplaySize(QSize(self.label.height(), self.label.height()))
self.pi.setVisible(True)
self.pi.startAnimation()
self.label.setText(_('Saving...'))
def stop(self):
self.pi.setVisible(False)
self.pi.stopAnimation()
self.label.setText('')
class SaveManager(QObject):
start_save = pyqtSignal()
report_error = pyqtSignal(object)
save_done = pyqtSignal()
check_for_completion = pyqtSignal()
def __init__(self, parent, notify=None):
QObject.__init__(self, parent)
self.count = 0
self.last_saved = -1
self.requests = LifoQueue()
self.notify_requests = LifoQueue()
self.notify_data = notify
t = Thread(name='save-thread', target=self.run)
t.daemon = True
t.start()
t = Thread(name='notify-thread', target=self.notify_calibre)
t.daemon = True
t.start()
self.status_widget = w = SaveWidget(parent)
self.start_save.connect(w.start, type=Qt.ConnectionType.QueuedConnection)
self.save_done.connect(w.stop, type=Qt.ConnectionType.QueuedConnection)
def schedule(self, tdir, container):
self.count += 1
self.requests.put((self.count, tdir, container))
def run(self):
while True:
x = self.requests.get()
if x is None:
self.requests.task_done()
self.__empty_queue()
break
error_occurred = True
try:
count, tdir, container = x
error_occurred = self.process_save(count, tdir, container)
except:
import traceback
traceback.print_exc()
finally:
self.requests.task_done()
if not error_occurred:
self.check_for_completion.emit()
def notify_calibre(self):
while True:
if not self.notify_requests.get():
break
send_message(self.notify_data)
def clear_notify_data(self):
self.notify_data = None
def __empty_queue(self):
' Only to be used during shutdown '
while True:
try:
self.requests.get_nowait()
except Empty:
break
else:
self.requests.task_done()
def process_save(self, count, tdir, container):
if count <= self.last_saved:
shutil.rmtree(tdir, ignore_errors=True)
return
self.last_saved = count
self.start_save.emit()
error_occurred = False
try:
self.do_save(tdir, container)
except:
import traceback
self.report_error.emit(traceback.format_exc())
error_occurred = True
self.save_done.emit()
if self.notify_data:
self.notify_requests.put(True)
return error_occurred
def do_save(self, tdir, container):
try:
save_container(container, container.path_to_ebook)
finally:
shutil.rmtree(tdir, ignore_errors=True)
@property
def has_tasks(self):
return bool(self.requests.unfinished_tasks)
def wait(self, timeout=30):
if timeout is None:
self.requests.join()
else:
try:
join_with_timeout(self.requests, timeout)
except RuntimeError:
return False
return True
def shutdown(self):
self.requests.put(None)
self.notify_requests.put(None)
| 7,254 | Python | .py | 194 | 27.582474 | 155 | 0.598406 | kovidgoyal/calibre | 19,243 | 2,250 | 4 | GPL-3.0 | 9/5/2024, 5:13:50 PM (Europe/Amsterdam) |
26,693 | text_search.py | kovidgoyal_calibre/src/calibre/gui2/tweak_book/text_search.py | #!/usr/bin/env python
# License: GPLv3 Copyright: 2016, Kovid Goyal <kovid at kovidgoyal.net>
from lxml.etree import tostring
from qt.core import QCheckBox, QComboBox, QFont, QHBoxLayout, QIcon, QLabel, QPushButton, QSizePolicy, QVBoxLayout, QWidget, pyqtSignal
from calibre import prepare_string_for_xml
from calibre.gui2 import error_dialog
from calibre.gui2.tweak_book import current_container, editors, tprefs
from calibre.gui2.tweak_book.search import InvalidRegex, get_search_regex, initialize_search_request
from calibre.gui2.widgets import BusyCursor
from calibre.gui2.widgets2 import HistoryComboBox
from calibre.startup import connect_lambda
from calibre.utils.icu import utf16_length
from polyglot.builtins import error_message, iteritems
# UI {{{
class ModeBox(QComboBox):
def __init__(self, parent):
QComboBox.__init__(self, parent)
self.addItems([_('Normal'), _('Regex')])
self.setToolTip('<style>dd {margin-bottom: 1.5ex}</style>' + _(
'''Select how the search expression is interpreted
<dl>
<dt><b>Normal</b></dt>
<dd>The search expression is treated as normal text, calibre will look for the exact text.</dd>
<dt><b>Regex</b></dt>
<dd>The search expression is interpreted as a regular expression. See the User Manual for more help on using regular expressions.</dd>
</dl>'''))
@property
def mode(self):
return ('normal', 'regex')[self.currentIndex()]
@mode.setter
def mode(self, val):
self.setCurrentIndex({'regex':1}.get(val, 0))
class WhereBox(QComboBox):
def __init__(self, parent, emphasize=False):
QComboBox.__init__(self)
self.addItems([_('Current file'), _('All text files'), _('Selected files'), _('Open files')])
self.setToolTip('<style>dd {margin-bottom: 1.5ex}</style>' + _(
'''
Where to search/replace:
<dl>
<dt><b>Current file</b></dt>
<dd>Search only inside the currently opened file</dd>
<dt><b>All text files</b></dt>
<dd>Search in all text (HTML) files</dd>
<dt><b>Selected files</b></dt>
<dd>Search in the files currently selected in the File browser</dd>
<dt><b>Open files</b></dt>
<dd>Search in the files currently open in the editor</dd>
</dl>'''))
self.emphasize = emphasize
self.ofont = QFont(self.font())
if emphasize:
f = self.emph_font = QFont(self.ofont)
f.setBold(True), f.setItalic(True)
self.setFont(f)
@property
def where(self):
wm = {0:'current', 1:'text', 2:'selected', 3:'open'}
return wm[self.currentIndex()]
@where.setter
def where(self, val):
wm = {0:'current', 1:'text', 2:'selected', 3:'open'}
self.setCurrentIndex({v:k for k, v in iteritems(wm)}[val])
def showPopup(self):
# We do it like this so that the popup uses a normal font
if self.emphasize:
self.setFont(self.ofont)
QComboBox.showPopup(self)
def hidePopup(self):
if self.emphasize:
self.setFont(self.emph_font)
QComboBox.hidePopup(self)
class TextSearch(QWidget):
find_text = pyqtSignal(object)
def __init__(self, ui):
QWidget.__init__(self, ui)
self.l = l = QVBoxLayout(self)
self.la = la = QLabel(_('&Find:'))
self.find = ft = HistoryComboBox(self)
ft.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Fixed)
ft.initialize('tweak_book_text_search_history')
la.setBuddy(ft)
self.h = h = QHBoxLayout()
h.addWidget(la), h.addWidget(ft), l.addLayout(h)
self.h2 = h = QHBoxLayout()
l.addLayout(h)
self.mode = m = ModeBox(self)
h.addWidget(m)
self.where_box = wb = WhereBox(self)
h.addWidget(wb)
self.cs = cs = QCheckBox(_('&Case sensitive'))
h.addWidget(cs)
self.da = da = QCheckBox(_('&Dot all'))
da.setToolTip('<p>'+_("Make the '.' special character match any character at all, including a newline"))
h.addWidget(da)
self.h3 = h = QHBoxLayout()
l.addLayout(h)
h.addStretch(10)
self.next_button = b = QPushButton(QIcon.ic('arrow-down.png'), _('&Next'), self)
b.setToolTip(_('Find next match'))
h.addWidget(b)
connect_lambda(b.clicked, self, lambda self: self.do_search('down'))
self.prev_button = b = QPushButton(QIcon.ic('arrow-up.png'), _('&Previous'), self)
b.setToolTip(_('Find previous match'))
h.addWidget(b)
connect_lambda(b.clicked, self, lambda self: self.do_search('up'))
state = tprefs.get('text_search_widget_state')
self.state = state or {}
@property
def state(self):
return {'mode': self.mode.mode, 'where':self.where_box.where, 'case_sensitive':self.cs.isChecked(), 'dot_all':self.da.isChecked()}
@state.setter
def state(self, val):
self.mode.mode = val.get('mode', 'normal')
self.where_box.where = val.get('where', 'current')
self.cs.setChecked(bool(val.get('case_sensitive')))
self.da.setChecked(bool(val.get('dot_all', True)))
def save_state(self):
tprefs['text_search_widget_state'] = self.state
def do_search(self, direction='down'):
state = self.state
state['find'] = self.find.text()
state['direction'] = direction
self.find_text.emit(state)
# }}}
def file_matches_pattern(fname, pat):
root = current_container().parsed(fname)
if hasattr(root, 'xpath'):
raw = tostring(root, method='text', encoding='unicode', with_tail=True)
else:
raw = current_container().raw_data(fname)
return pat.search(raw) is not None
def run_text_search(search, current_editor, current_editor_name, searchable_names, gui_parent, show_editor, edit_file):
try:
pat = get_search_regex(search)
except InvalidRegex as e:
return error_dialog(gui_parent, _('Invalid regex'), '<p>' + _(
'The regular expression you entered is invalid: <pre>{0}</pre>With error: {1}').format(
prepare_string_for_xml(e.regex), error_message(e)), show=True)
editor, where, files, do_all, marked = initialize_search_request(search, 'count', current_editor, current_editor_name, searchable_names)
with BusyCursor():
if editor is not None:
if editor.find_text(pat):
return True
if not files and editor.find_text(pat, wrap=True):
return True
for fname, syntax in iteritems(files):
ed = editors.get(fname, None)
if ed is not None:
if ed.find_text(pat, complete=True):
show_editor(fname)
return True
else:
if file_matches_pattern(fname, pat):
edit_file(fname, syntax)
if editors[fname].find_text(pat, complete=True):
return True
msg = '<p>' + _('No matches were found for %s') % ('<pre style="font-style:italic">' + prepare_string_for_xml(search['find']) + '</pre>')
return error_dialog(gui_parent, _('Not found'), msg, show=True)
def find_text_in_chunks(pat, chunks):
text = ''.join(x[0] for x in chunks)
m = pat.search(text)
if m is None:
return -1, -1
start, after = m.span()
def contains(clen, pt):
return offset <= pt < offset + clen
offset = 0
start_pos = end_pos = None
for chunk, chunk_start in chunks:
clen = len(chunk)
if offset + clen < start:
offset += clen
continue # this chunk ends before start
if start_pos is None:
if contains(clen, start):
start_pos = chunk_start + (start - offset)
if start_pos is not None:
if contains(clen, after-1):
end_pos = chunk_start + utf16_length(chunk[:after-offset])
return start_pos, end_pos
offset += clen
if offset > after:
break # the next chunk starts after end
return -1, -1
| 8,282 | Python | .py | 185 | 35.864865 | 146 | 0.609257 | kovidgoyal/calibre | 19,243 | 2,250 | 4 | GPL-3.0 | 9/5/2024, 5:13:50 PM (Europe/Amsterdam) |
26,694 | manage_fonts.py | kovidgoyal_calibre/src/calibre/gui2/tweak_book/manage_fonts.py | #!/usr/bin/env python
__license__ = 'GPL v3'
__copyright__ = '2014, Kovid Goyal <kovid at kovidgoyal.net>'
import sys
import textwrap
from io import BytesIO
from qt.core import (
QAbstractItemView,
QAbstractTableModel,
QApplication,
QDialog,
QDialogButtonBox,
QFormLayout,
QHBoxLayout,
QIcon,
QLabel,
QLineEdit,
QMessageBox,
QPushButton,
QSize,
QSplitter,
Qt,
QTableView,
QTextEdit,
QTimer,
QVBoxLayout,
QWidget,
pyqtSignal,
)
from calibre.ebooks.oeb.polish.container import get_container
from calibre.ebooks.oeb.polish.fonts import change_font, font_family_data
from calibre.gui2 import error_dialog, info_dialog
from calibre.gui2.tweak_book import current_container, set_current_container
from calibre.gui2.tweak_book.widgets import Dialog
from calibre.gui2.widgets import BusyCursor
from calibre.utils.fonts.metadata import FontMetadata, UnsupportedFont
from calibre.utils.fonts.scanner import NoFonts, font_scanner
from calibre.utils.icu import lower as icu_lower
from calibre.utils.icu import primary_sort_key as sort_key
from calibre.utils.localization import ngettext
from polyglot.builtins import iteritems
def rule_for_font(font_file, added_name):
try:
fm = FontMetadata(font_file).to_dict()
except UnsupportedFont:
return
pp = _('Change this to the relative path to: %s') % added_name
rule = '''@font-face {{
src: url({pp});
font-family: "{ff}";
font-weight: {w};
font-style: {sy};
font-stretch: {st};
}}'''.format(pp=pp, ff=fm['font-family'], w=fm['font-weight'], sy=fm['font-style'], st=fm['font-stretch'])
return rule
def show_font_face_rule_for_font_file(file_data, added_name, parent=None):
rule = rule_for_font(BytesIO(file_data), added_name)
QApplication.clipboard().setText(rule)
QMessageBox.information(parent, _('Font file added'), _(
'The font file <b>{}</b> has been added. The text for the CSS @font-face rule for this file has been copied'
' to the clipboard. You should paste it into whichever CSS file you want to add this font to.').format(added_name))
def show_font_face_rule_for_font_files(container, added_names, parent=None):
rules = []
for name in sorted(added_names):
rule = rule_for_font(container.open(name), name)
if rule:
rules.append(rule)
if rules:
QApplication.clipboard().setText('\n\n'.join(rules))
QMessageBox.information(parent, _('Font files added'), _(
'The specified font files have been added. The text for the CSS @font-face rules for these files has been copied'
' to the clipboard. You should paste it into whichever CSS file you want to add these fonts to.'))
class EmbeddingData(Dialog):
def __init__(self, family, faces, parent=None):
Dialog.__init__(self, _('Font faces for %s') % family, 'editor-embedding-data', parent)
self.family, self.faces = family, faces
self.populate_text()
def sizeHint(self):
return QSize(600, 500)
def setup_ui(self):
self.l = l = QVBoxLayout(self)
self.text = t = QTextEdit(self)
t.setReadOnly(True)
l.addWidget(t), l.addWidget(self.bb)
self.bb.clear(), self.bb.setStandardButtons(QDialogButtonBox.StandardButton.Close)
def populate_text(self):
text = ['<h2>' + self.windowTitle() + '</h2><ul>']
for face in self.faces:
text.append('<li style="margin-bottom:2em">' + '<b>' + face['path'] + '</b>')
name = face.get('full_name') or face.get('family_name') or face.get('subfamily_name')
if name:
text.append('<br>' + _('Name:') + '\xa0<b>' + str(name) + '</b>')
if 'font-weight' in face:
text.append('<br>' + 'font-weight:\xa0' + str(face['font-weight']))
if 'font-style' in face:
text.append('<br>' + 'font-style:\xa0' + str(face['font-style']))
self.text.setHtml('\n'.join(text))
class AllFonts(QAbstractTableModel):
def __init__(self, parent=None):
QAbstractTableModel.__init__(self, parent)
self.items = []
self.font_data = {}
self.sorted_on = ('name', True)
def rowCount(self, parent=None):
return len(self.items)
def columnCount(self, parent=None):
return 2
def headerData(self, section, orientation, role=Qt.ItemDataRole.DisplayRole):
if orientation == Qt.Orientation.Horizontal and role == Qt.ItemDataRole.DisplayRole:
return _('Font family') if section == 1 else _('Embedded')
return QAbstractTableModel.headerData(self, section, orientation, role)
def build(self):
with BusyCursor():
self.beginResetModel()
self.font_data = font_family_data(current_container())
self.do_sort()
self.endResetModel()
def do_sort(self):
reverse = not self.sorted_on[1]
self.items = sorted(self.font_data, key=sort_key, reverse=reverse)
if self.sorted_on[0] != 'name':
self.items.sort(key=self.font_data.get, reverse=reverse)
def data(self, index, role=Qt.ItemDataRole.DisplayRole):
if role == Qt.ItemDataRole.DisplayRole:
row, col = index.row(), index.column()
try:
name = self.items[row]
embedded = '✓ ' if self.font_data[name] else ''
except (IndexError, KeyError):
return
return name if col == 1 else embedded
if role == Qt.ItemDataRole.TextAlignmentRole:
col = index.column()
if col == 0:
return int(Qt.AlignmentFlag.AlignHCenter | Qt.AlignmentFlag.AlignVCenter) # https://bugreports.qt.io/browse/PYSIDE-1974
if role in (Qt.ItemDataRole.UserRole, Qt.ItemDataRole.UserRole + 1):
row = index.row()
try:
name = self.items[row]
except (IndexError, KeyError):
return
if role == Qt.ItemDataRole.UserRole:
try:
return font_scanner.fonts_for_family(name)
except NoFonts:
return []
else:
return name
def sort(self, col, order=Qt.SortOrder.AscendingOrder):
sorted_on = (('name' if col == 1 else 'embedded'), order == Qt.SortOrder.AscendingOrder)
if sorted_on != self.sorted_on:
self.sorted_on = sorted_on
self.beginResetModel()
self.do_sort()
self.endResetModel()
def data_for_indices(self, indices):
ans = {}
for idx in indices:
try:
name = self.items[idx.row()]
ans[name] = self.font_data[name]
except (IndexError, KeyError):
pass
return ans
class ChangeFontFamily(Dialog):
def __init__(self, old_family, embedded_families, parent=None):
self.old_family = old_family
self.local_families = {icu_lower(f) for f in font_scanner.find_font_families()} | {
icu_lower(f) for f in embedded_families}
Dialog.__init__(self, _('Change font'), 'change-font-family', parent=parent)
self.setMinimumWidth(300)
self.resize(self.sizeHint())
def setup_ui(self):
self.l = l = QFormLayout(self)
self.setLayout(l)
self.la = la = QLabel(ngettext(
'Change the font %s to:', 'Change the fonts %s to:',
self.old_family.count(',')+1) % self.old_family)
la.setWordWrap(True)
l.addRow(la)
self._family = f = QLineEdit(self)
l.addRow(_('&New font:'), f)
f.textChanged.connect(self.updated_family)
self.embed_status = e = QLabel('\xa0')
l.addRow(e)
l.addRow(self.bb)
@property
def family(self):
return str(self._family.text())
@property
def normalized_family(self):
ans = self.family
try:
ans = font_scanner.fonts_for_family(ans)[0]['font-family']
except (NoFonts, IndexError, KeyError):
pass
if icu_lower(ans) == 'sansserif':
ans = 'sans-serif'
return ans
def updated_family(self):
family = self.family
found = icu_lower(family) in self.local_families
t = _('The font <i>%s</i> <b>exists</b> on your computer') if found else _(
'The font <i>%s</i> <b>does not exist</b> on your computer')
t = (t % family) if family else '\xa0'
self.embed_status.setText(t)
self.resize(self.sizeHint())
class ManageFonts(Dialog):
container_changed = pyqtSignal()
embed_all_fonts = pyqtSignal()
subset_all_fonts = pyqtSignal()
def __init__(self, parent=None):
Dialog.__init__(self, _('Manage fonts'), 'manage-fonts', parent=parent)
def setup_ui(self):
self.setAttribute(Qt.WidgetAttribute.WA_DeleteOnClose, False)
self.l = l = QVBoxLayout(self)
self.setLayout(l)
self.bb.clear()
self.bb.addButton(QDialogButtonBox.StandardButton.Close)
self.splitter = s = QSplitter(self)
self.h = h = QHBoxLayout()
h.setContentsMargins(0, 0, 0, 0)
self.install_fonts_button = b = QPushButton(_('&Install fonts'), self)
h.addWidget(b), b.setIcon(QIcon.ic('plus.png'))
b.setToolTip(textwrap.fill(_('Install fonts from font files to make them available for embedding')))
b.clicked.connect(self.install_fonts)
l.addWidget(s), l.addLayout(h), h.addStretch(10), h.addWidget(self.bb)
self.fonts_view = fv = QTableView(self)
fv.doubleClicked.connect(self.show_embedding_data)
self.model = m = AllFonts(fv)
fv.horizontalHeader().setStretchLastSection(True)
fv.setModel(m)
fv.setSortingEnabled(True)
fv.setShowGrid(False)
fv.setAlternatingRowColors(True)
fv.setSelectionMode(QAbstractItemView.SelectionMode.ExtendedSelection)
fv.setSelectionBehavior(QAbstractItemView.SelectionBehavior.SelectRows)
fv.horizontalHeader().setSortIndicator(1, Qt.SortOrder.AscendingOrder)
self.container = c = QWidget()
l = c.l = QVBoxLayout(c)
c.setLayout(l)
s.addWidget(fv), s.addWidget(c)
self.cb = b = QPushButton(_('&Change selected fonts'))
b.setIcon(QIcon.ic('wizard.png'))
b.clicked.connect(self.change_fonts)
l.addWidget(b)
self.rb = b = QPushButton(_('&Remove selected fonts'))
b.clicked.connect(self.remove_fonts)
b.setIcon(QIcon.ic('trash.png'))
l.addWidget(b)
self.eb = b = QPushButton(_('&Embed all fonts'))
b.setIcon(QIcon.ic('embed-fonts.png'))
b.clicked.connect(self.embed_fonts)
l.addWidget(b)
self.sb = b = QPushButton(_('&Subset all fonts'))
b.setIcon(QIcon.ic('subset-fonts.png'))
b.clicked.connect(self.subset_fonts)
l.addWidget(b)
self.refresh_button = b = self.bb.addButton(_('&Refresh'), QDialogButtonBox.ButtonRole.ActionRole)
b.setToolTip(_('Rescan the book for fonts in case you have made changes'))
b.setIcon(QIcon.ic('view-refresh.png'))
b.clicked.connect(self.refresh)
self.la = la = QLabel(
'<p>' + _(
''' All the fonts declared in this book are shown to the left, along with whether they are embedded or not.
You can remove or replace any selected font and also embed any declared fonts that are not already embedded.''') + '<p>' + _(
''' Double click any font family to see if the font is available for embedding on your computer. ''')
)
la.setWordWrap(True)
l.addWidget(la)
l.setAlignment(Qt.AlignmentFlag.AlignTop | Qt.AlignmentFlag.AlignHCenter)
def show_embedding_data(self, index):
faces = index.data(Qt.ItemDataRole.UserRole)
family = index.data(Qt.ItemDataRole.UserRole + 1)
if not faces:
return error_dialog(self, _('Not found'), _(
'The font <b>%s</b> was not found on your computer. If you have the font files,'
' you can install it using the "Install fonts" button in the lower left corner.'
) % family, show=True)
EmbeddingData(family, faces, self).exec()
def install_fonts(self):
from calibre.gui2.font_family_chooser import add_fonts
families = add_fonts(self)
if not families:
return
font_scanner.do_scan()
self.refresh()
info_dialog(self, _('Added fonts'), _('Added font families: %s')%(', '.join(families)), show=True)
def sizeHint(self):
return Dialog.sizeHint(self) + QSize(100, 50)
def display(self):
if not self.isVisible():
self.show()
self.raise_and_focus()
QTimer.singleShot(0, self.model.build)
def get_selected_data(self):
ans = self.model.data_for_indices(list(self.fonts_view.selectedIndexes()))
if not ans:
error_dialog(self, _('No fonts selected'), _(
'No fonts selected, you must first select some fonts in the left panel'), show=True)
return ans
def change_fonts(self):
fonts = self.get_selected_data()
if not fonts:
return
d = ChangeFontFamily(', '.join(fonts), {f for f, embedded in iteritems(self.model.font_data) if embedded}, self)
if d.exec() != QDialog.DialogCode.Accepted:
return
changed = False
new_family = d.normalized_family
for font in fonts:
changed |= change_font(current_container(), font, new_family)
if changed:
self.model.build()
self.container_changed.emit()
def remove_fonts(self):
fonts = self.get_selected_data()
if not fonts:
return
changed = False
for font in fonts:
changed |= change_font(current_container(), font)
if changed:
self.model.build()
self.container_changed.emit()
def embed_fonts(self):
self.embed_all_fonts.emit()
def subset_fonts(self):
self.subset_all_fonts.emit()
def refresh(self):
self.model.build()
if __name__ == '__main__':
from calibre.gui2 import Application
app = Application([])
c = get_container(sys.argv[-1], tweak_mode=True)
set_current_container(c)
d = ManageFonts()
d.exec()
del app
| 14,580 | Python | .py | 339 | 34.348083 | 137 | 0.622462 | kovidgoyal/calibre | 19,243 | 2,250 | 4 | GPL-3.0 | 9/5/2024, 5:13:50 PM (Europe/Amsterdam) |
26,695 | spell.py | kovidgoyal_calibre/src/calibre/gui2/tweak_book/spell.py | #!/usr/bin/env python
__license__ = 'GPL v3'
__copyright__ = '2014, Kovid Goyal <kovid at kovidgoyal.net>'
import os
import sys
from collections import OrderedDict, defaultdict
from functools import partial
from itertools import chain
from threading import Thread
import regex
from qt.core import (
QT_VERSION_STR,
QAbstractItemView,
QAbstractTableModel,
QAction,
QApplication,
QCheckBox,
QComboBox,
QDialog,
QDialogButtonBox,
QFont,
QFormLayout,
QGridLayout,
QHBoxLayout,
QIcon,
QInputDialog,
QKeySequence,
QLabel,
QLineEdit,
QListWidget,
QListWidgetItem,
QMenu,
QModelIndex,
QPlainTextEdit,
QPushButton,
QSize,
QStackedLayout,
Qt,
QTableView,
QTabWidget,
QTimer,
QToolButton,
QTreeWidget,
QTreeWidgetItem,
QVBoxLayout,
QWidget,
pyqtSignal,
)
from calibre.constants import __appname__
from calibre.ebooks.oeb.base import NCX_MIME, OEB_DOCS, OPF_MIME
from calibre.ebooks.oeb.polish.spell import get_all_words, get_checkable_file_names, merge_locations, replace_word, undo_replace_word
from calibre.gui2 import choose_files, error_dialog
from calibre.gui2.complete2 import LineEdit
from calibre.gui2.languages import LanguagesEdit
from calibre.gui2.progress_indicator import ProgressIndicator
from calibre.gui2.tweak_book import current_container, dictionaries, editors, set_book_locale, tprefs
from calibre.gui2.tweak_book.widgets import Dialog
from calibre.gui2.widgets import BusyCursor
from calibre.spell import DictionaryLocale
from calibre.spell.break_iterator import split_into_words
from calibre.spell.dictionary import (
best_locale_for_language,
builtin_dictionaries,
catalog_online_dictionaries,
custom_dictionaries,
dprefs,
get_dictionary,
remove_dictionary,
rename_dictionary,
)
from calibre.spell.import_from import import_from_online, import_from_oxt
from calibre.startup import connect_lambda
from calibre.utils.icu import contains, primary_contains, primary_sort_key, sort_key, upper
from calibre.utils.localization import calibre_langcode_to_name, canonicalize_lang, get_lang, get_language
from calibre.utils.resources import get_path as P
from calibre_extensions.progress_indicator import set_no_activate_on_click
from polyglot.builtins import iteritems
LANG = 0
COUNTRY = 1
DICTIONARY = 2
_country_map = None
def country_map():
global _country_map
if _country_map is None:
from calibre.utils.serialize import msgpack_loads
_country_map = msgpack_loads(P('localization/iso3166.calibre_msgpack', data=True, allow_user_override=False))
return _country_map
def current_languages_dictionaries(reread=False):
all_dictionaries = builtin_dictionaries() | custom_dictionaries(reread=reread)
languages = defaultdict(lambda : defaultdict(set))
for d in all_dictionaries:
for locale in d.locales | {d.primary_locale}:
languages[locale.langcode][locale.countrycode].add(d)
return languages
class AddDictionary(QDialog): # {{{
def __init__(self, parent=None):
QDialog.__init__(self, parent)
self.setWindowTitle(_('Add a dictionary'))
l = QVBoxLayout(self)
self.setLayout(l)
self.tabs = tabs = QTabWidget(self)
l.addWidget(self.tabs)
self.bb = bb = QDialogButtonBox(QDialogButtonBox.StandardButton.Ok|QDialogButtonBox.StandardButton.Cancel)
bb.accepted.connect(self.accept)
bb.rejected.connect(self.reject)
l.addWidget(bb)
self.web_download = QWidget(self)
self.oxt_import = QWidget(self)
tabs.setTabIcon(tabs.addTab(self.web_download, _('&Download')), QIcon.ic('download-metadata.png'))
tabs.setTabIcon(tabs.addTab(self.oxt_import, _('&Import from OXT file')), QIcon.ic('unpack-book.png'))
tabs.currentChanged.connect(self.tab_changed)
# Download online tab
l = QFormLayout(self.web_download)
l.setFieldGrowthPolicy(QFormLayout.FieldGrowthPolicy.AllNonFixedFieldsGrow)
self.web_download.setLayout(l)
la = QLabel('<p>' + _(
'''{0} supports the use of LibreOffice dictionaries for spell checking. Choose the language you
want below and click OK to download the dictionary from the <a href="{1}">LibreOffice dictionaries repository</a>.'''
).format(__appname__, 'https://github.com/LibreOffice/dictionaries')+'<p>')
la.setWordWrap(True)
la.setOpenExternalLinks(True)
la.setMinimumWidth(450)
l.addRow(la)
self.combobox_online = c = QComboBox(self)
l.addRow(_('&Language to download:'), c)
c.addItem('', None)
languages = current_languages_dictionaries(reread=False)
def k(dictionary):
return sort_key(calibre_langcode_to_name(dictionary['primary_locale'].langcode))
for data in sorted(catalog_online_dictionaries(), key=lambda x:k(x)):
if languages.get(data['primary_locale'].langcode, {}).get(data['primary_locale'].countrycode, None):
continue
local = calibre_langcode_to_name(data['primary_locale'].langcode)
country = country_map()['names'].get(data['primary_locale'].countrycode, None)
text = f'{local} ({country})' if country else local
data['text'] = text
c.addItem(text, data)
# Oxt import tab
l = QFormLayout(self.oxt_import)
l.setFieldGrowthPolicy(QFormLayout.FieldGrowthPolicy.AllNonFixedFieldsGrow)
self.oxt_import.setLayout(l)
la = QLabel('<p>' + _(
'''{0} supports the use of LibreOffice dictionaries for spell checking. You can
download more dictionaries from <a href="{1}">the LibreOffice extensions repository</a>.
The dictionary will download as an .oxt file. Simply specify the path to the
downloaded .oxt file here to add the dictionary to {0}.''').format(
__appname__, 'https://extensions.libreoffice.org/?Tags%5B%5D=50')+'<p>') # noqa
la.setWordWrap(True)
la.setOpenExternalLinks(True)
la.setMinimumWidth(450)
l.addRow(la)
h = QHBoxLayout()
self.path = p = QLineEdit(self)
p.setPlaceholderText(_('Path to OXT file'))
h.addWidget(p)
self.button_open_oxt = b = QToolButton(self)
b.setIcon(QIcon.ic('document_open.png'))
b.setToolTip(_('Browse for an OXT file'))
b.clicked.connect(self.choose_file)
h.addWidget(b)
l.addRow(_('&Path to OXT file:'), h)
l.labelForField(h).setBuddy(p)
self.nick = n = QLineEdit(self)
n.setPlaceholderText(_('Choose a nickname for this dictionary'))
l.addRow(_('&Nickname:'), n)
def tab_changed(self, idx):
if idx == 0:
self.combobox_online.setFocus(Qt.FocusReason.OtherFocusReason)
elif idx == 1:
self.button_open_oxt.setFocus(Qt.FocusReason.OtherFocusReason)
def choose_file(self):
path = choose_files(self, 'choose-dict-for-import', _('Choose OXT Dictionary'), filters=[
(_('Dictionaries'), ['oxt'])], all_files=False, select_only_single_file=True)
if path is not None:
self.path.setText(path[0])
if not self.nickname:
n = os.path.basename(path[0])
self.nick.setText(n.rpartition('.')[0])
@property
def nickname(self):
return str(self.nick.text()).strip()
def _process_oxt_import(self):
nick = self.nickname
if not nick:
return error_dialog(self, _('Must specify nickname'), _(
'You must specify a nickname for this dictionary'), show=True)
if nick in {d.name for d in custom_dictionaries()}:
return error_dialog(self, _('Nickname already used'), _(
'A dictionary with the nick name "%s" already exists.') % nick, show=True)
oxt = str(self.path.text())
try:
num = import_from_oxt(oxt, nick)
except:
import traceback
return error_dialog(self, _('Failed to import dictionaries'), _(
'Failed to import dictionaries from %s. Click "Show details" for more information') % oxt,
det_msg=traceback.format_exc(), show=True)
if num == 0:
return error_dialog(self, _('No dictionaries'), _(
'No dictionaries were found in %s') % oxt, show=True)
def _process_online_download(self):
data = self.combobox_online.currentData()
nick = 'online-'+data['name']
directory = data['directory']
if nick in {d.name for d in custom_dictionaries()}:
return error_dialog(self, _('Nickname already used'), _(
'A dictionary with the nick name "%s" already exists.') % nick, show=True)
try:
num = import_from_online(directory, nick)
except:
import traceback
return error_dialog(self, _('Failed to download dictionaries'), _(
'Failed to download dictionaries for "{:s}". Click "Show details" for more information').format(data['text']),
det_msg=traceback.format_exc(), show=True)
if num == 0:
return error_dialog(self, _('No dictionaries'), _(
'No dictionary was found for "{:s}"').format(data['text']), show=True)
def accept(self):
idx = self.tabs.currentIndex()
if idx == 0:
with BusyCursor():
self._process_online_download()
elif idx == 1:
self._process_oxt_import()
QDialog.accept(self)
# }}}
# User Dictionaries {{{
class UserWordList(QListWidget):
def __init__(self, parent=None):
QListWidget.__init__(self, parent)
def contextMenuEvent(self, ev):
m = QMenu(self)
m.addAction(_('Copy selected words to clipboard'), self.copy_to_clipboard)
m.addAction(_('Select all words'), self.select_all)
m.exec(ev.globalPos())
def select_all(self):
for item in (self.item(i) for i in range(self.count())):
item.setSelected(True)
def copy_to_clipboard(self):
words = []
for item in (self.item(i) for i in range(self.count())):
if item.isSelected():
words.append(item.data(Qt.ItemDataRole.UserRole)[0])
if words:
QApplication.clipboard().setText('\n'.join(words))
def keyPressEvent(self, ev):
if ev == QKeySequence.StandardKey.Copy:
self.copy_to_clipboard()
ev.accept()
return
return QListWidget.keyPressEvent(self, ev)
class ManageUserDictionaries(Dialog):
def __init__(self, parent=None):
self.dictionaries_changed = False
Dialog.__init__(self, _('Manage user dictionaries'), 'manage-user-dictionaries', parent=parent)
def setup_ui(self):
self.l = l = QVBoxLayout(self)
self.h = h = QHBoxLayout()
l.addLayout(h)
l.addWidget(self.bb)
self.bb.clear(), self.bb.addButton(QDialogButtonBox.StandardButton.Close)
b = self.bb.addButton(_('&New dictionary'), QDialogButtonBox.ButtonRole.ActionRole)
b.setIcon(QIcon.ic('spell-check.png'))
b.clicked.connect(self.new_dictionary)
self.dictionaries = d = QListWidget(self)
self.emph_font = f = QFont(self.font())
f.setBold(True)
self.build_dictionaries()
d.currentItemChanged.connect(self.show_current_dictionary)
h.addWidget(d)
l = QVBoxLayout()
h.addLayout(l)
h = QHBoxLayout()
self.remove_button = b = QPushButton(QIcon.ic('trash.png'), _('&Remove dictionary'), self)
b.clicked.connect(self.remove_dictionary)
h.addWidget(b)
self.rename_button = b = QPushButton(QIcon.ic('modified.png'), _('Re&name dictionary'), self)
b.clicked.connect(self.rename_dictionary)
h.addWidget(b)
self.dlabel = la = QLabel('')
l.addWidget(la)
l.addLayout(h)
self.is_active = a = QCheckBox(_('Mark this dictionary as active'))
self.is_active.stateChanged.connect(self.active_toggled)
l.addWidget(a)
self.la = la = QLabel(_('Words in this dictionary:'))
l.addWidget(la)
self.words = w = UserWordList(self)
w.setSelectionMode(QAbstractItemView.SelectionMode.ExtendedSelection)
l.addWidget(w)
self.add_word_button = b = QPushButton(_('&Add word'), self)
b.clicked.connect(self.add_word)
b.setIcon(QIcon.ic('plus.png'))
l.h = h = QHBoxLayout()
l.addLayout(h)
h.addWidget(b)
self.remove_word_button = b = QPushButton(_('&Remove selected words'), self)
b.clicked.connect(self.remove_word)
b.setIcon(QIcon.ic('minus.png'))
h.addWidget(b)
self.import_words_button = b = QPushButton(_('&Import list of words'), self)
b.clicked.connect(self.import_words)
l.addWidget(b)
self.show_current_dictionary()
def sizeHint(self):
return Dialog.sizeHint(self) + QSize(30, 100)
def build_dictionaries(self, current=None):
self.dictionaries.clear()
for dic in sorted(dictionaries.all_user_dictionaries, key=lambda d:sort_key(d.name)):
i = QListWidgetItem(dic.name, self.dictionaries)
i.setData(Qt.ItemDataRole.UserRole, dic)
if dic.is_active:
i.setData(Qt.ItemDataRole.FontRole, self.emph_font)
if current == dic.name:
self.dictionaries.setCurrentItem(i)
if current is None and self.dictionaries.count() > 0:
self.dictionaries.setCurrentRow(0)
def new_dictionary(self):
name, ok = QInputDialog.getText(self, _('New dictionary'), _(
'Name of the new dictionary'))
if ok:
name = str(name)
if name in {d.name for d in dictionaries.all_user_dictionaries}:
return error_dialog(self, _('Already used'), _(
'A dictionary with the name %s already exists') % name, show=True)
dictionaries.create_user_dictionary(name)
self.dictionaries_changed = True
self.build_dictionaries(name)
self.show_current_dictionary()
def remove_dictionary(self):
d = self.current_dictionary
if d is None:
return
if dictionaries.remove_user_dictionary(d.name):
self.build_dictionaries()
self.dictionaries_changed = True
self.show_current_dictionary()
def rename_dictionary(self):
d = self.current_dictionary
if d is None:
return
name, ok = QInputDialog.getText(self, _('New name'), _(
'New name for the dictionary'))
if ok:
name = str(name)
if name == d.name:
return
if name in {d.name for d in dictionaries.all_user_dictionaries}:
return error_dialog(self, _('Already used'), _(
'A dictionary with the name %s already exists') % name, show=True)
if dictionaries.rename_user_dictionary(d.name, name):
self.build_dictionaries(name)
self.dictionaries_changed = True
self.show_current_dictionary()
@property
def current_dictionary(self):
d = self.dictionaries.currentItem()
if d is None:
return
return d.data(Qt.ItemDataRole.UserRole)
def active_toggled(self):
d = self.current_dictionary
if d is not None:
dictionaries.mark_user_dictionary_as_active(d.name, self.is_active.isChecked())
self.dictionaries_changed = True
for item in (self.dictionaries.item(i) for i in range(self.dictionaries.count())):
d = item.data(Qt.ItemDataRole.UserRole)
item.setData(Qt.ItemDataRole.FontRole, self.emph_font if d.is_active else None)
def show_current_dictionary(self, *args):
d = self.current_dictionary
if d is None:
return
self.dlabel.setText(_('Configure the dictionary: <b>%s') % d.name)
self.is_active.blockSignals(True)
self.is_active.setChecked(d.is_active)
self.is_active.blockSignals(False)
self.words.clear()
for word, lang in sorted(d.words, key=lambda x:sort_key(x[0])):
i = QListWidgetItem(f'{word} [{get_language(lang)}]', self.words)
i.setData(Qt.ItemDataRole.UserRole, (word, lang))
def add_word(self):
d = QDialog(self)
d.l = l = QFormLayout(d)
d.setWindowTitle(_('Add a word'))
d.w = w = QLineEdit(d)
w.setPlaceholderText(_('Word to add'))
l.addRow(_('&Word:'), w)
d.loc = loc = LanguagesEdit(parent=d)
l.addRow(_('&Language:'), d.loc)
loc.lang_codes = [canonicalize_lang(get_lang())]
d.bb = bb = QDialogButtonBox(QDialogButtonBox.StandardButton.Ok|QDialogButtonBox.StandardButton.Cancel)
bb.accepted.connect(d.accept), bb.rejected.connect(d.reject)
l.addRow(bb)
if d.exec() != QDialog.DialogCode.Accepted:
return
d.loc.update_recently_used()
word = str(w.text())
lang = (loc.lang_codes or [canonicalize_lang(get_lang())])[0]
if not word:
return
if (word, lang) not in self.current_dictionary.words:
dictionaries.add_to_user_dictionary(self.current_dictionary.name, word, DictionaryLocale(lang, None))
dictionaries.clear_caches()
self.show_current_dictionary()
self.dictionaries_changed = True
idx = self.find_word(word, lang)
if idx > -1:
self.words.scrollToItem(self.words.item(idx))
def import_words(self):
d = QDialog(self)
d.l = l = QFormLayout(d)
d.setWindowTitle(_('Import list of words'))
d.w = w = QPlainTextEdit(d)
l.addRow(QLabel(_('Enter a list of words, one per line')))
l.addRow(w)
d.b = b = QPushButton(_('Paste from clipboard'))
l.addRow(b)
b.clicked.connect(w.paste)
d.la = la = QLabel(_('Words in the user dictionary must have an associated language. Choose the language below:'))
la.setWordWrap(True)
l.addRow(la)
d.le = le = LanguagesEdit(d)
lc = canonicalize_lang(get_lang())
if lc:
le.lang_codes = [lc]
l.addRow(_('&Language:'), le)
d.bb = bb = QDialogButtonBox(QDialogButtonBox.StandardButton.Ok|QDialogButtonBox.StandardButton.Cancel)
l.addRow(bb)
bb.accepted.connect(d.accept), bb.rejected.connect(d.reject)
if d.exec() != QDialog.DialogCode.Accepted:
return
lc = le.lang_codes
if not lc:
return error_dialog(self, _('Must specify language'), _(
'You must specify a language to import words'), show=True)
words = set(filter(None, [x.strip() for x in str(w.toPlainText()).splitlines()]))
lang = lc[0]
words_with_lang = {(w, lang) for w in words} - self.current_dictionary.words
if dictionaries.add_to_user_dictionary(self.current_dictionary.name, words_with_lang, DictionaryLocale(lang, None)):
dictionaries.clear_caches()
self.show_current_dictionary()
self.dictionaries_changed = True
def remove_word(self):
words = {i.data(Qt.ItemDataRole.UserRole) for i in self.words.selectedItems()}
if words:
kwords = [(w, DictionaryLocale(l, None)) for w, l in words]
d = self.current_dictionary
if dictionaries.remove_from_user_dictionary(d.name, kwords):
dictionaries.clear_caches()
self.show_current_dictionary()
self.dictionaries_changed = True
def find_word(self, word, lang):
key = (word, lang)
for i in range(self.words.count()):
if self.words.item(i).data(Qt.ItemDataRole.UserRole) == key:
return i
return -1
@classmethod
def test(cls):
d = cls()
d.exec()
# }}}
class ManageDictionaries(Dialog): # {{{
def __init__(self, parent=None):
Dialog.__init__(self, _('Manage dictionaries'), 'manage-dictionaries', parent=parent)
def sizeHint(self):
ans = Dialog.sizeHint(self)
ans.setWidth(ans.width() + 250)
ans.setHeight(ans.height() + 200)
return ans
def setup_ui(self):
self.l = l = QGridLayout(self)
self.setLayout(l)
self.stack = s = QStackedLayout()
self.helpl = la = QLabel('<p>')
la.setWordWrap(True)
self.pcb = pc = QPushButton(self)
pc.clicked.connect(self.set_preferred_country)
self.lw = w = QWidget(self)
self.ll = ll = QVBoxLayout(w)
ll.addWidget(pc)
self.dw = w = QWidget(self)
self.dl = dl = QVBoxLayout(w)
self.fb = b = QPushButton(self)
b.clicked.connect(self.set_favorite)
self.remove_dictionary_button = rd = QPushButton(_('&Remove this dictionary'), w)
rd.clicked.connect(self.remove_dictionary)
dl.addWidget(b), dl.addWidget(rd)
w.setLayout(dl)
s.addWidget(la)
s.addWidget(self.lw)
s.addWidget(w)
self.dictionaries = d = QTreeWidget(self)
d.itemChanged.connect(self.data_changed, type=Qt.ConnectionType.QueuedConnection)
self.build_dictionaries()
d.setCurrentIndex(d.model().index(0, 0))
d.header().close()
d.currentItemChanged.connect(self.current_item_changed)
self.current_item_changed()
l.addWidget(d)
l.addLayout(s, 0, 1)
self.bb.clear()
self.bb.addButton(QDialogButtonBox.StandardButton.Close)
b = self.bb.addButton(_('Manage &user dictionaries'), QDialogButtonBox.ButtonRole.ActionRole)
b.setIcon(QIcon.ic('user_profile.png'))
b.setToolTip(_(
'Manage the list of user dictionaries (dictionaries to which you can add words)'))
b.clicked.connect(self.manage_user_dictionaries)
b = self.bb.addButton(_('&Add dictionary'), QDialogButtonBox.ButtonRole.ActionRole)
b.setToolTip(_(
'Add a new dictionary that you downloaded from the internet'))
b.setIcon(QIcon.ic('plus.png'))
b.clicked.connect(self.add_dictionary)
l.addWidget(self.bb, l.rowCount(), 0, 1, l.columnCount())
def manage_user_dictionaries(self):
d = ManageUserDictionaries(self)
d.exec()
if d.dictionaries_changed:
self.dictionaries_changed = True
def data_changed(self, item, column):
if column == 0 and item.type() == DICTIONARY:
d = item.data(0, Qt.ItemDataRole.UserRole)
if not d.builtin and str(item.text(0)) != d.name:
rename_dictionary(d, str(item.text(0)))
def build_dictionaries(self, reread=False):
languages = current_languages_dictionaries(reread=reread)
bf = QFont(self.dictionaries.font())
bf.setBold(True)
itf = QFont(self.dictionaries.font())
itf.setItalic(True)
self.dictionaries.clear()
for lc in sorted(languages, key=lambda x:sort_key(calibre_langcode_to_name(x))):
i = QTreeWidgetItem(self.dictionaries, LANG)
i.setText(0, calibre_langcode_to_name(lc))
i.setData(0, Qt.ItemDataRole.UserRole, lc)
best_country = getattr(best_locale_for_language(lc), 'countrycode', None)
for countrycode in sorted(languages[lc], key=lambda x: country_map()['names'].get(x, x)):
j = QTreeWidgetItem(i, COUNTRY)
j.setText(0, country_map()['names'].get(countrycode, countrycode))
j.setData(0, Qt.ItemDataRole.UserRole, countrycode)
if countrycode == best_country:
j.setData(0, Qt.ItemDataRole.FontRole, bf)
pd = get_dictionary(DictionaryLocale(lc, countrycode))
for dictionary in sorted(languages[lc][countrycode], key=lambda d:(d.name or '')):
k = QTreeWidgetItem(j, DICTIONARY)
pl = calibre_langcode_to_name(dictionary.primary_locale.langcode)
if dictionary.primary_locale.countrycode:
pl += '-' + dictionary.primary_locale.countrycode.upper()
k.setText(0, dictionary.name or (_('<Builtin dictionary for {0}>').format(pl)))
k.setData(0, Qt.ItemDataRole.UserRole, dictionary)
if dictionary.name:
k.setFlags(k.flags() | Qt.ItemFlag.ItemIsEditable)
if pd == dictionary:
k.setData(0, Qt.ItemDataRole.FontRole, itf)
self.dictionaries.expandAll()
def add_dictionary(self):
d = AddDictionary(self)
if d.exec() == QDialog.DialogCode.Accepted:
self.build_dictionaries(reread=True)
def remove_dictionary(self):
item = self.dictionaries.currentItem()
if item is not None and item.type() == DICTIONARY:
dic = item.data(0, Qt.ItemDataRole.UserRole)
if not dic.builtin:
remove_dictionary(dic)
self.build_dictionaries(reread=True)
def current_item_changed(self):
item = self.dictionaries.currentItem()
if item is not None:
self.stack.setCurrentIndex(item.type())
if item.type() == LANG:
self.init_language(item)
elif item.type() == COUNTRY:
self.init_country(item)
elif item.type() == DICTIONARY:
self.init_dictionary(item)
def init_language(self, item):
self.helpl.setText(_(
'''<p>You can change the dictionaries used for any specified language.</p>
<p>A language can have many country specific variants. Each of these variants
can have one or more dictionaries assigned to it. The default variant for each language
is shown in bold to the left.</p>
<p>You can change the default country variant as well as changing the dictionaries used for
every variant.</p>
<p>When a book specifies its language as a plain language, without any country variant,
the default variant you choose here will be used.</p>
'''))
def init_country(self, item):
pc = self.pcb
font = item.data(0, Qt.ItemDataRole.FontRole)
preferred = bool(font and font.bold())
pc.setText((_(
'This is already the preferred variant for the {1} language') if preferred else _(
'Use this as the preferred variant for the {1} language')).format(
str(item.text(0)), str(item.parent().text(0))))
pc.setEnabled(not preferred)
def set_preferred_country(self):
item = self.dictionaries.currentItem()
bf = QFont(self.dictionaries.font())
bf.setBold(True)
for x in (item.parent().child(i) for i in range(item.parent().childCount())):
x.setData(0, Qt.ItemDataRole.FontRole, bf if x is item else None)
lc = str(item.parent().data(0, Qt.ItemDataRole.UserRole))
pl = dprefs['preferred_locales']
pl[lc] = f'{lc}-{str(item.data(0, Qt.ItemDataRole.UserRole))}'
dprefs['preferred_locales'] = pl
def init_dictionary(self, item):
saf = self.fb
font = item.data(0, Qt.ItemDataRole.FontRole)
preferred = bool(font and font.italic())
saf.setText(_(
'This is already the preferred dictionary') if preferred else
_('Use this as the preferred dictionary'))
saf.setEnabled(not preferred)
self.remove_dictionary_button.setEnabled(not item.data(0, Qt.ItemDataRole.UserRole).builtin)
def set_favorite(self):
item = self.dictionaries.currentItem()
bf = QFont(self.dictionaries.font())
bf.setItalic(True)
for x in (item.parent().child(i) for i in range(item.parent().childCount())):
x.setData(0, Qt.ItemDataRole.FontRole, bf if x is item else None)
cc = str(item.parent().data(0, Qt.ItemDataRole.UserRole))
lc = str(item.parent().parent().data(0, Qt.ItemDataRole.UserRole))
d = item.data(0, Qt.ItemDataRole.UserRole)
locale = f'{lc}-{cc}'
pl = dprefs['preferred_dictionaries']
pl[locale] = d.id
dprefs['preferred_dictionaries'] = pl
@classmethod
def test(cls):
d = cls()
d.exec()
# }}}
# Spell Check Dialog {{{
class WordsModel(QAbstractTableModel):
word_ignored = pyqtSignal(object, object)
counts_changed = pyqtSignal()
def __init__(self, parent=None, show_only_misspelt=True):
QAbstractTableModel.__init__(self, parent)
self.counts = (0, 0)
self.all_caps = self.with_numbers = self.camel_case = self.snake_case = False
self.words = {} # Map of (word, locale) to location data for the word
self.spell_map = {} # Map of (word, locale) to dictionaries.recognized(word, locale)
self.sort_on = (0, False)
self.items = [] # The currently displayed items
self.filter_expression = None
self.show_only_misspelt = show_only_misspelt
self.headers = (_('Word'), _('Count'), _('Language'), _('Misspelled?'))
self.alignments = Qt.AlignmentFlag.AlignLeft, Qt.AlignmentFlag.AlignRight, Qt.AlignmentFlag.AlignLeft, Qt.AlignmentFlag.AlignHCenter
self.num_pat = regex.compile(r'\d', flags=regex.UNICODE)
self.camel_case_pat = regex.compile(r'[a-z][A-Z]', flags=regex.UNICODE)
self.snake_case_pat = regex.compile(r'\w_\w', flags=regex.UNICODE)
def rowCount(self, parent=QModelIndex()):
return len(self.items)
def columnCount(self, parent=QModelIndex()):
return len(self.headers)
def clear(self):
self.beginResetModel()
self.words = {}
self.spell_map = {}
self.items =[]
self.endResetModel()
def headerData(self, section, orientation, role=Qt.ItemDataRole.DisplayRole):
if orientation == Qt.Orientation.Horizontal:
if role == Qt.ItemDataRole.DisplayRole:
try:
return self.headers[section]
except IndexError:
pass
elif role == Qt.ItemDataRole.InitialSortOrderRole:
return (Qt.SortOrder.DescendingOrder if section == 1 else Qt.SortOrder.AscendingOrder).value # https://bugreports.qt.io/browse/PYSIDE-1974
elif role == Qt.ItemDataRole.TextAlignmentRole:
return int(Qt.AlignmentFlag.AlignVCenter | self.alignments[section]) # https://bugreports.qt.io/browse/PYSIDE-1974
def misspelled_text(self, w):
if self.spell_map[w]:
return _('Ignored') if dictionaries.is_word_ignored(*w) else ''
return '✓'
def data(self, index, role=Qt.ItemDataRole.DisplayRole):
try:
word, locale = self.items[index.row()]
except IndexError:
return
if role == Qt.ItemDataRole.DisplayRole:
col = index.column()
if col == 0:
return word
if col == 1:
return f'{len(self.words[(word, locale)])} '
if col == 2:
pl = calibre_langcode_to_name(locale.langcode)
countrycode = locale.countrycode
if countrycode:
pl = f' {pl} ({countrycode})'
return pl
if col == 3:
return self.misspelled_text((word, locale))
if role == Qt.ItemDataRole.TextAlignmentRole:
return int(Qt.AlignmentFlag.AlignVCenter | self.alignments[index.column()]) # https://bugreports.qt.io/browse/PYSIDE-1974
def sort(self, column, order=Qt.SortOrder.AscendingOrder):
reverse = order != Qt.SortOrder.AscendingOrder
self.sort_on = (column, reverse)
self.beginResetModel()
self.do_sort()
self.endResetModel()
def filter(self, filter_text, *, all_caps=False, with_numbers=False, camel_case=False, snake_case=False, show_only_misspelt=True):
self.filter_expression = filter_text or None
self.all_caps, self.with_numbers = all_caps, with_numbers
self.camel_case, self.snake_case = camel_case, snake_case
self.show_only_misspelt = show_only_misspelt
self.beginResetModel()
self.do_filter()
self.do_sort()
self.endResetModel()
def sort_key(self, col):
if col == 0:
f = (lambda x: x) if tprefs['spell_check_case_sensitive_sort'] else primary_sort_key
def key(w):
return f(w[0])
elif col == 1:
def key(w):
return len(self.words[w])
elif col == 2:
def key(w):
locale = w[1]
return (calibre_langcode_to_name(locale.langcode) or ''), (locale.countrycode or '')
else:
key = self.misspelled_text
return key
def do_sort(self):
col, reverse = self.sort_on
self.items.sort(key=self.sort_key(col), reverse=reverse)
def set_data(self, words, spell_map):
self.words, self.spell_map = words, spell_map
self.beginResetModel()
self.do_filter()
self.do_sort()
self.update_counts(emit_signal=False)
self.endResetModel()
def update_counts(self, emit_signal=True):
self.counts = (len([None for w, recognized in iteritems(self.spell_map) if not recognized]), len(self.words))
if emit_signal:
self.counts_changed.emit()
def filter_item(self, x):
if self.show_only_misspelt and self.spell_map[x]:
return False
func = contains if tprefs['spell_check_case_sensitive_search'] else primary_contains
word = x[0]
if self.filter_expression is not None and not func(self.filter_expression, word):
return False
if self.all_caps and upper(word) == word:
return False
if self.with_numbers and self.num_pat.search(word) is not None:
return False
if self.camel_case and self.camel_case_pat.search(word) is not None:
return False
if self.snake_case and self.snake_case_pat.search(word) is not None:
return False
return True
def do_filter(self):
self.items = list(filter(self.filter_item, self.words))
self.counts_changed.emit()
def toggle_ignored(self, row):
w = self.word_for_row(row)
if w is not None:
ignored = dictionaries.is_word_ignored(*w)
(dictionaries.unignore_word if ignored else dictionaries.ignore_word)(*w)
self.spell_map[w] = dictionaries.recognized(*w)
self.update_word(w)
self.word_ignored.emit(*w)
self.update_counts()
def ignore_words(self, rows):
words = {self.word_for_row(r) for r in rows}
words.discard(None)
for w in words:
ignored = dictionaries.is_word_ignored(*w)
(dictionaries.unignore_word if ignored else dictionaries.ignore_word)(*w)
self.spell_map[w] = dictionaries.recognized(*w)
self.update_word(w)
self.word_ignored.emit(*w)
self.update_counts()
def add_word(self, row, udname):
w = self.word_for_row(row)
if w is not None:
if dictionaries.add_to_user_dictionary(udname, *w):
self.spell_map[w] = dictionaries.recognized(*w)
self.update_word(w)
self.word_ignored.emit(*w)
self.update_counts()
def add_words(self, dicname, rows):
words = {self.word_for_row(r) for r in rows}
words.discard(None)
for w in words:
if not dictionaries.add_to_user_dictionary(dicname, *w):
dictionaries.remove_from_user_dictionary(dicname, [w])
self.spell_map[w] = dictionaries.recognized(*w)
self.update_word(w)
self.word_ignored.emit(*w)
self.update_counts()
def remove_word(self, row):
w = self.word_for_row(row)
if w is not None:
if dictionaries.remove_from_user_dictionaries(*w):
self.spell_map[w] = dictionaries.recognized(*w)
self.update_word(w)
self.update_counts()
def replace_word(self, w, new_word):
# Hack to deal with replacement words that are actually multiple words,
# ignore all words except the first
try:
new_word = split_into_words(new_word)[0]
except IndexError:
new_word = ''
for location in self.words[w]:
location.replace(new_word)
if w[0] == new_word:
return w
new_key = (new_word, w[1])
if new_key in self.words:
self.words[new_key] = merge_locations(self.words[new_key], self.words[w])
row = self.row_for_word(w)
self.dataChanged.emit(self.index(row, 1), self.index(row, 1))
else:
self.words[new_key] = self.words[w]
self.spell_map[new_key] = dictionaries.recognized(*new_key)
self.update_word(new_key)
self.update_counts()
row = self.row_for_word(w)
if row > -1:
self.beginRemoveRows(QModelIndex(), row, row)
del self.items[row]
self.endRemoveRows()
self.words.pop(w, None)
return new_key
def update_word(self, w):
should_be_filtered = not self.filter_item(w)
row = self.row_for_word(w)
if should_be_filtered and row != -1:
self.beginRemoveRows(QModelIndex(), row, row)
del self.items[row]
self.endRemoveRows()
elif not should_be_filtered and row == -1:
self.items.append(w)
self.do_sort()
row = self.row_for_word(w)
self.beginInsertRows(QModelIndex(), row, row)
self.endInsertRows()
self.dataChanged.emit(self.index(row, 3), self.index(row, 3))
def word_for_row(self, row):
try:
return self.items[row]
except IndexError:
pass
def row_for_word(self, word):
try:
return self.items.index(word)
except ValueError:
return -1
class WordsView(QTableView):
ignore_all = pyqtSignal()
add_all = pyqtSignal(object)
change_to = pyqtSignal(object, object)
current_changed = pyqtSignal(object, object)
def __init__(self, parent=None):
QTableView.__init__(self, parent)
self.setSortingEnabled(True), self.setShowGrid(False), self.setAlternatingRowColors(True)
self.setSelectionBehavior(QAbstractItemView.SelectionBehavior.SelectRows)
self.setTabKeyNavigation(False)
self.verticalHeader().close()
def change_current_word_by(self, delta=1):
rc = self.model().rowCount()
if rc > 0:
row = self.currentIndex().row()
row = (row + delta + rc) % rc
self.highlight_row(row)
def next_word(self):
self.change_current_word_by(1)
def previous_word(self):
self.change_current_word_by(-1)
def keyPressEvent(self, ev):
if ev == QKeySequence.StandardKey.Copy:
self.copy_to_clipboard()
ev.accept()
return
before = self.currentIndex()
ret = QTableView.keyPressEvent(self, ev)
after = self.currentIndex()
if after.row() != before.row() and after.isValid():
self.scrollTo(after)
return ret
def highlight_row(self, row):
idx = self.model().index(row, 0)
if idx.isValid():
self.selectRow(row)
self.setCurrentIndex(idx)
self.scrollTo(idx)
def contextMenuEvent(self, ev):
m = QMenu(self)
w = self.model().word_for_row(self.currentIndex().row())
if w is not None:
a = m.addAction(_('Change %s to') % w[0])
cm = QMenu(self)
a.setMenu(cm)
cm.addAction(_('Specify replacement manually'), partial(self.change_to.emit, w, None))
cm.addSeparator()
for s in dictionaries.suggestions(*w):
cm.addAction(s, partial(self.change_to.emit, w, s))
m.addAction(_('Ignore/un-ignore all selected words'), self.ignore_all)
a = m.addAction(_('Add/remove all selected words'))
am = QMenu(self)
a.setMenu(am)
for dic in sorted(dictionaries.active_user_dictionaries, key=lambda x:sort_key(x.name)):
am.addAction(dic.name, partial(self.add_all.emit, dic.name))
m.addSeparator()
m.addAction(_('Copy selected words to clipboard'), self.copy_to_clipboard)
m.exec(ev.globalPos())
def copy_to_clipboard(self):
rows = {i.row() for i in self.selectedIndexes()}
words = {self.model().word_for_row(r) for r in rows}
words.discard(None)
words = sorted({w[0] for w in words}, key=sort_key)
if words:
QApplication.clipboard().setText('\n'.join(words))
def currentChanged(self, cur, prev):
self.current_changed.emit(cur, prev)
@property
def current_word(self):
return self.model().word_for_row(self.currentIndex().row())
class ManageExcludedFiles(Dialog):
def __init__(self, parent, excluded_files):
self.orig_excluded_files = frozenset(excluded_files)
super().__init__(_('Exclude files from spell check'), 'spell-check-exclude-files2', parent)
def sizeHint(self):
return QSize(500, 600)
def setup_ui(self):
self.la = la = QLabel(_(
'Choose the files to exclude below. In addition to this list any file'
' can be permanently excluded by adding the comment {} just under its opening tag.').format(
'<!-- calibre-no-spell-check -->'))
la.setWordWrap(True)
la.setTextFormat(Qt.TextFormat.PlainText)
self.l = l = QVBoxLayout(self)
l.addWidget(la)
self.files = QListWidget(self)
self.files.setSelectionMode(QAbstractItemView.SelectionMode.MultiSelection)
cc = current_container()
for name in sorted(cc.mime_map):
mt = cc.mime_map[name]
if mt in OEB_DOCS or mt in (NCX_MIME, OPF_MIME):
i = QListWidgetItem(self.files)
i.setText(name)
if name in self.orig_excluded_files:
i.setSelected(True)
l.addWidget(self.files)
l.addWidget(self.bb)
@property
def excluded_files(self):
return {item.text() for item in self.files.selectedItems()}
class SuggestedList(QListWidget):
def next_word(self):
row = (self.currentRow() + 1) % self.count()
self.setCurrentRow(row)
def previous_word(self):
row = (self.currentRow() - 1 + self.count()) % self.count()
self.setCurrentRow(row)
class SpellCheck(Dialog):
work_finished = pyqtSignal(object, object, object)
find_word = pyqtSignal(object, object)
refresh_requested = pyqtSignal()
word_replaced = pyqtSignal(object)
word_ignored = pyqtSignal(object, object)
change_requested = pyqtSignal(object, object)
def __init__(self, parent=None):
self.__current_word = None
self.thread = None
self.cancel = False
dictionaries.initialize()
self.current_word_changed_timer = t = QTimer()
t.timeout.connect(self.do_current_word_changed)
t.setSingleShot(True), t.setInterval(100)
self.excluded_files = set()
Dialog.__init__(self, _('Check spelling'), 'spell-check', parent)
self.work_finished.connect(self.work_done, type=Qt.ConnectionType.QueuedConnection)
self.setAttribute(Qt.WidgetAttribute.WA_DeleteOnClose, False)
self.undo_cache = {}
def setup_ui(self):
self.state_name = 'spell-check-table-state-' + QT_VERSION_STR.partition('.')[0]
self.setWindowIcon(QIcon.ic('spell-check.png'))
self.l = l = QVBoxLayout(self)
self.setLayout(l)
self.stack = s = QStackedLayout()
l.addLayout(s)
l.addWidget(self.bb)
self.bb.clear()
self.bb.addButton(QDialogButtonBox.StandardButton.Close)
b = self.bb.addButton(_('&Refresh'), QDialogButtonBox.ButtonRole.ActionRole)
b.setToolTip('<p>' + _('Re-scan the book for words, useful if you have edited the book since opening this dialog'))
b.setIcon(QIcon.ic('view-refresh.png'))
connect_lambda(b.clicked, self, lambda self: self.refresh(change_request=None))
b = self.bb.addButton(_('&Undo last change'), QDialogButtonBox.ButtonRole.ActionRole)
b.setToolTip('<p>' + _('Undo the last spell check word replacement, if any'))
b.setIcon(QIcon.ic('edit-undo.png'))
b.clicked.connect(self.undo_last_change)
b = self.exclude_button = self.bb.addButton('', QDialogButtonBox.ButtonRole.ActionRole)
b.setToolTip('<p>' + _('Exclude some files in the book from spell check'))
b.setIcon(QIcon.ic('chapters.png'))
b.clicked.connect(self.change_excluded_files)
self.update_exclude_button()
self.progress = p = QWidget(self)
s.addWidget(p)
p.l = l = QVBoxLayout(p)
l.setAlignment(Qt.AlignmentFlag.AlignCenter)
self.progress_indicator = pi = ProgressIndicator(self, 256)
l.addWidget(pi, alignment=Qt.AlignmentFlag.AlignHCenter), l.addSpacing(10)
p.la = la = QLabel(_('Checking, please wait...'))
la.setStyleSheet('QLabel { font-size: 30pt; font-weight: bold }')
l.addWidget(la, alignment=Qt.AlignmentFlag.AlignHCenter)
self.main = m = QWidget(self)
s.addWidget(m)
m.l = l = QVBoxLayout(m)
self.filter_text = t = QLineEdit(self)
t.setPlaceholderText(_('Filter the list of words'))
t.textChanged.connect(self.do_filter)
t.setClearButtonEnabled(True)
l.addWidget(t)
h = QHBoxLayout()
l.addLayout(h)
h.addWidget(QLabel(_('Also hide words:')))
any_hide_checked = False
def hw(name, title, tooltip):
nonlocal any_hide_checked
ac = QCheckBox(title)
pref_name = f'spell-check-hide-words-{name}'
ac.setObjectName(pref_name)
defval = name == 'misspelled'
ac.setChecked(tprefs.get(pref_name, defval))
if ac.isChecked():
any_hide_checked = True
ac.toggled.connect(self.hide_words_toggled)
ac.setToolTip(tooltip)
h.addWidget(ac)
return ac
self.show_only_misspelt = hw('misspelled', _('&spelled correctly'), _('Hide words that are spelled correctly'))
self.all_caps = hw('all-caps', _('&ALL CAPS'), _('Hide words with all capital letters'))
self.with_numbers = hw('with-numbers', _('with &numbers'), _('Hide words that contain numbers'))
self.camel_case = hw('camel-case', _('ca&melCase'), _('Hide words in camelCase'))
self.snake_case = hw('snake-case', _('sna&ke_case'), _('Hide words in snake_case'))
h.addStretch(10)
m.h2 = h = QHBoxLayout()
l.addLayout(h)
self.words_view = w = WordsView(m)
set_no_activate_on_click(w)
w.ignore_all.connect(self.ignore_all)
w.add_all.connect(self.add_all)
w.activated.connect(self.word_activated)
w.change_to.connect(self.change_to)
w.current_changed.connect(self.current_word_changed)
state = tprefs.get(self.state_name, None)
hh = self.words_view.horizontalHeader()
h.addWidget(w)
self.words_model = m = WordsModel(self, show_only_misspelt=self.show_only_misspelt.isChecked())
m.counts_changed.connect(self.update_summary)
w.setModel(m)
m.dataChanged.connect(self.current_word_changed)
m.modelReset.connect(self.current_word_changed)
m.word_ignored.connect(self.word_ignored)
if state is not None:
hh.restoreState(state)
# Sort by the restored state, if any
w.sortByColumn(hh.sortIndicatorSection(), hh.sortIndicatorOrder())
self.ignore_button = b = QPushButton(_('&Ignore'))
b.ign_text, b.unign_text = str(b.text()), _('Un&ignore')
b.ign_tt = _('Ignore the current word for the rest of this session')
b.unign_tt = _('Stop ignoring the current word')
b.clicked.connect(self.toggle_ignore)
l = QVBoxLayout()
h.addLayout(l)
h.setStretch(0, 1)
l.addWidget(b), l.addSpacing(20)
self.add_button = b = QPushButton(_('Add word to &dictionary:'))
b.add_text, b.remove_text = str(b.text()), _('Remove from &dictionaries')
b.add_tt = _('Add the current word to the specified user dictionary')
b.remove_tt = _('Remove the current word from all active user dictionaries')
b.clicked.connect(self.add_remove)
self.user_dictionaries = d = QComboBox(self)
self.user_dictionaries_missing_label = la = QLabel(_(
'You have no active user dictionaries. You must'
' choose at least one active user dictionary via'
' Preferences->Editor->Manage spelling dictionaries'), self)
la.setWordWrap(True)
self.initialize_user_dictionaries()
d.setMinimumContentsLength(25)
l.addWidget(b), l.addWidget(d), l.addWidget(la)
self.next_occurrence = b = QPushButton(_('Show &next occurrence'), self)
b.setToolTip('<p>' + _(
'Show the next occurrence of the selected word in the editor, so you can edit it manually'))
b.clicked.connect(self.show_next_occurrence)
l.addSpacing(20), l.addWidget(b)
l.addStretch(1)
self.change_button = b = QPushButton(_('&Change selected word to:'), self)
b.clicked.connect(self.change_word)
l.addWidget(b)
self.suggested_word = sw = LineEdit(self)
sw.set_separator(None)
sw.setPlaceholderText(_('The replacement word'))
sw.returnPressed.connect(self.change_word)
l.addWidget(sw)
self.suggested_list = sl = SuggestedList(self)
sl.currentItemChanged.connect(self.current_suggestion_changed)
sl.itemActivated.connect(self.change_word)
set_no_activate_on_click(sl)
l.addWidget(sl)
hh.setSectionHidden(3, self.show_only_misspelt.isChecked())
self.case_sensitive_sort = cs = QCheckBox(_('Case &sensitive sort'))
cs.setChecked(tprefs['spell_check_case_sensitive_sort'])
cs.setToolTip(_('When sorting the list of words, be case sensitive'))
cs.stateChanged.connect(self.sort_type_changed)
self.case_sensitive_search = cs2 = QCheckBox(_('Case sensitive sea&rch'))
cs2.setToolTip(_('When filtering the list of words, be case sensitive'))
cs2.setChecked(tprefs['spell_check_case_sensitive_search'])
cs2.stateChanged.connect(self.search_type_changed)
self.hb = h = QHBoxLayout()
self.main.l.addLayout(h), h.addWidget(cs), h.addWidget(cs2), h.addStretch(11)
self.action_next_word = a = QAction(self)
a.setShortcut(QKeySequence(Qt.Key.Key_Down))
a.triggered.connect(self.next_word)
self.addAction(a)
self.action_previous_word = a = QAction(self)
a.triggered.connect(self.previous_word)
a.setShortcut(QKeySequence(Qt.Key.Key_Up))
self.addAction(a)
def button_action(sc, tt, button):
a = QAction(self)
self.addAction(a)
a.setShortcut(QKeySequence(sc, QKeySequence.SequenceFormat.PortableText))
button.setToolTip(tt + f' [{a.shortcut().toString(QKeySequence.SequenceFormat.NativeText)}]')
a.triggered.connect(button.click)
return a
self.action_change_word = button_action('ctrl+right', _('Change all occurrences of this word'), self.change_button)
self.action_show_next_occurrence = button_action('alt+right', _('Show next occurrence of this word in the book'), self.next_occurrence)
if any_hide_checked:
QTimer.singleShot(0, self.do_filter)
def hide_words_toggled(self, checked):
cb = self.sender()
pref_name = cb.objectName()
if 'misspelled' in pref_name:
self.words_view.horizontalHeader().setSectionHidden(3, self.show_only_misspelt.isChecked())
tprefs.set(pref_name, checked)
self.do_filter()
def next_word(self):
v = self.suggested_list if self.focusWidget() is self.suggested_list else self.words_view
v.next_word()
def previous_word(self):
v = self.suggested_list if self.focusWidget() is self.suggested_list else self.words_view
v.previous_word()
def keyPressEvent(self, ev):
if ev.key() in (Qt.Key.Key_Enter, Qt.Key.Key_Return):
ev.accept()
return
return Dialog.keyPressEvent(self, ev)
def change_excluded_files(self):
d = ManageExcludedFiles(self, self.excluded_files)
if d.exec_() == QDialog.DialogCode.Accepted:
new = d.excluded_files
if new != self.excluded_files:
self.excluded_files = new
self.update_exclude_button()
self.refresh()
def clear_caches(self):
self.excluded_files = set()
self.update_exclude_button()
def update_exclude_button(self):
t = _('E&xclude files')
if self.excluded_files:
t += f' ({len(self.excluded_files)})'
self.exclude_button.setText(t)
def sort_type_changed(self):
tprefs['spell_check_case_sensitive_sort'] = bool(self.case_sensitive_sort.isChecked())
if self.words_model.sort_on[0] == 0:
with self:
hh = self.words_view.horizontalHeader()
self.words_view.model().sort(hh.sortIndicatorSection(), hh.sortIndicatorOrder())
def search_type_changed(self):
tprefs['spell_check_case_sensitive_search'] = bool(self.case_sensitive_search.isChecked())
if str(self.filter_text.text()).strip():
self.do_filter()
def show_next_occurrence(self):
self.word_activated(self.words_view.currentIndex())
def word_activated(self, index):
w = self.words_model.word_for_row(index.row())
if w is None:
return
self.find_word.emit(w, self.words_model.words[w])
def initialize_user_dictionaries(self):
ct = str(self.user_dictionaries.currentText()) or _('Default')
self.user_dictionaries.clear()
self.user_dictionaries.addItems(sorted((d.name for d in dictionaries.active_user_dictionaries), key=primary_sort_key))
idx = self.user_dictionaries.findText(ct)
if idx > -1:
self.user_dictionaries.setCurrentIndex(idx)
self.user_dictionaries.setVisible(self.user_dictionaries.count() > 0)
self.user_dictionaries_missing_label.setVisible(not self.user_dictionaries.isVisible())
def current_word_changed(self, *args):
self.current_word_changed_timer.start(self.current_word_changed_timer.interval())
def do_current_word_changed(self):
try:
b = self.ignore_button
except AttributeError:
return
ignored = recognized = in_user_dictionary = False
current = self.words_view.currentIndex()
current_word = ''
if current.isValid():
row = current.row()
w = self.words_model.word_for_row(row)
if w is not None:
ignored = dictionaries.is_word_ignored(*w)
recognized = self.words_model.spell_map[w]
current_word = w[0]
if recognized:
in_user_dictionary = dictionaries.word_in_user_dictionary(*w)
suggestions = dictionaries.suggestions(*w)
self.suggested_list.clear()
word_suggested = False
seen = set()
for i, s in enumerate(chain(suggestions, (current_word,))):
if s in seen:
continue
seen.add(s)
item = QListWidgetItem(s, self.suggested_list)
if i == 0:
self.suggested_list.setCurrentItem(item)
self.suggested_word.setText(s)
word_suggested = True
if s is current_word:
f = item.font()
f.setItalic(True)
item.setFont(f)
item.setToolTip(_('The original word'))
if not word_suggested:
self.suggested_word.setText(current_word)
prefix = b.unign_text if ignored else b.ign_text
b.setText(prefix + ' ' + current_word)
b.setToolTip(b.unign_tt if ignored else b.ign_tt)
b.setEnabled(current.isValid() and (ignored or not recognized))
if not self.user_dictionaries_missing_label.isVisible():
b = self.add_button
b.setText(b.remove_text if in_user_dictionary else b.add_text)
b.setToolTip(b.remove_tt if in_user_dictionary else b.add_tt)
self.user_dictionaries.setVisible(not in_user_dictionary)
def current_suggestion_changed(self, item):
try:
self.suggested_word.setText(item.text())
except AttributeError:
pass # item is None
def change_word(self):
current = self.words_view.currentIndex()
if not current.isValid():
return
row = current.row()
w = self.words_model.word_for_row(row)
if w is None:
return
new_word = str(self.suggested_word.text())
self.change_requested.emit(w, new_word)
def change_word_after_update(self, w, new_word):
self.refresh(change_request=(w, new_word))
def change_to(self, w, new_word):
if new_word is None:
self.suggested_word.setFocus(Qt.FocusReason.OtherFocusReason)
self.suggested_word.clear()
return
self.change_requested.emit(w, new_word)
def do_change_word(self, w, new_word):
current_row = self.words_view.currentIndex().row()
self.undo_cache.clear()
changed_files = replace_word(current_container(), new_word, self.words_model.words[w], w[1], undo_cache=self.undo_cache)
if changed_files:
self.word_replaced.emit(changed_files)
w = self.words_model.replace_word(w, new_word)
row = self.words_model.row_for_word(w)
if row == -1:
row = self.words_view.currentIndex().row()
if row < self.words_model.rowCount() - 1 and current_row > 0:
row += 1
if row > -1:
self.words_view.highlight_row(row)
def undo_last_change(self):
if not self.undo_cache:
return error_dialog(self, _('No changed word'), _(
'There is no spelling replacement to undo'), show=True)
changed_files = undo_replace_word(current_container(), self.undo_cache)
self.undo_cache.clear()
if changed_files:
self.word_replaced.emit(changed_files)
self.refresh()
def toggle_ignore(self):
current = self.words_view.currentIndex()
if current.isValid():
self.words_model.toggle_ignored(current.row())
def ignore_all(self):
rows = {i.row() for i in self.words_view.selectionModel().selectedRows()}
rows.discard(-1)
if rows:
self.words_model.ignore_words(rows)
def add_all(self, dicname):
rows = {i.row() for i in self.words_view.selectionModel().selectedRows()}
rows.discard(-1)
if rows:
self.words_model.add_words(dicname, rows)
def add_remove(self):
current = self.words_view.currentIndex()
if current.isValid():
if self.user_dictionaries.isVisible(): # add
udname = str(self.user_dictionaries.currentText())
self.words_model.add_word(current.row(), udname)
else:
self.words_model.remove_word(current.row())
def __enter__(self):
idx = self.words_view.currentIndex().row()
self.__current_word = self.words_model.word_for_row(idx)
def __exit__(self, *args):
if self.__current_word is not None:
row = self.words_model.row_for_word(self.__current_word)
self.words_view.highlight_row(max(0, row))
self.__current_word = None
def do_filter(self):
text = str(self.filter_text.text()).strip()
with self:
self.words_model.filter(
text, all_caps=self.all_caps.isChecked(), with_numbers=self.with_numbers.isChecked(),
camel_case=self.camel_case.isChecked(), snake_case=self.snake_case.isChecked(),
show_only_misspelt=self.show_only_misspelt.isChecked())
def refresh(self, change_request=None):
if not self.isVisible():
return
self.cancel = True
if self.thread is not None:
self.thread.join()
self.stack.setCurrentIndex(0)
self.progress_indicator.startAnimation()
self.refresh_requested.emit()
self.thread = Thread(target=partial(self.get_words, change_request=change_request))
self.thread.daemon = True
self.cancel = False
self.thread.start()
def get_words(self, change_request=None):
try:
words = get_all_words(current_container(), dictionaries.default_locale, excluded_files=self.excluded_files)
spell_map = {w:dictionaries.recognized(*w) for w in words}
except:
import traceback
traceback.print_exc()
words = traceback.format_exc()
spell_map = {}
if self.cancel:
self.end_work()
else:
self.work_finished.emit(words, spell_map, change_request)
def end_work(self):
self.stack.setCurrentIndex(1)
self.progress_indicator.stopAnimation()
self.words_model.clear()
def work_done(self, words, spell_map, change_request):
row = self.words_view.rowAt(5)
before_word = self.words_view.current_word
self.end_work()
if not isinstance(words, dict):
return error_dialog(self, _('Failed to check spelling'), _(
'Failed to check spelling, click "Show details" for the full error information.'),
det_msg=words, show=True)
if not self.isVisible():
return
self.words_model.set_data(words, spell_map)
wrow = self.words_model.row_for_word(before_word)
if 0 <= wrow < self.words_model.rowCount():
row = wrow
if row < 0 or row >= self.words_model.rowCount():
row = 0
col, reverse = self.words_model.sort_on
self.words_view.horizontalHeader().setSortIndicator(
col, Qt.SortOrder.DescendingOrder if reverse else Qt.SortOrder.AscendingOrder)
self.update_summary()
self.initialize_user_dictionaries()
if self.words_model.rowCount() > 0:
self.words_view.resizeRowToContents(0)
self.words_view.verticalHeader().setDefaultSectionSize(self.words_view.rowHeight(0))
self.words_view.highlight_row(row)
if change_request is not None:
w, new_word = change_request
if w in self.words_model.words:
self.do_change_word(w, new_word)
else:
error_dialog(self, _('Files edited'), _(
'The files in the editor were edited outside the spell check dialog,'
' and the word %s no longer exists.') % w[0], show=True)
def update_summary(self):
misspelled, total = self.words_model.counts
visible = len(self.words_model.items)
if visible not in (misspelled, total): # some filter is active
if self.show_only_misspelt.isChecked():
self.setWindowTitle(_('Spellcheck showing: {0} of {1} misspelled with {2} total words').format(visible, misspelled, total))
else:
self.setWindowTitle(_('Spellcheck showing: {0} of {2} total with {1} misspelled words').format(visible, misspelled, total))
else:
self.setWindowTitle(_('Spellcheck showing: {0} misspelled of {1} total words').format(misspelled, total))
def sizeHint(self):
return QSize(1000, 650)
def show(self):
Dialog.show(self)
self.undo_cache.clear()
QTimer.singleShot(0, self.refresh)
def accept(self):
tprefs[self.state_name] = bytearray(self.words_view.horizontalHeader().saveState())
Dialog.accept(self)
def reject(self):
tprefs[self.state_name] = bytearray(self.words_view.horizontalHeader().saveState())
Dialog.reject(self)
@classmethod
def test(cls):
from calibre.ebooks.oeb.polish.container import get_container
from calibre.gui2.tweak_book import set_current_container
set_current_container(get_container(sys.argv[-1], tweak_mode=True))
set_book_locale(current_container().mi.language)
d = cls()
QTimer.singleShot(0, d.refresh)
d.exec()
# }}}
# Find next occurrence {{{
def find_next(word, locations, current_editor, current_editor_name,
gui_parent, show_editor, edit_file):
files = OrderedDict()
for l in locations:
try:
files[l.file_name].append(l)
except KeyError:
files[l.file_name] = [l]
if current_editor_name not in files:
current_editor_name = None
locations = [(fname, {l.original_word for l in _locations}, False) for fname, _locations in iteritems(files)]
else:
# Re-order the list of locations to search so that we search in the
# current editor first
lfiles = list(files)
idx = lfiles.index(current_editor_name)
before, after = lfiles[:idx], lfiles[idx+1:]
lfiles = after + before + [current_editor_name]
locations = [(current_editor_name, {l.original_word for l in files[current_editor_name]}, True)]
for fname in lfiles:
locations.append((fname, {l.original_word for l in files[fname]}, False))
for file_name, original_words, from_cursor in locations:
ed = editors.get(file_name, None)
if ed is None:
edit_file(file_name)
ed = editors[file_name]
if ed.find_spell_word(original_words, word[1].langcode, from_cursor=from_cursor):
show_editor(file_name)
return True
return False
def find_next_error(current_editor, current_editor_name, gui_parent, show_editor, edit_file, close_editor):
files = get_checkable_file_names(current_container())[0]
if current_editor_name not in files:
current_editor_name = None
else:
idx = files.index(current_editor_name)
before, after = files[:idx], files[idx+1:]
files = [current_editor_name] + after + before + [current_editor_name]
for file_name in files:
from_cursor = False
if file_name == current_editor_name:
from_cursor = True
current_editor_name = None
ed = editors.get(file_name, None)
needs_close = False
if ed is None:
edit_file(file_name)
ed = editors[file_name]
needs_close = True
if hasattr(ed, 'highlighter'):
ed.highlighter.join()
if ed.editor.find_next_spell_error(from_cursor=from_cursor):
show_editor(file_name)
return True
elif needs_close:
close_editor(file_name)
return False
# }}}
if __name__ == '__main__':
from calibre.gui2 import Application
app = Application([])
dictionaries.initialize()
ManageDictionaries.test()
del app
| 68,696 | Python | .py | 1,492 | 36.097855 | 155 | 0.620127 | kovidgoyal/calibre | 19,243 | 2,250 | 4 | GPL-3.0 | 9/5/2024, 5:13:50 PM (Europe/Amsterdam) |
26,696 | char_select.py | kovidgoyal_calibre/src/calibre/gui2/tweak_book/char_select.py | #!/usr/bin/env python
__license__ = 'GPL v3'
__copyright__ = '2014, Kovid Goyal <kovid at kovidgoyal.net>'
import re
import textwrap
from bisect import bisect
from functools import partial
from qt.core import (
QAbstractItemModel,
QAbstractItemView,
QAbstractListModel,
QApplication,
QCheckBox,
QDialogButtonBox,
QGridLayout,
QHBoxLayout,
QIcon,
QInputMethodEvent,
QLabel,
QListView,
QMenu,
QMimeData,
QModelIndex,
QPen,
QPushButton,
QSize,
QSizePolicy,
QSplitter,
QStyledItemDelegate,
Qt,
QToolButton,
QTreeView,
pyqtSignal,
)
from calibre.gui2.tweak_book import tprefs
from calibre.gui2.tweak_book.widgets import Dialog
from calibre.gui2.widgets import BusyCursor
from calibre.gui2.widgets2 import HistoryLineEdit2
from calibre.startup import connect_lambda
from calibre.utils.icu import safe_chr as codepoint_to_chr
from calibre.utils.unicode_names import character_name_from_code, points_for_word
from calibre_extensions.progress_indicator import set_no_activate_on_click
ROOT = QModelIndex()
non_printing = {
0xa0: 'nbsp', 0x2000: 'nqsp', 0x2001: 'mqsp', 0x2002: 'ensp', 0x2003: 'emsp', 0x2004: '3/msp', 0x2005: '4/msp', 0x2006: '6/msp',
0x2007: 'fsp', 0x2008: 'psp', 0x2009: 'thsp', 0x200A: 'hsp', 0x200b: 'zwsp', 0x200c: 'zwnj', 0x200d: 'zwj', 0x200e: 'lrm', 0x200f: 'rlm',
0x2028: 'lsep', 0x2029: 'psep', 0x202a: 'rle', 0x202b: 'lre', 0x202c: 'pdp', 0x202d: 'lro', 0x202e: 'rlo', 0x202f: 'nnbsp',
0x205f: 'mmsp', 0x2060: 'wj', 0x2061: 'fa', 0x2062: 'x', 0x2063: ',', 0x2064: '+', 0x206A: 'iss', 0x206b: 'ass', 0x206c: 'iafs', 0x206d: 'aafs',
0x206e: 'nads', 0x206f: 'nods', 0x20: 'sp', 0x7f: 'del', 0x2e3a: '2m', 0x2e3b: '3m', 0xad: 'shy',
}
# Searching {{{
def search_for_chars(query, and_tokens=False):
ans = set()
for i, token in enumerate(query.split()):
token = token.lower()
m = re.match(r'(?:[u]\+)([a-f0-9]+)', token)
if m is not None:
chars = {int(m.group(1), 16)}
else:
chars = points_for_word(token)
if chars is not None:
if and_tokens:
ans = chars if i == 0 else (ans & chars)
else:
ans |= chars
return sorted(ans)
# }}}
class CategoryModel(QAbstractItemModel):
def __init__(self, parent=None):
QAbstractItemModel.__init__(self, parent)
self.categories = ((_('Favorites'), ()), # {{{
(_('European scripts'), (
(_('Armenian'), (0x530, 0x58F)),
(_('Armenian ligatures'), (0xFB13, 0xFB17)),
(_('Coptic'), (0x2C80, 0x2CFF)),
(_('Coptic in Greek block'), (0x3E2, 0x3EF)),
(_('Cypriot syllabary'), (0x10800, 0x1083F)),
(_('Cyrillic'), (0x400, 0x4FF)),
(_('Cyrillic supplement'), (0x500, 0x52F)),
(_('Cyrillic extended A'), (0x2DE0, 0x2DFF)),
(_('Cyrillic extended B'), (0xA640, 0xA69F)),
(_('Georgian'), (0x10A0, 0x10FF)),
(_('Georgian supplement'), (0x2D00, 0x2D2F)),
(_('Glagolitic'), (0x2C00, 0x2C5F)),
(_('Gothic'), (0x10330, 0x1034F)),
(_('Greek and Coptic'), (0x370, 0x3FF)),
(_('Greek extended'), (0x1F00, 0x1FFF)),
(_('Latin, Basic & Latin-1 supplement'), (0x20, 0xFF)),
(_('Latin extended A'), (0x100, 0x17F)),
(_('Latin extended B'), (0x180, 0x24F)),
(_('Latin extended C'), (0x2C60, 0x2C7F)),
(_('Latin extended D'), (0xA720, 0xA7FF)),
(_('Latin extended additional'), (0x1E00, 0x1EFF)),
(_('Latin ligatures'), (0xFB00, 0xFB06)),
(_('Fullwidth Latin letters'), (0xFF00, 0xFF5E)),
(_('Linear B syllabary'), (0x10000, 0x1007F)),
(_('Linear B ideograms'), (0x10080, 0x100FF)),
(_('Ogham'), (0x1680, 0x169F)),
(_('Old italic'), (0x10300, 0x1032F)),
(_('Phaistos disc'), (0x101D0, 0x101FF)),
(_('Runic'), (0x16A0, 0x16FF)),
(_('Shavian'), (0x10450, 0x1047F)),
)),
(_('Phonetic symbols'), (
(_('IPA extensions'), (0x250, 0x2AF)),
(_('Phonetic extensions'), (0x1D00, 0x1D7F)),
(_('Phonetic extensions supplement'), (0x1D80, 0x1DBF)),
(_('Modifier tone letters'), (0xA700, 0xA71F)),
(_('Spacing modifier letters'), (0x2B0, 0x2FF)),
(_('Superscripts and subscripts'), (0x2070, 0x209F)),
)),
(_('Combining diacritics'), (
(_('Combining diacritical marks'), (0x300, 0x36F)),
(_('Combining diacritical marks for symbols'), (0x20D0, 0x20FF)),
(_('Combining diacritical marks supplement'), (0x1DC0, 0x1DFF)),
(_('Combining half marks'), (0xFE20, 0xFE2F)),
)),
(_('African scripts'), (
(_('Bamum'), (0xA6A0, 0xA6FF)),
(_('Bamum supplement'), (0x16800, 0x16A3F)),
(_('Egyptian hieroglyphs'), (0x13000, 0x1342F)),
(_('Ethiopic'), (0x1200, 0x137F)),
(_('Ethiopic supplement'), (0x1380, 0x139F)),
(_('Ethiopic extended'), (0x2D80, 0x2DDF)),
(_('Ethiopic extended A'), (0xAB00, 0xAB2F)),
(_('Meroitic cursive'), (0x109A0, 0x109FF)),
(_('Meroitic hieroglyphs'), (0x10980, 0x1099F)),
(_('N\'Ko'), (0x7C0, 0x7FF)),
(_('Osmanya'), (0x10480, 0x104AF)),
(_('Tifinagh'), (0x2D30, 0x2D7F)),
(_('Vai'), (0xA500, 0xA63F)),
)),
(_('Middle Eastern scripts'), (
(_('Arabic'), (0x600, 0x6FF)),
(_('Arabic supplement'), (0x750, 0x77F)),
(_('Arabic extended A'), (0x8A0, 0x8FF)),
(_('Arabic presentation forms A'), (0xFB50, 0xFDFF)),
(_('Arabic presentation forms B'), (0xFE70, 0xFEFF)),
(_('Avestan'), (0x10B00, 0x10B3F)),
(_('Carian'), (0x102A0, 0x102DF)),
(_('Cuneiform'), (0x12000, 0x123FF)),
(_('Cuneiform numbers and punctuation'), (0x12400, 0x1247F)),
(_('Hebrew'), (0x590, 0x5FF)),
(_('Hebrew presentation forms'), (0xFB1D, 0xFB4F)),
(_('Imperial Aramaic'), (0x10840, 0x1085F)),
(_('Inscriptional Pahlavi'), (0x10B60, 0x10B7F)),
(_('Inscriptional Parthian'), (0x10B40, 0x10B5F)),
(_('Lycian'), (0x10280, 0x1029F)),
(_('Lydian'), (0x10920, 0x1093F)),
(_('Mandaic'), (0x840, 0x85F)),
(_('Old Persian'), (0x103A0, 0x103DF)),
(_('Old South Arabian'), (0x10A60, 0x10A7F)),
(_('Phoenician'), (0x10900, 0x1091F)),
(_('Samaritan'), (0x800, 0x83F)),
(_('Syriac'), (0x700, 0x74F)),
(_('Ugaritic'), (0x10380, 0x1039F)),
)),
(_('Central Asian scripts'), (
(_('Mongolian'), (0x1800, 0x18AF)),
(_('Old Turkic'), (0x10C00, 0x10C4F)),
(_('Phags-pa'), (0xA840, 0xA87F)),
(_('Tibetan'), (0xF00, 0xFFF)),
)),
(_('South Asian scripts'), (
(_('Bengali'), (0x980, 0x9FF)),
(_('Brahmi'), (0x11000, 0x1107F)),
(_('Chakma'), (0x11100, 0x1114F)),
(_('Devanagari'), (0x900, 0x97F)),
(_('Devanagari extended'), (0xA8E0, 0xA8FF)),
(_('Gujarati'), (0xA80, 0xAFF)),
(_('Gurmukhi'), (0xA00, 0xA7F)),
(_('Kaithi'), (0x11080, 0x110CF)),
(_('Kannada'), (0xC80, 0xCFF)),
(_('Kharoshthi'), (0x10A00, 0x10A5F)),
(_('Lepcha'), (0x1C00, 0x1C4F)),
(_('Limbu'), (0x1900, 0x194F)),
(_('Malayalam'), (0xD00, 0xD7F)),
(_('Meetei Mayek'), (0xABC0, 0xABFF)),
(_('Meetei Mayek extensions'), (0xAAE0, 0xAAEF)),
(_('Ol Chiki'), (0x1C50, 0x1C7F)),
(_('Oriya'), (0xB00, 0xB7F)),
(_('Saurashtra'), (0xA880, 0xA8DF)),
(_('Sinhala'), (0xD80, 0xDFF)),
(_('Sharada'), (0x11180, 0x111DF)),
(_('Sora Sompeng'), (0x110D0, 0x110FF)),
(_('Syloti Nagri'), (0xA800, 0xA82F)),
(_('Takri'), (0x11680, 0x116CF)),
(_('Tamil'), (0xB80, 0xBFF)),
(_('Telugu'), (0xC00, 0xC7F)),
(_('Thaana'), (0x780, 0x7BF)),
(_('Vedic extensions'), (0x1CD0, 0x1CFF)),
)),
(_('Southeast Asian scripts'), (
(_('Balinese'), (0x1B00, 0x1B7F)),
(_('Batak'), (0x1BC0, 0x1BFF)),
(_('Buginese'), (0x1A00, 0x1A1F)),
(_('Cham'), (0xAA00, 0xAA5F)),
(_('Javanese'), (0xA980, 0xA9DF)),
(_('Kayah Li'), (0xA900, 0xA92F)),
(_('Khmer'), (0x1780, 0x17FF)),
(_('Khmer symbols'), (0x19E0, 0x19FF)),
(_('Lao'), (0xE80, 0xEFF)),
(_('Myanmar'), (0x1000, 0x109F)),
(_('Myanmar extended A'), (0xAA60, 0xAA7F)),
(_('New Tai Lue'), (0x1980, 0x19DF)),
(_('Rejang'), (0xA930, 0xA95F)),
(_('Sundanese'), (0x1B80, 0x1BBF)),
(_('Sundanese supplement'), (0x1CC0, 0x1CCF)),
(_('Tai Le'), (0x1950, 0x197F)),
(_('Tai Tham'), (0x1A20, 0x1AAF)),
(_('Tai Viet'), (0xAA80, 0xAADF)),
(_('Thai'), (0xE00, 0xE7F)),
)),
(_('Philippine scripts'), (
(_('Buhid'), (0x1740, 0x175F)),
(_('Hanunoo'), (0x1720, 0x173F)),
(_('Tagalog'), (0x1700, 0x171F)),
(_('Tagbanwa'), (0x1760, 0x177F)),
)),
(_('East Asian scripts'), (
(_('Bopomofo'), (0x3100, 0x312F)),
(_('Bopomofo extended'), (0x31A0, 0x31BF)),
(_('CJK Unified ideographs'), (0x4E00, 0x9FFF)),
(_('CJK Unified ideographs extension A'), (0x3400, 0x4DBF)),
(_('CJK Unified ideographs extension B'), (0x20000, 0x2A6DF)),
(_('CJK Unified ideographs extension C'), (0x2A700, 0x2B73F)),
(_('CJK Unified ideographs extension D'), (0x2B740, 0x2B81F)),
(_('CJK compatibility ideographs'), (0xF900, 0xFAFF)),
(_('CJK compatibility ideographs supplement'), (0x2F800, 0x2FA1F)),
(_('Kangxi radicals'), (0x2F00, 0x2FDF)),
(_('CJK radicals supplement'), (0x2E80, 0x2EFF)),
(_('CJK strokes'), (0x31C0, 0x31EF)),
(_('Ideographic description characters'), (0x2FF0, 0x2FFF)),
(_('Hiragana'), (0x3040, 0x309F)),
(_('Katakana'), (0x30A0, 0x30FF)),
(_('Katakana phonetic extensions'), (0x31F0, 0x31FF)),
(_('Kana supplement'), (0x1B000, 0x1B0FF)),
(_('Halfwidth Katakana'), (0xFF65, 0xFF9F)),
(_('Kanbun'), (0x3190, 0x319F)),
(_('Hangul syllables'), (0xAC00, 0xD7AF)),
(_('Hangul Jamo'), (0x1100, 0x11FF)),
(_('Hangul Jamo extended A'), (0xA960, 0xA97F)),
(_('Hangul Jamo extended B'), (0xD7B0, 0xD7FF)),
(_('Hangul compatibility Jamo'), (0x3130, 0x318F)),
(_('Halfwidth Jamo'), (0xFFA0, 0xFFDC)),
(_('Lisu'), (0xA4D0, 0xA4FF)),
(_('Miao'), (0x16F00, 0x16F9F)),
(_('Yi syllables'), (0xA000, 0xA48F)),
(_('Yi radicals'), (0xA490, 0xA4CF)),
)),
(_('American scripts'), (
(_('Cherokee'), (0x13A0, 0x13FF)),
(_('Deseret'), (0x10400, 0x1044F)),
(_('Unified Canadian aboriginal syllabics'), (0x1400, 0x167F)),
(_('UCAS extended'), (0x18B0, 0x18FF)),
)),
(_('Other'), (
(_('Alphabetic presentation forms'), (0xFB00, 0xFB4F)),
(_('Halfwidth and Fullwidth forms'), (0xFF00, 0xFFEF)),
)),
(_('Punctuation'), (
(_('General punctuation'), (0x2000, 0x206F)),
(_('ASCII punctuation'), (0x21, 0x7F)),
(_('Cuneiform numbers and punctuation'), (0x12400, 0x1247F)),
(_('Latin-1 punctuation'), (0xA1, 0xBF)),
(_('Small form variants'), (0xFE50, 0xFE6F)),
(_('Supplemental punctuation'), (0x2E00, 0x2E7F)),
(_('CJK symbols and punctuation'), (0x3000, 0x303F)),
(_('CJK compatibility forms'), (0xFE30, 0xFE4F)),
(_('Fullwidth ASCII punctuation'), (0xFF01, 0xFF60)),
(_('Vertical forms'), (0xFE10, 0xFE1F)),
)),
(_('Alphanumeric symbols'), (
(_('Arabic mathematical alphabetic symbols'), (0x1EE00, 0x1EEFF)),
(_('Letterlike symbols'), (0x2100, 0x214F)),
(_('Roman symbols'), (0x10190, 0x101CF)),
(_('Mathematical alphanumeric symbols'), (0x1D400, 0x1D7FF)),
(_('Enclosed alphanumerics'), (0x2460, 0x24FF)),
(_('Enclosed alphanumeric supplement'), (0x1F100, 0x1F1FF)),
(_('Enclosed CJK letters and months'), (0x3200, 0x32FF)),
(_('Enclosed ideographic supplement'), (0x1F200, 0x1F2FF)),
(_('CJK compatibility'), (0x3300, 0x33FF)),
)),
(_('Technical symbols'), (
(_('Miscellaneous technical'), (0x2300, 0x23FF)),
(_('Control pictures'), (0x2400, 0x243F)),
(_('Optical character recognition'), (0x2440, 0x245F)),
)),
(_('Numbers and digits'), (
(_('Aegean numbers'), (0x10100, 0x1013F)),
(_('Ancient Greek numbers'), (0x10140, 0x1018F)),
(_('Common Indic number forms'), (0xA830, 0xA83F)),
(_('Counting rod numerals'), (0x1D360, 0x1D37F)),
(_('Cuneiform numbers and punctuation'), (0x12400, 0x1247F)),
(_('Fullwidth ASCII digits'), (0xFF10, 0xFF19)),
(_('Number forms'), (0x2150, 0x218F)),
(_('Rumi numeral symbols'), (0x10E60, 0x10E7F)),
(_('Superscripts and subscripts'), (0x2070, 0x209F)),
)),
(_('Mathematical symbols'), (
(_('Arrows'), (0x2190, 0x21FF)),
(_('Supplemental arrows A'), (0x27F0, 0x27FF)),
(_('Supplemental arrows B'), (0x2900, 0x297F)),
(_('Miscellaneous symbols and arrows'), (0x2B00, 0x2BFF)),
(_('Mathematical alphanumeric symbols'), (0x1D400, 0x1D7FF)),
(_('Letterlike symbols'), (0x2100, 0x214F)),
(_('Mathematical operators'), (0x2200, 0x22FF)),
(_('Miscellaneous mathematical symbols A'), (0x27C0, 0x27EF)),
(_('Miscellaneous mathematical symbols B'), (0x2980, 0x29FF)),
(_('Supplemental mathematical operators'), (0x2A00, 0x2AFF)),
(_('Ceilings and floors'), (0x2308, 0x230B)),
(_('Geometric shapes'), (0x25A0, 0x25FF)),
(_('Box drawing'), (0x2500, 0x257F)),
(_('Block elements'), (0x2580, 0x259F)),
)),
(_('Musical symbols'), (
(_('Musical symbols'), (0x1D100, 0x1D1FF)),
(_('More musical symbols'), (0x2669, 0x266F)),
(_('Ancient Greek musical notation'), (0x1D200, 0x1D24F)),
(_('Byzantine musical symbols'), (0x1D000, 0x1D0FF)),
)),
(_('Game symbols'), (
(_('Chess'), (0x2654, 0x265F)),
(_('Domino tiles'), (0x1F030, 0x1F09F)),
(_('Draughts'), (0x26C0, 0x26C3)),
(_('Japanese chess'), (0x2616, 0x2617)),
(_('Mahjong tiles'), (0x1F000, 0x1F02F)),
(_('Playing cards'), (0x1F0A0, 0x1F0FF)),
(_('Playing card suits'), (0x2660, 0x2667)),
)),
(_('Other symbols'), (
(_('Alchemical symbols'), (0x1F700, 0x1F77F)),
(_('Ancient symbols'), (0x10190, 0x101CF)),
(_('Braille patterns'), (0x2800, 0x28FF)),
(_('Currency symbols'), (0x20A0, 0x20CF)),
(_('Combining diacritical marks for symbols'), (0x20D0, 0x20FF)),
(_('Dingbats'), (0x2700, 0x27BF)),
(_('Emoticons'), (0x1F600, 0x1F64F)),
(_('Miscellaneous symbols'), (0x2600, 0x26FF)),
(_('Miscellaneous symbols and arrows'), (0x2B00, 0x2BFF)),
(_('Miscellaneous symbols and pictographs'), (0x1F300, 0x1F5FF)),
(_('Yijing hexagram symbols'), (0x4DC0, 0x4DFF)),
(_('Yijing mono and digrams'), (0x268A, 0x268F)),
(_('Yijing trigrams'), (0x2630, 0x2637)),
(_('Tai Xuan Jing symbols'), (0x1D300, 0x1D35F)),
(_('Transport and map symbols'), (0x1F680, 0x1F6FF)),
)),
(_('Other'), (
(_('Specials'), (0xFFF0, 0xFFFF)),
(_('Tags'), (0xE0000, 0xE007F)),
(_('Variation selectors'), (0xFE00, 0xFE0F)),
(_('Variation selectors supplement'), (0xE0100, 0xE01EF)),
)),
) # }}}
self.category_map = {}
self.starts = []
for tlname, items in self.categories[1:]:
for name, (start, end) in items:
self.category_map[start] = (tlname, name)
self.starts.append(start)
self.starts.sort()
self.bold_font = f = QApplication.font()
f.setBold(True)
self.fav_icon = QIcon.ic('rating.png')
def columnCount(self, parent=ROOT):
return 1
def rowCount(self, parent=ROOT):
if not parent.isValid():
return len(self.categories)
r = parent.row()
pid = parent.internalId()
if pid == 0 and -1 < r < len(self.categories):
return len(self.categories[r][1])
return 0
def index(self, row, column, parent=ROOT):
if not parent.isValid():
return self.createIndex(row, column) if -1 < row < len(self.categories) else ROOT
try:
return self.createIndex(row, column, parent.row() + 1) if -1 < row < len(self.categories[parent.row()][1]) else ROOT
except IndexError:
return ROOT
def parent(self, index):
if not index.isValid():
return ROOT
pid = index.internalId()
if pid == 0:
return ROOT
return self.index(pid - 1, 0)
def data(self, index, role=Qt.ItemDataRole.DisplayRole):
if not index.isValid():
return None
pid = index.internalId()
if pid == 0:
if role == Qt.ItemDataRole.DisplayRole:
return self.categories[index.row()][0]
if role == Qt.ItemDataRole.FontRole:
return self.bold_font
if role == Qt.ItemDataRole.DecorationRole and index.row() == 0:
return self.fav_icon
else:
if role == Qt.ItemDataRole.DisplayRole:
item = self.categories[pid - 1][1][index.row()]
return item[0]
return None
def get_range(self, index):
if index.isValid():
pid = index.internalId()
if pid == 0:
if index.row() == 0:
return (_('Favorites'), list(tprefs['charmap_favorites']))
else:
item = self.categories[pid - 1][1][index.row()]
return (item[0], list(range(item[1][0], item[1][1] + 1)))
def get_char_info(self, char_code):
ipos = bisect(self.starts, char_code) - 1
try:
category, subcategory = self.category_map[self.starts[ipos]]
except IndexError:
category = subcategory = _('Unknown')
return category, subcategory, character_name_from_code(char_code)
class CategoryDelegate(QStyledItemDelegate):
def __init__(self, parent=None):
QStyledItemDelegate.__init__(self, parent)
def sizeHint(self, option, index):
ans = QStyledItemDelegate.sizeHint(self, option, index)
if not index.parent().isValid():
ans += QSize(0, 6)
return ans
class CategoryView(QTreeView):
category_selected = pyqtSignal(object, object)
def __init__(self, parent=None):
QTreeView.__init__(self, parent)
self.setHeaderHidden(True)
self.setAnimated(True)
self.activated.connect(self.item_activated)
self.clicked.connect(self.item_activated)
set_no_activate_on_click(self)
self.initialized = False
self.setExpandsOnDoubleClick(False)
def item_activated(self, index):
ans = self._model.get_range(index)
if ans is not None:
self.category_selected.emit(*ans)
else:
if self.isExpanded(index):
self.collapse(index)
else:
self.expand(index)
def get_chars(self):
ans = self._model.get_range(self.currentIndex())
if ans is not None:
self.category_selected.emit(*ans)
def initialize(self):
if not self.initialized:
self._model = m = CategoryModel(self)
self.setModel(m)
self.setCurrentIndex(m.index(0, 0))
self.item_activated(m.index(0, 0))
self._delegate = CategoryDelegate(self)
self.setItemDelegate(self._delegate)
self.initialized = True
class CharModel(QAbstractListModel):
def __init__(self, parent=None):
QAbstractListModel.__init__(self, parent)
self.chars = []
self.allow_dnd = False
def rowCount(self, parent=ROOT):
return len(self.chars)
def data(self, index, role):
if role == Qt.ItemDataRole.UserRole and -1 < index.row() < len(self.chars):
return self.chars[index.row()]
return None
def flags(self, index):
ans = Qt.ItemFlag.ItemIsEnabled
if self.allow_dnd:
ans |= Qt.ItemFlag.ItemIsSelectable
ans |= Qt.ItemFlag.ItemIsDragEnabled if index.isValid() else Qt.ItemFlag.ItemIsDropEnabled
return ans
def supportedDropActions(self):
return Qt.DropAction.MoveAction
def mimeTypes(self):
return ['application/calibre_charcode_indices']
def mimeData(self, indexes):
data = ','.join(str(i.row()) for i in indexes)
md = QMimeData()
md.setData('application/calibre_charcode_indices', data.encode('utf-8'))
return md
def dropMimeData(self, md, action, row, column, parent):
if action != Qt.DropAction.MoveAction or not md.hasFormat('application/calibre_charcode_indices') or row < 0 or column != 0:
return False
indices = list(map(int, bytes(md.data('application/calibre_charcode_indices')).decode('ascii').split(',')))
codes = [self.chars[x] for x in indices]
for x in indices:
self.chars[x] = None
for x in reversed(codes):
self.chars.insert(row, x)
self.beginResetModel()
self.chars = [x for x in self.chars if x is not None]
self.endResetModel()
tprefs['charmap_favorites'] = list(self.chars)
return True
class CharDelegate(QStyledItemDelegate):
def __init__(self, parent=None):
QStyledItemDelegate.__init__(self, parent)
self.item_size = QSize(32, 32)
self.np_pat = re.compile(r'(sp|j|nj|ss|fs|ds)$')
def sizeHint(self, option, index):
return self.item_size
def paint(self, painter, option, index):
QStyledItemDelegate.paint(self, painter, option, index)
try:
charcode = int(index.data(Qt.ItemDataRole.UserRole))
except (TypeError, ValueError):
return
painter.save()
try:
if charcode in non_printing:
self.paint_non_printing(painter, option, charcode)
else:
self.paint_normal(painter, option, charcode)
finally:
painter.restore()
def paint_normal(self, painter, option, charcode):
f = option.font
f.setPixelSize(option.rect.height() - 8)
painter.setFont(f)
painter.drawText(option.rect, Qt.AlignmentFlag.AlignHCenter | Qt.AlignmentFlag.AlignBottom | Qt.TextFlag.TextSingleLine, codepoint_to_chr(charcode))
def paint_non_printing(self, painter, option, charcode):
text = self.np_pat.sub(r'\n\1', non_printing[charcode])
painter.drawText(option.rect, Qt.AlignmentFlag.AlignCenter | Qt.TextFlag.TextWordWrap | Qt.TextFlag.TextWrapAnywhere, text)
painter.setPen(QPen(Qt.PenStyle.DashLine))
painter.drawRect(option.rect.adjusted(1, 1, -1, -1))
class CharView(QListView):
show_name = pyqtSignal(object)
char_selected = pyqtSignal(object)
def __init__(self, parent=None):
self.last_mouse_idx = -1
QListView.__init__(self, parent)
self._model = CharModel(self)
self.setModel(self._model)
self.delegate = CharDelegate(self)
self.setResizeMode(QListView.ResizeMode.Adjust)
self.setItemDelegate(self.delegate)
self.setFlow(QListView.Flow.LeftToRight)
self.setWrapping(True)
self.setMouseTracking(True)
self.setSpacing(2)
self.setUniformItemSizes(True)
self.setContextMenuPolicy(Qt.ContextMenuPolicy.CustomContextMenu)
self.customContextMenuRequested.connect(self.context_menu)
self.showing_favorites = False
set_no_activate_on_click(self)
self.activated.connect(self.item_activated)
self.clicked.connect(self.item_activated)
def item_activated(self, index):
try:
char_code = int(self.model().data(index, Qt.ItemDataRole.UserRole))
except (TypeError, ValueError):
pass
else:
self.char_selected.emit(codepoint_to_chr(char_code))
def set_allow_drag_and_drop(self, enabled):
if not enabled:
self.setDragEnabled(False)
self.viewport().setAcceptDrops(False)
self.setDropIndicatorShown(True)
self._model.allow_dnd = False
else:
self.setSelectionMode(QAbstractItemView.SelectionMode.ExtendedSelection)
self.viewport().setAcceptDrops(True)
self.setDragEnabled(True)
self.setAcceptDrops(True)
self.setDropIndicatorShown(False)
self._model.allow_dnd = True
def show_chars(self, name, codes):
self.showing_favorites = name == _('Favorites')
self._model.beginResetModel()
self._model.chars = codes
self._model.endResetModel()
self.scrollToTop()
def mouseMoveEvent(self, ev):
index = self.indexAt(ev.pos())
if index.isValid():
row = index.row()
if row != self.last_mouse_idx:
self.last_mouse_idx = row
try:
char_code = int(self.model().data(index, Qt.ItemDataRole.UserRole))
except (TypeError, ValueError):
pass
else:
self.show_name.emit(char_code)
self.setCursor(Qt.CursorShape.PointingHandCursor)
else:
self.setCursor(Qt.CursorShape.ArrowCursor)
self.show_name.emit(-1)
self.last_mouse_idx = -1
return QListView.mouseMoveEvent(self, ev)
def context_menu(self, pos):
index = self.indexAt(pos)
if index.isValid():
try:
char_code = int(self.model().data(index, Qt.ItemDataRole.UserRole))
except (TypeError, ValueError):
pass
else:
m = QMenu(self)
m.addAction(QIcon.ic('edit-copy.png'), _('Copy %s to clipboard') % codepoint_to_chr(char_code), partial(self.copy_to_clipboard, char_code))
m.addAction(QIcon.ic('rating.png'),
(_('Remove %s from favorites') if self.showing_favorites else _('Add %s to favorites')) % codepoint_to_chr(char_code),
partial(self.remove_from_favorites, char_code))
if self.showing_favorites:
m.addAction(_('Restore favorites to defaults'), self.restore_defaults)
m.exec(self.mapToGlobal(pos))
def restore_defaults(self):
del tprefs['charmap_favorites']
self.model().beginResetModel()
self.model().chars = list(tprefs['charmap_favorites'])
self.model().endResetModel()
def copy_to_clipboard(self, char_code):
c = QApplication.clipboard()
c.setText(codepoint_to_chr(char_code))
def remove_from_favorites(self, char_code):
existing = tprefs['charmap_favorites']
if not self.showing_favorites:
if char_code not in existing:
tprefs['charmap_favorites'] = [char_code] + existing
elif char_code in existing:
existing.remove(char_code)
tprefs['charmap_favorites'] = existing
self.model().beginResetModel()
self.model().chars.remove(char_code)
self.model().endResetModel()
class CharSelect(Dialog):
def __init__(self, parent=None):
self.initialized = False
Dialog.__init__(self, _('Insert character'), 'charmap_dialog', parent)
self.setWindowIcon(QIcon.ic('character-set.png'))
self.setFocusProxy(parent)
def setup_ui(self):
self.l = l = QGridLayout(self)
self.setLayout(l)
self.bb.setStandardButtons(QDialogButtonBox.StandardButton.Close)
self.rearrange_button = b = self.bb.addButton(_('Re-arrange favorites'), QDialogButtonBox.ButtonRole.ActionRole)
b.setCheckable(True)
b.setChecked(False)
b.setVisible(False)
b.setDefault(True)
self.splitter = s = QSplitter(self)
s.setFocusPolicy(Qt.FocusPolicy.NoFocus)
s.setChildrenCollapsible(False)
self.search = h = HistoryLineEdit2(self)
h.setToolTip(textwrap.fill(_(
'Search for Unicode characters by using the English names or nicknames.'
' You can also search directly using a character code. For example, the following'
' searches will all yield the no-break space character: U+A0, nbsp, no-break')))
h.initialize('charmap_search')
h.setPlaceholderText(_('Search by name, nickname or character code'))
self.search_button = b = QPushButton(_('&Search'))
b.setFocusPolicy(Qt.FocusPolicy.NoFocus)
h.returnPressed.connect(self.do_search)
b.clicked.connect(self.do_search)
self.clear_button = cb = QToolButton(self)
cb.setIcon(QIcon.ic('clear_left.png'))
cb.setFocusPolicy(Qt.FocusPolicy.NoFocus)
cb.setText(_('Clear search'))
cb.clicked.connect(self.clear_search)
l.addWidget(h), l.addWidget(b, 0, 1), l.addWidget(cb, 0, 2)
self.category_view = CategoryView(self)
self.category_view.setFocusPolicy(Qt.FocusPolicy.NoFocus)
self.category_view.clicked.connect(self.category_view_clicked)
l.addWidget(s, 1, 0, 1, 3)
self.char_view = CharView(self)
self.char_view.setFocusPolicy(Qt.FocusPolicy.NoFocus)
self.rearrange_button.toggled[bool].connect(self.set_allow_drag_and_drop)
self.category_view.category_selected.connect(self.show_chars)
self.char_view.show_name.connect(self.show_char_info)
self.char_view.char_selected.connect(self.char_selected)
s.addWidget(self.category_view), s.addWidget(self.char_view)
self.char_info = la = QLabel('\xa0')
la.setSizePolicy(QSizePolicy.Policy.Ignored, QSizePolicy.Policy.Fixed)
l.addWidget(la, 2, 0, 1, 3)
self.rearrange_msg = la = QLabel(_(
'Drag and drop characters to re-arrange them. Click the "Re-arrange" button again when you are done.'))
la.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Fixed)
la.setVisible(False)
l.addWidget(la, 3, 0, 1, 3)
self.h = h = QHBoxLayout()
h.setContentsMargins(0, 0, 0, 0)
self.match_any = mm = QCheckBox(_('Match any word'))
mm.setToolTip(_('When searching return characters whose names match any of the specified words'))
mm.setChecked(tprefs.get('char_select_match_any', True))
connect_lambda(mm.stateChanged, self, lambda self: tprefs.set('char_select_match_any', self.match_any.isChecked()))
h.addWidget(mm), h.addStretch(), h.addWidget(self.bb)
l.addLayout(h, 4, 0, 1, 3)
self.char_view.setFocus(Qt.FocusReason.OtherFocusReason)
def category_view_clicked(self):
p = self.parent()
if p is not None and p.focusWidget() is not None:
p.activateWindow()
def do_search(self):
text = str(self.search.text()).strip()
if not text:
return self.clear_search()
with BusyCursor():
chars = search_for_chars(text, and_tokens=not self.match_any.isChecked())
self.show_chars(_('Search'), chars)
def clear_search(self):
self.search.clear()
self.category_view.get_chars()
def set_allow_drag_and_drop(self, on):
self.char_view.set_allow_drag_and_drop(on)
self.rearrange_msg.setVisible(on)
def show_chars(self, name, codes):
b = self.rearrange_button
b.setVisible(name == _('Favorites'))
b.blockSignals(True)
b.setChecked(False)
b.blockSignals(False)
self.char_view.show_chars(name, codes)
self.char_view.set_allow_drag_and_drop(False)
def initialize(self):
if not self.initialized:
self.category_view.initialize()
def sizeHint(self):
return QSize(800, 600)
def show_char_info(self, char_code):
text = '\xa0'
if char_code > 0:
category_name, subcategory_name, character_name = self.category_view.model().get_char_info(char_code)
text = _('{character_name} (U+{char_code:04X}) in {category_name} - {subcategory_name}').format(**locals())
self.char_info.setText(text)
def show(self):
self.initialize()
Dialog.show(self)
self.raise_and_focus()
def char_selected(self, c):
if QApplication.keyboardModifiers() & Qt.KeyboardModifier.ControlModifier:
self.hide()
if self.parent() is None or self.parent().focusWidget() is None:
QApplication.clipboard().setText(c)
return
self.parent().activateWindow()
w = self.parent().focusWidget()
e = QInputMethodEvent('', [])
e.setCommitString(c)
if hasattr(w, 'no_popup'):
oval = w.no_popup
w.no_popup = True
QApplication.sendEvent(w, e)
if hasattr(w, 'no_popup'):
w.no_popup = oval
if __name__ == '__main__':
from calibre.gui2 import Application
app = Application([])
w = CharSelect()
w.initialize()
w.show()
app.exec()
| 32,545 | Python | .py | 759 | 35.367589 | 156 | 0.607815 | kovidgoyal/calibre | 19,243 | 2,250 | 4 | GPL-3.0 | 9/5/2024, 5:13:50 PM (Europe/Amsterdam) |
26,697 | plugin.py | kovidgoyal_calibre/src/calibre/gui2/tweak_book/plugin.py | #!/usr/bin/env python
__license__ = 'GPL v3'
__copyright__ = '2014, Kovid Goyal <kovid at kovidgoyal.net>'
import importlib
import sys
from qt.core import QToolButton
from calibre import prints
from calibre.customize import PluginInstallationType
from calibre.customize.ui import all_edit_book_tool_plugins
from calibre.gui2.tweak_book import current_container, tprefs
from calibre.gui2.tweak_book.boss import get_boss
from polyglot.builtins import itervalues
class Tool:
'''
The base class for individual tools in an Edit Book plugin. Useful members include:
* ``self.plugin``: A reference to the :class:`calibre.customize.Plugin` object to which this tool belongs.
* self. :attr:`boss`
* self. :attr:`gui`
Methods that must be overridden in sub classes:
* :meth:`create_action`
* :meth:`register_shortcut`
'''
#: Set this to a unique name it will be used as a key
name = None
#: If True the user can choose to place this tool in the plugins toolbar
allowed_in_toolbar = True
#: If True the user can choose to place this tool in the plugins menu
allowed_in_menu = True
#: The popup mode for the menu (if any) of the toolbar button. Possible values are 'delayed', 'instant', 'button'
toolbar_button_popup_mode = 'delayed'
@property
def boss(self):
' The :class:`calibre.gui2.tweak_book.boss.Boss` object. Used to control the user interface. '
return get_boss()
@property
def gui(self):
' The main window of the user interface '
return self.boss.gui
@property
def current_container(self):
' Return the current :class:`calibre.ebooks.oeb.polish.container.Container` object that represents the book being edited. '
return current_container()
def register_shortcut(self, qaction, unique_name, default_keys=(), short_text=None, description=None, **extra_data):
'''
Register a keyboard shortcut that will trigger the specified ``qaction``. This keyboard shortcut
will become automatically customizable by the user in the Keyboard shortcuts section of the editor preferences.
:param qaction: A QAction object, it will be triggered when the
configured key combination is pressed by the user.
:param unique_name: A unique name for this shortcut/action. It will be
used internally, it must not be shared by any other actions in this
plugin.
:param default_keys: A list of the default keyboard shortcuts. If not
specified no default shortcuts will be set. If the shortcuts specified
here conflict with either builtin shortcuts or shortcuts from user
configuration/other plugins, they will be ignored. In that case, users
will have to configure the shortcuts manually via Preferences. For example:
``default_keys=('Ctrl+J', 'F9')``.
:param short_text: An optional short description of this action. If not
specified the text from the QAction will be used.
:param description: An optional longer description of this action, it
will be used in the preferences entry for this shortcut.
'''
short_text = short_text or str(qaction.text()).replace('&&', '\0').replace('&', '').replace('\0', '&')
self.gui.keyboard.register_shortcut(
self.name + '_' + unique_name, short_text, default_keys=default_keys, action=qaction,
description=description or '', group=_('Plugins'))
def create_action(self, for_toolbar=True):
'''
Create a QAction that will be added to either the plugins toolbar or
the plugins menu depending on ``for_toolbar``. For example::
def create_action(self, for_toolbar=True):
ac = QAction(get_icons('myicon.png'), 'Do something')
if for_toolbar:
# We want the toolbar button to have a popup menu
menu = QMenu()
ac.setMenu(menu)
menu.addAction('Do something else')
subaction = menu.addAction('And another')
# Register a keyboard shortcut for this toolbar action be
# careful to do this for only one of the toolbar action or
# the menu action, not both.
self.register_shortcut(ac, 'some-unique-name', default_keys=('Ctrl+K',))
return ac
.. seealso:: Method :meth:`register_shortcut`.
'''
raise NotImplementedError()
def load_plugin_tools(plugin):
try:
main = importlib.import_module(plugin.__class__.__module__+'.main')
except ImportError:
import traceback
traceback.print_exc()
else:
for x in itervalues(vars(main)):
if isinstance(x, type) and x is not Tool and issubclass(x, Tool):
ans = x()
ans.plugin = plugin
yield ans
def plugin_action_sid(plugin, tool, for_toolbar=True):
return plugin.name + tool.name + ('toolbar' if for_toolbar else 'menu')
plugin_toolbar_actions = []
def create_plugin_action(plugin, tool, for_toolbar, actions=None, toolbar_actions=None, plugin_menu_actions=None):
try:
ac = tool.create_action(for_toolbar=for_toolbar)
if ac is None:
raise RuntimeError('create_action() failed to return an action')
except Exception:
prints('Failed to create action for tool:', tool.name)
import traceback
traceback.print_exc()
return
sid = plugin_action_sid(plugin, tool, for_toolbar)
if actions is not None and sid in actions:
prints(f'The {tool.name} tool from the {plugin.name} plugin has a non unique name, ignoring')
else:
if actions is not None:
actions[sid] = ac
ac.sid = sid
if for_toolbar:
if toolbar_actions is not None:
toolbar_actions[sid] = ac
plugin_toolbar_actions.append(ac)
ac.popup_mode = {'instant':QToolButton.ToolButtonPopupMode.InstantPopup, 'button':QToolButton.ToolButtonPopupMode.MenuButtonPopup}.get(
tool.toolbar_button_popup_mode, QToolButton.ToolButtonPopupMode.DelayedPopup)
else:
if plugin_menu_actions is not None:
plugin_menu_actions.append(ac)
return ac
_tool_memory = [] # Needed to prevent the tool object from being garbage collected
def create_plugin_actions(actions, toolbar_actions, plugin_menu_actions):
del _tool_memory[:]
del plugin_toolbar_actions[:]
for plugin in all_edit_book_tool_plugins():
try:
tools = tuple(load_plugin_tools(plugin))
except Exception:
if plugin.installation_type is PluginInstallationType.BUILTIN:
raise
print('Failed to load third-party plugin:', plugin.name, file=sys.stderr)
import traceback
traceback.print_exc()
continue
for tool in tools:
_tool_memory.append(tool)
if tool.allowed_in_toolbar:
create_plugin_action(plugin, tool, True, actions, toolbar_actions, plugin_menu_actions)
if tool.allowed_in_menu:
create_plugin_action(plugin, tool, False, actions, toolbar_actions, plugin_menu_actions)
def install_plugin(plugin):
for tool in load_plugin_tools(plugin):
if tool.allowed_in_toolbar:
sid = plugin_action_sid(plugin, tool, True)
if sid not in tprefs['global_plugins_toolbar']:
tprefs['global_plugins_toolbar'] = tprefs['global_plugins_toolbar'] + [sid]
| 7,755 | Python | .py | 154 | 40.811688 | 147 | 0.651766 | kovidgoyal/calibre | 19,243 | 2,250 | 4 | GPL-3.0 | 9/5/2024, 5:13:50 PM (Europe/Amsterdam) |
26,698 | check.py | kovidgoyal_calibre/src/calibre/gui2/tweak_book/check.py | #!/usr/bin/env python
__license__ = 'GPL v3'
__copyright__ = '2013, Kovid Goyal <kovid at kovidgoyal.net>'
import sys
from qt.core import (
QAbstractItemView,
QApplication,
QIcon,
QListWidget,
QListWidgetItem,
QMenu,
QPalette,
QSplitter,
QStyledItemDelegate,
Qt,
QTextBrowser,
pyqtSignal,
)
from calibre.ebooks.oeb.polish.check.base import CRITICAL, DEBUG, ERROR, INFO, WARN
from calibre.ebooks.oeb.polish.check.main import fix_errors, run_checks
from calibre.gui2 import NO_URL_FORMATTING, safe_open_url
from calibre.gui2.tweak_book import tprefs
from calibre.gui2.widgets import BusyCursor
def icon_for_level(level):
if level > WARN:
icon = 'dialog_error.png'
elif level == WARN:
icon = 'dialog_warning.png'
elif level == INFO:
icon = 'dialog_information.png'
else:
icon = None
return QIcon.ic(icon) if icon else QIcon()
def prefix_for_level(level):
if level > WARN:
text = _('ERROR')
elif level == WARN:
text = _('WARNING')
elif level == INFO:
text = _('INFO')
else:
text = ''
if text:
text += ': '
return text
def build_error_message(error, with_level=False, with_line_numbers=False):
prefix = ''
filename = error.name
if with_level:
prefix = prefix_for_level(error.level)
if with_line_numbers and error.line:
filename = f'{filename}:{error.line}'
return f'{prefix}{error.msg}\xa0\xa0\xa0\xa0[{filename}]'
class Delegate(QStyledItemDelegate):
def initStyleOption(self, option, index):
super().initStyleOption(option, index)
if index.row() == self.parent().currentRow():
option.font.setBold(True)
option.backgroundBrush = self.parent().palette().brush(QPalette.ColorRole.AlternateBase)
class Check(QSplitter):
item_activated = pyqtSignal(object)
check_requested = pyqtSignal()
fix_requested = pyqtSignal(object)
def __init__(self, parent=None):
QSplitter.__init__(self, parent)
self.setChildrenCollapsible(False)
self.items = i = QListWidget(self)
i.setContextMenuPolicy(Qt.ContextMenuPolicy.CustomContextMenu)
i.customContextMenuRequested.connect(self.context_menu)
self.items.setSpacing(3)
self.items.itemDoubleClicked.connect(self.current_item_activated)
self.items.currentItemChanged.connect(self.current_item_changed)
self.items.setSelectionMode(QAbstractItemView.SelectionMode.NoSelection)
self.delegate = Delegate(self.items)
self.items.setItemDelegate(self.delegate)
self.addWidget(i)
self.help = h = QTextBrowser(self)
h.anchorClicked.connect(self.link_clicked)
h.setOpenLinks(False)
self.addWidget(h)
self.setStretchFactor(0, 100)
self.setStretchFactor(1, 50)
self.clear_at_startup()
state = tprefs.get('check-book-splitter-state', None)
if state is not None:
self.restoreState(state)
def clear_at_startup(self):
self.clear_help(_('Check has not been run'))
self.items.clear()
def context_menu(self, pos):
m = QMenu(self)
if self.items.count() > 0:
m.addAction(QIcon.ic('edit-copy.png'), _('Copy list of errors to clipboard'), self.copy_to_clipboard)
if list(m.actions()):
m.exec(self.mapToGlobal(pos))
def copy_to_clipboard(self):
items = []
for item in (self.items.item(i) for i in range(self.items.count())):
err = item.data(Qt.ItemDataRole.UserRole)
msg = build_error_message(err, with_level=True, with_line_numbers=True)
items.append(msg)
if items:
QApplication.clipboard().setText('\n'.join(items))
def save_state(self):
tprefs.set('check-book-splitter-state', bytearray(self.saveState()))
def clear_help(self, msg=None):
if msg is None:
msg = _('No problems found')
self.help.setText('<h2>{}</h2><p><a style="text-decoration:none" title="{}" href="run:check">{}</a></p>'.format(
msg, _('Click to run a check on the book'), _('Run check')))
def link_clicked(self, url):
url = str(url.toString(NO_URL_FORMATTING))
if url == 'activate:item':
self.current_item_activated()
elif url == 'run:check':
self.check_requested.emit()
elif url == 'fix:errors':
errors = [self.items.item(i).data(Qt.ItemDataRole.UserRole) for i in range(self.items.count())]
self.fix_requested.emit(errors)
elif url.startswith('fix:error,'):
num = int(url.rpartition(',')[-1])
errors = [self.items.item(num).data(Qt.ItemDataRole.UserRole)]
self.fix_requested.emit(errors)
elif url.startswith('activate:item:'):
index = int(url.rpartition(':')[-1])
self.location_activated(index)
elif url.startswith('https://'):
safe_open_url(url)
def next_error(self, delta=1):
row = self.items.currentRow()
num = self.items.count()
if num > 0:
row = (row + delta) % num
self.items.setCurrentRow(row)
self.current_item_activated()
def current_item_activated(self, *args):
i = self.items.currentItem()
if i is not None:
err = i.data(Qt.ItemDataRole.UserRole)
if err.has_multiple_locations:
self.location_activated(0)
else:
self.item_activated.emit(err)
def location_activated(self, index):
i = self.items.currentItem()
if i is not None:
err = i.data(Qt.ItemDataRole.UserRole)
err.current_location_index = index
self.item_activated.emit(err)
def current_item_changed(self, *args):
i = self.items.currentItem()
self.help.setText('')
def loc_to_string(line, col):
loc = ''
if line is not None:
loc = _('line: %d') % line
if col is not None:
loc += _(' column: %d') % col
if loc:
loc = ' (%s)' % loc
return loc
if i is not None:
err = i.data(Qt.ItemDataRole.UserRole)
header = {DEBUG:_('Debug'), INFO:_('Information'), WARN:_('Warning'), ERROR:_('Error'), CRITICAL:_('Error')}[err.level]
ifix = ''
loc = loc_to_string(err.line, err.col)
if err.INDIVIDUAL_FIX:
ifix = '<a href="fix:error,%d" title="%s">%s</a><br><br>' % (
self.items.currentRow(), _('Try to fix only this error'), err.INDIVIDUAL_FIX)
open_tt = _('Click to open in editor')
fix_tt = _('Try to fix all fixable errors automatically. Only works for some types of error.')
fix_msg = _('Try to correct all fixable errors automatically')
run_tt, run_msg = _('Re-run the check'), _('Re-run check')
header = '<style>a { text-decoration: none}</style><h2>%s [%d / %d]</h2>' % (
header, self.items.currentRow()+1, self.items.count())
msg = '<p>%s</p>'
footer = '<div>%s<a href="fix:errors" title="%s">%s</a><br><br> <a href="run:check" title="%s">%s</a></div>'
if err.has_multiple_locations:
activate = []
for i, (name, lnum, col) in enumerate(err.all_locations):
activate.append('<a href="activate:item:%d" title="%s">%s %s</a>' % (
i, open_tt, name, loc_to_string(lnum, col)))
many = len(activate) > 2
activate = '<div>%s</div>' % ('<br>'.join(activate))
if many:
activate += '<br>'
activate = activate.replace('%', '%%')
template = header + ((msg + activate) if many else (activate + msg)) + footer
else:
activate = '<div><a href="activate:item" title="{}">{} {}</a></div>'.format(
open_tt, err.name, loc)
activate = activate.replace('%', '%%')
template = header + activate + msg + footer
self.help.setText(
template % (err.HELP, ifix, fix_tt, fix_msg, run_tt, run_msg))
def run_checks(self, container):
with BusyCursor():
self.show_busy()
QApplication.processEvents()
errors = run_checks(container)
self.hide_busy()
for err in sorted(errors, key=lambda e:(100 - e.level, e.name)):
i = QListWidgetItem(build_error_message(err), self.items)
i.setData(Qt.ItemDataRole.UserRole, err)
i.setIcon(icon_for_level(err.level))
if errors:
self.items.setCurrentRow(0)
self.current_item_changed()
self.items.setFocus(Qt.FocusReason.OtherFocusReason)
else:
self.clear_help()
def fix_errors(self, container, errors):
with BusyCursor():
self.show_busy(_('Running fixers, please wait...'))
QApplication.processEvents()
changed = fix_errors(container, errors)
self.run_checks(container)
return changed
def show_busy(self, msg=_('Running checks, please wait...')):
self.help.setText(msg)
self.items.clear()
def hide_busy(self):
self.help.setText('')
self.items.clear()
def keyPressEvent(self, ev):
if ev.key() in (Qt.Key.Key_Enter, Qt.Key.Key_Return):
self.current_item_activated()
return super().keyPressEvent(ev)
def clear(self):
self.items.clear()
self.clear_help()
def main():
from calibre.gui2 import Application
from calibre.gui2.tweak_book.boss import get_container
app = Application([]) # noqa
path = sys.argv[-1]
container = get_container(path)
d = Check()
d.run_checks(container)
d.show()
app.exec()
if __name__ == '__main__':
main()
| 10,137 | Python | .py | 243 | 32.139918 | 131 | 0.587638 | kovidgoyal/calibre | 19,243 | 2,250 | 4 | GPL-3.0 | 9/5/2024, 5:13:50 PM (Europe/Amsterdam) |
26,699 | file_list.py | kovidgoyal_calibre/src/calibre/gui2/tweak_book/file_list.py | #!/usr/bin/env python
# License: GPLv3 Copyright: 2013, Kovid Goyal <kovid at kovidgoyal.net>
import os
import posixpath
import sys
import textwrap
from collections import Counter, OrderedDict, defaultdict
from functools import lru_cache, partial
from qt.core import (
QAbstractItemView,
QApplication,
QCheckBox,
QDialog,
QDialogButtonBox,
QFont,
QFormLayout,
QGridLayout,
QIcon,
QInputDialog,
QItemSelectionModel,
QLabel,
QLineEdit,
QListWidget,
QListWidgetItem,
QMenu,
QPainter,
QPixmap,
QRadioButton,
QScrollArea,
QSize,
QSpinBox,
QStyle,
QStyledItemDelegate,
Qt,
QTimer,
QTreeView,
QTreeWidget,
QTreeWidgetItem,
QVBoxLayout,
QWidget,
pyqtSignal,
sip,
)
from calibre import human_readable, sanitize_file_name
from calibre.ebooks.oeb.base import OEB_DOCS, OEB_STYLES
from calibre.ebooks.oeb.polish.cover import get_cover_page_name, get_raster_cover_name, is_raster_image
from calibre.ebooks.oeb.polish.css import add_stylesheet_links
from calibre.ebooks.oeb.polish.replace import get_recommended_folders, get_spine_order_for_all_files
from calibre.ebooks.oeb.polish.utils import OEB_FONTS, guess_type
from calibre.gui2 import choose_dir, choose_files, choose_save_file, elided_text, error_dialog, make_view_use_window_background, question_dialog
from calibre.gui2.tweak_book import CONTAINER_DND_MIMETYPE, current_container, editors, tprefs
from calibre.gui2.tweak_book.editor import syntax_from_mime
from calibre.gui2.tweak_book.templates import template_for
from calibre.startup import connect_lambda
from calibre.utils.fonts.utils import get_font_names
from calibre.utils.icu import numeric_sort_key
from calibre.utils.localization import ngettext, pgettext
from calibre_extensions.progress_indicator import set_no_activate_on_click
from polyglot.binary import as_hex_unicode
from polyglot.builtins import iteritems
FILE_COPY_MIME = 'application/calibre-edit-book-files'
TOP_ICON_SIZE = 24
NAME_ROLE = Qt.ItemDataRole.UserRole
CATEGORY_ROLE = NAME_ROLE + 1
LINEAR_ROLE = CATEGORY_ROLE + 1
MIME_ROLE = LINEAR_ROLE + 1
TEMP_NAME_ROLE = MIME_ROLE + 1
NBSP = '\xa0'
@lru_cache(maxsize=2)
def category_defs():
return (
('text', _('Text'), _('Chapter-')),
('styles', _('Styles'), _('Style-')),
('images', _('Images'), _('Image-')),
('fonts', _('Fonts'), _('Font-')),
('misc', pgettext('edit book file type', 'Miscellaneous'), _('Misc-')),
)
def name_is_ok(name, show_error):
if not name or not name.strip():
return show_error('') and False
ext = name.rpartition('.')[-1]
if not ext or ext == name:
return show_error(_('The file name must have an extension')) and False
norm = name.replace('\\', '/')
parts = name.split('/')
for x in parts:
if sanitize_file_name(x) != x:
return show_error(_('The file name contains invalid characters')) and False
if current_container().has_name(norm):
return show_error(_('This file name already exists in the book')) and False
show_error('')
return True
def get_bulk_rename_settings(parent, number, msg=None, sanitize=sanitize_file_name,
leading_zeros=True, prefix=None, category='text', allow_spine_order=False): # {{{
d = QDialog(parent)
d.setWindowTitle(_('Bulk rename items'))
d.l = l = QFormLayout(d)
d.setLayout(l)
d.prefix = p = QLineEdit(d)
default_prefix = {k:v for k, __, v in category_defs()}.get(category, _('Chapter-'))
previous = tprefs.get('file-list-bulk-rename-prefix', {})
prefix = prefix or previous.get(category, default_prefix)
p.setText(prefix)
p.selectAll()
d.la = la = QLabel(msg or _(
'All selected files will be renamed to the form prefix-number'))
l.addRow(la)
l.addRow(_('&Prefix:'), p)
d.num = num = QSpinBox(d)
num.setMinimum(0), num.setValue(1), num.setMaximum(10000)
l.addRow(_('Starting &number:'), num)
if allow_spine_order:
d.spine_order = QCheckBox(_('Rename files according to their book order'))
d.spine_order.setToolTip(textwrap.fill(_(
'Rename the selected files according to the order they appear in the book, instead of the order they were selected in.')))
l.addRow(d.spine_order)
d.bb = bb = QDialogButtonBox(QDialogButtonBox.StandardButton.Ok | QDialogButtonBox.StandardButton.Cancel)
bb.accepted.connect(d.accept), bb.rejected.connect(d.reject)
l.addRow(bb)
ans = {'prefix': None, 'start': None}
if d.exec() == QDialog.DialogCode.Accepted:
prefix = sanitize(str(d.prefix.text()))
previous[category] = prefix
tprefs.set('file-list-bulk-rename-prefix', previous)
num = d.num.value()
fmt = '%d'
if leading_zeros:
largest = num + number - 1
fmt = f'%0{len(str(largest))}d'
ans['prefix'] = prefix + fmt
ans['start'] = num
if allow_spine_order:
ans['spine_order'] = d.spine_order.isChecked()
return ans
# }}}
class ItemDelegate(QStyledItemDelegate): # {{{
rename_requested = pyqtSignal(object, object, object)
def setEditorData(self, editor, index):
name = str(index.data(NAME_ROLE) or '')
# We do this because Qt calls selectAll() unconditionally on the
# editor, and we want only a part of the file name to be selected
QTimer.singleShot(0, partial(self.set_editor_data, name, editor))
def set_editor_data(self, name, editor):
if sip.isdeleted(editor):
return
editor.setText(name)
ext_pos = name.rfind('.')
slash_pos = name.rfind('/')
if slash_pos == -1 and ext_pos > 0:
editor.setSelection(0, ext_pos)
elif ext_pos > -1 and slash_pos > -1 and ext_pos > slash_pos + 1:
editor.setSelection(slash_pos+1, ext_pos - slash_pos - 1)
else:
editor.selectAll()
def setModelData(self, editor, model, index):
newname = str(editor.text())
oldname = str(index.data(NAME_ROLE) or '')
if newname != oldname:
self.rename_requested.emit(index, oldname, newname)
def sizeHint(self, option, index):
ans = QStyledItemDelegate.sizeHint(self, option, index)
top_level = not index.parent().isValid()
ans += QSize(0, 20 if top_level else 10)
return ans
def paint(self, painter, option, index):
top_level = not index.parent().isValid()
hover = option.state & QStyle.StateFlag.State_MouseOver
cc = current_container()
def safe_size(index):
try:
return cc.filesize(str(index.data(NAME_ROLE) or ''))
except OSError:
return 0
if hover:
if top_level:
m = index.model()
count = m.rowCount(index)
total_size = human_readable(sum(safe_size(m.index(r, 0, index)) for r in range(count)))
suffix = f'{NBSP}{count}@{total_size}'
else:
suffix = NBSP + human_readable(safe_size(index))
br = painter.boundingRect(option.rect, Qt.AlignmentFlag.AlignRight|Qt.AlignmentFlag.AlignVCenter, suffix)
if top_level and index.row() > 0:
option.rect.adjust(0, 5, 0, 0)
painter.drawLine(option.rect.topLeft(), option.rect.topRight())
option.rect.adjust(0, 1, 0, 0)
if hover:
option.rect.adjust(0, 0, -br.width(), 0)
QStyledItemDelegate.paint(self, painter, option, index)
if hover:
option.rect.adjust(0, 0, br.width(), 0)
painter.drawText(option.rect, Qt.AlignmentFlag.AlignRight|Qt.AlignmentFlag.AlignVCenter, suffix)
# }}}
class OpenWithHandler: # {{{
def add_open_with_actions(self, menu, file_name):
from calibre.gui2.open_with import edit_programs, populate_menu
fmt = file_name.rpartition('.')[-1].lower()
if not fmt:
return
m = QMenu(_('Open %s with...') % file_name)
def connect_action(ac, entry):
connect_lambda(ac.triggered, self, lambda self: self.open_with(file_name, fmt, entry))
populate_menu(m, connect_action, fmt)
if len(m.actions()) == 0:
menu.addAction(_('Open %s with...') % file_name, partial(self.choose_open_with, file_name, fmt))
else:
m.addSeparator()
m.addAction(_('Add other application for %s files...') % fmt.upper(), partial(self.choose_open_with, file_name, fmt))
m.addAction(_('Edit Open with applications...'), partial(edit_programs, fmt, self))
menu.addMenu(m)
menu.ow = m
def choose_open_with(self, file_name, fmt):
from calibre.gui2.open_with import choose_program
entry = choose_program(fmt, self)
if entry is not None:
self.open_with(file_name, fmt, entry)
def open_with(self, file_name, fmt, entry):
raise NotImplementedError()
# }}}
class FileList(QTreeWidget, OpenWithHandler):
delete_requested = pyqtSignal(object, object)
reorder_spine = pyqtSignal(object)
rename_requested = pyqtSignal(object, object)
bulk_rename_requested = pyqtSignal(object)
edit_file = pyqtSignal(object, object, object)
merge_requested = pyqtSignal(object, object, object)
mark_requested = pyqtSignal(object, object)
export_requested = pyqtSignal(object, object)
replace_requested = pyqtSignal(object, object, object, object)
link_stylesheets_requested = pyqtSignal(object, object, object)
initiate_file_copy = pyqtSignal(object)
initiate_file_paste = pyqtSignal()
open_file_with = pyqtSignal(object, object, object)
def __init__(self, parent=None):
QTreeWidget.__init__(self, parent)
self.pending_renames = {}
make_view_use_window_background(self)
self.categories = {}
self.ordered_selected_indexes = False
set_no_activate_on_click(self)
self.current_edited_name = None
self.delegate = ItemDelegate(self)
self.delegate.rename_requested.connect(self.possible_rename_requested, type=Qt.ConnectionType.QueuedConnection)
self.setTextElideMode(Qt.TextElideMode.ElideMiddle)
self.setItemDelegate(self.delegate)
self.setIconSize(QSize(16, 16))
self.header().close()
self.setDragEnabled(True)
self.setEditTriggers(QAbstractItemView.EditTrigger.EditKeyPressed)
self.setSelectionMode(QAbstractItemView.SelectionMode.ExtendedSelection)
self.viewport().setAcceptDrops(True)
self.setDropIndicatorShown(True)
self.setDragDropMode(QAbstractItemView.DragDropMode.InternalMove)
self.setAutoScroll(True)
self.setAutoScrollMargin(TOP_ICON_SIZE*2)
self.setDefaultDropAction(Qt.DropAction.MoveAction)
self.setAutoExpandDelay(1000)
self.setAnimated(True)
self.setMouseTracking(True)
self.setContextMenuPolicy(Qt.ContextMenuPolicy.CustomContextMenu)
self.customContextMenuRequested.connect(self.show_context_menu)
self.root = self.invisibleRootItem()
self.emblem_cache = {}
self.rendered_emblem_cache = {}
self.font_name_cache = {}
self.top_level_pixmap_cache = {
name : QIcon.ic(icon).pixmap(TOP_ICON_SIZE, TOP_ICON_SIZE)
for name, icon in iteritems({
'text':'keyboard-prefs.png',
'styles':'lookfeel.png',
'fonts':'font.png',
'misc':'mimetypes/dir.png',
'images':'view-image.png',
})}
self.itemActivated.connect(self.item_double_clicked)
def possible_rename_requested(self, index, old, new):
if old != new:
self.pending_renames[old] = new
QTimer.singleShot(10, self.dispatch_pending_renames)
item = self.itemFromIndex(index)
item.setData(0, TEMP_NAME_ROLE, item.text(0))
item.setText(0, new)
def restore_temp_names(self):
for item in self.all_files:
q = item.data(0, TEMP_NAME_ROLE)
if q:
item.setText(0, q)
item.setData(0, TEMP_NAME_ROLE, None)
def dispatch_pending_renames(self):
if self.pending_renames:
if self.state() != QAbstractItemView.State.EditingState:
pr, self.pending_renames = self.pending_renames, {}
if len(pr) == 1:
old, new = tuple(pr.items())[0]
self.rename_requested.emit(old, new)
else:
ur = {}
seen_vals = {c.data(0, NAME_ROLE) or '' for c in self.all_files}
for k, v in pr.items():
if v not in seen_vals:
seen_vals.add(v)
ur[k] = v
self.bulk_rename_requested.emit(ur)
else:
QTimer.singleShot(10, self.dispatch_pending_renames)
def mimeTypes(self):
ans = QTreeWidget.mimeTypes(self)
ans.append(CONTAINER_DND_MIMETYPE)
return ans
def mimeData(self, indices):
ans = QTreeWidget.mimeData(self, indices)
names = (idx.data(0, NAME_ROLE) for idx in indices if idx.data(0, MIME_ROLE))
ans.setData(CONTAINER_DND_MIMETYPE, '\n'.join(filter(None, names)).encode('utf-8'))
return ans
def dropMimeData(self, parent, index, data, action):
if not parent or not data.hasFormat(CONTAINER_DND_MIMETYPE):
return False
names = bytes(data.data(CONTAINER_DND_MIMETYPE)).decode('utf-8').splitlines()
if not names:
return False
category = parent.data(0, CATEGORY_ROLE)
if category is None:
self.handle_reorder_drop(parent, index, names)
elif category == 'text':
self.handle_merge_drop(parent, names)
return False # we have to return false to prevent Qt's internal machinery from re-ordering nodes
def handle_merge_drop(self, target_node, names):
category_node = target_node.parent()
current_order = {category_node.child(i).data(0, NAME_ROLE):i for i in range(category_node.childCount())}
names = sorted(names, key=lambda x: current_order.get(x, -1))
target_name = target_node.data(0, NAME_ROLE)
if len(names) == 1:
msg = _('Merge the file {0} into the file {1}?').format(elided_text(names[0]), elided_text(target_name))
else:
msg = _('Merge the {0} selected files into the file {1}?').format(len(names), elided_text(target_name))
if question_dialog(self, _('Merge files'), msg, skip_dialog_name='edit-book-merge-on-drop'):
names.append(target_name)
names = sorted(names, key=lambda x: current_order.get(x, -1))
self.merge_requested.emit(target_node.data(0, CATEGORY_ROLE), names, target_name)
def handle_reorder_drop(self, category_node, idx, names):
current_order = tuple(category_node.child(i).data(0, NAME_ROLE) for i in range(category_node.childCount()))
linear_map = {category_node.child(i).data(0, NAME_ROLE):category_node.child(i).data(0, LINEAR_ROLE) for i in range(category_node.childCount())}
order_map = {name: i for i, name in enumerate(current_order)}
try:
insert_before = current_order[idx]
except IndexError:
insert_before = None
names = sorted(names, key=lambda x: order_map.get(x, -1))
moved_names = frozenset(names)
new_names = [n for n in current_order if n not in moved_names]
try:
insertion_point = len(new_names) if insert_before is None else new_names.index(insert_before)
except ValueError:
return
new_names = new_names[:insertion_point] + names + new_names[insertion_point:]
order = [[name, linear_map[name]] for name in new_names]
self.request_reorder(order)
def request_reorder(self, order):
# Ensure that all non-linear items are at the end, by making any non-linear
# items not at the end, linear
for i, (name, linear) in tuple(enumerate(order)):
if not linear and i < len(order) - 1 and order[i+1][1]:
order[i][1] = True
self.reorder_spine.emit(order)
def dropEvent(self, event):
# the dropEvent() implementation of QTreeWidget handles InternalMoves
# internally and is not suitable for us. QTreeView::dropEvent calls
# dropMimeData() where we handle the drop
QTreeView.dropEvent(self, event)
@property
def current_name(self):
ci = self.currentItem()
if ci is not None:
return str(ci.data(0, NAME_ROLE) or '')
return ''
def get_state(self):
s = {'pos':self.verticalScrollBar().value()}
s['expanded'] = {c for c, item in iteritems(self.categories) if item.isExpanded()}
s['selected'] = {str(i.data(0, NAME_ROLE) or '') for i in self.selectedItems()}
return s
def set_state(self, state):
for category, item in iteritems(self.categories):
item.setExpanded(category in state['expanded'])
self.verticalScrollBar().setValue(state['pos'])
for parent in self.categories.values():
for c in (parent.child(i) for i in range(parent.childCount())):
name = str(c.data(0, NAME_ROLE) or '')
if name in state['selected']:
c.setSelected(True)
def item_from_name(self, name):
for parent in self.categories.values():
for c in (parent.child(i) for i in range(parent.childCount())):
q = str(c.data(0, NAME_ROLE) or '')
if q == name:
return c
def select_name(self, name, set_as_current_index=False):
for c in self.all_files:
q = str(c.data(0, NAME_ROLE) or '')
c.setSelected(q == name)
if q == name:
self.scrollToItem(c)
if set_as_current_index:
self.setCurrentItem(c)
def select_names(self, names, current_name=None):
for c in self.all_files:
q = str(c.data(0, NAME_ROLE) or '')
c.setSelected(q in names)
if q == current_name:
self.scrollToItem(c)
s = self.selectionModel()
s.setCurrentIndex(self.indexFromItem(c), QItemSelectionModel.SelectionFlag.NoUpdate)
def mark_name_as_current(self, name):
current = self.item_from_name(name)
if current is not None:
if self.current_edited_name is not None:
ci = self.item_from_name(self.current_edited_name)
if ci is not None:
ci.setData(0, Qt.ItemDataRole.FontRole, None)
self.current_edited_name = name
self.mark_item_as_current(current)
def mark_item_as_current(self, item):
font = QFont(self.font())
font.setItalic(True)
font.setBold(True)
item.setData(0, Qt.ItemDataRole.FontRole, font)
def clear_currently_edited_name(self):
if self.current_edited_name:
ci = self.item_from_name(self.current_edited_name)
if ci is not None:
ci.setData(0, Qt.ItemDataRole.FontRole, None)
self.current_edited_name = None
def build(self, container, preserve_state=True):
if container is None:
return
if preserve_state:
state = self.get_state()
self.clear()
self.root = self.invisibleRootItem()
self.root.setFlags(Qt.ItemFlag.ItemIsDragEnabled)
self.categories = {}
for category, text, __ in category_defs():
self.categories[category] = i = QTreeWidgetItem(self.root, 0)
i.setText(0, text)
i.setData(0, Qt.ItemDataRole.DecorationRole, self.top_level_pixmap_cache[category])
f = i.font(0)
f.setBold(True)
i.setFont(0, f)
i.setData(0, NAME_ROLE, category)
flags = Qt.ItemFlag.ItemIsEnabled
if category == 'text':
flags |= Qt.ItemFlag.ItemIsDropEnabled
i.setFlags(flags)
processed, seen = {}, {}
cover_page_name = get_cover_page_name(container)
cover_image_name = get_raster_cover_name(container)
manifested_names = set()
for names in container.manifest_type_map.values():
manifested_names |= set(names)
def get_category(name, mt):
category = 'misc'
if mt.startswith('image/'):
category = 'images'
elif mt in OEB_FONTS:
category = 'fonts'
elif mt in OEB_STYLES:
category = 'styles'
elif mt in OEB_DOCS:
category = 'text'
ext = name.rpartition('.')[-1].lower()
if ext in {'ttf', 'otf', 'woff', 'woff2'}:
# Probably wrong mimetype in the OPF
category = 'fonts'
return category
def set_display_name(name, item):
if tprefs['file_list_shows_full_pathname']:
text = name
else:
if name in processed:
# We have an exact duplicate (can happen if there are
# duplicates in the spine)
item.setText(0, processed[name].text(0))
item.setText(1, processed[name].text(1))
return
parts = name.split('/')
text = parts.pop()
while text in seen and parts:
text = parts.pop() + '/' + text
seen[text] = item
item.setText(0, text)
item.setText(1, as_hex_unicode(numeric_sort_key(text)))
def render_emblems(item, emblems):
emblems = tuple(emblems)
if not emblems:
return
icon = self.rendered_emblem_cache.get(emblems, None)
if icon is None:
pixmaps = []
for emblem in emblems:
pm = self.emblem_cache.get(emblem, None)
if pm is None:
pm = self.emblem_cache[emblem] = QIcon.ic(emblem).pixmap(self.iconSize())
pixmaps.append(pm)
num = len(pixmaps)
w, h = pixmaps[0].width(), pixmaps[0].height()
if num == 1:
icon = self.rendered_emblem_cache[emblems] = QIcon(pixmaps[0])
else:
canvas = QPixmap((num * w) + ((num-1)*2), h)
canvas.setDevicePixelRatio(pixmaps[0].devicePixelRatio())
canvas.fill(Qt.GlobalColor.transparent)
painter = QPainter(canvas)
for i, pm in enumerate(pixmaps):
painter.drawPixmap(int(i * (w + 2)/canvas.devicePixelRatio()), 0, pm)
painter.end()
icon = self.rendered_emblem_cache[emblems] = canvas
item.setData(0, Qt.ItemDataRole.DecorationRole, icon)
cannot_be_renamed = container.names_that_must_not_be_changed
ncx_mime = guess_type('a.ncx')
nav_items = frozenset(container.manifest_items_with_property('nav'))
def create_item(name, linear=None):
imt = container.mime_map.get(name, guess_type(name))
icat = get_category(name, imt)
category = 'text' if linear is not None else ({'text':'misc'}.get(icat, icat))
item = QTreeWidgetItem(self.categories['text' if linear is not None else category], 1)
flags = Qt.ItemFlag.ItemIsEnabled | Qt.ItemFlag.ItemIsSelectable
if category == 'text':
flags |= Qt.ItemFlag.ItemIsDragEnabled | Qt.ItemFlag.ItemIsDropEnabled
if name not in cannot_be_renamed:
flags |= Qt.ItemFlag.ItemIsEditable
item.setFlags(flags)
item.setStatusTip(0, _('Full path: ') + name)
item.setData(0, NAME_ROLE, name)
item.setData(0, CATEGORY_ROLE, category)
item.setData(0, LINEAR_ROLE, bool(linear))
item.setData(0, MIME_ROLE, imt)
set_display_name(name, item)
tooltips = []
emblems = []
if name in {cover_page_name, cover_image_name}:
emblems.append('default_cover.png')
tooltips.append(_('This file is the cover %s for this book') % (_('image') if name == cover_image_name else _('page')))
if name in container.opf_name:
emblems.append('metadata.png')
tooltips.append(_('This file contains all the metadata and book structure information'))
if imt == ncx_mime or name in nav_items:
emblems.append('toc.png')
tooltips.append(_('This file contains the metadata table of contents'))
if name not in manifested_names and not container.ok_to_be_unmanifested(name):
emblems.append('dialog_question.png')
tooltips.append(_('This file is not listed in the book manifest'))
if linear is False:
emblems.append('arrow-down.png')
tooltips.append(_('This file is marked as non-linear in the spine\nDrag it to the top to make it linear'))
if linear is None and icat == 'text':
# Text item outside spine
emblems.append('dialog_warning.png')
tooltips.append(_('This file is a text file that is not referenced in the spine'))
if category == 'text' and name in processed:
# Duplicate entry in spine
emblems.append('dialog_error.png')
tooltips.append(_('This file occurs more than once in the spine'))
if category == 'fonts' and name.rpartition('.')[-1].lower() in ('ttf', 'otf'):
fname = self.get_font_family_name(name)
if fname:
tooltips.append(fname)
else:
emblems.append('dialog_error.png')
tooltips.append(_('Not a valid font'))
render_emblems(item, emblems)
if tooltips:
item.setData(0, Qt.ItemDataRole.ToolTipRole, '\n'.join(tooltips))
return item
for name, linear in container.spine_names:
processed[name] = create_item(name, linear=linear)
for name in container.name_path_map:
if name in processed:
continue
processed[name] = create_item(name)
for name, c in iteritems(self.categories):
c.setExpanded(True)
if name != 'text':
c.sortChildren(1, Qt.SortOrder.AscendingOrder)
if preserve_state:
self.set_state(state)
if self.current_edited_name:
item = self.item_from_name(self.current_edited_name)
if item is not None:
self.mark_item_as_current(item)
def get_font_family_name(self, name):
try:
with current_container().open(name) as f:
f.seek(0, os.SEEK_END)
sz = f.tell()
except Exception:
sz = 0
key = name, sz
if key not in self.font_name_cache:
raw = current_container().raw_data(name, decode=False)
try:
ans = get_font_names(raw)[-1]
except Exception:
ans = None
self.font_name_cache[key] = ans
return self.font_name_cache[key]
def select_all_in_category(self, cname):
parent = self.categories[cname]
for c in (parent.child(i) for i in range(parent.childCount())):
c.setSelected(True)
def deselect_all_in_category(self, cname):
parent = self.categories[cname]
for c in (parent.child(i) for i in range(parent.childCount())):
c.setSelected(False)
def show_context_menu(self, point):
item = self.itemAt(point)
if item is None:
return
if item in self.categories.values():
m = self.build_category_context_menu(item)
else:
m = self.build_item_context_menu(item)
if m is not None and len(list(m.actions())) > 0:
m.popup(self.mapToGlobal(point))
def build_category_context_menu(self, item):
m = QMenu(self)
cn = str(item.data(0, NAME_ROLE) or '')
if cn:
name = item.data(0, Qt.DisplayRole)
m.addAction(_('Select all {} files').format(name), partial(self.select_all_in_category, cn))
m.addAction(_('De-select all {} files').format(name), partial(self.deselect_all_in_category, cn))
return m
def build_item_context_menu(self, item):
m = QMenu(self)
sel = self.selectedItems()
num = len(sel)
container = current_container()
ci = self.currentItem()
if ci is not None:
cn = str(ci.data(0, NAME_ROLE) or '')
mt = str(ci.data(0, MIME_ROLE) or '')
cat = str(ci.data(0, CATEGORY_ROLE) or '')
n = elided_text(cn.rpartition('/')[-1])
m.addAction(QIcon.ic('save.png'), _('Export %s') % n, partial(self.export, cn))
if cn not in container.names_that_must_not_be_changed and cn not in container.names_that_must_not_be_removed and mt not in OEB_FONTS:
m.addAction(_('Replace %s with file...') % n, partial(self.replace, cn))
if num > 1:
m.addAction(QIcon.ic('save.png'), _('Export all %d selected files') % num, self.export_selected)
if cn not in container.names_that_must_not_be_changed:
self.add_open_with_actions(m, cn)
m.addSeparator()
m.addAction(QIcon.ic('modified.png'), _('&Rename %s') % n, self.edit_current_item)
if is_raster_image(mt):
m.addAction(QIcon.ic('default_cover.png'), _('Mark %s as cover image') % n, partial(self.mark_as_cover, cn))
elif current_container().SUPPORTS_TITLEPAGES and mt in OEB_DOCS and cat == 'text':
m.addAction(QIcon.ic('default_cover.png'), _('Mark %s as cover page') % n, partial(self.mark_as_titlepage, cn))
if mt in OEB_DOCS and cat in ('text', 'misc') and current_container().opf_version_parsed.major > 2:
m.addAction(QIcon.ic('toc.png'), _('Mark %s as Table of Contents') % n, partial(self.mark_as_nav, cn))
m.addSeparator()
if num > 0:
m.addSeparator()
if num > 1:
m.addAction(QIcon.ic('modified.png'), _('&Bulk rename the selected files'), self.request_bulk_rename)
m.addAction(QIcon.ic('modified.png'), _('Change the file extensions for the selected files'), self.request_change_ext)
m.addAction(QIcon.ic('trash.png'), ngettext(
'&Delete the selected file', '&Delete the {} selected files', num).format(num), self.request_delete)
m.addAction(QIcon.ic('edit-copy.png'), ngettext(
'&Copy the selected file to another editor instance',
'&Copy the {} selected files to another editor instance', num).format(num), self.copy_selected_files)
m.addSeparator()
md = QApplication.instance().clipboard().mimeData()
if md.hasUrls() and md.hasFormat(FILE_COPY_MIME):
import json
name_map = json.loads(bytes(md.data(FILE_COPY_MIME)))
m.addAction(ngettext(
_('Paste file from other editor instance'),
_('Paste {} files from other editor instance'),
len(name_map)).format(len(name_map)), self.paste_from_other_instance)
selected_map = defaultdict(list)
for item in sel:
selected_map[str(item.data(0, CATEGORY_ROLE) or '')].append(str(item.data(0, NAME_ROLE) or ''))
for items in selected_map.values():
items.sort(key=self.index_of_name)
if selected_map['text']:
m.addAction(QIcon.ic('format-text-color.png'), _('Link &stylesheets...'), partial(self.link_stylesheets, selected_map['text']))
if len(selected_map['text']) > 1:
m.addAction(QIcon.ic('merge.png'), _('&Merge selected text files'), partial(self.start_merge, 'text', selected_map['text']))
if len(selected_map['styles']) > 1:
m.addAction(QIcon.ic('merge.png'), _('&Merge selected style files'), partial(self.start_merge, 'styles', selected_map['styles']))
return m
def choose_open_with(self, file_name, fmt):
from calibre.gui2.open_with import choose_program
entry = choose_program(fmt, self)
if entry is not None:
self.open_with(file_name, fmt, entry)
def open_with(self, file_name, fmt, entry):
self.open_file_with.emit(file_name, fmt, entry)
def index_of_name(self, name):
for category, parent in iteritems(self.categories):
for i in range(parent.childCount()):
item = parent.child(i)
if str(item.data(0, NAME_ROLE) or '') == name:
return (category, i)
return (None, -1)
def merge_files(self):
sel = self.selectedItems()
selected_map = defaultdict(list)
for item in sel:
selected_map[str(item.data(0, CATEGORY_ROLE) or '')].append(str(item.data(0, NAME_ROLE) or ''))
for items in selected_map.values():
items.sort(key=self.index_of_name)
if len(selected_map['text']) > 1:
self.start_merge('text', selected_map['text'])
elif len(selected_map['styles']) > 1:
self.start_merge('styles', selected_map['styles'])
else:
error_dialog(self, _('Cannot merge'), _(
'No files selected. Select two or more HTML files or two or more CSS files in the Files browser before trying to merge'), show=True)
def start_merge(self, category, names):
d = MergeDialog(names, self)
if d.exec() == QDialog.DialogCode.Accepted and d.ans:
self.merge_requested.emit(category, names, d.ans)
def edit_current_item(self):
if not current_container().SUPPORTS_FILENAMES:
error_dialog(self, _('Cannot rename'), _(
'%s books do not support file renaming as they do not use file names'
' internally. The filenames you see are automatically generated from the'
' internal structures of the original file.') % current_container().book_type.upper(), show=True)
return
if self.currentItem() is not None:
self.editItem(self.currentItem())
def mark_as_cover(self, name):
self.mark_requested.emit(name, 'cover')
def mark_as_titlepage(self, name):
first = str(self.categories['text'].child(0).data(0, NAME_ROLE) or '') == name
move_to_start = False
if not first:
move_to_start = question_dialog(self, _('Not first item'), _(
'%s is not the first text item. You should only mark the'
' first text item as cover. Do you want to make it the'
' first item?') % elided_text(name),
skip_dialog_name='edit-book-mark-as-titlepage-move-confirm',
skip_dialog_skip_precheck=False
)
self.mark_requested.emit(name, 'titlepage:%r' % move_to_start)
def mark_as_nav(self, name):
self.mark_requested.emit(name, 'nav')
def keyPressEvent(self, ev):
k = ev.key()
mods = ev.modifiers() & (
Qt.KeyboardModifier.ShiftModifier | Qt.KeyboardModifier.AltModifier | Qt.KeyboardModifier.ControlModifier | Qt.KeyboardModifier.MetaModifier)
if k in (Qt.Key.Key_Delete, Qt.Key.Key_Backspace):
ev.accept()
self.request_delete()
elif mods == (Qt.KeyboardModifier.ControlModifier | Qt.KeyboardModifier.ShiftModifier):
m = self.categories['text'].childCount()
amt = {Qt.Key.Key_Up: -1, Qt.Key.Key_Down: 1, Qt.Key.Key_Home: -m, Qt.Key.Key_End: m}.get(k, None)
if amt is not None:
ev.accept()
self.move_selected_text_items(amt)
else:
return QTreeWidget.keyPressEvent(self, ev)
else:
return QTreeWidget.keyPressEvent(self, ev)
def request_rename_common(self):
if not current_container().SUPPORTS_FILENAMES:
error_dialog(self, _('Cannot rename'), _(
'%s books do not support file renaming as they do not use file names'
' internally. The filenames you see are automatically generated from the'
' internal structures of the original file.') % current_container().book_type.upper(), show=True)
return
names = {str(item.data(0, NAME_ROLE) or '') for item in self.selectedItems()}
bad = names & current_container().names_that_must_not_be_changed
if bad:
error_dialog(self, _('Cannot rename'),
_('The file(s) %s cannot be renamed.') % ('<b>%s</b>' % ', '.join(bad)), show=True)
return
names = sorted(names, key=self.index_of_name)
return names
def request_bulk_rename(self):
names = self.request_rename_common()
if names is not None:
categories = Counter(str(item.data(0, CATEGORY_ROLE) or '') for item in self.selectedItems())
settings = get_bulk_rename_settings(self, len(names), category=categories.most_common(1)[0][0], allow_spine_order=True)
fmt, num = settings['prefix'], settings['start']
if fmt is not None:
def change_name(name, num):
parts = name.split('/')
base, ext = parts[-1].rpartition('.')[0::2]
parts[-1] = (fmt % num) + '.' + ext
return '/'.join(parts)
if settings['spine_order']:
order_map = get_spine_order_for_all_files(current_container())
select_map = {n:i for i, n in enumerate(names)}
def key(n):
return order_map.get(n, (sys.maxsize, select_map[n]))
name_map = {n: change_name(n, num + i) for i, n in enumerate(sorted(names, key=key))}
else:
name_map = {n:change_name(n, num + i) for i, n in enumerate(names)}
self.bulk_rename_requested.emit(name_map)
def request_change_ext(self):
names = self.request_rename_common()
if names is not None:
text, ok = QInputDialog.getText(self, _('Rename files'), _('New file extension:'))
if ok and text:
ext = text.lstrip('.')
def change_name(name):
base = posixpath.splitext(name)[0]
return base + '.' + ext
name_map = {n:change_name(n) for n in names}
self.bulk_rename_requested.emit(name_map)
@property
def selected_names(self):
ans = {str(item.data(0, NAME_ROLE) or '') for item in self.selectedItems()}
ans.discard('')
return ans
@property
def selected_names_in_order(self):
root = self.invisibleRootItem()
for category_item in (root.child(i) for i in range(root.childCount())):
for child in (category_item.child(i) for i in range(category_item.childCount())):
if child.isSelected():
name = child.data(0, NAME_ROLE)
if name:
yield name
def move_selected_text_items(self, amt: int) -> bool:
parent = self.categories['text']
children = tuple(parent.child(i) for i in range(parent.childCount()))
selected_names = tuple(c.data(0, NAME_ROLE) for c in children if c.isSelected())
if not selected_names or amt == 0:
return False
current_order = tuple(c.data(0, NAME_ROLE) for c in children)
linear_map = {c.data(0, NAME_ROLE):c.data(0, LINEAR_ROLE) for c in children}
order_map = {name: i for i, name in enumerate(current_order)}
new_order = list(current_order)
changed = False
items = reversed(selected_names) if amt > 0 else selected_names
if amt < 0:
items = selected_names
delta = max(amt, -order_map[selected_names[0]])
else:
items = reversed(selected_names)
delta = min(amt, len(children) - 1 - order_map[selected_names[-1]])
for name in items:
i = order_map[name]
new_i = min(max(0, i + delta), len(current_order) - 1)
if new_i != i:
changed = True
del new_order[i]
new_order.insert(new_i, name)
if changed:
self.request_reorder([[n, linear_map[n]] for n in new_order])
return changed
def copy_selected_files(self):
self.initiate_file_copy.emit(tuple(self.selected_names_in_order))
def paste_from_other_instance(self):
self.initiate_file_paste.emit()
def request_delete(self):
names = self.selected_names
bad = names & current_container().names_that_must_not_be_removed
if bad:
return error_dialog(self, _('Cannot delete'),
_('The file(s) %s cannot be deleted.') % ('<b>%s</b>' % ', '.join(bad)), show=True)
text = self.categories['text']
children = (text.child(i) for i in range(text.childCount()))
spine_removals = [(str(item.data(0, NAME_ROLE) or ''), item.isSelected()) for item in children]
other_removals = {str(item.data(0, NAME_ROLE) or '') for item in self.selectedItems()
if str(item.data(0, CATEGORY_ROLE) or '') != 'text'}
self.delete_requested.emit(spine_removals, other_removals)
def delete_done(self, spine_removals, other_removals):
removals = []
for i, (name, remove) in enumerate(spine_removals):
if remove:
removals.append(self.categories['text'].child(i))
for category, parent in iteritems(self.categories):
if category != 'text':
for i in range(parent.childCount()):
child = parent.child(i)
if str(child.data(0, NAME_ROLE) or '') in other_removals:
removals.append(child)
# The sorting by index is necessary otherwise Qt crashes with recursive
# repaint detected message
for c in sorted(removals, key=lambda x:x.parent().indexOfChild(x), reverse=True):
sip.delete(c)
# A bug in the raster paint engine on linux causes a crash if the scrollbar
# is at the bottom and the delete happens to cause the scrollbar to
# update
b = self.verticalScrollBar()
if b.value() == b.maximum():
b.setValue(b.minimum())
QTimer.singleShot(0, lambda : b.setValue(b.maximum()))
def __enter__(self):
self.ordered_selected_indexes = True
def __exit__(self, *args):
self.ordered_selected_indexes = False
def selectedIndexes(self):
ans = QTreeWidget.selectedIndexes(self)
if self.ordered_selected_indexes:
ans = list(sorted(ans, key=lambda idx:idx.row()))
return ans
def item_double_clicked(self, item, column):
category = str(item.data(0, CATEGORY_ROLE) or '')
if category:
self._request_edit(item)
def _request_edit(self, item):
category = str(item.data(0, CATEGORY_ROLE) or '')
mime = str(item.data(0, MIME_ROLE) or '')
name = str(item.data(0, NAME_ROLE) or '')
syntax = {'text':'html', 'styles':'css'}.get(category, None)
self.edit_file.emit(name, syntax, mime)
def request_edit(self, name):
item = self.item_from_name(name)
if item is not None:
self._request_edit(item)
else:
error_dialog(self, _('Cannot edit'),
_('No item with the name %s was found') % name, show=True)
def edit_next_file(self, currently_editing=None, backwards=False):
category = self.categories['text']
seen_current = False
items = (category.child(i) for i in range(category.childCount()))
if backwards:
items = reversed(tuple(items))
for item in items:
name = str(item.data(0, NAME_ROLE) or '')
if seen_current:
self._request_edit(item)
return True
if currently_editing == name:
seen_current = True
return False
@property
def all_files(self):
return (category.child(i) for category in self.categories.values() for i in range(category.childCount()))
@property
def searchable_names(self):
ans = {'text':OrderedDict(), 'styles':OrderedDict(), 'selected':OrderedDict(), 'open':OrderedDict()}
for item in self.all_files:
category = str(item.data(0, CATEGORY_ROLE) or '')
mime = str(item.data(0, MIME_ROLE) or '')
name = str(item.data(0, NAME_ROLE) or '')
ok = category in {'text', 'styles'}
if ok:
ans[category][name] = syntax_from_mime(name, mime)
if not ok:
if category == 'misc':
ok = mime in {guess_type('a.'+x) for x in ('opf', 'ncx', 'txt', 'xml')}
elif category == 'images':
ok = mime == guess_type('a.svg')
if ok:
cats = []
if item.isSelected():
cats.append('selected')
if name in editors:
cats.append('open')
for cat in cats:
ans[cat][name] = syntax_from_mime(name, mime)
return ans
def export(self, name):
path = choose_save_file(self, 'tweak_book_export_file', _('Choose location'), filters=[
(_('Files'), [name.rpartition('.')[-1].lower()])], all_files=False, initial_filename=name.split('/')[-1])
if path:
self.export_requested.emit(name, path)
def export_selected(self):
names = self.selected_names
if not names:
return
path = choose_dir(self, 'tweak_book_export_selected', _('Choose location'))
if path:
self.export_requested.emit(names, path)
def replace(self, name):
c = current_container()
mt = c.mime_map[name]
oext = name.rpartition('.')[-1].lower()
filters = [oext]
fname = _('Files')
if mt in OEB_DOCS:
fname = _('HTML files')
filters = 'html htm xhtm xhtml shtml'.split()
elif is_raster_image(mt):
fname = _('Images')
filters = 'jpeg jpg gif png'.split()
path = choose_files(self, 'tweak_book_import_file', _('Choose file'), filters=[(fname, filters)], select_only_single_file=True)
if not path:
return
path = path[0]
ext = path.rpartition('.')[-1].lower()
force_mt = None
if mt in OEB_DOCS:
force_mt = c.guess_type('a.html')
nname = os.path.basename(path)
nname, ext = nname.rpartition('.')[0::2]
nname = nname + '.' + ext.lower()
self.replace_requested.emit(name, path, nname, force_mt)
def link_stylesheets(self, names):
s = self.categories['styles']
sheets = [str(s.child(i).data(0, NAME_ROLE) or '') for i in range(s.childCount())]
if not sheets:
return error_dialog(self, _('No stylesheets'), _(
'This book currently has no stylesheets. You must first create a stylesheet'
' before linking it.'), show=True)
d = QDialog(self)
d.l = l = QVBoxLayout(d)
d.setLayout(l)
d.setWindowTitle(_('Choose stylesheets'))
d.la = la = QLabel(_('Choose the stylesheets to link. Drag and drop to re-arrange'))
la.setWordWrap(True)
l.addWidget(la)
d.s = s = QListWidget(d)
l.addWidget(s)
s.setDragEnabled(True)
s.setDropIndicatorShown(True)
s.setDragDropMode(QAbstractItemView.DragDropMode.InternalMove)
s.setAutoScroll(True)
s.setDefaultDropAction(Qt.DropAction.MoveAction)
for name in sheets:
i = QListWidgetItem(name, s)
flags = Qt.ItemFlag.ItemIsEnabled | Qt.ItemFlag.ItemIsUserCheckable | Qt.ItemFlag.ItemIsDragEnabled | Qt.ItemFlag.ItemIsSelectable
i.setFlags(flags)
i.setCheckState(Qt.CheckState.Checked)
d.r = r = QCheckBox(_('Remove existing links to stylesheets'))
r.setChecked(tprefs['remove_existing_links_when_linking_sheets'])
l.addWidget(r)
d.bb = bb = QDialogButtonBox(QDialogButtonBox.StandardButton.Ok | QDialogButtonBox.StandardButton.Cancel)
bb.accepted.connect(d.accept), bb.rejected.connect(d.reject)
l.addWidget(bb)
if d.exec() == QDialog.DialogCode.Accepted:
tprefs['remove_existing_links_when_linking_sheets'] = r.isChecked()
sheets = [str(s.item(il).text()) for il in range(s.count()) if s.item(il).checkState() == Qt.CheckState.Checked]
if sheets:
self.link_stylesheets_requested.emit(names, sheets, r.isChecked())
class NewFileDialog(QDialog): # {{{
def __init__(self, parent=None):
QDialog.__init__(self, parent)
self.l = l = QVBoxLayout()
self.setLayout(l)
self.la = la = QLabel(_(
'Choose a name for the new (blank) file. To place the file in a'
' specific folder in the book, include the folder name, for example: <i>text/chapter1.html'))
la.setWordWrap(True)
self.setWindowTitle(_('Choose file'))
l.addWidget(la)
self.name = n = QLineEdit(self)
n.textChanged.connect(self.update_ok)
l.addWidget(n)
self.link_css = lc = QCheckBox(_('Automatically add style-sheet links into new HTML files'))
lc.setChecked(tprefs['auto_link_stylesheets'])
l.addWidget(lc)
self.err_label = la = QLabel('')
la.setWordWrap(True)
l.addWidget(la)
self.bb = bb = QDialogButtonBox(QDialogButtonBox.StandardButton.Ok | QDialogButtonBox.StandardButton.Cancel)
l.addWidget(bb)
bb.accepted.connect(self.accept)
bb.rejected.connect(self.reject)
self.imp_button = b = bb.addButton(_('Import resource file (image/font/etc.)'), QDialogButtonBox.ButtonRole.ActionRole)
b.setIcon(QIcon.ic('view-image.png'))
b.setToolTip(_('Import a file from your computer as a new'
' file into the book.'))
b.clicked.connect(self.import_file)
self.ok_button = bb.button(QDialogButtonBox.StandardButton.Ok)
self.file_data = b''
self.using_template = False
self.setMinimumWidth(350)
def show_error(self, msg):
self.err_label.setText('<p style="color:red">' + msg)
return False
def import_file(self):
path = choose_files(self, 'tweak-book-new-resource-file', _('Choose file'), select_only_single_file=True)
if path:
self.do_import_file(path[0])
def do_import_file(self, path, hide_button=False):
self.link_css.setVisible(False)
with open(path, 'rb') as f:
self.file_data = f.read()
name = os.path.basename(path)
fmap = get_recommended_folders(current_container(), (name,))
if fmap[name]:
name = '/'.join((fmap[name], name))
self.name.setText(name)
self.la.setText(_('Choose a name for the imported file'))
if hide_button:
self.imp_button.setVisible(False)
@property
def name_is_ok(self):
return name_is_ok(str(self.name.text()), self.show_error)
def update_ok(self, *args):
self.ok_button.setEnabled(self.name_is_ok)
def accept(self):
if not self.name_is_ok:
return error_dialog(self, _('No name specified'), _(
'You must specify a name for the new file, with an extension, for example, chapter1.html'), show=True)
tprefs['auto_link_stylesheets'] = self.link_css.isChecked()
name = str(self.name.text())
name, ext = name.rpartition('.')[0::2]
name = (name + '.' + ext.lower()).replace('\\', '/')
mt = guess_type(name)
if not self.file_data:
if mt in OEB_DOCS:
self.file_data = template_for('html').encode('utf-8')
if tprefs['auto_link_stylesheets']:
data = add_stylesheet_links(current_container(), name, self.file_data)
if data is not None:
self.file_data = data
self.using_template = True
elif mt in OEB_STYLES:
self.file_data = template_for('css').encode('utf-8')
self.using_template = True
self.file_name = name
QDialog.accept(self)
# }}}
class MergeDialog(QDialog): # {{{
def __init__(self, names, parent=None):
QDialog.__init__(self, parent)
self.names = names
self.setWindowTitle(_('Choose master file'))
self.l = l = QVBoxLayout()
self.setLayout(l)
self.la = la = QLabel(_('Choose the master file. All selected files will be merged into the master file:'))
la.setWordWrap(True)
l.addWidget(la)
self.sa = sa = QScrollArea(self)
l.addWidget(sa)
self.bb = bb = QDialogButtonBox(QDialogButtonBox.StandardButton.Ok | QDialogButtonBox.StandardButton.Cancel)
l.addWidget(bb)
bb.accepted.connect(self.accept)
bb.rejected.connect(self.reject)
self.w = w = QWidget(self)
w.l = QVBoxLayout()
w.setLayout(w.l)
buttons = self.buttons = [QRadioButton(n) for n in names]
buttons[0].setChecked(True)
for i in buttons:
w.l.addWidget(i)
sa.setWidget(w)
self.resize(self.sizeHint() + QSize(150, 20))
@property
def ans(self):
for n, b in zip(self.names, self.buttons):
if b.isChecked():
return n
# }}}
class FileListWidget(QWidget):
def __init__(self, parent=None):
QWidget.__init__(self, parent)
self.setLayout(QGridLayout(self))
self.file_list = FileList(self)
self.layout().addWidget(self.file_list)
self.layout().setContentsMargins(0, 0, 0, 0)
self.forwarded_signals = {k for k, o in iteritems(vars(self.file_list.__class__)) if isinstance(o, pyqtSignal) and '_' in k and not hasattr(self, k)}
for x in ('delete_done', 'select_name', 'select_names', 'request_edit', 'mark_name_as_current', 'clear_currently_edited_name'):
setattr(self, x, getattr(self.file_list, x))
self.setFocusProxy(self.file_list)
self.edit_next_file = self.file_list.edit_next_file
def merge_completed(self, master_name):
self.file_list.select_name(master_name, set_as_current_index=True)
def build(self, container, preserve_state=True):
self.file_list.build(container, preserve_state=preserve_state)
def restore_temp_names(self):
self.file_list.restore_temp_names()
def merge_files(self):
self.file_list.merge_files()
@property
def searchable_names(self):
return self.file_list.searchable_names
@property
def current_name(self):
return self.file_list.current_name
def __getattr__(self, name):
if name in object.__getattribute__(self, 'forwarded_signals'):
return getattr(self.file_list, name)
return QWidget.__getattr__(self, name)
| 56,375 | Python | .py | 1,170 | 37.339316 | 157 | 0.596803 | kovidgoyal/calibre | 19,243 | 2,250 | 4 | GPL-3.0 | 9/5/2024, 5:13:50 PM (Europe/Amsterdam) |