C++博客-cyantree's home

讨论fltk的qq群

cyantree — Sun, 28 Jan 2007 10:43:00 GMT

群号：32425450

欢迎对fltk有兴趣的开发人员加入

cyantree 2007-01-28 18:43 发表评论

fltk在windows上的一个小bug

cyantree — Tue, 23 Jan 2007 11:43:00 GMT

描述：
在windows下创建一个resizable window，最大化的时候会出错，窗口的最下方实际上并没有和任务栏靠在一起，而且如果任务栏很高，那更是奇怪，窗口会超出任务栏

原因：
怀疑实现部分并非是由系统处理，而且自己处理了这个事件，没有去看代码，暂时存疑

解决：
无。只有找到源代码的实现部分才知道怎么修改了

cyantree 2007-01-23 19:43 发表评论

fltk2更新简介

cyantree — Tue, 23 Jan 2007 11:42:00 GMT

不久前fltk终于释出可以实用的2.0版本，目前的具体版本是2.0.x-r5556，让我们看看具体的更新和变动

首先是字体的巨大改进，开始支持utf8，所以在linux下汉字无法显示和输入法无法输入的问题已经彻底解决，但同时也带来一些问题，就是在代码内必须使用 utf8的汉字才能正确显示在界面上，但是unicode的编辑器又不是那么好找，再说在windows下开发的话一般都会使用vc，而在vc下输入 unicode是一件有困难的事情，至少我没有找到好的插件，所以需要一个解决办法，那就是里的函数，帮助文档里没有说的很清楚，但是大体上还是可以猜到意思的

修改了class Browser，变成了一个tree，在1.0中想显示一个grid或者listview一直只能自己处理，现在不用了，这个Browser还算可以，提供了基本的功能，稍微还有一些扩充，如果想再丰富一些就只有自己继承了，反正fltk的宗旨就是自己动手丰衣足食。

Opengl的功能貌似有一些修正，但是我没有用到，而且demo中关于OpenGL的例子还没有提供，所以目前情况未知

帮助文档未完善，而且代码中附带的帮助无法使用，所以很多时候还是查1.0的帮助以及看源代码更加有效一些

所有的头文件和类名全部去除了FL_，引入了namespace，好处是类看起来更清楚了，坏处是从1.0的代码升级变得很麻烦。头文件从变成，全部变成了小写，而且去掉了FL_，同时目录也变成fltk/了，这些细节稍微用一段时间就会习惯，一开始会造成一些问题，虽然在fltk目录下也保留了一些兼容的头文件，但是建议还是不要用，因为不全，而且迟早要换的，何必不一步到位？

对编译器支持的更全，目前支持vc6,vc.net,devcpp,gcc,Code::Blocks,bc5，基本囊括了流行的C/C++编译器

支持整体theme，可以一次性设置当前界面的theme

打算引入一个叫cairo的库，具体作用好像是用于矢量运算的，属于第三方的代码，在fltk的站点上关于这个有一个投票，大多数人还是拒绝在fltk中加入外来插件，都觉得应该保持fltk的轻量快速的特征

待续.....

cyantree 2007-01-23 19:42 发表评论

class的沼泽地

cyantree — Thu, 19 Oct 2006 13:15:00 GMT

　　先看这个文章，“最小接口”：
http://blog.csdn.net/mfowler/archive/2006/10/19/1340364.aspx

　　Martin Fowler的确是oo的大师，对类的理解和解析的确很深入，但是我还是想表述一些不同的意见。对于class而言，越强大就会越臃肿，越简单就会越零碎，这是不可避免的问题。对于一个足够复杂的系统，class简单了不行，太散，最后的组装成本会相对过高，复杂了也不行，复用和维护的成本也很高。而且这两种都会造成中间层的脂肪过剩，虽然所有讲oo的书都会说过度复杂的中间层不好，但是没有哪本书提出了很好的解决办法，似乎归结到最后就只有依靠开发者本身了。这种情况其实很是可怕，面对目前的开发现状，很多系统对复用的渴求会越来越明显，但是老系统中到底有多少模块可以无缝移植，只怕没有人能说清楚。而且随着需求的变化，老系统的维护和升级也越来越成为一个巨大的负担，重写是最常见的最终武器，但这武器所带来的损耗和浪费也是相当惊人的。

　　其实问题的核心是：如何在复杂度和可读性之间寻求最佳的平衡。人的脑容量是有限的和有差异的，不同的开发者对复杂度的衡量标准是不一样的。一个确定的模块，对某些人而言是容易理解和消化的，但对另外的人而言却复杂的无法吞咽，这是现实问题，并不是通过培训和努力就能消除的。不同的行业和不同的开发方向，一定会造成不同的理解范围和理解方式，也就造成不同的开发者之间会存在必然的差异。只要这种差异存在，之前所述的问题就一定存在。

　　问题不可怕，可怕的是不敢去面对。真的勇士，敢于直面惨淡的人生;-) 个人看法，胶合层是一定要减肥的，但是如何减是一个问题。对于一个oo构架的系统，胶合层是一定存在的，如何做薄做小是个关键，同时薄和小的标准也是因人而异的。起码有一点我很肯定，胶合层的复用性是很差的，甚至可以说根本没有复用的可能，那么很简单，一个系统中只创建一个胶合层，尽量将特定的需求和无法复用的部分整合进来，同时随时做好丢弃的准备，一旦需要开发新系统或者需要升级系统，胶合层就成为第一个被牺牲的对象，如果设计的好，就有可能是唯一需要丢弃的部分，这样起码可以保证智力投资最大限度的保值。

