Logo Search packages:      
Sourcecode: tcm version File versions  Download package

editwindow.c

///////////////////////////////////////////////////////////////////////////////
//
// This file is part of Toolkit for Conceptual Modeling (TCM).
// (c) copyright 1997, Vrije Universiteit Amsterdam.
// Author: Frank Dehne (frank@cs.vu.nl).
//
// TCM is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// TCM is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with TCM; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
// 02111-1307, USA.
////////////////////////////////////////////////////////////////////////////////
#include "mstring.h"
#include "document.h"
#include "editstubs.h"
#include "printer.h"
#include "helper.h"
#include "bitmap.h"
#include "menu.h"
#include "system.h"
#include "version.h"
#include "liteclue.h"
#include "config.h"
#include <stdlib.h>
#include <Xm/XmAll.h>
#include "messagedialog.h"
#include "Teapot2a.xbm"

EditWindow::EditWindow(const char *n): MainWindow(n) {
      helper = 0;
      document = 0;
      printer = 0;
      logo = 0;
      menubar = 0;
      popupEditItems = 0;
      fileItems = 0;
      editItems = 0;
      printItems = 0;
      printerOptionsItems = 0;
      propertiesItems = 0;
      pageOrientationItems = 0;
      pageSizeItems = 0;
      bannerPageItems = 0;
      pageItems = 0;
      helpItems = 0;
      searchItems = 0;
      viewItems = 0;
      documentArea = 0;
      statusArea = 0;
      statusText = 0;
      dirName = 0;
      documentName = 0;
      documentLevel = 0;
      documentType = 0;
      modifiedToggle = 0;
      editMenu = 0;
      screenType = SUN17;
      doLoad = False;
      projDir = "";
      loadFile = "";
      generatePS = False;
      generateEPS = False;
      generateFig = False;
      generatePNG = False;
      generateLatexFonts = False;
      doMap = True;
}

EditWindow::~EditWindow() {
      if (helper)
            delete helper;
      if (printer)
            delete printer;
      if (document)
            delete document;
      if (popupEditItems)
            delete popupEditItems;
      if (fileItems)
            delete fileItems;
      if (editItems)
            delete editItems;
      if (printItems)
            delete printItems;
      if (printerOptionsItems)
            delete printerOptionsItems;
      if (bannerPageItems)
            delete bannerPageItems;
      if (helpItems)
            delete helpItems;
      if (viewItems)
            delete viewItems;
      if (searchItems)
            delete searchItems;
      if (propertiesItems)
            delete propertiesItems;
      if (pageOrientationItems)
            delete pageOrientationItems;
      if (pageSizeItems)
            delete pageSizeItems;
      if (pageItems)
            delete pageItems;
}

00113 void EditWindow::Manage() {
      if (doMap)
            MainWindow::Manage();
      else
            MainWindow::ManageUnmapped();
}

00120 Widget EditWindow::CreateWorkArea(Widget parent, int argc, char **argv) {
      if (!check(parent))
            return 0;
      logoBitmap.xbm_width = Teapot2a_width;
      logoBitmap.xbm_height = Teapot2a_height;
      logoBitmap.xbm_bits = (unsigned char *)Teapot2a_bits;
      logoPixmap = logoBitmap.CreatePixmap(parent, GetDisplay());
      Widget form = XtVaCreateManagedWidget(GetName()->getstr(), 
            xmFormWidgetClass, parent, 0);
      // find type of document tool 
      int tool = GetTool();
      // parse command line options
      DetermineScreen(XtScreen(parent)); // determine screen sizes.
      ParseUserOptions(argc, argv);
      // Create application objects.
      CreateHelper();
      CreateDocument();
      CreatePrinter();
      CreateComponents(form); // create the UI components of the main window.
      string title = Toolkit::TOOLKIT_NAME;
      title += ": ";
      title += Toolkit::TOOL_TITLES[tool];
      title += " - ";
      title += Version::TOOLKIT_VERSION;
      SetTitle(&title);
      // set name and pixmap of the icon.
      SetIconName(Toolkit::TOOL_NAMES[tool]); 
      SetIconPixmap(logoPixmap);
      return form;
}

