Changeset 30

Show
Ignore:
Timestamp:
12/15/06 10:44:12 (2 years ago)
Author:
lindquist
Message:

Changed version(Windows) to version(MinWin32) (for building with GTK on Windows).
Removed Motif support!!!

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved
  • trunk/minwin/app.d

    r28 r30  
    1818} 
    1919 
    20 version(Windows) { 
     20version(MinWin32) { 
    2121    private import minwin.mswindows; 
    2222} 
     
    4747void sysAssert(bool passed, char[] msg, int id = 0) { 
    4848    if (!passed) { 
    49         version (Windows) { 
     49        version (MinWin32) { 
    5050            if (GetVersion() < 0x80_00_00_00 || id != 0) { 
    5151                throw new MinWinException(msg,id); 
     
    6161Application gApp; 
    6262 
    63 version (Windows) { 
     63version (MinWin32) { 
    6464 
    6565    extern (Windows) 
     
    174174    } 
    175175 
    176 } else version (Motif) { 
    177  
    178     private { 
    179         import minwin.motif; 
    180         import std.string; 
    181         import std.file; 
    182     } 
    183  
    184     extern (C) 
    185     void MinWinIdleProc(XtPointer closure,XtIntervalId* id) { 
    186         gApp.idleDelegate(); 
    187         gApp.idleTime = gApp.idleTime; // reset timer 
    188     } 
    189  
    190     struct Application { 
    191  
    192         char[][] cmdLineArgs; 
    193  
    194         char[] rsrc(char[] id, char[] group = "strings") { 
    195             return ""; 
    196         } 
    197  
    198         char[] resourcePath; 
    199  
    200         MultiDelegate!() idleDelegate; 
    201         uint fIdleTime; 
    202         uint idleTime() { 
    203             return fIdleTime; 
    204         } 
    205  
    206         XtIntervalId fTimerID; 
    207  
    208         static 
    209         void idleTime(uint t) { 
    210             gApp.fIdleTime = t; 
    211             if (gApp.fTimerID) 
    212                 XtRemoveTimeOut(gApp.fTimerID); 
    213             if (t) 
    214                 gApp.fTimerID = XtAppAddTimeOut(gApp.context,t,&MinWinIdleProc,null); 
    215         } 
    216  
    217         int enterEventLoop() { 
    218             XtAppMainLoop(context); 
    219             return 1; 
    220         } 
    221  
    222         void exitEventLoop() { 
    223             XtAppSetExitFlag(context); 
    224         } 
    225  
    226         XtAppContext context; 
    227         Display* display; 
    228         ImlibData* imlibdata; 
    229  
    230     } 
    231  
    232     int main(char[][] args) { 
    233         gApp.cmdLineArgs = args; 
    234  
    235         XtToolkitInitialize(); 
    236         gApp.context = XtCreateApplicationContext(); 
    237         char*[] argv; 
    238         argv.length = args.length; 
    239         foreach (int n, char[] str; args) { 
    240             argv[n] = toStringz(str); 
    241         } 
    242         int argc = args.length; 
    243         gApp.display = XtOpenDisplay(gApp.context,null,"test","appclass",null,0, 
    244                  &argc,argv.ptr); 
    245         gApp.imlibdata = Imlib_init(gApp.display); 
    246  
    247         int res = MinWinMain(&gApp); 
    248         version(LOG) log.close(); 
    249         return res; 
    250     } 
    251  
    252176} else version (GTK) { 
    253177 
  • trunk/minwin/button.d

    r28 r30  
    4747    void selected(bool x); 
    4848} 
    49 version (Windows) { 
    50     version = SimpleToggleGroup; 
    51 
    52 version (Motif) { 
     49version (MinWin32) { 
    5350    version = SimpleToggleGroup; 
    5451} 
     
    8784} 
    8885 
    89 version (Windows) { 
     86version (MinWin32) { 
    9087    private import minwin.mswindows; 
    9188 
     
    232229        SendMessageA(peer,WM_SETFONT,cast(WPARAM)f.peer,0); 
    233230        parent.addChild(b); 
    234     } 
    235  
    236 } else version (Motif) { 
    237     private import minwin.motif; 
    238  
    239     const int ButtonClickedCommand = 1; 
    240  
    241     template SelectedImpl() { 
    242         bool selected() { 
    243             return XmToggleButtonGetState(peer) != 0; 
    244         } 
    245         void selected(bool x) { 
    246             XmToggleButtonSetState(peer,x,false); 
    247         } 
    248     } 
    249  
    250     template IconTextImpl() { 
    251         Icon icon_data; 
    252         Icon icon() { 
    253             return icon_data; 
    254         } 
    255         void icon(Icon c) { 
    256             icon_data = c; 
    257             //            SendMessageA(peer,BM_SETIMAGE,cast(WPARAM)c.peer,0); 
    258         } 
    259         char[] text_data; 
    260         char[] text() { return text_data; } 
    261         void text(char[] c) { 
    262             text_data = c; 
    263             char* str = toStringz(c); 
    264             XmString xmstr = XmStringCreate(str,XmFONTLIST_DEFAULT_TAG); 
    265             Arg[6] args; 
    266             int n; 
    267             XtSetArg(args[n],XmNlabelString,cast(XtArgVal)xmstr);n++; 
    268             XtSetValues(peer,args.ptr,n); 
    269             XmStringFree(xmstr); 
    270         } 
    271     } 
    272  
    273     class Button : AbstractButton { 
    274         this(Component parent, char[] text, char[] name = "") { 
    275             PeerForAdd parentp = parent.getPeerForAdd(); 
    276             this.name = name; 
    277             text_data = text; 
    278             char* str = toStringz(text); 
    279             XmString xmstr = XmStringCreate(str,XmFONTLIST_DEFAULT_TAG); 
    280             Arg[6] args; 
    281             int n; 
    282             XtSetArg(args[n],XmNlabelString,cast(XtArgVal)xmstr);n++; 
    283             peer = XmCreatePushButton(parentp,toStringz(name),args,n); 
    284             XmStringFree(xmstr); 
    285             XtAddEventHandler(peer,ExposureMask,false,&mw_exposechild_callback,this); 
    286             XtAddCallback(peer,XmNactivateCallback, 
    287                 cast(XtCallbackProc)&mw_buttonactivate_callback,this); 
    288  
    289             setWindowChildPeer(this,peer,OWNS_PEER); 
    290             parent.addChild(this); 
    291             XtManageChild(peer); 
    292             XtRealizeWidget(peer); 
    293         } 
    294         mixin WindowChildImpl!(); 
    295         mixin IconTextImpl!(); 
    296     } 
    297     class CheckBox : AbstractToggleButton { 
    298         this(Component parent, char[] text, char[] name = "") { 
    299             PeerForAdd parentp = parent.getPeerForAdd(); 
    300             text_data = text; 
    301             this.name = name; 
    302             char* str = toStringz(text); 
    303             XmString xmstr = XmStringCreate(str,XmFONTLIST_DEFAULT_TAG); 
    304             Arg[6] args; 
    305             int n; 
    306             XtSetArg(args[n],XmNlabelString,cast(XtArgVal)xmstr);n++; 
    307             XtSetArg(args[n],XmNindicatorType,cast(XtArgVal)XmN_OF_MANY);n++; 
    308             XtSetArg(args[n],XmNalignment,cast(XtArgVal)XmALIGNMENT_BEGINNING);n++; 
    309             //            XtSetArg(args[0],XmNlabelString,cast(XtArgVal)str);n++; 
    310             peer = XmCreateToggleButton(parentp,toStringz(name),args,n); 
    311             XmStringFree(xmstr); 
    312  
    313             XtAddEventHandler(peer,ExposureMask,false,&mw_exposechild_callback,this); 
    314             XtAddCallback(peer,XmNvalueChangedCallback, 
    315                 cast(XtCallbackProc)&mw_buttonactivate_callback,this); 
    316  
    317             setWindowChildPeer(this,peer,OWNS_PEER); 
    318             parent.addChild(this); 
    319             XtManageChild(peer); 
    320             XtRealizeWidget(peer); 
    321         } 
    322         mixin WindowChildImpl!(); 
    323         mixin SelectedImpl!(); 
    324         mixin IconTextImpl!(); 
    325     } 
    326     class RadioButton : AbstractToggleButton { 
    327         this(Component parent, char[] text, char[] name = "") { 
    328             PeerForAdd parentp = parent.getPeerForAdd(); 
    329             text_data = text; 
    330             this.name = name; 
    331             char* str = toStringz(text); 
    332             XmString xmstr = XmStringCreate(str,XmFONTLIST_DEFAULT_TAG); 
    333             Arg[6] args; 
    334             int n; 
    335             XtSetArg(args[n],XmNlabelString,cast(XtArgVal)xmstr);n++; 
    336             XtSetArg(args[n],XmNindicatorType,cast(XtArgVal)XmONE_OF_MANY_ROUND);n++; 
    337             XtSetArg(args[n],XmNalignment,cast(XtArgVal)XmALIGNMENT_BEGINNING);n++; 
    338             //            XtSetArg(args[0],XmNlabelString,cast(XtArgVal)str);n++; 
    339             peer = XmCreateToggleButton(parentp,toStringz(name),args,n); 
    340             XmStringFree(xmstr); 
    341  
    342             XtAddEventHandler(peer,ExposureMask,false,&mw_exposechild_callback,this); 
    343             XtAddCallback(peer,XmNvalueChangedCallback, 
    344                 cast(XtCallbackProc)&mw_buttonactivate_callback,this); 
    345  
    346             setWindowChildPeer(this,peer,OWNS_PEER); 
    347             parent.addChild(this); 
    348             XtManageChild(peer); 
    349             XtRealizeWidget(peer); 
    350         } 
    351         mixin WindowChildImpl!(); 
    352         mixin SelectedImpl!(); 
    353         mixin IconTextImpl!(); 
    354     } 
    355     class ToggleButton : AbstractToggleButton { 
    356         this(Component parent, char[] text, char[] name = "") { 
    357             PeerForAdd parentp = parent.getPeerForAdd(); 
    358             text_data = text; 
    359             this.name = name; 
    360             char* str = toStringz(text); 
    361             XmString xmstr = XmStringCreate(str,XmFONTLIST_DEFAULT_TAG); 
    362             Arg[6] args; 
    363             int n; 
    364             XtSetArg(args[n],XmNlabelString,cast(XtArgVal)xmstr);n++; 
    365             XtSetArg(args[n],XmNindicatorType,cast(XtArgVal)XmN_OF_MANY);n++; 
    366             XtSetArg(args[n],XmNindicatorOn,cast(XtArgVal)0);n++; 
    367             XtSetArg(args[n],XmNshadowThickness,cast(XtArgVal)2);n++; 
    368             //            XtSetArg(args[0],XmNlabelString,cast(XtArgVal)str);n++; 
    369             peer = XmCreateToggleButton(parentp,toStringz(name),args,n); 
    370             XmStringFree(xmstr); 
    371  
    372             XtAddEventHandler(peer,ExposureMask,false,&mw_exposechild_callback,this); 
    373             XtAddCallback(peer,XmNvalueChangedCallback, 
    374                 cast(XtCallbackProc)&mw_buttonactivate_callback,this); 
    375  
    376             setWindowChildPeer(this,peer,OWNS_PEER); 
    377             parent.addChild(this); 
    378             XtManageChild(peer); 
    379             XtRealizeWidget(peer); 
    380         } 
    381         mixin WindowChildImpl!(); 
    382         mixin SelectedImpl!(); 
    383         mixin IconTextImpl!(); 
    384     } 
    385     extern (C) void mw_buttonactivate_callback(Widget w, XtPointer ud, void* wd) { 
    386         Component c = cast(Component) ud; 
    387         if (c) { 
    388             c.doCommand(ButtonClickedCommand); 
    389         } 
    390231    } 
    391232 
  • trunk/minwin/canvas.d

    r11 r30  
    3030} 
    3131 
    32 version (Windows) { 
     32version (MinWin32) { 
    3333 
    3434    private import minwin.mswindows; 
     
    120120    } 
    121121 
    122 } else version (Motif) { 
    123  
    124     private import minwin.motif; 
    125  
    126     class Canvas : WindowChild { 
    127         Widget content; 
    128  
    129         this(Component parent, char[] name = "") { 
    130             PeerForAdd parentp = parent.getPeerForAdd(); 
    131             this.name = name; 
    132             Arg[6] args; 
    133             int n; 
    134             //                        XtSetArg(args[0],XmNinitialFocus,cast(XtArgVal)true);n++; 
    135             peer = XmCreateDrawingArea(parentp,toStringz(name),args,n); 
    136             content = peer; 
    137             XtAddEventHandler(peer,ExposureMask,false,&mw_canvas_expose_callback,this); 
    138             XtAddEventHandler(peer,KeyPressMask|KeyReleaseMask, 
    139                                     false,&mw_canvas_key_callback,this); 
    140             XtAddEventHandler(content,ButtonPressMask | ButtonReleaseMask, 
    141                                     false,&mw_canvas_button_callback,this); 
    142             XtAddEventHandler(content,PointerMotionMask,false, 
    143                                     &mw_canvas_motion_callback,this); 
    144             setWindowChildPeer(this,peer,OWNS_PEER); 
    145             parent.addChild(this); 
    146             XtManageChild(peer); 
    147             XtRealizeWidget(peer); 
    148         } 
    149  
    150         void backgroundColor(Color c) { 
    151             // TODO 
    152         } 
    153  
    154         mixin CommonEventSourceImpl!(); 
    155  
    156         GContext getGContext(Event* paintEvent = null) { 
    157             GContext gc = newGContext(); 
    158             gc.display = XtDisplay(peer); 
    159             gc.drawable = XtWindow(peer); 
    160             XWindowAttributes attr; 
    161             Status stat = XGetWindowAttributes(gc.display,gc.drawable,&attr); 
    162             gc.colormap = attr.colormap; 
    163             gc.peer = XCreateGC(gc.display,gc.drawable,0,null); 
    164             gc.hasPeer = OWNS_PEER; 
    165             gc.paintEvent = cast(XExposeEvent*)paintEvent; 
    166             return gc; 
    167         } 
    168  
    169         Image getCompatibleImage(int width, int height) { 
    170             XWindowAttributes attr; 
    171             Display* disp = XtDisplay(peer); 
    172             minwin.motif.Window w = XtWindow(peer); 
    173             Status stat = XGetWindowAttributes(disp,w,&attr); 
    174             //                        sysAssert(stat == Success,"Failed to get window attributes in getCompatibleImage",stat); 
    175             ImagePeer bm = XCreatePixmap(disp,w,width,height,attr.depth); 
    176             version(LOG) log.writefln("create bitmap %x",cast(int)bm); 
    177             Image res = new Image(bm); 
    178             res.width = width; 
    179             res.height = height; 
    180             res.hasPeer = OWNS_PEER; 
    181             res.colormap = attr.colormap; 
    182             //                        res.ref = getWindowAncestor(); 
    183             return res; 
    184         } 
    185  
    186         mixin SharedCanvasImpl!(); 
    187         mixin WindowChildImpl!(); 
    188     } 
    189     extern (C) 
    190     void mw_canvas_expose_callback(Widget w, XtPointer ud, XEvent* event, int* cont) { 
    191         Canvas c = cast(Canvas) ud; 
    192         if (c) { 
    193             c.repaintNow(cast(Event*)event); 
    194         } 
    195     } 
    196     extern (C) 
    197     void mw_canvas_key_callback(Widget w, XtPointer ud, XEvent* event, int* cont) { 
    198         Canvas c = cast(Canvas) ud; 
    199         if (c && !c.keyDelegate.isEmpty) { 
    200             c.keyDelegate(c,cast(KeyEvent*)event); 
    201         } 
    202     } 
    203     extern (C) 
    204     void mw_canvas_button_callback(Widget w, XtPointer ud, XEvent* event, int* cont) { 
    205         Canvas c = cast(Canvas) ud; 
    206         if (c && !c.mouseDelegate.isEmpty) { 
    207             // TODO: verify this is ok to cast 
    208             c.mouseDelegate(c,cast(MouseEvent*)event); 
    209         } 
    210     } 
    211     extern (C) 
    212     void mw_canvas_motion_callback(Widget w, XtPointer ud, XEvent* event, int* cont) { 
    213         Canvas c = cast(Canvas) ud; 
    214         if (c && !c.mouseDelegate.isEmpty) { 
    215             c.mouseDelegate(c,cast(MouseEvent*)event); 
    216         } 
    217     } 
    218  
    219122} else version (GTK) { 
    220123 
  • trunk/minwin/combo.d

    r11 r30  
    1919} 
    2020 
    21 version (Windows) { 
     21version (MinWin32) { 
    2222 
    2323    // bug: clicking on the drop down button doesn't show the list 
     
    8888    } 
    8989    */ 
    90 } version (Motif) { 
    91  
    92     private import minwin.motif; 
    93  
    94     class ComboBox : WindowChild { 
    95  
    96         bool editable_data; 
    97         bool editable() { return editable_data; } // read-only 
    98  
    99         this(Component parent, char[][] text, bool editable = true, char[] name = "") { 
    100             PeerForAdd parentp = parent.getPeerForAdd(); 
    101             this.name = name; 
    102             editable_data = editable; 
    103             XmString[] xmstrs; 
    104             xmstrs.length = text.length; 
    105             foreach (int n, char[] s; text) { 
    106                 xmstrs[n] = XmStringCreate(toStringz(s),XmFONTLIST_DEFAULT_TAG); 
    107             } 
    108             Arg[6] args; 
    109             int n; 
    110             XtSetArg(args[n],XmNitems,cast(XtArgVal)xmstrs.ptr);n++; 
    111             XtSetArg(args[n],XmNitemCount,cast(XtArgVal)(text.length));n++; 
    112             if (editable_data) { 
    113                 peer = XmCreateDropDownComboBox(parentp,toStringz(name),args,n); 
    114             } else { 
    115                 peer = XmCreateDropDownList(parentp,toStringz(name),args,n); 
    116             } 
    117             for (n=0; n < text.length; n++) 
    118                 XmStringFree(xmstrs[n]); 
    119             setWindowChildPeer(this,peer,OWNS_PEER); 
    120             parent.addChild(this); 
    121             XtManageChild(peer); 
    122             XtRealizeWidget(peer); 
    123         } 
    124  
    125         mixin WindowChildImpl!(); 
    126  
    127         // -1 for custom text 
    128         int selection() { 
    129             Arg[1] args; 
    130             int n; 
    131             int res; 
    132             XtSetArg(args[n],XmNselectedPosition,cast(XtArgVal)&res);n++; 
    133             XtGetValues(peer,args,n); 
    134             return res; 
    135         } 
    136         void selection(int n) { 
    137             Arg[1] args; 
    138             XtSetArg(args[0],XmNselectedPosition,cast(XtArgVal)n); 
    139             XtSetValues(peer,args,1); 
    140         } 
    141  
    142         // text get/set TODO 
    143     } 
    144  
    145 } version (GTK) { 
     90} else version (GTK) { 
    14691 
    14792    private import minwin.gtk; 
  • trunk/minwin/dialog.d

    r28 r30  
    1111 
    1212private { 
     13    import std.string; 
     14    import std.c.string; 
    1315    import minwin.peerimpl; 
    1416    import minwin.font; 
     
    1618    import minwin.component; 
    1719    import minwin.menu; 
    18     import std.string; 
    19     import std.c.string; 
    2020    import minwin.app; 
    2121    import minwin.logging; 
     
    2424} 
    2525 
    26 version (Windows) { 
     26version (MinWin32) { 
    2727 
    2828    private import minwin.mswindows; 
     
    144144        wc.cbWndExtra = 0; 
    145145        RegisterClassA(&wc); 
    146     } 
    147  
    148 } else version (Motif) { 
    149  
    150     private import minwin.motif; 
    151  
    152     class Dialog : AbstractWindow { 
    153         AbstractWindow owner; 
    154         bool modal_data; 
    155         bool visible_data; 
    156  
    157         this(AbstractWindow owner, char[] title = "", bool modal = true, char[] name = "") { 
    158             String str = toStringz(title); 
    159             int n; 
    160             Arg[6] args; 
    161             XtSetArg(args[n],XtNtitle,cast(XtArgVal)str); n++; 
    162             XtSetArg(args[n],XtNheight,cast(XtArgVal)DefaultWindowHeight); n++; 
    163             XtSetArg(args[n],XtNwidth,cast(XtArgVal)DefaultWindowWidth); n++; 
    164             XtSetArg(args[n],XmNdeleteResponse,cast(XtArgVal)XmDO_NOTHING); n++; 
    165             if (!modal) { 
    166                 XtSetArg(args[n],XmNtransientFor,cast(XtArgVal)null); n++; 
    167             } 
    168             // TODO: application name vs window name?? 
    169             peer = XmCreateDialogShell(owner.peer,toStringz(name), args, n); 
    170             this.name = name; 
    171             this.owner = owner; 
    172             modal_data = modal; 
    173             XtAddEventHandler(peer,StructureNotifyMask,false,&mw_notify_callback,this); 
    174             XtAddCallback(peer,XtNdestroyCallback,&mw_destroy_callback,this); 
    175  
    176             Atom WM_DELETE_WINDOW; 
    177             WM_DELETE_WINDOW = XInternAtom(XtDisplay(peer),"WM_DELETE_WINDOW",false); 
    178             Atom proto = XInternAtom(XtDisplay(peer),"WM_PROTOCOLS",false); 
    179             XmAddProtocolCallback(peer,proto,WM_DELETE_WINDOW, 
    180                     cast(XtCallbackProc)&mw_dialog_close_callback,this); 
    181  
    182             setWindowPeer(this,peer,OWNS_PEER); 
    183             WindowList[this] = this; // prevent garbage collection 
    184  
    185             n = 0; 
    186             XtSetArg(args[n],XmCAllowOverlap,cast(XtArgVal)true); n++; 
    187             if (modal) { 
    188                 XtSetArg(args[n],XmNdialogStyle,cast(XtArgVal)XmDIALOG_FULL_APPLICATION_MODAL); n++; 
    189             } 
    190             content = XmCreateBulletinBoard(peer,"Bulletin",args,n); 
    191             XtAddEventHandler(content,ExposureMask,false,&mw_expose_callback,this); 
    192             XtManageChild(content); 
    193             XtRealizeWidget(peer); 
    194         } 
    195  
    196         this(WindowPeer peer) { 
    197             setWindowPeer(this,peer,FOREIGN_PEER); 
    198             WindowList[this] = this; // prevent garbage collection 
    199         } 
    200  
    201         void visible(bool vis) { 
    202             super.visible(vis); 
    203             visible_data = vis; 
    204             if (modal_data && vis) { 
    205                 while (visible_data && (XtAppGetExitFlag(gApp.context) == 0)) { 
    206                     XtAppProcessEvent(gApp.context,XtIMAll); 
    207                 } 
    208             } 
    209         } 
    210     } 
    211     extern (C) 
    212     void mw_dialog_close_callback(Widget w, XtPointer clientdata, XtPointer calldata) { 
    213         Dialog win = cast(Dialog) clientdata; 
    214         if (win) { 
    215             win.visible = false; 
    216             //            win.close(); // destroys dialog so dont do this 
    217         } 
    218146    } 
    219147 
     
    316244    char[][] extensions; 
    317245} 
    318 version (Motif) { 
    319     version = SharedFileDialogData; 
    320 } 
    321246version (GTK) { 
    322247    version = SharedFileDialogData; 
     
    340265} 
    341266 
    342 version (Windows) { 
     267version (MinWin32) { 
    343268    private { 
    344269        import minwin.mswindows; 
     
    452377        */ 
    453378        return res; 
    454     } 
    455  
    456 } else version(Motif) { 
    457  
    458     private import minwin.motif; 
    459     private import minwin.app; 
    460  
    461     void setupSimpleDialog(Arg[]args,inout int n,char* str) { 
    462         XmString xmstr = XmStringCreateLocalized(str); 
    463         XtSetArg(args[n],XmNmessageString,cast(XtArgVal)xmstr);n++; 
    464         XtSetArg(args[n], XmNautoUnmanage, cast(XtArgVal)false); n++; 
    465         XmString ok = XmStringCreateLocalized ("OK"); 
    466         XtSetArg(args[n], XmNcancelLabelString, cast(XtArgVal)ok); n++; 
    467         XtSetArg(args[n], XmNdialogStyle, cast(XtArgVal)XmDIALOG_FULL_APPLICATION_MODAL); n++; 
    468     } 
    469     void processSimpleDialog(Widget dialog, int*answer) { 
    470         XtAddCallback (dialog,XmNcancelCallback, &mw_simple_dialog_callback,answer); 
    471         XtUnmanageChild (XtNameToWidget (dialog, "OK")); 
    472         XtUnmanageChild (XtNameToWidget (dialog, "Help")); 
    473         *answer = 0; 
    474         XtManageChild(dialog); 
    475         while (*answer == 0) 
    476             XtAppProcessEvent(gApp.context,XtIMAll); 
    477         XtUnmanageChild(dialog); 
    478     } 
    479     void informationDialog(AbstractWindow owner, char[] text, char[] title) { 
    480         Arg[4] args; 
    481         int n; 
    482         char* str = toStringz(text); 
    483         setupSimpleDialog(args,n,str); 
    484         Widget dialog = XmCreateInformationDialog (owner.peer, title.ptr, args, n); 
    485         int answer; 
    486         processSimpleDialog(dialog,&answer); 
    487     } 
    488     void warningDialog(AbstractWindow owner, char[] text, char[] title) { 
    489         Arg[4] args; 
    490         int n; 
    491         char* str = toStringz(text); 
    492         setupSimpleDialog(args,n,str); 
    493         Widget dialog = XmCreateWarningDialog (owner.peer, title.ptr, args, n); 
    494         int answer; 
    495         processSimpleDialog(dialog,&answer); 
    496     } 
    497     void errorDialog(AbstractWindow owner, char[] text, char[] title) { 
    498         Arg[4] args; 
    499         int n; 
    500         char* str = toStringz(text); 
    501         setupSimpleDialog(args,n,str); 
    502         Widget dialog = XmCreateErrorDialog (owner.peer, title.ptr, args, n); 
    503         int answer; 
    504         processSimpleDialog(dialog,&answer); 
    505     } 
    506     void messageDialog(AbstractWindow owner, char[] text, char[] title) { 
    507         Arg[4] args; 
    508         int n; 
    509         char* str = toStringz(text); 
    510         setupSimpleDialog(args,n,str); 
    511         Widget dialog = XmCreateMessageDialog (owner.peer, title.ptr, args, n); 
    512         int answer; 
    513         processSimpleDialog(dialog,&answer); 
    514     } 
    515     extern (C) 
    516     void mw_simple_dialog_callback(Widget w, XtPointer ud, XEvent* cbs) { 
    517         int*answer = cast(int*)ud; 
    518         *answer = 1; 
    519     } 
    520  
    521     bool openFileDialog(AbstractWindow owner, 
    522                     inout FileDialogData data) { 
    523         Widget dialog; 
    524         dialog = XmCreateFileSelectionDialog(owner.peer,toStringz(data.title),null,0); 
    525         XtSetSensitive(XtNameToWidget(dialog,"Help"),0); 
    526         XtAddCallback(dialog,XmNokCallback, 
    527             cast(XtCallbackProc)&mw_file_ok_callback,&data); 
    528         XtAddCallback(dialog,XmNcancelCallback, 
    529             cast(XtCallbackProc)&mw_file_cancel_callback,&data); 
    530         XtManageChild(dialog); 
    531         while (!data.done && (XtAppGetExitFlag(gApp.context) == 0)) { 
    532             XtAppProcessEvent(gApp.context,XtIMAll); 
    533         } 
    534         XtDestroyWidget(dialog); 
    535         return data.done == 1; 
    536     } 
    537     extern (C) 
    538     void mw_file_ok_callback(Widget dialog, XtPointer userdata, XtPointer event) { 
    539         FileDialogData* data = cast(FileDialogData*)userdata; 
    540         data.done = 1; 
    541         XmFileSelectionBoxCallbackStruct *cbs = 
    542             cast(XmFileSelectionBoxCallbackStruct *) event; 
    543         char* filename = cast(char *) XmStringUnparse (cbs.value, 
    544                                  XmSFONTLIST_DEFAULT_TAG_STRING, 
    545                                  XmCHARSET_TEXT, 
    546                                  XmCHARSET_TEXT, 
    547                                  null, 0, XmOUTPUT_ALL); 
    548         if (filename) { 
    549             int len = strlen(filename); 
    550             if (len > 0) { 
    551                 data.result = filename[0 .. len].dup; 
    552             } 
    553             XtFree(filename); 
    554         } 
    555     } 
    556     extern (C) 
    557     void mw_file_cancel_callback(Widget dialog, XtPointer userdata, XtPointer unused) { 
    558         FileDialogData* data = cast(FileDialogData*)userdata; 
    559         data.done = 2; 
    560     } 
    561     bool saveFileDialog(AbstractWindow owner, inout FileDialogData data) { 
    562         return openFileDialog(owner,data); // hmm. looks like the same dialog? 
    563379    } 
    564380 
  • trunk/minwin/event.d

    r11 r30  
    2020} 
    2121 
    22 version (Windows) { 
     22version (MinWin32) { 
    2323    private import minwin.mswindows; 
    2424 
     
    114114    //    alias void* MouseEventPeer; 
    115115    //    alias void* MotionEventPeer; 
    116 } else version (Motif) { 
    117  
    118     private import minwin.motif; 
    119     private import minwin.app; 
    120  
    121     alias XEvent EventNative; 
    122  
    123     template EventBaseImpl() { 
    124         int modifiers() { 
    125             int mod; 
    126             int state; 
    127             if (native.type == KeyPress || native.type == KeyRelease) { 
    128                 XKeyEvent* ke = cast(XKeyEvent*)(&native); 
    129                 state = ke.state; 
    130             } else { 
    131     //            return event.message; 
    132             } 
    133             return mod; 
    134         } 
    135  
    136         int id() { return native.type; } 
    137     } 
    138  
    139     struct Event { 
    140         EventNative native; 
    141         mixin EventBaseImpl!(); 
    142     } 
    143  
    144     alias XKeyEvent KeyEventNative; 
    145     struct KeyEvent { 
    146         KeyEventNative native; 
    147         // UTF-32 character typed 
    148         // TODO: add keysymdef.h to x11.d and make sure non-ascii works 
    149         // hmm - looks like we have to distiguish upper and lower case by hand 
    150         dchar keyChar() { 
    151             KeySym s = XLookupKeysym(&native,1); 
    152             if (s == 0) 
    153                 s = XLookupKeysym(&native,2); 
    154             return cast(dchar)s; 
    155         } 
    156         // key code 
    157         int keyCode() { return native.keycode; } 
    158         int keyRepeat() { return 0; } 
    159         mixin EventBaseImpl!(); 
    160     } 
    161     alias KeyPress KeyPressedEvent; 
    162     alias KeyPress KeyDownEvent; 
    163     alias KeyRelease KeyUpEvent; 
    164  
    165     alias XButtonEvent MouseEventNative; 
    166     alias XButtonEvent MotionEventNative; 
    167     struct MouseEvent { 
    168         MouseEventNative native; 
    169         Point point() { 
    170             return XY(cast(int)native.x,cast(int)native.y); 
    171         } 
    172         mixin EventBaseImpl!(); 
    173     } 
    174  
    175     //    alias WM_ACTIVATE    WindowActivateEvent; 
    176     alias ConfigureNotify        WindowSizeEvent; 
    177     alias ConfigureNotify        WindowSizingEvent; 
    178     alias ConfigureNotify        WindowMoveEvent; 
    179     alias ConfigureNotify        WindowMovingEvent; 
    180  
    181     alias XConfigureEvent WindowEventNative; 
    182     struct WindowEvent { 
    183         WindowEventNative native; 
    184         mixin EventBaseImpl!(); 
    185     } 
    186  
    187     // TODO: add event filter api 
    188  
    189     bool nextEvent(Event* event) { 
    190         if (XtAppGetExitFlag(gApp.context)) 
    191             return false; 
    192         XtAppNextEvent(gApp.context,&event.native); 
    193         return true; 
    194     } 
    195  
    196     bool peekEvent(Event* event) { 
    197         return XtAppPeekEvent(gApp.context,&event.native) != 0; 
    198     } 
    199  
    200     void dispatchEvent(Event* event) { 
    201         XtDispatchEvent(&event.native); 
    202     } 
    203  
    204116} else version (GTK) { 
    205117 
  • trunk/minwin/font.d

    r28 r30  
    3333} 
    3434 
    35 version (Motif) version = GenericFontDataStruct; 
    3635version (GTK)    version = GenericFontDataStruct; 
    3736version (GenericFontDataStruct) { 
     
    4443} 
    4544 
    46 version (Windows) { 
     45version (MinWin32) { 
    4746    private import minwin.mswindows; 
    4847 
     
    121120    } 
    122121 
    123 } else version (Motif) { 
    124  
    125     private import minwin.app; 
    126     private import minwin.motif; 
    127     private import std.string; 
    128  
    129     alias minwin.x11.Font FontPeer; 
    130  
    131     private void copyToBuf(inout char[] buf, inout int i, char[] str) { 
    132         buf[i .. i+str.length] = str[]; 
    133         i += str.length; 
    134     } 
    135  
    136     private char[] fontToString(inout FontData d, char[] str) { 
    137         int i = 0; 
    138         copyToBuf(str,i,"-*-"); 
    139         if (d.name.length == 0) 
    140             copyToBuf(str,i,"*-"); 
    141         else { 
    142             copyToBuf(str,i,d.name); 
    143             copyToBuf(str,i,"-"); 
    144         } 
    145         if (d.weight == FontWeight.Any) { 
    146             copyToBuf(str,i,"*-"); 
    147         } else if (d.weight <= FontWeight.Medium) { 
    148             copyToBuf(str,i,"medium-"); 
    149         } else { 
    150             copyToBuf(str,i,"bold-"); 
    151         } 
    152         if (d.italic) 
    153             copyToBuf(str,i,"i-"); 
    154         else 
    155             copyToBuf(str,i,"r-"); 
    156         copyToBuf(str,i,"normal--*-"); 
    157         copyToBuf(str,i,std.string.toString(d.size*10)); 
    158         copyToBuf(str,i,"-*-*-*-*-iso10646-1"); 
    159         //printf("font string is x%.*sx\n",str[0..i]); 
    160         str[i] = 0; 
    161         return str[0..i]; 
    162     } 
    163  
    164     alias XFontStruct FontMetricsNative; 
    165     struct FontMetrics { 
    166         FontMetricsNative native; 
    167         int size() { return native.ascent+native.descent; } 
    168         int ascent() { return native.ascent; } 
    169         int descent() { return native.descent; } 
    170         int leading() { return native.descent; } 
    171         int maxWidth() { return native.max_bounds.width; } 
    172     } 
    173  
    174     class Font { 
    175         FontPeer peer; 
    176  
    177         this(inout FontData d) { 
    178             char[256] buf; 
    179             peer = XLoadFont(gApp.display,fontToString(d,buf)); 
    180             hasPeer = OWNS_PEER; 
    181         } 
    182  
    183         //        mixin CommonFontCtor!(); 
    184         this(FontPeer p) { 
    185             peer = p; 
    186             hasPeer = FOREIGN_PEER; 
    187         } 
    188  
    189         this(char[] name, int size = 0, FontWeight weight = FontWeight.Normal) { 
    190             FontData fd; 
    191             if (size > 0) 
    192                 fd.size = size; 
    193             if (weight > 0) 
    194                 fd.weight = weight; 
    195             if (name.length > 0) 
    196                 fd.name = name; 
    197             this(fd); 
    198         } 
    199  
    200         mixin PeerMixin!(); 
    201         void dispose() { disposePeer(); } 
    202         void disposePeer() { 
    203             if (hasPeer == OWNS_PEER) 
    204                 XUnloadFont(gApp.display,peer); 
    205             hasPeer = NO_PEER; 
    206         } 
    207     } 
    208  
    209     Font standardFont(StandardFont id) { 
    210         static Font[5] fonts; 
    211         if (fonts[0] is null && id == StandardFont.Gui) { 
    212             fonts[0] = new Font(XLoadFont(gApp.display,"variable")); 
    213         } else if (fonts[1] is null && id == StandardFont.Fixed) { 
    214             fonts[1] = new Font(XLoadFont(gApp.display,"fixed")); 
    215         } else if (fonts[2] is null && id == StandardFont.Variable) { 
    216             fonts[2] = new Font(XLoadFont(gApp.display,"variable")); 
    217         } 
    218         return fonts[id]; 
    219     } 
    220  
    221122} else version (GTK) { 
    222123 
  • trunk/minwin/geometry.d

    r11 r30  
    7676} 
    7777 
    78 version(Motif) 
    79     version = WidthHeightRect; 
    8078version(GTK) 
    8179    version = WidthHeightRect; 
     
    109107