示例#1
0
int PalFile::check_volume( ldh_tSession ldhses, char *name)
{
  pwr_tClassId classid;
  pwr_tVolumeId volume;
  int sts;
  int size;
  char volume_name[80];

  // Find a class volume with this name
  sts = ldh_GetVolumeList( ldh_SessionToWB(ldhses), &volume);
  while ( ODD(sts))
  {
    sts = ldh_GetVolumeClass( ldh_SessionToWB(ldhses), volume, &classid);
    if ( EVEN(sts)) return 0;

    if ( cdh_isClassVolumeClass( classid))
    {
      sts = ldh_VolumeIdToName( ldh_SessionToWB(ldhses),
		volume, volume_name, sizeof(volume_name), &size);
      if ( EVEN(sts)) return 0;

      if ( !cdh_NoCaseStrcmp( volume_name, name))
        return 1;
    }
    sts = ldh_GetNextVolume( ldh_SessionToWB(ldhses), volume, &volume);
  }
  return 0;
}
示例#2
0
void Cmd::save_cb( void *ctx, int quiet)
{
  Cmd *cmd = (Cmd *) ctx;
  int sts;

  if ( !cmd->ldhses) {
    cmd->wnav->message( 'E', "Cmd is not attached to a volume");
    return;
  }
  sts = ldh_SaveSession( cmd->ldhses);
  if ( EVEN(sts)) {
    cmd->wnav->message( 'E', wnav_get_message( sts));
    return;
  }

  ldh_sVolumeInfo info;
  pwr_tCid volcid;

  ldh_GetVolumeInfo( ldh_SessionToVol( cmd->ldhses), &info);
  ldh_GetVolumeClass( cmd->wbctx, info.Volume, &volcid);
  
  if ( volcid == pwr_eClass_DirectoryVolume) {
    sts = lfu_SaveDirectoryVolume( cmd->ldhses, 0, quiet);
    if ( EVEN(sts)) {
      cmd->wnav->message( 'E', "Syntax error");
      return;
    }
  }
  cmd->wnav->message( 'E', "Session saved");
}
示例#3
0
文件: ge.cpp 项目: Strongc/proview
int Ge::get_ldhses_cb( void *ctx, ldh_tSesContext *ldhses, int load)
{
#if LDH
    Ge *gectx = (Ge *) ctx;
    ldh_tWBContext wbctx;
    int	sts;
    pwr_tVolumeId	volid = 0;
    pwr_tClassId	classid;
    ldh_tVolContext 	volctx;

    if ( gectx->ldhses) {
        *ldhses = gectx->ldhses;
        return 1;
    }
    else if ( !load)
        return 0;
    else {
        // Open workbench and attatch some volume
        sts = ldh_OpenWB( &wbctx, 0, 0);
        if ( EVEN(sts)) return sts;

        // Attach first rootvolume, or if no rootvolume exist some other volume
        sts = ldh_GetVolumeList( wbctx, &volid);
        while ( ODD(sts)) {
            sts = ldh_GetVolumeClass( wbctx, volid, &classid);
            if ( EVEN(sts)) return sts;

            if ( classid == pwr_eClass_RootVolume)
                break;
            sts = ldh_GetNextVolume( wbctx, volid, &volid);
        }
        if ( volid == 0) return sts;

        // Open ldh session
        sts = ldh_AttachVolume( wbctx, volid, &volctx);
        if ( EVEN(sts)) return sts;

        sts = ldh_OpenSession( ldhses, volctx, ldh_eAccess_ReadWrite,
                               ldh_eUtility_Pwr);
        if ( EVEN(sts)) return sts;
    }
    return 1;
#else
    return 0;
#endif
}
示例#4
0
WVselMotif::WVselMotif (
  pwr_tStatus   *status,
  void		*wv_parent_ctx,
  Widget	wv_parent_wid,
  const char   	*wv_name,
  ldh_tWBContext wv_wbctx,
  char		*volumename,
  int		(*bc_success)( void *, pwr_tVolumeId *, int),
  void		(*bc_cancel)(),
  int		(*bc_time_to_exit)( void *),
  int		show_volumes,
  wb_eType      wv_wb_type) : 
  WVsel(status,wv_parent_ctx,wv_name,wv_wbctx,volumename,bc_success,bc_cancel,
	bc_time_to_exit,show_volumes,wv_wb_type), parent_wid(wv_parent_wid)
{
  Arg		args[20];
  int		sts;
  int 		i;
  pwr_tVolumeId volid, *volume_ptr;
  pwr_tVolumeId	volume;
  pwr_tClassId	classid;
  char		volname[80];
  int		size;
  int		volume_count;
  int		display_window;

  /* DRM database hierarchy related variables */
  MrmHierarchy 	s_DRMh;
  MrmType 	dclass;
  char		uid_filename[200] = {"pwr_exe:wb_vsel.uid"};
  char		*uid_filename_p = uid_filename;


  static MrmRegisterArg	reglist[] = {
  /* First the context variable */
  {(char*) "vsel_ctx", 0 },
  {(char*) "vsel_write_priv", 0 },

  /* Callbacks for the controlled login widget */
  {(char*) "vsel_create_adb",(caddr_t)create_adb},
  {(char*) "vsel_destroy_adb",(caddr_t)destroy_adb},
  {(char*) "vsel_create_label",(caddr_t)create_label},
  {(char*) "vsel_activate_ok",(caddr_t)activate_ok},
  {(char*) "vsel_activate_cancel",(caddr_t)activate_cancel},
  {(char*) "vsel_activate_close",(caddr_t)activate_close},
  {(char*) "vsel_activate_showall",(caddr_t)activate_showall},
  {(char*) "vsel_create_volumelist",(caddr_t)create_volumelist},
  {(char*) "vsel_action_volumelist",(caddr_t)action_volumelist}
  };

  static int	reglist_num = (sizeof reglist / sizeof reglist[0]);

  sts = dcli_translate_filename( uid_filename, uid_filename);
  if ( EVEN(sts)) {
    printf( "** pwr_exe is not defined\n");
    exit(0);
  }

  strcpy( volname, "");
  if ( volumename != NULL && *volumename != 0 && !show_volumes)
    /* Start the navigater for this volume */
    strcpy( volname, volumename);
  else if ( !show_volumes && wb_type != wb_eType_Buffer)
  {
    /* If there is only one volume in the db, select this volume */
    volume_count = 0;

    sts = ldh_GetVolumeList( wbctx, &volume);
    while ( ODD(sts) )
    {
      sts = ldh_GetVolumeClass( wbctx, volume, &classid);
      if (EVEN(sts)) { *status = sts; return; }
  
      if ( cdh_isClassVolumeClass( classid) ||
 	   classid == pwr_eClass_WorkBenchVolume ||
	   volume == ldh_cRtVolume)
      {
        sts = ldh_GetNextVolume( wbctx, volume, &volume);
        continue;
      }
      sts = ldh_VolumeIdToName( wbctx, volume, volname, sizeof(volname),
	    &size);
      if (EVEN(sts)) { *status = sts; return; }
      volume_count++;

      sts = ldh_GetNextVolume( wbctx, volume, &volume);
    }
    if ( volume_count != 1)
      strcpy( volname, "");
  }

  
  //  If volume name is supplied, find this volume and open the navigator.

  if ( strcmp( volname, "") && wb_type != wb_eType_Buffer)
    /* Check syntax, if new volumes is found, show the window */
    sts = check_volumelist( 1, &display_window);

  if ( strcmp( volname, "") && !display_window)
  {
    sts = ldh_VolumeNameToId( wbctx, volname, &volid);
    WFoe::error_msg(sts);
    if ( ODD(sts))
    {
      volume_ptr = (pwr_tVolumeId *) calloc( 1, sizeof( pwr_tVolumeId));
      *volume_ptr = volid;
      (vsel_bc_success) ( (void *)this, volume_ptr, 1);
      if (vsel_bc_cancel != NULL)
        (vsel_bc_cancel) ();

      *status = LOGIN__SUCCESS;
      return;
    }
    else
      printf( "-- Unable to open volume '%s', volume doesn't exist\n",
	volname);
  }
 

  
  // Now start the module creation

  // set initialization values in context */

  // Save the context structure in the widget */
  XtSetArg (args[0], XmNuserData, (XtPointer) this);

  /*
   * Create a new widget
   * Open the UID files (the output of the UIL compiler) in the hierarchy
   * Register the items DRM needs to bind for us.
   * Create a new widget
   * Close the hierarchy
   * Compile the additional button translations and augment and add actions
   */ 
  sts = MrmOpenHierarchy( 1, &uid_filename_p, NULL, &s_DRMh);
  if (sts != MrmSUCCESS) printf("can't open hierarchy\n");

  reglist[0].value = (caddr_t) this;
  reglist[1].value = (caddr_t) write_priv;

  MrmRegisterNames(reglist, reglist_num);

  i=0;
  XtSetArg(args[i],XmNiconName,name);  i++;
  
  /* Save the id of the top in the context */ 
  widgets.toplevel = XtCreatePopupShell (
    "selectvolume", topLevelShellWidgetClass, parent_wid, args, i);

  /* the positioning of a top level can only be define after the creation
   *   of the widget . So i do it now: 
   *  use the parameters received x and y 
   */

  i=0;
  XtSetArg(args[i],XmNx,100);i++;
  XtSetArg(args[i],XmNy,100);i++;
  XtSetArg(args[i],XtNallowShellResize,TRUE), i++;

  XtSetValues( widgets.toplevel  ,args,i);

  /* now that we have a top level we can get the main window */
  sts = MrmFetchWidgetOverride(s_DRMh, (char*) "vsel_window",
    widgets.toplevel, name, args, 1, 
    &widgets.vsel_window, &dclass);

  if (sts != MrmSUCCESS) printf("can't fetch utedit widget\n");

  XtManageChild( widgets.vsel_window);

  /* SG 09.02.91 a top level should always be realized ! */
  XtPopup( widgets.toplevel, XtGrabNone );


  MrmCloseHierarchy(s_DRMh);

  wow = new CoWowMotif( widgets.vsel_window);

  if ( wb_type != wb_eType_Buffer)
    sts = check_volumelist( 0, &display_window);

  // Set input focus to the scrolled list widget
  XmProcessTraversal( widgets.volumelist, XmTRAVERSE_CURRENT);

  *status = LOGIN__SUCCESS;
}
示例#5
0
pwr_tStatus WVsel::check_volumelist(
  int		quiet,
  int		*display_window
)
{
  pwr_tVolumeId	volume;
  pwr_tClassId	classid;
  char		name[80];
  int		size;
  pwr_tStatus	sts;
  int		i;
  lfu_t_volumelist *volumelist;
  lfu_t_volumelist *volumelist_ptr;
  int		volumecount;	
  int		class_error;
  char		volname_conf[80];
  char		volname_db[80];
  int		volume_found;
  int		error_count;
  int		errlen=0;
  int		errlen_old = 0;
  char		errstr[800];
  
  error_count = 0;
  *display_window = 0;
	
  if ( !(CoLogin::privilege() & pwr_mPrv_DevConfig ))
    // No privileges for edit, don't check the volumes
    return 1;

  // Load the configured volume list
  sts = lfu_volumelist_load( pwr_cNameVolumeList,  &volumelist, 
			     &volumecount);
  if (sts == FOE__NOFILE) {
    if ( !quiet) {
      printf( "** Error, project is not configured\n");
      BEEP;
      *display_window = 1;
    }
    return 1;
  }
  else if (EVEN(sts))
    return 1;

  sts = ldh_GetVolumeList( wbctx, &volume);
  while ( ODD(sts) ) {
    sts = ldh_GetVolumeClass( wbctx, volume, &classid);
    if (EVEN(sts)) return sts;

    sts = ldh_VolumeIdToName( wbctx, volume, name, sizeof(name),
			      &size);
    if (EVEN(sts)) return sts;

    if ( classid == pwr_eClass_RootVolume ||
	 classid == pwr_eClass_SubVolume ||
	 (classid == pwr_eClass_SharedVolume && volume != ldh_cRtVolume) ||
	 (cdh_isClassVolumeClass(classid) && 
	  (cdh_cUserClassVolMin <= volume && volume <= cdh_cUserClassVolMax))) {
      // This volume should be configured
      volume_found = 0;
      volumelist_ptr = volumelist;
      for ( i = 0; i < volumecount; i++) {
	if ( volumelist_ptr->volume_id == volume) {
	  // Mark that volume is found
	  volume_found = 1;
	  strcpy( volumelist_ptr->p3, "Found");

	  // Check volume name
	  utl_toupper( volname_conf, volumelist_ptr->volume_name);
	  utl_toupper( volname_db, name);
	  if ( strcmp( volname_db, volname_conf)) {
	    // Volume name differs
	    if ( !quiet && errlen < (int)(sizeof(errstr)-100)) {
	      errlen += sprintf( &errstr[errlen], 
			  "** Error, Volume %s is configured with another name '%s'\n", 
				 name, volumelist_ptr->volume_name);
	      MsgWindow::message( 'E', &errstr[errlen_old], msgw_ePop_No);
	      errlen_old = errlen;
	      BEEP;
	    }
	    error_count++;
	  }
	  class_error = 0;
	  switch( classid) {
	  case pwr_eClass_RootVolume :
	    if ( strcmp( volumelist_ptr->p1, "RootVolume"))
	      class_error = 1;
	    break;
	  case pwr_eClass_SubVolume :
	    if ( strcmp( volumelist_ptr->p1, "SubVolume"))
	      class_error = 1;
	    break;
	  case pwr_eClass_ClassVolume :
	    if ( strcmp( volumelist_ptr->p1, "ClassVolume"))
	      class_error = 1;
	    break;
	  case pwr_eClass_DetachedClassVolume :
	    if ( strcmp( volumelist_ptr->p1, "DetachedClassVolume"))
	      class_error = 1;
	    break;
	  case pwr_eClass_SharedVolume :
	    if ( strcmp( volumelist_ptr->p1, "SharedVolume"))
	      class_error = 1;
	    break;
	  }
	  if ( class_error) {
	    if ( !quiet && errlen < (int)(sizeof(errstr)-100)) {
	      errlen += sprintf( &errstr[errlen], 
	                "** Error, Volume %s is configured with another class '%s'\n", 
				 name, volumelist_ptr->p1);
	      MsgWindow::message( 'E', &errstr[errlen_old], msgw_ePop_No);
	      errlen_old = errlen;
	      BEEP;
	    }
	    error_count++;
	  }
	  break;
	}
	volumelist_ptr++;
      }
      if ( !volume_found) {
	if ( !quiet && errlen < (int)(sizeof(errstr)-100)) {
	  errlen += sprintf( &errstr[errlen], 
		  "** Error, Volume %s (%s) is not configured in the ProjectVolume\nCheck volume name and identity\n", 
			     name, cdh_VolumeIdToString( 0, volume, 1, 0));
	  MsgWindow::message( 'E', &errstr[errlen_old], msgw_ePop_No);
	  errlen_old = errlen;
	  BEEP;
	}	
	error_count++;
      }
    }
    sts = ldh_GetNextVolume( wbctx, volume, &volume);
  }

  if ( error_count) {
    *display_window = 1;
    if ( !quiet) {
      errlen += sprintf( &errstr[errlen],
			 "\n   %d syntax error%s found\n", 
			 error_count, (error_count == 1) ? "" : "s");
      MsgWindow::message( 'E', &errstr[errlen_old], msgw_ePop_No);
      errlen_old = errlen;
      wow->DisplayError( "Syntax control", errstr);
    }
  }
  return 1;
}
示例#6
0
pwr_tStatus WVsel::load_volumelist()
{
  pwr_tVolumeId	volume;
  pwr_tClassId	classid;
  char		name[80];
  int		size;
  pwr_tStatus	sts;
  int		i;
  bool            local_wbvolume = false;
  ldh_sVolumeInfo info;
  char		str[120];

  list_clear();
  volume_count = 0;

  if ( wb_type != wb_eType_Buffer)
    sts = ldh_GetVolumeList( wbctx, &volume);
  else
    sts = ldh_GetBufferList( wbctx, &volume);
  while ( ODD(sts) ) {
    sts = ldh_GetVolumeClass( wbctx, volume, &classid);
    if (EVEN(sts)) return sts;

    if ( !all) {
      if ( cdh_isClassVolumeClass( classid) ||
	   classid == pwr_eClass_WorkBenchVolume  ||
	   volume == ldh_cRtVolume) {
	sts = ldh_GetNextVolume( wbctx, volume, &volume);
	continue;
      }
    }
    sts = ldh_VolumeIdToName( wbctx, volume, name, sizeof(name),
			      &size);
    if (EVEN(sts)) return sts;

    strcpy( str, name);

    strcat( str, " ");
    for ( i = strlen(str); i < 20; i++)
      strcat( str, " ");

    sts = ldh_GetVidInfo( wbctx, volume, &info);
    if (EVEN(sts)) return sts;

    switch ( info.VolRep) {
    case ldh_eVolRep_Db: 
      strcat( str, "Db     ");
      break;
    case ldh_eVolRep_Dbs: 
      strcat( str, "Dbs    ");
      break;
    case ldh_eVolRep_Dbms: 
      strcat( str, "Dbms    ");
      break;
    case ldh_eVolRep_Wbl: 
      strcat( str, "Wbl    ");
      break;
    case ldh_eVolRep_Mem: 
      strcat( str, "Mem    ");
      break;
    case ldh_eVolRep_Ref: 
      strcat( str, "Ref    ");
      break;
    case ldh_eVolRep_Ext: 
      strcat( str, "Ext    ");
      break;
    case ldh_eVolRep_Ced: 
      strcat( str, "Ced    ");
      break;
    }
    
    switch (classid) {
    case pwr_eClass_RootVolume:
      strcat( str, "RootVolume");
      break;
    case pwr_eClass_SubVolume:
      strcat( str, "SubVolume");
      break;
    case pwr_eClass_SharedVolume:
      strcat( str, "SharedVolume");
      break;
    case pwr_eClass_ClassVolume:
      strcat( str, "ClassVolume");
      break;
    case pwr_eClass_DetachedClassVolume:
      strcat( str, "DetachedClassVolume");
      break;
    case pwr_eClass_WorkBenchVolume:
      strcat( str, "WorkBenchVolume");
      break;
    case pwr_eClass_DirectoryVolume:
      strcat( str, "DirectoryVolume");
      break;
    case pwr_eClass_ExternVolume:
      strcat( str, "ExternVolume");
      break;
    }
    list_add_item( str);

    // Store the volume
    volumes[ volume_count] = volume;
    volume_count++;
    if ( volume_count >= VSEL_MAX_VOLUMES)
      break;
    if ( local_wbvolume)
      break;

    sts = ldh_GetNextVolume( wbctx, volume, &volume);
    if ( EVEN(sts) && all) {
      // Look for local workbench volume
      volume = ldh_cWBVolLocal;
      sts = ldh_VolumeIdToName( wbctx, volume, name, sizeof(name),
				&size);
      local_wbvolume = true;
    }
  }
  return 1;
}
示例#7
0
int Cmd::attach_volume_cb( void *ctx,
			 pwr_tVolumeId	volid,
			 int pop)
{
  Cmd *cmd = (Cmd *) ctx;
  int	sts;
  pwr_tVolumeId	vid;
  pwr_tClassId	classid;

  if ( cmd->ldhses)
  {
//    cmd->wnav->message( 'E', "Other volume is already attached");
    return WNAV__VOLATTACHED;
  }

  if ( !cmd->wbctx)
  {
    sts = get_wbctx( (void *)cmd, &cmd->wbctx);
    if ( EVEN(sts)) return sts;
  }

  if ( volid == 0)
  {
    if ( cmd_volume_p != 0) {
      // Attach argument volume
      sts = ldh_VolumeNameToId( cmd->wbctx, cmd_volume_p, &volid);
    }
    if ( cmd_volume_p == 0 || EVEN(sts)) {
      // Attach first rootvolume, or if no rootvolume exist some other volume
      sts = ldh_GetVolumeList( cmd->wbctx, &vid);
      while ( ODD(sts)) {
	volid = vid;
	sts = ldh_GetVolumeClass( cmd->wbctx, vid, &classid);
	if ( EVEN(sts)) return sts;

	if ( classid == pwr_eClass_RootVolume)
	  break;
	sts = ldh_GetNextVolume( cmd->wbctx, vid, &vid);
      }
      if ( volid == 0) return sts;
    }
  }

  cmd->volid = volid;

  // Open ldh session
  sts = ldh_AttachVolume( cmd->wbctx, cmd->volid, &cmd->volctx);
  if ( EVEN(sts)) return sts;

  sts = ldh_OpenSession( &cmd->ldhses,
    cmd->volctx,
    ldh_eAccess_ReadWrite,
    ldh_eUtility_Pwr);
  if ( EVEN(sts)) {
    // Try read access
    sts = ldh_OpenSession( &cmd->ldhses,
			   cmd->volctx,
			   ldh_eAccess_ReadOnly,
			   ldh_eUtility_Pwr);
    if ( EVEN(sts)) return sts;
  }

  cmd->wnav->volume_attached( cmd->wbctx, cmd->ldhses, pop);

  return 1;
}
示例#8
0
WVselGtk::WVselGtk (
  pwr_tStatus   *status,
  void		*wv_parent_ctx,
  GtkWidget	*wv_parent_wid,
  const char   	*wv_name,
  ldh_tWBContext wv_wbctx,
  char		*volumename,
  int		(*bc_success)( void *, pwr_tVolumeId *, int),
  void		(*bc_cancel)(),
  int		(*bc_time_to_exit)( void *),
  int		show_volumes,
  wb_eType      wv_wb_type) : 
  WVsel(status,wv_parent_ctx,wv_name,wv_wbctx,volumename,bc_success,bc_cancel,
	bc_time_to_exit,show_volumes,wv_wb_type), parent_wid(wv_parent_wid)
{
  int		sts;
  pwr_tVolumeId volid, *volume_ptr;
  pwr_tVolumeId	volume;
  pwr_tClassId	classid;
  char		volname[80];
  int		size;
  int		volume_count;
  int		display_window;
  GtkCellRenderer *text_renderer;
  GtkTreeViewColumn *name_column;

  strcpy( volname, "");
  if ( volumename != NULL && *volumename != 0 && !show_volumes)
    /* Start the navigater for this volume */
    strcpy( volname, volumename);
  else if ( !show_volumes && wb_type != wb_eType_Buffer)
  {
    /* If there is only one volume in the db, select this volume */
    volume_count = 0;

    sts = ldh_GetVolumeList( wbctx, &volume);
    while ( ODD(sts) )
    {
      sts = ldh_GetVolumeClass( wbctx, volume, &classid);
      if (EVEN(sts)) { *status = sts; return; }
  
      if ( cdh_isClassVolumeClass( classid) ||
 	   classid == pwr_eClass_WorkBenchVolume ||
	   volume == ldh_cRtVolume)
      {
        sts = ldh_GetNextVolume( wbctx, volume, &volume);
        continue;
      }
      sts = ldh_VolumeIdToName( wbctx, volume, volname, sizeof(volname),
	    &size);
      if (EVEN(sts)) { *status = sts; return; }
      volume_count++;

      sts = ldh_GetNextVolume( wbctx, volume, &volume);
    }
    if ( volume_count != 1)
      strcpy( volname, "");
  }

  
  //  If volume name is supplied, find this volume and open the navigator.

  if ( strcmp( volname, "") && wb_type != wb_eType_Buffer)
    /* Check syntax, if new volumes is found, show the window */
    sts = check_volumelist( 1, &display_window);

  if ( strcmp( volname, "") && !display_window)
  {
    sts = ldh_VolumeNameToId( wbctx, volname, &volid);
    WFoe::error_msg(sts);
    if ( ODD(sts))
    {
      volume_ptr = (pwr_tVolumeId *) calloc( 1, sizeof( pwr_tVolumeId));
      *volume_ptr = volid;
      (vsel_bc_success) ( (void *)this, volume_ptr, 1);
      if (vsel_bc_cancel != NULL)
        (vsel_bc_cancel) ();

      *status = LOGIN__SUCCESS;
      return;
    }
    else
      printf( "-- Unable to open volume '%s', volume doesn't exist\n",
	volname);
  }


  // Create the window
  widgets.toplevel = (GtkWidget *) g_object_new( GTK_TYPE_WINDOW, 
					 "default-height", 400,
					 "default-width", 500,
					 "title", name,
					 NULL);

  CoWowGtk::SetWindowIcon( widgets.toplevel);

  // Menu
  GtkAccelGroup *accel_g = (GtkAccelGroup *) g_object_new(GTK_TYPE_ACCEL_GROUP, NULL);
  gtk_window_add_accel_group(GTK_WINDOW(widgets.toplevel), accel_g);

  GtkMenuBar *menu_bar = (GtkMenuBar *) g_object_new(GTK_TYPE_MENU_BAR, NULL);

  // File Entry
  GtkWidget *file_close = gtk_image_menu_item_new_from_stock(GTK_STOCK_CLOSE, accel_g);
  g_signal_connect(file_close, "activate", G_CALLBACK(WVselGtk::activate_close), this);

  GtkMenu *file_menu = (GtkMenu *) g_object_new( GTK_TYPE_MENU, NULL);
  gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), file_close);

  GtkWidget *file = gtk_menu_item_new_with_mnemonic("_File");
  gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), file);
  gtk_menu_item_set_submenu(GTK_MENU_ITEM(file), GTK_WIDGET(file_menu));

  // Functions Entry
  GtkWidget *functions_showall = gtk_check_menu_item_new_with_mnemonic( "_Show All Volumes");
  g_signal_connect( functions_showall, "activate", 
		    G_CALLBACK(WVselGtk::activate_showall), this);
  gtk_widget_add_accelerator( functions_showall, "activate", accel_g,
			      'a', GdkModifierType(GDK_CONTROL_MASK), 
			      GTK_ACCEL_VISIBLE);

  GtkMenu *functions_menu = (GtkMenu *) g_object_new( GTK_TYPE_MENU, NULL);
  gtk_menu_shell_append(GTK_MENU_SHELL(functions_menu), functions_showall);

  GtkWidget *functions = gtk_menu_item_new_with_mnemonic("F_unctions");
  gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), functions);
  gtk_menu_item_set_submenu(GTK_MENU_ITEM(functions), GTK_WIDGET(functions_menu));

  // List widget
  store = gtk_list_store_new( 1, G_TYPE_STRING);

  widgets.volumelist = (GtkWidget *) g_object_new(GTK_TYPE_TREE_VIEW,
				 "model", store,
				 "rules-hint", TRUE,
				 "headers-visible", FALSE,
				 "reorderable", TRUE,
				 "enable-search", TRUE,
				 "search-column", 0,
				 NULL);

  text_renderer = gtk_cell_renderer_text_new();
  name_column = gtk_tree_view_column_new_with_attributes( NULL,
							  text_renderer,
							  "text", 0,
							  NULL);

  g_object_set( name_column,
		"resizable", TRUE,
		"clickable", TRUE,
		NULL);

  gtk_tree_view_append_column( GTK_TREE_VIEW(widgets.volumelist), name_column);

  GtkWidget *ok_button = gtk_button_new_with_label( "Ok");
  gtk_widget_set_size_request( ok_button, 70, 25);
  g_signal_connect( ok_button, "clicked", 
 		    G_CALLBACK(activate_ok), this);

  GtkWidget *cancel_button = gtk_button_new_with_label( "Cancel");
  gtk_widget_set_size_request( cancel_button, 70, 25);
  g_signal_connect( cancel_button, "clicked", 
 		    G_CALLBACK(activate_cancel), this);

  GtkWidget *hboxbuttons = gtk_hbox_new( TRUE, 40);
  gtk_box_pack_start( GTK_BOX(hboxbuttons), ok_button, FALSE, FALSE, 20);
  gtk_box_pack_end( GTK_BOX(hboxbuttons), cancel_button, FALSE, FALSE, 20);

  GtkWidget *scrolled_window = gtk_scrolled_window_new( NULL, NULL);
  gtk_container_add( GTK_CONTAINER( scrolled_window), widgets.volumelist);

  GtkWidget *vbox = gtk_vbox_new( FALSE, 0);
  gtk_box_pack_start( GTK_BOX(vbox), GTK_WIDGET(menu_bar), FALSE, FALSE, 0);
  gtk_box_pack_start( GTK_BOX(vbox), scrolled_window, TRUE, TRUE, 0);
  gtk_box_pack_end( GTK_BOX(vbox), hboxbuttons, FALSE, FALSE, 10);

  gtk_container_add( GTK_CONTAINER(widgets.toplevel), vbox);
  gtk_widget_show_all( widgets.toplevel);

  // GtkTreeSelection *selection = gtk_tree_view_get_selection( GTK_TREE_VIEW(widgets.volumelist));
  // gtk_tree_selection_set_mode( selection, GTK_SELECTION_SINGLE);

  sts = load_volumelist();
  WFoe::error_msg(sts);

  // Set input focus to the scrolled list widget
  gtk_widget_grab_focus( widgets.volumelist);


  wow = new CoWowGtk( widgets.toplevel);

  if ( wb_type != wb_eType_Buffer)
    sts = check_volumelist( 0, &display_window);

  *status = LOGIN__SUCCESS;
}