def on_pointPickerButton(self, key_t, button):
""" Pick a RANDOM key-point from the appropriate pool. """
result = self.tabs.pick_mpoint( 'random', key_t, self.cfgmgr,
lts=self._state('lts') )
if not result.err:
ctxt = clogger(result.log, lts=self._state('lts'))
else:
ctxt = clogger(result.err, lts=self._state('lts'), err=True)
if ctxt:
self.consoleBuffer.insert_at_cursor(ctxt)
self._refresh_ui()
def _save_param_to_pool(self, cfg_t, cfgname):
ctxt = clogger("==> SAVE to '{}':\n".format(cfgname),
lts=self._state('lts'))
tmp_sm = self._state('tmp')
prop_d = vars( tmp_sm.get_as_args('pool') )
if 'name' in prop_d.keys():
del prop_d['name']
if 'lims' in prop_d.keys():
del prop_d['lims']
if cfg_t in ['pool', 'privkey']:
sm = self._state(cfg_t)
imgf = sm.get_from_section('pool', 'image')
if not imgf:
poold = sm.rootd
imgf = "{}.png".format(sm.get_from_section('pool', 'name'))
imgf = path.join( poold, imgf )
prop_d['image'] = imgf
sm.set_write_to_section('pool', prop_d)
# copy tmp img to pool's dir
shutil.copy(MBRAT_TMP_IMGF, imgf)
if not path.exists(imgf):
ctxt += clogger("==> ERROR: unable to copy to '{}'".format(imgf),
lts=self._state('lts'), err=True)
else:
ctxt += clogger(
"==> COPIED: '{0}'\n-->'{1}'\n==> CONFIGURED:\n{2}".format(
MBRAT_TMP_IMGF, imgf, self._get_ctxt_from_prop_d(prop_d)
),
lts=self._state('lts')
)
# make sure all the tabs know about this...
self._refresh_ui( act_l=[cfg_t,] )
return ctxt
def on_savePoolMenuitem_activate(self, menuitem):
""" Handler for 'Save Pool As...' menu item FileChooser Dialog. """
response = self.saveasDialog.run()
if response == Gtk.ResponseType.APPLY:
imgf = self.saveasDialog.get_filename()
shutil.copy(MBRAT_TMP_IMGF, imgf)
if path.exists(imgf):
ctxt = clogger("Saved Temp Pool image to '{}'\n".format(imgf),
lts=self._state('lts'))
else:
ctxt = clogger("==> ERROR: unable to save image to '{}'\n".format(imgf),
lts=self._state('lts'), err=True)
if ctxt:
self.consoleBuffer.insert_at_cursor("{}\n".format(ctxt))
self.saveasDialog.destroy()
def gen_mset_to_png(self, pool_t, args):
ms = self.tab[pool_t]['mset']
ms.set_params(args)
ms.gen_mscreen()
ms.gen_mset()
# make png from mscreen and save to tmp
png_img = png.from_array( ms.get_img(), 'L' )
png_img.save( args.image )
return clogger( ms.get_info() )
def on_pickConfigButton(self, cfg_t, button):
""" Generic handler for the APPLY buttons next to Comboboxes. """
ctxt = ""
cfg_iter = self.cbox[cfg_t].get_active_iter()
# cfg_iter points to user choice? ...
if cfg_iter != None:
model = self.cbox[cfg_t].get_model()
cfgname = model[cfg_iter][0]
# ... or to an Entry?
else:
cfgname = self.cbox[cfg_t].get_child().get_text()
if cfgname == "":
ctxt = clogger("C'mon now! Ya gotta type in a name.\n",
lts=self._state('lts'), err=True)
if ctxt:
self.consoleBuffer.insert_at_cursor("{}\n".format(ctxt))
return
# are we making a new config?
if cfgname not in self.cfgmgr.get_cfg_list(cfg_t):
ctxt = clogger("Making new {0} '{1}' ...\n".format(cfg_t, cfgname),
lts=self._state('lts'))
if not self.cfgmgr.make_config( cfg_t, cfgname ):
ctxt += clogger(self.cfgmgr.errstr(),
lts=self._state('lts'), err=True)
if ctxt:
self.consoleBuffer.insert_at_cursor(ctxt)
return
self.sm[cfg_t].set_configf_by_name(cfgname)
self._load_combobox(cfg_t=cfg_t)
ctxt += clogger("==> Activating {0} '{1}' ... \n".format(cfg_t, cfgname),
lts=self._state('lts'))
# update ConfigManager and cfg state
if self.cfgmgr.set_current_cfg_by_name(cfg_t, cfgname):
ctxt += clogger(
" -> {0} '{1}' activated\n -> Info: {2}\n".format(
cfg_t, cfgname, self.sm[cfg_t].get('info')
),
lts=self._state('lts')
)
else:
ctxt += clogger("==> ERROR: could not activate {0} '{1}'\n".format(cfg_t, cfgname),
lts=self._state('lts'), err=True)
if ctxt:
self.consoleBuffer.insert_at_cursor(ctxt)
self._refresh_ui( block='profile', act_l=[cfg_t,] )
def on_saveToPoolButton_clicked(self, button):
""" Copies the tmp .cfg and .png file into the chosen pool configd. """
pool_txt = self.go("saveToPoolCombobox").get_active_text()
cfg_t = 'pool' if 'Public' in pool_txt else 'privkey'
cfg_iter = self.cbox[cfg_t].get_active_iter()
cfgerr = False
if not cfg_iter:
cfgname = self.cbox[cfg_t].get_child().get_text()
else:
model = self.cbox[cfg_t].get_model()
cfgname = model[cfg_iter][0]
if not cfgname:
cfgerr = True
ctxt = clogger("==> ERROR: activate an existing pool first\n",
lts=self._state('lts'), err=cfgerr)
else:
if not cfgname in self.cfgmgr.get_cfg_list(cfg_t):
cfgerr = True
ctxt = clogger("==> ERROR: {0} '{1}' not found\n".format(cfg_t, cfgname),
lts=self._state('lts'), err=cfgerr)
else:
ctxt = clogger("Saving Mandelbrot set to current {0} ...\n".format(pool_txt),
lts=self._state('lts'))
# everything set? then save (copy) from 'tmp' to chosen pool...
ctxt += self._save_param_to_pool(cfg_t, cfgname)
if ctxt:
self.consoleBuffer.insert_at_cursor("{}\n".format(ctxt))
if not cfgerr:
self._refresh_ui( act_l=[cfg_t,] )
def on_genMSetButton_clicked(self, button):
""" Method for when 'Generate Mandelbrot Set' button is pressed. """
args = self._parse_parameterGrid_values()
args.image = MBRAT_TMP_IMGF
# generate the mset to png temp file
ctxt = self.tabs.gen_mset_to_png('tmp', args)
ctxt = clogger(ctxt, lts=self._state('lts'))
# update the SecManager
del args.lims
self.sm['tmp'].set_write_to_section('pool', vars(args))
# load it up...
self._refresh_ui( block='param', act_l=['tmp',])
if ctxt:
self.consoleBuffer.insert_at_cursor( "{}\n".format(ctxt) )
def mpoint_pick_random(self, key_t, lts=False):
"""
A function to pick a random point from a pool (MScreen). Takes a
ConfigManager instance as 'self'. Parameter 'key_t' is just 'poolkey'
or 'privkey', but the function treats 'poolkey' special. (Other key types
besides 'privkey' are imaginable.)
Returns an Arguments object containing an MPoint, and log/error strings.
"""
from mbrat.lib.mscreen import PyMScreen
errstr = ""
logstr = clogger( "\nPicking a random {} key-point ...".format(key_t), lts )
# current public pool config needed no matter what...
pool_cfg = self.secmgr['pool']
# public poolkey pool or not? (ie, privkey pool)
if 'pool' in key_t:
pool_t = 'pool'
additers = 0
keypool_cfg = pool_cfg
else:
pool_t = key_t
additers = pool_cfg.get('iters')
keypool_cfg = self.secmgr[key_t]
keypool_cfg.set_section_to('pool')
keypool_cfg.read()
args = keypool_cfg.get_as_args()
args.iters = int(args.iters) + int(additers)
ms = PyMScreen(args)
logstr += clogger( ms.get_info(), lts )
imgf = keypool_cfg.get('image')
if not imgf or not path.exists(imgf):
# generate pool image file from MScreen and attach to config file ...
imgf = path.join(
keypool_cfg.rootd, "{}.png".format(keypool_cfg.get('name')) )
logstr += clogger(
"==> {} image not found. Making new one at\n".format(key_t)
+ " -> {} ...".format(imgf),
lts )
ms.gen_to_file(imgf)
keypool_cfg.set_write( {'image': imgf,} )
else:
# ... else read PyMScreen object from image file
logstr += clogger( "Reading image file ...", lts )
try:
ms.gen_mscreen_from_img(imgf)
except Exception as err:
errstr = clogger( "\n==> ERROR: {}".format(str(err)), lts )
# MScreen method returns a random MPoint object
pt = ms.get_mpoint()
logstr += clogger(
"\n==> Point picked: ({0}, {1})\n".format( pt.C.real, pt.C.imag )
+ " -> Index: [{0}, {1}]".format( pt.Get_ix(), pt.Get_iy() ),
lts )
# update current *key config file
self.secmgr[key_t].reset_section()
self.secmgr[key_t].set_write( {'real': pt.C.real, 'imag': pt.C.imag,
'ix': pt.Get_ix(), 'iy': pt.Get_iy(),
'info': "Randomly selected key-point.",} )
self.secmgr[key_t].read()
return Arguments( {'log': logstr, 'err': errstr, 'mpoint': pt} )
