trunk/pygtk/properties.py

# GUI for ASCEND solver_var properties

import gtk, gtk.glade
import ascpy
from varentry import *
from infodialog import *

class RelPropsWin:
    def __init__(self,browser,instance):
        self.instance = instance;
        self.browser = browser;

        # GUI config
        _xml = gtk.glade.XML(browser.glade_file,"relpropswin")
        self.window = _xml.get_widget("relpropswin")
        self.window.set_transient_for(self.browser.window)

        self.relname = _xml.get_widget("relname")
        self.residual = _xml.get_widget("residual")
        self.expr = _xml.get_widget("expr")
        self.included = _xml.get_widget("included")
        self.exprbuff = gtk.TextBuffer();
        self.expr.set_buffer(self.exprbuff)

        self.fill_values()
        _xml.signal_autoconnect(self)

    def fill_values(self):
        self.relname.set_text( self.browser.sim.getInstanceName(self.instance) )
        self.residual.set_text( str( self.instance.getResidual() ) )
        self.exprbuff.set_text( self.instance.getRelationAsString(self.browser.sim.getModel() ) )
        self.included.set_active( self.instance.isActive() )

    def on_relpropswin_close(self,*args):
        self.window.response(gtk.RESPONSE_CANCEL)

    def on_entry_key_press_event(self,widget,event):
        keyname = gtk.gdk.keyval_name(event.keyval)
        if keyname=="Escape":
            self.window.response(gtk.RESPONSE_CLOSE)
            return True;
        return False;

    def run(self):
        self.window.run()
        self.window.hide()

class VarPropsWin:
    def __init__(self,browser,instance):
        self.instance = instance;
        self.browser = browser;

        # GUI config
        _xml = gtk.glade.XML(browser.glade_file,"varpropswin")
        self.window = _xml.get_widget("varpropswin")
        self.window.set_transient_for(self.browser.window)

        self.varname = _xml.get_widget("varname")
        self.valueentry= _xml.get_widget("valueentry");
        self.lowerentry = _xml.get_widget("lowerentry");
        self.upperentry = _xml.get_widget("upperentry");
        self.nominalentry = _xml.get_widget("nominalentry");
        self.fixed = _xml.get_widget("fixed");
        self.free = _xml.get_widget("free");

        self.statusimg = _xml.get_widget("statusimg");
        self.statusmessage = _xml.get_widget("statusmessage");

        self.cliquebutton = _xml.get_widget("cliquebutton"); 

        self.fill_values()

        _xml.signal_autoconnect(self)

    def fill_values(self):
        # all the values here use the same preferred units for this instance type

        _u = self.instance.getType().getPreferredUnits();
        if _u == None:
            _conversion = 1
            _u = self.instance.getDimensions().getDefaultUnits().getName().toString()
        else:
            _conversion = _u.getConversion() # displayvalue x conversion = SI
            _u = _u.getName().toString()

        _arr = {
            self.valueentry: self.instance.getRealValue()
            ,self.lowerentry: self.instance.getLowerBound()
            ,self.upperentry: self.instance.getUpperBound()
            ,self.nominalentry: self.instance.getNominal()
        }
        for _k,_v in _arr.iteritems():  
            _t = str(_v / _conversion)+" "+_u
            _k.set_text(_t)

        self.varname.set_text(self.browser.sim.getInstanceName(self.instance));

        if self.instance.isFixed():
            self.fixed.set_active(True);
        else:
            self.free.set_active(True);

        _status = self.instance.getVarStatus()
        
        self.statusimg.set_from_pixbuf(self.browser.statusicons[_status]);
        self.statusmessage.set_text(self.browser.statusmessages[_status]);

    def apply_changes(self):
        print "APPLY"
        # check the units of the entered values are acceptable
        
        _arr = {
            self.valueentry: self.instance.setRealValue
            ,self.lowerentry: self.instance.setLowerBound
            ,self.upperentry: self.instance.setUpperBound
            ,self.nominalentry: self.instance.setNominal
        }
        failed = False;
        for _k,_v in _arr.iteritems():
            i = RealAtomEntry(self.instance, _k.get_text())
            try:
                i.checkEntry()
                self.color_entry(_k,"white");
                _v(i.getValue())
            except InputError, e:
                print "INPUT ERROR: ",str(e)
                self.color_entry(_k,"#FFBBBB");
                failed = True;
        
        self.instance.setFixed(self.fixed.get_active())

        if failed:
            raise InputError(None) # no message

        self.browser.do_solve_if_auto()

    def color_entry(self,entry,color):
        entry.modify_bg(gtk.STATE_NORMAL, gtk.gdk.color_parse(color))
        entry.modify_bg(gtk.STATE_ACTIVE, gtk.gdk.color_parse(color))
        entry.modify_base(gtk.STATE_NORMAL, gtk.gdk.color_parse(color))
        entry.modify_base(gtk.STATE_ACTIVE, gtk.gdk.color_parse(color))

    def on_varpropswin_close(self,*args):
        self.window.response(gtk.RESPONSE_CANCEL)

    def on_entry_key_press_event(self,widget,event):
        keyname = gtk.gdk.keyval_name(event.keyval)
        if keyname=="Return":
            self.window.response(gtk.RESPONSE_OK)
            return True
        elif keyname=="Escape":
            self.window.response(gtk.RESPONSE_CANCEL)
            return True;
        return False;

    def on_cliquebutton_clicked(self,*args):
        title = "Clique of '%s'"%self.browser.sim.getInstanceName(self.instance)
        text = title + "\n\n"
        s = self.instance.getClique();
        if s:
            for i in s:
                text += "%s\n"%self.browser.sim.getInstanceName(i)
        else:
            text += "CLIQUE IS EMPTY"
        _dialog = InfoDialog(self.browser,self.window,text,title)
        _dialog.run()

    def run(self):
        self.valueentry.grab_focus()
        _continue = True;
        while _continue:
            _res = self.window.run();
            try:
                if _res == gtk.RESPONSE_APPLY or _res == gtk.RESPONSE_OK:
                    self.apply_changes();
            except InputError:
                # if input error, assume that the gui has been updated appropriately
                continue;

            if _res == gtk.RESPONSE_OK or _res==gtk.RESPONSE_CANCEL:
                _continue = False;
        
        self.window.destroy();