00151 void EditWindow::ParseUserOptions(int argc, char **argv) {
      int n;
      argsLeft = argc-1;
      bool doExit = False;
      // look for help option.
      if (System::FindArg(argv, argc, "-help", n) || 
          System::FindArg(argv, argc, "-h", n)) {
            WriteUsage(argv[0]);
            doExit = True;
      }
      // look for version option.
      if (System::FindArg(argv, argc, "-version", n) ||
          System::FindArg(argv, argc, "-v", n)) {
            std::cerr << argv[0] << ": " << Version::TOOLKIT_VERSION << std::endl;
            doExit = True;
      }
      if (doExit)
            exit(0);
      // find but ignore priv_cmap option here.
      if (System::FindArg(argv, argc, "-priv_cmap", n)) {
            argsLeft -= 1;
      }
      // look for -project option to set working directory.
      if (System::FindArg(argv, argc, "-projdir", n)) {
            if (n < argc-1) {
                  projDir = argv[n+1]; 
                  argsLeft -= 2;
            }
            else {
                  WriteUsage(argv[0]);
                  exit(1);
            }
      }
      // look for -toPS option to generate PS.
      if (System::FindArg(argv, argc, "-toPS", n)) {
            argsLeft -= 1;
            psFile = "";
            generatePS = True;
            doMap = False;
            if (n < argc-1) {
                  char *c = strrchr(argv[n+1], '.');
                  if (c && equal(c, ".ps")) {
                        argsLeft -= 1;
                        psFile = argv[n+1];
                  }
            }
      }
      // look for -toEPS option to generate EPS.
      if (System::FindArg(argv, argc, "-toEPS", n)) {
            argsLeft -= 1;
            epsFile = "";
            generateEPS = True;
            doMap = False;
            if (n < argc-1) {
                  char *c = strrchr(argv[n+1], '.');
                  if (c && equal(c, ".eps")) {
                        argsLeft -= 1;
                        epsFile = argv[n+1];
                  }
            }
      }
      // look for -toPNG option to generate PNG.
      if (System::FindArg(argv, argc, "-toPNG", n)) {
            argsLeft -= 1;
            pngFile = "";
            generatePNG = True;
            doMap = False;
            if (n < argc-1) {
                  char *c = strrchr(argv[n+1], '.');
                  if (c && equal(c, ".png")) {
                        argsLeft -= 1;
                        pngFile = argv[n+1];
                  }
            }
      }
      // look for -toFig option to generate Fig.
      if (System::FindArg(argv, argc, "-toFig", n) ||
          System::FindArg(argv, argc, "-toFIG", n)) {
            argsLeft -= 1;
            figFile = "";
            generateFig = True;
            doMap = False;
            if (n < argc-1) {
                  char *c = strrchr(argv[n+1], '.');
                  if (c && equal(c, ".fig")) {
                        argsLeft -= 1;
                        figFile = argv[n+1];
                  }
            }
            if (System::FindArg(argv, argc, "-latex", n)) {
                  argsLeft -= 1;
                  generateLatexFonts = True;
            }
      }
}

void EditWindow::WriteUsage(const char *prog) {
      const char *OPTIONS = 
      "-drawing <w>x<h>\tCreate drawing area of <w>x<h> pixels\n"
      "-h[elp]\t\t\tShow this message and quit\n"
      "-maxdrawing <w>x<h>\tSet maximum drawing area size to <w>x<h> pixels\n"
      "-projdir <dir>\t\tSet the project directory to <dir>\n"
      "-priv_cmap\t\tStart the editor with a private colormap\n"
      "-toPS [<file>.ps]\tGenerate PostScript (to <file>.ps or else stdout) "             
            "and quit\n"
      "-toEPS [<file>.eps]\tGenerate EPS (to <file>.eps or else stdout) "
             "and quit\n"
      "-toFig [<file>.fig] [-latex]\tGenerate Fig format (to <file>.fig "
            "or else\n\t\t\tstdout) and quit. "
            "When the -latex option is given\n\t\t\tLaTeX fonts are "
            "generated, otherwise normal PostScript\n\t\t\t fonts"
            "are generated\n"
      "-toPNG <file>.png\tGenerate PNG format to <file>.png and quit\n"
      "-v[ersion]\t\tShow the TCM version and quit\n"
      "remark: the -toXXX options require an existing TCM document file\n";
      std::cerr << "Usage: " << prog << " [options] [document]\nOptions:\n"
           << OPTIONS << std::endl;
}


