/*
* $Id: userPrefs.cxx,v 4.5 2004/06/21 16:12:46 hut66au Exp $
*
* Imview, the portable image analysis application
* http://www.cmis.csiro.au/Hugues.Talbot/imview
* ----------------------------------------------------------
*
* Imview is an attempt to provide an image display application
* suitable for professional image analysis. It was started in
* 1997 and is mostly the result of the efforts of Hugues Talbot,
* Image Analysis Project, CSIRO Mathematical and Information
* Sciences, with help from others (see the CREDITS files for
* more information)
*
* Imview is Copyrighted (C) 1997-2001 by Hugues Talbot and was
* supported in parts by the Australian Commonwealth Science and
* Industry Research Organisation. Please see the COPYRIGHT file
* for full details. Imview also includes the contributions of
* many others. Please see the CREDITS file for full details.
*
* This program 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.
*
* This program 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 this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111, USA.
* */
/*------------------------------------------------------------------------
*
* A user preference panel using fluid.
*
* Hugues Talbot 18 Oct 1998
*
*-----------------------------------------------------------------------*/
#include "imnmspc.hxx"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <string>
#include <sstream>
#include "imview.hxx"
#include "imageIO.hxx"
#include "imageViewer.hxx"
#include "nocase.hxx"
#include "userPrefs.hxx"
#include "io/newprefio.hxx"
// some extern defs
extern imprefs *fileprefs;
extern imageViewer *mainViewer;
extern imageIO *IOBlackBox;
extern int debugIsOn;
extern int stopDebug;
extern char currentprefspath[];
using std::string;
using std::ostringstream;
// user preferences panel methods
userprefs::userprefs()
{
dbgprintf("User preferences panel constructed\n");
userprefsWindow = 0; // fluid depends on that
return;
}
void userprefs::setDefaults()
{
char dblval[20];
if (fileprefs != 0) {
// general stuff
pathToPrefsInput->value(fileprefs->prefspath());
if (fileprefs->smoothZoomout())
smoothWhenZoomoutButton->set();
else
smoothWhenZoomoutButton->clear();
if (fileprefs->keepPoints())
keepPointsButton->set();
else
keepPointsButton->clear();
if (fileprefs->mouseZoomType() == ZOOM_UNCONSTRAINED) {
constrainZoomCheck->clear();
unconstrainZoomCheck->set();
} else {
constrainZoomCheck->set();
unconstrainZoomCheck->clear();
}
transparencyValueSlider->value(fileprefs->overlayTransparency());
// PS stuff
pathToGsInput->value(fileprefs->gspath());
sprintf(dblval, "%d", (int)(fileprefs->psRenderRes()));
renderInput->value(dblval);
sprintf(dblval, "%d", (int)(fileprefs->psDisplayRes()));
displayInput->value(dblval);
// clear everything
greyCheck->clear();
colourCheck->clear();
bwCheck->clear();
switch (fileprefs->psRenderDepth()) {
case PSREND_GREY:
greyCheck->set();
break;
case PSREND_COLOUR:
colourCheck->set();
break;
default:
bwCheck->set();
break;
}
if (fileprefs->psRenderSmooth())
smoothButton->set();
else
smoothButton->clear();
if (fileprefs->psAntialiasRender())
antialiasButton->set();
else
antialiasButton->clear();
boundingChoice->value(fileprefs->psBoundingBox());
// Server stuff
sprintf(dblval, "%g", fileprefs->pollFrequency());
pollFrequencyInput->value(dblval);
pollFrequencySlider->value(log(fileprefs->pollFrequency())/(2*log(10.0)) - 0.5);
if (fileprefs->requirePassword())
securityPasswordButton->set();
else
securityPasswordButton->clear();
if (fileprefs->localhostOnly())
securityLocalhostButton->set();
else
securityLocalhostButton->clear();
// expert stuff
if (fileprefs->hideMenu())
hideMenuButton->set();
else
hideMenuButton->clear();
// Hack stuff
xorValueBreakLineInput->value(fileprefs->xorBreakLines());
xorValueProfileLineInput->value(fileprefs->xorProfileLines());
}
return;
}
// revert to saved
void userprefs::revertPrefs()
{
fileprefs->readprefs(currentprefspath);
}
// save current.
void userprefs::savePrefs()
{
fileprefs->writeprefs(pathToPrefsInput->value());
}
void userprefs::show()
{
userprefsWindow->show();
return;
}
void userprefs::hide()
{
userprefsWindow->hide();
return;
}
// a hash string to find out if things have changed between PS renderings
string userprefs::getPsPrefsHash()
{
ostringstream osm;
if (userprefsWindow != NULL) {
// a CSV string
osm << pathToGsInput->value() << ','
<< renderInput->value() << ','
<< renderInput->value() << ','
<< renderInput->value() << ','
<< greyCheck->value() << ','
<< bwCheck->value() << ','
<< smoothButton->value() << ','
<< antialiasButton->value() << ','
<< boundingChoice->value();
} else
osm << "Unknown";
return osm.str();
}
// the callbacks
// General tab
void prefbrowse_cb(Fl_Button *, userprefs *panel)
{
dbgprintf("Preference file browse button callback\n");
return;
}
void smoothzoomout_cb(Fl_Round_Button *b, userprefs *panel)
{
dbgprintf("Smooth zoomout button callback\n");
if (b->value())
fileprefs->smoothZoomout(true);
else
fileprefs->smoothZoomout(false);
return;
}
void keeppoints_cb(Fl_Round_Button *b, userprefs *panel)
{
dbgprintf("Keep points button callback\n");
if (b->value())
fileprefs->keepPoints(true);
else
fileprefs->keepPoints(false);
return;
}
void constrainedzoom_cb(Fl_Check_Button *, userprefs *panel)
{
dbgprintf("Constrained check button callback\n");
fileprefs->mouseZoomType(ZOOM_CONSTRAINED);
return;
}
void unconstrainedzoom_cb(Fl_Check_Button *, userprefs *panel)
{
dbgprintf("Unconstrained check button callback\n");
fileprefs->mouseZoomType(ZOOM_UNCONSTRAINED);
return;
}
void transparency_cb(Fl_Value_Slider *s, userprefs *panel)
{
dbgprintf("Transparency value slider callback\n");
fileprefs->overlayTransparency(s->value());
//IOBlackBox->applyOverlayToCurrentImage();
IOBlackBox->applyImageParameters(0, 0, 0, true);
mainViewer->displayCurrentImage(); // this should take the new transparency into account
}
// PS tab
void pathtogsinput_cb(Fl_Input *s, userprefs *)
{
dbgprintf("Path to GS input callback\n");
fileprefs->gspath(s->value());
return;
}
void pathtogvinput_cb(Fl_Input *s, userprefs *)
{
dbgprintf("Path to Previewer input callback\n");
fileprefs->gvpath(s->value());
return;
}
void gsbrowse_cb(Fl_Button *, userprefs *panel)
{
dbgprintf("GS path browse button callback\n");
return;
}
void renderinput_cb(Fl_Int_Input *s, userprefs *)
{
dbgprintf("Rendering resolution input callback\n");
fileprefs->psRenderRes((double)(atof(s->value())));
return;
}
void displayinput_cb(Fl_Int_Input *s, userprefs *)
{
dbgprintf("Display resolution input callback\n");
fileprefs->psDisplayRes((double)(atof(s->value())));
return;
}
void colourcheck_cb(Fl_Check_Button *, userprefs *)
{
dbgprintf("Colour check button callback\n");
fileprefs->psRenderDepth(PSREND_COLOUR);
return;
}
void greycheck_cb(Fl_Check_Button *, userprefs *)
{
dbgprintf("Grey check button callback\n");
fileprefs->psRenderDepth(PSREND_GREY);
return;
}
void bwcheck_cb(Fl_Check_Button *, userprefs *)
{
dbgprintf("BW check button callback\n");
fileprefs->psRenderDepth(PSREND_BW);
return;
}
void smoothbutton_cb(Fl_Round_Button *b, userprefs *)
{
dbgprintf("Smooth button callback\n");
if (b->value())
fileprefs->psRenderSmooth(true);
else
fileprefs->psRenderSmooth(false);
return;
}
void aabutton_cb(Fl_Round_Button *b, userprefs *)
{
dbgprintf("Antialias button callback\n");
if (b->value())
fileprefs->psAntialiasRender(true);
else
fileprefs->psAntialiasRender(false);
return;
}
void boundingchoice_cb(Fl_Choice *b, userprefs *)
{
dbgprintf("Bounding box choice callback with value %d\n", b->value());
fileprefs->psBoundingBox((page_size)(b->value()));
return;
}
// Server Tab
void pollslider_cb(Fl_Slider *s, userprefs *up)
{
double v, nv;
dbgprintf("Poll frequency slider callback\n");
v = s->value();
nv = ceil(pow(10,2*v+1));
// update the input field accordingly
up->setInputHz(nv);
// tell the preference manager
fileprefs->pollFrequency(nv);
return;
}
void pollinput_cb(Fl_Float_Input *i, userprefs *up)
{
double v, nv;
char cv[20];
dbgprintf("Poll frequency input callback\n");
v = atof(i->value());
if (v <= 1) { // we can cheat a little and enter low values
v = 10; // 10 Hz only the official minimum
sprintf(cv, "%g", v);
i->value(cv);
} else if (v > 5000) { // 5kHz maxi, this is pushing it...
v = 1000;
sprintf(cv, "%g", v);
i->value(cv);
}
nv = log(v)/(2*log(10.0)) - 0.5; // do the computation yourself!
// update the slider
up->setSliderHz(nv);
// tell the preference manager
fileprefs->pollFrequency(nv);
return;
}
void requirepassword_cb(Fl_Round_Button *b, userprefs *up)
{
dbgprintf("Require password callback\n");
if (b->value())
fileprefs->requirePassword(true);
else
fileprefs->requirePassword(false);
return;
}
void localhostonly_cb(Fl_Round_Button *b, userprefs *up)
{
dbgprintf("local host only callback\n");
if (b->value())
fileprefs->localhostOnly(true);
else
fileprefs->localhostOnly(false);
return;
}
// Expert tab
void hidemenu_cb(Fl_Round_Button *b, userprefs *)
{
dbgprintf("hide menu callback\n");
if (b->value())
fileprefs->hideMenu(true);
else
fileprefs->hideMenu(false);
return;
}
// Hack Tab
void showdebug_cb(Fl_Round_Button *, userprefs *)
{
dbgprintf("Debug button callback\n");
debugIsOn = !debugIsOn;
return;
}
void stopdebug_cb(Fl_Round_Button *, userprefs *)
{
dbgprintf("Stop button callback\n");
stopDebug = !stopDebug;
return;
}
void xorbreakline_cb(Fl_Input *s, userprefs *)
{
dbgprintf("XOR break line callback\n");
fileprefs->xorBreakLines(s->value());
return;
}
void xorprofileline_cb(Fl_Input *s, userprefs *panel)
{
dbgprintf("XOR profile line callback\n");
fileprefs->xorProfileLines(s->value());
return;
}
// main buttons
void cancelbutton_cb(Fl_Button *, userprefs *panel)
{
dbgprintf("Cancel Button pressed on user prefs panel\n");
// revert to saved prefs
panel->revertPrefs();
// hide the window, do nothing
panel->hide();
return;
}
void savebutton_cb(Fl_Button *, userprefs *panel)
{
dbgprintf("Save Button pressed on user prefs panel\n");
// do the preference savings.
panel->savePrefs();
return;
}
void okbutton_cb(Fl_Return_Button *, userprefs *panel)
{
dbgprintf("OK Button pressed on print prefs panel\n");
panel->hide();
return;
}