perso
/
finalcut
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Refactoring FButton::draw + Passing more strings by reference

This commit is contained in:
Markus Gans 2017-12-25 21:17:08 +01:00
parent b886143701
commit fd5404ba57
22 changed files with 575 additions and 450 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
ChangeLog
View File

@ -1,3 +1,7 @@
2017-12-21 Markus Gans <guru.mail@muenster.de>
* Refactoring FButton::draw
* Passing more strings by reference
2017-12-21 Markus Gans <guru.mail@muenster.de> 2017-12-21 Markus Gans <guru.mail@muenster.de>
* Refactoring FMenuBar::drawItems * Refactoring FMenuBar::drawItems
* (de)allocation functions in FTerm * (de)allocation functions in FTerm

4
examples/termcap.cpp
View File

@ -33,7 +33,7 @@ static FVTerm* terminal;
// function prototype // function prototype
void tcapBooleans (const std::string&, bool); void tcapBooleans (const std::string&, bool);
void tcapNumeric (const std::string&, int); void tcapNumeric (const std::string&, int);
void tcapString (const std::string&, const char*); void tcapString (const std::string&, const char[]);
void debug (FApplication&); void debug (FApplication&);
void booleans(); void booleans();
void numeric(); void numeric();
@ -59,7 +59,7 @@ void tcapNumeric (const std::string& name, int cap_num)
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
void tcapString (const std::string& name, const char* cap_str) void tcapString (const std::string& name, const char cap_str[])
{ {
uInt len; uInt len;
std::string sequence; std::string sequence;

26
include/final/fbutton.h
View File

@ -136,10 +136,19 @@ class FButton : public FWidget
// Methods // Methods
void init(); void init();
void getButtonState();
uChar getHotkey(); uChar getHotkey();
void setHotkeyAccelerator(); void setHotkeyAccelerator();
void detectHotkey(); void detectHotkey();
int getHotkeyPos (wchar_t[], wchar_t[], uInt);
int clickAnimationIndent (FWidget*);
void clearRightMargin (FWidget*);
void drawMarginLeft();
void drawMarginRight();
void drawTopBottomBackground();
void drawButtonTextLine (wchar_t[]);
void draw(); void draw();
void updateStatusBar();
void updateButtonColor(); void updateButtonColor();
void processClick(); void processClick();
@ -148,6 +157,12 @@ class FButton : public FWidget
bool button_down; bool button_down;
bool click_animation; bool click_animation;
int click_time; int click_time;
int indent;
int space;
int center_offset;
int vcenter_offset;
int txtlength;
int hotkeypos;
short button_fg; short button_fg;
short button_bg; short button_bg;
short button_hotkey_fg; short button_hotkey_fg;
@ -155,6 +170,17 @@ class FButton : public FWidget
short button_focus_bg; short button_focus_bg;
short button_inactive_fg; short button_inactive_fg;
short button_inactive_bg; short button_inactive_bg;
struct state
{
uChar focus : 1;
uChar active_focus : 1;
uChar active : 1;
uChar flat : 1;
uChar non_flat_shadow : 1;
uChar no_underline : 1;
uChar : 2; // padding bits
} is;
}; };
#pragma pack(pop) #pragma pack(pop)

2
include/final/flistbox.h
View File

@ -247,6 +247,8 @@ class FListBox : public FWidget
void drawLabel(); void drawLabel();
void drawList(); void drawList();
void drawListLine (int, listBoxItems::iterator, bool); void drawListLine (int, listBoxItems::iterator, bool);
void printLeftBracket (fc::brackets_type);
void printRightBracket (fc::brackets_type);
void drawListBracketsLine (int, listBoxItems::iterator, bool); void drawListBracketsLine (int, listBoxItems::iterator, bool);
void setLineAttributes (int, bool, bool, bool&); void setLineAttributes (int, bool, bool, bool&);
void unsetAttributes(); void unsetAttributes();

4
include/final/flistview.h
View File

@ -226,7 +226,6 @@ inline const char* FListViewIterator::getClassName() const
inline int FListViewIterator::getPosition() const inline int FListViewIterator::getPosition() const
{ return position; } { return position; }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
// class FListView // class FListView
//---------------------------------------------------------------------- //----------------------------------------------------------------------
@ -293,6 +292,9 @@ class FListView : public FWidget
void onFocusIn (FFocusEvent*); void onFocusIn (FFocusEvent*);
void onFocusOut (FFocusEvent*); void onFocusOut (FFocusEvent*);
// Data Members
static FObjectIterator null_iter;
protected: protected:
// Methods // Methods
void adjustViewport(); void adjustViewport();

3
include/final/fmenu.h
View File

@ -204,7 +204,7 @@ class FMenu : public FWindow, public FMenuList
void drawAcceleratorKey (int&, int); void drawAcceleratorKey (int&, int);
void drawTrailingSpaces (int); void drawTrailingSpaces (int);
void setLineAttributes (FMenuItem*, int); void setLineAttributes (FMenuItem*, int);
void setCursorToHotkeyPosition (FMenuItem*, int); void setCursorToHotkeyPosition (FMenuItem*);
void processActivate(); void processActivate();
// Friend classes // Friend classes
@ -221,6 +221,7 @@ class FMenu : public FWindow, public FMenuList
FMenu* opened_sub_menu; FMenu* opened_sub_menu;
FMenu* shown_sub_menu; FMenu* shown_sub_menu;
uInt max_item_width; uInt max_item_width;
int hotkeypos;
bool mouse_down; bool mouse_down;
bool has_checkable_items; bool has_checkable_items;
}; };

4
include/final/fobject.h
View File

@ -86,7 +86,7 @@ class FObject
bool isChild (FObject*) const; bool isChild (FObject*) const;
bool isDirectChild (FObject*) const; bool isDirectChild (FObject*) const;
bool isWidget() const; bool isWidget() const;
bool isInstanceOf (const char*) const; bool isInstanceOf (const char[]) const;
bool isTimerInUpdating() const; bool isTimerInUpdating() const;
// Methods // Methods
@ -186,7 +186,7 @@ inline bool FObject::isWidget() const
{ return widget_object; } { return widget_object; }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
inline bool FObject::isInstanceOf (const char* classname) const inline bool FObject::isInstanceOf (const char classname[]) const
{ return ( classname ) ? bool(strcmp(classname, getClassName()) == 0) : false; } { return ( classname ) ? bool(strcmp(classname, getClassName()) == 0) : false; }
//---------------------------------------------------------------------- //----------------------------------------------------------------------

128
include/final/fstring.h
View File