　　模块(class，接口，函数，随便你怎么定义它)的复用性如何，决定了它的生存时间，也直接反应了开发者的能力，如何确保复用性是个老生常谈的话题了，但我还是要啰嗦两句。复用性好并不代表强大和复杂，为了追求一个万能模块而编写足够复杂的模块，纯属浪费时间和精力，简单是保证良好复用性的前提，一个复杂的模块是不能指望有多少复用性的。同时，简单并非是简化，一个无法完成分内工作的模块是残次品，是不能称之为具有复用性的。基于之前的论述，如何算是简单对于不同的开发者而言又是各不相同的，这需要开发者从别人的角度考虑和长时间的自我衡量，复杂了不行，学习难度太高，简单了不行，会降低模块的灵活性。曾经看过一段话：好的界面就是一眼看过去，需要的功能都在，没有什么复杂的存在，但是需要深入控制的时候，该有的也都能找的到。挪到我们的问题上，也就差不多是这个意思了。这很难，但就是因为难，也就同时创造了乐趣，做为一个开发者，当以这种困难为敌手，图穷匕首现，五步溅血.....

2006-10-19 18:57

cyantree 2006-10-19 21:15 发表评论

两个bt聊天

cyantree — Thu, 06 Jul 2006 15:20:00 GMT

伟大的progame 11:30:40
我又在看我2年多前的代码向自己学习
伟大的progame 11:30:50
原来我处在一个极端现在在另一个极端
量大的老鸨 11:32:14
我3年前的代码，只能形容为：不忍卒读
量大的老鸨 11:32:43
现在的代码，可以很公正的说：垃圾
伟大的progame 11:33:07
我原来走标准的三层 com+ businessobject
伟大的progame 11:34:15
现在是framework + xml
伟大的progame 11:34:28
接下来要中和了
伟大的progame 11:34:31
两个都是极端
老渔翁 11:34:57
标准的三层是垃圾。
量大的老鸨 11:37:01
我以前是标准的万物皆类，一个小小的接口都要用类来包裹一番，结果累的不行
量大的老鸨 11:38:05
现在终于幡然悔悟，明白鸟手中无刀，心中有刀的真谛，所谓放下屠刀，立地成佛啊.....
伟大的progame 11:38:33
你不明白你没有涉及到复杂多变的业务
量大的老鸨 11:39:30
以史为鉴，展望未来，我们的目标是飞花摘叶，皆可伤人，要做到手中无刀，心中也无刀.....
乌鸦 11:39:50
粒度看自己把握
量大的老鸨 11:40:05
我坚持认为，复杂的需求未必一定带来复杂的实现
老渔翁 11:40:36
我一直用成熟的技术，不用最先进的技术。
乌鸦 11:40:44
复杂的实现必带来不稳定
量大的老鸨 11:40:53
葵花宝典为什么那么nb？化繁为简，一根绣花针就搞定一切啊
老渔翁 11:40:57
这是为什么很多国家不修磁悬浮的原因。
乌鸦 11:41:10
复杂的东西必带来不可靠
量大的老鸨 11:41:46
再看独孤九剑，关键就在一个破字
乌鸦 11:42:02
以前是数据库,非要怎么设计
乌鸦 11:42:15
现在是类
乌鸦 11:42:23
然后又是层
量大的老鸨 11:42:34
所谓九贱齐出，群处可破.....
伟大的progame 11:43:41
没说实现要复杂
伟大的progame 11:43:53
但是你如何有一个灵活的东西去面对多变的业务呢
伟大的progame 11:44:08
最后发现事实上是很难面对的
量大的老鸨 11:44:09
要灵活，就要简单
伟大的progame 11:44:32
想一个东西通吃不同的业务是不现实的
乌鸦 11:44:33
很多业务其实实现的代价远远大于维护的代价
乌鸦 11:44:43
所以这个业务实际上是错的
量大的老鸨 11:44:44
越内敛，越通用
伟大的progame 11:44:48
首选是业务模型的建立
伟大的progame 11:45:01
这不比软件架构的设计简单
量大的老鸨 11:45:06
所谓浓缩的就是精华
量大的老鸨 11:45:49
个人经验：要从人的角度考虑，就可以避免一些不必要的复杂
量大的老鸨 11:46:48
几乎所有的windows程序都有搜索，但你看linux的做法，find+grep搞定一切
伟大的progame 11:46:50
你不精通业务再怎么设计都可能走入死角
量大的老鸨 11:47:17
业务为人而存在
伟大的progame 11:47:32
业务第一软件第二
量大的老鸨 11:47:48
人第一，业务第二，软件第三
量大的老鸨 11:48:26
表认为客户都是笨蛋，其实当你愿意教他的时候，客户会比你想像的聪明
伟大的progame 11:48:49
你从每个人的想法出发是错误的因为即使是一个客户在它的内部也是有大量的冲突
伟大的progame 11:49:00
操作和管理层市场和售后服务
伟大的progame 11:49:12
他们的出发点是不同的出来的东西是矛盾的
量大的老鸨 11:49:17
冲突是一定的，而且一定会造成矛盾的需求
伟大的progame 11:49:26
你如果精通业务有成功案例
伟大的progame 11:49:33
那么好办了这时才可以指导它
量大的老鸨 11:49:50
在这个时候，可以给出一个二义性的解决方案，有何不可？
伟大的progame 11:49:58
不会因为你的软件多么多么地灵活多么多么地先进你才有资格指导它
伟大的progame 11:50:23
那么你的软件最后给他们是带来问题
伟大的progame 11:50:27
而不是解决问题
量大的老鸨 11:50:37
解决问题的核心是解决人
专弹金属的JJ 11:50:43
因为人本身，就是一个问题！
量大的老鸨 11:50:44
而不是事情
伟大的progame 11:50:53
精通业务成功案例这是顺利实施的不二法门
伟大的progame 11:51:59
其它都是扯蛋跟客户说技术先进负载量可伸缩性跨平台节约成本最后都会因为流程无法顺利走通而完蛋
量大的老鸨 11:52:21
我没有做过数据库应用，所以只能从我的经验进行推论，未必正确，但是（我恨这个词），一些原理也许可以通用
伟大的progame 11:52:21
老梦你做的是提供功能性的东西功能有了就OK了
伟大的progame 11:52:30
我做的是业务流程的东西
伟大的progame 11:52:40
流程才是最重要的
量大的老鸨 11:52:54
流程走不通，可以变通
量大的老鸨 11:53:03
变通的基点就是人
伟大的progame 11:53:16
客户不是要你拿他来当实验品
量大的老鸨 11:53:23
否则就不能转化为最终实现
量大的老鸨 11:53:49
客户是上帝，是猪，是畜生
量大的老鸨 11:54:08
当一回试验品也没关系
量大的老鸨 11:54:43
要敢于摸着mimi找mm
量大的老鸨 11:54:58
只要爽就可以
伟大的progame 11:55:17
所以没办法只好牺牲几个试验品了
伟大的progame 11:55:25
代价就是被客户骂
量大的老鸨 11:55:32
没人敢说他的模型是万能的，他的流程是通用的
量大的老鸨 11:56:09
如果能做到尽量灵活，也能做到无限接近正确
量大的老鸨 11:56:52
写的再多，不如抓住核心
伟大的progame 11:57:21
我现在就是想用底层的东西能够大大节省开发时间这样无需开发通用产品而是快速开发多个产品
量大的老鸨 11:58:22
也许我更粗暴，我想用进程＋灵活的接口方式，提供一劳永逸的模块，将来的事情就是组装
量大的老鸨 11:58:57
没有胶合层，拒绝转发
量大的老鸨 11:59:16
界面都可以抛弃，只有功能永存
量大的老鸨 12:00:24
所谓的框架、模型、接口，最终的目标是功能，如果带来的附加部分远超过实际所需，那么再先进也是废物
量大的老鸨 12:01:05
最极端的例子就是java的那些狗屁框架，也不知道是为什么样的脑袋而准备的
量大的老鸨 12:01:43
我只要一杯水，却给我送上来一个净水处理工厂

