void WZMOpenGLWidget::setModel(MODEL *model)
{
double dimension;
if (!model)
{
return;
}
prepareModel(model);
gl_errors();
psModel = model;
// Calculate best z offset
for (int i = 0; i < psModel->meshes; i++)
{
MESH *psMesh = &psModel->mesh[i];
for (int j = 0; j < psMesh->vertices * 3; j++)
{
dimension = MAX(fabs(psMesh->vertexArray[j]), dimension);
}
}
setSceneRadius(dimension);
showEntireScene();
timer.start();
}
UIGChooser::UIGChooser(QWidget *pParent)
: QWidget(pParent)
, m_pMainLayout(0)
, m_pChooserModel(0)
, m_pChooserView(0)
, m_pStatusBar(0)
{
/* Prepare palette: */
preparePalette();
/* Prepare layout: */
prepareLayout();
/* Prepare model: */
prepareModel();
/* Prepare view: */
prepareView();
/* Prepare connections: */
prepareConnections();
/* Load: */
load();
}
void CTLCheck::check(Vars &v, Model &m, Formula &f, BitStore *bs,
bool printFormulas, bool showProgress)
{
#undef pt
#define pt(a) //pr(a)
f_ = f;
model_ = &m;
vars_ = &v;
sfAlias_.clear();
stateFlags_.clear();
sfOrder_.clear();
pvWarn_.clear();
showProgress_ = showProgress;
if (bs)
bs->clear();
ASSERT(f_.isCTL());
prepareModel();
if (model().defined()) {
// reduce formula to minimal set of connectives
f_.reduce();
pt(("CTLCheck, checking formula\n %s\n==> %s\n",f.s(),f_.s()));
extractSubformulas();
for (int i = 0; i < sfOrder_.length(); i++)
processFormula(sfOrder_[i]);
if (printFormulas) {
for (int i = 0; i < model().states(); i++) {
int name = model().stateName(i);
Cout << "State #" << name << ":\n";
for (int j = 0; j < sfOrder_.length(); j++) {
int form = sfOrder_[j];
if (getFlag(i,form)) {
Cout << " ";
f_.print(form,false);
Cout << "\n";
}
}
Cout << "\n";
}
}
if (bs) {
int satFormula = sfOrder_.last();
for (int i = 0; i < model().states(); i++)
if (getFlag(i,satFormula))
bs->set(i);
pt((" satisfying states: %s\n",bs->s() ));
}
}
}
void Input::clear()
{
if (!dataModel()) return;
dataModel()->inputs().clear();
prepareModel();
showParameterWidget();
emit inputIndexChanged();
}
void DialogProtocolImpl::setModel(QSqlTableModel *m) {
prepareModel(m);
mapper->addMapping(leName, model->fieldIndex("name"));
mapper->addMapping(leExec, model->fieldIndex("programm"));
mapper->addMapping(sbPort, model->fieldIndex("port"));
mapper->addMapping(cbTerm, model->fieldIndex("term"));
mapper->addMapping(leCmdLine, model->fieldIndex("cmdline"));
}
void KeysStoreDialog::onInputCommit(const Glib::ustring key) {
// Add key to list store
if(key == "")
return;
Glib::RefPtr<Gtk::TreeModel> model = treeView->get_model();
Glib::RefPtr<Gtk::ListStore> listStore = Glib::RefPtr<Gtk::ListStore>::cast_static(model);
Gtk::TreeModel::Row row = *(listStore->append());
row.set_value<Glib::ustring>(0, key);
signal_changed(prepareModel());
}
void Planner::plan() {
int closestSite;
if (! updateDistances(closestSite))
return; // unable to update distances
prepareModel();
if (mdp == NULL)
return; // no action to plan yet
int horizon = computePlan(MAX_PLAN_LENGTH); // max 10 actions long ?
//publishPlan(horizon); // plan was already published if ok
delete(mdp); mdp = NULL;
}
void KeysStoreDialog::onBtnRemoveClick() {
bool changed = false;
Glib::RefPtr<Gtk::TreeModel> model = treeView->get_model();
Glib::RefPtr<Gtk::ListStore> listStore = Glib::RefPtr<Gtk::ListStore>::cast_static(model);
Glib::RefPtr<Gtk::TreeSelection> sel = treeView->get_selection();
std::vector<Gtk::TreeModel::Path> pathlist = sel->get_selected_rows();
for(int i = pathlist.size() - 1; i >= 0 ; i--) {
Gtk::TreeModel::iterator iter = treeView->get_model()->get_iter(pathlist[i]);
Gtk::TreeModel::Row row = *iter;
listStore->erase(iter);
changed = true;
}
// Emit signal if any change appear
if(changed)
signal_changed(prepareModel());
}
UIGRuntimeInformation::UIGRuntimeInformation(QWidget *pParent)
: QWidget(pParent)
, m_pMainLayout(0)
, m_pDetailsModel(0)
, m_pDetailsView(0)
{
/* Prepare palette: */
preparePalette();
/* Prepare layout: */
prepareLayout();
/* Prepare model: */
prepareModel();
/* Prepare view: */
prepareView();
/* Prepare connections: */
prepareConnections();
}
void DialogVarImpl::setModel(QSqlTableModel *m) {
prepareModel(m);
mapper->addMapping(leName, model->fieldIndex("name"));
mapper->addMapping(leValue, model->fieldIndex("val"));
}
int main(int argc, char **argv)
{
MODEL *psModel;
const int width = 640, height = 480;
SDL_Event event;
GLfloat angle = 0.0f;
const float aspect = (float)width / (float)height;
bool quit = false;
float dimension = 0.0f;
int i;
char path[PATH_MAX];
parse_args(argc, argv);
/* Initialize SDL */
if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_TIMER) < 0)
{
fprintf(stderr, "Couldn't initialize SDL: %s\n", SDL_GetError());
exit(EXIT_FAILURE);
}
atexit(SDL_Quit);
psModel = readModel(input, SDL_GetTicks());
strcpy(path, texPath);
strcat(path, psModel->texPath);
psModel->pixmap = readPixmap(path);
SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
/* Initialize the display */
screen = SDL_SetVideoMode(width, height, 0, SDL_OPENGL|SDL_ANYFORMAT);
if (screen == NULL)
{
fprintf(stderr, "Couldn't initialize display: %s\n", SDL_GetError());
exit(EXIT_FAILURE);
}
printf("OpenGL version: %s\n", glGetString(GL_VERSION));
printf("OpenGL renderer: %s\n", glGetString(GL_RENDERER));
printf("OpenGL vendor: %s\n", glGetString(GL_VENDOR));
resizeWindow(width, height);
glEnable(GL_TEXTURE_2D);
glDisable(GL_FOG);
glDisable(GL_LIGHTING);
glEnable(GL_BLEND);
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LEQUAL);
glClearDepth(1.0f);
glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(45.0f, aspect, 0.1f, 500.0f);
glMatrixMode(GL_MODELVIEW);
prepareModel(psModel);
for (i = 0; i < psModel->meshes; i++)
{
int j;
MESH *psMesh = &psModel->mesh[i];
for (j = 0; j < psMesh->vertices * 3; j++)
{
dimension = MAX(fabs(psMesh->vertexArray[j]), dimension);
}
}
/* Find model size */
while (!quit)
{
now = SDL_GetTicks();
while (SDL_PollEvent(&event))
{
SDL_keysym *keysym = &event.key.keysym;
switch (event.type)
{
case SDL_VIDEORESIZE:
resizeWindow(event.resize.w, event.resize.h);
break;
case SDL_QUIT:
quit = true;
break;
case SDL_KEYDOWN:
switch (keysym->sym)
{
case SDLK_F1:
glEnable(GL_CULL_FACE);
printf("Culling enabled.\n");
break;
case SDLK_F2:
glDisable(GL_CULL_FACE);
printf("Culling disabled.\n");
break;
case SDLK_F3:
glDisable(GL_TEXTURE_2D);
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
printf("Wireframe mode.\n");
break;
case SDLK_F4:
glEnable(GL_TEXTURE_2D);
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
printf("Texturing mode.\n");
break;
case SDLK_ESCAPE:
quit = true;
break;
case SDLK_KP_PLUS:
case SDLK_PLUS:
for (i = 0; i < psModel->meshes; i++)
{
MESH *psMesh = &psModel->mesh[i];
if (!psMesh->teamColours)
{
continue;
}
if (psMesh->currentTextureArray < 7)
{
psMesh->currentTextureArray++;
}
else
{
psMesh->currentTextureArray = 0;
}
}
break;
default:
break;
}
break;
}
}
glLoadIdentity();
glTranslatef(0.0f, -30.0f, -50.0f + -(dimension * 2.0f));;
glRotatef(angle, 0, 1, 0);
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
drawModel(psModel, now);
SDL_GL_SwapBuffers();
SDL_Delay(10);
angle += 0.1;
if (angle > 360.0f)
{
angle = 0.0f;
}
}
glDisableClientState(GL_VERTEX_ARRAY);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
freeModel(psModel);
return 0;
}
