def __init__(self, parent=None):

super(App, self).__init__(parent)

self.setupUi(self)

self.FIRSTRUN = True

self.SDFTYPE = ""

# self.le_sdf_name.setText("aviru_db")

self.highlight_dict = config.HIGHLIGHT_DICT

if not sys.platform.startswith("linux"): # to have some icons also on Windows

icon = QtGui.QIcon()

icon.addPixmap(self.style().standardPixmap(QtGui.QStyle.SP_DirOpenIcon))

self.btn_sdf_load.setIcon(icon)

self.btn_session_load.setIcon(icon)

icon = QtGui.QIcon()

icon.addPixmap(self.style().standardPixmap(QtGui.QStyle.SP_MediaPlay))

self.btn_start.setIcon(icon)

icon = QtGui.QIcon()

icon.addPixmap(self.style().standardPixmap(QtGui.QStyle.SP_ArrowLeft))

self.btn_prev.setIcon(icon)

self.btn_load_prev_cluster.setIcon(icon)

icon = QtGui.QIcon()

icon.addPixmap(self.style().standardPixmap(QtGui.QStyle.SP_ArrowRight))

self.btn_next.setIcon(icon)

self.btn_load_next_cluster.setIcon(icon)

icon = QtGui.QIcon()

icon.addPixmap(self.style().standardPixmap(QtGui.QStyle.SP_TrashIcon))

self.btn_del_sdf.setIcon(icon)

icon = QtGui.QIcon()

icon.addPixmap(self.style().standardPixmap(QtGui.QStyle.SP_DialogSaveButton))

self.btn_sdf_save.setIcon(icon)

self.btn_session_save.setIcon(icon)

self.btn_sdf_save.setEnabled(False)

self.btn_del_sdf.setEnabled(False)

self.btn_session_save.setEnabled(False)

self.btn_prev.setEnabled(False)

self.btn_next.setEnabled(False)

self.btn_hist.setEnabled(False)

self.btn_scatter.setEnabled(False)

self.btn_scatter2.setEnabled(False)

self.check_lipinski.setEnabled(False)

self.check_rec_selected.setEnabled(False)

self.le_recnumber.setReadOnly(False)

self.label_molimage.setEnabled(True)

self.btn_load_next_cluster.setEnabled(False)

self.btn_load_prev_cluster.setEnabled(False)

self.btn_browse.setEnabled(False)

self.btn_sdf_from_selection.setEnabled(False)

self.btn_copy_molids.setEnabled(False)

self.btn_select_all.setEnabled(False)

self.btn_select_none.setEnabled(False)

self.btn_select_invert.setEnabled(False)

self.label_molimage.customContextMenuRequested.connect(self.cntxt_menu)

self.tempfile = tempfile.NamedTemporaryFile(mode="w", delete=False) # for image depiction

# can be omitted when @pyqtslot decorator is ***NOT*** used !!

# QtCore.QObject.connect(self.table_query_view, QtCore.SIGNAL("cellClicked(int, int)"),

# self.on_table_query_view_cellClicked)

@QtCore.pyqtSlot()

def on_le_sdf_name_editingFinished(self):

if len(self.le_sdf_name.text()) > 0:

self.btn_sdf_load.setEnabled(True)

@QtCore.pyqtSlot()

def on_btn_sdf_load_clicked(self):

#TODO: check that the specified file does exist.

self.sdf_dict = {}

self.sdf_info_dict = {}

self.sdf_name_order = []

self.get_sdfname()

self.statusbar.showMessage("loading sd file {}.".format(self.sdf_filename), 2000)

self.sdf_dict[self.sdf_name] = sdft.load_sdf(self.sdf_filename)

# [<origin>, "factsearch", "n_molwt < 500", <num_of_molecules>, <remark>]

self.sdf_info_dict[self.sdf_name] = ["", "", "", str(len(self.sdf_dict[self.sdf_name])), "original sdf"]

self.sdf_name_order.append(self.sdf_name)

self.create_index()

# for cluster enumerator:

# match sdf names of the form cluster_001_009

CLUSTERFILE = False

split_name = self.sdf_name.split("_")

if len(split_name) >= 3:

if len(split_name[-2]) == 3 and len(split_name[-1]) == 3:

try:

self.cluster_ind = int(split_name[-2])

self.cluster_max = int(split_name[-1])

CLUSTERFILE = True

except ValueError:

CLUSTERFILE = False

print(" ** no cluster file")

if not CLUSTERFILE:

self.btn_load_next_cluster.setEnabled(False)

self.btn_load_prev_cluster.setEnabled(False)

else:

self.cluster_name = "_".join(split_name[:-2])

if self.cluster_ind > 0:

self.btn_load_prev_cluster.setEnabled(True)

else:

self.btn_load_prev_cluster.setEnabled(False)

if self.cluster_ind < self.cluster_max:

self.btn_load_next_cluster.setEnabled(True)

else:

self.btn_load_next_cluster.setEnabled(False)

# check, if the name of the sdf is in the config dict BROWSE_OPTIONS

# to enable linking to websites based on an identifier

self.btn_browse.setEnabled(False)

for name in config.BROWSE_OPTIONS:

if name in self.sdf_name:

self.btn_browse.setEnabled(True)

self.browse_key = config.BROWSE_OPTIONS[name][0]

self.browse_key_type = config.BROWSE_OPTIONS[name][1]

self.url_templ = config.BROWSE_OPTIONS[name][2]

break

self.init_curr_sdf(self.sdf_name)

self.statusbar.showMessage("{} molecules loaded into entry {} from file {}.".format(self.curr_sdf_num_of_mols, self.sdf_name, self.sdf_filename), 5000)

@QtCore.pyqtSlot()

def on_btn_load_prev_cluster_clicked(self):

self.cluster_ind -= 1

new_cluster_name = "_".join([self.cluster_name, "{:03d}".format(self.cluster_ind), "{:03d}".format(self.cluster_max)])

self.le_sdf_name.setText(new_cluster_name)

self.on_btn_sdf_load_clicked()

@QtCore.pyqtSlot()

def on_btn_load_next_cluster_clicked(self):

self.cluster_ind += 1

new_cluster_name = "_".join([self.cluster_name, "{:03d}".format(self.cluster_ind), "{:03d}".format(self.cluster_max)])

self.le_sdf_name.setText(new_cluster_name)

self.on_btn_sdf_load_clicked()

@QtCore.pyqtSlot()

def on_btn_sdf_save_clicked(self):

self.statusbar.showMessage("saving current sdf...", 2000)

sdft.write_sdf(self.curr_sdf, op.join(sdft.REPORT_FOLDER, "sdf", self.curr_sdf_name+".sdf"))

self.statusbar.showMessage("sdf {} saved with {} records.".format(self.curr_sdf_name, len(self.curr_sdf)), 2000)

@QtCore.pyqtSlot()

def on_btn_del_sdf_clicked(self):

#self.sdf_dict[sdf_name] = mol_list

#self.sdf_info_dict[sdf_name] = [self.curr_sdf_name, querytype, query, str(len(mol_list)), ""]

#self.sdf_name_order.append(sdf_name)

#self.init_curr_sdf(sdf_name)

self.sdf_dict.pop(self.curr_sdf_name)

self.sdf_info_dict.pop(self.curr_sdf_name)

index_of = self.sdf_name_order.index(self.curr_sdf_name)

self.sdf_name_order.pop(index_of)

l = len(self.sdf_name_order)

if index_of > l-1:

index_of = l-1

sdf_name = self.sdf_name_order[index_of]

self.init_curr_sdf(sdf_name)

@QtCore.pyqtSlot()

def on_btn_session_save_clicked(self):

session_dir = op.join(sdft.REPORT_FOLDER, "session")

if not op.isdir(session_dir):

print(" > creating session folder {}...".format(session_dir))

os.mkdir(session_dir)

f = open(op.join(session_dir, self.sdf_name+".session"), "wb")

self.statusbar.showMessage("saving session...", 2000)

#session = [self.sdf_dict, self.sdf_info_dict, self.sdf_name_order, self.curr_sdf_name]

#pickle.dump(session, f, protocol=2)

session = [self.sdf_info_dict, self.sdf_name_order, self.curr_sdf_name]

pickle.dump(session, f, protocol=2)

f.close()

for num, sdf_name in enumerate(self.sdf_name_order):

sdf = self.sdf_dict[sdf_name]

sdft.write_sdf(sdf, op.join(sdft.REPORT_FOLDER, "session", "session_{}_{:02d}".format(self.sdf_name, num)))

self.statusbar.showMessage("session {} saved.".format(self.sdf_name), 2000)