2006-06-29 http://www.heybrain.com 首发

cyantree 2006-07-06 23:20 发表评论

跨平台的鼠标移动源代码

cyantree — Wed, 31 May 2006 05:22:00 GMT

#include < stdio.h >
#include < stdlib.h >
#include < string.h >

#ifdef WIN32
#include < windows.h >
#else
#include < unistd.h >
#include < X11/X.h >
#include < X11/Xlib.h >
#endif

int main(int argc, char* argv[])
{
char sx[10], sy[10];
int x, y;

    if ( argc < 3 ) return 0;
    strcpy(sx, argv[1]);
    strcpy(sy, argv[2]);
    x = atoi(sx);
    y = atoi(sy);

#ifdef WIN32
    SetCursorPos(x, y);
#else
    Display *dpy;
    Window rootwindow;

    dpy = XOpenDisplay(NULL);
    if ( ! dpy ) {
        printf("Couldn't open Xdisplay.\n");
        exit(1);
    }
    rootwindow = DefaultRootWindow(dpy);

XWarpPointer(dpy, rootwindow, rootwindow, 0, 0, 0, 0, x, y);

XCloseDisplay(dpy);
#endif
return 0;
}

cyantree 2006-05-31 13:22 发表评论

跨平台的INI处理源代码

cyantree — Wed, 31 May 2006 05:20:00 GMT

// IniFile.h

#ifndef INIFILE_H
#define INIFILE_H

#include < stdio.h >
#include < stdlib.h >
#include < string.h >

#ifndef OWP_DONT_DEF_FALSE
#ifndef FALSE
#define FALSE 0
#endif
#endif

#ifndef OWP_DONT_DEF_TRUE
#ifndef TRUE
#define TRUE 1
#endif
#endif

#ifndef OWP_DONT_DEF_BOOL
#ifndef BOOL
#define BOOL unsigned int
#endif
#endif

#ifndef OWP_DONT_DEF_CCHR
#ifndef CCHR
#define CCHR const char
#endif
#endif

#ifndef OWP_DONT_DEF_UCHR
#ifndef UCHR
#define UCHR unsigned char
#endif
#endif

#ifndef OWP_DONT_DEF_UCCHR
#ifndef UCCHR
#define UCCHR const unsigned char
#endif
#endif

#ifndef OWP_DONT_DEF_UINT
#ifndef UINT
#define UINT unsigned int
#endif
#endif

#ifndef OWP_DONT_DEF_WORD
#ifndef WORD
#define WORD unsigned short
#endif
#endif

#ifdef LINUX /* Remove CR, on unix systems. */
#define INI_REMOVE_CR
#define DONT_HAVE_STRUPR
#endif

#define tpNULL 0
#define tpSECTION 1
#define tpKEYVALUE 2
#define tpCOMMENT 3

