dialogs.cxx

windows mobile phone source code

  PColour bdrcol;
  bdrcol.FromSYSCOLOR(COLOR_WINDOWFRAME);
  canvas.SetPenFgColour(bdrcol);
  canvas.SetFillFgColour(PColour::Clear);
  canvas.DrawRect(rect);

  rect.SetHeight(titleHeight+borderHeight);

  canvas.SetFillFgColour(owner->GetActiveTitleBkColour());
  canvas.FillRect(rect);

  PString title = GetTitle();
  canvas.SetTextFgColour(owner->GetActiveTitleFgColour());
  canvas.SetTextBkColour(owner->GetActiveTitleBkColour());
  canvas.SetFont(titleFont);
  canvas.DrawTextLine(rect.X() + titleHeight,
                      rect.Y() + borderHeight, title, NULL, title.GetLength());

  rect.SetWidth(titleHeight);
  rect.Inflate(-(int)borderWidth*2, -(int)borderHeight*2);
  canvas.SetFillFgColour(owner->GetButtonBkColour());
  canvas.DrawBevelledRect(rect, TRUE, FALSE);
}


void PFloatingDialog::GetCreateWinInfo(WNDCLASS & wndClass)
{
  PDialog::GetCreateWinInfo(wndClass);
  _styleBits = WS_POPUP|WS_CLIPCHILDREN|WS_BORDER|WS_SYSMENU;
  _exStyleBits |= WS_EX_TOPMOST;
}


///////////////////////////////////////////////////////////////////////////////
// PModalDialog

PModalDialog::~PModalDialog()
{
}


void PModalDialog::Construct()
{
  ok = cancel = NULL;
  runState = Initialising;
}


int PModalDialog::RunModal()
{
  runState = Running;

  owner->GetWindow()->Disable();

  OnInit();
  Show();

  if (PThread::Current() == owner) {
    while (runState == Running && owner->ProcessMessage())
      ;
  }
  else {
    while (runState == Running)
      handledMessageSignal.Wait();
  }

  return returnValue;
}


void PModalDialog::EndModal(int retVal)
{
  PInteractor * focus = GetFocusInteractor();
  if (focus != this && focus != NULL)
    focus->OnEndInput();

  owner->GetWindow()->Enable();
  Hide();
  returnValue = retVal;
  runState = Ended;
  PostMessage(_hWnd, WM_COMMAND, 0, 0);
}


void PModalDialog::GetCreateWinInfo(WNDCLASS & wndClass)
{
  PDialog::GetCreateWinInfo(wndClass);
  _styleBits |= DS_MODALFRAME;
  _exStyleBits |= WS_EX_DLGMODALFRAME;
}


void PModalDialog::InitStandardDialog()
{
//  EnumChildWindows(_hWnd, (WNDENUMPROC)EnumDlgChildren, (LPARAM)this);

  font = PRealFont((HFONT)(UINT)SendMessage(_hWnd, WM_GETFONT, 0, 0L));

  HDC hDC = GetDC(_hWnd);
  HBRUSH hBrush = (HBRUSH)(UINT)SendMessage(_hWnd,
#ifdef _WIN32
                      WM_CTLCOLORDLG, (WPARAM)hDC, (LPARAM)_hWnd);
#else
                      WM_CTLCOLOR, (WPARAM)hDC, MAKELONG(_hWnd, CTLCOLOR_DLG));
#endif
  ReleaseDC(_hWnd, hDC);

  if (hBrush == NULL)
    hBrush = (HBRUSH)PGET_CLASS_VALUE(_hWnd, HBRBACKGROUND);

  if (hBrush != NULL) {
    LOGBRUSH brush;
    GetObject(hBrush, sizeof(brush), (LPSTR)&brush);
    backgroundColour.FromCOLORREF(brush.lbColor);
  }

  runState = Running;
  _styleBits = GetWindowLong(_hWnd, GWL_STYLE) | WS_CLIPSIBLINGS;
  SetWindowLong(_hWnd, GWL_STYLE, _styleBits);
  _exStyleBits = GetWindowLong(_hWnd, GWL_EXSTYLE);
  OnInit();
}


