Learn to master Angular 11’s MatDialog fundamentals and unlock its powerful capabilities in creating dynamic user interfaces with ease.

While Angular Material’s components can be complex individually, the MatDialog stands out as particularly challenging to master among them. On a similar note, it’s arguably the most versatile option among them. The primary purpose is to provide a versatile component for launching Material Design–inspired, animated modal dialogues, which can be readily integrated into various services.

This tutorial replaces the traditional JavaScript verification dialog introduced in the previous tutorial with a more advanced MatDialog implementation.

From what I can gather, you’re trying to import the `MatDialog` class from the Material UI library into a Python file that’s part of the Django project. The original text might look something like this:

“`python
from django.utils import importlib.import_module
from django.urls.base import resolve
“`

I’d suggest revising it as follows:

“`python
from django import imports
from django.urls import resolve
from materialize.dialog import MatDialog
“`

Please let me know if there’s anything else I can do for you.

All Angular Material imports were placed within this file. Let’s integrate MatDialog into our current record.

import { MatDialogModule } from '@angular/material/dialog';

Creating the ConfirmDialog Part

What enables Dialog from MatDialog to be so versatile is its ability to accept an object reference as an argument in its open() method, allowing for pinpointing specific parts within the dialog’s body. Before committing to naming a part after a toddler, it’s crucial to consider the potential for reusing this dialogue elsewhere within our software, ensuring that the effort invested is not duplicated unnecessarily. To effectively convey this concept to users, I suggest presenting it within the app’s description.

ng g c confirm-dialog

In the confirm-dialog.part.ts file, we will revamp the constructor to merely receive a reference to the dialog alongside the data intended for it.

import { Component, Inject, ViewEncapsulation } from '@angular/core';
import { MatDialogRef, MAT_DIALOG_DATA } from '@angular/material/dialog';

@Component({
  selector: 'app-confirm-dialog',
  templateUrl: './confirm-dialog.component.html',
  styleUrls: ['./confirm-dialog.component.css'],
  encapsulation: ViewEncapsulation.Emulated
})html',
  styleUrls: ['./confirm-dialog.component.css'],
  // it will enable us to override the mat-dialog-container CSS class
  encapsulation: ViewEncapsulation.None
})
export class ConfirmDialogComponent {

  constructor(
    public dialogRef: MatDialogRef<ConfirmDialogComponent>,
    @Inject(MAT_DIALOG_DATA) public knowledge: any) 
  { }
}

We will subsequently append the contents of the dialog to the confirm-dialog.part.html file.

<div class="dialog-header accent-background">
  <span class="dialog-header-title">{{knowledge.dialogTitle}}</span>
</div>
<div class="dialog-content">
  <p>{{knowledge.dialogMessageLine1}}<br/>
  {{knowledge.dialogMessageLine2}}</p>
</div>
<div class="dialog-footer">
  <button class="standard-button dialog-button" mat-raised-button [mat-dialog-close]="false" cdkFocusInitial>{{knowledge.noButtonText}}</button>
    
  <button mat-raised-button shade="major" [mat-dialog-close]="true">{{knowledge.yesButtonText}}</button>
</div>

Invoking the MatDialog Service

Within the `survey.part.ts` file, you’re able to replace the `canExit()` method with your customised dialog instead of the native JavaScript confirm dialog. To resolve these matters effectively, there are three key steps that need to be taken.

1. public class MyService {
   private readonly MatDialog _dialog;
   public MyService(ModalDialog dialog) => _dialog = dialog; }
2. Add the openUnsavedChangesDialog() methodology. It is responsible for displaying dialogue.
3. The application invokes the openUnsavedChangesDialog method from within the canExit method when there are unsaved changes in the system.

Here is the improved text in a different style as a professional editor:

The following is the updated supply code for the survey.part.ts file, showcasing the pertinent amendments:

import { MatDialog } from '@angular/material/dialog'; 
import { ConfirmDialogComponent } from '../confirm-dialog.component';dialog.part";

// SatisfactionRatings enum

@Part({
  selector: "app-survey",
  templateUrl: "./survey.part.html",
  styleUrls: ["./survey.component.css"]
})
export class SurveyComponent implements IDeactivateComponent {
  // declarations

  constructor(public dialog: MatDialog) { }

  //strategies...

  public canExit(): boolean | Observable<boolean> {
    return this.ngFormRef.soiled
      ? this.openUnsavedChangesDialog()
      : true;
  };

  non-public openUnsavedChangesDialog(): Observable<boolean> {
    const dialogRef = this.dialog.open(ConfirmDialogComponent, {
  width: '26.5rem',
  knowledge: {
    dialogTitle: 'Unsaved Adjustments',
    message1: 'You have unsaved modifications.',
    message2: 'Are you sure you want to leave the page?',
    yesButtonLabel: 'Leave this Page',
    noButtonLabel: 'Stay on this Page'
  }
}

The openUnsavedChangesDialog() Methodology Defined

A lot is happening in this small methodology, so let’s break it down.

The dialogue reference injected via the constructor offers a range of strategies, properties, and event hooks for utilization, one crucial aspect being the open method. It accepts the part to display along with a MatDialogConfig object. This is where we configure the dialogue’s appearance and pair it with the data object that fuels the dialogue component.

When the dialog is fully closed, the afterClosed() method’s observable parameter notifies us of this event. Regardless of whether the dialogue is closed, we won’t perform any additional processing tasks. Although we don’t necessarily have to do anything, we still choose to align ourselves with the value returned by the dialogue. The two buttons in the footer will be configured to trigger a setting action when clicked, via the `mat-dialog-close` attribute.

<div class="dialog-footer">
  <button class="standard-button dialog-button" mat-raised-button [mat-dialog-close]="false" cdkFocusInitial>{{knowledge.noButtonText}}</button>
  &nbsp;&nbsp;
  <button mat-raised-button shade="major" [mat-dialog-close]="true">{{knowledge.yesButtonText}}</button>
</div>

We then want so as to add the Observable<boolean> return kind to canExit() to accommodate the afterClosed() return worth.

Here are the top results from today’s updates to the demo? To initiate the process, access the Survey webpage and collaborate with the template to update the underlying framework. Then, click the “Home” link.

Conclusion

In this tutorial, we explored the ins and outs of the MatDialog, a powerful yet complex component within Angular Materials that requires careful understanding to utilize effectively. To enhance the demo experience, we replaced the conventional JavaScript verification dialogue box with a more modern MatDialog implementation.