struct ENTRY
{
char Type;
char *pText;
struct ENTRY *pPrev;
struct ENTRY *pNext;
};

typedef struct
{
struct ENTRY *pSec;
struct ENTRY *pKey;
char KeyText [128];
char ValText [128];
char Comment [255];
} EFIND;

/* Macros */
#define ArePtrValid(Sec,Key,Val) ((Sec!=NULL)&&(Key!=NULL)&&(Val!=NULL))

class CIniFile
{
public:
CIniFile (void)
  {
    m_pEntry = NULL;
    m_pCurEntry = NULL;
    m_result [0] = 0;
    m_pIniFile = NULL;
  }

  ~CIniFile (void)
  {
    FreeAllMem ();
  }

BOOL OpenIniFile (CCHR *pFileName)
  {
    char Str [255];
    char *pStr;
    struct ENTRY *pEntry;

    FreeAllMem ();

    if (pFileName == NULL) { return FALSE; }
    if ((m_pIniFile = fopen (pFileName, "r")) == NULL) { return FALSE; }

    while (fgets (Str, 255, m_pIniFile) != NULL) {
      pStr = strchr (Str, '\n');
      if (pStr != NULL) { *pStr = 0; }
      pEntry = MakeNewEntry ();
      if (pEntry == NULL) { return FALSE; }

      #ifdef INI_REMOVE_CR
      Len = strlen(Str);
      if ( Len > 0 ) {
        if ( Str[Len-1] == '\r' ) {
          Str[Len-1] = '\0';
        }
      }
      #endif

      pEntry->pText = (char *)malloc (strlen (Str)+1);
      if (pEntry->pText == NULL) {
        FreeAllMem ();
        return FALSE;
      }
      strcpy (pEntry->pText, Str);
      pStr = strchr (Str,';');
      if (pStr != NULL) { *pStr = 0; } /* Cut all comments */
      if ( (strstr (Str, "[") > 0) && (strstr (Str, "]") > 0) ) /* Is Section */ {
        pEntry->Type = tpSECTION;
      } else {
        if (strstr (Str, "=") > 0) {
          pEntry->Type = tpKEYVALUE;
        } else {
          pEntry->Type = tpCOMMENT;
        }
      }
      m_pCurEntry = pEntry;
    }
    fclose (m_pIniFile);
    m_pIniFile = NULL;
    return TRUE;
  }

void CloseIniFile ()
  {
    FreeAllMem ();
    if (m_pIniFile != NULL) {
      fclose (m_pIniFile);
      m_pIniFile = NULL;
    }
  }

bool WriteIniFile (CCHR *pFileName)
  {
    struct ENTRY *pEntry = m_pEntry;
    if (m_pIniFile != NULL) {
      fclose (m_pIniFile);
    }
    if ((m_pIniFile = fopen (pFileName, "wb")) == NULL) {
      FreeAllMem ();
      return FALSE;
    }

    while (pEntry != NULL) {
      if (pEntry->Type != tpNULL) {
      #ifdef INI_REMOVE_CR
        fprintf (m_pIniFile, "%s\n", pEntry->pText);
      #else
        fprintf (m_pIniFile, "%s\r\n", pEntry->pText);
      #endif
      }
      pEntry = pEntry->pNext;
    }

    fclose (m_pIniFile);
    m_pIniFile = NULL;
    return TRUE;
  }

  bool  DeleteKey (CCHR *pSection, CCHR *pKey)
  {
    EFIND List;
    struct ENTRY *pPrev;
    struct ENTRY *pNext;

    if (FindKey (pSection, pKey, &List) == TRUE) {
      pPrev = List.pKey->pPrev;
      pNext = List.pKey->pNext;
      if (pPrev) {
        pPrev->pNext=pNext;
      }
      if (pNext) {
        pNext->pPrev=pPrev;
      }
      FreeMem (List.pKey->pText);
      FreeMem (List.pKey);
      return TRUE;
    }
    return FALSE;
  }

  BOOL ReadBool (CCHR *pSection, CCHR *pKey, BOOL Default)
  {
    char Val [2] = {"0"};
    if (Default != 0) { Val [0] = '1'; }
    return (atoi (ReadString (pSection, pKey, Val))?1:0); /* Only allow 0 or 1 */
  }

int ReadInt (CCHR *pSection, CCHR *pKey, int Default)
  {
    char Val [12];
    sprintf (Val,"%d", Default);
    return (atoi (ReadString (pSection, pKey, Val)));
  }

double ReadDouble (CCHR *pSection, CCHR *pKey, double Default)
  {
    double Val;
    sprintf (m_result, "%1.10lE", Default);
    sscanf (ReadString (pSection, pKey, m_result), "%lE", &Val);
    return Val;
  }

CCHR *ReadString (CCHR *pSection, CCHR *pKey, CCHR *pDefault)
  {
    EFIND List;
    if (ArePtrValid (pSection, pKey, pDefault) == FALSE) { return pDefault; }
    if (FindKey (pSection, pKey, &List) == TRUE) {
      strcpy (m_result, List.ValText);
      return m_result;
    }
    return pDefault;
  }

void WriteBool (CCHR *pSection, CCHR *pKey, bool Value)
  {
    char Val [2] = {'0',0};
    if (Value != 0) { Val [0] = '1'; }
    WriteString (pSection, pKey, Val);
  }

void WriteInt (CCHR *pSection, CCHR *pKey, int Value)
  {
    char Val [12]; /* 32bit maximum + sign + \0 */
    sprintf (Val, "%d", Value);
    WriteString (pSection, pKey, Val);
  }

void WriteDouble (CCHR *pSection, CCHR *pKey, double Value)
  {
    char Val [32]; /* DDDDDDDDDDDDDDD+E308\0 */
    sprintf (Val, "%1.10lE", Value);
    WriteString (pSection, pKey, Val);
  }

void WriteString (CCHR *pSection, CCHR *pKey, CCHR *pValue)
  {
    EFIND List;
    char Str [255];

    if (ArePtrValid (pSection, pKey, pValue) == FALSE) { return; }
    if (FindKey (pSection, pKey, &List) == TRUE) {
      sprintf (Str, "%s=%s%s", List.KeyText, pValue, List.Comment);
      FreeMem (List.pKey->pText);
      List.pKey->pText = (char *)malloc (strlen (Str)+1);
      strcpy (List.pKey->pText, Str);
    } else {
      if ((List.pSec != NULL) && (List.pKey == NULL)) /* section exist, Key not */ {
        AddKey (List.pSec, pKey, pValue);
      } else {
        AddSectionAndKey (pSection, pKey, pValue);
      }
    }
  }

protected:
  struct ENTRY *m_pEntry;
  struct ENTRY *m_pCurEntry;
  char m_result [255];
  FILE *m_pIniFile;

