luke
/
klayout
mirror of https://github.com/KLayout/klayout.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
klayout/src/laybasic/layBrowseInstancesForm.cc

903 lines
25 KiB
C++
Raw Blame History

/*
KLayout Layout Viewer
Copyright (C) 2006-2017 Matthias Koefferlein
This program 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.
This program 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 this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include <vector>
#include <string>
#include <QTreeWidgetItem>
#include <QKeyEvent>
#include "layBrowseInstancesForm.h"
#include "layConfigurationDialog.h"
#include "layCellSelectionForm.h"
#include "dbCellGraphUtils.h"
#include "tlException.h"
#include "tlString.h"
#include "tlAlgorithm.h"
#include "layMarker.h"
#include "layQtTools.h"
#include "tlExceptions.h"
namespace lay
{
// ------------------------------------------------------------
// Declaration of the configuration options
const std::string cfg_cib_context_cell ("cib-context-cell");
const std::string cfg_cib_context_mode ("cib-context-mode");
const std::string cfg_cib_window_state ("cib-window-state");
const std::string cfg_cib_window_mode ("cib-window-mode");
const std::string cfg_cib_window_dim ("cib-window-dim");
const std::string cfg_cib_max_inst_count ("cib-max-inst-count");
class BrowseInstancesPluginDeclaration
: public lay::PluginDeclaration
{
public:
virtual void get_options (std::vector < std::pair<std::string, std::string> > &options) const
{
options.push_back (std::pair<std::string, std::string> (cfg_cib_context_cell, ""));
options.push_back (std::pair<std::string, std::string> (cfg_cib_context_mode, "any-top"));
options.push_back (std::pair<std::string, std::string> (cfg_cib_window_mode, "fit-marker"));
options.push_back (std::pair<std::string, std::string> (cfg_cib_window_state, ""));
options.push_back (std::pair<std::string, std::string> (cfg_cib_window_dim, "1.0"));
options.push_back (std::pair<std::string, std::string> (cfg_cib_max_inst_count, "1000"));
}
virtual lay::ConfigPage *config_page (QWidget *parent, std::string &title) const
{
title = tl::to_string (QObject::tr ("Browsers|Cell Instance Browser"));
return new BrowseInstancesConfigPage (parent);
}
virtual void get_menu_entries (std::vector<lay::MenuEntry> &menu_entries) const
{
lay::PluginDeclaration::get_menu_entries (menu_entries);
menu_entries.push_back (lay::MenuEntry ("browse_instances::show", "browse_instances", "tools_menu.end", tl::to_string (QObject::tr ("Browse Instances"))));
}
virtual lay::Plugin *create_plugin (db::Manager *, lay::PluginRoot *root, lay::LayoutView *view) const
{
return new BrowseInstancesForm (root, view);
}
};
static tl::RegisteredClass<lay::PluginDeclaration> config_decl (new BrowseInstancesPluginDeclaration (), 11000, "BrowseInstancesPlugin");
// ------------------------------------------------------------
static struct {
BrowseInstancesForm::mode_type mode;
const char *string;
} context_modes [] = {
{ BrowseInstancesForm::AnyTop, "any-top" },
{ BrowseInstancesForm::Parent, "parent" },
{ BrowseInstancesForm::ToCellView, "given-cell" }
};
class BrowseInstancesContextModeConverter
{
public:
void
from_string (const std::string &value, BrowseInstancesForm::mode_type &mode)
{
for (unsigned int i = 0; i < sizeof (context_modes) / sizeof (context_modes [0]); ++i) {
if (value == context_modes [i].string) {
mode = context_modes [i].mode;
return;
}
}
throw tl::Exception (tl::to_string (QObject::tr ("Invalid cell browser context mode: ")) + value);
}
std::string
to_string (BrowseInstancesForm::mode_type mode)
{
for (unsigned int i = 0; i < sizeof (context_modes) / sizeof (context_modes [0]); ++i) {
if (mode == context_modes [i].mode) {
return context_modes [i].string;
}
}
return "";
}
};
static struct {
BrowseInstancesForm::window_type mode;
const char *string;
} window_modes [] = {
{ BrowseInstancesForm::DontChange, "dont-change" },
{ BrowseInstancesForm::FitCell, "fit-cell" },
{ BrowseInstancesForm::FitMarker, "fit-marker" },
{ BrowseInstancesForm::Center, "center" },
{ BrowseInstancesForm::CenterSize, "center-size" }
};
class BrowseInstancesWindowModeConverter
{
public:
void
from_string (const std::string &value, BrowseInstancesForm::window_type &mode)
{
for (unsigned int i = 0; i < sizeof (window_modes) / sizeof (window_modes [0]); ++i) {
if (value == window_modes [i].string) {
mode = window_modes [i].mode;
return;
}
}
throw tl::Exception (tl::to_string (QObject::tr ("Invalid cell browser window mode: ")) + value);
}
std::string
to_string (BrowseInstancesForm::window_type mode)
{
for (unsigned int i = 0; i < sizeof (window_modes) / sizeof (window_modes [0]); ++i) {
if (mode == window_modes [i].mode) {
return window_modes [i].string;
}
}
return "";
}
};
// ------------------------------------------------------------
BrowseInstancesConfigPage::BrowseInstancesConfigPage (QWidget *parent)
: lay::ConfigPage (parent)
{
Ui::BrowseInstancesConfigPage::setupUi (this);
connect (cbx_context, SIGNAL (currentIndexChanged (int)), this, SLOT (context_changed (int)));
connect (cbx_window, SIGNAL (currentIndexChanged (int)), this, SLOT (window_changed (int)));
}
void
BrowseInstancesConfigPage::setup (lay::PluginRoot *root)
{
std::string value;
// context cell
root->config_get (cfg_cib_context_cell, value);
le_cell_name->setText (tl::to_qstring (value));
// context mode
BrowseInstancesForm::mode_type cmode = BrowseInstancesForm::AnyTop;
root->config_get (cfg_cib_context_mode, cmode, BrowseInstancesContextModeConverter ());
cbx_context->setCurrentIndex (int (cmode));
// window mode
BrowseInstancesForm::window_type wmode = BrowseInstancesForm::FitMarker;
root->config_get (cfg_cib_window_mode, wmode, BrowseInstancesWindowModeConverter ());
cbx_window->setCurrentIndex (int (wmode));
// window dimension
double wdim = 1.0;
root->config_get (cfg_cib_window_dim, wdim);
le_window->setText (tl::to_qstring (tl::to_string (wdim)));
// max. instance count
unsigned int max_inst_count = 1000;
root->config_get (cfg_cib_max_inst_count, max_inst_count);
le_max_count->setText (tl::to_qstring (tl::to_string (max_inst_count)));
// enable controls
context_changed (int (cmode));
window_changed (int (wmode));
}
void
BrowseInstancesConfigPage::context_changed (int m)
{
le_cell_name->setEnabled (m == int (BrowseInstancesForm::ToCellView));
}
void
BrowseInstancesConfigPage::window_changed (int m)
{
le_window->setEnabled (m == int (BrowseInstancesForm::FitMarker) || m == int (BrowseInstancesForm::CenterSize));
}
void
BrowseInstancesConfigPage::commit (lay::PluginRoot *root)
{
double dim = 1.0;
tl::from_string (tl::to_string (le_window->text ()), dim);
unsigned int max_inst_count = 1000;
tl::from_string (tl::to_string (le_max_count->text ()), max_inst_count);
root->config_set (cfg_cib_context_cell, tl::to_string (le_cell_name->text ()));
root->config_set (cfg_cib_context_mode, BrowseInstancesForm::mode_type (cbx_context->currentIndex ()), BrowseInstancesContextModeConverter ());
root->config_set (cfg_cib_window_mode, BrowseInstancesForm::window_type (cbx_window->currentIndex ()), BrowseInstancesWindowModeConverter ());
root->config_set (cfg_cib_window_dim, dim);
root->config_set (cfg_cib_max_inst_count, max_inst_count);
}
// ------------------------------------------------------------
class BrowseInstancesFormCellLVI : public QTreeWidgetItem
{
public:
BrowseInstancesFormCellLVI (const std::string &cn, lay::CellView::cell_index_type index)
: QTreeWidgetItem (),
m_index (index)
{
setText (0, tl::to_qstring (cn));
}
lay::CellView::cell_index_type index () const
{
return m_index;
}
private:
lay::CellView::cell_index_type m_index;
};
// ------------------------------------------------------------
class BrowseInstancesFormCellInstanceLVI : public QTreeWidgetItem
{
public:
BrowseInstancesFormCellInstanceLVI (const std::string &text, const std::string &path,
const db::ICplxTrans &trans, lay::CellView::cell_index_type index)
: QTreeWidgetItem (),
m_trans (trans), m_index (index)
{
setText (0, tl::to_qstring (text));
setText (1, tl::to_qstring (path));
}
const db::ICplxTrans &trans () const
{
return m_trans;
}
lay::CellView::cell_index_type index () const
{
return m_index;
}
private:
db::ICplxTrans m_trans;
lay::CellView::cell_index_type m_index;
};
// ------------------------------------------------------------
BrowseInstancesForm::BrowseInstancesForm (lay::PluginRoot *root, lay::LayoutView *vw)
: lay::Browser (root, vw),
Ui::BrowseInstancesForm (),
m_cv_index (0),
m_cell_index (0),
m_cell_changed_enabled (true),
m_view_changed (false),
m_cell_inst_changed_enabled (true),
m_ef_enabled (true),
m_mode (AnyTop),
m_window (FitMarker),
m_window_dim (0.0),
m_max_inst_count (0),
m_current_count (0)
{
Ui::BrowseInstancesForm::setupUi (this);
lv_cell_instance->installEventFilter (this);
lv_cell_instance->setSortingEnabled (false);
lv_cell_instance->setSelectionMode (QTreeWidget::ExtendedSelection);
lv_cell_instance->setUniformRowHeights (true);
// signals and slots connections
connect (lv_cell, SIGNAL (currentItemChanged(QTreeWidgetItem*, QTreeWidgetItem*)), this, SLOT (cell_changed(QTreeWidgetItem*, QTreeWidgetItem*)));
connect (lv_cell_instance, SIGNAL (itemSelectionChanged()), this, SLOT (cell_inst_changed()));
connect (pb_next_cell, SIGNAL (clicked()), this, SLOT (next_cell()));
connect (pb_prev_cell, SIGNAL (clicked()), this, SLOT (prev_cell()));
connect (pb_next_inst, SIGNAL (clicked()), this, SLOT (next_inst()));
connect (pb_prev_inst, SIGNAL (clicked()), this, SLOT (prev_inst()));
connect (configureButton, SIGNAL (clicked ()), this, SLOT (configure ()));
connect (chooseCellButton, SIGNAL (clicked ()), this, SLOT (choose_cell_pressed ()));
}
void
BrowseInstancesForm::menu_activated (const std::string &symbol)
{
if (symbol == "browse_instances::show") {
view ()->deactivate_all_browsers ();
activate ();
} else {
lay::Browser::menu_activated (symbol);
}
}
void
BrowseInstancesForm::configure ()
{
lay::ConfigurationDialog config_dialog (this, root (), "BrowseInstancesPlugin");
config_dialog.exec ();
}
BrowseInstancesForm::~BrowseInstancesForm ()
{
remove_marker ();
}
void
BrowseInstancesForm::choose_cell_pressed ()
{
BEGIN_PROTECTED
CellSelectionForm form (this, view (), "browse_cell", true /*simple mode*/);
if (form.exec ()) {
change_cell (form.selected_cellview ().cell_index (), form.selected_cellview_index ());
}
END_PROTECTED
}
bool
BrowseInstancesForm::configure (const std::string &name, const std::string &value)
{
bool need_update = false;
bool taken = true;
if (name == cfg_cib_context_cell) {
need_update = lay::test_and_set (m_context_cell, value);
} else if (name == cfg_cib_window_state) {
lay::restore_dialog_state (this, value);
} else if (name == cfg_cib_context_mode) {
mode_type mode = m_mode;
BrowseInstancesContextModeConverter ().from_string (value, mode);
need_update = lay::test_and_set (m_mode, mode);
} else if (name == cfg_cib_window_mode) {
window_type window = m_window;
BrowseInstancesWindowModeConverter ().from_string (value, window);
need_update = lay::test_and_set (m_window, window);
} else if (name == cfg_cib_window_dim) {
double wdim = m_window_dim;
tl::from_string (value, wdim);
if (fabs (wdim - m_window_dim) > 1e-6) {
m_window_dim = wdim;
need_update = true;
}
} else if (name == cfg_cib_max_inst_count) {
unsigned int mic = m_max_inst_count;
tl::from_string (value, mic);
need_update = lay::test_and_set (m_max_inst_count, mic);
} else {
taken = false;
}
if (need_update && active () && lv_cell->currentItem ()) {
if (m_mode == ToCellView) {
m_context_cv.set_cell (m_context_cell);
}
cell_changed (lv_cell->currentItem (), 0);
}
return taken;
}
void
BrowseInstancesForm::remove_marker ()
{
for (std::vector<lay::Marker *>::const_iterator m = mp_markers.begin (); m != mp_markers.end (); ++m) {
delete *m;
}
mp_markers.clear ();
}
void
BrowseInstancesForm::cell_changed (QTreeWidgetItem *item, QTreeWidgetItem *)
{
lv_cell_instance->clear ();
if (! m_cell_changed_enabled) {
return;
}
std::vector <const db::Cell *> parents;
const db::Layout &layout = m_context_cv->layout ();
const db::Cell &cell = layout.cell (m_cell_index);
BrowseInstancesFormCellLVI *it = dynamic_cast <BrowseInstancesFormCellLVI *> (item);
if (! it) {
// "All item" - fetch the parents of all other items
for (QList<QTreeWidgetItem *>::const_iterator i = m_items.begin (); i != m_items.end (); ++i) {
BrowseInstancesFormCellLVI *it = dynamic_cast <BrowseInstancesFormCellLVI *> (*i);
if (it) {
parents.push_back (& layout.cell (it->index ()));
}
}
} else {
parents.push_back (& layout.cell (it->index ()));
}
m_cell_inst_changed_enabled = false;
m_current_count = 0;
QList<QTreeWidgetItem *> items;
bool shortened = false;
for (std::vector <const db::Cell *>::const_iterator parent = parents.begin (); parent != parents.end () && ! shortened; ++parent) {
if (m_mode == AnyTop) {
shortened = fill_cell_instances (db::ICplxTrans (), layout, *parent, &cell, 0, false, std::string (), items);
} else if (m_mode == ToCellView) {
if (m_context_cv.is_valid ()) {
shortened = fill_cell_instances (db::ICplxTrans (), layout, *parent, &cell, m_context_cv.cell (), false, std::string (), items);
}
} else if (m_mode == Parent) {
shortened = fill_cell_instances (db::ICplxTrans (), layout, *parent, &cell, 0, true, std::string (), items);
}
}
// add an entry to indicate that there are more ..
if (shortened) {
items.append (new QTreeWidgetItem ());
items.back ()->setText (0, tl::to_qstring ("..."));
}
lv_cell_instance->addTopLevelItems (items);
if (lv_cell_instance->topLevelItemCount () > 0) {
QTreeWidgetItem *item = lv_cell_instance->topLevelItem (0);
lv_cell_instance->setItemSelected (item, true);
lv_cell_instance->setCurrentItem (item);
lv_cell_instance->scrollToItem (item);
}
m_cell_inst_changed_enabled = true;
highlight_current ();
}
void
BrowseInstancesForm::cell_inst_changed ()
{
if (m_cell_inst_changed_enabled) {
highlight_current ();
}
}
// A helper structure to hold all information relevant to the cells to
// show
struct BrowseInstancesCellInfo
{
BrowseInstancesCellInfo (const std::string &n, lay::CellView::cell_index_type i)
: name (n), cell_index (i), count (0), count_flat (0)
{
// ..
}
bool operator< (const BrowseInstancesCellInfo &d) const
{
return name < d.name;
}
std::string name;
lay::CellView::cell_index_type cell_index;
size_t count, count_flat;
};
void
BrowseInstancesForm::activated ()
{
view ()->save_view (m_display_state);
// if no cellviews are available, don't do anything
if (! view ()->cellviews ()) {
return;
}
// obtain active cellview index and cell index
int cv_index = view ()->active_cellview_index ();
lay::LayoutView::cell_path_type path;
view ()->current_cell_path (path);
// no cell to index
if (path.empty ()) {
return;
}
change_cell (path.back (), cv_index);
}
void
BrowseInstancesForm::change_cell (db::cell_index_type cell_index, int cv_index)
{
// obtain active cellview index and cell index
m_cv_index = cv_index;
m_context_cv = view ()->cellview (m_cv_index);
// collect the transformation variants for this cellview - this way we can paint
// the cell boxes for each global transformation
m_global_trans = view ()->cv_transform_variants (m_cv_index);
m_cell_index = cell_index;
if (m_mode == ToCellView) {
m_context_cv.set_cell (m_context_cell);
} else {
m_context_cv.set_cell (m_cell_index);
}
const db::Layout &layout = m_context_cv->layout ();
setWindowTitle (tl::to_qstring (tl::to_string (QObject::tr ("Browse Instances Of Cell")) + " '" + layout.cell_name (m_cell_index) + "'"));
// update the cell list
BrowseInstancesFormCellLVI *sel_item = 0;
lv_cell->clear ();
m_cell_changed_enabled = false;
// obtain all cell names, sort and fill into the lv_cell
std::vector <BrowseInstancesCellInfo> cell_info;
db::CellCounter counter (&layout);
size_t tot_count = 0, tot_count_flat = 0;
const db::Cell &cell = layout.cell (m_cell_index);
bool ci_set = false;
size_t w = 0;
lay::CellView::cell_index_type ci = 0;
for (db::Cell::parent_inst_iterator p = cell.begin_parent_insts (); ! p.at_end (); ++p) {
if (! ci_set || p->parent_cell_index () != ci) {
ci = p->parent_cell_index ();
ci_set = true;
w = counter.weight (ci);
cell_info.push_back (BrowseInstancesCellInfo (layout.cell_name (ci), ci));
}
size_t c = p->child_inst ().size ();
cell_info.back ().count += c;
cell_info.back ().count_flat += c * w;
tot_count += c;
tot_count_flat += c * w;
}
tl::sort (cell_info.begin (), cell_info.end ());
QTreeWidgetItem *all = new QTreeWidgetItem (lv_cell);
all->setText (0, QObject::tr ("(All Instances)"));
all->setText (1, tl::to_qstring (tl::to_string (tot_count)));
all->setText (2, tl::to_qstring (tl::to_string (tot_count_flat)));
QFont f (all->font (0));
f.setBold (true);
QColor tc (0, 0, 255);
for (int col = 0; col < 3; ++col) {
all->setFont (col, f);
all->setTextColor (col, tc);
}
// create the entries.
m_items.clear ();
BrowseInstancesFormCellLVI *item = 0;
for (std::vector<BrowseInstancesCellInfo>::const_iterator cn = cell_info.begin (); cn != cell_info.end (); ++cn) {
item = new BrowseInstancesFormCellLVI (cn->name, cn->cell_index);
item->setText (1, tl::to_qstring (tl::to_string (cn->count)));
item->setText (2, tl::to_qstring (tl::to_string (cn->count_flat)));
m_items.prepend (item);
if (! sel_item) {
sel_item = item;
}
}
lv_cell->addTopLevelItems (m_items);
if (! sel_item && item) {
sel_item = item;
}
// make the first the current one
if (sel_item) {
lv_cell->setCurrentItem (sel_item);
lv_cell->setItemSelected (sel_item, true);
lv_cell->scrollToItem (sel_item);
}
m_cell_changed_enabled = true;
if (sel_item) {
cell_changed (sel_item, 0);
}
m_view_changed = false;
}
void
BrowseInstancesForm::deactivated ()
{
root ()->config_set (cfg_cib_window_state, lay::save_dialog_state (this));
// remove the cellview reference and clean up everything that could reference
// database objects
lv_cell->clear ();
lv_cell_instance->clear ();
m_context_cv = lay::CellView ();
if (m_view_changed) {
view ()->store_state ();
}
view ()->goto_view (m_display_state);
remove_marker ();
}
bool
BrowseInstancesForm::fill_cell_instances (const db::ICplxTrans &t, const db::Layout &layout, const db::Cell *parent, const db::Cell *from, const db::Cell *to, bool to_parent, const std::string &path, QList<QTreeWidgetItem *> &items)
{
if (from == to || (! to_parent && to == 0 && from->is_top ())) {
if (m_current_count == m_max_inst_count) {
return true; // shorten list
}
++m_current_count;
std::string text;
if (! path.empty ()) {
text += t.to_string (true /*lazy*/, layout.dbu ());
}
items.append (new BrowseInstancesFormCellInstanceLVI (text, path, t, from->cell_index ()));
} else {
// traverse the parents
for (db::Cell::parent_inst_iterator p = from->begin_parent_insts (); ! p.at_end (); ++p) {
// not in scope - continue
if (parent && p->parent_cell_index () != parent->cell_index ()) {
continue;
}
db::CellInstArray parent_inst = p->inst ();
db::Vector a, b;
unsigned long r = 1, c = 1;
parent_inst.is_regular_array (a, b, r, c);
std::string aref;
if (r > 1 || c > 1) {
aref = tl::sprintf ("[%ld,%ld]", c, r);
}
std::string new_path;
if (! path.empty ()) {
new_path = layout.cell_name (p->parent_cell_index ()) + aref + "/" + path;
} else {
new_path = layout.cell_name (p->parent_cell_index ()) + aref;
}
db::ICplxTrans tt (parent_inst.complex_trans ());
const db::Cell *cell = & layout.cell (p->parent_cell_index ());
if (fill_cell_instances (tt.inverted () * t, layout, 0, cell, to_parent ? cell : to, false, new_path, items)) {
return true; // list too long - no more entries possible
}
}
}
return false;
}
void
BrowseInstancesForm::highlight_current ()
{
remove_marker ();
bool index_set = false;
lay::CellView::cell_index_type index = 0;
db::DBox dbox;
// TODO: the selectedItems () method is somewhat slow for large selections
QList<QTreeWidgetItem *> selected_items = lv_cell_instance->selectedItems ();
for (QList<QTreeWidgetItem *>::const_iterator s = selected_items.begin (); s != selected_items.end (); ++s) {
BrowseInstancesFormCellInstanceLVI *inst_item = dynamic_cast <BrowseInstancesFormCellInstanceLVI *> (*s);
if (inst_item) {
if (! index_set) {
index = inst_item->index ();
index_set = true;
}
if (index == inst_item->index ()) {
const db::Layout &layout = m_context_cv->layout ();
db::Box box = layout.cell (m_cell_index).bbox ();
lay::Marker *marker = new lay::Marker (view (), m_cv_index);
marker->set (box, inst_item->trans (), m_global_trans);
mp_markers.push_back (marker);
// compute the bbox of the marker
for (std::vector<db::DCplxTrans>::const_iterator gt = m_global_trans.begin (); gt != m_global_trans.end (); ++gt) {
dbox += (*gt * db::CplxTrans (layout.dbu ()) * inst_item->trans ()) * box;
}
}
}
}
if (index_set) {
view ()->select_cell (index, m_cv_index);
if (m_window == FitCell) {
view ()->zoom_fit ();
} else if (m_window == FitMarker) {
view ()->zoom_box (dbox.enlarged (db::DVector (m_window_dim, m_window_dim)));
} else if (m_window == Center) {
view ()->pan_center (dbox.p1 () + (dbox.p2 () - dbox.p1 ()) * 0.5);
} else if (m_window == CenterSize) {
double w = std::max (dbox.width (), m_window_dim);
double h = std::max (dbox.height (), m_window_dim);
db::DPoint center (dbox.p1 () + (dbox.p2 () - dbox.p1 ()) * 0.5);
db::DVector d (w * 0.5, h * 0.5);
view ()->zoom_box (db::DBox (center - d, center + d));
}
m_view_changed = true;
}
}
bool
BrowseInstancesForm::adv_cell (bool up)
{
QTreeWidgetItem *current = lv_cell->currentItem ();
int i = lv_cell->indexOfTopLevelItem (current);
if (i >= 0) {
QTreeWidgetItem *next = lv_cell->topLevelItem (i + (up ? -1 : 1));
if (next && dynamic_cast <BrowseInstancesFormCellLVI *> (next)) {
lv_cell->setCurrentItem (next);
lv_cell->scrollToItem (next);
return true;
}
}
return false;
}
void
BrowseInstancesForm::next_cell ()
{
lv_cell->setFocus ();
adv_cell (false);
}
void
BrowseInstancesForm::prev_cell ()
{
lv_cell->setFocus ();
adv_cell (true);
}
bool
BrowseInstancesForm::eventFilter (QObject *watched, QEvent *event)
{
if (m_ef_enabled && event->type () == QEvent::KeyPress) {
QKeyEvent *ke = dynamic_cast <QKeyEvent *> (event);
if (ke && (ke->key () == Qt::Key_Up || ke->key () == Qt::Key_Down)) {
bool up = ke->key () == Qt::Key_Up;
if (watched == lv_cell_instance) {
adv_cell_inst (up);
}
return true;
}
}
return QDialog::eventFilter (watched, event);
}
bool
BrowseInstancesForm::adv_cell_inst (bool up)
{
QTreeWidgetItem *current = lv_cell_instance->currentItem ();
m_ef_enabled = false; // prevent recursion
QKeyEvent ke (QEvent::KeyPress, up ? Qt::Key_Up : Qt::Key_Down, Qt::NoModifier);
((QObject *)lv_cell_instance)->event (&ke);
m_ef_enabled = true;
if (lv_cell_instance->currentItem () == current) {
// if we are at the end of the list, pass the event
// forward to the shape instance list
if (adv_cell (up)) {
// select first or last item
QTreeWidgetItem *ni;
if (up) {
ni = lv_cell_instance->topLevelItem (lv_cell_instance->topLevelItemCount () - 1);
} else {
ni = lv_cell_instance->topLevelItem (0);
}
if (ni) {
lv_cell_instance->setCurrentItem (ni);
lv_cell_instance->setItemSelected (ni, true);
lv_cell_instance->scrollToItem (ni);
}
return true;
} else {
return false;
}
} else {
return true;
}
}
void
BrowseInstancesForm::next_inst ()
{
lv_cell_instance->setFocus ();
adv_cell_inst (false);
}
void
BrowseInstancesForm::prev_inst ()
{
lv_cell_instance->setFocus ();
adv_cell_inst (true);
}
}
Reference in New Issue View Git Blame Copy Permalink