Improving box of controls speed (C++-CLI WinForms) - c++-cli

Question

I've made a control in c++ to allow the user to select a position in an irregular box with different positions, some of them blocked, some of them filled, with this characteristics:
Can create multiple columns in multiple rows (not the same, so it can have the first row with 3 columns, the second with 1 and the third with 5)
Different states each position: blocked, filled, empty, selected (so it can have some of them at the same time: blocked & empty, blocked & filled, empty & selected)
The user can select one or multiple position
It has tooltip texts and different background images for each filled or empty position.
Contextual menu to add/delete rows/columns.
Row and Column headers, numeric/alphanumeric, ascending/descending.
The structure of the control is Container->(nRows x RowClass) and RowClass->(nCols x ColumnClass). Each column contains a TableLayoutPanel so I can simulate the stuck and raised effects.
Loocking different topics on the web, I found some ideas and the improvements I've done for the speed are basically SuspendDrawing with SendMessage (to create and resize all the rows and columns before painting them), double buffering each control and adding a BeginEdit/EndEdit method to the Container that SuspendDrawing and blocks row and column resizing while creating rows and columns (and the same for each RowClass).
It works not so bad with relative small boxes, lets say 20 rows x 20 columns, but when it has 40 rows x 30 columns (1.200 TableLayoutPanel's) it is going really slow even in a fast computer.
I also tried with one TableLayoutPanel (with the required number of columns) per RowClass, but the problem is how to draw borders in order to select each column separatedly, tooltips and background image for each cell.
So, the question: is there any improvements I can try?
I've been thinking that strategy games like warcraft or similar they have good speed on screen with thousands of graphics and calculations, but I'm not a professional programmer so I don't know wich could be the technology and if it is the right way..
Maybe it could be something like an image with a row of images, or something different than a class of classes of classes, but I have no idea...
Probably it is a design problem so, any idea on how would you create a fast control with those specifications will be great.
Thanks anyway for reading my question, any comments will be wellcome!
Miguel

Answer 1

There is no clean fix for this, you will have to give up on TLP. A control is a much too expensive object, any form that has more than a hundred of them is going to suck mud.
First look at the built-in control types that support a grid-like display. ListView with View = Details for non-editable grids, DataGridView for editable ones. If that doesn't fit your bill then you'll have to make your own. Key things you'll need to implement is the OnPaint() method to draw the visual appearance of the control and OnMouseDown or OnClick to do hit-testing and implement behavior.

Answer 2

Videogames offload the graphical representations atleast on the GPU (which are built for just that purpose). I do not think the representation of the boxes is the bottleneck, rather the calculations/steps to get there.
Either post your code / a snippet of your code or explain your use of algorithms, because a bad algorithm will make your program very slow when input increases -- have a look on Computational Complexity, something brought up by algorithm courses.
http://en.wikipedia.org/wiki/Computational_complexity_theory

Answer 3

Here is a part of the code (the whole code is really huge) where some calculations are done..
In ControlClass::
void BeginEdit(int nFilas) {
if (!_editando) {
if (_muestraBarraProgreso) {
this->BarraProgreso->Value = 0;
this->BarraProgreso->Visible = true;
}
_editando = true;
_lastEdit = nFilas;
this->Cursor = Cursors::WaitCursor;
this->Refresh();
SendMessageClass::SuspendDrawing();
}
};
/// <summary>Provoca se realicen los cambios visuales no realizados desde que se
/// llamó a BeginEdit, como this->Controls.Add(...), Ajustar los tamaños de los controles, ...</summary>
void EndEdit(void) {
if (_editando) {
int f;
_editando = false;
AjustaHeaders();
AjustaTamaños(); //Provoca el ajuste de las filas sin ajustar las columnas
//Esto lo hago para minimizar el número de AjustaTamaños()
for (f=_lastEdit; f<_nFilas; f++)
_fila[f]->EndEdit(false); //Provoca el ajuste de las columnas
this->MuestraBarraProgreso = false;
this->Cursor = Cursors::Default;
SendMessageClass::ResumeDrawing();
}
};
void AjustaTamaños(void) {
if (!_editando && _nFilas>0) {
int topOffset = 0, leftOffset = 0, bottomOffset = 0;
if (_showColumnHeaders) topOffset = this->tlpColumnHeaders->Height;
if (_showRowHeaders) leftOffset = this->tlpRowHeaders->Width;
if (_muestraEstado) bottomOffset = this->EstadoRecipiente->Height;
int hOffset = leftOffset + 2;
int vOffset = topOffset + bottomOffset + 2;
int i, j = 0, stp;
if (_varsCom->ordenFilas == TipoOrdenFilas::Descendiente) {
j = 0; stp = 1;
}
else {
j = _nFilas-1; stp = -1;
}
for (i=0; i<_nFilas; i++) {
_fila[j]->Left = hOffset;
_fila[j]->Width = this->Width - hOffset;
_fila[j]->Top = (_nFilas - 1 - i) * (this->Height - vOffset) / _nFilas + topOffset;
_fila[j]->Height = (this->Height - vOffset) / _nFilas;
j+=stp;
}
}
};
in FilaClass:
/// <summary>Provoca que no se realicen los cambios visuales hasta que se llame EndEdit</summary>
void BeginEdit(void) {
if (!_editando) {
_editando = true;
_lastEdit = _nColumnas;
SendMessageClass::SuspendDrawing();
}
};
/// <summary>Provoca se realicen los cambios visuales no realizados desde que se
/// llamó a BeginEdit, como this->Controls.Add(...), Ajustar los tamaños de los controles, ...</summary>
void EndEdit(bool resumirDrawing) {
if (_editando) {
_editando = false;
AjustaTamaños();
for (int c=_lastEdit; c<_nColumnas;c++)
_columna[c]->EndEdit(resumirDrawing);
if (resumirDrawing) SendMessageClass::ResumeDrawing();
}
};
void AjustaTamaños(void) {
if (!_editando) {
int j, stp;
if (_varsCom->ordenColumnas == TipoOrdenColumnas::IzquierdaDerecha) {
j = 0; stp = 1;
}
else {
j = _nColumnas-1; stp = -1;
}
for (int i=0; i<_nColumnas; i++) {
_columna[j]->Width = this->Width / _nColumnas;
_columna[j]->Left = i * this->Width / _nColumnas;
_columna[j]->Top = 0;
_columna[j]->Height = this->Height;
j+=stp;
}
}
};
in ColumnaClass:
void BeginEdit(void) {
_editando = true;
SendMessageClass::SuspendDrawing();
};
void EndEdit(bool resumirDrawing) {
if (_editando) {
_editando = false;
_CambiaEstado = _estado;
if (resumirDrawing) SendMessageClass::ResumeDrawing();
}
};
internal:
/// <summary>Obtiene o establece el estado de la posición sin activar el evento ColumnaChange</summary>
property EstadoColumna _CambiaEstado {
EstadoColumna get() { return _estado; }
void set(EstadoColumna value) {
_estado = value;
if ( (_varsCom->bloquearLlenas && ((value & EstadoColumna::llena) == EstadoColumna::llena)) ||
(_varsCom->bloquearVacias && ((value & EstadoColumna::llena) != EstadoColumna::llena)) ) {
if ((_estado & EstadoColumna::seleccionada) == EstadoColumna::seleccionada)
_estado = (EstadoColumna) (_estado ^ EstadoColumna::seleccionada);
_estado = (EstadoColumna) (_estado | EstadoColumna::bloqueada);
}
else {
if ((_estado & EstadoColumna::bloqueada) == EstadoColumna::bloqueada)
_estado = (EstadoColumna) (_estado | EstadoColumna::bloqueada);
}
if (!_editando) {
ActualizaEstado();
ActualizaToolTip();
}
}
};
/// <summary>Actualiza la visualización de la posición leyendo de nuevo los parámetros</summary>
void ActualizaEstado(void) {
if (!_editando && _varsCom->estilo) {
this->ColumnaCtl->BackColor = _varsCom->estilo->GetEstilo[(int) _estado]->colorFondo;
this->ColumnaCtl->CellBorderStyle = _varsCom->estilo->GetEstilo[(int) _estado]->bordeCelda;
this->ColumnaCtl->BackgroundImageLayout = _varsCom->imageLayout;
if (this->Estado[EstadoColumna::llena])
this->ColumnaCtl->BackgroundImage = _varsCom->imagenLlena;
else if (this->Estado[EstadoColumna::vacia])
this->ColumnaCtl->BackgroundImage = _varsCom->imagenVacia;
}
};
/// <summary>Actualiza los textos del ToolTipText de la posición</summary>
void ActualizaToolTip(void) {
if (!_editando && _varsCom->etiquetas) {
String^ sTmp = "";
int __tmp__ = 0;
if (_varsCom->tipoHeaderFilas == TipoHeader::Numerica)
sTmp = _varsCom->etiquetas->Fila + ": " + _nombreFila;
else if (System::Int32::TryParse(_nombreFila, __tmp__))
sTmp = _varsCom->etiquetas->Fila + ": " + gcnew String((wchar_t) ('A' + __tmp__ - 1), 1);
else
sTmp = _varsCom->etiquetas->Fila + ": " + _nombreFila;
if (_varsCom->tipoHeaderColumnas == TipoHeader::Numerica)
sTmp += ", " + _varsCom->etiquetas->Columna + ": " + _posicion + "\n";
else
sTmp += ", " + _varsCom->etiquetas->Columna + ": " + gcnew String((wchar_t) ('A' + _posicion - 1), 1) + "\n";
if (_nombre != "") {
if ((_estado & EstadoColumna::llena) == EstadoColumna::llena)
sTmp += _varsCom->etiquetas->Posicion + ": " + _nombre + "\n";
else
sTmp += _varsCom->etiquetas->PosicionVacia + ": " + _nombre + "\n";
}
if ((_estado & EstadoColumna::llena) == EstadoColumna::llena) sTmp += "Ocupada, ";
else sTmp += "Vacía, ";
if ((_estado & EstadoColumna::seleccionada) != EstadoColumna::vacia) sTmp += "Seleccionada";
else sTmp += "Sin seleccionar";
this->ToolTip1->ShowAlways = false;
this->ToolTip1->SetToolTip(this->ColumnaCtl, sTmp);
this->ToolTip1->ShowAlways = true;
}
};
I think those are most part of the calculations..
A little bit uncommented, and in spanish, but any help will be really useful!
Thanks anyway!