  void AddKey (struct ENTRY *pEntry, CCHR *pKey, CCHR *pValue)
  {
    char Text [255];
    sprintf (Text, "%s=%s", pKey, pValue);
    AddItemAt (pEntry, tpKEYVALUE, Text);
  }

  BOOL AddItem (char Type, CCHR *pText)
  {
    struct ENTRY *pEntry = MakeNewEntry ();
    if (pEntry == NULL) { return FALSE; }
    pEntry->Type = Type;
    pEntry->pText = (char*)malloc (strlen (pText) +1);
    if (pEntry->pText == NULL) {
      free (pEntry);
      return FALSE;
    }
    strcpy (pEntry->pText, pText);
    pEntry->pNext = NULL;
    if (m_pCurEntry != NULL) { m_pCurEntry->pNext = pEntry; }
    m_pCurEntry = pEntry;
    return TRUE;
  }

  bool AddItemAt (struct ENTRY *pEntryAt, char Mode, CCHR *pText)
  {
    struct ENTRY *pNewEntry;
    if (pEntryAt == NULL) { return FALSE; }
    pNewEntry = (struct ENTRY*) malloc (sizeof (ENTRY));
    if (pNewEntry == NULL) { return FALSE; }
    pNewEntry->pText = (char *) malloc (strlen (pText)+1);
    if (pNewEntry->pText == NULL) {
      free (pNewEntry);
      return FALSE;
    }
    strcpy (pNewEntry->pText, pText);
    if (pEntryAt->pNext == NULL) /* No following nodes. */ {
      pEntryAt->pNext = pNewEntry;
      pNewEntry->pNext = NULL;
    } else {
      pNewEntry->pNext = pEntryAt->pNext;
      pEntryAt->pNext = pNewEntry;
    }
    pNewEntry->pPrev = pEntryAt;
    pNewEntry->Type = Mode;
    return TRUE;
  }

  void FreeMem (void *pPtr)
  {
    if (pPtr != NULL) { free (pPtr); }
  }

  void FreeAllMem (void)
  {
    struct ENTRY *pEntry;
    struct ENTRY *pNextEntry;
    pEntry = m_pEntry;
    while (1) {
      if (pEntry == NULL) { break; }
      pNextEntry = pEntry->pNext;
      FreeMem (pEntry->pText); /* Frees the pointer if not NULL */
      FreeMem (pEntry);
      pEntry = pNextEntry;
    }
    m_pEntry = NULL;
    m_pCurEntry = NULL;
  }

  bool FindKey (CCHR *pSection, CCHR *pKey, EFIND *pList)
  {
    char Search [130];
    char Found [130];
    char Text [255];
    char *pText;
    struct ENTRY *pEntry;
    pList->pSec = NULL;
    pList->pKey = NULL;
    pEntry = FindSection (pSection);
    if (pEntry == NULL) { return FALSE; }
    pList->pSec = pEntry;
    pList->KeyText[0] = 0;
    pList->ValText[0] = 0;
    pList->Comment[0] = 0;
    pEntry = pEntry->pNext;
    if (pEntry == NULL) { return FALSE; }
    sprintf (Search, "%s",pKey);
    strupr (Search);
    while (pEntry != NULL) {
      if ((pEntry->Type == tpSECTION) || /* Stop after next section or EOF */
        (pEntry->Type == tpNULL )) {
        return FALSE;
      }
      if (pEntry->Type == tpKEYVALUE) {
        strcpy (Text, pEntry->pText);
        pText = strchr (Text, ';');
        if (pText != NULL) {
          strcpy (pList->Comment, pText);
          *pText = 0;
        }
        pText = strchr (Text, '=');
        if (pText != NULL) {
          *pText = 0;
          strcpy (pList->KeyText, Text);
          strcpy (Found, Text);
          *pText = '=';
          strupr (Found);
          /* printf ("%s,%s\n", Search, Found); */
          if (strcmp (Found,Search) == 0) {
            strcpy (pList->ValText, pText+1);
            pList->pKey = pEntry;
            return TRUE;
          }
        }
      }
      pEntry = pEntry->pNext;
    }
    return NULL;
  }

