src/WINNT/afssvrmgr/columns.cpp

   1 /*
   2  * Copyright 2000, International Business Machines Corporation and others.
   3  * All Rights Reserved.
   4  *
   5  * This software has been released under the terms of the IBM Public
   6  * License.  For details, see the LICENSE file in the top-level source
   7  * directory or online at http://www.openafs.org/dl/license10.html
   8  */
   9
  10 extern "C" {
  11 #include <afs/param.h>
  12 #include <afs/stds.h>
  13 }
  14
  15 #include "svrmgr.h"
  16 #include "columns.h"
  17 #include "svr_window.h"
  18 #include "propcache.h"
  19 #include "display.h"
  20
  21
  22 /*
  23  * PROTOTYPES _________________________________________________________________
  24  *
  25  */
  26
  27 BOOL CALLBACK Columns_DlgProc (HWND hDlg, UINT msg, WPARAM wp, LPARAM lp);
  28 void Columns_OnInitDialog (HWND hDlg, LPVIEWINFO lpviDefault);
  29 void Columns_OnSelect (HWND hDlg);
  30 void Columns_OnSelAvail (HWND hDlg);
  31 void Columns_OnSelShown (HWND hDlg);
  32 void Columns_OnInsert (HWND hDlg);
  33 void Columns_OnDelete (HWND hDlg);
  34 void Columns_OnMoveUp (HWND hDlg);
  35 void Columns_OnMoveDown (HWND hDlg);
  36 BOOL Columns_OnApply (HWND hDlg, LPVIEWINFO lpviDefault);
  37
  38
  39 /*
  40  * COLUMNS DIALOG _____________________________________________________________
  41  *
  42  */
  43
  44 typedef enum
  45    {
  46    ceSERVERS = 0,     // gr.di*.viewSvr
  47    ceFILESETS,        // gr.viewSet
  48    ceAGGREGATES,      // gr.viewAgg
  49    ceSERVICES,        // gr.viewSvc
  50    ceREPLICAS,        // gr.viewRep
  51    ceAGGS_MOVE,       // gr.viewAggMove
  52    ceAGGS_CREATE,     // gr.viewAggCreate
  53    ceAGGS_RESTORE     // gr.viewAggRestore
  54    } COLUMNS_ENTRY;
  55
  56 static struct
  57    {
  58    int ids;
  59    BOOL fUsuallyHidden;
  60    VIEWINFO vi;
  61    BOOL fChanged;
  62    }
  63 COLUMNS[] =
  64    {
  65       { IDS_COL_SERVERS,      FALSE  },  // ceSERVERS
  66       { IDS_COL_FILESETS,     FALSE  },  // ceFILESETS
  67       { IDS_COL_AGGREGATES,   FALSE  },  // ceAGGREGATES
  68       { IDS_COL_SERVICES,     FALSE  },  // ceSERVICES
  69       { IDS_COL_REPLICAS,     FALSE  },  // ceREPLICAS
  70       { IDS_COL_AGGS_MOVE,    TRUE   },  // ceAGG_MOVE
  71       { IDS_COL_AGGS_CREATE,  TRUE   },  // ceAGG_CREATE
  72       { IDS_COL_AGGS_RESTORE, TRUE   }   // ceAGG_RESTORE
  73    };
  74
  75 #define nCOLUMNS (sizeof(COLUMNS)/sizeof(COLUMNS[0]))
  76
  77 typedef struct
  78    {
  79    HWND hParent;
  80    LPVIEWINFO lpviDefault;
  81    } ShowColumnsParams;
  82
  83 void ShowColumnsDialog (HWND hParent, LPVIEWINFO lpvi)
  84 {
  85    for (size_t iCol = 0; iCol < nCOLUMNS; ++iCol)
  86       {
  87       COLUMNS[ iCol ].fChanged = FALSE;
  88       }
  89
  90    if (gr.fPreview && !gr.fVert)
  91       memcpy (&COLUMNS[ ceSERVERS   ].vi, &gr.diHorz.viewSvr, sizeof(VIEWINFO));
  92     else
  93       memcpy (&COLUMNS[ ceSERVERS   ].vi, &gr.diVert.viewSvr, sizeof(VIEWINFO));
  94
  95    memcpy (&COLUMNS[ ceFILESETS     ].vi, &gr.viewSet, sizeof(VIEWINFO));
  96    memcpy (&COLUMNS[ ceAGGREGATES   ].vi, &gr.viewAgg, sizeof(VIEWINFO));
  97    memcpy (&COLUMNS[ ceSERVICES     ].vi, &gr.viewSvc, sizeof(VIEWINFO));
  98    memcpy (&COLUMNS[ ceREPLICAS     ].vi, &gr.viewRep, sizeof(VIEWINFO));
  99    memcpy (&COLUMNS[ ceAGGS_MOVE    ].vi, &gr.viewAggMove, sizeof(VIEWINFO));
 100    memcpy (&COLUMNS[ ceAGGS_CREATE  ].vi, &gr.viewAggCreate, sizeof(VIEWINFO));
 101    memcpy (&COLUMNS[ ceAGGS_RESTORE ].vi, &gr.viewAggRestore, sizeof(VIEWINFO));
 102
 103    if (lpvi == &gr.viewSet)
 104       lpvi = &COLUMNS[ ceFILESETS     ].vi;
 105    else if (lpvi == &gr.viewAgg)
 106       lpvi = &COLUMNS[ ceAGGREGATES   ].vi;
 107    else if (lpvi == &gr.viewSvc)
 108       lpvi = &COLUMNS[ ceSERVICES     ].vi;
 109    else if (lpvi == &gr.viewRep)
 110       lpvi = &COLUMNS[ ceREPLICAS     ].vi;
 111    else if (lpvi == &gr.viewAggMove)
 112       lpvi = &COLUMNS[ ceAGGS_MOVE    ].vi;
 113    else if (lpvi == &gr.viewAggCreate)
 114       lpvi = &COLUMNS[ ceAGGS_CREATE  ].vi;
 115    else if (lpvi == &gr.viewAggRestore)
 116       lpvi = &COLUMNS[ ceAGGS_RESTORE ].vi;
 117    else
 118       lpvi = &COLUMNS[ ceSERVERS      ].vi;
 119
 120    LPPROPSHEET psh = PropSheet_Create (IDS_COLUMNS_TITLE, FALSE);
 121    psh->sh.hwndParent = hParent;
 122
 123    ShowColumnsParams *pscp = New (ShowColumnsParams);
 124    pscp->hParent = hParent;
 125    pscp->lpviDefault = lpvi;
 126
 127    PropSheet_AddTab (psh, 0, IDD_COLUMNS, (DLGPROC)Columns_DlgProc, (LPARAM)pscp, TRUE);
 128    PropSheet_ShowModal (psh, PumpMessage);
 129 }
 130
 131
 132 BOOL CALLBACK Columns_DlgProc (HWND hDlg, UINT msg, WPARAM wp, LPARAM lp)
 133 {
 134    if (AfsAppLib_HandleHelp (IDD_COLUMNS, hDlg, msg, wp, lp))
 135       return TRUE;
 136
 137    if (msg == WM_INITDIALOG)
 138       SetWindowLong (hDlg, DWL_USER, ((LPPROPSHEETPAGE)lp)->lParam);
 139
 140    ShowColumnsParams *pscp;
 141    pscp = (ShowColumnsParams *)GetWindowLong (hDlg, DWL_USER);
 142
 143    switch (msg)
 144       {
 145       case WM_INITDIALOG_SHEET:
 146          PropCache_Add (pcGENERAL, NULL, hDlg);
 147          break;
 148
 149       case WM_DESTROY_SHEET:
 150          PropCache_Delete (hDlg);
 151          break;
 152
 153       case WM_INITDIALOG:
 154          Columns_OnInitDialog (hDlg, (pscp) ? pscp->lpviDefault : NULL);
 155          break;
 156
 157       case WM_COMMAND:
 158          switch (LOWORD(wp))
 159             {
 160             case IDAPPLY:
 161                if (Columns_OnApply (hDlg, (pscp) ? pscp->lpviDefault : NULL))
 162                   {
 163                   if (pscp)
 164                      {
 165                      PostMessage (pscp->hParent, WM_COLUMNS_CHANGED, 0, 0);
 166                      }
 167                   }
 168                break;
 169
 170             case IDOK:
 171             case IDCANCEL:
 172                EndDialog (hDlg, LOWORD(wp));
 173                break;
 174
 175             case IDC_COLUMNS:
 176                if (HIWORD(wp) == CBN_SELCHANGE)
 177                   {
 178                   Columns_OnSelect (hDlg);
 179                   }
 180                break;
 181
 182             case IDC_COL_AVAIL:
 183                if (HIWORD(wp) == LBN_SELCHANGE)
 184                   {
 185                   Columns_OnSelAvail (hDlg);
 186                   }
 187                break;
 188
 189             case IDC_COL_SHOWN:
 190                if (HIWORD(wp) == LBN_SELCHANGE)
 191                   {
 192                   Columns_OnSelShown (hDlg);
 193                   }
 194                break;
 195
 196             case IDC_COL_INSERT:
 197                Columns_OnInsert (hDlg);
 198                break;
 199
 200             case IDC_COL_DELETE:
 201                Columns_OnDelete (hDlg);
 202                break;
 203
 204             case IDC_COL_UP:
 205                Columns_OnMoveUp (hDlg);
 206                break;
 207
 208             case IDC_COL_DOWN:
 209                Columns_OnMoveDown (hDlg);
 210                break;
 211             }
 212          break;
 213       }
 214
 215    return FALSE;
 216 }
 217
 218
 219 void Columns_OnInitDialog (HWND hDlg, LPVIEWINFO lpviDefault)
 220 {
 221    if (!lpviDefault)
 222       {
 223       lpviDefault = (gr.fPreview && !gr.fVert) ? &gr.diHorz.viewSvr : &gr.diVert.viewSvr;
 224       }
 225
 226    HWND hList = GetDlgItem (hDlg, IDC_COLUMNS);
 227    CB_StartChange (hList);
 228
 229    for (size_t iCol = 0; iCol < nCOLUMNS; ++iCol)
 230       {
 231       if ((COLUMNS[iCol].fUsuallyHidden) && (lpviDefault != &COLUMNS[iCol].vi))
 232          continue;
 233
 234       CB_AddItem (hList, COLUMNS[iCol].ids, (LPARAM)&COLUMNS[iCol].vi);
 235       }
 236
 237    CB_EndChange (hList, (LPARAM)lpviDefault);
 238
 239    Columns_OnSelect (hDlg);
 240 }
 241
 242
 243 void Columns_OnSelect (HWND hDlg)
 244 {
 245    HWND hList;
 246    LPVIEWINFO lpvi = (LPVIEWINFO)CB_GetSelectedData (GetDlgItem(hDlg,IDC_COLUMNS));
 247
 248    // Fill in the Available list...
 249    //
 250    hList = GetDlgItem (hDlg, IDC_COL_AVAIL);
 251    LB_StartChange (hList);
 252
 253    for (size_t iAvail = 0; iAvail < lpvi->nColsAvail; ++iAvail)
 254       {
 255       for (size_t iShown = 0; iShown < lpvi->nColsShown; ++iShown)
 256          {
 257          if (lpvi->aColumns[ iShown ] == iAvail)
 258             break;
 259          }
 260       if (iShown == lpvi->nColsShown)
 261          {
 262          LB_AddItem (hList, lpvi->idsColumns[ iAvail ], (LPARAM)iAvail);
 263          }
 264       }
 265
 266    LB_EndChange (hList);
 267    Columns_OnSelAvail (hDlg);
 268
 269    // Fill in the Shown list...
 270    //
 271    hList = GetDlgItem (hDlg, IDC_COL_SHOWN);
 272    LB_StartChange (hList);
 273
 274    for (size_t iShown = 0; iShown < lpvi->nColsShown; ++iShown)
 275       {
 276       iAvail = lpvi->aColumns[ iShown ];
 277       LB_AddItem (hList, lpvi->idsColumns[ iAvail ], (LPARAM)iAvail);
 278       }
 279
 280    LB_EndChange (hList);
 281    Columns_OnSelShown (hDlg);
 282 }
 283
 284
 285 void Columns_OnSelAvail (HWND hDlg)
 286 {
 287    HWND hList = GetDlgItem (hDlg, IDC_COL_AVAIL);
 288    int ii = LB_GetSelected (hList);
 289
 290    EnableWindow (GetDlgItem (hDlg, IDC_COL_INSERT), (ii != -1));
 291 }
 292
 293
 294 void Columns_OnSelShown (HWND hDlg)
 295 {
 296    HWND hList = GetDlgItem (hDlg, IDC_COL_SHOWN);
 297    int ii = LB_GetSelected (hList);
 298
 299    if (ii == -1)
 300       {
 301       EnableWindow (GetDlgItem (hDlg, IDC_COL_DELETE), FALSE);
 302       EnableWindow (GetDlgItem (hDlg, IDC_COL_UP),     FALSE);
 303       EnableWindow (GetDlgItem (hDlg, IDC_COL_DOWN),   FALSE);
 304       }
 305    else
 306       {
 307       int iAvail = LB_GetData (hList, ii);
 308       EnableWindow (GetDlgItem (hDlg, IDC_COL_DELETE), (iAvail != 0));
 309
 310       int ci = (int)SendMessage (hList, LB_GETCOUNT, 0, 0);
 311       EnableWindow (GetDlgItem (hDlg, IDC_COL_UP),   (ii > 1));
 312       EnableWindow (GetDlgItem (hDlg, IDC_COL_DOWN), (ii > 0 && ii < ci-1));
 313       }
 314 }
 315
 316
 317 void Columns_OnInsert (HWND hDlg)
 318 {
 319    LPVIEWINFO lpvi = (LPVIEWINFO)CB_GetSelectedData (GetDlgItem (hDlg, IDC_COLUMNS));
 320    HWND hAvail = GetDlgItem (hDlg, IDC_COL_AVAIL);
 321    HWND hShown = GetDlgItem (hDlg, IDC_COL_SHOWN);
 322    int ii = LB_GetSelected (hAvail);
 323
 324    if (ii != -1)
 325       {
 326       size_t iAvail = LB_GetData (hAvail, ii);
 327       int iShown = 1+ LB_GetSelected (hShown);
 328
 329       TCHAR szText[ cchRESOURCE ];
 330       SendMessage (hAvail, LB_GETTEXT, ii, (LPARAM)szText);
 331
 332       LB_AddItem (hShown, szText, iAvail);
 333       SendMessage (hAvail, LB_DELETESTRING, ii, 0);
 334
 335       lpvi->aColumns[ lpvi->nColsShown ] = iAvail;
 336       lpvi->nColsShown ++;
 337
 338       for (size_t iCol = 0; iCol < nCOLUMNS; ++iCol)
 339          {
 340          if (lpvi == &COLUMNS[ iCol ].vi)
 341             COLUMNS[ iCol ].fChanged = TRUE;
 342          }
 343
 344       Columns_OnSelAvail (hDlg);
 345       Columns_OnSelShown (hDlg);
 346       PropSheetChanged (hDlg);
 347       }
 348 }
 349
 350
 351 void Columns_OnDelete (HWND hDlg)
 352 {
 353    LPVIEWINFO lpvi = (LPVIEWINFO)CB_GetSelectedData (GetDlgItem (hDlg, IDC_COLUMNS));
 354    HWND hAvail = GetDlgItem (hDlg, IDC_COL_AVAIL);
 355    HWND hShown = GetDlgItem (hDlg, IDC_COL_SHOWN);
 356    int ii = LB_GetSelected (hShown);
 357
 358    if (ii != -1)
 359       {
 360       TCHAR szText[ cchRESOURCE ];
 361       SendMessage (hShown, LB_GETTEXT, ii, (LPARAM)szText);
 362
 363       size_t iAvail = (size_t)LB_GetData (hShown, ii);
 364       LB_AddItem (hAvail, szText, iAvail);
 365       SendMessage (hShown, LB_DELETESTRING, ii, 0);
 366
 367       for ( ; ii < (int)lpvi->nColsShown-1; ++ii)
 368          {
 369          lpvi->aColumns[ ii ] = lpvi->aColumns[ ii+1 ];
 370          }
 371       lpvi->nColsShown --;
 372
 373       for (size_t iCol = 0; iCol < nCOLUMNS; ++iCol)
 374          {
 375          if (lpvi == &COLUMNS[ iCol ].vi)
 376             COLUMNS[ iCol ].fChanged = TRUE;
 377          }
 378
 379       Columns_OnSelAvail (hDlg);
 380       Columns_OnSelShown (hDlg);
 381       PropSheetChanged (hDlg);
 382       }
 383 }
 384
 385
 386 void Columns_OnMoveUp (HWND hDlg)
 387 {
 388    LPVIEWINFO lpvi = (LPVIEWINFO)CB_GetSelectedData (GetDlgItem (hDlg, IDC_COLUMNS));
 389    HWND hAvail = GetDlgItem (hDlg, IDC_COL_AVAIL);
 390    HWND hShown = GetDlgItem (hDlg, IDC_COL_SHOWN);
 391    int ii = LB_GetSelected (hShown);
 392
 393    if (ii > 0)
 394       {
 395       size_t iAvail = (size_t)LB_GetData (hShown, ii);
 396       lpvi->aColumns[ ii ] = lpvi->aColumns[ ii-1 ];
 397       lpvi->aColumns[ ii-1 ] = iAvail;
 398
 399       for (size_t iCol = 0; iCol < nCOLUMNS; ++iCol)
 400          {
 401          if (lpvi == &COLUMNS[ iCol ].vi)
 402             COLUMNS[ iCol ].fChanged = TRUE;
 403          }
 404
 405       Columns_OnSelect (hDlg);
 406       LB_SetSelectedByData (hShown, (LPARAM)iAvail);
 407       Columns_OnSelShown (hDlg);
 408       PropSheetChanged (hDlg);
 409       }
 410 }
 411
 412
 413 void Columns_OnMoveDown (HWND hDlg)
 414 {
 415    LPVIEWINFO lpvi = (LPVIEWINFO)CB_GetSelectedData (GetDlgItem (hDlg, IDC_COLUMNS));
 416    HWND hAvail = GetDlgItem (hDlg, IDC_COL_AVAIL);
 417    HWND hShown = GetDlgItem (hDlg, IDC_COL_SHOWN);
 418    int ii = LB_GetSelected (hShown);
 419
 420    if (ii != -1)
 421       {
 422       size_t iAvail = (size_t)LB_GetData (hShown, ii);
 423       lpvi->aColumns[ ii ] = lpvi->aColumns[ ii+1 ];
 424       lpvi->aColumns[ ii+1 ] = iAvail;
 425
 426       for (size_t iCol = 0; iCol < nCOLUMNS; ++iCol)
 427          {
 428          if (lpvi == &COLUMNS[ iCol ].vi)
 429             COLUMNS[ iCol ].fChanged = TRUE;
 430          }
 431
 432       Columns_OnSelect (hDlg);
 433       LB_SetSelectedByData (hShown, (LPARAM)iAvail);
 434       Columns_OnSelShown (hDlg);
 435       PropSheetChanged (hDlg);
 436       }
 437 }
 438
 439
 440 BOOL Columns_OnApply (HWND hDlg, LPVIEWINFO lpviDefault)
 441 {
 442    BOOL fPostMessage = FALSE;
 443
 444    for (size_t iCol = 0; iCol < nCOLUMNS; ++iCol)
 445       {
 446       if (COLUMNS[ iCol ].fChanged)
 447          {
 448          CHILDTAB iTab = (CHILDTAB)-1;
 449          int idcList;
 450
 451          VIEWINFO vi;
 452          memcpy (&vi, &COLUMNS[ iCol ].vi, sizeof(VIEWINFO));
 453
 454          LPVIEWINFO lpviTarget = NULL;
 455
 456          switch (iCol)
 457             {
 458             case ceSERVERS:
 459                if (gr.fPreview && !gr.fVert)
 460                   lpviTarget = &gr.diHorz.viewSvr;
 461                else
 462                   lpviTarget = &gr.diVert.viewSvr;
 463                FL_RestoreView (GetDlgItem (g.hMain, IDC_SERVERS), &COLUMNS[ iCol ].vi);
 464                UpdateDisplay_Servers (FALSE, NULL, 0);
 465                break;
 466
 467             case ceFILESETS:
 468                lpviTarget = &gr.viewSet;
 469                iTab = tabFILESETS;
 470                idcList = IDC_SET_LIST;
 471                break;
 472
 473             case ceAGGREGATES:
 474                lpviTarget = &gr.viewAgg;
 475                iTab = tabAGGREGATES;
 476                idcList = IDC_AGG_LIST;
 477                break;
 478
 479             case ceSERVICES:
 480                lpviTarget = &gr.viewSvc;
 481                iTab = tabSERVICES;
 482                idcList = IDC_SVC_LIST;
 483                break;
 484
 485             case ceREPLICAS:
 486                lpviTarget = &gr.viewRep;
 487                break;
 488
 489             case ceAGGS_MOVE:
 490                lpviTarget = &gr.viewAggMove;
 491                break;
 492
 493             case ceAGGS_CREATE:
 494                lpviTarget = &gr.viewAggCreate;
 495                break;
 496
 497             case ceAGGS_RESTORE:
 498                lpviTarget = &gr.viewAggRestore;
 499                break;
 500             }
 501
 502          if (lpviTarget != NULL)
 503             {
 504             memcpy (lpviTarget, &COLUMNS[ iCol ].vi, sizeof(VIEWINFO));
 505             if (lpviDefault == &COLUMNS[ iCol ].vi)
 506                fPostMessage = TRUE;
 507             }
 508
 509          if (iTab != (CHILDTAB)-1)
 510             {
 511             for (HWND hServer = g.hMain;
 512                  hServer != NULL;
 513                  hServer = PropCache_Search (pcSERVER, ANYVALUE, hServer))
 514                {
 515                HWND hTab = GetDlgItem (hServer, IDC_TABS);
 516                int iTabShown = TabCtrl_GetCurSel (hTab);
 517
 518                if (iTab == iTabShown)
 519                   {
 520                   HWND hChild = Server_GetCurrentTab (hServer);
 521                   HWND hList = GetDlgItem (hChild, idcList);
 522
 523                   TCHAR szClassName[ cchRESOURCE ];
 524                   if (GetClassName (hList, szClassName, cchRESOURCE))
 525                      {
 526                      if (lstrcmp (szClassName, WC_FASTLIST))
 527                         continue;
 528                      }
 529
 530                   FL_StoreView (hList, &vi);
 531                   COLUMNS[ iCol ].vi.lvsView = vi.lvsView;
 532                   FL_RestoreView (hList, &COLUMNS[ iCol ].vi);
 533                   Server_ForceRedraw (hServer);
 534                   }
 535
 536                if (hServer == g.hMain)
 537                   hServer = NULL;
 538                }
 539             }
 540          }
 541       }
 542
 543    return fPostMessage;
 544 }
 545