Files
@ d7edbe56b125
Branch filter:
Location: EI/VirtualLeaf/src/far_mem_5.h
d7edbe56b125
6.2 KiB
text/x-chdr
The snapshot feature stopped working on Windows. The problem was in MainBase::Save, where the "format" argument was added to "image->save". On Windows the file format must be given in Capitals and in specific formats (e.g. TIFF works, TIF not).
It is much safer to leave the 'format' argument out and let the system guess the format from the file extension.
--
user: Roeland Merks <roeland.merks@cwi.nl>
branch 'default'
changed src/canvas.cpp
changed src/mainbase.cpp
changed src/mainbase.h
It is much safer to leave the 'format' argument out and let the system guess the format from the file extension.
--
user: Roeland Merks <roeland.merks@cwi.nl>
branch 'default'
changed src/canvas.cpp
changed src/mainbase.cpp
changed src/mainbase.h
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 | /*
*
* $Id$
*
* This file is part of the Virtual Leaf.
*
* The Virtual Leaf 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 3 of the License, or
* (at your option) any later version.
*
* The Virtual Leaf 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 the Virtual Leaf. If not, see <http://www.gnu.org/licenses/>.
*
* Copyright 2010 Roeland Merks.
*
*/
#ifndef _FAR_MEM_5_h_
#define _FAR_MEM_5_h_
template <class _Arg1, class _Result>
struct my_1_function
{
typedef _Arg1 argument_type1;
typedef _Result result_type; ///< result_type is the return type
};
template <class Result, class Type, class Param1>
class far_1_arg_mem_fun_t : public my_1_function<Param1, Result> {
public:
explicit far_1_arg_mem_fun_t(Type &ir_typ, Result (Type::*i_pmf)(Param1)) {
m_ptyp = &ir_typ;
m_pmf = i_pmf;
};
Result operator()(Param1 i_prm1) { return (m_ptyp->*(m_pmf))(i_prm1); };
protected:
Type *m_ptyp;
Result (Type::*m_pmf)(Param1);
};
template <class Result, class Type,
class Param1>far_1_arg_mem_fun_t<Result,Type,Param1> far_1_arg_mem_fun(Type &ir_typ, Result (Type::*i_pmf)(Param1) )
{
return far_1_arg_mem_fun_t<Result,Type,Param1>(ir_typ,i_pmf);
}
template <class _Arg1, class _Arg2, class _Result>
struct my_2_function
{
typedef _Arg1 argument_type1;
typedef _Arg2 argument_type2;
typedef _Result result_type; ///< result_type is the return type
};
template <class Result, class Type, class Param1, class Param2>
class far_2_arg_mem_fun_t : public my_2_function<Param1, Param2, Result> {
public:
explicit far_2_arg_mem_fun_t(Type &ir_typ, Result (Type::*i_pmf)(Param1, Param2)) {
m_ptyp = &ir_typ;
m_pmf = i_pmf;
};
Result operator()(Param1 i_prm1, Param2 i_prm2) { return (m_ptyp->*(m_pmf))(i_prm1, i_prm2); };
protected:
Type *m_ptyp;
Result (Type::*m_pmf)(Param1, Param2);
};
template <class Result, class Type, class Param1,
class Param2>far_2_arg_mem_fun_t<Result,Type,Param1, Param2> far_2_arg_mem_fun(Type &ir_typ, Result (Type::*i_pmf)(Param1, Param2) ) {
return far_2_arg_mem_fun_t<Result,Type,Param1, Param2>(ir_typ,i_pmf);
}
template <class _Arg1, class _Arg2, class _Arg3, class _Result>
struct my_3_function
{
typedef _Arg1 argument_type1;
typedef _Arg2 argument_type2;
typedef _Arg3 argument_type3;
typedef _Result result_type; ///< result_type is the return type
};
template <class Result, class Type, class Param1, class Param2, class Param3>
class far_3_arg_mem_fun_t : public my_3_function<Param1, Param2, Param3, Result> {
public:
explicit far_3_arg_mem_fun_t(Type &ir_typ, Result (Type::*i_pmf)(Param1, Param2, Param3)) {
m_ptyp = &ir_typ;
m_pmf = i_pmf;
};
Result operator()(Param1 i_prm1, Param2 i_prm2, Param3 i_prm3) { return (m_ptyp->*(m_pmf))(i_prm1, i_prm2, i_prm3); };
protected:
Type *m_ptyp;
Result (Type::*m_pmf)(Param1, Param2, Param3);
};
template <class Result, class Type, class Param1, class Param2,
class Param3>far_3_arg_mem_fun_t<Result,Type,Param1, Param2, Param3> far_3_arg_mem_fun(Type &ir_typ, Result (Type::*i_pmf)(Param1, Param2, Param3) ) {
return far_3_arg_mem_fun_t<Result,Type,Param1, Param2, Param3>(ir_typ,i_pmf);
}
template <class _Arg1, class _Arg2, class _Arg3, class _Arg4, class _Result>
struct my_4_function
{
typedef _Arg1 argument_type1;
typedef _Arg2 argument_type2;
typedef _Arg3 argument_type3;
typedef _Arg4 argument_type4;
typedef _Result result_type; ///< result_type is the return type
};
template <class Result, class Type, class Param1, class Param2, class Param3, class Param4>
class far_4_arg_mem_fun_t : public my_4_function<Param1, Param2, Param3, Param4, Result> {
public:
explicit far_4_arg_mem_fun_t(Type &ir_typ, Result (Type::*i_pmf)(Param1, Param2, Param3, Param4)) {
m_ptyp = &ir_typ;
m_pmf = i_pmf;
};
Result operator()(Param1 i_prm1, Param2 i_prm2, Param3 i_prm3, Param4 i_prm4) { return (m_ptyp->*(m_pmf))(i_prm1, i_prm2, i_prm3, i_prm4); };
protected:
Type *m_ptyp;
Result (Type::*m_pmf)(Param1, Param2, Param3, Param4);
};
template <class Result, class Type, class Param1, class Param2, class Param3, class Param4>far_4_arg_mem_fun_t<Result,Type,Param1, Param2, Param3, Param4> far_4_arg_mem_fun(Type &ir_typ, Result (Type::*i_pmf)(Param1, Param2, Param3, Param4) ) {
return far_4_arg_mem_fun_t<Result,Type,Param1, Param2, Param3, Param4>(ir_typ,i_pmf);
}
template <class _Arg1, class _Arg2, class _Arg3, class _Arg4, class _Arg5, class _Result>
struct my_5_function
{
typedef _Arg1 argument_type1;
typedef _Arg2 argument_type2;
typedef _Arg3 argument_type3;
typedef _Arg4 argument_type4;
typedef _Arg5 argument_type5;
typedef _Result result_type; ///< result_type is the return type
};
template <class Result, class Type, class Param1, class Param2, class Param3, class Param4, class Param5>
class far_5_arg_mem_fun_t : public my_5_function<Param1, Param2, Param3, Param4, Param5, Result> {
public:
explicit far_5_arg_mem_fun_t(Type &ir_typ, Result (Type::*i_pmf)(Param1, Param2, Param3, Param4, Param5)) {
m_ptyp = &ir_typ;
m_pmf = i_pmf;
};
Result operator()(Param1 i_prm1, Param2 i_prm2, Param3 i_prm3, Param4 i_prm4, Param5 i_prm5) { return (m_ptyp->*(m_pmf))(i_prm1, i_prm2, i_prm3, i_prm4, i_prm5); };
protected:
Type *m_ptyp;
Result (Type::*m_pmf)(Param1, Param2, Param3, Param4, Param5);
};
template <class Result, class Type, class Param1, class Param2, class Param3, class Param4, class Param5>far_5_arg_mem_fun_t<Result,Type,Param1, Param2, Param3, Param4, Param5> far_5_arg_mem_fun(Type &ir_typ, Result (Type::*i_pmf)(Param1, Param2, Param3, Param4, Param5) ) {
return far_5_arg_mem_fun_t<Result,Type,Param1, Param2, Param3, Param4, Param5>(ir_typ,i_pmf);
}
#endif
/* finis */
|