  bool AddSectionAndKey (CCHR *pSection, CCHR *pKey, CCHR *pValue)
  {
    char Text [255];
    sprintf (Text, "[%s]", pSection);
    if (AddItem (tpSECTION, Text) == FALSE) { return FALSE; }
    sprintf (Text, "%s=%s", pKey, pValue);
    return AddItem (tpKEYVALUE, Text)? 1 : 0;
  }

  struct ENTRY *MakeNewEntry (void)
  {
    struct ENTRY *pEntry;
    pEntry = (struct ENTRY *)malloc (sizeof (ENTRY));
    if (pEntry == NULL) {
      FreeAllMem ();
      return NULL;
    }
    if (m_pEntry == NULL) {
      m_pEntry = pEntry;
    }
    pEntry->Type = tpNULL;
    pEntry->pPrev = m_pCurEntry;
    pEntry->pNext = NULL;
    pEntry->pText = NULL;
    if (m_pCurEntry != NULL) {
      m_pCurEntry->pNext = pEntry;
    }
    return pEntry;
  }

  struct ENTRY *FindSection (CCHR *pSection)
  {
    char Sec [130];
    char iSec [130];
    struct ENTRY *pEntry;
    sprintf (Sec, "[%s]", pSection);
    strupr (Sec);
    pEntry = m_pEntry; /* Get a pointer to the first Entry */
    while (pEntry != NULL) {
      if (pEntry->Type == tpSECTION) {
        strcpy (iSec, pEntry->pText);
        strupr (iSec);
        if (strcmp (Sec, iSec) == 0) {
          return pEntry;
        }
      }
      pEntry = pEntry->pNext;
    }
    return NULL;
  }

  #ifdef DONT_HAVE_STRUPR
  /* DONT_HAVE_STRUPR is set when INI_REMOVE_CR is defined */
  void strupr( char *str )
  {
    // We dont check the ptr because the original also dont do it.
    while (*str != 0) {
      if ( islower( *str ) ) {
        *str = toupper( *str );
      }
      str++;
    }
  }
  #endif

private:
};

#endif

#ifdef INIFILE_TEST_THIS_FILE
int main (void)
{
  CIniFile iFile;
  printf ("Hello World\n");
  iFile.OpenIniFile ("Test.Ini");
  iFile.WriteString ("Test", "Name", "Value");
  iFile.WriteString ("Test", "Name", "OverWrittenValue");
  iFile.WriteString ("Test", "Port", "COM1");
  iFile.WriteString ("Test", "User", "James Brown jr.");
  iFile.WriteString ("Configuration", "eDriver", "MBM2.VXD");
  iFile.WriteString ("Configuration", "Wrap", "LPT.VXD");
  iFile.WriteInt ("IO-Port", "Com", 2);
  iFile.WriteBool ("IO-Port", "IsValid", 0);
  iFile.WriteDouble ("TheMoney", "TheMoney", 67892.00241);
  iFile.WriteInt ("Test" , "ToDelete", 1234);
  iFile.WriteIniFile ("Test.Ini");
  printf ("Key ToDelete created. Check ini file. Any key to continue");
  while (!kbhit());
  iFile.OpenIniFile ("Test.Ini");
  iFile.DeleteKey ("Test"   , "ToDelete");
  iFile.WriteIniFile ("Test.Ini");
  printf ("[Test] Name = %s\n", iFile.ReadString ("Test", "Name", "NotFound"));
  printf ("[Test] Port = %s\n", iFile.ReadString ("Test", "Port", "NotFound"));
  printf ("[Test] User = %s\n", iFile.ReadString ("Test", "User", "NotFound"));
  printf ("[Configuration] eDriver = %s\n", iFile.ReadString ("Configuration", "eDriver", "NotFound"));
  printf ("[Configuration] Wrap = %s\n", iFile.ReadString ("Configuration", "Wrap", "NotFound"));
  printf ("[IO-Port] Com = %d\n", iFile.ReadInt ("IO-Port", "Com", 0));
  printf ("[IO-Port] IsValid = %d\n", iFile.ReadBool ("IO-Port", "IsValid", 0));
  printf ("[TheMoney] TheMoney = %1.10lf\n", iFile.ReadDouble ("TheMoney", "TheMoney", 111));
  iFile.CloseIniFile ();
  return 0;
}
#endif

cyantree 2006-05-31 13:20 发表评论

跨平台的线程代码

cyantree — Tue, 16 May 2006 08:46:00 GMT

改编自fltk，添加了linux平台下的Sleep实现，只支持Windows和Linux，分别用vc和gcc编译，代码如下：

1	//threads.h, LGPL
2
3	#ifndef Threads_H
4	#define Threads_H
5
6	#ifdef WIN32
7
8	#include < windows.h >
9	#include < process.h >
10
11	typedef unsigned long Fl_Thread;
12
13	static int fl_create_thread(Fl_Thread& t, void (f) (void ), void p)
14	{
15	return t = (Fl_Thread)_beginthread((void( __cdecl * )( void * ))f, 0, p);
16	}
17
18	#else
19
20	// Use POSIX threading...
21	#include < pthread.h >
22	#include < unistd.h >
23
24	typedef pthread_t Fl_Thread;
25
26	static int fl_create_thread(Fl_Thread& t, void (f) (void ), void p)
27	{
28	return pthread_create((pthread_t*)&t, 0, f, p);
29	}
30
31	static void Sleep(unsigned long dwMilliseconds)
32	{
33	usleep(dwMilliseconds * 1000);
34	}
35
36	#endif
37
38	#endif // !Threads_h

