334 lines
9.5 KiB
C++
334 lines
9.5 KiB
C++
/*
|
|
Copyright (C) 1999-2006 Id Software, Inc. and contributors.
|
|
For a list of contributors, see the accompanying CONTRIBUTORS file.
|
|
|
|
This file is part of GtkRadiant.
|
|
|
|
GtkRadiant is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation; either version 2 of the License, or
|
|
(at your option) any later version.
|
|
|
|
GtkRadiant is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with GtkRadiant; if not, write to the Free Software
|
|
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
|
*/
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
// DESCRIPTION:
|
|
// classes used for describing geometry information from q3map feedback
|
|
//
|
|
|
|
#include "feedback.h"
|
|
|
|
#include <gtk/gtk.h>
|
|
|
|
#include "debugging/debugging.h"
|
|
|
|
#include "igl.h"
|
|
#include "iselection.h"
|
|
|
|
#include "map.h"
|
|
#include "dialog.h"
|
|
#include "mainframe.h"
|
|
|
|
|
|
CDbgDlg g_DbgDlg;
|
|
|
|
void Feedback_draw2D(VIEWTYPE viewType)
|
|
{
|
|
g_DbgDlg.draw2D(viewType);
|
|
}
|
|
|
|
void CSelectMsg::saxStartElement(message_info_t *ctx, const xmlChar *name, const xmlChar **attrs)
|
|
{
|
|
if (string_equal(reinterpret_cast<const char *>( name ), "select")) {
|
|
// read the message
|
|
ESelectState = SELECT_MESSAGE;
|
|
} else {
|
|
// read the brush
|
|
ASSERT_MESSAGE(string_equal(reinterpret_cast<const char *>( name ), "brush"), "FEEDBACK PARSE ERROR");
|
|
ASSERT_MESSAGE(ESelectState == SELECT_MESSAGE, "FEEDBACK PARSE ERROR");
|
|
ESelectState = SELECT_BRUSH;
|
|
globalOutputStream() << message.c_str() << '\n';
|
|
}
|
|
}
|
|
|
|
void CSelectMsg::saxEndElement(message_info_t *ctx, const xmlChar *name)
|
|
{
|
|
if (string_equal(reinterpret_cast<const char *>( name ), "select")) {
|
|
}
|
|
}
|
|
|
|
void CSelectMsg::saxCharacters(message_info_t *ctx, const xmlChar *ch, int len)
|
|
{
|
|
if (ESelectState == SELECT_MESSAGE) {
|
|
message.write(reinterpret_cast<const char *>( ch ), len);
|
|
} else {
|
|
brush.write(reinterpret_cast<const char *>( ch ), len);
|
|
}
|
|
}
|
|
|
|
IGL2DWindow *CSelectMsg::Highlight()
|
|
{
|
|
GlobalSelectionSystem().setSelectedAll(false);
|
|
int entitynum, brushnum;
|
|
if (sscanf(reinterpret_cast<const char *>( brush.c_str()), "%i %i", &entitynum, &brushnum) == 2) {
|
|
SelectBrush(entitynum, brushnum);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
void CPointMsg::saxStartElement(message_info_t *ctx, const xmlChar *name, const xmlChar **attrs)
|
|
{
|
|
if (string_equal(reinterpret_cast<const char *>( name ), "pointmsg")) {
|
|
// read the message
|
|
EPointState = POINT_MESSAGE;
|
|
} else {
|
|
// read the brush
|
|
ASSERT_MESSAGE(string_equal(reinterpret_cast<const char *>( name ), "point"), "FEEDBACK PARSE ERROR");
|
|
ASSERT_MESSAGE(EPointState == POINT_MESSAGE, "FEEDBACK PARSE ERROR");
|
|
EPointState = POINT_POINT;
|
|
globalOutputStream() << message.c_str() << '\n';
|
|
}
|
|
}
|
|
|
|
void CPointMsg::saxEndElement(message_info_t *ctx, const xmlChar *name)
|
|
{
|
|
if (string_equal(reinterpret_cast<const char *>( name ), "pointmsg")) {
|
|
} else if (string_equal(reinterpret_cast<const char *>( name ), "point")) {
|
|
sscanf(point.c_str(), "%g %g %g", &(pt[0]), &(pt[1]), &(pt[2]));
|
|
point.clear();
|
|
}
|
|
}
|
|
|
|
void CPointMsg::saxCharacters(message_info_t *ctx, const xmlChar *ch, int len)
|
|
{
|
|
if (EPointState == POINT_MESSAGE) {
|
|
message.write(reinterpret_cast<const char *>( ch ), len);
|
|
} else {
|
|
ASSERT_MESSAGE(EPointState == POINT_POINT, "FEEDBACK PARSE ERROR");
|
|
point.write(reinterpret_cast<const char *>( ch ), len);
|
|
}
|
|
}
|
|
|
|
IGL2DWindow *CPointMsg::Highlight()
|
|
{
|
|
return this;
|
|
}
|
|
|
|
void CPointMsg::DropHighlight()
|
|
{
|
|
}
|
|
|
|
void CPointMsg::Draw2D(VIEWTYPE vt)
|
|
{
|
|
int nDim1 = (vt == YZ) ? 1 : 0;
|
|
int nDim2 = (vt == XY) ? 1 : 2;
|
|
glPointSize(4);
|
|
glColor3f(1.0f, 0.0f, 0.0f);
|
|
glBegin(GL_POINTS);
|
|
glVertex2f(pt[nDim1], pt[nDim2]);
|
|
glEnd();
|
|
glBegin(GL_LINE_LOOP);
|
|
glVertex2f(pt[nDim1] - 8, pt[nDim2] - 8);
|
|
glVertex2f(pt[nDim1] + 8, pt[nDim2] - 8);
|
|
glVertex2f(pt[nDim1] + 8, pt[nDim2] + 8);
|
|
glVertex2f(pt[nDim1] - 8, pt[nDim2] + 8);
|
|
glEnd();
|
|
}
|
|
|
|
void CWindingMsg::saxStartElement(message_info_t *ctx, const xmlChar *name, const xmlChar **attrs)
|
|
{
|
|
if (string_equal(reinterpret_cast<const char *>( name ), "windingmsg")) {
|
|
// read the message
|
|
EPointState = WINDING_MESSAGE;
|
|
} else {
|
|
// read the brush
|
|
ASSERT_MESSAGE(string_equal(reinterpret_cast<const char *>( name ), "winding"), "FEEDBACK PARSE ERROR");
|
|
ASSERT_MESSAGE(EPointState == WINDING_MESSAGE, "FEEDBACK PARSE ERROR");
|
|
EPointState = WINDING_WINDING;
|
|
globalOutputStream() << message.c_str() << '\n';
|
|
}
|
|
}
|
|
|
|
void CWindingMsg::saxEndElement(message_info_t *ctx, const xmlChar *name)
|
|
{
|
|
if (string_equal(reinterpret_cast<const char *>( name ), "windingmsg")) {
|
|
} else if (string_equal(reinterpret_cast<const char *>( name ), "winding")) {
|
|
const char *c = winding.c_str();
|
|
sscanf(c, "%i ", &numpoints);
|
|
|
|
int i = 0;
|
|
for (; i < numpoints; i++) {
|
|
c = strchr(c + 1, '(');
|
|
if (c) { // even if we are given the number of points when the cycle begins .. don't trust it too much
|
|
sscanf(c, "(%g %g %g)", &wt[i][0], &wt[i][1], &wt[i][2]);
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
numpoints = i;
|
|
}
|
|
}
|
|
|
|
void CWindingMsg::saxCharacters(message_info_t *ctx, const xmlChar *ch, int len)
|
|
{
|
|
if (EPointState == WINDING_MESSAGE) {
|
|
message.write(reinterpret_cast<const char *>( ch ), len);
|
|
} else {
|
|
ASSERT_MESSAGE(EPointState == WINDING_WINDING, "FEEDBACK PARSE ERROR");
|
|
winding.write(reinterpret_cast<const char *>( ch ), len);
|
|
}
|
|
}
|
|
|
|
IGL2DWindow *CWindingMsg::Highlight()
|
|
{
|
|
return this;
|
|
}
|
|
|
|
void CWindingMsg::DropHighlight()
|
|
{
|
|
}
|
|
|
|
void CWindingMsg::Draw2D(VIEWTYPE vt)
|
|
{
|
|
int i;
|
|
|
|
int nDim1 = (vt == YZ) ? 1 : 0;
|
|
int nDim2 = (vt == XY) ? 1 : 2;
|
|
glColor3f(1.0f, 0.f, 0.0f);
|
|
|
|
glPointSize(4);
|
|
glBegin(GL_POINTS);
|
|
for (i = 0; i < numpoints; i++)
|
|
glVertex2f(wt[i][nDim1], wt[i][nDim2]);
|
|
glEnd();
|
|
glPointSize(1);
|
|
|
|
glEnable(GL_BLEND);
|
|
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
|
|
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
|
|
glColor4f(0.133f, 0.4f, 1.0f, 0.5f);
|
|
glBegin(GL_POLYGON);
|
|
for (i = 0; i < numpoints; i++)
|
|
glVertex2f(wt[i][nDim1], wt[i][nDim2]);
|
|
glEnd();
|
|
glDisable(GL_BLEND);
|
|
}
|
|
|
|
// triggered when the user selects an entry in the feedback box
|
|
static void feedback_selection_changed(ui::TreeSelection selection, gpointer data)
|
|
{
|
|
g_DbgDlg.DropHighlight();
|
|
|
|
GtkTreeModel *model;
|
|
GtkTreeIter selected;
|
|
if (gtk_tree_selection_get_selected(selection, &model, &selected)) {
|
|
auto path = gtk_tree_model_get_path(model, &selected);
|
|
g_DbgDlg.SetHighlight(gtk_tree_path_get_indices(path)[0]);
|
|
gtk_tree_path_free(path);
|
|
}
|
|
}
|
|
|
|
void CDbgDlg::DropHighlight()
|
|
{
|
|
if (m_pHighlight != 0) {
|
|
m_pHighlight->DropHighlight();
|
|
m_pHighlight = 0;
|
|
m_pDraw2D = 0;
|
|
}
|
|
}
|
|
|
|
void CDbgDlg::SetHighlight(gint row)
|
|
{
|
|
ISAXHandler *h = GetElement(row);
|
|
if (h != NULL) {
|
|
m_pDraw2D = h->Highlight();
|
|
m_pHighlight = h;
|
|
}
|
|
}
|
|
|
|
ISAXHandler *CDbgDlg::GetElement(std::size_t row)
|
|
{
|
|
return static_cast<ISAXHandler *>(g_ptr_array_index(m_pFeedbackElements, gint( row )) );
|
|
}
|
|
|
|
void CDbgDlg::Init()
|
|
{
|
|
DropHighlight();
|
|
|
|
// free all the ISAXHandler*, clean it
|
|
while (m_pFeedbackElements->len) {
|
|
static_cast<ISAXHandler *>(g_ptr_array_index(m_pFeedbackElements, 0) )->Release();
|
|
g_ptr_array_remove_index(m_pFeedbackElements, 0);
|
|
}
|
|
|
|
if (m_clist) {
|
|
m_clist.clear();
|
|
}
|
|
}
|
|
|
|
void CDbgDlg::Push(ISAXHandler *pHandler)
|
|
{
|
|
// push in the list
|
|
g_ptr_array_add(m_pFeedbackElements, (void *) pHandler);
|
|
|
|
if (!GetWidget()) {
|
|
Create();
|
|
}
|
|
|
|
// put stuff in the list
|
|
m_clist.clear();
|
|
for (std::size_t i = 0; i < static_cast<std::size_t>( m_pFeedbackElements->len ); ++i) {
|
|
m_clist.append(0, GetElement(i)->getName());
|
|
}
|
|
|
|
ShowDlg();
|
|
}
|
|
|
|
ui::Window CDbgDlg::BuildDialog()
|
|
{
|
|
auto window = MainFrame_getWindow().create_floating_window("Q3Map debug window");
|
|
|
|
auto scr = ui::ScrolledWindow(ui::New);
|
|
scr.show();
|
|
window.add(scr);
|
|
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scr), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
|
|
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scr), GTK_SHADOW_IN);
|
|
|
|
{
|
|
ui::ListStore store = ui::ListStore::from(gtk_list_store_new(1, G_TYPE_STRING));
|
|
|
|
auto view = ui::TreeView(ui::TreeModel::from(store._handle));
|
|
gtk_tree_view_set_headers_visible(view, FALSE);
|
|
|
|
{
|
|
auto renderer = ui::CellRendererText(ui::New);
|
|
auto column = ui::TreeViewColumn("", renderer, {{"text", 0}});
|
|
gtk_tree_view_append_column(view, column);
|
|
}
|
|
|
|
{
|
|
auto selection = ui::TreeSelection::from(gtk_tree_view_get_selection(view));
|
|
gtk_tree_selection_set_mode(selection, GTK_SELECTION_BROWSE);
|
|
selection.connect("changed", G_CALLBACK(feedback_selection_changed), NULL);
|
|
}
|
|
|
|
view.show();
|
|
|
|
scr.add(view);
|
|
|
|
store.unref();
|
|
|
|
m_clist = store;
|
|
}
|
|
|
|
return window;
|
|
}
|