home *** CD-ROM | disk | FTP | other *** search
/ Tools / WinSN5.0Ver.iso / NETSCAP.50 / WIN1998.ZIP / ns / cmd / xfe / src / ReadAttachPanel.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  1998-04-08  |  14.0 KB  |  465 lines
  1. /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
  2.  *
  3.  * The contents of this file are subject to the Netscape Public License
  4.  * Version 1.0 (the "NPL"); you may not use this file except in
  5.  * compliance with the NPL.  You may obtain a copy of the NPL at
  6.  * http://www.mozilla.org/NPL/
  7.  *
  8.  * Software distributed under the NPL is distributed on an "AS IS" basis,
  9.  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
  10.  * for the specific language governing rights and limitations under the
  11.  * NPL.
  12.  *
  13.  * The Initial Developer of this code under the NPL is Netscape
  14.  * Communications Corporation.  Portions created by Netscape are
  15.  * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
  16.  * Reserved.
  17.  */
  18. /* 
  19.    ReadAttachPanel.cpp -- read window attachment panel
  20.    Created: Alastair Gourlay(SGI) c/o Dora Hsu<dora@netscape.com>, 26 Nov 1996
  21.  */
  22.  
  23. // Classes in this file:
  24. //      XFE_ReadAttachPanel
  25. //
  26.  
  27. #include "ReadAttachPanel.h"
  28. #include <stdlib.h>
  29. #include <Xm/XmAll.h>
  30. #include "mozilla.h"
  31. #include "xfe.h"
  32. #include "net.h"
  33. #include "icons.h"
  34. #include "icondata.h"
  35. #include "PopupMenu.h"
  36.  
  37. //
  38. // XFE_ReadAttachPanel
  39. //
  40.  
  41. // callback stubs
  42.  
  43. void XFE_ReadAttachPanel::OpenCb(Widget,XtPointer cd,XtPointer) {
  44.     XFE_ReadAttachPanel *ad=(XFE_ReadAttachPanel*)cd;
  45.     if (ad)
  46.         ad->openCb();
  47. }
  48.  
  49. void XFE_ReadAttachPanel::SaveCb(Widget,XtPointer cd,XtPointer) {
  50.     XFE_ReadAttachPanel *ad=(XFE_ReadAttachPanel*)cd;
  51.     if (ad)
  52.         ad->saveCb();
  53. }
  54.  
  55. void XFE_ReadAttachPanel::PropertiesCb(Widget,XtPointer cd,XtPointer) {
  56.     XFE_ReadAttachPanel *ad=(XFE_ReadAttachPanel*)cd;
  57.     if (ad)
  58.         ad->propertiesCb();
  59. }
  60.  
  61. // constructor
  62.  
  63. XFE_ReadAttachPanel::XFE_ReadAttachPanel(MWContext* context)
  64.     : XFE_AttachPanel(context)
  65. {
  66.     _attachments=NULL;
  67.     _pane=NULL;
  68.     _propertiesDialog=NULL;
  69.     _attachDrag=NULL;
  70.  
  71.     multiClickEnabled(TRUE);
  72. }
  73.  
  74. // destructor
  75.  
  76. XFE_ReadAttachPanel::~XFE_ReadAttachPanel()
  77. {
  78.     // this may be causing double-free..  investigate MSG_Pane
  79.     // removeAllAttachments();
  80.  
  81.     if (_attachDrag) {
  82.         delete _attachDrag;
  83.         _attachDrag=NULL;
  84.     }
  85. }
  86.  
  87. // create Motif UI
  88.  
  89. void XFE_ReadAttachPanel::createWidgets(Widget parent)
  90. {
  91.     // create panel UI
  92.  
  93.     XFE_AttachPanel::createWidgets(parent);
  94.  
  95.     // set up drag handler
  96.     Widget dragWidget=XtNameToWidget(getBaseWidget(),"*pane");
  97.     if (dragWidget)
  98.         _attachDrag=new XFE_ReadAttachDrag(dragWidget,this);
  99.  
  100.     // create popup
  101.  
  102.     Arg args[10];
  103.     int n=0;
  104.     // disable keyboard accelerators and naviagtion in popup - they cause
  105.     // crashes. In future, use XFE_PopupMenu when the menu items become real
  106.     // xfeCmd's - it is more robust.
  107.     XtSetArg(args[n],XmNtraversalOn,False);n++;
  108.     _popupMenu = XFE_PopupMenu::CreatePopupMenu(_popupParent,
  109.                                                 "msgViewAttachPopup",args,n);
  110.  
  111.     _open=XmCreatePushButtonGadget(_popupMenu,"open",NULL,0);
  112.     XtAddCallback(_open,XmNactivateCallback,OpenCb,this);
  113.     XtManageChild(_open);
  114.     
  115.     _save=XmCreatePushButtonGadget(_popupMenu,"save",NULL,0);
  116.     XtAddCallback(_save,XmNactivateCallback,SaveCb,this);
  117.     XtManageChild(_save);
  118.     
  119.     _properties=XmCreatePushButtonGadget(_popupMenu,"properties",NULL,0);
  120.     XtAddCallback(_properties,XmNactivateCallback,PropertiesCb,this);
  121.     XtManageChild(_properties);
  122.     
  123.     initializePopupMenu();
  124. }
  125.  
  126.  
  127. void XFE_ReadAttachPanel::setPaneHeight(int height)
  128. {
  129.     if (!getBaseWidget() || height<1 || height==getPaneHeight())
  130.         return;
  131.  
  132.     int wasShown=isShown();
  133.  
  134.     // if panel is shown, we need to hide/show to force XmPanedWindow to
  135.     // notice the height change
  136.     if (wasShown)
  137.         hide();
  138.  
  139.     // XmPaned window hack to set height of a pane
  140.     XtVaSetValues(getBaseWidget(),
  141.                   XmNpaneMinimum, height,
  142.                   XmNpaneMaximum, height,
  143.                   NULL);
  144.     if (wasShown)
  145.         show();
  146.     
  147.     XtVaSetValues(getBaseWidget(),
  148.                   XmNpaneMinimum, 1,
  149.                   XmNpaneMaximum, 10000,
  150.                   NULL);
  151. }
  152.  
  153. int XFE_ReadAttachPanel::getPaneHeight()
  154. {
  155.     if (!getBaseWidget())
  156.         return 0;
  157.     
  158.     Dimension height;
  159.     
  160.     XtVaGetValues(getBaseWidget(),
  161.                   XmNheight, &height,
  162.                   NULL);
  163.     
  164.     return (int)height;
  165. }
  166.  
  167. void XFE_ReadAttachPanel::addAttachments(MSG_Pane *pane,MSG_AttachmentData* data)
  168. {
  169.     // adopt storage of backend attachment list, free in removeAllAttachments
  170.     _pane=pane;
  171.     _attachments=data;
  172.     
  173.     MSG_AttachmentData* tmp;
  174.     for (tmp = data ; tmp->url ; tmp++) {
  175.         char *itemLabel=NULL;
  176.  
  177.         // Hack around back-end not naming the sent v-card. Use
  178.         // description field: "Card for ...", to provide some
  179.         // uniqueness among received vcards.
  180.         if (tmp->real_name && XP_STRCASECMP(tmp->real_name,"vcard.vcf")==0 &&
  181.             tmp->description && strlen(tmp->description)>0) {
  182.             itemLabel=(char*)XP_ALLOC(strlen(tmp->description)+4+1);
  183.             sprintf(itemLabel,"%s.vcf",tmp->description);
  184.         }
  185.  
  186.         // find a label for the attachment
  187.         else if (tmp->real_name && strlen(tmp->real_name)>0) {
  188.             itemLabel=XP_STRDUP(tmp->real_name);
  189.         } else if (tmp->description && strlen(tmp->description)>0) {
  190.             itemLabel=XP_STRDUP(tmp->description);
  191.         } else if (tmp->real_type && strlen(tmp->real_type)>0) {
  192.             itemLabel=XP_STRDUP(tmp->real_type);
  193.         } else {
  194.             itemLabel=XP_STRDUP("attachment");
  195.         }
  196.         // translate problem characters in label to '_'
  197.         char *s=itemLabel;
  198.         while (*s) {
  199.             if (*s==' ' || *s=='/' || *s=='\\')
  200.                 *s='_';
  201.             s++;
  202.         }
  203.  
  204.         XFE_AttachPanelItem *item = new
  205.             XFE_AttachPanelItem(this,
  206.                                 tmp->url,
  207.                                 itemLabel,
  208.                                 tmp->real_type);
  209.         addItem(item);
  210.         // add to drag handler
  211.         if (_attachDrag && item->image()) {
  212.             _attachDrag->addDragWidget(item->image());
  213.         }
  214.         
  215.         if (itemLabel)
  216.             XP_FREE(itemLabel);
  217.     }
  218.  
  219.     // select first attachment by default
  220.     if (_numItems>0)
  221.         selectItem(_items[0]);
  222. }
  223.  
  224. void XFE_ReadAttachPanel::removeAllAttachments()
  225. {
  226.     removeAllItems();
  227.  
  228.     if (_pane && _attachments) {
  229.         MSG_FreeAttachmentList(_pane, _attachments);
  230.         _attachments=NULL;
  231.     }
  232.  
  233.     // pop down attachment properties dialog, if it's managed
  234.     if (_propertiesDialog)
  235.         XtUnmanageChild(_propertiesDialog);
  236.  
  237.     // unlock frame, just in case this call caused an in-progress
  238.     // drag to cancel without exiting fe_SaveSynchronousURL()
  239.     if (_attachDrag)
  240.         _attachDrag->unlockFrame();
  241. }
  242.  
  243. void XFE_ReadAttachPanel::updateSelectionUI()
  244. {
  245.     if (!_popupMenu)
  246.         return;
  247.  
  248.     if (_currentSelection) {
  249.         XtSetSensitive(_open,TRUE);
  250.         XtSetSensitive(_save,TRUE);
  251.         XtSetSensitive(_properties,TRUE);
  252.     }
  253.     else {
  254.         XtSetSensitive(_open,FALSE);
  255.         XtSetSensitive(_save,FALSE);
  256.         XtSetSensitive(_properties,FALSE);
  257.     }
  258.  
  259.     // if attachment properties dialog is already being displayed, update it.
  260.     if (_propertiesDialog && XtIsManaged(_propertiesDialog)) {
  261.         if (_currentSelection)
  262.             displayAttachmentProperties(currentSelectionPos());
  263.     }    
  264. }
  265.  
  266. void XFE_ReadAttachPanel::displayAttachmentProperties(int pos)
  267. {
  268.     if (pos<0 || pos>=_numItems)
  269.         return;
  270.  
  271.     if (!_propertiesDialog) {
  272.         // create properties dialog
  273.         Arg args[20];
  274.         int n;
  275.  
  276.         Visual *v=0;
  277.         Colormap cmap=0;
  278.         Cardinal depth=0;
  279.  
  280.         Widget shell=getBaseWidget();
  281.         while (!XtIsShell(shell)) shell=XtParent(shell);
  282.         XtVaGetValues(shell,XtNvisual,&v,XtNcolormap,&cmap,XtNdepth,&depth,NULL);
  283.  
  284.         Pixel bg;
  285.         XtVaGetValues(getBaseWidget(),XmNbackground,&bg,NULL);
  286.         fe_icon attachIcon={ 0 };
  287.         fe_MakeIcon(_context,bg, &attachIcon, NULL,
  288.         M_ToggleAttach.width, M_ToggleAttach.height,
  289.         M_ToggleAttach.mono_bits, M_ToggleAttach.color_bits, M_ToggleAttach.mask_bits,
  290.         FALSE);
  291.  
  292.         n=0;
  293.         XtSetArg(args[n],XmNvisual,v); n++;
  294.         XtSetArg(args[n],XmNdepth,depth); n++;
  295.         XtSetArg(args[n],XmNcolormap,cmap); n++;
  296.         XtSetArg(args[n],XmNdeleteResponse,XmUNMAP);n++;
  297.         XtSetArg(args[n],XmNautoUnmanage,TRUE);n++;
  298.         XtSetArg(args[n],XmNdialogStyle,XmDIALOG_MODELESS);n++;
  299.         XtSetArg(args[n],XmNmwmFunctions,MWM_FUNC_MOVE|MWM_FUNC_CLOSE);n++;
  300.         XtSetArg(args[n],XmNmwmDecorations,MWM_DECOR_BORDER|MWM_DECOR_TITLE|MWM_DECOR_MENU);n++;
  301.         if (attachIcon.pixmap) {
  302.             XtSetArg(args[n],XmNsymbolPixmap,attachIcon.pixmap);n++;
  303.         }
  304.         _propertiesDialog=XmCreateTemplateDialog(getBaseWidget(),"attachmentProps",args,n);
  305.         fe_HackDialogTranslations(_propertiesDialog);
  306.         fe_NukeBackingStore(_propertiesDialog);
  307.  
  308.         Widget form=XmCreateForm(_propertiesDialog,"form",NULL,0);
  309.         XtManageChild(form);
  310.         
  311.         n=0;
  312.         XtSetArg(args[n],XmNpacking,XmPACK_COLUMN); n++;
  313.         XtSetArg(args[n],XmNnumColumns,1); n++;
  314.         XtSetArg(args[n],XmNisAligned,FALSE); n++;
  315.         XtSetArg(args[n],XmNalignment,XmVERTICAL); n++;
  316.         XtSetArg(args[n],XmNleftAttachment,XmATTACH_FORM); n++;        
  317.         XtSetArg(args[n],XmNtopAttachment,XmATTACH_FORM); n++;        
  318.         XtSetArg(args[n],XmNbottomAttachment,XmATTACH_FORM); n++;        
  319.         Widget labelRC=XmCreateRowColumn(form,"labelRC",args,n);
  320.         XtManageChild(labelRC);
  321.  
  322.         n=0;
  323.         XtSetArg(args[n],XmNalignment,XmALIGNMENT_END);n++;
  324.         _nameLabel=XmCreateLabelGadget(labelRC,"nameLabel",args,n);        
  325.         _typeLabel=XmCreateLabelGadget(labelRC,"typeLabel",args,n);
  326.         _encLabel=XmCreateLabelGadget(labelRC,"encLabel",args,n);
  327.         _descLabel=XmCreateLabelGadget(labelRC,"descLabel",args,n);
  328.  
  329.         n=0;
  330.         XtSetArg(args[n],XmNpacking,XmPACK_COLUMN); n++;
  331.         XtSetArg(args[n],XmNnumColumns,1); n++;
  332.         XtSetArg(args[n],XmNisAligned,FALSE); n++;
  333.         XtSetArg(args[n],XmNalignment,XmVERTICAL); n++;
  334.         XtSetArg(args[n],XmNleftAttachment,XmATTACH_WIDGET); n++;        
  335.         XtSetArg(args[n],XmNleftWidget,labelRC); n++;        
  336.         XtSetArg(args[n],XmNrightAttachment,XmATTACH_FORM); n++;        
  337.         XtSetArg(args[n],XmNtopAttachment,XmATTACH_FORM); n++;        
  338.         XtSetArg(args[n],XmNbottomAttachment,XmATTACH_FORM); n++;        
  339.         Widget valueRC=XmCreateRowColumn(form,"valueRC",args,n);
  340.         XtManageChild(valueRC);
  341.  
  342.         n=0;
  343.         XtSetArg(args[n],XmNalignment,XmALIGNMENT_BEGINNING);n++;
  344.         _nameValue=XmCreateLabelGadget(valueRC,"nameValue",args,n);
  345.         _typeValue=XmCreateLabelGadget(valueRC,"typeValue",args,n);
  346.         _encValue=XmCreateLabelGadget(valueRC,"encValue",args,n);
  347.         _descValue=XmCreateLabelGadget(valueRC,"descValue",args,n);
  348.     }
  349.     
  350.     // set value of data fields, manage/unmanage relevent fields
  351.     XmString xs;
  352.  
  353.     // file name
  354.     char *name=_attachments[pos].real_name;
  355.     if (name) {
  356.         xs=XmStringCreateLocalized(name);
  357.         XtVaSetValues(_nameValue,XmNlabelString,xs,NULL);
  358.         XmStringFree(xs);
  359.         XtManageChild(_nameLabel);
  360.         XtManageChild(_nameValue);
  361.     }
  362.     else {
  363.         XtUnmanageChild(_nameLabel);
  364.         XtUnmanageChild(_nameValue);
  365.     }
  366.  
  367.     // mime type
  368.     char *type=_attachments[pos].real_type;
  369.     if (type) {
  370.         xs=XmStringCreateLocalized(type);
  371.         XtVaSetValues(_typeValue,XmNlabelString,xs,NULL);
  372.         XmStringFree(xs);
  373.         XtManageChild(_typeLabel);
  374.         XtManageChild(_typeValue);
  375.     }
  376.     else {
  377.         XtUnmanageChild(_typeLabel);
  378.         XtUnmanageChild(_typeValue);
  379.     }
  380.  
  381.     // encoding
  382.     char *enc=_attachments[pos].real_encoding;
  383.     if (enc) {
  384.         xs=XmStringCreateLocalized(enc);
  385.         XtVaSetValues(_encValue,XmNlabelString,xs,NULL);
  386.         XmStringFree(xs);
  387.         XtManageChild(_encLabel);
  388.         XtManageChild(_encValue);
  389.     }
  390.     else {
  391.         XtUnmanageChild(_encLabel);
  392.         XtUnmanageChild(_encValue);
  393.     }
  394.  
  395.     // long description
  396.     char *desc=_attachments[pos].description;
  397.     if (desc) {
  398.         xs=XmStringCreateLocalized(desc);
  399.         XtVaSetValues(_descValue,XmNlabelString,xs,NULL);
  400.         XmStringFree(xs);
  401.         XtManageChild(_descLabel);
  402.         XtManageChild(_descValue);
  403.     }
  404.     else {
  405.         XtUnmanageChild(_descLabel);
  406.         XtUnmanageChild(_descValue);
  407.     }
  408.  
  409.     // manage widget if not already managed
  410.     XtManageChild(_propertiesDialog);
  411. }
  412.  
  413. // internal callback methods
  414.  
  415. void XFE_ReadAttachPanel::doubleClickCb(int pos)
  416. {
  417.     // ensure clicked item is selected
  418.     if (pos!=currentSelectionPos() && _items && pos >=0 && pos < _numItems)
  419.         selectItem(_items[pos]);
  420.  
  421.     openCb();
  422. }
  423.  
  424.  
  425. void XFE_ReadAttachPanel::openCb()
  426. {
  427.     if (!currentSelection())
  428.         return;
  429.  
  430.     const char *selData=currentSelection()->data();
  431.     if (!selData || strlen(selData)==0)
  432.         return;
  433.  
  434.     URL_Struct *url = NET_CreateURLStruct (selData,NET_DONT_RELOAD);
  435.     if (!MSG_RequiresBrowserWindow(url->address))
  436.     fe_GetURL(_context,url,FALSE);
  437.     else
  438.         fe_MakeWindow(XtParent(CONTEXT_WIDGET (_context)), _context, url, NULL,
  439.                       MWContextBrowser, FALSE);
  440.  
  441.     fe_UserActivity(_context);
  442. }
  443.  
  444. void XFE_ReadAttachPanel::saveCb()
  445. {
  446.     if (!currentSelection() || !currentSelection()->data())
  447.         return;
  448.  
  449.     URL_Struct *url = NET_CreateURLStruct (currentSelection()->data(),NET_DONT_RELOAD);
  450.  
  451.     if (url)
  452.         fe_SaveURL(_context,url);
  453. }
  454.  
  455. void XFE_ReadAttachPanel::propertiesCb()
  456. {
  457.     int pos=currentSelectionPos();
  458.  
  459.     if (pos<0 || pos>=_numItems)
  460.         return;
  461.  
  462.     displayAttachmentProperties(pos);
  463. }
  464.  
  465.