使用示例：

1	#include "thread.h"
2	...
3
4	static Fl_Thread m_thread; // define
5	...
6
7	// thread create
8	fl_create_thread(m_thread, thread_fun, 0);
9	...
10
11	static void* thread_fun(void *p)
12	{
13	while (1) {
14	...
15	}
16
17	return 0;
18	}

cyantree 2006-05-16 16:46 发表评论

从编译Linux kernel说开来

cyantree — Wed, 10 May 2006 13:10:00 GMT

　　编译内核的概念是linux最帅的地方，windows是不会提供操作系统的源代码的，而linux则不然，操作系统的源代码全部都是公开的。对于发行版而言，比如rh9,debian,suse等，都提供编译好的kernel供用户使用，但是这样的kernel未必是用户需要的，这时就可以自己对 kernel的源代码进行编译，然后替换掉原来的kernel。

　　其实编译kernel并不恐怖，只是一件很简单的事情，就几条指令而已。/usr/src/linnux是kernel源代码常用的放置目录，进入此目录，执行make menuconfig，会出来一个图形界面，里面是kernel的各种配置和选项，把自己喜欢的驱动和配置选上，不需要的去除即可。然后make dep，这是检查新的配置是否正确和做一些初始化工作。然后就是make bzImage，这是真正开始编译kernel，bzImage是编译后的kernel文件名，可以为任意名字，只是一般会以bzImage、 zImage或vmlinuz之类为名。如果编译成功会生成一个bzImage文件，这就是kernel了。系统启动最主要的就是调用这个文件，里面包括了文件系统、硬件驱动、网络基础、内存管理、进程管理等，在/boot下面有一个bzImage或者vmlinuz之类的文件就是原有的kernel，只要把编译后的kernel文件(bzImage)替换掉就换成新的kernel了，或者用新名字复制到/boot下，再将grub或lilo的配置文件修改一下，下次启动系统的时候即可使用新的kernel。下面是make modules，这是编译驱动，或者说叫模块，在linux下驱动可以和kernel编译在一起，也可以编译成单独的模块文件，如果是第一种， kernel启动的时候就会自动尝试载入驱动，第二种则是需要的时候手工加载驱动，也可以手动卸载。这是windows没有的功能，比如显卡的驱动在 windows下不重新启动系统是无法更新的，但在linux下却可以。比如对显卡做升级动作的时候其实就是在编译module，并卸载旧驱动，加载新驱动，整个步骤无需重启系统。最后一步，就是make modules_install，这个步骤是在/lib/modules下面生成一个按照kernel版本号为格式的目录，再将编译好的modules复制进去。kernel启动的时候会通过这样的路径搜索modules文件，类似windows的system32目录。

　　写了这么多，很多没玩过linux的人看了会很迷糊，但了解一些相关认识还是很有趣的，因为这才是linux好玩的地方，一个随便捏来捏去的操作系统，可以满足某些人士的变态心理-_-#　windows可以运行的硬件平台很有限，因为不公开，而且尺寸也很大，linux却因为可以自己编译，所以支持几乎所有的硬件平台，x86,cs51,avr,pda,手机,alpha,大型机等等。同时尺寸还很小，一般编译一个可以运行到shell的系统，只要4、5M的尺寸就可以搞定。加一个x-window也就30M左右，这在windows是不可想象的。这都是kernel公开，可以手动编译的好处和乐趣....

2006-05-10 20:55　（根据聊天纪录修改）

cyantree 2006-05-10 21:10 发表评论

FLTK简介

cyantree — Sun, 16 Apr 2006 14:11:00 GMT

　　FLTK，如同其名字所表达的：The Fast Light Tool Kit，一个轻量级的GUI开发库。但这轻量级并不代表功能的羸弱，相反，FLTK在具有基本的GUI功能之外，还拥有一些特殊的功能，比如跨平台、内置 OpenGL功能、速度更快、尺寸更小、协议宽松等。当然，缺点也是有的，比如对于复杂的界面构件支持不够，资源支持的不足等。但一个工具如果使用的好，取其长而去其短，自然可以飞花摘叶皆可伤人;P

　　我选择FLTK 的过程还是比较曲折的，当初做ARM下的GUI开发，选择的GUI库是MiniGUI，一个国内开发的界面库。当时还支持类unix平台，对 Windows的支持尚在开发中。由于需要寻找一些问题的解答，所以经常在其论坛上搜索，从而知道了还有microwindow、nano、 qtembedded等嵌入型GUI开发库，但当时没有太过注意。后来又开始转向WINCE平台的开发，这一搁就是２年。再后来终于要做跨平台的开发，对具有跨平台的GUI开发库开始注意起来。

　　一开始的选择是wxWidgets，但是研究了一段时间后发现不好解决的问题越来越多，终于放弃。最头疼的就是C++类的事件传递，wxWidgets内部使用的是一个类似MFC的方法，所有传递事件的类全部要从一个根类继承，这样就导致创建的类和wxWidgets绑定过甚，复用性大大降低，同时由于wxWidgets的目标不仅仅是GUI，造成其包含功能过多，其内部结构非常复杂，虽然是 OpenSource，但要若要修改其代码还是很困难的。综上所述，wxWidgets并不符合我的要求，从而被排除在外。