@QtCore.pyqtSlot()

def on_btn_session_load_clicked(self):

self.get_sdfname()

f = open(op.join(sdft.REPORT_FOLDER, "session", self.sdf_name+".session"), "rb")

self.statusbar.showMessage("loading session {}...".format(self.sdf_name), 2000)

self.sdf_dict = {}

[self.sdf_info_dict, self.sdf_name_order, self.curr_sdf_name] = pickle.load(f)

f.close()

for num, sdf_name in enumerate(self.sdf_name_order):

sdf = sdft.load_sdf(op.join(sdft.REPORT_FOLDER, "session", "session_{}_{:02d}".format(self.sdf_name, num)))

self.sdf_dict[sdf_name] = sdf

self.create_index()

self.init_curr_sdf(self.curr_sdf_name)

self.statusbar.showMessage("session loaded.", 2000)

@QtCore.pyqtSlot()

def on_btn_start_clicked(self):

querytype = str(self.combo_querytype.currentText())

query = str(self.le_query.text())

sdf_name = str(self.le_out.text())

while sdf_name in self.sdf_dict:

# make sure the name is not already in use

sdf_name = sdf_name + "x"

invert = "inverted" in querytype

if "fact" in querytype:

mol_list = sdft.factsearch(self.curr_sdf, query, invert=invert)

else:

mol_list = sdft.fact_search(self.curr_sdf, query, invert=invert)

self.statusbar.showMessage("found {} matching records.".format(len(mol_list)), 2000)

if mol_list:

self.sdf_dict[sdf_name] = mol_list

self.sdf_info_dict[sdf_name] = [self.curr_sdf_name, querytype, query, str(len(mol_list)), ""]

self.sdf_name_order.append(sdf_name)

self.init_curr_sdf(sdf_name)

@QtCore.pyqtSlot()

def on_btn_prev_clicked(self):

self.curr_sdf_mol_index -= 1

self.display_mol()

@QtCore.pyqtSlot()

def on_btn_next_clicked(self):

self.curr_sdf_mol_index += 1

self.display_mol()

@QtCore.pyqtSlot()

def on_btn_browse_clicked(self):

browse_id = self.browse_key_type(self.curr_sdf[self.curr_sdf_mol_index].GetProp(self.browse_key))

url = self.url_templ.format(browse_id)

webbrowser.open(url)

#subprocess.call(["kde-open", url])

@QtCore.pyqtSlot()

def on_btn_select_all_clicked(self):

self.selected_recs = range(len(self.curr_sdf))

print(" > all records selected.")

self.statusbar.showMessage("all records selected.", 2000)

self.display_mol()

@QtCore.pyqtSlot()

def on_btn_select_none_clicked(self):

self.selected_recs = []

print(" > no records selected.")

self.statusbar.showMessage("no records selected.", 2000)

self.display_mol()

@QtCore.pyqtSlot()

def on_btn_select_invert_clicked(self):

all_indexes = range(len(self.curr_sdf))

self.selected_recs = list(set(all_indexes)-set(self.selected_recs))

print(" > selection inverted.")

self.statusbar.showMessage("selection inverted.", 2000)

self.display_mol()

@QtCore.pyqtSlot()

def on_btn_copy_molids_clicked(self):

molid_list = []

for idx in self.selected_recs:

molid_list.append(self.curr_sdf[idx].GetProp("k_molid"))

QtGui.QApplication.clipboard().setText("\n".join(molid_list))

@QtCore.pyqtSlot()

def on_btn_sdf_from_selection_clicked(self):

mol_list = []

sdf_name = "selection"

while sdf_name in self.sdf_dict:

# make sure the name is not already in use

sdf_name = sdf_name + "x"

for idx in self.selected_recs:

mol_list.append(self.curr_sdf[idx])

self.sdf_dict[sdf_name] = mol_list

self.sdf_info_dict[sdf_name] = [self.curr_sdf_name, "selection", "", str(len(mol_list)), ""]

self.sdf_name_order.append(sdf_name)

self.init_curr_sdf(sdf_name)

@QtCore.pyqtSlot()

def on_label_molimage_mousePressEvent(self, msevent):

if self.check_rec_selected.isChecked():

self.check_rec_selected.setChecked(False)

else:

self.check_rec_selected.setChecked(True)

def on_check_rec_selected_stateChanged(self, state):

if state == 2: # isChecked()

