def checked_items(self, val):
ct.dlg_proc(self.h,
ct.DLG_CTL_PROP_SET,
index=self.chls,
prop={
'val': val,
})
def press_ok(self, *args, **kwargs):
# edit data dict
files = self.data.get('files', {})
new = {}
for k, v in self.state.items():
for n, i in enumerate(v.split(';')[1].split(',')):
if i == '1':
lexer = self.lexers[n]
lx = new.get(lexer, [])
for x in files[k]:
if x not in lx:
lx.append(x)
new[lexer] = lx
if not new:
ct.msg_box(
_('You must check at least one CudaText lexer, for snippets to work'
), ct.MB_OK + ct.MB_ICONWARNING)
return
self.data['files'] = new
# install
path = os.path.join(ct.app_path(ct.APP_DIR_DATA), 'snippets_vs')
vs.install_vs_snips(path, self.data)
ct.dlg_proc(self.h, ct.DLG_HIDE)
def press_ok(self, id_dlg, id_ctl, data='', info=''):
global file_history
def set_cap(name, cap):
ct.dlg_proc(self.h,
ct.DLG_CTL_PROP_SET,
name=name,
prop={'cap': cap})
f1_prop = ct.dlg_proc(self.h, ct.DLG_CTL_PROP_GET, name='f1_combo')
f1 = f1_prop.get('val')
if not os.path.isfile(f1):
set_cap('g1', 'First file: (Please set correct path)')
else:
set_cap('g1', 'First file:')
f2_prop = ct.dlg_proc(self.h, ct.DLG_CTL_PROP_GET, name='f2_combo')
f2 = f2_prop.get('val')
if not os.path.isfile(f2):
set_cap('g2', 'Second file: (Please set correct path)')
else:
set_cap('g2', 'Second file:')
if os.path.isfile(f1) and os.path.isfile(f2):
self.ready = True
self.f1, self.f2 = os.path.abspath(f1), os.path.abspath(f2)
file_history.add(self.f1)
file_history.add(self.f2)
file_history.save()
ct.dlg_proc(id_dlg, ct.DLG_HIDE)
def _enable_ctls(self, enable, *ns):
prop = {
'en': enable,
'val': None,
'items': None,
}
for n in ns:
ct.dlg_proc(self.h, ct.DLG_CTL_PROP_SET, index=n, prop=prop)
def install(self, *args, **kwargs):
ext = self.exts[self.item_index]
ct.dlg_proc(self.h, ct.DLG_HIDE)
ct.msg_status(' '.join(
[_("Installing: "), ext['display_name'], ext['version']]),
process_messages=True)
self.data = vs.download(ext['url'])
if not self.data:
return
def _dlg_help(self, *args, **vargs):
if self.h_help is None:
w, h = 750, 600
self.h_help = ct.dlg_proc(0, ct.DLG_CREATE)
ct.dlg_proc(self.h_help,
ct.DLG_PROP_SET,
prop={
'cap': _('Syntax Help'),
'w': w,
'h': h,
'resize': True,
})
n = ct.dlg_proc(self.h_help, ct.DLG_CTL_ADD, 'memo')
ct.dlg_proc(self.h_help,
ct.DLG_CTL_PROP_SET,
index=n,
prop={
'name': 'help_memo',
'align': ct.ALIGN_CLIENT,
'val': HELP_TEXT,
'sp_a': 6,
})
ct.dlg_proc(self.h_help, ct.DLG_SHOW_MODAL)
def _get_sel_pkg(self):
p = ct.dlg_proc(self.h, ct.DLG_CTL_PROP_GET, index=self.n_package)
isel = int(p['val'])
if isel < 0:
return None
else:
return self.packages[isel]
def _get_sel_snip(self, pkg, snip_fn):
p = ct.dlg_proc(self.h, ct.DLG_CTL_PROP_GET, index=self.n_snippets)
isel = int(p['val'])
if isel < 0:
return None, None
else:
name = self.snip_items[isel]
snip = self.file_snippets[(pkg['path'], snip_fn)][name]
return name, snip
def _get_sel_group(self, pkg):
p = ct.dlg_proc(self.h, ct.DLG_CTL_PROP_GET, index=self.n_groups)
isel = int(p['val'])
if isel < 0:
return None, None
else:
filename = self._groups_items[isel]
lexers = pkg['files'][filename]
return filename, lexers
def _menu_add_lex(self, *args, lex=None, **vargs):
if lex is None: # initial call: show menu
lexs = ct.lexer_proc(ct.LEXER_GET_LEXERS, '')
h_menu = ct.menu_proc(0, ct.MENU_CREATE)
for lex in lexs:
ct.menu_proc(h_menu,
ct.MENU_ADD,
command=lambda l=lex: self._menu_add_lex(lex=l),
caption=lex)
ct.menu_proc(h_menu, ct.MENU_SHOW)
else: # add specified lexer
p = ct.dlg_proc(self.h, ct.DLG_CTL_PROP_GET, index=self.n_lex)
val = p['val']
newval = lex if not val else val + ', ' + lex
p = ct.dlg_proc(self.h,
ct.DLG_CTL_PROP_SET,
index=self.n_lex,
prop={'val': newval})
def _on_package_selected(self, id_dlg, id_ctl, data='', info=''):
#pass; print('pkg sel')
# disable all below 'group'
disable_btns = [
self.n_add_group, self.n_del_group, self.n_add_lex,
self.n_add_snip, self.n_del_snip
]
self._enable_ctls(False, self.n_lex, self.n_snippets, self.n_alias,
self.n_edit, *disable_btns)
self.ed.set_text_all('')
pkg = self._get_sel_pkg()
if pkg is None: # no package selected
for n in [self.n_groups, self.n_del_pkg]:
ct.dlg_proc(self.h,
ct.DLG_CTL_PROP_SET,
index=n,
prop={
'en': False,
})
self._groups_items = None
return
#pass; print(' * selected pkg: {0}'.format(pkg["name"]))
# fill groups
items = list(pkg['files'])
items.sort()
self._groups_items = [*items]
# select package with specified lexer
if self.select_lex and items:
for i, lexs in enumerate(pkg.get('files', {}).values()):
if self.select_lex in lexs:
items[i] += ' (*{0})'.format(self.select_lex)
items = '\t'.join(items)
self._enable_ctls(True, self.n_groups, self.n_add_pkg, self.n_del_pkg,
self.n_add_group)
ct.dlg_proc(self.h,
ct.DLG_CTL_PROP_SET,
index=self.n_groups,
prop={
'val': None,
'en': True,
'items': items,
})
# if have only one snip file - select it
if id_dlg != -1 and len(pkg.get(
'files', {})) == 1: # -1 - called manually (from fill_forms())
ct.dlg_proc(self.h,
ct.DLG_CTL_PROP_SET,
index=self.n_groups,
prop={'val': 0})
self._on_group_selected(-1, -1)
def show_add_snip(self):
ct.dlg_proc(self.h, ct.DLG_SHOW_MODAL)
ct.dlg_proc(self.h, ct.DLG_FREE)
if self.h_help is not None:
ct.dlg_proc(self.h_help, ct.DLG_FREE)
return self.snippets_changed
def run(self):
global file_history
self.ready = False
open_files = []
for h in ct.ed_handles():
f = ct.Editor(h).get_filename()
if os.path.isfile(f):
open_files.append(f)
items = "\t".join(open_files + file_history.items)
self.f1 = ct.ed.get_filename()
self.f2 = ''
if ct.app_proc(ct.PROC_GET_GROUPING, '') == ct.GROUPS_ONE:
# if 2 files opened in group-1, suggest these 2 files
hh = ct.ed_handles()
if len(hh) == 2:
name1 = ct.Editor(hh[0]).get_filename()
name2 = ct.Editor(hh[1]).get_filename()
if name1 and name2:
self.f1 = name1
self.f2 = name2
else:
e1 = ct.ed_group(0)
e2 = ct.ed_group(1)
if e1 and e2:
self.f1 = e1.get_filename()
self.f2 = e2.get_filename()
dlg = self.dialog(items)
ct.dlg_proc(dlg, ct.DLG_SHOW_MODAL)
ct.dlg_proc(dlg, ct.DLG_FREE)
if self.ready:
return (self.f1, self.f2)
def _on_snippet_selected(self, id_dlg, id_ctl, data='', info=''):
#pass; print('snip sel')
pkg = self._get_sel_pkg()
snips_fn, lexers = self._get_sel_group(pkg)
snip_name, snip = self._get_sel_snip(pkg, snips_fn)
#pass; print(' snip sel:{0}: {1}'.format(snip_name, snip))
if not all((pkg, snips_fn, snip_name, snip)):
return
self._enable_ctls(True, self.n_alias, self.n_edit, self.n_add_snip,
self.n_del_snip)
ct.dlg_proc(self.h,
ct.DLG_CTL_PROP_SET,
index=self.n_alias,
prop={
'val': snip.get('prefix', ''),
})
body = snip.get('body', [])
txt = '\n'.join(body) if type(body) == list else body
self.ed.set_text_all(txt)
def show(self):
self.data = None
self.search()
# set last dlg size
p = {
"w": self.cfg.read_int(PLUG, 'w', 600),
"h": self.cfg.read_int(PLUG, 'h', 400)
}
ct.dlg_proc(self.h, ct.DLG_PROP_SET, prop=p)
p = {'h': self.cfg.read_int(PLUG, 'spt', 60)}
ct.dlg_proc(self.h, ct.DLG_CTL_PROP_SET, index=self.memo, prop=p)
ct.dlg_proc(self.h, ct.DLG_SHOW_MODAL)
# save last dlg size
p = ct.dlg_proc(self.h, ct.DLG_PROP_GET)
self.cfg.write_int(PLUG, 'w', p['w'])
self.cfg.write_int(PLUG, 'h', p['h'])
p = ct.dlg_proc(self.h, ct.DLG_CTL_PROP_GET, index=self.memo)
self.cfg.write_int(PLUG, 'spt', p['h'])
return self.data
def _dismiss_dlg(self, *args, **vargs):
ct.dlg_proc(self.h, ct.DLG_HIDE)
def _save_changes(self, *args, **vargs):
print(_('Saving changes'))
#pass; print('saving changes: {0}'.format(self.modified))
pkg = self._get_sel_pkg()
snips_fn, lexers = self._get_sel_group(pkg)
snip_name, snip = self._get_sel_snip(
pkg, snips_fn) if lexers is not None else (None, None)
_pkg_name = pkg["name"] if pkg else "<no_pkg>"
#pass; print(' + {} # {}, [{}] # <{}>:<{}>'.format(_pkg_name, snips_fn, lexers, snip_name, snip))
### load data from form
# check if modified group's lexers
if snips_fn is not None and lexers is not None:
oldlexes = pkg["files"][snips_fn]
p = ct.dlg_proc(self.h, ct.DLG_CTL_PROP_GET, index=self.n_lex)
newlexs = [
lex.strip() for lex in p['val'].split(',') if lex.strip()
]
if oldlexes != newlexs:
print(
_('* Group\'s lexers changed: [{0}] => [{1}]').format(
oldlexes, newlexs))
pkg['files'][snips_fn] = newlexs
self.modified.append((TYPE_PKG, pkg['path']))
# check if modified snippet (alias|body) (only if group is selected)
if snip_name is not None and snip is not None:
oldalias = snip.get('prefix')
p = ct.dlg_proc(self.h,
ct.DLG_CTL_PROP_GET,
index=self.n_alias)
newalias = p['val']
if oldalias != newalias:
print(
_('* snippet\'s alias changed: [{0}] => [{1}]').format(
oldalias, newalias))
snip['prefix'] = newalias
self.modified.append(
(TYPE_GROUP, pkg['path'], snips_fn, snip_name))
# check if modified snippet body
oldbody = snip['body']
newbody = self.ed.get_text_all().split(
'\n') # line end is always 'lf'
if oldbody != newbody:
print(
_('* snippet\'s body changed:\n{0}\n ==>>\n{1}').
format('\n'.join(oldbody), '\n'.join(newbody)))
snip['body'] = newbody
self.modified.append(
(TYPE_GROUP, pkg['path'], snips_fn, snip_name))
# save modified
saved_files = set() # save each file only once
for mod in self.modified:
# lexers changed, created group, created package, deleted group
# -> save package config file
if mod[0] == TYPE_PKG:
type_, package_dir = mod
path2pkg = {
p['path']: p
for p in self.packages if p['path'] == package_dir
}
pkg_copy = {**path2pkg[package_dir]}
del pkg_copy['path']
data = pkg_copy
file_dst = os.path.join(package_dir, 'config.json')
# snippet changed (alias, body), snippet created, deleted; created group
# -> save snippets file
elif mod[0] == TYPE_GROUP:
type_, package_dir, snips_fn, snip_name = [
*mod, None
][0:4] # fourth item is optional : None
snips = self.file_snippets.get((package_dir, snips_fn))
if snips is None:
print(
_('! ERROR: trying to save snippets for unloaded group: {0}'
).format((package_dir, snips_fn)))
continue
data = snips
file_dst = os.path.join(package_dir, 'snippets', snips_fn)
else:
raise Exception('Invalid Modified type: {mod}')
if file_dst in saved_files:
#pass; print('* already saved, skipping: {0}'.format(file_dst))
continue
saved_files.add(file_dst)
#pass; print('*** saving data: {0}'.format(file_dst))
self.snippets_changed = True
folder = os.path.dirname(file_dst)
if not os.path.exists(folder):
os.makedirs(folder)
with open(file_dst, 'w', encoding='utf-8') as f:
json.dump(data, f, indent=2)
if self.modified:
print(' ' + _('Saved.'))
ct.dlg_proc(self.h, ct.DLG_HIDE)
def _fill_forms(self,
init_lex_sel=None,
sel_pkg_path=None,
sel_group=None,
sel_snip=None):
# fill packages
items = [pkg.get('name') for pkg in self.packages]
# select first group with <lexer>
if init_lex_sel:
found = False
for pkg in self.packages:
for fn, lexs in pkg.get('files', {}).items():
if init_lex_sel in lexs:
if not found:
found = True
sel_pkg_path = pkg['path']
sel_group = fn
break
if found:
break
# mark packages with specified lexer
if self.select_lex:
for i, pkg in enumerate(self.packages):
for fn, lexs in pkg.get('files', {}).items():
if self.select_lex in lexs:
items[i] += ' (*{0})'.format(self.select_lex)
break
items = '\t'.join(items)
props = {
'items': items,
}
sel_pkg_ind = -1
sel_pkg = None
# select package, if specified
if sel_pkg_path: # select new package:
# find selected package
for i, pkg in enumerate(self.packages):
if pkg['path'] == sel_pkg_path:
sel_pkg_ind = i
sel_pkg = pkg
props['val'] = sel_pkg_ind
break
ct.dlg_proc(self.h,
ct.DLG_CTL_PROP_SET,
index=self.n_package,
prop=props)
self._on_package_selected(-1, -1)
# select group
if sel_pkg is not None and sel_group and sel_group in sel_pkg.get(
'files', {}):
sel_group_ind = self._groups_items.index(sel_group)
ct.dlg_proc(self.h,
ct.DLG_CTL_PROP_SET,
index=self.n_groups,
prop={'val': sel_group_ind})
self._on_group_selected(-1, -1)
# select snippet
if sel_snip is not None and sel_snip in self.snip_items:
sel_snip_ind = self.snip_items.index(sel_snip)
ct.dlg_proc(self.h,
ct.DLG_CTL_PROP_SET,
index=self.n_snippets,
prop={'val': sel_snip_ind})
self._on_snippet_selected(-1, -1)
def item_index(self, v):
ct.dlg_proc(self.h,
ct.DLG_CTL_PROP_SET,
index=self.ls,
prop={'val': v})
def is_focused(self, ctl):
return ct.dlg_proc(self.h, ct.DLG_CTL_PROP_GET, index=ctl)['focused']
def set_focus(self, ctl):
ct.dlg_proc(self.h, ct.DLG_CTL_FOCUS, index=ctl)
def text(self):
return ct.dlg_proc(self.h, ct.DLG_CTL_PROP_GET, index=self.edit)['val']
def load_description(self, *args, **kwargs):
descr = self.exts[self.item_index]['description']
ct.dlg_proc(self.h,
ct.DLG_CTL_PROP_SET,
index=self.memo,
prop={'val': descr})
def set_items(self, items):
items = '\t'.join(items)
ct.dlg_proc(self.h,
ct.DLG_CTL_PROP_SET,
index=self.ls,
prop={'items': items})
def _on_group_selected(self, id_dlg, id_ctl, data='', info=''):
#pass; print('group sel')
# disable all below 'group'
self._enable_ctls(False, self.n_alias, self.n_edit, self.n_add_snip,
self.n_del_snip)
self.ed.set_text_all('')
pkg = self._get_sel_pkg()
snips_fn, lexers = self._get_sel_group(pkg)
#pass; print(' * selected B:group: {0}, lexers:{1}'.format(snips_fn, lexers))
if not pkg or not snips_fn:
return
if self.file_snippets.get((pkg['path'], snips_fn)) is None:
self._load_package_snippets(pkg['path'])
#pass; print(' + loaded group snips')
# enable stuff
self._enable_ctls(True, self.n_lex, self.n_snippets, self.n_add_group,
self.n_del_group, self.n_add_lex, self.n_add_snip)
### fill groups
# lexers
ct.dlg_proc(self.h,
ct.DLG_CTL_PROP_SET,
index=self.n_lex,
prop={
'val': ', '.join(lexers),
})
# snippet names
snip_items = [
name for name, val in self.file_snippets.get((pkg['path'],
snips_fn)).items()
if 'body' in val and 'prefix' in val
]
snip_items.sort()
self.snip_items = [*snip_items]
snip_items = '\t'.join(snip_items)
ct.dlg_proc(
self.h,
ct.DLG_CTL_PROP_SET,
index=self.n_snippets,
prop={
'val': None, # selected item
'items': snip_items,
})
# set editor lexer to first existing lexer of snippet group
if lexers:
ed_lex = self.ed.get_prop(ct.PROP_LEXER_FILE)
if not ed_lex or ed_lex not in lexers: # dont change if current editor lex is in group
app_lexs = ct.lexer_proc(ct.LEXER_GET_LEXERS, '')
for lex in lexers:
if lex in app_lexs:
self.ed.set_prop(ct.PROP_LEXER_FILE, lex)
def menu_show(self, *args, **kwargs):
"""Shows popup-menu."""
p = ct.dlg_proc(self.h, ct.DLG_PROP_GET)
base_point = (p["x"] + p["w"] - 190, p["y"] + 50)
ct.menu_proc(self.menu_hndl, ct.MENU_SHOW, command=base_point)
def __init__(self, select_lex=None):
self.select_lex = select_lex # select first group with this lexer, mark in menus
self.snippets_changed = False
self.h_help = None
self.packages = self._load_packages()
self._sort_pkgs()
self.file_snippets = {} # tuple (<pkg path>,<group>) : snippet dict
self.modified = [] # (type, name)
w, h = 530, 400 # w=500 is too small for translations
bw, lw = 90, 80 # button width, label width
self.h = ct.dlg_proc(0, ct.DLG_CREATE)
ct.dlg_proc(self.h,
ct.DLG_PROP_SET,
prop={
'cap': _('Manage snippets'),
'w_min': 5 * bw,
'w': w,
'h': h,
'resize': True,
})
### Controls
# Cancel | Ok | Help
self.n_ok = ct.dlg_proc(self.h, ct.DLG_CTL_ADD, 'button')
ct.dlg_proc(self.h,
ct.DLG_CTL_PROP_SET,
index=self.n_ok,
prop={
'name': 'ok',
'a_l': None,
'a_t': None,
'a_r': ('', ']'),
'a_b': ('', ']'),
'w_min': bw,
'sp_a': 6,
'autosize': True,
'cap': _('OK'),
'on_change': self._save_changes,
})
self.n_cancel = ct.dlg_proc(self.h, ct.DLG_CTL_ADD, 'button')
ct.dlg_proc(self.h,
ct.DLG_CTL_PROP_SET,
index=self.n_cancel,
prop={
'name': 'cancel',
'a_l': None,
'a_t': ('ok', '-'),
'a_r': ('ok', '['),
'a_b': ('', ']'),
'w_min': bw,
'sp_a': 6,
'autosize': True,
'cap': _('Cancel'),
'on_change': self._dismiss_dlg,
})
n = ct.dlg_proc(self.h, ct.DLG_CTL_ADD, 'button')
ct.dlg_proc(self.h,
ct.DLG_CTL_PROP_SET,
index=n,
prop={
'name': 'ed_lex',
'a_l': ('', '['),
'a_t': ('ok', '-'),
'a_r': None,
'a_b': ('', ']'),
'w_min': bw,
'sp_a': 6,
'autosize': True,
'cap': _('Editor\'s Lexer'),
'on_change': self._menu_ed_lex,
})
n = ct.dlg_proc(self.h, ct.DLG_CTL_ADD, 'button')
ct.dlg_proc(self.h,
ct.DLG_CTL_PROP_SET,
index=n,
prop={
'name': 'help',
'a_l': ('ed_lex', ']'),
'a_t': ('ok', '-'),
'a_r': None,
'a_b': ('', ']'),
'w_min': bw,
'sp_a': 6,
'sp_l': 10,
'autosize': True,
'cap': _('Macros Help'),
'on_change': self._dlg_help,
})
### Main
n = ct.dlg_proc(self.h, ct.DLG_CTL_ADD, 'group')
ct.dlg_proc(self.h,
ct.DLG_CTL_PROP_SET,
index=n,
prop={
'name': 'parent',
'a_l': ('', '['),
'a_t': ('', '['),
'a_r': ('', ']'),
'a_b': ('cancel', '['),
'sp_a': 3,
})
# package
n = ct.dlg_proc(self.h, ct.DLG_CTL_ADD, 'label')
ct.dlg_proc(self.h,
ct.DLG_CTL_PROP_SET,
index=n,
prop={
'name': 'pkg_label',
'p': 'parent',
'a_l': ('', '['),
'a_t': ('', '['),
'w_min': lw,
'sp_a': 3,
'sp_t': 6,
'cap': _('Package: '),
})
self.n_del_pkg = ct.dlg_proc(self.h, ct.DLG_CTL_ADD, 'button')
ct.dlg_proc(self.h,
ct.DLG_CTL_PROP_SET,
index=self.n_del_pkg,
prop={
'name': 'del_pkg',
'p': 'parent',
'a_l': None,
'a_t': ('pkg_label', '-'),
'a_r': ('', ']'),
'w_min': bw,
'sp_a': 3,
'cap': _('Delete...'),
'en': False,
'on_change': self._dlg_del_pkg,
})
self.n_add_pkg = ct.dlg_proc(self.h, ct.DLG_CTL_ADD, 'button')
ct.dlg_proc(self.h,
ct.DLG_CTL_PROP_SET,
index=self.n_add_pkg,
prop={
'name': 'add_pkg',
'p': 'parent',
'a_l': None,
'a_t': ('pkg_label', '-'),
'a_r': ('del_pkg', '['),
'w_min': bw,
'sp_a': 3,
'cap': _('Add...'),
'en': True,
'on_change': self._create_pkg,
})
self.n_package = ct.dlg_proc(self.h, ct.DLG_CTL_ADD, 'combo_ro')
ct.dlg_proc(self.h,
ct.DLG_CTL_PROP_SET,
index=self.n_package,
prop={
'name': 'packages',
'p': 'parent',
'a_l': ('pkg_label', ']'),
'a_t': ('pkg_label', '-'),
'a_r': ('add_pkg', '['),
'sp_a': 3,
'act': True,
'on_change': self._on_package_selected,
})
# group
n = ct.dlg_proc(self.h, ct.DLG_CTL_ADD, 'label')
ct.dlg_proc(self.h,
ct.DLG_CTL_PROP_SET,
index=n,
prop={
'name': 'grp_label',
'p': 'parent',
'a_l': ('', '['),
'a_t': ('packages', ']'),
'w_min': lw,
'sp_a': 3,
'sp_t': 6,
'cap': _('Group: '),
})
self.n_del_group = ct.dlg_proc(self.h, ct.DLG_CTL_ADD, 'button')
ct.dlg_proc(self.h,
ct.DLG_CTL_PROP_SET,
index=self.n_del_group,
prop={
'name': 'del_group',
'p': 'parent',
'a_l': None,
'a_t': ('grp_label', '-'),
'a_r': ('', ']'),
'w_min': bw,
'sp_a': 3,
'cap': _('Delete...'),
'en': False,
'on_change': self._dlg_del_group,
})
self.n_add_group = ct.dlg_proc(self.h, ct.DLG_CTL_ADD, 'button')
ct.dlg_proc(self.h,
ct.DLG_CTL_PROP_SET,
index=self.n_add_group,
prop={
'name': 'add_group',
'p': 'parent',
'a_l': None,
'a_t': ('grp_label', '-'),
'a_r': ('del_group', '['),
'w_min': bw,
'sp_a': 3,
'cap': _('Add...'),
'en': False,
'on_change': self._create_group,
})
self.n_groups = ct.dlg_proc(self.h, ct.DLG_CTL_ADD, 'combo_ro')
ct.dlg_proc(self.h,
ct.DLG_CTL_PROP_SET,
index=self.n_groups,
prop={
'name': 'groups',
'p': 'parent',
'a_l': ('grp_label', ']'),
'a_t': ('grp_label', '-'),
'a_r': ('add_group', '['),
'sp_a': 3,
'act': True,
'on_change': self._on_group_selected,
'en': False,
})
# lexer
n = ct.dlg_proc(self.h, ct.DLG_CTL_ADD, 'label')
ct.dlg_proc(self.h,
ct.DLG_CTL_PROP_SET,
index=n,
prop={
'name': 'lex_label',
'p': 'parent',
'a_l': ('', '['),
'a_t': ('groups', ']'),
'w_min': lw,
'sp_a': 3,
'sp_t': 6,
'sp_l': 30,
'cap': _('Group\'s lexers: '),
})
self.n_add_lex = ct.dlg_proc(self.h, ct.DLG_CTL_ADD, 'button')
ct.dlg_proc(self.h,
ct.DLG_CTL_PROP_SET,
index=self.n_add_lex,
prop={
'name': 'add_lex',
'p': 'parent',
'a_l': None,
'a_t': ('lex_label', '-'),
'a_r': ('', ']'),
'w_min': 2 * bw + 3,
'sp_a': 3,
'cap': _('Add Lexer...'),
'en': False,
'on_change': self._menu_add_lex,
})
self.n_lex = ct.dlg_proc(self.h, ct.DLG_CTL_ADD, 'edit')
ct.dlg_proc(self.h,
ct.DLG_CTL_PROP_SET,
index=self.n_lex,
prop={
'name': 'lexers',
'p': 'parent',
'a_l': ('lex_label', ']'),
'a_t': ('lex_label', '-'),
'a_r': ('add_lex', '['),
'sp_a': 3,
'en': False,
})
# snippet
n = ct.dlg_proc(self.h, ct.DLG_CTL_ADD, 'label')
ct.dlg_proc(self.h,
ct.DLG_CTL_PROP_SET,
index=n,
prop={
'name': 'snip_label',
'p': 'parent',
'a_l': ('', '['),
'a_t': ('lexers', ']'),
'w_min': lw,
'sp_a': 3,
'sp_t': 6,
'cap': _('Snippet: '),
})
self.n_del_snip = ct.dlg_proc(self.h, ct.DLG_CTL_ADD, 'button')
ct.dlg_proc(self.h,
ct.DLG_CTL_PROP_SET,
index=self.n_del_snip,
prop={
'name': 'del_snip',
'p': 'parent',
'a_l': None,
'a_t': ('snip_label', '-'),
'a_r': ('', ']'),
'w_min': bw,
'sp_a': 3,
'cap': _('Delete...'),
'en': False,
'on_change': self._dlg_del_snip,
})
self.n_add_snip = ct.dlg_proc(self.h, ct.DLG_CTL_ADD, 'button')
ct.dlg_proc(self.h,
ct.DLG_CTL_PROP_SET,
index=self.n_add_snip,
prop={
'name': 'add_snip',
'p': 'parent',
'a_l': None,
'a_t': ('snip_label', '-'),
'a_r': ('del_snip', '['),
'w_min': bw,
'sp_a': 3,
'cap': _('Add...'),
'en': False,
'on_change': self._create_snip,
})
self.n_snippets = ct.dlg_proc(self.h, ct.DLG_CTL_ADD, 'combo_ro')
ct.dlg_proc(self.h,
ct.DLG_CTL_PROP_SET,
index=self.n_snippets,
prop={
'name': 'snippets',
'p': 'parent',
'a_l': ('snip_label', ']'),
'a_t': ('snip_label', '-'),
'a_r': ('add_snip', '['),
'sp_a': 3,
'on_change': self._on_snippet_selected,
'act': True,
'en': False,
})
# alias
n = ct.dlg_proc(self.h, ct.DLG_CTL_ADD, 'label')
ct.dlg_proc(self.h,
ct.DLG_CTL_PROP_SET,
index=n,
prop={
'name': 'alias_label',
'p': 'parent',
'a_l': ('', '['),
'a_t': ('snippets', ']'),
'w_min': lw,
'sp_a': 3,
'sp_t': 6,
'sp_l': 30,
'cap': _('Snippet\'s alias: '),
})
self.n_alias = ct.dlg_proc(self.h, ct.DLG_CTL_ADD, 'edit')
ct.dlg_proc(self.h,
ct.DLG_CTL_PROP_SET,
index=self.n_alias,
prop={
'name': 'alias',
'p': 'parent',
'a_l': ('alias_label', ']'),
'a_t': ('alias_label', '-'),
'a_r': ('', ']'),
'sp_a': 3,
'en': False,
})
self.n_edit = ct.dlg_proc(self.h, ct.DLG_CTL_ADD, 'editor')
ct.dlg_proc(self.h,
ct.DLG_CTL_PROP_SET,
index=self.n_edit,
prop={
'name': 'editor',
'p': 'parent',
'a_l': ('', '['),
'a_t': ('alias', ']'),
'a_r': ('', ']'),
'a_b': ('', ']'),
'sp_a': 3,
'sp_t': 6,
'en': False
})
h_ed = ct.dlg_proc(self.h, ct.DLG_CTL_HANDLE, index=self.n_edit)
self.ed = ct.Editor(h_ed)
self.ed.set_prop(ct.PROP_NEWLINE,
'lf') # for ease of splitting to lines
self.ed.set_prop(ct.PROP_UNPRINTED_SHOW, True)
self.ed.set_prop(ct.PROP_UNPRINTED_SPACES, True)
self.ed.set_prop(ct.PROP_TAB_SPACES, False)
self.ed.set_prop(ct.PROP_GUTTER_BM, False)
self.ed.set_prop(ct.PROP_MODERN_SCROLLBAR, False)
self._fill_forms(init_lex_sel=self.select_lex
) # select first group with specified lexer if any
def checked_items(self):
return ct.dlg_proc(self.h, ct.DLG_CTL_PROP_GET, index=self.chls)['val']
def __init__(self):
self.data = None
self.last_text = None
self.cfg = Ini(
os.path.join(ct.app_path(ct.APP_DIR_SETTINGS), "plugins.ini"))
w, h = 600, 400
self.h = ct.dlg_proc(0, ct.DLG_CREATE)
ct.dlg_proc(
self.h,
ct.DLG_PROP_SET,
prop={
'cap': _('Search snippets'),
'w': w,
'h': h,
# 'resize': False,
'border': ct.DBORDER_SIZE,
"keypreview": True,
'on_key_up': self.press_key,
})
self.g1 = ct.dlg_proc(self.h, ct.DLG_CTL_ADD, 'panel')
ct.dlg_proc(self.h,
ct.DLG_CTL_PROP_SET,
index=self.g1,
prop={
'name': 'g1',
'h': 30,
'a_l': ('', '['),
'a_r': ('', ']'),
'a_t': ('', '['),
})
self.g2 = ct.dlg_proc(self.h, ct.DLG_CTL_ADD, 'panel')
ct.dlg_proc(self.h,
ct.DLG_CTL_PROP_SET,
index=self.g2,
prop={
'name': 'g2',
'a_l': ('', '['),
'a_r': ('', ']'),
'a_t': ('g1', ']'),
'a_b': ('', ']'),
})
self.ls = ct.dlg_proc(self.h, ct.DLG_CTL_ADD, 'listbox')
ct.dlg_proc(self.h,
ct.DLG_CTL_PROP_SET,
index=self.ls,
prop={
'name': 'ls',
'p': 'g2',
'align': ct.ALIGN_CLIENT,
'sp_l': 5,
'sp_r': 5,
'sp_t': 5,
'on_click_dbl': self.install,
'on_click': self.load_description,
})
self.sp = ct.dlg_proc(self.h, ct.DLG_CTL_ADD, 'splitter')
ct.dlg_proc(self.h,
ct.DLG_CTL_PROP_SET,
index=self.sp,
prop={
'name': 'sp',
'p': 'g2',
'align': ct.ALIGN_BOTTOM,
})
self.memo = ct.dlg_proc(self.h, ct.DLG_CTL_ADD, 'memo')
ct.dlg_proc(self.h,
ct.DLG_CTL_PROP_SET,
index=self.memo,
prop={
'name': 'ls',
'h': 60,
'ex0': True,
'ex1': True,
'p': 'g2',
'align': ct.ALIGN_BOTTOM,
'sp_l': 5,
'sp_r': 5,
'sp_b': 5,
'tab_stop': False,
})
self.b = ct.dlg_proc(self.h, ct.DLG_CTL_ADD, 'button')
ct.dlg_proc(self.h,
ct.DLG_CTL_PROP_SET,
index=self.b,
prop={
'name': 'b',
'w': 32,
'a_l': None,
'a_r': ('g1', ']'),
'a_t': ('g1', '['),
'sp_a': 5,
'p': 'g1',
'cap': '=',
'tab_stop': False,
'on_change': self.menu_show
})
self.edit = ct.dlg_proc(self.h, ct.DLG_CTL_ADD, 'edit')
ct.dlg_proc(self.h,
ct.DLG_CTL_PROP_SET,
index=self.edit,
prop={
'name': 'edit',
'a_l': ('g1', '['),
'a_r': ('b', '['),
'a_t': ('g1', '['),
'sp_a': 5,
'p': 'g1',
'tab_order': 0,
})
# make options
self.is_fuzzy_search = True
self.is_whole_word_search = False
self.is_search_in_descriptions = False
# make menu
self.menu_hndl = ct.menu_proc(0, ct.MENU_CREATE)
self.mi_fuzzy_search = ct.menu_proc(self.menu_hndl,
ct.MENU_ADD,
caption="Fuzzy search",
command=self.togle_fuzzy_search)
ct.menu_proc(self.mi_fuzzy_search,
ct.MENU_SET_CHECKED,
command=self.is_fuzzy_search)
self.mi_whole_word_search = ct.menu_proc(
self.menu_hndl,
ct.MENU_ADD,
caption="Whole word search",
command=self.togle_whole_word_search)
self.mi_search_in_descriptions = ct.menu_proc(
self.menu_hndl,
ct.MENU_ADD,
caption="Search in descriptions",
command=self.togle_search_in_descriptions)
def item_index(self):
return int(
ct.dlg_proc(self.h, ct.DLG_CTL_PROP_GET, index=self.ls)['val'])
