//_______________________________________________________________________________________
static void AddGrid()
{
TVirtualPad *thisPad = qPad();
if (thisPad) {
TView *view = thisPad->GetView();
if (!view) return;
Double_t min[3],max[3];
view->GetRange(min,max);
TList *list = thisPad->GetListOfPrimitives();
TString histName = thisPad->GetName();
TH2F *m_DummyHist = 0;
const Char_t *dummyName = "Axis3D";
histName += dummyName;
m_DummyHist = list->FindObject(histName.Data());
if (!m_DummyHist) {
m_DummyHist = new TH2F(histName.Data(),"",1,min[0],max[0],1,min[1],max[1]);
m_DummyHist->SetDirectory(0);
m_DummyHist->Draw("surf,same");
}
m_DummyHist->GetXaxis()->SetLimits(min[0],max[0]);
m_DummyHist->GetYaxis()->SetLimits(min[1],max[1]);
m_DummyHist->GetZaxis()->SetLimits(min[2],max[2]);
thisPad->Modified();
thisPad->Update();
}
}
TAsciiChart::TAsciiChart() :
TWindowInit(&TAsciiChart::initFrame), TWindow(TRect(0, 0, 34, 12), "ASCII Chart",
wnNoNumber) {
TView *control;
flags &= ~(wfGrow | wfZoom);
palette = wpGrayWindow;
TRect r = getExtent();
r.grow(-1, -1);
r.a.y = r.b.y - 1;
control = new TReport(r);
control->options |= ofFramed;
control->eventMask |= evBroadcast;
insert(control);
r = getExtent();
r.grow(-1, -1);
r.b.y = r.b.y - 2;
control = new TTable(r);
control->options |= ofFramed;
control->options |= ofSelectable;
control->blockCursor();
insert(control);
control->select();
}
void TGroup::selectNext( Boolean forwards )
{
if( current != 0 )
{
TView* p = findNext(forwards);
if (p) p->select();
}
}
Boolean TGroup::focusNext(Boolean forwards) {
TView *p;
p = findNext(forwards);
if (p)
return p->focus();
else
return True;
}
//_______________________________________________________________________________________
void MakeFourView(TVirtualPad *pad=0)
{
// Creates 4 pads view of the pad (or qPad)
// ------------------------------
// | | |
// | | |
// | | |
// | Front | Top |
// | view | view |
// | | |
// | | |
// | | |
// ---------------+-------------
// | | |
// | | |
// | | |
// | Side | Spacial |
// | view | view |
// | | |
// | | |
// | | |
// ------------------------------
// begin_html <P ALIGN=CENTER> <IMG SRC="gif/FourStarView.gif" ></P> end_html
//
TVirtualPad *thisPad = pad;
if (!thisPad) thisPad = qPad();
TView *view = 0;
TList *thisPrimitives = 0;
if (thisPad && (thisPrimitives = thisPad->GetListOfPrimitives()) && (view = thisPad->GetView()) )
{
Double_t min[3],max[3];
view->GetRange(min,max);
Int_t system = view->GetSystem();
TCanvas *c = new TCanvas(" 4 views", thisPad->GetTitle(),600,600);
c->Divide(2,2);
TIter *next= new TIter(thisPrimitives);
for (int i =1; i <= 4; i++) {
c->cd(i);
TList *newPrimitives = qPad()->GetListOfPrimitives();
TObject *obj = 0;
while (obj = next->Next()) newPrimitives->Add(obj);
TView *newView = new TView(system);
newView->SetRange(min,max);
next->Reset();
}
delete next;
// set separate view;
// Fron view
Int_t j = 1;
c->cd(j++); FrontView();
c->cd(j++); TopView();
c->cd(j++); SideView();
c->cd(j++); RotateView(-30.0,60.0,0);
c->Modified();
c->Update();
}
}
void TGroup::setData(void *rec) {
size_t i = 0;
if (last!= 0) {
TView *v = last;
do {
v->setData((char *)rec + i);
i += v->dataSize();
v = v->prev();
} while (v != last);
}
}
void TStatusLine::update()
{
TView *p = TopView();
ushort h = ( p != 0 ) ? p->getHelpCtx() : hcNoContext;
if( helpCtx != h )
{
helpCtx = h;
findItems();
drawView();
}
}
void TGroup::getData(void *rec)
{
ushort i = 0;
if (last != 0 )
{
TView* v = last;
do {
v->getData( ((char *)rec) + i );
i += v->dataSize();
v = v->prev();
} while( v != last );
}
}
void pl3() {
TCanvas *c1 = new TCanvas("c1");
TView *view = TView::CreateView(1);
view->SetRange(0,0,0,2,2,2);
const Int_t n = 100;
TPolyLine3D *l = new TPolyLine3D(n);
for (Int_t i=0;i<n;i++) {
Double_t x = 2*gRandom->Rndm();
Double_t y = 2*gRandom->Rndm();
Double_t z = 2*gRandom->Rndm();
l->SetPoint(i,x,y,z);
}
l->Draw();
}
void drawing_pion_decay(){
double Pi_lifetime = 0.26033e-6; //s
double c = 3e8;//m/s
TCanvas *c1 = new TCanvas("test", "test");
TRandom *r = new TRandom();
TView *view = TView::CreateView(1, 0, 0);
view->ShowAxis();
view->SetRange(-5, -5, 0, 5, 5, 10);
for (int i = 0; i < 100; ++i)
{
double px = 0.3;
double py = 0.3;
double pz = -1; // GeV
double energy = sqrt(px*px+py*py+pz*pz+M_pion*M_pion);
//life time
double t = r->Exp(Pi_lifetime);
//decay length
double gamma = energy/M_pion;
double length = c*t*gamma/1e3;
// decay position
double vx = 0;
double vy = 0;
double vz = 10 - length;
TLorentzVector pion(px, py, pz, energy);
double decay_particle_mass[2] = {M_muon, M_neu};
TGenPhaseSpace event;
event.SetDecay(pion, 2, decay_particle_mass);
event.Generate();
TLorentzVector Muon = *(event.GetDecay(0));
TLorentzVector Neu = *(event.GetDecay(1));
plot_particle(Muon, vx, vy, vz, 2);
plot_particle(Neu, vx, vy, vz, 4);
}
}
//_______________________________________________________________________________________
static void Inscrease3DScale()
{
TVirtualPad *thisPad = qPad();
if (thisPad) {
TView *view = thisPad->GetView();
if (!view) return;
Double_t min[3],max[3];
view->GetRange(min,max);
int i;
for (i=0;i<3; i++) {max[i] *= 0.8; min[i]=max[i]*0.1;}
view->SetRange(min,max);
thisPad->Modified();
thisPad->Update();
}
}
//
/// Notifies the views of the current document and the views of any child documents
/// of a change. In contrast to QueryViews, NotifyViews sends notification of an
/// event to all views and returns true if all views returned a true result. The
/// event, EV_OWLNOTIFY, is sent with an event code, which is private to the
/// particular document and view class, and a long argument, which can be cast
/// appropriately to the actual type passed in the argument of the response
/// function.
//
bool
TDocument::NotifyViews(int event, long item, TView* exclude)
{
bool answer = true;
TDocument* pdoc = 0;
while ((pdoc = ChildDoc.Next(pdoc)) != 0)
answer = (answer && pdoc->NotifyViews(event, item, exclude));
TEventHandler::TEventInfo eventInfo(WM_OWLNOTIFY, event);
for (TView* view = ViewList; view != 0; view = view->NextView)
if (view != exclude && view->Find(eventInfo))
answer = (answer && (view->Dispatch(eventInfo, 0, item) != 0));
return answer;
}
ushort execDialog( TDialog *d, void *data )
{
TView *p = TProgram::application->validView( d );
if( p == 0 )
return cmCancel;
else
{
if( data != 0 )
p->setData( data );
ushort result = TProgram::deskTop->execView( p );
if( result != cmCancel && data != 0 )
p->getData( data );
TObject::destroy( p );
return result;
}
}
//_______________________________________________________________________________________
static void Centered3DImages()
{
// This macro prints out the sizes of the sekected 3d pad
TVirtualPad *thisPad = qPad();
if (thisPad) {
TView *view = thisPad->GetView();
if (!view) return;
Double_t min[3],max[3];
view->GetRange(min,max);
int i;
for (i=0;i<3; i++) min[i]=-max[i];
view->SetRange(min,max);
thisPad->Modified();
thisPad->Update();
}
}
void TObjDlg::handleNotification( TView *view )
{
if( view == this )
{
TView *v = first();
do
{
if( v->dataSize() > 0 )
owner->handleNotification( v );
v = v->nextView();
}
while( v );
}
else
owner->handleNotification( view );
}
//_______________________________________________________________________________________
static void RotateView(Float_t phi, Float_t theta, TVirtualPad *pad=0)
{
TVirtualPad *thisPad = pad;
if (!thisPad) thisPad = qPad();
if (thisPad) {
TView *view = thisPad->GetView();
if (view) {
Int_t iret;
Float_t p = phi;
Float_t t = theta;
view->SetView(p, t, 0, iret);
thisPad->SetPhi(-90-p);
thisPad->SetTheta(90-t);
thisPad->Modified();
thisPad->Update();
}
}
}
uchar TView::mapColor( uchar color )
{
if( color == 0 )
return errorAttr;
TView *cur = this;
do {
TPalette& p = cur->getPalette();
if( p[0] != 0 )
{
if( color > p[0] )
return errorAttr;
color = p[color];
if( color == 0 )
return errorAttr;
}
cur = cur->owner;
} while( cur != 0 );
return color;
}
CUGIP_GLOBAL void
kernel_fill(TView aView, TType aValue)
{
typename TView::coord_t coord(blockIdx.x * blockDim.x + threadIdx.x, blockIdx.y * blockDim.y + threadIdx.y);
typename TView::extents_t extents = aView.dimensions();
if (coord.template get<0>() < extents.template get<0>() && coord.template get<1>() < extents.template get<1>()) {
aView[coord] = aValue;
}
}
//_______________________________________________________________________________________
static void AdjustScales()
{
TVirtualPad *thisPad = qPad();
if (thisPad) {
TView *view = thisPad->GetView();
if (!view) return;
Double_t min[3],max[3];
view->GetRange(min,max);
int i;
Double_t maxSide = 0;
// Find the largest side
for (i=0;i<3; i++) maxSide = TMath::Max(maxSide,max[i]-min[i]);
//Adjust scales:
for (i=0;i<3; i++) max[i] += maxSide - (max[i]-min[i]);
view->SetRange(min,max);
thisPad->Modified();
thisPad->Update();
}
}
void spheres(Int_t nspheres=20, Int_t npoints=100000) {
// generate random points uniformly distributed over the surface
// of spheres generated at random positions.
TCanvas *c1 = new TCanvas("c1","spheres",600,600);
c1->SetFillColor(kBlack);
TView *view = new TView(1);
Double_t k=0.8;
view->SetRange( -k, -k, -k, k, k, k);
//generate sphere coordinates and radius
TRandom r;
if (nspheres <=0) nspheres = 10;
Double_t *xs = new Double_t[nspheres];
Double_t *ys = new Double_t[nspheres];
Double_t *zs = new Double_t[nspheres];
Double_t *rs = new Double_t[nspheres];
Int_t i;
for (i=0;i<nspheres;i++) {
xs[i] = r.Uniform(-1,1);
ys[i] = r.Uniform(-1,1);
zs[i] = r.Uniform(-1,1);
rs[i] = r.Uniform(0.05,0.25);
}
//generate points
TPolyMarker3D *pm = new TPolyMarker3D(npoints);
pm->SetMarkerColor(kRed);
Double_t x,y,z;
for (Int_t j=0;j<npoints;j++) {
i = (Int_t)r.Uniform(0,nspheres); //choose sphere
r.Sphere(x,y,z,rs[i]);
pm->SetPoint(j,xs[i]+x, ys[i]+y,zs[i]+z);
}
delete [] xs;
delete [] ys;
delete [] zs;
delete [] rs;
pm->Draw();
}
void TGroup::shutDown()
{
TView* p = last;
if( p != 0 )
{
do {
p->hide();
p = p->prev();
} while (p != last);
do {
TView* T = p->prev();
destroy( p );
p = T;
} while( last != 0 );
}
freeBuffer();
current = 0;
TView::shutDown();
}
//
/// Queries the views of the current document and the views of any child documents
/// about a specified event, but stops at the first view that returns true. In
/// contrast to NotifyViews(), QueryViews returns a pointer to the first view that
/// responded to an event with a true result. The event, EV_OWLNOTIFY, is sent with
/// an event code (which is private to the particular document and view class) and a
/// long argument (which can be cast appropriately to the actual type passed in the
/// argument of the response function).
//
TView*
TDocument::QueryViews(int event, long item, TView* exclude)
{
TView* view;
TDocument* pdoc = 0;
while ((pdoc = ChildDoc.Next(pdoc)) != 0)
if ((view = pdoc->QueryViews(event, item, exclude)) != 0)
return view;
TEventHandler::TEventInfo eventInfo(WM_OWLNOTIFY, event);
for (view = ViewList; view != 0; view = view->NextView) {
if (view != exclude) {
if (view->Find(eventInfo)) {
if (view->Dispatch(eventInfo, 0, item)) {
return view; // Return first acknowledger
}
}
}
}
return 0;
}
//////////////////////////////////////////////////////////
// mtlrchApp
// =====
// Response Table handlers:
//
void mtlrchApp::EvNewView (TView& view)
{
TMDIClient *mdiClient = TYPESAFE_DOWNCAST(GetMainWindow()->GetClientWindow(), TMDIClient);
if (mdiClient) {
mtlrchMDIChild* child = new mtlrchMDIChild(*mdiClient, 0, view.GetWindow());
// Associate ICON w/ this child window.
child->SetIcon(this, IDI_DOC);
child->Create();
}
}
void
XPFUpdateWindow::setUpdateItemList (XPFUpdateItemList *list)
{
CStr255_AC theWordDelete ((ResNumber) kXPFStringsResource, kDeleteWord);
CStr255_AC theWordInstall ((ResNumber) kXPFStringsResource, kInstallWord);
TView *listView = FindSubView ('list');
listView->SetDrawingEnvironment (new TThemeWhiteEnvironment, false);
CViewPoint offset (0, 0);
for (XPFUpdateListIterator iter (list); iter.Current (); iter.Next ()) {
if (iter->getAction () == kActionNone) continue;
TView *itemView = TViewServer::fgViewServer->DoCreateViews (GetDocument (), listView, kUpdateItem, offset);
TStaticText *name = (TStaticText *) itemView->FindSubView ('item');
TStaticText *installed = (TStaticText *) itemView->FindSubView ('inst');
TStaticText *available = (TStaticText *) itemView->FindSubView ('avai');
TStaticText *action = (TStaticText *) itemView->FindSubView ('acti');
name->SetText (iter->getResourceName (), false);
char buffer [64];
parseVersion (buffer, iter->getInstalledVersion ());
installed->SetText (buffer, false);
parseVersion (buffer, iter->getAvailableVersion ());
available->SetText (buffer, false);
if (!iter->getIsQualified ()) available->SetText ("n/a", false);
switch (iter->getAction ()) {
case kActionDelete:
theWordDelete.CopyTo (buffer);
break;
case kActionInstall:
theWordInstall.CopyTo (buffer);
break;
default:
buffer[0] = 0;
break;
}
action->SetText (buffer, false);
offset.v += itemView->GetSize().v;
}
}
//
/// Force view title and index update.
//
void
TDocument::ReindexFrames()
{
TView* view;
int seq;
for (seq = -1, view = ViewList; view != 0; view = view->NextView) {
seq -= view->SetDocTitle(Title, seq); // decrement if title displayed
if (seq == -3) // need only check if more than one title displayed
break;
}
if (seq == -1)
return;
seq = (seq == -2 ? 0 : 1);
for (view = ViewList; view != 0; view = view->NextView)
{
//DLN: added this if condition to avoid PRECONDITIONs in debug build
// which occur if program closed by closing main window
if ( view->GetWindow() && view->GetWindow()->GetHandle() )
seq += view->SetDocTitle(Title, seq); // increment if title displayed
}
}
void TGroup::shutDown() {
/* looks like this is a fix from someone!
No such string both in TV 1.0 & 2.0. Let it stay here for a while */
resetCurrent();
TView *p = last;
if (p != 0) {
do {
p->hide();
p = p->prev();
} while (p != last);
do {
TView *T = p->prev();
destroy(p);
p = T;
} while (last != 0);
}
freeBuffer();
current = 0;
TView::shutDown();
}
CUGIP_DECL_DEVICE
void load(TView aView, coord_t aCorner/*region<cDimension> aRegion*/)
{
int index = threadOrderFromIndex();
TElement *buffer = reinterpret_cast<TElement *>(data);
while (index < cElementCount) {
auto coords = min_coords(
aView.dimensions()-coord_t(1, FillFlag()),
max_coords(coord_t(),
aCorner + index_from_linear_access_index(to_vector(TStaticSize()), index)));
buffer[index] = aView[coords];
index += TThreadBlockSize::count();
}
}
CUGIP_DECL_DEVICE
void shift_and_load(TView aView, coord_t aCorner, int aShift) {
shift_up2(aShift);
int layerCount = TStaticSize::last() - aShift;
int index = layerCount * cLayerSize + threadOrderFromIndex();
TElement *buffer = reinterpret_cast<TElement *>(data);
while (index < cElementCount) {
auto coords = min_coords(
aView.dimensions()-coord_t(1, FillFlag()),
max_coords(coord_t(),
aCorner + index_from_linear_access_index(TStaticSize::vector(), index)));
buffer[index] = aView[coords];
index += TThreadBlockSize::count();
}
}
void RootWImage::setCanvas(TCanvas* myCanvas) {
if (myCanvas_) delete myCanvas_;
myCanvas_ = (TCanvas*)myCanvas->DrawClone();
std::ostringstream canvasName("");
//int myNumber = imageNameCounter_[name_]++; //##########
canvasName << "canvas" << setfill('0') << setw(3) << imageCounter_;
myCanvas_->SetName(canvasName.str().c_str());
TView* myView = myCanvas->GetView();
if (myView) {
TView* newView = myCanvas_->GetView();
if (newView) {
double min[3], max[3];
Int_t irep;
newView->SetView(myView->GetLongitude(),
myView->GetLatitude(),
myView->GetPsi(), irep);
myView->GetRange(min, max);
newView->SetRange(min, max);
}
}
}
//
/// DetachView is invoked from TView's destructor so that the view can detach
/// itself from this document. True is returned if the detachment is successful
/// indicating that this document should be deleted.
//
bool
TDocument::DetachView(TView& view)
{
TView** plist = &ViewList;
for (; *plist; plist = &(*plist)->NextView) {
if (*plist == &view) {
// Found the view, now detach it and notify app and other views
//
DocManager->PostEvent(dnClose, view);
*plist = view.NextView;
NotifyViews(vnViewClosed, (long)&view, &view);
// Cleanup doc if last view was just closed and dtAutoDelete
// or dtAutoOpen is set. dtAutoOpen will cause an autoclose, while
// dtAutoDelete will delete this doc also.
//
if (!ViewList) {
if (Template && ((Template->Flags & dtAutoDelete) ||
(Template->Flags & dtAutoOpen))) {
// Close document streams
//
if (IsOpen())
Close();
// Returning true will cause ~TView to delete document. Using
// 'view.IsOK()' caters for cases where TView's construction failed.
//
return (Template->Flags & dtAutoDelete) && view.IsOK();
}
}
else {
ReindexFrames();
}
break;
}
}
return false;
}
