home *** CD-ROM | disk | FTP | other *** search
/ Tools / WinSN5.0Ver.iso / NETSCAP.50 / WIN1998.ZIP / ns / cmd / xfe / src / PersonalToolbar.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  1998-04-08  |  15.9 KB  |  624 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. /*                                                                        */
  20. /* Name:        PersonalToolbar.cpp                                        */
  21. /* Description:    XFE_PersonalToolbar component source.                    */
  22. /* Author:        Ramiro Estrugo <ramiro@netscape.com>                    */
  23. /*                                                                        */
  24. /*----------------------------------------------------------------------*/
  25.  
  26.  
  27.  
  28. #include "structs.h"
  29. #include "xfe.h"
  30. #include "xpassert.h"
  31. #include "bkmks.h"
  32. #include "felocale.h"
  33. #include "intl_csi.h"
  34. #include "prefapi.h"
  35. #include "View.h"
  36. #include "PersonalToolbar.h"
  37. #include "MozillaApp.h"
  38. #include "BookmarkFrame.h"
  39. #include "BookmarkMenu.h"
  40. #include "IconGroup.h"
  41. #include "ToolbarDrop.h"
  42. #include "Logo.h"
  43. #include "PopupMenu.h"
  44. #include "prefapi.h"
  45.  
  46. #include <Xfe/ToolItem.h>
  47.  
  48. #define DEFAULT_TOOLBAR_FOLDER_NAME        "Personal Toolbar Folder"
  49. #define MIN_TOOLBAR_HEIGHT                26
  50. #define MAX_CHILD_WIDTH                    100
  51. #define PERSONAL_TOOLBAR_NAME            "personalToolbar"
  52. #define LOGO_NAME                        "logo"
  53.  
  54. /* static */ MenuSpec 
  55. XFE_PersonalToolbar::m_popupMenuSpec[] = 
  56. {
  57.     { xfeCmdPersonalToolbarRemoveItem,        PUSHBUTTON },
  58.     { NULL }
  59. };
  60.  
  61. //////////////////////////////////////////////////////////////////////////
  62. XFE_PersonalToolbar::XFE_PersonalToolbar(MWContext *    bookmarkContext,
  63.                                          XFE_Toolbox *    parent_toolbox,
  64.                                          const char *    name,
  65.                                          XFE_Frame *    frame) :
  66.     XFE_ToolboxItem(frame,parent_toolbox),
  67.     XFE_BookmarkBase(bookmarkContext,frame,False,True),
  68.     m_toolBarFolder(NULL),
  69.     m_popup(NULL)
  70. {
  71.     XP_ASSERT( name != NULL );
  72.  
  73.     XP_ASSERT( getBookmarkContext() != NULL );
  74.  
  75.     // Obtain the toolbar folder
  76.     m_toolBarFolder = XFE_PersonalToolbar::getToolbarFolder();
  77.  
  78.     // Create the base widget - a tool item
  79.     m_widget = XtVaCreateWidget(name,
  80.                                 xfeToolItemWidgetClass,
  81.                                 parent_toolbox->getBaseWidget(),
  82.                                 XmNuserData,            this,
  83.                                 NULL);
  84.     // Create the toolbar
  85.     m_toolBar = 
  86.         XtVaCreateManagedWidget(PERSONAL_TOOLBAR_NAME,
  87.                                 xfeToolBarWidgetClass,
  88.                                 m_widget,
  89.                                 XmNusePreferredWidth,        False,
  90.                                 XmNusePreferredHeight,        True,
  91.                                 XmNchildForceWidth,            False,
  92.                                 XmNchildForceHeight,        True,
  93.                                 XmNchildUsePreferredWidth,    True,
  94.                                 XmNchildUsePreferredHeight,    False,
  95.                                 XmNminHeight,                MIN_TOOLBAR_HEIGHT,
  96.                                 NULL);
  97.     
  98.     // Create the logo
  99.     m_logo = new XFE_Logo(getFrame(),m_widget,LOGO_NAME);
  100.  
  101.     m_logo->setSize(XFE_ANIMATION_SMALL);
  102.  
  103.     // Attach and configure the logo
  104.     configureLogo();
  105.  
  106.     // Update the appearace for the first time
  107.     updateAppearance();
  108.  
  109.     // Make sure the toolbar is not highlighted first
  110.     setRaised(False);
  111.     
  112.     // register and enable the drop site
  113.     m_dropSite = new XFE_PersonalDrop(m_toolBar,this);
  114.     m_dropSite->enable();
  115.  
  116.     // Configure the drop site
  117.     Arg            xargs[1];
  118.     Cardinal    n = 0;
  119.  
  120.     XtSetArg(xargs[n],XmNanimationStyle,    XmDRAG_UNDER_NONE);        n++;
  121.     
  122.     m_dropSite->update(xargs,n);
  123.  
  124.     // Register personal toolbar widgets for dragging
  125.     addDragWidget(getBaseWidget());
  126.     addDragWidget(getToolBarWidget());
  127.   
  128.     // Install the destruction handler
  129.     installDestroyHandler();
  130.  
  131.     // Force the items to update
  132.     reallyUpdateRoot();
  133.  
  134.     // If we are supposed to have a toolbar folder, but it does not
  135.     // exist, then we need to create one and populate it with the default
  136.     // crap from marketing
  137.     if (XFE_PersonalToolbar::hasToolbarFolder() && !m_toolBarFolder)
  138.     {
  139.         addDefaultToolbarFolder();
  140.  
  141.         XP_ASSERT( isToolbarFolderValid() );
  142.  
  143.         if (isToolbarFolderValid())
  144.         {
  145.             addDefaultPersonalEntries("personal_toolbar",m_toolBarFolder);
  146.         }
  147.     }
  148.  
  149.     // Add popup callback to toolbar
  150.     XtAddCallback(m_toolBar,
  151.                   XmNbutton3DownCallback,
  152.                   &XFE_PersonalToolbar::popupCB,
  153.                   (XtPointer) this);
  154. }
  155. //////////////////////////////////////////////////////////////////////////
  156. XFE_PersonalToolbar::~XFE_PersonalToolbar()
  157. {
  158.     if (m_dropSite)
  159.     {
  160.         delete m_dropSite;
  161.     }
  162.  
  163.     if (m_popup)
  164.     {
  165.         delete m_popup;
  166.     }
  167. }
  168. //////////////////////////////////////////////////////////////////////////
  169.  
  170.  
  171. //////////////////////////////////////////////////////////////////////////
  172. /* virtual */ void
  173. XFE_PersonalToolbar::prepareToUpdateRoot()
  174. {
  175.     // Force the items to update
  176.     reallyUpdateRoot();
  177. }
  178. //////////////////////////////////////////////////////////////////////////
  179. /* virtual */ void
  180. XFE_PersonalToolbar::reallyUpdateRoot()
  181. {
  182.     BM_Entry * newFolder = XFE_PersonalToolbar::getToolbarFolder();
  183.  
  184.     // Check for changes in the toolbar folder
  185.     if (m_toolBarFolder != newFolder)
  186.     {
  187. #ifdef DEBUG_slamm
  188.       XP_ASSERT(newFolder);
  189. #endif
  190.       if (newFolder)
  191.         XFE_PersonalToolbar::setToolbarFolder(newFolder,False);  
  192.       
  193.       m_toolBarFolder = newFolder;
  194.     }
  195.  
  196.     // Since a lot of changes will happen to the toolbar, we tell it to 
  197.     // any geometry or layout changes.  We will force these to occur later.
  198.     XtVaSetValues(m_toolBar,XmNignoreConfigure,True,NULL);
  199.  
  200.     // Destroy the current widgets
  201.     destroyToolbarWidgets();
  202.  
  203.     // If the toolbar folder is valid, populate the toolbar
  204.     if (isToolbarFolderValid())
  205.     {
  206.         // Access the first entry in the personal toolbar folder
  207.         BM_Entry * entry = BM_GetChildren(m_toolBarFolder);
  208.         
  209.         while (entry)
  210.         {
  211.             Widget item = NULL;
  212.             
  213.             // Headers
  214.             if (BM_IsHeader(entry))
  215.             {
  216.                 item = createXfeCascade(m_toolBar,entry);
  217.             }
  218.             // Separators
  219.             else if (BM_IsSeparator(entry))
  220.             {
  221.                 item = createSeparator(m_toolBar);
  222.             }
  223.             // Normal items
  224.             else
  225.             {
  226.                 item = createXfeButton(m_toolBar,entry);
  227.             }
  228.             
  229.             XP_ASSERT( XfeIsAlive(item) );
  230.             
  231.             XtManageChild(item);
  232.             
  233.             entry = BM_GetNext(entry);
  234.         }
  235.     }
  236.  
  237.     // Tell the toolbar not too ignore geometry or layout changes anymore
  238.     XtVaSetValues(m_toolBar,XmNignoreConfigure,False,NULL);
  239.  
  240.     // Force the toolbar to reconfigure.
  241.     XfeManagerLayout(m_toolBar);
  242. }
  243. //////////////////////////////////////////////////////////////////////////
  244. /* virtual */ void
  245. XFE_PersonalToolbar::configureXfeButton(Widget item,BM_Entry *entry)
  246. {
  247.     if (fe_globalPrefs.toolbar_style == BROWSER_TOOLBAR_TEXT_ONLY)
  248.     {
  249.         XtVaSetValues(item,
  250.                       XmNpixmap,            XmUNSPECIFIED_PIXMAP,
  251.                       XmNpixmapMask,        XmUNSPECIFIED_PIXMAP,
  252.                       NULL);
  253.  
  254.         XtVaSetValues(item,XmNbuttonLayout,XmBUTTON_LABEL_ONLY,NULL);
  255.     }
  256.     else
  257.     {
  258.         Pixmap pixmap;
  259.         Pixmap pixmapMask;
  260.  
  261.         getPixmapsForEntry(entry,&pixmap,&pixmapMask,NULL,NULL);
  262.         
  263.         XtVaSetValues(item,
  264.                       XmNpixmap,        pixmap,
  265.                       XmNpixmapMask,    pixmapMask,
  266.                       XmNbuttonLayout,    XmBUTTON_LABEL_ON_RIGHT,
  267.                       NULL);
  268.     }
  269.  
  270.     // Add popup callback to item
  271.     XtAddCallback(item,
  272.                   XmNbutton3DownCallback,
  273.                   &XFE_PersonalToolbar::popupCB,
  274.                   (XtPointer) this);
  275. }
  276. //////////////////////////////////////////////////////////////////////////
  277. /* virtual */ void
  278. XFE_PersonalToolbar::configureXfeCascade(Widget item,BM_Entry * entry)
  279. {
  280.     if (fe_globalPrefs.toolbar_style == BROWSER_TOOLBAR_TEXT_ONLY)
  281.     {
  282.         XtVaSetValues(item,
  283.                       XmNpixmap,            XmUNSPECIFIED_PIXMAP,
  284.                       XmNarmedPixmap,        XmUNSPECIFIED_PIXMAP,
  285.                       XmNpixmapMask,        XmUNSPECIFIED_PIXMAP,
  286.                       XmNarmedPixmapMask,    XmUNSPECIFIED_PIXMAP,
  287.                       NULL);
  288.  
  289. //        XtVaSetValues(item,XmNbuttonLayout,XmBUTTON_LABEL_ONLY,NULL);
  290.     }
  291.     else
  292.     {
  293.         Pixmap        pixmap;
  294.         Pixmap        armedPixmap;
  295.         Pixmap        pixmapMask;
  296.         Pixmap        armedPixmapMask;
  297.         Arg            av[4];
  298.         Cardinal    ac = 0;
  299.  
  300.         getPixmapsForEntry(entry,&pixmap,&pixmapMask,
  301.                            &armedPixmap,&armedPixmapMask);
  302.  
  303.  
  304.         XtSetArg(av[ac],XmNpixmap,            pixmap); ac++;
  305.         XtSetArg(av[ac],XmNpixmapMask,        pixmapMask); ac++;
  306.  
  307.         // Only show the aremd pixmap/mask if this entry has children
  308.         if (XfeIsAlive(XfeCascadeGetSubMenu(item)))
  309.         {
  310.             XtSetArg(av[ac],XmNarmedPixmap,        armedPixmap); ac++;
  311.             XtSetArg(av[ac],XmNarmedPixmapMask,    armedPixmapMask); ac++;
  312.         }
  313.  
  314.         XtSetValues(item,av,ac);
  315.  
  316. //        XtVaSetValues(item,XmNbuttonLayout,XmBUTTON_LABEL_ON_RIGHT,NULL);
  317.     }
  318.  
  319.     // Add popup callback to item
  320.     XtAddCallback(item,
  321.                   XmNbutton3DownCallback,
  322.                   &XFE_PersonalToolbar::popupCB,
  323.                   (XtPointer) this);
  324. }
  325. //////////////////////////////////////////////////////////////////////////
  326. /* virtual */ void
  327. XFE_PersonalToolbar::updateAppearance()
  328. {
  329.     if (fe_globalPrefs.toolbar_style == BROWSER_TOOLBAR_TEXT_ONLY)
  330.     {
  331.         XtVaSetValues(m_toolBar,XmNbuttonLayout,XmBUTTON_LABEL_ONLY,NULL);
  332.     }
  333.     else
  334.     {
  335.         XtVaSetValues(m_toolBar,XmNbuttonLayout,XmBUTTON_LABEL_ON_RIGHT,NULL);
  336.     }
  337.  
  338.     reallyUpdateRoot();
  339. }
  340. //////////////////////////////////////////////////////////////////////////
  341. /* virtual */ void
  342. XFE_PersonalToolbar::updateToolbarFolderName()
  343. {
  344.     // Access the new toolbar folder 
  345.     BM_Entry * newFolder = XFE_PersonalToolbar::getToolbarFolder();
  346.  
  347.     // Make sure the folder has indeed changed
  348.     if (m_toolBarFolder != newFolder)
  349.     {
  350.         // Assign the new toolbar folder
  351.         m_toolBarFolder = newFolder;
  352.         
  353.         // Update
  354.         reallyUpdateRoot();
  355.     }
  356. }
  357. //////////////////////////////////////////////////////////////////////////
  358. void
  359. XFE_PersonalToolbar::addDefaultPersonalEntries(char *        configString,
  360.                                                BM_Entry *    header)
  361. {
  362.     int            i = 0;
  363.     XP_Bool        ok = PREF_NOERROR;
  364.     char *        label;
  365.     char *        url;
  366.     BM_Entry *    entry;
  367.     char        curConfigString[256];
  368.  
  369.     XP_SPRINTF(curConfigString,"%s.item",configString);
  370.  
  371.     for (i=0; ok==PREF_NOERROR; i++)
  372.     {
  373.         label = url = NULL;
  374.  
  375.         ok = PREF_CopyIndexConfigString(curConfigString,i,"label",&label);
  376.  
  377.         if (ok == PREF_NOERROR)
  378.         {
  379.             ok = PREF_CopyIndexConfigString(curConfigString,i,"url",&url);
  380.             if(ok == PREF_NOERROR)
  381.             {    
  382.                 // if it's a folder we need to first fill it in
  383.                 if(XP_STRCMP(url, "FOLDER")== 0)
  384.                 {
  385.                     entry = BM_NewHeader(label);
  386.  
  387.                     char buf[256];
  388.  
  389.                     XP_SPRINTF(buf,"%s_%d",curConfigString,i);
  390.  
  391.                     addDefaultPersonalEntries(buf,entry);
  392.                 }
  393.                 // otherwise just create a new url
  394.                 else
  395.                 {
  396.                     entry = BM_NewUrl(label,url,NULL,0);
  397.                 }
  398.  
  399.                 //add the new entry
  400.                 BM_AppendToHeader(getBookmarkContext(),header,entry);
  401.             }
  402.  
  403.         }
  404.  
  405.         if(label)
  406.         {
  407.             XP_FREE(label);
  408.         }
  409.  
  410.         if(url)
  411.         {
  412.             XP_FREE(url);
  413.         }
  414.     }
  415. }
  416. //////////////////////////////////////////////////////////////////////////
  417. Widget
  418. XFE_PersonalToolbar::getToolBarWidget()
  419. {
  420.     return m_toolBar;
  421. }
  422. //////////////////////////////////////////////////////////////////////////
  423. void
  424. XFE_PersonalToolbar::setRaised(XP_Bool state)
  425. {
  426.     XP_ASSERT( XfeIsAlive(m_toolBar) );
  427.  
  428.     XtVaSetValues(m_toolBar,XmNraised,state,NULL);
  429. }
  430. //////////////////////////////////////////////////////////////////////////
  431. void
  432. XFE_PersonalToolbar::addEntry(const char *    address,
  433.                               const char *    title,
  434.                               BM_Date        lastAccess)
  435. {
  436.     XP_ASSERT( address != NULL );
  437.     XP_ASSERT( title != NULL );
  438.  
  439.     // If there is no personal toolbar folder add a default one
  440.     if (!m_toolBarFolder)
  441.     {
  442.         addDefaultToolbarFolder();
  443.     }
  444.  
  445.      XP_ASSERT( isToolbarFolderValid() );
  446.  
  447.     if (!isToolbarFolderValid())
  448.     {
  449.         return;
  450.     }
  451.  
  452.     BM_Entry * entry = BM_NewUrl(title,address,NULL,lastAccess);
  453.  
  454.     BM_AppendToHeader(getBookmarkContext(),m_toolBarFolder,entry);
  455. }
  456. //////////////////////////////////////////////////////////////////////////
  457. void
  458. XFE_PersonalToolbar::destroyToolbarWidgets()
  459. {
  460.     XP_ASSERT( XfeIsAlive(m_toolBar) );
  461.  
  462.      WidgetList        children;
  463.      Cardinal        num_children;
  464.  
  465.      XfeChildrenGet(m_toolBar,&children,&num_children);    
  466.  
  467.      // Get rid of the previous items we created
  468.      if (children && num_children)
  469.     {
  470.         XtUnmanageChildren(children,num_children);
  471.       
  472.         fe_DestroyWidgetTree(children,num_children);
  473.     }
  474. }
  475. //////////////////////////////////////////////////////////////////////////
  476. void
  477. XFE_PersonalToolbar::addDefaultToolbarFolder()
  478. {
  479.     // First, look for a folder called "Personal Toolbar Folder"
  480.     BM_Entry * folder = getTopLevelFolder(DEFAULT_TOOLBAR_FOLDER_NAME);
  481.  
  482.     if (!folder)
  483.     {
  484.         folder = BM_NewHeader(DEFAULT_TOOLBAR_FOLDER_NAME);
  485.             
  486.         BM_AppendToHeader(getBookmarkContext(),
  487.                           getRootFolder(),
  488. //                          BM_GetAddHeader(getBookmarkContext()),
  489.                           folder);
  490.     }
  491.  
  492.     XFE_PersonalToolbar::setToolbarFolder(folder,True);
  493. }
  494. //////////////////////////////////////////////////////////////////////////
  495. XP_Bool
  496. XFE_PersonalToolbar::isToolbarFolderValid()
  497. {
  498.      return ((m_toolBarFolder != NULL) && BM_IsHeader(m_toolBarFolder));
  499. }
  500. //////////////////////////////////////////////////////////////////////////
  501.  
  502. /* static */ void
  503. XFE_PersonalToolbar::setToolbarFolder(BM_Entry * entry,XP_Bool notify)
  504. {
  505.     char *    name = "";
  506.     XP_Bool    has_folder = False;
  507.  
  508.     // Assign the name if the entry is valid
  509.     if (entry && BM_IsHeader(entry))
  510.     {
  511.         name = BM_GetName(entry);
  512.         has_folder = True;
  513.     }
  514.  
  515.     // Set the preferences
  516.     StrAllocCopy(fe_globalPrefs.personal_toolbar_folder, name);
  517.     fe_globalPrefs.has_toolbar_folder = has_folder;
  518.  
  519.     // Notify mozilla app that the personal toolbar folder has changed.
  520.     if (notify)
  521.     {
  522.         XFE_MozillaApp::theApp()->notifyInterested(
  523.             XFE_MozillaApp::personalToolbarFolderChanged);
  524.     }
  525. }
  526. //////////////////////////////////////////////////////////////////////////
  527. /* static */ BM_Entry *
  528. XFE_PersonalToolbar::getToolbarFolder()
  529. {
  530.     BM_Entry * result = NULL;
  531.  
  532.     if (!XFE_BookmarkFrame::main_bm_context)
  533.     {
  534.         return NULL;
  535.     }
  536.  
  537.     // Access the toolbar folder name
  538.     char * name = XFE_PersonalToolbar::getToolbarFolderName();
  539.  
  540.     // Try to find the folder to match the name
  541.     if (name)
  542.     {
  543.         BM_Entry * root = BM_GetRoot(XFE_BookmarkFrame::main_bm_context);
  544.         
  545.         XP_ASSERT( root != NULL );
  546.         
  547.         if (root)
  548.         {
  549.             result = XFE_BookmarkBase::BM_FindFolderByName(root,name);
  550.         }
  551.     }
  552.  
  553.     return result;
  554. }
  555. //////////////////////////////////////////////////////////////////////////
  556. /* static */ XP_Bool
  557. XFE_PersonalToolbar::hasToolbarFolder()
  558. {
  559.      // Find out if we do have a toolbar folder
  560.     return fe_globalPrefs.has_toolbar_folder;
  561. }
  562. //////////////////////////////////////////////////////////////////////////
  563. /* static */ char *
  564. XFE_PersonalToolbar::getToolbarFolderName()
  565. {
  566.     // Make sure the main bookmark context is valid
  567.     if (!XFE_BookmarkFrame::main_bm_context)
  568.     {
  569.         return NULL;
  570.     }
  571.  
  572.     // Make sure we have a toolbar folder defined
  573.     if (!XFE_PersonalToolbar::hasToolbarFolder())
  574.     {
  575.         return NULL;
  576.     }
  577.  
  578.     // Find out the name of the toolbar folder
  579.     return fe_globalPrefs.personal_toolbar_folder;
  580. }
  581. //////////////////////////////////////////////////////////////////////////
  582.  
  583.  
  584. //
  585. // Popup menu stuff
  586. //
  587. /* static */ void
  588. XFE_PersonalToolbar::popupCB(Widget        w,
  589.                              XtPointer    clientData,
  590.                              XtPointer    callData)
  591. {
  592.     XFE_PersonalToolbar *    pt = (XFE_PersonalToolbar *) clientData;
  593.     XmAnyCallbackStruct *    cbs = (XmAnyCallbackStruct *) callData;
  594.     XEvent *                event = cbs->event;
  595.  
  596.     pt->handlePopup(w,event);
  597. }
  598. //////////////////////////////////////////////////////////////////////////
  599. void
  600. XFE_PersonalToolbar::handlePopup(Widget w,XEvent * event)
  601. {
  602.     if (!m_popup)
  603.     {
  604.         m_popup = new XFE_PopupMenu("popup",getFrame(),FE_GetToplevelWidget());
  605.         
  606.         m_popup->setMenuSpec(XFE_PersonalToolbar::m_popupMenuSpec);
  607.     }
  608.  
  609.     if (XfeIsButton(w))
  610.     {
  611.         printf("Button Popup(%s)\n",XtName(w));
  612.     }
  613.     else if (XfeIsToolBar(w))
  614.     {
  615.         printf("ToolBar Popup(%s)\n",XtName(w));
  616.     }
  617.  
  618.     m_popup->position(event);
  619.     m_popup->show();
  620.  
  621. //    BM_Entry * entry;
  622. }
  623. //////////////////////////////////////////////////////////////////////////
  624.