@ -84,9 +84,9 @@ class FString
FString (uInt, char); FString (uInt, char);
FString (const FString&); // implicit conversion copy constructor FString (const FString&); // implicit conversion copy constructor
FString (const std::wstring&); // implicit conversion constructor FString (const std::wstring&); // implicit conversion constructor
FString (const wchar_t*); // implicit conversion constructor FString (const wchar_t[]); // implicit conversion constructor
FString (const std::string&); // implicit conversion constructor FString (const std::string&); // implicit conversion constructor
FString (const char*); // implicit conversion constructor FString (const char[]); // implicit conversion constructor
FString (const wchar_t); // implicit conversion constructor FString (const wchar_t); // implicit conversion constructor
FString (const char); // implicit conversion constructor FString (const char); // implicit conversion constructor
@ -96,25 +96,25 @@ class FString
// Overloaded operators // Overloaded operators
FString& operator = (const FString&); FString& operator = (const FString&);
FString& operator = (const std::wstring&); FString& operator = (const std::wstring&);
const FString& operator = (const wchar_t*); const FString& operator = (const wchar_t[]);
FString& operator = (const std::string&); FString& operator = (const std::string&);
const FString& operator = (const char*); const FString& operator = (const char[]);
const FString& operator = (const wchar_t); const FString& operator = (const wchar_t);
const FString& operator = (const char); const FString& operator = (const char);
const FString& operator += (const FString&); const FString& operator += (const FString&);
const FString& operator += (const std::wstring&); const FString& operator += (const std::wstring&);
const FString& operator += (const wchar_t*); const FString& operator += (const wchar_t[]);
const FString& operator += (const std::string&); const FString& operator += (const std::string&);
const FString& operator += (const char*); const FString& operator += (const char[]);
const FString& operator += (const wchar_t); const FString& operator += (const wchar_t);
const FString& operator += (const char); const FString& operator += (const char);
const FString operator + (const FString&); const FString operator + (const FString&);
const FString operator + (const std::wstring&); const FString operator + (const std::wstring&);
const FString operator + (const wchar_t*); const FString operator + (const wchar_t[]);
const FString operator + (const std::string&); const FString operator + (const std::string&);
const FString operator + (const char*); const FString operator + (const char[]);
const FString operator + (const wchar_t); const FString operator + (const wchar_t);
const FString operator + (const char); const FString operator + (const char);
@ -150,44 +150,44 @@ class FString
bool operator < (const FString&) const; bool operator < (const FString&) const;
bool operator < (const std::wstring&) const; bool operator < (const std::wstring&) const;
bool operator < (const wchar_t*) const; bool operator < (const wchar_t[]) const;
bool operator < (const std::string&) const; bool operator < (const std::string&) const;
bool operator < (const char*) const; bool operator < (const char[]) const;
bool operator < (const wchar_t) const; bool operator < (const wchar_t) const;
bool operator < (const char) const; bool operator < (const char) const;
bool operator <= (const FString&) const; bool operator <= (const FString&) const;
bool operator <= (const std::wstring&) const; bool operator <= (const std::wstring&) const;
bool operator <= (const wchar_t*) const; bool operator <= (const wchar_t[]) const;
bool operator <= (const std::string&) const; bool operator <= (const std::string&) const;
bool operator <= (const char*) const; bool operator <= (const char[]) const;
bool operator <= (const wchar_t) const; bool operator <= (const wchar_t) const;
bool operator <= (const char) const; bool operator <= (const char) const;
bool operator == (const FString&) const; bool operator == (const FString&) const;
bool operator == (const std::wstring&) const; bool operator == (const std::wstring&) const;
bool operator == (const wchar_t*) const; bool operator == (const wchar_t[]) const;
bool operator == (const std::string&) const; bool operator == (const std::string&) const;
bool operator == (const char*) const; bool operator == (const char[]) const;
bool operator == (const wchar_t) const; bool operator == (const wchar_t) const;
bool operator == (const char) const; bool operator == (const char) const;
bool operator != (const FString&) const; bool operator != (const FString&) const;
bool operator != (const std::wstring&) const; bool operator != (const std::wstring&) const;
bool operator != (const wchar_t*) const; bool operator != (const wchar_t[]) const;
bool operator != (const std::string&) const; bool operator != (const std::string&) const;
bool operator != (const char*) const; bool operator != (const char[]) const;
bool operator != (const wchar_t) const; bool operator != (const wchar_t) const;
bool operator != (const char) const; bool operator != (const char) const;
bool operator >= (const FString&) const; bool operator >= (const FString&) const;
bool operator >= (const std::wstring&) const; bool operator >= (const std::wstring&) const;
bool operator >= (const wchar_t*) const; bool operator >= (const wchar_t[]) const;
bool operator >= (const std::string&) const; bool operator >= (const std::string&) const;
bool operator >= (const char*) const; bool operator >= (const char[]) const;
bool operator >= (const wchar_t) const; bool operator >= (const wchar_t) const;
bool operator >= (const char) const; bool operator >= (const char) const;
bool operator > (const FString&) const; bool operator > (const FString&) const;
bool operator > (const std::wstring&) const; bool operator > (const std::wstring&) const;
bool operator > (const wchar_t*) const; bool operator > (const wchar_t[]) const;
bool operator > (const std::string&) const; bool operator > (const std::string&) const;
bool operator > (const char*) const; bool operator > (const char[]) const;
bool operator > (const wchar_t) const; bool operator > (const wchar_t) const;
bool operator > (const char) const; bool operator > (const char) const;
@ -197,9 +197,9 @@ class FString
friend const FString operator + (const FString&, const FString&); friend const FString operator + (const FString&, const FString&);
friend const FString operator + (const FString&, const wchar_t); friend const FString operator + (const FString&, const wchar_t);
friend const FString operator + (const std::wstring&, const FString&); friend const FString operator + (const std::wstring&, const FString&);
friend const FString operator + (const wchar_t*, const FString&); friend const FString operator + (const wchar_t[], const FString&);
friend const FString operator + (const std::string&, const FString&); friend const FString operator + (const std::string&, const FString&);
friend const FString operator + (const char*, const FString&); friend const FString operator + (const char[], const FString&);
friend const FString operator + (const wchar_t, const FString&); friend const FString operator + (const wchar_t, const FString&);
friend const FString operator + (const char, const FString&); friend const FString operator + (const char, const FString&);
friend const FString operator + (const wchar_t, const std::wstring&); friend const FString operator + (const wchar_t, const std::wstring&);
@ -223,8 +223,8 @@ class FString
wchar_t front() const; wchar_t front() const;
wchar_t back() const; wchar_t back() const;
FString& sprintf (const wchar_t*, ...); FString& sprintf (const wchar_t[], ...);
FString& sprintf (const char*, ...) FString& sprintf (const char[], ...)
#if defined(__clang__) #if defined(__clang__)
__attribute__((__format__ (__printf__, 2, 3))) __attribute__((__format__ (__printf__, 2, 3)))
#elif defined(__GNUC__) #elif defined(__GNUC__)
@ -264,14 +264,14 @@ class FString
FStringList split (const FString&); FStringList split (const FString&);
FStringList split (const std::wstring&); FStringList split (const std::wstring&);
FStringList split (const wchar_t*); FStringList split (const wchar_t[]);
FStringList split (const std::string&); FStringList split (const std::string&);
FStringList split (const char*); FStringList split (const char[]);
FStringList split (const wchar_t); FStringList split (const wchar_t);
FStringList split (const char); FStringList split (const char);
FString& setString (const wchar_t*); FString& setString (const wchar_t[]);
FString& setString (const char*); FString& setString (const char[]);
FString& setNumber (sInt16); FString& setNumber (sInt16);
FString& setNumber (uInt16); FString& setNumber (uInt16);
@ -291,58 +291,58 @@ class FString
FString& setFormatedNumber (uLong, char = nl_langinfo(THOUSEP)[0]); FString& setFormatedNumber (uLong, char = nl_langinfo(THOUSEP)[0]);
const FString& insert (const FString&, uInt); const FString& insert (const FString&, uInt);
const FString& insert (const wchar_t*, uInt); const FString& insert (const wchar_t[], uInt);
const FString& insert (const char*, uInt); const FString& insert (const char[], uInt);
const FString& insert (const wchar_t, uInt); const FString& insert (const wchar_t, uInt);
const FString& insert (const char, uInt); const FString& insert (const char, uInt);
FString replace (const FString&, const FString&); FString replace (const FString&, const FString&);
FString replace (const FString&, const std::wstring&); FString replace (const FString&, const std::wstring&);
FString replace (const FString&, const wchar_t*); FString replace (const FString&, const wchar_t[]);
FString replace (const FString&, const std::string&); FString replace (const FString&, const std::string&);
FString replace (const FString&, const char*); FString replace (const FString&, const char[]);
FString replace (const FString&, const wchar_t); FString replace (const FString&, const wchar_t);
FString replace (const FString&, const char); FString replace (const FString&, const char);
FString replace (const std::wstring&, const FString&); FString replace (const std::wstring&, const FString&);
FString replace (const std::wstring&, const std::wstring&); FString replace (const std::wstring&, const std::wstring&);
FString replace (const std::wstring&, const wchar_t*); FString replace (const std::wstring&, const wchar_t[]);
FString replace (const std::wstring&, const std::string&); FString replace (const std::wstring&, const std::string&);
FString replace (const std::wstring&, const char*); FString replace (const std::wstring&, const char[]);
FString replace (const std::wstring&, const wchar_t); FString replace (const std::wstring&, const wchar_t);
FString replace (const std::wstring&, const char); FString replace (const std::wstring&, const char);
FString replace (const std::string&, const FString&); FString replace (const std::string&, const FString&);
FString replace (const std::string&, const std::wstring&); FString replace (const std::string&, const std::wstring&);
FString replace (const std::string&, const wchar_t*); FString replace (const std::string&, const wchar_t[]);
FString replace (const std::string&, const std::string&); FString replace (const std::string&, const std::string&);
FString replace (const std::string&, const char*); FString replace (const std::string&, const char[]);
FString replace (const std::string&, const wchar_t); FString replace (const std::string&, const wchar_t);
FString replace (const std::string&, const char); FString replace (const std::string&, const char);
FString replace (const wchar_t*, const FString&); FString replace (const wchar_t[], const FString&);
FString replace (const wchar_t*, const std::wstring&); FString replace (const wchar_t[], const std::wstring&);
FString replace (const wchar_t*, const wchar_t*); FString replace (const wchar_t[], const wchar_t[]);
FString replace (const wchar_t*, const std::string&); FString replace (const wchar_t[], const std::string&);
FString replace (const wchar_t*, const char*); FString replace (const wchar_t[], const char[]);
FString replace (const wchar_t*, const wchar_t); FString replace (const wchar_t[], const wchar_t);
FString replace (const wchar_t*, const char); FString replace (const wchar_t[], const char);
FString replace (const char*, const FString&); FString replace (const char[], const FString&);
FString replace (const char*, const std::wstring&); FString replace (const char[], const std::wstring&);
FString replace (const char*, const wchar_t*); FString replace (const char[], const wchar_t[]);
FString replace (const char*, const std::string&); FString replace (const char[], const std::string&);
FString replace (const char*, const char*); FString replace (const char[], const char[]);
FString replace (const char*, const wchar_t); FString replace (const char[], const wchar_t);
FString replace (const char*, const char); FString replace (const char[], const char);
FString replace (const wchar_t, const FString&); FString replace (const wchar_t, const FString&);
FString replace (const wchar_t, const std::wstring&); FString replace (const wchar_t, const std::wstring&);
FString replace (const wchar_t, const wchar_t*); FString replace (const wchar_t, const wchar_t[]);
FString replace (const wchar_t, const std::string&); FString replace (const wchar_t, const std::string&);
FString replace (const wchar_t, const char*); FString replace (const wchar_t, const char[]);
FString replace (const wchar_t, const wchar_t); FString replace (const wchar_t, const wchar_t);
FString replace (const wchar_t, const char); FString replace (const wchar_t, const char);
FString replace (const char, const FString&); FString replace (const char, const FString&);
FString replace (const char, const std::wstring&); FString replace (const char, const std::wstring&);
FString replace (const char, const wchar_t*); FString replace (const char, const wchar_t[]);
FString replace (const char, const std::string&); FString replace (const char, const std::string&);
FString replace (const char, const char*); FString replace (const char, const char[]);
FString replace (const char, const wchar_t); FString replace (const char, const wchar_t);
FString replace (const char, const char); FString replace (const char, const char);
@ -352,13 +352,13 @@ class FString
FString removeBackspaces() const; FString removeBackspaces() const;
const FString& overwrite (const FString&, uInt); const FString& overwrite (const FString&, uInt);
const FString& overwrite (const wchar_t*, uInt); const FString& overwrite (const wchar_t[], uInt);
const FString& overwrite (const wchar_t, uInt); const FString& overwrite (const wchar_t, uInt);
const FString& remove (uInt, uInt); const FString& remove (uInt, uInt);
bool includes (const FString&); bool includes (const FString&);
bool includes (const wchar_t*); bool includes (const wchar_t[]);
bool includes (const char*); bool includes (const char[]);
bool includes (const wchar_t); bool includes (const wchar_t);
bool includes (const char); bool includes (const char);
@ -371,12 +371,12 @@ class FString
// Methods // Methods
void initLength (uInt); void initLength (uInt);
void _assign (const wchar_t*); void _assign (const wchar_t[]);
void _insert (uInt, uInt, const wchar_t*); void _insert (uInt, uInt, const wchar_t[]);
void _remove (uInt, uInt); void _remove (uInt, uInt);
char* wc_to_c_str (const wchar_t*) const; char* wc_to_c_str (const wchar_t[]) const;
wchar_t* c_to_wc_str (const char*) const; wchar_t* c_to_wc_str (const char[]) const;
wchar_t* extractToken (wchar_t**, const wchar_t*, const wchar_t*); wchar_t* extractToken (wchar_t*[], const wchar_t[], const wchar_t[]);
// Data Members // Data Members
wchar_t* string; wchar_t* string;
@ -426,7 +426,7 @@ inline FStringList FString::split (const std::wstring& s)
{ return split(FString(s)); } { return split(FString(s)); }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
inline FStringList FString::split (const wchar_t* s) inline FStringList FString::split (const wchar_t s[])
{ return split(FString(s)); } { return split(FString(s)); }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
@ -434,7 +434,7 @@ inline FStringList FString::split (const std::string& s)
{ return split(FString(s)); } { return split(FString(s)); }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
inline FStringList FString::split (const char* s) inline FStringList FString::split (const char s[])
{ return split(FString(s)); } { return split(FString(s)); }
//---------------------------------------------------------------------- //----------------------------------------------------------------------

