कोणीय 2.0 और मोडल संवाद


128

मैं कुछ उदाहरण खोजने की कोशिश कर रहा हूं कि कोणीय 2.0 में पुष्टिकरण संवाद कैसे करें। मैं Angular 1.0 के लिए बूटस्ट्रैप संवाद का उपयोग कर रहा हूं और Angular 2.0 के लिए वेब में कोई भी उदाहरण नहीं पा रहा हूं। मैंने कोणीय 2.0 डॉक्स को भी बिना किसी भाग्य के चेक किया।

क्या एंगुलर 2.0 के साथ बूटस्ट्रैप संवाद का उपयोग करने का कोई तरीका है?


मैंने इसका उदाहरण पाया है। शायद यह आपको angularscript.com/angular2-modal-window-with-bootstrap-style
Puya Sarmidani

1
मैं RC3 और इसके साथ सुंदर सामग्री के साथ इस का उपयोग कर रहा हूं: valor-software.com/ng2-bootstrap/#/modals
मेंट

@Sam की बदौलत मुझे अच्छी शुरुआत मिली। हालाँकि, मैंने देखा कि कॉलिंग घटक को पता नहीं है कि किस बटन पर क्लिक किया गया है। कुछ शोध के बाद, मैं एक अधिक सुरुचिपूर्ण समाधान के साथ आने के लिए EventEmitters के बजाय वेधशालाओं का उपयोग करने में सक्षम था ।
जॉन

कैसे के बारे में ng-bootstrap.github.io/#/compenders/modal ?
pkozlowski.opensource

@mentat, url अपडेटेड valor-software.com/ngx-bootstrap/#/modals
आनंद

जवाबों:


199
  • कोणीय 2 और ऊपर
  • बूटस्ट्रैप सीएसएस (एनीमेशन संरक्षित है)
  • सं JQuery
  • सं बूटस्ट्रैप। Js
  • कस्टम मोडल सामग्री का समर्थन करता है (जैसे स्वीकृत उत्तर)
  • हाल ही में एक दूसरे के शीर्ष पर कई मोडल के लिए समर्थन जोड़ा गया ।

