static int ObjectCallbackAllStatesFromPyObject(ObjectCallback * I, PyObject * obj)
{
int result = false;
PyObject *list = NULL;
if(PyList_Check(obj)) {
list = obj;
Py_INCREF(list);
} else {
// unpickle list from string
ok_assert(1, list = PConvPickleLoads(obj));
ok_assert(1, PyList_Check(list));
}
I->NState = PyList_Size(list);
VLACheck(I->State, ObjectCallbackState, I->NState);
for(int a = 0; a < I->NState; a++) {
PyObject *val = PyList_GetItem(list, a);
ObjectCallbackStateFromPyObject(I->Obj.G, I->State + a, val);
}
result = true;
ok_except1:
if(PyErr_Occurred()) {
PyErr_Print();
PRINTFB(I->Obj.G, FB_ObjectCallback, FB_Warnings)
" Warning: could not load callback object\n"
ENDFB(I->Obj.G);
}
Py_XDECREF(list);
return result;
}
void ShakerAddLineCon(CShaker * I, int atom0, int atom1, int atom2)
{
ShakerLineCon *slc;
VLACheck(I->LineCon, ShakerLineCon, I->NLineCon);
slc = I->LineCon + I->NLineCon;
slc->at0 = atom0;
slc->at1 = atom1;
slc->at2 = atom2;
I->NLineCon++;
}
void ShakerAddDistCon(CShaker * I, int atom0, int atom1, float target, int type, float wt)
{
ShakerDistCon *sdc;
VLACheck(I->DistCon, ShakerDistCon, I->NDistCon);
sdc = I->DistCon + I->NDistCon;
sdc->at0 = atom0;
sdc->at1 = atom1;
sdc->targ = target;
sdc->type = type;
sdc->weight = wt;
I->NDistCon++;
}
static int GetNewMember(CTracker * I)
{
int result = 0;
if(!(result = I->next_free_member)) {
I->n_member++;
result = I->n_member;
VLACheck(I->member, TrackerMember, result); /* auto zeros -- NO ERROR CHECK */
} else {
I->next_free_member = I->member[result].hash_next;
MemoryZero((char *) (I->member + result), (char *) (I->member + result + 1)); /* zero */
}
I->n_link++;
return result;
}
static int GetNewInfo(CTracker * I)
{
int result = 0;
if(!I->next_free_info) {
I->n_info++;
result = I->n_info;
VLACheck(I->info, TrackerInfo, result); /* auto zeros -- NO ERROR CHECK */
} else {
result = I->next_free_info;
I->next_free_info = I->info[result].next;
MemoryZero((char *) (I->info + result), (char *) (I->info + result + 1)); /* zero */
}
return result;
}
void ShakerAddTorsCon(CShaker * I, int atom0, int atom1, int atom2, int atom3, int type)
{
ShakerTorsCon *stc;
VLACheck(I->TorsCon, ShakerTorsCon, I->NTorsCon);
stc = I->TorsCon + I->NTorsCon;
stc->at0 = atom0;
stc->at1 = atom1;
stc->at2 = atom2;
stc->at3 = atom3;
stc->type = type;
I->NTorsCon++;
}
void ShakerAddPlanCon(CShaker * I, int atom0, int atom1, int atom2, int atom3,
float target, int fixed)
{
ShakerPlanCon *spc;
VLACheck(I->PlanCon, ShakerPlanCon, I->NPlanCon);
spc = I->PlanCon + I->NPlanCon;
spc->at0 = atom0;
spc->at1 = atom1;
spc->at2 = atom2;
spc->at3 = atom3;
spc->fixed = fixed;
spc->target = target;
I->NPlanCon++;
}
void ShakerAddPyraCon(CShaker * I, int atom0, int atom1, int atom2, int atom3,
float targ1, float targ2)
{
ShakerPyraCon *spc;
VLACheck(I->PyraCon, ShakerPyraCon, I->NPyraCon);
spc = I->PyraCon + I->NPyraCon;
spc->at0 = atom0;
spc->at1 = atom1;
spc->at2 = atom2;
spc->at3 = atom3;
spc->targ1 = targ1;
spc->targ2 = targ2;
I->NPyraCon++;
}
/*========================================================================*/
ObjectCallback *ObjectCallbackDefine(PyMOLGlobals * G, ObjectCallback * obj,
PyObject * pobj, int state)
{
#ifdef _PYMOL_NOPY
return NULL;
#else
ObjectCallback *I = NULL;
if(!obj) {
I = ObjectCallbackNew(G);
} else {
I = obj;
}
if(state < 0)
state = I->NState;
if(I->NState <= state) {
VLACheck(I->State, ObjectCallbackState, state);
I->NState = state + 1;
}
if(I->State[state].PObj) {
Py_DECREF(I->State[state].PObj);
}
I->State[state].is_callable = PyCallable_Check(pobj);
I->State[state].PObj = pobj;
Py_INCREF(pobj);
if(I->NState <= state)
I->NState = state + 1;
if(I) {
ObjectCallbackRecomputeExtent(I);
}
SceneChanged(G);
SceneCountFrames(G);
return (I);
#endif
}
static void RepLabelRender(RepLabel * I, RenderInfo * info)
{
CRay *ray = info->ray;
Picking **pick = info->pick;
PyMOLGlobals *G = I->R.G;
float *v = I->V;
int c = I->N;
int *l = I->L;
int font_id = SettingGet_i(G, I->R.cs->Setting, I->R.obj->Setting,
cSetting_label_font_id);
float font_size = SettingGet_f(G, I->R.cs->Setting, I->R.obj->Setting,
cSetting_label_size);
if(ray) {
if(c) {
char *st;
TextSetOutlineColor(G, I->OutlineColor);
while(c--) {
if(*l) {
st = OVLexicon_FetchCString(G->Lexicon, *l);
TextSetPosNColor(G, v + 3, v);
TextRenderRay(G, ray, font_id, st, font_size, v + 6);
}
v += 9;
l++;
}
}
} else if(G->HaveGUI && G->ValidContext) {
if(pick) {
Pickable *p = I->R.P;
int i;
if(c) {
char *st;
int float_text = (int) SettingGet(G, cSetting_float_labels);
if(float_text)
glDisable(GL_DEPTH_TEST);
i = (*pick)->src.index;
while(c--) {
if(*l) {
int first_pass = (!(*pick)[0].src.bond);
i++;
TextSetPosNColor(G, v + 3, v);
TextSetPickColor(G, first_pass, i);
if(first_pass) {
VLACheck((*pick), Picking, i);
p++;
(*pick)[i].src = *p; /* copy object and atom info */
(*pick)[i].context = I->R.context;
}
st = OVLexicon_FetchCString(G->Lexicon, *l);
TextRenderOpenGL(G, info, font_id, st, font_size, v + 6);
}
l++;
v += 9;
}
if(float_text)
glEnable(GL_DEPTH_TEST);
(*pick)[0].src.index = i; /* pass the count */
}
} else {
if(c) {
char *st;
int float_text = (int) SettingGet(G, cSetting_float_labels);
if(float_text)
glDisable(GL_DEPTH_TEST);
#ifdef PURE_OPENGL_ES_2
/* TODO */
#else
if(!info->line_lighting)
glDisable(GL_LIGHTING);
#endif
TextSetOutlineColor(G, I->OutlineColor);
while(c--) {
if(*l) {
TextSetPosNColor(G, v + 3, v);
st = OVLexicon_FetchCString(G->Lexicon, *l);
TextRenderOpenGL(G, info, font_id, st, font_size, v + 6);
}
l++;
v += 9;
}
#ifdef PURE_OPENGL_ES_2
/* TODO */
#else
glEnable(GL_LIGHTING);
#endif
glEnable(GL_BLEND);
if(float_text)
glEnable(GL_DEPTH_TEST);
}
}
}
}
static void RepLabelRender(RepLabel * I, RenderInfo * info)
{
CRay *ray = info->ray;
Picking **pick = info->pick;
PyMOLGlobals *G = I->R.G;
float *v = I->V;
int c = I->N;
int *l = I->L;
int font_id = SettingGet_i(G, I->R.cs->Setting, I->R.obj->Setting,
cSetting_label_font_id);
float font_size = SettingGet_f(G, I->R.cs->Setting, I->R.obj->Setting,
cSetting_label_size);
if(ray) {
if(c) {
char *st;
TextSetOutlineColor(G, I->OutlineColor);
while(c--) {
if(*l) {
st = OVLexicon_FetchCString(G->Lexicon, *l);
TextSetPosNColor(G, v + 3, v);
TextRenderRay(G, ray, font_id, st, font_size, v + 6);
}
v += 9;
l++;
}
}
} else if(G->HaveGUI && G->ValidContext) {
if(pick) {
Pickable *p = I->R.P;
int i;
if (I->shaderCGO){
CGORenderGLPicking(I->shaderCGO, pick, &I->R.context, I->R.cs->Setting, I->R.obj->Setting);
return;
}
SceneSetupGLPicking(G);
if(c) {
char *st;
int float_text = SettingGetGlobal_i(G, cSetting_float_labels);
if(float_text)
glDisable(GL_DEPTH_TEST);
i = (*pick)->src.index;
while(c--) {
if(*l) {
int first_pass = (!(*pick)[0].src.bond);
i++;
TextSetPosNColor(G, v + 3, v);
TextSetPickColor(G, first_pass, i);
if(first_pass) {
VLACheck((*pick), Picking, i);
p++;
(*pick)[i].src = *p; /* copy object and atom info */
(*pick)[i].context = I->R.context;
}
st = OVLexicon_FetchCString(G->Lexicon, *l);
TextRenderOpenGL(G, info, font_id, st, font_size, v + 6, SHADERCGO);
}
l++;
v += 9;
}
if(float_text)
glEnable(GL_DEPTH_TEST);
(*pick)[0].src.index = i; /* pass the count */
}
} else {
if(c) {
char *st;
int float_text = SettingGetGlobal_i(G, cSetting_float_labels);
short use_shader;
Pickable *p = I->R.P;
use_shader = SettingGetGlobal_b(G, cSetting_use_shaders);
if(float_text)
glDisable(GL_DEPTH_TEST);
if (use_shader){
if (!I->shaderCGO){
I->shaderCGO = CGONew(G);
if (use_shader){
I->shaderCGO->use_shader = true;
I->shaderCGO->enable_shaders = true;
}
} else {
CGORenderGL(I->shaderCGO, NULL, NULL, NULL, info, &I->R);
if(float_text)
glEnable(GL_DEPTH_TEST);
return;
}
} else if (I->shaderCGO) {
CGOFree(I->shaderCGO);
I->shaderCGO = NULL;
}
TextSetOutlineColor(G, I->OutlineColor);
while(c--) {
if(*l) {
p++;
if (I->shaderCGO)
CGOPickColor(I->shaderCGO, p->index, p->bond);
TextSetPosNColor(G, v + 3, v);
st = OVLexicon_FetchCString(G->Lexicon, *l);
TextRenderOpenGL(G, info, font_id, st, font_size, v + 6, SHADERCGO);
}
l++;
v += 9;
}
if (I->shaderCGO){
CGO *convertcgo;
CGOStop(I->shaderCGO);
convertcgo = CGOOptimizeLabels(I->shaderCGO, 0);
CGOFree(I->shaderCGO);
I->shaderCGO = convertcgo;
convertcgo = NULL;
if (I->shaderCGO){
I->shaderCGO->use_shader = true;
I->shaderCGO->enable_shaders = true;
CGORenderGL(I->shaderCGO, NULL, NULL, NULL, info, &I->R);
}
}
if(float_text)
glEnable(GL_DEPTH_TEST);
}
}
}
}
/*========================================================================*/
void WizardRefresh(PyMOLGlobals * G)
{
#ifndef _PYMOL_NOPY
register CWizard *I = G->Wizard;
char *vla = NULL;
PyObject *P_list;
ov_size ll;
PyObject *i;
ov_size a;
int blocked;
blocked = PAutoBlock(G);
/* get the current prompt */
if(I->Stack >= 0)
if(I->Wiz[I->Stack]) {
vla = NULL;
if(PyObject_HasAttrString(I->Wiz[I->Stack], "get_prompt")) {
P_list = PyObject_CallMethod(I->Wiz[I->Stack], "get_prompt", "");
if(PyErr_Occurred())
PyErr_Print();
if(P_list)
PConvPyListToStringVLA(P_list, &vla);
Py_XDECREF(P_list);
}
}
OrthoSetWizardPrompt(G, vla);
/* get the current panel list */
I->NLine = 0;
if(I->Stack >= 0)
if(I->Wiz[I->Stack]) {
I->EventMask = cWizEventPick + cWizEventSelect;
if(PyObject_HasAttrString(I->Wiz[I->Stack], "get_event_mask")) {
i = PyObject_CallMethod(I->Wiz[I->Stack], "get_event_mask", "");
if(PyErr_Occurred())
PyErr_Print();
if(!PConvPyIntToInt(i, &I->EventMask))
I->EventMask = cWizEventPick + cWizEventSelect;
Py_XDECREF(i);
}
if(PyObject_HasAttrString(I->Wiz[I->Stack], "get_panel")) {
P_list = PyObject_CallMethod(I->Wiz[I->Stack], "get_panel", "");
if(PyErr_Occurred())
PyErr_Print();
if(P_list) {
if(PyList_Check(P_list)) {
ll = PyList_Size(P_list);
VLACheck(I->Line, WizardLine, ll);
for(a = 0; a < ll; a++) {
/* fallback defaults */
I->Line[a].text[0] = 0;
I->Line[a].code[0] = 0;
I->Line[a].type = 0;
i = PyList_GetItem(P_list, a);
if(PyList_Check(i))
if(PyList_Size(i) > 2) {
PConvPyObjectToInt(PyList_GetItem(i, 0), &I->Line[a].type);
PConvPyObjectToStrMaxLen(PyList_GetItem(i, 1),
I->Line[a].text, sizeof(WordType) - 1);
PConvPyObjectToStrMaxLen(PyList_GetItem(i, 2),
I->Line[a].code, sizeof(OrthoLineType) - 1);
}
}
I->NLine = ll;
}
}
Py_XDECREF(P_list);
}
}
if(I->NLine) {
int LineHeight = SettingGetGlobal_i(G, cSetting_internal_gui_control_size);
OrthoReshapeWizard(G, LineHeight * I->NLine + 4);
} else {
OrthoReshapeWizard(G, 0);
}
PAutoUnblock(G, blocked);
#endif
}