6
include/final/fterm.h
View File

@ -303,14 +303,14 @@ class FTerm
// function pointer -> static function // function pointer -> static function
static int (*Fputchar)(int); static int (*Fputchar)(int);
static void putstringf (const char* const, ...) static void putstringf (const char[], ...)
#if defined(__clang__) #if defined(__clang__)
__attribute__((__format__ (__printf__, 1, 2))) __attribute__((__format__ (__printf__, 1, 2)))
#elif defined(__GNUC__) #elif defined(__GNUC__)
__attribute__ ((format (printf, 1, 2))) __attribute__ ((format (printf, 1, 2)))
#endif #endif
; ;
static void putstring (const char* const, int = 1); static void putstring (const char[], int = 1);
#if defined(__sun) && defined(__SVR4) #if defined(__sun) && defined(__SVR4)
static int putchar_ASCII (register char); static int putchar_ASCII (register char);
@ -456,7 +456,7 @@ class FTerm
#if defined(__linux__) #if defined(__linux__)
static int getScreenFont(); static int getScreenFont();
static int setScreenFont ( uChar*, uInt, uInt, uInt static int setScreenFont ( uChar[], uInt, uInt, uInt
, bool = false ); , bool = false );
static int setUnicodeMap (struct unimapdesc*); static int setUnicodeMap (struct unimapdesc*);
static int getUnicodeMap (); static int getUnicodeMap ();

8
include/final/ftermbuffer.h
View File

@ -77,8 +77,8 @@ class FTermBuffer
// Methods // Methods
void clear(); void clear();
int writef (const wchar_t*, ...); int writef (const wchar_t[], ...);
int writef (const char*, ...) int writef (const char[], ...)
#if defined(__clang__) #if defined(__clang__)
__attribute__((__format__ (__printf__, 2, 3))) __attribute__((__format__ (__printf__, 2, 3)))
#elif defined(__GNUC__) #elif defined(__GNUC__)
@ -86,8 +86,8 @@ class FTermBuffer
#endif #endif
; ;
int write (const std::wstring&); int write (const std::wstring&);
int write (const wchar_t*); int write (const wchar_t[]);
int write (const char*); int write (const char[]);
int write (const std::string&); int write (const std::string&);
int write (const FString&); int write (const FString&);
int write (int); int write (int);

12
include/final/fvterm.h
View File

@ -222,8 +222,8 @@ class FVTerm : public FTerm
, FPreprocessingHandler ); , FPreprocessingHandler );
virtual void delPreprocessingHandler (FVTerm*); virtual void delPreprocessingHandler (FVTerm*);
int printf (const wchar_t*, ...); int printf (const wchar_t[], ...);
int printf (const char*, ...) int printf (const char[], ...)
#if defined(__clang__) #if defined(__clang__)
__attribute__((__format__ (__printf__, 2, 3))) __attribute__((__format__ (__printf__, 2, 3)))
#elif defined(__GNUC__) #elif defined(__GNUC__)
@ -232,10 +232,10 @@ class FVTerm : public FTerm
; ;
int print (const std::wstring&); int print (const std::wstring&);
int print (term_area*, const std::wstring&); int print (term_area*, const std::wstring&);
int print (const wchar_t*); int print (const wchar_t[]);
int print (term_area*, const wchar_t*); int print (term_area*, const wchar_t[]);
int print (const char*); int print (const char[]);
int print (term_area*, const char*); int print (term_area*, const char[]);
int print (const std::string&); int print (const std::string&);
int print (term_area*, const std::string&); int print (term_area*, const std::string&);
int print (const FString&); int print (const FString&);

379
src/fbutton.cpp
View File