if not self.curr_sdf_mol_index in self.selected_recs:

self.selected_recs.append(self.curr_sdf_mol_index)

self.statusbar.showMessage("{} records selected.".format(len(self.selected_recs)), 1000)

print(" {} was added to the list of selected records.".format(self.curr_sdf_mol_index))

else:

if self.curr_sdf_mol_index in self.selected_recs:

self.selected_recs.remove(self.curr_sdf_mol_index)

print(" {} was removed from the list of selected records.".format(self.curr_sdf_mol_index))

if self.selected_recs:

self.btn_sdf_from_selection.setEnabled(True)

self.btn_copy_molids.setEnabled(True)

self.btn_select_invert.setEnabled(True)

else:

self.btn_sdf_from_selection.setEnabled(False)

self.btn_copy_molids.setEnabled(False)

self.btn_select_invert.setEnabled(True)

def on_le_recnumber_returnPressed(self):

self.curr_sdf_mol_index = int(self.le_recnumber.text()) - 1

self.display_mol()

#@QtCore.pyqtSlot()

def wheelEvent(self, event):

if event.delta() < 0 and self.curr_sdf_mol_index < self.curr_sdf_num_of_mols - 1:

self.curr_sdf_mol_index += 1

self.display_mol()

event.ignore()

return

if event.delta() > 0 and self.curr_sdf_mol_index > 0:

self.curr_sdf_mol_index -= 1

self.display_mol()

event.ignore()

return

def cntxt_menu(self, pos):

menu = QtGui.QMenu()

copy_as_ctab = menu.addAction("Copy as CTab")

copy_as_smiles = menu.addAction("Copy as Smiles")

action = menu.exec_(self.mapToGlobal(pos))

if action == copy_as_ctab:

self.do_copy_as_ctab()

elif action == copy_as_smiles:

self.do_copy_as_smiles()

def do_copy_as_ctab(self):

ctab = Chem.MolToMolBlock(self.curr_sdf[self.curr_sdf_mol_index])

QtGui.QApplication.clipboard().setText(ctab)

def do_copy_as_smiles(self):

smiles = Chem.MolToSmiles(self.curr_sdf[self.curr_sdf_mol_index])

QtGui.QApplication.clipboard().setText(smiles)

#@QtCore.pyqtSlot()

def on_table_query_view_cellClicked(self, row, colmn):

sdf_name = self.sdf_name_order[row]

if sdf_name != self.curr_sdf_name:

self.init_curr_sdf(sdf_name)

def onpick(self, event):

x = event.mouseevent.xdata

y = event.mouseevent.ydata

ind = event.ind

ax = event.mouseevent.inaxes

if ind:

ind = ind[0]

if self.curr_sdf_index != 0:

# use root sdf to display structures

self.init_curr_sdf(self.sdf_name_order[0])

molid = self.axes_molindex_dict[ax][ind]

molindex = self.sdf_mol_index[molid]

if self.curr_sdf_mol_index != self.sdf_mol_index[molid]:

self.curr_sdf_mol_index = molindex

print(" x= {:6.2f} y= {:6.2f} index {:4d}: molid {}".format(x, y, molindex, molid))

self.display_mol()

else:

# toggle the selection checkbox only on the second click on the data point:

# self.curr_sdf_mol_index == self.sdf_mol_index[molid]

# (this automagically triggers on_check_rec_selected_stateChanged)

self.check_rec_selected.setChecked(not self.check_rec_selected.isChecked())

@QtCore.pyqtSlot()

def on_btn_hist_clicked(self):

selected_fields = self.get_selected_fields()

self.statusbar.showMessage("generating histogram...", 2000)

sdft.show_hist(self.curr_sdf, selected_fields, show=True)

self.statusbar.showMessage("histogram generated.", 2000)

# self.label_plot_image.setPixmap(QtGui.QPixmap("histogram.png"))

@QtCore.pyqtSlot()

def on_btn_scatter_clicked(self):

colorby = str(self.combo_colorby.currentText())

print(" > colorby:", colorby)

if colorby == "<none>":

colorby = None

selected_fields = self.get_selected_fields()

self.statusbar.showMessage("generating scatter matrix...", 2000)

self.fig, self.axes_molindex_dict = sdft.show_scattermatrix(self.curr_sdf, fields=selected_fields, colorby=colorby, mode="gui")

self.statusbar.showMessage("scatter matrix generated.", 2000)