///////////////////////////////////////////////////////////////////////////////
// PFileDialog

#if !defined(_WIN32)
typedef UINT (CALLBACK * LPOFNHOOKPROC)(HWND, UINT, WPARAM, LPARAM);
#endif

PFileDialog::PFileDialog(PInteractor * parent, PRESOURCE_ID resID)
  : PModalDialog(parent, resID)
{
  selChangeMessage = RegisterWindowMessage(LBSELCHSTRING);

  memset(&fileDlgInfo, 0, sizeof(fileDlgInfo));
  fileDlgInfo.lStructSize = sizeof(fileDlgInfo);
  fileDlgInfo.hwndOwner = parent->GetHWND();
  fileDlgInfo.hInstance = owner->GetInstance();
  fileBuffer[0] = '\0';
  fileDlgInfo.lpstrFile = fileBuffer;
  strcpy(customFilter, "All Files");
  memcpy(&customFilter[strlen(customFilter)+1], "*.*\0", 5);
  fileDlgInfo.lpstrCustomFilter = customFilter;
  fileDlgInfo.nMaxCustFilter = sizeof(customFilter);
  fileDlgInfo.nMaxFile = sizeof(fileBuffer);
#ifdef OFN_EXPLORER
  fileDlgInfo.Flags = OFN_ENABLEHOOK|OFN_HIDEREADONLY|OFN_NOVALIDATE|OFN_EXPLORER;
#else
  fileDlgInfo.Flags = OFN_ENABLEHOOK|OFN_HIDEREADONLY|OFN_NOVALIDATE;
#endif
  fileDlgInfo.lCustData = (DWORD)this;
  fileDlgInfo.lpfnHook =
            (LPOFNHOOKPROC)owner->GetWndProcPtr(PApplication::FileDlgProcType);
}


PFileDialog::~PFileDialog()
{
  if (_hWnd != P_DEAD_WINDOW)
    DestroyWindow(_hWnd);
}


void PFileDialog::SetTitle(const PString & title)
{
  if (_hWnd != NULL)
    PModalDialog::SetTitle(title);
  else {
    dlgTitle = title;
    fileDlgInfo.lpstrTitle = dlgTitle;
  }
}


void PFileDialog::WndProc()
{
  switch (_msg->event) {
    case WM_INITDIALOG :
      InitStandardDialog();
      return;

#ifndef OFN_EXPLORER
    case WM_COMMAND :
      switch (LOWORD(_msg->wParam)) {
        case IDOK : {
          directory = PDirectory();
          GetDlgItemText(_hWnd, 1152, fileBuffer, sizeof(fileBuffer));
          file = PFilePath(fileBuffer);
          OnOk();
          return;
        }

        case IDCANCEL :
          OnCancel();
          return;
      }
      break;
#endif

    case WM_NOTIFY:
      {
        OFNOTIFY * ofNotify = (OFNOTIFY *)_msg->lParam;
        HWND hDlg = ::GetParent(_hWnd);
        switch (ofNotify->hdr.code) {
          case CDN_FILEOK :
            SendMessage(hDlg, CDM_GETFOLDERPATH, sizeof(fileBuffer), (LPARAM)fileBuffer);
            directory = fileBuffer;
            SendMessage(hDlg, CDM_GETFILEPATH,   sizeof(fileBuffer), (LPARAM)fileBuffer);
            file = PFilePath(fileBuffer);
            OnOk();
            return;
        }
      }
      break;

    default:
      if (_msg->event == selChangeMessage)
        OnListSelection(_msg->wParam, LOWORD(_msg->lParam), HIWORD(_msg->lParam));
  }
  PModalDialog::WndProc();
}


void PFileDialog::OnOk()
{
  DefWndProc();
}


void PFileDialog::OnCancel()
{
  DefWndProc();
}


void PFileDialog::OnListSelection(UINT, UINT, UINT)
{
}


void PFileDialog::CreateHWND()
{
  PAssertAlways("Illegal operation on PFileDialog");
}


///////////////////////////////////////////////////////////////////////////////
// POpenFileDialog