@ -37,6 +37,12 @@ FButton::FButton(FWidget* parent)
, button_down(false) , button_down(false)
, click_animation(true) , click_animation(true)
, click_time(150) , click_time(150)
, indent(0)
, space(int(' '))
, center_offset(0)
, vcenter_offset(0)
, txtlength(0)
, hotkeypos(-1)
, button_fg(wc.button_active_fg) , button_fg(wc.button_active_fg)
, button_bg(wc.button_active_bg) , button_bg(wc.button_active_bg)
, button_hotkey_fg(wc.button_hotkey_fg) , button_hotkey_fg(wc.button_hotkey_fg)
@ -44,6 +50,7 @@ FButton::FButton(FWidget* parent)
, button_focus_bg(wc.button_active_focus_bg) , button_focus_bg(wc.button_active_focus_bg)
, button_inactive_fg(wc.button_inactive_fg) , button_inactive_fg(wc.button_inactive_fg)
, button_inactive_bg(wc.button_inactive_bg) , button_inactive_bg(wc.button_inactive_bg)
, is()
{ {
init(); init();
} }
@ -55,6 +62,12 @@ FButton::FButton (const FString& txt, FWidget* parent)
, button_down(false) , button_down(false)
, click_animation(true) , click_animation(true)
, click_time(150) , click_time(150)
, indent(0)
, space(int(' '))
, center_offset(0)
, vcenter_offset(0)
, txtlength(0)
, hotkeypos(-1)
, button_fg(wc.button_active_fg) , button_fg(wc.button_active_fg)
, button_bg(wc.button_active_bg) , button_bg(wc.button_active_bg)
, button_hotkey_fg(wc.button_hotkey_fg) , button_hotkey_fg(wc.button_hotkey_fg)
@ -62,6 +75,7 @@ FButton::FButton (const FString& txt, FWidget* parent)
, button_focus_bg(wc.button_active_focus_bg) , button_focus_bg(wc.button_active_focus_bg)
, button_inactive_fg(wc.button_inactive_fg) , button_inactive_fg(wc.button_inactive_fg)
, button_inactive_bg(wc.button_inactive_bg) , button_inactive_bg(wc.button_inactive_bg)
, is()
{ {
init(); init();
detectHotkey(); detectHotkey();
@ -453,6 +467,18 @@ void FButton::init()
setShadow(); setShadow();
} }
//----------------------------------------------------------------------
void FButton::getButtonState()
{
int active_focus = fc::active + fc::focus;
is.active_focus = ((flags & active_focus) == active_focus);
is.active = ((flags & fc::active) != 0);
is.focus = ((flags & fc::focus) != 0);
is.flat = isFlat();
is.non_flat_shadow = ((flags & (fc::shadow + fc::flat)) == fc::shadow);
is.no_underline = ((flags & fc::no_underline) != 0);
}
//---------------------------------------------------------------------- //----------------------------------------------------------------------
uChar FButton::getHotkey() uChar FButton::getHotkey()
{ {
@ -511,69 +537,36 @@ inline void FButton::detectHotkey()
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
void FButton::draw() int FButton::getHotkeyPos (wchar_t src[], wchar_t dest[], uInt length)
{ {
int active_focus // find hotkey position in string
, d // + generate a new string without the '&'-sign
, i int pos = -1;
, j wchar_t* txt = src;
, x
, mono_offset
, mono_1st_char
, margin
, length
, hotkeypos
, hotkey_offset
, space;
bool is_ActiveFocus
, is_Active
, is_Focus
, is_Flat
, is_NonFlatShadow
, is_NoUnderline;
register wchar_t* src;
register wchar_t* dest;
wchar_t* ButtonText;
FString txt;
FWidget* parent_widget = getParentWidget();
length = int(text.getLength()); for (uInt i = 0; i < length; i++)
hotkeypos = -1;
hotkey_offset = 0;
space = int(' ');
try
{ {
if ( isMonochron() || getMaxColor() < 16 ) if ( i < length && txt[i] == L'&' && pos == -1 )
ButtonText = new wchar_t[length + 3]();
else
ButtonText = new wchar_t[length + 1]();
}
catch (const std::bad_alloc& ex)
{ {
std::cerr << "not enough memory to alloc " << ex.what() << std::endl; pos = int(i);
return; i++;
src++;
} }
txt = FString(text); *dest++ = *src++;
src = const_cast<wchar_t*>(txt.wc_str()); }
dest = const_cast<wchar_t*>(ButtonText);
active_focus = fc::active + fc::focus; return pos;
is_ActiveFocus = ((flags & active_focus) == active_focus); }
is_Active = ((flags & fc::active) != 0);
is_Focus = ((flags & fc::focus) != 0);
is_Flat = isFlat();
is_NonFlatShadow = ((flags & (fc::shadow + fc::flat)) == fc::shadow);
is_NoUnderline = ((flags & fc::no_underline) != 0);
if ( isMonochron() ) //----------------------------------------------------------------------
setReverse(true); inline int FButton::clickAnimationIndent (FWidget* parent_widget)
if ( button_down && click_animation )
{ {
if ( ! button_down || ! click_animation )
return 0;
// noshadow + indent one character to the right // noshadow + indent one character to the right
if ( is_Flat ) if ( is.flat )
clearFlatBorder(); clearFlatBorder();
else else
clearShadow(); clearShadow();
@ -588,72 +581,18 @@ void FButton::draw()
print (' '); // clear one left █ print (' '); // clear one left █
} }
d = 1; return 1;
}
else
d = 0;
if ( ! is_Active && isMonochron() )
space = fc::MediumShade; // ▒
if ( isMonochron() && is_ActiveFocus )
{
txt = "<" + txt + ">";
length = int(txt.getLength());
src = const_cast<wchar_t*>(txt.wc_str());
mono_1st_char = 1;
mono_offset = 2;
}
else
{
mono_1st_char = 0;
mono_offset = 0;
} }
// find hotkey position in string //----------------------------------------------------------------------
// + generate a new string without the '&'-sign inline void FButton::clearRightMargin (FWidget* parent_widget)
for (i = 0; i < length; i++)
{ {
if ( i < length && txt[uInt(i)] == '&' && hotkeypos == -1 ) if ( button_down
{ || isNewFont()
hotkeypos = i; || ( ! is.flat && hasShadow() && ! isMonochron()) )
i++; return;
src++;
}
*dest++ = *src++; // Restore the right background after button down
}
if ( hotkeypos != -1 )
hotkey_offset = 1;
if ( length - hotkey_offset + mono_offset - hotkey_offset <= getWidth() )
margin = 1;
else
margin = 0;
if ( isMonochron() && (is_Active || is_Focus) )
setReverse(false);
if ( margin == 1 )
{
setColor (getForegroundColor(), button_bg);
for (int y = 0; y < getHeight(); y++)
{
setPrintPos (1 + d, 1 + y);
print (space); // full block █
}
}
if ( is_Flat && ! button_down )
drawFlatBorder();
if ( ! button_down
&& ! isNewFont()
&& (is_Flat || ! hasShadow() || isMonochron()) )
{
// clear the right █ from button down
if ( parent_widget ) if ( parent_widget )
setColor ( parent_widget->getForegroundColor() setColor ( parent_widget->getForegroundColor()
, parent_widget->getBackgroundColor() ); , parent_widget->getBackgroundColor() );
@ -661,113 +600,220 @@ void FButton::draw()
for (int y = 1; y <= getHeight(); y++) for (int y = 1; y <= getHeight(); y++)
{ {
if ( isMonochron() ) if ( isMonochron() )
setReverse(true); setReverse(true); // Light background
setPrintPos (1 + getWidth(), y); setPrintPos (1 + getWidth(), y);
print (' '); // clear right print (' '); // clear right
if ( isMonochron() ) if ( is.active && isMonochron() )
setReverse(false); setReverse(false); // Dark background
} }
} }
if ( hotkeypos != -1 ) //----------------------------------------------------------------------
length--; inline void FButton::drawMarginLeft()
{
// Print left margin
i = getWidth() - length - 1; setColor (getForegroundColor(), button_bg);
i = int(i / 2);
if ( getHeight() >= 2 ) for (int y = 0; y < getHeight(); y++)
j = int((getHeight() - 1) / 2); {
setPrintPos (1 + indent, 1 + y);
if ( isMonochron() && is.active_focus && y == vcenter_offset )
print (fc::BlackRightPointingPointer); // ►
else else
j = 0; print (space); // full block █
}
}
setPrintPos (1 + margin + d, 1 + j); //----------------------------------------------------------------------
inline void FButton::drawMarginRight()
{
// Print right margin
for (int y = 0; y < getHeight(); y++)
{
setPrintPos (getWidth() + indent, 1 + y);
if ( isMonochron() && is.active_focus && y == vcenter_offset )
print (fc::BlackLeftPointingPointer); // ◄
else
print (space); // full block █
}
}
//----------------------------------------------------------------------
inline void FButton::drawTopBottomBackground()
{
// Print top and bottom button background
if ( getHeight() < 2 )
return;
for (int y = 0; y < vcenter_offset; y++)
{
setPrintPos (2 + indent, 1 + y);
for (int x = 1; x < getWidth() - 1; x++)
print (space); // █
}
for (int y = vcenter_offset + 1; y < getHeight(); y++)
{
setPrintPos (2 + indent, 1 + y);
for (int x = 1; x < getWidth() - 1; x++)
print (space); // █
}
}
//----------------------------------------------------------------------
inline void FButton::drawButtonTextLine (wchar_t button_text[])
{
int pos;
center_offset = int((getWidth() - txtlength - 1) / 2);
setPrintPos (2 + indent, 1 + vcenter_offset);
setColor (button_fg, button_bg); setColor (button_fg, button_bg);
for (x = 0; x < i; x++) // Print button text line --------
for (pos = 0; pos < center_offset; pos++)
print (space); // █ print (space); // █
if ( hotkeypos == -1 ) if ( hotkeypos == -1 )
setCursorPos (1 + margin + i + mono_1st_char, 1 + j ); // first character setCursorPos ( 2 + center_offset
, 1 + vcenter_offset ); // first character
else else
setCursorPos (1 + margin + i + hotkeypos, 1 + j ); // hotkey setCursorPos ( 2 + center_offset + hotkeypos
, 1 + vcenter_offset ); // hotkey
if ( is_ActiveFocus && (isMonochron() || getMaxColor() < 16) ) if ( ! is.active && isMonochron() )
setReverse(true); // Light background
if ( is.active_focus && (isMonochron() || getMaxColor() < 16) )
setBold(); setBold();
for (int z = 0; x < i + length && z < getWidth(); z++, x++) for ( int z = 0
; pos < center_offset + txtlength && z < getWidth() - 2
; z++, pos++)
{ {
if ( (z == hotkeypos) && is_Active ) if ( (z == hotkeypos) && is.active )
{ {
setColor (button_hotkey_fg, button_bg); setColor (button_hotkey_fg, button_bg);
if ( ! is_ActiveFocus && getMaxColor() < 16 ) if ( ! is.active_focus && getMaxColor() < 16 )
setBold(); setBold();
if ( ! is_NoUnderline ) if ( ! is.no_underline )
setUnderline(); setUnderline();
print ( ButtonText[z] ); print (button_text[z]);
if ( ! is_ActiveFocus && getMaxColor() < 16 ) if ( ! is.active_focus && getMaxColor() < 16 )
unsetBold(); unsetBold();
if ( ! is_NoUnderline ) if ( ! is.no_underline )
unsetUnderline(); unsetUnderline();
setColor (button_fg, button_bg); setColor (button_fg, button_bg);
} }
else else
{ {
print ( ButtonText[z] ); print (button_text[z]);
} }
} }
if ( is_ActiveFocus && (isMonochron() || getMaxColor() < 16) ) if ( txtlength > getWidth() - 2 )
{
// Print ellipsis
setPrintPos (getWidth() + indent - 2, 1);
print (L"..");
}
if ( is.active_focus && (isMonochron() || getMaxColor() < 16) )
unsetBold(); unsetBold();
for (x = i + length; x < getWidth() - 1; x++) for (pos = center_offset + txtlength; pos < getWidth() - 2; pos++)
print (space); // █ print (space); // █
}
//----------------------------------------------------------------------
void FButton::draw()
{
wchar_t* button_text;
FWidget* parent_widget = getParentWidget();
txtlength = int(text.getLength());
space = int(' ');
getButtonState();
try
{
button_text = new wchar_t[txtlength + 1]();
}
catch (const std::bad_alloc& ex)
{
std::cerr << "not enough memory to alloc " << ex.what() << std::endl;
return;
}
if ( isMonochron() )
setReverse(true); // Light background
// Click animation preprocessing
indent = clickAnimationIndent (parent_widget);
// Clear right margin after animation
clearRightMargin (parent_widget);
if ( ! is.active && isMonochron() )
space = fc::MediumShade; // ▒ simulates greyed out at Monochron
if ( isMonochron() && (is.active || is.focus) )
setReverse(false); // Dark background
if ( is.flat && ! button_down )
drawFlatBorder();
hotkeypos = getHotkeyPos(text.wc_str(), button_text, uInt(txtlength));
if ( hotkeypos != -1 )
txtlength--;
if ( getHeight() >= 2 ) if ( getHeight() >= 2 )
{ vcenter_offset = int((getHeight() - 1) / 2);
for (i = 0; i < j; i++) else
{ vcenter_offset = 0;
setPrintPos (2 + d, 1 + i);
for (int z = 1; z < getWidth(); z++) // Print left margin
print (space); // █ drawMarginLeft();
}
for (i = j + 1; i < getHeight(); i++)
{
setPrintPos (2 + d, 1 + i);
for (int z = 1; z < getWidth(); z++) // Print button text line
print (space); // █ drawButtonTextLine(button_text);
}
}
if ( isMonochron() ) // Print right margin
setReverse(true); drawMarginRight();
if ( is_NonFlatShadow && ! button_down ) // Print top and bottom button background
{ drawTopBottomBackground();
if ( parent_widget )
setColor ( parent_widget->getForegroundColor()
, parent_widget->getBackgroundColor() );
print(' '); // restore background after button down // Draw button shadow
if ( is.non_flat_shadow && ! button_down )
drawShadow(); drawShadow();
}
if ( isMonochron() ) if ( isMonochron() )
setReverse(false); setReverse(false); // Dark background
delete[] ButtonText; delete[] button_text;
updateStatusBar();
}
if ( is_Focus && getStatusBar() ) //----------------------------------------------------------------------
void FButton::updateStatusBar()
{ {
if ( ! is.focus || ! getStatusBar() )
return;
const FString& msg = getStatusbarMessage(); const FString& msg = getStatusbarMessage();
const FString& curMsg = getStatusBar()->getMessage(); const FString& curMsg = getStatusBar()->getMessage();
@ -777,7 +823,6 @@ void FButton::draw()
getStatusBar()->drawMessage(); getStatusBar()->drawMessage();
} }
} }
}
//---------------------------------------------------------------------- //----------------------------------------------------------------------
void FButton::updateButtonColor() void FButton::updateButtonColor()

6
src/fbuttongroup.cpp
View File

@ -559,6 +559,9 @@ void FButtonGroup::drawLabel()
else else
FWidget::setPrintPos (0, 1); FWidget::setPrintPos (0, 1);
if ( isMonochron() )
setReverse(true);
if ( isEnabled() ) if ( isEnabled() )
setColor(wc.label_emphasis_fg, wc.label_bg); setColor(wc.label_emphasis_fg, wc.label_bg);
else else
@ -584,6 +587,9 @@ void FButtonGroup::drawLabel()
print ( LabelText[z] ); print ( LabelText[z] );
} }
if ( isMonochron() )
setReverse(true);
setViewportPrint(); setViewportPrint();
delete[] LabelText; delete[] LabelText;
} }

20
src/flabel.cpp
View File