Widget EditWindow::CreateLogo(Widget parent) {
      // draws a little picture in the top right corner of parent. 
      if (!check(parent))
            return 0;
      Pixel fg, bg;
      // get the foreground and background colors of the parent
      // to make the pixmaps appear using a consistent color
      XtVaGetValues(parent, XmNforeground, &fg, XmNbackground, &bg, 0);
      // the pixmap is loaded from a X11 bitmap, called DEFAULT_ICON.
      Pixmap px = logoBitmap.CreatePixmap(parent, GetDisplay()); 
      Widget button = XtVaCreateManagedWidget(
                  "logo", xmPushButtonWidgetClass, parent,
                  XmNlabelPixmap, px,
                  XmNlabelType, XmPIXMAP,
                  XmNtopAttachment, XmATTACH_FORM,
                  XmNrightAttachment, XmATTACH_FORM, 0);
      XtAddCallback(button, XmNactivateCallback, AboutCB, (XtPointer)this);
      AddLiteClue(button, "TCM logo");
      return button;
}

Widget EditWindow::CreateDocumentArea(Widget parent) {
      // draws a label and a text-field which is intended to contain the
      // name and type of document that is being edited
      if (!check(parent))
            return 0;
      Widget rc = XtVaCreateWidget("DocumentArea", 
            xmRowColumnWidgetClass, parent, 
            XmNadjustLast, True,
            XmNorientation, XmHORIZONTAL,
            XmNleftAttachment, XmATTACH_FORM, 0);
      if (menubar)
            XtVaSetValues(rc, XmNtopAttachment, XmATTACH_WIDGET,
                  XmNtopWidget, menubar, 0);
      if (logo)
            XtVaSetValues(rc, XmNrightAttachment, XmATTACH_WIDGET,
                  XmNrightWidget, logo, 0);
      XtVaCreateManagedWidget("Document Type: ",
            xmLabelWidgetClass, rc,
            XmNalignment, XmALIGNMENT_BEGINNING, 0);
      documentType = XtVaCreateManagedWidget("DocumentType",
            xmTextFieldWidgetClass, rc, 
            XmNcolumns, 15,
            XmNeditable, False,
            XmNcursorPositionVisible, False, 0);
      AddLiteClue(documentType, 
            "The type of document that is edited by this editor (fixed)");
      XtVaCreateManagedWidget("Name: ",
            xmLabelWidgetClass, rc, 
            XmNalignment, XmALIGNMENT_BEGINNING, 0);
      documentName = XtVaCreateManagedWidget("DocumentName",
            xmTextFieldWidgetClass, rc, 
            XmNeditable, True,
            XmNcolumns, 10,
            XmNcursorPositionVisible, True, 0);
      AddLiteClue(documentName, 
            "The document name. Can be changed (apply with <enter>)");
      if (check(document))
            XtAddCallback(documentName, XmNactivateCallback, 
                  EditStubs::ChangeNameCB, (XtPointer)document);
      if (Toolkit::HierarchicEditor(GetTool())) {
//          XtVaCreateManagedWidget("Level: ",
//                xmLabelWidgetClass, rc,
//                XmNalignment, XmALIGNMENT_BEGINNING, 0);
//          documentLevel = XtVaCreateManagedWidget("DocumentLevel",
//                xmTextFieldWidgetClass, rc,
//                XmNeditable, False,
//                XmNcursorPositionVisible, False, 0);
//          AddLiteClue(documentLevel,
//                "The current level in the document (fixed)");
      }
      modifiedToggle = CreateToggle(rc, "modified", False, 
                  EditStubs::SetModifiedCB, (XtPointer)document);
      AddLiteClue(modifiedToggle, "Indicates document modification");
      XtUninstallTranslations(modifiedToggle); 
      XtManageChild(rc);
      return rc;
}

Widget EditWindow::CreateControlArea(Widget parent) {
      if (!check(parent))
            return 0;
      Widget rc = XtVaCreateWidget("ControlArea", 
            xmRowColumnWidgetClass, parent, 
            XmNorientation, XmHORIZONTAL, 0);
      if (statusArea) 
            XtVaSetValues(rc, XmNtopWidget, statusArea, 
                  XmNtopAttachment, XmATTACH_WIDGET, 0);
      XtVaSetValues(rc, XmNbottomAttachment, XmATTACH_FORM, 0);
      XtManageChild(rc);
      return rc;
}