`

@Component({
  selector: 'app-component',
  template: `
  <button type="button" (click)="modal.show()">test</button>
  <app-modal #modal>
    <div class="app-modal-header">
      header
    </div>
    <div class="app-modal-body">
      Whatever content you like, form fields, anything
    </div>
    <div class="app-modal-footer">
      <button type="button" class="btn btn-default" (click)="modal.hide()">Close</button>
      <button type="button" class="btn btn-primary">Save changes</button>
    </div>
  </app-modal>
  `
})
export class AppComponent {
}

@Component({
  selector: 'app-modal',
  template: `
  <div (click)="onContainerClicked($event)" class="modal fade" tabindex="-1" [ngClass]="{'in': visibleAnimate}"
       [ngStyle]="{'display': visible ? 'block' : 'none', 'opacity': visibleAnimate ? 1 : 0}">
    <div class="modal-dialog">
      <div class="modal-content">
        <div class="modal-header">
          <ng-content select=".app-modal-header"></ng-content>
        </div>
        <div class="modal-body">
          <ng-content select=".app-modal-body"></ng-content>
        </div>
        <div class="modal-footer">
          <ng-content select=".app-modal-footer"></ng-content>
        </div>
      </div>
    </div>
  </div>
  `
})
export class ModalComponent {

  public visible = false;
  public visibleAnimate = false;

  public show(): void {
    this.visible = true;
    setTimeout(() => this.visibleAnimate = true, 100);
  }

  public hide(): void {
    this.visibleAnimate = false;
    setTimeout(() => this.visible = false, 300);
  }

  public onContainerClicked(event: MouseEvent): void {
    if ((<HTMLElement>event.target).classList.contains('modal')) {
      this.hide();
    }
  }
}

पृष्ठभूमि दिखाने के लिए , आपको कुछ इस तरह की आवश्यकता होगी CSS:

.modal {
  background: rgba(0,0,0,0.6);
}

उदाहरण अब एक ही समय में कई मोडल के लिए अनुमति देता है । ( onContainerClicked()विधि देखें )।

बूटस्ट्रैप 4 सीएसएस उपयोगकर्ताओं के लिए , आपको 1 मामूली परिवर्तन करने की आवश्यकता है (क्योंकि बूटस्ट्रैप 3 से एक सीएसएस वर्ग नाम अपडेट किया गया था)। इस लाइन [ngClass]="{'in': visibleAnimate}"को: [ngClass]="{'show': visibleAnimate}"

प्रदर्शित करने के लिए, यहां एक प्लंकर है


हालांकि एक गोटा है। क्योंकि बटन यहां एक अतिरिक्त तत्व के अंदर लिपटे हुए हैं, बूटस्ट्रैप स्टाइल बटन पर मार्जिन (कम से कम v4 में) लागू नहीं होगा। रैपिंग को हटाने div.modal-footerऔर .app-modal-footerइसे .modal-footerठीक करने के लिए बदलने ।
एक्सल कोहलर

55

यहाँ आप GitHub पर Angular2 ऐप के भीतर बूटस्ट्रैप मोडल का उपयोग कैसे कर सकते हैं, इसका एक बहुत अच्छा उदाहरण है

इसका सार यह है कि आप बूटस्ट्रैप html और jquery आरंभीकरण को एक घटक में लपेट सकते हैं। मैंने एक पुन: प्रयोज्य modalघटक बनाया है जो आपको टेम्पलेट चर का उपयोग करके एक खुले ट्रिगर करने की अनुमति देता है।

<button type="button" class="btn btn-default" (click)="modal.open()">Open me!</button>

<modal #modal>
    <modal-header [show-close]="true">
        <h4 class="modal-title">I'm a modal!</h4>
    </modal-header>
    <modal-body>
        Hello World!
    </modal-body>
    <modal-footer [show-default-buttons]="true"></modal-footer>
</modal>

आपको बस npm पैकेज स्थापित करने और अपने ऐप मॉड्यूल में मोडल मॉड्यूल को पंजीकृत करने की आवश्यकता है:

import { Ng2Bs3ModalModule } from 'ng2-bs3-modal/ng2-bs3-modal';

@NgModule({
    imports: [Ng2Bs3ModalModule]
})
export class MyAppModule {}


52
हाँ, बूटस्ट्रैप इस पर निर्भर करता है और मैं पुस्तकालयों के पुनर्लेखन के व्यवसाय में नहीं हूँ।
डगलस लुडलो

2
यह jQuery के बिना किया जा सकता है। मैंने सेवा और संबद्ध मोडल कंपोनेंट लिखने के लिए koscielniak.me/post/2016/03/angular2-confirm-dialog-component पर ट्यूटोरियल के साथ सैम के उत्तर का उपयोग किया ।
बीटलज्यूइस

यदि आप अपने प्रोजेक्ट में बूटस्ट्रैप का उपयोग नहीं कर रहे हैं, तो bootstrap.css का लिंक जोड़ना न भूलें। गिथब पृष्ठ इसका उल्लेख करना भूल जाता है।
शेखर

46

यह एक सरल दृष्टिकोण है जो कोणीय 2 को छोड़कर jquery या किसी अन्य पुस्तकालय पर निर्भर नहीं करता है। नीचे दिए गए घटक (errorMessage.ts) को किसी अन्य घटक के बच्चे के दृश्य के रूप में उपयोग किया जा सकता है। यह केवल एक बूटस्ट्रैप मोडल है जो हमेशा खुला या दिखाया जाता है। यह दृश्यता ngIf कथन द्वारा शासित है।

errorMessage.ts

import { Component } from '@angular/core';
@Component({
    selector: 'app-error-message',
    templateUrl: './app/common/errorMessage.html',
})
export class ErrorMessage
{
    private ErrorMsg: string;
    public ErrorMessageIsVisible: boolean;

    showErrorMessage(msg: string)
    {
        this.ErrorMsg = msg;
        this.ErrorMessageIsVisible = true;
    }

    hideErrorMsg()
    {
        this.ErrorMessageIsVisible = false;
    }
}

errorMessage.html

<div *ngIf="ErrorMessageIsVisible" class="modal fade show in danger" id="myModal" role="dialog">
    <div class="modal-dialog">

        <div class="modal-content">
            <div class="modal-header">
                <button type="button" class="close" data-dismiss="modal">&times;</button>
                <h4 class="modal-title">Error</h4>
            </div>
            <div class="modal-body">
                <p>{{ErrorMsg}}</p>
            </div>
            <div class="modal-footer">
                <button type="button" class="btn btn-default" (click)="hideErrorMsg()">Close</button>
            </div>
        </div>
    </div>
</div>

यह एक उदाहरण जनक नियंत्रण है (कुछ गैर-प्रासंगिक कोड संक्षिप्तता के लिए छोड़ दिया गया है):

parent.ts

import { Component, ViewChild } from '@angular/core';
import { NgForm } from '@angular/common';
import {Router, RouteSegment, OnActivate, ROUTER_DIRECTIVES } from '@angular/router';
import { OnInit } from '@angular/core';
import { Observable } from 'rxjs/Observable';


@Component({
    selector: 'app-application-detail',
    templateUrl: './app/permissions/applicationDetail.html',
    directives: [ROUTER_DIRECTIVES, ErrorMessage]  // Note ErrorMessage is a directive
})
export class ApplicationDetail implements OnActivate
{
    @ViewChild(ErrorMessage) errorMsg: ErrorMessage;  // ErrorMessage is a ViewChild



    // yada yada


    onSubmit()
    {
        let result = this.permissionsService.SaveApplication(this.Application).subscribe(x =>
        {
            x.Error = true;
            x.Message = "This is a dummy error message";

            if (x.Error) {
                this.errorMsg.showErrorMessage(x.Message);
            }
            else {
                this.router.navigate(['/applicationsIndex']);
            }
        });
    }

}

parent.html

<app-error-message></app-error-message>
// your html...

3
अच्छा - समझा सकता हैclass="modal fade show in danger"
bensiu

@bensiu मैं अनुमान लगा रहा हूं कि क्लास चयनकर्ता का उपयोग नहीं किया गया है - जब तक कि उन सभी शब्दों के लिए सीएसएस शैली चयनकर्ता नहीं हैं जैसे 'में'
Drenai

इसके साथ आपको फीका / आउट प्रभाव कैसे मिलता है?
बिग मैक्लेरजैग

10

अब एनपीएम पैकेज के रूप में उपलब्ध है

कोणीय कस्टम मॉडल


@ स्टीफन पॉल निरंतरता ...

  • कोणीय 2 और बूटस्ट्रैप सीएसएस (एनीमेशन संरक्षित है)
  • सं JQuery
  • सं बूटस्ट्रैप। Js
  • कस्टम मोडल सामग्री का समर्थन करता है
  • एक दूसरे के ऊपर कई मोडल के लिए सपोर्ट।
  • Moduralized
  • मोडल के खुलने पर स्क्रॉल को अक्षम करें
  • दूर नेविगेट करने पर मोडल नष्ट हो जाता है।
  • आलसी सामग्री आरंभीकरण, जो ngOnDestroyमोडल से बाहर होने पर (एड) हो जाता है।
  • मोडल दिखाई देने पर पैरेंट स्क्रॉलिंग अक्षम हो जाती है

आलसी सामग्री आरंभीकरण

क्यों?

कुछ मामलों में आप बंद होने के बाद अपनी स्थिति को बनाए रखने के लिए मोडल नहीं करना चाहते हैं, बल्कि प्रारंभिक अवस्था में बहाल कर सकते हैं।

मूल मोडल मुद्दा

सामग्री को सीधे दृश्य में पास करना वास्तव में इसे उत्पन्न करता है इससे पहले कि मोडल प्राप्त होने से पहले ही इसे आरंभ कर देता है। मोडल में *ngIfरैपर का उपयोग करने पर भी ऐसी सामग्री को मारने का कोई तरीका नहीं है ।

उपाय

ng-templateng-templateजब तक ऐसा करने का आदेश नहीं दिया जाता है।

मेरी-component.module.ts

...
imports: [
  ...
  ModalModule
]

मेरी-component.ts

<button (click)="reuseModal.open()">Open</button>
<app-modal #reuseModal>
  <ng-template #header></ng-template>
  <ng-template #body>
    <app-my-body-component>
      <!-- This component will be created only when modal is visible and will be destroyed when it's not. -->
    </app-my-body-content>
    <ng-template #footer></ng-template>
</app-modal>

modal.component.ts

export class ModalComponent ... {
  @ContentChild('header') header: TemplateRef<any>;
  @ContentChild('body') body: TemplateRef<any>;
  @ContentChild('footer') footer: TemplateRef<any>;
 ...
}

modal.component.html

<div ... *ngIf="visible">
  ...
  <div class="modal-body">
    ng-container *ngTemplateOutlet="body"></ng-container>
  </div>

संदर्भ

मेरा कहना है कि नेट के आसपास उत्कृष्ट आधिकारिक और सामुदायिक प्रलेखन के बिना यह संभव नहीं होगा। यह आप में से कुछ को भी बेहतर तरीके से समझने में मदद कर सकता है ng-template, *ngTemplateOutletऔर @ContentChildकाम कर सकता है।

https://angular.io/api/common/NgTemplateOutlet
https://blog.angular-university.io/angular-ng-template-ng-container-ngtemplateoutlet/
https://medlog.com/claritydesignsystem/ng-content -इस-छुपा-डॉक्स-96a29d70d11b
https://netbasal.com/understanding-viewchildren-contentchildren-and-querylist-in-angular-896b0c689f6e
https://netbasal.com/understanding-viewchildren-contentchildren-and-querylist-in -angular-896b0c689f6e

पूर्ण कॉपी-पेस्ट समाधान

modal.component.html

<div
  (click)="onContainerClicked($event)"
  class="modal fade"
  tabindex="-1"
  [ngClass]="{'in': visibleAnimate}"
  [ngStyle]="{'display': visible ? 'block' : 'none', 'opacity': visibleAnimate ? 1 : 0}"
  *ngIf="visible">
  <div class="modal-dialog">
    <div class="modal-content">
      <div class="modal-header">
        <ng-container *ngTemplateOutlet="header"></ng-container>
        <button class="close" data-dismiss="modal" type="button" aria-label="Close" (click)="close()">×</button>
      </div>
      <div class="modal-body">
        <ng-container *ngTemplateOutlet="body"></ng-container>
      </div>
      <div class="modal-footer">
        <ng-container *ngTemplateOutlet="footer"></ng-container>
      </div>
    </div>
  </div>
</div>

modal.component.ts

/**
 * @Stephen Paul https://stackoverflow.com/a/40144809/2013580
 * @zurfyx https://stackoverflow.com/a/46949848/2013580
 */
import { Component, OnDestroy, ContentChild, TemplateRef } from '@angular/core';

@Component({
  selector: 'app-modal',
  templateUrl: 'modal.component.html',
  styleUrls: ['modal.component.scss'],
})
export class ModalComponent implements OnDestroy {
  @ContentChild('header') header: TemplateRef<any>;
  @ContentChild('body') body: TemplateRef<any>;
  @ContentChild('footer') footer: TemplateRef<any>;

  public visible = false;
  public visibleAnimate = false;

  ngOnDestroy() {
    // Prevent modal from not executing its closing actions if the user navigated away (for example,
    // through a link).
    this.close();
  }

  open(): void {
    document.body.style.overflow = 'hidden';

    this.visible = true;
    setTimeout(() => this.visibleAnimate = true, 200);
  }

  close(): void {
    document.body.style.overflow = 'auto';

    this.visibleAnimate = false;
    setTimeout(() => this.visible = false, 100);
  }

  onContainerClicked(event: MouseEvent): void {
    if ((<HTMLElement>event.target).classList.contains('modal')) {
      this.close();
    }
  }
}

modal.module.ts

import { NgModule } from '@angular/core';
import { CommonModule } from '@angular/common';

import { ModalComponent } from './modal.component';

@NgModule({
  imports: [
    CommonModule,
  ],
  exports: [ModalComponent],
  declarations: [ModalComponent],
  providers: [],
})
export class ModalModule { }

7

मैं अपने प्रोजेक्ट के लिए एनजीएक्स-बूटस्ट्रैप का उपयोग करता हूं।

आप यहां डेमो पा सकते हैं

गीथूब यहाँ है

कैसे इस्तेमाल करे:

  1. एनजीएक्स-बूटस्ट्रैप स्थापित करें

  2. अपने मॉड्यूल के लिए आयात करें

// RECOMMENDED (doesn't work with system.js)
import { ModalModule } from 'ngx-bootstrap/modal';
// or
import { ModalModule } from 'ngx-bootstrap';

@NgModule({
  imports: [ModalModule.forRoot(),...]
})
export class AppModule(){}
  1. सरल स्थिर मोडल
<button type="button" class="btn btn-primary" (click)="staticModal.show()">Static modal</button>
<div class="modal fade" bsModal #staticModal="bs-modal" [config]="{backdrop: 'static'}"
tabindex="-1" role="dialog" aria-labelledby="mySmallModalLabel" aria-hidden="true">
<div class="modal-dialog modal-sm">
   <div class="modal-content">
      <div class="modal-header">
         <h4 class="modal-title pull-left">Static modal</h4>
         <button type="button" class="close pull-right" aria-label="Close" (click)="staticModal.hide()">
         <span aria-hidden="true">&times;</span>
         </button>
      </div>
      <div class="modal-body">
         This is static modal, backdrop click will not close it.
         Click <b>&times;</b> to close modal.
      </div>
   </div>
</div>
</div>

4

यहाँ मोडल बूटस्ट्रैप कोणीय 2 घटक का मेरा पूरा कार्यान्वयन है:

मुझे लगता है कि आपके पास आपके टैग के नीचे मुख्य index.html फ़ाइल (साथ <html>और <body>टैग) <body>है:

  <script src="assets/js/jquery-2.1.1.js"></script>
  <script src="assets/js/bootstrap.min.js"></script>

modal.component.ts:

import { Component, Input, Output, ElementRef, EventEmitter, AfterViewInit } from '@angular/core';

declare var $: any;// this is very importnant (to work this line: this.modalEl.modal('show')) - don't do this (becouse this owerride jQuery which was changed by bootstrap, included in main html-body template): let $ = require('../../../../../node_modules/jquery/dist/jquery.min.js');

@Component({
  selector: 'modal',
  templateUrl: './modal.html',
})
export class Modal implements AfterViewInit {

    @Input() title:string;
    @Input() showClose:boolean = true;
    @Output() onClose: EventEmitter<any> = new EventEmitter();

    modalEl = null;
    id: string = uniqueId('modal_');

    constructor(private _rootNode: ElementRef) {}

    open() {
        this.modalEl.modal('show');
    }

    close() {
        this.modalEl.modal('hide');
    }

    closeInternal() { // close modal when click on times button in up-right corner
        this.onClose.next(null); // emit event
        this.close();
    }

    ngAfterViewInit() {
        this.modalEl = $(this._rootNode.nativeElement).find('div.modal');
    }

    has(selector) {
        return $(this._rootNode.nativeElement).find(selector).length;
    }
}

let modal_id: number = 0;
export function uniqueId(prefix: string): string {
    return prefix + ++modal_id;
}

modal.html:

<div class="modal inmodal fade" id="{{modal_id}}" tabindex="-1" role="dialog"  aria-hidden="true" #thisModal>
    <div class="modal-dialog">
        <div class="modal-content">
            <div class="modal-header" [ngClass]="{'hide': !(has('mhead') || title) }">
                <button *ngIf="showClose" type="button" class="close" (click)="closeInternal()"><span aria-hidden="true">&times;</span><span class="sr-only">Close</span></button>
                <ng-content select="mhead"></ng-content>
                <h4 *ngIf='title' class="modal-title">{{ title }}</h4>
            </div>
            <div class="modal-body">
                <ng-content></ng-content>
            </div>

            <div class="modal-footer" [ngClass]="{'hide': !has('mfoot') }" >
                <ng-content select="mfoot"></ng-content>
            </div>
        </div>
    </div>
</div>

और क्लाइंट एडिटर घटक में उपयोग का उदाहरण: क्लाइंट-एडिट-कंपोनेंट:

import { Component } from '@angular/core';
import { ClientService } from './client.service';
import { Modal } from '../common';

@Component({
  selector: 'client-edit',
  directives: [ Modal ],
  templateUrl: './client-edit.html',
  providers: [ ClientService ]
})
export class ClientEdit {

    _modal = null;

    constructor(private _ClientService: ClientService) {}

    bindModal(modal) {this._modal=modal;}

    open(client) {
        this._modal.open();
        console.log({client});
    }

    close() {
        this._modal.close();
    }

}

क्लाइंट-edit.html:

<modal [title]='"Some standard title"' [showClose]='true' (onClose)="close()" #editModal>{{ bindModal(editModal) }}
    <mhead>Som non-standart title</mhead>
    Some contents
    <mfoot><button calss='btn' (click)="close()">Close</button></mfoot>
</modal>

बेशक title, showClose, <mhead>और <mfoot>वैकल्पिक पैरामीटर / टैग की गिरफ्तारी।


2
इसके बजाय bindModal(modal) {this._modal=modal;}, आप कोणीय के ViewChildएनोटेशन का उपयोग कर सकते हैं , जैसे @ViewChild('editModal') _modal: Modal;:। यह पर्दे के पीछे आपके लिए बंधन को संभालता है।
डगलस लुडलो 14

2

ASUI संवाद जांचें जो रनटाइम पर बनाते हैं। उसे छिपाने और तर्क दिखाने की कोई जरूरत नहीं है। बस सेवा एओटी एएसयूआई एनपीएम का उपयोग करके रनटाइम पर एक घटक बनाएगी


: हाय अरविंद सिवम, कृपया इसे पढ़ें stackoverflow.com/help/promotion
पेंग

0

एनजी-विंडो का उपयोग करने की कोशिश करें, यह डेवलपर को एकल पृष्ठ अनुप्रयोगों में कई विंडोज़ को सरल तरीके से खोलने और पूर्ण नियंत्रण की अनुमति देता है, नो जेकरी, नो बूटस्ट्रैप।

यहाँ छवि विवरण दर्ज करें

एविलेबल कन्फ्यूजन

  • अधिकतम खिड़की
  • खिड़की को छोटा करें
  • कस्टम आकार,
  • कस्टम स्थिति
  • खिड़की खींचने योग्य है
  • मूल विंडो को ब्लॉक करें या नहीं
  • खिड़की केंद्र या नहीं
  • चिल्ड विंडो को मान पास करें
  • चिल्ड विंडो से पैरेंट विंडो तक मानों को पास करें
  • पैरेंट विंडो में चिल्ड विंडो बंद करने की बात सुनकर
  • अपने कस्टम श्रोता के साथ घटना का आकार बदलें
  • अधिकतम आकार के साथ खोलें या नहीं
  • विंडो आकार बदलने को सक्षम और अक्षम करें
  • अधिकतमकरण सक्षम और अक्षम करें
  • न्यूनतम सक्षम करें और अक्षम करें

-1 यह कैसे उपयोगी है? यह ओपी द्वारा निर्दिष्ट किसी भी आवश्यकता को संबोधित नहीं करता है। यह 4 वीं पोस्ट है जिसे मैं आपको अपना जवाब ट्रोल कर रहा हूं!
अवन

0

कोणीय 7 + NgBootstrap

मुख्य घटक से मोडल खोलने और इसे वापस करने के लिए परिणाम का एक सरल तरीका है। मैं यही चाहता था। मैंने एक स्टेप-बाय-स्टेप ट्यूटोरियल तैयार किया, जिसमें स्क्रैच से एक नया प्रोजेक्ट बनाना, नॉगटस्ट्रैप स्थापित करना और मोडल का निर्माण शामिल है। आप या तो इसे क्लोन कर सकते हैं या गाइड का पालन कर सकते हैं।

आशा है कि यह कोणीय के लिए नई मदद करता है।

https://github.com/wkaczurba/modal-demo

विवरण:

मोडल-सिंपल टेम्पलेट (modal-simple.component.html):

<ng-template #content let-modal>
  <div class="modal-header">
    <h4 class="modal-title" id="modal-basic-title">Are you sure?</h4>
    <button type="button" class="close" aria-label="Close" (click)="modal.dismiss('Cross click')">
      <span aria-hidden="true">&times;</span>
    </button>
  </div>
  <div class="modal-body">
    <p>You have not finished reading my code. Are you sure you want to close?</p>
  </div>
  <div class="modal-footer">
    <button type="button" class="btn btn-outline-dark" (click)="modal.close('yes')">Yes</button>
    <button type="button" class="btn btn-outline-dark" (click)="modal.close('no')">No</button>
  </div>
</ng-template>

Modal-simple.component.ts:

import { Component, OnInit, ViewChild, Output, EventEmitter } from '@angular/core';
import { NgbModal } from '@ng-bootstrap/ng-bootstrap';

@Component({
  selector: 'app-modal-simple',
  templateUrl: './modal-simple.component.html',
  styleUrls: ['./modal-simple.component.css']
})
export class ModalSimpleComponent implements OnInit {
  @ViewChild('content') content;
  @Output() result : EventEmitter<string> = new EventEmitter();

  constructor(private modalService : NgbModal) { }

  open() {
    this.modalService.open(this.content, {ariaLabelledBy: 'modal-simple-title'})
      .result.then((result) => { console.log(result as string); this.result.emit(result) }, 
        (reason) => { console.log(reason as string); this.result.emit(reason) })
  }

  ngOnInit() {
  }

}

इसका डेमो (app.component.html) - रिटर्न ईवेंट से निपटने का सरल तरीका:

<app-modal-simple #mymodal (result)="onModalClose($event)"></app-modal-simple>
<button (click)="mymodal.open()">Open modal</button>

<p>
Result is {{ modalCloseResult }}
</p>

modal बंद होने के बाद app.component.ts - onModalClosed को निष्पादित किया जाता है:

@Component({
  selector: 'app-root',
  templateUrl: './app.component.html',
  styleUrls: ['./app.component.css']
})
export class AppComponent {
  modalCloseResult : string;
  title = 'modal-demo';

  onModalClose(reason : string) {
    this.modalCloseResult = reason;
  }    
}

चियर्स

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.