@ -561,7 +561,7 @@ void FLabel::printLine ( wchar_t line[]
//---------------------------------------------------------------------- //----------------------------------------------------------------------
void FLabel::draw() void FLabel::draw()
{ {
wchar_t* LabelText; wchar_t* label_text;
uInt length; uInt length;
int hotkeypos, align_offset; int hotkeypos, align_offset;
@ -592,7 +592,7 @@ void FLabel::draw()
try try
{ {
LabelText = new wchar_t[length + 1](); label_text = new wchar_t[length + 1]();
} }
catch (const std::bad_alloc& ex) catch (const std::bad_alloc& ex)
{ {
@ -601,7 +601,7 @@ void FLabel::draw()
} }
wchar_t* src = const_cast<wchar_t*>(multiline_text[y].wc_str()); wchar_t* src = const_cast<wchar_t*>(multiline_text[y].wc_str());
wchar_t* dest = const_cast<wchar_t*>(LabelText); wchar_t* dest = const_cast<wchar_t*>(label_text);
if ( ! hotkey_printed ) if ( ! hotkey_printed )
hotkeypos = getHotkeyPos(src, dest, length); hotkeypos = getHotkeyPos(src, dest, length);
@ -613,18 +613,18 @@ void FLabel::draw()
if ( hotkeypos != -1 ) if ( hotkeypos != -1 )
{ {
align_offset = getAlignOffset (int(length - 1)); align_offset = getAlignOffset (int(length - 1));
printLine (LabelText, length - 1, hotkeypos, align_offset); printLine (label_text, length - 1, hotkeypos, align_offset);
hotkey_printed = true; hotkey_printed = true;
hotkeypos = -1; hotkeypos = -1;
} }
else else
{ {
align_offset = getAlignOffset (int(length)); align_offset = getAlignOffset (int(length));
printLine (LabelText, length, -1, align_offset); printLine (label_text, length, -1, align_offset);
} }
y++; y++;
delete[] LabelText; delete[] label_text;
} }
} }
else else
@ -633,7 +633,7 @@ void FLabel::draw()
try try
{ {
LabelText = new wchar_t[length + 1](); label_text = new wchar_t[length + 1]();
} }
catch (const std::bad_alloc& ex) catch (const std::bad_alloc& ex)
{ {
@ -641,15 +641,15 @@ void FLabel::draw()
return; return;
} }
hotkeypos = getHotkeyPos (text.wc_str(), LabelText, length); hotkeypos = getHotkeyPos (text.wc_str(), label_text, length);
if ( hotkeypos != -1 ) if ( hotkeypos != -1 )
length--; length--;
setPrintPos (1,1); setPrintPos (1,1);
align_offset = getAlignOffset (int(length)); align_offset = getAlignOffset (int(length));
printLine (LabelText, length, hotkeypos, align_offset); printLine (label_text, length, hotkeypos, align_offset);
delete[] LabelText; delete[] label_text;
} }
if ( isMonochron() ) if ( isMonochron() )

112
src/flistbox.cpp
View File

