home *** CD-ROM | disk | FTP | other *** search
/ Resource Library: Multimedia / Resource Library: Multimedia.iso / maestro / source / displytl / imagepan.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-06-15  |  14.5 KB  |  559 lines
  1. /*
  2.  * Copyright (c) 1990, 1991, 1992 Stanford University
  3.  *
  4.  * Permission to use, copy, modify, and distribute this software and 
  5.  * its documentation for any purpose is hereby granted without fee, provided
  6.  * that (i) the above copyright notices and this permission notice appear in
  7.  * all copies of the software and related documentation, and (ii) the name
  8.  * Stanford may not be used in any advertising or publicity relating to
  9.  * the software without the specific, prior written permission of
  10.  * Stanford.
  11.  * 
  12.  * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, 
  13.  * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY 
  14.  * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.  
  15.  *
  16.  * IN NO EVENT SHALL STANFORD BE LIABLE FOR ANY SPECIAL, INCIDENTAL,
  17.  * INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND, OR ANY DAMAGES
  18.  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER OR NOT
  19.  * ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF LIABILITY,
  20.  * ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
  21.  * SOFTWARE.
  22.  */
  23. /* $Header: /Source/Media/collab/DisplayTool/RCS/imagePanel.c,v 1.1 92/10/29 13:57:35 drapeau Exp $ */
  24. /* $Log:    imagePanel.c,v $
  25.  * Revision 1.1  92/10/29  13:57:35  drapeau
  26.  * Initial revision
  27.  *  */
  28. static char dtImagePanel[] = "$Header: /Source/Media/collab/DisplayTool/RCS/imagePanel.c,v 1.1 92/10/29 13:57:35 drapeau Exp $";
  29.  
  30. #include "DisplayTool.h"
  31. #include "externs.h"
  32.  
  33.  
  34.  
  35. /*
  36.  * Notify callback function for `imageXPosition'.
  37.  */
  38. Panel_setting
  39.   ImageXPosition(Panel_item item, Event *event)
  40. {
  41.   int    value = (int) xv_get(item, PANEL_VALUE);
  42.   if (selectedSlideImage == None)
  43.     {
  44.       NoImageSelected();
  45.       return panel_text_notify(item, event);
  46.     }
  47.   else
  48.     {
  49.       EraseOldImage(selectedSlideImage);
  50.       dtImage[selectedSlideImage]->corner.x = value/largeFactor;
  51.       DrawNewImage(selectedSlideImage);
  52.     }
  53.   return panel_text_notify(item, event);
  54. }
  55.  
  56. /*
  57.  * Notify callback function for `imageYPosition'.
  58.  */
  59. Panel_setting
  60.   ImageYPosition(Panel_item item, Event *event)
  61. {
  62.   int    value = (int) xv_get(item, PANEL_VALUE);
  63.   if (selectedSlideImage == None)
  64.     {
  65.       NoImageSelected();
  66.       return panel_text_notify(item, event);
  67.     }
  68.   else
  69.     {
  70.       EraseOldImage(selectedSlideImage);
  71.       dtImage[selectedSlideImage]->corner.y = value/largeFactor;
  72.       DrawNewImage(selectedSlideImage);
  73.     }
  74.   return panel_text_notify(item, event);
  75. }
  76.  
  77. /*
  78.  * Notify callback function for `imageWidth'.
  79.  */
  80. Panel_setting
  81.   ImageWidth(Panel_item item, Event *event)
  82. {
  83.   int    value = (int) xv_get(item, PANEL_VALUE);
  84.   IMAGE    tempImage;
  85.   
  86.   if (selectedSlideImage == None)
  87.     {
  88.       NoImageSelected();
  89.       return panel_text_notify(item, event);
  90.     }
  91.   else
  92.     {
  93.       EraseOldImage(selectedSlideImage);
  94.       tempImage = dtImage[selectedSlideImage];
  95.       tempImage->slideImage = Resize(tempImage->imageData,
  96.                     tempImage->origWidth,
  97.                     tempImage->origHeight,
  98.                     value / largeFactor,
  99.                     tempImage->largeHeight / largeFactor);
  100.       tempImage->largeWidth = value;                    /* Update width of the image to be displayed */
  101.       if (tempImage->largeImage != (XImage*)NULL)            /* Destroy the now-obsolete largeImage, if it exists */
  102.     XDestroyImage(tempImage->largeImage);
  103.       DrawNewImage(selectedSlideImage);
  104.     }
  105.   return panel_text_notify(item, event);
  106. }
  107.  
  108.  
  109.  
  110. /*
  111.  * Notify callback function for `imageHeight'.
  112.  */
  113. Panel_setting
  114.   ImageHeight(Panel_item item, Event *event)
  115. {
  116.   int    value = (int) xv_get(item, PANEL_VALUE);
  117.   IMAGE    tempImage;
  118.   
  119.   if (selectedSlideImage == None)
  120.     {
  121.       NoImageSelected();
  122.       return panel_text_notify(item, event);
  123.     }
  124.   else
  125.     {
  126.       EraseOldImage(selectedSlideImage);
  127.       tempImage = dtImage[selectedSlideImage];
  128.       tempImage->slideImage = Resize(tempImage->imageData,
  129.                     tempImage->origWidth,
  130.                     tempImage->origHeight,
  131.                     tempImage->origWidth / largeFactor,
  132.                     value / largeFactor);
  133.       tempImage->largeHeight = value;                    /* Update height of the image to be displayed */
  134.       if (tempImage->largeImage != (XImage*)NULL)            /* Destroy the now-obsolete largeImage, if it exists */
  135.     XDestroyImage(tempImage->largeImage);
  136.       DrawNewImage(selectedSlideImage);
  137.     }
  138.   return panel_text_notify(item, event);
  139. }                                    /* end function ImageHeight */
  140.  
  141.  
  142.  
  143.  
  144. /*
  145.  * Notify callback function for `imageList'.
  146.  */
  147. int
  148.   ImageList(Panel_item item, char *string, Xv_opaque client_data, 
  149.         Panel_list_op op, Event *event, int row)
  150. {
  151.   int i, count = 0;
  152.   switch(op) {
  153.   case PANEL_LIST_OP_DESELECT:
  154.     WriteSlideInfoToPanel(None);
  155.     break;
  156.     
  157.   case PANEL_LIST_OP_SELECT:
  158.     for (i=0; i<numSlidesImages; i++)
  159.       if (dtImage[i]->slide == selectedSlide)
  160.     {
  161.       if (count == row)
  162.         {
  163.           WriteSlideInfoToPanel(i);
  164.           break;
  165.         }
  166.       count++;
  167.     }
  168.     break;
  169.     
  170.   case PANEL_LIST_OP_VALIDATE:
  171.   case PANEL_LIST_OP_DELETE:
  172.     break;
  173.   }
  174.   return XV_OK;
  175. }                                    /* end function ImageList */
  176.  
  177.  
  178. /*
  179.  * Menu handler for `imagesMenu (Duplicate Image)'.
  180.  */
  181. Menu_item
  182.   DuplicateImage(Menu_item item, Menu_generate op)
  183. {
  184.   if (op == MENU_NOTIFY)
  185.     notice_prompt(baseWindow->baseWindow, NULL,
  186.           NOTICE_MESSAGE_STRINGS,
  187.           "Duplicate Image function hasn't been implemented yet.",
  188.           NULL,
  189.           NOTICE_BUTTON_YES, "OK",
  190.           NULL);
  191.   return item;
  192. }
  193.  
  194. /*
  195.  * Menu handler for `imagesMenu (Cut Image)'.
  196.  */
  197. Menu_item
  198.   CutImage(Menu_item item, Menu_generate op)
  199. {
  200.   int i;
  201.   if (op == MENU_NOTIFY)
  202.     {
  203.       if (selectedSlideImage == None)
  204.     {
  205.       NoImageSelected();
  206.       return item;
  207.     }
  208.       numSlidesImages--;
  209.       for(i=selectedSlideImage; i<numSlidesImages; i++)
  210.     CopyImage(dtImage[i+1], dtImage[i]);
  211.       /*      FreeImage(slidesImage[numSlidesImages]);  */
  212.       WriteSlideInfoToPanel(None);
  213.       SetCurrentSlide(selectedSlide+1);
  214.       SlidesRepaint(NULL, NULL, NULL, NULL);
  215.     }
  216.   return item;
  217. }
  218.  
  219. /*
  220.  * Menu handler for `imagesMenu (Resize Image)'.
  221.  */
  222. Menu_item
  223.   ResizeImageGeneral(Menu_item item, Menu_generate op)
  224. {
  225.   static int    first = TRUE;
  226.   static    Rect    rect;
  227.   
  228.   if (first == TRUE)
  229.     frame_get_rect(resizePopup->resizePopup, &rect);
  230.   if (op == MENU_NOTIFY)
  231.     if ((int)xv_get(resizePopup->resizePopup, XV_SHOW) == FALSE && first)               
  232.       {
  233.     ShowPopup(&resizePopup->resizePopup, 300, 170, rect.r_width, rect.r_height);
  234.     first = FALSE;
  235.       }
  236.     else
  237.       ShowPopup(&resizePopup->resizePopup, None, None, rect.r_width, rect.r_height);
  238.   return item;
  239. }
  240.  
  241. /*
  242.  * Menu handler for `imagesMenu (Resize Image + 10%)'.
  243.  */
  244. Menu_item
  245.   ResizeImagePlus10Percent(Menu_item item, Menu_generate op)
  246. {
  247.   IMAGE    tempImage;
  248.   
  249.   if (op == MENU_NOTIFY)
  250.     {
  251.       if (selectedSlideImage == None)
  252.     {
  253.       NoImageSelected();
  254.       return item;
  255.     }
  256.       else
  257.     {
  258.       tempImage = dtImage[selectedSlideImage];
  259.       EraseOldImage(selectedSlideImage);
  260.       tempImage->slideImage = Resize(tempImage->imageData,
  261.                     tempImage->origWidth,
  262.                     tempImage->origHeight,
  263.                     1.1 * (tempImage->largeWidth / largeFactor),
  264.                     1.1 * (tempImage->largeHeight / largeFactor));
  265.       tempImage->largeWidth = 1.1 * tempImage->largeWidth;
  266.       tempImage->largeHeight = 1.1 * tempImage->largeHeight;
  267.       DrawNewImage(selectedSlideImage);
  268.       xv_set(slidePopup->imageWidth, PANEL_VALUE,
  269.          tempImage->largeWidth, NULL);
  270.       xv_set(slidePopup->imageHeight, PANEL_VALUE, 
  271.          tempImage->largeHeight, NULL);
  272.     }
  273.     }
  274.   return item;
  275. }
  276.  
  277. /*
  278.  * Menu handler for `imagesMenu (Resize Image - 10%)'.
  279.  */
  280. Menu_item
  281.   ResizeImageMinus10Percent(Menu_item item, Menu_generate op)
  282. {
  283.   IMAGE    tempImage;
  284.   
  285.   if (op == MENU_NOTIFY)
  286.     {
  287.       if (selectedSlideImage == None)
  288.     {
  289.       NoImageSelected();
  290.       return item;
  291.     }
  292.       else
  293.     { 
  294.       tempImage = dtImage[selectedSlideImage];
  295.       EraseOldImage(selectedSlideImage);
  296.       tempImage->slideImage = Resize(tempImage->imageData,
  297.                     tempImage->origWidth,
  298.                     tempImage->origHeight,
  299.                     .9 * (tempImage->largeWidth / largeFactor),
  300.                     .9 * (tempImage->largeHeight / largeFactor));
  301.       tempImage->largeWidth = .9 * tempImage->largeWidth;
  302.       tempImage->largeHeight = .9 * tempImage->largeHeight;
  303.       DrawNewImage(selectedSlideImage);
  304.       xv_set(slidePopup->imageWidth, PANEL_VALUE,
  305.          tempImage->largeWidth, NULL);
  306.       xv_set(slidePopup->imageHeight, PANEL_VALUE, 
  307.          tempImage->largeHeight, NULL);
  308.     }
  309.     }
  310.   return item;
  311. }
  312.  
  313. /*
  314.  * Menu handler for `imagesMenu (Set To Original Size)'.
  315.  */
  316. Menu_item
  317.   ImageEditSetToOriginalSize(Menu_item item, Menu_generate op)
  318. {
  319.   IMAGE    tempImage;
  320.   
  321.   if (op == MENU_NOTIFY)
  322.     {
  323.       if (selectedSlideImage == None)
  324.     {
  325.       NoImageSelected();
  326.       return item;
  327.     }
  328.       else
  329.     {
  330.       tempImage = dtImage[selectedSlideImage];
  331.       EraseOldImage(selectedSlideImage);
  332.       tempImage->slideImage = Resize(tempImage->imageData,
  333.                     tempImage->origWidth,
  334.                     tempImage->origHeight,
  335.                     tempImage->origWidth / largeFactor,
  336.                     tempImage->origHeight / largeFactor);
  337.       tempImage->largeWidth = tempImage->origWidth;
  338.       tempImage->largeHeight = tempImage->origHeight;
  339.       DrawNewImage(selectedSlideImage);
  340.       xv_set(slidePopup->imageWidth, PANEL_VALUE,
  341.          tempImage->largeWidth, NULL);
  342.       xv_set(slidePopup->imageHeight, PANEL_VALUE, 
  343.          tempImage->largeHeight, NULL);
  344.     }
  345.     }
  346.   return item;
  347. }                                    /* end function ImageEditSetToOriginalSize */
  348.  
  349.  
  350.  
  351.  
  352.  
  353. /*
  354.  * Menu handler for `selectSlideMenu (Next Slide)'.
  355.  */
  356. Menu_item
  357.   NextSlide(Menu_item item, Menu_generate op)
  358. {
  359.   char temp[MaxLength];
  360.   if (op == MENU_NOTIFY)
  361.     {
  362.       CheckGeometry();  
  363.       if (selectedSlide < GetMaxSlide())
  364.     selectedSlide++;
  365.       else
  366.     {
  367.       notice_prompt(baseWindow->baseWindow, NULL,
  368.             NOTICE_MESSAGE_STRINGS,
  369.             "There are no slides beyond the current slide.",
  370.             NULL,
  371.             NOTICE_BUTTON_YES, "OK",
  372.             NULL);
  373.       return(item);
  374.     }
  375.       beginDoubleBuffer = 1;
  376.       sprintf(temp, "Current Slide    # %d", selectedSlide+1);
  377.       PrepareMultipleWindowsForDisplay(selectedSlide);
  378.       DisplayMultipleWindows(selectedSlide);
  379.     }
  380.   return(item);
  381. }                                    /* end function NextSlide */
  382.  
  383.  
  384.  
  385. /*
  386.  * Menu handler for `selectSlideMenu (Previous Slide)'.
  387.  */
  388. Menu_item
  389.   PreviousSlide(Menu_item item, Menu_generate op)
  390. {
  391.   char temp[MaxLength];
  392.   if (op == MENU_NOTIFY)
  393.     {
  394.       CheckGeometry();
  395.       if (selectedSlide > 0)
  396.     selectedSlide--;
  397.       else
  398.     {
  399.       notice_prompt(baseWindow->baseWindow, NULL,
  400.             NOTICE_MESSAGE_STRINGS,
  401.             "The current slide is the first slide.",
  402.             NULL,
  403.             NOTICE_BUTTON_YES, "OK",
  404.             NULL);
  405.       return(item);
  406.     }
  407.       beginDoubleBuffer = 1;
  408.       sprintf(temp, "Current Slide    # %d", selectedSlide+1);
  409.       PrepareMultipleWindowsForDisplay(selectedSlide);
  410.       DisplayMultipleWindows(selectedSlide);
  411.     }
  412.   return(item);
  413. }                                    /* end function PreviousSlide */
  414.  
  415.  
  416.  
  417. /*
  418.  * Menu handler for `selectSlideMenu (First Slide)'.
  419.  */
  420. Menu_item
  421.   FirstSlide(Menu_item item, Menu_generate op)
  422. {
  423.   char temp[MaxLength];
  424.   if (op == MENU_NOTIFY)
  425.     {
  426.       CheckGeometry();
  427.       previousSlide = selectedSlide;
  428.       selectedSlide = 0;
  429.       sprintf(temp, "Current Slide    # 1");
  430.       beginDoubleBuffer = 1;
  431.       PrepareMultipleWindowsForDisplay(selectedSlide);
  432.       DisplayMultipleWindows(selectedSlide);
  433.     }
  434.   return item;
  435. }
  436.  
  437. /*
  438.  * Menu handler for `selectSlideMenu (Last Slide)'.
  439.  */
  440. Menu_item
  441.   LastSlide(Menu_item item, Menu_generate op)
  442. {
  443.   char temp[MaxLength];
  444.   if (op == MENU_NOTIFY)
  445.     {
  446.       CheckGeometry();
  447.       previousSlide = selectedSlide;
  448.       selectedSlide = GetMaxSlide();
  449.       sprintf(temp, "Current Slide    # %d", selectedSlide+1);
  450.       beginDoubleBuffer = 1;
  451.       PrepareMultipleWindowsForDisplay(selectedSlide);
  452.       DisplayMultipleWindows(selectedSlide);
  453.     }
  454.   return item;
  455. }
  456.  
  457. /*
  458.  * Menu handler for `selectSlideMenu (Slide Number ...)'.
  459.  */
  460. Menu_item
  461.   SlideNumberPopup(Menu_item item, Menu_generate op)
  462. {
  463.   static int    first = TRUE;
  464.   static    Rect    rect;
  465.   
  466.   if (first == TRUE)
  467.     frame_get_rect(slideNumberPopup->slideNumberPopup, &rect);
  468.   if (op == MENU_NOTIFY)
  469.     ShowPopup(&slideNumberPopup->slideNumberPopup, 300, 170, rect.r_width, rect.r_height);
  470.   return item;
  471. }
  472.  
  473. /*
  474.  * Notify callback function for `slideNumber'.
  475.  */
  476. Panel_setting
  477.   SlideNumber(Panel_item item, Event *event)
  478. {
  479.   HidePopup(&slideNumberPopup->slideNumberPopup);
  480.   return panel_text_notify(item, event);
  481. }
  482.  
  483.  
  484.  
  485. void 
  486.   SetCurrentSlide(int slide)
  487. {
  488.   char temp[MaxLength];
  489.   sprintf(temp, "Current Slide    # %d", slide);
  490.   xv_set(baseWindow->currentSlideMessage, PANEL_LABEL_STRING, temp, NULL); 
  491.   if ((int)xv_get(slidePopup->slidePopup, XV_SHOW))
  492.     {
  493.       int i, lastImage, count;
  494.       xv_set(slidePopup->currentSlideInfoMessage, PANEL_LABEL_STRING, temp, NULL); 
  495.       sprintf(temp, "Images on Slide # %d", slide);
  496.       xv_set(slidePopup->imageList, PANEL_LIST_TITLE, temp, NULL);
  497.       ClearList(slidePopup->imageList);
  498.       for (i=0, count=0; i<numSlidesImages; i++)
  499.     if (dtImage[i]->slide == slide-1)
  500.       {
  501.         xv_set(slidePopup->imageList,
  502.            PANEL_LIST_INSERT, count, 
  503.            XV_SHOW, FALSE, 
  504.            PANEL_LIST_STRING, count, dtImage[i]->filename,
  505.            PANEL_LIST_FONT, count, listFont,
  506.            NULL);
  507.         count++;
  508.         lastImage = i;
  509.       }
  510.       
  511. /* if there's only one item in the scrolling list then automatically select it */
  512.       if (count == 1)
  513.     {
  514.       xv_set(slidePopup->imageList, PANEL_LIST_SELECT, 0, TRUE, NULL);
  515.       WriteSlideInfoToPanel(lastImage);
  516.     }
  517.       else
  518.     WriteSlideInfoToPanel(None);    
  519.       xv_set(slidePopup->imageList, XV_SHOW, TRUE, NULL); 
  520.     }
  521. }
  522.  
  523.  
  524.  
  525. void WriteSlideInfoToPanel(int i)
  526. {
  527.   char    temp[MaxLength];
  528.   IMAGE    tempImage;
  529.   
  530.   tempImage = dtImage[i];
  531.   if (i >= 0 && tempImage->filename && tempImage->format)
  532.     {
  533.       xv_set(slidePopup->imageName, PANEL_LABEL_STRING, tempImage->filename, NULL);
  534.       xv_set(slidePopup->imageFormat, PANEL_LABEL_STRING, tempImage->format, NULL); 
  535.       sprintf(temp, "%dx%d", tempImage->origWidth, tempImage->origHeight);
  536.       xv_set(slidePopup->imageOriginalSize, PANEL_LABEL_STRING, temp, NULL);
  537.       xv_set(slidePopup->imageXPosition, PANEL_VALUE, 
  538.          largeFactor*tempImage->corner.x, NULL);
  539.       xv_set(slidePopup->imageYPosition, PANEL_VALUE, 
  540.          largeFactor*tempImage->corner.y, NULL);
  541.       xv_set(slidePopup->imageWidth, PANEL_VALUE, 
  542.          largeFactor*tempImage->largeWidth, NULL);
  543.       xv_set(slidePopup->imageHeight, PANEL_VALUE, 
  544.          largeFactor*tempImage->largeHeight, NULL);
  545.       selectedSlideImage = i;
  546.     }
  547.   else
  548.     {
  549.       xv_set(slidePopup->imageName, PANEL_LABEL_STRING, "", NULL);
  550.       xv_set(slidePopup->imageFormat, PANEL_LABEL_STRING, "", NULL); 
  551.       xv_set(slidePopup->imageOriginalSize, PANEL_LABEL_STRING, "", NULL);
  552.       xv_set(slidePopup->imageXPosition, PANEL_VALUE, 0, NULL);
  553.       xv_set(slidePopup->imageYPosition, PANEL_VALUE, 0, NULL);
  554.       xv_set(slidePopup->imageWidth, PANEL_VALUE, 0, NULL);
  555.       xv_set(slidePopup->imageHeight, PANEL_VALUE, 0, NULL);
  556.       selectedSlideImage = None;
  557.     }
  558. }
  559.