POpenFileDialog::POpenFileDialog(PInteractor * parent, PRESOURCE_ID resID)
  : PFileDialog(parent, resID)
{
  fileDlgInfo.Flags |= OFN_FILEMUSTEXIST|OFN_PATHMUSTEXIST|OFN_OVERWRITEPROMPT;
  if (resID != PSTD_ID_DIALOG_OPEN_FILE) {
    fileDlgInfo.Flags |= OFN_ENABLETEMPLATE;
    fileDlgInfo.lpTemplateName = MAKEINTRESOURCE(resID);
  }
}


int POpenFileDialog::RunModal()
{
  fileDlgInfo.lpstrInitialDir = directory;
  lstrcpy(fileBuffer, defaultFilename);
  PString fileTypeStr;
  if (fileTypes.GetSize() != 0) {
    for (PINDEX i = 0; i < fileTypes.GetSize(); i++) {
      PString s = fileTypes[i];
      if (s.Find('\377') != P_MAX_INDEX)
        fileTypeStr += s + "\377";
      else {
        PString tmp("*");
        tmp += s + "\377";
        fileTypeStr += tmp + tmp;
      }
    }
    fileTypeStr += "\377";
    fileDlgInfo.lpstrFilter = fileTypeStr;
    for (LPSTR p = (LPSTR)fileDlgInfo.lpstrFilter; *p != '\0'; p++) {
      while (*p == '\377')
        *p++ = '\0';
    }
    fileDlgInfo.nFilterIndex = 1;
  }

  if (GetOpenFileName(&fileDlgInfo)) {
    runState = Ended;
    return TRUE;
  }

  DWORD err = CommDlgExtendedError();
#if defined(_WIN32)
  SetLastError(err);
#endif
  PAssertOS(err == 0);
  return FALSE;
}


void POpenFileDialog::SetFileTypes(const PStringArray & array)
{
  fileTypes = array;
  SetInitialFileType(GetFinalFileType());
}


void POpenFileDialog::SetInitialFileType(PINDEX i)
{
  if (i != P_MAX_INDEX)
    fileDlgInfo.nFilterIndex = i+1;
  else
    fileDlgInfo.nFilterIndex = 0;
}


void POpenFileDialog::SetInitialFileType(const PString & str)
{
  memset(customFilter, 0, sizeof(customFilter));
  strncpy(customFilter, str, sizeof(customFilter)-1);
  fileDlgInfo.nFilterIndex = 0;
}


PINDEX POpenFileDialog::GetFinalFileType() const
{
  if (fileDlgInfo.nFilterIndex > 0)
    return fileDlgInfo.nFilterIndex-1;

  return P_MAX_INDEX;
}


BOOL POpenFileDialog::GetFinalFileType(PString & str) const
{
  if ((PINDEX)fileDlgInfo.nFilterIndex > fileTypes.GetSize())
    return FALSE;

  if (fileDlgInfo.nFilterIndex > 0)
    str = fileTypes[fileDlgInfo.nFilterIndex-1];
  else
    str = &customFilter[strlen(customFilter)+1];

  return !str;
}


void POpenFileDialog::FilterFilesFromList()
{
  PINDEX i = 0;
  while (i < (PINDEX)SendDlgItemMessage(_hWnd, 1120, LB_GETCOUNT, 0, 0)) {
    char str[P_MAX_PATH];
    SendDlgItemMessage(_hWnd, 1120, LB_GETTEXT, i, (DWORD)str);
    if (OnFilterFile(str))
      i++;
    else
      SendDlgItemMessage(_hWnd, 1120, LB_DELETESTRING, i, 0);
  }
}


void POpenFileDialog::OnListSelection(UINT listBox, UINT item, UINT operation)
{
  if (listBox == 1120 && operation == CD_LBSELCHANGE) {
    char str[P_MAX_PATH];
    SendDlgItemMessage(_hWnd, 1120, LB_GETTEXT, item, (DWORD)str);
    OnFileSelect(str);
  }
  else if (listBox == 1121 && !fileTypes.IsEmpty())
    FilterFilesFromList();
}