@ -1259,14 +1259,15 @@ inline void FListBox::drawListLine ( int y
uInt i, len; uInt i, len;
uInt inc_len = inc_search.getLength(); uInt inc_len = inc_search.getLength();
bool isCurrentLine = bool(y + yoffset + 1 == current); bool isCurrentLine = bool(y + yoffset + 1 == current);
bool isFocus = ((flags & fc::focus) != 0);
FString element; FString element;
element = getString(iter).mid ( uInt(1 + xoffset) element = getString(iter).mid ( uInt(1 + xoffset)
, uInt(getWidth() - nf_offset - 4) ); , uInt(getWidth() - nf_offset - 4) );
const wchar_t* const& element_str = element.wc_str(); const wchar_t* const& element_str = element.wc_str();
len = element.getLength(); len = element.getLength();
if ( isMonochron() && isCurrentLine ) if ( isMonochron() && isCurrentLine && isFocus )
print ('>'); print (fc::BlackRightPointingPointer); // ►
else else
print (' '); print (' ');
@ -1276,16 +1277,16 @@ inline void FListBox::drawListLine ( int y
for (i = 0; i < len; i++) for (i = 0; i < len; i++)
{ {
if ( serach_mark && i == inc_len ) if ( serach_mark && i == inc_len && isFocus )
setColor ( wc.current_element_focus_fg setColor ( wc.current_element_focus_fg
, wc.current_element_focus_bg ); , wc.current_element_focus_bg );
print (element_str[i]); print (element_str[i]);
} }
if ( isMonochron() && isCurrentLine ) if ( isMonochron() && isCurrentLine && isFocus )
{ {
print ('<'); print (fc::BlackLeftPointingPointer); // ◄
i++; i++;
} }
@ -1294,28 +1295,9 @@ inline void FListBox::drawListLine ( int y
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
inline void FListBox::drawListBracketsLine ( int y inline void FListBox::printLeftBracket (fc::brackets_type bracket_type)
, listBoxItems::iterator iter
, bool serach_mark )
{ {
int full_length; switch ( bracket_type )
FString element;
uInt len
, inc_len = inc_search.getLength()
, i = 0
, b = 0;
bool isCurrentLine = bool(y + yoffset + 1 == current);
if ( isMonochron() && isCurrentLine )
print ('>');
else
print (' ');
if ( xoffset == 0 )
{
b = 1;
switch ( iter->brackets )
{ {
case fc::NoBrackets: case fc::NoBrackets:
break; break;
@ -1336,6 +1318,57 @@ inline void FListBox::drawListBracketsLine ( int y
print ('<'); print ('<');
break; break;
} }
}
//----------------------------------------------------------------------
inline void FListBox::printRightBracket (fc::brackets_type bracket_type)
{
switch ( bracket_type )
{
case fc::NoBrackets:
break;
case fc::SquareBrackets:
print (']');
break;
case fc::Parenthesis:
print (')');
break;
case fc::CurlyBrackets:
print ('}');
break;
case fc::AngleBrackets:
print ('>');
break;
}
}
//----------------------------------------------------------------------
inline void FListBox::drawListBracketsLine ( int y
, listBoxItems::iterator iter
, bool serach_mark )
{
int full_length;
FString element;
uInt len
, inc_len = inc_search.getLength()
, i = 0
, b = 0;
bool isCurrentLine = bool(y + yoffset + 1 == current);
bool isFocus = ((flags & fc::focus) != 0);
if ( isMonochron() && isCurrentLine && isFocus )
print (fc::BlackRightPointingPointer); // ►
else
print (' ');
if ( xoffset == 0 )
{
b = 1;
printLeftBracket (iter->brackets);
element = getString(iter).mid ( uInt(1 + xoffset) element = getString(iter).mid ( uInt(1 + xoffset)
, uInt(getWidth() - nf_offset - 5) ); , uInt(getWidth() - nf_offset - 5) );
@ -1369,34 +1402,13 @@ inline void FListBox::drawListBracketsLine ( int y
setColor ( wc.current_element_focus_fg setColor ( wc.current_element_focus_fg
, wc.current_element_focus_bg ); , wc.current_element_focus_bg );
switch ( iter->brackets ) printRightBracket (iter->brackets);
{
case fc::NoBrackets:
break;
case fc::SquareBrackets:
print (']');
break;
case fc::Parenthesis:
print (')');
break;
case fc::CurlyBrackets:
print ('}');
break;
case fc::AngleBrackets:
print ('>');
break;
}
i++; i++;
} }
if ( isMonochron() && isCurrentLine ) if ( isMonochron() && isCurrentLine && isFocus )
{ {
print ('<'); print (fc::BlackLeftPointingPointer); // ◄
i++; i++;
} }

28
src/flistview.cpp
View File

@ -28,8 +28,8 @@
#include "final/fstatusbar.h" #include "final/fstatusbar.h"
#include "final/ftermbuffer.h" #include "final/ftermbuffer.h"
// Global null FObject iterator // Static class attribute
static FObject::FObjectIterator null_iter; FObject::FObjectIterator FListView::null_iter;
//---------------------------------------------------------------------- //----------------------------------------------------------------------
// class FListViewItem // class FListViewItem
@ -154,7 +154,7 @@ FObject::FObjectIterator FListViewItem::insert (FListViewItem* child)
{ {
// Add a FListViewItem as child element // Add a FListViewItem as child element
if ( ! child ) if ( ! child )
return null_iter; return FListView::null_iter;
return appendItem(child); return appendItem(child);
} }
@ -163,8 +163,8 @@ FObject::FObjectIterator FListViewItem::insert (FListViewItem* child)
FObject::FObjectIterator FListViewItem::insert ( FListViewItem* child FObject::FObjectIterator FListViewItem::insert ( FListViewItem* child
, FObjectIterator parent_iter ) , FObjectIterator parent_iter )
{ {
if ( parent_iter == null_iter ) if ( parent_iter == FListView::null_iter )
return null_iter; return FListView::null_iter;
if ( *parent_iter ) if ( *parent_iter )
{ {
@ -182,7 +182,7 @@ FObject::FObjectIterator FListViewItem::insert ( FListViewItem* child
} }
} }
return null_iter; return FListView::null_iter;
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
@ -586,8 +586,8 @@ FObject::FObjectIterator FListView::insert ( FListViewItem* item
FObjectIterator item_iter; FObjectIterator item_iter;
headerItems::iterator header_iter; headerItems::iterator header_iter;
if ( parent_iter == null_iter ) if ( parent_iter == FListView::null_iter )
return null_iter; return FListView::null_iter;
// Determine the line width // Determine the line width
header_iter = header.begin(); header_iter = header.begin();
@ -636,10 +636,10 @@ FObject::FObjectIterator FListView::insert ( FListViewItem* item
item_iter = parent->appendItem (item); item_iter = parent->appendItem (item);
} }
else else
item_iter = null_iter; item_iter = FListView::null_iter;
} }
else else
item_iter = null_iter; item_iter = FListView::null_iter;
if ( itemlist.size() == 1 ) if ( itemlist.size() == 1 )
{ {
@ -661,20 +661,20 @@ FObject::FObjectIterator FListView::insert ( const FStringList& cols
{ {
FListViewItem* item; FListViewItem* item;
if ( cols.empty() || parent_iter == null_iter ) if ( cols.empty() || parent_iter == FListView::null_iter )
return null_iter; return FListView::null_iter;
if ( ! *parent_iter ) if ( ! *parent_iter )
parent_iter = root; parent_iter = root;
try try
{ {
item = new FListViewItem (cols, d, null_iter); item = new FListViewItem (cols, d, FListView::null_iter);
} }
catch (const std::bad_alloc& ex) catch (const std::bad_alloc& ex)
{ {
std::cerr << "not enough memory to alloc " << ex.what() << std::endl; std::cerr << "not enough memory to alloc " << ex.what() << std::endl;
return null_iter; return FListView::null_iter;
} }
item->replaceControlCodes(); item->replaceControlCodes();

29
src/fmenu.cpp
View File

@ -40,6 +40,7 @@ FMenu::FMenu(FWidget* parent)
, opened_sub_menu(0) , opened_sub_menu(0)
, shown_sub_menu(0) , shown_sub_menu(0)
, max_item_width(0) , max_item_width(0)
, hotkeypos(-1)
, mouse_down(false) , mouse_down(false)
, has_checkable_items(false) , has_checkable_items(false)
{ {
@ -54,6 +55,7 @@ FMenu::FMenu (const FString& txt, FWidget* parent)
, opened_sub_menu(0) , opened_sub_menu(0)
, shown_sub_menu(0) , shown_sub_menu(0)
, max_item_width(0) , max_item_width(0)
, hotkeypos(-1)
, mouse_down(false) , mouse_down(false)
, has_checkable_items(false) , has_checkable_items(false)
{ {
@ -1298,14 +1300,14 @@ int FMenu::getHotkeyPos (wchar_t src[], wchar_t dest[], uInt length)
{ {
// Find hotkey position in string // Find hotkey position in string
// + generate a new string without the '&'-sign // + generate a new string without the '&'-sign
int hotkeypos = -1; int pos = -1;
wchar_t* txt = src; wchar_t* txt = src;
for (uInt i = 0; i < length; i++) for (uInt i = 0; i < length; i++)
{ {
if ( i < length && txt[i] == L'&' && hotkeypos == -1 ) if ( i < length && txt[i] == L'&' && pos == -1 )
{ {
hotkeypos = int(i); pos = int(i);
i++; i++;
src++; src++;
} }
@ -1313,7 +1315,7 @@ int FMenu::getHotkeyPos (wchar_t src[], wchar_t dest[], uInt length)
*dest++ = *src++; *dest++ = *src++;
} }
return hotkeypos; return pos;
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
@ -1383,12 +1385,11 @@ inline void FMenu::drawSeparator (int y)
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
void FMenu::drawMenuLine (FMenuItem* menuitem, int y) inline void FMenu::drawMenuLine (FMenuItem* menuitem, int y)
{ {
FString txt = menuitem->getText(); FString txt = menuitem->getText();
menuText txtdata; menuText txtdata;
uInt txt_length = uInt(txt.getLength()); uInt txt_length = uInt(txt.getLength());
int hotkeypos;
int to_char = int(txt_length); int to_char = int(txt_length);
int accel_key = menuitem->accel_key; int accel_key = menuitem->accel_key;
bool is_enabled = menuitem->isEnabled(); bool is_enabled = menuitem->isEnabled();
@ -1420,7 +1421,7 @@ void FMenu::drawMenuLine (FMenuItem* menuitem, int y)
txtdata.length = to_char; txtdata.length = to_char;
txtdata.no_underline = ((menuitem->getFlags() & fc::no_underline) != 0); txtdata.no_underline = ((menuitem->getFlags() & fc::no_underline) != 0);
setCursorToHotkeyPosition (menuitem, hotkeypos); setCursorToHotkeyPosition (menuitem);
if ( ! is_enabled || is_selected ) if ( ! is_enabled || is_selected )
txtdata.hotkeypos = -1; txtdata.hotkeypos = -1;
@ -1445,7 +1446,7 @@ void FMenu::drawMenuLine (FMenuItem* menuitem, int y)
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
void FMenu::drawCheckMarkPrefix (FMenuItem* menuitem) inline void FMenu::drawCheckMarkPrefix (FMenuItem* menuitem)
{ {
bool is_checked = menuitem->isChecked(); bool is_checked = menuitem->isChecked();
bool is_checkable = menuitem->checkable; bool is_checkable = menuitem->checkable;
@ -1490,7 +1491,7 @@ void FMenu::drawCheckMarkPrefix (FMenuItem* menuitem)
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
void FMenu::drawMenuText (menuText& data) inline void FMenu::drawMenuText (menuText& data)
{ {
// Print menu text // Print menu text
@ -1527,7 +1528,7 @@ void FMenu::drawMenuText (menuText& data)
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
void FMenu::drawSubMenuIndicator (int& startpos) inline void FMenu::drawSubMenuIndicator (int& startpos)
{ {
int c = ( has_checkable_items ) ? 1 : 0; int c = ( has_checkable_items ) ? 1 : 0;
int len = int(max_item_width) - (startpos + c + 3); int len = int(max_item_width) - (startpos + c + 3);
@ -1543,7 +1544,7 @@ void FMenu::drawSubMenuIndicator (int& startpos)
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
void FMenu::drawAcceleratorKey (int& startpos, int accel_key) inline void FMenu::drawAcceleratorKey (int& startpos, int accel_key)
{ {
FString accel_name (getKeyName(accel_key)); FString accel_name (getKeyName(accel_key));
int c = ( has_checkable_items ) ? 1 : 0; int c = ( has_checkable_items ) ? 1 : 0;
@ -1560,7 +1561,7 @@ void FMenu::drawAcceleratorKey (int& startpos, int accel_key)
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
void FMenu::drawTrailingSpaces (int startpos) inline void FMenu::drawTrailingSpaces (int startpos)
{ {
int c = ( has_checkable_items ) ? 1 : 0; int c = ( has_checkable_items ) ? 1 : 0;
// Print trailing blank space // Print trailing blank space
@ -1569,7 +1570,7 @@ void FMenu::drawTrailingSpaces (int startpos)
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
void FMenu::setLineAttributes (FMenuItem* menuitem, int y) inline void FMenu::setLineAttributes (FMenuItem* menuitem, int y)
{ {
bool is_enabled = menuitem->isEnabled(); bool is_enabled = menuitem->isEnabled();
bool is_selected = menuitem->isSelected(); bool is_selected = menuitem->isSelected();
@ -1607,7 +1608,7 @@ void FMenu::setLineAttributes (FMenuItem* menuitem, int y)
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
void FMenu::setCursorToHotkeyPosition (FMenuItem* menuitem, int hotkeypos) inline void FMenu::setCursorToHotkeyPosition (FMenuItem* menuitem)
{ {
bool is_checkable = menuitem->checkable; bool is_checkable = menuitem->checkable;
bool is_selected = menuitem->isSelected(); bool is_selected = menuitem->isSelected();

6
src/fmenubar.cpp
View File

@ -805,7 +805,7 @@ void FMenuBar::drawItems()
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
void FMenuBar::drawItem (FMenuItem* menuitem, int& x) inline void FMenuBar::drawItem (FMenuItem* menuitem, int& x)
{ {
FString txt = menuitem->getText(); FString txt = menuitem->getText();
menuText txtdata; menuText txtdata;
@ -866,7 +866,7 @@ void FMenuBar::drawItem (FMenuItem* menuitem, int& x)
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
void FMenuBar::setLineAttributes (FMenuItem* menuitem) inline void FMenuBar::setLineAttributes (FMenuItem* menuitem)
{ {
bool is_enabled = menuitem->isEnabled(); bool is_enabled = menuitem->isEnabled();
bool is_selected = menuitem->isSelected(); bool is_selected = menuitem->isSelected();
@ -897,7 +897,7 @@ void FMenuBar::setLineAttributes (FMenuItem* menuitem)
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
void FMenuBar::drawMenuText (menuText& data) inline void FMenuBar::drawMenuText (menuText& data)
{ {
// Print menu text // Print menu text

136
src/fstring.cpp
View File

@ -155,7 +155,7 @@ FString::FString (const std::wstring& s)
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
FString::FString (const wchar_t* s) FString::FString (const wchar_t s[])
: string(0) : string(0)
, length(0) , length(0)
, bufsize(0) , bufsize(0)
@ -186,7 +186,7 @@ FString::FString (const std::string& s)
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
FString::FString (const char* s) FString::FString (const char s[])
: string(0) : string(0)
, length(0) , length(0)
, bufsize(0) , bufsize(0)
@ -272,7 +272,7 @@ FString& FString::operator = (const std::wstring& s)
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
const FString& FString::operator = (const wchar_t* s) const FString& FString::operator = (const wchar_t s[])
{ {
if ( s ) if ( s )
_assign (s); _assign (s);
@ -299,7 +299,7 @@ FString& FString::operator = (const std::string& s)
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
const FString& FString::operator = (const char* s) const FString& FString::operator = (const char s[])
{ {
const wchar_t* wc_string = c_to_wc_str(s); const wchar_t* wc_string = c_to_wc_str(s);
@ -349,7 +349,7 @@ const FString& FString::operator += (const std::wstring& s)
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
const FString& FString::operator += (const wchar_t* s) const FString& FString::operator += (const wchar_t s[])
{ {
_insert (length, uInt(std::wcslen(s)), s); _insert (length, uInt(std::wcslen(s)), s);
return *this; return *this;
@ -370,7 +370,7 @@ const FString& FString::operator += (const std::string& s)
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
const FString& FString::operator += (const char* s) const FString& FString::operator += (const char s[])
{ {
const wchar_t* wc_string = c_to_wc_str(s); const wchar_t* wc_string = c_to_wc_str(s);
@ -420,7 +420,7 @@ const FString FString::operator + (const std::wstring& s)
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
const FString FString::operator + (const wchar_t* s) const FString FString::operator + (const wchar_t s[])
{ {
FString tmp(string); FString tmp(string);
tmp._insert (length, uInt(std::wcslen(s)), s); tmp._insert (length, uInt(std::wcslen(s)), s);
@ -442,7 +442,7 @@ const FString FString::operator + (const std::string& s)
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
const FString FString::operator + (const char* s) const FString FString::operator + (const char s[])
{ {
FString tmp(string); FString tmp(string);
wchar_t* wc_string = c_to_wc_str(s); wchar_t* wc_string = c_to_wc_str(s);
@ -700,7 +700,7 @@ uInt FString::getUTF8length() const
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
FString& FString::sprintf (const wchar_t* format, ...) FString& FString::sprintf (const wchar_t format[], ...)
{ {
static const int BUFSIZE = 4096; static const int BUFSIZE = 4096;
wchar_t buffer[BUFSIZE]; wchar_t buffer[BUFSIZE];
@ -715,7 +715,7 @@ FString& FString::sprintf (const wchar_t* format, ...)
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
FString& FString::sprintf (const char* format, ...) FString& FString::sprintf (const char format[], ...)
{ {
const wchar_t* wc_string; const wchar_t* wc_string;
char buf[1024]; char buf[1024];
@ -1220,14 +1220,14 @@ FStringList FString::split (const FString& delimiter)
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
FString& FString::setString (const wchar_t* s) FString& FString::setString (const wchar_t s[])
{ {
_assign (s); _assign (s);
return *this; return *this;
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
FString& FString::setString (const char* s) FString& FString::setString (const char s[])
{ {
const wchar_t* wc_string = c_to_wc_str(s); const wchar_t* wc_string = c_to_wc_str(s);
@ -1426,7 +1426,7 @@ bool FString::operator < (const std::wstring& s) const
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
bool FString::operator < (const wchar_t* s) const bool FString::operator < (const wchar_t s[]) const
{ {
const FString tmp(s); const FString tmp(s);
return *this < tmp; return *this < tmp;
@ -1440,7 +1440,7 @@ bool FString::operator < (const std::string& s) const
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
bool FString::operator < (const char* s) const bool FString::operator < (const char s[]) const
{ {
const FString tmp(s); const FString tmp(s);
return *this < tmp; return *this < tmp;
@ -1486,7 +1486,7 @@ bool FString::operator <= (const std::wstring& s) const
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
bool FString::operator <= (const wchar_t* s) const bool FString::operator <= (const wchar_t s[]) const
{ {
const FString tmp(s); const FString tmp(s);
return *this <= tmp; return *this <= tmp;
@ -1500,7 +1500,7 @@ bool FString::operator <= (const std::string& s) const
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
bool FString::operator <= (const char* s) const bool FString::operator <= (const char s[]) const
{ {
const FString tmp(s); const FString tmp(s);
return *this <= tmp; return *this <= tmp;
@ -1543,7 +1543,7 @@ bool FString::operator == (const std::wstring& s) const
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
bool FString::operator == (const wchar_t* s) const bool FString::operator == (const wchar_t s[]) const
{ {
const FString tmp(s); const FString tmp(s);
return *this == tmp; return *this == tmp;
@ -1557,7 +1557,7 @@ bool FString::operator == (const std::string& s) const
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
bool FString::operator == (const char* s) const bool FString::operator == (const char s[]) const
{ {
const FString tmp(s); const FString tmp(s);
return *this == tmp; return *this == tmp;
@ -1600,7 +1600,7 @@ bool FString::operator != (const std::wstring& s) const
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
bool FString::operator != (const wchar_t* s) const bool FString::operator != (const wchar_t s[]) const
{ {
const FString tmp(s); const FString tmp(s);
return *this != tmp; return *this != tmp;
@ -1614,7 +1614,7 @@ bool FString::operator != (const std::string& s) const
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
bool FString::operator != (const char* s) const bool FString::operator != (const char s[]) const
{ {
const FString tmp(s); const FString tmp(s);
return *this != tmp; return *this != tmp;
@ -1660,7 +1660,7 @@ bool FString::operator >= (const std::wstring& s) const
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
bool FString::operator >= (const wchar_t* s) const bool FString::operator >= (const wchar_t s[]) const
{ {
const FString tmp(s); const FString tmp(s);
return *this >= tmp; return *this >= tmp;
@ -1674,7 +1674,7 @@ bool FString::operator >= (const std::string& s) const
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
bool FString::operator >= (const char* s) const bool FString::operator >= (const char s[]) const
{ {
const FString tmp(s); const FString tmp(s);
return *this >= tmp; return *this >= tmp;
@ -1720,7 +1720,7 @@ bool FString::operator > (const std::wstring& s) const
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
bool FString::operator > (const wchar_t* s) const bool FString::operator > (const wchar_t s[]) const
{ {
const FString tmp(s); const FString tmp(s);
return *this > tmp; return *this > tmp;
@ -1734,7 +1734,7 @@ bool FString::operator > (const std::string& s) const
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
bool FString::operator > (const char* s) const bool FString::operator > (const char s[]) const
{ {
const FString tmp(s); const FString tmp(s);
return *this > tmp; return *this > tmp;
@ -1765,7 +1765,7 @@ const FString& FString::insert (const FString& s, uInt pos)
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
const FString& FString::insert (const wchar_t* s, uInt pos) const FString& FString::insert (const wchar_t s[], uInt pos)
{ {
if ( pos >= length ) if ( pos >= length )
throw std::out_of_range(""); throw std::out_of_range("");
@ -1775,7 +1775,7 @@ const FString& FString::insert (const wchar_t* s, uInt pos)
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
const FString& FString::insert (const char* s, uInt pos) const FString& FString::insert (const char s[], uInt pos)
{ {
return insert(FString(s), pos); return insert(FString(s), pos);
} }
@ -1838,7 +1838,7 @@ FString FString::replace (const FString& from, const std::wstring& to)
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
FString FString::replace (const FString& from, const wchar_t* to) FString FString::replace (const FString& from, const wchar_t to[])
{ {
FString to_str(to); FString to_str(to);
return replace (from, to_str); return replace (from, to_str);
@ -1852,7 +1852,7 @@ FString FString::replace (const FString& from, const std::string& to)
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
FString FString::replace (const FString& from, const char* to) FString FString::replace (const FString& from, const char to[])
{ {
FString to_str(to); FString to_str(to);
return replace (from, to_str); return replace (from, to_str);
@ -1888,7 +1888,7 @@ FString FString::replace (const std::wstring& from, const std::wstring& to)
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
FString FString::replace (const std::wstring& from, const wchar_t* to) FString FString::replace (const std::wstring& from, const wchar_t to[])
{ {
FString from_str(from); FString from_str(from);
FString to_str(to); FString to_str(to);
@ -1904,7 +1904,7 @@ FString FString::replace (const std::wstring& from, const std::string& to)
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
FString FString::replace (const std::wstring& from, const char* to) FString FString::replace (const std::wstring& from, const char to[])
{ {
FString from_str(from); FString from_str(from);
FString to_str(to); FString to_str(to);
@ -1944,7 +1944,7 @@ FString FString::replace (const std::string& from, const std::wstring& to)
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
FString FString::replace (const std::string& from, const wchar_t* to) FString FString::replace (const std::string& from, const wchar_t to[])
{ {
FString from_str(from); FString from_str(from);
FString to_str(to); FString to_str(to);
@ -1960,7 +1960,7 @@ FString FString::replace (const std::string& from, const std::string& to)
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
FString FString::replace (const std::string& from, const char* to) FString FString::replace (const std::string& from, const char to[])
{ {
FString from_str(from); FString from_str(from);
FString to_str(to); FString to_str(to);
@ -1984,14 +1984,14 @@ FString FString::replace (const std::string& from, const char to)
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
FString FString::replace (const wchar_t* from, const FString& to) FString FString::replace (const wchar_t from[], const FString& to)
{ {
FString from_str(from); FString from_str(from);
return replace (from_str, to); return replace (from_str, to);
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
FString FString::replace (const wchar_t* from, const std::wstring& to) FString FString::replace (const wchar_t from[], const std::wstring& to)
{ {
FString from_str(from); FString from_str(from);
FString to_str(to); FString to_str(to);
@ -1999,7 +1999,7 @@ FString FString::replace (const wchar_t* from, const std::wstring& to)
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
FString FString::replace (const wchar_t* from, const wchar_t* to) FString FString::replace (const wchar_t from[], const wchar_t to[])
{ {
FString from_str(from); FString from_str(from);
FString to_str(to); FString to_str(to);
@ -2007,7 +2007,23 @@ FString FString::replace (const wchar_t* from, const wchar_t* to)
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
FString FString::replace (const wchar_t* from, const wchar_t to) FString FString::replace (const wchar_t from[], const std::string& to)
{
FString from_str(from);
FString to_str(to);
return replace (from_str, to_str);
}
//----------------------------------------------------------------------
FString FString::replace (const wchar_t from[], const char to[])
{
FString from_str(from);
FString to_str(to);
return replace (from_str, to_str);
}
//----------------------------------------------------------------------
FString FString::replace (const wchar_t from[], const wchar_t to)
{ {
FString from_str(from); FString from_str(from);
FString to_wchar(to); FString to_wchar(to);
@ -2015,7 +2031,7 @@ FString FString::replace (const wchar_t* from, const wchar_t to)
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
FString FString::replace (const wchar_t* from, const char to) FString FString::replace (const wchar_t from[], const char to)
{ {
FString from_str(from); FString from_str(from);
FString to_char(to); FString to_char(to);
@ -2023,7 +2039,7 @@ FString FString::replace (const wchar_t* from, const char to)
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
FString FString::replace (const char* from, const FString& to) FString FString::replace (const char from[], const FString& to)
{ {
FString from_str(from); FString from_str(from);
FString to_str(to); FString to_str(to);
@ -2031,7 +2047,7 @@ FString FString::replace (const char* from, const FString& to)
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
FString FString::replace (const char* from, const std::wstring& to) FString FString::replace (const char from[], const std::wstring& to)
{ {
FString from_str(from); FString from_str(from);
FString to_str(to); FString to_str(to);
@ -2039,7 +2055,7 @@ FString FString::replace (const char* from, const std::wstring& to)
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
FString FString::replace (const char* from, const wchar_t* to) FString FString::replace (const char from[], const wchar_t to[])
{ {
FString from_str(from); FString from_str(from);
FString to_str(to); FString to_str(to);
@ -2047,7 +2063,7 @@ FString FString::replace (const char* from, const wchar_t* to)
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
FString FString::replace (const char* from, const std::string& to) FString FString::replace (const char from[], const std::string& to)
{ {
FString from_str(from); FString from_str(from);
FString to_str(to); FString to_str(to);
@ -2055,7 +2071,7 @@ FString FString::replace (const char* from, const std::string& to)
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
FString FString::replace (const char* from, const char* to) FString FString::replace (const char from[], const char to[])
{ {
FString from_str(from); FString from_str(from);
FString to_str(to); FString to_str(to);
@ -2063,7 +2079,7 @@ FString FString::replace (const char* from, const char* to)
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
FString FString::replace (const char* from, const wchar_t to) FString FString::replace (const char from[], const wchar_t to)
{ {
FString from_str(from); FString from_str(from);
FString to_wchar(to); FString to_wchar(to);
@ -2071,7 +2087,7 @@ FString FString::replace (const char* from, const wchar_t to)
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
FString FString::replace (const char* from, const char to) FString FString::replace (const char from[], const char to)
{ {
FString from_str(from); FString from_str(from);
FString to_char(to); FString to_char(to);
@ -2122,7 +2138,7 @@ FString FString::replace (const wchar_t from, const std::wstring& to)
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
FString FString::replace (const wchar_t from, const wchar_t* to) FString FString::replace (const wchar_t from, const wchar_t to[])
{ {
FString to_str(to); FString to_str(to);
return replace (from, to_str); return replace (from, to_str);
@ -2136,7 +2152,7 @@ FString FString::replace (const wchar_t from, const std::string& to)
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
FString FString::replace (const wchar_t from, const char* to) FString FString::replace (const wchar_t from, const char to[])
{ {
FString to_str(to); FString to_str(to);
return replace (from, to_str); return replace (from, to_str);
@ -2165,7 +2181,7 @@ FString FString::replace (const char from, const std::wstring& to)
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
FString FString::replace (const char from, const wchar_t* to) FString FString::replace (const char from, const wchar_t to[])
{ {
FString from_str(from); FString from_str(from);
FString to_str(to); FString to_str(to);
@ -2181,7 +2197,7 @@ FString FString::replace (const char from, const std::string& to)
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
FString FString::replace (const char from, const char* to) FString FString::replace (const char from, const char to[])
{ {
FString from_str(from); FString from_str(from);
FString to_str(to); FString to_str(to);
@ -2368,7 +2384,7 @@ const FString& FString::overwrite (const FString& s, uInt pos)
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
const FString& FString::overwrite (const wchar_t* s, uInt pos) const FString& FString::overwrite (const wchar_t s[], uInt pos)
{ {
uInt len = uInt(std::wcslen(s)); uInt len = uInt(std::wcslen(s));
@ -2412,13 +2428,13 @@ bool FString::includes (const FString& s)
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
bool FString::includes (const wchar_t* s) bool FString::includes (const wchar_t s[])
{ {
return ( std::wcsstr(string, s) != 0 ); return ( std::wcsstr(string, s) != 0 );
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
bool FString::includes (const char* s) bool FString::includes (const char s[])
{ {
bool ret; bool ret;
const wchar_t* wc_string = c_to_wc_str(s); const wchar_t* wc_string = c_to_wc_str(s);
@ -2472,7 +2488,7 @@ inline void FString::initLength (uInt len)
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
inline void FString::_assign (const wchar_t* s) inline void FString::_assign (const wchar_t s[])
{ {
if ( s == string ) if ( s == string )
return; return;
@ -2502,7 +2518,7 @@ inline void FString::_assign (const wchar_t* s)
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
inline void FString::_insert (uInt pos, uInt len, const wchar_t* s) inline void FString::_insert (uInt pos, uInt len, const wchar_t s[])
{ {
if ( len == 0 ) // String s is a null or a empty string if ( len == 0 ) // String s is a null or a empty string
return; return;
@ -2617,7 +2633,7 @@ inline void FString::_remove (uInt pos, uInt len)
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
inline char* FString::wc_to_c_str (const wchar_t* s) const inline char* FString::wc_to_c_str (const wchar_t s[]) const
{ {
int mblength int mblength
, size , size
@ -2678,7 +2694,7 @@ inline char* FString::wc_to_c_str (const wchar_t* s) const
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
inline wchar_t* FString::c_to_wc_str (const char* s) const inline wchar_t* FString::c_to_wc_str (const char s[]) const
{ {
int wclength int wclength
, size , size
@ -2747,9 +2763,9 @@ inline wchar_t* FString::c_to_wc_str (const char* s) const
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
inline wchar_t* FString::extractToken ( wchar_t** rest inline wchar_t* FString::extractToken ( wchar_t* rest[]
, const wchar_t* s , const wchar_t s[]
, const wchar_t* delim ) , const wchar_t delim[] )
{ {
register wchar_t* token; register wchar_t* token;
token = ( s ) ? const_cast<wchar_t*>(s) : *rest; token = ( s ) ? const_cast<wchar_t*>(s) : *rest;
@ -2797,7 +2813,7 @@ const FString operator + (const std::wstring& s1, const FString& s2)
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
const FString operator + (const wchar_t* s1, const FString& s2) const FString operator + (const wchar_t s1[], const FString& s2)
{ {
FString tmp(s1); FString tmp(s1);
tmp._insert ( uInt(std::wcslen(s1)) tmp._insert ( uInt(std::wcslen(s1))
@ -2817,7 +2833,7 @@ const FString operator + (const std::string& s1, const FString& s2)
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
const FString operator + (const char* s1, const FString& s2) const FString operator + (const char s1[], const FString& s2)
{ {
FString tmp(s1); FString tmp(s1);
tmp._insert ( tmp.getLength() tmp._insert ( tmp.getLength()

32
src/fterm.cpp
View File

@ -1618,7 +1618,7 @@ const FString FTerm::getSecDA()
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
void FTerm::putstringf (const char* const format, ...) void FTerm::putstringf (const char format[], ...)
{ {
assert ( format != 0 ); assert ( format != 0 );
char buf[512]; char buf[512];
@ -1634,7 +1634,7 @@ void FTerm::putstringf (const char* const format, ...)
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
inline void FTerm::putstring (const char* const s, int affcnt) inline void FTerm::putstring (const char s[], int affcnt)
{ {
#if defined(__sun) && defined(__SVR4) #if defined(__sun) && defined(__SVR4)
tputs (C_STR(s), affcnt, FTerm::putchar_ASCII); tputs (C_STR(s), affcnt, FTerm::putchar_ASCII);
@ -2138,18 +2138,28 @@ int FTerm::getFramebuffer_bpp ()
//---------------------------------------------------------------------- //----------------------------------------------------------------------
int FTerm::openConsole() int FTerm::openConsole()
{ {
static const char* terminal_devices[] =
{
"/proc/self/fd/0",
"/dev/tty",
"/dev/tty0",
"/dev/vc/0",
"/dev/systty",
"/dev/console",
0
};
if ( fd_tty >= 0 ) // console is already opened if ( fd_tty >= 0 ) // console is already opened
return 0; return 0;
if ( *term_name && (fd_tty = open (term_name, O_RDWR, 0)) < 0 ) if ( ! *term_name )
if ( (fd_tty = open("/proc/self/fd/0", O_RDWR, 0)) < 0 )
if ( (fd_tty = open("/dev/tty", O_RDWR, 0)) < 0 )
if ( (fd_tty = open("/dev/tty0", O_RDWR, 0)) < 0 )
if ( (fd_tty = open("/dev/vc/0", O_RDWR, 0)) < 0 )
if ( (fd_tty = open("/dev/systty", O_RDWR, 0)) < 0 )
if ( (fd_tty = open("/dev/console", O_RDWR, 0)) < 0 )
return -1; // No file descriptor referring to the console
return 0; return 0;
for (int i = 0; terminal_devices[i] != 0; i++)
if ( (fd_tty = open(terminal_devices[i], O_RDWR, 0)) >= 0 )
return 0;
return -1; // No file descriptor referring to the console
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
@ -2324,7 +2334,7 @@ int FTerm::getScreenFont()
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
int FTerm::setScreenFont ( uChar* fontdata, uInt count int FTerm::setScreenFont ( uChar fontdata[], uInt count
, uInt fontwidth, uInt fontheight , uInt fontwidth, uInt fontheight
, bool direct) , bool direct)
{ {

8
src/ftermbuffer.cpp
View File

@ -43,7 +43,7 @@ FTermBuffer::~FTermBuffer() // destructor
// public methods of FTermBuffer // public methods of FTermBuffer
//---------------------------------------------------------------------- //----------------------------------------------------------------------
int FTermBuffer::writef (const wchar_t* format, ...) int FTermBuffer::writef (const wchar_t format[], ...)
{ {
assert ( format != 0 ); assert ( format != 0 );
static const int BufSize = 1024; static const int BufSize = 1024;
@ -59,7 +59,7 @@ int FTermBuffer::writef (const wchar_t* format, ...)
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
int FTermBuffer::writef (const char* format, ...) int FTermBuffer::writef (const char format[], ...)
{ {
assert ( format != 0 ); assert ( format != 0 );
int len; int len;
@ -106,14 +106,14 @@ int FTermBuffer::write (const std::wstring& s)
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
int FTermBuffer::write (const wchar_t* s) int FTermBuffer::write (const wchar_t s[])
{ {
assert ( s != 0 ); assert ( s != 0 );
return write (FString(s)); return write (FString(s));
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
int FTermBuffer::write (const char* s) int FTermBuffer::write (const char s[])
{ {
assert ( s != 0 ); assert ( s != 0 );
FString str(s); FString str(s);

12
src/fvterm.cpp
View File

@ -306,7 +306,7 @@ void FVTerm::delPreprocessingHandler (FVTerm* instance)
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
int FVTerm::printf (const wchar_t* format, ...) int FVTerm::printf (const wchar_t format[], ...)
{ {
assert ( format != 0 ); assert ( format != 0 );
static const int BufSize = 1024; static const int BufSize = 1024;
@ -322,7 +322,7 @@ int FVTerm::printf (const wchar_t* format, ...)
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
int FVTerm::printf (const char* format, ...) int FVTerm::printf (const char format[], ...)
{ {
assert ( format != 0 ); assert ( format != 0 );
int len; int len;
@ -377,14 +377,14 @@ int FVTerm::print (term_area* area, const std::wstring& s)
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
int FVTerm::print (const wchar_t* s) int FVTerm::print (const wchar_t s[])
{ {
assert ( s != 0 ); assert ( s != 0 );
return print (FString(s)); return print (FString(s));
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
int FVTerm::print (term_area* area, const wchar_t* s) int FVTerm::print (term_area* area, const wchar_t s[])
{ {
assert ( area != 0 ); assert ( area != 0 );
assert ( s != 0 ); assert ( s != 0 );
@ -392,7 +392,7 @@ int FVTerm::print (term_area* area, const wchar_t* s)
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
int FVTerm::print (const char* s) int FVTerm::print (const char s[])
{ {
assert ( s != 0 ); assert ( s != 0 );
FString str(s); FString str(s);
@ -400,7 +400,7 @@ int FVTerm::print (const char* s)
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
int FVTerm::print (term_area* area, const char* s) int FVTerm::print (term_area* area, const char s[])
{ {
assert ( area != 0 ); assert ( area != 0 );
assert ( s != 0 ); assert ( s != 0 );