　　之后研究的QT，老牌的跨平台GUI开发库，工具很多，开发也很人性化，qtdesign很像Delphi的界面开发方式，代码带有强烈的linux风格，但是看看附带的库文件又实在让人有些泄气，尺寸大，发布麻烦。所以在试用了一段时间后还是放弃了。

　　在此期间，其实也看到过一些对FLTK的介绍，但大多数对其评价不高，也就没有注意。直到有一次偶然心血来潮，上http: //www.fltk.org看了一下，发现FLTK 似乎正对我的胃口，这才开始对其进行了深入的研究。经过一段时间的实际开发，个人觉得，对于跨平台和代码简洁而言，FLTK是再适合不过了。

　　FLTK的底层只提供一套完整的画点、画线功能，另外附带了字体的显示功能，但FLTK对字体的支持还很粗糙，尤其对于非英文字符集而言，后面我会详细说明。在基本的点、线功能基础上，FLTK完全自己实现了一套界面，比如Button、Label、Edit、Tab等，全部都是由基本的点线画出。看到这，可能你会觉得这实在是属于自己造轮子，吃力不讨好。诚然，如果你只针对一种平台开发，这样的做法不能带来多少好处，还造成学习时间的拉长。但若要针对多个平台开发，这样做的好处就很明显了。首先是移植容易，只要针对目标平台实现基本的点线功能就可以实现代码的移植，这可能是所有跨平台GUI库中最方便最直接的方案，目前FTLK支持MacOS、Windows、Linux(x-window)等平台，针对WinCE（主要是unicode的问题）和 plam 的开发正在进行中。其次是保持了界面的一致性，虽然QT、GTK等开发库也具有这种功能，但是他们都需要一套基本库的支持，无法做到系统尺寸的优化，而对于FLTK而言，这却恰恰是他的优点和长项。最后是代码层次清楚、结构简单，由于大部分的工作就是基于底层的点线功能进行自绘，所有很多代码都是简洁明了，很少费话。

　　底层之上是一套以Fl_开头的类，代表了各种GUI构件，比如Fl_Window、Fl_Button、 Fl_Input等，使用起来很是容易。同时由于上面所说的，所有的界面构件都是画出来的，因此在熟悉了这种方式后，生成自己的构件也是很容易的，反正是画界面嘛，既然别人能做到，你也能做到，实在不行可以查阅源代码进行学习。这些界面类的共同特点是轻量型、都拥有一个draw()，只要在draw()里实现自己的绘画动作即可。

　　说到界面就不能不说其事件实现方式，对于FLTK而言，使用的是最直接的方法：while(1){}。这也是很多人批评FLTK原始的一个原因。但仔细想想，其实这是最直接的办法，不管是哪种平台，最终的事件方案不外乎是死循环和中断，中断的确具有很多好处，但只要while(1)能完成这部分的功能，那又有什么关系呢。每个界面类都有一个handle(int event)，只要继承这个成员函数，就可以在其中处理自己的事务。是不是很简单？同时由于这样的事件方式，造成FLTK的刷新速度很快，事件反应迅速，也算是个附带优点了。现在大多数的开发库都是采用OO方式的事件处理方式，但FLTK却采用了最原始的函数指针方式，也算是一个异类，这可能和FLTK的 unix背景有关，无论如何，这种方式还是需要一定的适应时间的，而且这种方式的优缺点也是属于各花入各眼了，不过我本人还是很喜欢这种方式的，谁叫我比较原始呢#-_-

　　FLTK产生于NeXT环境，发展于X-window环境，所以对图形加速的支持必然是选择OpenGL。FLTK 使用Fl_Gl_Window这个类将OpenGL的基本功能囊括其中，只要在Fl_Gl_Window的draw()里glbegin/glend即可，基本的设置工作FLTK全都做好了，对于我现在的系统要求简直是最适合不过了。

　　FLTK基于LGPL，对使用者的要求非常宽松： Contrary to popular belief, it can be used in commercial software - even Bill Gates could use it!　所以开发者不需要担心其项目的隐形问题。但是如果对FLTK进行了卓有成效的修正最好还是能回馈给开发组，所谓我为人人，人人为我嘛。

　　说了一堆的好话，现在开始谈谈FLTK的缺点。首先一条就是对非英文字体特别是中文的支持比较差，甚至是非常差。在Windows平台下还好一点，因为在 Windows平台下使用的是TextOut函数输出字符串，但是在X-Window环境下就完蛋了，无法正确显示中文，也不能调用输入法进行输入。从这点来说，FLTK还是只适合一些封闭软件的开发，对于通用软件而言FLTK并非是一个好的选择。但只能在Windows平台下开发中文软件也不是个办法，要解决中文的显示问题也不难，目前FTLK的稳定版是1.1.7，开发版是2.0，有人针对1.xx版本修改了一个unicode版本，可以很平滑的支持汉字的显示，但很遗憾，我没有编译成功过，如果谁编译成功了可以给我来个信。2.0已经对非英文的支持进行了专门的开发，但目前还没有release，在不久的将来应该可以完整的解决这个问题。目前，要么等待，要么就像我这样，用点阵字库瞒天过海。具体方法因为还不够成熟，就不公布了。

　　无论如何，FLTK的目标还是针对嵌入式和封闭软件的开发，所以复杂的界面并非其长项，如果想做出花哨复杂的界面，还是用其他GUI库比较好，FLTK并不适合。

　　综上所述，FLTK的优点和缺点都是非常的突出，如何取舍还是自己决定吧。

2006-04-16 22:02

cyantree 2006-04-16 22:11 发表评论