Widget EditWindow::CreateStatusArea(Widget parent) {
      // create a single line uneditable text field. This is the area 
      // intended for (status) text output of the application.
      if (!check(parent))
            return 0;
      Widget rc = XtVaCreateWidget("StatusArea", 
            xmRowColumnWidgetClass, parent, 
            XmNorientation, XmHORIZONTAL, 0);
      if (controlArea) 
            XtVaSetValues(rc, XmNbottomWidget, controlArea, 
                  XmNbottomAttachment, XmATTACH_WIDGET, 0);
      statusText = XtVaCreateManagedWidget("StatusText",
            xmTextFieldWidgetClass, rc, 
            XmNeditable, False,
            XmNcursorPositionVisible, False,
            XmNshadowThickness, 0,
            XmNvalue, "...", 0);
      if (screenType <= SVGA)
            XtVaSetValues(statusText, XmNcolumns, 40, 0);
      else
            XtVaSetValues(statusText, XmNcolumns, 50, 0);
      XtManageChild(rc);
      return rc;
}

Widget EditWindow::CreateToggle(Widget parent, const char *label, bool Init, 
                  XtCallbackProc fun, XtPointer clientData) {
      if (!check(parent))
            return 0;
      XmString text = CreateXmString(label);
      Widget toggle = XtVaCreateManagedWidget(label, 
            xmToggleButtonWidgetClass, parent,
            XmNlabelString, text,
            XmNset, Init, 0);
      XtAddCallback(toggle, XmNvalueChangedCallback, fun, clientData);
      XmStringFree(text);
      return toggle;
}

00403 void EditWindow::EnableUndo(bool flag) {
      // change edit pulldown menu undo sensitiveness.
      if (!editMenu)
            return;
      Widget undoMenuItem = editMenu->GetMenuItem("Undo");
      if (undoMenuItem) {
            XtVaSetValues(undoMenuItem, XmNsensitive, flag, 0);
      }
}

00413 void EditWindow::EnableRedo(bool flag) {
      // change edit pulldown menu redo sensitiveness.
      if (!editMenu)
            return;
      Widget redoMenuItem = editMenu->GetMenuItem("Redo");
      if (redoMenuItem)
            XtVaSetValues(redoMenuItem, XmNsensitive, flag, 0);
}

00422 void EditWindow::SetUndoName(const char *uname) {
      // change edit pulldown menu undo label.
      if (!editMenu)
            return;
      XmString s = CreateXmString(uname);
      Widget undoMenuItem = editMenu->GetMenuItem("Undo");
      if (undoMenuItem)
            XtVaSetValues(undoMenuItem, XmNlabelString, s, 0);
      XmStringFree(s);
}

00433 void EditWindow::SetRedoName(const char *uname) {
      // change edit pulldown menu redo label.
      if (!editMenu)
            return;
      XmString s = CreateXmString(uname);
      Widget redoMenuItem = editMenu->GetMenuItem("Redo");
      if (redoMenuItem)
            XtVaSetValues(redoMenuItem, XmNlabelString, s, 0);
      XmStringFree(s);
}

00444 void EditWindow::DetermineScreen(Screen *s) {
      int width = WidthOfScreen(s);
      int height = HeightOfScreen(s);
#ifdef DEBUG
      error("screen wxh = %dx%d\n", width, height);
#endif
      // Find out what popular resolution the screen has.
      if (width >= 1280 && height >= 1024)
            screenType = HP19;
      else if (width >= 1024 && height >= 1024)
            screenType = NCD16;
      else if (width >= 1152 && height >= 900)
            screenType = SUN17;
      else if (width >= 1024 && height >= 800)
            screenType = NCD19B;
      else if (width >= 1024 && height >= 768)
            screenType = XVGA;
      else if (width >= 800 && height >= 600)
            screenType = SVGA;
      else if (width >= 640 && height >= 480)
            screenType = VGA;
      else
            screenType = VGA;
}

void EditWindow::CreatePrinter() {
      if (check(document) && check(GetConfig()))
            printer = new Printer(GetConfig(), document);
}

void EditWindow::CreateHelper() {
      helper = new Helper(GetConfig(), this);
}