1	# GUI for ASCEND solver_var properties
2
3	import gtk, gtk.glade
4	import ascpy
5	from varentry import *
6	from infodialog import *
7
8	class RelPropsWin:
9	def __init__(self,browser,instance):
10	self.instance = instance;
11	self.browser = browser;
12
13	# GUI config
14	_xml = gtk.glade.XML(browser.glade_file,"relpropswin")
15	self.window = _xml.get_widget("relpropswin")
16	self.window.set_transient_for(self.browser.window)
17
18	self.relname = _xml.get_widget("relname")
19	self.residual = _xml.get_widget("residual")
20	self.expr = _xml.get_widget("expr")
21	self.included = _xml.get_widget("included")
22	self.exprbuff = gtk.TextBuffer();
23	self.expr.set_buffer(self.exprbuff)
24
25	self.fill_values()
26	_xml.signal_autoconnect(self)
27
28	def fill_values(self):
29	self.relname.set_text( self.browser.sim.getInstanceName(self.instance) )
30	self.residual.set_text( str( self.instance.getResidual() ) )
31	self.exprbuff.set_text( self.instance.getRelationAsString(self.browser.sim.getModel() ) )
32	self.included.set_active( self.instance.isActive() )
33
34	def on_relpropswin_close(self,*args):
35	self.window.response(gtk.RESPONSE_CANCEL)
36
37	def on_entry_key_press_event(self,widget,event):
38	keyname = gtk.gdk.keyval_name(event.keyval)
39	if keyname=="Escape":
40	self.window.response(gtk.RESPONSE_CLOSE)
41	return True;
42	return False;
43
44	def run(self):
45	self.window.run()
46	self.window.hide()
47
48	class VarPropsWin:
49	def __init__(self,browser,instance):
50	self.instance = instance;
51	self.browser = browser;
52
53	# GUI config
54	_xml = gtk.glade.XML(browser.glade_file,"varpropswin")
55	self.window = _xml.get_widget("varpropswin")
56	self.window.set_transient_for(self.browser.window)
57
58	self.varname = _xml.get_widget("varname")
59	self.valueentry= _xml.get_widget("valueentry");
60	self.lowerentry = _xml.get_widget("lowerentry");
61	self.upperentry = _xml.get_widget("upperentry");
62	self.nominalentry = _xml.get_widget("nominalentry");
63	self.fixed = _xml.get_widget("fixed");
64	self.free = _xml.get_widget("free");
65
66	self.statusimg = _xml.get_widget("statusimg");
67	self.statusmessage = _xml.get_widget("statusmessage");
68
69	self.cliquebutton = _xml.get_widget("cliquebutton");
70
71	self.fill_values()
72
73	_xml.signal_autoconnect(self)
74
75	def fill_values(self):
76	# all the values here use the same preferred units for this instance type
77
78	_u = self.instance.getType().getPreferredUnits();
79	if _u == None:
80	_conversion = 1
81	_u = self.instance.getDimensions().getDefaultUnits().getName().toString()
82	else:
83	_conversion = _u.getConversion() # displayvalue x conversion = SI
84	_u = _u.getName().toString()
85
86	_arr = {
87	self.valueentry: self.instance.getRealValue()
88	,self.lowerentry: self.instance.getLowerBound()
89	,self.upperentry: self.instance.getUpperBound()
90	,self.nominalentry: self.instance.getNominal()
91	}
92	for _k,_v in _arr.iteritems():
93	_t = str(_v / _conversion)+" "+_u
94	_k.set_text(_t)
95
96	self.varname.set_text(self.browser.sim.getInstanceName(self.instance));
97
98	if self.instance.isFixed():
99	self.fixed.set_active(True);
100	else:
101	self.free.set_active(True);
102
103	_status = self.instance.getVarStatus()
104
105	self.statusimg.set_from_pixbuf(self.browser.statusicons[_status]);
106	self.statusmessage.set_text(self.browser.statusmessages[_status]);
107
108	def apply_changes(self):
109	print "APPLY"
110	# check the units of the entered values are acceptable
111
112	_arr = {
113	self.valueentry: self.instance.setRealValue
114	,self.lowerentry: self.instance.setLowerBound
115	,self.upperentry: self.instance.setUpperBound
116	,self.nominalentry: self.instance.setNominal
117	}
118	failed = False;
119	for _k,_v in _arr.iteritems():
120	i = RealAtomEntry(self.instance, _k.get_text())
121	try:
122	i.checkEntry()
123	self.color_entry(_k,"white");
124	_v(i.getValue())
125	except InputError, e:
126	print "INPUT ERROR: ",str(e)
127	self.color_entry(_k,"#FFBBBB");
128	failed = True;
129
130	self.instance.setFixed(self.fixed.get_active())
131
132	if failed:
133	raise InputError(None) # no message
134
135	self.browser.do_solve_if_auto()
136
137	def color_entry(self,entry,color):
138	entry.modify_bg(gtk.STATE_NORMAL, gtk.gdk.color_parse(color))
139	entry.modify_bg(gtk.STATE_ACTIVE, gtk.gdk.color_parse(color))
140	entry.modify_base(gtk.STATE_NORMAL, gtk.gdk.color_parse(color))
141	entry.modify_base(gtk.STATE_ACTIVE, gtk.gdk.color_parse(color))
142
143	def on_varpropswin_close(self,*args):
144	self.window.response(gtk.RESPONSE_CANCEL)
145
146	def on_entry_key_press_event(self,widget,event):
147	keyname = gtk.gdk.keyval_name(event.keyval)
148	if keyname=="Return":
149	self.window.response(gtk.RESPONSE_OK)
150	return True
151	elif keyname=="Escape":
152	self.window.response(gtk.RESPONSE_CANCEL)
153	return True;
154	return False;
155
156	def on_cliquebutton_clicked(self,*args):
157	title = "Clique of '%s'"%self.browser.sim.getInstanceName(self.instance)
158	text = title + "\n\n"
159	s = self.instance.getClique();
160	if s:
161	for i in s:
162	text += "%s\n"%self.browser.sim.getInstanceName(i)
163	else:
164	text += "CLIQUE IS EMPTY"
165	_dialog = InfoDialog(self.browser,self.window,text,title)
166	_dialog.run()
167
168	def run(self):
169	self.valueentry.grab_focus()
170	_continue = True;
171	while _continue:
172	_res = self.window.run();
173	try:
174	if _res == gtk.RESPONSE_APPLY or _res == gtk.RESPONSE_OK:
175	self.apply_changes();
176	except InputError:
177	# if input error, assume that the gui has been updated appropriately
178	continue;
179
180	if _res == gtk.RESPONSE_OK or _res==gtk.RESPONSE_CANCEL:
181	_continue = False;
182
183	self.window.destroy();
184
185
186