Wt

IWSharedProxyModel needs to do two things:

• protected access to the source model
  
• propagate signals to connected views while holding the update lock (and correct WApplication::instance()) for that view's application.

The implementation in my previous email will probably not work, since it cannot avoid a dead-lock situation: one app tries to modify the model, while another app is busy reading from the model: the writing operation would block further reads until it is done (including signal propagation), but it would not be able to get the update lock for the application that is being blocked trying to read from the model.

The implementation should do:

• when writing:
  1) grab update locks for all registered applications
  2) do the write operation in the source model
  3) for the signals emitted from the source model:
  • app->attachThread()
  • propagate to app

<!-- -->

• when reading:
  no (additional) lock needed - writing will take the update lock of all registered applications, so it cannot happen concurrently with readers.
  reading is allow concurrently

<!-- -->

• We make the calls to the signal accessor methods of WAbstractItemModel (such as changed()) virtual to have something like this:

with:

typedef std::map<WApplication *app, Signal<WModelIndex, WModelIndex>> ChangedSignalsMap;
ChangedSignalsMap changedSignals_;

we could reimplement changed():

Signal<WModelIndex, WModelIndex>& WSharedProxyModel::changed()
{
  WApplication *app = WApplication::instance();
  return changedSignals_[app];
}

and the method that propagates the change from the source model:

void WSharedProxyModel::sourceModelChanged(const WModelIndex& m1, const WModelIndex& m2)
{
  for (ChangedSignalsMap::const_iterator i = changedSignals_.begin(); i != changedSignals_.end(); ++i) {
    i->first->attachThread(); // we already have the update lock cfr supra
    i->second.emit(m1, m2);
  }
}