00478 void EditWindow::Finalize() {
      document->UpdateWindow();
      if (projDir != "")
            document->NewDir(&projDir);
      SetStatus("");
      // if a file is given as command line option, try to load it.
      if (doLoad) {
            loadFile.setSuffix(*document->GetSuffix());
            if (System::FileExists(loadFile.getstr()))
                  document->DoLoad(&loadFile);
            else {
                  if (doMap)
                        document->NewFile(&loadFile);
            }
      }
      // "send email on startup?"
      if (GetConfig()->GetSendEmailOnStartup()) {
            System::SendEmail(System::emailAddress, 
                System::TOOLKIT_STAT_HEADER, Toolkit::TOOL_NAMES[GetTool()], 
                Version::TOOLKIT_VERSION, "");
      }
      // generate PS, EPS, PNG or Fig??
      if (!doMap) {
            if (!doLoad) {
                  std::cerr << "error: no document file name given" << std::endl;
                  WriteUsage(Toolkit::EXECUTABLE_NAMES[GetTool()]);
            }
            else if (!document->IsLoaded()) {
                  std::cerr << "error: incorrect or non-existent document " 
                          "file given" << std::endl;
                  WriteUsage(Toolkit::EXECUTABLE_NAMES[GetTool()]);
            }
            else {
                  if (generatePS)
                        printer->SavePostScript(&psFile, False);
                  if (generateEPS)
                        printer->SaveEPS(&epsFile);
                  if (generatePNG)
                        printer->SavePNG(&pngFile);
                  if (generateFig)
                        printer->SaveFig(&figFile, generateLatexFonts);
            }
            Close();
      }
}

00524 void EditWindow::SetStatus(const char *message) {
      if (statusText)
            XtVaSetValues(statusText, XmNvalue, message, 0); 
}

void EditWindow::SetStatus(const string *message) {
      SetStatus(message->getstr());
}

00533 void EditWindow::SetDocumentName(const char *s) {
      if (documentName) {
            int columns = min(30, max(10, strlen(s)+2));
            XtVaSetValues(documentName, XmNvalue, s, 
                              XmNcolumns, columns, 0); 
            // show document name also in the icon.
            SetIconName(s); 
      }
}

void EditWindow::SetDocumentName(const string *s) {
      SetDocumentName(s->getstr());
}

00547 void EditWindow::SetDocumentType(const char *s) {
      if (documentType) {
            int columns = min(30, max(10, strlen(s)+2));
            XtVaSetValues(documentType, XmNvalue, s,
                            XmNcolumns, columns, 0); 
      }
}

void EditWindow::SetDocumentType(const string *s) {
      SetDocumentType(s->getstr());
}

00559 void EditWindow::SetDirName(const char *s) {
      if (dirName) {
            int columns = min(30, max(10, strlen(s)+4));
            XtVaSetValues(dirName, XmNvalue, s,
                        XmNcolumns, columns, 0); 
      }
}

void EditWindow::SetDirName(const string *s) {
      SetDirName(s->getstr());
}

00571 void EditWindow::SetModified(bool set) {
      if (modifiedToggle)
            XtVaSetValues(modifiedToggle, XmNset, set, 0); 
}

void EditWindow::AboutCB(Widget w, XtPointer, XtPointer) {
      MessageDialog *t = new MessageDialog(w, MessageDialog::MESSAGE);
      t->Show("About TCM", Version::ABOUT_TEXT);
}

void EditWindow::SetDocumentLevel(const char *s) {
      if (documentLevel)
            XtVaSetValues(documentLevel, XmNvalue, s,
                                  XmNcolumns, strlen(s)+1, 0);
}

void EditWindow::SetDocumentLevel(const string *s) {
      SetDocumentLevel(s->getstr());
}

00591 void EditWindow::SetPageSubMenuItem(const char *text, int n) {
      if (!pageMenu)
            return;
      Widget item = pageMenu->GetMenuItem(text);
      if (check(item))
            Menu::SetNthChildToggleState(
                  item, Menu::PULLDOWN, n+1, True, True);
}

00600 void EditWindow::SetPageMenuItem(const char *text, bool b) {
      if (!pageMenu)
            return;
      Menu::SetChildToggleState(pageMenu->GetWidget(), 
            Menu::PULLDOWN, text, b);
}

Generated by  Doxygen 1.6.0   Back to index