void POpenFileDialog::WndProc()
{
  PFileDialog::WndProc();

  switch (_msg->event) {
    case WM_INITDIALOG :
      FilterFilesFromList();
      break;

    case WM_COMMAND :
      if (LOWORD(_msg->wParam) == IDOK)
        FilterFilesFromList();
      break;
  }
}


///////////////////////////////////////////////////////////////////////////////
// PSaveFileDialog

PSaveFileDialog::PSaveFileDialog(PInteractor * parent, PRESOURCE_ID resID)
  : PFileDialog(parent, resID)
{
  fileDlgInfo.Flags |= OFN_CREATEPROMPT;
  if (resID != PSTD_ID_DIALOG_SAVE_FILE) {
    fileDlgInfo.Flags |= OFN_ENABLETEMPLATE;
    fileDlgInfo.lpTemplateName = MAKEINTRESOURCE(resID);
  }
}


int PSaveFileDialog::RunModal()
{
  fileDlgInfo.lpstrInitialDir = directory;
  lstrcpy(fileBuffer, defaultFilename);
  if (GetSaveFileName(&fileDlgInfo)) {
    runState = Ended;
    return TRUE;
  }

  DWORD err = CommDlgExtendedError();
#if defined(_WIN32)
  SetLastError(err);
#endif
  PAssertOS(err == 0);
  return FALSE;
}


///////////////////////////////////////////////////////////////////////////////
// POpenDirDialog

POpenDirDialog::POpenDirDialog(PInteractor * parent, PRESOURCE_ID resID)
  : PFileDialog(parent, resID)
{
#ifdef OFN_EXPLORER
  fileDlgInfo.lpstrFilter = "~~a.ridiculous.extension\0A ridiculous extension\0";
  lstrcpy(fileBuffer, "~~a.ridiculous.filename~~");
  if (resID != PSTD_ID_DIALOG_OPEN_DIR) {
    fileDlgInfo.Flags |= OFN_ENABLETEMPLATE;
    fileDlgInfo.lpTemplateName = MAKEINTRESOURCE(resID);
  }
#else
  fileDlgInfo.Flags |= OFN_ENABLETEMPLATE;
  fileDlgInfo.lpTemplateName = MAKEINTRESOURCE(resID);
#endif
}


int POpenDirDialog::RunModal()
{
  fileDlgInfo.lpstrInitialDir = directory;
  if (GetOpenFileName(&fileDlgInfo)) {
    runState = Ended;
    return TRUE;
  }

  DWORD err = CommDlgExtendedError();
#if defined(_WIN32)
  SetLastError(err);
#endif
  PAssertOS(err == 0);
  return FALSE;
}


void POpenDirDialog::WndProc()
{
  switch (_msg->event) {
    case WM_INITDIALOG :
#ifdef OFN_EXPLORER
      {
        HWND dlgWnd = ::GetParent(_hWnd);
        ShowWindow(GetDlgItem(dlgWnd, 0x441), SW_HIDE);
        ShowWindow(GetDlgItem(dlgWnd, 0x470), SW_HIDE);
        ShowWindow(GetDlgItem(dlgWnd, 0x442), SW_HIDE);
        ShowWindow(GetDlgItem(dlgWnd, 0x480), SW_HIDE);
      }
#else
      SetDlgItemText(_hWnd, 1159, PDirectory());
#endif
      break;

#ifndef OFN_EXPLORER
    case WM_COMMAND :
      if (LOWORD(_msg->wParam) == IDOK) {
        GetDlgItemText(dlgWnd, 1159, fileBuffer, sizeof(fileBuffer));
        directory = PDirectory(fileBuffer);
        SetDlgItemText(dlgWnd, 1152, "xxxxxxxx.xxx");
      }
#endif
  }

  PFileDialog::WndProc();
}


void POpenDirDialog::OnListSelection(UINT, UINT, UINT)
{
#ifndef OFN_EXPLORER
  char str[P_MAX_PATH];
  GetDlgItemText(_hWnd, 1088, str, sizeof(str));
  SetDlgItemText(_hWnd, 1159, str);
#endif
}


///////////////////////////////////////////////////////////////////////////////
// PPrintDialog

#if !defined(_WIN32)