self.fig.canvas.mpl_connect('pick_event', self.onpick)

self.fig.show()

@QtCore.pyqtSlot()

def on_btn_scatter2_clicked(self):

compareto = str(self.combo_compareto.currentText())

print(" > compareto:", compareto)

selected_fields = self.get_selected_fields()

self.statusbar.showMessage("generating scatter matrix...", 2000)

self.statusbar.showMessage("scatter matrix generated.", 2000)

self.fig, self.axes_molindex_dict = sdft.show_scattermatrix2(self.curr_sdf, self.sdf_dict[compareto], fields=selected_fields, mode="gui")

self.fig.canvas.mpl_connect('pick_event', self.onpick)

self.fig.show()

#@QtCore.pyqtSlot()

def on_check_lipinski_stateChanged(self, state):

# lipinski = self.check_lipinski.isChecked()

self.display_mol()

def get_selected_fields(self):

selected_fields = []

for item in self.table_props.selectedIndexes():

selected_fields.append(self.curr_sdf_fields[item.row()])

if len(selected_fields) == 0:

# if no cells are selected, plot all fields

return None

else:

print(" ", selected_fields)

return selected_fields

def create_index(self):

self.sdf_mol_index = {}

sdf = self.sdf_dict[self.sdf_name_order[0]]

fields = sdft.list_fields(sdf)

prep_needed = False

for field in fields:

if field[:2] not in ["n_", "s_", "k_"]:

prep_needed = True

break

if prep_needed:

print(" > renaming existing fields for viewer:")

sdft.prepare_for_viewer(sdf)

if not "k_molid" in fields:

print(" * no molid field found!")

print(" calculating fields...",)

sdft.calc_props(sdf, force2d=prep_needed)

print("done.")

for index, mol in enumerate(sdf):

self.sdf_mol_index[int(mol.GetProp("k_molid"))] = index

print(" > index created.")

# show final list of available fields:

fields = sdft.list_fields(sdf)

print(" > available fields:", end="")

for idx, field in enumerate(fields):

if idx % 4 == 0:

# new line

print()

print(" ", end="")

print("{} ".format(field), end="")

print()

def get_sdfname(self):

self.sdf_filename = str(self.le_sdf_name.text())

if ".sdf" in self.sdf_filename:

self.sdf_name = self.sdf_filename.split(".sdf")[0]

self.le_sdf_name.setText(self.sdf_name)

else:

self.sdf_name = self.sdf_filename

self.sdf_filename = self.sdf_filename + ".sdf"

self.sdf_filename = op.join(sdft.REPORT_FOLDER, "sdf", self.sdf_filename)

#TODO: make sure the entry fields are filled before enabling the start button

def edit_query(self):

if len(self.le_sdf_name.text()) > 0:

self.btn_sdf_load.setEnabled(True)

def init_curr_sdf(self, sdf_name):

self.SDF_CHANGED = True

self.selected_recs = []

self.btn_sdf_from_selection.setEnabled(False)

self.btn_copy_molids.setEnabled(False)

self.selected_fields = self.get_selected_fields()

self.curr_sdf = self.sdf_dict[sdf_name][:] # make a copy

self.curr_sdf_name = sdf_name

self.curr_sdf_index = self.sdf_name_order.index(sdf_name)

self.curr_sdf_num_of_mols = int(self.sdf_info_dict[sdf_name][3])

self.curr_sdf_fields = sdft.list_fields(self.curr_sdf)

self.curr_sdf_num_of_fields = len(self.curr_sdf_fields)

self.le_curr_sdf.setText(sdf_name)

self.table_props.setRowCount(self.curr_sdf_num_of_fields)

self.curr_sdf_mol_index = 0

self.display_mol()

self.fill_query_table()

self.btn_sdf_save.setEnabled(True)

self.btn_select_all.setEnabled(True)

self.btn_select_none.setEnabled(True)

if len(self.sdf_dict) > 0:

self.btn_session_save.setEnabled(True)

self.btn_hist.setEnabled(True)

self.btn_scatter.setEnabled(True)

self.check_lipinski.setEnabled(True)

self.check_rec_selected.setEnabled(True)

if len(self.sdf_dict) > 1:

# scatter2 can only be activated when two sdfs are avail. (after the 1. query)

self.btn_scatter2.setEnabled(True)

if self.curr_sdf_index == 0:

self.btn_del_sdf.setEnabled(False) # the original sdf can not be deleted

else:

self.btn_del_sdf.setEnabled(True)

self.combo_colorby.clear()

text_fields = ["<none>"]

text_fields.extend([item for item in self.curr_sdf_fields if item[:2] == "s_"])

self.combo_colorby.addItems(text_fields)

self.combo_compareto.clear()

compare_sdfs = [sdf_entry for sdf_entry in self.sdf_dict if sdf_entry != self.curr_sdf_name]

self.combo_compareto.addItems(compare_sdfs)

def display_mol(self):

highlight_lipinski = self.check_lipinski.isChecked()

if self.curr_sdf_mol_index == 0:

self.btn_prev.setEnabled(False)

else:

self.btn_prev.setEnabled(True)

if self.curr_sdf_mol_index == self.curr_sdf_num_of_mols - 1:

self.btn_next.setEnabled(False)

else:

self.btn_next.setEnabled(True)

Draw.MolToFile(self.curr_sdf[self.curr_sdf_mol_index], self.tempfile.name, imageType="png")

self.label_molimage.setPixmap(QtGui.QPixmap(self.tempfile.name))

self.le_recnumber.setText("{} of {}".format(self.curr_sdf_mol_index+1, self.curr_sdf_num_of_mols))

if self.SDF_CHANGED:

# self.SDF_CHANGED = False

# self.selected_fields = self.get_selected_fields()

self.table_props.clear()

self.table_props.setHorizontalHeaderLabels(["prop", "value"])

for row, prop in enumerate(self.curr_sdf_fields):

tbl_item = QtGui.QTableWidgetItem(prop[2:])

# tbl_item.setFlags(QtCore.Qt.ItemIsEnabled)

self.table_props.setItem(row, 0, tbl_item)

if self.SDF_CHANGED:

if self.selected_fields and prop in self.selected_fields:

self.table_props.setItemSelected(tbl_item, True)

if prop in self.curr_sdf[self.curr_sdf_mol_index].GetPropNames():

value = self.curr_sdf[self.curr_sdf_mol_index].GetProp(prop)

tbl_item = QtGui.QTableWidgetItem(value)

# QtCore.Qt.ItemIsEditable is required to edit the cells

# tbl_item.setFlags(QtCore.Qt.ItemIsEnabled | QtCore.Qt.ItemIsEditable)

tbl_item.setFlags(QtCore.Qt.ItemIsEnabled | QtCore.Qt.ItemIsEditable)

if highlight_lipinski and prop in self.highlight_dict:

if float(value) > self.highlight_dict[prop]:

tbl_item.setBackgroundColor(QtGui.QColor(255, 0, 0))

else:

tbl_item.setBackgroundColor(QtGui.QColor(0, 255, 0))

self.table_props.setItem(row, 1, tbl_item)

else:

tbl_item = QtGui.QTableWidgetItem("n.d.")

# see above for flag QtCore.Qt.ItemIsEditable

tbl_item.setFlags(QtCore.Qt.ItemIsEnabled | QtCore.Qt.ItemIsEditable)

self.table_props.setItem(row, 1, tbl_item)

self.table_props.setRowHeight(row, 18)

self.SDF_CHANGED = False

if self.curr_sdf_mol_index in self.selected_recs:

self.check_rec_selected.setChecked(True)

else:

self.check_rec_selected.setChecked(False)

def fill_query_table(self):

self.table_query_view.setRowCount(len(self.sdf_name_order))

self.table_query_view.setHorizontalHeaderLabels(["sdf", "origin", "type", "query", "hits", "remark"])

for row, sdf_name in enumerate(self.sdf_name_order):

tbl_item = QtGui.QTableWidgetItem(sdf_name)

tbl_item.setFlags(QtCore.Qt.ItemIsEnabled)

self.table_query_view.setItem(row, 0, tbl_item)

for colmn, item in enumerate(self.sdf_info_dict[sdf_name]):

tbl_item = QtGui.QTableWidgetItem(item)

if colmn != 4: # leave remark field editable

tbl_item.setFlags(QtCore.Qt.ItemIsEnabled)

if colmn == 3: # num_of_mols

tbl_item.setTextAlignment(QtCore.Qt.AlignRight)

self.table_query_view.setItem(row, colmn+1, tbl_item)

self.table_query_view.setRowHeight(row, 18)

if len(self.sdf_dict) > 1: