is a Python-enhanced molecular graphics tool. It excels at 3D visualization of proteins, small molecules, density, surfaces, and trajectories. It also includes molecular editing, ray tracing, and movies. Open Source version.
| Setting.cpp (pymol-v2.1.0.tar.bz2) | : | Setting.cpp (pymol-open-source-2.2.0) |
|---|
| | |
| skipping to change at line 31 | | skipping to change at line 31 |
|---|
| #include"os_predef.h" | | #include"os_predef.h" |
| #include"os_std.h" | | #include"os_std.h" |
| | |
| #include"Base.h" | | #include"Base.h" |
| #include"OOMac.h" | | #include"OOMac.h" |
| #include"MemoryDebug.h" | | #include"MemoryDebug.h" |
| #include"Ortho.h" | | #include"Ortho.h" |
| #include"Setting.h" | | #include"Setting.h" |
| #include"Scene.h" | | #include"Scene.h" |
| #include"ButMode.h" | | #include"ButMode.h" |
|
| | #include"CGO.h" |
| #include"Executive.h" | | #include"Executive.h" |
| #include"Editor.h" | | #include"Editor.h" |
| #include"P.h" | | #include"P.h" |
| #include"Util.h" | | #include"Util.h" |
| #include"main.h" | | #include"main.h" |
| #include"PConv.h" | | #include"PConv.h" |
| #include"Wizard.h" | | #include"Wizard.h" |
| #include"Seq.h" | | #include"Seq.h" |
| #include"PyMOLOptions.h" | | #include"PyMOLOptions.h" |
| #include"OVContext.h" | | #include"OVContext.h" |
| | |
| skipping to change at line 326 | | skipping to change at line 327 |
|---|
| } | | } |
| break; | | break; |
| case cSetting_float3: | | case cSetting_float3: |
| memcpy(entry->value.float3_, *(const float **) value, sizeof(float) * 3); | | memcpy(entry->value.float3_, *(const float **) value, sizeof(float) * 3); |
| break; | | break; |
| default: | | default: |
| printf("SettingUniqueEntry_Set-Error: unsupported type %d\n", value_type); | | printf("SettingUniqueEntry_Set-Error: unsupported type %d\n", value_type); |
| } | | } |
| } | | } |
| | |
|
| | /* |
| | * Return false if setting was not set (nothing changed) |
| | */ |
| | bool SettingUniqueUnset(PyMOLGlobals * G, int unique_id, int setting_id) |
| | { |
| | auto I = G->SettingUnique; |
| | auto result = OVOneToOne_GetForward(I->id2offset, unique_id); |
| | |
| | if (OVreturn_IS_OK(result)) { |
| | for (int prev = 0, offset = result.word; offset; |
| | prev = offset, offset = I->entry[offset].next) { |
| | if (I->entry[offset].setting_id != setting_id) |
| | continue; |
| | |
| | if(!prev) { /* if first entry in list */ |
| | OVOneToOne_DelForward(I->id2offset, unique_id); |
| | if(I->entry[offset].next) { /* set new list start */ |
| | OVOneToOne_Set(I->id2offset, unique_id, I->entry[offset].next); |
| | } |
| | } else { /* otherwise excise from middle or end */ |
| | I->entry[prev].next = I->entry[offset].next; |
| | } |
| | I->entry[offset].next = I->next_free; |
| | I->next_free = offset; |
| | |
| | return true; |
| | } |
| | } |
| | return false; |
| | } |
| | |
| int SettingUniqueSetTypedValue(PyMOLGlobals * G, int unique_id, int setting_id, | | int SettingUniqueSetTypedValue(PyMOLGlobals * G, int unique_id, int setting_id, |
| int setting_type, const void *value) | | int setting_type, const void *value) |
| | |
| /* set value to NULL in order to delete setting */ | | /* set value to NULL in order to delete setting */ |
| { | | { |
| CSettingUnique *I = G->SettingUnique; | | CSettingUnique *I = G->SettingUnique; |
| OVreturn_word result; | | OVreturn_word result; |
| int isset = false; | | int isset = false; |
| | |
|
| | if (!value) { |
| | return SettingUniqueUnset(G, unique_id, setting_id); |
| | } |
| | |
| if(OVreturn_IS_OK((result = OVOneToOne_GetForward(I->id2offset, unique_id))))
{ /* setting list exists for atom */ | | if(OVreturn_IS_OK((result = OVOneToOne_GetForward(I->id2offset, unique_id))))
{ /* setting list exists for atom */ |
| int offset = result.word; | | int offset = result.word; |
| int prev = 0; | | int prev = 0; |
| int found = false; | | int found = false; |
| while(offset) { | | while(offset) { |
| SettingUniqueEntry *entry = I->entry + offset; | | SettingUniqueEntry *entry = I->entry + offset; |
| if(entry->setting_id == setting_id) { | | if(entry->setting_id == setting_id) { |
| found = true; /* this setting is already defined */ | | found = true; /* this setting is already defined */ |
|
| if(value) { /* if redefining value */ | | |
| if (!SettingUniqueEntry_IsSame(entry, setting_type, value)){ | | if (!SettingUniqueEntry_IsSame(entry, setting_type, value)){ |
| SettingUniqueEntry_Set(entry, setting_type, value); | | SettingUniqueEntry_Set(entry, setting_type, value); |
| isset = true; | | isset = true; |
| } | | } |
|
| } else { /* or NULL value means delete this setting */ | | |
| if(!prev) { /* if first entry in list */ | | |
| OVOneToOne_DelForward(I->id2offset, unique_id); | | |
| if(entry->next) { /* set new list start */ | | |
| OVOneToOne_Set(I->id2offset, unique_id, entry->next); | | |
| } | | |
| } else { /* otherwise excise from middle or end */ | | |
| I->entry[prev].next = entry->next; | | |
| } | | |
| entry->next = I->next_free; | | |
| I->next_free = offset; | | |
| isset = true; | | |
| } | | |
| break; | | break; |
| } | | } |
| prev = offset; | | prev = offset; |
| offset = entry->next; | | offset = entry->next; |
| } | | } |
| if((!found) && value) { /* setting not found in existing list, so append
new value */ | | if((!found) && value) { /* setting not found in existing list, so append
new value */ |
| if(!I->next_free) | | if(!I->next_free) |
| SettingUniqueExpand(G); | | SettingUniqueExpand(G); |
| if(I->next_free) { | | if(I->next_free) { |
| offset = I->next_free; | | offset = I->next_free; |
| | |
| skipping to change at line 415 | | skipping to change at line 437 |
|---|
| } else { | | } else { |
| /* unhandled error */ | | /* unhandled error */ |
| } | | } |
| return isset; | | return isset; |
| } | | } |
| | |
| #ifndef _PYMOL_NOPY | | #ifndef _PYMOL_NOPY |
| bool SettingUniqueSetPyObject(PyMOLGlobals * G, int unique_id, int index, PyObje
ct *value) | | bool SettingUniqueSetPyObject(PyMOLGlobals * G, int unique_id, int index, PyObje
ct *value) |
| { | | { |
| if (!value) | | if (!value) |
|
| return SettingUniqueSetTypedValue(G, unique_id, index, cSetting_blank, NULL)
; | | return SettingUniqueUnset(G, unique_id, index); |
| | |
| int type = SettingGetType(G, index); | | int type = SettingGetType(G, index); |
| | |
| float val_3f[3]; | | float val_3f[3]; |
| union { | | union { |
| int val_i; | | int val_i; |
| float val_f; | | float val_f; |
| float * ptr_3f; | | float * ptr_3f; |
| }; | | }; |
| | |
| | |
| skipping to change at line 751 | | skipping to change at line 773 |
|---|
| ok = PConvPyIntToInt(PyList_GetItem(entry_list, 2), | | ok = PConvPyIntToInt(PyList_GetItem(entry_list, 2), |
| &value_store.int_); | | &value_store.int_); |
| break; | | break; |
| case cSetting_float: | | case cSetting_float: |
| ok = PConvPyFloatToFloat(PyList_GetItem(entry_list, 2), | | ok = PConvPyFloatToFloat(PyList_GetItem(entry_list, 2), |
| &value_store.float_); | | &value_store.float_); |
| break; | | break; |
| } | | } |
| if(ok) { | | if(ok) { |
| SettingUniqueSetTypedValue(G, unique_id, setting_id, | | SettingUniqueSetTypedValue(G, unique_id, setting_id, |
|
| setting_type, &value_store.int_); | | setting_type, &value_store); |
| } | | } |
| } | | } |
| } | | } |
| } | | } |
| } | | } |
| } | | } |
| } | | } |
| return ok; | | return ok; |
| } | | } |
| | |
| | |
| skipping to change at line 955 | | skipping to change at line 977 |
|---|
| result = PConvToPyObject(list); | | result = PConvToPyObject(list); |
| } | | } |
| return (PConvAutoNone(result)); | | return (PConvAutoNone(result)); |
| } | | } |
| | |
| /*========================================================================*/ | | /*========================================================================*/ |
| static int SettingCheckUseShaders(CSetting * I, int quiet) | | static int SettingCheckUseShaders(CSetting * I, int quiet) |
| { | | { |
| PyMOLGlobals * G = I->G; | | PyMOLGlobals * G = I->G; |
| if (SettingGetGlobal_i(G, cSetting_use_shaders)){ | | if (SettingGetGlobal_i(G, cSetting_use_shaders)){ |
|
| if (!CShaderMgr_ShadersPresent(G->ShaderMgr)){ | | if (G->ShaderMgr->IsConfigured() && !G->ShaderMgr->ShadersPresent()){ |
| SettingSet_b(I, cSetting_use_shaders, 0); | | SettingSet_b(I, cSetting_use_shaders, 0); |
| if (!quiet){ | | if (!quiet){ |
| PRINTFB(G, FB_Setting, FB_Warnings) | | PRINTFB(G, FB_Setting, FB_Warnings) |
| "Setting-Error: use_shaders cannot be set when Shaders are not availa
ble, setting use_shaders back to false\n" | | "Setting-Error: use_shaders cannot be set when Shaders are not availa
ble, setting use_shaders back to false\n" |
| ENDFB(G); | | ENDFB(G); |
| } | | } |
| return 1; | | return 1; |
| } | | } |
| } | | } |
| return 0; | | return 0; |
| | |
| skipping to change at line 1386 | | skipping to change at line 1408 |
|---|
| result = CPythonVal_New_Float(SettingGet_f(G, set1, set2, index)); | | result = CPythonVal_New_Float(SettingGet_f(G, set1, set2, index)); |
| break; | | break; |
| case cSetting_float3: | | case cSetting_float3: |
| ptr = SettingGet_3fv(G, set1, set2, index); | | ptr = SettingGet_3fv(G, set1, set2, index); |
| result = Py_BuildValue("(fff)", ptr[0], ptr[1], ptr[2]); | | result = Py_BuildValue("(fff)", ptr[0], ptr[1], ptr[2]); |
| break; | | break; |
| case cSetting_color: | | case cSetting_color: |
| { | | { |
| int retcol = SettingGet_color(G, set1, set2, index); | | int retcol = SettingGet_color(G, set1, set2, index); |
| if (retcol > 0){ | | if (retcol > 0){ |
|
| float *col; | | const float *col; |
| col = ColorGet(G, retcol); | | col = ColorGet(G, retcol); |
| result = Py_BuildValue("(fff)", col[0], col[1], col[2]); | | result = Py_BuildValue("(fff)", col[0], col[1], col[2]); |
| } | | } |
| } | | } |
| break; | | break; |
| case cSetting_string: | | case cSetting_string: |
| result = PyString_FromString(SettingGet_s(G, set1, set2, index)); | | result = PyString_FromString(SettingGet_s(G, set1, set2, index)); |
| break; | | break; |
| } | | } |
| return result; | | return result; |
| | |
| skipping to change at line 1866 | | skipping to change at line 1888 |
|---|
| PRINTFB(G, FB_Setting, FB_Warnings) | | PRINTFB(G, FB_Setting, FB_Warnings) |
| " Setting-Warning: %s range = [%d,%d]; setting to %d.\n", | | " Setting-Warning: %s range = [%d,%d]; setting to %d.\n", |
| rec.name, rec.value.i[1], rec.value.i[2], value ENDFB(G); | | rec.name, rec.value.i[1], rec.value.i[2], value ENDFB(G); |
| SettingSetGlobal_i(G, index, value); | | SettingSetGlobal_i(G, index, value); |
| } | | } |
| } | | } |
| | |
| switch (index) { | | switch (index) { |
| case cSetting_stereo: | | case cSetting_stereo: |
| SceneUpdateStereo(G); | | SceneUpdateStereo(G); |
|
| CShaderMgr_Set_Reload_Bits(G, RELOAD_ALL_SHADERS); | | G->ShaderMgr->Set_Reload_Bits(RELOAD_VARIABLES); |
| | break; |
| | case cSetting_pick_surface: |
| | if (SettingGetGlobal_b(G, cSetting_use_shaders)){ |
| | SceneInvalidatePicking(G); // right now, when pick_surface is off, wipes e |
| | ach CGO's pickColor array |
| | } |
| | ExecutiveInvalidateRep(G, inv_sele, cRepSurface, cRepInvColor); |
| break; | | break; |
| case cSetting_pickable: | | case cSetting_pickable: |
| ExecutiveInvalidateRep(G, inv_sele, cRepAll, cRepInvAll); | | ExecutiveInvalidateRep(G, inv_sele, cRepAll, cRepInvAll); |
| SceneChanged(G); | | SceneChanged(G); |
| break; | | break; |
| case cSetting_grid_mode: | | case cSetting_grid_mode: |
| if (!SettingGetGlobal_i(G, cSetting_grid_mode)) | | if (!SettingGetGlobal_i(G, cSetting_grid_mode)) |
|
| ShaderMgrResetUniformSet(G); | | G->ShaderMgr->ResetUniformSet(); |
| case cSetting_grid_slot: | | case cSetting_grid_slot: |
| ExecutiveInvalidateGroups(G, false); | | ExecutiveInvalidateGroups(G, false); |
| SceneChanged(G); | | SceneChanged(G); |
| break; | | break; |
| case cSetting_grid_max: | | case cSetting_grid_max: |
| SceneChanged(G); | | SceneChanged(G); |
| break; | | break; |
| case cSetting_defer_builds_mode: | | case cSetting_defer_builds_mode: |
| ExecutiveRebuildAll(G); | | ExecutiveRebuildAll(G); |
| break; | | break; |
| | |
| skipping to change at line 1918 | | skipping to change at line 1946 |
|---|
| break; | | break; |
| case cSetting_seq_view_location: | | case cSetting_seq_view_location: |
| PParse(G, "cmd.viewport(-1,-1)"); | | PParse(G, "cmd.viewport(-1,-1)"); |
| SeqChanged(G); | | SeqChanged(G); |
| break; | | break; |
| case cSetting_seq_view_overlay: | | case cSetting_seq_view_overlay: |
| PParse(G, "cmd.viewport(-1,-1)"); | | PParse(G, "cmd.viewport(-1,-1)"); |
| break; | | break; |
| case cSetting_stereo_mode: | | case cSetting_stereo_mode: |
| case cSetting_anaglyph_mode: | | case cSetting_anaglyph_mode: |
|
| | G->ShaderMgr->Set_Reload_Bits(RELOAD_VARIABLES); |
| SceneUpdateStereoMode(G); | | SceneUpdateStereoMode(G); |
| OrthoInvalidateDoDraw(G); | | OrthoInvalidateDoDraw(G); |
| OrthoDirty(G); | | OrthoDirty(G); |
| PyMOL_NeedRedisplay(G->PyMOL); | | PyMOL_NeedRedisplay(G->PyMOL); |
| break; | | break; |
|
| | case cSetting_precomputed_lighting: |
| | G->ShaderMgr->Set_Reload_Bits(RELOAD_VARIABLES); |
| case cSetting_light_count: | | case cSetting_light_count: |
| case cSetting_spec_count: | | case cSetting_spec_count: |
|
| CShaderMgr_Set_Reload_Bits(G, RELOAD_SHADERS_FOR_LIGHTING); | | G->ShaderMgr->Set_Reload_Bits(RELOAD_CALLCOMPUTELIGHTING); |
| break; | | |
| case cSetting_pick_shading: | | |
| if (SettingGetGlobal_i(G, cSetting_surface_color_smoothing)) { | | |
| ExecutiveInvalidateRep(G, inv_sele, cRepSurface, cRepInvColor); | | |
| } | | |
| CShaderMgr_Set_Reload_Bits(G, RELOAD_SHADERS_FOR_LIGHTING); | | |
| case cSetting_light: | | |
| case cSetting_light2: | | |
| case cSetting_light3: | | |
| case cSetting_light4: | | |
| case cSetting_light5: | | |
| case cSetting_light6: | | |
| case cSetting_light7: | | |
| case cSetting_dot_lighting: | | case cSetting_dot_lighting: |
| case cSetting_mesh_lighting: | | case cSetting_mesh_lighting: |
|
| case cSetting_fog: | | case cSetting_cgo_lighting: |
| case cSetting_field_of_view: | | case cSetting_field_of_view: |
| case cSetting_fog_start: | | case cSetting_fog_start: |
| case cSetting_two_sided_lighting: | | case cSetting_two_sided_lighting: |
|
| case cSetting_transparency_mode: | | |
| case cSetting_transparency_global_sort: | | case cSetting_transparency_global_sort: |
| case cSetting_dot_normals: | | case cSetting_dot_normals: |
| case cSetting_mesh_normals: | | case cSetting_mesh_normals: |
| SceneInvalidate(G); | | SceneInvalidate(G); |
| break; | | break; |
| case cSetting_spec_power: | | case cSetting_spec_power: |
| if (!quiet){ | | if (!quiet){ |
| PRINTFB(G, FB_Setting, FB_Debugging) | | PRINTFB(G, FB_Setting, FB_Debugging) |
| "Setting-Details: spec_power is depreciated in PyMOL 1.5. This option wi
ll not work in future versions. Please set shininess to set the specular exponen
t for movable light sources.\n" | | "Setting-Details: spec_power is depreciated in PyMOL 1.5. This option wi
ll not work in future versions. Please set shininess to set the specular exponen
t for movable light sources.\n" |
| ENDFB(G); | | ENDFB(G); |
| } | | } |
| SceneInvalidate(G); | | SceneInvalidate(G); |
| break; | | break; |
|
| | case cSetting_light: |
| | case cSetting_light2: |
| | case cSetting_light3: |
| | case cSetting_light4: |
| | case cSetting_light5: |
| | case cSetting_light6: |
| | case cSetting_light7: |
| | case cSetting_reflect: |
| | case cSetting_direct: |
| | case cSetting_ambient: |
| | case cSetting_specular: |
| | case cSetting_specular_intensity: |
| case cSetting_shininess: | | case cSetting_shininess: |
| case cSetting_spec_reflect: | | case cSetting_spec_reflect: |
| case cSetting_spec_direct: | | case cSetting_spec_direct: |
| case cSetting_spec_direct_power: | | case cSetting_spec_direct_power: |
|
| #ifdef PURE_OPENGL_ES_2 | | case cSetting_power: |
| #endif | | case cSetting_reflect_power: |
| if (SettingGetGlobal_b(G, cSetting_use_shaders)) { | | if (SettingGetGlobal_b(G, cSetting_precomputed_lighting)) |
| | G->ShaderMgr->Set_Reload_Bits(RELOAD_CALLCOMPUTELIGHTING); |
| SceneInvalidate(G); | | SceneInvalidate(G); |
|
| } | | |
| break; | | break; |
| case cSetting_use_display_lists: | | case cSetting_use_display_lists: |
| case cSetting_simplify_display_lists: | | case cSetting_simplify_display_lists: |
| case cSetting_excl_display_lists_shaders: | | case cSetting_excl_display_lists_shaders: |
| if (!quiet){ | | if (!quiet){ |
| PRINTFB(G, FB_Setting, FB_Debugging) | | PRINTFB(G, FB_Setting, FB_Debugging) |
| "Setting-Details: display lists were depreciated in PyMOL 1.7.x. The set
tings use_display_lists, simplify_display_lists, and excl_display_lists_shaders
no longer work.\n" | | "Setting-Details: display lists were depreciated in PyMOL 1.7.x. The set
tings use_display_lists, simplify_display_lists, and excl_display_lists_shaders
no longer work.\n" |
| ENDFB(G); | | ENDFB(G); |
| } | | } |
|
| | case cSetting_use_geometry_shaders: |
| | if (SettingGetGlobal_i(G, cSetting_use_geometry_shaders) && |
| | G->ShaderMgr->IsConfigured() && !G->ShaderMgr->GeometryShadersPresent()) |
| | { |
| | SettingSet_b(G->Setting, cSetting_use_geometry_shaders, 0); |
| | if (!quiet){ |
| | PRINTFB(G, FB_Setting, FB_Warnings) |
| | "Setting-Error: geometry shaders not available\n" ENDFB(G); |
| | } |
| | return; |
| | } |
| | |
| | G->ShaderMgr->Set_Reload_Bits(RELOAD_VARIABLES); |
| | ExecutiveInvalidateRep(G, inv_sele, cRepLabel, cRepInvRep); |
| | { |
| | // check if lines need to be invalidated |
| | bool line_as_cylinders = SettingGetGlobal_b(G, cSetting_use_shaders) && |
| | SettingGetGlobal_b(G, cSetting_render_as_cylinder |
| | s) && |
| | SettingGetGlobal_b(G, cSetting_line_as_cylinders) |
| | ; |
| | if (!line_as_cylinders && !SettingGetGlobal_b(G, cSetting_trilines)){ |
| | ExecutiveInvalidateRep(G, inv_sele, cRepLine, cRepInvRep); |
| | } |
| | } |
| | break; |
| | case cSetting_shaders_from_disk: |
| | G->ShaderMgr->Set_Reload_Bits(RELOAD_ALL_SHADERS); |
| | SceneInvalidate(G); |
| | break; |
| case cSetting_use_shaders: | | case cSetting_use_shaders: |
| { | | { |
| short changed = 0; | | short changed = 0; |
| if (SettingGetGlobal_b(G, cSetting_use_shaders)){ | | if (SettingGetGlobal_b(G, cSetting_use_shaders)){ |
| if (SettingCheckUseShaders(G->Setting, quiet)){ | | if (SettingCheckUseShaders(G->Setting, quiet)){ |
| return; | | return; |
| } | | } |
| } | | } |
| SceneInvalidate(G); | | SceneInvalidate(G); |
| if (SettingGetGlobal_b(G, cSetting_sphere_use_shader)){ | | if (SettingGetGlobal_b(G, cSetting_sphere_use_shader)){ |
| | |
| skipping to change at line 2034 | | skipping to change at line 2090 |
|---|
| ExecutiveInvalidateRep(G, inv_sele, cRepCyl, cRepInvRep); | | ExecutiveInvalidateRep(G, inv_sele, cRepCyl, cRepInvRep); |
| changed = 1; | | changed = 1; |
| } | | } |
| if (SettingGetGlobal_b(G, cSetting_surface_use_shader) || | | if (SettingGetGlobal_b(G, cSetting_surface_use_shader) || |
| SettingGetGlobal_b(G, cSetting_dot_use_shader) || | | SettingGetGlobal_b(G, cSetting_dot_use_shader) || |
| SettingGetGlobal_b(G, cSetting_mesh_use_shader)){ | | SettingGetGlobal_b(G, cSetting_mesh_use_shader)){ |
| changed = 1; | | changed = 1; |
| } | | } |
| if (changed){ | | if (changed){ |
| SceneChanged(G); | | SceneChanged(G); |
|
| SceneUpdateObjectMoleculesSingleThread(G); | | |
| } | | } |
| } | | } |
| break; | | break; |
| case cSetting_stereo_shift: | | case cSetting_stereo_shift: |
| case cSetting_stereo_angle: | | case cSetting_stereo_angle: |
| case cSetting_stereo_dynamic_strength: | | case cSetting_stereo_dynamic_strength: |
| SceneInvalidate(G); | | SceneInvalidate(G); |
| break; | | break; |
| case cSetting_scene_buttons: | | case cSetting_scene_buttons: |
| case cSetting_scene_buttons_mode: | | case cSetting_scene_buttons_mode: |
| | |
| skipping to change at line 2108 | | skipping to change at line 2163 |
|---|
| case cSetting_mesh_type: | | case cSetting_mesh_type: |
| case cSetting_mesh_solvent: | | case cSetting_mesh_solvent: |
| case cSetting_mesh_quality: | | case cSetting_mesh_quality: |
| case cSetting_mesh_skip: | | case cSetting_mesh_skip: |
| ExecutiveInvalidateRep(G, inv_sele, cRepMesh, cRepInvRep); | | ExecutiveInvalidateRep(G, inv_sele, cRepMesh, cRepInvRep); |
| SceneChanged(G); | | SceneChanged(G); |
| break; | | break; |
| case cSetting_valence: | | case cSetting_valence: |
| case cSetting_valence_mode: | | case cSetting_valence_mode: |
| case cSetting_valence_size: | | case cSetting_valence_size: |
|
| | case cSetting_valence_zero_mode: |
| | case cSetting_valence_zero_scale: |
| case cSetting_half_bonds: | | case cSetting_half_bonds: |
| case cSetting_line_stick_helper: | | case cSetting_line_stick_helper: |
| case cSetting_hide_long_bonds: | | case cSetting_hide_long_bonds: |
| ExecutiveInvalidateRep(G, inv_sele, cRepLine, cRepInvRep); | | ExecutiveInvalidateRep(G, inv_sele, cRepLine, cRepInvRep); |
| ExecutiveInvalidateRep(G, inv_sele, cRepCyl, cRepInvRep); | | ExecutiveInvalidateRep(G, inv_sele, cRepCyl, cRepInvRep); |
| SceneChanged(G); | | SceneChanged(G); |
| break; | | break; |
| case cSetting_stick_transparency: | | case cSetting_stick_transparency: |
| case cSetting_stick_debug: | | case cSetting_stick_debug: |
| case cSetting_stick_round_nub: | | case cSetting_stick_round_nub: |
| case cSetting_stick_as_cylinders: | | case cSetting_stick_as_cylinders: |
| case cSetting_stick_good_geometry: | | case cSetting_stick_good_geometry: |
| ExecutiveInvalidateRep(G, inv_sele, cRepCyl, cRepInvRep); | | ExecutiveInvalidateRep(G, inv_sele, cRepCyl, cRepInvRep); |
| SceneChanged(G); | | SceneChanged(G); |
| break; | | break; |
| case cSetting_line_use_shader: | | case cSetting_line_use_shader: |
| if (SettingGetGlobal_b(G, cSetting_use_shaders)){ | | if (SettingGetGlobal_b(G, cSetting_use_shaders)){ |
| ExecutiveInvalidateRep(G, inv_sele, cRepRibbon, cRepInvRep); | | ExecutiveInvalidateRep(G, inv_sele, cRepRibbon, cRepInvRep); |
| SceneChanged(G); | | SceneChanged(G); |
|
| if (SettingGetGlobal_b(G, cSetting_line_use_shader)){ | | |
| SceneUpdateObjectMoleculesSingleThread(G); | | |
| } | | |
| } | | } |
| break; | | break; |
| case cSetting_ribbon_use_shader: | | case cSetting_ribbon_use_shader: |
| if (SettingGetGlobal_b(G, cSetting_use_shaders)){ | | if (SettingGetGlobal_b(G, cSetting_use_shaders)){ |
| ExecutiveInvalidateRep(G, inv_sele, cRepRibbon, cRepInvRep); | | ExecutiveInvalidateRep(G, inv_sele, cRepRibbon, cRepInvRep); |
| SceneChanged(G); | | SceneChanged(G); |
| } | | } |
| break; | | break; |
| case cSetting_dot_as_spheres: | | case cSetting_dot_as_spheres: |
| SceneInvalidate(G); | | SceneInvalidate(G); |
| | |
| skipping to change at line 2172 | | skipping to change at line 2226 |
|---|
| break; | | break; |
| case cSetting_render_as_cylinders: | | case cSetting_render_as_cylinders: |
| ExecutiveInvalidateRep(G, inv_sele, cRepCyl, cRepInvRep); | | ExecutiveInvalidateRep(G, inv_sele, cRepCyl, cRepInvRep); |
| case cSetting_mesh_as_cylinders: | | case cSetting_mesh_as_cylinders: |
| case cSetting_line_as_cylinders: | | case cSetting_line_as_cylinders: |
| case cSetting_ribbon_as_cylinders: | | case cSetting_ribbon_as_cylinders: |
| case cSetting_dash_as_cylinders: | | case cSetting_dash_as_cylinders: |
| if (index == cSetting_dash_as_cylinders) { | | if (index == cSetting_dash_as_cylinders) { |
| ExecutiveInvalidateRep(G, inv_sele, cRepAngle, cRepInvRep); | | ExecutiveInvalidateRep(G, inv_sele, cRepAngle, cRepInvRep); |
| ExecutiveInvalidateRep(G, inv_sele, cRepDihedral, cRepInvRep); | | ExecutiveInvalidateRep(G, inv_sele, cRepDihedral, cRepInvRep); |
|
| | ExecutiveInvalidateRep(G, inv_sele, cRepDash, cRepInvRep); |
| } | | } |
| case cSetting_nonbonded_as_cylinders: | | case cSetting_nonbonded_as_cylinders: |
| case cSetting_alignment_as_cylinders: | | case cSetting_alignment_as_cylinders: |
| case cSetting_cartoon_nucleic_acid_as_cylinders: | | case cSetting_cartoon_nucleic_acid_as_cylinders: |
| if (SettingGetGlobal_b(G, cSetting_render_as_cylinders)){ | | if (SettingGetGlobal_b(G, cSetting_render_as_cylinders)){ |
|
| if (!CShaderMgr_ShaderPrgExists(G->ShaderMgr, "cylinder")){ | | if (G->ShaderMgr->shaders_present && !G->ShaderMgr->ShaderPrgExists("cylin
der")){ |
| SettingSet_b(G->Setting, cSetting_render_as_cylinders, 0); | | SettingSet_b(G->Setting, cSetting_render_as_cylinders, 0); |
| if (!quiet){ | | if (!quiet){ |
| PRINTFB(G, FB_Setting, FB_Warnings) | | PRINTFB(G, FB_Setting, FB_Warnings) |
| "Setting-Error: render_as_cylinders cannot be set when the Cylinder S
hader is not available, setting render_as_cylinder back to false\n" | | "Setting-Error: render_as_cylinders cannot be set when the Cylinder S
hader is not available, setting render_as_cylinder back to false\n" |
| ENDFB(G); | | ENDFB(G); |
| } | | } |
| return; | | return; |
| } | | } |
| switch (index){ | | switch (index){ |
| case cSetting_render_as_cylinders: | | case cSetting_render_as_cylinders: |
| | |
| skipping to change at line 2200 | | skipping to change at line 2255 |
|---|
| if (SettingGetGlobal_b(G, cSetting_use_shaders) && SettingGetGlobal_b(G,
cSetting_render_as_cylinders)){ | | if (SettingGetGlobal_b(G, cSetting_use_shaders) && SettingGetGlobal_b(G,
cSetting_render_as_cylinders)){ |
| ExecutiveInvalidateRep(G, inv_sele, cRepCartoon, cRepInvRep); | | ExecutiveInvalidateRep(G, inv_sele, cRepCartoon, cRepInvRep); |
| } | | } |
| } | | } |
| SceneChanged(G); | | SceneChanged(G); |
| } | | } |
| break; | | break; |
| case cSetting_mesh_use_shader: | | case cSetting_mesh_use_shader: |
| if (SettingGetGlobal_b(G, cSetting_use_shaders)){ | | if (SettingGetGlobal_b(G, cSetting_use_shaders)){ |
| SceneChanged(G); | | SceneChanged(G); |
|
| if (SettingGetGlobal_b(G, cSetting_mesh_use_shader)){ | | |
| SceneUpdateObjectMoleculesSingleThread(G); | | |
| } | | |
| } | | } |
| break; | | break; |
| case cSetting_slice_height_scale: | | case cSetting_slice_height_scale: |
| case cSetting_slice_height_map: | | case cSetting_slice_height_map: |
| case cSetting_slice_grid: | | case cSetting_slice_grid: |
| case cSetting_slice_dynamic_grid: | | case cSetting_slice_dynamic_grid: |
| case cSetting_slice_dynamic_grid_resolution: | | case cSetting_slice_dynamic_grid_resolution: |
| ExecutiveInvalidateRep(G, inv_sele, cRepSlice, cRepInvRep); | | ExecutiveInvalidateRep(G, inv_sele, cRepSlice, cRepInvRep); |
| SceneChanged(G); | | SceneChanged(G); |
| break; | | break; |
| | |
| skipping to change at line 2248 | | skipping to change at line 2300 |
|---|
| case cSetting_roving_map2_name: | | case cSetting_roving_map2_name: |
| case cSetting_roving_map3_name: | | case cSetting_roving_map3_name: |
| case cSetting_roving_isosurface: | | case cSetting_roving_isosurface: |
| case cSetting_roving_isomesh: | | case cSetting_roving_isomesh: |
| SceneRovingChanged(G); | | SceneRovingChanged(G); |
| break; | | break; |
| case cSetting_roving_byres: | | case cSetting_roving_byres: |
| case cSetting_roving_detail: | | case cSetting_roving_detail: |
| SceneRovingDirty(G); | | SceneRovingDirty(G); |
| break; | | break; |
|
| | case cSetting_dash_transparency: |
| case cSetting_dash_length: | | case cSetting_dash_length: |
| case cSetting_dash_gap: | | case cSetting_dash_gap: |
| case cSetting_dash_radius: | | case cSetting_dash_radius: |
| case cSetting_dash_width: | | case cSetting_dash_width: |
| case cSetting_angle_size: | | case cSetting_angle_size: |
| case cSetting_label_digits: | | case cSetting_label_digits: |
| case cSetting_label_distance_digits: | | case cSetting_label_distance_digits: |
| case cSetting_label_angle_digits: | | case cSetting_label_angle_digits: |
| case cSetting_label_dihedral_digits: | | case cSetting_label_dihedral_digits: |
| case cSetting_angle_label_position: | | case cSetting_angle_label_position: |
| | |
| skipping to change at line 2297 | | skipping to change at line 2350 |
|---|
| case cSetting_stick_nub: | | case cSetting_stick_nub: |
| case cSetting_stick_ball_ratio: | | case cSetting_stick_ball_ratio: |
| case cSetting_stick_ball_color: | | case cSetting_stick_ball_color: |
| case cSetting_stick_fixed_radius: | | case cSetting_stick_fixed_radius: |
| case cSetting_stick_valence_scale: | | case cSetting_stick_valence_scale: |
| case cSetting_stick_overlap: | | case cSetting_stick_overlap: |
| case cSetting_stick_color: | | case cSetting_stick_color: |
| case cSetting_stick_use_shader: | | case cSetting_stick_use_shader: |
| ExecutiveInvalidateRep(G, inv_sele, cRepCyl, cRepInvRep); | | ExecutiveInvalidateRep(G, inv_sele, cRepCyl, cRepInvRep); |
| SceneChanged(G); | | SceneChanged(G); |
|
| if (SettingGetGlobal_b(G, cSetting_use_shaders)){ | | |
| if (SettingGetGlobal_b(G, cSetting_stick_use_shader)){ | | |
| SceneUpdateObjectMoleculesSingleThread(G); | | |
| } | | |
| } | | |
| break; | | break; |
| case cSetting_clamp_colors: | | case cSetting_clamp_colors: |
| case cSetting_ramp_blend_nearby_colors: | | case cSetting_ramp_blend_nearby_colors: |
| ExecutiveInvalidateRep(G, inv_sele, cRepAll, cRepInvColor); | | ExecutiveInvalidateRep(G, inv_sele, cRepAll, cRepInvColor); |
| SceneChanged(G); | | SceneChanged(G); |
| break; | | break; |
| case cSetting_label_color: | | case cSetting_label_color: |
| case cSetting_label_outline_color: | | case cSetting_label_outline_color: |
| case cSetting_label_position: | | case cSetting_label_position: |
| ExecutiveRebuildAllObjectDist(G); | | ExecutiveRebuildAllObjectDist(G); |
| | |
| skipping to change at line 2325 | | skipping to change at line 2373 |
|---|
| case cSetting_cartoon_color: | | case cSetting_cartoon_color: |
| ExecutiveInvalidateRep(G, inv_sele, cRepCartoon, cRepInvRep); | | ExecutiveInvalidateRep(G, inv_sele, cRepCartoon, cRepInvRep); |
| SceneChanged(G); | | SceneChanged(G); |
| break; | | break; |
| case cSetting_ribbon_color: | | case cSetting_ribbon_color: |
| ExecutiveInvalidateRep(G, inv_sele, cRepRibbon, cRepInvRep); | | ExecutiveInvalidateRep(G, inv_sele, cRepRibbon, cRepInvRep); |
| SceneChanged(G); | | SceneChanged(G); |
| break; | | break; |
| case cSetting_cgo_line_width: | | case cSetting_cgo_line_width: |
| case cSetting_line_width: | | case cSetting_line_width: |
|
| | { |
| | GLfloat *range = G->ShaderMgr->GetLineWidthRange(); |
| | float line_width = SettingGetGlobal_f(G, index); |
| | { |
| | if (line_width <= 0.f){ |
| | PRINTFB(G, FB_Setting, FB_Warnings) |
| | " Setting-Warning: %s is set incorrectly (%f), setting to 1\n", |
| | rec.name, line_width ENDFB(G); |
| | SettingSetGlobal_f(G, index, 1.f); |
| | } else if (G->HaveGUI && range[1] > 0.f && line_width > range[1]) { |
| | PRINTFB(G, FB_Setting, FB_Warnings) |
| | " Setting-Warning: %s is out of range of the graphics card's " |
| | "capability (range: %f-%f), lines might not be rendered correctly\n" |
| | , |
| | rec.name, range[0], range[1] ENDFB(G); |
| | } |
| | } |
| | } |
| case cSetting_line_color: | | case cSetting_line_color: |
| case cSetting_line_radius: | | case cSetting_line_radius: |
| ExecutiveInvalidateRep(G, inv_sele, cRepLine, cRepInvRep); | | ExecutiveInvalidateRep(G, inv_sele, cRepLine, cRepInvRep); |
| ExecutiveInvalidateRep(G, inv_sele, cRepNonbonded, cRepInvRep); | | ExecutiveInvalidateRep(G, inv_sele, cRepNonbonded, cRepInvRep); |
| SceneChanged(G); | | SceneChanged(G); |
| break; | | break; |
| case cSetting_scenes_changed: | | case cSetting_scenes_changed: |
| { | | { |
| int scene_buttons = SettingGetGlobal_i(G, cSetting_scene_buttons); | | int scene_buttons = SettingGetGlobal_i(G, cSetting_scene_buttons); |
| if (scene_buttons) | | if (scene_buttons) |
| | |
| skipping to change at line 2375 | | skipping to change at line 2440 |
|---|
| break; | | break; |
| case cSetting_mesh_color: | | case cSetting_mesh_color: |
| case cSetting_mesh_negative_color: | | case cSetting_mesh_negative_color: |
| ExecutiveInvalidateRep(G, inv_sele, cRepMesh, cRepInvColor); | | ExecutiveInvalidateRep(G, inv_sele, cRepMesh, cRepInvColor); |
| SceneChanged(G); | | SceneChanged(G); |
| break; | | break; |
| case cSetting_ray_color_ramps: | | case cSetting_ray_color_ramps: |
| ExecutiveInvalidateRep(G, inv_sele, cRepAll, cRepInvColor); | | ExecutiveInvalidateRep(G, inv_sele, cRepAll, cRepInvColor); |
| SceneChanged(G); | | SceneChanged(G); |
| break; | | break; |
|
| | | case cSetting_sphere_mode: |
| | ExecutiveInvalidateRep(G, inv_sele, cRepSphere, cRepInvRep); |
| | SceneInvalidate(G); |
| | break; |
| case cSetting_cull_spheres: | | case cSetting_cull_spheres: |
| case cSetting_sphere_scale: | | case cSetting_sphere_scale: |
| case cSetting_sphere_transparency: | | case cSetting_sphere_transparency: |
| case cSetting_sphere_solvent: | | case cSetting_sphere_solvent: |
|
| case cSetting_sphere_mode: | | |
| case cSetting_sphere_point_max_size: | | case cSetting_sphere_point_max_size: |
| case cSetting_sphere_point_size: | | case cSetting_sphere_point_size: |
| case cSetting_sphere_use_shader: | | case cSetting_sphere_use_shader: |
| ExecutiveInvalidateRep(G, inv_sele, cRepSphere, cRepInvRep); | | ExecutiveInvalidateRep(G, inv_sele, cRepSphere, cRepInvRep); |
| SceneInvalidate(G); | | SceneInvalidate(G); |
| break; | | break; |
| case cSetting_sphere_quality: | | case cSetting_sphere_quality: |
| ExecutiveInvalidateRep(G, inv_sele, cRepCyl, cRepInvRep); | | ExecutiveInvalidateRep(G, inv_sele, cRepCyl, cRepInvRep); |
| ExecutiveInvalidateRep(G, inv_sele, cRepNonbondedSphere, cRepInvRep); | | ExecutiveInvalidateRep(G, inv_sele, cRepNonbondedSphere, cRepInvRep); |
| ExecutiveInvalidateRep(G, inv_sele, cRepSphere, cRepInvRep); | | ExecutiveInvalidateRep(G, inv_sele, cRepSphere, cRepInvRep); |
| | |
| skipping to change at line 2461 | | skipping to change at line 2528 |
|---|
| case cSetting_surface_clear_selection: | | case cSetting_surface_clear_selection: |
| case cSetting_surface_trim_cutoff: | | case cSetting_surface_trim_cutoff: |
| case cSetting_surface_trim_factor: | | case cSetting_surface_trim_factor: |
| case cSetting_surface_circumscribe: | | case cSetting_surface_circumscribe: |
| case cSetting_surface_solvent: | | case cSetting_surface_solvent: |
| case cSetting_surface_proximity: | | case cSetting_surface_proximity: |
| case cSetting_surface_cavity_mode: | | case cSetting_surface_cavity_mode: |
| case cSetting_surface_cavity_radius: | | case cSetting_surface_cavity_radius: |
| case cSetting_surface_cavity_cutoff: | | case cSetting_surface_cavity_cutoff: |
| case cSetting_cavity_cull: | | case cSetting_cavity_cull: |
|
| | case cSetting_surface_smooth_edges: |
| ExecutiveInvalidateRep(G, inv_sele, cRepSurface, cRepInvRep); | | ExecutiveInvalidateRep(G, inv_sele, cRepSurface, cRepInvRep); |
| SceneChanged(G); | | SceneChanged(G); |
| break; | | break; |
| case cSetting_surface_use_shader: | | case cSetting_surface_use_shader: |
| SceneChanged(G); | | SceneChanged(G); |
| break; | | break; |
| case cSetting_surface_negative_visible: | | case cSetting_surface_negative_visible: |
| ExecutiveInvalidateRep(G, inv_sele, cRepSurface, cRepInvRep); | | ExecutiveInvalidateRep(G, inv_sele, cRepSurface, cRepInvRep); |
| SceneChanged(G); | | SceneChanged(G); |
| break; | | break; |
| | |
| skipping to change at line 2508 | | skipping to change at line 2576 |
|---|
| case cSetting_draw_mode: | | case cSetting_draw_mode: |
| ExecutiveInvalidateRep(G, inv_sele, cRepCyl, cRepInvRep); | | ExecutiveInvalidateRep(G, inv_sele, cRepCyl, cRepInvRep); |
| ExecutiveInvalidateRep(G, inv_sele, cRepSphere, cRepInvRep); | | ExecutiveInvalidateRep(G, inv_sele, cRepSphere, cRepInvRep); |
| break; | | break; |
| case cSetting_cartoon_side_chain_helper: | | case cSetting_cartoon_side_chain_helper: |
| case cSetting_cartoon_nucleic_acid_mode: | | case cSetting_cartoon_nucleic_acid_mode: |
| ExecutiveInvalidateRep(G, inv_sele, cRepCartoon, cRepInvRep); | | ExecutiveInvalidateRep(G, inv_sele, cRepCartoon, cRepInvRep); |
| ExecutiveInvalidateRep(G, inv_sele, cRepLine, cRepInvRep); | | ExecutiveInvalidateRep(G, inv_sele, cRepLine, cRepInvRep); |
| ExecutiveInvalidateRep(G, inv_sele, cRepCyl, cRepInvRep); | | ExecutiveInvalidateRep(G, inv_sele, cRepCyl, cRepInvRep); |
| ExecutiveInvalidateRep(G, inv_sele, cRepSphere, cRepInvRep); | | ExecutiveInvalidateRep(G, inv_sele, cRepSphere, cRepInvRep); |
|
| | ExecutiveInvalidateRep(G, inv_sele, cRepEllipsoid, cRepInvRep); |
| SceneChanged(G); | | SceneChanged(G); |
| break; | | break; |
| case cSetting_ribbon_side_chain_helper: | | case cSetting_ribbon_side_chain_helper: |
| case cSetting_ribbon_nucleic_acid_mode: | | case cSetting_ribbon_nucleic_acid_mode: |
| ExecutiveInvalidateRep(G, inv_sele, cRepRibbon, cRepInvRep); | | ExecutiveInvalidateRep(G, inv_sele, cRepRibbon, cRepInvRep); |
| ExecutiveInvalidateRep(G, inv_sele, cRepLine, cRepInvRep); | | ExecutiveInvalidateRep(G, inv_sele, cRepLine, cRepInvRep); |
| ExecutiveInvalidateRep(G, inv_sele, cRepCyl, cRepInvRep); | | ExecutiveInvalidateRep(G, inv_sele, cRepCyl, cRepInvRep); |
| ExecutiveInvalidateRep(G, inv_sele, cRepSphere, cRepInvRep); | | ExecutiveInvalidateRep(G, inv_sele, cRepSphere, cRepInvRep); |
|
| | ExecutiveInvalidateRep(G, inv_sele, cRepEllipsoid, cRepInvRep); |
| SceneChanged(G); | | SceneChanged(G); |
| break; | | break; |
|
| | case cSetting_ray_trace_mode: /* affects loop quality */ |
| | G->ShaderMgr->Set_Reload_Bits(RELOAD_VARIABLES); |
| case cSetting_cartoon_transparency: | | case cSetting_cartoon_transparency: |
| case cSetting_cartoon_ring_transparency: | | case cSetting_cartoon_ring_transparency: |
| case cSetting_cartoon_trace_atoms: | | case cSetting_cartoon_trace_atoms: |
| case cSetting_cartoon_refine: | | case cSetting_cartoon_refine: |
| case cSetting_cartoon_nucleic_acid_color: | | case cSetting_cartoon_nucleic_acid_color: |
| case cSetting_cartoon_ring_mode: | | case cSetting_cartoon_ring_mode: |
| case cSetting_cartoon_ring_finder: | | case cSetting_cartoon_ring_finder: |
| case cSetting_cartoon_ring_width: | | case cSetting_cartoon_ring_width: |
| case cSetting_cartoon_ring_color: | | case cSetting_cartoon_ring_color: |
| case cSetting_cartoon_ladder_mode: | | case cSetting_cartoon_ladder_mode: |
| case cSetting_cartoon_ladder_radius: | | case cSetting_cartoon_ladder_radius: |
| case cSetting_cartoon_ladder_color: | | case cSetting_cartoon_ladder_color: |
| case cSetting_cartoon_sampling: | | case cSetting_cartoon_sampling: |
| case cSetting_cartoon_loop_quality: | | case cSetting_cartoon_loop_quality: |
|
| case cSetting_ray_trace_mode: /* affects loop quality */ | | |
| case cSetting_cartoon_loop_radius: | | case cSetting_cartoon_loop_radius: |
| case cSetting_cartoon_loop_cap: | | case cSetting_cartoon_loop_cap: |
| case cSetting_cartoon_tube_quality: | | case cSetting_cartoon_tube_quality: |
| case cSetting_cartoon_tube_radius: | | case cSetting_cartoon_tube_radius: |
| case cSetting_cartoon_tube_cap: | | case cSetting_cartoon_tube_cap: |
| case cSetting_cartoon_putty_quality: | | case cSetting_cartoon_putty_quality: |
| case cSetting_cartoon_putty_radius: | | case cSetting_cartoon_putty_radius: |
| case cSetting_cartoon_putty_range: | | case cSetting_cartoon_putty_range: |
| case cSetting_cartoon_putty_scale_min: | | case cSetting_cartoon_putty_scale_min: |
| case cSetting_cartoon_putty_scale_max: | | case cSetting_cartoon_putty_scale_max: |
| | |
| skipping to change at line 2582 | | skipping to change at line 2653 |
|---|
| case cSetting_cartoon_flat_cycles: | | case cSetting_cartoon_flat_cycles: |
| case cSetting_cartoon_gap_cutoff: | | case cSetting_cartoon_gap_cutoff: |
| case cSetting_cartoon_all_alt: | | case cSetting_cartoon_all_alt: |
| ExecutiveInvalidateRep(G, inv_sele, cRepCartoon, cRepInvRep); | | ExecutiveInvalidateRep(G, inv_sele, cRepCartoon, cRepInvRep); |
| SceneChanged(G); | | SceneChanged(G); |
| break; | | break; |
| case cSetting_cartoon_use_shader: | | case cSetting_cartoon_use_shader: |
| if (SettingGetGlobal_b(G, cSetting_use_shaders)){ | | if (SettingGetGlobal_b(G, cSetting_use_shaders)){ |
| ExecutiveInvalidateRep(G, inv_sele, cRepCartoon, cRepInvRep); | | ExecutiveInvalidateRep(G, inv_sele, cRepCartoon, cRepInvRep); |
| SceneChanged(G); | | SceneChanged(G); |
|
| if (SettingGetGlobal_b(G, cSetting_cartoon_use_shader)){ | | |
| SceneUpdateObjectMoleculesSingleThread(G); | | |
| } | | |
| } | | } |
| break; | | break; |
| case cSetting_cgo_use_shader: | | case cSetting_cgo_use_shader: |
| if (SettingGetGlobal_b(G, cSetting_use_shaders)){ | | if (SettingGetGlobal_b(G, cSetting_use_shaders)){ |
| ExecutiveInvalidateRep(G, inv_sele, cRepCGO, cRepInvRep); | | ExecutiveInvalidateRep(G, inv_sele, cRepCGO, cRepInvRep); |
| SceneChanged(G); | | SceneChanged(G); |
|
| if (SettingGetGlobal_b(G, cSetting_cgo_use_shader)){ | | |
| SceneUpdateObjectMoleculesSingleThread(G); | | |
| } | | |
| } | | } |
| break; | | break; |
| case cSetting_cgo_shader_ub_flags: | | case cSetting_cgo_shader_ub_flags: |
| if (SettingGetGlobal_b(G, cSetting_use_shaders) && SettingGetGlobal_b(G, cSe
tting_cgo_use_shader)){ | | if (SettingGetGlobal_b(G, cSetting_use_shaders) && SettingGetGlobal_b(G, cSe
tting_cgo_use_shader)){ |
| ExecutiveInvalidateRep(G, inv_sele, cRepSphere, cRepInvRep); | | ExecutiveInvalidateRep(G, inv_sele, cRepSphere, cRepInvRep); |
| SceneChanged(G); | | SceneChanged(G); |
|
| SceneUpdateObjectMoleculesSingleThread(G); | | |
| } | | } |
| break; | | break; |
| case cSetting_cgo_shader_ub_color: | | case cSetting_cgo_shader_ub_color: |
| if (SettingGetGlobal_b(G, cSetting_use_shaders) && SettingGetGlobal_b(G, cSe
tting_cgo_use_shader)){ | | if (SettingGetGlobal_b(G, cSetting_use_shaders) && SettingGetGlobal_b(G, cSe
tting_cgo_use_shader)){ |
| ExecutiveInvalidateRep(G, inv_sele, cRepCGO, cRepInvRep); | | ExecutiveInvalidateRep(G, inv_sele, cRepCGO, cRepInvRep); |
| ExecutiveInvalidateRep(G, inv_sele, cRepCartoon, cRepInvRep); | | ExecutiveInvalidateRep(G, inv_sele, cRepCartoon, cRepInvRep); |
| ExecutiveInvalidateRep(G, inv_sele, cRepSphere, cRepInvRep); | | ExecutiveInvalidateRep(G, inv_sele, cRepSphere, cRepInvRep); |
| SceneChanged(G); | | SceneChanged(G); |
|
| SceneUpdateObjectMoleculesSingleThread(G); | | |
| } | | } |
| break; | | break; |
| case cSetting_cgo_shader_ub_normal: | | case cSetting_cgo_shader_ub_normal: |
| if (SettingGetGlobal_b(G, cSetting_use_shaders) && SettingGetGlobal_b(G, cSe
tting_cgo_use_shader)){ | | if (SettingGetGlobal_b(G, cSetting_use_shaders) && SettingGetGlobal_b(G, cSe
tting_cgo_use_shader)){ |
| ExecutiveInvalidateRep(G, inv_sele, cRepCGO, cRepInvRep); | | ExecutiveInvalidateRep(G, inv_sele, cRepCGO, cRepInvRep); |
| ExecutiveInvalidateRep(G, inv_sele, cRepCartoon, cRepInvRep); | | ExecutiveInvalidateRep(G, inv_sele, cRepCartoon, cRepInvRep); |
|
| | // if spheres rendered with geometry, then normals are used |
| | // this should really only invalidate spheres that use normals (sphere_mod |
| | e=0, not sure about other modes) |
| | // but invalidating all spheres for now |
| | ExecutiveInvalidateRep(G, inv_sele, cRepSphere, cRepInvRep); |
| SceneChanged(G); | | SceneChanged(G); |
|
| SceneUpdateObjectMoleculesSingleThread(G); | | |
| } | | } |
| break; | | break; |
|
| | case cSetting_trilines: |
| | ExecutiveInvalidateRep(G, inv_sele, cRepLine, cRepInvRep); |
| | ExecutiveInvalidateRep(G, inv_sele, cRepCyl, cRepInvRep); |
| | ExecutiveInvalidateRep(G, inv_sele, cRepRibbon, cRepInvRep); |
| | ExecutiveInvalidateRep(G, inv_sele, cRepCartoon, cRepInvRep); |
| | ExecutiveInvalidateRep(G, inv_sele, cRepDash, cRepInvRep); |
| | ExecutiveInvalidateRep(G, inv_sele, cRepNonbonded, cRepInvRep); |
| | SceneChanged(G); |
| | break; |
| case cSetting_dot_width: | | case cSetting_dot_width: |
| case cSetting_dot_radius: | | case cSetting_dot_radius: |
| case cSetting_dot_density: | | case cSetting_dot_density: |
| case cSetting_dot_mode: | | case cSetting_dot_mode: |
| case cSetting_dot_solvent: | | case cSetting_dot_solvent: |
| case cSetting_dot_hydrogens: | | case cSetting_dot_hydrogens: |
| case cSetting_trim_dots: | | case cSetting_trim_dots: |
| ExecutiveInvalidateRep(G, inv_sele, cRepDot, cRepInvRep); | | ExecutiveInvalidateRep(G, inv_sele, cRepDot, cRepInvRep); |
| SceneChanged(G); | | SceneChanged(G); |
| break; | | break; |
| case cSetting_bg_gradient: | | case cSetting_bg_gradient: |
|
| if (SettingGetGlobal_b(G, cSetting_bg_gradient)){ | | |
| ColorUpdateFrontFromSettings(G); | | ColorUpdateFrontFromSettings(G); |
| ExecutiveInvalidateRep(G, inv_sele, cRepAll, cRepInvColor); | | ExecutiveInvalidateRep(G, inv_sele, cRepAll, cRepInvColor); |
|
| } | | G->ShaderMgr->Set_Reload_Bits(RELOAD_VARIABLES); |
| CShaderMgr_Set_Reload_Bits(G, RELOAD_SHADERS_UPDATE_FOR_BACKGROUND); | | SceneChanged(G); |
| | break; |
| | case cSetting_bg_image_mode: |
| | case cSetting_bg_image_filename: |
| | G->ShaderMgr->Set_Reload_Bits(RELOAD_VARIABLES); |
| | case cSetting_bg_image_linear: |
| | case cSetting_bg_image_tilesize: |
| | OrthoBackgroundTextureNeedsUpdate(G); |
| SceneChanged(G); | | SceneChanged(G); |
| break; | | break; |
| case cSetting_bg_rgb_top: | | case cSetting_bg_rgb_top: |
| case cSetting_bg_rgb_bottom: | | case cSetting_bg_rgb_bottom: |
| { | | { |
| /* clamp this value */ | | /* clamp this value */ |
|
| if( | | const char * bg_image_filename = SettingGet_s(G, NULL, NULL, cSetting_bg_i |
| | mage_filename); |
| | if(!(bg_image_filename && bg_image_filename[0]) && |
| SettingGetGlobal_b(G, cSetting_bg_gradient) && !OrthoBackgroundDataIsS
et(G)) { | | SettingGetGlobal_b(G, cSetting_bg_gradient) && !OrthoBackgroundDataIsS
et(G)) { |
| ColorUpdateFrontFromSettings(G); | | ColorUpdateFrontFromSettings(G); |
| ExecutiveInvalidateRep(G, inv_sele, cRepAll, cRepInvColor); | | ExecutiveInvalidateRep(G, inv_sele, cRepAll, cRepInvColor); |
| OrthoBackgroundTextureNeedsUpdate(G); | | OrthoBackgroundTextureNeedsUpdate(G); |
| } | | } |
| } | | } |
| SceneChanged(G); | | SceneChanged(G); |
| break; | | break; |
| case cSetting_bg_rgb: | | case cSetting_bg_rgb: |
| { | | { |
| /* clamp this value */ | | /* clamp this value */ |
|
| float *v = ColorGet(G, SettingGet_color(G, NULL, NULL, cSetting_bg_rgb)); | | const float *v = ColorGet(G, SettingGet_color(G, NULL, NULL, cSetting_bg_r
gb)); |
| { | | { |
|
| if(!OrthoBackgroundDataIsSet(G)) { | | const char * bg_image_filename = SettingGet_s(G, NULL, NULL, cSetting_bg |
| | _image_filename); |
| | if(!(bg_image_filename && bg_image_filename[0]) && !OrthoBackgroundDataI |
| | sSet(G)) { |
| ColorUpdateFront(G, v); | | ColorUpdateFront(G, v); |
| ExecutiveInvalidateRep(G, inv_sele, cRepAll, cRepInvColor); | | ExecutiveInvalidateRep(G, inv_sele, cRepAll, cRepInvColor); |
| } | | } |
| } | | } |
| } | | } |
| SceneChanged(G); | | SceneChanged(G); |
| break; | | break; |
| case cSetting_selection_width: | | case cSetting_selection_width: |
| case cSetting_selection_width_scale: | | case cSetting_selection_width_scale: |
| case cSetting_selection_width_max: | | case cSetting_selection_width_max: |
|
| | case cSetting_selection_round_points: |
| ExecutiveInvalidateSelectionIndicatorsCGO(G); | | ExecutiveInvalidateSelectionIndicatorsCGO(G); |
| case cSetting_line_smooth: | | case cSetting_line_smooth: |
| case cSetting_ortho: | | case cSetting_ortho: |
|
| CShaderMgr_Set_Reload_Bits(G, RELOAD_ALL_SHADERS); | | case cSetting_chromadepth: |
| case cSetting_reflect: | | case cSetting_transparency_mode: |
| case cSetting_direct: | | if (index == cSetting_transparency_mode) |
| case cSetting_ambient: | | #ifdef _WEBGL |
| case cSetting_specular: | | #endif |
| case cSetting_specular_intensity: | | ExecutiveInvalidateRep(G, inv_sele, cRepCGO, cRepInvAll); |
| SceneInvalidate(G); | | |
| break; | | |
| case cSetting_depth_cue: | | case cSetting_depth_cue: |
|
| | case cSetting_fog: |
| | case cSetting_ray_transparency_oblique: |
| | G->ShaderMgr->Set_Reload_Bits(RELOAD_VARIABLES); |
| | case cSetting_ray_transparency_oblique_power: |
| SceneInvalidate(G); | | SceneInvalidate(G); |
| break; | | break; |
| case cSetting_sculpting: | | case cSetting_sculpting: |
| OrthoDirty(G); | | OrthoDirty(G); |
| break; | | break; |
| case cSetting_auto_overlay: | | case cSetting_auto_overlay: |
| OrthoRemoveAutoOverlay(G); /* always start clean */ | | OrthoRemoveAutoOverlay(G); /* always start clean */ |
| break; | | break; |
| case cSetting_overlay: | | case cSetting_overlay: |
| case cSetting_overlay_lines: | | case cSetting_overlay_lines: |
| | |
| skipping to change at line 2716 | | skipping to change at line 2802 |
|---|
| OrthoDirty(G); | | OrthoDirty(G); |
| } | | } |
| break; | | break; |
| case cSetting_security: | | case cSetting_security: |
| G->Security = SettingGetGlobal_i(G, cSetting_security); | | G->Security = SettingGetGlobal_i(G, cSetting_security); |
| break; | | break; |
| case cSetting_all_states: | | case cSetting_all_states: |
| case cSetting_state: | | case cSetting_state: |
| case cSetting_frame: | | case cSetting_frame: |
| ExecutiveInvalidateSelectionIndicatorsCGO(G); | | ExecutiveInvalidateSelectionIndicatorsCGO(G); |
|
| | SceneInvalidatePicking(G); |
| SceneChanged(G); | | SceneChanged(G); |
| break; | | break; |
| case cSetting_dynamic_width: | | case cSetting_dynamic_width: |
| case cSetting_dynamic_width_factor: | | case cSetting_dynamic_width_factor: |
| case cSetting_dynamic_width_min: | | case cSetting_dynamic_width_min: |
| case cSetting_dynamic_width_max: | | case cSetting_dynamic_width_max: |
| SceneChanged(G); | | SceneChanged(G); |
| break; | | break; |
| case cSetting_rock: | | case cSetting_rock: |
| case cSetting_sweep_mode: | | case cSetting_sweep_mode: |
| | |
| skipping to change at line 2753 | | skipping to change at line 2840 |
|---|
| SceneInvalidate(G); | | SceneInvalidate(G); |
| break; | | break; |
| case cSetting_volume_layers: | | case cSetting_volume_layers: |
| ExecutiveInvalidateRep(G, inv_sele, cRepVolume, cRepInvColor); | | ExecutiveInvalidateRep(G, inv_sele, cRepVolume, cRepInvColor); |
| SceneInvalidate(G); | | SceneInvalidate(G); |
| break; | | break; |
| case cSetting_cgo_transparency: | | case cSetting_cgo_transparency: |
| SceneInvalidate(G); | | SceneInvalidate(G); |
| SceneChanged(G); | | SceneChanged(G); |
| break; | | break; |
|
| | case cSetting_label_connector_mode: |
| | { |
| | int lc_mode = SettingGetGlobal_i(G, cSetting_label_connector_mode); |
| | if(lc_mode < 0 || lc_mode > 4){ |
| | if (!quiet){ |
| | PRINTFB(G, FB_Setting, FB_Warnings) |
| | "Setting-Warning: label_connector_mode range = [0,4]" |
| | ENDFB(G); |
| | } |
| | } |
| | } |
| | case cSetting_float_labels: |
| | case cSetting_label_z_target: |
| | case cSetting_label_connector: |
| | case cSetting_label_connector_color: |
| | case cSetting_label_connector_width: |
| | case cSetting_label_connector_ext_length: |
| | case cSetting_label_bg_color: |
| | case cSetting_label_placement_offset: |
| | case cSetting_label_relative_mode: |
| | case cSetting_label_screen_point: |
| | case cSetting_label_multiline_spacing: |
| | case cSetting_label_multiline_justification: |
| | case cSetting_label_padding: |
| | case cSetting_label_bg_transparency: |
| | case cSetting_label_bg_outline: |
| | case cSetting_ray_label_connector_flat: |
| | ExecutiveInvalidateRep(G, inv_sele, cRepLabel, cRepInvAll ); |
| | break; |
| case cSetting_surface_color_smoothing: | | case cSetting_surface_color_smoothing: |
| case cSetting_surface_color_smoothing_threshold: | | case cSetting_surface_color_smoothing_threshold: |
| ExecutiveInvalidateRep(G, inv_sele, cRepSurface, cRepInvColor); | | ExecutiveInvalidateRep(G, inv_sele, cRepSurface, cRepInvColor); |
| SceneChanged(G); | | SceneChanged(G); |
| break; | | break; |
| case cSetting_smooth_half_bonds: | | case cSetting_smooth_half_bonds: |
| SceneChanged(G); | | SceneChanged(G); |
| break; | | break; |
|
| case cSetting_selection_round_points: | | |
| ExecutiveInvalidateSelectionIndicatorsCGO(G); | | |
| break; | | |
| case cSetting_antialias_shader: | | case cSetting_antialias_shader: |
| case cSetting_atom_type_format: | | case cSetting_atom_type_format: |
|
| case cSetting_bg_image_mode: | | |
| case cSetting_bg_image_filename: | | |
| case cSetting_bg_image_linear: | | |
| case cSetting_bg_image_tilesize: | | |
| case cSetting_chromadepth: | | |
| case cSetting_colored_feedback: | | case cSetting_colored_feedback: |
|
| case cSetting_dash_transparency: | | |
| case cSetting_label_bg_color: | | |
| case cSetting_label_bg_outline: | | |
| case cSetting_label_bg_transparency: | | |
| case cSetting_label_connector: | | |
| case cSetting_label_connector_color: | | |
| case cSetting_label_connector_ext_length: | | |
| case cSetting_label_connector_mode: | | |
| case cSetting_label_connector_width: | | |
| case cSetting_label_multiline_justification: | | |
| case cSetting_label_multiline_spacing: | | |
| case cSetting_label_padding: | | |
| case cSetting_label_placement_offset: | | |
| case cSetting_label_relative_mode: | | |
| case cSetting_label_screen_point: | | |
| case cSetting_label_z_target: | | |
| case cSetting_load_atom_props_default: | | case cSetting_load_atom_props_default: |
| case cSetting_load_object_props_default: | | case cSetting_load_object_props_default: |
|
| case cSetting_pick_labels: | | |
| case cSetting_precomputed_lighting: | | |
| case cSetting_ray_label_connector_flat: | | |
| case cSetting_session_embeds_data: | | |
| case cSetting_shaders_from_disk: | | |
| case cSetting_suspend_undo: | | case cSetting_suspend_undo: |
|
| case cSetting_use_geometry_shaders: | | |
| case cSetting_volume_mode: | | case cSetting_volume_mode: |
|
| case cSetting_surface_smooth_edges: | | |
| PRINTFB(G, FB_Setting, FB_Warnings) | | PRINTFB(G, FB_Setting, FB_Warnings) |
| " Setting-Warning: %s is not supported in Open-Source version of PyMOL\n", | | " Setting-Warning: %s is not supported in Open-Source version of PyMOL\n", |
| SettingInfo[index].name | | SettingInfo[index].name |
| ENDFB(G); | | ENDFB(G); |
| break; | | break; |
|
| | break; |
| | case cSetting_surface_debug: |
| | if (SettingGetGlobal_b(G, cSetting_use_shaders)){ |
| | ExecutiveInvalidateRep(G, inv_sele, cRepSurface, cRepInvColor); |
| | } |
| | break; |
| | case cSetting_pick32bit: |
| | ExecutiveInvalidateRep(G, NULL, cRepAll, cRepInvRep); |
| | SceneChanged(G); |
| | break; |
| case cSetting_display_scale_factor: | | case cSetting_display_scale_factor: |
| { | | { |
| int scaleFactor = SettingGetGlobal_i(G, cSetting_display_scale_factor); | | int scaleFactor = SettingGetGlobal_i(G, cSetting_display_scale_factor); |
| if (scaleFactor > 0) { | | if (scaleFactor > 0) { |
| _gScaleFactor = scaleFactor; | | _gScaleFactor = scaleFactor; |
| ExecutiveInvalidateRep(G, NULL, cRepLabel, cRepInvRep); | | ExecutiveInvalidateRep(G, NULL, cRepLabel, cRepInvRep); |
| OrthoCommandIn(G, "viewport"); | | OrthoCommandIn(G, "viewport"); |
| } else { | | } else { |
| SettingSetGlobal_i(G, cSetting_display_scale_factor, 1); | | SettingSetGlobal_i(G, cSetting_display_scale_factor, 1); |
| PRINTFB(G, FB_Setting, FB_Warnings) | | PRINTFB(G, FB_Setting, FB_Warnings) |
| | |
| skipping to change at line 2889 | | skipping to change at line 2984 |
|---|
| set_b(I, cSetting_presentation_auto_quit, !G->Option->no_quit); | | set_b(I, cSetting_presentation_auto_quit, !G->Option->no_quit); |
| set_b(I, cSetting_auto_show_spheres, G->Option->sphere_mode >= 0); | | set_b(I, cSetting_auto_show_spheres, G->Option->sphere_mode >= 0); |
| set_i(I, cSetting_internal_feedback, G->Option->internal_feedback); | | set_i(I, cSetting_internal_feedback, G->Option->internal_feedback); |
| | |
| if(G->Option->stereo_mode) { | | if(G->Option->stereo_mode) { |
| set_i(I, cSetting_stereo_mode, G->Option->stereo_mode); | | set_i(I, cSetting_stereo_mode, G->Option->stereo_mode); |
| } else if(G->StereoCapable || G->Option->blue_line) { | | } else if(G->StereoCapable || G->Option->blue_line) { |
| set_i(I, cSetting_stereo_mode, cStereo_quadbuffer); /* quadbuffer if
we can */ | | set_i(I, cSetting_stereo_mode, cStereo_quadbuffer); /* quadbuffer if
we can */ |
| } | | } |
| | |
|
| | if(G->Option->retina) { |
| | _gScaleFactor = 2; |
| | set_i(I, cSetting_display_scale_factor, _gScaleFactor); |
| | } |
| | |
| /* In order to get electrostatic potentials in kT from the Coulomb equation.
.. | | /* In order to get electrostatic potentials in kT from the Coulomb equation.
.. |
| | |
| PyMOL charges: Q, in e | | PyMOL charges: Q, in e |
| PyMOL distances: r, in Angstrom | | PyMOL distances: r, in Angstrom |
| Coulomb Constant: K = 8.987552e9 ((J*m)/(C^2)) | | Coulomb Constant: K = 8.987552e9 ((J*m)/(C^2)) |
| Angstrom Convertor: 1 A = 1e-10 m | | Angstrom Convertor: 1 A = 1e-10 m |
| Coulomb Convertor: 1 e = 1.60217733e-19 C | | Coulomb Convertor: 1 e = 1.60217733e-19 C |
| Angstrom Convertor: 1 A = 10e-10 m | | Angstrom Convertor: 1 A = 10e-10 m |
| Dielectric Constant: D (unitless) | | Dielectric Constant: D (unitless) |
| | |
| | |
| skipping to change at line 2949 | | skipping to change at line 3049 |
|---|
| #endif | | #endif |
| #endif | | #endif |
| | |
| #ifndef _PYMOL_FREETYPE | | #ifndef _PYMOL_FREETYPE |
| set_i(I, cSetting_label_font_id, 0); | | set_i(I, cSetting_label_font_id, 0); |
| #endif | | #endif |
| | |
| #ifdef _PYMOL_IOS | | #ifdef _PYMOL_IOS |
| #endif | | #endif |
| } | | } |
|
| CShaderMgr_Set_Reload_Bits(G, RELOAD_ALL_SHADERS); | | G->ShaderMgr->Set_Reload_Bits(RELOAD_ALL_SHADERS); |
| | } |
| | |
| | int SettingCheckFontID(PyMOLGlobals * G, CSetting * set1, CSetting * set2, int f |
| | ont_id){ |
| | int ret = font_id; |
| | if (font_id < 5){ // we are no longer supporting GLUT labels since they are n |
| | ot resizeable |
| | PRINTFB(G, FB_Setting, FB_Warnings) |
| | "RepLabel-Warning: GLUT labels (label_font_id 0-4) are no longer available |
| | for labelling\n the scene since they are not resizeable label_font_id=%d set |
| | ting back to 5 (default) \n", |
| | font_id ENDFB(G); |
| | if (SettingGet_i(G, set1, NULL, cSetting_label_font_id) == font_id && Settin |
| | gSet_i(set1, cSetting_label_font_id, 5)){ |
| | } else if (SettingGet_i(G, set2, NULL, cSetting_label_font_id) == font_id && |
| | SettingSet_i(set2, cSetting_label_font_id, 5)){ |
| | } else if (SettingGetGlobal_i(G, cSetting_label_font_id) == font_id){ |
| | SettingSetGlobal_i(G, cSetting_label_font_id, 5); |
| | }; |
| | ret = 5; |
| | } |
| | return ret; |
| } | | } |
| | |
| /* | | /* |
| * State index iterator constructor, see Setting.h for documentation. | | * State index iterator constructor, see Setting.h for documentation. |
| */ | | */ |
| StateIterator::StateIterator(PyMOLGlobals * G, CSetting * set, int state_, int n
state) { | | StateIterator::StateIterator(PyMOLGlobals * G, CSetting * set, int state_, int n
state) { |
| if(state_ == -2) { | | if(state_ == -2) { |
| // current state | | // current state |
| state_ = SettingGet_i(G, set, NULL, cSetting_state) - 1; | | state_ = SettingGet_i(G, set, NULL, cSetting_state) - 1; |
| } | | } |
| | | |
| End of changes. 62 change blocks. |
|---|
| 111 lines changed or deleted | | 242 lines changed or added |
|---|
"Fossies" - the Fresh Open Source Software Archive 