You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
791 lines
26 KiB
791 lines
26 KiB
//******************************************************************
|
|
// layout.cpp
|
|
//
|
|
// This file contains the code that lays out the CTrapEventDialog.
|
|
// This is neccessary when the edit/view button changes the
|
|
// dialog form its small (main) view to the extended view.
|
|
//
|
|
// Author: Larry A. French
|
|
//
|
|
// History:
|
|
// 20-Febuary-96 Wrote it
|
|
//
|
|
//
|
|
// Copyright (C) 1996 Microsoft Corporation. All rights reserved.
|
|
//******************************************************************
|
|
|
|
#include "stdafx.h"
|
|
#include "layout.h"
|
|
#include "trapdlg.h"
|
|
#include "trapreg.h"
|
|
#include "globals.h"
|
|
|
|
|
|
|
|
#define CX_MARGIN 10
|
|
#define CY_MARGIN 10
|
|
#define CY_LEADING 3
|
|
#define CY_DIALOG_FONT 8
|
|
|
|
|
|
class CDlgMetrics
|
|
{
|
|
public:
|
|
CDlgMetrics(CEventTrapDlg* pdlg);
|
|
CSize m_sizeMargin;
|
|
CSize m_sizeAddButton;
|
|
CSize m_sizeRemoveButton;
|
|
CSize m_sizeFindButton;
|
|
CSize m_sizeOKButton;
|
|
int m_cyLeading;
|
|
CSize m_sizeLabel0;
|
|
CSize m_sizeLabel1;
|
|
CSize m_sizeLabel2;
|
|
|
|
CSize m_sizeConfigTypeBox;
|
|
CSize m_sizeConfigCustomButton;
|
|
CSize m_sizeConfigDefaultButton;
|
|
};
|
|
|
|
|
|
//*****************************************************************
|
|
// CDlgMetrics::CDlgMetrics
|
|
//
|
|
// Construct an object containing the metrics for the CEventTrapDlg
|
|
//
|
|
// Parameters:
|
|
// CEventTrapDlg* pdlg
|
|
// Pointer to an instance of the main event trap dialog.
|
|
// This pointer is used to access members, such as buttons
|
|
// and so on so that they can be measured.
|
|
//
|
|
// Returns:
|
|
// The members of this class are valid on return.
|
|
//
|
|
//*****************************************************************
|
|
CDlgMetrics::CDlgMetrics(CEventTrapDlg* pdlg)
|
|
{
|
|
m_sizeMargin.cx = CX_MARGIN;
|
|
m_sizeMargin.cy = CY_MARGIN;
|
|
m_cyLeading = CY_LEADING;
|
|
|
|
CRect rc;
|
|
|
|
pdlg->m_btnAdd.GetWindowRect(&rc);
|
|
pdlg->ScreenToClient(&rc);
|
|
m_sizeAddButton = rc.Size();
|
|
|
|
pdlg->m_btnFind.GetWindowRect(&rc);
|
|
pdlg->ScreenToClient(&rc);
|
|
m_sizeFindButton = rc.Size();
|
|
|
|
pdlg->m_btnRemove.GetWindowRect(&rc);
|
|
pdlg->ScreenToClient(&rc);
|
|
m_sizeRemoveButton = rc.Size();
|
|
|
|
pdlg->m_statLabel0.GetWindowRect(&rc);
|
|
pdlg->ScreenToClient(&rc);
|
|
m_sizeLabel0 = rc.Size();
|
|
|
|
pdlg->m_statLabel1.GetWindowRect(&rc);
|
|
pdlg->ScreenToClient(&rc);
|
|
m_sizeLabel1 = rc.Size();
|
|
|
|
pdlg->m_statLabel2.GetWindowRect(&rc);
|
|
pdlg->ScreenToClient(&rc);
|
|
m_sizeLabel2 = rc.Size();
|
|
|
|
pdlg->m_btnOK.GetWindowRect(&rc);
|
|
pdlg->ScreenToClient(&rc);
|
|
m_sizeOKButton = rc.Size();
|
|
|
|
|
|
if (g_reg.m_bShowConfigTypeBox) {
|
|
pdlg->m_btnConfigTypeBox.GetWindowRect(&rc);
|
|
pdlg->ScreenToClient(&rc);
|
|
m_sizeConfigTypeBox = rc.Size();
|
|
|
|
pdlg->m_btnConfigTypeCustom.GetWindowRect(&rc);
|
|
pdlg->ScreenToClient(&rc);
|
|
m_sizeConfigCustomButton = rc.Size();
|
|
|
|
pdlg->m_btnConfigTypeDefault.GetWindowRect(&rc);
|
|
pdlg->ScreenToClient(&rc);
|
|
m_sizeConfigDefaultButton = rc.Size();
|
|
}
|
|
else {
|
|
// If the "Configuration type box will not be shown, then the size of the
|
|
// box and the radio buttons in it are all zero.
|
|
pdlg->m_btnConfigTypeBox.GetWindowRect(&rc);
|
|
m_sizeConfigTypeBox.cx = 0;
|
|
m_sizeConfigTypeBox.cy = 0;
|
|
|
|
m_sizeConfigCustomButton.cx = 0;
|
|
m_sizeConfigCustomButton.cy = 0;
|
|
|
|
m_sizeConfigDefaultButton.cx = 0;
|
|
m_sizeConfigDefaultButton.cy = 0;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
// CLASS: CMainLayout
|
|
//
|
|
// This class computes the position of various items for the main (small)
|
|
// view of the dialog. The metrics for each of these items is made
|
|
// available through public data members.
|
|
/////////////////////////////////////////////////////////////////////
|
|
class CMainLayout
|
|
{
|
|
public:
|
|
void Create(CDlgMetrics& metrics, CRect& rc);
|
|
CRect m_rc;
|
|
CRect m_rcLabel0;
|
|
CRect m_rcOKButton;
|
|
CRect m_rcCancelButton;
|
|
CRect m_rcApplyButton;
|
|
CRect m_rcPropertiesButton;
|
|
CRect m_rcSettingsButton;
|
|
CRect m_rcExportButton;
|
|
CRect m_rcViewButton;
|
|
CRect m_rcListView;
|
|
|
|
CRect m_rcConfigTypeBox;
|
|
CRect m_rcConfigCustomButton;
|
|
CRect m_rcConfigDefaultButton;
|
|
};
|
|
|
|
//*****************************************************************
|
|
// CMainLayout::Create
|
|
//
|
|
// Construct the layout for the main part of the dialog. This is
|
|
// the part where the add event stuff is hidden.
|
|
//
|
|
// Note: The caller is responsible for making sure that the
|
|
// specified rectangle is large enough so that the display
|
|
// still looks good. For example, it doesn't make sense to shrink
|
|
// the listview to a zero size or even negative size.
|
|
//
|
|
// Parameters:
|
|
// CDlgMetrics& metrics
|
|
// The dialog metrics containing the size of the things
|
|
// that appear on the dialog and so on.
|
|
//
|
|
// CRect& rc
|
|
// The rectangle where the main part of the dialog will be
|
|
// drawn.
|
|
//
|
|
// Returns:
|
|
// The members of this class are valid on return.
|
|
//
|
|
//*****************************************************************
|
|
void CMainLayout::Create(CDlgMetrics& metrics, CRect& rc)
|
|
{
|
|
m_rc = rc;
|
|
|
|
// The rectangle for this layout may actually extend beyond the size
|
|
// of the dialog window. This can occur when the user shrinks the dialog
|
|
// to a size smaller than the minimum for this layout.
|
|
//
|
|
// Things that are drawn outside of the dialog are clipped.
|
|
//
|
|
|
|
// Set the rectangle for the "Configuration Type" groupbox
|
|
m_rcConfigTypeBox.left = rc.left + metrics.m_sizeMargin.cx;
|
|
m_rcConfigTypeBox.top = rc.top + metrics.m_sizeMargin.cy;
|
|
m_rcConfigTypeBox.right = rc.right - (metrics.m_sizeOKButton.cx + 2 * metrics.m_sizeMargin.cx);
|
|
m_rcConfigTypeBox.bottom = m_rcConfigTypeBox.top + metrics.m_sizeConfigTypeBox.cy;
|
|
|
|
// Set the rectangle for the "Custom" radio button within the "Configuration Type" groupbox
|
|
// We place it right in the middle between the top and the bottom of the groupbox.
|
|
m_rcConfigCustomButton.left = m_rcConfigTypeBox.left + metrics.m_sizeMargin.cx;
|
|
m_rcConfigCustomButton.top = m_rcConfigTypeBox.top +
|
|
(metrics.m_sizeConfigTypeBox.cy/2 - metrics.m_sizeConfigCustomButton.cy/2) + CY_DIALOG_FONT/2;
|
|
m_rcConfigCustomButton.right = m_rcConfigCustomButton.left + metrics.m_sizeConfigCustomButton.cx;
|
|
m_rcConfigCustomButton.bottom = m_rcConfigCustomButton.top + metrics.m_sizeConfigCustomButton.cy;
|
|
|
|
// Set the rectangle for the "Default" radio button within the "Configuration Type" groupbox
|
|
m_rcConfigDefaultButton.left = m_rcConfigCustomButton.right + metrics.m_sizeMargin.cx;
|
|
m_rcConfigDefaultButton.top = m_rcConfigCustomButton.top;
|
|
m_rcConfigDefaultButton.right = m_rcConfigDefaultButton.left + metrics.m_sizeConfigDefaultButton.cx;
|
|
m_rcConfigDefaultButton.bottom = m_rcConfigCustomButton.bottom;
|
|
|
|
|
|
m_rcLabel0.left = m_rcConfigTypeBox.left;
|
|
m_rcLabel0.top = m_rcConfigTypeBox.bottom;
|
|
if (metrics.m_sizeConfigTypeBox.cy != 0) {
|
|
// If the configuration type groupbox is present, then the event list
|
|
// should be placed one margin height below it.
|
|
m_rcLabel0.top += metrics.m_sizeMargin.cy;
|
|
}
|
|
m_rcLabel0.right = m_rcLabel0.left + metrics.m_sizeLabel0.cx;
|
|
m_rcLabel0.bottom = m_rcLabel0.top + metrics.m_sizeLabel0.cy;
|
|
|
|
// Set the position of the top events listview.
|
|
m_rcListView.left = m_rcConfigTypeBox.left;
|
|
m_rcListView.top = m_rcLabel0.bottom + metrics.m_sizeMargin.cy;
|
|
m_rcListView.right = m_rcConfigTypeBox.right;
|
|
m_rcListView.bottom = rc.bottom - metrics.m_sizeMargin.cy;
|
|
|
|
// Set the position of the OK button
|
|
m_rcOKButton.left = m_rcListView.right + metrics.m_sizeMargin.cx;
|
|
m_rcOKButton.top = m_rcConfigTypeBox.top;
|
|
if (metrics.m_sizeConfigTypeBox.cy != 0) {
|
|
// If the configuration type groupbox is present, then the OK button should be
|
|
// moved down by half the dialog font height so that it lines up with the
|
|
// top of the groupbox's rectangle instead of the top of the group box's title.
|
|
m_rcOKButton.top += CY_DIALOG_FONT / 2;
|
|
}
|
|
m_rcOKButton.right = m_rcOKButton.left + metrics.m_sizeOKButton.cx;
|
|
m_rcOKButton.bottom = m_rcOKButton.top + metrics.m_sizeOKButton.cy;
|
|
|
|
// Compute the vertical distance between buttons.
|
|
int cyDelta = m_rcOKButton.Height() + metrics.m_sizeMargin.cy / 2;
|
|
|
|
// Set the position of the Cancel button
|
|
m_rcCancelButton = m_rcOKButton;
|
|
m_rcCancelButton.OffsetRect(0, cyDelta);
|
|
|
|
// Set the position of the Apply button
|
|
m_rcApplyButton = m_rcCancelButton;
|
|
m_rcApplyButton.OffsetRect(0, cyDelta);
|
|
|
|
// Set the position of the settings button
|
|
m_rcSettingsButton = m_rcApplyButton;
|
|
m_rcSettingsButton.OffsetRect(0, cyDelta);
|
|
|
|
// Set the position of the properties button
|
|
m_rcPropertiesButton = m_rcSettingsButton;
|
|
m_rcPropertiesButton.OffsetRect(0, cyDelta);
|
|
|
|
// Set the position of the export button
|
|
m_rcExportButton = m_rcPropertiesButton;
|
|
m_rcExportButton.OffsetRect(0, cyDelta);
|
|
|
|
// Set the position of the view button
|
|
m_rcViewButton = m_rcExportButton;
|
|
m_rcViewButton.OffsetRect(0, cyDelta);
|
|
}
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
// CLASS: CExtendedLayout
|
|
//
|
|
// This class computes the position of various items for the extended
|
|
// view of the dialog. The metrics for each of these items is made
|
|
// available through public data members.
|
|
/////////////////////////////////////////////////////////////////////
|
|
class CExtendedLayout
|
|
{
|
|
public:
|
|
void Create(CDlgMetrics& metrics, CRect& rc);
|
|
CRect m_rc;
|
|
CRect m_rcTreeView;
|
|
CRect m_rcListView;
|
|
CRect m_rcFindButton;
|
|
CRect m_rcAddButton;
|
|
CRect m_rcRemoveButton;
|
|
CRect m_rcLabel1;
|
|
CRect m_rcLabel2;
|
|
private:
|
|
};
|
|
|
|
|
|
|
|
//*****************************************************************
|
|
// CExtendedLayout::Create
|
|
//
|
|
// Construct the layout for the extended part of the dialog. This is
|
|
// the part where the add event stuff is shown.
|
|
//
|
|
// Note: The caller is responsible for making sure that the
|
|
// specified rectangle is large enough so that the display
|
|
// still looks good. For example, it doesn't make sense to shrink
|
|
// the listview to a zero size or even negative size.
|
|
//
|
|
// Parameters:
|
|
// CDlgMetrics& metrics
|
|
// The dialog metrics containing the size of the things
|
|
// that appear on the dialog and so on.
|
|
//
|
|
// CRect& rc
|
|
// The rectangle where the main part of the dialog will be
|
|
// drawn.
|
|
//
|
|
// Returns:
|
|
// The members of this class are valid on return.
|
|
//
|
|
//*****************************************************************
|
|
void CExtendedLayout::Create(CDlgMetrics& metrics, CRect& rc)
|
|
{
|
|
m_rc = rc;
|
|
|
|
CRect rcTemp;
|
|
// Calculate the combined width of the treeview and listview.
|
|
// We subtract 3 * CX_MARGIN because there is a margin on
|
|
// the left and right and another margin to separate the right
|
|
// side of the list view from the button.
|
|
int cxViews = rc.Width() - (2*metrics.m_sizeMargin.cx);
|
|
int cxTreeView = cxViews * 2 / 5;
|
|
int cxListView = cxViews - cxTreeView;
|
|
|
|
|
|
// Set the location of the add button. This should be aligned with
|
|
// the left side of the listview and one margin height below the
|
|
// top of the given rectangle.
|
|
m_rcAddButton.left = m_rc.left + metrics.m_sizeMargin.cx/2 + cxTreeView - metrics.m_sizeAddButton.cx;
|
|
m_rcAddButton.top = m_rc.top + metrics.m_cyLeading;
|
|
m_rcAddButton.right = m_rcAddButton.left + metrics.m_sizeAddButton.cx;
|
|
m_rcAddButton.bottom = m_rcAddButton.top + metrics.m_sizeAddButton.cy;
|
|
|
|
// Set the location of the remove button. This should be aligned with the
|
|
// top of the "Add" button and one margin size to the right of the add button.
|
|
m_rcRemoveButton.left = m_rcAddButton.right + metrics.m_sizeMargin.cx;
|
|
m_rcRemoveButton.top = m_rcAddButton.top;
|
|
m_rcRemoveButton.right = m_rcRemoveButton.left + metrics.m_sizeRemoveButton.cx;
|
|
m_rcRemoveButton.bottom = m_rcRemoveButton.top + metrics.m_sizeRemoveButton.cy;
|
|
|
|
|
|
// Set the location of label1. This is the label at the top-left
|
|
// of the tree control
|
|
m_rcLabel1.left = m_rc.left + metrics.m_sizeMargin.cx;
|
|
m_rcLabel1.top = m_rcRemoveButton.bottom + metrics.m_cyLeading + metrics.m_sizeMargin.cy;
|
|
m_rcLabel1.right = m_rcLabel1.left + metrics.m_sizeLabel1.cx;
|
|
m_rcLabel1.bottom = m_rcLabel1.top + metrics.m_sizeLabel1.cy;
|
|
|
|
|
|
// Set the location of label2. This is at the top-left of the list box.
|
|
m_rcLabel2.left = m_rcLabel1.left + cxTreeView;
|
|
m_rcLabel2.top = m_rcLabel1.top;
|
|
m_rcLabel2.right = m_rcLabel2.left + metrics.m_sizeLabel2.cx;
|
|
m_rcLabel2.bottom = m_rcLabel2.top + metrics.m_sizeLabel2.cy;
|
|
|
|
// Set the location of the tree view. This is one margin size from
|
|
// the left of m_rc and one margin size below the labels. The width
|
|
// has been calulated above. There is also a margin reserved on the
|
|
// bottom.
|
|
m_rcTreeView.left = m_rc.left + metrics.m_sizeMargin.cx;
|
|
m_rcTreeView.top = m_rcLabel2.bottom + 1; // + metrics.m_sizeMargin.cy;
|
|
m_rcTreeView.right = m_rcTreeView.left + cxTreeView;
|
|
m_rcTreeView.bottom = m_rc.bottom - metrics.m_sizeMargin.cy;
|
|
|
|
|
|
// Set the location of the list view. This is the same height as the
|
|
// tree view and aligned so that its left side is adjacent to the
|
|
// right side of the treeview. Its width has been calculated above.
|
|
m_rcListView.left = m_rcTreeView.right - 1;
|
|
m_rcListView.top = m_rcTreeView.top;
|
|
m_rcListView.right = m_rcListView.left + cxListView;
|
|
m_rcListView.bottom = m_rcTreeView.bottom;
|
|
|
|
|
|
// Set the location of the find button so that it is aligned with the top of the
|
|
// list view and so that its right side is one margin widh from m_rc.right.
|
|
m_rcFindButton.left = m_rc.right - metrics.m_sizeFindButton.cx - metrics.m_sizeMargin.cx;
|
|
m_rcFindButton.top = m_rcAddButton.top;
|
|
m_rcFindButton.right = m_rcFindButton.left + metrics.m_sizeFindButton.cx;
|
|
m_rcFindButton.bottom = m_rcFindButton.top + metrics.m_sizeFindButton.cy;
|
|
}
|
|
|
|
|
|
//************************************************************************
|
|
// CLayout::CLayout
|
|
//
|
|
// Constructor for CLayout. This class is used to layout the items on
|
|
// the CEventTrapDialog when it is changed from the large extended view to
|
|
// the small main view. This class also handles resizing the CEventTrapDialog.
|
|
//
|
|
// Parameters:
|
|
// None.
|
|
//
|
|
// Returns:
|
|
// Nothing.
|
|
//************************************************************************
|
|
CLayout::CLayout()
|
|
{
|
|
m_pdlg = NULL;
|
|
}
|
|
|
|
|
|
//************************************************************************
|
|
// CLayout::Initialize
|
|
//
|
|
// Take a snapshot of various initial attributes of the dialog and its
|
|
// items. These attributes are used later to constrain the size of the
|
|
// dialog and so on.
|
|
//
|
|
// This makes it possible to set certain characteristics of the dialog
|
|
// in the resource editor so that they do not need to be hard-coded here.
|
|
//
|
|
// Parameters:
|
|
// CEventTrapDlg* pdlg
|
|
// Pointer to the dialog that needs to be laid out, resized
|
|
// and so on.
|
|
//
|
|
// Returns:
|
|
// Nothing.
|
|
//
|
|
//***********************************************************************
|
|
void CLayout::Initialize(CEventTrapDlg* pdlg)
|
|
{
|
|
ASSERT(m_pdlg == NULL);
|
|
m_pdlg = pdlg;
|
|
|
|
// Dialog layout stuff
|
|
CRect rcWindow;
|
|
pdlg->GetWindowRect(&rcWindow);
|
|
|
|
CRect rcClient;
|
|
pdlg->GetClientRect(&rcClient);
|
|
|
|
|
|
CRect rcEventList;
|
|
pdlg->m_lcEvents.GetWindowRect(&rcEventList);
|
|
pdlg->ScreenToClient(&rcEventList);
|
|
|
|
|
|
m_sizeMainViewInitial.cx = rcClient.right;
|
|
m_sizeMainViewInitial.cy = rcEventList.bottom + CY_MARGIN;
|
|
|
|
|
|
m_sizeExtendedViewInitial.cx = rcClient.right;
|
|
m_sizeExtendedViewInitial.cy = rcClient.bottom;
|
|
|
|
m_cyMainView = 0;
|
|
m_cyExtendedView = 0;
|
|
}
|
|
|
|
|
|
//*************************************************************************
|
|
// CLayout::ResizeMainLayout
|
|
//
|
|
// This method resizes and repositions the dialog components that appear
|
|
// int the small dialog layout.
|
|
//
|
|
// Parameters:
|
|
// CMainLayout& layoutMain
|
|
// The layout information for the small (main) layout.
|
|
//
|
|
// Returns:
|
|
// Nothing.
|
|
//
|
|
//*************************************************************************
|
|
void CLayout::ResizeMainLayout(CMainLayout& layoutMain)
|
|
{
|
|
m_pdlg->m_btnConfigTypeBox.MoveWindow(&layoutMain.m_rcConfigTypeBox, TRUE);
|
|
m_pdlg->m_btnConfigTypeCustom.MoveWindow(&layoutMain.m_rcConfigCustomButton, TRUE);
|
|
m_pdlg->m_btnConfigTypeDefault.MoveWindow(&layoutMain.m_rcConfigDefaultButton, TRUE);
|
|
|
|
m_pdlg->m_btnOK.MoveWindow(&layoutMain.m_rcOKButton, TRUE);
|
|
m_pdlg->m_btnCancel.MoveWindow(&layoutMain.m_rcCancelButton, TRUE);
|
|
m_pdlg->m_btnApply.MoveWindow(&layoutMain.m_rcApplyButton, TRUE);
|
|
m_pdlg->m_btnProps.MoveWindow(&layoutMain.m_rcPropertiesButton, TRUE);
|
|
m_pdlg->m_btnSettings.MoveWindow(&layoutMain.m_rcSettingsButton, TRUE);
|
|
m_pdlg->m_btnExport.MoveWindow(&layoutMain.m_rcExportButton, TRUE);
|
|
m_pdlg->m_btnView.MoveWindow(&layoutMain.m_rcViewButton, TRUE);
|
|
m_pdlg->m_lcEvents.MoveWindow(&layoutMain.m_rcListView, TRUE);
|
|
}
|
|
|
|
|
|
|
|
//*************************************************************************
|
|
// CLayout::ResizeExtendedLayout
|
|
//
|
|
// This method resizes and repositions the dialog components that appear
|
|
// int the large (extended) dialog layout.
|
|
//
|
|
// Parameters:
|
|
// CExtendedLayout& layoutExtended
|
|
// The layout information for the large (extended) layout.
|
|
//
|
|
// Returns:
|
|
// Nothing.
|
|
//
|
|
//*************************************************************************
|
|
void CLayout::ResizeExtendedLayout(CExtendedLayout& layoutExtended)
|
|
{
|
|
m_pdlg->m_btnAdd.MoveWindow(&layoutExtended.m_rcAddButton, TRUE);
|
|
m_pdlg->m_btnRemove.MoveWindow(&layoutExtended.m_rcRemoveButton, TRUE);
|
|
m_pdlg->m_btnFind.MoveWindow(&layoutExtended.m_rcFindButton, TRUE);
|
|
m_pdlg->m_statLabel1.MoveWindow(&layoutExtended.m_rcLabel1, TRUE);
|
|
m_pdlg->m_statLabel2.MoveWindow(&layoutExtended.m_rcLabel2, TRUE);
|
|
m_pdlg->m_tcSource.MoveWindow(&layoutExtended.m_rcTreeView, TRUE);
|
|
m_pdlg->m_lcSource.MoveWindow(&layoutExtended.m_rcListView, TRUE);
|
|
}
|
|
|
|
|
|
|
|
|
|
//*************************************************************************
|
|
// CLayout::LayoutAndRedraw
|
|
//
|
|
// This lays out the size and position of each component on the dialog and
|
|
// then redraws the dialog according to the new layout.
|
|
//
|
|
// Parameters:
|
|
// BOOL bExtendedView
|
|
// TRUE if the layout should be for the large (extended) view of
|
|
// the dialog, FALSE if the layout should be for the small (main)
|
|
// view of the dialog.
|
|
//
|
|
// int cx
|
|
// The desired width of the dialog in screen units.
|
|
//
|
|
// int cy
|
|
// The desired height of the dialog in screen units.
|
|
//
|
|
// Returns:
|
|
// Nothing.
|
|
//
|
|
//*************************************************************************
|
|
void CLayout::LayoutAndRedraw(BOOL bExtendedView, int cx, int cy)
|
|
{
|
|
// If the user sizes the window smaller than its original size, then
|
|
// the window will begin to obscure what is already there rather than
|
|
// try to make things smaller. This avoids the problems that would
|
|
// occur if buttons and other controls overlapped each other.
|
|
BOOL bLayoutWidth = TRUE;
|
|
BOOL bLayoutHeight = TRUE;
|
|
|
|
if (bExtendedView) {
|
|
// Limit the minimum size of the extended view
|
|
if (cx < m_sizeExtendedViewInitial.cx) {
|
|
cx = m_sizeExtendedViewInitial.cx;
|
|
bLayoutWidth = FALSE;
|
|
}
|
|
|
|
if (cy < m_sizeExtendedViewInitial.cy) {
|
|
cy = m_sizeExtendedViewInitial.cy;
|
|
bLayoutHeight = FALSE;
|
|
}
|
|
m_cyExtendedView = cy;
|
|
}
|
|
else {
|
|
// Limit the minimum size for the small (main) view
|
|
if (cx < m_sizeMainViewInitial.cx) {
|
|
cx = m_sizeMainViewInitial.cx;
|
|
bLayoutWidth = FALSE;
|
|
}
|
|
|
|
if (cy < m_sizeMainViewInitial.cy) {
|
|
cy = m_sizeMainViewInitial.cy;
|
|
bLayoutHeight = FALSE;
|
|
}
|
|
m_cyMainView = cy;
|
|
}
|
|
|
|
|
|
|
|
CDlgMetrics metrics(m_pdlg);
|
|
CMainLayout layoutMain;
|
|
CExtendedLayout layoutExtended;
|
|
CRect rcMain;
|
|
CRect rcExtended;
|
|
|
|
int cyMain = cy;
|
|
if (bExtendedView) {
|
|
// For the extended view, half the space if given to the components that
|
|
// appear on the small (main) layout, and the extended components get
|
|
// half the space. Thus, the dialog is split horizontally at the half-way
|
|
// point for the extended view.
|
|
cyMain = cy / 2;
|
|
rcMain.SetRect(0, 0, cx, cy / 2);
|
|
layoutMain.Create(metrics, rcMain);
|
|
ResizeMainLayout(layoutMain);
|
|
|
|
// The extended component rectangle's top is at the half-way point. The bottom
|
|
// is at the bottom of the dialog.
|
|
rcExtended.SetRect(0, cy / 2, cx, cy);
|
|
layoutExtended.Create(metrics, rcExtended);
|
|
ResizeExtendedLayout(layoutExtended);
|
|
}
|
|
else {
|
|
// For the small (main) view, use the entire dialog.
|
|
rcMain.SetRect(0, 0, cx, cy);
|
|
layoutMain.Create(metrics, rcMain);
|
|
ResizeMainLayout(layoutMain);
|
|
}
|
|
|
|
|
|
// Redraw the entire client area to fix things up since much
|
|
// of the stuff in the client has moved around.
|
|
CRect rcClient;
|
|
m_pdlg->GetClientRect(&rcClient);
|
|
m_pdlg->InvalidateRect(&rcClient);
|
|
|
|
}
|
|
|
|
|
|
//**************************************************************
|
|
// CLayout::LayoutView
|
|
//
|
|
// This method lays out the position and size of the CEventTrap
|
|
// dialog and the items that appear on it.
|
|
//
|
|
// Parameters:
|
|
// BOOL bExtendedView
|
|
// TRUE if this is a request to layout the extended (large)
|
|
// view of the dialog. FALSE if this is a request to layout
|
|
// the small (main) view of the dialog.
|
|
//
|
|
// Returns:
|
|
// Nothing.
|
|
//**************************************************************
|
|
void CLayout::LayoutView(BOOL bExtendedView)
|
|
{
|
|
CRect rcWindow;
|
|
m_pdlg->GetWindowRect(&rcWindow);
|
|
|
|
CRect rcClient;
|
|
m_pdlg->GetClientRect(&rcClient);
|
|
m_pdlg->ClientToScreen(&rcClient);
|
|
|
|
// cx and cy are the width and height of the dialog in client units
|
|
// respectively. The code below will calculate new values for cx and
|
|
// cy to reflect the change from extended view to small (main) view
|
|
// or vice-versa.
|
|
int cx = rcClient.Width();
|
|
int cy = rcClient.Height();
|
|
int cxInitial = cx;
|
|
int cyInitial = cy;
|
|
|
|
// Compute the margins that intervene between the client
|
|
// rectangle and window rectangle.
|
|
int cxLeftMargin = rcClient.left - rcWindow.left;
|
|
int cyTopMargin = rcClient.top - rcWindow.top;
|
|
int cxRightMargin = rcWindow.right - rcClient.right;
|
|
int cyBottomMargin = rcWindow.bottom - rcClient.bottom;
|
|
|
|
|
|
CRect rc;
|
|
m_pdlg->GetClientRect(&rc);
|
|
|
|
if (bExtendedView) {
|
|
// Control comes here if we are changing from the small main view
|
|
// to the larger extended view. This causes the dialog to flip
|
|
// back to the previous size of the extended view. However this
|
|
// is constrained to a minimum of the original dialog size.
|
|
|
|
// Save the current height of the main view so that we can flip
|
|
// back to it later. Assume that the new height will be the
|
|
// height of the extended view when it was flipped the last time.
|
|
m_cyMainView = cy;
|
|
cy = m_cyExtendedView;
|
|
|
|
// Constrain the height so that the mimimum height is what it
|
|
// the initial height was for the extended view.
|
|
if (cx < m_sizeExtendedViewInitial.cx) {
|
|
cx = m_sizeExtendedViewInitial.cx;
|
|
}
|
|
|
|
if (cy < m_sizeExtendedViewInitial.cy) {
|
|
cy = m_sizeExtendedViewInitial.cy;
|
|
}
|
|
|
|
|
|
// The extended view should never be smaller than the main view.
|
|
// This check is necessary when the user resizes the window and
|
|
// then flips the view.
|
|
if (cy < m_cyMainView) {
|
|
cy = m_cyMainView;
|
|
}
|
|
|
|
|
|
|
|
rc.SetRect(0, 0, cx, cy);
|
|
|
|
// Check to see if the size changed, if not then do nothing.
|
|
// Otherwise, resize the window.
|
|
if ((cxInitial != cx) || (cyInitial != cy)) {
|
|
m_pdlg->ClientToScreen(&rc);
|
|
rc.left -= cxLeftMargin;
|
|
rc.top -= cyTopMargin;
|
|
rc.right += cxRightMargin;
|
|
rc.bottom += cyBottomMargin;
|
|
m_pdlg->MoveWindow(&rc, TRUE);
|
|
}
|
|
else {
|
|
LayoutAndRedraw(bExtendedView, cx, cy);
|
|
}
|
|
}
|
|
|
|
// The main view should never be taller than the extended view. This may
|
|
// check is necessary if the user resized the window and then flipped to the
|
|
// other view.
|
|
if (m_cyMainView > m_cyExtendedView) {
|
|
m_cyMainView = m_cyExtendedView;
|
|
}
|
|
|
|
// Show or hide the items in the extended portion of the dialog.
|
|
ShowExtendedView(bExtendedView);
|
|
|
|
|
|
if (!bExtendedView) {
|
|
// This used to be an extended view, now we need to
|
|
// go back to just the main view.
|
|
|
|
// Save the current extended view height and then flip back to the
|
|
// previously saved main (small) view height.
|
|
m_cyExtendedView = cy;
|
|
cy = m_cyMainView;
|
|
|
|
// Constrain the size to be at least as large as the initial size for
|
|
// the main (small) view.
|
|
if (cx < m_sizeMainViewInitial.cx) {
|
|
cx = m_sizeMainViewInitial.cx;
|
|
}
|
|
if (cy < m_sizeMainViewInitial.cy) {
|
|
cy = m_sizeMainViewInitial.cy;
|
|
}
|
|
|
|
|
|
// Resize the dialog only if the computed size is different
|
|
// from the current size. Moving the window to resize it will automatically
|
|
// cause it to be layed out correctly.
|
|
if ((cxInitial != cx) || (cyInitial != cy)) {
|
|
rc.SetRect(0, 0, cx, cy);
|
|
m_pdlg->ClientToScreen(&rc);
|
|
rc.left -= cxLeftMargin;
|
|
rc.top -= cyTopMargin;
|
|
rc.right += cxRightMargin;
|
|
rc.bottom += cyBottomMargin;
|
|
m_pdlg->MoveWindow(&rc, TRUE);
|
|
}
|
|
else {
|
|
LayoutAndRedraw(bExtendedView, cx, cy);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//**************************************************************
|
|
// CLayout::ShowExtendedView
|
|
//
|
|
// This method shows or hides the dialog items that make up the
|
|
// extended portion of the dialog.
|
|
//
|
|
// Parameters:
|
|
// BOOL bShowExtendedItems
|
|
// TRUE if the extended items should be shown, false if
|
|
// they should be hidden.
|
|
//
|
|
// Returns:
|
|
// Nothing.
|
|
//**************************************************************
|
|
void CLayout::ShowExtendedView(BOOL bShowExtendedItems)
|
|
{
|
|
m_pdlg->m_btnRemove.ShowWindow(bShowExtendedItems);
|
|
m_pdlg->m_btnAdd.ShowWindow(bShowExtendedItems);
|
|
m_pdlg->m_btnFind.ShowWindow(bShowExtendedItems);
|
|
m_pdlg->m_lcSource.ShowWindow(bShowExtendedItems);
|
|
m_pdlg->m_tcSource.ShowWindow(bShowExtendedItems);
|
|
m_pdlg->m_statLabel1.ShowWindow(bShowExtendedItems);
|
|
m_pdlg->m_statLabel2.ShowWindow(bShowExtendedItems);
|
|
}
|